From: Rob Clark Date: Sat, 7 May 2016 17:01:24 +0000 (-0400) Subject: nir/algebraic: support for power-of-two optimizations X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=dfbae7d64f4d563bc65af338cdcb217f10474c1c;p=mesa.git nir/algebraic: support for power-of-two optimizations Some optimizations, like converting integer multiply/divide into left/ right shifts, have additional constraints on the search expression. Like requiring that a variable is a constant power of two. Support these cases by allowing a fxn name to be appended to the search var expression (ie. "a#32(is_power_of_two)"). Signed-off-by: Rob Clark Reviewed-by: Kenneth Graunke Reviewed-by: Jason Ekstrand --- diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h index 20f65201890..3f9309c04dd 100644 --- a/src/compiler/nir/nir.h +++ b/src/compiler/nir/nir.h @@ -1651,6 +1651,9 @@ typedef struct nir_shader_compiler_options { /* lower {slt,sge,seq,sne} to {flt,fge,feq,fne} + b2f: */ bool lower_scmp; + /** enables rules to lower idiv by power-of-two: */ + bool lower_idiv; + /* Does the native fdot instruction replicate its result for four * components? If so, then opt_algebraic_late will turn all fdotN * instructions into fdot_replicatedN instructions. diff --git a/src/compiler/nir/nir_algebraic.py b/src/compiler/nir/nir_algebraic.py index 285f8534846..19ac6ee2ba4 100644 --- a/src/compiler/nir/nir_algebraic.py +++ b/src/compiler/nir/nir_algebraic.py @@ -76,6 +76,7 @@ class Value(object): return Constant(val, name_base) __template = mako.template.Template(""" +#include "compiler/nir/nir_search_helpers.h" static const ${val.c_type} ${val.name} = { { ${val.type_enum}, ${val.bit_size} }, % if isinstance(val, Constant): @@ -84,6 +85,7 @@ static const ${val.c_type} ${val.name} = { ${val.index}, /* ${val.var_name} */ ${'true' if val.is_constant else 'false'}, ${val.type() or 'nir_type_invalid' }, + ${val.cond if val.cond else 'NULL'}, % elif isinstance(val, Expression): ${'true' if val.inexact else 'false'}, nir_op_${val.opcode}, @@ -113,7 +115,7 @@ static const ${val.c_type} ${val.name} = { Variable=Variable, Expression=Expression) -_constant_re = re.compile(r"(?P[^@]+)(?:@(?P\d+))?") +_constant_re = re.compile(r"(?P[^@\(]+)(?:@(?P\d+))?") class Constant(Value): def __init__(self, val, name): @@ -150,7 +152,8 @@ class Constant(Value): return "nir_type_float" _var_name_re = re.compile(r"(?P#)?(?P\w+)" - r"(?:@(?Pint|uint|bool|float)?(?P\d+)?)?") + r"(?:@(?Pint|uint|bool|float)?(?P\d+)?)?" + r"(?P\([^\)]+\))?") class Variable(Value): def __init__(self, val, name, varset): @@ -161,6 +164,7 @@ class Variable(Value): self.var_name = m.group('name') self.is_constant = m.group('const') is not None + self.cond = m.group('cond') self.required_type = m.group('type') self.bit_size = int(m.group('bits')) if m.group('bits') else 0 diff --git a/src/compiler/nir/nir_opt_algebraic.py b/src/compiler/nir/nir_opt_algebraic.py index f8db2b690ac..011263a14d7 100644 --- a/src/compiler/nir/nir_opt_algebraic.py +++ b/src/compiler/nir/nir_opt_algebraic.py @@ -45,10 +45,11 @@ d = 'd' # however, be used for backend-requested lowering operations as those need to # happen regardless of precision. # -# Variable names are specified as "[#]name[@type]" where "#" inicates that -# the given variable will only match constants and the type indicates that +# Variable names are specified as "[#]name[@type][(cond)]" where "#" inicates +# that the given variable will only match constants and the type indicates that # the given variable will only match values from ALU instructions with the -# given output type. +# given output type, and (cond) specifies an additional condition function +# (see nir_search_helpers.h). # # For constants, you have to be careful to make sure that it is the right # type because python is unaware of the source and destination types of the @@ -62,6 +63,14 @@ d = 'd' # constructed value should have that bit-size. optimizations = [ + + (('imul', a, '#b@32(is_pos_power_of_two)'), ('ishl', a, ('find_lsb', b))), + (('imul', a, '#b@32(is_neg_power_of_two)'), ('ineg', ('ishl', a, ('find_lsb', ('iabs', b))))), + (('udiv', a, '#b@32(is_pos_power_of_two)'), ('ushr', a, ('find_lsb', b))), + (('idiv', a, '#b@32(is_pos_power_of_two)'), ('imul', ('isign', a), ('ushr', ('iabs', a), ('find_lsb', b))), 'options->lower_idiv'), + (('idiv', a, '#b@32(is_neg_power_of_two)'), ('ineg', ('imul', ('isign', a), ('ushr', ('iabs', a), ('find_lsb', ('iabs', b))))), 'options->lower_idiv'), + (('umod', a, '#b(is_pos_power_of_two)'), ('iand', a, ('isub', b, 1))), + (('fneg', ('fneg', a)), a), (('ineg', ('ineg', a)), a), (('fabs', ('fabs', a)), ('fabs', a)), diff --git a/src/compiler/nir/nir_search.c b/src/compiler/nir/nir_search.c index 2c2fd9208c2..b21fb2c979e 100644 --- a/src/compiler/nir/nir_search.c +++ b/src/compiler/nir/nir_search.c @@ -127,6 +127,9 @@ match_value(const nir_search_value *value, nir_alu_instr *instr, unsigned src, instr->src[src].src.ssa->parent_instr->type != nir_instr_type_load_const) return false; + if (var->cond && !var->cond(instr, src, num_components, new_swizzle)) + return false; + if (var->type != nir_type_invalid) { if (instr->src[src].src.ssa->parent_instr->type != nir_instr_type_alu) return false; diff --git a/src/compiler/nir/nir_search.h b/src/compiler/nir/nir_search.h index a500febc915..f55d797e05e 100644 --- a/src/compiler/nir/nir_search.h +++ b/src/compiler/nir/nir_search.h @@ -68,6 +68,16 @@ typedef struct { * never match anything. */ nir_alu_type type; + + /** Optional condition fxn ptr + * + * This is only allowed in search expressions, and allows additional + * constraints to be placed on the match. Typically used for 'is_constant' + * variables to require, for example, power-of-two in order for the search + * to match. + */ + bool (*cond)(nir_alu_instr *instr, unsigned src, + unsigned num_components, const uint8_t *swizzle); } nir_search_variable; typedef struct { diff --git a/src/compiler/nir/nir_search_helpers.h b/src/compiler/nir/nir_search_helpers.h new file mode 100644 index 00000000000..50379441265 --- /dev/null +++ b/src/compiler/nir/nir_search_helpers.h @@ -0,0 +1,94 @@ +/* + * Copyright © 2016 Red Hat + * + * 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. + * + * Authors: + * Rob Clark + */ + +#ifndef _NIR_SEARCH_HELPERS_ +#define _NIR_SEARCH_HELPERS_ + +#include "nir.h" + +static inline bool +__is_power_of_two(unsigned int x) +{ + return ((x != 0) && !(x & (x - 1))); +} + +static inline bool +is_pos_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components, + const uint8_t *swizzle) +{ + nir_const_value *val = nir_src_as_const_value(instr->src[src].src); + + /* only constant src's: */ + if (!val) + return false; + + for (unsigned i = 0; i < num_components; i++) { + switch (nir_op_infos[instr->op].input_types[src]) { + case nir_type_int: + if (val->i32[swizzle[i]] < 0) + return false; + if (!__is_power_of_two(val->i32[swizzle[i]])) + return false; + break; + case nir_type_uint: + if (!__is_power_of_two(val->u32[swizzle[i]])) + return false; + break; + default: + return false; + } + } + + return true; +} + +static inline bool +is_neg_power_of_two(nir_alu_instr *instr, unsigned src, unsigned num_components, + const uint8_t *swizzle) +{ + nir_const_value *val = nir_src_as_const_value(instr->src[src].src); + + /* only constant src's: */ + if (!val) + return false; + + for (unsigned i = 0; i < num_components; i++) { + switch (nir_op_infos[instr->op].input_types[src]) { + case nir_type_int: + if (val->i32[swizzle[i]] > 0) + return false; + if (!__is_power_of_two(abs(val->i32[swizzle[i]]))) + return false; + break; + default: + return false; + } + } + + return true; +} + +#endif /* _NIR_SEARCH_ */