src/mesa/drivers/dri/i965/intel_syncobj.c

   1 /*
   2  * Copyright © 2008 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *
  26  */
  27
  28 /** @file intel_syncobj.c
  29  *
  30  * Support for ARB_sync
  31  *
  32  * ARB_sync is implemented by flushing the current batchbuffer and keeping a
  33  * reference on it.  We can then check for completion or wait for completion
  34  * using the normal buffer object mechanisms.  This does mean that if an
  35  * application is using many sync objects, it will emit small batchbuffers
  36  * which may end up being a significant overhead.  In other tests of removing
  37  * gratuitous batchbuffer syncs in Mesa, it hasn't appeared to be a significant
  38  * performance bottleneck, though.
  39  */
  40
  41 #include "main/imports.h"
  42
  43 #include "brw_context.h"
  44 #include "intel_batchbuffer.h"
  45 #include "intel_reg.h"
  46
  47 static struct gl_sync_object *
  48 intel_new_sync_object(struct gl_context *ctx, GLuint id)
  49 {
  50    struct intel_sync_object *sync;
  51
  52    sync = calloc(1, sizeof(struct intel_sync_object));
  53
  54    return &sync->Base;
  55 }
  56
  57 static void
  58 intel_delete_sync_object(struct gl_context *ctx, struct gl_sync_object *s)
  59 {
  60    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  61
  62    drm_intel_bo_unreference(sync->bo);
  63    free(sync);
  64 }
  65
  66 static void
  67 intel_fence_sync(struct gl_context *ctx, struct gl_sync_object *s,
  68                GLenum condition, GLbitfield flags)
  69 {
  70    struct brw_context *brw = brw_context(ctx);
  71    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  72
  73    assert(condition == GL_SYNC_GPU_COMMANDS_COMPLETE);
  74    intel_batchbuffer_emit_mi_flush(brw);
  75
  76    sync->bo = brw->batch.bo;
  77    drm_intel_bo_reference(sync->bo);
  78
  79    intel_batchbuffer_flush(brw);
  80 }
  81
  82 static void intel_client_wait_sync(struct gl_context *ctx, struct gl_sync_object *s,
  83                                  GLbitfield flags, GLuint64 timeout)
  84 {
  85    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  86
  87    if (sync->bo && drm_intel_gem_bo_wait(sync->bo, timeout) == 0) {
  88       s->StatusFlag = 1;
  89       drm_intel_bo_unreference(sync->bo);
  90       sync->bo = NULL;
  91    }
  92 }
  93
  94 /* We have nothing to do for WaitSync.  Our GL command stream is sequential,
  95  * so given that the sync object has already flushed the batchbuffer,
  96  * any batchbuffers coming after this waitsync will naturally not occur until
  97  * the previous one is done.
  98  */
  99 static void intel_server_wait_sync(struct gl_context *ctx, struct gl_sync_object *s,
 100                                  GLbitfield flags, GLuint64 timeout)
 101 {
 102 }
 103
 104 static void intel_check_sync(struct gl_context *ctx, struct gl_sync_object *s)
 105 {
 106    struct intel_sync_object *sync = (struct intel_sync_object *)s;
 107
 108    if (sync->bo && !drm_intel_bo_busy(sync->bo)) {
 109       drm_intel_bo_unreference(sync->bo);
 110       sync->bo = NULL;
 111       s->StatusFlag = 1;
 112    }
 113 }
 114
 115 void intel_init_syncobj_functions(struct dd_function_table *functions)
 116 {
 117    functions->NewSyncObject = intel_new_sync_object;
 118    functions->DeleteSyncObject = intel_delete_sync_object;
 119    functions->FenceSync = intel_fence_sync;
 120    functions->CheckSync = intel_check_sync;
 121    functions->ClientWaitSync = intel_client_wait_sync;
 122    functions->ServerWaitSync = intel_server_wait_sync;
 123 }