From c4ab7af30f38d340d4f56aa3b7dc6af9460539c7 Mon Sep 17 00:00:00 2001 From: Jon Ashburn Date: Thu, 9 Jul 2015 15:02:25 -0600 Subject: misc: Support Pipeline caches and multi pipeline create, bug 14033 API changes --- demos/cube.c | 10 +- demos/tri.c | 9 +- include/vk_layer.h | 13 +- include/vulkan.h | 84 +++-- layers/draw_state.cpp | 106 +++--- layers/mem_tracker.cpp | 51 +-- layers/multi.cpp | 26 +- layers/param_checker.cpp | 889 ++++------------------------------------------ layers/shader_checker.cpp | 39 +- loader/gpa_helper.h | 26 +- loader/table_ops.h | 39 +- loader/trampoline.c | 33 +- vk_helper.py | 5 +- vulkan.py | 49 +-- 14 files changed, 343 insertions(+), 1036 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index abd0f600..70aeb5b4 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -344,6 +344,7 @@ struct demo { VkCmdBuffer cmd; // Buffer for initialization commands VkPipelineLayout pipeline_layout; VkDescriptorSetLayout desc_layout; + VkPipelineCache pipelineCache; VkPipeline pipeline; VkDynamicVpState viewport; @@ -1377,7 +1378,7 @@ static VkShader demo_prepare_fs(struct demo *demo) static void demo_prepare_pipeline(struct demo *demo) { VkGraphicsPipelineCreateInfo pipeline; - + VkPipelineCacheCreateInfo pipelineCache; VkPipelineIaStateCreateInfo ia; VkPipelineRsStateCreateInfo rs; VkPipelineCbStateCreateInfo cb; @@ -1455,8 +1456,12 @@ static void demo_prepare_pipeline(struct demo *demo) pipeline.pVpState = &vp; pipeline.pDsState = &ds; pipeline.pStages = shaderStages; + memset(&pipelineCache, 0, sizeof(pipelineCache)); + pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; - err = vkCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline); + err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache); + assert(!err); + err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline); assert(!err); for (uint32_t i = 0; i < pipeline.stageCount; i++) { @@ -1650,6 +1655,7 @@ static void demo_cleanup(struct demo *demo) vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, demo->depth_stencil); vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE, demo->pipeline); + vkDestroyPipelineCache(demo->device, demo->pipelineCache); vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, demo->pipeline_layout); vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, demo->desc_layout); diff --git a/demos/tri.c b/demos/tri.c index 73227f2d..3a5378ab 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -194,6 +194,7 @@ struct demo { VkCmdBuffer draw_cmd; // Command Buffer for drawing commands VkPipelineLayout pipeline_layout; VkDescriptorSetLayout desc_layout; + VkPipelineCache pipelineCache; VkPipeline pipeline; VkDynamicVpState viewport; @@ -1017,6 +1018,7 @@ static VkShader demo_prepare_fs(struct demo *demo) static void demo_prepare_pipeline(struct demo *demo) { VkGraphicsPipelineCreateInfo pipeline; + VkPipelineCacheCreateInfo pipelineCache; VkPipelineVertexInputStateCreateInfo vi; VkPipelineIaStateCreateInfo ia; @@ -1102,7 +1104,12 @@ static void demo_prepare_pipeline(struct demo *demo) pipeline.pDsState = &ds; pipeline.pStages = shaderStages; - err = vkCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline); + memset(&pipelineCache, 0, sizeof(pipelineCache)); + pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; + + err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache); + assert(!err); + err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline); assert(!err); for (uint32_t i = 0; i < pipeline.stageCount; i++) { diff --git a/include/vk_layer.h b/include/vk_layer.h index c2c54658..3e915b1b 100644 --- a/include/vk_layer.h +++ b/include/vk_layer.h @@ -69,12 +69,13 @@ typedef struct VkLayerDispatchTable_ PFN_vkCreateDepthStencilView CreateDepthStencilView; PFN_vkCreateShaderModule CreateShaderModule; PFN_vkCreateShader CreateShader; - PFN_vkCreateGraphicsPipeline CreateGraphicsPipeline; - PFN_vkCreateGraphicsPipelineDerivative CreateGraphicsPipelineDerivative; - PFN_vkCreateComputePipeline CreateComputePipeline; - PFN_vkStorePipeline StorePipeline; - PFN_vkLoadPipeline LoadPipeline; - PFN_vkLoadPipelineDerivative LoadPipelineDerivative; + PFN_vkCreatePipelineCache CreatePipelineCache; + PFN_vkDestroyPipelineCache DestroyPipelineCache; + PFN_vkGetPipelineCacheSize GetPipelineCacheSize; + PFN_vkGetPipelineCacheData GetPipelineCacheData; + PFN_vkMergePipelineCaches MergePipelineCaches; + PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines; + PFN_vkCreateComputePipelines CreateComputePipelines; PFN_vkCreatePipelineLayout CreatePipelineLayout; PFN_vkCreateSampler CreateSampler; PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; diff --git a/include/vulkan.h b/include/vulkan.h index 9f3a8c44..8ef46cc8 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -82,6 +82,7 @@ VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShaderModule, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable) +VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineCache, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable) VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable) @@ -104,6 +105,7 @@ VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable) #define VK_MAX_DESCRIPTION 256 #define VK_MAX_MEMORY_TYPES 32 #define VK_MAX_MEMORY_HEAPS 16 +#define VK_UUID_LENGTH 16 #define VK_LOD_CLAMP_NONE MAX_FLOAT #define VK_LAST_MIP_LEVEL UINT32_MAX #define VK_LAST_ARRAY_SLICE UINT32_MAX @@ -787,7 +789,8 @@ typedef enum VkStructureType_ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 42, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 43, VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES = 45, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45, + VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES = 46, VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, EXTENSION_PROPERTIES) } VkStructureType; @@ -824,7 +827,8 @@ typedef enum VkObjectType_ VK_OBJECT_TYPE_EVENT = 26, VK_OBJECT_TYPE_QUERY_POOL = 27, VK_OBJECT_TYPE_FRAMEBUFFER = 28, - VK_OBJECT_TYPE_RENDER_PASS = 29, + VK_OBJECT_TYPE_PIPELINE_CACHE = 29, + VK_OBJECT_TYPE_RENDER_PASS = 30, // Valid ranges for core Vulkan: VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, @@ -1019,6 +1023,7 @@ typedef enum VkPipelineCreateFlagBits_ { VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0), VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1), + VK_PIPELINE_CREATE_DERIVATIVE_BIT = VK_BIT(2), } VkPipelineCreateFlagBits; // Channel flags @@ -1239,6 +1244,7 @@ typedef struct VkPhysicalDeviceProperties_ uint32_t deviceId; VkPhysicalDeviceType deviceType; char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; + uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; } VkPhysicalDeviceProperties; typedef struct VkPhysicalDeviceFeatures_ @@ -1821,6 +1827,15 @@ typedef struct VkShaderCreateInfo_ VkShaderCreateFlags flags; // Reserved } VkShaderCreateInfo; +typedef struct VkPipelineCacheCreateInfo_ +{ + VkStructureType sType; + const void* pNext; + size_t initialSize; + const void* initialData; + size_t maxSize; +} VkPipelineCacheCreateInfo; + typedef struct VkDescriptorSetLayoutBinding_ { VkDescriptorType descriptorType; // Type of the descriptors in this binding @@ -1889,6 +1904,8 @@ typedef struct VkComputePipelineCreateInfo_ VkPipelineShaderStageCreateInfo cs; VkPipelineCreateFlags flags; // Pipeline creation flags VkPipelineLayout layout; // Interface layout of the pipeline + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; } VkComputePipelineCreateInfo; typedef struct VkVertexInputBindingDescription_ @@ -2033,6 +2050,8 @@ typedef struct VkGraphicsPipelineCreateInfo_ const VkPipelineCbStateCreateInfo* pCbState; VkPipelineCreateFlags flags; // Pipeline creation flags VkPipelineLayout layout; // Interface layout of the pipeline + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; } VkGraphicsPipelineCreateInfo; typedef struct VkPipelineLayoutCreateInfo_ @@ -2290,12 +2309,13 @@ typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView); typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline); -typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline); +typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); +typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); +typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); +typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); +typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); @@ -2677,41 +2697,43 @@ VkResult VKAPI vkCreateShader( VkShader* pShader); // Pipeline functions - -VkResult VKAPI vkCreateGraphicsPipeline( +VkResult VKAPI vkCreatePipelineCache( VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline); + const VkPipelineCacheCreateInfo* pCreateInfo, + VkPipelineCache* pPipelineCache); -VkResult VKAPI vkCreateGraphicsPipelineDerivative( +VkResult VKAPI vkDestroyPipelineCache( VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline basePipeline, - VkPipeline* pPipeline); + VkPipelineCache pipelineCache); -VkResult VKAPI vkCreateComputePipeline( +size_t VKAPI vkGetPipelineCacheSize( VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline); + VkPipelineCache pipelineCache); -VkResult VKAPI vkStorePipeline( +VkResult VKAPI vkGetPipelineCacheData( VkDevice device, - VkPipeline pipeline, - size_t* pDataSize, + VkPipelineCache pipelineCache, void* pData); -VkResult VKAPI vkLoadPipeline( +VkResult VKAPI vkMergePipelineCaches( VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline* pPipeline); + VkPipelineCache destCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); -VkResult VKAPI vkLoadPipelineDerivative( +VkResult VKAPI vkCreateGraphicsPipelines( VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline basePipeline, - VkPipeline* pPipeline); + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); // Pipeline layout functions diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index c1ad7fbe..ff990367 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -1532,23 +1532,69 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const V return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) +//TODO handle pipeline caches +VkResult VKAPI vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + VkPipelineCache* pPipelineCache) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache); + return result; +} + +VkResult VKAPI vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyPipelineCache(device, pipelineCache); + return result; +} + +size_t VKAPI vkGetPipelineCacheSize( + VkDevice device, + VkPipelineCache pipelineCache) +{ + size_t size = get_dispatch_table(draw_state_device_table_map, device)->GetPipelineCacheSize(device, pipelineCache); + return size; +} + +VkResult VKAPI vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + void* pData) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pData); + return result; +} + +VkResult VKAPI vkMergePipelineCaches( + VkDevice device, + VkPipelineCache destCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches); + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { VkResult result = VK_ERROR_BAD_PIPELINE_DATA; + //TODO handle count > 1 and handle pipelineCache // The order of operations here is a little convoluted but gets the job done // 1. Pipeline create state is first shadowed into PIPELINE_NODE struct // 2. Create state is then validated (which uses flags setup during shadowing) // 3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap loader_platform_thread_lock_mutex(&globalLock); - PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfo, NULL); + PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfos, NULL); bool32_t valid = verifyPipelineCreateState(device, pPipeNode); loader_platform_thread_unlock_mutex(&globalLock); if (VK_TRUE == valid) { - result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, *pPipeline, 0, DRAWSTATE_NONE, "DS", - "Created Gfx Pipeline %p", (void*)*pPipeline); + result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); + log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, *pPipelines, 0, DRAWSTATE_NONE, "DS", + "Created Gfx Pipeline %p", (void*)*pPipelines); loader_platform_thread_lock_mutex(&globalLock); - pPipeNode->pipeline = *pPipeline; + pPipeNode->pipeline = *pPipelines; pipelineMap[pPipeNode->pipeline] = pPipeNode; loader_platform_thread_unlock_mutex(&globalLock); } else { @@ -1563,38 +1609,6 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const V return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( - VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline basePipeline, - VkPipeline* pPipeline) -{ - VkResult result = VK_ERROR_BAD_PIPELINE_DATA; - loader_platform_thread_lock_mutex(&globalLock); - PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfo, NULL); - bool32_t valid = verifyPipelineCreateState(device, pipelineMap[basePipeline]); - loader_platform_thread_unlock_mutex(&globalLock); - if (VK_TRUE == valid) { - result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, *pPipeline, 0, DRAWSTATE_NONE, "DS", - "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline); - loader_platform_thread_lock_mutex(&globalLock); - pPipeNode->pipeline = *pPipeline; - pipelineMap[pPipeNode->pipeline] = pPipeNode; - loader_platform_thread_unlock_mutex(&globalLock); - } - else { // Skipped pipeline creation due to bad CreateInfo data - if (pPipeNode) { - // If we allocated a pipeNode, need to clean it up here - delete[] pPipeNode->pVertexBindingDescriptions; - delete[] pPipeNode->pVertexAttributeDescriptions; - delete[] pPipeNode->pAttachments; - delete pPipeNode; - } - } - return result; -} - VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler); @@ -2706,10 +2720,18 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcNa return (void*) vkCreateColorAttachmentView; if (!strcmp(funcName, "vkCreateDepthStencilView")) return (void*) vkCreateDepthStencilView; - if (!strcmp(funcName, "vkCreateGraphicsPipeline")) - return (void*) vkCreateGraphicsPipeline; - if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative")) - return (void*) vkCreateGraphicsPipelineDerivative; + if (!strcmp(funcName, "CreatePipelineCache")) + return (void*) vkCreatePipelineCache; + if (!strcmp(funcName, "DestroyPipelineCache")) + return (void*) vkDestroyPipelineCache; + if (!strcmp(funcName, "GetPipelineCacheSize")) + return (void*) vkGetPipelineCacheSize; + if (!strcmp(funcName, "GetPipelineCacheData")) + return (void*) vkGetPipelineCacheData; + if (!strcmp(funcName, "MergePipelineCaches")) + return (void*) vkMergePipelineCaches; + if (!strcmp(funcName, "vkCreateGraphicsPipelines")) + return (void*) vkCreateGraphicsPipelines; if (!strcmp(funcName, "vkCreateSampler")) return (void*) vkCreateSampler; if (!strcmp(funcName, "vkCreateDescriptorSetLayout")) diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 3dc7fb83..5bf41ccf 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -1507,45 +1507,34 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateShader( return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline( +//TODO do we need to intercept pipelineCache functions to track objects? +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines( VkDevice device, - const VkGraphicsPipelineCreateInfo *pCreateInfo, - VkPipeline *pPipeline) + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo *pCreateInfos, + VkPipeline *pPipelines) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); + add_object_info(*pPipelines, pCreateInfos->sType, pCreateInfos, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( - VkDevice device, - const VkGraphicsPipelineCreateInfo *pCreateInfo, - VkPipeline basePipeline, - VkPipeline *pPipeline) -{ - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateGraphicsPipelineDerivative( - device, pCreateInfo, basePipeline, pPipeline); - if (result == VK_SUCCESS) { - loader_platform_thread_lock_mutex(&globalLock); - add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); - loader_platform_thread_unlock_mutex(&globalLock); - } - return result; -} - -VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline( +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipelines( VkDevice device, - const VkComputePipelineCreateInfo *pCreateInfo, - VkPipeline *pPipeline) + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo *pCreateInfos, + VkPipeline *pPipelines) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline"); + add_object_info(*pPipelines, pCreateInfos->sType, pCreateInfos, sizeof(VkComputePipelineCreateInfo), "compute_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; @@ -2261,12 +2250,10 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr( return (void*) vkCreateDepthStencilView; if (!strcmp(funcName, "vkCreateShader")) return (void*) vkCreateShader; - if (!strcmp(funcName, "vkCreateGraphicsPipeline")) - return (void*) vkCreateGraphicsPipeline; - if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative")) - return (void*) vkCreateGraphicsPipelineDerivative; - if (!strcmp(funcName, "vkCreateComputePipeline")) - return (void*) vkCreateComputePipeline; + if (!strcmp(funcName, "vkCreateGraphicsPipelines")) + return (void*) vkCreateGraphicsPipelines; + if (!strcmp(funcName, "vkCreateComputePipelines")) + return (void*) vkCreateComputePipelines; if (!strcmp(funcName, "vkCreateSampler")) return (void*) vkCreateSampler; if (!strcmp(funcName, "vkCreateDynamicViewportState")) diff --git a/layers/multi.cpp b/layers/multi.cpp index acdfaf6b..574e5c23 100644 --- a/layers/multi.cpp +++ b/layers/multi.cpp @@ -134,27 +134,21 @@ VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamp return result; } -VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines) { VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) device; printf("At start of multi1 layer vkCreateGraphicsPipeline()\n"); - VkResult result = device_dispatch_table1(device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = device_dispatch_table1(device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); printf("Completed multi1 layer vkCreateGraphicsPipeline()\n"); return result; } -VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) -{ - VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) device; - - printf("At start of multi1 layer vkStorePipeline()\n"); - VkResult result = device_dispatch_table1(device)->StorePipeline(device, pipeline, pDataSize, pData); - printf("Completed multi1 layer vkStorePipeline()\n"); - return result; -} - VK_LAYER_EXPORT void * VKAPI multi1GetDeviceProcAddr(VkDevice device, const char* pName) { VkBaseLayerObject* devw = (VkBaseLayerObject *) device; @@ -172,10 +166,8 @@ VK_LAYER_EXPORT void * VKAPI multi1GetDeviceProcAddr(VkDevice device, const char return (void *) multi1DestroyDevice; if (!strcmp("vkCreateSampler", pName)) return (void *) multi1CreateSampler; - if (!strcmp("vkCreateGraphicsPipeline", pName)) - return (void *) multi1CreateGraphicsPipeline; - if (!strcmp("vkStorePipeline", pName)) - return (void *) multi1StorePipeline; + if (!strcmp("vkCreateGraphicsPipelines", pName)) + return (void *) multi1CreateGraphicsPipelines; else { VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) device; VkLayerDispatchTable* pTable = device_dispatch_table1(device); diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index 1f55e38f..0ee1b7e4 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -4645,8 +4645,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateShader( return result; } +//TODO handle count > 1 void PreCreateGraphicsPipeline( VkDevice device, + uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfo) { if(device == nullptr) @@ -5117,8 +5119,10 @@ void PreCreateGraphicsPipeline( } } +//TODO handle count > 1 void PostCreateGraphicsPipeline( VkDevice device, + uint32_t count, VkPipeline* pPipeline, VkResult result) { @@ -5149,899 +5153,168 @@ void PostCreateGraphicsPipeline( return; } } - -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline( +//TODO add intercept of pipelineCache entrypoints +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines( VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline) + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines) { - PreCreateGraphicsPipeline(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + PreCreateGraphicsPipeline(device, count, pCreateInfos); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); - PostCreateGraphicsPipeline(device, pPipeline, result); + PostCreateGraphicsPipeline(device, count, pPipelines, result); return result; } -void PreCreateGraphicsPipelineDerivative( +//TODO handle count > 1 +void PreCreateComputePipeline( VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo) + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfo) { if(device == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer"); + "vkCreateComputePipeline parameter, VkDevice device, is null pointer"); return; } if(pCreateInfo == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkGraphicsPipelineCreateInfo* pCreateInfo, is null pointer"); + "vkCreateComputePipeline parameter, const VkComputePipelineCreateInfo* pCreateInfo, is null pointer"); return; } if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pStages == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineShaderStageCreateInfo* pCreateInfo->pStages, is null pointer"); - return; - } - if(pCreateInfo->pStages->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pStages->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pStages->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pStages->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pNext, is null pointer"); - return; - } - if(pCreateInfo->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE || - pCreateInfo->pStages->stage > VK_SHADER_STAGE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkShaderStage pCreateInfo->pStages->stage, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pStages->shader == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkShader pCreateInfo->pStages->shader, is null pointer"); - return; - } - if(pCreateInfo->pStages->pLinkConstBufferInfo == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkLinkConstBuffer* pCreateInfo->pStages->pLinkConstBufferInfo, is null pointer"); - return; - } - if(pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pLinkConstBufferInfo->pBufferData, is null pointer"); - return; - } - if(pCreateInfo->pStages->pSpecializationInfo == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationInfo* pCreateInfo->pStages->pSpecializationInfo, is null pointer"); - return; - } - if(pCreateInfo->pStages->pSpecializationInfo->pMap == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkSpecializationMapEntry* pCreateInfo->pStages->pSpecializationInfo->pMap, is null pointer"); - return; - } - if(pCreateInfo->pStages->pSpecializationInfo->pData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pStages->pSpecializationInfo->pData, is null pointer"); - return; - } - if(pCreateInfo->pVertexInputState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVertexInputStateCreateInfo* pCreateInfo->pVertexInputState, is null pointer"); - return; - } - if(pCreateInfo->pVertexInputState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pVertexInputState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVertexInputState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pVertexInputState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVertexInputState->pNext, is null pointer"); - return; - } - if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputBindingDescription* pCreateInfo->pVertexInputState->pVertexBindingDescriptions, is null pointer"); - return; - } - if(pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE || - pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkVertexInputStepRate pCreateInfo->pVertexInputState->pVertexBindingDescriptions->stepRate, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkVertexInputAttributeDescription* pCreateInfo->pVertexInputState->pVertexAttributeDescriptions, is null pointer"); - return; - } - if(pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE || - pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pVertexInputState->pVertexAttributeDescriptions->format, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pIaState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineIaStateCreateInfo* pCreateInfo->pIaState, is null pointer"); - return; - } - if(pCreateInfo->pIaState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pIaState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pIaState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pIaState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pIaState->pNext, is null pointer"); - return; - } - if(pCreateInfo->pIaState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE || - pCreateInfo->pIaState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkPrimitiveTopology pCreateInfo->pIaState->topology, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pTessState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineTessStateCreateInfo* pCreateInfo->pTessState, is null pointer"); - return; - } - if(pCreateInfo->pTessState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pTessState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pTessState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pTessState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pTessState->pNext, is null pointer"); - return; - } - if(pCreateInfo->pVpState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineVpStateCreateInfo* pCreateInfo->pVpState, is null pointer"); - return; - } - if(pCreateInfo->pVpState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pVpState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pVpState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pVpState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pVpState->pNext, is null pointer"); - return; - } - if(pCreateInfo->pVpState->clipOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE || - pCreateInfo->pVpState->clipOrigin > VK_COORDINATE_ORIGIN_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pVpState->clipOrigin, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pVpState->depthMode < VK_DEPTH_MODE_BEGIN_RANGE || - pCreateInfo->pVpState->depthMode > VK_DEPTH_MODE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkDepthMode pCreateInfo->pVpState->depthMode, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pRsState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineRsStateCreateInfo* pCreateInfo->pRsState, is null pointer"); - return; - } - if(pCreateInfo->pRsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pRsState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pRsState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pRsState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pRsState->pNext, is null pointer"); + "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator"); return; } - if(pCreateInfo->pRsState->pointOrigin < VK_COORDINATE_ORIGIN_BEGIN_RANGE || - pCreateInfo->pRsState->pointOrigin > VK_COORDINATE_ORIGIN_END_RANGE) + if(pCreateInfo->cs.sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || + pCreateInfo->cs.sType > VK_STRUCTURE_TYPE_END_RANGE) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCoordinateOrigin pCreateInfo->pRsState->pointOrigin, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->cs.sType, is unrecognized enumerator"); return; } - if(pCreateInfo->pRsState->provokingVertex < VK_PROVOKING_VERTEX_BEGIN_RANGE || - pCreateInfo->pRsState->provokingVertex > VK_PROVOKING_VERTEX_END_RANGE) + if(pCreateInfo->cs.pNext == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkProvokingVertex pCreateInfo->pRsState->provokingVertex, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pNext, is null pointer"); return; } - if(pCreateInfo->pRsState->fillMode < VK_FILL_MODE_BEGIN_RANGE || - pCreateInfo->pRsState->fillMode > VK_FILL_MODE_END_RANGE) + if(pCreateInfo->cs.stage < VK_SHADER_STAGE_BEGIN_RANGE || + pCreateInfo->cs.stage > VK_SHADER_STAGE_END_RANGE) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkFillMode pCreateInfo->pRsState->fillMode, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkShaderStage pCreateInfo->cs.stage, is unrecognized enumerator"); return; } - if(pCreateInfo->pRsState->cullMode < VK_CULL_MODE_BEGIN_RANGE || - pCreateInfo->pRsState->cullMode > VK_CULL_MODE_END_RANGE) + if(pCreateInfo->cs.shader == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCullMode pCreateInfo->pRsState->cullMode, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkShader pCreateInfo->cs.shader, is null pointer"); return; } - if(pCreateInfo->pRsState->frontFace < VK_FRONT_FACE_BEGIN_RANGE || - pCreateInfo->pRsState->frontFace > VK_FRONT_FACE_END_RANGE) + if(pCreateInfo->cs.pLinkConstBufferInfo == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkFrontFace pCreateInfo->pRsState->frontFace, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, const VkLinkConstBuffer* pCreateInfo->cs.pLinkConstBufferInfo, is null pointer"); return; } - if(pCreateInfo->pMsState == nullptr) + if(pCreateInfo->cs.pLinkConstBufferInfo->pBufferData == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineMsStateCreateInfo* pCreateInfo->pMsState, is null pointer"); + "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pLinkConstBufferInfo->pBufferData, is null pointer"); return; } - if(pCreateInfo->pMsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pMsState->sType > VK_STRUCTURE_TYPE_END_RANGE) + if(pCreateInfo->cs.pSpecializationInfo == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pMsState->sType, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, const VkSpecializationInfo* pCreateInfo->cs.pSpecializationInfo, is null pointer"); return; } - if(pCreateInfo->pMsState->pNext == nullptr) + if(pCreateInfo->cs.pSpecializationInfo->pMap == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pMsState->pNext, is null pointer"); + "vkCreateComputePipeline parameter, const VkSpecializationMapEntry* pCreateInfo->cs.pSpecializationInfo->pMap, is null pointer"); return; } - if(pCreateInfo->pDsState == nullptr) + if(pCreateInfo->cs.pSpecializationInfo->pData == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineDsStateCreateInfo* pCreateInfo->pDsState, is null pointer"); + "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pSpecializationInfo->pData, is null pointer"); return; } - if(pCreateInfo->pDsState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pDsState->sType > VK_STRUCTURE_TYPE_END_RANGE) + if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags)) { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pDsState->sType, is unrecognized enumerator"); + std::string reason = "vkCreateComputePipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags); + log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); return; } - if(pCreateInfo->pDsState->pNext == nullptr) + if(pCreateInfo->layout == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pDsState->pNext, is null pointer"); + "vkCreateComputePipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer"); return; } - if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE || - pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE) +} + +//TODO handle count > 1 +void PostCreateComputePipeline( + VkDevice device, + uint32_t count, + VkPipeline* pPipeline, + VkResult result) +{ + if(device == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkDevice device, is null pointer"); return; } - if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE || - pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE) + + if(pPipeline == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->depthCompareOp, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer"); return; } - if(pCreateInfo->pDsState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE) + if((*pPipeline) == nullptr) { log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilFailOp, is unrecognized enumerator"); + "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer"); return; } - if(pCreateInfo->pDsState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE) + + if(result != VK_SUCCESS) { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilPassOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->front.stencilDepthFailOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE || - pCreateInfo->pDsState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->front.stencilCompareOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilFailOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilPassOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE || - pCreateInfo->pDsState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStencilOp pCreateInfo->pDsState->back.stencilDepthFailOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pDsState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE || - pCreateInfo->pDsState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkCompareOp pCreateInfo->pDsState->back.stencilCompareOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbStateCreateInfo* pCreateInfo->pCbState, is null pointer"); - return; - } - if(pCreateInfo->pCbState->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->pCbState->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkStructureType pCreateInfo->pCbState->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const void* pCreateInfo->pCbState->pNext, is null pointer"); - return; - } - if(pCreateInfo->pCbState->logicOp < VK_LOGIC_OP_BEGIN_RANGE || - pCreateInfo->pCbState->logicOp > VK_LOGIC_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkLogicOp pCreateInfo->pCbState->logicOp, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer"); - return; - } - if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendColor, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->destBlendColor > VK_BLEND_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendColor, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpColor, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->srcBlendAlpha, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlend pCreateInfo->pCbState->pAttachments->destBlendAlpha, is unrecognized enumerator"); - return; - } - if(pCreateInfo->pCbState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE || - pCreateInfo->pCbState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkBlendOp pCreateInfo->pCbState->pAttachments->blendOpAlpha, is unrecognized enumerator"); - return; - } - if(!ValidateEnumerator((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask)) - { - std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkChannelFlags pCreateInfo->pCbState->pAttachments->channelWriteMask, is " + EnumeratorString((VkChannelFlagBits)pCreateInfo->pCbState->pAttachments->channelWriteMask); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } - if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags)) - { - std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } - if(pCreateInfo->layout == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkPipelineLayout pCreateInfo->layout, is null pointer"); - return; - } -} - -void PostCreateGraphicsPipelineDerivative( - VkDevice device, - VkPipeline basePipeline, - VkPipeline* pPipeline, - VkResult result) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkDevice device, is null pointer"); - return; - } - - if(basePipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkPipeline basePipeline, is null pointer"); - return; - } - - if(pPipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - if((*pPipeline) == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateGraphicsPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - - if(result != VK_SUCCESS) - { - std::string reason = "vkCreateGraphicsPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } -} - -VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( - VkDevice device, - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipeline basePipeline, - VkPipeline* pPipeline) -{ - PreCreateGraphicsPipelineDerivative(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); - - PostCreateGraphicsPipelineDerivative(device, basePipeline, pPipeline, result); - - return result; -} - -void PreCreateComputePipeline( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkDevice device, is null pointer"); - return; - } - - if(pCreateInfo == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const VkComputePipelineCreateInfo* pCreateInfo, is null pointer"); - return; - } - if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->cs.sType < VK_STRUCTURE_TYPE_BEGIN_RANGE || - pCreateInfo->cs.sType > VK_STRUCTURE_TYPE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkStructureType pCreateInfo->cs.sType, is unrecognized enumerator"); - return; - } - if(pCreateInfo->cs.pNext == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pNext, is null pointer"); - return; - } - if(pCreateInfo->cs.stage < VK_SHADER_STAGE_BEGIN_RANGE || - pCreateInfo->cs.stage > VK_SHADER_STAGE_END_RANGE) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkShaderStage pCreateInfo->cs.stage, is unrecognized enumerator"); - return; - } - if(pCreateInfo->cs.shader == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkShader pCreateInfo->cs.shader, is null pointer"); - return; - } - if(pCreateInfo->cs.pLinkConstBufferInfo == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const VkLinkConstBuffer* pCreateInfo->cs.pLinkConstBufferInfo, is null pointer"); - return; - } - if(pCreateInfo->cs.pLinkConstBufferInfo->pBufferData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pLinkConstBufferInfo->pBufferData, is null pointer"); - return; - } - if(pCreateInfo->cs.pSpecializationInfo == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const VkSpecializationInfo* pCreateInfo->cs.pSpecializationInfo, is null pointer"); - return; - } - if(pCreateInfo->cs.pSpecializationInfo->pMap == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const VkSpecializationMapEntry* pCreateInfo->cs.pSpecializationInfo->pMap, is null pointer"); - return; - } - if(pCreateInfo->cs.pSpecializationInfo->pData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, const void* pCreateInfo->cs.pSpecializationInfo->pData, is null pointer"); - return; - } - if(!ValidateEnumerator((VkPipelineCreateFlagBits)pCreateInfo->flags)) - { - std::string reason = "vkCreateComputePipeline parameter, VkPipelineCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkPipelineCreateFlagBits)pCreateInfo->flags); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } - if(pCreateInfo->layout == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkPipelineLayout pCreateInfo->layout, is null pointer"); - return; - } -} - -void PostCreateComputePipeline( - VkDevice device, - VkPipeline* pPipeline, - VkResult result) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkDevice device, is null pointer"); - return; - } - - if(pPipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - if((*pPipeline) == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkCreateComputePipeline parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - - if(result != VK_SUCCESS) - { - std::string reason = "vkCreateComputePipeline parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } -} - -VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkPipeline* pPipeline) -{ - PreCreateComputePipeline(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipeline(device, pCreateInfo, pPipeline); - - PostCreateComputePipeline(device, pPipeline, result); - - return result; -} - -void PreStorePipeline( - VkDevice device) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkStorePipeline parameter, VkDevice device, is null pointer"); - return; - } -} - -void PostStorePipeline( - VkDevice device, - VkPipeline pipeline, - size_t* pDataSize, - void* pData, - VkResult result) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkStorePipeline parameter, VkDevice device, is null pointer"); - return; - } - - if(pipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkStorePipeline parameter, VkPipeline pipeline, is null pointer"); - return; - } - - if(pDataSize == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkStorePipeline parameter, size_t* pDataSize, is null pointer"); - return; - } - - if(pData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkStorePipeline parameter, void* pData, is null pointer"); - return; - } - - if(result != VK_SUCCESS) - { - std::string reason = "vkStorePipeline parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } -} - -VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline( - VkDevice device, - VkPipeline pipeline, - size_t* pDataSize, - void* pData) -{ - PreStorePipeline(device); - VkResult result = get_dispatch_table(pc_device_table_map, device)->StorePipeline(device, pipeline, pDataSize, pData); - - PostStorePipeline(device, pipeline, pDataSize, pData, result); - - return result; -} - -void PreLoadPipeline( - VkDevice device, - const void* pData) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipeline parameter, VkDevice device, is null pointer"); - return; - } - - if(pData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipeline parameter, const void* pData, is null pointer"); - return; - } -} - -void PostLoadPipeline( - VkDevice device, - size_t dataSize, - VkPipeline* pPipeline, - VkResult result) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipeline parameter, VkDevice device, is null pointer"); - return; - } - - - if(pPipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - if((*pPipeline) == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipeline parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - - if(result != VK_SUCCESS) - { - std::string reason = "vkLoadPipeline parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); + std::string reason = "vkCreateComputePipeline parameter, VkResult result, is " + EnumeratorString(result); + log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); return; } } -VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline( +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipelines( VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline* pPipeline) + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines) { - PreLoadPipeline(device, pData); - VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipeline(device, dataSize, pData, pPipeline); + PreCreateComputePipeline(device, count, pCreateInfos); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines); - PostLoadPipeline(device, dataSize, pPipeline, result); + PostCreateComputePipeline(device, count, pPipelines, result); return result; } -void PreLoadPipelineDerivative( - VkDevice device, - const void* pData) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer"); - return; - } - - if(pData == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, const void* pData, is null pointer"); - return; - } -} - -void PostLoadPipelineDerivative( - VkDevice device, - size_t dataSize, - VkPipeline basePipeline, - VkPipeline* pPipeline, - VkResult result) -{ - if(device == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, VkDevice device, is null pointer"); - return; - } - - - if(basePipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, VkPipeline basePipeline, is null pointer"); - return; - } - - if(pPipeline == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - if((*pPipeline) == nullptr) - { - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", - "vkLoadPipelineDerivative parameter, VkPipeline* pPipeline, is null pointer"); - return; - } - - if(result != VK_SUCCESS) - { - std::string reason = "vkLoadPipelineDerivative parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str()); - return; - } -} - -VK_LAYER_EXPORT VkResult VKAPI vkLoadPipelineDerivative( - VkDevice device, - size_t dataSize, - const void* pData, - VkPipeline basePipeline, - VkPipeline* pPipeline) -{ - PreLoadPipelineDerivative(device, pData); - VkResult result = get_dispatch_table(pc_device_table_map, device)->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); - - PostLoadPipelineDerivative(device, dataSize, basePipeline, pPipeline, result); - - return result; -} void PreCreatePipelineLayout( VkDevice device, @@ -9562,18 +8835,10 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* fun return (void*) vkCreateDepthStencilView; if (!strcmp(funcName, "vkCreateShader")) return (void*) vkCreateShader; - if (!strcmp(funcName, "vkCreateGraphicsPipeline")) - return (void*) vkCreateGraphicsPipeline; - if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative")) - return (void*) vkCreateGraphicsPipelineDerivative; - if (!strcmp(funcName, "vkCreateComputePipeline")) - return (void*) vkCreateComputePipeline; - if (!strcmp(funcName, "vkStorePipeline")) - return (void*) vkStorePipeline; - if (!strcmp(funcName, "vkLoadPipeline")) - return (void*) vkLoadPipeline; - if (!strcmp(funcName, "vkLoadPipelineDerivative")) - return (void*) vkLoadPipelineDerivative; + if (!strcmp(funcName, "vkCreateGraphicsPipelines")) + return (void*) vkCreateGraphicsPipelines; + if (!strcmp(funcName, "vkCreateComputePipelines")) + return (void*) vkCreateComputePipelines; if (!strcmp(funcName, "vkCreatePipelineLayout")) return (void*) vkCreatePipelineLayout; if (!strcmp(funcName, "vkCreateSampler")) diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp index 170b96ec..8d1a865f 100644 --- a/layers/shader_checker.cpp +++ b/layers/shader_checker.cpp @@ -846,8 +846,9 @@ shader_stage_attribs[VK_SHADER_STAGE_FRAGMENT + 1] = { }; +//TODO handle count > 1 static bool -validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCreateInfo) +validate_graphics_pipeline(VkDevice dev, uint32_t count, VkGraphicsPipelineCreateInfo const *pCreateInfo) { /* We seem to allow pipeline stages to be specified out of order, so collect and identify them * before trying to do anything more: */ @@ -917,19 +918,21 @@ validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCr return pass; } - +//TODO handle pipelineCache entry points VK_LAYER_EXPORT VkResult VKAPI -vkCreateGraphicsPipeline(VkDevice device, - const VkGraphicsPipelineCreateInfo *pCreateInfo, - VkPipeline *pPipeline) +vkCreateGraphicsPipelines(VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo *pCreateInfos, + VkPipeline *pPipelines) { - bool pass = validate_graphics_pipeline(device, pCreateInfo); + bool pass = validate_graphics_pipeline(device, count, pCreateInfos); if (pass) { /* The driver is allowed to crash if passed junk. Only actually create the * pipeline if we didn't run into any showstoppers above. */ - return get_dispatch_table(shader_checker_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + return get_dispatch_table(shader_checker_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); } else { return VK_ERROR_UNKNOWN; @@ -937,25 +940,6 @@ vkCreateGraphicsPipeline(VkDevice device, } -VK_LAYER_EXPORT VkResult VKAPI -vkCreateGraphicsPipelineDerivative(VkDevice device, - const VkGraphicsPipelineCreateInfo *pCreateInfo, - VkPipeline basePipeline, - VkPipeline *pPipeline) -{ - bool pass = validate_graphics_pipeline(device, pCreateInfo); - - if (pass) { - /* The driver is allowed to crash if passed junk. Only actually create the - * pipeline if we didn't run into any showstoppers above. - */ - return get_dispatch_table(shader_checker_device_table_map, device)->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); - } - else { - return VK_ERROR_UNKNOWN; - } -} - VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VkLayerDispatchTable *pDeviceTable = get_dispatch_table(shader_checker_device_table_map, *pDevice); @@ -1065,8 +1049,7 @@ VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcN ADD_HOOK(vkCreateShaderModule); ADD_HOOK(vkCreateShader); ADD_HOOK(vkDestroyDevice); - ADD_HOOK(vkCreateGraphicsPipeline); - ADD_HOOK(vkCreateGraphicsPipelineDerivative); + ADD_HOOK(vkCreateGraphicsPipelines); #undef ADD_HOOK VkLayerDispatchTable* pTable = get_dispatch_table(shader_checker_device_table_map, dev); diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h index a54f63bb..9532d5d2 100644 --- a/loader/gpa_helper.h +++ b/loader/gpa_helper.h @@ -149,18 +149,20 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkCreateShaderModule; if (!strcmp(name, "CreateShader")) return (void*) vkCreateShader; - if (!strcmp(name, "CreateGraphicsPipeline")) - return (void*) vkCreateGraphicsPipeline; - if (!strcmp(name, "CreateGraphicsPipelineDerivative")) - return (void*) vkCreateGraphicsPipelineDerivative; - if (!strcmp(name, "CreateComputePipeline")) - return (void*) vkCreateComputePipeline; - if (!strcmp(name, "StorePipeline")) - return (void*) vkStorePipeline; - if (!strcmp(name, "LoadPipeline")) - return (void*) vkLoadPipeline; - if (!strcmp(name, "LoadPipelineDerivative")) - return (void*) vkLoadPipelineDerivative; + if (!strcmp(name, "CreatePipelineCache")) + return (void*) vkCreatePipelineCache; + if (!strcmp(name, "DestroyPipelineCache")) + return (void*) vkDestroyPipelineCache; + if (!strcmp(name, "GetPipelineCacheSize")) + return (void*) vkGetPipelineCacheSize; + if (!strcmp(name, "GetPipelineCacheData")) + return (void*) vkGetPipelineCacheData; + if (!strcmp(name, "MergePipelineCaches")) + return (void*) vkMergePipelineCaches; + if (!strcmp(name, "CreateGraphicsPipelines")) + return (void*) vkCreateGraphicsPipelines; + if (!strcmp(name, "CreateComputePipelines")) + return (void*) vkCreateComputePipelines; if (!strcmp(name, "CreatePipelineLayout")) return (void*) vkCreatePipelineLayout; if (!strcmp(name, "CreateSampler")) diff --git a/loader/table_ops.h b/loader/table_ops.h index 4f3b5012..7563af84 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -78,12 +78,13 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->CreateDepthStencilView = (PFN_vkCreateDepthStencilView) gpa(dev, "vkCreateDepthStencilView"); table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(dev, "vkCreateShaderModule"); table->CreateShader = (PFN_vkCreateShader) gpa(dev, "vkCreateShader"); - table->CreateGraphicsPipeline = (PFN_vkCreateGraphicsPipeline) gpa(dev, "vkCreateGraphicsPipeline"); - table->CreateGraphicsPipelineDerivative = (PFN_vkCreateGraphicsPipelineDerivative) gpa(dev, "vkCreateGraphicsPipelineDerivative"); - table->CreateComputePipeline = (PFN_vkCreateComputePipeline) gpa(dev, "vkCreateComputePipeline"); - table->StorePipeline = (PFN_vkStorePipeline) gpa(dev, "vkStorePipeline"); - table->LoadPipeline = (PFN_vkLoadPipeline) gpa(dev, "vkLoadPipeline"); - table->LoadPipelineDerivative = (PFN_vkLoadPipelineDerivative) gpa(dev, "vkLoadPipelineDerivative"); + table->CreatePipelineCache = (PFN_vkCreatePipelineCache) gpa(dev, "vkCreatePipelineCache"); + table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache) gpa(dev, "vkDestroyPipelineCache"); + table->GetPipelineCacheSize = (PFN_vkGetPipelineCacheSize) gpa(dev, "vkGetPipelineCacheSize"); + table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData) gpa(dev, "vkGetPipelineCacheData"); + table->MergePipelineCaches = (PFN_vkMergePipelineCaches) gpa(dev, "vkMergePipelineCaches"); + table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) gpa(dev, "vkCreateGraphicsPipelines"); + table->CreateComputePipelines = (PFN_vkCreateComputePipelines) gpa(dev, "vkCreateComputePipelines"); table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(dev, "vkCreatePipelineLayout"); table->CreateSampler = (PFN_vkCreateSampler) gpa(dev, "vkCreateSampler"); table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(dev, "vkCreateDescriptorSetLayout"); @@ -237,18 +238,20 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->CreateShaderModule; if (!strcmp(name, "CreateShader")) return (void *) table->CreateShader; - if (!strcmp(name, "CreateGraphicsPipeline")) - return (void *) table->CreateGraphicsPipeline; - if (!strcmp(name, "CreateGraphicsPipelineDerivative")) - return (void *) table->CreateGraphicsPipelineDerivative; - if (!strcmp(name, "CreateComputePipeline")) - return (void *) table->CreateComputePipeline; - if (!strcmp(name, "StorePipeline")) - return (void *) table->StorePipeline; - if (!strcmp(name, "LoadPipeline")) - return (void *) table->LoadPipeline; - if (!strcmp(name, "LoadPipelineDerivative")) - return (void *) table->LoadPipelineDerivative; + if (!strcmp(name, "CreatePipelineCache")) + return (void*) vkCreatePipelineCache; + if (!strcmp(name, "DestroyPipelineCache")) + return (void*) vkDestroyPipelineCache; + if (!strcmp(name, "GetPipelineCacheSize")) + return (void*) vkGetPipelineCacheSize; + if (!strcmp(name, "GetPipelineCacheData")) + return (void*) vkGetPipelineCacheData; + if (!strcmp(name, "MergePipelineCaches")) + return (void*) vkMergePipelineCaches; + if (!strcmp(name, "CreateGraphicsPipelines")) + return (void*) vkCreateGraphicsPipelines; + if (!strcmp(name, "CreateComputePipelines")) + return (void*) vkCreateComputePipelines; if (!strcmp(name, "CreatePipelineLayout")) return (void *) table->CreatePipelineLayout; if (!strcmp(name, "CreateSampler")) diff --git a/loader/trampoline.c b/loader/trampoline.c index 19f1cbbc..a7b60378 100644 --- a/loader/trampoline.c +++ b/loader/trampoline.c @@ -690,58 +690,67 @@ LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreat return disp->CreateShader(device, pCreateInfo, pShader); } -LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) +LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache); } -LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) +LOADER_EXPORT VkResult VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + return disp->DestroyPipelineCache(device, pipelineCache); } -LOADER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) +LOADER_EXPORT size_t VKAPI vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateComputePipeline(device, pCreateInfo, pPipeline); + return disp->GetPipelineCacheSize(device, pipelineCache); } -LOADER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) +LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->StorePipeline(device, pipeline, pDataSize, pData); + return disp->GetPipelineCacheData(device, pipelineCache, pData); } -LOADER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) +LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->LoadPipeline(device, dataSize, pData, pPipeline); + return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches); } -LOADER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) +LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); + return disp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); +} + +LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) +{ + const VkLayerDispatchTable *disp; + + disp = loader_get_dispatch(device); + + return disp->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines); } LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) diff --git a/vk_helper.py b/vk_helper.py index 9e5b2e63..64b02b9f 100755 --- a/vk_helper.py +++ b/vk_helper.py @@ -882,12 +882,15 @@ class StructWrapperGen: else: sh_funcs.append('%s' % lineinfo.get()) sh_funcs.append(' ss[%u] << &pStruct->%s;' % (index, self.struct_dict[s][m]['name'])) + elif self.struct_dict[s][m]['array']: + sh_funcs.append('%s' % lineinfo.get()) + sh_funcs.append(' ss[%u] << (void*)pStruct->%s;' % (index, self.struct_dict[s][m]['name'])) elif 'bool' in self.struct_dict[s][m]['type'].lower(): sh_funcs.append('%s' % lineinfo.get()) sh_funcs.append(' ss[%u].str(pStruct->%s ? "TRUE" : "FALSE");' % (index, self.struct_dict[s][m]['name'])) elif 'uint8' in self.struct_dict[s][m]['type'].lower(): sh_funcs.append('%s' % lineinfo.get()) - sh_funcs.append(' ss[%u] << (uint32_t)pStruct->%s;' % (index, self.struct_dict[s][m]['name'])) + sh_funcs.append(' ss[%u] << pStruct->%s;' % (index, self.struct_dict[s][m]['name'])) elif 'void' in self.struct_dict[s][m]['type'].lower() and self.struct_dict[s][m]['ptr']: sh_funcs.append('%s' % lineinfo.get()) sh_funcs.append(' if (StreamControl::writeAddress)') diff --git a/vulkan.py b/vulkan.py index 01112c79..f73942f1 100755 --- a/vulkan.py +++ b/vulkan.py @@ -198,6 +198,7 @@ core = Extension( "VkDepthStencilView", "VkShader", "VkPipeline", + "VkPipelineCache", "VkSampler", "VkDescriptorSet", "VkDescriptorSetLayout", @@ -512,40 +513,43 @@ core = Extension( Param("const VkShaderCreateInfo*", "pCreateInfo"), Param("VkShader*", "pShader")]), - Proto("VkResult", "CreateGraphicsPipeline", + Proto("VkResult", "CreatePipelineCache", [Param("VkDevice", "device"), - Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfo"), - Param("VkPipeline*", "pPipeline")]), + Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"), + Param("VkPipelineCache*", "pPipelineCache")]), - Proto("VkResult", "CreateGraphicsPipelineDerivative", + Proto("VkResult", "DestroyPipelineCache", [Param("VkDevice", "device"), - Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfo"), - Param("VkPipeline", "basePipeline"), - Param("VkPipeline*", "pPipeline")]), + Param("VkPipelineCache", "pipelineCache")]), - Proto("VkResult", "CreateComputePipeline", + Proto("size_t", "GetPipelineCacheSize", [Param("VkDevice", "device"), - Param("const VkComputePipelineCreateInfo*", "pCreateInfo"), - Param("VkPipeline*", "pPipeline")]), + Param("VkPipelineCache", "pipelineCache")]), - Proto("VkResult", "StorePipeline", + Proto("VkResult", "GetPipelineCacheData", [Param("VkDevice", "device"), - Param("VkPipeline", "pipeline"), - Param("size_t*", "pDataSize"), + Param("VkPipelineCache", "pipelineCache"), Param("void*", "pData")]), - Proto("VkResult", "LoadPipeline", + Proto("VkResult", "MergePipelineCaches", [Param("VkDevice", "device"), - Param("size_t", "dataSize"), - Param("const void*", "pData"), - Param("VkPipeline*", "pPipeline")]), + Param("VkPipelineCache", "destCache"), + Param("uint32_t", "srcCacheCount"), + Param("const VkPipelineCache*", "pSrcCaches")]), - Proto("VkResult", "LoadPipelineDerivative", + Proto("VkResult", "CreateGraphicsPipelines", [Param("VkDevice", "device"), - Param("size_t", "dataSize"), - Param("const void*", "pData"), - Param("VkPipeline", "basePipeline"), - Param("VkPipeline*", "pPipeline")]), + Param("VkPipelineCache", "pipelineCache"), + Param("uint32_t", "count"), + Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"), + Param("VkPipeline*", "pPipelines")]), + + Proto("VkResult", "CreateComputePipelines", + [Param("VkDevice", "device"), + Param("VkPipelineCache", "pipelineCache"), + Param("uint32_t", "count"), + Param("const VkComputePipelineCreateInfo*", "pCreateInfos"), + Param("VkPipeline*", "pPipelines")]), Proto("VkResult", "CreatePipelineLayout", [Param("VkDevice", "device"), @@ -942,6 +946,7 @@ object_list = [ "VkDepthStencilView", "VkShader", "VkPipeline", + "VkPipelineCache", "VkPipelineLayout", "VkSampler", "VkDescriptorSet", -- cgit v1.2.3