X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fshared.c;h=357368b38deb8bf221585adfe3a3280650cff5fa;hb=b8223244c38ad1c433b33b37bff3f19e7a9d2cfc;hp=b889364f0dc19ef4ab4f18ee3137ddafb7cfdcaf;hpb=653a83445f94620673f747a4ace6847a2c7fdb4d;p=mesa.git

diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c
index b889364f0dc..357368b38de 100644
--- a/src/mesa/main/shared.c
+++ b/src/mesa/main/shared.c
@@ -1,6 +1,5 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.5
  *
  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
  *
@@ -17,9 +16,10 @@
  * 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
- * BRIAN PAUL 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.
+ * 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.
  */
 
 /**
@@ -28,22 +28,25 @@
  */
 
 
-
-#include "imports.h"
 #include "mtypes.h"
 #include "hash.h"
-#include "arrayobj.h"
+#include "atifragshader.h"
 #include "bufferobj.h"
 #include "shared.h"
-#include "shader/program.h"
-#include "shader/shader_api.h"
+#include "program/program.h"
 #include "dlist.h"
-#if FEATURE_ATI_fragment_shader
-#include "shader/atifragshader.h"
-#endif
-#if FEATURE_ARB_sync
+#include "samplerobj.h"
+#include "shaderapi.h"
+#include "shaderobj.h"
 #include "syncobj.h"
-#endif
+#include "texturebindless.h"
+
+#include "util/hash_table.h"
+#include "util/set.h"
+#include "util/u_memory.h"
+
+static void
+free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared);
 
 /**
  * Allocate and initialize a shared context state structure.
@@ -55,7 +58,7 @@
  * failure.
  */
 struct gl_shared_state *
-_mesa_alloc_shared_state(GLcontext *ctx)
+_mesa_alloc_shared_state(struct gl_context *ctx)
 {
    struct gl_shared_state *shared;
    GLuint i;
@@ -64,68 +67,76 @@ _mesa_alloc_shared_state(GLcontext *ctx)
    if (!shared)
       return NULL;
 
-   _glthread_INIT_MUTEX(shared->Mutex);
+   simple_mtx_init(&shared->Mutex, mtx_plain);
 
    shared->DisplayList = _mesa_NewHashTable();
+   shared->BitmapAtlas = _mesa_NewHashTable();
    shared->TexObjects = _mesa_NewHashTable();
    shared->Programs = _mesa_NewHashTable();
 
-#if FEATURE_ARB_vertex_program
-   shared->DefaultVertexProgram = (struct gl_vertex_program *)
-      ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
-#endif
-
-#if FEATURE_ARB_fragment_program
-   shared->DefaultFragmentProgram = (struct gl_fragment_program *)
-      ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-#endif
+   shared->DefaultVertexProgram =
+      ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0, true);
+   shared->DefaultFragmentProgram =
+      ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0, true);
 
-#if FEATURE_ATI_fragment_shader
    shared->ATIShaders = _mesa_NewHashTable();
    shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
-#endif
 
-#if FEATURE_ARB_shader_objects
    shared->ShaderObjects = _mesa_NewHashTable();
-#endif
 
-#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
    shared->BufferObjects = _mesa_NewHashTable();
-#endif
 
-   /* Allocate the default buffer object */
-   shared->NullBufferObj = ctx->Driver.NewBufferObject(ctx, 0, 0);
+   /* GL_ARB_sampler_objects */
+   shared->SamplerObjects = _mesa_NewHashTable();
+
+   /* GL_ARB_bindless_texture */
+   _mesa_init_shared_handles(shared);
+
+   /* ARB_shading_language_include */
+   _mesa_init_shader_includes(shared);
+   mtx_init(&shared->ShaderIncludeMutex, mtx_plain);
 
    /* Create default texture objects */
    for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
       /* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */
-      static const GLenum targets[NUM_TEXTURE_TARGETS] = {
+      static const GLenum targets[] = {
+         GL_TEXTURE_2D_MULTISAMPLE,
+         GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
+         GL_TEXTURE_CUBE_MAP_ARRAY,
+         GL_TEXTURE_BUFFER,
          GL_TEXTURE_2D_ARRAY_EXT,
          GL_TEXTURE_1D_ARRAY_EXT,
+         GL_TEXTURE_EXTERNAL_OES,
          GL_TEXTURE_CUBE_MAP,
          GL_TEXTURE_3D,
          GL_TEXTURE_RECTANGLE_NV,
          GL_TEXTURE_2D,
          GL_TEXTURE_1D
       };
+      STATIC_ASSERT(ARRAY_SIZE(targets) == NUM_TEXTURE_TARGETS);
       shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]);
+      /* Need to explicitly set/overwrite the TargetIndex field here since
+       * the call to _mesa_tex_target_to_index() in NewTextureObject() may
+       * fail if the texture target is not supported.
+       */
+      shared->DefaultTex[i]->TargetIndex = i;
    }
 
    /* sanity check */
    assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1);
 
    /* Mutex and timestamp for texobj state validation */
-   _glthread_INIT_MUTEX(shared->TexMutex);
+   mtx_init(&shared->TexMutex, mtx_recursive);
    shared->TextureStateStamp = 0;
 
-#if FEATURE_EXT_framebuffer_object
    shared->FrameBuffers = _mesa_NewHashTable();
    shared->RenderBuffers = _mesa_NewHashTable();
-#endif
 
-#if FEATURE_ARB_sync
-   make_empty_list(& shared->SyncObjects);
-#endif
+   shared->SyncObjects = _mesa_set_create(NULL, _mesa_hash_pointer,
+                                          _mesa_key_pointer_equal);
+
+   shared->MemoryObjects = _mesa_NewHashTable();
+   shared->SemaphoreObjects = _mesa_NewHashTable();
 
    return shared;
 }
@@ -138,11 +149,23 @@ static void
 delete_displaylist_cb(GLuint id, void *data, void *userData)
 {
    struct gl_display_list *list = (struct gl_display_list *) data;
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    _mesa_delete_list(ctx, list);
 }
 
 
+/**
+ * Callback for deleting a bitmap atlas.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_bitmap_atlas_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_bitmap_atlas *atlas = (struct gl_bitmap_atlas *) data;
+   struct gl_context *ctx = (struct gl_context *) userData;
+   _mesa_delete_bitmap_atlas(ctx, atlas);
+}
+
+
 /**
  * Callback for deleting a texture object.  Called by _mesa_HashDeleteAll().
  */
@@ -150,7 +173,7 @@ static void
 delete_texture_cb(GLuint id, void *data, void *userData)
 {
    struct gl_texture_object *texObj = (struct gl_texture_object *) data;
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    ctx->Driver.DeleteTexture(ctx, texObj);
 }
 
@@ -162,16 +185,15 @@ static void
 delete_program_cb(GLuint id, void *data, void *userData)
 {
    struct gl_program *prog = (struct gl_program *) data;
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    if(prog != &_mesa_DummyProgram) {
-      ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */
+      assert(prog->RefCount == 1); /* should only be referenced by hash table */
       prog->RefCount = 0;  /* now going away */
       ctx->Driver.DeleteProgram(ctx, prog);
    }
 }
 
 
-#if FEATURE_ATI_fragment_shader
 /**
  * Callback for deleting an ATI fragment shader object.
  * Called by _mesa_HashDeleteAll().
@@ -180,10 +202,9 @@ static void
 delete_fragshader_cb(GLuint id, void *data, void *userData)
 {
    struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    _mesa_delete_ati_fragment_shader(ctx, shader);
 }
-#endif
 
 
 /**
@@ -193,11 +214,9 @@ static void
 delete_bufferobj_cb(GLuint id, void *data, void *userData)
 {
    struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      ctx->Driver.UnmapBuffer(ctx, 0, bufObj);
-      bufObj->Pointer = NULL;
-   }
+   struct gl_context *ctx = (struct gl_context *) userData;
+
+   _mesa_buffer_unmap_all_mappings(ctx, bufObj);
    _mesa_reference_buffer_object(ctx, &bufObj, NULL);
 }
 
@@ -209,7 +228,7 @@ delete_bufferobj_cb(GLuint id, void *data, void *userData)
 static void
 free_shader_program_data_cb(GLuint id, void *data, void *userData)
 {
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    struct gl_shader_program *shProg = (struct gl_shader_program *) data;
 
    if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
@@ -225,15 +244,15 @@ free_shader_program_data_cb(GLuint id, void *data, void *userData)
 static void
 delete_shader_cb(GLuint id, void *data, void *userData)
 {
-   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_context *ctx = (struct gl_context *) userData;
    struct gl_shader *sh = (struct gl_shader *) data;
-   if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
-      _mesa_free_shader(ctx, sh);
+   if (_mesa_validate_shader_target(ctx, sh->Type)) {
+      _mesa_delete_shader(ctx, sh);
    }
    else {
       struct gl_shader_program *shProg = (struct gl_shader_program *) data;
-      ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
-      _mesa_free_shader_program(ctx, shProg);
+      assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
+      _mesa_delete_shader_program(ctx, shProg);
    }
 }
 
@@ -265,19 +284,53 @@ delete_framebuffer_cb(GLuint id, void *data, void *userData)
 static void
 delete_renderbuffer_cb(GLuint id, void *data, void *userData)
 {
+   struct gl_context *ctx = (struct gl_context *) userData;
    struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
    rb->RefCount = 0;  /* see comment for FBOs above */
    if (rb->Delete)
-      rb->Delete(rb);
+      rb->Delete(ctx, rb);
+}
+
+
+/**
+ * Callback for deleting a sampler object. Called by _mesa_HashDeleteAll()
+ */
+static void
+delete_sampler_object_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_context *ctx = (struct gl_context *) userData;
+   struct gl_sampler_object *sampObj = (struct gl_sampler_object *) data;
+   _mesa_reference_sampler_object(ctx, &sampObj, NULL);
 }
 
+/**
+ * Callback for deleting a memory object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_memory_object_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_memory_object *memObj = (struct gl_memory_object *) data;
+   struct gl_context *ctx = (struct gl_context *) userData;
+   ctx->Driver.DeleteMemoryObject(ctx, memObj);
+}
+
+/**
+ * Callback for deleting a memory object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_semaphore_object_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_semaphore_object *semObj = (struct gl_semaphore_object *) data;
+   struct gl_context *ctx = (struct gl_context *) userData;
+   ctx->Driver.DeleteSemaphoreObject(ctx, semObj);
+}
 
 /**
  * Deallocate a shared state object and all children structures.
  *
  * \param ctx GL context.
  * \param shared shared state pointer.
- * 
+ *
  * Frees the display lists, the texture objects (calling the driver texture
  * deletion callback to free its private data) and the vertex programs, as well
  * as their hash tables.
@@ -285,109 +338,158 @@ delete_renderbuffer_cb(GLuint id, void *data, void *userData)
  * \sa alloc_shared_state().
  */
 static void
-free_shared_state(GLcontext *ctx, struct gl_shared_state *shared)
+free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared)
 {
    GLuint i;
 
+   /* Free the dummy/fallback texture objects */
+   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
+      if (shared->FallbackTex[i])
+         ctx->Driver.DeleteTexture(ctx, shared->FallbackTex[i]);
+   }
+
    /*
     * Free display lists
     */
-   _mesa_HashDeleteAll(shared->DisplayList, delete_displaylist_cb, ctx);
-   _mesa_DeleteHashTable(shared->DisplayList);
-
-#if FEATURE_ARB_shader_objects
-   _mesa_HashWalk(shared->ShaderObjects, free_shader_program_data_cb, ctx);
-   _mesa_HashDeleteAll(shared->ShaderObjects, delete_shader_cb, ctx);
-   _mesa_DeleteHashTable(shared->ShaderObjects);
-#endif
-
-   _mesa_HashDeleteAll(shared->Programs, delete_program_cb, ctx);
-   _mesa_DeleteHashTable(shared->Programs);
-
-#if FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &shared->DefaultVertexProgram, NULL);
-#endif
-
-#if FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &shared->DefaultFragmentProgram, NULL);
-#endif
-
-#if FEATURE_ATI_fragment_shader
-   _mesa_HashDeleteAll(shared->ATIShaders, delete_fragshader_cb, ctx);
-   _mesa_DeleteHashTable(shared->ATIShaders);
-   _mesa_delete_ati_fragment_shader(ctx, shared->DefaultFragmentShader);
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
-   _mesa_HashDeleteAll(shared->BufferObjects, delete_bufferobj_cb, ctx);
-   _mesa_DeleteHashTable(shared->BufferObjects);
-#endif
-
-#if FEATURE_EXT_framebuffer_object
-   _mesa_HashDeleteAll(shared->FrameBuffers, delete_framebuffer_cb, ctx);
-   _mesa_DeleteHashTable(shared->FrameBuffers);
-   _mesa_HashDeleteAll(shared->RenderBuffers, delete_renderbuffer_cb, ctx);
-   _mesa_DeleteHashTable(shared->RenderBuffers);
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object
-   _mesa_reference_buffer_object(ctx, &shared->NullBufferObj, NULL);
-#endif
-
-#if FEATURE_ARB_sync
-   {
-      struct simple_node *node;
-      struct simple_node *temp;
-
-      foreach_s(node, temp, & shared->SyncObjects) {
-	 _mesa_unref_sync_object(ctx, (struct gl_sync_object *) node);
+   if (shared->DisplayList) {
+      _mesa_HashDeleteAll(shared->DisplayList, delete_displaylist_cb, ctx);
+      _mesa_DeleteHashTable(shared->DisplayList);
+   }
+
+   if (shared->BitmapAtlas) {
+      _mesa_HashDeleteAll(shared->BitmapAtlas, delete_bitmap_atlas_cb, ctx);
+      _mesa_DeleteHashTable(shared->BitmapAtlas);
+   }
+
+   if (shared->ShaderObjects) {
+      _mesa_HashWalk(shared->ShaderObjects, free_shader_program_data_cb, ctx);
+      _mesa_HashDeleteAll(shared->ShaderObjects, delete_shader_cb, ctx);
+      _mesa_DeleteHashTable(shared->ShaderObjects);
+   }
+
+   if (shared->Programs) {
+      _mesa_HashDeleteAll(shared->Programs, delete_program_cb, ctx);
+      _mesa_DeleteHashTable(shared->Programs);
+   }
+
+   if (shared->DefaultVertexProgram)
+      _mesa_reference_program(ctx, &shared->DefaultVertexProgram, NULL);
+
+   if (shared->DefaultFragmentProgram)
+      _mesa_reference_program(ctx, &shared->DefaultFragmentProgram, NULL);
+
+   if (shared->DefaultFragmentShader)
+      _mesa_delete_ati_fragment_shader(ctx, shared->DefaultFragmentShader);
+
+   if (shared->ATIShaders) {
+      _mesa_HashDeleteAll(shared->ATIShaders, delete_fragshader_cb, ctx);
+      _mesa_DeleteHashTable(shared->ATIShaders);
+   }
+
+   if (shared->BufferObjects) {
+      _mesa_HashDeleteAll(shared->BufferObjects, delete_bufferobj_cb, ctx);
+      _mesa_DeleteHashTable(shared->BufferObjects);
+   }
+
+   if (shared->FrameBuffers) {
+      _mesa_HashDeleteAll(shared->FrameBuffers, delete_framebuffer_cb, ctx);
+      _mesa_DeleteHashTable(shared->FrameBuffers);
+   }
+
+   if (shared->RenderBuffers) {
+      _mesa_HashDeleteAll(shared->RenderBuffers, delete_renderbuffer_cb, ctx);
+      _mesa_DeleteHashTable(shared->RenderBuffers);
+   }
+
+   if (shared->SyncObjects) {
+      set_foreach(shared->SyncObjects, entry) {
+         _mesa_unref_sync_object(ctx, (struct gl_sync_object *) entry->key, 1);
       }
+
+      _mesa_set_destroy(shared->SyncObjects, NULL);
+   }
+
+   if (shared->SamplerObjects) {
+      _mesa_HashDeleteAll(shared->SamplerObjects, delete_sampler_object_cb,
+                          ctx);
+      _mesa_DeleteHashTable(shared->SamplerObjects);
    }
-#endif
 
    /*
     * Free texture objects (after FBOs since some textures might have
     * been bound to FBOs).
     */
-   ASSERT(ctx->Driver.DeleteTexture);
+   assert(ctx->Driver.DeleteTexture);
    /* the default textures */
    for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
-      ctx->Driver.DeleteTexture(ctx, shared->DefaultTex[i]);
+      if (shared->DefaultTex[i])
+         ctx->Driver.DeleteTexture(ctx, shared->DefaultTex[i]);
    }
 
    /* all other textures */
-   _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx);
-   _mesa_DeleteHashTable(shared->TexObjects);
+   if (shared->TexObjects) {
+      _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx);
+      _mesa_DeleteHashTable(shared->TexObjects);
+   }
+
+   _mesa_free_shared_handles(shared);
+
+   /* ARB_shading_language_include */
+   _mesa_destroy_shader_includes(shared);
+   mtx_destroy(&shared->ShaderIncludeMutex);
+
+   if (shared->MemoryObjects) {
+      _mesa_HashDeleteAll(shared->MemoryObjects, delete_memory_object_cb, ctx);
+      _mesa_DeleteHashTable(shared->MemoryObjects);
+   }
 
-   _glthread_DESTROY_MUTEX(shared->Mutex);
-   _glthread_DESTROY_MUTEX(shared->TexMutex);
+   if (shared->SemaphoreObjects) {
+      _mesa_HashDeleteAll(shared->SemaphoreObjects, delete_semaphore_object_cb, ctx);
+      _mesa_DeleteHashTable(shared->SemaphoreObjects);
+   }
+
+   simple_mtx_destroy(&shared->Mutex);
+   mtx_destroy(&shared->TexMutex);
 
-   _mesa_free(shared);
+   free(shared);
 }
 
 
 /**
- * Decrement shared state object reference count and potentially free it
- * and all children structures.
- *
- * \param ctx GL context.
- * \param shared shared state pointer.
- *
- * \sa free_shared_state().
+ * gl_shared_state objects are ref counted.
+ * If ptr's refcount goes to zero, free the shared state.
  */
 void
-_mesa_release_shared_state(GLcontext *ctx, struct gl_shared_state *shared)
+_mesa_reference_shared_state(struct gl_context *ctx,
+                             struct gl_shared_state **ptr,
+                             struct gl_shared_state *state)
 {
-   GLint RefCount;
-
-   _glthread_LOCK_MUTEX(shared->Mutex);
-   RefCount = --shared->RefCount;
-   _glthread_UNLOCK_MUTEX(shared->Mutex);
+   if (*ptr == state)
+      return;
+
+   if (*ptr) {
+      /* unref old state */
+      struct gl_shared_state *old = *ptr;
+      GLboolean delete;
+
+      simple_mtx_lock(&old->Mutex);
+      assert(old->RefCount >= 1);
+      old->RefCount--;
+      delete = (old->RefCount == 0);
+      simple_mtx_unlock(&old->Mutex);
+
+      if (delete) {
+         free_shared_state(ctx, old);
+      }
 
-   assert(RefCount >= 0);
+      *ptr = NULL;
+   }
 
-   if (RefCount == 0) {
-      /* free shared state */
-      free_shared_state( ctx, shared );
+   if (state) {
+      /* reference new state */
+      simple_mtx_lock(&state->Mutex);
+      state->RefCount++;
+      *ptr = state;
+      simple_mtx_unlock(&state->Mutex);
    }
 }