/*!
* \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;
}
