X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Floop_unroll.cpp;h=3434fde62926026b8a0d9bbf8aab07bebcd75c7f;hb=1fafd008392d5240dc36d0c72978cef62e21b4b1;hp=11709587e24e57ce3c2adf43c2bb7d0463f4a68e;hpb=41ed47d6b8fb6c032e2907ef2e49e414c26f35c1;p=mesa.git diff --git a/src/glsl/loop_unroll.cpp b/src/glsl/loop_unroll.cpp index 11709587e24..3434fde6292 100644 --- a/src/glsl/loop_unroll.cpp +++ b/src/glsl/loop_unroll.cpp @@ -43,6 +43,46 @@ public: }; +static bool +is_break(ir_instruction *ir) +{ + return ir != NULL && ir->ir_type == ir_type_loop_jump + && ((ir_loop_jump *) ir)->is_break(); +} + +class loop_unroll_count : public ir_hierarchical_visitor { +public: + int nodes; + bool fail; + + loop_unroll_count(exec_list *list) + { + nodes = 0; + fail = false; + + run(list); + } + + virtual ir_visitor_status visit_enter(ir_assignment *ir) + { + nodes++; + return visit_continue; + } + + virtual ir_visitor_status visit_enter(ir_expression *ir) + { + nodes++; + return visit_continue; + } + + virtual ir_visitor_status visit_enter(ir_loop *ir) + { + fail = true; + return visit_continue; + } +}; + + ir_visitor_status loop_unroll_visitor::visit_leave(ir_loop *ir) { @@ -70,49 +110,86 @@ loop_unroll_visitor::visit_leave(ir_loop *ir) if (iterations > (int) max_iterations) return visit_continue; + /* Don't try to unroll nested loops and loops with a huge body. + */ + loop_unroll_count count(&ir->body_instructions); + + if (count.fail || count.nodes * iterations > (int)max_iterations * 5) + 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()); - + 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. + 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. */ - return visit_continue; - } + 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; - /* Remove the break from the if-statement. - */ - last->remove(); + /* 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); + } - void *const mem_ctx = talloc_parent(ir); + /* Remove the break from the if-statement. + */ + break_ir->remove(); + + void *const mem_ctx = ralloc_parent(ir); ir_instruction *ir_to_replace = ir; for (int i = 0; i < iterations; i++) { @@ -121,8 +198,8 @@ loop_unroll_visitor::visit_leave(ir_loop *ir) copy_list.make_empty(); clone_ir_list(mem_ctx, ©_list, &ir->body_instructions); - last_if = ((ir_instruction*)copy_list.get_tail())->as_if(); - assert(last_if); + ir_if = ((ir_instruction *) copy_list.get_tail())->as_if(); + assert(ir_if != NULL); ir_to_replace->insert_before(©_list); ir_to_replace->remove(); @@ -132,7 +209,7 @@ loop_unroll_visitor::visit_leave(ir_loop *ir) 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; + ? &ir_if->then_instructions : &ir_if->else_instructions; list->push_tail(ir_to_replace); } @@ -141,21 +218,10 @@ loop_unroll_visitor::visit_leave(ir_loop *ir) 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); + void *const mem_ctx = ralloc_parent(ir); for (int i = 0; i < iterations; i++) { exec_list copy_list;