March 2023 - Wine-Commits - list.winehq.org

Nikolay Sivov : vkd3d-shader/sm4: Write sample count field for multisampled texture declaration.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 2880be647e77f6cde7f8efcba3bcdd1ccc0afbb1 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/2880be647e77f6cde7f8efcba3bcd… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Sat Mar 4 19:59:02 2023 +0100 vkd3d-shader/sm4: Write sample count field for multisampled texture declaration. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_sm4.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 3e1769ac..f81be3e9 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -1164,7 +1164,7 @@ static void write_sm4_dcl_sampler(struct vkd3d_bytecode_buffer *buffer, const st static void write_sm4_dcl_texture(struct vkd3d_bytecode_buffer *buffer, const struct hlsl_ir_var *var) { bool uav = (var->data_type->base_type == HLSL_TYPE_UAV); - const struct sm4_instruction instr = + struct sm4_instruction instr = { .opcode = (uav ? VKD3D_SM5_OP_DCL_UAV_TYPED : VKD3D_SM4_OP_DCL_RESOURCE) | (sm4_resource_dimension(var->data_type) << VKD3D_SM4_RESOURCE_TYPE_SHIFT), @@ -1177,6 +1177,13 @@ static void write_sm4_dcl_texture(struct vkd3d_bytecode_buffer *buffer, const st .idx[0] = sm4_resource_format(var->data_type) * 0x1111, .idx_count = 1, }; + + if (var->data_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS + || var->data_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY) + { + instr.opcode |= var->data_type->sample_count << VKD3D_SM4_RESOURCE_SAMPLE_COUNT_SHIFT; + } + write_sm4_instruction(buffer, &instr); }

1 0

Conor McCarthy : vkd3d-shader/dxbc: Validate and skip the signature section header size.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 9f6e6d3fcdc3a88456643106fa5798e9db5b5fc2 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/9f6e6d3fcdc3a88456643106fa579… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Tue Mar 7 14:06:36 2023 +1000 vkd3d-shader/dxbc: Validate and skip the signature section header size. Silences a very common warning. --- libs/vkd3d-shader/dxbc.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 008be3c8..c7a52195 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1709,6 +1709,9 @@ static void skip_dword_unknown(const char **ptr, unsigned int count) unsigned int i; uint32_t d; + if (!count) + return; + WARN("Skipping %u unknown DWORDs:\n", count); for (i = 0; i < count; ++i) { @@ -1922,9 +1925,9 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s bool has_stream_index, has_min_precision; struct vkd3d_shader_signature_element *e; const char *data = section->data.code; + uint32_t count, header_size; const char *ptr = data; unsigned int i; - uint32_t count; if (!require_space(0, 2, sizeof(uint32_t), section->data.size)) { @@ -1937,7 +1940,17 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s read_dword(&ptr, &count); TRACE("%u elements.\n", count); - skip_dword_unknown(&ptr, 1); /* It seems to always be 0x00000008. */ + read_dword(&ptr, &header_size); + i = header_size / sizeof(uint32_t); + if (align(header_size, sizeof(uint32_t)) != header_size || i < 2 + || !require_space(2, i - 2, sizeof(uint32_t), section->data.size)) + { + WARN("Invalid header size %#x.\n", header_size); + vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_DXBC_INVALID_SIGNATURE, + "Signature header size %#x is invalid.\n", header_size); + return VKD3D_ERROR_INVALID_ARGUMENT; + } + skip_dword_unknown(&ptr, i - 2); if (!require_space(ptr - data, count, 6 * sizeof(uint32_t), section->data.size)) {

1 0

Conor McCarthy : vkd3d-shader/dxbc: Pass a message context to for_each_dxbc_section().
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 83e39e26500afeb5109217753f48a9bd51e09881 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/83e39e26500afeb5109217753f48a… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Tue Mar 7 13:57:37 2023 +1000 vkd3d-shader/dxbc: Pass a message context to for_each_dxbc_section(). --- libs/vkd3d-shader/dxbc.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index d8eef8a5..b01e30e5 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1867,7 +1867,8 @@ void vkd3d_shader_free_dxbc(struct vkd3d_shader_dxbc_desc *dxbc) static int for_each_dxbc_section(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_message_context *message_context, const char *source_name, - int (*section_handler)(const struct vkd3d_shader_dxbc_section_desc *section, void *ctx), void *ctx) + int (*section_handler)(const struct vkd3d_shader_dxbc_section_desc *section, + struct vkd3d_shader_message_context *message_context, void *ctx), void *ctx) { struct vkd3d_shader_dxbc_desc desc; unsigned int i; @@ -1878,7 +1879,7 @@ static int for_each_dxbc_section(const struct vkd3d_shader_code *dxbc, for (i = 0; i < desc.section_count; ++i) { - if ((ret = section_handler(&desc.sections[i], ctx)) < 0) + if ((ret = section_handler(&desc.sections[i], message_context, ctx)) < 0) break; } @@ -1916,7 +1917,7 @@ int vkd3d_shader_parse_dxbc(const struct vkd3d_shader_code *dxbc, } static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *section, - struct vkd3d_shader_signature *s) + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *s) { bool has_stream_index, has_min_precision; struct vkd3d_shader_signature_element *e; @@ -2002,7 +2003,8 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s return VKD3D_OK; } -static int isgn_handler(const struct vkd3d_shader_dxbc_section_desc *section, void *ctx) +static int isgn_handler(const struct vkd3d_shader_dxbc_section_desc *section, + struct vkd3d_shader_message_context *message_context, void *ctx) { struct vkd3d_shader_signature *is = ctx; @@ -2014,7 +2016,7 @@ static int isgn_handler(const struct vkd3d_shader_dxbc_section_desc *section, vo FIXME("Multiple input signatures.\n"); vkd3d_shader_free_shader_signature(is); } - return shader_parse_signature(section, is); + return shader_parse_signature(section, message_context, is); } int shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, @@ -2029,7 +2031,8 @@ int shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, return ret; } -static int shdr_handler(const struct vkd3d_shader_dxbc_section_desc *section, void *context) +static int shdr_handler(const struct vkd3d_shader_dxbc_section_desc *section, + struct vkd3d_shader_message_context *message_context, void *context) { struct vkd3d_shader_desc *desc = context; int ret; @@ -2043,7 +2046,7 @@ static int shdr_handler(const struct vkd3d_shader_dxbc_section_desc *section, vo FIXME("Multiple input signatures.\n"); break; } - if ((ret = shader_parse_signature(section, &desc->input_signature)) < 0) + if ((ret = shader_parse_signature(section, message_context, &desc->input_signature)) < 0) return ret; break; @@ -2055,7 +2058,7 @@ static int shdr_handler(const struct vkd3d_shader_dxbc_section_desc *section, vo FIXME("Multiple output signatures.\n"); break; } - if ((ret = shader_parse_signature(section, &desc->output_signature)) < 0) + if ((ret = shader_parse_signature(section, message_context, &desc->output_signature)) < 0) return ret; break; @@ -2066,7 +2069,7 @@ static int shdr_handler(const struct vkd3d_shader_dxbc_section_desc *section, vo FIXME("Multiple patch constant signatures.\n"); break; } - if ((ret = shader_parse_signature(section, &desc->patch_constant_signature)) < 0) + if ((ret = shader_parse_signature(section, message_context, &desc->patch_constant_signature)) < 0) return ret; break; @@ -2618,7 +2621,8 @@ static int shader_parse_root_signature(const struct vkd3d_shader_code *data, return VKD3D_OK; } -static int rts0_handler(const struct vkd3d_shader_dxbc_section_desc *section, void *context) +static int rts0_handler(const struct vkd3d_shader_dxbc_section_desc *section, + struct vkd3d_shader_message_context *message_context, void *context) { struct vkd3d_shader_versioned_root_signature_desc *desc = context;

1 0

Giovanni Mascellani : vkd3d: Always enqueue wait operations, even when they can be executed right away.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 09d2c8d1909aac06091403a6691c0037de10b698 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/09d2c8d1909aac06091403a6691c0… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Thu Mar 2 12:11:55 2023 +0100 vkd3d: Always enqueue wait operations, even when they can be executed right away. --- libs/vkd3d/command.c | 24 +----------------------- 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 5d8eb3e9..2ee1e8d5 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -6611,23 +6611,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Wait(ID3D12CommandQueue *if TRACE("iface %p, fence %p, value %#"PRIx64".\n", iface, fence_iface, value); vkd3d_mutex_lock(&command_queue->op_mutex); - vkd3d_mutex_lock(&fence->mutex); - - if (!command_queue->ops_count && value <= fence->max_pending_value) - { - hr = d3d12_command_queue_wait_locked(command_queue, fence, value); - goto done; - } - - /* This is the critical part required to support out-of-order signal. - * Normally we would be able to submit waits and signals out of order, but - * we don't have virtualized queues in Vulkan, so we need to handle the case - * where multiple queues alias over the same physical queue, so effectively, - * we need to manage out-of-order submits ourselves. */ if (!(op = d3d12_command_queue_require_space_locked(command_queue))) { - vkd3d_mutex_unlock(&fence->mutex); hr = E_OUTOFMEMORY; goto done; } @@ -6637,15 +6623,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Wait(ID3D12CommandQueue *if d3d12_fence_incref(fence); - /* Add the queue to the blocked list after writing the op to ensure the queue isn't - * removed again in another thread because it has no ops. */ - if (command_queue->ops_count == 1) - hr = d3d12_command_queue_record_as_blocked(command_queue); - - /* The fence must remain locked until the op is created and the queue is added to the blocked list, - * because if an unblocking d3d12_fence_Signal() call occurs on another thread before the above - * work is done, flushing will be delayed until the next signal, if one occurs at all. */ - vkd3d_mutex_unlock(&fence->mutex); + d3d12_command_queue_submit_locked(command_queue); done: vkd3d_mutex_unlock(&command_queue->op_mutex);

1 0

Zebediah Figura : include: Document that vkd3d_shader_signature may contain pointers into the input shader blob.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 98624f2e8fdfa9e86218e1738f72a989503ef7f7 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/98624f2e8fdfa9e86218e1738f72a… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Wed Feb 22 17:41:12 2023 -0600 include: Document that vkd3d_shader_signature may contain pointers into the input shader blob. --- include/vkd3d_shader.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index ee8ce8d0..bf5e1387 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -1839,6 +1839,9 @@ VKD3D_SHADER_API void vkd3d_shader_free_scan_descriptor_info( * Members of \a signature may be allocated by vkd3d-shader. The signature * should be freed with vkd3d_shader_free_shader_signature() when no longer * needed. + * \n + * The signature may contain pointers into the input shader, and should only be + * accessed while the input shader remains valid. * * \param messages Optional output location for error or informational messages * produced by the parser.

1 0

Giovanni Mascellani : vkd3d: Always enqueue signal operations, even when they can be executed right away.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 9eba44396a00d35366026d5e0ed85d8e6c124ca6 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/9eba44396a00d35366026d5e0ed85… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Thu Mar 2 12:04:57 2023 +0100 vkd3d: Always enqueue signal operations, even when they can be executed right away. --- libs/vkd3d/command.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 7b522427..5d8eb3e9 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -6274,12 +6274,6 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * vkd3d_mutex_lock(&command_queue->op_mutex); - if (!command_queue->ops_count) - { - hr = d3d12_command_queue_signal(command_queue, fence, value); - goto done; - } - if (!(op = d3d12_command_queue_require_space_locked(command_queue))) { hr = E_OUTOFMEMORY; @@ -6291,6 +6285,8 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * d3d12_fence_incref(fence); + d3d12_command_queue_submit_locked(command_queue); + done: vkd3d_mutex_unlock(&command_queue->op_mutex); return hr;

1 0

Giovanni Mascellani : vkd3d: Do not keep the CS queue locked while processing it.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: bb2fa97c33fd1591097741b809854763c0623697 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/bb2fa97c33fd1591097741b809854… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Thu Feb 9 12:16:34 2023 +0100 vkd3d: Do not keep the CS queue locked while processing it. d3d12_command_queue_flush_ops() can renter itself while processing signal events. Since we don't use recursive mutexes, we currently have to check some of the queue variables without holding the mutex, which is not safe. This is solved by allowing the queue to release its mutex while it is processing entries: when flushing, the queue is briefly locked, the is_flushing flag is set, the queue content is copied away and the queue is unlocked again. After having processed the entries, the queue is locked again to check is something else was added in the meantime. This is repeated until the queue is empty (or a wait operation is blocking it). This should also remove some latency when a thread pushes to the queue while another one is processing it, but I didn't try to measure any impact. While it is expected that with this patch the queue mutex will be locked and unlocked more frequently, it should also remain locked for less time, hopefully creating little contention. --- libs/vkd3d/command.c | 170 +++++++++++++++++++++++++++++++-------------- libs/vkd3d/vkd3d_private.h | 18 ++++- 2 files changed, 134 insertions(+), 54 deletions(-)

1 0

Conor McCarthy : vkd3d-shader/dxbc: Emit a shader error for an invalid signature data size.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 3b5316be821a664e54edc963fd3c69259db7df95 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/3b5316be821a664e54edc963fd3c6… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Tue Mar 7 14:04:44 2023 +1000 vkd3d-shader/dxbc: Emit a shader error for an invalid signature data size. --- libs/vkd3d-shader/dxbc.c | 2 ++ libs/vkd3d-shader/vkd3d_shader_private.h | 1 + 2 files changed, 3 insertions(+) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index b01e30e5..008be3c8 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1929,6 +1929,8 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s if (!require_space(0, 2, sizeof(uint32_t), section->data.size)) { WARN("Invalid data size %#zx.\n", section->data.size); + vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_DXBC_INVALID_SIGNATURE, + "Section size %zu is smaller than the minimum signature header size.\n", section->data.size); return VKD3D_ERROR_INVALID_ARGUMENT; } diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 78a48e55..64a53803 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -69,6 +69,7 @@ enum vkd3d_shader_error VKD3D_SHADER_ERROR_DXBC_INVALID_CHUNK_OFFSET = 5, VKD3D_SHADER_ERROR_DXBC_INVALID_CHUNK_SIZE = 6, VKD3D_SHADER_ERROR_DXBC_OUT_OF_MEMORY = 7, + VKD3D_SHADER_ERROR_DXBC_INVALID_SIGNATURE = 8, VKD3D_SHADER_ERROR_TPF_MISMATCHED_CF = 1000, VKD3D_SHADER_ERROR_TPF_INVALID_REGISTER_RANGE = 1001,

1 0

Giovanni Mascellani : vkd3d: Always enqueue execute operations, even when they can be executed right away.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 0d329ba168f98634dd680f0ff26bb13f4eab3550 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/0d329ba168f98634dd680f0ff26bb… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Wed Feb 8 17:08:50 2023 +0100 vkd3d: Always enqueue execute operations, even when they can be executed right away. The goal is to simplify the CS queue handling: with this and the following changes operations are always started by d3d12_command_queue_flush_ops(), in order to make further refactoring easier. Notice that while with this change executing an operation on an empty CS queue is a bit less efficient, it doesn't require more locking. On the other hand, this change paves the road for executing CS operations without holding the queue lock. --- libs/vkd3d/command.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 772649cd..7b522427 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -27,6 +27,7 @@ static void d3d12_fence_signal_timeline_semaphore(struct d3d12_fence *fence, uin static HRESULT d3d12_command_queue_signal(struct d3d12_command_queue *command_queue, struct d3d12_fence *fence, uint64_t value); static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any); +static HRESULT d3d12_command_queue_flush_ops_locked(struct d3d12_command_queue *queue, bool *flushed_any); HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue) @@ -6147,6 +6148,18 @@ static void d3d12_command_queue_execute(struct d3d12_command_queue *command_queu vkd3d_free(buffers); } +static void d3d12_command_queue_submit_locked(struct d3d12_command_queue *queue) +{ + bool flushed_any = false; + HRESULT hr; + + if (queue->ops_count == 1) + { + if (FAILED(hr = d3d12_command_queue_flush_ops_locked(queue, &flushed_any))) + ERR("Cannot flush queue, hr %#x.\n", hr); + } +} + static void STDMETHODCALLTYPE d3d12_command_queue_ExecuteCommandLists(ID3D12CommandQueue *iface, UINT command_list_count, ID3D12CommandList * const *command_lists) { @@ -6185,13 +6198,6 @@ static void STDMETHODCALLTYPE d3d12_command_queue_ExecuteCommandLists(ID3D12Comm vkd3d_mutex_lock(&command_queue->op_mutex); - if (!command_queue->ops_count) - { - d3d12_command_queue_execute(command_queue, buffers, command_list_count); - vkd3d_mutex_unlock(&command_queue->op_mutex); - return; - } - if (!(op = d3d12_command_queue_require_space_locked(command_queue))) { ERR("Failed to add op.\n"); @@ -6201,6 +6207,8 @@ static void STDMETHODCALLTYPE d3d12_command_queue_ExecuteCommandLists(ID3D12Comm op->u.execute.buffers = buffers; op->u.execute.buffer_count = command_list_count; + d3d12_command_queue_submit_locked(command_queue); + vkd3d_mutex_unlock(&command_queue->op_mutex); return; } @@ -6769,13 +6777,9 @@ static const struct ID3D12CommandQueueVtbl d3d12_command_queue_vtbl = d3d12_command_queue_GetDesc, }; -/* flushed_any is initialised by the caller. */ static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any) { - struct vkd3d_cs_op_data *op; - struct d3d12_fence *fence; - HRESULT hr = S_OK; - unsigned int i; + HRESULT hr; if (!queue->ops_count) return S_OK; @@ -6788,6 +6792,21 @@ static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, vkd3d_mutex_lock(&queue->op_mutex); + hr = d3d12_command_queue_flush_ops_locked(queue, flushed_any); + + vkd3d_mutex_unlock(&queue->op_mutex); + + return hr; +} + +/* flushed_any is initialised by the caller. */ +static HRESULT d3d12_command_queue_flush_ops_locked(struct d3d12_command_queue *queue, bool *flushed_any) +{ + struct vkd3d_cs_op_data *op; + struct d3d12_fence *fence; + HRESULT hr = S_OK; + unsigned int i; + /* Currently only required for d3d12_command_queue_signal(), but set it here anyway. */ queue->is_flushing = true; @@ -6832,7 +6851,6 @@ static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, done: queue->is_flushing = false; - vkd3d_mutex_unlock(&queue->op_mutex); return hr; }

1 0

Giovanni Mascellani : vkd3d: Hold the queue mutex when adding the queue to a blocked list.
by Alexandre Julliard March 8, 2023

March 8, 2023

Module: vkd3d Branch: master Commit: 0c6df4956093cf16c8b40cb1e2c83e9e2585f63a URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/0c6df4956093cf16c8b40cb1e2c83… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Wed Feb 8 15:23:56 2023 +0100 vkd3d: Hold the queue mutex when adding the queue to a blocked list. Otherwise it could be added more than once. Note that the deleted comment is wrong: between when d3d12_command_queue_flush_ops() returns and when the queue is added back to the blocked list, the queue might have been pushed to and flushed an arbitrary number of times. --- libs/vkd3d/command.c | 60 ++++++++++++++++++++++++---------------------------- 1 file changed, 28 insertions(+), 32 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 2d3007cf..772649cd 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -26,7 +26,7 @@ static HRESULT d3d12_fence_signal(struct d3d12_fence *fence, uint64_t value, VkF static void d3d12_fence_signal_timeline_semaphore(struct d3d12_fence *fence, uint64_t timeline_value); static HRESULT d3d12_command_queue_signal(struct d3d12_command_queue *command_queue, struct d3d12_fence *fence, uint64_t value); -static bool d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any); +static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any); HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue) @@ -636,27 +636,23 @@ static HRESULT d3d12_fence_update_pending_value(struct d3d12_fence *fence) return S_OK; } -static HRESULT d3d12_device_add_blocked_command_queues(struct d3d12_device *device, - struct d3d12_command_queue * const *command_queues, unsigned int count) +static HRESULT d3d12_command_queue_record_as_blocked(struct d3d12_command_queue *command_queue) { + struct d3d12_device *device = command_queue->device; HRESULT hr = S_OK; - unsigned int i; - - if (count == 0) - return S_OK; vkd3d_mutex_lock(&device->blocked_queues_mutex); - if ((i = ARRAY_SIZE(device->blocked_queues) - device->blocked_queue_count) < count) + if (device->blocked_queue_count < ARRAY_SIZE(device->blocked_queues)) { - FIXME("Failed to add %u blocked command queue(s) to device %p.\n", count - i, device); - count = i; + device->blocked_queues[device->blocked_queue_count++] = command_queue; + } + else + { + WARN("Failed to add blocked command queue %p to device %p.\n", command_queue, device); hr = E_FAIL; } - for (i = 0; i < count; ++i) - device->blocked_queues[device->blocked_queue_count++] = command_queues[i]; - vkd3d_mutex_unlock(&device->blocked_queues_mutex); return hr; } @@ -665,6 +661,7 @@ static HRESULT d3d12_device_flush_blocked_queues_once(struct d3d12_device *devic { struct d3d12_command_queue *blocked_queues[VKD3D_MAX_DEVICE_BLOCKED_QUEUES]; unsigned int i, blocked_queue_count; + HRESULT hr = S_OK; *flushed_any = false; @@ -679,18 +676,17 @@ static HRESULT d3d12_device_flush_blocked_queues_once(struct d3d12_device *devic vkd3d_mutex_unlock(&device->blocked_queues_mutex); - i = 0; - while (i < blocked_queue_count) + for (i = 0; i < blocked_queue_count; ++i) { - if (d3d12_command_queue_flush_ops(blocked_queues[i], flushed_any)) - blocked_queues[i] = blocked_queues[--blocked_queue_count]; - else - ++i; + HRESULT new_hr; + + new_hr = d3d12_command_queue_flush_ops(blocked_queues[i], flushed_any); + + if (SUCCEEDED(hr)) + hr = new_hr; } - /* None of these queues could have been re-added during the above loop because - * blocked queues always have a nonzero op count. */ - return d3d12_device_add_blocked_command_queues(device, blocked_queues, blocked_queue_count); + return hr; } static HRESULT d3d12_device_flush_blocked_queues(struct d3d12_device *device) @@ -6640,7 +6636,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Wait(ID3D12CommandQueue *if /* Add the queue to the blocked list after writing the op to ensure the queue isn't * removed again in another thread because it has no ops. */ if (command_queue->ops_count == 1) - hr = d3d12_device_add_blocked_command_queues(command_queue->device, &command_queue, 1); + hr = d3d12_command_queue_record_as_blocked(command_queue); /* The fence must remain locked until the op is created and the queue is added to the blocked list, * because if an unblocking d3d12_fence_Signal() call occurs on another thread before the above @@ -6774,21 +6770,21 @@ static const struct ID3D12CommandQueueVtbl d3d12_command_queue_vtbl = }; /* flushed_any is initialised by the caller. */ -static bool d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any) +static HRESULT d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, bool *flushed_any) { struct vkd3d_cs_op_data *op; struct d3d12_fence *fence; - bool flushed_all = false; + HRESULT hr = S_OK; unsigned int i; if (!queue->ops_count) - return true; + return S_OK; - /* This function may be re-entered during a call below to d3d12_command_queue_signal(). - * We return true because the first caller is responsible for re-adding this queue to - * the flush list if it ends up returning false. */ + /* This function may be re-entered when invoking + * d3d12_command_queue_signal(). The first call is responsible + * for re-adding the queue to the flush list. */ if (queue->is_flushing) - return true; + return S_OK; vkd3d_mutex_lock(&queue->op_mutex); @@ -6808,6 +6804,7 @@ static bool d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, boo vkd3d_mutex_unlock(&fence->mutex); queue->ops_count -= i; memmove(queue->ops, op, queue->ops_count * sizeof(*op)); + hr = d3d12_command_queue_record_as_blocked(queue); goto done; } d3d12_command_queue_wait_locked(queue, fence, op->u.wait.value); @@ -6831,13 +6828,12 @@ static bool d3d12_command_queue_flush_ops(struct d3d12_command_queue *queue, boo } queue->ops_count = 0; - flushed_all = true; done: queue->is_flushing = false; vkd3d_mutex_unlock(&queue->op_mutex); - return flushed_all; + return hr; } static HRESULT d3d12_command_queue_init(struct d3d12_command_queue *queue,

1 0