glsl: Walk a list of ir_dereference_array to mark array elements as accessed
Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Cc: mesa-stable@lists.freedesktop.org Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
This commit is contained in:
parent
e92935089b
commit
d32956935e
|
@ -34,7 +34,7 @@
|
||||||
#include "util/hash_table.h"
|
#include "util/hash_table.h"
|
||||||
|
|
||||||
ir_array_refcount_visitor::ir_array_refcount_visitor()
|
ir_array_refcount_visitor::ir_array_refcount_visitor()
|
||||||
: derefs(0), num_derefs(0), derefs_size(0)
|
: last_array_deref(0), derefs(0), num_derefs(0), derefs_size(0)
|
||||||
{
|
{
|
||||||
this->mem_ctx = ralloc_context(NULL);
|
this->mem_ctx = ralloc_context(NULL);
|
||||||
this->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
|
this->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
|
||||||
|
@ -159,6 +159,77 @@ ir_array_refcount_visitor::get_array_deref()
|
||||||
return d;
|
return d;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
ir_visitor_status
|
||||||
|
ir_array_refcount_visitor::visit_enter(ir_dereference_array *ir)
|
||||||
|
{
|
||||||
|
/* It could also be a vector or a matrix. Individual elements of vectors
|
||||||
|
* are natrices are not tracked, so bail.
|
||||||
|
*/
|
||||||
|
if (!ir->array->type->is_array())
|
||||||
|
return visit_continue;
|
||||||
|
|
||||||
|
/* If this array dereference is a child of an array dereference that was
|
||||||
|
* already visited, just continue on. Otherwise, for an arrays-of-arrays
|
||||||
|
* dereference like x[1][2][3][4], we'd process the [1][2][3][4] sequence,
|
||||||
|
* the [1][2][3] sequence, the [1][2] sequence, and the [1] sequence. This
|
||||||
|
* ensures that we only process the full sequence.
|
||||||
|
*/
|
||||||
|
if (last_array_deref && last_array_deref->array == ir) {
|
||||||
|
last_array_deref = ir;
|
||||||
|
return visit_continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
last_array_deref = ir;
|
||||||
|
|
||||||
|
num_derefs = 0;
|
||||||
|
|
||||||
|
ir_rvalue *rv = ir;
|
||||||
|
while (rv->ir_type == ir_type_dereference_array) {
|
||||||
|
ir_dereference_array *const deref = rv->as_dereference_array();
|
||||||
|
|
||||||
|
assert(deref != NULL);
|
||||||
|
assert(deref->array->type->is_array());
|
||||||
|
|
||||||
|
ir_rvalue *const array = deref->array;
|
||||||
|
const ir_constant *const idx = deref->array_index->as_constant();
|
||||||
|
array_deref_range *const dr = get_array_deref();
|
||||||
|
|
||||||
|
dr->size = array->type->array_size();
|
||||||
|
|
||||||
|
if (idx != NULL) {
|
||||||
|
dr->index = idx->get_int_component(0);
|
||||||
|
} else {
|
||||||
|
/* An unsized array can occur at the end of an SSBO. We can't track
|
||||||
|
* accesses to such an array, so bail.
|
||||||
|
*/
|
||||||
|
if (array->type->array_size() == 0)
|
||||||
|
return visit_continue;
|
||||||
|
|
||||||
|
dr->index = dr->size;
|
||||||
|
}
|
||||||
|
|
||||||
|
rv = array;
|
||||||
|
}
|
||||||
|
|
||||||
|
ir_dereference_variable *const var_deref = rv->as_dereference_variable();
|
||||||
|
|
||||||
|
/* If the array being dereferenced is not a variable, bail. At the very
|
||||||
|
* least, ir_constant and ir_dereference_record are possible.
|
||||||
|
*/
|
||||||
|
if (var_deref == NULL)
|
||||||
|
return visit_continue;
|
||||||
|
|
||||||
|
ir_array_refcount_entry *const entry =
|
||||||
|
this->get_variable_entry(var_deref->var);
|
||||||
|
|
||||||
|
if (entry == NULL)
|
||||||
|
return visit_stop;
|
||||||
|
|
||||||
|
entry->mark_array_elements_referenced(derefs, num_derefs);
|
||||||
|
|
||||||
|
return visit_continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
ir_visitor_status
|
ir_visitor_status
|
||||||
ir_array_refcount_visitor::visit(ir_dereference_variable *ir)
|
ir_array_refcount_visitor::visit(ir_dereference_variable *ir)
|
||||||
|
|
|
@ -140,6 +140,7 @@ public:
|
||||||
virtual ir_visitor_status visit(ir_dereference_variable *);
|
virtual ir_visitor_status visit(ir_dereference_variable *);
|
||||||
|
|
||||||
virtual ir_visitor_status visit_enter(ir_function_signature *);
|
virtual ir_visitor_status visit_enter(ir_function_signature *);
|
||||||
|
virtual ir_visitor_status visit_enter(ir_dereference_array *);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Find variable in the hash table, and insert it if not present
|
* Find variable in the hash table, and insert it if not present
|
||||||
|
@ -157,6 +158,15 @@ private:
|
||||||
/** Get an array_deref_range element from private tracking. */
|
/** Get an array_deref_range element from private tracking. */
|
||||||
array_deref_range *get_array_deref();
|
array_deref_range *get_array_deref();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Last ir_dereference_array that was visited
|
||||||
|
*
|
||||||
|
* Used to prevent some redundant calculations.
|
||||||
|
*
|
||||||
|
* \sa ::visit_enter(ir_dereference_array *)
|
||||||
|
*/
|
||||||
|
ir_dereference_array *last_array_deref;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* \name array_deref_range tracking
|
* \name array_deref_range tracking
|
||||||
*/
|
*/
|
||||||
|
|
|
@ -23,12 +23,18 @@
|
||||||
#include <gtest/gtest.h>
|
#include <gtest/gtest.h>
|
||||||
#include "ir.h"
|
#include "ir.h"
|
||||||
#include "ir_array_refcount.h"
|
#include "ir_array_refcount.h"
|
||||||
|
#include "ir_builder.h"
|
||||||
|
#include "util/hash_table.h"
|
||||||
|
|
||||||
|
using namespace ir_builder;
|
||||||
|
|
||||||
class array_refcount_test : public ::testing::Test {
|
class array_refcount_test : public ::testing::Test {
|
||||||
public:
|
public:
|
||||||
virtual void SetUp();
|
virtual void SetUp();
|
||||||
virtual void TearDown();
|
virtual void TearDown();
|
||||||
|
|
||||||
|
exec_list instructions;
|
||||||
|
ir_factory *body;
|
||||||
void *mem_ctx;
|
void *mem_ctx;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -39,6 +45,14 @@ public:
|
||||||
*/
|
*/
|
||||||
const glsl_type *array_3_of_array_4_of_array_5_of_vec4;
|
const glsl_type *array_3_of_array_4_of_array_5_of_vec4;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* glsl_type for a int[3].
|
||||||
|
*
|
||||||
|
* The exceptionally verbose name is picked because it matches the syntax
|
||||||
|
* of http://cdecl.org/.
|
||||||
|
*/
|
||||||
|
const glsl_type *array_3_of_int;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Wrapper to access private member "bits" of ir_array_refcount_entry
|
* Wrapper to access private member "bits" of ir_array_refcount_entry
|
||||||
*
|
*
|
||||||
|
@ -81,6 +95,9 @@ array_refcount_test::SetUp()
|
||||||
{
|
{
|
||||||
mem_ctx = ralloc_context(NULL);
|
mem_ctx = ralloc_context(NULL);
|
||||||
|
|
||||||
|
instructions.make_empty();
|
||||||
|
body = new ir_factory(&instructions, mem_ctx);
|
||||||
|
|
||||||
/* The type of vec4 x[3][4][5]; */
|
/* The type of vec4 x[3][4][5]; */
|
||||||
const glsl_type *const array_5_of_vec4 =
|
const glsl_type *const array_5_of_vec4 =
|
||||||
glsl_type::get_array_instance(glsl_type::vec4_type, 5);
|
glsl_type::get_array_instance(glsl_type::vec4_type, 5);
|
||||||
|
@ -88,15 +105,105 @@ array_refcount_test::SetUp()
|
||||||
glsl_type::get_array_instance(array_5_of_vec4, 4);
|
glsl_type::get_array_instance(array_5_of_vec4, 4);
|
||||||
array_3_of_array_4_of_array_5_of_vec4 =
|
array_3_of_array_4_of_array_5_of_vec4 =
|
||||||
glsl_type::get_array_instance(array_4_of_array_5_of_vec4, 3);
|
glsl_type::get_array_instance(array_4_of_array_5_of_vec4, 3);
|
||||||
|
|
||||||
|
array_3_of_int = glsl_type::get_array_instance(glsl_type::int_type, 3);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
array_refcount_test::TearDown()
|
array_refcount_test::TearDown()
|
||||||
{
|
{
|
||||||
|
delete body;
|
||||||
|
body = NULL;
|
||||||
|
|
||||||
ralloc_free(mem_ctx);
|
ralloc_free(mem_ctx);
|
||||||
mem_ctx = NULL;
|
mem_ctx = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static operand
|
||||||
|
deref_array(operand array, operand index)
|
||||||
|
{
|
||||||
|
void *mem_ctx = ralloc_parent(array.val);
|
||||||
|
|
||||||
|
ir_rvalue *val = new(mem_ctx) ir_dereference_array(array.val, index.val);
|
||||||
|
|
||||||
|
return operand(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
static operand
|
||||||
|
deref_struct(operand s, const char *field)
|
||||||
|
{
|
||||||
|
void *mem_ctx = ralloc_parent(s.val);
|
||||||
|
|
||||||
|
ir_rvalue *val = new(mem_ctx) ir_dereference_record(s.val, field);
|
||||||
|
|
||||||
|
return operand(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Verify that only the specified set of ir_variables exists in the hash table
|
||||||
|
*/
|
||||||
|
static void
|
||||||
|
validate_variables_in_hash_table(struct hash_table *ht,
|
||||||
|
unsigned count,
|
||||||
|
...)
|
||||||
|
{
|
||||||
|
ir_variable **vars = new ir_variable *[count];
|
||||||
|
va_list args;
|
||||||
|
|
||||||
|
/* Make a copy of the list of expected ir_variables. The copied list can
|
||||||
|
* be modified during the checking.
|
||||||
|
*/
|
||||||
|
va_start(args, count);
|
||||||
|
|
||||||
|
for (unsigned i = 0; i < count; i++)
|
||||||
|
vars[i] = va_arg(args, ir_variable *);
|
||||||
|
|
||||||
|
va_end(args);
|
||||||
|
|
||||||
|
struct hash_entry *entry;
|
||||||
|
hash_table_foreach(ht, entry) {
|
||||||
|
const ir_instruction *const ir = (ir_instruction *) entry->key;
|
||||||
|
const ir_variable *const v = ir->as_variable();
|
||||||
|
|
||||||
|
if (v == NULL) {
|
||||||
|
ADD_FAILURE() << "Invalid junk in hash table: ir_type = "
|
||||||
|
<< ir->ir_type << ", address = "
|
||||||
|
<< (void *) ir;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned i;
|
||||||
|
for (i = 0; i < count; i++) {
|
||||||
|
if (vars[i] == NULL)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (vars[i] == v)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i == count) {
|
||||||
|
ADD_FAILURE() << "Invalid variable in hash table: \""
|
||||||
|
<< v->name << "\"";
|
||||||
|
} else {
|
||||||
|
/* As each variable is encountered, remove it from the set. Don't
|
||||||
|
* bother compacting the set because we don't care about
|
||||||
|
* performance here.
|
||||||
|
*/
|
||||||
|
vars[i] = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Check that there's nothing left in the set. */
|
||||||
|
for (unsigned i = 0; i < count; i++) {
|
||||||
|
if (vars[i] != NULL) {
|
||||||
|
ADD_FAILURE() << "Variable was not in the hash table: \""
|
||||||
|
<< vars[i]->name << "\"";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
delete [] vars;
|
||||||
|
}
|
||||||
|
|
||||||
TEST_F(array_refcount_test, ir_array_refcount_entry_initial_state_for_scalar)
|
TEST_F(array_refcount_test, ir_array_refcount_entry_initial_state_for_scalar)
|
||||||
{
|
{
|
||||||
ir_variable *const var =
|
ir_variable *const var =
|
||||||
|
@ -290,3 +397,321 @@ TEST_F(array_refcount_test, mark_array_elements_referenced_whole_first_and_third
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, do_not_process_vector_indexing)
|
||||||
|
{
|
||||||
|
/* Vectors and matrices can also be indexed in much the same manner as
|
||||||
|
* arrays. The visitor should not try to track per-element accesses to
|
||||||
|
* these types.
|
||||||
|
*/
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::float_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_c = new(mem_ctx) ir_variable(glsl_type::vec4_type,
|
||||||
|
"c",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
body->emit(assign(var_a, deref_array(var_c, var_b)));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *entry_a = v.get_variable_entry(var_a);
|
||||||
|
ir_array_refcount_entry *entry_b = v.get_variable_entry(var_b);
|
||||||
|
ir_array_refcount_entry *entry_c = v.get_variable_entry(var_c);
|
||||||
|
|
||||||
|
EXPECT_TRUE(entry_a->is_referenced);
|
||||||
|
EXPECT_TRUE(entry_b->is_referenced);
|
||||||
|
EXPECT_TRUE(entry_c->is_referenced);
|
||||||
|
|
||||||
|
/* As validated by previous tests, for non-array types, num_bits is 1. */
|
||||||
|
ASSERT_EQ(1, get_num_bits(*entry_c));
|
||||||
|
EXPECT_FALSE(entry_c->is_linearized_index_referenced(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, do_not_process_matrix_indexing)
|
||||||
|
{
|
||||||
|
/* Vectors and matrices can also be indexed in much the same manner as
|
||||||
|
* arrays. The visitor should not try to track per-element accesses to
|
||||||
|
* these types.
|
||||||
|
*/
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::vec4_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_c = new(mem_ctx) ir_variable(glsl_type::mat4_type,
|
||||||
|
"c",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
body->emit(assign(var_a, deref_array(var_c, var_b)));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *entry_a = v.get_variable_entry(var_a);
|
||||||
|
ir_array_refcount_entry *entry_b = v.get_variable_entry(var_b);
|
||||||
|
ir_array_refcount_entry *entry_c = v.get_variable_entry(var_c);
|
||||||
|
|
||||||
|
EXPECT_TRUE(entry_a->is_referenced);
|
||||||
|
EXPECT_TRUE(entry_b->is_referenced);
|
||||||
|
EXPECT_TRUE(entry_c->is_referenced);
|
||||||
|
|
||||||
|
/* As validated by previous tests, for non-array types, num_bits is 1. */
|
||||||
|
ASSERT_EQ(1, get_num_bits(*entry_c));
|
||||||
|
EXPECT_FALSE(entry_c->is_linearized_index_referenced(0));
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, do_not_process_array_inside_structure)
|
||||||
|
{
|
||||||
|
/* Structures can contain arrays. The visitor should not try to track
|
||||||
|
* per-element accesses to arrays contained inside structures.
|
||||||
|
*/
|
||||||
|
const glsl_struct_field fields[] = {
|
||||||
|
glsl_struct_field(array_3_of_int, "i"),
|
||||||
|
};
|
||||||
|
|
||||||
|
const glsl_type *const record_of_array_3_of_int =
|
||||||
|
glsl_type::get_record_instance(fields, ARRAY_SIZE(fields), "S");
|
||||||
|
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(record_of_array_3_of_int,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
/* a = b.i[2] */
|
||||||
|
body->emit(assign(var_a,
|
||||||
|
deref_array(
|
||||||
|
deref_struct(var_b, "i"),
|
||||||
|
body->constant(int(2)))));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *entry_a = v.get_variable_entry(var_a);
|
||||||
|
ir_array_refcount_entry *entry_b = v.get_variable_entry(var_b);
|
||||||
|
|
||||||
|
EXPECT_TRUE(entry_a->is_referenced);
|
||||||
|
EXPECT_TRUE(entry_b->is_referenced);
|
||||||
|
|
||||||
|
ASSERT_EQ(1, get_num_bits(*entry_b));
|
||||||
|
EXPECT_FALSE(entry_b->is_linearized_index_referenced(0));
|
||||||
|
|
||||||
|
validate_variables_in_hash_table(v.ht, 2, var_a, var_b);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, visit_simple_indexing)
|
||||||
|
{
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::vec4_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(array_3_of_array_4_of_array_5_of_vec4,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
/* a = b[2][1][0] */
|
||||||
|
body->emit(assign(var_a,
|
||||||
|
deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(2))),
|
||||||
|
body->constant(int(1))),
|
||||||
|
body->constant(int(0)))));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
const unsigned accessed_element = 0 + (1 * 5) + (2 * 4 * 5);
|
||||||
|
ir_array_refcount_entry *entry_b = v.get_variable_entry(var_b);
|
||||||
|
const unsigned total_elements = var_b->type->arrays_of_arrays_size();
|
||||||
|
|
||||||
|
for (unsigned i = 0; i < total_elements; i++)
|
||||||
|
EXPECT_EQ(i == accessed_element, entry_b->is_linearized_index_referenced(i)) <<
|
||||||
|
"i = " << i;
|
||||||
|
|
||||||
|
validate_variables_in_hash_table(v.ht, 2, var_a, var_b);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, visit_whole_second_array_indexing)
|
||||||
|
{
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::vec4_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(array_3_of_array_4_of_array_5_of_vec4,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_i = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"i",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
/* a = b[2][i][1] */
|
||||||
|
body->emit(assign(var_a,
|
||||||
|
deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(2))),
|
||||||
|
var_i),
|
||||||
|
body->constant(int(1)))));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *const entry_b = v.get_variable_entry(var_b);
|
||||||
|
for (unsigned i = 0; i < 3; i++) {
|
||||||
|
for (unsigned j = 0; j < 4; j++) {
|
||||||
|
for (unsigned k = 0; k < 5; k++) {
|
||||||
|
const bool accessed = (i == 2) && (k == 1);
|
||||||
|
const unsigned linearized_index = k + (j * 5) + (i * 4 * 5);
|
||||||
|
|
||||||
|
EXPECT_EQ(accessed,
|
||||||
|
entry_b->is_linearized_index_referenced(linearized_index)) <<
|
||||||
|
"i = " << i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
validate_variables_in_hash_table(v.ht, 3, var_a, var_b, var_i);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, visit_array_indexing_an_array)
|
||||||
|
{
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::vec4_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(array_3_of_array_4_of_array_5_of_vec4,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_c = new(mem_ctx) ir_variable(array_3_of_int,
|
||||||
|
"c",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_i = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"i",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
/* a = b[2][3][c[i]] */
|
||||||
|
body->emit(assign(var_a,
|
||||||
|
deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(2))),
|
||||||
|
body->constant(int(3))),
|
||||||
|
deref_array(var_c, var_i))));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *const entry_b = v.get_variable_entry(var_b);
|
||||||
|
|
||||||
|
for (unsigned i = 0; i < 3; i++) {
|
||||||
|
for (unsigned j = 0; j < 4; j++) {
|
||||||
|
for (unsigned k = 0; k < 5; k++) {
|
||||||
|
const bool accessed = (i == 2) && (j == 3);
|
||||||
|
const unsigned linearized_index = k + (j * 5) + (i * 4 * 5);
|
||||||
|
|
||||||
|
EXPECT_EQ(accessed,
|
||||||
|
entry_b->is_linearized_index_referenced(linearized_index)) <<
|
||||||
|
"array b[" << i << "][" << j << "][" << k << "], " <<
|
||||||
|
"linear index = " << linearized_index;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ir_array_refcount_entry *const entry_c = v.get_variable_entry(var_c);
|
||||||
|
|
||||||
|
for (unsigned i = 0; i < var_c->type->array_size(); i++) {
|
||||||
|
EXPECT_EQ(true, entry_c->is_linearized_index_referenced(i)) <<
|
||||||
|
"array c, i = " << i;
|
||||||
|
}
|
||||||
|
|
||||||
|
validate_variables_in_hash_table(v.ht, 4, var_a, var_b, var_c, var_i);
|
||||||
|
}
|
||||||
|
|
||||||
|
TEST_F(array_refcount_test, visit_array_indexing_with_itself)
|
||||||
|
{
|
||||||
|
const glsl_type *const array_2_of_array_3_of_int =
|
||||||
|
glsl_type::get_array_instance(array_3_of_int, 2);
|
||||||
|
|
||||||
|
const glsl_type *const array_2_of_array_2_of_array_3_of_int =
|
||||||
|
glsl_type::get_array_instance(array_2_of_array_3_of_int, 2);
|
||||||
|
|
||||||
|
ir_variable *var_a = new(mem_ctx) ir_variable(glsl_type::int_type,
|
||||||
|
"a",
|
||||||
|
ir_var_auto);
|
||||||
|
ir_variable *var_b = new(mem_ctx) ir_variable(array_2_of_array_2_of_array_3_of_int,
|
||||||
|
"b",
|
||||||
|
ir_var_auto);
|
||||||
|
|
||||||
|
/* Given GLSL code:
|
||||||
|
*
|
||||||
|
* int b[2][2][3];
|
||||||
|
* a = b[ b[0][0][0] ][ b[ b[0][1][0] ][ b[1][0][0] ][1] ][2]
|
||||||
|
*
|
||||||
|
* b[0][0][0], b[0][1][0], and b[1][0][0] are trivially accessed.
|
||||||
|
*
|
||||||
|
* b[*][*][1] and b[*][*][2] are accessed.
|
||||||
|
*
|
||||||
|
* Only b[1][1][0] is not accessed.
|
||||||
|
*/
|
||||||
|
operand b000 = deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(0))),
|
||||||
|
body->constant(int(0))),
|
||||||
|
body->constant(int(0)));
|
||||||
|
|
||||||
|
operand b010 = deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(0))),
|
||||||
|
body->constant(int(1))),
|
||||||
|
body->constant(int(0)));
|
||||||
|
|
||||||
|
operand b100 = deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, body->constant(int(1))),
|
||||||
|
body->constant(int(0))),
|
||||||
|
body->constant(int(0)));
|
||||||
|
|
||||||
|
operand b_b010_b100_1 = deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, b010),
|
||||||
|
b100),
|
||||||
|
body->constant(int(1)));
|
||||||
|
|
||||||
|
body->emit(assign(var_a,
|
||||||
|
deref_array(
|
||||||
|
deref_array(
|
||||||
|
deref_array(var_b, b000),
|
||||||
|
b_b010_b100_1),
|
||||||
|
body->constant(int(2)))));
|
||||||
|
|
||||||
|
ir_array_refcount_visitor v;
|
||||||
|
|
||||||
|
visit_list_elements(&v, &instructions);
|
||||||
|
|
||||||
|
ir_array_refcount_entry *const entry_b = v.get_variable_entry(var_b);
|
||||||
|
|
||||||
|
for (unsigned i = 0; i < 2; i++) {
|
||||||
|
for (unsigned j = 0; j < 2; j++) {
|
||||||
|
for (unsigned k = 0; k < 3; k++) {
|
||||||
|
const bool accessed = !(i == 1 && j == 1 && k == 0);
|
||||||
|
const unsigned linearized_index = k + (j * 3) + (i * 2 * 3);
|
||||||
|
|
||||||
|
EXPECT_EQ(accessed,
|
||||||
|
entry_b->is_linearized_index_referenced(linearized_index)) <<
|
||||||
|
"array b[" << i << "][" << j << "][" << k << "], " <<
|
||||||
|
"linear index = " << linearized_index;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
validate_variables_in_hash_table(v.ht, 2, var_a, var_b);
|
||||||
|
}
|
||||||
|
|
Loading…
Reference in New Issue