Lines Matching defs:manager
51 * when built without threads we share a single global task manager and use
56 * is expected to have a separate manager; no "worker threads" are shared by
106 isc__taskmgr_t * manager;
118 /* Locked by task manager lock. */
144 /* Locked by task manager lock. */
242 empty_readyq(isc__taskmgr_t *manager);
245 pop_readyq(isc__taskmgr_t *manager);
248 push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
298 isc__taskmgr_t *manager = task->manager;
307 LOCK(&manager->lock);
308 UNLINK(manager->tasks, task, link);
310 if (FINISHED(manager)) {
313 * task manager is exiting. Wake up
317 BROADCAST(&manager->work_available);
320 UNLOCK(&manager->lock);
325 isc_mem_put(manager->mctx, task, sizeof(*task));
332 isc__taskmgr_t *manager = (void*)manager0;
337 REQUIRE(VALID_MANAGER(manager));
340 task = isc_mem_get(manager->mctx, sizeof(*task));
346 isc_mem_put(manager->mctx, task, sizeof(*task));
349 LOCK(&manager->lock);
351 task->manager = manager;
365 UNLOCK(&manager->lock);
368 LOCK(&manager->lock);
369 if (!manager->exiting) {
371 task->quantum = manager->default_quantum;
372 APPEND(manager->tasks, task, link);
375 UNLOCK(&manager->lock);
379 isc_mem_put(manager->mctx, task, sizeof(*task));
452 * Caller must NOT hold manager lock.
456 isc__taskmgr_t *manager = task->manager;
461 REQUIRE(VALID_MANAGER(manager));
466 LOCK(&manager->lock);
467 push_readyq(manager, task);
469 if (manager->mode == isc_taskmgrmode_normal || has_privilege)
470 SIGNAL(&manager->work_available);
472 UNLOCK(&manager->lock);
586 * ready requires locking the manager. If we tried to do
811 event = isc_event_allocate(task->manager->mctx,
829 isc_mem_put(task->manager->mctx, event, sizeof(*event));
918 * Return ISC_TRUE if the current ready list for the manager, which is
920 * the manager is currently in normal or privileged execution mode.
922 * Caller must hold the task manager lock.
925 empty_readyq(isc__taskmgr_t *manager) {
928 if (manager->mode == isc_taskmgrmode_normal)
929 queue = manager->ready_tasks;
931 queue = manager->ready_priority_tasks;
938 * list for the manager.
942 * Caller must hold the task manager lock.
945 pop_readyq(isc__taskmgr_t *manager) {
948 if (manager->mode == isc_taskmgrmode_normal)
949 task = HEAD(manager->ready_tasks);
951 task = HEAD(manager->ready_priority_tasks);
954 DEQUEUE(manager->ready_tasks, task, ready_link);
956 DEQUEUE(manager->ready_priority_tasks, task,
967 * Caller must hold the task manager lock.
970 push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
971 ENQUEUE(manager->ready_tasks, task, ready_link);
973 ENQUEUE(manager->ready_priority_tasks, task,
978 dispatch(isc__taskmgr_t *manager) {
986 REQUIRE(VALID_MANAGER(manager));
1042 LOCK(&manager->lock);
1044 while (!FINISHED(manager)) {
1049 * the task while only holding the manager lock, and then
1056 while ((empty_readyq(manager) || manager->pause_requested ||
1057 manager->exclusive_requested) && !FINISHED(manager))
1062 WAIT(&manager->work_available, &manager->lock);
1069 empty_readyq(manager))
1075 task = pop_readyq(manager);
1086 * Note we only unlock the manager lock if we actually
1087 * have a task to do. We must reacquire the manager
1090 manager->tasks_running++;
1091 UNLOCK(&manager->lock);
1204 LOCK(&manager->lock);
1205 manager->tasks_running--;
1207 if (manager->exclusive_requested &&
1208 manager->tasks_running == 1) {
1209 SIGNAL(&manager->exclusive_granted);
1210 } else if (manager->pause_requested &&
1211 manager->tasks_running == 0) {
1212 SIGNAL(&manager->paused);
1236 push_readyq(manager, task);
1253 if (manager->tasks_running == 0 && empty_readyq(manager)) {
1254 manager->mode = isc_taskmgrmode_normal;
1255 if (!empty_readyq(manager))
1256 BROADCAST(&manager->work_available);
1262 ISC_LIST_APPENDLIST(manager->ready_tasks, new_ready_tasks, ready_link);
1263 ISC_LIST_APPENDLIST(manager->ready_priority_tasks, new_priority_tasks,
1265 if (empty_readyq(manager))
1266 manager->mode = isc_taskmgrmode_normal;
1269 UNLOCK(&manager->lock);
1278 isc__taskmgr_t *manager = uap;
1283 dispatch(manager);
1297 manager_free(isc__taskmgr_t *manager) {
1300 LOCK(&manager->lock);
1302 (void)isc_condition_destroy(&manager->exclusive_granted);
1303 (void)isc_condition_destroy(&manager->work_available);
1304 (void)isc_condition_destroy(&manager->paused);
1305 isc_mem_free(manager->mctx, manager->threads);
1307 manager->common.impmagic = 0;
1308 manager->common.magic = 0;
1309 mctx = manager->mctx;
1310 UNLOCK(&manager->lock);
1311 DESTROYLOCK(&manager->lock);
1312 isc_mem_put(mctx, manager, sizeof(*manager));
1326 isc__taskmgr_t *manager;
1329 * Create a new task manager.
1350 manager = isc_mem_get(mctx, sizeof(*manager));
1351 if (manager == NULL)
1353 manager->common.methods = &taskmgrmethods;
1354 manager->common.impmagic = TASK_MANAGER_MAGIC;
1355 manager->common.magic = ISCAPI_TASKMGR_MAGIC;
1356 manager->mode = isc_taskmgrmode_normal;
1357 manager->mctx = NULL;
1358 result = isc_mutex_init(&manager->lock);
1361 LOCK(&manager->lock);
1364 manager->workers = 0;
1365 manager->threads = isc_mem_allocate(mctx,
1367 if (manager->threads == NULL) {
1371 if (isc_condition_init(&manager->work_available) != ISC_R_SUCCESS) {
1379 if (isc_condition_init(&manager->exclusive_granted) != ISC_R_SUCCESS) {
1387 if (isc_condition_init(&manager->paused) != ISC_R_SUCCESS) {
1398 manager->default_quantum = default_quantum;
1399 INIT_LIST(manager->tasks);
1400 INIT_LIST(manager->ready_tasks);
1401 INIT_LIST(manager->ready_priority_tasks);
1402 manager->tasks_running = 0;
1403 manager->exclusive_requested = ISC_FALSE;
1404 manager->pause_requested = ISC_FALSE;
1405 manager->exiting = ISC_FALSE;
1407 isc_mem_attach(mctx, &manager->mctx);
1414 if (isc_thread_create(run, manager,
1415 &manager->threads[manager->workers]) ==
1417 manager->workers++;
1421 UNLOCK(&manager->lock);
1424 manager_free(manager);
1430 manager->refs = 1;
1431 UNLOCK(&manager->lock);
1432 taskmgr = manager;
1435 *managerp = (isc_taskmgr_t *)manager;
1441 (void)isc_condition_destroy(&manager->exclusive_granted);
1443 (void)isc_condition_destroy(&manager->work_available);
1445 isc_mem_free(mctx, manager->threads);
1447 UNLOCK(&manager->lock);
1448 DESTROYLOCK(&manager->lock);
1451 isc_mem_put(mctx, manager, sizeof(*manager));
1457 isc__taskmgr_t *manager;
1466 manager = (void*)(*managerp);
1467 REQUIRE(VALID_MANAGER(manager));
1474 manager->refs--;
1475 if (manager->refs > 0) {
1485 * task manager, it should ask some non-worker thread to call
1496 * task manager lock and a task lock at the same time.
1499 LOCK(&manager->lock);
1504 INSIST(!manager->exiting);
1505 manager->exiting = ISC_TRUE;
1510 manager->mode = isc_taskmgrmode_normal;
1516 for (task = HEAD(manager->tasks);
1521 push_readyq(manager, task);
1528 * it will cause the workers to see manager->exiting.
1530 BROADCAST(&manager->work_available);
1531 UNLOCK(&manager->lock);
1536 for (i = 0; i < manager->workers; i++)
1537 (void)isc_thread_join(manager->threads[i], NULL);
1542 UNLOCK(&manager->lock);
1543 while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
1544 (void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
1546 if (!ISC_LIST_EMPTY(manager->tasks))
1549 INSIST(ISC_LIST_EMPTY(manager->tasks));
1555 manager_free(manager);
1562 isc__taskmgr_t *manager = (void*)manager0;
1564 LOCK(&manager->lock);
1565 manager->mode = mode;
1566 UNLOCK(&manager->lock);
1571 isc__taskmgr_t *manager = (void*)manager0;
1573 LOCK(&manager->lock);
1574 mode = manager->mode;
1575 UNLOCK(&manager->lock);
1582 isc__taskmgr_t *manager = (void*)manager0;
1586 if (manager == NULL)
1587 manager = taskmgr;
1589 if (manager == NULL)
1592 LOCK(&manager->lock);
1593 is_ready = !empty_readyq(manager);
1594 UNLOCK(&manager->lock);
1601 isc__taskmgr_t *manager = (void*)manager0;
1604 if (manager == NULL)
1605 manager = taskmgr;
1607 if (manager == NULL)
1610 dispatch(manager);
1618 isc__taskmgr_t *manager = (void*)manager0;
1619 LOCK(&manager->lock);
1620 while (manager->tasks_running > 0) {
1621 WAIT(&manager->paused, &manager->lock);
1623 manager->pause_requested = ISC_TRUE;
1624 UNLOCK(&manager->lock);
1629 isc__taskmgr_t *manager = (void*)manager0;
1631 LOCK(&manager->lock);
1632 if (manager->pause_requested) {
1633 manager->pause_requested = ISC_FALSE;
1634 BROADCAST(&manager->work_available);
1636 UNLOCK(&manager->lock);
1644 isc__taskmgr_t *manager = task->manager;
1646 LOCK(&manager->lock);
1647 if (manager->exclusive_requested) {
1648 UNLOCK(&manager->lock);
1651 manager->exclusive_requested = ISC_TRUE;
1652 while (manager->tasks_running > 1) {
1653 WAIT(&manager->exclusive_granted, &manager->lock);
1655 UNLOCK(&manager->lock);
1666 isc__taskmgr_t *manager = task->manager;
1669 LOCK(&manager->lock);
1670 REQUIRE(manager->exclusive_requested);
1671 manager->exclusive_requested = ISC_FALSE;
1672 BROADCAST(&manager->work_available);
1673 UNLOCK(&manager->lock);
1682 isc__taskmgr_t *manager = task->manager;
1696 LOCK(&manager->lock);
1698 ENQUEUE(manager->ready_priority_tasks, task,
1701 DEQUEUE(manager->ready_priority_tasks, task,
1703 UNLOCK(&manager->lock);