src/glsl/link_uniforms.cpp

   1 /*
   2  * Copyright © 2011 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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "main/core.h"
  25 #include "ir.h"
  26 #include "linker.h"
  27 #include "ir_uniform.h"
  28 #include "glsl_symbol_table.h"
  29 #include "program/hash_table.h"
  30 #include "program.h"
  31
  32 static inline unsigned int
  33 align(unsigned int a, unsigned int align)
  34 {
  35    return (a + align - 1) / align * align;
  36 }
  37
  38 /**
  39  * \file link_uniforms.cpp
  40  * Assign locations for GLSL uniforms.
  41  *
  42  * \author Ian Romanick <ian.d.romanick@intel.com>
  43  */
  44
  45 /**
  46  * Count the backing storage requirements for a type
  47  */
  48 static unsigned
  49 values_for_type(const glsl_type *type)
  50 {
  51    if (type->is_sampler()) {
  52       return 1;
  53    } else if (type->is_array() && type->fields.array->is_sampler()) {
  54       return type->array_size();
  55    } else {
  56       return type->component_slots();
  57    }
  58 }
  59
  60 void
  61 uniform_field_visitor::process(ir_variable *var)
  62 {
  63    const glsl_type *t = var->type;
  64
  65    /* Only strdup the name if we actually will need to modify it. */
  66    if (t->is_record() || (t->is_array() && t->fields.array->is_record())) {
  67       char *name = ralloc_strdup(NULL, var->name);
  68       recursion(var->type, &name, strlen(name));
  69       ralloc_free(name);
  70    } else {
  71       this->visit_field(t, var->name);
  72    }
  73 }
  74
  75 void
  76 uniform_field_visitor::recursion(const glsl_type *t, char **name,
  77                                  size_t name_length)
  78 {
  79    /* Records need to have each field processed individually.
  80     *
  81     * Arrays of records need to have each array element processed
  82     * individually, then each field of the resulting array elements processed
  83     * individually.
  84     */
  85    if (t->is_record()) {
  86       for (unsigned i = 0; i < t->length; i++) {
  87          const char *field = t->fields.structure[i].name;
  88          size_t new_length = name_length;
  89
  90          /* Append '.field' to the current uniform name. */
  91          ralloc_asprintf_rewrite_tail(name, &new_length, ".%s", field);
  92
  93          recursion(t->fields.structure[i].type, name, new_length);
  94       }
  95    } else if (t->is_array() && t->fields.array->is_record()) {
  96       for (unsigned i = 0; i < t->length; i++) {
  97          size_t new_length = name_length;
  98
  99          /* Append the subscript to the current uniform name */
 100          ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
 101
 102          recursion(t->fields.array, name, new_length);
 103       }
 104    } else {
 105       this->visit_field(t, *name);
 106    }
 107 }
 108
 109 /**
 110  * Class to help calculate the storage requirements for a set of uniforms
 111  *
 112  * As uniforms are added to the active set the number of active uniforms and
 113  * the storage requirements for those uniforms are accumulated.  The active
 114  * uniforms are added the the hash table supplied to the constructor.
 115  *
 116  * If the same uniform is added multiple times (i.e., once for each shader
 117  * target), it will only be accounted once.
 118  */
 119 class count_uniform_size : public uniform_field_visitor {
 120 public:
 121    count_uniform_size(struct string_to_uint_map *map)
 122       : num_active_uniforms(0), num_values(0), num_shader_samplers(0),
 123         num_shader_uniform_components(0), map(map)
 124    {
 125       /* empty */
 126    }
 127
 128    void start_shader()
 129    {
 130       this->num_shader_samplers = 0;
 131       this->num_shader_uniform_components = 0;
 132    }
 133
 134    /**
 135     * Total number of active uniforms counted
 136     */
 137    unsigned num_active_uniforms;
 138
 139    /**
 140     * Number of data values required to back the storage for the active uniforms
 141     */
 142    unsigned num_values;
 143
 144    /**
 145     * Number of samplers used
 146     */
 147    unsigned num_shader_samplers;
 148
 149    /**
 150     * Number of uniforms used in the current shader
 151     */
 152    unsigned num_shader_uniform_components;
 153
 154 private:
 155    virtual void visit_field(const glsl_type *type, const char *name)
 156    {
 157       assert(!type->is_record());
 158       assert(!(type->is_array() && type->fields.array->is_record()));
 159
 160       /* Count the number of samplers regardless of whether the uniform is
 161        * already in the hash table.  The hash table prevents adding the same
 162        * uniform for multiple shader targets, but in this case we want to
 163        * count it for each shader target.
 164        */
 165       const unsigned values = values_for_type(type);
 166       if (type->contains_sampler()) {
 167          this->num_shader_samplers +=
 168             type->is_array() ? type->array_size() : 1;
 169       } else {
 170          /* Accumulate the total number of uniform slots used by this shader.
 171           * Note that samplers do not count against this limit because they
 172           * don't use any storage on current hardware.
 173           */
 174          this->num_shader_uniform_components += values;
 175       }
 176
 177       /* If the uniform is already in the map, there's nothing more to do.
 178        */
 179       unsigned id;
 180       if (this->map->get(id, name))
 181          return;
 182
 183       this->map->put(this->num_active_uniforms, name);
 184
 185       /* Each leaf uniform occupies one entry in the list of active
 186        * uniforms.
 187        */
 188       this->num_active_uniforms++;
 189       this->num_values += values;
 190    }
 191
 192    struct string_to_uint_map *map;
 193 };
 194
 195 /**
 196  * Class to help parcel out pieces of backing storage to uniforms
 197  *
 198  * Each uniform processed has some range of the \c gl_constant_value
 199  * structures associated with it.  The association is done by finding
 200  * the uniform in the \c string_to_uint_map and using the value from
 201  * the map to connect that slot in the \c gl_uniform_storage table
 202  * with the next available slot in the \c gl_constant_value array.
 203  *
 204  * \warning
 205  * This class assumes that every uniform that will be processed is
 206  * already in the \c string_to_uint_map.  In addition, it assumes that
 207  * the \c gl_uniform_storage and \c gl_constant_value arrays are "big
 208  * enough."
 209  */
 210 class parcel_out_uniform_storage : public uniform_field_visitor {
 211 public:
 212    parcel_out_uniform_storage(struct string_to_uint_map *map,
 213                               struct gl_uniform_storage *uniforms,
 214                               union gl_constant_value *values)
 215       : map(map), uniforms(uniforms), next_sampler(0), values(values)
 216    {
 217       memset(this->targets, 0, sizeof(this->targets));
 218    }
 219
 220    void start_shader()
 221    {
 222       this->shader_samplers_used = 0;
 223       this->shader_shadow_samplers = 0;
 224    }
 225
 226    void set_and_process(struct gl_shader_program *prog,
 227                         ir_variable *var)
 228    {
 229       ubo_var = NULL;
 230       if (var->uniform_block != -1) {
 231          struct gl_uniform_block *block =
 232             &prog->UniformBlocks[var->uniform_block];
 233
 234          ubo_block_index = var->uniform_block;
 235          ubo_var_index = var->location;
 236          ubo_var = &block->Uniforms[var->location];
 237          ubo_byte_offset = ubo_var->Offset;
 238       }
 239
 240       process(var);
 241    }
 242
 243    struct gl_uniform_buffer_variable *ubo_var;
 244    int ubo_block_index;
 245    int ubo_var_index;
 246    int ubo_byte_offset;
 247
 248 private:
 249    virtual void visit_field(const glsl_type *type, const char *name)
 250    {
 251       assert(!type->is_record());
 252       assert(!(type->is_array() && type->fields.array->is_record()));
 253
 254       unsigned id;
 255       bool found = this->map->get(id, name);
 256       assert(found);
 257
 258       if (!found)
 259          return;
 260
 261       /* If there is already storage associated with this uniform, it means
 262        * that it was set while processing an earlier shader stage.  For
 263        * example, we may be processing the uniform in the fragment shader, but
 264        * the uniform was already processed in the vertex shader.
 265        */
 266       if (this->uniforms[id].storage != NULL) {
 267          /* If the uniform already has storage set from another shader stage,
 268           * mark the samplers used for this shader stage.
 269           */
 270          if (type->contains_sampler()) {
 271             const unsigned count = MAX2(1, this->uniforms[id].array_elements);
 272             const unsigned shadow = (type->is_array())
 273                ? type->fields.array->sampler_shadow : type->sampler_shadow;
 274
 275             for (unsigned i = 0; i < count; i++) {
 276                const unsigned s = this->uniforms[id].sampler + i;
 277
 278                this->shader_samplers_used |= 1U << s;
 279                this->shader_shadow_samplers |= shadow << s;
 280             }
 281          }
 282
 283          return;
 284       }
 285
 286       const glsl_type *base_type;
 287       if (type->is_array()) {
 288          this->uniforms[id].array_elements = type->length;
 289          base_type = type->fields.array;
 290       } else {
 291          this->uniforms[id].array_elements = 0;
 292          base_type = type;
 293       }
 294
 295       if (base_type->is_sampler()) {
 296          this->uniforms[id].sampler = this->next_sampler;
 297
 298          /* Increment the sampler by 1 for non-arrays and by the number of
 299           * array elements for arrays.
 300           */
 301          this->next_sampler += MAX2(1, this->uniforms[id].array_elements);
 302
 303          const gl_texture_index target = base_type->sampler_index();
 304          const unsigned shadow = base_type->sampler_shadow;
 305          for (unsigned i = this->uniforms[id].sampler
 306                  ; i < this->next_sampler
 307                  ; i++) {
 308             this->targets[i] = target;
 309             this->shader_samplers_used |= 1U << i;
 310             this->shader_shadow_samplers |= shadow << i;
 311          }
 312
 313       } else {
 314          this->uniforms[id].sampler = ~0;
 315       }
 316
 317       this->uniforms[id].name = ralloc_strdup(this->uniforms, name);
 318       this->uniforms[id].type = base_type;
 319       this->uniforms[id].initialized = 0;
 320       this->uniforms[id].num_driver_storage = 0;
 321       this->uniforms[id].driver_storage = NULL;
 322       this->uniforms[id].storage = this->values;
 323       if (this->ubo_var) {
 324          this->uniforms[id].block_index = this->ubo_block_index;
 325
 326          unsigned alignment = type->std140_base_alignment(ubo_var->RowMajor);
 327          this->ubo_byte_offset = align(this->ubo_byte_offset, alignment);
 328          this->uniforms[id].offset = this->ubo_byte_offset;
 329          this->ubo_byte_offset += type->std140_size(ubo_var->RowMajor);
 330
 331          this->uniforms[id].array_stride = 0;
 332          this->uniforms[id].matrix_stride = 0;
 333          this->uniforms[id].row_major = base_type->is_matrix() &&
 334             ubo_var->RowMajor;
 335       } else {
 336          this->uniforms[id].block_index = -1;
 337          this->uniforms[id].offset = -1;
 338          this->uniforms[id].array_stride = -1;
 339          this->uniforms[id].matrix_stride = -1;
 340          this->uniforms[id].row_major = false;
 341       }
 342
 343       this->values += values_for_type(type);
 344    }
 345
 346    struct string_to_uint_map *map;
 347
 348    struct gl_uniform_storage *uniforms;
 349    unsigned next_sampler;
 350
 351 public:
 352    union gl_constant_value *values;
 353
 354    gl_texture_index targets[MAX_SAMPLERS];
 355
 356    /**
 357     * Mask of samplers used by the current shader stage.
 358     */
 359    unsigned shader_samplers_used;
 360
 361    /**
 362     * Mask of samplers used by the current shader stage for shadows.
 363     */
 364    unsigned shader_shadow_samplers;
 365 };
 366
 367 /**
 368  * Merges a uniform block into an array of uniform blocks that may or
 369  * may not already contain a copy of it.
 370  *
 371  * Returns the index of the new block in the array.
 372  */
 373 int
 374 link_cross_validate_uniform_block(void *mem_ctx,
 375                                   struct gl_uniform_block **linked_blocks,
 376                                   unsigned int *num_linked_blocks,
 377                                   struct gl_uniform_block *new_block)
 378 {
 379    for (unsigned int i = 0; i < *num_linked_blocks; i++) {
 380       struct gl_uniform_block *old_block = &(*linked_blocks)[i];
 381       if (strcmp(old_block->Name, new_block->Name) == 0) {
 382          if (old_block->NumUniforms != new_block->NumUniforms) {
 383             return -1;
 384          }
 385
 386          for (unsigned j = 0; j < old_block->NumUniforms; j++) {
 387             if (strcmp(old_block->Uniforms[j].Name,
 388                        new_block->Uniforms[j].Name) != 0)
 389                return -1;
 390
 391             if (old_block->Uniforms[j].Offset !=
 392                 new_block->Uniforms[j].Offset)
 393                return -1;
 394
 395             if (old_block->Uniforms[j].RowMajor !=
 396                 new_block->Uniforms[j].RowMajor)
 397                return -1;
 398          }
 399          return i;
 400       }
 401    }
 402
 403    *linked_blocks = reralloc(mem_ctx, *linked_blocks,
 404                              struct gl_uniform_block,
 405                              *num_linked_blocks + 1);
 406    int linked_block_index = (*num_linked_blocks)++;
 407    struct gl_uniform_block *linked_block = &(*linked_blocks)[linked_block_index];
 408
 409    memcpy(linked_block, new_block, sizeof(*new_block));
 410    linked_block->Uniforms = ralloc_array(*linked_blocks,
 411                                          struct gl_uniform_buffer_variable,
 412                                          linked_block->NumUniforms);
 413
 414    memcpy(linked_block->Uniforms,
 415           new_block->Uniforms,
 416           sizeof(*linked_block->Uniforms) * linked_block->NumUniforms);
 417
 418    for (unsigned int i = 0; i < linked_block->NumUniforms; i++) {
 419       struct gl_uniform_buffer_variable *ubo_var =
 420          &linked_block->Uniforms[i];
 421
 422       ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name);
 423    }
 424
 425    return linked_block_index;
 426 }
 427
 428 /**
 429  * Walks the IR and update the references to uniform blocks in the
 430  * ir_variables to point at linked shader's list (previously, they
 431  * would point at the uniform block list in one of the pre-linked
 432  * shaders).
 433  */
 434 static bool
 435 link_update_uniform_buffer_variables(struct gl_shader *shader)
 436 {
 437    foreach_list(node, shader->ir) {
 438       ir_variable *const var = ((ir_instruction *) node)->as_variable();
 439
 440       if ((var == NULL) || (var->uniform_block == -1))
 441          continue;
 442
 443       assert(var->mode == ir_var_uniform);
 444
 445       bool found = false;
 446       for (unsigned i = 0; i < shader->NumUniformBlocks; i++) {
 447          for (unsigned j = 0; j < shader->UniformBlocks[i].NumUniforms; j++) {
 448             if (!strcmp(var->name, shader->UniformBlocks[i].Uniforms[j].Name)) {
 449                found = true;
 450                var->uniform_block = i;
 451                var->location = j;
 452                break;
 453             }
 454          }
 455          if (found)
 456             break;
 457       }
 458       assert(found);
 459    }
 460
 461    return true;
 462 }
 463
 464 void
 465 link_assign_uniform_block_offsets(struct gl_shader *shader)
 466 {
 467    for (unsigned b = 0; b < shader->NumUniformBlocks; b++) {
 468       struct gl_uniform_block *block = &shader->UniformBlocks[b];
 469
 470       unsigned offset = 0;
 471       for (unsigned int i = 0; i < block->NumUniforms; i++) {
 472          struct gl_uniform_buffer_variable *ubo_var = &block->Uniforms[i];
 473          const struct glsl_type *type = ubo_var->Type;
 474
 475          unsigned alignment = type->std140_base_alignment(ubo_var->RowMajor);
 476          unsigned size = type->std140_size(ubo_var->RowMajor);
 477
 478          offset = align(offset, alignment);
 479          ubo_var->Offset = offset;
 480          offset += size;
 481       }
 482       block->UniformBufferSize = offset;
 483    }
 484 }
 485
 486 void
 487 link_assign_uniform_locations(struct gl_shader_program *prog)
 488 {
 489    ralloc_free(prog->UniformStorage);
 490    prog->UniformStorage = NULL;
 491    prog->NumUserUniformStorage = 0;
 492
 493    if (prog->UniformHash != NULL) {
 494       prog->UniformHash->clear();
 495    } else {
 496       prog->UniformHash = new string_to_uint_map;
 497    }
 498
 499    /* Uniforms that lack an initializer in the shader code have an initial
 500     * value of zero.  This includes sampler uniforms.
 501     *
 502     * Page 24 (page 30 of the PDF) of the GLSL 1.20 spec says:
 503     *
 504     *     "The link time initial value is either the value of the variable's
 505     *     initializer, if present, or 0 if no initializer is present. Sampler
 506     *     types cannot have initializers."
 507     */
 508    memset(prog->SamplerUnits, 0, sizeof(prog->SamplerUnits));
 509
 510    for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
 511       if (prog->_LinkedShaders[i] == NULL)
 512          continue;
 513
 514       if (!link_update_uniform_buffer_variables(prog->_LinkedShaders[i]))
 515          return;
 516    }
 517
 518    /* First pass: Count the uniform resources used by the user-defined
 519     * uniforms.  While this happens, each active uniform will have an index
 520     * assigned to it.
 521     *
 522     * Note: this is *NOT* the index that is returned to the application by
 523     * glGetUniformLocation.
 524     */
 525    count_uniform_size uniform_size(prog->UniformHash);
 526    for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
 527       if (prog->_LinkedShaders[i] == NULL)
 528          continue;
 529
 530       /* Reset various per-shader target counts.
 531        */
 532       uniform_size.start_shader();
 533
 534       foreach_list(node, prog->_LinkedShaders[i]->ir) {
 535          ir_variable *const var = ((ir_instruction *) node)->as_variable();
 536
 537          if ((var == NULL) || (var->mode != ir_var_uniform))
 538             continue;
 539
 540          /* FINISHME: Update code to process built-in uniforms!
 541           */
 542          if (strncmp("gl_", var->name, 3) == 0)
 543             continue;
 544
 545          uniform_size.process(var);
 546       }
 547
 548       prog->_LinkedShaders[i]->num_samplers = uniform_size.num_shader_samplers;
 549       prog->_LinkedShaders[i]->num_uniform_components =
 550          uniform_size.num_shader_uniform_components;
 551    }
 552
 553    const unsigned num_user_uniforms = uniform_size.num_active_uniforms;
 554    const unsigned num_data_slots = uniform_size.num_values;
 555
 556    /* On the outside chance that there were no uniforms, bail out.
 557     */
 558    if (num_user_uniforms == 0)
 559       return;
 560
 561    struct gl_uniform_storage *uniforms =
 562       rzalloc_array(prog, struct gl_uniform_storage, num_user_uniforms);
 563    union gl_constant_value *data =
 564       rzalloc_array(uniforms, union gl_constant_value, num_data_slots);
 565 #ifndef NDEBUG
 566    union gl_constant_value *data_end = &data[num_data_slots];
 567 #endif
 568
 569    parcel_out_uniform_storage parcel(prog->UniformHash, uniforms, data);
 570
 571    for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
 572       if (prog->_LinkedShaders[i] == NULL)
 573          continue;
 574
 575       /* Reset various per-shader target counts.
 576        */
 577       parcel.start_shader();
 578
 579       foreach_list(node, prog->_LinkedShaders[i]->ir) {
 580          ir_variable *const var = ((ir_instruction *) node)->as_variable();
 581
 582          if ((var == NULL) || (var->mode != ir_var_uniform))
 583             continue;
 584
 585          /* FINISHME: Update code to process built-in uniforms!
 586           */
 587          if (strncmp("gl_", var->name, 3) == 0)
 588             continue;
 589
 590          parcel.set_and_process(prog, var);
 591       }
 592
 593       prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used;
 594       prog->_LinkedShaders[i]->shadow_samplers = parcel.shader_shadow_samplers;
 595    }
 596
 597    assert(sizeof(prog->SamplerTargets) == sizeof(parcel.targets));
 598    memcpy(prog->SamplerTargets, parcel.targets, sizeof(prog->SamplerTargets));
 599
 600 #ifndef NDEBUG
 601    for (unsigned i = 0; i < num_user_uniforms; i++) {
 602       assert(uniforms[i].storage != NULL);
 603    }
 604
 605    assert(parcel.values == data_end);
 606 #endif
 607
 608    prog->NumUserUniformStorage = num_user_uniforms;
 609    prog->UniformStorage = uniforms;
 610
 611    link_set_uniform_initializers(prog);
 612
 613    return;
 614 }