<div dir="ltr"> <div class="gmail_extra"> <div class="gmail_quote">On Mon, Jan 5, 2015 at 10:24 PM, Connor Abbott <<a href="mailto:cwabbott0@gmail.com" target="_blank">cwabbott0@gmail.com</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On Tue, Dec 16, 2014 at 1:12 AM, Jason Ekstrand <<a href="mailto:jason@jlekstrand.net">jason@jlekstrand.net</a>> wrote: > --- > src/glsl/Makefile.sources | 1 + > src/glsl/nir/nir.h | 1 + > src/glsl/nir/nir_opt_constant_folding.c | 283 +++++++++++++++++++++++++++++++ > src/mesa/drivers/dri/i965/brw_fs_nir.cpp | 2 + > 4 files changed, 287 insertions(+) > create mode 100644 src/glsl/nir/nir_opt_constant_folding.c > > diff --git a/src/glsl/Makefile.sources b/src/glsl/Makefile.sources > index d243f12..7fd650b 100644 > --- a/src/glsl/Makefile.sources > +++ b/src/glsl/Makefile.sources > @@ -36,6 +36,7 @@ NIR_FILES = \ > $(GLSL_SRCDIR)/nir/nir_metadata.c \ > $(GLSL_SRCDIR)/nir/nir_opcodes.c \ > $(GLSL_SRCDIR)/nir/nir_opcodes.h \ > + $(GLSL_SRCDIR)/nir/nir_opt_constant_folding.c \ > $(GLSL_SRCDIR)/nir/nir_opt_copy_propagate.c \ > $(GLSL_SRCDIR)/nir/nir_opt_cse.c \ > $(GLSL_SRCDIR)/nir/nir_opt_dce.c \ > diff --git a/src/glsl/nir/nir.h b/src/glsl/nir/nir.h > index 630e841..46f069f 100644 > --- a/src/glsl/nir/nir.h > +++ b/src/glsl/nir/nir.h > @@ -1403,6 +1403,7 @@ void nir_convert_to_ssa(nir_shader *shader); > void nir_convert_from_ssa(nir_shader *shader); > > bool nir_opt_algebraic(nir_shader *shader); > +bool nir_opt_constant_folding(nir_shader *shader); > > bool nir_opt_global_to_local(nir_shader *shader); > > diff --git a/src/glsl/nir/nir_opt_constant_folding.c b/src/glsl/nir/nir_opt_constant_folding.c > new file mode 100644 > index 0000000..3523713 > --- /dev/null > +++ b/src/glsl/nir/nir_opt_constant_folding.c > @@ -0,0 +1,283 @@ > +/* > + * Copyright © 2014 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. > + * > + * Authors: > + * Jason Ekstrand (<a href="mailto:jason@jlekstrand.net">jason@jlekstrand.net</a>) > + * > + */ > + > +#include "nir.h" > +#include <math.h> > + > +/* > + * Implements SSA-based constant folding. > + */ > + > +struct constant_fold_state { > + void *mem_ctx; > + nir_function_impl *impl; > + bool progress; > +}; > + > +#define SRC_COMP(T, IDX, CMP) src[IDX]->value.T[instr->src[IDX].swizzle[CMP]] > +#define SRC(T, IDX) SRC_COMP(T, IDX, i) > +#define DEST_COMP(T, CMP) dest->value.T[CMP] > +#define DEST(T) DEST_COMP(T, i) > + > +#define FOLD_PER_COMP(EXPR) \ > + for (unsigned i = 0; i < instr->dest.dest.ssa.num_components; i++) { \ > + EXPR; \ > + } \ > + > +static bool > +constant_fold_alu_instr(nir_alu_instr *instr, void *void_state) > +{ > + struct constant_fold_state *state = void_state; > + nir_load_const_instr *src[4], *dest; > + > + if (!instr->dest.dest.is_ssa) > + return false; > + > + for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) { > + if (!instr->src[i].src.is_ssa) > + return false; > + > + if (instr->src[i].src.ssa->parent_instr->type != nir_instr_type_load_const) > + return false; > + > + src[i] = nir_instr_as_load_const(instr->src[i].src.ssa->parent_instr); > + } > + > + dest = nir_load_const_instr_create(state->mem_ctx); > + dest->array_elems = 0; > + dest->num_components = instr->dest.dest.ssa.num_components; > + > + switch (instr->op) { > + case nir_op_ineg: > + FOLD_PER_COMP(DEST(i) = -SRC(i, 0)); > + break; > + case nir_op_fneg: > + FOLD_PER_COMP(DEST(f) = -SRC(f, 0)); > + break; > + case nir_op_inot: > + FOLD_PER_COMP(DEST(i) = ~SRC(i, 0)); > + break; > + case nir_op_fnot: > + FOLD_PER_COMP(DEST(f) = (SRC(f, 0) == 0.0f) ? 1.0f : 0.0f); > + break; > + case nir_op_frcp: > + FOLD_PER_COMP(DEST(f) = 1.0f / SRC(f, 0)); > + break; > + case nir_op_frsq: > + FOLD_PER_COMP(DEST(f) = 1.0f / sqrt(SRC(f, 0))); > + break; > + case nir_op_fsqrt: > + FOLD_PER_COMP(DEST(f) = sqrtf(SRC(f, 0))); > + break; > + case nir_op_fexp: > + FOLD_PER_COMP(DEST(f) = expf(SRC(f, 0))); > + break; > + case nir_op_flog: > + FOLD_PER_COMP(DEST(f) = logf(SRC(f, 0))); > + break; > + case nir_op_fexp2: > + FOLD_PER_COMP(DEST(f) = exp2f(SRC(f, 0))); > + break; > + case nir_op_flog2: > + FOLD_PER_COMP(DEST(f) = log2f(SRC(f, 0))); > + break; > + case nir_op_f2i: > + FOLD_PER_COMP(DEST(i) = SRC(f, 0)); > + break; > + case nir_op_f2u: > + FOLD_PER_COMP(DEST(u) = SRC(f, 0)); > + break; > + case nir_op_i2f: > + FOLD_PER_COMP(DEST(f) = SRC(i, 0)); > + break; > + case nir_op_f2b: > + FOLD_PER_COMP(DEST(u) = (SRC(i, 0) == 0.0f) ? NIR_FALSE : NIR_TRUE); > + break; > + case nir_op_b2f: > + FOLD_PER_COMP(DEST(f) = SRC(u, 0) ? 1.0f : 0.0f); > + break; > + case nir_op_i2b: > + FOLD_PER_COMP(DEST(u) = SRC(i, 0) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_u2f: > + FOLD_PER_COMP(DEST(f) = SRC(u, 0)); > + break; > + case nir_op_bany2: > + DEST_COMP(u, 0) = (SRC_COMP(u, 0, 0) || SRC_COMP(u, 0, 1)) ? > + NIR_TRUE : NIR_FALSE; > + break; > + case nir_op_fadd: > + FOLD_PER_COMP(DEST(f) = SRC(f, 0) + SRC(f, 1)); > + break; > + case nir_op_iadd: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) + SRC(i, 1)); > + break; > + case nir_op_fsub: > + FOLD_PER_COMP(DEST(f) = SRC(f, 0) - SRC(f, 1)); > + break; > + case nir_op_isub: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) - SRC(i, 1)); > + break; > + case nir_op_fmul: > + FOLD_PER_COMP(DEST(f) = SRC(f, 0) * SRC(f, 1)); > + break; > + case nir_op_imul: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) * SRC(i, 1)); > + break; > + case nir_op_fdiv: > + FOLD_PER_COMP(DEST(f) = SRC(f, 0) / SRC(f, 1)); > + break; > + case nir_op_idiv: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) / SRC(i, 1)); > + break; > + case nir_op_udiv: > + FOLD_PER_COMP(DEST(u) = SRC(u, 0) / SRC(u, 1)); > + break; > + case nir_op_flt: > + FOLD_PER_COMP(DEST(u) = (SRC(f, 0) < SRC(f, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_fge: > + FOLD_PER_COMP(DEST(u) = (SRC(f, 0) >= SRC(f, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_feq: > + FOLD_PER_COMP(DEST(u) = (SRC(f, 0) == SRC(f, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_fne: > + FOLD_PER_COMP(DEST(u) = (SRC(f, 0) != SRC(f, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ilt: > + FOLD_PER_COMP(DEST(u) = (SRC(i, 0) < SRC(i, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ige: > + FOLD_PER_COMP(DEST(u) = (SRC(i, 0) >= SRC(i, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ieq: > + FOLD_PER_COMP(DEST(u) = (SRC(i, 0) == SRC(i, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ine: > + FOLD_PER_COMP(DEST(u) = (SRC(i, 0) != SRC(i, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ult: > + FOLD_PER_COMP(DEST(u) = (SRC(u, 0) < SRC(u, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_uge: > + FOLD_PER_COMP(DEST(u) = (SRC(u, 0) >= SRC(u, 1)) ? NIR_TRUE : NIR_FALSE); > + break; > + case nir_op_ishl: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) << SRC(i, 1)); > + break; > + case nir_op_ishr: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) >> SRC(i, 1)); > + break; > + case nir_op_ushr: > + FOLD_PER_COMP(DEST(u) = SRC(u, 0) >> SRC(u, 1)); > + break; > + case nir_op_iand: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) & SRC(i, 1)); > + break; > + case nir_op_ior: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) | SRC(i, 1)); > + break; > + case nir_op_ixor: > + FOLD_PER_COMP(DEST(i) = SRC(i, 0) ^ SRC(i, 1)); > + break; > + default: > + ralloc_free(dest); > + return false; > + } > + > + if (instr->dest.saturate) { > + assert(nir_op_infos[instr->op].output_type == nir_type_float); > + for (int i = 0; i < 4; ++i) { > + if (dest->value.f[i] > 1.0f) > + dest->value.f[i] = 1.0f; > + else if (dest->value.f[i] < 0.0f) > + dest->value.f[i] = 0.0f; > + } > + } </div></div>I think this is just dead code... we don't even handle abs and negate. </blockquote><div> </div><div>Yeah, it probably is. We could add abs and negate, but meh. I'll just add asserts. </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <div><div class="h5"> > + > + dest->dest.is_ssa = true; > + nir_ssa_def_init(&dest->instr, &dest->dest.ssa, > + instr->dest.dest.ssa.num_components, > + instr-><a href="http://dest.dest.ssa.name" target="_blank">dest.dest.ssa.name</a>); > + > + nir_instr_insert_before(&instr->instr, &dest->instr); > + > + nir_src new_src = { > + .is_ssa = true, > + .ssa = &dest->dest.ssa, > + }; > + > + nir_ssa_def_rewrite_uses(&instr->dest.dest.ssa, new_src, state->mem_ctx); > + > + nir_instr_remove(&instr->instr); > + ralloc_free(instr); > + > + return true; > +} > + > +static bool > +constant_fold_block(nir_block *block, void *void_state) > +{ > + struct constant_fold_state *state = void_state; > + > + nir_foreach_instr_safe(block, instr) { > + if (instr->type != nir_instr_type_alu) > + continue; > + > + state->progress |= constant_fold_alu_instr(nir_instr_as_alu(instr), state); > + } > + > + return true; > +} > + > +static bool > +nir_opt_constant_folding_impl(nir_function_impl *impl) > +{ > + struct constant_fold_state state; > + > + state.mem_ctx = ralloc_parent(impl); > + state.impl = impl; > + state.progress = false; > + > + nir_foreach_block(impl, constant_fold_block, &state); > + > + return state.progress; > +} > + > +bool > +nir_opt_constant_folding(nir_shader *shader) > +{ > + bool progress = false; > + > + nir_foreach_overload(shader, overload) { > + if (overload->impl) > + progress |= nir_opt_constant_folding_impl(overload->impl); > + } > + > + return progress; > +} > diff --git a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp > index 039dd4d..f719c86 100644 > --- a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp > +++ b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp > @@ -55,6 +55,8 @@ fs_visitor::emit_nir_code() > nir_validate_shader(nir); > progress |= nir_opt_algebraic(nir); > nir_validate_shader(nir); > + progress |= nir_opt_constant_folding(nir); > + nir_validate_shader(nir); > } while (progress); > > /* Lower a bunch of stuff */ > -- > 2.2.0 > </div></div>> _______________________________________________ > mesa-dev mailing list > <a href="mailto:mesa-dev@lists.freedesktop.org">mesa-dev@lists.freedesktop.org</a> > <a href="http://lists.freedesktop.org/mailman/listinfo/mesa-dev" target="_blank">http://lists.freedesktop.org/mailman/listinfo/mesa-dev</a> </blockquote></div> </div></div>