OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ecc6c3d4ab31c6cd848bce02790000c165a02229
third_party_mesa3d/src/glsl/opt_algebraic.cpp

622 lines
17 KiB
C++
Raw Normal View History

glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
/*
* 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.
*/
/**
glsl: Fix Doxygen tag \file in recently renamed files
2010-11-17 10:43:10 -08:00
* \file opt_algebraic.cpp
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
*
* Takes advantage of association, commutivity, and other algebraic
* properties to simplify expressions.
*/
#include "ir.h"
#include "ir_visitor.h"
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
#include "ir_rvalue_visitor.h"
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
#include "ir_optimization.h"
glsl: Optimize (not A) or (not B) into not (A and B). A few Serious Sam 3 shaders affected: instructions in affected programs: 4384 -> 4344 (-0.91%) Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:40:16 -07:00
#include "ir_builder.h"
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
#include "glsl_types.h"
glsl: Optimize (not A) or (not B) into not (A and B). A few Serious Sam 3 shaders affected: instructions in affected programs: 4384 -> 4344 (-0.91%) Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:40:16 -07:00
using namespace ir_builder;
glsl: Put a bunch of optimization visitors under anonymous namespaces. Because these classes are used entirely from their own source files and not from separate DSOs, the linker gets to produce massively less code. This cuts about 13k of text in the libdricore case. In the non-libdricore case, the additional linkage information allows the compiler to inline some code, so libglsl.a size actually increases by about 300 bytes. For a dricore build, improves shader_runner runtime on glsl-fs-copy-propagation-texcoords-1 by 0.21% +/- 0.03% (n=353574, outliers removed). No statistically significant difference with n=322 on glslparsertest on a yofrankie shader intended to test compiler performance. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-29 16:18:37 -07:00
namespace {
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
/**
* Visitor class for replacing expressions with ir_constant values.
*/
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
class ir_algebraic_visitor : public ir_rvalue_visitor {
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
public:
ir_algebraic_visitor()
{
this->progress = false;
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
this->mem_ctx = NULL;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
virtual ~ir_algebraic_visitor()
{
}
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
ir_rvalue *handle_expression(ir_expression *ir);
void handle_rvalue(ir_rvalue **rvalue);
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
bool reassociate_constant(ir_expression *ir1,
int const_index,
ir_constant *constant,
ir_expression *ir2);
void reassociate_operands(ir_expression *ir1,
int op1,
ir_expression *ir2,
int op2);
glsl: When doing algebraic simplification, make sure the type still matches. When simplifying (vec4(1.0) / (float(x))) to rcp(float(x)), we forgot to produce a vec4, angering ir_validate when starting alien-arena. Fixes: glsl-algebraic-add-zero-2 glsl-algebraic-div-one-2 glsl-algebraic-mul-one-2 glsl-algebraic-sub-zero-3 glsl-algebraic-rcp-sqrt-2
2010-08-17 13:24:50 -07:00
ir_rvalue *swizzle_if_required(ir_expression *expr,
ir_rvalue *operand);
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
void *mem_ctx;
glsl: When doing algebraic simplification, make sure the type still matches. When simplifying (vec4(1.0) / (float(x))) to rcp(float(x)), we forgot to produce a vec4, angering ir_validate when starting alien-arena. Fixes: glsl-algebraic-add-zero-2 glsl-algebraic-div-one-2 glsl-algebraic-mul-one-2 glsl-algebraic-sub-zero-3 glsl-algebraic-rcp-sqrt-2
2010-08-17 13:24:50 -07:00
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
bool progress;
};
glsl: Put a bunch of optimization visitors under anonymous namespaces. Because these classes are used entirely from their own source files and not from separate DSOs, the linker gets to produce massively less code. This cuts about 13k of text in the libdricore case. In the non-libdricore case, the additional linkage information allows the compiler to inline some code, so libglsl.a size actually increases by about 300 bytes. For a dricore build, improves shader_runner runtime on glsl-fs-copy-propagation-texcoords-1 by 0.21% +/- 0.03% (n=353574, outliers removed). No statistically significant difference with n=322 on glslparsertest on a yofrankie shader intended to test compiler performance. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-05-29 16:18:37 -07:00
} /* unnamed namespace */
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
static inline bool
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
is_vec_zero(ir_constant *ir)
{
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return (ir == NULL) ? false : ir->is_zero();
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
static inline bool
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
is_vec_one(ir_constant *ir)
{
glsl: Refactor is_vec_{zero,one} to be methods of ir_constant These predicates will be used in other places soon.
2010-11-12 10:19:08 -08:00
return (ir == NULL) ? false : ir->is_one();
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
glsl: Optimize pow(2, x) --> exp2(x). On Haswell, POW takes 24 cycles, while EXP2 only takes 14. Plus, using POW requires putting 2.0 in a register, while EXP2 doesn't. I believe that EXP2 will be faster than POW on basically all GPUs, so it makes sense to optimize it. Looking at the savage2 subset of shader-db: total instructions in shared programs: 113225 -> 113179 (-0.04%) instructions in affected programs: 2139 -> 2093 (-2.15%) instances of 'math pow': 795 -> 749 (-6.14%) instances of 'math exp': 389 -> 435 (11.8%) Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:57:01 -08:00
static inline bool
is_vec_two(ir_constant *ir)
{
return (ir == NULL) ? false : ir->is_value(2.0, 2);
}
glsl: Optimize mul(a, -1) into neg(a). Two extra instructions in some heroesofnewerth shaders, but a win for everything else. total instructions in shared programs: 1531352 -> 1530815 (-0.04%) instructions in affected programs: 121898 -> 121361 (-0.44%) Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-10-15 23:42:19 -07:00
static inline bool
is_vec_negative_one(ir_constant *ir)
{
return (ir == NULL) ? false : ir->is_negative_one();
}
glsl: Transform dot product by a basis vector into a swizzle Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-04 21:59:34 -04:00
static inline bool
is_vec_basis(ir_constant *ir)
{
return (ir == NULL) ? false : ir->is_basis();
}
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
static void
update_type(ir_expression *ir)
{
if (ir->operands[0]->type->is_vector())
ir->type = ir->operands[0]->type;
else
ir->type = ir->operands[1]->type;
}
void
ir_algebraic_visitor::reassociate_operands(ir_expression *ir1,
int op1,
ir_expression *ir2,
int op2)
{
ir_rvalue *temp = ir2->operands[op2];
ir2->operands[op2] = ir1->operands[op1];
ir1->operands[op1] = temp;
/* Update the type of ir2. The type of ir1 won't have changed --
* base types matched, and at least one of the operands of the 2
* binops is still a vector if any of them were.
*/
update_type(ir2);
this->progress = true;
}
/**
* Reassociates a constant down a tree of adds or multiplies.
*
* Consider (2 * (a * (b * 0.5))). We want to send up with a * b.
*/
bool
ir_algebraic_visitor::reassociate_constant(ir_expression *ir1, int const_index,
ir_constant *constant,
ir_expression *ir2)
{
if (!ir2 || ir1->operation != ir2->operation)
return false;
/* Don't want to even think about matrices. */
if (ir1->operands[0]->type->is_matrix() ||
glsl: fix matrix type check in ir_algebraic Fixes glsl-mat-mul-1.
2010-11-30 13:24:44 -08:00
ir1->operands[1]->type->is_matrix() ||
ir2->operands[0]->type->is_matrix() ||
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
ir2->operands[1]->type->is_matrix())
return false;
ir_constant *ir2_const[2];
ir2_const[0] = ir2->operands[0]->constant_expression_value();
ir2_const[1] = ir2->operands[1]->constant_expression_value();
if (ir2_const[0] && ir2_const[1])
return false;
if (ir2_const[0]) {
reassociate_operands(ir1, const_index, ir2, 1);
return true;
} else if (ir2_const[1]) {
reassociate_operands(ir1, const_index, ir2, 0);
return true;
}
if (reassociate_constant(ir1, const_index, constant,
ir2->operands[0]->as_expression())) {
update_type(ir2);
return true;
}
if (reassociate_constant(ir1, const_index, constant,
ir2->operands[1]->as_expression())) {
update_type(ir2);
return true;
}
return false;
}
glsl: When doing algebraic simplification, make sure the type still matches. When simplifying (vec4(1.0) / (float(x))) to rcp(float(x)), we forgot to produce a vec4, angering ir_validate when starting alien-arena. Fixes: glsl-algebraic-add-zero-2 glsl-algebraic-div-one-2 glsl-algebraic-mul-one-2 glsl-algebraic-sub-zero-3 glsl-algebraic-rcp-sqrt-2
2010-08-17 13:24:50 -07:00
/* When eliminating an expression and just returning one of its operands,
* we may need to swizzle that operand out to a vector if the expression was
* vector type.
*/
ir_rvalue *
ir_algebraic_visitor::swizzle_if_required(ir_expression *expr,
ir_rvalue *operand)
{
if (expr->type->is_vector() && operand->type->is_scalar()) {
return new(mem_ctx) ir_swizzle(operand, 0, 0, 0, 0,
expr->type->vector_elements);
} else
return operand;
}
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
ir_rvalue *
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
ir_algebraic_visitor::handle_expression(ir_expression *ir)
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
{
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
ir_constant *op_const[4] = {NULL, NULL, NULL, NULL};
ir_expression *op_expr[4] = {NULL, NULL, NULL, NULL};
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
unsigned int i;
glsl: Add support for new bit built-ins in ARB_gpu_shader5. v2: Move use of ir_binop_bfm and ir_triop_bfi to a later patch. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 17:45:12 -07:00
assert(ir->get_num_operands() <= 4);
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
for (i = 0; i < ir->get_num_operands(); i++) {
if (ir->operands[i]->type->is_matrix())
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
return ir;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
op_const[i] = ir->operands[i]->constant_expression_value();
op_expr[i] = ir->operands[i]->as_expression();
}
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
if (this->mem_ctx == NULL)
Convert everything from the talloc API to the ralloc API.
2011-01-21 14:32:31 -08:00
this->mem_ctx = ralloc_parent(ir);
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
switch (ir->operation) {
glsl: Optimize ~~x into x. v2: Fix pasteo of an extra abs being inserted (caught by many). Rewrite to drop the silly switch statement. Reviewed-by: Matt Turner <mattst88@gmail.com> (v1)
2014-01-18 10:36:28 -08:00
case ir_unop_bit_not:
if (op_expr[0] && op_expr[0]->operation == ir_unop_bit_not)
return op_expr[0]->operands[0];
break;
glsl: Optimize abs(-expr) and abs(abs(expr)) into abs(expr). Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:44 -07:00
case ir_unop_abs:
if (op_expr[0] == NULL)
break;
switch (op_expr[0]->operation) {
case ir_unop_abs:
case ir_unop_neg:
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
return abs(op_expr[0]->operands[0]);
glsl: Optimize abs(-expr) and abs(abs(expr)) into abs(expr). Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:44 -07:00
default:
break;
}
break;
glsl: Optimize -(-expr) into expr. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:45 -07:00
case ir_unop_neg:
if (op_expr[0] == NULL)
break;
if (op_expr[0]->operation == ir_unop_neg) {
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return op_expr[0]->operands[0];
glsl: Optimize -(-expr) into expr. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:45 -07:00
}
break;
glsl: Optimize log(exp(x)) and exp(log(x)) into x. Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-18 10:47:19 -08:00
case ir_unop_exp:
if (op_expr[0] == NULL)
break;
if (op_expr[0]->operation == ir_unop_log) {
return op_expr[0]->operands[0];
}
break;
case ir_unop_log:
if (op_expr[0] == NULL)
break;
if (op_expr[0]->operation == ir_unop_exp) {
return op_expr[0]->operands[0];
}
break;
case ir_unop_exp2:
if (op_expr[0] == NULL)
break;
if (op_expr[0]->operation == ir_unop_log2) {
return op_expr[0]->operands[0];
}
break;
case ir_unop_log2:
if (op_expr[0] == NULL)
break;
if (op_expr[0]->operation == ir_unop_exp2) {
return op_expr[0]->operands[0];
}
break;
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
case ir_unop_logic_not: {
enum ir_expression_operation new_op = ir_unop_logic_not;
if (op_expr[0] == NULL)
break;
switch (op_expr[0]->operation) {
ir_algebraic: Support other comparisons in ir_unop_logic_not
2010-08-09 10:46:38 -07:00
case ir_binop_less: new_op = ir_binop_gequal; break;
case ir_binop_greater: new_op = ir_binop_lequal; break;
case ir_binop_lequal: new_op = ir_binop_greater; break;
case ir_binop_gequal: new_op = ir_binop_less; break;
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
case ir_binop_equal: new_op = ir_binop_nequal; break;
case ir_binop_nequal: new_op = ir_binop_equal; break;
glsl: introduce ir_binop_all_equal and ir_binop_any_equal, allow vector cmps Currently GLSL IR forbids any vector comparisons, and defines "ir_binop_equal" and "ir_binop_nequal" to compare all elements and give a single bool. This is highly unintuitive and prevents generation of optimal Mesa IR. Hence, first rename "ir_binop_equal" to "ir_binop_all_equal" and "ir_binop_nequal" to "ir_binop_any_nequal". Second, readd "ir_binop_equal" and "ir_binop_nequal" with the same semantics as less, lequal, etc. Third, allow all comparisons to acts on vectors. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-09-08 01:31:39 +02:00
case ir_binop_all_equal: new_op = ir_binop_any_nequal; break;
case ir_binop_any_nequal: new_op = ir_binop_all_equal; break;
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
default:
/* The default case handler is here to silence a warning from GCC.
*/
break;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
if (new_op != ir_unop_logic_not) {
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
return new(mem_ctx) ir_expression(new_op,
ir->type,
op_expr[0]->operands[0],
op_expr[0]->operands[1]);
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
break;
ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement Currently only ir_binop_equal and ir_binop_nequal are supported, but soon all of the relational operators will be added. Making this change now will simplify those commits.
2010-08-09 09:54:47 -07:00
}
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
case ir_binop_add:
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_zero(op_const[0]))
return ir->operands[1];
if (is_vec_zero(op_const[1]))
return ir->operands[0];
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
/* Reassociate addition of constants so that we can do constant
* folding.
*/
if (op_const[0] && !op_const[1])
glsl: Use saved values instead of recomputing them. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:43 -07:00
reassociate_constant(ir, 0, op_const[0], op_expr[1]);
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
if (op_const[1] && !op_const[0])
glsl: Use saved values instead of recomputing them. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:43 -07:00
reassociate_constant(ir, 1, op_const[1], op_expr[0]);
glsl: Optimize open-coded lrp into lrp. total instructions in shared programs: 1498191 -> 1487051 (-0.74%) instructions in affected programs: 669388 -> 658248 (-1.66%) GAINED: 1 LOST: 0 Reviewed-by: Matt Turner <mattst88@gmail.com> Signed-off-by: Jordan Justen <jordan.l.justen@intel.com>
2013-11-04 10:23:24 -08:00
/* Replace (-x + y) * a + x and commutative variations with lrp(x, y, a).
*
* (-x + y) * a + x
* (x * -a) + (y * a) + x
* x + (x * -a) + (y * a)
* x * (1 - a) + y * a
* lrp(x, y, a)
*/
for (int mul_pos = 0; mul_pos < 2; mul_pos++) {
ir_expression *mul = op_expr[mul_pos];
if (!mul || mul->operation != ir_binop_mul)
continue;
/* Multiply found on one of the operands. Now check for an
* inner addition operation.
*/
for (int inner_add_pos = 0; inner_add_pos < 2; inner_add_pos++) {
ir_expression *inner_add =
mul->operands[inner_add_pos]->as_expression();
if (!inner_add || inner_add->operation != ir_binop_add)
continue;
/* Inner addition found on one of the operands. Now check for
* one of the operands of the inner addition to be the negative
* of x_operand.
*/
for (int neg_pos = 0; neg_pos < 2; neg_pos++) {
ir_expression *neg =
inner_add->operands[neg_pos]->as_expression();
if (!neg || neg->operation != ir_unop_neg)
continue;
ir_rvalue *x_operand = ir->operands[1 - mul_pos];
if (!neg->operands[0]->equals(x_operand))
continue;
ir_rvalue *y_operand = inner_add->operands[1 - neg_pos];
ir_rvalue *a_operand = mul->operands[1 - inner_add_pos];
if (x_operand->type != y_operand->type ||
x_operand->type != a_operand->type)
continue;
return lrp(x_operand, y_operand, a_operand);
}
}
}
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
break;
case ir_binop_sub:
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
if (is_vec_zero(op_const[0]))
return neg(ir->operands[1]);
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_zero(op_const[1]))
return ir->operands[0];
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
break;
case ir_binop_mul:
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_one(op_const[0]))
return ir->operands[1];
if (is_vec_one(op_const[1]))
return ir->operands[0];
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_zero(op_const[0]) || is_vec_zero(op_const[1]))
ir_algebraic: Use ir_constant::zero.
2010-07-28 12:20:38 -07:00
return ir_constant::zero(ir, ir->type);
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
if (is_vec_negative_one(op_const[0]))
return neg(ir->operands[1]);
if (is_vec_negative_one(op_const[1]))
return neg(ir->operands[0]);
glsl: Optimize mul(a, -1) into neg(a). Two extra instructions in some heroesofnewerth shaders, but a win for everything else. total instructions in shared programs: 1531352 -> 1530815 (-0.04%) instructions in affected programs: 121898 -> 121361 (-0.44%) Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-10-15 23:42:19 -07:00
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
/* Reassociate multiplication of constants so that we can do
* constant folding.
*/
if (op_const[0] && !op_const[1])
glsl: Use saved values instead of recomputing them. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:43 -07:00
reassociate_constant(ir, 0, op_const[0], op_expr[1]);
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
if (op_const[1] && !op_const[0])
glsl: Use saved values instead of recomputing them. Reviewed-by: Paul Berry <stereotype441@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-16 16:56:43 -07:00
reassociate_constant(ir, 1, op_const[1], op_expr[0]);
glsl2: Make ir_algebraic reassociate add/mul operands for constant folding. It's rather easy to produce two constant multiplies separated by other multiplies while writing a BRDF shader, and non-obvious enough in the resulting codegen that I didn't catch it in my demo code until just recently. Cuts 3 965 instructions from my demo (<1%), and 20 from glsl-fs-raytrace (1.3%).
2010-07-26 23:56:19 -07:00
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
break;
case ir_binop_div:
if (is_vec_one(op_const[0]) && ir->type->base_type == GLSL_TYPE_FLOAT) {
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return new(mem_ctx) ir_expression(ir_unop_rcp,
glsl: When doing algebraic simplification, make sure the type still matches. When simplifying (vec4(1.0) / (float(x))) to rcp(float(x)), we forgot to produce a vec4, angering ir_validate when starting alien-arena. Fixes: glsl-algebraic-add-zero-2 glsl-algebraic-div-one-2 glsl-algebraic-mul-one-2 glsl-algebraic-sub-zero-3 glsl-algebraic-rcp-sqrt-2
2010-08-17 13:24:50 -07:00
ir->operands[1]->type,
glsl: Make ir_algebraic new expressions allocate out of the parent. This could reduce the amount of memory used by a shader tree after optimization, and increases consistency with other passes.
2010-08-17 13:27:44 -07:00
ir->operands[1],
NULL);
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_one(op_const[1]))
return ir->operands[0];
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
break;
glsl: Check for zero vectors in ir_binop_dot Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-04 16:17:12 -04:00
case ir_binop_dot:
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (is_vec_zero(op_const[0]) || is_vec_zero(op_const[1]))
glsl: Check for zero vectors in ir_binop_dot Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-04 16:17:12 -04:00
return ir_constant::zero(mem_ctx, ir->type);
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
glsl: Transform dot product by a basis vector into a swizzle Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-04 21:59:34 -04:00
if (is_vec_basis(op_const[0])) {
unsigned component = 0;
for (unsigned c = 0; c < op_const[0]->type->vector_elements; c++) {
if (op_const[0]->value.f[c] == 1.0)
component = c;
}
return new(mem_ctx) ir_swizzle(ir->operands[1], component, 0, 0, 0, 1);
}
if (is_vec_basis(op_const[1])) {
unsigned component = 0;
for (unsigned c = 0; c < op_const[1]->type->vector_elements; c++) {
if (op_const[1]->value.f[c] == 1.0)
component = c;
}
return new(mem_ctx) ir_swizzle(ir->operands[0], component, 0, 0, 0, 1);
}
glsl: Check for zero vectors in ir_binop_dot Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2012-06-04 16:17:12 -04:00
break;
glsl: Drop no-op shifts involving 0. I noticed this in a shader in Unigine Heaven that was spilling. While it doesn't really reduce register pressure, it shaves a few instructions anyway (7955 -> 7882). v2: Fix turning "0 >> x" into "x" instead of "0" (caught by Erik Faye-Lund). Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-21 17:01:49 -07:00
case ir_binop_rshift:
case ir_binop_lshift:
/* 0 >> x == 0 */
if (is_vec_zero(op_const[0]))
return ir->operands[0];
/* x >> 0 == x */
if (is_vec_zero(op_const[1]))
return ir->operands[0];
break;
glsl2: Perform algebraic simplifications on logical binary operators Reduces glsl-vs-all-01 from 42 Mesa IR instructions (including the END) to 17.
2010-09-01 10:13:21 -07:00
case ir_binop_logic_and:
if (is_vec_one(op_const[0])) {
return ir->operands[1];
} else if (is_vec_one(op_const[1])) {
return ir->operands[0];
} else if (is_vec_zero(op_const[0]) || is_vec_zero(op_const[1])) {
return ir_constant::zero(mem_ctx, ir->type);
glsl: Optimize (not A) and (not B) into not (A or B). No shader-db changes, but seems like a good idea. Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:42:34 -07:00
} else if (op_expr[0] && op_expr[0]->operation == ir_unop_logic_not &&
op_expr[1] && op_expr[1]->operation == ir_unop_logic_not) {
/* De Morgan's Law:
* (not A) and (not B) === not (A or B)
*/
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return logic_not(logic_or(op_expr[0]->operands[0],
glsl: Optimize (not A) and (not B) into not (A or B). No shader-db changes, but seems like a good idea. Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:42:34 -07:00
op_expr[1]->operands[0]));
glsl: Apply the transformation "(a && a) -> a" in opt_algebraic. Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
2013-10-31 09:32:42 -07:00
} else if (ir->operands[0]->equals(ir->operands[1])) {
/* (a && a) == a */
return ir->operands[0];
glsl2: Perform algebraic simplifications on logical binary operators Reduces glsl-vs-all-01 from 42 Mesa IR instructions (including the END) to 17.
2010-09-01 10:13:21 -07:00
}
break;
case ir_binop_logic_xor:
if (is_vec_zero(op_const[0])) {
return ir->operands[1];
} else if (is_vec_zero(op_const[1])) {
return ir->operands[0];
} else if (is_vec_one(op_const[0])) {
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
return logic_not(ir->operands[1]);
glsl2: Perform algebraic simplifications on logical binary operators Reduces glsl-vs-all-01 from 42 Mesa IR instructions (including the END) to 17.
2010-09-01 10:13:21 -07:00
} else if (is_vec_one(op_const[1])) {
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
return logic_not(ir->operands[0]);
glsl: Apply the transformation "(a ^^ a) -> false" in opt_algebraic. Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
2013-11-07 12:10:25 -08:00
} else if (ir->operands[0]->equals(ir->operands[1])) {
/* (a ^^ a) == false */
return ir_constant::zero(mem_ctx, ir->type);
glsl2: Perform algebraic simplifications on logical binary operators Reduces glsl-vs-all-01 from 42 Mesa IR instructions (including the END) to 17.
2010-09-01 10:13:21 -07:00
}
break;
case ir_binop_logic_or:
if (is_vec_zero(op_const[0])) {
return ir->operands[1];
} else if (is_vec_zero(op_const[1])) {
return ir->operands[0];
} else if (is_vec_one(op_const[0]) || is_vec_one(op_const[1])) {
ir_constant_data data;
for (unsigned i = 0; i < 16; i++)
data.b[i] = true;
return new(mem_ctx) ir_constant(ir->type, &data);
glsl: Optimize (not A) or (not B) into not (A and B). A few Serious Sam 3 shaders affected: instructions in affected programs: 4384 -> 4344 (-0.91%) Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:40:16 -07:00
} else if (op_expr[0] && op_expr[0]->operation == ir_unop_logic_not &&
op_expr[1] && op_expr[1]->operation == ir_unop_logic_not) {
/* De Morgan's Law:
* (not A) or (not B) === not (A and B)
*/
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return logic_not(logic_and(op_expr[0]->operands[0],
glsl: Optimize (not A) or (not B) into not (A and B). A few Serious Sam 3 shaders affected: instructions in affected programs: 4384 -> 4344 (-0.91%) Reviewed-by: Eric Anholt <eric@anholt.net>
2013-10-23 16:40:16 -07:00
op_expr[1]->operands[0]));
glsl: Apply the transformation "(a || a) -> a" in opt_algebraic. total instructions in shared programs: 1732385 -> 1732373 (-0.00%) instructions in affected programs: 416 -> 404 (-2.88%) GAINED: 0 LOST: 0 (That's 4 already-short fragment shaders in dota2) Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
2013-10-31 00:10:32 -07:00
} else if (ir->operands[0]->equals(ir->operands[1])) {
/* (a || a) == a */
return ir->operands[0];
glsl2: Perform algebraic simplifications on logical binary operators Reduces glsl-vs-all-01 from 42 Mesa IR instructions (including the END) to 17.
2010-09-01 10:13:21 -07:00
}
break;
glsl: Optimize pow(1.0, X) --> 1.0. Surprisingly, this helps one vertex shader in 3DMMES. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:19:42 -08:00
case ir_binop_pow:
/* 1^x == 1 */
if (is_vec_one(op_const[0]))
return op_const[0];
glsl: Optimize pow(2, x) --> exp2(x). On Haswell, POW takes 24 cycles, while EXP2 only takes 14. Plus, using POW requires putting 2.0 in a register, while EXP2 doesn't. I believe that EXP2 will be faster than POW on basically all GPUs, so it makes sense to optimize it. Looking at the savage2 subset of shader-db: total instructions in shared programs: 113225 -> 113179 (-0.04%) instructions in affected programs: 2139 -> 2093 (-2.15%) instances of 'math pow': 795 -> 749 (-6.14%) instances of 'math exp': 389 -> 435 (11.8%) Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:57:01 -08:00
glsl: Optimize pow(x, 1) -> x. total instructions in shared programs: 1627826 -> 1627754 (-0.00%) instructions in affected programs: 6640 -> 6568 (-1.08%) GAINED: 0 LOST: 0 (HoN and savage2) Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-18 10:57:29 -08:00
/* x^1 == x */
if (is_vec_one(op_const[1]))
return ir->operands[0];
glsl: Optimize pow(2, x) --> exp2(x). On Haswell, POW takes 24 cycles, while EXP2 only takes 14. Plus, using POW requires putting 2.0 in a register, while EXP2 doesn't. I believe that EXP2 will be faster than POW on basically all GPUs, so it makes sense to optimize it. Looking at the savage2 subset of shader-db: total instructions in shared programs: 113225 -> 113179 (-0.04%) instructions in affected programs: 2139 -> 2093 (-2.15%) instances of 'math pow': 795 -> 749 (-6.14%) instances of 'math exp': 389 -> 435 (11.8%) Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:57:01 -08:00
/* pow(2,x) == exp2(x) */
if (is_vec_two(op_const[0]))
return expr(ir_unop_exp2, ir->operands[1]);
glsl: Optimize pow(1.0, X) --> 1.0. Surprisingly, this helps one vertex shader in 3DMMES. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-05 22:19:42 -08:00
break;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
case ir_unop_rcp:
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
if (op_expr[0] && op_expr[0]->operation == ir_unop_rcp)
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
return op_expr[0]->operands[0];
glsl: Apply the transformation "1/rsq(x) == sqrt(x)" in opt_algebraic. The comment was stale, because the lowering in question wasn't happening in lower_instructions.cpp. Presumably if the lowering ever moves there, we can plumb the lowering mask through to opt_algebraic. total instructions in shared programs: 1618696 -> 1616810 (-0.12%) instructions in affected programs: 243018 -> 241132 (-0.78%) GAINED: 0 LOST: 0 Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
2013-11-07 12:15:13 -08:00
/* While ir_to_mesa.cpp will lower sqrt(x) to rcp(rsq(x)), it does so at
* its IR level, so we can always apply this transformation.
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
*/
glsl: Apply the transformation "1/rsq(x) == sqrt(x)" in opt_algebraic. The comment was stale, because the lowering in question wasn't happening in lower_instructions.cpp. Presumably if the lowering ever moves there, we can plumb the lowering mask through to opt_algebraic. total instructions in shared programs: 1618696 -> 1616810 (-0.12%) instructions in affected programs: 243018 -> 241132 (-0.78%) GAINED: 0 LOST: 0 Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
2013-11-07 12:15:13 -08:00
if (op_expr[0] && op_expr[0]->operation == ir_unop_rsq)
return sqrt(op_expr[0]->operands[0]);
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
/* As far as we know, all backends are OK with rsq. */
if (op_expr[0] && op_expr[0]->operation == ir_unop_sqrt) {
glsl: Use ir_builder more in opt_algebraic. While ir_builder is slightly less efficient, we're only increasing the work when there's actual optimization being done, and it's way more readable code. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 15:03:45 -07:00
return rsq(op_expr[0]->operands[0]);
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
break;
glsl: Optimize various cases of fma (aka MAD). Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-18 11:06:16 -08:00
case ir_triop_fma:
/* Operands are op0 * op1 + op2. */
if (is_vec_zero(op_const[0]) || is_vec_zero(op_const[1])) {
return ir->operands[2];
} else if (is_vec_zero(op_const[2])) {
return mul(ir->operands[0], ir->operands[1]);
} else if (is_vec_one(op_const[0])) {
return add(ir->operands[1], ir->operands[2]);
} else if (is_vec_one(op_const[1])) {
return add(ir->operands[0], ir->operands[2]);
}
break;
glsl: Optimize ir_triop_lrp(x, y, a) with a = 0.0f or 1.0f Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-02-15 17:51:46 -08:00
case ir_triop_lrp:
/* Operands are (x, y, a). */
if (is_vec_zero(op_const[2])) {
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return ir->operands[0];
glsl: Optimize ir_triop_lrp(x, y, a) with a = 0.0f or 1.0f Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-02-15 17:51:46 -08:00
} else if (is_vec_one(op_const[2])) {
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
return ir->operands[1];
glsl: Optimize lrp(x, x, coefficient) --> x. total instructions in shared programs: 1627754 -> 1624534 (-0.20%) instructions in affected programs: 45748 -> 42528 (-7.04%) GAINED: 3 LOST: 0 (serious sam, humus domino demo) Reviewed-by: Matt Turner <mattst88@gmail.com>
2014-01-18 11:00:51 -08:00
} else if (ir->operands[0]->equals(ir->operands[1])) {
return ir->operands[0];
glsl: Optimize lrp(0, y, a) into y * a. Helps two programs in shader-db: instructions in affected programs: 254 -> 234 (-7.87%) Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2014-02-24 15:00:44 -08:00
} else if (is_vec_zero(op_const[0])) {
return mul(ir->operands[1], ir->operands[2]);
glsl: Optimize ir_triop_lrp(x, y, a) with a = 0.0f or 1.0f Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
2013-02-15 17:51:46 -08:00
}
break;
glsl: Optimize triop_csel with all-true or all-false. Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-11-01 12:29:12 -07:00
case ir_triop_csel:
if (is_vec_one(op_const[0]))
return ir->operands[1];
if (is_vec_zero(op_const[0]))
return ir->operands[2];
break;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
default:
break;
}
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
return ir;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
void
ir_algebraic_visitor::handle_rvalue(ir_rvalue **rvalue)
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
{
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
if (!*rvalue)
return;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
ir_expression *expr = (*rvalue)->as_expression();
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
if (!expr || expr->operation == ir_quadop_vector)
glsl2: Add a generic visitor class to call back with pointers to each rvalue. I keep copy and pasting this code all over, so consolidate it in one place.
2010-08-13 20:39:24 -07:00
return;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
glsl: Move common code out of opt_algebraic's handle_expression(). Matt and I had each screwed up these common required patterns recently, in ways that wouldn't have been noticed for a long time if not for code review. Just enforce it in the caller so that we don't rely on code review catching these bugs. Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com>
2013-10-24 14:55:50 -07:00
ir_rvalue *new_rvalue = handle_expression(expr);
if (new_rvalue == *rvalue)
return;
/* If the expr used to be some vec OP scalar returning a vector, and the
* optimization gave us back a scalar, we still need to turn it into a
* vector.
*/
*rvalue = swizzle_if_required(expr, new_rvalue);
this->progress = true;
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
}
bool
do_algebraic(exec_list *instructions)
{
ir_algebraic_visitor v;
visit_list_elements(&v, instructions);
return v.progress;
}
Reference in New Issue Copy Permalink