[Mesa-dev] [PATCH 3/5] st/mesa: use asynchronous flushes

[Nicolai Hähnle]

From: Nicolai Hähnle <nicolai.haehnle at amd.com>

---
 src/mesa/state_tracker/st_cb_flush.c   |  4 ++--
 src/mesa/state_tracker/st_cb_syncobj.c | 26 ++++++++++++++++++++++++--
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/src/mesa/state_tracker/st_cb_flush.c b/src/mesa/state_tracker/st_cb_flush.c
index c8452d0e6f7..5f4e2ac3cc1 100644
--- a/src/mesa/state_tracker/st_cb_flush.c
+++ b/src/mesa/state_tracker/st_cb_flush.c
@@ -56,21 +56,21 @@ void st_flush(struct st_context *st,
 }
 
 
 /**
  * Flush, and wait for completion.
  */
 void st_finish( struct st_context *st )
 {
    struct pipe_fence_handle *fence = NULL;
 
-   st_flush(st, &fence, 0);
+   st_flush(st, &fence, PIPE_FLUSH_ASYNC | PIPE_FLUSH_HINT_FINISH);
 
    if(fence) {
       st->pipe->screen->fence_finish(st->pipe->screen, NULL, fence,
                                      PIPE_TIMEOUT_INFINITE);
       st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);
    }
 
    st_manager_flush_swapbuffers();
 }
 
@@ -81,21 +81,21 @@ void st_finish( struct st_context *st )
  */
 static void st_glFlush(struct gl_context *ctx)
 {
    struct st_context *st = st_context(ctx);
 
    /* Don't call st_finish() here.  It is not the state tracker's
     * responsibilty to inject sleeps in the hope of avoiding buffer
     * synchronization issues.  Calling finish() here will just hide
     * problems that need to be fixed elsewhere.
     */
-   st_flush(st, NULL, 0);
+   st_flush(st, NULL, PIPE_FLUSH_ASYNC);
 
    st_manager_flush_frontbuffer(st);
 }
 
 
 /**
  * Called via ctx->Driver.Finish()
  */
 static void st_glFinish(struct gl_context *ctx)
 {
diff --git a/src/mesa/state_tracker/st_cb_syncobj.c b/src/mesa/state_tracker/st_cb_syncobj.c
index 637fbe3b73a..44323b4750a 100644
--- a/src/mesa/state_tracker/st_cb_syncobj.c
+++ b/src/mesa/state_tracker/st_cb_syncobj.c
@@ -123,22 +123,44 @@ static void st_client_wait_sync(struct gl_context *ctx,
 
 static void st_check_sync(struct gl_context *ctx, struct gl_sync_object *obj)
 {
    st_client_wait_sync(ctx, obj, 0, 0);
 }
 
 static void st_server_wait_sync(struct gl_context *ctx,
                                 struct gl_sync_object *obj,
                                 GLbitfield flags, GLuint64 timeout)
 {
-   /* NO-OP.
-    * Neither Gallium nor DRM interfaces support blocking on the GPU. */
+   struct pipe_context *pipe = st_context(ctx)->pipe;
+   struct pipe_screen *screen = pipe->screen;
+   struct st_sync_object *so = (struct st_sync_object*)obj;
+   struct pipe_fence_handle *fence = NULL;
+
+   /* Nothing needs to be done here if the driver does not support async
+    * flushes. */
+   if (!pipe->fence_server_sync)
+      return;
+
+   /* If the fence doesn't exist, assume it's signalled. */
+   mtx_lock(&so->mutex);
+   if (!so->fence) {
+      mtx_unlock(&so->mutex);
+      so->b.StatusFlag = GL_TRUE;
+      return;
+   }
+
+   /* We need a local copy of the fence pointer. */
+   screen->fence_reference(screen, &fence, so->fence);
+   mtx_unlock(&so->mutex);
+
+   pipe->fence_server_sync(pipe, fence);
+   screen->fence_reference(screen, &fence, NULL);
 }
 
 void st_init_syncobj_functions(struct dd_function_table *functions)
 {
    functions->NewSyncObject = st_new_sync_object;
    functions->FenceSync = st_fence_sync;
    functions->DeleteSyncObject = st_delete_sync_object;
    functions->CheckSync = st_check_sync;
    functions->ClientWaitSync = st_client_wait_sync;
    functions->ServerWaitSync = st_server_wait_sync;
-- 
2.11.0