[prev in list] [next in list] [prev in thread] [next in thread]
List: wine-devel
Subject: Re: [PATCH vkd3d 1/3] vkd3d: Deal correctly with SM 5.1 register spaces.
From: Zebediah Figura <zfigura () codeweavers ! com>
Date: 2020-02-28 17:07:23
Message-ID: 5a9ac63a-4f4c-1199-0630-720829513bce () codeweavers ! com
[Download RAW message or body]
I'm not particularly qualified to review this code, but from suggestions
from the vkd3d maintainer, and a few observations of my own...
On 2/20/20 5:18 AM, Hans-Kristian Arntzen wrote:
> Resource index is found in idx[0] in SM 5.0, but idx[1] when using SM
> 5.1, and register space is encoded reparately. An rb_tree keeps track of
> the internal resource index idx[0] and can map that to space/binding as
> required when emitting SPIR-V.
>
> For this to work, we must also make UAV counters register space aware.
> In earlier implementation, UAV counter mask was assumed to correlate 1:1
> with register_index, which breaks on SM 5.1.
Perhaps this should be broken out into a separate patch, then? If
there's a reason why that doesn't make sense, could that be more clearly
communicated?
Maybe the difference in resource index (i.e. [0] vs [1]) could also be
broken out into a separate patch.
>
> Signed-off-by: Hans-Kristian Arntzen <post@arntzen-software.no>
> ---
> include/vkd3d_shader.h | 16 ++
> libs/vkd3d-shader/dxbc.c | 29 ++++
> libs/vkd3d-shader/spirv.c | 194 ++++++++++++++++++++---
> libs/vkd3d-shader/vkd3d_shader_private.h | 5 +
> libs/vkd3d/command.c | 32 ++--
> libs/vkd3d/state.c | 65 +++++---
> libs/vkd3d/vkd3d_private.h | 1 +
> 7 files changed, 288 insertions(+), 54 deletions(-)
>
> diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h
> index 6b4d3f5..ec52e26 100644
> --- a/include/vkd3d_shader.h
> +++ b/include/vkd3d_shader.h
> @@ -35,6 +35,7 @@ enum vkd3d_shader_structure_type
> VKD3D_SHADER_STRUCTURE_TYPE_SCAN_INFO,
> VKD3D_SHADER_STRUCTURE_TYPE_TRANSFORM_FEEDBACK_INFO,
> VKD3D_SHADER_STRUCTURE_TYPE_DOMAIN_SHADER_COMPILE_ARGUMENTS,
> + VKD3D_SHADER_STRUCTURE_TYPE_EFFECTIVE_UAV_COUNTER_BINDING_INFO,
>
> VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_STRUCTURE_TYPE),
> };
> @@ -138,6 +139,7 @@ struct vkd3d_shader_parameter
> struct vkd3d_shader_resource_binding
> {
> enum vkd3d_shader_descriptor_type type;
> + unsigned int register_space;
> unsigned int register_index;
> enum vkd3d_shader_visibility shader_visibility;
> unsigned int flags; /* vkd3d_shader_binding_flags */
> @@ -159,8 +161,10 @@ struct vkd3d_shader_combined_resource_sampler
>
> struct vkd3d_shader_uav_counter_binding
> {
> + unsigned int register_space;
> unsigned int register_index; /* u# */
> enum vkd3d_shader_visibility shader_visibility;
> + unsigned int counter_index;
>
> struct vkd3d_shader_descriptor_binding binding;
> unsigned int offset;
> @@ -168,6 +172,7 @@ struct vkd3d_shader_uav_counter_binding
>
> struct vkd3d_shader_push_constant_buffer
> {
> + unsigned int register_space;
> unsigned int register_index;
> enum vkd3d_shader_visibility shader_visibility;
>
> @@ -215,6 +220,17 @@ struct vkd3d_shader_transform_feedback_info
> unsigned int buffer_stride_count;
> };
>
> +/* Extends vkd3d_shader_interface_info. */
> +struct vkd3d_shader_effective_uav_counter_binding_info
> +{
> + enum vkd3d_shader_structure_type type;
> + const void *next;
> +
> + unsigned int *uav_register_spaces;
> + unsigned int *uav_register_bindings;
> + unsigned int uav_counter_count;
> +};
> +
> enum vkd3d_shader_target
> {
> VKD3D_SHADER_TARGET_NONE,
> diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c
> index 98c51e4..b3f53ab 100644
> --- a/libs/vkd3d-shader/dxbc.c
> +++ b/libs/vkd3d-shader/dxbc.c
> @@ -624,6 +624,10 @@ static void shader_sm4_read_dcl_resource(struct \
> vkd3d_shader_instruction *ins, ins->flags = (opcode_token & \
> VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT;
> shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.semantic.register_space); + if (shader_is_sm_5_1(priv))
> + ins->declaration.semantic.register_index = \
> ins->declaration.semantic.reg.reg.idx[1].offset; + else
> + ins->declaration.semantic.register_index = \
> ins->declaration.semantic.reg.reg.idx[0].offset; }
>
> static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction \
> *ins, @@ -647,9 +651,12 @@ static void shader_sm4_read_dcl_constant_buffer(struct \
> vkd3d_shader_instruction return;
> }
>
> + ins->declaration.cb.register_index = \
> ins->declaration.cb.src.reg.idx[1].offset; ins->declaration.cb.size = *tokens++;
> shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.cb.register_space); }
> + else
> + ins->declaration.cb.register_index = \
> ins->declaration.cb.src.reg.idx[0].offset; }
>
> static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins,
> @@ -663,6 +670,10 @@ static void shader_sm4_read_dcl_sampler(struct \
> vkd3d_shader_instruction *ins, FIXME("Unhandled sampler mode %#x.\n", ins->flags);
> shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_SAMPLER, \
> &ins->declaration.sampler.src); shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.sampler.register_space); + if (shader_is_sm_5_1(priv))
> + ins->declaration.sampler.register_index = \
> ins->declaration.sampler.src.reg.idx[1].offset; + else
> + ins->declaration.sampler.register_index = \
> ins->declaration.sampler.src.reg.idx[0].offset; }
>
> static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins,
> @@ -863,6 +874,10 @@ static void shader_sm5_read_dcl_uav_raw(struct \
> vkd3d_shader_instruction *ins, shader_sm4_read_dst_param(priv, &tokens, end, \
> VKD3D_DATA_UAV, &ins->declaration.raw_resource.dst); ins->flags = (opcode_token & \
> VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; \
> shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.raw_resource.register_space); + if (shader_is_sm_5_1(priv))
> + ins->declaration.raw_resource.register_index = \
> ins->declaration.raw_resource.dst.reg.idx[1].offset; + else
> + ins->declaration.raw_resource.register_index = \
> ins->declaration.raw_resource.dst.reg.idx[0].offset; }
>
> static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction \
> *ins, @@ -874,9 +889,14 @@ static void shader_sm5_read_dcl_uav_structured(struct \
> vkd3d_shader_instruction * shader_sm4_read_dst_param(priv, &tokens, end, \
> VKD3D_DATA_UAV, &ins->declaration.structured_resource.reg); ins->flags = \
> (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; \
> ins->declaration.structured_resource.byte_stride = *tokens; + tokens++;
> if (ins->declaration.structured_resource.byte_stride % 4)
> FIXME("Byte stride %u is not multiple of 4.\n", \
> ins->declaration.structured_resource.byte_stride); \
> shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.structured_resource.register_space); + if \
> (shader_is_sm_5_1(priv)) + \
> ins->declaration.structured_resource.register_index = \
> ins->declaration.structured_resource.reg.reg.idx[1].offset; + else
> + ins->declaration.structured_resource.register_index = \
> ins->declaration.structured_resource.reg.reg.idx[0].offset; }
>
> static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins,
> @@ -909,9 +929,14 @@ static void shader_sm5_read_dcl_resource_structured(struct \
> vkd3d_shader_instruct
> shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, \
> &ins->declaration.structured_resource.reg); \
> ins->declaration.structured_resource.byte_stride = *tokens; + tokens++;
> if (ins->declaration.structured_resource.byte_stride % 4)
> FIXME("Byte stride %u is not multiple of 4.\n", \
> ins->declaration.structured_resource.byte_stride); \
> shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.structured_resource.register_space); + if \
> (shader_is_sm_5_1(priv)) + \
> ins->declaration.structured_resource.register_index = \
> ins->declaration.structured_resource.reg.reg.idx[1].offset; + else
> + ins->declaration.structured_resource.register_index = \
> ins->declaration.structured_resource.reg.reg.idx[0].offset; }
>
> static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins,
> @@ -922,6 +947,10 @@ static void shader_sm5_read_dcl_resource_raw(struct \
> vkd3d_shader_instruction *in
> shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, \
> &ins->declaration.dst); shader_sm4_read_register_space(priv, &tokens, end, \
> &ins->declaration.raw_resource.register_space); + if (shader_is_sm_5_1(priv))
> + ins->declaration.raw_resource.register_index = \
> ins->declaration.dst.reg.idx[1].offset; + else
> + ins->declaration.raw_resource.register_index = \
> ins->declaration.dst.reg.idx[0].offset; }
>
> static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins,
> diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c
> index 3d88be9..f286f8b 100644
> --- a/libs/vkd3d-shader/spirv.c
> +++ b/libs/vkd3d-shader/spirv.c
> @@ -1890,6 +1890,20 @@ struct vkd3d_symbol
> } info;
> };
>
> +struct vkd3d_sm51_symbol_key
> +{
> + enum vkd3d_shader_descriptor_type descriptor_type;
> + unsigned int idx;
> +};
> +
> +struct vkd3d_sm51_symbol
> +{
> + struct rb_entry entry;
> + struct vkd3d_sm51_symbol_key key;
> + unsigned int register_space;
> + unsigned int resource_idx;
> +};
> +
> static int vkd3d_symbol_compare(const void *key, const struct rb_entry *entry)
> {
> const struct vkd3d_symbol *a = key;
> @@ -1900,6 +1914,13 @@ static int vkd3d_symbol_compare(const void *key, const \
> struct rb_entry *entry) return memcmp(&a->key, &b->key, sizeof(a->key));
> }
>
> +static int vkd3d_sm51_symbol_compare(const void *key, const struct rb_entry \
> *entry) +{
> + const struct vkd3d_sm51_symbol_key *a = key;
> + const struct vkd3d_sm51_symbol *b = RB_ENTRY_VALUE(entry, const struct \
> vkd3d_sm51_symbol, entry); + return memcmp(a, &b->key, sizeof(*a));
> +}
> +
> static void vkd3d_symbol_free(struct rb_entry *entry, void *context)
> {
> struct vkd3d_symbol *s = RB_ENTRY_VALUE(entry, struct vkd3d_symbol, entry);
> @@ -1907,6 +1928,13 @@ static void vkd3d_symbol_free(struct rb_entry *entry, void \
> *context) vkd3d_free(s);
> }
>
> +static void vkd3d_sm51_symbol_free(struct rb_entry *entry, void *context)
> +{
> + struct vkd3d_sm51_symbol *s = RB_ENTRY_VALUE(entry, struct vkd3d_sm51_symbol, \
> entry); +
> + vkd3d_free(s);
> +}
> +
> static void vkd3d_symbol_make_register(struct vkd3d_symbol *symbol,
> const struct vkd3d_shader_register *reg)
> {
> @@ -2052,6 +2080,7 @@ struct vkd3d_hull_shader_variables
>
> struct vkd3d_dxbc_compiler
> {
> + struct vkd3d_shader_version shader_version;
> struct vkd3d_spirv_builder spirv_builder;
>
> uint32_t options;
> @@ -2062,6 +2091,8 @@ struct vkd3d_dxbc_compiler
> struct vkd3d_hull_shader_variables hs;
> uint32_t sample_positions_id;
>
> + struct rb_tree sm51_resource_table;
> +
> enum vkd3d_shader_type shader_type;
>
> unsigned int branch_id;
> @@ -2107,6 +2138,11 @@ struct vkd3d_dxbc_compiler
> size_t spec_constants_size;
> };
>
> +static bool shader_is_sm_5_1(const struct vkd3d_dxbc_compiler *compiler)
> +{
> + return (compiler->shader_version.major * 100 + compiler->shader_version.minor) \
> >= 501; +}
> +
> static bool is_control_point_phase(const struct vkd3d_shader_phase *phase)
> {
> return phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE;
> @@ -2131,6 +2167,8 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const \
> struct vkd3d_shader
> memset(compiler, 0, sizeof(*compiler));
>
> + compiler->shader_version = *shader_version;
> +
> max_element_count = max(output_signature->element_count, \
> patch_constant_signature->element_count); if (!(compiler->output_info = \
> vkd3d_calloc(max_element_count, sizeof(*compiler->output_info)))) {
> @@ -2142,6 +2180,7 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const \
> struct vkd3d_shader compiler->options = compiler_options;
>
> rb_init(&compiler->symbol_table, vkd3d_symbol_compare);
> + rb_init(&compiler->sm51_resource_table, vkd3d_sm51_symbol_compare);
>
> compiler->shader_type = shader_version->type;
>
> @@ -2227,9 +2266,10 @@ static bool \
> vkd3d_dxbc_compiler_check_shader_visibility(const struct vkd3d_dxbc_ }
>
> static struct vkd3d_push_constant_buffer_binding \
> *vkd3d_dxbc_compiler_find_push_constant_buffer(
> - const struct vkd3d_dxbc_compiler *compiler, const struct \
> vkd3d_shader_register *reg) + const struct vkd3d_dxbc_compiler *compiler, \
> const struct vkd3d_shader_constant_buffer *cb) {
> - unsigned int reg_idx = reg->idx[0].offset;
> + unsigned int reg_idx = cb->register_index;
> + unsigned int reg_space = cb->register_space;
> unsigned int i;
>
> for (i = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i)
> @@ -2239,7 +2279,7 @@ static struct vkd3d_push_constant_buffer_binding \
> *vkd3d_dxbc_compiler_find_push_ if \
> (!vkd3d_dxbc_compiler_check_shader_visibility(compiler, \
> current->pc.shader_visibility)) continue;
>
> - if (current->pc.register_index == reg_idx)
> + if (current->pc.register_index == reg_idx && current->pc.register_space == \
> reg_space) return current;
> }
>
> @@ -2274,6 +2314,49 @@ static bool vkd3d_dxbc_compiler_has_combined_sampler(const \
> struct vkd3d_dxbc_com return false;
> }
>
> +static bool vkd3d_get_binding_info_for_register(
> + struct vkd3d_dxbc_compiler *compiler,
> + const struct vkd3d_shader_register *reg,
> + unsigned int *reg_space, unsigned int *reg_binding)
> +{
> + const struct vkd3d_sm51_symbol *symbol;
> + struct vkd3d_sm51_symbol_key key;
> + const struct rb_entry *entry;
> +
> + if (shader_is_sm_5_1(compiler))
> + {
> + key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_UNKNOWN;
> + if (reg->type == VKD3DSPR_CONSTBUFFER)
> + key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_CBV;
> + else if (reg->type == VKD3DSPR_RESOURCE)
> + key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV;
> + else if (reg->type == VKD3DSPR_UAV)
> + key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
> + else if (reg->type == VKD3DSPR_SAMPLER)
> + key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER;
> + else
> + FIXME("Unhandled register type %#x.\n", reg->type);
> +
> + key.idx = reg->idx[0].offset;
> + entry = rb_get(&compiler->sm51_resource_table, &key);
> + if (entry)
> + {
> + symbol = RB_ENTRY_VALUE(entry, const struct vkd3d_sm51_symbol, entry);
> + *reg_space = symbol->register_space;
> + *reg_binding = symbol->resource_idx;
> + return true;
> + }
> + else
> + return false;
> + }
> + else
> + {
> + *reg_space = 0;
> + *reg_binding = reg->idx[0].offset;
> + return true;
> + }
> +}
> +
> static struct vkd3d_shader_descriptor_binding \
> vkd3d_dxbc_compiler_get_descriptor_binding( struct vkd3d_dxbc_compiler *compiler, \
> const struct vkd3d_shader_register *reg, enum vkd3d_shader_resource_type \
> resource_type, bool is_uav_counter) @@ -2282,8 +2365,9 @@ static struct \
> vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor enum \
> vkd3d_shader_descriptor_type descriptor_type; enum vkd3d_shader_binding_flag \
> resource_type_flag; struct vkd3d_shader_descriptor_binding binding;
> - unsigned int reg_idx = reg->idx[0].offset;
> unsigned int i;
> + unsigned int reg_space = 0;
> + unsigned int reg_idx = 0;
>
> descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_UNKNOWN;
> if (reg->type == VKD3DSPR_CONSTBUFFER)
As long as we're here, it's my understanding that variable declarations
should be sorted in "reverse Christmas tree" order.
> @@ -2300,6 +2384,11 @@ static struct vkd3d_shader_descriptor_binding \
> vkd3d_dxbc_compiler_get_descriptor resource_type_flag = resource_type == \
> VKD3D_SHADER_RESOURCE_BUFFER ? VKD3D_SHADER_BINDING_FLAG_BUFFER : \
> VKD3D_SHADER_BINDING_FLAG_IMAGE;
> + if (!vkd3d_get_binding_info_for_register(compiler, reg, ®_space, ®_idx))
> + {
> + ERR("Failed to find binding for resource type %#x.\n", reg->type);
> + }
> +
> if (is_uav_counter)
> {
> assert(descriptor_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV);
> @@ -2313,8 +2402,19 @@ static struct vkd3d_shader_descriptor_binding \
> vkd3d_dxbc_compiler_get_descriptor if (current->offset)
> FIXME("Atomic counter offsets are not supported yet.\n");
>
> - if (current->register_index == reg_idx)
> + /* Do not use space/binding, but just the plain index here, since \
> that's how the UAV counter mask is exposed. */ + if \
> (current->counter_index == reg->idx[0].offset) + {
> + /* Let pipeline know what the actual space/bindings for the \
> counter are. */ + const struct \
> vkd3d_shader_effective_uav_counter_binding_info *binding_info = + \
> vkd3d_find_struct(shader_interface->next, EFFECTIVE_UAV_COUNTER_BINDING_INFO); + \
> if (binding_info && current->counter_index < binding_info->uav_counter_count) + \
> { + binding_info->uav_register_spaces[current->counter_index] = \
> reg_space; + \
> binding_info->uav_register_bindings[current->counter_index] = reg_idx; + \
> } return current->binding;
> + }
> }
> if (shader_interface->uav_counter_count)
> FIXME("Could not find descriptor binding for UAV counter %u.\n", reg_idx);
> @@ -2331,7 +2431,7 @@ static struct vkd3d_shader_descriptor_binding \
> vkd3d_dxbc_compiler_get_descriptor if \
> (!vkd3d_dxbc_compiler_check_shader_visibility(compiler, \
> current->shader_visibility)) continue;
>
> - if (current->type == descriptor_type && current->register_index == \
> reg_idx) + if (current->type == descriptor_type && \
> current->register_index == reg_idx && current->register_space == reg_space) return \
> current->binding; }
> if (shader_interface->binding_count)
> @@ -2828,7 +2928,8 @@ static void \
> vkd3d_dxbc_compiler_emit_dereference_register(struct vkd3d_dxbc_comp {
> assert(!reg->idx[0].rel_addr);
> indexes[index_count++] = vkd3d_dxbc_compiler_get_constant_uint(compiler, \
> register_info->member_idx);
> - indexes[index_count++] = \
> vkd3d_dxbc_compiler_emit_register_addressing(compiler, ®->idx[1]); + \
> indexes[index_count++] = vkd3d_dxbc_compiler_emit_register_addressing(compiler, + \
> ®->idx[shader_is_sm_5_1(compiler) ? 2 : 1]); }
> else if (reg->type == VKD3DSPR_IMMCONSTBUFFER)
> {
> @@ -2838,6 +2939,11 @@ static void \
> vkd3d_dxbc_compiler_emit_dereference_register(struct vkd3d_dxbc_comp {
> indexes[index_count++] = vkd3d_dxbc_compiler_emit_register_addressing(compiler, \
> ®->idx[1]); }
> + else if (reg->type == VKD3DSPR_SAMPLER)
> + {
> + /* SM 5.1 will have an index here referring to something which we throw \
> away. */ + index_count = 0;
> + }
> else if (register_info->is_aggregate)
> {
> struct vkd3d_shader_register_index reg_idx = reg->idx[0];
> @@ -4914,7 +5020,8 @@ static void \
> vkd3d_dxbc_compiler_emit_push_constant_buffers(struct vkd3d_dxbc_com if \
> (!cb->reg.type) continue;
>
> - cb_size = cb->reg.idx[1].offset;
> + cb_size = (cb->pc.size + 15) / 16;
> +
> length_id = vkd3d_dxbc_compiler_get_constant_uint(compiler, cb_size);
> member_ids[j] = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id);
> vkd3d_spirv_build_op_decorate1(builder, member_ids[j], SpvDecorationArrayStride, \
> 16); @@ -4965,10 +5072,19 @@ static void \
> vkd3d_dxbc_compiler_emit_dcl_constant_buffer(struct vkd3d_dxbc_compi
> assert(!(instruction->flags & ~VKD3DSI_INDEXED_DYNAMIC));
>
> - if (cb->register_space)
> - FIXME("Unhandled register space %u.\n", cb->register_space);
> + if (shader_is_sm_5_1(compiler))
> + {
> + struct vkd3d_sm51_symbol *sym;
> + sym = vkd3d_calloc(1, sizeof(*sym));
> + sym->key.idx = reg->idx[0].offset;
> + sym->key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_CBV;
> + sym->register_space = instruction->declaration.cb.register_space;
> + sym->resource_idx = instruction->declaration.cb.register_index;
> + if (rb_put(&compiler->sm51_resource_table, &sym->key, &sym->entry) == -1)
> + vkd3d_free(sym);
> + }
>
> - if ((push_cb = vkd3d_dxbc_compiler_find_push_constant_buffer(compiler, reg)))
> + if ((push_cb = vkd3d_dxbc_compiler_find_push_constant_buffer(compiler, cb)))
> {
> /* Push constant buffers are handled in
> * vkd3d_dxbc_compiler_emit_push_constant_buffers().
> @@ -5050,8 +5166,17 @@ static void vkd3d_dxbc_compiler_emit_dcl_sampler(struct \
> vkd3d_dxbc_compiler *com uint32_t type_id, ptr_type_id, var_id;
> struct vkd3d_symbol reg_symbol;
>
> - if (instruction->declaration.sampler.register_space)
> - FIXME("Unhandled register space %u.\n", \
> instruction->declaration.sampler.register_space); + if \
> (shader_is_sm_5_1(compiler)) + {
> + struct vkd3d_sm51_symbol *sym;
> + sym = vkd3d_calloc(1, sizeof(*sym));
> + sym->key.idx = reg->idx[0].offset;
> + sym->key.descriptor_type = VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER;
> + sym->register_space = instruction->declaration.sampler.register_space;
> + sym->resource_idx = instruction->declaration.sampler.register_index;
> + if (rb_put(&compiler->sm51_resource_table, &sym->key, &sym->entry) == -1)
> + vkd3d_free(sym);
> + }
>
> if (vkd3d_dxbc_compiler_has_combined_sampler(compiler, NULL, reg))
> return;
> @@ -5272,8 +5397,18 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource(struct \
> vkd3d_dxbc_compiler *co {
> const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic;
>
> - if (semantic->register_space)
> - FIXME("Unhandled register space %u.\n", semantic->register_space);
> + if (shader_is_sm_5_1(compiler))
> + {
> + struct vkd3d_sm51_symbol *sym;
> + sym = vkd3d_calloc(1, sizeof(*sym));
> + sym->key.idx = semantic->reg.reg.idx[0].offset;
> + sym->key.descriptor_type = semantic->reg.reg.type == VKD3DSPR_UAV ? \
> VKD3D_SHADER_DESCRIPTOR_TYPE_UAV : VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; + \
> sym->register_space = semantic->register_space; + sym->resource_idx = \
> semantic->register_index; + if (rb_put(&compiler->sm51_resource_table, \
> &sym->key, &sym->entry) == -1) + vkd3d_free(sym);
> + }
> +
> if (instruction->flags)
> FIXME("Unhandled UAV flags %#x.\n", instruction->flags);
>
> @@ -5286,8 +5421,18 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource_raw(struct \
> vkd3d_dxbc_compiler {
> const struct vkd3d_shader_raw_resource *resource = \
> &instruction->declaration.raw_resource;
> - if (resource->register_space)
> - FIXME("Unhandled register space %u.\n", resource->register_space);
> + if (shader_is_sm_5_1(compiler))
> + {
> + struct vkd3d_sm51_symbol *sym;
> + sym = vkd3d_calloc(1, sizeof(*sym));
> + sym->key.idx = resource->dst.reg.idx[0].offset;
> + sym->key.descriptor_type = resource->dst.reg.type == VKD3DSPR_UAV ? \
> VKD3D_SHADER_DESCRIPTOR_TYPE_UAV : VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; + \
> sym->register_space = resource->register_space; + sym->resource_idx = \
> resource->register_index; + if (rb_put(&compiler->sm51_resource_table, \
> &sym->key, &sym->entry) == -1) + vkd3d_free(sym);
> + }
> +
> if (instruction->flags)
> FIXME("Unhandled UAV flags %#x.\n", instruction->flags);
>
> @@ -5302,8 +5447,18 @@ static void \
> vkd3d_dxbc_compiler_emit_dcl_resource_structured(struct vkd3d_dxbc_c const struct \
> vkd3d_shader_register *reg = &resource->reg.reg; unsigned int stride = \
> resource->byte_stride;
> - if (resource->register_space)
> - FIXME("Unhandled register space %u.\n", resource->register_space);
> + if (shader_is_sm_5_1(compiler))
> + {
> + struct vkd3d_sm51_symbol *sym;
> + sym = vkd3d_calloc(1, sizeof(*sym));
> + sym->key.idx = resource->reg.reg.idx[0].offset;
> + sym->key.descriptor_type = resource->reg.reg.type == VKD3DSPR_UAV ? \
> VKD3D_SHADER_DESCRIPTOR_TYPE_UAV : VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; + \
> sym->register_space = resource->register_space; + sym->resource_idx = \
> resource->register_index; + if (rb_put(&compiler->sm51_resource_table, \
> &sym->key, &sym->entry) == -1) + vkd3d_free(sym);
> + }
> +
> if (instruction->flags)
> FIXME("Unhandled UAV flags %#x.\n", instruction->flags);
>
> @@ -8717,6 +8872,7 @@ void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler \
> *compiler) vkd3d_spirv_builder_free(&compiler->spirv_builder);
>
> rb_destroy(&compiler->symbol_table, vkd3d_symbol_free, NULL);
> + rb_destroy(&compiler->sm51_resource_table, vkd3d_sm51_symbol_free, NULL);
>
> vkd3d_free(compiler->shader_phases);
> vkd3d_free(compiler->spec_constants);
> diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h \
> b/libs/vkd3d-shader/vkd3d_shader_private.h index 100d515..135b48b 100644
> --- a/libs/vkd3d-shader/vkd3d_shader_private.h
> +++ b/libs/vkd3d-shader/vkd3d_shader_private.h
> @@ -615,6 +615,7 @@ struct vkd3d_shader_semantic
> enum vkd3d_data_type resource_data_type;
> struct vkd3d_shader_dst_param reg;
> unsigned int register_space;
> + unsigned int register_index;
> };
>
> enum vkd3d_shader_input_sysval_semantic
> @@ -662,6 +663,7 @@ struct vkd3d_shader_register_semantic
> struct vkd3d_shader_sampler
> {
> struct vkd3d_shader_src_param src;
> + unsigned int register_index;
> unsigned int register_space;
> };
>
> @@ -669,6 +671,7 @@ struct vkd3d_shader_constant_buffer
> {
> struct vkd3d_shader_src_param src;
> unsigned int size;
> + unsigned int register_index;
> unsigned int register_space;
> };
>
> @@ -676,12 +679,14 @@ struct vkd3d_shader_structured_resource
> {
> struct vkd3d_shader_dst_param reg;
> unsigned int byte_stride;
> + unsigned int register_index;
> unsigned int register_space;
> };
>
> struct vkd3d_shader_raw_resource
> {
> struct vkd3d_shader_dst_param dst;
> + unsigned int register_index;
> unsigned int register_space;
> };
>
> diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c
> index 8a7ff66..7245802 100644
> --- a/libs/vkd3d/command.c
> +++ b/libs/vkd3d/command.c
> @@ -2655,7 +2655,7 @@ static void d3d12_command_list_update_descriptor_table(struct \
> d3d12_command_list const struct d3d12_root_descriptor_table *descriptor_table;
> const struct d3d12_root_descriptor_table_range *range;
> VkDevice vk_device = list->device->vk_device;
> - unsigned int i, j, descriptor_count;
> + unsigned int i, j, k, descriptor_count;
> struct d3d12_desc *descriptor;
>
> descriptor_table = root_signature_get_descriptor_table(root_signature, index);
> @@ -2678,14 +2678,26 @@ static void \
> d3d12_command_list_update_descriptor_table(struct d3d12_command_list unsigned int \
> register_idx = range->base_register_idx + j;
> /* Track UAV counters. */
> - if (range->descriptor_magic == VKD3D_DESCRIPTOR_MAGIC_UAV
> - && register_idx < ARRAY_SIZE(bindings->vk_uav_counter_views))
> + if (list->state->uav_counter_mask != 0 && range->descriptor_magic == \
> VKD3D_DESCRIPTOR_MAGIC_UAV) {
> - VkBufferView vk_counter_view = descriptor->magic == \
> VKD3D_DESCRIPTOR_MAGIC_UAV
> - ? descriptor->u.view->vk_counter_view : VK_NULL_HANDLE;
> - if (bindings->vk_uav_counter_views[register_idx] != \
> vk_counter_view)
> - bindings->uav_counter_dirty_mask |= 1u << register_idx;
> - bindings->vk_uav_counter_views[register_idx] = vk_counter_view;
> + const struct vkd3d_shader_uav_counter_binding *counter_bindings = \
> list->state->uav_counters; + for (k = 0; k < \
> VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS; k++) + {
> + if (list->state->uav_counter_mask & (1u << k))
> + {
> + if (counter_bindings->register_space == \
> range->register_space && + \
> counter_bindings->register_index == register_idx) + {
> + VkBufferView vk_counter_view = descriptor->magic == \
> VKD3D_DESCRIPTOR_MAGIC_UAV + \
> ? descriptor->u.view->vk_counter_view : VK_NULL_HANDLE; + \
> if (bindings->vk_uav_counter_views[k] != vk_counter_view) + \
> bindings->uav_counter_dirty_mask |= 1u << k; + \
> bindings->vk_uav_counter_views[k] = vk_counter_view; + \
> break; + }
> + counter_bindings++;
> + }
> + }
> }
>
> if (!vk_write_descriptor_set_from_d3d12_desc(current_descriptor_write,
> @@ -2841,7 +2853,7 @@ static void \
> d3d12_command_list_update_uav_counter_descriptors(struct d3d12_comma const struct \
> vkd3d_shader_uav_counter_binding *uav_counter = &state->uav_counters[i]; const \
> VkBufferView *vk_uav_counter_views = bindings->vk_uav_counter_views;
> - assert(vk_uav_counter_views[uav_counter->register_index]);
> + assert(vk_uav_counter_views[uav_counter->counter_index]);
>
> vk_descriptor_writes[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
> vk_descriptor_writes[i].pNext = NULL;
> @@ -2852,7 +2864,7 @@ static void \
> d3d12_command_list_update_uav_counter_descriptors(struct d3d12_comma \
> vk_descriptor_writes[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; \
> vk_descriptor_writes[i].pImageInfo = NULL; vk_descriptor_writes[i].pBufferInfo = \
> NULL;
> - vk_descriptor_writes[i].pTexelBufferView = \
> &vk_uav_counter_views[uav_counter->register_index]; + \
> vk_descriptor_writes[i].pTexelBufferView = \
> &vk_uav_counter_views[uav_counter->counter_index]; }
>
> VK_CALL(vkUpdateDescriptorSets(vk_device, uav_counter_count, vk_descriptor_writes, \
> 0, NULL));
> diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c
> index e1f7da9..9add56b 100644
> --- a/libs/vkd3d/state.c
> +++ b/libs/vkd3d/state.c
> @@ -309,12 +309,6 @@ static bool vk_binding_from_d3d12_descriptor_range(struct \
> VkDescriptorSetLayoutB = \
> vk_descriptor_type_from_d3d12_range_type(descriptor_range->RangeType, is_buffer); \
> binding_desc->descriptorCount = 1;
> - if (descriptor_range->RegisterSpace)
> - {
> - FIXME("Unhandled register space %u.\n", descriptor_range->RegisterSpace);
> - return false;
> - }
> -
> binding_desc->stageFlags = stage_flags_from_visibility(shader_visibility);
> binding_desc->pImmutableSamplers = NULL;
>
> @@ -495,12 +489,6 @@ static HRESULT d3d12_root_signature_init_push_constants(struct \
> d3d12_root_signat if (p->ParameterType != \
> D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS) continue;
>
> - if (p->u.Constants.RegisterSpace)
> - {
> - FIXME("Unhandled register space %u for parameter %u.\n", \
> p->u.Constants.RegisterSpace, i);
> - return E_NOTIMPL;
> - }
> -
> idx = push_constant_count == 1 ? 0 : p->ShaderVisibility;
> offset = push_constants_offset[idx];
> push_constants_offset[idx] += p->u.Constants.Num32BitValues * sizeof(uint32_t);
> @@ -510,6 +498,7 @@ static HRESULT d3d12_root_signature_init_push_constants(struct \
> d3d12_root_signat ? push_constants[0].stageFlags : \
> stage_flags_from_visibility(p->ShaderVisibility); root_constant->offset = offset;
>
> + root_signature->root_constants[j].register_space = \
> p->u.Constants.RegisterSpace; root_signature->root_constants[j].register_index = \
> p->u.Constants.ShaderRegister; root_signature->root_constants[j].shader_visibility
> = vkd3d_shader_visibility_from_d3d12(p->ShaderVisibility);
> @@ -533,7 +522,7 @@ struct vkd3d_descriptor_set_context
> };
>
> static void d3d12_root_signature_append_vk_binding(struct d3d12_root_signature \
> *root_signature,
> - enum vkd3d_shader_descriptor_type descriptor_type, unsigned int \
> register_idx, + enum vkd3d_shader_descriptor_type descriptor_type, unsigned \
> int register_space, unsigned int register_idx, bool buffer_descriptor, enum \
> vkd3d_shader_visibility shader_visibility, struct vkd3d_descriptor_set_context \
> *context) {
> @@ -541,6 +530,7 @@ static void d3d12_root_signature_append_vk_binding(struct \
> d3d12_root_signature * = \
> &root_signature->descriptor_mapping[context->descriptor_index++];
> mapping->type = descriptor_type;
> + mapping->register_space = register_space;
> mapping->register_index = register_idx;
> mapping->shader_visibility = shader_visibility;
> mapping->flags = buffer_descriptor ? VKD3D_SHADER_BINDING_FLAG_BUFFER : \
> VKD3D_SHADER_BINDING_FLAG_IMAGE; @@ -549,7 +539,7 @@ static void \
> d3d12_root_signature_append_vk_binding(struct d3d12_root_signature * }
>
> static uint32_t d3d12_root_signature_assign_vk_bindings(struct d3d12_root_signature \
> *root_signature,
> - enum vkd3d_shader_descriptor_type descriptor_type, unsigned int \
> base_register_idx, + enum vkd3d_shader_descriptor_type descriptor_type, \
> unsigned int register_space, unsigned int base_register_idx, unsigned int \
> binding_count, bool is_buffer_descriptor, bool duplicate_descriptors, enum \
> vkd3d_shader_visibility shader_visibility, struct vkd3d_descriptor_set_context \
> *context) {
> @@ -566,10 +556,10 @@ static uint32_t \
> d3d12_root_signature_assign_vk_bindings(struct d3d12_root_signat {
> if (duplicate_descriptors)
> d3d12_root_signature_append_vk_binding(root_signature, descriptor_type,
> - base_register_idx + i, true, shader_visibility, context);
> + register_space, base_register_idx + i, true, \
> shader_visibility, context);
> d3d12_root_signature_append_vk_binding(root_signature, descriptor_type,
> - base_register_idx + i, is_buffer_descriptor, shader_visibility, \
> context); + register_space, base_register_idx + i, \
> is_buffer_descriptor, shader_visibility, context); }
> return first_binding;
> }
> @@ -625,7 +615,7 @@ static HRESULT \
> d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo
> vk_binding = d3d12_root_signature_assign_vk_bindings(root_signature,
> vkd3d_descriptor_type_from_d3d12_range_type(range->RangeType),
> - range->BaseShaderRegister, range->NumDescriptors, false, true,
> + range->RegisterSpace, range->BaseShaderRegister, \
> range->NumDescriptors, false, true, \
> vkd3d_shader_visibility_from_d3d12(p->ShaderVisibility), context);
> /* Unroll descriptor range. */
> @@ -658,6 +648,7 @@ static HRESULT \
> d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo \
> table->ranges[j].binding = vk_binding; table->ranges[j].descriptor_magic = \
> vkd3d_descriptor_magic_from_d3d12(range->RangeType); \
> table->ranges[j].base_register_idx = range->BaseShaderRegister; + \
> table->ranges[j].register_space = range->RegisterSpace; }
> }
>
> @@ -683,15 +674,9 @@ static HRESULT \
> d3d12_root_signature_init_root_descriptors(struct d3d12_root_sign
> root_signature->push_descriptor_mask |= 1u << i;
>
> - if (p->u.Descriptor.RegisterSpace)
> - {
> - FIXME("Unhandled register space %u for parameter %u.\n", \
> p->u.Descriptor.RegisterSpace, i);
> - return E_NOTIMPL;
> - }
> -
> cur_binding->binding = d3d12_root_signature_assign_vk_bindings(root_signature,
> vkd3d_descriptor_type_from_d3d12_root_parameter_type(p->ParameterType),
> - p->u.Descriptor.ShaderRegister, 1, true, false,
> + p->u.Descriptor.RegisterSpace, p->u.Descriptor.ShaderRegister, 1, \
> true, false, vkd3d_shader_visibility_from_d3d12(p->ShaderVisibility), context);
> cur_binding->descriptorType = \
> vk_descriptor_type_from_d3d12_root_parameter(p->ParameterType); \
> cur_binding->descriptorCount = 1; @@ -728,7 +713,7 @@ static HRESULT \
> d3d12_root_signature_init_static_samplers(struct d3d12_root_signa return hr;
>
> cur_binding->binding = d3d12_root_signature_assign_vk_bindings(root_signature,
> - VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, s->ShaderRegister, 1, false, \
> false, + VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, s->RegisterSpace, \
> s->ShaderRegister, 1, false, false, \
> vkd3d_shader_visibility_from_d3d12(s->ShaderVisibility), context); \
> cur_binding->descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER; \
> cur_binding->descriptorCount = 1; @@ -1451,7 +1436,14 @@ static HRESULT \
> d3d12_pipeline_state_init_compute_uav_counters(struct d3d12_pipel if \
> (!(shader_info->uav_counter_mask & (1u << i))) continue;
>
> + /* UAV counters will lookup Vulkan bindings based on the mask index \
> directly. + * We currently don't know the actual space/binding for this \
> UAV, + * but register_space/register_index are fixed up later after \
> compilation is finished. */ + state->uav_counters[j].register_space = 0;
> state->uav_counters[j].register_index = i;
> +
> + state->uav_counters[j].counter_index = i;
> +
> state->uav_counters[j].shader_visibility = VKD3D_SHADER_VISIBILITY_COMPUTE;
> state->uav_counters[j].binding.set = context.set_index;
> state->uav_counters[j].binding.binding = context.descriptor_binding;
> @@ -1507,6 +1499,10 @@ static HRESULT d3d12_pipeline_state_init_compute(struct \
> d3d12_pipeline_state *st struct vkd3d_shader_code dxbc;
> HRESULT hr;
> int ret;
> + unsigned int i, j;
> + unsigned int uav_counter_spaces[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS] = { 0 \
> }; + unsigned int uav_counter_bindings[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS] \
> = { 0 }; + struct vkd3d_shader_effective_uav_counter_binding_info \
> uav_binding_info = { VKD3D_SHADER_STRUCTURE_TYPE_EFFECTIVE_UAV_COUNTER_BINDING_INFO \
> };
> state->ID3D12PipelineState_iface.lpVtbl = &d3d12_pipeline_state_vtbl;
> state->refcount = 1;
> @@ -1550,8 +1546,14 @@ static HRESULT d3d12_pipeline_state_init_compute(struct \
> d3d12_pipeline_state *st shader_interface.uav_counters = state->uav_counters;
> shader_interface.uav_counter_count = vkd3d_popcount(state->uav_counter_mask);
>
> + shader_interface.next = &uav_binding_info;
> + uav_binding_info.uav_register_spaces = uav_counter_spaces;
> + uav_binding_info.uav_register_bindings = uav_counter_bindings;
> + uav_binding_info.uav_counter_count = VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS;
> +
> vk_pipeline_layout = state->vk_pipeline_layout
> ? state->vk_pipeline_layout : root_signature->vk_pipeline_layout;
> +
> if (FAILED(hr = vkd3d_create_compute_pipeline(device, &desc->CS, &shader_interface,
> vk_pipeline_layout, &state->u.compute.vk_pipeline)))
> {
> @@ -1575,6 +1577,17 @@ static HRESULT d3d12_pipeline_state_init_compute(struct \
> d3d12_pipeline_state *st return hr;
> }
>
> + /* Map back to actual space/bindings for the UAV counter now that we know. */
> + for (i = 0, j = 0; i < VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS; i++)
> + {
> + if (state->uav_counter_mask & (1u << i))
> + {
> + state->uav_counters[j].register_space = uav_counter_spaces[i];
> + state->uav_counters[j].register_index = uav_counter_bindings[i];
> + j++;
> + }
> + }
> +
> state->vk_bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
> d3d12_device_add_ref(state->device = device);
>
> @@ -2911,6 +2924,7 @@ HRESULT vkd3d_uav_clear_state_init(struct \
> vkd3d_uav_clear_state *state, struct d
> binding.type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
> binding.register_index = 0;
> + binding.register_space = 0;
> binding.shader_visibility = VKD3D_SHADER_VISIBILITY_COMPUTE;
> binding.binding.set = 0;
> binding.binding.binding = 0;
> @@ -2919,6 +2933,7 @@ HRESULT vkd3d_uav_clear_state_init(struct \
> vkd3d_uav_clear_state *state, struct d push_constant_range.offset = 0;
> push_constant_range.size = sizeof(struct vkd3d_uav_clear_args);
>
> + push_constant.register_space = 0;
> push_constant.register_index = 0;
> push_constant.shader_visibility = VKD3D_SHADER_VISIBILITY_COMPUTE;
> push_constant.offset = 0;
> diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h
> index 0c031d2..2309031 100644
> --- a/libs/vkd3d/vkd3d_private.h
> +++ b/libs/vkd3d/vkd3d_private.h
> @@ -659,6 +659,7 @@ struct d3d12_root_descriptor_table_range
>
> uint32_t descriptor_magic;
> unsigned int base_register_idx;
> + unsigned int register_space;
> };
>
> struct d3d12_root_descriptor_table
>
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic