On 2015-05-14 07:06:30, Iago Toral Quiroga wrote:
> Extend the existing lower_ubo_reference pass to also detect SSBO writes
> and lower them to ir_ssbo_store nodes.
> ---
> src/glsl/lower_ubo_reference.cpp | 412
> +++++++++++++++++++++++++++++++--------
> 1 file changed, 336 insertions(+), 76 deletions(-)
>
> diff --git a/src/glsl/lower_ubo_reference.cpp
> b/src/glsl/lower_ubo_reference.cpp
> index fb8a890..8cb28f5 100644
> --- a/src/glsl/lower_ubo_reference.cpp
> +++ b/src/glsl/lower_ubo_reference.cpp
> @@ -139,12 +139,34 @@ public:
> }
>
> void handle_rvalue(ir_rvalue **rvalue);
> + ir_visitor_status visit_enter(ir_assignment *ir);
> +
> + void setup_for_load_or_write(ir_variable *var,
> + ir_dereference *deref,
> + ir_rvalue **offset,
> + unsigned *const_offset,
> + bool *row_major,
> + int *matrix_columns,
> + bool *is_buffer);
> +
> void emit_ubo_loads(ir_dereference *deref, ir_variable *base_offset,
> unsigned int deref_offset, bool row_major,
> int matrix_columns);
> ir_expression *ubo_load(const struct glsl_type *type,
> ir_rvalue *offset);
>
> +
> + void check_for_ssbo_write(ir_assignment *ir);
> + void write_to_memory(ir_dereference *deref,
> + ir_variable *var,
> + ir_variable *write_var,
> + unsigned write_mask);
> + void emit_ssbo_writes(ir_dereference *deref, ir_variable *base_offset,
> + unsigned int deref_offset, bool row_major,
> + int matrix_columns, unsigned write_mask);
> + ir_ssbo_store *ssbo_write(ir_rvalue *deref, ir_rvalue *offset,
> + unsigned write_mask);
> +
> void *mem_ctx;
> struct gl_shader *shader;
> struct gl_uniform_buffer_variable *ubo_var;
> @@ -219,26 +241,21 @@ interface_field_name(void *mem_ctx, char *base_name,
> ir_dereference *d,
> }
>
> void
> -lower_ubo_reference_visitor::handle_rvalue(ir_rvalue **rvalue)
> +lower_ubo_reference_visitor::setup_for_load_or_write(ir_variable *var,
> + ir_dereference *deref,
> + ir_rvalue **offset,
> + unsigned *const_offset,
> + bool *row_major,
> + int *matrix_columns,
> + bool *is_buffer)
> {
> - if (!*rvalue)
> - return;
> -
> - ir_dereference *deref = (*rvalue)->as_dereference();
> - if (!deref)
> - return;
> -
> - ir_variable *var = deref->variable_referenced();
> - if (!var || !var->is_in_uniform_block())
> - return;
> -
> - mem_ctx = ralloc_parent(*rvalue);
> -
> + /* Fix out the name of the interface block*/
> ir_rvalue *nonconst_block_index;
> const char *const field_name =
> interface_field_name(mem_ctx, (char *) var->get_interface_type()->name,
> deref, &nonconst_block_index);
>
> + /* Locate the ubo block by interface name */
> this->uniform_block = NULL;
> for (unsigned i = 0; i < shader->NumUniformBlocks; i++) {
> if (strcmp(field_name, shader->UniformBlocks[i].Name) == 0) {
> @@ -253,10 +270,7 @@ lower_ubo_reference_visitor::handle_rvalue(ir_rvalue
> **rvalue)
> this->uniform_block = index;
> }
>
> - if (shader->UniformBlocks[i].IsBuffer)
> - this->opcode = ir_binop_ssbo_load;
> - else
> - this->opcode = ir_binop_ubo_load;
> + *is_buffer = shader->UniformBlocks[i].IsBuffer;
>
> struct gl_uniform_block *block = &shader->UniformBlocks[i];
>
> @@ -269,10 +283,10 @@ lower_ubo_reference_visitor::handle_rvalue(ir_rvalue
> **rvalue)
>
> assert(this->uniform_block);
>
> - ir_rvalue *offset = new(mem_ctx) ir_constant(0u);
> - unsigned const_offset = 0;
> - bool row_major = is_dereferenced_thing_row_major(deref);
> - int matrix_columns = 1;
> + *offset = new(mem_ctx) ir_constant(0u);
> + *const_offset = 0;
> + *row_major = is_dereferenced_thing_row_major(deref);
> + *matrix_columns = 1;
>
> /* Calculate the offset to the start of the region of the UBO
> * dereferenced by *rvalue. This may be a variable offset if an
> @@ -281,76 +295,76 @@ lower_ubo_reference_visitor::handle_rvalue(ir_rvalue
> **rvalue)
> while (deref) {
> switch (deref->ir_type) {
> case ir_type_dereference_variable: {
> - const_offset += ubo_var->Offset;
> - deref = NULL;
> - break;
> + *const_offset += ubo_var->Offset;
> + deref = NULL;
> + break;
> }
>
> case ir_type_dereference_array: {
> - ir_dereference_array *deref_array = (ir_dereference_array *)deref;
> - unsigned array_stride;
> - if (deref_array->array->type->is_matrix() && row_major) {
> - /* When loading a vector out of a row major matrix, the
> - * step between the columns (vectors) is the size of a
> - * float, while the step between the rows (elements of a
> - * vector) is handled below in emit_ubo_loads.
> - */
> - array_stride = 4;
> + ir_dereference_array *deref_array = (ir_dereference_array *) deref;
> + unsigned array_stride;
> + if (deref_array->array->type->is_matrix() && *row_major) {
> + /* When loading a vector out of a row major matrix, the
> + * step between the columns (vectors) is the size of a
> + * float, while the step between the rows (elements of a
> + * vector) is handled below in emit_ubo_loads.
> + */
> + array_stride = 4;
> if (deref_array->array->type->is_double())
> array_stride *= 2;
> - matrix_columns = deref_array->array->type->matrix_columns;
> + *matrix_columns = deref_array->array->type->matrix_columns;
> } else if (deref_array->type->is_interface()) {
> /* We're processing an array dereference of an interface instance
> - * array. The thing being dereferenced *must* be a variable
> - * dereference because intefaces cannot be embedded an other
> - * types. In terms of calculating the offsets for the lowering
> - * pass, we don't care about the array index. All elements of an
> - * interface instance array will have the same offsets relative to
> - * the base of the block that backs them.
> + * array. The thing being dereferenced *must* be a variable
> + * dereference because interfaces cannot be embedded in other
> + * types. In terms of calculating the offsets for the lowering
> + * pass, we don't care about the array index. All elements of an
> + * interface instance array will have the same offsets relative
> to
> + * the base of the block that backs them.
> */
> assert(deref_array->array->as_dereference_variable());
> deref = deref_array->array->as_dereference();
> break;
> - } else {
> + } else {
> /* Whether or not the field is row-major (because it might be a
> - * bvec2 or something) does not affect the array itself. We need
> + * bvec2 or something) does not affect the array itself. We need
> * to know whether an array element in its entirety is row-major.
> */
> const bool array_row_major =
> is_dereferenced_thing_row_major(deref_array);
>
> - array_stride = deref_array->type->std140_size(array_row_major);
> - array_stride = glsl_align(array_stride, 16);
> - }
> + array_stride = deref_array->type->std140_size(array_row_major);
> + array_stride = glsl_align(array_stride, 16);
> + }
>
> ir_rvalue *array_index = deref_array->array_index;
> if (array_index->type->base_type == GLSL_TYPE_INT)
> array_index = i2u(array_index);
>
> - ir_constant *const_index =
> + ir_constant *const_index =
> array_index->constant_expression_value(NULL);
> - if (const_index) {
> - const_offset += array_stride * const_index->value.u[0];
> - } else {
> - offset = add(offset,
> - mul(array_index,
> - new(mem_ctx) ir_constant(array_stride)));
> - }
> - deref = deref_array->array->as_dereference();
> - break;
> + if (const_index) {
> + *const_offset += array_stride * const_index->value.u[0];
> + } else {
> + *offset = add(*offset,
> + mul(array_index,
> + new(mem_ctx) ir_constant(array_stride)));
> + }
> + deref = deref_array->array->as_dereference();
> + break;
> }
>
> case ir_type_dereference_record: {
> - ir_dereference_record *deref_record = (ir_dereference_record *)deref;
> - const glsl_type *struct_type = deref_record->record->type;
> - unsigned intra_struct_offset = 0;
> + ir_dereference_record *deref_record = (ir_dereference_record *)
> deref;
> + const glsl_type *struct_type = deref_record->record->type;
> + unsigned intra_struct_offset = 0;
>
> - for (unsigned int i = 0; i < struct_type->length; i++) {
> - const glsl_type *type = struct_type->fields.structure[i].type;
> + for (unsigned int i = 0; i < struct_type->length; i++) {
> + const glsl_type *type = struct_type->fields.structure[i].type;
>
> - ir_dereference_record *field_deref =
> - new(mem_ctx) ir_dereference_record(deref_record->record,
> -
> struct_type->fields.structure[i].name);
> + ir_dereference_record *field_deref = new(mem_ctx)
> + ir_dereference_record(deref_record->record,
> + struct_type->fields.structure[i].name);
> const bool field_row_major =
> is_dereferenced_thing_row_major(field_deref);
>
> @@ -358,11 +372,12 @@ lower_ubo_reference_visitor::handle_rvalue(ir_rvalue
> **rvalue)
>
> unsigned field_align =
> type->std140_base_alignment(field_row_major);
>
> - intra_struct_offset = glsl_align(intra_struct_offset,
> field_align);
> + intra_struct_offset = glsl_align(intra_struct_offset,
> field_align);
> +
> + if (strcmp(struct_type->fields.structure[i].name,
> + deref_record->field) == 0)
> + break;
>
> - if (strcmp(struct_type->fields.structure[i].name,
> - deref_record->field) == 0)
> - break;
> intra_struct_offset += type->std140_size(field_row_major);
>
> /* If the field just examined was itself a structure, apply rule
> @@ -377,19 +392,56 @@ lower_ubo_reference_visitor::handle_rvalue(ir_rvalue
> **rvalue)
> field_align);
>
> }
> - }
> -
> - const_offset += intra_struct_offset;
> + }
>
> - deref = deref_record->record->as_dereference();
> - break;
> + *const_offset += intra_struct_offset;
> + deref = deref_record->record->as_dereference();
> + break;
> }
> +
> default:
> - assert(!"not reached");
> - deref = NULL;
> - break;
> + assert(!"not reached");
> + deref = NULL;
> + break;
> }
> }
> +}
> +
> +void
> +lower_ubo_reference_visitor::handle_rvalue(ir_rvalue **rvalue)
> +{
> + if (!*rvalue)
> + return;
> +
> + ir_dereference *deref = (*rvalue)->as_dereference();
> + if (!deref)
> + return;
> +
> + ir_variable *var = deref->variable_referenced();
> + if (!var || !var->is_in_uniform_block())
> + return;
> +
> + mem_ctx = ralloc_parent(*rvalue);
> +
> + ir_rvalue *offset = NULL;
> + unsigned const_offset;
> + bool row_major;
> + int matrix_columns;
> + bool is_buffer;
> +
> + /* Compute the offset to the start if the dereference as well as other
> + * information we need to configure the write
> + */
> + setup_for_load_or_write(var, deref,
> + &offset, &const_offset,
> + &row_major, &matrix_columns,
> + &is_buffer);
> + assert(offset);
> +
> + if (is_buffer)
> + this->opcode = ir_binop_ssbo_load;
> + else
> + this->opcode = ir_binop_ubo_load;
>
> /* Now that we've calculated the offset to the start of the
> * dereference, walk over the type and emit loads into a temporary.
> @@ -549,6 +601,214 @@
> lower_ubo_reference_visitor::emit_ubo_loads(ir_dereference *deref,
> }
> }
>
> +ir_ssbo_store *
> +lower_ubo_reference_visitor::ssbo_write(ir_rvalue *deref,
> + ir_rvalue *offset,
> + unsigned write_mask)
> +{
> + ir_rvalue *block_ref = this->uniform_block->clone(mem_ctx, NULL);
> + ir_rvalue *val_ref = deref->clone(mem_ctx, NULL);
> + return new(mem_ctx) ir_ssbo_store(block_ref, offset, val_ref, write_mask);
> +}
> +
> +static inline int
> +writemask_for_size(unsigned n)
> +{
> + return ((1 << n) - 1);
> +}
> +
> +void
> +lower_ubo_reference_visitor::emit_ssbo_writes(ir_dereference *deref,
> + ir_variable *base_offset,
> + unsigned int deref_offset,
> + bool row_major,
> + int matrix_columns,
> + unsigned write_mask)
> +{
This code seems to be mostly a duplicate of the load case. Wouldn't
this leave us with two mostly similar complex code paths?
Maybe the low level emit could switch based on the opcode?
-Jordan
> + if (deref->type->is_record()) {
> + unsigned int field_offset = 0;
> +
> + for (unsigned i = 0; i < deref->type->length; i++) {
> + const struct glsl_struct_field *field =
> + &deref->type->fields.structure[i];
> + ir_dereference *field_deref =
> + new(mem_ctx) ir_dereference_record(deref->clone(mem_ctx, NULL),
> + field->name);
> +
> + field_offset =
> + glsl_align(field_offset,
> + field->type->std140_base_alignment(row_major));
> +
> + emit_ssbo_writes(field_deref, base_offset,
> + deref_offset + field_offset,
> + row_major, 1,
> +
> writemask_for_size(field_deref->type->vector_elements));
> +
> + field_offset += field->type->std140_size(row_major);
> + }
> + return;
> + }
> +
> + if (deref->type->is_array()) {
> + unsigned array_stride =
> + glsl_align(deref->type->fields.array->std140_size(row_major), 16);
> +
> + for (unsigned i = 0; i < deref->type->length; i++) {
> + ir_constant *element = new(mem_ctx) ir_constant(i);
> + ir_dereference *element_deref =
> + new(mem_ctx) ir_dereference_array(deref->clone(mem_ctx, NULL),
> + element);
> + emit_ssbo_writes(element_deref, base_offset,
> + deref_offset + i * array_stride,
> + row_major, 1,
> +
> writemask_for_size(element_deref->type->vector_elements));
> + }
> + return;
> + }
> +
> + if (deref->type->is_matrix()) {
> + for (unsigned i = 0; i < deref->type->matrix_columns; i++) {
> + ir_constant *col = new(mem_ctx) ir_constant(i);
> + ir_dereference *col_deref =
> + new(mem_ctx) ir_dereference_array(deref->clone(mem_ctx, NULL),
> col);
> +
> + if (row_major) {
> + /* For a row-major matrix, the next column starts at the next
> + * element.
> + */
> + int size_mul = deref->type->is_double() ? 8 : 4;
> + emit_ssbo_writes(col_deref, base_offset,
> + deref_offset + i * size_mul,
> + row_major, deref->type->matrix_columns,
> +
> writemask_for_size(col_deref->type->vector_elements));
> + } else {
> + /* std140 always rounds the stride of arrays (and matrices) to a
> + * vec4, so matrices are always 16 between columns/rows. With
> + * doubles, they will be 32 apart when there are more than 2
> rows.
> + */
> + int size_mul = (deref->type->is_double() &&
> + deref->type->vector_elements > 2) ? 32 : 16;
> + emit_ssbo_writes(col_deref, base_offset,
> + deref_offset + i * size_mul,
> + row_major, deref->type->matrix_columns,
> +
> writemask_for_size(col_deref->type->vector_elements));
> + }
> + }
> + return;
> + }
> +
> + assert(deref->type->is_scalar() || deref->type->is_vector());
> +
> + if (!row_major) {
> + ir_rvalue *offset =
> + add(base_offset, new(mem_ctx) ir_constant(deref_offset));
> + base_ir->insert_after(ssbo_write(deref, offset, write_mask));
> + } else {
> + unsigned N = deref->type->is_double() ? 8 : 4;
> +
> + /* We're dereffing a column out of a row-major matrix, so we
> + * gather the vector from each stored row.
> + */
> + assert(deref->type->base_type == GLSL_TYPE_FLOAT ||
> + deref->type->base_type == GLSL_TYPE_DOUBLE);
> + /* Matrices, row_major or not, are stored as if they were
> + * arrays of vectors of the appropriate size in std140.
> + * Arrays have their strides rounded up to a vec4, so the
> + * matrix stride is always 16. However a double matrix may either be 16
> + * or 32 depending on the number of columns.
> + */
> + assert(matrix_columns <= 4);
> + unsigned matrix_stride = glsl_align(matrix_columns * N, 16);
> +
> + for (unsigned i = 0; i < deref->type->vector_elements; i++) {
> + ir_rvalue *chan_offset =
> + add(base_offset,
> + new(mem_ctx) ir_constant(deref_offset + i * matrix_stride));
> +
> + base_ir->insert_after(ssbo_write(swizzle(deref, i, 1), chan_offset,
> 1));
> + }
> + }
> +}
> +
> +void
> +lower_ubo_reference_visitor::write_to_memory(ir_dereference *deref,
> + ir_variable *var,
> + ir_variable *write_var,
> + unsigned write_mask)
> +{
> + ir_rvalue *offset = NULL;
> + unsigned const_offset;
> + bool row_major;
> + int matrix_columns;
> + bool is_buffer;
> +
> + /* Compute the offset to the start if the dereference as well as other
> + * information we need to configure the write
> + */
> + setup_for_load_or_write(var, deref,
> + &offset, &const_offset,
> + &row_major, &matrix_columns,
> + &is_buffer);
> + assert(offset);
> + assert(is_buffer);
> +
> + /* Now emit writes from the temporary to memory */
> + ir_variable *write_offset =
> + new(mem_ctx) ir_variable(glsl_type::uint_type,
> + "ssbo_write_temp_offset",
> + ir_var_temporary);
> +
> + base_ir->insert_before(write_offset);
> + base_ir->insert_before(assign(write_offset, offset));
> +
> + deref = new(mem_ctx) ir_dereference_variable(write_var);
> + emit_ssbo_writes(deref, write_offset, const_offset,
> + row_major, matrix_columns, write_mask);
> +}
> +
> +void
> +lower_ubo_reference_visitor::check_for_ssbo_write(ir_assignment *ir)
> +{
> + if (!ir || !ir->lhs)
> + return;
> +
> + ir_rvalue *rvalue = ir->lhs->as_rvalue();
> + if (!rvalue)
> + return;
> +
> + ir_dereference *deref = ir->lhs->as_dereference();
> + if (!deref)
> + return;
> +
> + ir_variable *var = ir->lhs->variable_referenced();
> + if (!var || !var->is_in_uniform_block())
> + return;
> +
> + /* We have a write to a buffer variable, so declare a temporary and
> rewrite
> + * the assignment so that the temporary is the LHS.
> + */
> + mem_ctx = ralloc_parent(rvalue);
> +
> + const glsl_type *type = rvalue->type;
> + ir_variable *write_var = new(mem_ctx) ir_variable(type,
> + "ssbo_write_temp",
> + ir_var_temporary);
> + base_ir->insert_before(write_var);
> + ir->lhs = new(mem_ctx) ir_dereference_variable(write_var);
> +
> + /* Now we have to write the value assigned to the temporary back to
> memory */
> + write_to_memory(deref, var, write_var, ir->write_mask);
> + progress = true;
> +}
> +
> +
> +ir_visitor_status
> +lower_ubo_reference_visitor::visit_enter(ir_assignment *ir)
> +{
> + check_for_ssbo_write(ir);
> + return rvalue_visit(ir);
> +}
> +
> } /* unnamed namespace */
>
> void
> --
> 1.9.1
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/mesa-dev
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/mesa-dev
