aboutsummaryrefslogtreecommitdiff
path: root/mesalib/src/glsl/loop_unroll.cpp
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2010-12-28 16:10:20 +0000
committermarha <marha@users.sourceforge.net>2010-12-28 16:10:20 +0000
commit807c6931fe683fd844ceec1b023232181e6aae03 (patch)
tree1a131ed95fe2200d0ad33da8f7755a7ed2364adc /mesalib/src/glsl/loop_unroll.cpp
parent973099dda7e49e5abe29819a7124b3b1e7bd8b92 (diff)
downloadvcxsrv-807c6931fe683fd844ceec1b023232181e6aae03.tar.gz
vcxsrv-807c6931fe683fd844ceec1b023232181e6aae03.tar.bz2
vcxsrv-807c6931fe683fd844ceec1b023232181e6aae03.zip
xserver and mesa git update 28-12-2010
Diffstat (limited to 'mesalib/src/glsl/loop_unroll.cpp')
-rw-r--r--mesalib/src/glsl/loop_unroll.cpp401
1 files changed, 214 insertions, 187 deletions
diff --git a/mesalib/src/glsl/loop_unroll.cpp b/mesalib/src/glsl/loop_unroll.cpp
index 90797bde3..c54f2ca3d 100644
--- a/mesalib/src/glsl/loop_unroll.cpp
+++ b/mesalib/src/glsl/loop_unroll.cpp
@@ -1,187 +1,214 @@
-/*
- * Copyright © 2010 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 "glsl_types.h"
-#include "loop_analysis.h"
-#include "ir_hierarchical_visitor.h"
-
-class loop_unroll_visitor : public ir_hierarchical_visitor {
-public:
- loop_unroll_visitor(loop_state *state, unsigned max_iterations)
- {
- this->state = state;
- this->progress = false;
- this->max_iterations = max_iterations;
- }
-
- virtual ir_visitor_status visit_leave(ir_loop *ir);
-
- loop_state *state;
-
- bool progress;
- unsigned max_iterations;
-};
-
-
-ir_visitor_status
-loop_unroll_visitor::visit_leave(ir_loop *ir)
-{
- loop_variable_state *const ls = this->state->get(ir);
- int iterations;
-
- /* If we've entered a loop that hasn't been analyzed, something really,
- * really bad has happened.
- */
- if (ls == NULL) {
- assert(ls != NULL);
- return visit_continue;
- }
-
- iterations = ls->max_iterations;
-
- /* Don't try to unroll loops where the number of iterations is not known
- * at compile-time.
- */
- if (iterations < 0)
- return visit_continue;
-
- /* Don't try to unroll loops that have zillions of iterations either.
- */
- if (iterations > max_iterations)
- return visit_continue;
-
- if (ls->num_loop_jumps > 1)
- return visit_continue;
- else if (ls->num_loop_jumps) {
- /* recognize loops in the form produced by ir_lower_jumps */
- ir_instruction *last_ir =
- ((ir_instruction*)ir->body_instructions.get_tail());
-
- assert(last_ir != NULL);
-
- ir_if *last_if = last_ir->as_if();
- if (last_if) {
- bool continue_from_then_branch;
-
- /* Determine which if-statement branch, if any, ends with a break.
- * The branch that did *not* have the break will get a temporary
- * continue inserted in each iteration of the loop unroll.
- *
- * Note that since ls->num_loop_jumps is <= 1, it is impossible for
- * both branches to end with a break.
- */
- ir_instruction *last =
- (ir_instruction *) last_if->then_instructions.get_tail();
-
- if (last && last->ir_type == ir_type_loop_jump
- && ((ir_loop_jump*) last)->is_break()) {
- continue_from_then_branch = false;
- } else {
- last = (ir_instruction *) last_if->then_instructions.get_tail();
-
- if (last && last->ir_type == ir_type_loop_jump
- && ((ir_loop_jump*) last)->is_break())
- continue_from_then_branch = true;
- else
- /* Bail out if neither if-statement branch ends with a break.
- */
- return visit_continue;
- }
-
- /* Remove the break from the if-statement.
- */
- last->remove();
-
- void *const mem_ctx = talloc_parent(ir);
- ir_instruction *ir_to_replace = ir;
-
- for (int i = 0; i < iterations; i++) {
- exec_list copy_list;
-
- copy_list.make_empty();
- clone_ir_list(mem_ctx, &copy_list, &ir->body_instructions);
-
- last_if = ((ir_instruction*)copy_list.get_tail())->as_if();
- assert(last_if);
-
- ir_to_replace->insert_before(&copy_list);
- ir_to_replace->remove();
-
- /* placeholder that will be removed in the next iteration */
- ir_to_replace =
- new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_continue);
-
- exec_list *const list = (continue_from_then_branch)
- ? &last_if->then_instructions : &last_if->else_instructions;
-
- list->push_tail(ir_to_replace);
- }
-
- ir_to_replace->remove();
-
- this->progress = true;
- return visit_continue;
- } else if (last_ir->ir_type == ir_type_loop_jump
- && ((ir_loop_jump *)last_ir)->is_break()) {
- /* If the only loop-jump is a break at the end of the loop, the loop
- * will execute exactly once. Remove the break, set the iteration
- * count, and fall through to the normal unroller.
- */
- last_ir->remove();
- iterations = 1;
-
- this->progress = true;
- } else
- return visit_continue;
- }
-
- void *const mem_ctx = talloc_parent(ir);
-
- for (int i = 0; i < iterations; i++) {
- exec_list copy_list;
-
- copy_list.make_empty();
- clone_ir_list(mem_ctx, &copy_list, &ir->body_instructions);
-
- ir->insert_before(&copy_list);
- }
-
- /* The loop has been replaced by the unrolled copies. Remove the original
- * loop from the IR sequence.
- */
- ir->remove();
-
- this->progress = true;
- return visit_continue;
-}
-
-
-bool
-unroll_loops(exec_list *instructions, loop_state *ls, unsigned max_iterations)
-{
- loop_unroll_visitor v(ls, max_iterations);
-
- v.run(instructions);
-
- return v.progress;
-}
+/*
+ * Copyright © 2010 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 "glsl_types.h"
+#include "loop_analysis.h"
+#include "ir_hierarchical_visitor.h"
+
+class loop_unroll_visitor : public ir_hierarchical_visitor {
+public:
+ loop_unroll_visitor(loop_state *state, unsigned max_iterations)
+ {
+ this->state = state;
+ this->progress = false;
+ this->max_iterations = max_iterations;
+ }
+
+ virtual ir_visitor_status visit_leave(ir_loop *ir);
+
+ loop_state *state;
+
+ bool progress;
+ unsigned max_iterations;
+};
+
+
+static bool
+is_break(ir_instruction *ir)
+{
+ return ir != NULL && ir->ir_type == ir_type_loop_jump
+ && ((ir_loop_jump *) ir)->is_break();
+}
+
+
+ir_visitor_status
+loop_unroll_visitor::visit_leave(ir_loop *ir)
+{
+ loop_variable_state *const ls = this->state->get(ir);
+ int iterations;
+
+ /* If we've entered a loop that hasn't been analyzed, something really,
+ * really bad has happened.
+ */
+ if (ls == NULL) {
+ assert(ls != NULL);
+ return visit_continue;
+ }
+
+ iterations = ls->max_iterations;
+
+ /* Don't try to unroll loops where the number of iterations is not known
+ * at compile-time.
+ */
+ if (iterations < 0)
+ return visit_continue;
+
+ /* Don't try to unroll loops that have zillions of iterations either.
+ */
+ if (iterations > (int) max_iterations)
+ return visit_continue;
+
+ if (ls->num_loop_jumps > 1)
+ return visit_continue;
+ else if (ls->num_loop_jumps) {
+ ir_instruction *last_ir = (ir_instruction *) ir->body_instructions.get_tail();
+ assert(last_ir != NULL);
+
+ if (is_break(last_ir)) {
+ /* If the only loop-jump is a break at the end of the loop, the loop
+ * will execute exactly once. Remove the break, set the iteration
+ * count, and fall through to the normal unroller.
+ */
+ last_ir->remove();
+ iterations = 1;
+
+ this->progress = true;
+ } else {
+ ir_if *ir_if = NULL;
+ ir_instruction *break_ir = NULL;
+ bool continue_from_then_branch = false;
+
+ foreach_list(node, &ir->body_instructions) {
+ /* recognize loops in the form produced by ir_lower_jumps */
+ ir_instruction *cur_ir = (ir_instruction *) node;
+
+ ir_if = cur_ir->as_if();
+ if (ir_if != NULL) {
+ /* Determine which if-statement branch, if any, ends with a
+ * break. The branch that did *not* have the break will get a
+ * temporary continue inserted in each iteration of the loop
+ * unroll.
+ *
+ * Note that since ls->num_loop_jumps is <= 1, it is impossible
+ * for both branches to end with a break.
+ */
+ ir_instruction *ir_if_last =
+ (ir_instruction *) ir_if->then_instructions.get_tail();
+
+ if (is_break(ir_if_last)) {
+ continue_from_then_branch = false;
+ break_ir = ir_if_last;
+ break;
+ } else {
+ ir_if_last =
+ (ir_instruction *) ir_if->else_instructions.get_tail();
+
+ if (is_break(ir_if_last)) {
+ break_ir = ir_if_last;
+ continue_from_then_branch = true;
+ break;
+ }
+ }
+ }
+ }
+
+ if (break_ir == NULL)
+ return visit_continue;
+
+ /* move instructions after then if in the continue branch */
+ while (!ir_if->get_next()->is_tail_sentinel()) {
+ ir_instruction *move_ir = (ir_instruction *) ir_if->get_next();
+
+ move_ir->remove();
+ if (continue_from_then_branch)
+ ir_if->then_instructions.push_tail(move_ir);
+ else
+ ir_if->else_instructions.push_tail(move_ir);
+ }
+
+ /* Remove the break from the if-statement.
+ */
+ break_ir->remove();
+
+ void *const mem_ctx = talloc_parent(ir);
+ ir_instruction *ir_to_replace = ir;
+
+ for (int i = 0; i < iterations; i++) {
+ exec_list copy_list;
+
+ copy_list.make_empty();
+ clone_ir_list(mem_ctx, &copy_list, &ir->body_instructions);
+
+ ir_if = ((ir_instruction *) copy_list.get_tail())->as_if();
+ assert(ir_if != NULL);
+
+ ir_to_replace->insert_before(&copy_list);
+ ir_to_replace->remove();
+
+ /* placeholder that will be removed in the next iteration */
+ ir_to_replace =
+ new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_continue);
+
+ exec_list *const list = (continue_from_then_branch)
+ ? &ir_if->then_instructions : &ir_if->else_instructions;
+
+ list->push_tail(ir_to_replace);
+ }
+
+ ir_to_replace->remove();
+
+ this->progress = true;
+ return visit_continue;
+ }
+ }
+
+ void *const mem_ctx = talloc_parent(ir);
+
+ for (int i = 0; i < iterations; i++) {
+ exec_list copy_list;
+
+ copy_list.make_empty();
+ clone_ir_list(mem_ctx, &copy_list, &ir->body_instructions);
+
+ ir->insert_before(&copy_list);
+ }
+
+ /* The loop has been replaced by the unrolled copies. Remove the original
+ * loop from the IR sequence.
+ */
+ ir->remove();
+
+ this->progress = true;
+ return visit_continue;
+}
+
+
+bool
+unroll_loops(exec_list *instructions, loop_state *ls, unsigned max_iterations)
+{
+ loop_unroll_visitor v(ls, max_iterations);
+
+ v.run(instructions);
+
+ return v.progress;
+}