November 2019 - Wine-devel - list.winehq.org

vkd3d: Thoughts on how to include shaders in the project?
by Philip Rebohle 04 Nov '19

04 Nov '19

Hello, I'm currently looking into getting Deus Ex: Mankind Divided to run on vkd3d. Among other issues, it uses ClearUnorderedAccessView for typed buffer views, which is currently not supported and will require the use of a compute shader. There are also a few other areas where shader-based implementations might become necessary in the future, e.g. for copies between depth and color images, ResolveSubresource with typeless images, etc. What would be the preferred way to integrate shaders for this purpose in vkd3d? One option would be to compile GLSL shaders at build-time to a C header containing the SPIR-V code, which could then be included in the vkd3d source files directly. This would introduce glslangValidator as a new build-time dependency, is that acceptable? Also, how would this be implemented in the build system? I don't have much experience with autoconf, so some help in that regard would be highly appreciated. I'd like to avoid including pre-compiled SPIR-V binaries in the source tree directly or installing them as separate files if possible, since doing so would complicate the workflow significantly. Regards, - Philip

3 6

[PATCH v3 1/9] vbscript: Use arrays for global variable and function lists.
by Gabriel Ivăncescu 04 Nov '19

04 Nov '19

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- Supersedes 172426 to 172433. DISPID_FUNCTION_MASK has been chosen to be the same bit used in TypeLibs to separate functions from variables in MEMBERIDs. dlls/vbscript/compile.c | 31 +++++----- dlls/vbscript/interp.c | 56 ++++++++++++----- dlls/vbscript/vbdisp.c | 127 ++++++++++++--------------------------- dlls/vbscript/vbscript.c | 10 ++- dlls/vbscript/vbscript.h | 52 +++++++++++++--- 5 files changed, 149 insertions(+), 127 deletions(-) diff --git a/dlls/vbscript/compile.c b/dlls/vbscript/compile.c index 0727979..f7bceeb 100644 --- a/dlls/vbscript/compile.c +++ b/dlls/vbscript/compile.c @@ -1780,17 +1780,18 @@ static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl) static BOOL lookup_script_identifier(script_ctx_t *script, const WCHAR *identifier) { + dynamic_var_t **vars = script->global_vars; + function_t **funcs = script->global_funcs; class_desc_t *class; - dynamic_var_t *var; - function_t *func; + UINT i; - for(var = script->global_vars; var; var = var->next) { - if(!wcsicmp(var->name, identifier)) + for(i = 0; i < script->global_vars_num; i++) { + if(!wcsicmp(vars[i]->name, identifier)) return TRUE; } - for(func = script->global_funcs; func; func = func->next) { - if(!wcsicmp(func->name, identifier)) + for(i = 0; i < script->global_funcs_num; i++) { + if(!wcsicmp(funcs[i]->name, identifier)) return TRUE; } @@ -1956,17 +1957,19 @@ HRESULT compile_script(script_ctx_t *script, const WCHAR *src, const WCHAR *deli if(ctx.global_vars) { dynamic_var_t *var; - for(var = ctx.global_vars; var->next; var = var->next); - - var->next = script->global_vars; - script->global_vars = ctx.global_vars; + for (var = ctx.global_vars; var; var = var->next) + if (!add_global_var(script, var)) { + release_compiler(&ctx); + return compile_error(script, E_OUTOFMEMORY); + } } if(ctx.funcs) { - for(new_func = ctx.funcs; new_func->next; new_func = new_func->next); - - new_func->next = script->global_funcs; - script->global_funcs = ctx.funcs; + for (new_func = ctx.funcs; new_func; new_func = new_func->next) + if (!add_global_func(script, new_func)) { + release_compiler(&ctx); + return compile_error(script, E_OUTOFMEMORY); + } } if(ctx.classes) { diff --git a/dlls/vbscript/interp.c b/dlls/vbscript/interp.c index ad6454a..acd524f 100644 --- a/dlls/vbscript/interp.c +++ b/dlls/vbscript/interp.c @@ -95,10 +95,41 @@ static BOOL lookup_dynamic_vars(dynamic_var_t *var, const WCHAR *name, ref_t *re return FALSE; } +static BOOL lookup_global_vars(script_ctx_t *script, const WCHAR *name, ref_t *ref) +{ + dynamic_var_t **vars = script->global_vars; + UINT i, num = script->global_vars_num; + + for (i = 0; i < num; i++) { + if (!wcsicmp(vars[i]->name, name)) { + ref->type = vars[i]->is_const ? REF_CONST : REF_VAR; + ref->u.v = &vars[i]->v; + return TRUE; + } + } + + return FALSE; +} + +static BOOL lookup_global_funcs(script_ctx_t *script, const WCHAR *name, ref_t *ref) +{ + function_t **funcs = script->global_funcs; + UINT i, num = script->global_funcs_num; + + for (i = 0; i < num; i++) { + if (!wcsicmp(funcs[i]->name, name)) { + ref->type = REF_FUNC; + ref->u.f = funcs[i]; + return TRUE; + } + } + + return FALSE; +} + static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_t invoke_type, ref_t *ref) { named_item_t *item; - function_t *func; IDispatch *disp; unsigned i; DISPID id; @@ -128,10 +159,13 @@ static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_ } } - if(lookup_dynamic_vars(ctx->func->type == FUNC_GLOBAL ? ctx->script->global_vars : ctx->dynamic_vars, name, ref)) - return S_OK; + if(ctx->func->type == FUNC_GLOBAL) { + if(lookup_global_vars(ctx->script, name, ref)) + return S_OK; + }else { + if(lookup_dynamic_vars(ctx->dynamic_vars, name, ref)) + return S_OK; - if(ctx->func->type != FUNC_GLOBAL) { if(ctx->vbthis) { /* FIXME: Bind such identifier while generating bytecode. */ for(i=0; i < ctx->vbthis->desc->prop_cnt; i++) { @@ -162,16 +196,11 @@ static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_ } } - if(ctx->func->type != FUNC_GLOBAL && lookup_dynamic_vars(ctx->script->global_vars, name, ref)) + if(ctx->func->type != FUNC_GLOBAL && lookup_global_vars(ctx->script, name, ref)) return S_OK; - for(func = ctx->script->global_funcs; func; func = func->next) { - if(!wcsicmp(func->name, name)) { - ref->type = REF_FUNC; - ref->u.f = func; - return S_OK; - } - } + if(lookup_global_funcs(ctx->script, name, ref)) + return S_OK; hres = get_builtin_id(ctx->script->global_obj, name, &id); if(SUCCEEDED(hres)) { @@ -228,8 +257,7 @@ static HRESULT add_dynamic_var(exec_ctx_t *ctx, const WCHAR *name, V_VT(&new_var->v) = VT_EMPTY; if(ctx->func->type == FUNC_GLOBAL) { - new_var->next = ctx->script->global_vars; - ctx->script->global_vars = new_var; + add_global_var(ctx->script, new_var); }else { new_var->next = ctx->dynamic_vars; ctx->dynamic_vars = new_var; diff --git a/dlls/vbscript/vbdisp.c b/dlls/vbscript/vbdisp.c index 25a80fc..7b5e28f 100644 --- a/dlls/vbscript/vbdisp.c +++ b/dlls/vbscript/vbdisp.c @@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(vbscript); +#define DISPID_FUNCTION_MASK 0x20000000 #define FDEX_VERSION_MASK 0xf0000000 static inline BOOL is_func_id(vbdisp_t *This, DISPID id) @@ -526,49 +527,6 @@ HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret) return S_OK; } -struct _ident_map_t { - const WCHAR *name; - BOOL is_var; - union { - dynamic_var_t *var; - function_t *func; - } u; -}; - -static inline DISPID ident_to_id(ScriptDisp *This, ident_map_t *ident) -{ - return (ident-This->ident_map)+1; -} - -static inline ident_map_t *id_to_ident(ScriptDisp *This, DISPID id) -{ - return 0 < id && id <= This->ident_map_cnt ? This->ident_map+id-1 : NULL; -} - -static ident_map_t *add_ident(ScriptDisp *This, const WCHAR *name) -{ - ident_map_t *ret; - - if(!This->ident_map_size) { - This->ident_map = heap_alloc(4 * sizeof(*This->ident_map)); - if(!This->ident_map) - return NULL; - This->ident_map_size = 4; - }else if(This->ident_map_cnt == This->ident_map_size) { - ident_map_t *new_map; - - new_map = heap_realloc(This->ident_map, 2*This->ident_map_size*sizeof(*new_map)); - if(!new_map) - return NULL; - This->ident_map = new_map; - This->ident_map_size *= 2; - } - - ret = This->ident_map + This->ident_map_cnt++; - ret->name = name; - return ret; -} - static inline ScriptDisp *ScriptDisp_from_IDispatchEx(IDispatchEx *iface) { return CONTAINING_RECORD(iface, ScriptDisp, IDispatchEx_iface); @@ -616,7 +574,6 @@ static ULONG WINAPI ScriptDisp_Release(IDispatchEx *iface) if(!ref) { assert(!This->ctx); - heap_free(This->ident_map); heap_free(This); } @@ -675,44 +632,29 @@ static HRESULT WINAPI ScriptDisp_Invoke(IDispatchEx *iface, DISPID dispIdMember, static HRESULT WINAPI ScriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); - dynamic_var_t *var; - ident_map_t *ident; - function_t *func; + dynamic_var_t **vars; + function_t **funcs; + UINT i, num; TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid); if(!This->ctx) return E_UNEXPECTED; - for(ident = This->ident_map; ident < This->ident_map+This->ident_map_cnt; ident++) { - if(!wcsicmp(ident->name, bstrName)) { - *pid = ident_to_id(This, ident); + vars = This->ctx->global_vars; + num = This->ctx->global_vars_num; + for(i = 0; i < num; i++) { + if(!wcsicmp(vars[i]->name, bstrName)) { + *pid = i + 1; return S_OK; } } - for(var = This->ctx->global_vars; var; var = var->next) { - if(!wcsicmp(var->name, bstrName)) { - ident = add_ident(This, var->name); - if(!ident) - return E_OUTOFMEMORY; - - ident->is_var = TRUE; - ident->u.var = var; - *pid = ident_to_id(This, ident); - return S_OK; - } - } - - for(func = This->ctx->global_funcs; func; func = func->next) { - if(!wcsicmp(func->name, bstrName)) { - ident = add_ident(This, func->name); - if(!ident) - return E_OUTOFMEMORY; - - ident->is_var = FALSE; - ident->u.func = func; - *pid = ident_to_id(This, ident); + funcs = This->ctx->global_funcs; + num = This->ctx->global_funcs_num; + for(i = 0; i < num; i++) { + if(!wcsicmp(funcs[i]->name, bstrName)) { + *pid = i + 1 + DISPID_FUNCTION_MASK; return S_OK; } } @@ -725,35 +667,40 @@ static HRESULT WINAPI ScriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lc VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); - ident_map_t *ident; HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); - ident = id_to_ident(This, id); - if(!ident) - return DISP_E_MEMBERNOTFOUND; + if (id & DISPID_FUNCTION_MASK) + { + id &= ~DISPID_FUNCTION_MASK; + if (id > This->ctx->global_funcs_num) + return DISP_E_MEMBERNOTFOUND; - if(ident->is_var) { - if(ident->u.var->is_const) { - FIXME("const not supported\n"); - return E_NOTIMPL; + switch (wFlags) + { + case DISPATCH_METHOD: + case DISPATCH_METHOD | DISPATCH_PROPERTYGET: + hres = exec_script(This->ctx, TRUE, This->ctx->global_funcs[id - 1], NULL, pdp, pvarRes); + break; + default: + FIXME("Unsupported flags %x\n", wFlags); + hres = E_NOTIMPL; } - return invoke_variant_prop(This->ctx, &ident->u.var->v, wFlags, pdp, pvarRes); + return hres; } - switch(wFlags) { - case DISPATCH_METHOD: - case DISPATCH_METHOD|DISPATCH_PROPERTYGET: - hres = exec_script(This->ctx, TRUE, ident->u.func, NULL, pdp, pvarRes); - break; - default: - FIXME("Unsupported flags %x\n", wFlags); - hres = E_NOTIMPL; + if (id > This->ctx->global_vars_num) + return DISP_E_MEMBERNOTFOUND; + + if (This->ctx->global_vars[id - 1]->is_const) + { + FIXME("const not supported\n"); + return E_NOTIMPL; } - return hres; + return invoke_variant_prop(This->ctx, &This->ctx->global_vars[id - 1]->v, wFlags, pdp, pvarRes); } static HRESULT WINAPI ScriptDisp_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex) diff --git a/dlls/vbscript/vbscript.c b/dlls/vbscript/vbscript.c index 56c53b4..1f8c48e 100644 --- a/dlls/vbscript/vbscript.c +++ b/dlls/vbscript/vbscript.c @@ -131,12 +131,20 @@ IDispatch *lookup_named_item(script_ctx_t *ctx, const WCHAR *name, unsigned flag static void release_script(script_ctx_t *ctx) { class_desc_t *class_desc; + UINT i; collect_objects(ctx); clear_ei(&ctx->ei); - release_dynamic_vars(ctx->global_vars); + for(i = 0; i < ctx->global_vars_num; i++) + VariantClear(&ctx->global_vars[i]->v); + + heap_free(ctx->global_vars); + heap_free(ctx->global_funcs); ctx->global_vars = NULL; + ctx->global_funcs = NULL; + ctx->global_vars_num = 0; + ctx->global_funcs_num = 0; while(!list_empty(&ctx->named_items)) { named_item_t *iter = LIST_ENTRY(list_head(&ctx->named_items), named_item_t, entry); diff --git a/dlls/vbscript/vbscript.h b/dlls/vbscript/vbscript.h index fefed63..38fb874 100644 --- a/dlls/vbscript/vbscript.h +++ b/dlls/vbscript/vbscript.h @@ -34,6 +34,11 @@ #include "wine/heap.h" #include "wine/list.h" +static inline BOOL is_power_of_2(unsigned x) +{ + return !(x & (x - 1)); +} + typedef struct { void **blocks; DWORD block_cnt; @@ -120,16 +125,10 @@ struct _vbdisp_t { VARIANT props[1]; }; -typedef struct _ident_map_t ident_map_t; - typedef struct { IDispatchEx IDispatchEx_iface; LONG ref; - ident_map_t *ident_map; - unsigned ident_map_cnt; - unsigned ident_map_size; - script_ctx_t *ctx; } ScriptDisp; @@ -187,8 +186,11 @@ struct _script_ctx_t { EXCEPINFO ei; - dynamic_var_t *global_vars; - function_t *global_funcs; + UINT global_vars_num; + UINT global_funcs_num; + + dynamic_var_t **global_vars; + function_t **global_funcs; class_desc_t *classes; class_desc_t *procs; @@ -350,6 +352,40 @@ struct _vbscode_t { struct list entry; }; +static inline BOOL add_global_var(script_ctx_t *obj, dynamic_var_t *var) +{ + dynamic_var_t **vars; + + if (is_power_of_2(obj->global_vars_num)) + { + UINT num = max(16, obj->global_vars_num * 2); + + vars = heap_realloc(obj->global_vars, num * sizeof(*obj->global_vars)); + if (!vars) return FALSE; + obj->global_vars = vars; + } + obj->global_vars[obj->global_vars_num++] = var; + + return TRUE; +} + +static inline BOOL add_global_func(script_ctx_t *obj, function_t *func) +{ + function_t **funcs; + + if (is_power_of_2(obj->global_funcs_num)) + { + UINT num = max(16, obj->global_funcs_num * 2); + + funcs = heap_realloc(obj->global_funcs, num * sizeof(*obj->global_funcs)); + if (!funcs) return FALSE; + obj->global_funcs = funcs; + } + obj->global_funcs[obj->global_funcs_num++] = func; + + return TRUE; +} + void release_vbscode(vbscode_t*) DECLSPEC_HIDDEN; HRESULT compile_script(script_ctx_t*,const WCHAR*,const WCHAR*,DWORD,vbscode_t**) DECLSPEC_HIDDEN; HRESULT compile_procedure(script_ctx_t*,const WCHAR*,const WCHAR*,DWORD,class_desc_t**) DECLSPEC_HIDDEN; -- 2.21.0

2 9

[PATCH 4/4] vbscript: Allow arbitrary number of arguments in builtin functions.
by Jacek Caban 04 Nov '19

04 Nov '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/vbscript/global.c | 16 +++++++++++++--- dlls/vbscript/tests/api.vbs | 5 +++++ 2 files changed, 18 insertions(+), 3 deletions(-)

1 0

[PATCH 3/4] vbscript: Replace existing function for duplicated functions.
by Jacek Caban 04 Nov '19

04 Nov '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/vbscript/compile.c | 24 +++++++++++---------- dlls/vbscript/tests/lang.vbs | 15 +++++++++++++ dlls/vbscript/tests/run.c | 42 ++++++++++++++++++++++++++++++++++++ 3 files changed, 70 insertions(+), 11 deletions(-)

1 0

[PATCH 2/4] vbscript: Store global functions in an array.
by Jacek Caban 04 Nov '19

04 Nov '19

Based on patch by Gabriel Ivăncescu. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/vbscript/compile.c | 31 +++++++++++++++++++++---------- dlls/vbscript/interp.c | 4 ++-- dlls/vbscript/vbdisp.c | 5 +++-- dlls/vbscript/vbscript.c | 5 +++++ dlls/vbscript/vbscript.h | 5 ++++- 5 files changed, 35 insertions(+), 15 deletions(-)

1 0

[PATCH 1/4] vbscript: Support assigning to object default value.
by Jacek Caban 04 Nov '19

04 Nov '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/vbscript/interp.c | 5 +++ dlls/vbscript/tests/run.c | 64 +++++++++++++++++++++++++++------------ 2 files changed, 50 insertions(+), 19 deletions(-)

1 0

[PATCH] comctl32: Listbox item height is no longer limited to 255.
by Francois Gouget 04 Nov '19

04 Nov '19

The change happened between Windows 10 1607 and 1709 in comctl32 v6. Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- I confirmed the change in behavior by running ControlSpyV6.exe and manually sending the LB_SETITEMHEIGHT and LB_GETITEMHEIGHT messages, and also observing the impact on the rendering. I also ran the test in ControlSpyV5.exe which shows that comctl32 v5 still enforces the 255 height limit. I chose to have Wine implement the new behavior but maybe that should be dependent on v5 vs v6. Not sure how that's handled though. dlls/comctl32/listbox.c | 2 +- dlls/comctl32/tests/listbox.c | 25 ++++++++++++++++++++++--- 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index ab4c481aabc..0d6dcd6a0b8 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -1280,7 +1280,7 @@ static LRESULT LISTBOX_GetItemHeight( const LB_DESCR *descr, INT index ) */ static LRESULT LISTBOX_SetItemHeight( LB_DESCR *descr, INT index, INT height, BOOL repaint ) { - if (height > MAXBYTE) + if (height > MAXWORD) return -1; if (!height) height = 1; diff --git a/dlls/comctl32/tests/listbox.c b/dlls/comctl32/tests/listbox.c index 70e212892a4..d547fecc588 100644 --- a/dlls/comctl32/tests/listbox.c +++ b/dlls/comctl32/tests/listbox.c @@ -769,11 +769,30 @@ static void test_listbox_height(void) r = SendMessageA(hList, LB_GETITEMHEIGHT, 0, 0 ); ok( r == 20, "height wrong\n"); + /* Before Windows 10 1709 (or 1703?) the item height was limited to 255. + * Since then, with comctl32 V6 the limit is 65535. + */ r = SendMessageA( hList, LB_SETITEMHEIGHT, 0, MAKELPARAM( 256, 0 )); - ok( r == -1, "Failed to set item height, %d.\n", r); + if (r == -1) + { + ok(broken(r == -1), "Failed to set item height, %d.\n", r); - r = SendMessageA(hList, LB_GETITEMHEIGHT, 0, 0 ); - ok( r == 20, "Unexpected item height %d.\n", r); + r = SendMessageA(hList, LB_GETITEMHEIGHT, 0, 0 ); + ok( r == 20, "Unexpected item height %d.\n", r); + } + else + { + ok(r == 0, "Failed to set item height, %d.\n", r); + + r = SendMessageA(hList, LB_GETITEMHEIGHT, 0, 0 ); + ok( r == 256, "Unexpected item height %d.\n", r); + + r = SendMessageA( hList, LB_SETITEMHEIGHT, 0, MAKELPARAM( 65535, 0 )); + ok(r == 0, "Failed to set item height, %d.\n", r); + + r = SendMessageA(hList, LB_GETITEMHEIGHT, 0, 0 ); + ok( r == 65535, "Unexpected item height %d.\n", r); + } r = SendMessageA( hList, LB_SETITEMHEIGHT, 0, MAKELPARAM( 0xff, 0 )); ok( r == 0, "send message failed\n"); -- 2.20.1

1 0

[PATCH] vkd3d: Support RS 1.0 VOLATILE descriptors.
by Hans-Kristian Arntzen 04 Nov '19

04 Nov '19

Use EXT_descriptor_indexing's UPDATE_AFTER_BIND feature to support semantics required by RS 1.0 VOLATILE descriptors. We implement this by deferring all updates of desciptor sets until Submit time. This is fine, as command buffers cannot be executed simultaneously on D3D12, so at Submit time, we know that the command buffer is not being executed on the GPU, and updating descriptors for multiple submissions is correct. If EXT_descriptor_indexing is not available, the fallback is the older method, which matches RS 1.1 STATIC descriptor model. Signed-off-by: Hans-Kristian Arntzen <post(a)arntzen-software.no> --- libs/vkd3d/command.c | 358 +++++++++++++++++++++++++++++-------- libs/vkd3d/device.c | 20 ++- libs/vkd3d/state.c | 22 +++ libs/vkd3d/vkd3d_private.h | 19 +- tests/d3d12.c | 2 +- 5 files changed, 338 insertions(+), 83 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 0532ec0..3f78d17 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -1341,7 +1341,7 @@ static VkDescriptorPool d3d12_command_allocator_allocate_descriptor_pool( { pool_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; pool_desc.pNext = NULL; - pool_desc.flags = 0; + pool_desc.flags = device->vk_info.EXT_descriptor_indexing ? VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT : 0; pool_desc.maxSets = 512; pool_desc.poolSizeCount = ARRAY_SIZE(pool_sizes); pool_desc.pPoolSizes = pool_sizes; @@ -1865,6 +1865,10 @@ static void d3d12_command_list_invalidate_bindings(struct d3d12_command_list *li if (!state) return; + /* Each pipeline state has its own set layout for UAV counters + * based on their implicit usage in the shader. + * Binding a different pipeline state means having to re-remit + * UAV counters in a new descriptor set (and layout). */ if (state->uav_counter_mask) { struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[state->vk_bind_point]; @@ -2196,6 +2200,7 @@ static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandL if (list->allocator) d3d12_command_allocator_free_command_buffer(list->allocator, list); + vkd3d_free(list->descriptor_updates); vkd3d_free(list); d3d12_device_release(device); @@ -2334,6 +2339,9 @@ static void d3d12_command_list_reset_state(struct d3d12_command_list *list, list->state = NULL; + /* Recycle deferred descriptor update memory if possible. */ + list->descriptor_updates_count = 0; + memset(list->so_counter_buffers, 0, sizeof(list->so_counter_buffers)); memset(list->so_counter_buffer_offsets, 0, sizeof(list->so_counter_buffer_offsets)); @@ -2534,15 +2542,54 @@ static void d3d12_command_list_prepare_descriptors(struct d3d12_command_list *li * time in between. Thus, the contents must not be altered (overwritten * by an update command, or freed) between when the command is recorded * and when the command completes executing on the queue." + * + * Even if we have descriptor indexing and UPDATE_AFTER_BIND, + * we need at the very least a new descriptor set. */ bindings->descriptor_set = d3d12_command_allocator_allocate_descriptor_set(list->allocator, root_signature->vk_set_layout); + bindings->in_use = false; bindings->descriptor_table_dirty_mask |= bindings->descriptor_table_active_mask & root_signature->descriptor_table_mask; bindings->push_descriptor_dirty_mask |= bindings->push_descriptor_active_mask & root_signature->push_descriptor_mask; } +static void d3d12_command_list_prepare_uav_counter_descriptors(struct d3d12_command_list *list, + VkPipelineBindPoint bind_point) +{ + struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; + + if (bindings->uav_counter_descriptor_set && !bindings->uav_counter_in_use) + return; + + /* We cannot modify bound descriptor sets. We need a new descriptor set if + * we are about to update resource bindings. + * + * The Vulkan spec says: + * + * "The descriptor set contents bound by a call to + * vkCmdBindDescriptorSets may be consumed during host execution of the + * command, or during shader execution of the resulting draws, or any + * time in between. Thus, the contents must not be altered (overwritten + * by an update command, or freed) between when the command is recorded + * and when the command completes executing on the queue." + * + * Even if we have descriptor indexing and UPDATE_AFTER_BIND, + * we need at the very least a new descriptor set. + */ + + if (list->state->uav_counter_mask) + { + bindings->uav_counter_descriptor_set = d3d12_command_allocator_allocate_descriptor_set(list->allocator, + list->state->vk_set_layout); + } + else + bindings->uav_counter_descriptor_set = VK_NULL_HANDLE; + + bindings->uav_counter_in_use = false; +} + static bool vk_write_descriptor_set_from_d3d12_desc(VkWriteDescriptorSet *vk_descriptor_write, VkDescriptorImageInfo *vk_image_info, const struct d3d12_desc *descriptor, uint32_t descriptor_range_magic, VkDescriptorSet vk_descriptor_set, @@ -2611,26 +2658,61 @@ static bool vk_write_descriptor_set_from_d3d12_desc(VkWriteDescriptorSet *vk_des return true; } -static void d3d12_command_list_update_descriptor_table(struct d3d12_command_list *list, - VkPipelineBindPoint bind_point, unsigned int index, struct d3d12_desc *base_descriptor) +static void d3d12_command_list_defer_update_descriptor_table(struct d3d12_command_list *list, + VkPipelineBindPoint bind_point, uint64_t table_mask, bool uav) { + const struct d3d12_desc *base_descriptor; + unsigned i; + struct d3d12_deferred_descriptor_set_update *update; struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; - struct VkWriteDescriptorSet descriptor_writes[24], *current_descriptor_write; - const struct d3d12_root_signature *root_signature = bindings->root_signature; + + for (i = 0; i < ARRAY_SIZE(bindings->descriptor_tables); ++i) + { + if (table_mask & ((uint64_t)1 << i)) + { + if ((base_descriptor = d3d12_desc_from_gpu_handle(bindings->descriptor_tables[i]))) + { + vkd3d_array_reserve((void **)&list->descriptor_updates, &list->descriptor_updates_size, + list->descriptor_updates_count + 1, sizeof(*list->descriptor_updates)); + update = &list->descriptor_updates[list->descriptor_updates_count]; + + update->base_descriptor = base_descriptor; + update->index = i; + update->root_signature = bindings->root_signature; + update->descriptor_set = uav ? bindings->uav_counter_descriptor_set : bindings->descriptor_set; + update->uav = uav; + list->descriptor_updates_count++; + } + else + WARN("Descriptor table %u is not set.\n", i); + } + } +} + +static void d3d12_command_list_resolve_descriptor_table_uav(struct d3d12_command_list *list, + const struct d3d12_deferred_descriptor_set_update *update) +{ + const struct d3d12_root_signature *root_signature = update->root_signature; const struct vkd3d_vk_device_procs *vk_procs = &list->device->vk_procs; - struct VkDescriptorImageInfo image_infos[24], *current_image_info; 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; - struct d3d12_desc *descriptor; - - descriptor_table = root_signature_get_descriptor_table(root_signature, index); + unsigned int i, j; + unsigned int uav_counter_count; + const struct d3d12_desc *descriptor; + VkWriteDescriptorSet vk_descriptor_writes[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; + VkBufferView vk_uav_counter_views[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; + VkDescriptorSet vk_descriptor_set; + const struct d3d12_desc *base_descriptor = update->base_descriptor; + descriptor_table = root_signature_get_descriptor_table(root_signature, update->index); descriptor = base_descriptor; - descriptor_count = 0; - current_descriptor_write = descriptor_writes; - current_image_info = image_infos; + + vk_descriptor_set = update->descriptor_set; + if (!vk_descriptor_set) + return; + + /* FIXME: There should be a smarter way than scanning through all the descriptor table ranges for this. */ for (i = 0; i < descriptor_table->range_count; ++i) { range = &descriptor_table->ranges[i]; @@ -2644,20 +2726,74 @@ static void d3d12_command_list_update_descriptor_table(struct d3d12_command_list { unsigned int register_idx = range->base_register_idx + j; - /* Track UAV counters. */ + /* Fish out UAV counters. */ if (range->descriptor_magic == VKD3D_DESCRIPTOR_MAGIC_UAV - && register_idx < ARRAY_SIZE(bindings->vk_uav_counter_views)) + && register_idx < ARRAY_SIZE(vk_uav_counter_views)) { 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; + ? descriptor->u.view->vk_counter_view : VK_NULL_HANDLE; + vk_uav_counter_views[register_idx] = vk_counter_view; } + } + } + + uav_counter_count = vkd3d_popcount(list->state->uav_counter_mask); + assert(uav_counter_count <= ARRAY_SIZE(vk_descriptor_writes)); + + for (i = 0; i < uav_counter_count; ++i) + { + const struct vkd3d_shader_uav_counter_binding *uav_counter = &list->state->uav_counters[i]; + assert(vk_uav_counter_views[uav_counter->register_index]); + + vk_descriptor_writes[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + vk_descriptor_writes[i].pNext = NULL; + vk_descriptor_writes[i].dstSet = vk_descriptor_set; + vk_descriptor_writes[i].dstBinding = uav_counter->binding.binding; + vk_descriptor_writes[i].dstArrayElement = 0; + vk_descriptor_writes[i].descriptorCount = 1; + 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_CALL(vkUpdateDescriptorSets(vk_device, uav_counter_count, vk_descriptor_writes, 0, NULL)); +} + +static void d3d12_command_list_resolve_descriptor_table_normal(struct d3d12_command_list *list, + const struct d3d12_deferred_descriptor_set_update *update) +{ + const struct d3d12_root_descriptor_table *descriptor_table; + struct VkWriteDescriptorSet descriptor_writes[24], *current_descriptor_write; + struct VkDescriptorImageInfo image_infos[24], *current_image_info; + const struct d3d12_root_signature *root_signature = update->root_signature; + const struct vkd3d_vk_device_procs *vk_procs = &list->device->vk_procs; + const struct d3d12_root_descriptor_table_range *range; + VkDevice vk_device = list->device->vk_device; + unsigned int i, j, descriptor_count; + const struct d3d12_desc *descriptor; + const struct d3d12_desc *base_descriptor = update->base_descriptor; + + descriptor_table = root_signature_get_descriptor_table(root_signature, update->index); + + descriptor = update->base_descriptor; + descriptor_count = 0; + current_descriptor_write = descriptor_writes; + current_image_info = image_infos; + for (i = 0; i < descriptor_table->range_count; ++i) + { + range = &descriptor_table->ranges[i]; + if (range->offset != D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + descriptor = base_descriptor + range->offset; + } + + for (j = 0; j < range->descriptor_count; ++j, ++descriptor) + { if (!vk_write_descriptor_set_from_d3d12_desc(current_descriptor_write, - current_image_info, descriptor, range->descriptor_magic, - bindings->descriptor_set, range->binding, j)) + current_image_info, descriptor, range->descriptor_magic, + update->descriptor_set, range->binding, j)) continue; ++descriptor_count; @@ -2677,6 +2813,52 @@ static void d3d12_command_list_update_descriptor_table(struct d3d12_command_list VK_CALL(vkUpdateDescriptorSets(vk_device, descriptor_count, descriptor_writes, 0, NULL)); } +static void d3d12_command_list_resolve_descriptor_table(struct d3d12_command_list *list, + const struct d3d12_deferred_descriptor_set_update *update) +{ + if (update->uav) + d3d12_command_list_resolve_descriptor_table_uav(list, update); + else + d3d12_command_list_resolve_descriptor_table_normal(list, update); +} + +static void d3d12_command_list_resolve_descriptor_tables(struct d3d12_command_list *list) +{ + unsigned i; + for (i = 0; i < list->descriptor_updates_count; i++) + d3d12_command_list_resolve_descriptor_table(list, &list->descriptor_updates[i]); +} + +static void d3d12_command_list_update_descriptor_table(struct d3d12_command_list *list, + VkPipelineBindPoint bind_point, unsigned int index, struct d3d12_desc *base_descriptor) +{ + struct d3d12_deferred_descriptor_set_update update; + struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; + const struct d3d12_root_signature *root_signature = bindings->root_signature; + + update.descriptor_set = bindings->descriptor_set; + update.index = index; + update.root_signature = root_signature; + update.base_descriptor = base_descriptor; + update.uav = false; + d3d12_command_list_resolve_descriptor_table_normal(list, &update); +} + +static void d3d12_command_list_update_uav_counter_descriptor_table(struct d3d12_command_list *list, + VkPipelineBindPoint bind_point, unsigned int index, struct d3d12_desc *base_descriptor) +{ + struct d3d12_deferred_descriptor_set_update update; + struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; + const struct d3d12_root_signature *root_signature = bindings->root_signature; + + update.descriptor_set = bindings->uav_counter_descriptor_set; + update.index = index; + update.root_signature = root_signature; + update.base_descriptor = base_descriptor; + update.uav = true; + d3d12_command_list_resolve_descriptor_table_uav(list, &update); +} + static bool vk_write_descriptor_set_from_root_descriptor(VkWriteDescriptorSet *vk_descriptor_write, const struct d3d12_root_parameter *root_parameter, VkDescriptorSet vk_descriptor_set, VkBufferView *vk_buffer_view, const VkDescriptorBufferInfo *vk_buffer_info) @@ -2781,55 +2963,6 @@ done: vkd3d_free(buffer_infos); } -static void d3d12_command_list_update_uav_counter_descriptors(struct d3d12_command_list *list, - VkPipelineBindPoint bind_point) -{ - VkWriteDescriptorSet vk_descriptor_writes[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; - struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; - const struct vkd3d_vk_device_procs *vk_procs = &list->device->vk_procs; - const struct d3d12_pipeline_state *state = list->state; - VkDevice vk_device = list->device->vk_device; - VkDescriptorSet vk_descriptor_set; - unsigned int uav_counter_count; - unsigned int i; - - if (!state || !(state->uav_counter_mask & bindings->uav_counter_dirty_mask)) - return; - - uav_counter_count = vkd3d_popcount(state->uav_counter_mask); - assert(uav_counter_count <= ARRAY_SIZE(vk_descriptor_writes)); - - vk_descriptor_set = d3d12_command_allocator_allocate_descriptor_set(list->allocator, state->vk_set_layout); - if (!vk_descriptor_set) - return; - - for (i = 0; i < uav_counter_count; ++i) - { - 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]); - - vk_descriptor_writes[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - vk_descriptor_writes[i].pNext = NULL; - vk_descriptor_writes[i].dstSet = vk_descriptor_set; - vk_descriptor_writes[i].dstBinding = uav_counter->binding.binding; - vk_descriptor_writes[i].dstArrayElement = 0; - vk_descriptor_writes[i].descriptorCount = 1; - 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_CALL(vkUpdateDescriptorSets(vk_device, uav_counter_count, vk_descriptor_writes, 0, NULL)); - - VK_CALL(vkCmdBindDescriptorSets(list->vk_command_buffer, bind_point, - state->vk_pipeline_layout, state->set_index, 1, &vk_descriptor_set, 0, NULL)); - - bindings->uav_counter_dirty_mask = 0; -} - static void d3d12_command_list_update_descriptors(struct d3d12_command_list *list, VkPipelineBindPoint bind_point) { @@ -2842,31 +2975,86 @@ static void d3d12_command_list_update_descriptors(struct d3d12_command_list *lis if (!rs || !rs->vk_set_layout) return; + if ((bindings->descriptor_table_active_mask | bindings->push_descriptor_dirty_mask | + (list->state->uav_counter_mask & bindings->uav_counter_dirty_mask)) == 0) + { + /* Nothing is dirty, so just return early. */ + return; + } + if (bindings->descriptor_table_dirty_mask || bindings->push_descriptor_dirty_mask) d3d12_command_list_prepare_descriptors(list, bind_point); + if (list->state->uav_counter_mask & bindings->uav_counter_dirty_mask) + d3d12_command_list_prepare_uav_counter_descriptors(list, bind_point); - for (i = 0; i < ARRAY_SIZE(bindings->descriptor_tables); ++i) + if (list->device->vk_info.EXT_descriptor_indexing) + { + d3d12_command_list_defer_update_descriptor_table(list, bind_point, bindings->descriptor_table_dirty_mask, + false); + } + else { - if (bindings->descriptor_table_dirty_mask & ((uint64_t)1 << i)) + /* FIXME: FOR_EACH_BIT */ + for (i = 0; i < ARRAY_SIZE(bindings->descriptor_tables); ++i) { - if ((base_descriptor = d3d12_desc_from_gpu_handle(bindings->descriptor_tables[i]))) - d3d12_command_list_update_descriptor_table(list, bind_point, i, base_descriptor); - else - WARN("Descriptor table %u is not set.\n", i); + if (bindings->descriptor_table_dirty_mask & ((uint64_t) 1 << i)) + { + if ((base_descriptor = d3d12_desc_from_gpu_handle(bindings->descriptor_tables[i]))) + d3d12_command_list_update_descriptor_table(list, bind_point, i, base_descriptor); + else + WARN("Descriptor table %u is not set.\n", i); + } } } bindings->descriptor_table_dirty_mask = 0; + /* Need to go through all descriptor tables here in the root signature, + * not just descriptor_table_dirty_mask. Binding a different shader may not invalidate descriptor tables, + * but it may invalidate the UAV counter set. */ + if (bindings->uav_counter_dirty_mask) + { + if (list->device->vk_info.EXT_descriptor_indexing) + { + d3d12_command_list_defer_update_descriptor_table(list, bind_point, bindings->descriptor_table_active_mask, + true); + } + else + { + /* FIXME: FOR_EACH_BIT */ + for (i = 0; i < ARRAY_SIZE(bindings->descriptor_tables); i++) + { + if (bindings->descriptor_table_active_mask & ((uint64_t) 1 << i)) + { + if ((base_descriptor = d3d12_desc_from_gpu_handle(bindings->descriptor_tables[i]))) + d3d12_command_list_update_uav_counter_descriptor_table(list, bind_point, i, base_descriptor); + else + WARN("Descriptor table %u is not set.\n", i); + } + } + } + } + bindings->uav_counter_dirty_mask = 0; + d3d12_command_list_update_push_descriptors(list, bind_point); - if (bindings->descriptor_set) + /* Don't rebind the same descriptor set as long as we're in same pipeline layout. */ + if (bindings->descriptor_set && bindings->descriptor_set != bindings->descriptor_set_bound) { VK_CALL(vkCmdBindDescriptorSets(list->vk_command_buffer, bind_point, rs->vk_pipeline_layout, rs->main_set, 1, &bindings->descriptor_set, 0, NULL)); bindings->in_use = true; + bindings->descriptor_set_bound = bindings->descriptor_set; } - d3d12_command_list_update_uav_counter_descriptors(list, bind_point); + /* Don't rebind the same descriptor set as long as we're in same pipeline layout. */ + if (bindings->uav_counter_descriptor_set && + bindings->uav_counter_descriptor_set != bindings->uav_counter_descriptor_set_bound) + { + VK_CALL(vkCmdBindDescriptorSets(list->vk_command_buffer, bind_point, + list->state->vk_pipeline_layout, list->state->set_index, 1, &bindings->uav_counter_descriptor_set, 0, NULL)); + bindings->uav_counter_in_use = true; + bindings->uav_counter_descriptor_set_bound = bindings->uav_counter_descriptor_set; + } } static bool d3d12_command_list_begin_render_pass(struct d3d12_command_list *list) @@ -4032,6 +4220,10 @@ static void d3d12_command_list_set_root_signature(struct d3d12_command_list *lis bindings->descriptor_set = VK_NULL_HANDLE; bindings->descriptor_table_dirty_mask = bindings->descriptor_table_active_mask & root_signature->descriptor_table_mask; bindings->push_descriptor_dirty_mask = bindings->push_descriptor_active_mask & root_signature->push_descriptor_mask; + + bindings->uav_counter_descriptor_set = VK_NULL_HANDLE; + bindings->descriptor_set_bound = VK_NULL_HANDLE; + bindings->uav_counter_descriptor_set_bound = VK_NULL_HANDLE; } static void STDMETHODCALLTYPE d3d12_command_list_SetComputeRootSignature(ID3D12GraphicsCommandList1 *iface, @@ -5405,6 +5597,9 @@ static HRESULT d3d12_command_list_init(struct d3d12_command_list *list, struct d d3d12_device_add_ref(list->device = device); list->allocator = allocator; + list->descriptor_updates = NULL; + list->descriptor_updates_count = 0; + list->descriptor_updates_size = 0; if (SUCCEEDED(hr = d3d12_command_allocator_allocate_command_buffer(allocator, list))) { @@ -5642,6 +5837,13 @@ static void STDMETHODCALLTYPE d3d12_command_queue_ExecuteCommandLists(ID3D12Comm return; } + /* Descriptors in root signature in 1.0 are VOLATILE by default, so + * the descriptor heap only need to be valid right before we submit them to the GPU. + * If we have EXT_descriptor_indexing enabled with UpdateAfterBind, we update + * descriptor sets here rather than while we're recording the command buffer. + * For each submission of the command buffer, we can modify the descriptor heap as we please. */ + d3d12_command_list_resolve_descriptor_tables(cmd_list); + buffers[i] = cmd_list->vk_command_buffer; } diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 13ebc70..e159c1f 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1436,11 +1436,25 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, } if (vulkan_info->EXT_descriptor_indexing && descriptor_indexing - && (descriptor_indexing->descriptorBindingUniformBufferUpdateAfterBind - || descriptor_indexing->descriptorBindingStorageBufferUpdateAfterBind + && descriptor_indexing->descriptorBindingUniformBufferUpdateAfterBind + && descriptor_indexing->descriptorBindingSampledImageUpdateAfterBind + && descriptor_indexing->descriptorBindingStorageImageUpdateAfterBind + && descriptor_indexing->descriptorBindingUniformTexelBufferUpdateAfterBind) + { + TRACE("Enabling VK_EXT_descriptor_indexing for volatile descriptor updates.\n"); + } + else + { + WARN("VK_EXT_descriptor indexing not supported in sufficient capacity. Volatile descriptor updates will not work.\n"); + vulkan_info->EXT_descriptor_indexing = false; + } + + if (vulkan_info->EXT_descriptor_indexing && descriptor_indexing + && (descriptor_indexing->descriptorBindingUniformBufferUpdateAfterBind || descriptor_indexing->descriptorBindingUniformTexelBufferUpdateAfterBind + || descriptor_indexing->descriptorBindingStorageBufferUpdateAfterBind || descriptor_indexing->descriptorBindingStorageTexelBufferUpdateAfterBind) - && !physical_device_info->descriptor_indexing_properties.robustBufferAccessUpdateAfterBind) + && !physical_device_info->descriptor_indexing_properties.robustBufferAccessUpdateAfterBind) { WARN("Disabling robust buffer access for the update after bind feature.\n"); features->robustBufferAccess = VK_FALSE; diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index a321fa4..50cff1f 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -745,21 +745,43 @@ static HRESULT vkd3d_create_descriptor_set_layout(struct d3d12_device *device, VkDescriptorSetLayoutCreateFlags flags, unsigned int binding_count, const VkDescriptorSetLayoutBinding *bindings, VkDescriptorSetLayout *set_layout) { + unsigned int i; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; VkDescriptorSetLayoutCreateInfo set_desc; VkResult vr; + VkDescriptorSetLayoutBindingFlagsCreateInfoEXT flags_info; + VkDescriptorBindingFlagsEXT *binding_flags = NULL; set_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; set_desc.pNext = NULL; set_desc.flags = flags; set_desc.bindingCount = binding_count; set_desc.pBindings = bindings; + + if (!(flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) && device->vk_info.EXT_descriptor_indexing) + { + set_desc.flags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT; + flags_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT; + flags_info.pNext = NULL; + flags_info.bindingCount = binding_count; + binding_flags = vkd3d_malloc(sizeof(*binding_flags) * binding_count); + for (i = 0; i < binding_count; i++) + { + binding_flags[i] = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT | + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT; + } + flags_info.pBindingFlags = binding_flags; + set_desc.pNext = &flags_info; + } + if ((vr = VK_CALL(vkCreateDescriptorSetLayout(device->vk_device, &set_desc, NULL, set_layout))) < 0) { WARN("Failed to create Vulkan descriptor set layout, vr %d.\n", vr); + vkd3d_free(binding_flags); return hresult_from_vk_result(vr); } + vkd3d_free(binding_flags); return S_OK; } diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 2d62fda..58e9aa9 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -888,13 +888,16 @@ struct vkd3d_pipeline_bindings const struct d3d12_root_signature *root_signature; VkDescriptorSet descriptor_set; + VkDescriptorSet uav_counter_descriptor_set; + VkDescriptorSet descriptor_set_bound; + VkDescriptorSet uav_counter_descriptor_set_bound; bool in_use; + bool uav_counter_in_use; D3D12_GPU_DESCRIPTOR_HANDLE descriptor_tables[D3D12_MAX_ROOT_COST]; uint64_t descriptor_table_dirty_mask; uint64_t descriptor_table_active_mask; - VkBufferView vk_uav_counter_views[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; uint8_t uav_counter_dirty_mask; /* Needed when VK_KHR_push_descriptor is not available. */ @@ -903,6 +906,16 @@ struct vkd3d_pipeline_bindings uint32_t push_descriptor_active_mask; }; +struct d3d12_deferred_descriptor_set_update +{ + const struct d3d12_desc *base_descriptor; + unsigned int index; + + const struct d3d12_root_signature *root_signature; + VkDescriptorSet descriptor_set; + bool uav; +}; + /* ID3D12CommandList */ struct d3d12_command_list { @@ -946,6 +959,10 @@ struct d3d12_command_list VkBuffer so_counter_buffers[D3D12_SO_BUFFER_SLOT_COUNT]; VkDeviceSize so_counter_buffer_offsets[D3D12_SO_BUFFER_SLOT_COUNT]; + struct d3d12_deferred_descriptor_set_update *descriptor_updates; + size_t descriptor_updates_size; + size_t descriptor_updates_count; + struct vkd3d_private_store private_store; }; diff --git a/tests/d3d12.c b/tests/d3d12.c index 858cf99..16a048c 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -15799,7 +15799,7 @@ static void test_update_descriptor_heap_after_closing_command_list(void) D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); get_texture_readback_with_command_list(context.render_target, 0, &rb, queue, command_list); value = get_readback_uint(&rb, 0, 0, 0); - todo ok(value == 0xff00ff00, "Got unexpected value %#x.\n", value); + ok(value == 0xff00ff00, "Got unexpected value %#x.\n", value); release_resource_readback(&rb); ID3D12DescriptorHeap_Release(cpu_heap); -- 2.23.0

3 7

[PATCH] ntdll: Fix find_free_area outside of reserved areas with zero_bits != 0.
by Rémi Bernon 04 Nov '19

04 Nov '19

From: Paul Gofman <gofmanp(a)gmail.com> The search was initiated with base == 0, which returns NULL immediately if MEM_TOP_DOWN is not used. Using address_space_start instead fixes this issue. Then we assumed that all mmapped regions are known by Wine view tree, which is obviously not the case with external allocations. This could lead to memory corruption when find_free_area returns an expected free region which is already mmapped. Using MAP_FIXED forces mmap to succeed and corrupts the mapping. This patch uses safe mmap calls to check if the expected free memory is actually free, and iterates over the expected free ranges until it succeeds. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- Based on a patch from Paul Gofman <gofmanp(a)gmail.com> dlls/ntdll/virtual.c | 60 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 50 insertions(+), 10 deletions(-) diff --git a/dlls/ntdll/virtual.c b/dlls/ntdll/virtual.c index 68249de902e..bf8dab0e7f3 100644 --- a/dlls/ntdll/virtual.c +++ b/dlls/ntdll/virtual.c @@ -496,6 +496,33 @@ static struct file_view *find_view_range( const void *addr, size_t size ) return NULL; } +/*********************************************************************** + * try_map_free_area + * + * Try mmaping some expected free memory region, eventually stepping and + * retrying inside it, and return where it actually succeeded, or NULL. + */ +static void* try_map_free_area( void *base, void *end, ptrdiff_t step, + void *start, size_t size, int unix_prot ) +{ + void *ptr; + + while (start && base <= start && (char*)start + size <= (char*)end) + { + if ((ptr = wine_anon_mmap( start, size, unix_prot, 0 )) == start) + return start; + TRACE( "Found free area is already mapped, start %p.\n", start ); + + if (ptr != (void *)-1) + munmap( ptr, size ); + + if ((char *)end - (char *)start < step || (char *)start - (char *)base < step) + break; + start = (char *)start + step; + } + + return NULL; +} /*********************************************************************** * find_free_area @@ -503,9 +530,11 @@ static struct file_view *find_view_range( const void *addr, size_t size ) * Find a free area between views inside the specified range. * The csVirtual section must be held by caller. */ -static void *find_free_area( void *base, void *end, size_t size, size_t mask, int top_down ) +static void *find_free_area( void *base, void *end, size_t size, size_t mask, int top_down, + int map_area, int unix_prot ) { struct wine_rb_entry *first = NULL, *ptr = views_tree.root; + ptrdiff_t step = top_down ? -(mask + 1) : (mask + 1); void *start; /* find the first (resp. last) view inside the range */ @@ -538,7 +567,10 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in { struct file_view *view = WINE_RB_ENTRY_VALUE( first, struct file_view, entry ); - if ((char *)view->base + view->size <= (char *)start) break; + if (!map_area && (char *)view->base + view->size <= (char *)start) break; + if (map_area && (start = try_map_free_area( (char *)view->base + view->size, + (char *)start + size, step, + start, size, unix_prot ))) break; start = ROUND_ADDR( (char *)view->base - size, mask ); /* stop if remaining space is not large enough */ if (!start || start >= end || start < base) return NULL; @@ -554,13 +586,17 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in { struct file_view *view = WINE_RB_ENTRY_VALUE( first, struct file_view, entry ); - if ((char *)view->base >= (char *)start + size) break; + if (!map_area && (char *)view->base >= (char *)start + size) break; + if (map_area && (start = try_map_free_area( start, view->base, step, + start, size, unix_prot ))) break; start = ROUND_ADDR( (char *)view->base + view->size + mask, mask ); /* stop if remaining space is not large enough */ if (!start || start >= end || (char *)end - (char *)start < size) return NULL; first = wine_rb_next( first ); } } + + if (!first && map_area) return try_map_free_area( base, end, step, start, size, unix_prot ); return start; } @@ -1054,13 +1090,13 @@ static int alloc_reserved_area_callback( void *start, size_t size, void *arg ) { /* range is split in two by the preloader reservation, try first part */ if ((alloc->result = find_free_area( start, preload_reserve_start, alloc->size, - alloc->mask, alloc->top_down ))) + alloc->mask, alloc->top_down, FALSE, 0 ))) return 1; /* then fall through to try second part */ start = preload_reserve_end; } } - if ((alloc->result = find_free_area( start, end, alloc->size, alloc->mask, alloc->top_down ))) + if ((alloc->result = find_free_area( start, end, alloc->size, alloc->mask, alloc->top_down, FALSE, 0 ))) return 1; return 0; @@ -1163,14 +1199,18 @@ static NTSTATUS map_view( struct file_view **view_ret, void *base, size_t size, goto done; } - for (;;) + if (zero_bits_64) { - if (!zero_bits_64) - ptr = NULL; - else if (!(ptr = find_free_area( (void*)0, alloc.limit, view_size, mask, top_down ))) + if (!(ptr = find_free_area( address_space_start, alloc.limit, size, + mask, top_down, TRUE, VIRTUAL_GetUnixProt(vprot) ))) return STATUS_NO_MEMORY; + TRACE( "got mem with find_free_area %p-%p\n", ptr, (char *)ptr + size ); + goto done; + } - if ((ptr = wine_anon_mmap( ptr, view_size, VIRTUAL_GetUnixProt(vprot), ptr ? MAP_FIXED : 0 )) == (void *)-1) + for (;;) + { + if ((ptr = wine_anon_mmap( NULL, view_size, VIRTUAL_GetUnixProt(vprot), 0 )) == (void *)-1) { if (errno == ENOMEM) return STATUS_NO_MEMORY; return STATUS_INVALID_PARAMETER; -- 2.24.0.rc2

1 1

[PATCH v3] shcore: Add GetScaleFactorForMonitor stub
by Esdras Tarsis 04 Nov '19

04 Nov '19

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=48016 Signed-off-by: Esdras Tarsis <esdrastarsis(a)gmail.com> --- v3: Fix non-HRESULT return value. --- dlls/shcore/main.c | 10 ++++++++++ dlls/shcore/shcore.spec | 2 +- include/shellscalingapi.h | 22 ++++++++++++++++++++++ 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/dlls/shcore/main.c b/dlls/shcore/main.c index 6a6247930f..04812dd113 100644 --- a/dlls/shcore/main.c +++ b/dlls/shcore/main.c @@ -1517,6 +1517,16 @@ void WINAPI SetProcessReference(IUnknown *obj) process_ref = obj; } +/************************************************************************* + * GetScaleFactorForMonitor [SHCORE.@] + */ +HRESULT WINAPI GetScaleFactorForMonitor(HMONITOR monitor, DEVICE_SCALE_FACTOR *scale) +{ + FIXME("(%p, %p) - stub!\n", monitor, scale); + *scale = SCALE_100_PERCENT; + return S_OK; +} + struct thread_data { LPTHREAD_START_ROUTINE thread_proc; diff --git a/dlls/shcore/shcore.spec b/dlls/shcore/shcore.spec index 6a634bdee5..d5b7a342e3 100644 --- a/dlls/shcore/shcore.spec +++ b/dlls/shcore/shcore.spec @@ -12,7 +12,7 @@ @ stdcall GetProcessDpiAwareness(long ptr) @ stdcall GetProcessReference(ptr) @ stub GetScaleFactorForDevice -@ stub GetScaleFactorForMonitor +@ stdcall GetScaleFactorForMonitor(long ptr) @ stub IStream_Copy @ stdcall IStream_Read(ptr ptr long) _IStream_Read @ stub IStream_ReadStr diff --git a/include/shellscalingapi.h b/include/shellscalingapi.h index 1df85d5982..80dab0178f 100644 --- a/include/shellscalingapi.h +++ b/include/shellscalingapi.h @@ -34,8 +34,30 @@ typedef enum PROCESS_DPI_AWARENESS PROCESS_PER_MONITOR_DPI_AWARE } PROCESS_DPI_AWARENESS; +typedef enum DEVICE_SCALE_FACTOR +{ + DEVICE_SCALE_FACTOR_INVALID, + SCALE_100_PERCENT, + SCALE_120_PERCENT, + SCALE_125_PERCENT, + SCALE_140_PERCENT, + SCALE_150_PERCENT, + SCALE_160_PERCENT, + SCALE_175_PERCENT, + SCALE_180_PERCENT, + SCALE_200_PERCENT, + SCALE_225_PERCENT, + SCALE_250_PERCENT, + SCALE_300_PERCENT, + SCALE_350_PERCENT, + SCALE_400_PERCENT, + SCALE_450_PERCENT, + SCALE_500_PERCENT +} DEVICE_SCALE_FACTOR; + HRESULT WINAPI GetDpiForMonitor(HMONITOR,MONITOR_DPI_TYPE,UINT*,UINT*); HRESULT WINAPI GetProcessDpiAwareness(HANDLE,PROCESS_DPI_AWARENESS*); HRESULT WINAPI SetProcessDpiAwareness(PROCESS_DPI_AWARENESS); +HRESULT WINAPI GetScaleFactorForMonitor(HMONITOR,DEVICE_SCALE_FACTOR*); #endif /* __WINE_SHELLSCALINGAPI_H */ -- 2.23.0

2 1