src/compiler/glsl/loop_analysis.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "compiler/glsl_types.h"
  25 #include "loop_analysis.h"
  26 #include "ir_hierarchical_visitor.h"
  27
  28 static bool is_loop_terminator(ir_if *ir);
  29
  30 static bool all_expression_operands_are_loop_constant(ir_rvalue *,
  31                                                       hash_table *);
  32
  33 static ir_rvalue *get_basic_induction_increment(ir_assignment *, hash_table *);
  34
  35
  36 /**
  37  * Record the fact that the given loop variable was referenced inside the loop.
  38  *
  39  * \arg in_assignee is true if the reference was on the LHS of an assignment.
  40  *
  41  * \arg in_conditional_code_or_nested_loop is true if the reference occurred
  42  * inside an if statement or a nested loop.
  43  *
  44  * \arg current_assignment is the ir_assignment node that the loop variable is
  45  * on the LHS of, if any (ignored if \c in_assignee is false).
  46  */
  47 void
  48 loop_variable::record_reference(bool in_assignee,
  49                                 bool in_conditional_code_or_nested_loop,
  50                                 ir_assignment *current_assignment)
  51 {
  52    if (in_assignee) {
  53       assert(current_assignment != NULL);
  54
  55       if (in_conditional_code_or_nested_loop ||
  56           current_assignment->condition != NULL) {
  57          this->conditional_or_nested_assignment = true;
  58       }
  59
  60       if (this->first_assignment == NULL) {
  61          assert(this->num_assignments == 0);
  62
  63          this->first_assignment = current_assignment;
  64       }
  65
  66       this->num_assignments++;
  67    } else if (this->first_assignment == current_assignment) {
  68       /* This catches the case where the variable is used in the RHS of an
  69        * assignment where it is also in the LHS.
  70        */
  71       this->read_before_write = true;
  72    }
  73 }
  74
  75
  76 loop_state::loop_state()
  77 {
  78    this->ht = hash_table_ctor(0, hash_table_pointer_hash,
  79                               hash_table_pointer_compare);
  80    this->mem_ctx = ralloc_context(NULL);
  81    this->loop_found = false;
  82 }
  83
  84
  85 loop_state::~loop_state()
  86 {
  87    hash_table_dtor(this->ht);
  88    ralloc_free(this->mem_ctx);
  89 }
  90
  91
  92 loop_variable_state *
  93 loop_state::insert(ir_loop *ir)
  94 {
  95    loop_variable_state *ls = new(this->mem_ctx) loop_variable_state;
  96
  97    hash_table_insert(this->ht, ls, ir);
  98    this->loop_found = true;
  99
 100    return ls;
 101 }
 102
 103
 104 loop_variable_state *
 105 loop_state::get(const ir_loop *ir)
 106 {
 107    return (loop_variable_state *) hash_table_find(this->ht, ir);
 108 }
 109
 110
 111 loop_variable *
 112 loop_variable_state::get(const ir_variable *ir)
 113 {
 114    return (loop_variable *) hash_table_find(this->var_hash, ir);
 115 }
 116
 117
 118 loop_variable *
 119 loop_variable_state::insert(ir_variable *var)
 120 {
 121    void *mem_ctx = ralloc_parent(this);
 122    loop_variable *lv = rzalloc(mem_ctx, loop_variable);
 123
 124    lv->var = var;
 125
 126    hash_table_insert(this->var_hash, lv, lv->var);
 127    this->variables.push_tail(lv);
 128
 129    return lv;
 130 }
 131
 132
 133 loop_terminator *
 134 loop_variable_state::insert(ir_if *if_stmt)
 135 {
 136    void *mem_ctx = ralloc_parent(this);
 137    loop_terminator *t = new(mem_ctx) loop_terminator();
 138
 139    t->ir = if_stmt;
 140    this->terminators.push_tail(t);
 141
 142    return t;
 143 }
 144
 145
 146 /**
 147  * If the given variable already is recorded in the state for this loop,
 148  * return the corresponding loop_variable object that records information
 149  * about it.
 150  *
 151  * Otherwise, create a new loop_variable object to record information about
 152  * the variable, and set its \c read_before_write field appropriately based on
 153  * \c in_assignee.
 154  *
 155  * \arg in_assignee is true if this variable was encountered on the LHS of an
 156  * assignment.
 157  */
 158 loop_variable *
 159 loop_variable_state::get_or_insert(ir_variable *var, bool in_assignee)
 160 {
 161    loop_variable *lv = this->get(var);
 162
 163    if (lv == NULL) {
 164       lv = this->insert(var);
 165       lv->read_before_write = !in_assignee;
 166    }
 167
 168    return lv;
 169 }
 170
 171
 172 namespace {
 173
 174 class loop_analysis : public ir_hierarchical_visitor {
 175 public:
 176    loop_analysis(loop_state *loops);
 177
 178    virtual ir_visitor_status visit(ir_loop_jump *);
 179    virtual ir_visitor_status visit(ir_dereference_variable *);
 180
 181    virtual ir_visitor_status visit_enter(ir_call *);
 182
 183    virtual ir_visitor_status visit_enter(ir_loop *);
 184    virtual ir_visitor_status visit_leave(ir_loop *);
 185    virtual ir_visitor_status visit_enter(ir_assignment *);
 186    virtual ir_visitor_status visit_leave(ir_assignment *);
 187    virtual ir_visitor_status visit_enter(ir_if *);
 188    virtual ir_visitor_status visit_leave(ir_if *);
 189
 190    loop_state *loops;
 191
 192    int if_statement_depth;
 193
 194    ir_assignment *current_assignment;
 195
 196    exec_list state;
 197 };
 198
 199 } /* anonymous namespace */
 200
 201 loop_analysis::loop_analysis(loop_state *loops)
 202    : loops(loops), if_statement_depth(0), current_assignment(NULL)
 203 {
 204    /* empty */
 205 }
 206
 207
 208 ir_visitor_status
 209 loop_analysis::visit(ir_loop_jump *ir)
 210 {
 211    (void) ir;
 212
 213    assert(!this->state.is_empty());
 214
 215    loop_variable_state *const ls =
 216       (loop_variable_state *) this->state.get_head();
 217
 218    ls->num_loop_jumps++;
 219
 220    return visit_continue;
 221 }
 222
 223
 224 ir_visitor_status
 225 loop_analysis::visit_enter(ir_call *)
 226 {
 227    /* Mark every loop that we're currently analyzing as containing an ir_call
 228     * (even those at outer nesting levels).
 229     */
 230    foreach_in_list(loop_variable_state, ls, &this->state) {
 231       ls->contains_calls = true;
 232    }
 233
 234    return visit_continue_with_parent;
 235 }
 236
 237
 238 ir_visitor_status
 239 loop_analysis::visit(ir_dereference_variable *ir)
 240 {
 241    /* If we're not somewhere inside a loop, there's nothing to do.
 242     */
 243    if (this->state.is_empty())
 244       return visit_continue;
 245
 246    bool nested = false;
 247
 248    foreach_in_list(loop_variable_state, ls, &this->state) {
 249       ir_variable *var = ir->variable_referenced();
 250       loop_variable *lv = ls->get_or_insert(var, this->in_assignee);
 251
 252       lv->record_reference(this->in_assignee,
 253                            nested || this->if_statement_depth > 0,
 254                            this->current_assignment);
 255       nested = true;
 256    }
 257
 258    return visit_continue;
 259 }
 260
 261 ir_visitor_status
 262 loop_analysis::visit_enter(ir_loop *ir)
 263 {
 264    loop_variable_state *ls = this->loops->insert(ir);
 265    this->state.push_head(ls);
 266
 267    return visit_continue;
 268 }
 269
 270 ir_visitor_status
 271 loop_analysis::visit_leave(ir_loop *ir)
 272 {
 273    loop_variable_state *const ls =
 274       (loop_variable_state *) this->state.pop_head();
 275
 276    /* Function calls may contain side effects.  These could alter any of our
 277     * variables in ways that cannot be known, and may even terminate shader
 278     * execution (say, calling discard in the fragment shader).  So we can't
 279     * rely on any of our analysis about assignments to variables.
 280     *
 281     * We could perform some conservative analysis (prove there's no statically
 282     * possible assignment, etc.) but it isn't worth it for now; function
 283     * inlining will allow us to unroll loops anyway.
 284     */
 285    if (ls->contains_calls)
 286       return visit_continue;
 287
 288    foreach_in_list(ir_instruction, node, &ir->body_instructions) {
 289       /* Skip over declarations at the start of a loop.
 290        */
 291       if (node->as_variable())
 292          continue;
 293
 294       ir_if *if_stmt = ((ir_instruction *) node)->as_if();
 295
 296       if ((if_stmt != NULL) && is_loop_terminator(if_stmt))
 297          ls->insert(if_stmt);
 298       else
 299          break;
 300    }
 301
 302
 303    foreach_in_list_safe(loop_variable, lv, &ls->variables) {
 304       /* Move variables that are already marked as being loop constant to
 305        * a separate list.  These trivially don't need to be tested.
 306        */
 307       if (lv->is_loop_constant()) {
 308          lv->remove();
 309          ls->constants.push_tail(lv);
 310       }
 311    }
 312
 313    /* Each variable assigned in the loop that isn't already marked as being loop
 314     * constant might still be loop constant.  The requirements at this point
 315     * are:
 316     *
 317     *    - Variable is written before it is read.
 318     *
 319     *    - Only one assignment to the variable.
 320     *
 321     *    - All operands on the RHS of the assignment are also loop constants.
 322     *
 323     * The last requirement is the reason for the progress loop.  A variable
 324     * marked as a loop constant on one pass may allow other variables to be
 325     * marked as loop constant on following passes.
 326     */
 327    bool progress;
 328    do {
 329       progress = false;
 330
 331       foreach_in_list_safe(loop_variable, lv, &ls->variables) {
 332          if (lv->conditional_or_nested_assignment || (lv->num_assignments > 1))
 333             continue;
 334
 335          /* Process the RHS of the assignment.  If all of the variables
 336           * accessed there are loop constants, then add this
 337           */
 338          ir_rvalue *const rhs = lv->first_assignment->rhs;
 339          if (all_expression_operands_are_loop_constant(rhs, ls->var_hash)) {
 340             lv->rhs_clean = true;
 341
 342             if (lv->is_loop_constant()) {
 343                progress = true;
 344
 345                lv->remove();
 346                ls->constants.push_tail(lv);
 347             }
 348          }
 349       }
 350    } while (progress);
 351
 352    /* The remaining variables that are not loop invariant might be loop
 353     * induction variables.
 354     */
 355    foreach_in_list_safe(loop_variable, lv, &ls->variables) {
 356       /* If there is more than one assignment to a variable, it cannot be a
 357        * loop induction variable.  This isn't strictly true, but this is a
 358        * very simple induction variable detector, and it can't handle more
 359        * complex cases.
 360        */
 361       if (lv->num_assignments > 1)
 362          continue;
 363
 364       /* All of the variables with zero assignments in the loop are loop
 365        * invariant, and they should have already been filtered out.
 366        */
 367       assert(lv->num_assignments == 1);
 368       assert(lv->first_assignment != NULL);
 369
 370       /* The assignment to the variable in the loop must be unconditional and
 371        * not inside a nested loop.
 372        */
 373       if (lv->conditional_or_nested_assignment)
 374          continue;
 375
 376       /* Basic loop induction variables have a single assignment in the loop
 377        * that has the form 'VAR = VAR + i' or 'VAR = VAR - i' where i is a
 378        * loop invariant.
 379        */
 380       ir_rvalue *const inc =
 381          get_basic_induction_increment(lv->first_assignment, ls->var_hash);
 382       if (inc != NULL) {
 383          lv->increment = inc;
 384
 385          lv->remove();
 386          ls->induction_variables.push_tail(lv);
 387       }
 388    }
 389
 390    /* Search the loop terminating conditions for those of the form 'i < c'
 391     * where i is a loop induction variable, c is a constant, and < is any
 392     * relative operator.  From each of these we can infer an iteration count.
 393     * Also figure out which terminator (if any) produces the smallest
 394     * iteration count--this is the limiting terminator.
 395     */
 396    foreach_in_list(loop_terminator, t, &ls->terminators) {
 397       ir_if *if_stmt = t->ir;
 398
 399       /* If-statements can be either 'if (expr)' or 'if (deref)'.  We only care
 400        * about the former here.
 401        */
 402       ir_expression *cond = if_stmt->condition->as_expression();
 403       if (cond == NULL)
 404          continue;
 405
 406       switch (cond->operation) {
 407       case ir_binop_less:
 408       case ir_binop_greater:
 409       case ir_binop_lequal:
 410       case ir_binop_gequal: {
 411          /* The expressions that we care about will either be of the form
 412           * 'counter < limit' or 'limit < counter'.  Figure out which is
 413           * which.
 414           */
 415          ir_rvalue *counter = cond->operands[0]->as_dereference_variable();
 416          ir_constant *limit = cond->operands[1]->as_constant();
 417          enum ir_expression_operation cmp = cond->operation;
 418
 419          if (limit == NULL) {
 420             counter = cond->operands[1]->as_dereference_variable();
 421             limit = cond->operands[0]->as_constant();
 422
 423             switch (cmp) {
 424             case ir_binop_less:    cmp = ir_binop_greater; break;
 425             case ir_binop_greater: cmp = ir_binop_less;    break;
 426             case ir_binop_lequal:  cmp = ir_binop_gequal;  break;
 427             case ir_binop_gequal:  cmp = ir_binop_lequal;  break;
 428             default: assert(!"Should not get here.");
 429             }
 430          }
 431
 432          if ((counter == NULL) || (limit == NULL))
 433             break;
 434
 435          ir_variable *var = counter->variable_referenced();
 436
 437          ir_rvalue *init = find_initial_value(ir, var);
 438
 439          loop_variable *lv = ls->get(var);
 440          if (lv != NULL && lv->is_induction_var()) {
 441             t->iterations = calculate_iterations(init, limit, lv->increment,
 442                                                  cmp);
 443
 444             if (t->iterations >= 0 &&
 445                 (ls->limiting_terminator == NULL ||
 446                  t->iterations < ls->limiting_terminator->iterations)) {
 447                ls->limiting_terminator = t;
 448             }
 449          }
 450          break;
 451       }
 452
 453       default:
 454          break;
 455       }
 456    }
 457
 458    return visit_continue;
 459 }
 460
 461 ir_visitor_status
 462 loop_analysis::visit_enter(ir_if *ir)
 463 {
 464    (void) ir;
 465
 466    if (!this->state.is_empty())
 467       this->if_statement_depth++;
 468
 469    return visit_continue;
 470 }
 471
 472 ir_visitor_status
 473 loop_analysis::visit_leave(ir_if *ir)
 474 {
 475    (void) ir;
 476
 477    if (!this->state.is_empty())
 478       this->if_statement_depth--;
 479
 480    return visit_continue;
 481 }
 482
 483 ir_visitor_status
 484 loop_analysis::visit_enter(ir_assignment *ir)
 485 {
 486    /* If we're not somewhere inside a loop, there's nothing to do.
 487     */
 488    if (this->state.is_empty())
 489       return visit_continue_with_parent;
 490
 491    this->current_assignment = ir;
 492
 493    return visit_continue;
 494 }
 495
 496 ir_visitor_status
 497 loop_analysis::visit_leave(ir_assignment *ir)
 498 {
 499    /* Since the visit_enter exits with visit_continue_with_parent for this
 500     * case, the loop state stack should never be empty here.
 501     */
 502    assert(!this->state.is_empty());
 503
 504    assert(this->current_assignment == ir);
 505    this->current_assignment = NULL;
 506
 507    return visit_continue;
 508 }
 509
 510
 511 class examine_rhs : public ir_hierarchical_visitor {
 512 public:
 513    examine_rhs(hash_table *loop_variables)
 514    {
 515       this->only_uses_loop_constants = true;
 516       this->loop_variables = loop_variables;
 517    }
 518
 519    virtual ir_visitor_status visit(ir_dereference_variable *ir)
 520    {
 521       loop_variable *lv =
 522          (loop_variable *) hash_table_find(this->loop_variables, ir->var);
 523
 524       assert(lv != NULL);
 525
 526       if (lv->is_loop_constant()) {
 527          return visit_continue;
 528       } else {
 529          this->only_uses_loop_constants = false;
 530          return visit_stop;
 531       }
 532    }
 533
 534    hash_table *loop_variables;
 535    bool only_uses_loop_constants;
 536 };
 537
 538
 539 bool
 540 all_expression_operands_are_loop_constant(ir_rvalue *ir, hash_table *variables)
 541 {
 542    examine_rhs v(variables);
 543
 544    ir->accept(&v);
 545
 546    return v.only_uses_loop_constants;
 547 }
 548
 549
 550 ir_rvalue *
 551 get_basic_induction_increment(ir_assignment *ir, hash_table *var_hash)
 552 {
 553    /* The RHS must be a binary expression.
 554     */
 555    ir_expression *const rhs = ir->rhs->as_expression();
 556    if ((rhs == NULL)
 557        || ((rhs->operation != ir_binop_add)
 558            && (rhs->operation != ir_binop_sub)))
 559       return NULL;
 560
 561    /* One of the of operands of the expression must be the variable assigned.
 562     * If the operation is subtraction, the variable in question must be the
 563     * "left" operand.
 564     */
 565    ir_variable *const var = ir->lhs->variable_referenced();
 566
 567    ir_variable *const op0 = rhs->operands[0]->variable_referenced();
 568    ir_variable *const op1 = rhs->operands[1]->variable_referenced();
 569
 570    if (((op0 != var) && (op1 != var))
 571        || ((op1 == var) && (rhs->operation == ir_binop_sub)))
 572       return NULL;
 573
 574    ir_rvalue *inc = (op0 == var) ? rhs->operands[1] : rhs->operands[0];
 575
 576    if (inc->as_constant() == NULL) {
 577       ir_variable *const inc_var = inc->variable_referenced();
 578       if (inc_var != NULL) {
 579          loop_variable *lv =
 580             (loop_variable *) hash_table_find(var_hash, inc_var);
 581
 582          if (lv == NULL || !lv->is_loop_constant()) {
 583             assert(lv != NULL);
 584             inc = NULL;
 585          }
 586       } else
 587          inc = NULL;
 588    }
 589
 590    if ((inc != NULL) && (rhs->operation == ir_binop_sub)) {
 591       void *mem_ctx = ralloc_parent(ir);
 592
 593       inc = new(mem_ctx) ir_expression(ir_unop_neg,
 594                                        inc->type,
 595                                        inc->clone(mem_ctx, NULL),
 596                                        NULL);
 597    }
 598
 599    return inc;
 600 }
 601
 602
 603 /**
 604  * Detect whether an if-statement is a loop terminating condition
 605  *
 606  * Detects if-statements of the form
 607  *
 608  *  (if (expression bool ...) (break))
 609  */
 610 bool
 611 is_loop_terminator(ir_if *ir)
 612 {
 613    if (!ir->else_instructions.is_empty())
 614       return false;
 615
 616    ir_instruction *const inst =
 617       (ir_instruction *) ir->then_instructions.get_head();
 618    if (inst == NULL)
 619       return false;
 620
 621    if (inst->ir_type != ir_type_loop_jump)
 622       return false;
 623
 624    ir_loop_jump *const jump = (ir_loop_jump *) inst;
 625    if (jump->mode != ir_loop_jump::jump_break)
 626       return false;
 627
 628    return true;
 629 }
 630
 631
 632 loop_state *
 633 analyze_loop_variables(exec_list *instructions)
 634 {
 635    loop_state *loops = new loop_state;
 636    loop_analysis v(loops);
 637
 638    v.run(instructions);
 639    return v.loops;
 640 }