[Mesa-dev] [PATCH 62/95] i965/vec4: Add a shuffle_64bit_data helper
Francisco Jerez
currojerez at riseup.net
Mon Sep 12 21:19:16 UTC 2016
Iago Toral Quiroga <itoral at igalia.com> writes:
> SIMD4x2 64bit data is stored in register space like this:
>
> r0.0:DF x0 y0 z0 w0
> r0.1:DF x1 y1 z1 w1
>
> When we need to write data such as this to memory using 32-bit write
> messages we need to shuffle it in this fashion:
>
> r0.0:DF x0 y0 x1 y1
> r0.1:DF z0 w0 z1 w1
>
> and emit two 32-bit write messages, one for r0.0 at base_offset
> and another one for r0.1 at base_offset+16.
>
> We also need to do the inverse operation when we read using 32-bit messages
> to produce valid SIMD4x2 64bit data from the data read. We can achieve this
> by aplying the exact same shuffling to the data read, although we need to
> apply different channel enables since the layout of the data is reversed.
>
> This helper implements the data shuffling logic and we will use it in
> various places where we read and write 64bit data from/to memory.
> ---
> src/mesa/drivers/dri/i965/brw_vec4.h | 5 ++
> src/mesa/drivers/dri/i965/brw_vec4_nir.cpp | 96 ++++++++++++++++++++++++++++++
> 2 files changed, 101 insertions(+)
>
> diff --git a/src/mesa/drivers/dri/i965/brw_vec4.h b/src/mesa/drivers/dri/i965/brw_vec4.h
> index 26228d0..3337fc0 100644
> --- a/src/mesa/drivers/dri/i965/brw_vec4.h
> +++ b/src/mesa/drivers/dri/i965/brw_vec4.h
> @@ -327,6 +327,11 @@ public:
>
> src_reg setup_imm_df(double v);
>
> + vec4_instruction *shuffle_64bit_data(dst_reg dst, src_reg src,
> + bool for_write,
> + bblock_t *block = NULL,
> + vec4_instruction *ref = NULL);
> +
> virtual void emit_nir_code();
> virtual void nir_setup_uniforms();
> virtual void nir_setup_system_value_intrinsic(nir_intrinsic_instr *instr);
> diff --git a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> index 450db92..346e822 100644
> --- a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> +++ b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
> @@ -2145,4 +2145,100 @@ vec4_visitor::nir_emit_undef(nir_ssa_undef_instr *instr)
> dst_reg(VGRF, alloc.allocate(instr->def.bit_size / 32));
> }
>
> +/* SIMD4x2 64bit data is stored in register space like this:
> + *
> + * r0.0:DF x0 y0 z0 w0
> + * r0.1:DF x1 y1 z1 w1
> + *
> + * When we need to write data such as this to memory using 32-bit write
> + * messages we need to shuffle it in this fashion:
> + *
> + * r0.0:DF x0 y0 x1 y1 (to be written at base offset)
> + * r0.0:DF z0 w0 z1 w1 (to be written at base offset + 16)
> + *
> + * We need to do the inverse operation when we read using 32-bit messages,
> + * which we can do by applying the same exact shuffling on the 64-bit data
> + * read, only that because the data for each vertex is positioned differently
> + * we need to apply different channel enables.
> + *
> + * This function takes 64bit data and shuffles it as explained above.
> + *
> + * The @for_write parameter is used to specify if the shuffling is being done
> + * for proper SIMD4x2 64-bit data that needs to be shuffled prior to a 32-bit
> + * write message (for_write = true), or instead we are doing the inverse
> + * opperation and we have just read 64-bit data using a 32-bit messages that we
> + * need to shuffle to create valid SIMD4x2 64-bit data (for_write = false).
> + *
> + * If @block and @ref are non-NULL, then the shuffling is done after @ref,
> + * otherwise the instructions are emitted normally at the end. The function
> + * returns the last instruction inserted.
> + *
> + * Notice that @src and @dst cannot be the same register.
> + */
> +vec4_instruction *
> +vec4_visitor::shuffle_64bit_data(dst_reg dst, src_reg src, bool for_write,
> + bblock_t *block, vec4_instruction *ref)
> +{
> + assert(type_sz(src.type) == 8);
> + assert(type_sz(dst.type) == 8);
> + assert(!src.in_range(dst, 2));
> + assert(dst.writemask == WRITEMASK_XYZW);
> + assert(!ref == !block);
> +
> + vec4_instruction *inst, *last;
> + bool emit_before = ref != NULL;
> +
> + #define EMIT(i) \
> + if (!emit_before) { \
> + emit(i); \
> + } else { \
> + ref->insert_after(block, i); \
> + ref = i; \
> + } \
> + last = i;
> +
> + /* Resolve swizzle in src */
> + if (src.swizzle != BRW_SWIZZLE_XYZW) {
> + dst_reg data = dst_reg(this, glsl_type::dvec4_type);
> + inst = MOV(data, src);
> + EMIT(inst);
> + src = src_reg(data);
> + }
> +
> + /* dst+0.XY = src+0.XY */
> + dst.writemask = WRITEMASK_XY;
> + inst = MOV(dst, src);
> + inst->regs_written = 1;
> + inst->exec_size = 4;
> + EMIT(inst);
> +
> + /* dst+0.ZW = src+1.XY */
> + dst.writemask = WRITEMASK_ZW;
> + inst = MOV(dst, swizzle(offset(src, 1), BRW_SWIZZLE_XYXY));
> + inst->regs_written = 1;
> + inst->exec_size = 4;
> + inst->group = for_write ? 4 : 0;
> + EMIT(inst);
> +
> + /* dst+1.XY = src+0.ZW */
> + dst.writemask = WRITEMASK_XY;
> + inst = MOV(offset(dst, 1), swizzle(src, BRW_SWIZZLE_ZWZW));
> + inst->regs_written = 1;
> + inst->exec_size = 4;
> + inst->group = for_write ? 0 : 4;
> + EMIT(inst);
> +
> + /* dst+1.ZW = src+1.ZW */
> + dst.writemask = WRITEMASK_ZW;
> + inst = MOV(offset(dst, 1), offset(src, 1));
> + inst->regs_written = 1;
> + inst->exec_size = 4;
> + inst->group = 4;
> + EMIT(inst);
> +
> + #undef EMIT
> +
> + return last;
> +}
> +
This would be a *lot* simpler if you used and took as argument a VEC4
builder instead of constructing the IR manually (and if you used the
writemask() helper). It might need some small fixes for the VEC4
builder to initialize the new group and exec_size fields correctly but
it seems worth doing just because of this function alone.
> }
> --
> 2.7.4
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 212 bytes
Desc: not available
URL: <https://lists.freedesktop.org/archives/mesa-dev/attachments/20160912/90ba3849/attachment-0001.sig>
More information about the mesa-dev
mailing list