[Mesa-dev] [PATCHv2 08/13] mesa: add infrastructure for threaded shader compilation

Brian Paul brianp at vmware.com
Wed Jul 9 07:42:46 PDT 2014


On 07/09/2014 01:47 AM, Chia-I Wu wrote:
> Add _mesa_enable_glsl_threadpool to enable the thread pool for a context, and
> add ctx->Const.DeferCompileShader and ctx->Const.DeferLinkProgram to
> fine-control what gets threaded.
>
> Setting DeferCompileShader to true will make _mesa_glsl_compile_shader be
> executed in a worker thread.  The function is thread-safe so there is no
> restriction on DeferCompileShader.
>
> Setting DeferLinkProgram to true will make _mesa_glsl_link_shader be executed
> in a worker thread.  The function is thread-safe only when certain driver
> functions (as documented in struct gl_constants) are thread-safe.  It is
> drivers' responsibility to fix those driver functions before setting
> DeferLinkProgram.
>
> When DeferLinkProgram is set, drivers are not supposed to inspect the context
> in their LinkShader callbacks.  Instead, NotifyLinkShader is added.  Drivers
> should inspect the context in NotifyLinkShader and save what they need for
> LinkShader in gl_shader_program.
>
> As a final note, most applications will not benefit from threaded shader
> compilation because they check GL_COMPILE_STATUS/GL_LINK_STATUS immediately,
> giving the worker threads no time to do their jobs.  A possible improvement is
> to split LinkShader into two parts: the first part links and error checks
> while the second part optimizes and generates the machine code.  With the
> split, we can always defer the second part to the thread pool.
>
> Signed-off-by: Chia-I Wu <olv at lunarg.com>
> ---
>   src/mesa/main/context.c     |  29 +++++++++++
>   src/mesa/main/context.h     |   3 ++
>   src/mesa/main/dd.h          |   8 +++
>   src/mesa/main/mtypes.h      |  34 ++++++++++++
>   src/mesa/main/pipelineobj.c |  18 +++++++
>   src/mesa/main/shaderapi.c   | 122 +++++++++++++++++++++++++++++++++++++++-----
>   src/mesa/main/shaderobj.c   |  74 +++++++++++++++++++++++++--
>   src/mesa/main/shaderobj.h   |  55 ++++++++++++++++++--
>   8 files changed, 322 insertions(+), 21 deletions(-)
>
> diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
> index b082159..e27450c 100644
> --- a/src/mesa/main/context.c
> +++ b/src/mesa/main/context.c
> @@ -112,6 +112,7 @@
>   #include "points.h"
>   #include "polygon.h"
>   #include "queryobj.h"
> +#include "shaderapi.h"
>   #include "syncobj.h"
>   #include "rastpos.h"
>   #include "remap.h"
> @@ -139,6 +140,7 @@
>   #endif
>
>   #include "glsl_parser_extras.h"
> +#include "threadpool.h"
>   #include <stdbool.h>
>
>
> @@ -1187,6 +1189,27 @@ _mesa_create_context(gl_api api,
>      }
>   }
>
> +void
> +_mesa_enable_glsl_threadpool(struct gl_context *ctx, int max_threads)
> +{
> +   if (!ctx->ThreadPool)
> +      ctx->ThreadPool = _mesa_glsl_get_threadpool(max_threads);
> +}
> +
> +static void
> +wait_shader_object_cb(GLuint id, void *data, void *userData)
> +{
> +   struct gl_context *ctx = (struct gl_context *) userData;
> +   struct gl_shader *sh = (struct gl_shader *) data;
> +
> +   if (_mesa_validate_shader_target(ctx, sh->Type)) {
> +      _mesa_wait_shaders(ctx, &sh, 1);
> +   }
> +   else {
> +      struct gl_shader_program *shProg = (struct gl_shader_program *) data;
> +      _mesa_wait_shader_program(ctx, shProg);
> +   }
> +}
>
>   /**
>    * Free the data associated with the given context.
> @@ -1205,6 +1228,12 @@ _mesa_free_context_data( struct gl_context *ctx )
>         _mesa_make_current(ctx, NULL, NULL);
>      }
>
> +   if (ctx->ThreadPool) {
> +      _mesa_HashWalk(ctx->Shared->ShaderObjects, wait_shader_object_cb, ctx);
> +      _mesa_threadpool_unref(ctx->ThreadPool);
> +      ctx->ThreadPool = NULL;
> +   }
> +
>      /* unreference WinSysDraw/Read buffers */
>      _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
>      _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
> diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h
> index 792ab4c..b23f9fa 100644
> --- a/src/mesa/main/context.h
> +++ b/src/mesa/main/context.h
> @@ -118,6 +118,9 @@ _mesa_create_context(gl_api api,
>                        const struct dd_function_table *driverFunctions);
>
>   extern void
> +_mesa_enable_glsl_threadpool(struct gl_context *ctx, int max_threads);
> +
> +extern void
>   _mesa_free_context_data( struct gl_context *ctx );
>
>   extern void
> diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
> index 633ea2c..38f8c68 100644
> --- a/src/mesa/main/dd.h
> +++ b/src/mesa/main/dd.h
> @@ -447,6 +447,14 @@ struct dd_function_table {
>       */
>      /*@{*/
>      /**
> +    * Called when a shader program is to be linked.
> +    *
> +    * This is optional and gives drivers an opportunity to inspect the context
> +    * and prepare for LinkShader, which may be deferred to another thread.
> +    */
> +   void (*NotifyLinkShader)(struct gl_context *ctx,
> +                            struct gl_shader_program *shader);
> +   /**
>       * Called when a shader program is linked.
>       *
>       * This gives drivers an opportunity to clone the IR and make their
> diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
> index 5964576..316da23 100644
> --- a/src/mesa/main/mtypes.h
> +++ b/src/mesa/main/mtypes.h
> @@ -71,6 +71,8 @@ typedef GLuint64 GLbitfield64;
>    */
>   /*@{*/
>   struct _mesa_HashTable;
> +struct _mesa_threadpool;
> +struct _mesa_threadpool_task;
>   struct gl_attrib_node;
>   struct gl_list_extensions;
>   struct gl_meta_state;
> @@ -2510,6 +2512,14 @@ struct gl_shader
>          */
>         unsigned LocalSize[3];
>      } Comp;
> +
> +   /**
> +    * Deferred task of glCompileShader.  We should extend the mutex, not only
> +    * to protect the deferred task, but to protect the entire gl_shader.
> +    */
> +   mtx_t Mutex;
> +   struct _mesa_threadpool_task *Task;
> +   void *TaskData;

AFAICT, TaskData is always a gl_context *.  If so, should it be changed 
to "struct gl_context *TaskContext"?  Same thing in gl_shader_program.



>   };
>
>
> @@ -2770,6 +2780,15 @@ struct gl_shader_program
>       * #extension ARB_fragment_coord_conventions: enable
>       */
>      GLboolean ARB_fragment_coord_conventions_enable;
> +
> +   /**
> +    * Deferred task of glLinkProgram.  We should extend the mutex, not only
> +    * to protect the deferred task, but to protect the entire
> +    * gl_shader_program.
> +    */
> +   mtx_t Mutex;
> +   struct _mesa_threadpool_task *Task;
> +   void *TaskData;
>   };
>
>
> @@ -3489,6 +3508,18 @@ struct gl_constants
>      GLfloat MaxFragmentInterpolationOffset;
>
>      GLboolean FakeSWMSAA;
> +
> +   /*
> +    * Defer certain operations to a thread pool.
> +    *
> +    * When DeferLinkProgram is set, these functions must be thread-safe
> +    *
> +    *   ctx->Driver.NewShader
> +    *   ctx->Driver.DeleteShader
> +    *   ctx->Driver.LinkShader
> +    */
> +   GLboolean DeferCompileShader;
> +   GLboolean DeferLinkProgram;
>   };
>
>
> @@ -4262,6 +4293,9 @@ struct gl_context
>       * Once this field becomes true, it is never reset to false.
>       */
>      GLboolean ShareGroupReset;
> +
> +   /* A thread pool for threaded shader compilation */
> +   struct _mesa_threadpool *ThreadPool;
>   };
>
>
> diff --git a/src/mesa/main/pipelineobj.c b/src/mesa/main/pipelineobj.c
> index 90c1d00..ae4f80a 100644
> --- a/src/mesa/main/pipelineobj.c
> +++ b/src/mesa/main/pipelineobj.c
> @@ -211,6 +211,24 @@ _mesa_reference_pipeline_object_(struct gl_context *ctx,
>         }
>         else {
>            obj->RefCount++;
> +
> +         /*
> +          * The current pipeline object (as set by glUseProgram or
> +          * glBindProgramPipeline) cannot have unfinished tasks.
> +          */
> +         if (ptr == &ctx->_Shader) {
> +            if (obj->ActiveProgram)
> +               _mesa_wait_shader_program(ctx, obj->ActiveProgram);
> +            if (obj->Name) {
> +               int i;
> +
> +               for (i = 0; i < MESA_SHADER_STAGES; i++) {
> +                  if (obj->CurrentProgram[i])
> +                     _mesa_wait_shader_program(ctx, obj->CurrentProgram[i]);
> +               }
> +            }
> +         }
> +
>            *ptr = obj;
>         }
>         mtx_unlock(&obj->Mutex);
> diff --git a/src/mesa/main/shaderapi.c b/src/mesa/main/shaderapi.c
> index 2bbef35..339d7a2 100644
> --- a/src/mesa/main/shaderapi.c
> +++ b/src/mesa/main/shaderapi.c
> @@ -53,6 +53,7 @@
>   #include "program/prog_print.h"
>   #include "program/prog_parameter.h"
>   #include "ralloc.h"
> +#include "threadpool.h"
>   #include <stdbool.h>
>   #include "../glsl/glsl_parser_extras.h"
>   #include "../glsl/ir.h"
> @@ -210,7 +211,8 @@ _mesa_validate_shader_target(const struct gl_context *ctx, GLenum type)
>   static GLboolean
>   is_program(struct gl_context *ctx, GLuint name)
>   {
> -   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
> +   struct gl_shader_program *shProg =
> +      _mesa_lookup_shader_program_no_wait(ctx, name);
>      return shProg ? GL_TRUE : GL_FALSE;
>   }
>
> @@ -218,7 +220,7 @@ is_program(struct gl_context *ctx, GLuint name)
>   static GLboolean
>   is_shader(struct gl_context *ctx, GLuint name)
>   {
> -   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
> +   struct gl_shader *shader = _mesa_lookup_shader_no_wait(ctx, name);
>      return shader ? GL_TRUE : GL_FALSE;
>   }
>
> @@ -239,7 +241,7 @@ attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
>      if (!shProg)
>         return;
>
> -   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
> +   sh = _mesa_lookup_shader_err_no_wait(ctx, shader, "glAttachShader");
>      if (!sh) {
>         return;
>      }
> @@ -341,7 +343,9 @@ delete_shader_program(struct gl_context *ctx, GLuint name)
>       */
>      struct gl_shader_program *shProg;
>
> -   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
> +   /* no waiting until _mesa_delete_shader_program() */
> +   shProg = _mesa_lookup_shader_program_err_no_wait(ctx, name,
> +                                                    "glDeleteProgram");
>      if (!shProg)
>         return;
>
> @@ -359,7 +363,8 @@ delete_shader(struct gl_context *ctx, GLuint shader)
>   {
>      struct gl_shader *sh;
>
> -   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
> +   /* no waiting until _mesa_delete_shader() */
> +   sh = _mesa_lookup_shader_err_no_wait(ctx, shader, "glDeleteShader");
>      if (!sh)
>         return;
>
> @@ -812,6 +817,48 @@ shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
>   #endif
>   }
>
> +static bool
> +can_queue_task(struct gl_context *ctx)
> +{
> +   if (!ctx->ThreadPool)
> +      return false;
> +
> +   /* MESA_GLSL is set */
> +   if (ctx->_Shader->Flags)
> +      return false;
> +
> +   /* context requires synchronized compiler warnings and errors */
> +   if (_mesa_get_debug_state_int(ctx, GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB))
> +      return false;
> +
> +   return true;
> +}
> +



Can you add a comment on this function indicating that it's called from 
a threadpool thread?

> +static void
> +deferred_compile_shader(void *data)
> +{
> +   struct gl_shader *sh = (struct gl_shader *) data;
> +   struct gl_context *ctx = (struct gl_context *) sh->TaskData;
> +
> +   _mesa_glsl_compile_shader(ctx, sh, false, false);
> +}
> +


Maybe add a comment on this function too?

> +static bool
> +queue_compile_shader(struct gl_context *ctx, struct gl_shader *sh)
> +{
> +   if (!can_queue_task(ctx))
> +      return false;
> +   if (!ctx->Const.DeferCompileShader)
> +      return false;
> +
> +   sh->TaskData = (void *) ctx;
> +   sh->Task = _mesa_threadpool_queue_task(ctx->ThreadPool,
> +         deferred_compile_shader, (void *) sh);
> +   if (!sh->Task)
> +      sh->TaskData = NULL;
> +
> +   return (sh->Task != NULL);
> +}
>
>   /**
>    * Compile a shader.
> @@ -844,10 +891,12 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
>            fflush(stderr);
>         }
>
> -      /* this call will set the shader->CompileStatus field to indicate if
> -       * compilation was successful.
> +      /* This call will set the shader->CompileStatus field to indicate if
> +       * compilation was successful.  But if queueing succeeded, the field
> +       * will be set at a later point.
>          */
> -      _mesa_glsl_compile_shader(ctx, sh, false, false);
> +      if (!queue_compile_shader(ctx, sh))
> +         _mesa_glsl_compile_shader(ctx, sh, false, false);
>
>         if (ctx->_Shader->Flags & GLSL_LOG) {
>            _mesa_write_shader_to_file(sh);
> @@ -870,7 +919,7 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
>
>      }
>
> -   if (!sh->CompileStatus) {
> +   if (ctx->_Shader->Flags && !sh->CompileStatus) {
>         if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
>            fprintf(stderr, "GLSL source for %s shader %d:\n",
>                    _mesa_shader_stage_to_string(sh->Stage), sh->Name);
> @@ -887,6 +936,49 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
>   }
>
>
> +static void
> +deferred_link_program(void *data)
> +{
> +   struct gl_shader_program *shProg = (struct gl_shader_program *) data;
> +   struct gl_context *ctx = (struct gl_context *) shProg->TaskData;
> +
> +   _mesa_wait_shaders(ctx, shProg->Shaders, shProg->NumShaders);
> +   _mesa_glsl_link_shader(ctx, shProg);
> +}
> +
> +static bool
> +queue_link_program(struct gl_context *ctx, struct gl_shader_program *shProg)
> +{
> +   int i;
> +
> +   if (!can_queue_task(ctx))
> +      return false;
> +   if (!ctx->Const.DeferLinkProgram)
> +      return false;
> +
> +   /*
> +    * Rather than adding _mesa_wait_shader_program calls here and there, we
> +    * simply disallow threaded linking when the program is current or active.
> +    */
> +   if (ctx->_Shader->ActiveProgram == shProg)
> +      return false;
> +   /* be careful for separate programs */
> +   if (ctx->_Shader->Name != 0) {
> +      for (i = 0; i < MESA_SHADER_STAGES; i++) {
> +         if (ctx->_Shader->CurrentProgram[i] == shProg)
> +            return false;
> +      }
> +   }
> +
> +   shProg->TaskData = (void *) ctx;
> +   shProg->Task = _mesa_threadpool_queue_task(ctx->ThreadPool,
> +         deferred_link_program, (void *) shProg);
> +   if (!shProg->Task)
> +      shProg->TaskData = NULL;
> +
> +   return (shProg->Task != NULL);
> +}
> +
>   /**
>    * Link a program's shaders.
>    */
> @@ -912,10 +1004,16 @@ link_program(struct gl_context *ctx, GLuint program)
>
>      FLUSH_VERTICES(ctx, _NEW_PROGRAM);
>
> -   _mesa_glsl_link_shader(ctx, shProg);
> +   if (ctx->Driver.NotifyLinkShader)
> +      ctx->Driver.NotifyLinkShader(ctx, shProg);
> +
> +   if (!queue_link_program(ctx, shProg)) {
> +      _mesa_wait_shaders(ctx, shProg->Shaders, shProg->NumShaders);
> +      _mesa_glsl_link_shader(ctx, shProg);
> +   }
>
> -   if (shProg->LinkStatus == GL_FALSE &&
> -       (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
> +   if ((ctx->_Shader->Flags & GLSL_REPORT_ERRORS) &&
> +       shProg->LinkStatus == GL_FALSE) {
>         _mesa_debug(ctx, "Error linking program %u:\n%s\n",
>                     shProg->Name, shProg->InfoLog);
>      }
> diff --git a/src/mesa/main/shaderobj.c b/src/mesa/main/shaderobj.c
> index b9feff4..ab94d14 100644
> --- a/src/mesa/main/shaderobj.c
> +++ b/src/mesa/main/shaderobj.c
> @@ -41,6 +41,7 @@
>   #include "program/prog_parameter.h"
>   #include "program/hash_table.h"
>   #include "ralloc.h"
> +#include "threadpool.h"
>
>   /**********************************************************************/
>   /*** Shader object functions                                        ***/
> @@ -95,6 +96,7 @@ _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
>   void
>   _mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader)
>   {
> +   mtx_init(&shader->Mutex, mtx_plain);
>      shader->RefCount = 1;
>   }
>
> @@ -125,18 +127,51 @@ _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)
>   static void
>   _mesa_delete_shader(struct gl_context *ctx, struct gl_shader *sh)
>   {
> +   _mesa_wait_shaders(ctx, &sh, 1);
> +
>      free((void *)sh->Source);
>      free(sh->Label);
>      _mesa_reference_program(ctx, &sh->Program, NULL);
> +   mtx_destroy(&sh->Mutex);
>      ralloc_free(sh);
>   }
>
>
>   /**
> + * Wait for the threaded compile tasks to complete.
> + */
> +void
> +_mesa_wait_shaders(struct gl_context *ctx,
> +                   struct gl_shader **shaders,
> +                   int num_shaders)
> +{
> +   int i;
> +
> +   for (i = 0; i < num_shaders; i++) {
> +      struct gl_shader *sh = shaders[i];
> +
> +      mtx_lock(&sh->Mutex);
> +
> +      if (sh->Task) {
> +         struct gl_context *task_ctx = (struct gl_context *) sh->TaskData;
> +
> +         if (!_mesa_threadpool_complete_task(task_ctx->ThreadPool, sh->Task))
> +            sh->CompileStatus = GL_FALSE;
> +
> +         sh->Task = NULL;
> +         sh->TaskData = NULL;
> +      }
> +
> +      mtx_unlock(&sh->Mutex);
> +   }
> +}
> +
> +
> +/**
>    * Lookup a GLSL shader object.

Update the comment to explain _no_wait ?

>    */
>   struct gl_shader *
> -_mesa_lookup_shader(struct gl_context *ctx, GLuint name)
> +_mesa_lookup_shader_no_wait(struct gl_context *ctx, GLuint name)
>   {
>      if (name) {
>         struct gl_shader *sh = (struct gl_shader *)
> @@ -158,7 +193,8 @@ _mesa_lookup_shader(struct gl_context *ctx, GLuint name)
>    * As above, but record an error if shader is not found.

Update this comment too?

>    */
>   struct gl_shader *
> -_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller)
> +_mesa_lookup_shader_err_no_wait(struct gl_context *ctx, GLuint name,
> +                                const char *caller)
>   {
>      if (!name) {
>         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
> @@ -238,6 +274,8 @@ _mesa_reference_shader_program(struct gl_context *ctx,
>   void
>   _mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog)
>   {
> +   mtx_init(&prog->Mutex, mtx_plain);
> +
>      prog->Type = GL_SHADER_PROGRAM_MESA;
>      prog->RefCount = 1;
>
> @@ -373,17 +411,43 @@ _mesa_free_shader_program_data(struct gl_context *ctx,
>   static void
>   _mesa_delete_shader_program(struct gl_context *ctx, struct gl_shader_program *shProg)
>   {
> +   _mesa_wait_shader_program(ctx, shProg);
> +
>      _mesa_free_shader_program_data(ctx, shProg);
> +   mtx_destroy(&shProg->Mutex);
>
>      ralloc_free(shProg);
>   }
>
>
>   /**
> + * Wait for the threaded linking task to complete.
> + */
> +void
> +_mesa_wait_shader_program(struct gl_context *ctx,
> +                          struct gl_shader_program *shProg)
> +{
> +   mtx_lock(&shProg->Mutex);
> +
> +   if (shProg->Task) {
> +      struct gl_context *task_ctx = (struct gl_context *) shProg->TaskData;
> +
> +      if (!_mesa_threadpool_complete_task(task_ctx->ThreadPool,
> +                                          shProg->Task))
> +         shProg->LinkStatus = GL_FALSE;
> +      shProg->Task = NULL;
> +      shProg->TaskData = NULL;
> +   }
> +
> +   mtx_unlock(&shProg->Mutex);
> +}
> +
> +
> +/**
>    * Lookup a GLSL program object.
>    */
>   struct gl_shader_program *
> -_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)
> +_mesa_lookup_shader_program_no_wait(struct gl_context *ctx, GLuint name)
>   {
>      struct gl_shader_program *shProg;
>      if (name) {
> @@ -406,8 +470,8 @@ _mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)
>    * As above, but record an error if program is not found.
>    */
>   struct gl_shader_program *
> -_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
> -                                const char *caller)
> +_mesa_lookup_shader_program_err_no_wait(struct gl_context *ctx, GLuint name,
> +                                        const char *caller)
>   {
>      if (!name) {
>         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
> diff --git a/src/mesa/main/shaderobj.h b/src/mesa/main/shaderobj.h
> index fae8be8..c2f8a0d 100644
> --- a/src/mesa/main/shaderobj.h
> +++ b/src/mesa/main/shaderobj.h
> @@ -53,13 +53,35 @@ extern void
>   _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
>                          struct gl_shader *sh);
>
> +extern void
> +_mesa_wait_shaders(struct gl_context *ctx,
> +                   struct gl_shader **shaders,
> +                   int num_shaders);
> +
>   extern struct gl_shader *
> -_mesa_lookup_shader(struct gl_context *ctx, GLuint name);
> +_mesa_lookup_shader_no_wait(struct gl_context *ctx, GLuint name);
>
>   extern struct gl_shader *
> -_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller);
> +_mesa_lookup_shader_err_no_wait(struct gl_context *ctx, GLuint name,
> +                                const char *caller);
>
> +static inline struct gl_shader *
> +_mesa_lookup_shader(struct gl_context *ctx, GLuint name)
> +{
> +   struct gl_shader *sh = _mesa_lookup_shader_no_wait(ctx, name);
> +   if (sh)
> +      _mesa_wait_shaders(ctx, &sh, 1);
> +   return sh;
> +}
>
> +static inline struct gl_shader *
> +_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller)
> +{
> +   struct gl_shader *sh = _mesa_lookup_shader_err_no_wait(ctx, name, caller);
> +   if (sh)
> +      _mesa_wait_shaders(ctx, &sh, 1);
> +   return sh;
> +}
>
>   extern void
>   _mesa_reference_shader_program(struct gl_context *ctx,
> @@ -74,12 +96,37 @@ _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type);
>   extern void
>   _mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog);
>
> +extern void
> +_mesa_wait_shader_program(struct gl_context *ctx,
> +                          struct gl_shader_program *shProg);
> +
>   extern struct gl_shader_program *
> -_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name);
> +_mesa_lookup_shader_program_no_wait(struct gl_context *ctx, GLuint name);
>
>   extern struct gl_shader_program *
> +_mesa_lookup_shader_program_err_no_wait(struct gl_context *ctx, GLuint name,
> +                                        const char *caller);
> +
> +static inline struct gl_shader_program *
> +_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)
> +{
> +   struct gl_shader_program *shProg =
> +      _mesa_lookup_shader_program_no_wait(ctx, name);
> +   if (shProg)
> +      _mesa_wait_shader_program(ctx, shProg);
> +   return shProg;
> +}
> +
> +static inline struct gl_shader_program *
>   _mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
> -                                const char *caller);
> +                                const char *caller)
> +{
> +   struct gl_shader_program *shProg =
> +      _mesa_lookup_shader_program_err_no_wait(ctx, name, caller);
> +   if (shProg)
> +      _mesa_wait_shader_program(ctx, shProg);
> +   return shProg;
> +}
>
>   extern void
>   _mesa_clear_shader_program_data(struct gl_context *ctx,
>



More information about the mesa-dev mailing list