[Mesa-dev] [PATCH 03/11] mesa/glthread: switch to u_queue and redesign the batch management
Marek Olšák
maraeo at gmail.com
Thu Jun 22 01:02:58 UTC 2017
From: Marek Olšák <marek.olsak at amd.com>
This mirrors exactly how u_threaded_context works.
If you understand this, you also understand u_threaded_context.
---
src/mesa/main/glthread.c | 191 ++++++++++++++---------------------------------
src/mesa/main/glthread.h | 88 ++++++++--------------
src/mesa/main/marshal.h | 10 ++-
3 files changed, 91 insertions(+), 198 deletions(-)
diff --git a/src/mesa/main/glthread.c b/src/mesa/main/glthread.c
index e90709c..d467298 100644
--- a/src/mesa/main/glthread.c
+++ b/src/mesa/main/glthread.c
@@ -31,156 +31,97 @@
* quickly logs the GL commands to a buffer to be processed by a worker
* thread.
*/
#include "main/mtypes.h"
#include "main/glthread.h"
#include "main/marshal.h"
#include "main/marshal_generated.h"
#include "util/u_thread.h"
-static void
-glthread_allocate_batch(struct gl_context *ctx)
-{
- struct glthread_state *glthread = ctx->GLThread;
-
- /* TODO: handle memory allocation failure. */
- glthread->batch = malloc(sizeof(*glthread->batch));
- if (!glthread->batch)
- return;
- memset(glthread->batch, 0, offsetof(struct glthread_batch, buffer));
-}
static void
-glthread_unmarshal_batch(struct gl_context *ctx, struct glthread_batch *batch,
- const bool release_batch)
+glthread_unmarshal_batch(void *job, int thread_index)
{
+ struct glthread_batch *batch = (struct glthread_batch*)job;
+ struct gl_context *ctx = batch->ctx;
size_t pos = 0;
_glapi_set_dispatch(ctx->CurrentServerDispatch);
while (pos < batch->used)
pos += _mesa_unmarshal_dispatch_cmd(ctx, &batch->buffer[pos]);
assert(pos == batch->used);
-
- if (release_batch)
- free(batch);
- else
- batch->used = 0;
+ batch->used = 0;
}
-static void *
-glthread_worker(void *data)
+static void
+glthread_thread_initialization(void *job, int thread_index)
{
- struct gl_context *ctx = data;
- struct glthread_state *glthread = ctx->GLThread;
+ struct gl_context *ctx = (struct gl_context*)job;
ctx->Driver.SetBackgroundContext(ctx);
_glapi_set_context(ctx);
-
- u_thread_setname("mesa_glthread");
-
- pthread_mutex_lock(&glthread->mutex);
-
- while (true) {
- struct glthread_batch *batch;
-
- /* Block (dropping the lock) until new work arrives for us. */
- while (!glthread->batch_queue && !glthread->shutdown) {
- pthread_cond_broadcast(&glthread->work_done);
- pthread_cond_wait(&glthread->new_work, &glthread->mutex);
- }
-
- batch = glthread->batch_queue;
-
- if (glthread->shutdown && !batch) {
- pthread_cond_broadcast(&glthread->work_done);
- pthread_mutex_unlock(&glthread->mutex);
- return NULL;
- }
- glthread->batch_queue = batch->next;
- if (glthread->batch_queue_tail == &batch->next)
- glthread->batch_queue_tail = &glthread->batch_queue;
-
- glthread->busy = true;
- pthread_mutex_unlock(&glthread->mutex);
-
- glthread_unmarshal_batch(ctx, batch, true);
-
- pthread_mutex_lock(&glthread->mutex);
- glthread->busy = false;
- }
-
- /* UNREACHED */
- return NULL;
}
void
_mesa_glthread_init(struct gl_context *ctx)
{
struct glthread_state *glthread = calloc(1, sizeof(*glthread));
if (!glthread)
return;
+ if (!util_queue_init(&glthread->queue, "glthread", MARSHAL_MAX_BATCHES - 2,
+ 1, 0)) {
+ free(glthread);
+ return;
+ }
+
ctx->MarshalExec = _mesa_create_marshal_table(ctx);
if (!ctx->MarshalExec) {
+ util_queue_destroy(&glthread->queue);
free(glthread);
return;
}
- ctx->CurrentClientDispatch = ctx->MarshalExec;
-
- pthread_mutex_init(&glthread->mutex, NULL);
- pthread_cond_init(&glthread->new_work, NULL);
- pthread_cond_init(&glthread->work_done, NULL);
+ for (unsigned i = 0; i < MARSHAL_MAX_BATCHES; i++) {
+ glthread->batches[i].ctx = ctx;
+ util_queue_fence_init(&glthread->batches[i].fence);
+ }
- glthread->batch_queue_tail = &glthread->batch_queue;
+ ctx->CurrentClientDispatch = ctx->MarshalExec;
ctx->GLThread = glthread;
- glthread_allocate_batch(ctx);
-
- pthread_create(&glthread->thread, NULL, glthread_worker, ctx);
+ /* Execute the thread initialization function in the thread. */
+ struct util_queue_fence fence;
+ util_queue_fence_init(&fence);
+ util_queue_add_job(&glthread->queue, ctx, &fence,
+ glthread_thread_initialization, NULL);
+ util_queue_fence_wait(&fence);
+ util_queue_fence_destroy(&fence);
}
void
_mesa_glthread_destroy(struct gl_context *ctx)
{
struct glthread_state *glthread = ctx->GLThread;
if (!glthread)
return;
- _mesa_glthread_flush_batch(ctx);
+ _mesa_glthread_finish(ctx);
+ util_queue_destroy(&glthread->queue);
- pthread_mutex_lock(&glthread->mutex);
- glthread->shutdown = true;
- pthread_cond_broadcast(&glthread->new_work);
- pthread_mutex_unlock(&glthread->mutex);
-
- /* Since this waits for the thread to exit, it means that all queued work
- * will have been completed.
- */
- pthread_join(glthread->thread, NULL);
-
- pthread_cond_destroy(&glthread->new_work);
- pthread_cond_destroy(&glthread->work_done);
- pthread_mutex_destroy(&glthread->mutex);
-
- /* Due to the join above, there should be one empty batch allocated at this
- * point, and no batches queued.
- */
- assert(!glthread->batch->used);
- assert(!glthread->batch->next);
- free(glthread->batch);
- assert(!glthread->batch_queue);
+ for (unsigned i = 0; i < MARSHAL_MAX_BATCHES; i++)
+ util_queue_fence_destroy(&glthread->batches[i].fence);
free(glthread);
ctx->GLThread = NULL;
_mesa_glthread_restore_dispatch(ctx);
}
void
_mesa_glthread_restore_dispatch(struct gl_context *ctx)
{
@@ -189,96 +130,74 @@ _mesa_glthread_restore_dispatch(struct gl_context *ctx)
*
* Typically glxMakeCurrent will bind a new context (install new table) then
* old context might be deleted.
*/
if (_glapi_get_dispatch() == ctx->MarshalExec) {
ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
_glapi_set_dispatch(ctx->CurrentClientDispatch);
}
}
-static void
-_mesa_glthread_flush_batch_locked(struct gl_context *ctx)
+void
+_mesa_glthread_flush_batch(struct gl_context *ctx)
{
struct glthread_state *glthread = ctx->GLThread;
- struct glthread_batch *batch = glthread->batch;
-
- if (!batch->used)
+ if (!glthread)
return;
- /* Immediately reallocate a new batch, since the next marshalled call would
- * just do it.
- */
- glthread_allocate_batch(ctx);
+ struct glthread_batch *next = &glthread->batches[glthread->next];
+ if (!next->used)
+ return;
/* Debug: execute the batch immediately from this thread.
*
* Note that glthread_unmarshal_batch() changes the dispatch table so we'll
* need to restore it when it returns.
*/
if (false) {
- glthread_unmarshal_batch(ctx, batch, true);
+ glthread_unmarshal_batch(next, 0);
_glapi_set_dispatch(ctx->CurrentClientDispatch);
return;
}
- *glthread->batch_queue_tail = batch;
- glthread->batch_queue_tail = &batch->next;
- pthread_cond_broadcast(&glthread->new_work);
-}
-
-void
-_mesa_glthread_flush_batch(struct gl_context *ctx)
-{
- struct glthread_state *glthread = ctx->GLThread;
- struct glthread_batch *batch;
-
- if (!glthread)
- return;
-
- batch = glthread->batch;
- if (!batch->used)
- return;
-
- pthread_mutex_lock(&glthread->mutex);
- _mesa_glthread_flush_batch_locked(ctx);
- pthread_mutex_unlock(&glthread->mutex);
+ util_queue_add_job(&glthread->queue, next, &next->fence,
+ glthread_unmarshal_batch, NULL);
+ glthread->last = glthread->next;
+ glthread->next = (glthread->next + 1) % MARSHAL_MAX_BATCHES;
}
/**
* Waits for all pending batches have been unmarshaled.
*
* This can be used by the main thread to synchronize access to the context,
* since the worker thread will be idle after this.
*/
void
_mesa_glthread_finish(struct gl_context *ctx)
{
struct glthread_state *glthread = ctx->GLThread;
-
if (!glthread)
return;
/* If this is called from the worker thread, then we've hit a path that
* might be called from either the main thread or the worker (such as some
* dri interface entrypoints), in which case we don't need to actually
* synchronize against ourself.
*/
- if (pthread_equal(pthread_self(), glthread->thread))
+ if (u_thread_is_self(glthread->queue.threads[0]))
return;
- pthread_mutex_lock(&glthread->mutex);
-
- if (!(glthread->batch_queue || glthread->busy)) {
- if (glthread->batch && glthread->batch->used) {
- struct _glapi_table *dispatch = _glapi_get_dispatch();
- glthread_unmarshal_batch(ctx, glthread->batch, false);
- _glapi_set_dispatch(dispatch);
- }
- } else {
- _mesa_glthread_flush_batch_locked(ctx);
- while (glthread->batch_queue || glthread->busy)
- pthread_cond_wait(&glthread->work_done, &glthread->mutex);
- }
+ struct glthread_batch *last = &glthread->batches[glthread->last];
+ struct glthread_batch *next = &glthread->batches[glthread->next];
+
+ if (!util_queue_fence_is_signalled(&last->fence))
+ util_queue_fence_wait(&last->fence);
- pthread_mutex_unlock(&glthread->mutex);
+ if (next->used) {
+ /* Since glthread_unmarshal_batch changes the dispatch to direct,
+ * restore it after it's done.
+ */
+ struct _glapi_table *dispatch = _glapi_get_dispatch();
+ glthread_unmarshal_batch(next, 0);
+ _glapi_set_dispatch(dispatch);
+ }
}
diff --git a/src/mesa/main/glthread.h b/src/mesa/main/glthread.h
index 07bed38..5b938fd 100644
--- a/src/mesa/main/glthread.h
+++ b/src/mesa/main/glthread.h
@@ -22,104 +22,76 @@
*/
#ifndef _GLTHREAD_H
#define _GLTHREAD_H
#include "main/mtypes.h"
/* Command size is a number of bytes stored in a short. */
#define MARSHAL_MAX_CMD_SIZE 65535
+/* The number of batch slots in memory.
+ *
+ * One batch is being executed, one batch is being filled, the rest are
+ * waiting batches. There must be at least 1 slot for a waiting batch,
+ * so the minimum number of batches is 3.
+ */
+#define MARSHAL_MAX_BATCHES 4
+
#include <inttypes.h>
#include <stdbool.h>
#include <pthread.h>
+#include "util/u_queue.h"
enum marshal_dispatch_cmd_id;
-struct glthread_state
+/** A single batch of commands queued up for execution. */
+struct glthread_batch
{
- /** The worker thread that asynchronously processes our GL commands. */
- pthread_t thread;
+ /** Batch fence for waiting for the execution to finish. */
+ struct util_queue_fence fence;
- /**
- * Mutex used for synchronizing between the main thread and the worker
- * thread.
- */
- pthread_mutex_t mutex;
+ /** The worker thread will access the context with this. */
+ struct gl_context *ctx;
- /** Condvar used for waking the worker thread. */
- pthread_cond_t new_work;
-
- /** Condvar used for waking the main thread. */
- pthread_cond_t work_done;
+ /** Amount of data used by batch commands, in bytes. */
+ size_t used;
- /** Used to tell the worker thread to quit */
- bool shutdown;
+ /** Data contained in the command buffer. */
+ uint8_t buffer[MARSHAL_MAX_CMD_SIZE];
+};
- /** Indicates that the worker thread is currently processing a batch */
- bool busy;
+struct glthread_state
+{
+ /** Multithreaded queue. */
+ struct util_queue queue;
- /**
- * Singly-linked list of command batches that are awaiting execution by
- * a thread pool task. NULL if empty.
- */
- struct glthread_batch *batch_queue;
+ /** The ring of batches in memory. */
+ struct glthread_batch batches[MARSHAL_MAX_BATCHES];
- /**
- * Tail pointer for appending batches to the end of batch_queue. If the
- * queue is empty, this points to batch_queue.
- */
- struct glthread_batch **batch_queue_tail;
+ /** Index of the last submitted batch. */
+ unsigned last;
- /**
- * Batch containing commands that are being prepared for insertion into
- * batch_queue. NULL if there are no such commands.
- *
- * Since this is only used by the main thread, it doesn't need the mutex to
- * be accessed.
- */
- struct glthread_batch *batch;
+ /** Index of the batch being filled and about to be submitted. */
+ unsigned next;
/**
* Tracks on the main thread side whether the current vertex array binding
* is in a VBO.
*/
bool vertex_array_is_vbo;
/**
* Tracks on the main thread side whether the current element array (index
* buffer) binding is in a VBO.
*/
bool element_array_is_vbo;
};
-/**
- * A single batch of commands queued up for later execution by a thread pool
- * task.
- */
-struct glthread_batch
-{
- /**
- * Next batch of commands to execute after this batch, or NULL if this is
- * the last set of commands queued. Protected by ctx->Marshal.Mutex.
- */
- struct glthread_batch *next;
-
- /**
- * Amount of data used by batch commands, in bytes.
- */
- size_t used;
-
- /**
- * Data contained in the command buffer.
- */
- uint8_t buffer[MARSHAL_MAX_CMD_SIZE];
-};
-
void _mesa_glthread_init(struct gl_context *ctx);
void _mesa_glthread_destroy(struct gl_context *ctx);
void _mesa_glthread_restore_dispatch(struct gl_context *ctx);
void _mesa_glthread_flush_batch(struct gl_context *ctx);
void _mesa_glthread_finish(struct gl_context *ctx);
#endif /* _GLTHREAD_H*/
diff --git a/src/mesa/main/marshal.h b/src/mesa/main/marshal.h
index e9ecaf9..ddfa834 100644
--- a/src/mesa/main/marshal.h
+++ b/src/mesa/main/marshal.h
@@ -46,29 +46,31 @@ struct marshal_cmd_base
*/
uint16_t cmd_size;
};
static inline void *
_mesa_glthread_allocate_command(struct gl_context *ctx,
uint16_t cmd_id,
size_t size)
{
struct glthread_state *glthread = ctx->GLThread;
+ struct glthread_batch *next = &glthread->batches[glthread->next];
struct marshal_cmd_base *cmd_base;
const size_t aligned_size = ALIGN(size, 8);
- if (unlikely(glthread->batch->used + size > MARSHAL_MAX_CMD_SIZE))
+ if (unlikely(next->used + size > MARSHAL_MAX_CMD_SIZE)) {
_mesa_glthread_flush_batch(ctx);
+ next = &glthread->batches[glthread->next];
+ }
- cmd_base = (struct marshal_cmd_base *)
- &glthread->batch->buffer[glthread->batch->used];
- glthread->batch->used += aligned_size;
+ cmd_base = (struct marshal_cmd_base *)&next->buffer[next->used];
+ next->used += aligned_size;
cmd_base->cmd_id = cmd_id;
cmd_base->cmd_size = aligned_size;
return cmd_base;
}
/**
* Instead of conditionally handling marshaling previously-bound user vertex
* array data in draw calls (deprecated and removed in GL core), we just
* disable threading at the point where the user sets a user vertex array.
*/
--
2.7.4
More information about the mesa-dev
mailing list