<div dir="ltr"><div class="gmail_quote"><div dir="ltr">On Mon, Oct 22, 2018 at 6:06 PM Ian Romanick <<a href="mailto:idr@freedesktop.org">idr@freedesktop.org</a>> wrote: </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">On 10/22/2018 03:13 PM, Jason Ekstrand wrote: > --- > src/compiler/nir/nir_lower_alu_to_scalar.c | 8 ++-- > src/compiler/nir/nir_opcodes.py | 46 +++++++++++----------- > src/compiler/nir/nir_opcodes_c.py | 8 ++-- > 3 files changed, 31 insertions(+), 31 deletions(-) > > diff --git a/src/compiler/nir/nir_lower_alu_to_scalar.c b/src/compiler/nir/nir_lower_alu_to_scalar.c > index 0be3aba9456..e424dff25c4 100644 > --- a/src/compiler/nir/nir_lower_alu_to_scalar.c > +++ b/src/compiler/nir/nir_lower_alu_to_scalar.c > @@ -197,10 +197,10 @@ lower_alu_instr_scalar(nir_alu_instr *instr, nir_builder *b) > return false; > > LOWER_REDUCTION(nir_op_fdot, nir_op_fmul, nir_op_fadd); > - LOWER_REDUCTION(nir_op_ball_fequal, nir_op_feq, nir_op_iand); > - LOWER_REDUCTION(nir_op_ball_iequal, nir_op_ieq, nir_op_iand); > - LOWER_REDUCTION(nir_op_bany_fnequal, nir_op_fne, nir_op_ior); > - LOWER_REDUCTION(nir_op_bany_inequal, nir_op_ine, nir_op_ior); > + LOWER_REDUCTION(nir_op_b32all_fequal, nir_op_feq32, nir_op_iand); > + LOWER_REDUCTION(nir_op_b32all_iequal, nir_op_ieq32, nir_op_iand); > + LOWER_REDUCTION(nir_op_b32any_fnequal, nir_op_fne32, nir_op_ior); > + LOWER_REDUCTION(nir_op_b32any_inequal, nir_op_ine32, nir_op_ior); > LOWER_REDUCTION(nir_op_fall_equal, nir_op_seq, nir_op_fand); > LOWER_REDUCTION(nir_op_fany_nequal, nir_op_sne, nir_op_for); > > diff --git a/src/compiler/nir/nir_opcodes.py b/src/compiler/nir/nir_opcodes.py > index 4ef4ecc6f22..d349f74ed2a 100644 > --- a/src/compiler/nir/nir_opcodes.py > +++ b/src/compiler/nir/nir_opcodes.py > @@ -89,7 +89,7 @@ class Opcode(object): > # helper variables for strings > tfloat = "float" > tint = "int" > -tbool = "bool32" > +tbool32 = "bool32" > tuint = "uint" > tuint16 = "uint16" > tfloat32 = "float32" > @@ -192,10 +192,10 @@ for src_t in [tint, tuint, tfloat]: > > # We'll hand-code the to/from bool conversion opcodes. Because bool doesn't > # have multiple bit-sizes, we can always infer the size from the other type. > -unop_convert("f2b", tbool, tfloat, "src0 != 0.0") > -unop_convert("i2b", tbool, tint, "src0 != 0") > -unop_convert("b2f", tfloat, tbool, "src0 ? 1.0 : 0.0") > -unop_convert("b2i", tint, tbool, "src0 ? 1 : 0") > +unop_convert("f2b32", tbool32, tfloat, "src0 != 0.0") > +unop_convert("i2b32", tbool32, tint, "src0 != 0") > +unop_convert("b322f", tfloat, tbool32, "src0 ? 1.0 : 0.0") > +unop_convert("b322i", tint, tbool32, "src0 ? 1 : 0") Yeee-uck. b332i is hard to type and hard for my brain to parse. None of the other *2* opcodes have the size on the left side of the 2. The all infer the size from the source operand. I'd really like the sized Boolean types to work like the other sized types. I doubt we'll have have a using for a uint1 type, but I've been thinking about adding a bool8 or bool16 type for some time. There are quite a few cases where we carry Boolean values for a long, long time in some of the very large shaders. Those same shaders also often face register pressure. Being able to store those long lived values in a smaller type could be very helpful. </blockquote><div> </div><div>I was afraid someone was going to say that. :-/ I guess it wouldn't be too difficult to have a pre-patch that reworks b2i and b2f though that is going to touch ALL the drivers. I agree that it'd be the better more consistent thing to do. I'll look into it.</div><div> </div><div>--Jason </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> > > > # Unary floating-point rounding operations. > @@ -405,8 +405,8 @@ def binop_convert(name, out_type, in_type, alg_props, const_expr): > def binop(name, ty, alg_props, const_expr): > binop_convert(name, ty, ty, alg_props, const_expr) > > -def binop_compare(name, ty, alg_props, const_expr): > - binop_convert(name, tbool, ty, alg_props, const_expr) > +def binop_compare32(name, ty, alg_props, const_expr): > + binop_convert(name, tbool32, ty, alg_props, const_expr) > > def binop_horiz(name, out_size, out_type, src1_size, src1_type, src2_size, > src2_type, const_expr): > @@ -488,26 +488,26 @@ binop("frem", tfloat, "", "src0 - src1 * truncf(src0 / src1)") > > # these integer-aware comparisons return a boolean (0 or ~0) > > -binop_compare("flt", tfloat, "", "src0 < src1") > -binop_compare("fge", tfloat, "", "src0 >= src1") > -binop_compare("feq", tfloat, commutative, "src0 == src1") > -binop_compare("fne", tfloat, commutative, "src0 != src1") > -binop_compare("ilt", tint, "", "src0 < src1") > -binop_compare("ige", tint, "", "src0 >= src1") > -binop_compare("ieq", tint, commutative, "src0 == src1") > -binop_compare("ine", tint, commutative, "src0 != src1") > -binop_compare("ult", tuint, "", "src0 < src1") > -binop_compare("uge", tuint, "", "src0 >= src1") > +binop_compare32("flt32", tfloat, "", "src0 < src1") > +binop_compare32("fge32", tfloat, "", "src0 >= src1") > +binop_compare32("feq32", tfloat, commutative, "src0 == src1") > +binop_compare32("fne32", tfloat, commutative, "src0 != src1") > +binop_compare32("ilt32", tint, "", "src0 < src1") > +binop_compare32("ige32", tint, "", "src0 >= src1") > +binop_compare32("ieq32", tint, commutative, "src0 == src1") > +binop_compare32("ine32", tint, commutative, "src0 != src1") > +binop_compare32("ult32", tuint, "", "src0 < src1") > +binop_compare32("uge32", tuint, "", "src0 >= src1") > > # integer-aware GLSL-style comparisons that compare floats and ints > > -binop_reduce("ball_fequal", 1, tbool, tfloat, "{src0} == {src1}", > +binop_reduce("b32all_fequal", 1, tbool32, tfloat, "{src0} == {src1}", > "{src0} && {src1}", "{src}") > -binop_reduce("bany_fnequal", 1, tbool, tfloat, "{src0} != {src1}", > +binop_reduce("b32any_fnequal", 1, tbool32, tfloat, "{src0} != {src1}", > "{src0} || {src1}", "{src}") > -binop_reduce("ball_iequal", 1, tbool, tint, "{src0} == {src1}", > +binop_reduce("b32all_iequal", 1, tbool32, tint, "{src0} == {src1}", > "{src0} && {src1}", "{src}") > -binop_reduce("bany_inequal", 1, tbool, tint, "{src0} != {src1}", > +binop_reduce("b32any_inequal", 1, tbool32, tint, "{src0} != {src1}", > "{src0} || {src1}", "{src}") > > # non-integer-aware GLSL-style comparisons that return 0.0 or 1.0 > @@ -694,8 +694,8 @@ triop("fmed3", tfloat, "fmaxf(fminf(fmaxf(src0, src1), src2), fminf(src0, src1)) > triop("imed3", tint, "MAX2(MIN2(MAX2(src0, src1), src2), MIN2(src0, src1))") > triop("umed3", tuint, "MAX2(MIN2(MAX2(src0, src1), src2), MIN2(src0, src1))") > > -opcode("bcsel", 0, tuint, [0, 0, 0], > - [tbool, tuint, tuint], "", "src0 ? src1 : src2") > +opcode("b32csel", 0, tuint, [0, 0, 0], > + [tbool32, tuint, tuint], "", "src0 ? src1 : src2") > > # SM5 bfi assembly > triop("bfi", tuint32, """ > diff --git a/src/compiler/nir/nir_opcodes_c.py b/src/compiler/nir/nir_opcodes_c.py > index 8bfcda6d719..fe3fcd4c677 100644 > --- a/src/compiler/nir/nir_opcodes_c.py > +++ b/src/compiler/nir/nir_opcodes_c.py > @@ -92,9 +92,9 @@ nir_type_conversion_op(nir_alu_type src, nir_alu_type dst, nir_rounding_mode rnd > % endfor > case nir_type_bool: > % if src_t == 'float': > - return nir_op_f2b; > + return nir_op_f2b32; > % else: > - return nir_op_i2b; > + return nir_op_i2b32; > % endif > default: > unreachable("Invalid nir alu base type"); > @@ -104,9 +104,9 @@ nir_type_conversion_op(nir_alu_type src, nir_alu_type dst, nir_rounding_mode rnd > switch (dst_base) { > case nir_type_int: > case nir_type_uint: > - return nir_op_b2i; > + return nir_op_b322i; > case nir_type_float: > - return nir_op_b2f; > + return nir_op_b322f; > default: > unreachable("Invalid nir alu base type"); > } > </blockquote></div></div>