1/*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25/**
26 * \file shared.c
27 * Shared-context state
28 */
29
30#include "imports.h"
31#include "mtypes.h"
32#include "hash.h"
33#include "atifragshader.h"
34#include "bufferobj.h"
35#include "shared.h"
36#include "program/program.h"
37#include "dlist.h"
38#include "samplerobj.h"
39#include "shaderapi.h"
40#include "shaderobj.h"
41#include "syncobj.h"
42#include "texturebindless.h"
43
44#include "util/hash_table.h"
45#include "util/set.h"
46
47static void
48free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared);
49
50/**
51 * Allocate and initialize a shared context state structure.
52 * Initializes the display list, texture objects and vertex programs hash
53 * tables, allocates the texture objects. If it runs out of memory, frees
54 * everything already allocated before returning NULL.
55 *
56 * \return pointer to a gl_shared_state structure on success, or NULL on
57 * failure.
58 */
59struct gl_shared_state *
60_mesa_alloc_shared_state(struct gl_context *ctx)
61{
62   struct gl_shared_state *shared;
63   GLuint i;
64
65   shared = CALLOC_STRUCT(gl_shared_state);
66   if (!shared)
67      return NULL;
68
69   simple_mtx_init(&shared->Mutex, mtx_plain);
70
71   shared->DisplayList = _mesa_NewHashTable();
72   shared->BitmapAtlas = _mesa_NewHashTable();
73   shared->TexObjects = _mesa_NewHashTable();
74   shared->Programs = _mesa_NewHashTable();
75
76   shared->DefaultVertexProgram =
77      ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0, true);
78   shared->DefaultFragmentProgram =
79      ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0, true);
80
81   shared->ATIShaders = _mesa_NewHashTable();
82   shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
83
84   shared->ShaderObjects = _mesa_NewHashTable();
85
86   shared->BufferObjects = _mesa_NewHashTable();
87
88   /* GL_ARB_sampler_objects */
89   shared->SamplerObjects = _mesa_NewHashTable();
90
91   /* GL_ARB_bindless_texture */
92   _mesa_init_shared_handles(shared);
93
94   /* Allocate the default buffer object */
95   shared->NullBufferObj = ctx->Driver.NewBufferObject(ctx, 0);
96   if (!shared->NullBufferObj)
97      goto fail;
98
99   /* Create default texture objects */
100   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
101      /* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */
102      static const GLenum targets[] = {
103         GL_TEXTURE_2D_MULTISAMPLE,
104         GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
105         GL_TEXTURE_CUBE_MAP_ARRAY,
106         GL_TEXTURE_BUFFER,
107         GL_TEXTURE_2D_ARRAY_EXT,
108         GL_TEXTURE_1D_ARRAY_EXT,
109         GL_TEXTURE_EXTERNAL_OES,
110         GL_TEXTURE_CUBE_MAP,
111         GL_TEXTURE_3D,
112         GL_TEXTURE_RECTANGLE_NV,
113         GL_TEXTURE_2D,
114         GL_TEXTURE_1D
115      };
116      STATIC_ASSERT(ARRAY_SIZE(targets) == NUM_TEXTURE_TARGETS);
117      shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]);
118      /* Need to explicitly set/overwrite the TargetIndex field here since
119       * the call to _mesa_tex_target_to_index() in NewTextureObject() may
120       * fail if the texture target is not supported.
121       */
122      shared->DefaultTex[i]->TargetIndex = i;
123   }
124
125   /* sanity check */
126   assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1);
127
128   /* Mutex and timestamp for texobj state validation */
129   mtx_init(&shared->TexMutex, mtx_recursive);
130   shared->TextureStateStamp = 0;
131
132   shared->FrameBuffers = _mesa_NewHashTable();
133   shared->RenderBuffers = _mesa_NewHashTable();
134
135   shared->SyncObjects = _mesa_set_create(NULL, _mesa_hash_pointer,
136                                          _mesa_key_pointer_equal);
137
138   shared->MemoryObjects = _mesa_NewHashTable();
139   shared->SemaphoreObjects = _mesa_NewHashTable();
140
141   return shared;
142
143fail:
144   free_shared_state(ctx, shared);
145   return NULL;
146}
147
148
149/**
150 * Callback for deleting a display list.  Called by _mesa_HashDeleteAll().
151 */
152static void
153delete_displaylist_cb(GLuint id, void *data, void *userData)
154{
155   struct gl_display_list *list = (struct gl_display_list *) data;
156   struct gl_context *ctx = (struct gl_context *) userData;
157   _mesa_delete_list(ctx, list);
158}
159
160
161/**
162 * Callback for deleting a bitmap atlas.  Called by _mesa_HashDeleteAll().
163 */
164static void
165delete_bitmap_atlas_cb(GLuint id, void *data, void *userData)
166{
167   struct gl_bitmap_atlas *atlas = (struct gl_bitmap_atlas *) data;
168   struct gl_context *ctx = (struct gl_context *) userData;
169   _mesa_delete_bitmap_atlas(ctx, atlas);
170}
171
172
173/**
174 * Callback for deleting a texture object.  Called by _mesa_HashDeleteAll().
175 */
176static void
177delete_texture_cb(GLuint id, void *data, void *userData)
178{
179   struct gl_texture_object *texObj = (struct gl_texture_object *) data;
180   struct gl_context *ctx = (struct gl_context *) userData;
181   ctx->Driver.DeleteTexture(ctx, texObj);
182}
183
184
185/**
186 * Callback for deleting a program object.  Called by _mesa_HashDeleteAll().
187 */
188static void
189delete_program_cb(GLuint id, void *data, void *userData)
190{
191   struct gl_program *prog = (struct gl_program *) data;
192   struct gl_context *ctx = (struct gl_context *) userData;
193   if(prog != &_mesa_DummyProgram) {
194      assert(prog->RefCount == 1); /* should only be referenced by hash table */
195      prog->RefCount = 0;  /* now going away */
196      ctx->Driver.DeleteProgram(ctx, prog);
197   }
198}
199
200
201/**
202 * Callback for deleting an ATI fragment shader object.
203 * Called by _mesa_HashDeleteAll().
204 */
205static void
206delete_fragshader_cb(GLuint id, void *data, void *userData)
207{
208   struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
209   struct gl_context *ctx = (struct gl_context *) userData;
210   _mesa_delete_ati_fragment_shader(ctx, shader);
211}
212
213
214/**
215 * Callback for deleting a buffer object.  Called by _mesa_HashDeleteAll().
216 */
217static void
218delete_bufferobj_cb(GLuint id, void *data, void *userData)
219{
220   struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
221   struct gl_context *ctx = (struct gl_context *) userData;
222
223   _mesa_buffer_unmap_all_mappings(ctx, bufObj);
224   _mesa_reference_buffer_object(ctx, &bufObj, NULL);
225}
226
227
228/**
229 * Callback for freeing shader program data. Call it before delete_shader_cb
230 * to avoid memory access error.
231 */
232static void
233free_shader_program_data_cb(GLuint id, void *data, void *userData)
234{
235   struct gl_context *ctx = (struct gl_context *) userData;
236   struct gl_shader_program *shProg = (struct gl_shader_program *) data;
237
238   if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
239       _mesa_free_shader_program_data(ctx, shProg);
240   }
241}
242
243
244/**
245 * Callback for deleting shader and shader programs objects.
246 * Called by _mesa_HashDeleteAll().
247 */
248static void
249delete_shader_cb(GLuint id, void *data, void *userData)
250{
251   struct gl_context *ctx = (struct gl_context *) userData;
252   struct gl_shader *sh = (struct gl_shader *) data;
253   if (_mesa_validate_shader_target(ctx, sh->Type)) {
254      _mesa_delete_shader(ctx, sh);
255   }
256   else {
257      struct gl_shader_program *shProg = (struct gl_shader_program *) data;
258      assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
259      _mesa_delete_shader_program(ctx, shProg);
260   }
261}
262
263
264/**
265 * Callback for deleting a framebuffer object.  Called by _mesa_HashDeleteAll()
266 */
267static void
268delete_framebuffer_cb(GLuint id, void *data, void *userData)
269{
270   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
271   /* The fact that the framebuffer is in the hashtable means its refcount
272    * is one, but we're removing from the hashtable now.  So clear refcount.
273    */
274   /*assert(fb->RefCount == 1);*/
275   fb->RefCount = 0;
276
277   /* NOTE: Delete should always be defined but there are two reports
278    * of it being NULL (bugs 13507, 14293).  Work-around for now.
279    */
280   if (fb->Delete)
281      fb->Delete(fb);
282}
283
284
285/**
286 * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll()
287 */
288static void
289delete_renderbuffer_cb(GLuint id, void *data, void *userData)
290{
291   struct gl_context *ctx = (struct gl_context *) userData;
292   struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
293   rb->RefCount = 0;  /* see comment for FBOs above */
294   if (rb->Delete)
295      rb->Delete(ctx, rb);
296}
297
298
299/**
300 * Callback for deleting a sampler object. Called by _mesa_HashDeleteAll()
301 */
302static void
303delete_sampler_object_cb(GLuint id, void *data, void *userData)
304{
305   struct gl_context *ctx = (struct gl_context *) userData;
306   struct gl_sampler_object *sampObj = (struct gl_sampler_object *) data;
307   _mesa_reference_sampler_object(ctx, &sampObj, NULL);
308}
309
310/**
311 * Callback for deleting a memory object.  Called by _mesa_HashDeleteAll().
312 */
313static void
314delete_memory_object_cb(GLuint id, void *data, void *userData)
315{
316   struct gl_memory_object *memObj = (struct gl_memory_object *) data;
317   struct gl_context *ctx = (struct gl_context *) userData;
318   ctx->Driver.DeleteMemoryObject(ctx, memObj);
319}
320
321/**
322 * Callback for deleting a memory object.  Called by _mesa_HashDeleteAll().
323 */
324static void
325delete_semaphore_object_cb(GLuint id, void *data, void *userData)
326{
327   struct gl_semaphore_object *semObj = (struct gl_semaphore_object *) data;
328   struct gl_context *ctx = (struct gl_context *) userData;
329   ctx->Driver.DeleteSemaphoreObject(ctx, semObj);
330}
331
332/**
333 * Deallocate a shared state object and all children structures.
334 *
335 * \param ctx GL context.
336 * \param shared shared state pointer.
337 *
338 * Frees the display lists, the texture objects (calling the driver texture
339 * deletion callback to free its private data) and the vertex programs, as well
340 * as their hash tables.
341 *
342 * \sa alloc_shared_state().
343 */
344static void
345free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared)
346{
347   GLuint i;
348
349   /* Free the dummy/fallback texture objects */
350   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
351      if (shared->FallbackTex[i])
352         ctx->Driver.DeleteTexture(ctx, shared->FallbackTex[i]);
353   }
354
355   /*
356    * Free display lists
357    */
358   if (shared->DisplayList) {
359      _mesa_HashDeleteAll(shared->DisplayList, delete_displaylist_cb, ctx);
360      _mesa_DeleteHashTable(shared->DisplayList);
361   }
362
363   if (shared->BitmapAtlas) {
364      _mesa_HashDeleteAll(shared->BitmapAtlas, delete_bitmap_atlas_cb, ctx);
365      _mesa_DeleteHashTable(shared->BitmapAtlas);
366   }
367
368   if (shared->ShaderObjects) {
369      _mesa_HashWalk(shared->ShaderObjects, free_shader_program_data_cb, ctx);
370      _mesa_HashDeleteAll(shared->ShaderObjects, delete_shader_cb, ctx);
371      _mesa_DeleteHashTable(shared->ShaderObjects);
372   }
373
374   if (shared->Programs) {
375      _mesa_HashDeleteAll(shared->Programs, delete_program_cb, ctx);
376      _mesa_DeleteHashTable(shared->Programs);
377   }
378
379   if (shared->DefaultVertexProgram)
380      _mesa_reference_program(ctx, &shared->DefaultVertexProgram, NULL);
381
382   if (shared->DefaultFragmentProgram)
383      _mesa_reference_program(ctx, &shared->DefaultFragmentProgram, NULL);
384
385   if (shared->DefaultFragmentShader)
386      _mesa_delete_ati_fragment_shader(ctx, shared->DefaultFragmentShader);
387
388   if (shared->ATIShaders) {
389      _mesa_HashDeleteAll(shared->ATIShaders, delete_fragshader_cb, ctx);
390      _mesa_DeleteHashTable(shared->ATIShaders);
391   }
392
393   if (shared->BufferObjects) {
394      _mesa_HashDeleteAll(shared->BufferObjects, delete_bufferobj_cb, ctx);
395      _mesa_DeleteHashTable(shared->BufferObjects);
396   }
397
398   if (shared->FrameBuffers) {
399      _mesa_HashDeleteAll(shared->FrameBuffers, delete_framebuffer_cb, ctx);
400      _mesa_DeleteHashTable(shared->FrameBuffers);
401   }
402
403   if (shared->RenderBuffers) {
404      _mesa_HashDeleteAll(shared->RenderBuffers, delete_renderbuffer_cb, ctx);
405      _mesa_DeleteHashTable(shared->RenderBuffers);
406   }
407
408   if (shared->NullBufferObj)
409      _mesa_reference_buffer_object(ctx, &shared->NullBufferObj, NULL);
410
411   if (shared->SyncObjects) {
412      set_foreach(shared->SyncObjects, entry) {
413         _mesa_unref_sync_object(ctx, (struct gl_sync_object *) entry->key, 1);
414      }
415
416      _mesa_set_destroy(shared->SyncObjects, NULL);
417   }
418
419   if (shared->SamplerObjects) {
420      _mesa_HashDeleteAll(shared->SamplerObjects, delete_sampler_object_cb,
421                          ctx);
422      _mesa_DeleteHashTable(shared->SamplerObjects);
423   }
424
425   /*
426    * Free texture objects (after FBOs since some textures might have
427    * been bound to FBOs).
428    */
429   assert(ctx->Driver.DeleteTexture);
430   /* the default textures */
431   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
432      if (shared->DefaultTex[i])
433         ctx->Driver.DeleteTexture(ctx, shared->DefaultTex[i]);
434   }
435
436   /* all other textures */
437   if (shared->TexObjects) {
438      _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx);
439      _mesa_DeleteHashTable(shared->TexObjects);
440   }
441
442   _mesa_free_shared_handles(shared);
443
444   if (shared->MemoryObjects) {
445      _mesa_HashDeleteAll(shared->MemoryObjects, delete_memory_object_cb, ctx);
446      _mesa_DeleteHashTable(shared->MemoryObjects);
447   }
448
449   if (shared->SemaphoreObjects) {
450      _mesa_HashDeleteAll(shared->SemaphoreObjects, delete_semaphore_object_cb, ctx);
451      _mesa_DeleteHashTable(shared->SemaphoreObjects);
452   }
453
454   simple_mtx_destroy(&shared->Mutex);
455   mtx_destroy(&shared->TexMutex);
456
457   free(shared);
458}
459
460
461/**
462 * gl_shared_state objects are ref counted.
463 * If ptr's refcount goes to zero, free the shared state.
464 */
465void
466_mesa_reference_shared_state(struct gl_context *ctx,
467                             struct gl_shared_state **ptr,
468                             struct gl_shared_state *state)
469{
470   if (*ptr == state)
471      return;
472
473   if (*ptr) {
474      /* unref old state */
475      struct gl_shared_state *old = *ptr;
476      GLboolean delete;
477
478      simple_mtx_lock(&old->Mutex);
479      assert(old->RefCount >= 1);
480      old->RefCount--;
481      delete = (old->RefCount == 0);
482      simple_mtx_unlock(&old->Mutex);
483
484      if (delete) {
485         free_shared_state(ctx, old);
486      }
487
488      *ptr = NULL;
489   }
490
491   if (state) {
492      /* reference new state */
493      simple_mtx_lock(&state->Mutex);
494      state->RefCount++;
495      *ptr = state;
496      simple_mtx_unlock(&state->Mutex);
497   }
498}
499