• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "compiler/glsl_types.h"
59 #include "program/prog_instruction.h"
60 
61 namespace {
62 
63 class ir_vectorize_visitor : public ir_hierarchical_visitor {
64 public:
clear()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 
ir_vectorize_visitor()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    virtual ir_visitor_status visit_enter(ir_dereference_array *);
86    virtual ir_visitor_status visit_enter(ir_expression *);
87    virtual ir_visitor_status visit_enter(ir_if *);
88    virtual ir_visitor_status visit_enter(ir_loop *);
89    virtual ir_visitor_status visit_enter(ir_texture *);
90 
91    virtual ir_visitor_status visit_leave(ir_assignment *);
92 
93    void try_vectorize();
94 
95    ir_assignment *assignment[4];
96    ir_assignment *current_assignment, *last_assignment;
97    unsigned channels;
98    bool has_swizzle;
99 
100    bool progress;
101 };
102 
103 } /* unnamed namespace */
104 
105 /**
106  * Rewrites the swizzles and types of a right-hand side of an assignment.
107  *
108  * From the example above, this function would be called (by visit_tree()) on
109  * the nodes of the tree (expression float log2 (swiz z   (var_ref v0))),
110  * rewriting it into     (expression vec3  log2 (swiz xyz (var_ref v0))).
111  *
112  * The function operates on ir_expressions (and its operands) and ir_swizzles.
113  * For expressions it sets a new type and swizzles any non-expression and non-
114  * swizzle scalar operands into appropriately sized vector arguments. For
115  * example, if combining
116  *
117  * (assign (x) (var_ref r1) (expression float + (swiz x (var_ref v0) (var_ref v1))))
118  * (assign (y) (var_ref r1) (expression float + (swiz y (var_ref v0) (var_ref v1))))
119  *
120  * where v1 is a scalar, rewrite_swizzle() would insert a swizzle on
121  * (var_ref v1) such that the final result was
122  *
123  * (assign (xy) (var_ref r1) (expression vec2 + (swiz xy (var_ref v0))
124  *                                              (swiz xx (var_ref v1))))
125  *
126  * For swizzles, it sets a new type, and if the variable being swizzled is a
127  * vector it overwrites the swizzle mask with the ir_swizzle_mask passed as the
128  * data parameter. If the swizzled variable is scalar, then the swizzle was
129  * added by an earlier call to rewrite_swizzle() on an expression, so the
130  * mask should not be modified.
131  */
132 static void
rewrite_swizzle(ir_instruction * ir,void * data)133 rewrite_swizzle(ir_instruction *ir, void *data)
134 {
135    ir_swizzle_mask *mask = (ir_swizzle_mask *)data;
136 
137    switch (ir->ir_type) {
138    case ir_type_swizzle: {
139       ir_swizzle *swz = (ir_swizzle *)ir;
140       if (swz->val->type->is_vector()) {
141          swz->mask = *mask;
142       }
143       swz->type = glsl_type::get_instance(swz->type->base_type,
144                                           mask->num_components, 1);
145       break;
146    }
147    case ir_type_expression: {
148       ir_expression *expr = (ir_expression *)ir;
149       expr->type = glsl_type::get_instance(expr->type->base_type,
150                                            mask->num_components, 1);
151       for (unsigned i = 0; i < 4; i++) {
152          if (expr->operands[i]) {
153             ir_rvalue *rval = expr->operands[i]->as_rvalue();
154             if (rval && rval->type->is_scalar() &&
155                 !rval->as_expression() && !rval->as_swizzle()) {
156                expr->operands[i] = new(ir) ir_swizzle(rval, 0, 0, 0, 0,
157                                                       mask->num_components);
158             }
159          }
160       }
161       break;
162    }
163    default:
164       break;
165    }
166 }
167 
168 /**
169  * Attempt to vectorize the previously saved assignments, and clear them from
170  * consideration.
171  *
172  * If the assignments are able to be combined, it modifies in-place the last
173  * assignment seen to be an equivalent vector form of the scalar assignments.
174  * It then removes the other now obsolete scalar assignments.
175  */
176 void
try_vectorize()177 ir_vectorize_visitor::try_vectorize()
178 {
179    if (this->last_assignment && this->channels > 1) {
180       ir_swizzle_mask mask = {0, 0, 0, 0, channels, 0};
181 
182       this->last_assignment->write_mask = 0;
183 
184       for (unsigned i = 0, j = 0; i < 4; i++) {
185          if (this->assignment[i]) {
186             this->last_assignment->write_mask |= 1 << i;
187 
188             if (this->assignment[i] != this->last_assignment) {
189                this->assignment[i]->remove();
190             }
191 
192             switch (j) {
193             case 0: mask.x = i; break;
194             case 1: mask.y = i; break;
195             case 2: mask.z = i; break;
196             case 3: mask.w = i; break;
197             }
198 
199             j++;
200          }
201       }
202 
203       visit_tree(this->last_assignment->rhs, rewrite_swizzle, &mask);
204 
205       this->progress = true;
206    }
207    clear();
208 }
209 
210 /**
211  * Returns whether the write mask is a single channel.
212  */
213 static bool
single_channel_write_mask(unsigned write_mask)214 single_channel_write_mask(unsigned write_mask)
215 {
216    return write_mask != 0 && (write_mask & (write_mask - 1)) == 0;
217 }
218 
219 /**
220  * Translates single-channeled write mask to single-channeled swizzle.
221  */
222 static unsigned
write_mask_to_swizzle(unsigned write_mask)223 write_mask_to_swizzle(unsigned write_mask)
224 {
225    switch (write_mask) {
226    case WRITEMASK_X: return SWIZZLE_X;
227    case WRITEMASK_Y: return SWIZZLE_Y;
228    case WRITEMASK_Z: return SWIZZLE_Z;
229    case WRITEMASK_W: return SWIZZLE_W;
230    }
231    unreachable("not reached");
232 }
233 
234 /**
235  * Returns whether a single-channeled write mask matches a swizzle.
236  */
237 static bool
write_mask_matches_swizzle(unsigned write_mask,const ir_swizzle * swz)238 write_mask_matches_swizzle(unsigned write_mask,
239                            const ir_swizzle *swz)
240 {
241    return ((write_mask == WRITEMASK_X && swz->mask.x == SWIZZLE_X) ||
242            (write_mask == WRITEMASK_Y && swz->mask.x == SWIZZLE_Y) ||
243            (write_mask == WRITEMASK_Z && swz->mask.x == SWIZZLE_Z) ||
244            (write_mask == WRITEMASK_W && swz->mask.x == SWIZZLE_W));
245 }
246 
247 /**
248  * Upon entering an ir_assignment, attempt to vectorize the currently tracked
249  * assignments if the current assignment is not suitable. Keep a pointer to
250  * the current assignment.
251  */
252 ir_visitor_status
visit_enter(ir_assignment * ir)253 ir_vectorize_visitor::visit_enter(ir_assignment *ir)
254 {
255    ir_dereference *lhs = this->last_assignment != NULL ?
256                          this->last_assignment->lhs : NULL;
257    ir_rvalue *rhs = this->last_assignment != NULL ?
258                     this->last_assignment->rhs : NULL;
259 
260    if (ir->condition ||
261        this->channels >= 4 ||
262        !single_channel_write_mask(ir->write_mask) ||
263        this->assignment[write_mask_to_swizzle(ir->write_mask)] != NULL ||
264        (lhs && !ir->lhs->equals(lhs)) ||
265        (rhs && !ir->rhs->equals(rhs, ir_type_swizzle))) {
266       try_vectorize();
267    }
268 
269    this->current_assignment = ir;
270 
271    return visit_continue;
272 }
273 
274 /**
275  * Upon entering an ir_swizzle, set ::has_swizzle if we're visiting from an
276  * ir_assignment (i.e., that ::current_assignment is set) and the swizzle mask
277  * matches the current assignment's write mask.
278  *
279  * If the write mask doesn't match the swizzle mask, remove the current
280  * assignment from further consideration.
281  */
282 ir_visitor_status
visit_enter(ir_swizzle * ir)283 ir_vectorize_visitor::visit_enter(ir_swizzle *ir)
284 {
285    if (this->current_assignment) {
286       if (write_mask_matches_swizzle(this->current_assignment->write_mask, ir)) {
287          this->has_swizzle = true;
288       } else {
289          this->current_assignment = NULL;
290       }
291    }
292    return visit_continue;
293 }
294 
295 /* Upon entering an ir_array_dereference, remove the current assignment from
296  * further consideration. Since the index of an array dereference must scalar,
297  * we are not able to vectorize it.
298  *
299  * FINISHME: If all of scalar indices are identical we could vectorize.
300  */
301 ir_visitor_status
visit_enter(ir_dereference_array *)302 ir_vectorize_visitor::visit_enter(ir_dereference_array *)
303 {
304    this->current_assignment = NULL;
305    return visit_continue_with_parent;
306 }
307 
308 /**
309  * Upon entering an ir_expression, remove the current assignment from further
310  * consideration if the expression operates horizontally on vectors.
311  */
312 ir_visitor_status
visit_enter(ir_expression * ir)313 ir_vectorize_visitor::visit_enter(ir_expression *ir)
314 {
315    if (ir->is_horizontal()) {
316       this->current_assignment = NULL;
317       return visit_continue_with_parent;
318    }
319    return visit_continue;
320 }
321 
322 /* Since there is no statement to visit between the "then" and "else"
323  * instructions try to vectorize before, in between, and after them to avoid
324  * combining statements from different basic blocks.
325  */
326 ir_visitor_status
visit_enter(ir_if * ir)327 ir_vectorize_visitor::visit_enter(ir_if *ir)
328 {
329    try_vectorize();
330 
331    visit_list_elements(this, &ir->then_instructions);
332    try_vectorize();
333 
334    visit_list_elements(this, &ir->else_instructions);
335    try_vectorize();
336 
337    return visit_continue_with_parent;
338 }
339 
340 /* Since there is no statement to visit between the instructions in the body of
341  * the loop and the instructions after it try to vectorize before and after the
342  * body to avoid combining statements from different basic blocks.
343  */
344 ir_visitor_status
visit_enter(ir_loop * ir)345 ir_vectorize_visitor::visit_enter(ir_loop *ir)
346 {
347    try_vectorize();
348 
349    visit_list_elements(this, &ir->body_instructions);
350    try_vectorize();
351 
352    return visit_continue_with_parent;
353 }
354 
355 /**
356  * Upon entering an ir_texture, remove the current assignment from
357  * further consideration. Vectorizing multiple texture lookups into one
358  * is wrong.
359  */
360 ir_visitor_status
visit_enter(ir_texture *)361 ir_vectorize_visitor::visit_enter(ir_texture *)
362 {
363    this->current_assignment = NULL;
364    return visit_continue_with_parent;
365 }
366 
367 /**
368  * Upon leaving an ir_assignment, save a pointer to it in ::assignment[] if
369  * the swizzle mask(s) found were appropriate. Also save a pointer in
370  * ::last_assignment so that we can compare future assignments with it.
371  *
372  * Finally, clear ::current_assignment and ::has_swizzle.
373  */
374 ir_visitor_status
visit_leave(ir_assignment * ir)375 ir_vectorize_visitor::visit_leave(ir_assignment *ir)
376 {
377    if (this->has_swizzle && this->current_assignment) {
378       assert(this->current_assignment == ir);
379 
380       unsigned channel = write_mask_to_swizzle(this->current_assignment->write_mask);
381       this->assignment[channel] = ir;
382       this->channels++;
383 
384       this->last_assignment = this->current_assignment;
385    }
386    this->current_assignment = NULL;
387    this->has_swizzle = false;
388    return visit_continue;
389 }
390 
391 /**
392  * Combines scalar assignments of the same expression (modulo swizzle) to
393  * multiple channels of the same variable into a single vectorized expression
394  * and assignment.
395  */
396 bool
do_vectorize(exec_list * instructions)397 do_vectorize(exec_list *instructions)
398 {
399    ir_vectorize_visitor v;
400 
401    v.run(instructions);
402 
403    /* Try to vectorize the last assignments seen. */
404    v.try_vectorize();
405 
406    return v.progress;
407 }
408