int osd_work_item_wait(osd_work_item *item, osd_ticks_t timeout)
{
// if we're done already, just return
if (item->done)
return TRUE;
// if we don't have an event, create one
if (item->event == NULL)
item->event = osd_event_alloc(TRUE, FALSE); // manual reset, not signalled
else
osd_event_reset(item->event);
// if we don't have an event, we need to spin (shouldn't ever really happen)
if (item->event == NULL)
{
osd_ticks_t stopspin = osd_ticks() + timeout;
do {
int spin = 10000;
while (--spin && !item->done)
osd_yield_processor();
} while (!item->done && osd_ticks() < stopspin);
}
// otherwise, block on the event until done
else if (!item->done)
osd_event_wait(item->event, timeout);
// return TRUE if the refcount actually hit 0
return item->done;
}
static void *worker_thread_entry(void *param)
{
work_thread_info *thread = (work_thread_info *)param;
osd_work_queue *queue = thread->queue;
// loop until we exit
for ( ;; )
{
// block waiting for work or exit
// bail on exit, and only wait if there are no pending items in queue
if (!queue->exiting && queue->list == NULL)
{
begin_timing(thread->waittime);
osd_event_wait(thread->wakeevent, INFINITE);
end_timing(thread->waittime);
}
if (queue->exiting)
break;
// indicate that we are live
atomic_exchange32(&thread->active, TRUE);
atomic_increment32(&queue->livethreads);
// process work items
for ( ;; )
{
osd_ticks_t stopspin;
// process as much as we can
worker_thread_process(queue, thread);
// if we're a high frequency queue, spin for a while before giving up
if (queue->flags & WORK_QUEUE_FLAG_HIGH_FREQ && queue->list == NULL)
{
// spin for a while looking for more work
begin_timing(thread->spintime);
stopspin = osd_ticks() + SPIN_LOOP_TIME;
do {
int spin = 10000;
while (--spin && queue->list == NULL)
osd_yield_processor();
} while (queue->list == NULL && osd_ticks() < stopspin);
end_timing(thread->spintime);
}
// if nothing more, release the processor
if (queue->list == NULL)
break;
add_to_stat(&queue->spinloops, 1);
}
// decrement the live thread count
atomic_exchange32(&thread->active, FALSE);
atomic_decrement32(&queue->livethreads);
}
return NULL;
}
int osd_work_queue_wait(osd_work_queue *queue, osd_ticks_t timeout)
{
// if no threads, no waiting
if (queue->threads == 0)
return TRUE;
// if no items, we're done
if (queue->items == 0)
return TRUE;
// if this is a multi queue, help out rather than doing nothing
if (queue->flags & WORK_QUEUE_FLAG_MULTI)
{
work_thread_info *thread = &queue->thread[queue->threads];
end_timing(thread->waittime);
// process what we can as a worker thread
worker_thread_process(queue, thread);
// if we're a high frequency queue, spin until done
if (queue->flags & WORK_QUEUE_FLAG_HIGH_FREQ && queue->items != 0)
{
osd_ticks_t stopspin = osd_ticks() + timeout;
// spin until we're done
begin_timing(thread->spintime);
do {
int spin = 10000;
while (--spin && queue->items != 0)
osd_yield_processor();
} while (queue->items != 0 && osd_ticks() < stopspin);
end_timing(thread->spintime);
begin_timing(thread->waittime);
return (queue->items == 0);
}
begin_timing(thread->waittime);
}
// reset our done event and double-check the items before waiting
osd_event_reset(queue->doneevent);
atomic_exchange32(&queue->waiting, TRUE);
if (queue->items != 0)
osd_event_wait(queue->doneevent, timeout);
atomic_exchange32(&queue->waiting, FALSE);
// return TRUE if we actually hit 0
return (queue->items == 0);
}
