/*! * \brief test taskprocessor listener's task_pushed callback * * Adjusts private data's stats as indicated by the parameters. */ static void test_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty) { struct test_listener_pvt *pvt = ast_taskprocessor_listener_get_user_data(listener); ++pvt->num_pushed; if (was_empty) { ++pvt->num_was_empty; } }
static void serializer_shutdown(struct ast_taskprocessor_listener *listener) { struct serializer *ser = ast_taskprocessor_listener_get_user_data(listener); if (ser->shutdown_group) { serializer_shutdown_group_dec(ser->shutdown_group); } ao2_cleanup(ser); }
static void serializer_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty) { if (was_empty) { struct serializer *ser = ast_taskprocessor_listener_get_user_data(listener); struct ast_taskprocessor *tps = ast_taskprocessor_listener_get_tps(listener); if (ast_threadpool_push(ser->pool, execute_tasks, tps)) { ast_taskprocessor_unreference(tps); } } }
/*! * \brief Taskprocessor listener shutdown callback * * The threadpool will shut down and destroy all of its worker threads when * this is called back. By the time this gets called, the taskprocessor's * control taskprocessor has already been destroyed. Therefore there is no risk * in outright destroying the worker threads here. * \param listener The taskprocessor listener. The threadpool is the listener's private data. */ static void threadpool_tps_shutdown(struct ast_taskprocessor_listener *listener) { struct ast_threadpool *pool = ast_taskprocessor_listener_get_user_data(listener); if (pool->listener && pool->listener->callbacks->shutdown) { pool->listener->callbacks->shutdown(pool->listener); } ao2_cleanup(pool->active_threads); ao2_cleanup(pool->idle_threads); ao2_cleanup(pool->zombie_threads); ao2_cleanup(pool); }
/*! * \brief Taskprocessor listener emptied callback * * The threadpool queues a task to let the threadpool listener know that * the threadpool no longer contains any tasks. * \param listener The taskprocessor listener. The threadpool is the listener's private data. */ static void threadpool_tps_emptied(struct ast_taskprocessor_listener *listener) { struct ast_threadpool *pool = ast_taskprocessor_listener_get_user_data(listener); SCOPED_AO2LOCK(lock, pool); if (pool->shutting_down) { return; } if (pool->listener && pool->listener->callbacks->emptied) { ast_taskprocessor_push(pool->control_tps, queued_emptied, pool); } }
/*! * \brief Taskprocessor listener callback called when a task is added * * The threadpool uses this opportunity to queue a task on its control taskprocessor * in order to activate idle threads and notify the threadpool listener that the * task has been pushed. * \param listener The taskprocessor listener. The threadpool is the listener's private data * \param was_empty True if the taskprocessor was empty prior to the task being pushed */ static void threadpool_tps_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty) { struct ast_threadpool *pool = ast_taskprocessor_listener_get_user_data(listener); struct task_pushed_data *tpd; SCOPED_AO2LOCK(lock, pool); if (pool->shutting_down) { return; } tpd = task_pushed_data_alloc(pool, was_empty); if (!tpd) { return; } ast_taskprocessor_push(pool->control_tps, queued_task_pushed, tpd); }
/*! * \brief test taskprocessor listener's shutdown callback. */ static void test_shutdown(struct ast_taskprocessor_listener *listener) { struct test_listener_pvt *pvt = ast_taskprocessor_listener_get_user_data(listener); pvt->shutdown = 1; }
/*! * \brief test taskprocessor listener's emptied callback. */ static void test_emptied(struct ast_taskprocessor_listener *listener) { struct test_listener_pvt *pvt = ast_taskprocessor_listener_get_user_data(listener); ++pvt->num_emptied; }