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>

diff --git a/src/compiler/glsl/ir_array_refcount.cpp b/src/compiler/glsl/ir_array_refcount.cpp
index 7627fa13bd228c86f7c969877802703164777f8d..1a46b2185d4b875ad083ac9ec1cd8a0c53cfbdf3 100644 (file)
--- a/src/compiler/glsl/ir_array_refcount.cpp
+++ b/src/compiler/glsl/ir_array_refcount.cpp
@@ -34,7 +34,7 @@
 #include "util/hash_table.h"
 
 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->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
@@ -159,6 +159,77 @@ ir_array_refcount_visitor::get_array_deref()
    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_array_refcount_visitor::visit(ir_dereference_variable *ir)

diff --git a/src/compiler/glsl/ir_array_refcount.h b/src/compiler/glsl/ir_array_refcount.h
index 2988046aaedbdc9451edf45531d9be5156736e78..46ba36cbaa096ab0d5f1d3a37c8fa1689d98abb2 100644 (file)
--- a/src/compiler/glsl/ir_array_refcount.h
+++ b/src/compiler/glsl/ir_array_refcount.h
@@ -140,6 +140,7 @@ public:
    virtual ir_visitor_status visit(ir_dereference_variable *);
 
    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
@@ -157,6 +158,15 @@ private:
    /** Get an array_deref_range element from private tracking. */
    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
     */

diff --git a/src/compiler/glsl/tests/array_refcount_test.cpp b/src/compiler/glsl/tests/array_refcount_test.cpp
index 29bb133e231fd14e707df60b4d26f79120eb26d9..ecd7f46900b8913bf1e70012c65f7d21818bab29 100644 (file)
--- a/src/compiler/glsl/tests/array_refcount_test.cpp
+++ b/src/compiler/glsl/tests/array_refcount_test.cpp
@@ -23,12 +23,18 @@
 #include <gtest/gtest.h>
 #include "ir.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 {
 public:
    virtual void SetUp();
    virtual void TearDown();
 
+   exec_list instructions;
+   ir_factory *body;
    void *mem_ctx;
 
    /**
@@ -39,6 +45,14 @@ public:
     */
    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
     *
@@ -81,6 +95,9 @@ array_refcount_test::SetUp()
 {
    mem_ctx = ralloc_context(NULL);
 
+   instructions.make_empty();
+   body = new ir_factory(&instructions, mem_ctx);
+
    /* The type of vec4 x[3][4][5]; */
    const glsl_type *const array_5_of_vec4 =
       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);
    array_3_of_array_4_of_array_5_of_vec4 =
       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
 array_refcount_test::TearDown()
 {
+   delete body;
+   body = NULL;
+
    ralloc_free(mem_ctx);
    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)
 {
    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);
+}