/* * Copyright © 2018 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * 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 * 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. */ #include "nir.h" #include "linker_util.h" #include "gl_nir_linker.h" #include "compiler/glsl/ir_uniform.h" /* for gl_uniform_storage */ #include "main/context.h" /* This file do the common link for GLSL atomic counter uniforms, using NIR, * instead of IR as the counter-part glsl/link_uniforms.cpp * * Also note that this is tailored for ARB_gl_spirv needs and particularities */ struct active_atomic_counter_uniform { unsigned loc; nir_variable *var; }; struct active_atomic_buffer { struct active_atomic_counter_uniform *uniforms; unsigned num_uniforms; unsigned uniform_buffer_size; unsigned stage_counter_references[MESA_SHADER_STAGES]; unsigned size; }; static void add_atomic_counter(const void *ctx, struct active_atomic_buffer *buffer, unsigned uniform_loc, nir_variable *var) { if (buffer->num_uniforms >= buffer->uniform_buffer_size) { if (buffer->uniform_buffer_size == 0) buffer->uniform_buffer_size = 1; else buffer->uniform_buffer_size *= 2; buffer->uniforms = reralloc(ctx, buffer->uniforms, struct active_atomic_counter_uniform, buffer->uniform_buffer_size); } struct active_atomic_counter_uniform *uniform = buffer->uniforms + buffer->num_uniforms; uniform->loc = uniform_loc; uniform->var = var; buffer->num_uniforms++; } static void process_atomic_variable(const struct glsl_type *t, struct gl_shader_program *prog, unsigned *uniform_loc, nir_variable *var, struct active_atomic_buffer *buffers, unsigned *num_buffers, int *offset, unsigned shader_stage) { /* FIXME: Arrays of arrays get counted separately. For example: * x1[3][3][2] = 9 uniforms, 18 atomic counters * x2[3][2] = 3 uniforms, 6 atomic counters * x3[2] = 1 uniform, 2 atomic counters * * However this code marks all the counters as active even when they * might not be used. */ if (glsl_type_is_array(t) && glsl_type_is_array(glsl_get_array_element(t))) { for (unsigned i = 0; i < glsl_get_length(t); i++) { process_atomic_variable(glsl_get_array_element(t), prog, uniform_loc, var, buffers, num_buffers, offset, shader_stage); } } else { struct active_atomic_buffer *buf = buffers + var->data.binding; struct gl_uniform_storage *const storage = &prog->data->UniformStorage[*uniform_loc]; /* If this is the first time the buffer is used, increment * the counter of buffers used. */ if (buf->size == 0) (*num_buffers)++; add_atomic_counter(buffers, /* ctx */ buf, *uniform_loc, var); /* When checking for atomic counters we should count every member in * an array as an atomic counter reference. */ if (glsl_type_is_array(t)) buf->stage_counter_references[shader_stage] += glsl_get_length(t); else buf->stage_counter_references[shader_stage]++; buf->size = MAX2(buf->size, *offset + glsl_atomic_size(t)); storage->offset = *offset; *offset += glsl_atomic_size(t); (*uniform_loc)++; } } static struct active_atomic_buffer * find_active_atomic_counters(struct gl_context *ctx, struct gl_shader_program *prog, unsigned *num_buffers) { struct active_atomic_buffer *buffers = rzalloc_array(NULL, /* ctx */ struct active_atomic_buffer, ctx->Const.MaxAtomicBufferBindings); *num_buffers = 0; for (unsigned i = 0; i < MESA_SHADER_STAGES; ++i) { struct gl_linked_shader *sh = prog->_LinkedShaders[i]; if (sh == NULL) continue; nir_shader *nir = sh->Program->nir; nir_foreach_variable(var, &nir->uniforms) { if (!glsl_contains_atomic(var->type)) continue; int offset = var->data.offset; unsigned uniform_loc = var->data.location; process_atomic_variable(var->type, prog, &uniform_loc, var, buffers, num_buffers, &offset, i); } } return buffers; } void gl_nir_link_assign_atomic_counter_resources(struct gl_context *ctx, struct gl_shader_program *prog) { unsigned num_buffers; unsigned num_atomic_buffers[MESA_SHADER_STAGES] = {0}; struct active_atomic_buffer *abs = find_active_atomic_counters(ctx, prog, &num_buffers); prog->data->AtomicBuffers = rzalloc_array(prog->data, struct gl_active_atomic_buffer, num_buffers); prog->data->NumAtomicBuffers = num_buffers; unsigned buffer_idx = 0; for (unsigned binding = 0; binding < ctx->Const.MaxAtomicBufferBindings; binding++) { /* If the binding was not used, skip. */ if (abs[binding].size == 0) continue; struct active_atomic_buffer *ab = abs + binding; struct gl_active_atomic_buffer *mab = prog->data->AtomicBuffers + buffer_idx; /* Assign buffer-specific fields. */ mab->Binding = binding; mab->MinimumSize = ab->size; mab->Uniforms = rzalloc_array(prog->data->AtomicBuffers, GLuint, ab->num_uniforms); mab->NumUniforms = ab->num_uniforms; /* Assign counter-specific fields. */ for (unsigned j = 0; j < ab->num_uniforms; j++) { nir_variable *var = ab->uniforms[j].var; struct gl_uniform_storage *storage = &prog->data->UniformStorage[ab->uniforms[j].loc]; mab->Uniforms[j] = ab->uniforms[j].loc; storage->atomic_buffer_index = buffer_idx; storage->offset = var->data.offset; if (glsl_type_is_array(var->type)) { const struct glsl_type *without_array = glsl_without_array(var->type); storage->array_stride = glsl_atomic_size(without_array); } else { storage->array_stride = 0; } if (!glsl_type_is_matrix(var->type)) storage->matrix_stride = 0; } /* Assign stage-specific fields. */ for (unsigned stage = 0; stage < MESA_SHADER_STAGES; ++stage) { if (ab->stage_counter_references[stage]) { mab->StageReferences[stage] = GL_TRUE; num_atomic_buffers[stage]++; } else { mab->StageReferences[stage] = GL_FALSE; } } buffer_idx++; } /* Store a list pointers to atomic buffers per stage and store the index * to the intra-stage buffer list in uniform storage. */ for (unsigned stage = 0; stage < MESA_SHADER_STAGES; ++stage) { if (prog->_LinkedShaders[stage] == NULL || num_atomic_buffers[stage] <= 0) continue; struct gl_program *gl_prog = prog->_LinkedShaders[stage]->Program; gl_prog->info.num_abos = num_atomic_buffers[stage]; gl_prog->sh.AtomicBuffers = rzalloc_array(gl_prog, struct gl_active_atomic_buffer *, num_atomic_buffers[stage]); gl_prog->nir->info.num_abos = num_atomic_buffers[stage]; unsigned intra_stage_idx = 0; for (unsigned i = 0; i < num_buffers; i++) { struct gl_active_atomic_buffer *atomic_buffer = &prog->data->AtomicBuffers[i]; if (!atomic_buffer->StageReferences[stage]) continue; gl_prog->sh.AtomicBuffers[intra_stage_idx] = atomic_buffer; for (unsigned u = 0; u < atomic_buffer->NumUniforms; u++) { GLuint uniform_loc = atomic_buffer->Uniforms[u]; struct gl_opaque_uniform_index *opaque = prog->data->UniformStorage[uniform_loc].opaque + stage; opaque->index = intra_stage_idx; opaque->active = true; } intra_stage_idx++; } } assert(buffer_idx == num_buffers); ralloc_free(abs); }