glsl/loops: Stop creating normatively bound loops in loop_controls.

Previously, when loop_controls analyzed a loop and found that it had a
fixed bound (known at compile time), it would remove all of the loop
terminators and instead set the loop's normative_bound field to force
the loop to execute the correct number of times.

This made loop unrolling easy, but it had a serious disadvantage.
Since most GPU's don't have a native mechanism for executing a loop a
fixed number of times, in order to implement the normative bound, the
back-ends would have to synthesize a new loop induction variable.  As
a result, many loops wound up having two induction variables instead
of one.  This caused extra register pressure and unnecessary
instructions.

This patch modifies loop_controls so that it doesn't set the loop's
normative_bound anymore.  Instead it leaves one of the terminators in
the loop (the limiting terminator), so the back-end doesn't have to go
to any extra work to ensure the loop terminates at the right time.

This complicates loop unrolling slightly: when deciding whether a loop
can be unrolled, we have to account for the presence of the limiting
terminator.  And when we do unroll the loop, we have to remove the
limiting terminator first.

For an example of how this results in more efficient back end code,
consider the loop:

    for (int i = 0; i < 100; i++) {
      total += i;
    }

Previous to this patch, on i965, this loop would compile down to this
(vec4) native code:

          mov(8)       g4<1>.xD 0D
          mov(8)       g8<1>.xD 0D
    loop:
          cmp.ge.f0(8) null     g8<4;4,1>.xD 100D
    (+f0) if(8)
          break(8)
          endif(8)
          add(8)       g5<1>.xD g5<4;4,1>.xD g4<4;4,1>.xD
          add(8)       g8<1>.xD g8<4;4,1>.xD 1D
          add(8)       g4<1>.xD g4<4;4,1>.xD 1D
          while(8) loop

(notice that both g8 and g4 are loop induction variables; one is used
to terminate the loop, and the other is used to accumulate the total).

After this patch, the same loop compiles to:

          mov(8)       g4<1>.xD 0D
    loop:
          cmp.ge.f0(8) null     g4<4;4,1>.xD 100D
    (+f0) if(8)
          break(8)
          endif(8)
          add(8)       g5<1>.xD g5<4;4,1>.xD g4<4;4,1>.xD
          add(8)       g4<1>.xD g4<4;4,1>.xD 1D
          while(8) loop

Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>

1 files changed, 15 insertions, 10 deletions

diff --git a/src/glsl/loop_controls.cpp b/src/glsl/loop_controls.cpp
index 9e32ff5..385c203 100644
--- a/src/glsl/loop_controls.cpp
+++ b/src/glsl/loop_controls.cpp
@@ -195,16 +195,19 @@ loop_control_visitor::visit_leave(ir_loop *ir)
       }
 
       /* If the limiting terminator has a lower iteration count than the
-       * normative loop bound (if any), then make this a normatively bounded
-       * loop with the new iteration count.
+       * normative loop bound (if any), then the loop doesn't need a normative
+       * bound anymore.
        */
-      if (ir->normative_bound < 0 || iterations < ir->normative_bound)
-         ir->normative_bound = iterations;
+      if (ir->normative_bound >= 0 && iterations < ir->normative_bound)
+         ir->normative_bound = -1;
    }
 
    /* Remove the conditional break statements associated with all terminators
-    * that are associated with a fixed iteration count; the normative bound
-    * will take care of terminating the loop.
+    * that are associated with a fixed iteration count, except for the one
+    * associated with the limiting terminator--that one needs to stay, since
+    * it terminates the loop.  Exception: if the loop still has a normative
+    * bound, then that terminates the loop, so we don't even need the limiting
+    * terminator.
     */
    foreach_list(node, &ls->terminators) {
       loop_terminator *t = (loop_terminator *) node;
@@ -212,12 +215,14 @@ loop_control_visitor::visit_leave(ir_loop *ir)
       if (t->iterations < 0)
          continue;
 
-      t->ir->remove();
+      if (ir->normative_bound >= 0 || t != ls->limiting_terminator) {
+         t->ir->remove();
 
-      assert(ls->num_loop_jumps > 0);
-      ls->num_loop_jumps--;
+         assert(ls->num_loop_jumps > 0);
+         ls->num_loop_jumps--;
 
-      this->progress = true;
+         this->progress = true;
+      }
    }
 
    return visit_continue;