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);
}
void sdl_window_info::destroy()
{
sdl_window_info **prevptr;
ASSERT_MAIN_THREAD();
if (multithreading_enabled)
{
sdlwindow_sync();
}
//osd_event_wait(window->rendered_event, osd_ticks_per_second()*10);
// remove us from the list
for (prevptr = &sdl_window_list; *prevptr != NULL; prevptr = &(*prevptr)->m_next)
if (*prevptr == this)
{
*prevptr = this->m_next;
break;
}
// free the textures etc
execute_async_wait(&sdlwindow_video_window_destroy_wt, worker_param(this));
// free the render target, after the textures!
this->machine().render().target_free(m_target);
// free the event
osd_event_free(m_rendered_event);
// free the lock
osd_lock_free(this->m_render_lock);
}
static void sdlwindow_video_window_destroy(running_machine *machine, sdl_window_info *window)
{
sdl_window_info **prevptr;
worker_param wp;
ASSERT_MAIN_THREAD();
if (multithreading_enabled)
{
sdlwindow_sync();
}
//osd_event_wait(window->rendered_event, osd_ticks_per_second()*10);
// remove us from the list
for (prevptr = &sdl_window_list; *prevptr != NULL; prevptr = &(*prevptr)->next)
if (*prevptr == window)
{
*prevptr = window->next;
break;
}
// free the textures etc
clear_worker_param(&wp);
wp.window = window;
wp.machine = machine;
execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);
// free the render target, after the textures!
if (window->target != NULL)
render_target_free(window->target);
// free the event
osd_event_free(window->rendered_event);
// free the window itself
global_free(window);
}
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);
}
