src/mesa/drivers/dri/i915/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 "util/simple_list.h"
  42 #include "main/imports.h"
  43
  44 #include "intel_context.h"
  45 #include "intel_batchbuffer.h"
  46 #include "intel_reg.h"
  47
  48 static struct gl_sync_object *
  49 intel_new_sync_object(struct gl_context *ctx, GLuint id)
  50 {
  51    struct intel_sync_object *sync;
  52
  53    sync = calloc(1, sizeof(struct intel_sync_object));
  54    if (!sync)
  55       return NULL;
  56
  57    return &sync->Base;
  58 }
  59
  60 static void
  61 intel_delete_sync_object(struct gl_context *ctx, struct gl_sync_object *s)
  62 {
  63    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  64
  65    if (sync->bo)
  66       drm_intel_bo_unreference(sync->bo);
  67
  68    free(sync);
  69 }
  70
  71 static void
  72 intel_fence_sync(struct gl_context *ctx, struct gl_sync_object *s,
  73                GLenum condition, GLbitfield flags)
  74 {
  75    struct intel_context *intel = intel_context(ctx);
  76    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  77
  78    assert(condition == GL_SYNC_GPU_COMMANDS_COMPLETE);
  79    intel_batchbuffer_emit_mi_flush(intel);
  80
  81    sync->bo = intel->batch.bo;
  82    drm_intel_bo_reference(sync->bo);
  83
  84    intel_flush(ctx);
  85 }
  86
  87 static void intel_client_wait_sync(struct gl_context *ctx, struct gl_sync_object *s,
  88                                  GLbitfield flags, GLuint64 timeout)
  89 {
  90    struct intel_sync_object *sync = (struct intel_sync_object *)s;
  91
  92    if (sync->bo && drm_intel_gem_bo_wait(sync->bo, timeout) == 0) {
  93       s->StatusFlag = 1;
  94       drm_intel_bo_unreference(sync->bo);
  95       sync->bo = NULL;
  96    }
  97 }
  98
  99 /* We have nothing to do for WaitSync.  Our GL command stream is sequential,
 100  * so given that the sync object has already flushed the batchbuffer,
 101  * any batchbuffers coming after this waitsync will naturally not occur until
 102  * the previous one is done.
 103  */
 104 static void intel_server_wait_sync(struct gl_context *ctx, struct gl_sync_object *s,
 105                                  GLbitfield flags, GLuint64 timeout)
 106 {
 107 }
 108
 109 static void intel_check_sync(struct gl_context *ctx, struct gl_sync_object *s)
 110 {
 111    struct intel_sync_object *sync = (struct intel_sync_object *)s;
 112
 113    if (sync->bo && !drm_intel_bo_busy(sync->bo)) {
 114       drm_intel_bo_unreference(sync->bo);
 115       sync->bo = NULL;
 116       s->StatusFlag = 1;
 117    }
 118 }
 119
 120 void intel_init_syncobj_functions(struct dd_function_table *functions)
 121 {
 122    functions->NewSyncObject = intel_new_sync_object;
 123    functions->DeleteSyncObject = intel_delete_sync_object;
 124    functions->FenceSync = intel_fence_sync;
 125    functions->CheckSync = intel_check_sync;
 126    functions->ClientWaitSync = intel_client_wait_sync;
 127    functions->ServerWaitSync = intel_server_wait_sync;
 128 }