watchdog::~watchdog(void)
{
atomic_exchange32(&m_do_exit, 1);
osd_event_set(m_event);
osd_thread_wait_free(m_thread);
osd_event_free(m_event);
}
static OSDWORK_CALLBACK( draw_video_contents_wt )
{
UINT32 dc = 0;
int update = 1;
worker_param *wp = (worker_param *) param;
sdl_window_info *window = wp->window;
ASSERT_REDRAW_THREAD();
// Some configurations require events to be polled in the worker thread
sdlinput_process_events_buf(wp->machine());
window->primlist = wp->list;
// if no bitmap, just fill
if (window->primlist == NULL)
{
}
// otherwise, render with our drawing system
else
{
if( video_config.perftest )
measure_fps(window, dc, update);
else
window->draw(window, dc, update);
}
/* all done, ready for next */
osd_event_set(window->rendered_event);
osd_free(wp);
return NULL;
}
static void worker_thread_process(osd_work_queue *queue, work_thread_info *thread)
{
int threadid = thread - queue->thread;
begin_timing(thread->runtime);
// loop until everything is processed
while (true)
{
osd_work_item *item = NULL;
bool end_loop = false;
// use a critical section to synchronize the removal of items
{
INT32 lockslot = osd_scalable_lock_acquire(queue->lock);
if (queue->list == NULL)
{
end_loop = true;
}
else
{
// pull the item from the queue
item = (osd_work_item *)queue->list;
if (item != NULL)
{
queue->list = item->next;
if (queue->list == NULL)
queue->tailptr = (osd_work_item **)&queue->list;
}
}
osd_scalable_lock_release(queue->lock, lockslot);
}
if (end_loop)
break;
// process non-NULL items
if (item != NULL)
{
// call the callback and stash the result
begin_timing(thread->actruntime);
item->result = (*item->callback)(item->param, threadid);
end_timing(thread->actruntime);
// decrement the item count after we are done
atomic_decrement32(&queue->items);
atomic_exchange32(&item->done, TRUE);
add_to_stat(&thread->itemsdone, 1);
// if it's an auto-release item, release it
if (item->flags & WORK_ITEM_FLAG_AUTO_RELEASE)
osd_work_item_release(item);
// set the result and signal the event
else
{
INT32 lockslot = osd_scalable_lock_acquire(item->queue->lock);
if (item->event != NULL)
{
osd_event_set(item->event);
add_to_stat(&item->queue->setevents, 1);
}
osd_scalable_lock_release(item->queue->lock, lockslot);
}
// if we removed an item and there's still work to do, bump the stats
if (queue_has_list_items(queue))
add_to_stat(&queue->extraitems, 1);
}
}
// we don't need to set the doneevent for multi queues because they spin
if (queue->waiting)
{
osd_event_set(queue->doneevent);
add_to_stat(&queue->setevents, 1);
}
end_timing(thread->runtime);
}
osd_work_item *osd_work_item_queue_multiple(osd_work_queue *queue, osd_work_callback callback, INT32 numitems, void *parambase, INT32 paramstep, UINT32 flags)
{
osd_work_item *itemlist = NULL, *lastitem = NULL;
osd_work_item **item_tailptr = &itemlist;
INT32 lockslot;
int itemnum;
// loop over items, building up a local list of work
for (itemnum = 0; itemnum < numitems; itemnum++)
{
osd_work_item *item;
// first allocate a new work item; try the free list first
INT32 lockslot = osd_scalable_lock_acquire(queue->lock);
do
{
item = (osd_work_item *)queue->free;
} while (item != NULL && compare_exchange_ptr((PVOID volatile *)&queue->free, item, item->next) != item);
osd_scalable_lock_release(queue->lock, lockslot);
// if nothing, allocate something new
if (item == NULL)
{
// allocate the item
item = (osd_work_item *)osd_malloc(sizeof(*item));
if (item == NULL)
return NULL;
item->event = NULL;
item->queue = queue;
item->done = FALSE;
}
else
{
atomic_exchange32(&item->done, FALSE); // needs to be set this way to prevent data race/usage of uninitialized memory on Linux
}
// fill in the basics
item->next = NULL;
item->callback = callback;
item->param = parambase;
item->result = NULL;
item->flags = flags;
// advance to the next
lastitem = item;
*item_tailptr = item;
item_tailptr = &item->next;
parambase = (UINT8 *)parambase + paramstep;
}
// enqueue the whole thing within the critical section
lockslot = osd_scalable_lock_acquire(queue->lock);
*queue->tailptr = itemlist;
queue->tailptr = item_tailptr;
osd_scalable_lock_release(queue->lock, lockslot);
// increment the number of items in the queue
atomic_add32(&queue->items, numitems);
add_to_stat(&queue->itemsqueued, numitems);
// look for free threads to do the work
if (queue->livethreads < queue->threads)
{
int threadnum;
// iterate over all the threads
for (threadnum = 0; threadnum < queue->threads; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
// if this thread is not active, wake him up
if (!thread->active)
{
osd_event_set(thread->wakeevent);
add_to_stat(&queue->setevents, 1);
// for non-shared, the first one we find is good enough
if (--numitems == 0)
break;
}
}
}
// if no threads, run the queue now on this thread
if (queue->threads == 0)
{
end_timing(queue->thread[0].waittime);
worker_thread_process(queue, &queue->thread[0]);
begin_timing(queue->thread[0].waittime);
}
// only return the item if it won't get released automatically
return (flags & WORK_ITEM_FLAG_AUTO_RELEASE) ? NULL : lastitem;
}
void osd_work_queue_free(osd_work_queue *queue)
{
// if we have threads, clean them up
if (queue->thread != NULL)
{
int threadnum;
// stop the timer for "waittime" on the main thread
if (queue->flags & WORK_QUEUE_FLAG_MULTI)
{
end_timing(queue->thread[queue->threads].waittime);
}
// signal all the threads to exit
atomic_exchange32(&queue->exiting, TRUE);
for (threadnum = 0; threadnum < queue->threads; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
if (thread->wakeevent != NULL)
osd_event_set(thread->wakeevent);
}
// wait for all the threads to go away
for (threadnum = 0; threadnum < queue->threads; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
// block on the thread going away, then close the handle
if (thread->handle != NULL)
{
osd_thread_wait_free(thread->handle);
}
// clean up the wake event
if (thread->wakeevent != NULL)
osd_event_free(thread->wakeevent);
}
#if KEEP_STATISTICS
int allocthreadnum;
if (queue->flags & WORK_QUEUE_FLAG_MULTI)
allocthreadnum = queue->threads + 1;
else
allocthreadnum = queue->threads;
// output per-thread statistics
for (threadnum = 0; threadnum < allocthreadnum; threadnum++)
{
work_thread_info *thread = &queue->thread[threadnum];
osd_ticks_t total = thread->runtime + thread->waittime + thread->spintime;
printf("Thread %d: items=%9d run=%5.2f%% (%5.2f%%) spin=%5.2f%% wait/other=%5.2f%% total=%9d\n",
threadnum, thread->itemsdone,
(double)thread->runtime * 100.0 / (double)total,
(double)thread->actruntime * 100.0 / (double)total,
(double)thread->spintime * 100.0 / (double)total,
(double)thread->waittime * 100.0 / (double)total,
(UINT32) total);
}
#endif
}
// free the list
if (queue->thread != NULL)
osd_free(queue->thread);
// free all the events
if (queue->doneevent != NULL)
osd_event_free(queue->doneevent);
// free all items in the free list
while (queue->free != NULL)
{
osd_work_item *item = (osd_work_item *)queue->free;
queue->free = item->next;
if (item->event != NULL)
osd_event_free(item->event);
osd_free(item);
}
// free all items in the active list
while (queue->list != NULL)
{
osd_work_item *item = (osd_work_item *)queue->list;
queue->list = item->next;
if (item->event != NULL)
osd_event_free(item->event);
osd_free(item);
}
#if KEEP_STATISTICS
printf("Items queued = %9d\n", queue->itemsqueued);
printf("SetEvent calls = %9d\n", queue->setevents);
printf("Extra items = %9d\n", queue->extraitems);
printf("Spin loops = %9d\n", queue->spinloops);
#endif
osd_scalable_lock_free(queue->lock);
// free the queue itself
osd_free(queue);
}