src/glsl/opt_vectorize.cpp

   1 /*
   2  * Copyright © 2013 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 /**
  25  * \file opt_vectorize.cpp
  26  *
  27  * Combines scalar assignments of the same expression (modulo swizzle) to
  28  * multiple channels of the same variable into a single vectorized expression
  29  * and assignment.
  30  *
  31  * Many generated shaders contain scalarized code. That is, they contain
  32  *
  33  * r1.x = log2(v0.x);
  34  * r1.y = log2(v0.y);
  35  * r1.z = log2(v0.z);
  36  *
  37  * rather than
  38  *
  39  * r1.xyz = log2(v0.xyz);
  40  *
  41  * We look for consecutive assignments of the same expression (modulo swizzle)
  42  * to each channel of the same variable.
  43  *
  44  * For instance, we want to convert these three scalar operations
  45  *
  46  * (assign (x) (var_ref r1) (expression float log2 (swiz x (var_ref v0))))
  47  * (assign (y) (var_ref r1) (expression float log2 (swiz y (var_ref v0))))
  48  * (assign (z) (var_ref r1) (expression float log2 (swiz z (var_ref v0))))
  49  *
  50  * into a single vector operation
  51  *
  52  * (assign (xyz) (var_ref r1) (expression vec3 log2 (swiz xyz (var_ref v0))))
  53  */
  54
  55 #include "ir.h"
  56 #include "ir_visitor.h"
  57 #include "ir_optimization.h"
  58 #include "glsl_types.h"
  59 #include "program/prog_instruction.h"
  60
  61 namespace {
  62
  63 class ir_vectorize_visitor : public ir_hierarchical_visitor {
  64 public:
  65    void clear()
  66    {
  67       assignment[0] = NULL;
  68       assignment[1] = NULL;
  69       assignment[2] = NULL;
  70       assignment[3] = NULL;
  71       current_assignment = NULL;
  72       last_assignment = NULL;
  73       channels = 0;
  74       has_swizzle = false;
  75    }
  76
  77    ir_vectorize_visitor()
  78    {
  79       clear();
  80       progress = false;
  81    }
  82
  83    virtual ir_visitor_status visit_enter(ir_assignment *);
  84    virtual ir_visitor_status visit_enter(ir_swizzle *);
  85
  86    virtual ir_visitor_status visit_leave(ir_assignment *);
  87
  88    void try_vectorize();
  89
  90    ir_assignment *assignment[4];
  91    ir_assignment *current_assignment, *last_assignment;
  92    unsigned channels;
  93    bool has_swizzle;
  94
  95    bool progress;
  96 };
  97
  98 } /* unnamed namespace */
  99
 100 /**
 101  * Rewrites the swizzles and types of a right-hand side of an assignment.
 102  *
 103  * From the example above, this function would be called (by visit_tree()) on
 104  * the nodes of the tree (expression float log2 (swiz z   (var_ref v0))),
 105  * rewriting it into     (expression vec3  log2 (swiz xyz (var_ref v0))).
 106  *
 107  * The function modifies only ir_expressions and ir_swizzles. For expressions
 108  * it sets a new type and swizzles any scalar dereferences into appropriately
 109  * sized vector arguments. For example, if combining
 110  *
 111  * (assign (x) (var_ref r1) (expression float + (swiz x (var_ref v0) (var_ref v1))))
 112  * (assign (y) (var_ref r1) (expression float + (swiz y (var_ref v0) (var_ref v1))))
 113  *
 114  * where v1 is a scalar, rewrite_swizzle() would insert a swizzle on
 115  * (var_ref v1) such that the final result was
 116  *
 117  * (assign (xy) (var_ref r1) (expression vec2 + (swiz xy (var_ref v0))
 118  *                                              (swiz xx (var_ref v1))))
 119  *
 120  * For swizzles, it sets a new type, and if the variable being swizzled is a
 121  * vector it overwrites the swizzle mask with the ir_swizzle_mask passed as the
 122  * data parameter. If the swizzled variable is scalar, then the swizzle was
 123  * added by an earlier call to rewrite_swizzle() on an expression, so the
 124  * mask should not be modified.
 125  */
 126 static void
 127 rewrite_swizzle(ir_instruction *ir, void *data)
 128 {
 129    ir_swizzle_mask *mask = (ir_swizzle_mask *)data;
 130
 131    switch (ir->ir_type) {
 132    case ir_type_swizzle: {
 133       ir_swizzle *swz = (ir_swizzle *)ir;
 134       if (swz->val->type->is_vector()) {
 135          swz->mask = *mask;
 136       }
 137       swz->type = glsl_type::get_instance(swz->type->base_type,
 138                                           mask->num_components, 1);
 139       break;
 140    }
 141    case ir_type_expression: {
 142       ir_expression *expr = (ir_expression *)ir;
 143       expr->type = glsl_type::get_instance(expr->type->base_type,
 144                                            mask->num_components, 1);
 145       for (unsigned i = 0; i < 4; i++) {
 146          if (expr->operands[i]) {
 147             ir_dereference *deref = expr->operands[i]->as_dereference();
 148             if (deref && deref->type->is_scalar()) {
 149                expr->operands[i] = new(ir) ir_swizzle(deref, 0, 0, 0, 0,
 150                                                       mask->num_components);
 151             }
 152          }
 153       }
 154       break;
 155    }
 156    default:
 157       break;
 158    }
 159 }
 160
 161 /**
 162  * Attempt to vectorize the previously saved assignments, and clear them from
 163  * consideration.
 164  *
 165  * If the assignments are able to be combined, it modifies in-place the last
 166  * assignment seen to be an equivalent vector form of the scalar assignments.
 167  * It then removes the other now obsolete scalar assignments.
 168  */
 169 void
 170 ir_vectorize_visitor::try_vectorize()
 171 {
 172    if (this->last_assignment && this->channels > 1) {
 173       ir_swizzle_mask mask = {0, 0, 0, 0, channels, 0};
 174
 175       this->last_assignment->write_mask = 0;
 176
 177       for (unsigned i = 0, j = 0; i < 4; i++) {
 178          if (this->assignment[i]) {
 179             this->last_assignment->write_mask |= 1 << i;
 180
 181             if (this->assignment[i] != this->last_assignment) {
 182                this->assignment[i]->remove();
 183             }
 184
 185             switch (j) {
 186             case 0: mask.x = i; break;
 187             case 1: mask.y = i; break;
 188             case 2: mask.z = i; break;
 189             case 3: mask.w = i; break;
 190             }
 191
 192             j++;
 193          }
 194       }
 195
 196       visit_tree(this->last_assignment->rhs, rewrite_swizzle, &mask);
 197
 198       this->progress = true;
 199    }
 200    clear();
 201 }
 202
 203 /**
 204  * Returns whether the write mask is a single channel.
 205  */
 206 static bool
 207 single_channel_write_mask(unsigned write_mask)
 208 {
 209    return write_mask != 0 && (write_mask & (write_mask - 1)) == 0;
 210 }
 211
 212 /**
 213  * Translates single-channeled write mask to single-channeled swizzle.
 214  */
 215 static unsigned
 216 write_mask_to_swizzle(unsigned write_mask)
 217 {
 218    switch (write_mask) {
 219    case WRITEMASK_X: return SWIZZLE_X;
 220    case WRITEMASK_Y: return SWIZZLE_Y;
 221    case WRITEMASK_Z: return SWIZZLE_Z;
 222    case WRITEMASK_W: return SWIZZLE_W;
 223    }
 224    assert(!"not reached");
 225    unreachable();
 226 }
 227
 228 /**
 229  * Returns whether a single-channeled write mask matches a swizzle.
 230  */
 231 static bool
 232 write_mask_matches_swizzle(unsigned write_mask,
 233                            const ir_swizzle *swz)
 234 {
 235    return ((write_mask == WRITEMASK_X && swz->mask.x == SWIZZLE_X) ||
 236            (write_mask == WRITEMASK_Y && swz->mask.x == SWIZZLE_Y) ||
 237            (write_mask == WRITEMASK_Z && swz->mask.x == SWIZZLE_Z) ||
 238            (write_mask == WRITEMASK_W && swz->mask.x == SWIZZLE_W));
 239 }
 240
 241 /**
 242  * Upon entering an ir_assignment, attempt to vectorize the currently tracked
 243  * assignments if the current assignment is not suitable. Keep a pointer to
 244  * the current assignment.
 245  */
 246 ir_visitor_status
 247 ir_vectorize_visitor::visit_enter(ir_assignment *ir)
 248 {
 249    ir_dereference *lhs = this->last_assignment != NULL ?
 250                          this->last_assignment->lhs : NULL;
 251    ir_rvalue *rhs = this->last_assignment != NULL ?
 252                     this->last_assignment->rhs : NULL;
 253
 254    if (ir->condition ||
 255        this->channels >= 4 ||
 256        !single_channel_write_mask(ir->write_mask) ||
 257        (lhs && !ir->lhs->equals(lhs)) ||
 258        (rhs && !ir->rhs->equals(rhs, ir_type_swizzle))) {
 259       try_vectorize();
 260    }
 261
 262    this->current_assignment = ir;
 263
 264    return visit_continue;
 265 }
 266
 267 /**
 268  * Upon entering an ir_swizzle, set ::has_swizzle if we're visiting from an
 269  * ir_assignment (i.e., that ::current_assignment is set) and the swizzle mask
 270  * matches the current assignment's write mask.
 271  *
 272  * If the write mask doesn't match the swizzle mask, remove the current
 273  * assignment from further consideration.
 274  */
 275 ir_visitor_status
 276 ir_vectorize_visitor::visit_enter(ir_swizzle *ir)
 277 {
 278    if (this->current_assignment) {
 279       if (write_mask_matches_swizzle(this->current_assignment->write_mask, ir)) {
 280          this->has_swizzle = true;
 281       } else {
 282          this->current_assignment = NULL;
 283       }
 284    }
 285    return visit_continue;
 286 }
 287
 288 /**
 289  * Upon leaving an ir_assignment, save a pointer to it in ::assignment[] if
 290  * the swizzle mask(s) found were appropriate. Also save a pointer in
 291  * ::last_assignment so that we can compare future assignments with it.
 292  *
 293  * Finally, clear ::current_assignment and ::has_swizzle.
 294  */
 295 ir_visitor_status
 296 ir_vectorize_visitor::visit_leave(ir_assignment *ir)
 297 {
 298    if (this->has_swizzle && this->current_assignment) {
 299       assert(this->current_assignment == ir);
 300
 301       unsigned channel = write_mask_to_swizzle(this->current_assignment->write_mask);
 302       this->assignment[channel] = ir;
 303       this->channels++;
 304
 305       this->last_assignment = this->current_assignment;
 306    }
 307    this->current_assignment = NULL;
 308    this->has_swizzle = false;
 309    return visit_continue;
 310 }
 311
 312 /**
 313  * Combines scalar assignments of the same expression (modulo swizzle) to
 314  * multiple channels of the same variable into a single vectorized expression
 315  * and assignment.
 316  */
 317 bool
 318 do_vectorize(exec_list *instructions)
 319 {
 320    ir_vectorize_visitor v;
 321
 322    v.run(instructions);
 323
 324    /* Try to vectorize the last assignments seen. */
 325    v.try_vectorize();
 326
 327    return v.progress;
 328 }