Lines Matching defs:manager
53 * when built without threads we share a single global task manager and use
58 * is expected to have a separate manager; no "worker threads" are shared by
108 isc__taskmgr_t * manager;
120 /* Locked by task manager lock. */
146 /* Locked by task manager lock. */
244 empty_readyq(isc__taskmgr_t *manager);
247 pop_readyq(isc__taskmgr_t *manager);
250 push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
300 isc__taskmgr_t *manager = task->manager;
309 LOCK(&manager->lock);
310 UNLINK(manager->tasks, task, link);
312 if (FINISHED(manager)) {
315 * task manager is exiting. Wake up
319 BROADCAST(&manager->work_available);
322 UNLOCK(&manager->lock);
327 isc_mem_put(manager->mctx, task, sizeof(*task));
334 isc__taskmgr_t *manager = (void*)manager0;
339 REQUIRE(VALID_MANAGER(manager));
342 task = isc_mem_get(manager->mctx, sizeof(*task));
348 isc_mem_put(manager->mctx, task, sizeof(*task));
351 LOCK(&manager->lock);
353 task->manager = manager;
367 UNLOCK(&manager->lock);
370 LOCK(&manager->lock);
371 if (!manager->exiting) {
373 task->quantum = manager->default_quantum;
374 APPEND(manager->tasks, task, link);
377 UNLOCK(&manager->lock);
381 isc_mem_put(manager->mctx, task, sizeof(*task));
454 * Caller must NOT hold manager lock.
458 isc__taskmgr_t *manager = task->manager;
463 REQUIRE(VALID_MANAGER(manager));
468 LOCK(&manager->lock);
469 push_readyq(manager, task);
471 if (manager->mode == isc_taskmgrmode_normal || has_privilege)
472 SIGNAL(&manager->work_available);
474 UNLOCK(&manager->lock);
588 * ready requires locking the manager. If we tried to do
813 event = isc_event_allocate(task->manager->mctx,
831 isc_mem_put(task->manager->mctx, event, sizeof(*event));
916 *** Task Manager.
920 * Return ISC_TRUE if the current ready list for the manager, which is
922 * the manager is currently in normal or privileged execution mode.
924 * Caller must hold the task manager lock.
927 empty_readyq(isc__taskmgr_t *manager) {
930 if (manager->mode == isc_taskmgrmode_normal)
931 queue = manager->ready_tasks;
933 queue = manager->ready_priority_tasks;
940 * list for the manager.
944 * Caller must hold the task manager lock.
947 pop_readyq(isc__taskmgr_t *manager) {
950 if (manager->mode == isc_taskmgrmode_normal)
951 task = HEAD(manager->ready_tasks);
953 task = HEAD(manager->ready_priority_tasks);
956 DEQUEUE(manager->ready_tasks, task, ready_link);
958 DEQUEUE(manager->ready_priority_tasks, task,
969 * Caller must hold the task manager lock.
972 push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
973 ENQUEUE(manager->ready_tasks, task, ready_link);
975 ENQUEUE(manager->ready_priority_tasks, task,
980 dispatch(isc__taskmgr_t *manager) {
988 REQUIRE(VALID_MANAGER(manager));
1044 LOCK(&manager->lock);
1046 while (!FINISHED(manager)) {
1051 * the task while only holding the manager lock, and then
1058 while ((empty_readyq(manager) || manager->pause_requested ||
1059 manager->exclusive_requested) && !FINISHED(manager))
1064 WAIT(&manager->work_available, &manager->lock);
1071 empty_readyq(manager))
1077 task = pop_readyq(manager);
1088 * Note we only unlock the manager lock if we actually
1089 * have a task to do. We must reacquire the manager
1092 manager->tasks_running++;
1093 UNLOCK(&manager->lock);
1206 LOCK(&manager->lock);
1207 manager->tasks_running--;
1209 if (manager->exclusive_requested &&
1210 manager->tasks_running == 1) {
1211 SIGNAL(&manager->exclusive_granted);
1212 } else if (manager->pause_requested &&
1213 manager->tasks_running == 0) {
1214 SIGNAL(&manager->paused);
1238 push_readyq(manager, task);
1255 if (manager->tasks_running == 0 && empty_readyq(manager)) {
1256 manager->mode = isc_taskmgrmode_normal;
1257 if (!empty_readyq(manager))
1258 BROADCAST(&manager->work_available);
1264 ISC_LIST_APPENDLIST(manager->ready_tasks, new_ready_tasks, ready_link);
1265 ISC_LIST_APPENDLIST(manager->ready_priority_tasks, new_priority_tasks,
1267 if (empty_readyq(manager))
1268 manager->mode = isc_taskmgrmode_normal;
1271 UNLOCK(&manager->lock);
1280 manager = uap;
1285 dispatch(manager);
1299 manager_free(isc__taskmgr_t *manager) {
1302 LOCK(&manager->lock);
1304 (void)isc_condition_destroy(&manager->exclusive_granted);
1305 (void)isc_condition_destroy(&manager->work_available);
1306 (void)isc_condition_destroy(&manager->paused);
1307 isc_mem_free(manager->mctx, manager->threads);
1309 manager->common.impmagic = 0;
1310 manager->common.magic = 0;
1311 mctx = manager->mctx;
1312 UNLOCK(&manager->lock);
1313 DESTROYLOCK(&manager->lock);
1314 isc_mem_put(mctx, manager, sizeof(*manager));
1328 isc__taskmgr_t *manager;
1331 * Create a new task manager.
1352 manager = isc_mem_get(mctx, sizeof(*manager));
1353 if (manager == NULL)
1355 manager->common.methods = &taskmgrmethods;
1356 manager->common.impmagic = TASK_MANAGER_MAGIC;
1357 manager->common.magic = ISCAPI_TASKMGR_MAGIC;
1358 manager->mode = isc_taskmgrmode_normal;
1359 manager->mctx = NULL;
1360 result = isc_mutex_init(&manager->lock);
1363 LOCK(&manager->lock);
1366 manager->workers = 0;
1367 manager->threads = isc_mem_allocate(mctx,
1369 if (manager->threads == NULL) {
1373 if (isc_condition_init(&manager->work_available) != ISC_R_SUCCESS) {
1381 if (isc_condition_init(&manager->exclusive_granted) != ISC_R_SUCCESS) {
1389 if (isc_condition_init(&manager->paused) != ISC_R_SUCCESS) {
1400 manager->default_quantum = default_quantum;
1401 INIT_LIST(manager->tasks);
1402 INIT_LIST(manager->ready_tasks);
1403 INIT_LIST(manager->ready_priority_tasks);
1404 manager->tasks_running = 0;
1405 manager->exclusive_requested = ISC_FALSE;
1406 manager->pause_requested = ISC_FALSE;
1407 manager->exiting = ISC_FALSE;
1409 isc_mem_attach(mctx, &manager->mctx);
1416 if (isc_thread_create(run, manager,
1417 &manager->threads[manager->workers]) ==
1419 manager->workers++;
1423 UNLOCK(&manager->lock);
1426 manager_free(manager);
1432 manager->refs = 1;
1433 UNLOCK(&manager->lock);
1434 taskmgr = manager;
1437 *managerp = (isc_taskmgr_t *)manager;
1443 (void)isc_condition_destroy(&manager->exclusive_granted);
1445 (void)isc_condition_destroy(&manager->work_available);
1447 isc_mem_free(mctx, manager->threads);
1449 UNLOCK(&manager->lock);
1450 DESTROYLOCK(&manager->lock);
1453 isc_mem_put(mctx, manager, sizeof(*manager));
1459 isc__taskmgr_t *manager;
1468 manager = (void*)(*managerp);
1469 REQUIRE(VALID_MANAGER(manager));
1476 manager->refs--;
1477 if (manager->refs > 0) {
1487 * task manager, it should ask some non-worker thread to call
1498 * task manager lock and a task lock at the same time.
1501 LOCK(&manager->lock);
1506 INSIST(!manager->exiting);
1507 manager->exiting = ISC_TRUE;
1512 manager->mode = isc_taskmgrmode_normal;
1518 for (task = HEAD(manager->tasks);
1523 push_readyq(manager, task);
1530 * it will cause the workers to see manager->exiting.
1532 BROADCAST(&manager->work_available);
1533 UNLOCK(&manager->lock);
1538 for (i = 0; i < manager->workers; i++)
1539 (void)isc_thread_join(manager->threads[i], NULL);
1544 UNLOCK(&manager->lock);
1545 while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
1546 (void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
1548 if (!ISC_LIST_EMPTY(manager->tasks))
1551 INSIST(ISC_LIST_EMPTY(manager->tasks));
1557 manager_free(manager);
1564 isc__taskmgr_t *manager = (void*)manager0;
1566 LOCK(&manager->lock);
1567 manager->mode = mode;
1568 UNLOCK(&manager->lock);
1573 isc__taskmgr_t *manager = (void*)manager0;
1575 LOCK(&manager->lock);
1576 mode = manager->mode;
1577 UNLOCK(&manager->lock);
1584 isc__taskmgr_t *manager = (void*)manager0;
1588 if (manager == NULL)
1589 manager = taskmgr;
1591 if (manager == NULL)
1594 LOCK(&manager->lock);
1595 is_ready = !empty_readyq(manager);
1596 UNLOCK(&manager->lock);
1603 isc__taskmgr_t *manager = (void*)manager0;
1606 if (manager == NULL)
1607 manager = taskmgr;
1609 if (manager == NULL)
1612 dispatch(manager);
1620 isc__taskmgr_t *manager = (void*)manager0;
1621 LOCK(&manager->lock);
1622 while (manager->tasks_running > 0) {
1623 WAIT(&manager->paused, &manager->lock);
1625 manager->pause_requested = ISC_TRUE;
1626 UNLOCK(&manager->lock);
1631 isc__taskmgr_t *manager = (void*)manager0;
1633 LOCK(&manager->lock);
1634 if (manager->pause_requested) {
1635 manager->pause_requested = ISC_FALSE;
1636 BROADCAST(&manager->work_available);
1638 UNLOCK(&manager->lock);
1646 isc__taskmgr_t *manager = task->manager;
1648 LOCK(&manager->lock);
1649 if (manager->exclusive_requested) {
1650 UNLOCK(&manager->lock);
1653 manager->exclusive_requested = ISC_TRUE;
1654 while (manager->tasks_running > 1) {
1655 WAIT(&manager->exclusive_granted, &manager->lock);
1657 UNLOCK(&manager->lock);
1668 isc__taskmgr_t *manager = task->manager;
1671 LOCK(&manager->lock);
1672 REQUIRE(manager->exclusive_requested);
1673 manager->exclusive_requested = ISC_FALSE;
1674 BROADCAST(&manager->work_available);
1675 UNLOCK(&manager->lock);
1684 isc__taskmgr_t *manager = task->manager;
1698 LOCK(&manager->lock);
1700 ENQUEUE(manager->ready_priority_tasks, task,
1703 DEQUEUE(manager->ready_priority_tasks, task,
1705 UNLOCK(&manager->lock);
Indexes created Sun Mar 01 05:31:48 UTC 2026