/*
* Copyright © 2012 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "swapchain9.h"
#include "surface9.h"
#include "device9.h"
#include "nine_helpers.h"
#include "nine_pipe.h"
#include "nine_dump.h"
#include "util/u_inlines.h"
#include "util/u_surface.h"
#include "hud/hud_context.h"
#include "state_tracker/drm_driver.h"
#include "os/os_thread.h"
#include "threadpool.h"
static void *
threadpool_worker(void *data)
{
struct threadpool *pool = data;
pthread_mutex_lock(&pool->m);
while (!pool->shutdown) {
struct threadpool_task *task;
/* Block (dropping the lock) until new work arrives for us. */
while (!pool->workqueue && !pool->shutdown)
pthread_cond_wait(&pool->new_work, &pool->m);
if (pool->shutdown) {
pthread_mutex_unlock(&pool->m);
return NULL;
}
/* Pull the first task from the list. We don't free it -- it now lacks
* a reference other than the worker creator's, whose responsibility it
* is to call threadpool_wait_for_work() to free it.
*/
task = pool->workqueue;
pool->workqueue = task->next;
/* Call the task's work func. */
pthread_mutex_unlock(&pool->m);
task->work(task->data);
pthread_mutex_lock(&pool->m);
task->finished = TRUE;
pthread_cond_broadcast(&task->finish);
}
pthread_mutex_unlock(&pool->m);
return NULL;
}
struct threadpool *
_mesa_threadpool_create(void)
{
struct threadpool
*pool
= calloc(1, sizeof(*pool
));
if (!pool)
return NULL;
pthread_mutex_init(&pool->m, NULL);
pthread_cond_init(&pool->new_work, NULL);
pthread_create(&pool->thread, NULL, threadpool_worker, pool);
return pool;
}
void
_mesa_threadpool_destroy(struct threadpool *pool)
{
if (!pool)
return;
pthread_mutex_lock(&pool->m);
pool->shutdown = TRUE;
pthread_cond_broadcast(&pool->new_work);
pthread_mutex_unlock(&pool->m);
pthread_join(pool->thread, NULL);
pthread_cond_destroy(&pool->new_work);
pthread_mutex_destroy(&pool->m);
}
/**
* Queues a request for the work function to be asynchronously executed by the
* thread pool.
*
* The work func will get the "data" argument as its parameter -- any
* communication between the caller and the work function will occur through
* that.
*
* If there is an error, the work function is called immediately and NULL is
* returned.
*/
struct threadpool_task *
_mesa_threadpool_queue_task(struct threadpool *pool,
threadpool_task_func work, void *data)
{
struct threadpool_task *task, *previous;
if (!pool) {
work(data);
return NULL;
}
task
= calloc(1, sizeof(*task
)); if (!task) {
work(data);
return NULL;
}
task->work = work;
task->data = data;
task->next = NULL;
pthread_cond_init(&task->finish, NULL);
pthread_mutex_lock(&pool->m);
if (!pool->workqueue) {
pool->workqueue = task;
} else {
previous = pool->workqueue;
while (previous && previous->next)
previous = previous->next;
previous->next = task;
}
pthread_cond_signal(&pool->new_work);
pthread_mutex_unlock(&pool->m);
return task;
}
/**
* Blocks on the completion of the given task and frees the task.
*/
void
_mesa_threadpool_wait_for_task(struct threadpool *pool,
struct threadpool_task **task_handle)
{
struct threadpool_task *task = *task_handle;
if (!pool || !task)
return;
pthread_mutex_lock(&pool->m);
while (!task->finished)
pthread_cond_wait(&task->finish, &pool->m);
pthread_mutex_unlock(&pool->m);
pthread_cond_destroy(&task->finish);
*task_handle = NULL;
}