[Mesa-dev] [PATCH 15/31] nir: Rename boolean-related opcodes to include 32 in the name
Ian Romanick
idr at freedesktop.org
Mon Oct 22 23:06:08 UTC 2018
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.
>
>
> # 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");
> }
>
More information about the mesa-dev
mailing list