static apr_status_t remove_tasks(apr_thread_pool_t *me, void *owner)
{
apr_thread_pool_task_t *t_loc;
apr_thread_pool_task_t *next;
int seg;
t_loc = APR_RING_FIRST(me->tasks);
while (t_loc != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)) {
next = APR_RING_NEXT(t_loc, link);
if (t_loc->owner == owner) {
--me->task_cnt;
seg = TASK_PRIORITY_SEG(t_loc);
if (t_loc == me->task_idx[seg]) {
me->task_idx[seg] = APR_RING_NEXT(t_loc, link);
if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
apr_thread_pool_task,
link)
|| TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
me->task_idx[seg] = NULL;
}
}
APR_RING_REMOVE(t_loc, link);
}
t_loc = next;
}
return APR_SUCCESS;
}
static apr_status_t add_task(apr_thread_pool_t *me, apr_thread_start_t func,
void *param, apr_byte_t priority, int push,
void *owner)
{
apr_thread_pool_task_t *t;
apr_thread_pool_task_t *t_loc;
apr_thread_t *thd;
apr_status_t rv = APR_SUCCESS;
apr_thread_mutex_lock(me->lock);
t = task_new(me, func, param, priority, owner, 0);
if (NULL == t) {
apr_thread_mutex_unlock(me->lock);
return APR_ENOMEM;
}
t_loc = add_if_empty(me, t);
if (NULL == t_loc) {
goto FINAL_EXIT;
}
if (push) {
while (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
t_loc && t_loc->dispatch.priority >= t->dispatch.priority) {
t_loc = APR_RING_NEXT(t_loc, link);
}
}
APR_RING_INSERT_BEFORE(t_loc, t, link);
if (!push) {
if (t_loc == me->task_idx[TASK_PRIORITY_SEG(t)]) {
me->task_idx[TASK_PRIORITY_SEG(t)] = t;
}
}
FINAL_EXIT:
me->task_cnt++;
if (me->task_cnt > me->tasks_high)
me->tasks_high = me->task_cnt;
if (0 == me->thd_cnt || (0 == me->idle_cnt && me->thd_cnt < me->thd_max &&
me->task_cnt > me->threshold)) {
rv = apr_thread_create(&thd, NULL, thread_pool_func, me, me->pool);
if (APR_SUCCESS == rv) {
++me->thd_cnt;
if (me->thd_cnt > me->thd_high)
me->thd_high = me->thd_cnt;
}
}
apr_thread_mutex_unlock(me->lock);
apr_thread_mutex_lock(me->cond_lock);
apr_thread_cond_signal(me->cond);
apr_thread_mutex_unlock(me->cond_lock);
return rv;
}
/*
* Test it the task is the only one within the priority segment.
* If it is not, return the first element with same or lower priority.
* Otherwise, add the task into the queue and return NULL.
*
* NOTE: This function is not thread safe by itself. Caller should hold the lock
*/
static apr_thread_pool_task_t *add_if_empty(apr_thread_pool_t * me,
apr_thread_pool_task_t * const t)
{
int seg;
int next;
apr_thread_pool_task_t *t_next;
seg = TASK_PRIORITY_SEG(t);
if (me->task_idx[seg]) {
assert(APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
me->task_idx[seg]);
t_next = me->task_idx[seg];
while (t_next->dispatch.priority > t->dispatch.priority) {
t_next = APR_RING_NEXT(t_next, link);
if (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) ==
t_next) {
return t_next;
}
}
return t_next;
}
for (next = seg - 1; next >= 0; next--) {
if (me->task_idx[next]) {
APR_RING_INSERT_BEFORE(me->task_idx[next], t, link);
break;
}
}
if (0 > next) {
APR_RING_INSERT_TAIL(me->tasks, t, apr_thread_pool_task, link);
}
me->task_idx[seg] = t;
return NULL;
}
/*
* NOTE: This function is not thread safe by itself. Caller should hold the lock
*/
static apr_thread_pool_task_t *pop_task(apr_thread_pool_t * me)
{
apr_thread_pool_task_t *task = NULL;
int seg;
/* check for scheduled tasks */
if (me->scheduled_task_cnt > 0) {
task = APR_RING_FIRST(me->scheduled_tasks);
assert(task != NULL);
assert(task !=
APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
link));
/* if it's time */
if (task->dispatch.time <= apr_time_now()) {
--me->scheduled_task_cnt;
APR_RING_REMOVE(task, link);
return task;
}
}
/* check for normal tasks if we're not returning a scheduled task */
if (me->task_cnt == 0) {
return NULL;
}
task = APR_RING_FIRST(me->tasks);
assert(task != NULL);
assert(task != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link));
--me->task_cnt;
seg = TASK_PRIORITY_SEG(task);
if (task == me->task_idx[seg]) {
me->task_idx[seg] = APR_RING_NEXT(task, link);
if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
apr_thread_pool_task, link)
|| TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
me->task_idx[seg] = NULL;
}
}
APR_RING_REMOVE(task, link);
return task;
}
