/*
* 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;
}
APT_DECLARE(apt_list_elem_t*) apt_list_elem_insert(apt_obj_list_t *list, apt_list_elem_t *elem, void *obj, apr_pool_t *pool)
{
apt_list_elem_t *new_elem = apr_palloc(pool,sizeof(apt_list_elem_t));
new_elem->obj = obj;
APR_RING_INSERT_BEFORE(elem,new_elem,link);
return new_elem;
}
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;
}
/*
* schedule a task to run in "time" microseconds. Find the spot in the ring where
* the time fits. Adjust the short_time so the thread wakes up when the time is reached.
*/
static apr_status_t schedule_task(apr_thread_pool_t *me,
apr_thread_start_t func, void *param,
void *owner, apr_interval_time_t time)
{
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, 0, owner, time);
if (NULL == t) {
apr_thread_mutex_unlock(me->lock);
return APR_ENOMEM;
}
t_loc = APR_RING_FIRST(me->scheduled_tasks);
while (NULL != t_loc) {
/* if the time is less than the entry insert ahead of it */
if (t->dispatch.time < t_loc->dispatch.time) {
++me->scheduled_task_cnt;
APR_RING_INSERT_BEFORE(t_loc, t, link);
break;
}
else {
t_loc = APR_RING_NEXT(t_loc, link);
if (t_loc ==
APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
link)) {
++me->scheduled_task_cnt;
APR_RING_INSERT_TAIL(me->scheduled_tasks, t,
apr_thread_pool_task, link);
break;
}
}
}
/* there should be at least one thread for scheduled tasks */
if (0 == me->thd_cnt) {
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;
}
