glsl: reduce memory footprint of uniform_storage struct

The uniform will only be of a single type so store the data for
opaque types in a single array.

Cc: Francisco Jerez <currojerez@riseup.net>
Cc: Ilia Mirkin <imirkin@alum.mit.edu>

diff --git a/src/glsl/ir_uniform.h b/src/glsl/ir_uniform.h
index 858a7da6bb955e894df5eef5bfef93a1d4c64054..50fe76b7ea28fbd6fee39653a6722b1bf61fbe6c 100644 (file)
--- a/src/glsl/ir_uniform.h
+++ b/src/glsl/ir_uniform.h
@@ -110,11 +110,7 @@ struct gl_uniform_storage {
     */
    bool initialized;
 
-   struct gl_opaque_uniform_index sampler[MESA_SHADER_STAGES];
-
-   struct gl_opaque_uniform_index image[MESA_SHADER_STAGES];
-
-   struct gl_opaque_uniform_index subroutine[MESA_SHADER_STAGES];
+   struct gl_opaque_uniform_index opaque[MESA_SHADER_STAGES];
 
    /**
     * Storage used by the driver for the uniform

diff --git a/src/glsl/link_uniform_initializers.cpp b/src/glsl/link_uniform_initializers.cpp
index 34830829b4a63de3a7fba63856b5f1973ed93aae..0918d2af9b8204f6f1c14b270ea940220f83cf88 100644 (file)
--- a/src/glsl/link_uniform_initializers.cpp
+++ b/src/glsl/link_uniform_initializers.cpp
@@ -134,16 +134,16 @@ set_opaque_binding(gl_shader_program *prog, const char *name, int binding)
 
       if (shader) {
          if (storage->type->base_type == GLSL_TYPE_SAMPLER &&
-             storage->sampler[sh].active) {
+             storage->opaque[sh].active) {
             for (unsigned i = 0; i < elements; i++) {
-               const unsigned index = storage->sampler[sh].index + i;
+               const unsigned index = storage->opaque[sh].index + i;
                shader->SamplerUnits[index] = storage->storage[i].i;
             }
 
          } else if (storage->type->base_type == GLSL_TYPE_IMAGE &&
-                    storage->image[sh].active) {
+                    storage->opaque[sh].active) {
             for (unsigned i = 0; i < elements; i++) {
-               const unsigned index = storage->image[sh].index + i;
+               const unsigned index = storage->opaque[sh].index + i;
                shader->ImageUnits[index] = storage->storage[i].i;
             }
          }
@@ -243,8 +243,8 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog,
          for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
             gl_shader *shader = prog->_LinkedShaders[sh];
 
-            if (shader && storage->sampler[sh].active) {
-               unsigned index = storage->sampler[sh].index;
+            if (shader && storage->opaque[sh].active) {
+               unsigned index = storage->opaque[sh].index;
 
                shader->SamplerUnits[index] = storage->storage[0].i;
             }

diff --git a/src/glsl/link_uniforms.cpp b/src/glsl/link_uniforms.cpp
index 740b0a46aeec7aaeb55e80fd1ee39e83ab5878c4..0642ddc4bf5da2482e354c046c4e74ff55cf0d26 100644 (file)
--- a/src/glsl/link_uniforms.cpp
+++ b/src/glsl/link_uniforms.cpp
@@ -566,7 +566,7 @@ private:
                         struct gl_uniform_storage *uniform, const char *name)
    {
       if (base_type->is_sampler()) {
-         uniform->sampler[shader_type].active = true;
+         uniform->opaque[shader_type].active = true;
 
          /* Handle multiple samplers inside struct arrays */
          if (this->record_array_count > 1) {
@@ -586,8 +586,8 @@ private:
                /* In this case, we've already seen this uniform so we just use
                 * the next sampler index recorded the last time we visited.
                 */
-               uniform->sampler[shader_type].index = index;
-               index = inner_array_size + uniform->sampler[shader_type].index;
+               uniform->opaque[shader_type].index = index;
+               index = inner_array_size + uniform->opaque[shader_type].index;
                this->record_next_sampler->put(index, name_copy);
 
                ralloc_free(name_copy);
@@ -605,13 +605,13 @@ private:
                 * structs. This allows the offset to be easily calculated for
                 * indirect indexing.
                 */
-               uniform->sampler[shader_type].index = this->next_sampler;
+               uniform->opaque[shader_type].index = this->next_sampler;
                this->next_sampler +=
                   inner_array_size * this->record_array_count;
 
                /* Store the next index for future passes over the struct array
                 */
-               index = uniform->sampler[shader_type].index + inner_array_size;
+               index = uniform->opaque[shader_type].index + inner_array_size;
                this->record_next_sampler->put(index, name_copy);
                ralloc_free(name_copy);
             }
@@ -619,22 +619,19 @@ private:
             /* Increment the sampler by 1 for non-arrays and by the number of
              * array elements for arrays.
              */
-            uniform->sampler[shader_type].index = this->next_sampler;
+            uniform->opaque[shader_type].index = this->next_sampler;
             this->next_sampler += MAX2(1, uniform->array_elements);
          }
 
          const gl_texture_index target = base_type->sampler_index();
          const unsigned shadow = base_type->sampler_shadow;
-         for (unsigned i = uniform->sampler[shader_type].index;
+         for (unsigned i = uniform->opaque[shader_type].index;
               i < MIN2(this->next_sampler, MAX_SAMPLERS);
               i++) {
             this->targets[i] = target;
             this->shader_samplers_used |= 1U << i;
             this->shader_shadow_samplers |= shadow << i;
          }
-      } else {
-         uniform->sampler[shader_type].index = ~0;
-         uniform->sampler[shader_type].active = false;
       }
    }
 
@@ -642,17 +639,14 @@ private:
                       struct gl_uniform_storage *uniform)
    {
       if (base_type->is_image()) {
-         uniform->image[shader_type].index = this->next_image;
-         uniform->image[shader_type].active = true;
+         uniform->opaque[shader_type].index = this->next_image;
+         uniform->opaque[shader_type].active = true;
 
          /* Increment the image index by 1 for non-arrays and by the
           * number of array elements for arrays.
           */
          this->next_image += MAX2(1, uniform->array_elements);
 
-      } else {
-         uniform->image[shader_type].index = ~0;
-         uniform->image[shader_type].active = false;
       }
    }
 
@@ -660,17 +654,14 @@ private:
                            struct gl_uniform_storage *uniform)
    {
       if (base_type->is_subroutine()) {
-         uniform->subroutine[shader_type].index = this->next_subroutine;
-         uniform->subroutine[shader_type].active = true;
+         uniform->opaque[shader_type].index = this->next_subroutine;
+         uniform->opaque[shader_type].active = true;
 
          /* Increment the subroutine index by 1 for non-arrays and by the
           * number of array elements for arrays.
           */
          this->next_subroutine += MAX2(1, uniform->array_elements);
 
-      } else {
-         uniform->subroutine[shader_type].index = ~0;
-         uniform->subroutine[shader_type].active = false;
       }
    }
 
@@ -738,6 +729,10 @@ private:
         base_type = type;
       }
 
+      /* Initialise opaque data */
+      this->uniforms[id].opaque[shader_type].index = ~0;
+      this->uniforms[id].opaque[shader_type].active = false;
+
       /* This assigns uniform indices to sampler and image uniforms. */
       handle_samplers(base_type, &this->uniforms[id], name);
       handle_images(base_type, &this->uniforms[id]);
@@ -1029,7 +1024,7 @@ link_set_image_access_qualifiers(struct gl_shader_program *prog)
             assert(found);
             (void) found;
             const gl_uniform_storage *storage = &prog->UniformStorage[id];
-            const unsigned index = storage->image[i].index;
+            const unsigned index = storage->opaque[i].index;
             const GLenum access = (var->data.image_read_only ? GL_READ_ONLY :
                                    var->data.image_write_only ? GL_WRITE_ONLY :
                                    GL_READ_WRITE);
@@ -1238,7 +1233,7 @@ link_assign_uniform_locations(struct gl_shader_program *prog,
          if (!sh)
             continue;
 
-         if (!uniforms[i].subroutine[j].active)
+         if (!uniforms[i].opaque[j].active)
             continue;
 
          /* How many new entries for this uniform? */
@@ -1268,7 +1263,7 @@ link_assign_uniform_locations(struct gl_shader_program *prog,
          if (!sh)
             continue;
 
-         if (!uniforms[i].subroutine[j].active)
+         if (!uniforms[i].opaque[j].active)
             continue;
 
          sh->SubroutineUniformRemapTable =

diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp
index 826a1881baf40b353877cae0459648b7da2cb12d..6df8d61cc447029c016d84e3a1ffa6e461476aa3 100644 (file)
--- a/src/glsl/linker.cpp
+++ b/src/glsl/linker.cpp
@@ -3497,7 +3497,7 @@ build_program_resource_list(struct gl_shader_program *shProg)
          continue;
 
       for (int j = MESA_SHADER_VERTEX; j < MESA_SHADER_STAGES; j++) {
-         if (!shProg->UniformStorage[i].subroutine[j].active)
+         if (!shProg->UniformStorage[i].opaque[j].active)
             continue;
 
          type = _mesa_shader_stage_to_subroutine_uniform((gl_shader_stage)j);

diff --git a/src/glsl/nir/nir_lower_samplers.c b/src/glsl/nir/nir_lower_samplers.c
index 58ea0db4e0f12c85ffdd62d435c1973f71d4a47d..5df79a69a065bbaf9c5c53ab9af40fc657656ea6 100644 (file)
--- a/src/glsl/nir/nir_lower_samplers.c
+++ b/src/glsl/nir/nir_lower_samplers.c
@@ -131,13 +131,13 @@ lower_sampler(nir_tex_instr *instr, const struct gl_shader_program *shader_progr
    }
 
    if (location > shader_program->NumUniformStorage - 1 ||
-       !shader_program->UniformStorage[location].sampler[stage].active) {
+       !shader_program->UniformStorage[location].opaque[stage].active) {
       assert(!"cannot return a sampler");
       return;
    }
 
    instr->sampler_index +=
-      shader_program->UniformStorage[location].sampler[stage].index;
+      shader_program->UniformStorage[location].opaque[stage].index;
 
    instr->sampler = NULL;
 }

diff --git a/src/glsl/tests/set_uniform_initializer_tests.cpp b/src/glsl/tests/set_uniform_initializer_tests.cpp
index 91227d9487af5fc6957cad3317d9579476778809..0b1f66cb34286fa66a195b8fcd2745d5be46740d 100644 (file)
--- a/src/glsl/tests/set_uniform_initializer_tests.cpp
+++ b/src/glsl/tests/set_uniform_initializer_tests.cpp
@@ -117,8 +117,8 @@ establish_uniform_storage(struct gl_shader_program *prog, unsigned num_storage,
    prog->UniformStorage[index_to_set].array_elements = array_size;
    prog->UniformStorage[index_to_set].initialized = false;
    for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
-      prog->UniformStorage[index_to_set].sampler[sh].index = ~0;
-      prog->UniformStorage[index_to_set].sampler[sh].active = false;
+      prog->UniformStorage[index_to_set].opaque[sh].index = ~0;
+      prog->UniformStorage[index_to_set].opaque[sh].active = false;
    }
    prog->UniformStorage[index_to_set].num_driver_storage = 0;
    prog->UniformStorage[index_to_set].driver_storage = NULL;
@@ -138,8 +138,8 @@ establish_uniform_storage(struct gl_shader_program *prog, unsigned num_storage,
       prog->UniformStorage[i].array_elements = 0;
       prog->UniformStorage[i].initialized = false;
       for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
-         prog->UniformStorage[i].sampler[sh].index = ~0;
-         prog->UniformStorage[i].sampler[sh].active = false;
+         prog->UniformStorage[i].opaque[sh].index = ~0;
+         prog->UniformStorage[i].opaque[sh].active = false;
       }
       prog->UniformStorage[i].num_driver_storage = 0;
       prog->UniformStorage[i].driver_storage = NULL;

diff --git a/src/mesa/drivers/dri/i965/brw_shader.cpp b/src/mesa/drivers/dri/i965/brw_shader.cpp
index c8568f77304f0d93a48cc326a33a37138821d859..3960e86942188111f6609e596446aa5b1ced2292 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_shader.cpp
+++ b/src/mesa/drivers/dri/i965/brw_shader.cpp
@@ -1436,7 +1436,7 @@ brw_setup_image_uniform_values(gl_shader_stage stage,
       &stage_prog_data->param[param_start_index];
 
    for (unsigned i = 0; i < MAX2(storage->array_elements, 1); i++) {
-      const unsigned image_idx = storage->image[stage].index + i;
+      const unsigned image_idx = storage->opaque[stage].index + i;
       const brw_image_param *image_param =
          &stage_prog_data->image_param[image_idx];
 

diff --git a/src/mesa/main/shaderapi.c b/src/mesa/main/shaderapi.c
index 13fdf8c033bd2b4d79014cfd90797d1374740361..9dd1054c8ee4820f3be0fcf3252731471187ef1c 100644 (file)
--- a/src/mesa/main/shaderapi.c
+++ b/src/mesa/main/shaderapi.c
@@ -2597,7 +2597,7 @@ _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
 
    {
       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[location];
-      int offset = location - uni->subroutine[stage].index;
+      int offset = location - uni->opaque[stage].index;
       memcpy(params, &uni->storage[offset],
             sizeof(GLuint));
    }

diff --git a/src/mesa/main/uniform_query.cpp b/src/mesa/main/uniform_query.cpp
index 33c959dc1a5583f3b2faf6804cf129286a5b115a..d48729778aec3e6cba86720abf253aaa57daa336 100644 (file)
--- a/src/mesa/main/uniform_query.cpp
+++ b/src/mesa/main/uniform_query.cpp
@@ -804,11 +804,11 @@ _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
 
         /* If the shader stage doesn't use the sampler uniform, skip this.
          */
-        if (sh == NULL || !uni->sampler[i].active)
+        if (sh == NULL || !uni->opaque[i].active)
            continue;
 
          for (int j = 0; j < count; j++) {
-            sh->SamplerUnits[uni->sampler[i].index + offset + j] =
+            sh->SamplerUnits[uni->opaque[i].index + offset + j] =
                ((unsigned *) values)[j];
          }
 
@@ -850,11 +850,11 @@ _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
     */
    if (uni->type->is_image()) {
       for (int i = 0; i < MESA_SHADER_STAGES; i++) {
-        if (uni->image[i].active) {
+        if (uni->opaque[i].active) {
             struct gl_shader *sh = shProg->_LinkedShaders[i];
 
             for (int j = 0; j < count; j++)
-               sh->ImageUnits[uni->image[i].index + offset + j] =
+               sh->ImageUnits[uni->opaque[i].index + offset + j] =
                   ((GLint *) values)[j];
          }
       }

diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp
index 35ea791827afe3767a3f7c186ce927e742c114bc..e81f459da28bace8f2b9b23bdfdf422c21d92550 100644 (file)
--- a/src/mesa/program/ir_to_mesa.cpp
+++ b/src/mesa/program/ir_to_mesa.cpp
@@ -2352,11 +2352,12 @@ add_uniform_to_shader::visit_field(const glsl_type *type, const char *name,
         struct gl_uniform_storage *storage =
            &this->shader_program->UniformStorage[location];
 
-         assert(storage->sampler[shader_type].active);
+         assert(storage->type->is_sampler() &&
+                storage->opaque[shader_type].active);
 
         for (unsigned int j = 0; j < size / 4; j++)
             params->ParameterValues[index + j][0].f =
-               storage->sampler[shader_type].index + j;
+               storage->opaque[shader_type].index + j;
       }
    }
 

diff --git a/src/mesa/program/sampler.cpp b/src/mesa/program/sampler.cpp
index b1168fdade8d0d996ee7588066e93c45a2494a9d..1198a3c45f1d120a688db4810796e330d37666e3 100644 (file)
--- a/src/mesa/program/sampler.cpp
+++ b/src/mesa/program/sampler.cpp
@@ -119,7 +119,7 @@ _mesa_get_sampler_uniform_value(class ir_dereference *sampler,
       return 0;
    }
 
-   if (!shader_program->UniformStorage[location].sampler[shader].active) {
+   if (!shader_program->UniformStorage[location].opaque[shader].active) {
       assert(0 && "cannot return a sampler");
       linker_error(shader_program,
                   "cannot return a sampler named %s, because it is not "
@@ -128,7 +128,7 @@ _mesa_get_sampler_uniform_value(class ir_dereference *sampler,
       return 0;
    }
 
-   return shader_program->UniformStorage[location].sampler[shader].index +
+   return shader_program->UniformStorage[location].opaque[shader].index +
           getname.offset;
 }