1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2015 The Khronos Group Inc. 6 * Copyright (c) 2015 ARM Ltd. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 * 20 *//*! 21 * \file 22 * \brief Pipeline Cache Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktPipelineCacheTests.hpp" 26 #include "vktPipelineClearUtil.hpp" 27 #include "vktPipelineImageUtil.hpp" 28 #include "vktPipelineVertexUtil.hpp" 29 #include "vktTestCase.hpp" 30 #include "vktTestCaseUtil.hpp" 31 #include "vkImageUtil.hpp" 32 #include "vkMemUtil.hpp" 33 #include "vkPrograms.hpp" 34 #include "vkBuilderUtil.hpp" 35 #include "vkQueryUtil.hpp" 36 #include "vkRef.hpp" 37 #include "vkRefUtil.hpp" 38 #include "tcuImageCompare.hpp" 39 #include "deUniquePtr.hpp" 40 #include "deMemory.h" 41 #include "vkTypeUtil.hpp" 42 43 #include <sstream> 44 #include <vector> 45 46 namespace vkt 47 { 48 namespace pipeline 49 { 50 51 using namespace vk; 52 53 namespace 54 { 55 enum 56 { 57 VK_MAX_SHADER_STAGES = 6, 58 }; 59 60 // helper functions 61 62 std::string getShaderFlagStr (const VkShaderStageFlagBits shader, 63 bool isDescription) 64 { 65 std::ostringstream desc; 66 switch(shader) 67 { 68 case VK_SHADER_STAGE_VERTEX_BIT: 69 { 70 desc << ((isDescription) ? "vertex stage" : "vertex_stage"); 71 break; 72 } 73 case VK_SHADER_STAGE_FRAGMENT_BIT: 74 { 75 desc << ((isDescription) ? "fragment stage" : "fragment_stage"); 76 break; 77 } 78 case VK_SHADER_STAGE_GEOMETRY_BIT: 79 { 80 desc << ((isDescription) ? "geometry stage" : "geometry_stage"); 81 break; 82 } 83 case VK_SHADER_STAGE_COMPUTE_BIT: 84 { 85 desc << ((isDescription) ? "compute stage" : "compute_stage"); 86 break; 87 } 88 case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: 89 { 90 desc << ((isDescription) ? "tessellation control stage" : "tessellation_control_stage"); 91 break; 92 } 93 case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: 94 { 95 desc << ((isDescription) ? "tessellation evaluation stage" : "tessellation_evaluation_stage"); 96 break; 97 } 98 default: 99 desc << "unknown shader stage!"; 100 DE_FATAL("Unknown shader Stage!"); 101 break; 102 }; 103 104 return desc.str(); 105 } 106 107 // helper classes 108 class CacheTestParam 109 { 110 public: 111 CacheTestParam (const VkShaderStageFlagBits* shaders, 112 deUint32 count); 113 virtual ~CacheTestParam (void); 114 virtual const std::string generateTestName (void) const; 115 virtual const std::string generateTestDescription (void) const; 116 VkShaderStageFlagBits getShaderFlag (deUint32 ndx) const { return m_shaders[ndx]; } 117 deUint32 getShaderCount (void) const { return (deUint32)m_shaderCount; } 118 protected: 119 VkShaderStageFlagBits m_shaders[VK_MAX_SHADER_STAGES]; 120 size_t m_shaderCount; 121 }; 122 123 CacheTestParam::CacheTestParam (const VkShaderStageFlagBits* shaders, deUint32 count) 124 { 125 DE_ASSERT(count <= VK_MAX_SHADER_STAGES); 126 for (deUint32 ndx = 0; ndx < count; ndx++) 127 m_shaders[ndx] = shaders[ndx]; 128 m_shaderCount = count; 129 } 130 131 CacheTestParam::~CacheTestParam (void) 132 { 133 } 134 135 const std::string CacheTestParam::generateTestName (void) const 136 { 137 std::string result(getShaderFlagStr(m_shaders[0], false)); 138 139 for(deUint32 ndx = 1; ndx < m_shaderCount; ndx++) 140 result += '_' + getShaderFlagStr(m_shaders[ndx], false) ; 141 142 return result; 143 } 144 145 const std::string CacheTestParam::generateTestDescription (void) const 146 { 147 std::string result("Create pipeline cache with " + getShaderFlagStr(m_shaders[0], true)); 148 149 for(deUint32 ndx = 1; ndx < m_shaderCount; ndx++) 150 result += ' ' + getShaderFlagStr(m_shaders[ndx], true); 151 152 return result; 153 } 154 155 class SimpleGraphicsPipelineBuilder 156 { 157 public: 158 SimpleGraphicsPipelineBuilder (Context& context); 159 ~SimpleGraphicsPipelineBuilder (void) { } 160 void bindShaderStage (VkShaderStageFlagBits stage, 161 const char* sourceName, 162 const char* entryName); 163 void enableTessellationStage (deUint32 patchControlPoints); 164 Move<VkPipeline> buildPipeline (tcu::UVec2 renderSize, 165 VkRenderPass renderPass, 166 VkPipelineCache cache, 167 VkPipelineLayout pipelineLayout); 168 protected: 169 Context& m_context; 170 171 Move<VkShaderModule> m_shaderModules[VK_MAX_SHADER_STAGES]; 172 deUint32 m_shaderStageCount; 173 VkPipelineShaderStageCreateInfo m_shaderStageInfo[VK_MAX_SHADER_STAGES]; 174 175 deUint32 m_patchControlPoints; 176 }; 177 178 SimpleGraphicsPipelineBuilder::SimpleGraphicsPipelineBuilder (Context& context) 179 : m_context(context) 180 { 181 m_patchControlPoints = 0; 182 m_shaderStageCount = 0; 183 } 184 185 void SimpleGraphicsPipelineBuilder::bindShaderStage (VkShaderStageFlagBits stage, 186 const char* sourceName, 187 const char* entryName) 188 { 189 const DeviceInterface& vk = m_context.getDeviceInterface(); 190 const VkDevice vkDevice = m_context.getDevice(); 191 192 // Create shader module 193 deUint32* code = (deUint32*)m_context.getBinaryCollection().get(sourceName).getBinary(); 194 deUint32 codeSize = (deUint32)m_context.getBinaryCollection().get(sourceName).getSize(); 195 196 const VkShaderModuleCreateInfo moduleCreateInfo = 197 { 198 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType; 199 DE_NULL, // const void* pNext; 200 0u, // VkShaderModuleCreateFlags flags; 201 codeSize, // deUintptr codeSize; 202 code, // const deUint32* pCode; 203 }; 204 205 m_shaderModules[m_shaderStageCount] = createShaderModule(vk, vkDevice, &moduleCreateInfo); 206 207 // Prepare shader stage info 208 m_shaderStageInfo[m_shaderStageCount].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 209 m_shaderStageInfo[m_shaderStageCount].pNext = DE_NULL; 210 m_shaderStageInfo[m_shaderStageCount].flags = 0u; 211 m_shaderStageInfo[m_shaderStageCount].stage = stage; 212 m_shaderStageInfo[m_shaderStageCount].module = *m_shaderModules[m_shaderStageCount]; 213 m_shaderStageInfo[m_shaderStageCount].pName = entryName; 214 m_shaderStageInfo[m_shaderStageCount].pSpecializationInfo = DE_NULL; 215 216 m_shaderStageCount++; 217 } 218 219 Move<VkPipeline> SimpleGraphicsPipelineBuilder::buildPipeline (tcu::UVec2 renderSize, VkRenderPass renderPass, VkPipelineCache cache, VkPipelineLayout pipelineLayout) 220 { 221 const DeviceInterface& vk = m_context.getDeviceInterface(); 222 const VkDevice vkDevice = m_context.getDevice(); 223 224 // Create pipeline 225 const VkVertexInputBindingDescription vertexInputBindingDescription = 226 { 227 0u, // deUint32 binding; 228 sizeof(Vertex4RGBA), // deUint32 strideInBytes; 229 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate; 230 }; 231 232 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] = 233 { 234 { 235 0u, // deUint32 location; 236 0u, // deUint32 binding; 237 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format; 238 0u // deUint32 offsetInBytes; 239 }, 240 { 241 1u, // deUint32 location; 242 0u, // deUint32 binding; 243 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format; 244 DE_OFFSET_OF(Vertex4RGBA, color), // deUint32 offsetInBytes; 245 } 246 }; 247 248 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = 249 { 250 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; 251 DE_NULL, // const void* pNext; 252 0u, // VkPipelineVertexInputStateCreateFlags flags; 253 1u, // deUint32 vertexBindingDescriptionCount; 254 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; 255 2u, // deUint32 vertexAttributeDescriptionCount; 256 vertexInputAttributeDescriptions, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 257 }; 258 259 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = 260 { 261 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; 262 DE_NULL, // const void* pNext; 263 0u, // VkPipelineInputAssemblyStateCreateFlags flags; 264 (m_patchControlPoints == 0 ? VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST 265 : VK_PRIMITIVE_TOPOLOGY_PATCH_LIST), // VkPrimitiveTopology topology; 266 VK_FALSE, // VkBool32 primitiveRestartEnable; 267 }; 268 269 const VkViewport viewport = 270 { 271 0.0f, // float originX; 272 0.0f, // float originY; 273 (float)renderSize.x(), // float width; 274 (float)renderSize.y(), // float height; 275 0.0f, // float minDepth; 276 1.0f // float maxDepth; 277 }; 278 const VkRect2D scissor = 279 { 280 { 0, 0 }, // VkOffset2D offset; 281 { renderSize.x(), renderSize.y() } // VkExtent2D extent; 282 }; 283 const VkPipelineViewportStateCreateInfo viewportStateParams = 284 { 285 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; 286 DE_NULL, // const void* pNext; 287 0u, // VkPipelineViewportStateCreateFlags flags; 288 1u, // deUint32 viewportCount; 289 &viewport, // const VkViewport* pViewports; 290 1u, // deUint32 scissorCount; 291 &scissor // const VkRect2D* pScissors; 292 }; 293 294 const VkPipelineRasterizationStateCreateInfo rasterStateParams = 295 { 296 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; 297 DE_NULL, // const void* pNext; 298 0u, // VkPipelineRasterizationStateCreateFlags flags; 299 VK_FALSE, // VkBool32 depthClampEnable; 300 VK_FALSE, // VkBool32 rasterizerDiscardEnable; 301 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; 302 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; 303 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; 304 VK_FALSE, // VkBool32 depthBiasEnable; 305 0.0f, // float depthBiasConstantFactor; 306 0.0f, // float depthBiasClamp; 307 0.0f, // float depthBiasSlopeFactor; 308 1.0f, // float lineWidth; 309 }; 310 311 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = 312 { 313 VK_FALSE, // VkBool32 blendEnable; 314 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor; 315 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; 316 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp; 317 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor; 318 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor; 319 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; 320 VK_COLOR_COMPONENT_R_BIT | 321 VK_COLOR_COMPONENT_G_BIT | 322 VK_COLOR_COMPONENT_B_BIT | 323 VK_COLOR_COMPONENT_A_BIT // VkColorComponentFlags colorWriteMask; 324 }; 325 326 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = 327 { 328 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; 329 DE_NULL, // const void* pNext; 330 0u, // VkPipelineColorBlendStateCreateFlags flags; 331 VK_FALSE, // VkBool32 logicOpEnable; 332 VK_LOGIC_OP_COPY, // VkLogicOp logicOp; 333 1u, // deUint32 attachmentCount; 334 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments; 335 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4]; 336 }; 337 338 const VkPipelineMultisampleStateCreateInfo multisampleStateParams = 339 { 340 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; 341 DE_NULL, // const void* pNext; 342 0u, // VkPipelineMultisampleStateCreateFlags flags; 343 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; 344 VK_FALSE, // VkBool32 sampleShadingEnable; 345 0.0f, // float minSampleShading; 346 DE_NULL, // const VkSampleMask* pSampleMask; 347 VK_FALSE, // VkBool32 alphaToCoverageEnable; 348 VK_FALSE, // VkBool32 alphaToOneEnable; 349 }; 350 351 VkPipelineDepthStencilStateCreateInfo depthStencilStateParams = 352 { 353 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; 354 DE_NULL, // const void* pNext; 355 0u, // VkPipelineDepthStencilStateCreateFlags flags; 356 VK_TRUE, // VkBool32 depthTestEnable; 357 VK_TRUE, // VkBool32 depthWriteEnable; 358 VK_COMPARE_OP_LESS_OR_EQUAL, // VkCompareOp depthCompareOp; 359 VK_FALSE, // VkBool32 depthBoundsTestEnable; 360 VK_FALSE, // VkBool32 stencilTestEnable; 361 // VkStencilOpState front; 362 { 363 VK_STENCIL_OP_KEEP, // VkStencilOp failOp; 364 VK_STENCIL_OP_KEEP, // VkStencilOp passOp; 365 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; 366 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 367 0u, // deUint32 compareMask; 368 0u, // deUint32 writeMask; 369 0u, // deUint32 reference; 370 }, 371 // VkStencilOpState back; 372 { 373 VK_STENCIL_OP_KEEP, // VkStencilOp failOp; 374 VK_STENCIL_OP_KEEP, // VkStencilOp passOp; 375 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; 376 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 377 0u, // deUint32 compareMask; 378 0u, // deUint32 writeMask; 379 0u, // deUint32 reference; 380 }, 381 0.0f, // float minDepthBounds; 382 1.0f, // float maxDepthBounds; 383 }; 384 385 const VkPipelineTessellationStateCreateInfo tessStateCreateInfo = 386 { 387 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType; 388 DE_NULL, // const void* pNext; 389 0u, // VkPipelineTesselationStateCreateFlags flags; 390 m_patchControlPoints, // deUint32 patchControlPoints; 391 }; 392 const VkPipelineTessellationStateCreateInfo* pTessCreateInfo = (m_patchControlPoints > 0) 393 ? &tessStateCreateInfo 394 : DE_NULL; 395 396 const VkGraphicsPipelineCreateInfo graphicsPipelineParams = 397 { 398 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; 399 DE_NULL, // const void* pNext; 400 0u, // VkPipelineCreateFlags flags; 401 m_shaderStageCount, // deUint32 stageCount; 402 m_shaderStageInfo, // const VkPipelineShaderStageCreateInfo* pStages; 403 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 404 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 405 pTessCreateInfo, // const VkPipelineTessellationStateCreateInfo* pTessellationState; 406 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; 407 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterState; 408 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 409 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 410 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 411 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; 412 pipelineLayout, // VkPipelineLayout layout; 413 renderPass, // VkRenderPass renderPass; 414 0u, // deUint32 subpass; 415 0u, // VkPipeline basePipelineHandle; 416 0, // deInt32 basePipelineIndex; 417 }; 418 419 return createGraphicsPipeline(vk, vkDevice, cache, &graphicsPipelineParams); 420 } 421 422 void SimpleGraphicsPipelineBuilder::enableTessellationStage (deUint32 patchControlPoints) 423 { 424 m_patchControlPoints = patchControlPoints; 425 } 426 427 template <class Test> 428 vkt::TestCase* newTestCase (tcu::TestContext& testContext, 429 const CacheTestParam* testParam) 430 { 431 return new Test(testContext, 432 testParam->generateTestName().c_str(), 433 testParam->generateTestDescription().c_str(), 434 testParam); 435 } 436 437 Move<VkBuffer> createBufferAndBindMemory (Context& context, VkDeviceSize size, VkBufferUsageFlags usage, de::MovePtr<Allocation>* pAlloc) 438 { 439 const DeviceInterface& vk = context.getDeviceInterface(); 440 const VkDevice vkDevice = context.getDevice(); 441 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 442 443 const VkBufferCreateInfo vertexBufferParams = 444 { 445 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 446 DE_NULL, // const void* pNext; 447 0u, // VkBufferCreateFlags flags; 448 size, // VkDeviceSize size; 449 usage, // VkBufferUsageFlags usage; 450 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 451 1u, // deUint32 queueFamilyCount; 452 &queueFamilyIndex // const deUint32* pQueueFamilyIndices; 453 }; 454 455 Move<VkBuffer> vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams); 456 457 *pAlloc = context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible); 458 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, (*pAlloc)->getMemory(), (*pAlloc)->getOffset())); 459 460 return vertexBuffer; 461 } 462 463 Move<VkImage> createImage2DAndBindMemory (Context& context, 464 VkFormat format, 465 deUint32 width, 466 deUint32 height, 467 VkImageUsageFlags usage, 468 VkSampleCountFlagBits sampleCount, 469 de::details::MovePtr<Allocation>* pAlloc) 470 { 471 const DeviceInterface& vk = context.getDeviceInterface(); 472 const VkDevice vkDevice = context.getDevice(); 473 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 474 475 const VkImageCreateInfo colorImageParams = 476 { 477 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; 478 DE_NULL, // const void* pNext; 479 0u, // VkImageCreateFlags flags; 480 VK_IMAGE_TYPE_2D, // VkImageType imageType; 481 format, // VkFormat format; 482 { width, height, 1u }, // VkExtent3D extent; 483 1u, // deUint32 mipLevels; 484 1u, // deUint32 arraySize; 485 sampleCount, // deUint32 samples; 486 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; 487 usage, // VkImageUsageFlags usage; 488 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 489 1u, // deUint32 queueFamilyCount; 490 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices; 491 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; 492 }; 493 494 Move<VkImage> image = createImage(vk, vkDevice, &colorImageParams); 495 496 *pAlloc = context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any); 497 VK_CHECK(vk.bindImageMemory(vkDevice, *image, (*pAlloc)->getMemory(), (*pAlloc)->getOffset())); 498 499 return image; 500 } 501 502 // Test Classes 503 class CacheTest : public vkt::TestCase 504 { 505 public: 506 CacheTest(tcu::TestContext& testContext, 507 const std::string& name, 508 const std::string& description, 509 const CacheTestParam* param) 510 : vkt::TestCase (testContext, name, description) 511 , m_param (*param) 512 { } 513 virtual ~CacheTest (void) { } 514 protected: 515 const CacheTestParam m_param; 516 }; 517 518 class CacheTestInstance : public vkt::TestInstance 519 { 520 public: 521 enum 522 { 523 PIPELINE_CACHE_NDX_NO_CACHE, 524 PIPELINE_CACHE_NDX_CACHED, 525 PIPELINE_CACHE_NDX_COUNT, 526 }; 527 CacheTestInstance (Context& context, 528 const CacheTestParam* param); 529 virtual ~CacheTestInstance (void); 530 virtual tcu::TestStatus iterate (void); 531 protected: 532 virtual tcu::TestStatus verifyTestResult (void) = 0; 533 virtual void prepareCommandBuffer (void) = 0; 534 protected: 535 const CacheTestParam* m_param; 536 537 Move<VkCommandPool> m_cmdPool; 538 Move<VkCommandBuffer> m_cmdBuffer; 539 Move<VkFence> m_fence; 540 Move<VkPipelineCache> m_cache; 541 }; 542 543 CacheTestInstance::CacheTestInstance (Context& context, 544 const CacheTestParam* param) 545 : TestInstance (context) 546 , m_param (param) 547 { 548 const DeviceInterface& vk = m_context.getDeviceInterface(); 549 const VkDevice vkDevice = m_context.getDevice(); 550 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 551 552 // Create command pool 553 m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 554 555 // Create command buffer 556 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 557 558 // Create fence 559 m_fence = createFence(vk, vkDevice); 560 561 // Create the Pipeline Cache 562 { 563 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo = 564 { 565 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 566 DE_NULL, // const void* pNext; 567 0u, // VkPipelineCacheCreateFlags flags; 568 0u, // deUintptr initialDataSize; 569 DE_NULL, // const void* pInitialData; 570 }; 571 572 m_cache = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 573 } 574 } 575 576 CacheTestInstance::~CacheTestInstance (void) 577 { 578 } 579 580 tcu::TestStatus CacheTestInstance::iterate (void) 581 { 582 const DeviceInterface& vk = m_context.getDeviceInterface(); 583 const VkDevice vkDevice = m_context.getDevice(); 584 const VkQueue queue = m_context.getUniversalQueue(); 585 586 prepareCommandBuffer(); 587 588 VK_CHECK(vk.resetFences(vkDevice, 1u, &m_fence.get())); 589 590 const VkSubmitInfo submitInfo = 591 { 592 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; 593 DE_NULL, // const void* pNext; 594 0u, // deUint32 waitSemaphoreCount; 595 DE_NULL, // const VkSemaphore* pWaitSemaphores; 596 (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask; 597 1u, // deUint32 commandBufferCount; 598 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; 599 0u, // deUint32 signalSemaphoreCount; 600 DE_NULL, // const VkSemaphore* pSignalSemaphores; 601 }; 602 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *m_fence)); 603 604 VK_CHECK(vk.waitForFences(vkDevice, 1u, &m_fence.get(), true, ~(0ull) /* infinity*/)); 605 606 return verifyTestResult(); 607 } 608 609 class GraphicsCacheTest : public CacheTest 610 { 611 public: 612 GraphicsCacheTest (tcu::TestContext& testContext, 613 const std::string& name, 614 const std::string& description, 615 const CacheTestParam* param) 616 : CacheTest (testContext, name, description, param) 617 { } 618 virtual ~GraphicsCacheTest (void) { } 619 virtual void initPrograms (SourceCollections& programCollection) const; 620 virtual TestInstance* createInstance (Context& context) const; 621 }; 622 623 class GraphicsCacheTestInstance : public CacheTestInstance 624 { 625 public: 626 GraphicsCacheTestInstance (Context& context, 627 const CacheTestParam* param); 628 virtual ~GraphicsCacheTestInstance (void); 629 protected: 630 void prepareRenderPass (VkFramebuffer framebuffer, VkPipeline pipeline); 631 virtual void prepareCommandBuffer (void); 632 virtual tcu::TestStatus verifyTestResult (void); 633 634 protected: 635 const tcu::UVec2 m_renderSize; 636 const VkFormat m_colorFormat; 637 const VkFormat m_depthFormat; 638 Move<VkPipelineLayout> m_pipelineLayout; 639 640 Move<VkImage> m_depthImage; 641 de::MovePtr<Allocation> m_depthImageAlloc; 642 de::MovePtr<Allocation> m_colorImageAlloc[PIPELINE_CACHE_NDX_COUNT]; 643 Move<VkImageView> m_depthAttachmentView; 644 VkImageMemoryBarrier m_imageLayoutBarriers[3]; 645 646 Move<VkBuffer> m_vertexBuffer; 647 de::MovePtr<Allocation> m_vertexBufferMemory; 648 std::vector<Vertex4RGBA> m_vertices; 649 650 SimpleGraphicsPipelineBuilder m_pipelineBuilder; 651 Move<VkRenderPass> m_renderPass; 652 653 Move<VkImage> m_colorImage[PIPELINE_CACHE_NDX_COUNT]; 654 Move<VkImageView> m_colorAttachmentView[PIPELINE_CACHE_NDX_COUNT]; 655 Move<VkFramebuffer> m_framebuffer[PIPELINE_CACHE_NDX_COUNT]; 656 Move<VkPipeline> m_pipeline[PIPELINE_CACHE_NDX_COUNT]; 657 }; 658 659 void GraphicsCacheTest::initPrograms (SourceCollections& programCollection) const 660 { 661 for (deUint32 shaderNdx = 0; shaderNdx < m_param.getShaderCount(); shaderNdx++) 662 { 663 switch(m_param.getShaderFlag(shaderNdx)) 664 { 665 case VK_SHADER_STAGE_VERTEX_BIT: 666 programCollection.glslSources.add("color_vert") << glu::VertexSource( 667 "#version 310 es\n" 668 "layout(location = 0) in vec4 position;\n" 669 "layout(location = 1) in vec4 color;\n" 670 "layout(location = 0) out highp vec4 vtxColor;\n" 671 "void main (void)\n" 672 "{\n" 673 " gl_Position = position;\n" 674 " vtxColor = color;\n" 675 "}\n"); 676 break; 677 678 case VK_SHADER_STAGE_FRAGMENT_BIT: 679 programCollection.glslSources.add("color_frag") << glu::FragmentSource( 680 "#version 310 es\n" 681 "layout(location = 0) in highp vec4 vtxColor;\n" 682 "layout(location = 0) out highp vec4 fragColor;\n" 683 "void main (void)\n" 684 "{\n" 685 " fragColor = vtxColor;\n" 686 "}\n"); 687 break; 688 689 case VK_SHADER_STAGE_GEOMETRY_BIT: 690 programCollection.glslSources.add("dummy_geo") << glu::GeometrySource( 691 "#version 450 \n" 692 "layout(triangles) in;\n" 693 "layout(triangle_strip, max_vertices = 3) out;\n" 694 "layout(location = 0) in highp vec4 in_vtxColor[];\n" 695 "layout(location = 0) out highp vec4 vtxColor;\n" 696 "out gl_PerVertex { vec4 gl_Position; };\n" 697 "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" 698 "void main (void)\n" 699 "{\n" 700 " for(int ndx=0; ndx<3; ndx++)\n" 701 " {\n" 702 " gl_Position = gl_in[ndx].gl_Position;\n" 703 " vtxColor = in_vtxColor[ndx];\n" 704 " EmitVertex();\n" 705 " }\n" 706 " EndPrimitive();\n" 707 "}\n"); 708 break; 709 710 case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: 711 programCollection.glslSources.add("basic_tcs") << glu::TessellationControlSource( 712 "#version 450 \n" 713 "layout(vertices = 3) out;\n" 714 "layout(location = 0) in highp vec4 color[];\n" 715 "layout(location = 0) out highp vec4 vtxColor[];\n" 716 "out gl_PerVertex { vec4 gl_Position; } gl_out[3];\n" 717 "in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices];\n" 718 "void main()\n" 719 "{\n" 720 " gl_TessLevelOuter[0] = 4.0;\n" 721 " gl_TessLevelOuter[1] = 4.0;\n" 722 " gl_TessLevelOuter[2] = 4.0;\n" 723 " gl_TessLevelInner[0] = 4.0;\n" 724 " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" 725 " vtxColor[gl_InvocationID] = color[gl_InvocationID];\n" 726 "}\n"); 727 break; 728 729 case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: 730 programCollection.glslSources.add("basic_tes") << glu::TessellationEvaluationSource( 731 "#version 450 \n" 732 "layout(triangles, fractional_even_spacing, ccw) in;\n" 733 "layout(location = 0) in highp vec4 colors[];\n" 734 "layout(location = 0) out highp vec4 vtxColor;\n" 735 "out gl_PerVertex { vec4 gl_Position; };\n" 736 "in gl_PerVertex { vec4 gl_Position; } gl_in[gl_MaxPatchVertices];\n" 737 "void main() \n" 738 "{\n" 739 " float u = gl_TessCoord.x;\n" 740 " float v = gl_TessCoord.y;\n" 741 " float w = gl_TessCoord.z;\n" 742 " vec4 pos = vec4(0);\n" 743 " vec4 color = vec4(0);\n" 744 " pos.xyz += u * gl_in[0].gl_Position.xyz;\n" 745 " color.xyz += u * colors[0].xyz;\n" 746 " pos.xyz += v * gl_in[1].gl_Position.xyz;\n" 747 " color.xyz += v * colors[1].xyz;\n" 748 " pos.xyz += w * gl_in[2].gl_Position.xyz;\n" 749 " color.xyz += w * colors[2].xyz;\n" 750 " pos.w = 1.0;\n" 751 " color.w = 1.0;\n" 752 " gl_Position = pos;\n" 753 " vtxColor = color;\n" 754 "}\n"); 755 break; 756 757 default: 758 DE_FATAL("Unknown Shader Stage!"); 759 break; 760 }; 761 } 762 } 763 764 TestInstance* GraphicsCacheTest::createInstance (Context& context) const 765 { 766 return new GraphicsCacheTestInstance(context, &m_param); 767 } 768 769 GraphicsCacheTestInstance::GraphicsCacheTestInstance (Context& context, 770 const CacheTestParam* param) 771 : CacheTestInstance (context,param) 772 , m_renderSize (32u, 32u) 773 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) 774 , m_depthFormat (VK_FORMAT_D16_UNORM) 775 , m_pipelineBuilder (context) 776 { 777 const DeviceInterface& vk = m_context.getDeviceInterface(); 778 const VkDevice vkDevice = m_context.getDevice(); 779 780 // Create vertex buffer 781 { 782 m_vertexBuffer = createBufferAndBindMemory(m_context, 1024u, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, &m_vertexBufferMemory); 783 784 m_vertices = createOverlappingQuads(); 785 // Load vertices into vertex buffer 786 deMemcpy(m_vertexBufferMemory->getHostPtr(), m_vertices.data(), m_vertices.size() * sizeof(Vertex4RGBA)); 787 flushMappedMemoryRange(vk, vkDevice, m_vertexBufferMemory->getMemory(), m_vertexBufferMemory->getOffset(), 1024u); 788 } 789 790 // Create render pass 791 { 792 const VkAttachmentDescription colorAttachmentDescription = 793 { 794 0u, // VkAttachmentDescriptionFlags flags; 795 m_colorFormat, // VkFormat format; 796 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 797 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 798 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 799 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 800 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 801 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; 802 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout; 803 }; 804 805 const VkAttachmentDescription depthAttachmentDescription = 806 { 807 0u, // VkAttachmentDescriptionFlags flags; 808 m_depthFormat, // VkFormat format; 809 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 810 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 811 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp; 812 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 813 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 814 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; 815 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout; 816 }; 817 818 const VkAttachmentDescription attachments[2] = 819 { 820 colorAttachmentDescription, 821 depthAttachmentDescription 822 }; 823 824 const VkAttachmentReference colorAttachmentReference = 825 { 826 0u, // deUint32 attachment; 827 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 828 }; 829 830 const VkAttachmentReference depthAttachmentReference = 831 { 832 1u, // deUint32 attachment; 833 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout layout; 834 }; 835 836 const VkSubpassDescription subpassDescription = 837 { 838 0u, // VkSubpassDescriptionFlags flags; 839 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 840 0u, // deUint32 inputAttachmentCount; 841 DE_NULL, // const VkAttachmentReference* pInputAttachments; 842 1u, // deUint32 colorAttachmentCount; 843 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; 844 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 845 &depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment; 846 0u, // deUint32 preserveAttachmentCount; 847 DE_NULL // const VkAttachmentReference* pPreserveAttachments; 848 }; 849 850 const VkRenderPassCreateInfo renderPassParams = 851 { 852 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 853 DE_NULL, // const void* pNext; 854 0u, // VkRenderPassCreateFlags flags; 855 2u, // deUint32 attachmentCount; 856 attachments, // const VkAttachmentDescription* pAttachments; 857 1u, // deUint32 subpassCount; 858 &subpassDescription, // const VkSubpassDescription* pSubpasses; 859 0u, // deUint32 dependencyCount; 860 DE_NULL // const VkSubpassDependency* pDependencies; 861 }; 862 863 m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams); 864 } 865 866 const VkComponentMapping ComponentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A}; 867 // Create color image 868 { 869 m_colorImage[PIPELINE_CACHE_NDX_NO_CACHE] = createImage2DAndBindMemory(m_context, 870 m_colorFormat, 871 m_renderSize.x(), 872 m_renderSize.y(), 873 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 874 VK_SAMPLE_COUNT_1_BIT, 875 &m_colorImageAlloc[PIPELINE_CACHE_NDX_NO_CACHE]); 876 m_colorImage[PIPELINE_CACHE_NDX_CACHED] = createImage2DAndBindMemory(m_context, 877 m_colorFormat, 878 m_renderSize.x(), 879 m_renderSize.y(), 880 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 881 VK_SAMPLE_COUNT_1_BIT, 882 &m_colorImageAlloc[PIPELINE_CACHE_NDX_CACHED]); 883 } 884 885 // Create depth image 886 { 887 m_depthImage = createImage2DAndBindMemory(m_context, 888 m_depthFormat, 889 m_renderSize.x(), 890 m_renderSize.y(), 891 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 892 VK_SAMPLE_COUNT_1_BIT, 893 &m_depthImageAlloc); 894 } 895 896 // Set up image layout transition barriers 897 { 898 VkImageMemoryBarrier colorImageBarrier = 899 { 900 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; 901 DE_NULL, // const void* pNext; 902 0u, // VkAccessFlags srcAccessMask; 903 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask; 904 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout; 905 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout; 906 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; 907 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; 908 *m_colorImage[PIPELINE_CACHE_NDX_NO_CACHE], // VkImage image; 909 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 910 }; 911 912 m_imageLayoutBarriers[0] = colorImageBarrier; 913 914 colorImageBarrier.image = *m_colorImage[PIPELINE_CACHE_NDX_CACHED]; 915 m_imageLayoutBarriers[1] = colorImageBarrier; 916 917 const VkImageMemoryBarrier depthImageBarrier = 918 { 919 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; 920 DE_NULL, // const void* pNext; 921 0u, // VkAccessFlags srcAccessMask; 922 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask; 923 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout; 924 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout; 925 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; 926 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; 927 *m_depthImage, // VkImage image; 928 { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 929 }; 930 931 m_imageLayoutBarriers[2] = depthImageBarrier; 932 } 933 // Create color attachment view 934 { 935 VkImageViewCreateInfo colorAttachmentViewParams = 936 { 937 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 938 DE_NULL, // const void* pNext; 939 0u, // VkImageViewCreateFlags flags; 940 *m_colorImage[PIPELINE_CACHE_NDX_NO_CACHE], // VkImage image; 941 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; 942 m_colorFormat, // VkFormat format; 943 ComponentMappingRGBA, // VkComponentMapping components; 944 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 945 }; 946 947 m_colorAttachmentView[PIPELINE_CACHE_NDX_NO_CACHE] = createImageView(vk, vkDevice, &colorAttachmentViewParams); 948 949 colorAttachmentViewParams.image = *m_colorImage[PIPELINE_CACHE_NDX_CACHED]; 950 m_colorAttachmentView[PIPELINE_CACHE_NDX_CACHED] = createImageView(vk, vkDevice, &colorAttachmentViewParams); 951 } 952 953 // Create depth attachment view 954 { 955 const VkImageViewCreateInfo depthAttachmentViewParams = 956 { 957 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 958 DE_NULL, // const void* pNext; 959 0u, // VkImageViewCreateFlags flags; 960 *m_depthImage, // VkImage image; 961 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; 962 m_depthFormat, // VkFormat format; 963 ComponentMappingRGBA, // VkComponentMapping components; 964 { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 965 }; 966 967 m_depthAttachmentView = createImageView(vk, vkDevice, &depthAttachmentViewParams); 968 } 969 970 // Create framebuffer 971 { 972 VkImageView attachmentBindInfos[2] = 973 { 974 *m_colorAttachmentView[PIPELINE_CACHE_NDX_NO_CACHE], 975 *m_depthAttachmentView, 976 }; 977 978 const VkFramebufferCreateInfo framebufferParams = 979 { 980 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 981 DE_NULL, // const void* pNext; 982 0u, // VkFramebufferCreateFlags flags; 983 *m_renderPass, // VkRenderPass renderPass; 984 2u, // deUint32 attachmentCount; 985 attachmentBindInfos, // const VkImageView* pAttachments; 986 (deUint32)m_renderSize.x(), // deUint32 width; 987 (deUint32)m_renderSize.y(), // deUint32 height; 988 1u, // deUint32 layers; 989 }; 990 991 m_framebuffer[PIPELINE_CACHE_NDX_NO_CACHE] = createFramebuffer(vk, vkDevice, &framebufferParams); 992 993 attachmentBindInfos[0] = *m_colorAttachmentView[PIPELINE_CACHE_NDX_CACHED]; 994 m_framebuffer[PIPELINE_CACHE_NDX_CACHED] = createFramebuffer(vk, vkDevice, &framebufferParams); 995 } 996 997 // Bind shader stages 998 VkPhysicalDeviceFeatures features = m_context.getDeviceFeatures(); 999 for (deUint32 shaderNdx = 0; shaderNdx < m_param->getShaderCount(); shaderNdx++) 1000 { 1001 switch(m_param->getShaderFlag(shaderNdx)) 1002 { 1003 case VK_SHADER_STAGE_VERTEX_BIT: 1004 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_VERTEX_BIT, "color_vert", "main"); 1005 break; 1006 case VK_SHADER_STAGE_FRAGMENT_BIT: 1007 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_FRAGMENT_BIT, "color_frag", "main"); 1008 break; 1009 case VK_SHADER_STAGE_GEOMETRY_BIT: 1010 if (features.geometryShader == VK_FALSE) 1011 { 1012 TCU_THROW(NotSupportedError, "Geometry Shader Not Supported"); 1013 } 1014 else 1015 { 1016 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_GEOMETRY_BIT, "dummy_geo", "main"); 1017 } 1018 break; 1019 case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: 1020 if (features.tessellationShader == VK_FALSE) 1021 { 1022 TCU_THROW(NotSupportedError, "Tessellation Not Supported"); 1023 } 1024 else 1025 { 1026 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "basic_tcs", "main"); 1027 m_pipelineBuilder.enableTessellationStage(3); 1028 } 1029 break; 1030 case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: 1031 if (features.tessellationShader == VK_FALSE) 1032 { 1033 TCU_THROW(NotSupportedError, "Tessellation Not Supported"); 1034 } 1035 else 1036 { 1037 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "basic_tes", "main"); 1038 m_pipelineBuilder.enableTessellationStage(3); 1039 } 1040 break; 1041 default: 1042 DE_FATAL("Unknown Shader Stage!"); 1043 break; 1044 }; 1045 } 1046 1047 // Create pipeline layout 1048 { 1049 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 1050 { 1051 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 1052 DE_NULL, // const void* pNext; 1053 0u, // VkPipelineLayoutCreateFlags flags; 1054 0u, // deUint32 setLayoutCount; 1055 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts; 1056 0u, // deUint32 pushConstantRangeCount; 1057 DE_NULL // const VkPushConstantRange* pPushConstantRanges; 1058 }; 1059 1060 m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); 1061 } 1062 1063 m_pipeline[PIPELINE_CACHE_NDX_NO_CACHE] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_cache, *m_pipelineLayout); 1064 m_pipeline[PIPELINE_CACHE_NDX_CACHED] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_cache, *m_pipelineLayout); 1065 } 1066 1067 GraphicsCacheTestInstance::~GraphicsCacheTestInstance (void) 1068 { 1069 } 1070 1071 void GraphicsCacheTestInstance::prepareRenderPass (VkFramebuffer framebuffer, VkPipeline pipeline) 1072 { 1073 const DeviceInterface& vk = m_context.getDeviceInterface(); 1074 1075 const VkClearValue attachmentClearValues[2] = 1076 { 1077 defaultClearValue(m_colorFormat), 1078 defaultClearValue(m_depthFormat), 1079 }; 1080 1081 const VkRenderPassBeginInfo renderPassBeginInfo = 1082 { 1083 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; 1084 DE_NULL, // const void* pNext; 1085 *m_renderPass, // VkRenderPass renderPass; 1086 framebuffer, // VkFramebuffer framebuffer; 1087 { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea; 1088 2u, // deUint32 clearValueCount; 1089 attachmentClearValues // const VkClearValue* pClearValues; 1090 }; 1091 1092 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); 1093 1094 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); 1095 VkDeviceSize offsets = 0u; 1096 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &offsets); 1097 vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1u, 0u, 0u); 1098 1099 vk.cmdEndRenderPass(*m_cmdBuffer); 1100 } 1101 1102 void GraphicsCacheTestInstance::prepareCommandBuffer (void) 1103 { 1104 const DeviceInterface& vk = m_context.getDeviceInterface(); 1105 1106 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1107 { 1108 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1109 DE_NULL, // const void* pNext; 1110 0u, // VkCommandBufferUsageFlags flags; 1111 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1112 }; 1113 1114 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo)); 1115 1116 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 1117 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(m_imageLayoutBarriers), m_imageLayoutBarriers); 1118 1119 prepareRenderPass(*m_framebuffer[PIPELINE_CACHE_NDX_NO_CACHE], *m_pipeline[PIPELINE_CACHE_NDX_NO_CACHE]); 1120 1121 // After the first render pass, the images are in correct layouts 1122 1123 prepareRenderPass(*m_framebuffer[PIPELINE_CACHE_NDX_CACHED], *m_pipeline[PIPELINE_CACHE_NDX_CACHED]); 1124 1125 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer)); 1126 } 1127 1128 tcu::TestStatus GraphicsCacheTestInstance::verifyTestResult (void) 1129 { 1130 const DeviceInterface& vk = m_context.getDeviceInterface(); 1131 const VkDevice vkDevice = m_context.getDevice(); 1132 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 1133 1134 const VkQueue queue = m_context.getUniversalQueue(); 1135 de::MovePtr<tcu::TextureLevel> resultNoCache = readColorAttachment(vk, 1136 vkDevice, 1137 queue, 1138 queueFamilyIndex, 1139 m_context.getDefaultAllocator(), 1140 *m_colorImage[PIPELINE_CACHE_NDX_NO_CACHE], 1141 m_colorFormat, 1142 m_renderSize); 1143 de::MovePtr<tcu::TextureLevel> resultCache = readColorAttachment(vk, 1144 vkDevice, 1145 queue, 1146 queueFamilyIndex, 1147 m_context.getDefaultAllocator(), 1148 *m_colorImage[PIPELINE_CACHE_NDX_CACHED], 1149 m_colorFormat, 1150 m_renderSize); 1151 1152 bool compareOk = tcu::intThresholdCompare(m_context.getTestContext().getLog(), 1153 "IntImageCompare", 1154 "Image comparison", 1155 resultNoCache->getAccess(), 1156 resultCache->getAccess(), 1157 tcu::UVec4(1, 1, 1, 1), 1158 tcu::COMPARE_LOG_RESULT); 1159 1160 if (compareOk) 1161 return tcu::TestStatus::pass("Render images w/o cached pipeline match."); 1162 else 1163 return tcu::TestStatus::fail("Render Images mismatch."); 1164 } 1165 1166 class ComputeCacheTest : public CacheTest 1167 { 1168 public: 1169 ComputeCacheTest (tcu::TestContext& testContext, 1170 const std::string& name, 1171 const std::string& description, 1172 const CacheTestParam* param) 1173 : CacheTest (testContext, name, description, param) 1174 { } 1175 virtual ~ComputeCacheTest (void) { } 1176 virtual void initPrograms (SourceCollections& programCollection) const; 1177 virtual TestInstance* createInstance (Context& context) const; 1178 }; 1179 1180 class ComputeCacheTestInstance : public CacheTestInstance 1181 { 1182 public: 1183 ComputeCacheTestInstance (Context& context, 1184 const CacheTestParam* param); 1185 virtual ~ComputeCacheTestInstance (void); 1186 virtual void prepareCommandBuffer (void); 1187 protected: 1188 virtual tcu::TestStatus verifyTestResult (void); 1189 void buildBuffers (void); 1190 void buildDescriptorSets (deUint32 ndx); 1191 void buildShader (void); 1192 void buildPipeline (deUint32 ndx); 1193 protected: 1194 Move<VkBuffer> m_inputBuf; 1195 de::MovePtr<Allocation> m_inputBufferAlloc; 1196 Move<VkShaderModule> m_computeShaderModule; 1197 1198 Move<VkBuffer> m_outputBuf[PIPELINE_CACHE_NDX_COUNT]; 1199 de::MovePtr<Allocation> m_outputBufferAlloc[PIPELINE_CACHE_NDX_COUNT]; 1200 1201 Move<VkDescriptorPool> m_descriptorPool[PIPELINE_CACHE_NDX_COUNT]; 1202 Move<VkDescriptorSetLayout> m_descriptorSetLayout[PIPELINE_CACHE_NDX_COUNT]; 1203 Move<VkDescriptorSet> m_descriptorSet[PIPELINE_CACHE_NDX_COUNT]; 1204 1205 Move<VkPipelineLayout> m_pipelineLayout[PIPELINE_CACHE_NDX_COUNT]; 1206 Move<VkPipeline> m_pipeline[PIPELINE_CACHE_NDX_COUNT]; 1207 }; 1208 1209 void ComputeCacheTest::initPrograms (SourceCollections& programCollection) const 1210 { 1211 programCollection.glslSources.add("basic_compute") << glu::ComputeSource( 1212 "#version 310 es\n" 1213 "layout(local_size_x = 1) in;\n" 1214 "layout(std430) buffer;\n" 1215 "layout(binding = 0) readonly buffer Input0\n" 1216 "{\n" 1217 " vec4 elements[];\n" 1218 "} input_data0;\n" 1219 "layout(binding = 1) writeonly buffer Output\n" 1220 "{\n" 1221 " vec4 elements[];\n" 1222 "} output_data;\n" 1223 "void main()\n" 1224 "{\n" 1225 " uint ident = gl_GlobalInvocationID.x;\n" 1226 " output_data.elements[ident] = input_data0.elements[ident] * input_data0.elements[ident];\n" 1227 "}"); 1228 } 1229 1230 TestInstance* ComputeCacheTest::createInstance (Context& context) const 1231 { 1232 return new ComputeCacheTestInstance(context, &m_param); 1233 } 1234 1235 void ComputeCacheTestInstance::buildBuffers (void) 1236 { 1237 const DeviceInterface& vk = m_context.getDeviceInterface(); 1238 const VkDevice vkDevice = m_context.getDevice(); 1239 1240 // Create buffer object, allocate storage, and generate input data 1241 const VkDeviceSize size = sizeof(tcu::Vec4) * 128u; 1242 m_inputBuf = createBufferAndBindMemory(m_context, size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_inputBufferAlloc); 1243 1244 // Initialize input buffer 1245 tcu::Vec4* pVec = reinterpret_cast<tcu::Vec4*>(m_inputBufferAlloc->getHostPtr()); 1246 for (deUint32 ndx = 0u; ndx < 128u; ndx++) 1247 { 1248 for (deUint32 component = 0u; component < 4u; component++) 1249 pVec[ndx][component]= (float)(ndx * (component + 1u)); 1250 } 1251 flushMappedMemoryRange(vk, vkDevice, m_inputBufferAlloc->getMemory(), m_inputBufferAlloc->getOffset(), size); 1252 1253 // Clear the output buffer 1254 for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++) 1255 { 1256 m_outputBuf[ndx] = createBufferAndBindMemory(m_context, size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_outputBufferAlloc[ndx]); 1257 1258 pVec = reinterpret_cast<tcu::Vec4*>(m_outputBufferAlloc[ndx]->getHostPtr()); 1259 memset(pVec, 0u, size); 1260 flushMappedMemoryRange(vk, vkDevice, m_outputBufferAlloc[ndx]->getMemory(), m_outputBufferAlloc[ndx]->getOffset(), size); 1261 } 1262 } 1263 1264 void ComputeCacheTestInstance::buildDescriptorSets (deUint32 ndx) 1265 { 1266 const DeviceInterface& vk = m_context.getDeviceInterface(); 1267 const VkDevice vkDevice = m_context.getDevice(); 1268 1269 // Create descriptor set layout 1270 DescriptorSetLayoutBuilder descLayoutBuilder; 1271 1272 for (deUint32 bindingNdx = 0u; bindingNdx < 2u; bindingNdx++) 1273 descLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT); 1274 1275 m_descriptorSetLayout[ndx] = descLayoutBuilder.build(vk, vkDevice); 1276 1277 std::vector<VkDescriptorBufferInfo> descriptorInfos; 1278 descriptorInfos.push_back(makeDescriptorBufferInfo(*m_inputBuf, 0u, sizeof(tcu::Vec4) * 128u)); 1279 descriptorInfos.push_back(makeDescriptorBufferInfo(*m_outputBuf[ndx], 0u, sizeof(tcu::Vec4) * 128u)); 1280 1281 // Create descriptor pool 1282 m_descriptorPool[ndx] = DescriptorPoolBuilder().addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2u).build(vk, 1283 vkDevice, 1284 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1285 1u); 1286 1287 // Create descriptor set 1288 const VkDescriptorSetAllocateInfo descriptorSetAllocInfo = 1289 { 1290 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; 1291 DE_NULL, // const void* pNext; 1292 *m_descriptorPool[ndx], // VkDescriptorPool descriptorPool; 1293 1u, // deUint32 setLayoutCount; 1294 &m_descriptorSetLayout[ndx].get(), // const VkDescriptorSetLayout* pSetLayouts; 1295 }; 1296 m_descriptorSet[ndx] = allocateDescriptorSet(vk, vkDevice, &descriptorSetAllocInfo); 1297 1298 DescriptorSetUpdateBuilder builder; 1299 for (deUint32 descriptorNdx = 0u; descriptorNdx < 2u; descriptorNdx++) 1300 { 1301 builder.writeSingle(*m_descriptorSet[ndx], 1302 DescriptorSetUpdateBuilder::Location::binding(descriptorNdx), 1303 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1304 &descriptorInfos[descriptorNdx]); 1305 } 1306 builder.update(vk, vkDevice); 1307 } 1308 1309 void ComputeCacheTestInstance::buildShader (void) 1310 { 1311 const DeviceInterface& vk = m_context.getDeviceInterface(); 1312 const VkDevice vkDevice = m_context.getDevice(); 1313 1314 // Create compute shader 1315 VkShaderModuleCreateInfo shaderModuleCreateInfo = 1316 { 1317 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType; 1318 DE_NULL, // const void* pNext; 1319 0u, // VkShaderModuleCreateFlags flags; 1320 m_context.getBinaryCollection().get("basic_compute").getSize(), // deUintptr codeSize; 1321 (deUint32*)m_context.getBinaryCollection().get("basic_compute").getBinary(), // const deUint32* pCode; 1322 }; 1323 m_computeShaderModule = createShaderModule(vk, vkDevice, &shaderModuleCreateInfo); 1324 } 1325 1326 void ComputeCacheTestInstance::buildPipeline (deUint32 ndx) 1327 { 1328 const DeviceInterface& vk = m_context.getDeviceInterface(); 1329 const VkDevice vkDevice = m_context.getDevice(); 1330 1331 // Create compute pipeline layout 1332 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = 1333 { 1334 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 1335 DE_NULL, // const void* pNext; 1336 0u, // VkPipelineLayoutCreateFlags flags; 1337 1u, // deUint32 setLayoutCount; 1338 &m_descriptorSetLayout[ndx].get(), // const VkDescriptorSetLayout* pSetLayouts; 1339 0u, // deUint32 pushConstantRangeCount; 1340 DE_NULL, // const VkPushConstantRange* pPushConstantRanges; 1341 }; 1342 1343 m_pipelineLayout[ndx] = createPipelineLayout(vk, vkDevice, &pipelineLayoutCreateInfo); 1344 1345 const VkPipelineShaderStageCreateInfo stageCreateInfo = 1346 { 1347 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 1348 DE_NULL, // const void* pNext; 1349 0u, // VkPipelineShaderStageCreateFlags flags; 1350 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage; 1351 *m_computeShaderModule, // VkShaderModule module; 1352 "main", // const char* pName; 1353 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; 1354 }; 1355 1356 const VkComputePipelineCreateInfo pipelineCreateInfo = 1357 { 1358 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType; 1359 DE_NULL, // const void* pNext; 1360 0u, // VkPipelineCreateFlags flags; 1361 stageCreateInfo, // VkPipelineShaderStageCreateInfo stage; 1362 *m_pipelineLayout[ndx], // VkPipelineLayout layout; 1363 (VkPipeline)0, // VkPipeline basePipelineHandle; 1364 0u, // deInt32 basePipelineIndex; 1365 }; 1366 1367 m_pipeline[ndx] = createComputePipeline(vk, vkDevice, *m_cache, &pipelineCreateInfo); 1368 } 1369 1370 ComputeCacheTestInstance::ComputeCacheTestInstance (Context& context, 1371 const CacheTestParam* param) 1372 : CacheTestInstance (context, param) 1373 { 1374 buildBuffers(); 1375 1376 buildDescriptorSets(PIPELINE_CACHE_NDX_NO_CACHE); 1377 1378 buildDescriptorSets(PIPELINE_CACHE_NDX_CACHED); 1379 1380 buildShader(); 1381 1382 buildPipeline(PIPELINE_CACHE_NDX_NO_CACHE); 1383 1384 buildPipeline(PIPELINE_CACHE_NDX_CACHED); 1385 } 1386 1387 ComputeCacheTestInstance::~ComputeCacheTestInstance (void) 1388 { 1389 } 1390 1391 void ComputeCacheTestInstance::prepareCommandBuffer (void) 1392 { 1393 const DeviceInterface& vk = m_context.getDeviceInterface(); 1394 1395 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1396 { 1397 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1398 DE_NULL, // const void* pNext; 1399 0u, // VkCommandBufferUsageFlags flags; 1400 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1401 }; 1402 1403 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo)); 1404 1405 for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++) 1406 { 1407 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipeline[ndx]); 1408 vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipelineLayout[ndx], 0u, 1u, &m_descriptorSet[ndx].get(), 0u, DE_NULL); 1409 vk.cmdDispatch(*m_cmdBuffer, 128u, 1u, 1u); 1410 } 1411 1412 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer)); 1413 } 1414 1415 tcu::TestStatus ComputeCacheTestInstance::verifyTestResult (void) 1416 { 1417 const DeviceInterface& vk = m_context.getDeviceInterface(); 1418 const VkDevice vkDevice = m_context.getDevice(); 1419 1420 // Read the content of output buffers 1421 invalidateMappedMemoryRange(vk, 1422 vkDevice, 1423 m_outputBufferAlloc[PIPELINE_CACHE_NDX_NO_CACHE]->getMemory(), 1424 m_outputBufferAlloc[PIPELINE_CACHE_NDX_NO_CACHE]->getOffset(), 1425 sizeof(tcu::Vec4) * 128u); 1426 1427 invalidateMappedMemoryRange(vk, 1428 vkDevice, 1429 m_outputBufferAlloc[PIPELINE_CACHE_NDX_CACHED]->getMemory(), 1430 m_outputBufferAlloc[PIPELINE_CACHE_NDX_CACHED]->getOffset(), 1431 sizeof(tcu::Vec4) * 128u); 1432 // Compare the content 1433 deUint8* bufNoCache = reinterpret_cast<deUint8*>(m_outputBufferAlloc[PIPELINE_CACHE_NDX_NO_CACHE]->getHostPtr()); 1434 deUint8* bufCached = reinterpret_cast<deUint8*>(m_outputBufferAlloc[PIPELINE_CACHE_NDX_CACHED]->getHostPtr()); 1435 for (deUint32 ndx = 0u; ndx < sizeof(tcu::Vec4) * 128u; ndx++) 1436 { 1437 if (bufNoCache[ndx] != bufCached[ndx]) 1438 { 1439 return tcu::TestStatus::fail("Output buffers w/o cached pipeline mismatch."); 1440 } 1441 } 1442 1443 return tcu::TestStatus::pass("Output buffers w/o cached pipeline match."); 1444 } 1445 1446 class PipelineFromCacheTest : public GraphicsCacheTest 1447 { 1448 public: 1449 PipelineFromCacheTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param); 1450 virtual ~PipelineFromCacheTest (void) { } 1451 virtual TestInstance* createInstance (Context& context) const; 1452 }; 1453 1454 PipelineFromCacheTest::PipelineFromCacheTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param) 1455 : GraphicsCacheTest(testContext, name, description, param) 1456 { 1457 } 1458 1459 class PipelineFromCacheTestInstance : public GraphicsCacheTestInstance 1460 { 1461 public: 1462 PipelineFromCacheTestInstance (Context& context, const CacheTestParam* param); 1463 virtual ~PipelineFromCacheTestInstance (void); 1464 protected: 1465 Move<VkPipelineCache> m_newCache; 1466 deUint8* m_data; 1467 }; 1468 1469 TestInstance* PipelineFromCacheTest::createInstance (Context& context) const 1470 { 1471 return new PipelineFromCacheTestInstance(context, &m_param); 1472 } 1473 1474 PipelineFromCacheTestInstance::PipelineFromCacheTestInstance (Context& context, const CacheTestParam* param) 1475 : GraphicsCacheTestInstance (context, param) 1476 , m_data (DE_NULL) 1477 { 1478 const DeviceInterface& vk = m_context.getDeviceInterface(); 1479 const VkDevice vkDevice = m_context.getDevice(); 1480 1481 // Create more pipeline caches 1482 { 1483 size_t dataSize = 0u; 1484 1485 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, DE_NULL)); 1486 1487 m_data = new deUint8[dataSize]; 1488 DE_ASSERT(m_data); 1489 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data)); 1490 1491 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo = 1492 { 1493 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 1494 DE_NULL, // const void* pNext; 1495 0u, // VkPipelineCacheCreateFlags flags; 1496 dataSize, // deUintptr initialDataSize; 1497 m_data, // const void* pInitialData; 1498 }; 1499 m_newCache = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 1500 } 1501 m_pipeline[PIPELINE_CACHE_NDX_CACHED] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_newCache, *m_pipelineLayout); 1502 } 1503 1504 PipelineFromCacheTestInstance::~PipelineFromCacheTestInstance (void) 1505 { 1506 delete[] m_data; 1507 } 1508 1509 class PipelineFromIncompleteCacheTest : public GraphicsCacheTest 1510 { 1511 public: 1512 PipelineFromIncompleteCacheTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param); 1513 virtual ~PipelineFromIncompleteCacheTest (void) {} 1514 virtual TestInstance* createInstance (Context& context) const; 1515 }; 1516 1517 PipelineFromIncompleteCacheTest::PipelineFromIncompleteCacheTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param) 1518 : GraphicsCacheTest(testContext, name, description, param) 1519 { 1520 } 1521 1522 class PipelineFromIncompleteCacheTestInstance : public GraphicsCacheTestInstance 1523 { 1524 public: 1525 PipelineFromIncompleteCacheTestInstance(Context& context, const CacheTestParam* param); 1526 virtual ~PipelineFromIncompleteCacheTestInstance(void); 1527 protected: 1528 protected: 1529 Move<VkPipelineCache> m_newCache; 1530 deUint8* m_data; 1531 }; 1532 1533 TestInstance* PipelineFromIncompleteCacheTest::createInstance (Context& context) const 1534 { 1535 return new PipelineFromIncompleteCacheTestInstance(context, &m_param); 1536 } 1537 1538 PipelineFromIncompleteCacheTestInstance::PipelineFromIncompleteCacheTestInstance (Context& context, const CacheTestParam* param) 1539 : GraphicsCacheTestInstance (context, param) 1540 , m_data (DE_NULL) 1541 { 1542 const DeviceInterface& vk = m_context.getDeviceInterface(); 1543 const VkDevice vkDevice = m_context.getDevice(); 1544 1545 // Create more pipeline caches 1546 { 1547 size_t dataSize = 0u; 1548 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, DE_NULL)); 1549 1550 if (dataSize == 0) 1551 TCU_THROW(NotSupportedError, "Empty pipeline cache - unable to test"); 1552 1553 dataSize--; 1554 1555 m_data = new deUint8[dataSize]; 1556 DE_ASSERT(m_data); 1557 if (vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data) != VK_INCOMPLETE) 1558 TCU_THROW(TestError, "GetPipelineCacheData should return VK_INCOMPLETE state!"); 1559 1560 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo = 1561 { 1562 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 1563 DE_NULL, // const void* pNext; 1564 0u, // VkPipelineCacheCreateFlags flags; 1565 dataSize, // deUintptr initialDataSize; 1566 m_data, // const void* pInitialData; 1567 }; 1568 m_newCache = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 1569 } 1570 m_pipeline[PIPELINE_CACHE_NDX_CACHED] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_newCache, *m_pipelineLayout); 1571 } 1572 1573 PipelineFromIncompleteCacheTestInstance::~PipelineFromIncompleteCacheTestInstance (void) 1574 { 1575 delete[] m_data; 1576 } 1577 1578 class MergeCacheTest : public GraphicsCacheTest 1579 { 1580 public: 1581 MergeCacheTest (tcu::TestContext& testContext, 1582 const std::string& name, 1583 const std::string& description, 1584 const CacheTestParam* param) 1585 : GraphicsCacheTest (testContext, name, description, param) 1586 { } 1587 virtual ~MergeCacheTest (void) { } 1588 virtual TestInstance* createInstance (Context& context) const; 1589 }; 1590 1591 class MergeCacheTestInstance : public GraphicsCacheTestInstance 1592 { 1593 public: 1594 MergeCacheTestInstance (Context& context, 1595 const CacheTestParam* param); 1596 virtual ~MergeCacheTestInstance (void); 1597 protected: 1598 Move<VkPipelineCache> m_cacheGetData; 1599 Move<VkPipelineCache> m_cacheEmpty; 1600 Move<VkPipelineCache> m_cacheMerged; 1601 deUint8* m_data; 1602 }; 1603 1604 TestInstance* MergeCacheTest::createInstance (Context& context) const 1605 { 1606 return new MergeCacheTestInstance(context, &m_param); 1607 } 1608 1609 MergeCacheTestInstance::MergeCacheTestInstance (Context& context, const CacheTestParam* param) 1610 : GraphicsCacheTestInstance (context, param) 1611 , m_data (DE_NULL) 1612 { 1613 const DeviceInterface& vk = m_context.getDeviceInterface(); 1614 const VkDevice vkDevice = m_context.getDevice(); 1615 1616 // Create more pipeline caches 1617 { 1618 // Create a empty cache as one of source cache 1619 VkPipelineCacheCreateInfo pipelineCacheCreateInfo = 1620 { 1621 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 1622 DE_NULL, // const void* pNext; 1623 0u, // VkPipelineCacheCreateFlags flags; 1624 0u, // deUintptr initialDataSize; 1625 DE_NULL, // const void* pInitialData; 1626 }; 1627 m_cacheEmpty = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 1628 1629 // Create a empty cache for merge destination cache 1630 m_cacheMerged = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 1631 1632 // Create a cache with init data from m_cache 1633 size_t dataSize = 0u; 1634 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, DE_NULL)); 1635 1636 m_data = new deUint8[dataSize]; 1637 DE_ASSERT(m_data); 1638 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data)); 1639 1640 pipelineCacheCreateInfo.initialDataSize = dataSize; 1641 pipelineCacheCreateInfo.pInitialData = m_data; 1642 m_cacheGetData = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo); 1643 } 1644 1645 // Merge the caches 1646 const VkPipelineCache sourceCaches[] = 1647 { 1648 *m_cacheEmpty, 1649 *m_cacheGetData, 1650 }; 1651 VK_CHECK(vk.mergePipelineCaches(vkDevice, *m_cacheMerged, 2u, sourceCaches)); 1652 1653 // Create pipeline from merged cache 1654 m_pipeline[PIPELINE_CACHE_NDX_CACHED] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_cacheMerged, *m_pipelineLayout); 1655 } 1656 1657 MergeCacheTestInstance::~MergeCacheTestInstance (void) 1658 { 1659 delete[] m_data; 1660 } 1661 1662 class CacheHeaderTest : public GraphicsCacheTest 1663 { 1664 public: 1665 CacheHeaderTest(tcu::TestContext& testContext, 1666 const std::string& name, 1667 const std::string& description, 1668 const CacheTestParam* param) 1669 : GraphicsCacheTest(testContext, name, description, param) 1670 { } 1671 virtual ~CacheHeaderTest(void) { } 1672 virtual TestInstance* createInstance(Context& context) const; 1673 }; 1674 1675 class CacheHeaderTestInstance : public GraphicsCacheTestInstance 1676 { 1677 public: 1678 CacheHeaderTestInstance (Context& context, const CacheTestParam* param); 1679 virtual ~CacheHeaderTestInstance (void); 1680 protected: 1681 deUint8* m_data; 1682 1683 struct CacheHeader 1684 { 1685 deUint32 HeaderLength; 1686 deUint32 HeaderVersion; 1687 deUint32 VendorID; 1688 deUint32 DeviceID; 1689 deUint8 PipelineCacheUUID[VK_UUID_SIZE]; 1690 } m_header; 1691 }; 1692 1693 TestInstance* CacheHeaderTest::createInstance (Context& context) const 1694 { 1695 return new CacheHeaderTestInstance(context, &m_param); 1696 } 1697 1698 CacheHeaderTestInstance::CacheHeaderTestInstance (Context& context, const CacheTestParam* param) 1699 : GraphicsCacheTestInstance (context, param) 1700 , m_data (DE_NULL) 1701 { 1702 const DeviceInterface& vk = m_context.getDeviceInterface(); 1703 const VkDevice vkDevice = m_context.getDevice(); 1704 1705 // Create more pipeline caches 1706 { 1707 // Create a cache with init data from m_cache 1708 size_t dataSize = 0u; 1709 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, DE_NULL)); 1710 1711 if (dataSize < sizeof(m_header)) 1712 TCU_THROW(TestError, "Pipeline cache size is smaller than header size"); 1713 1714 m_data = new deUint8[dataSize]; 1715 DE_ASSERT(m_data); 1716 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data)); 1717 1718 deMemcpy(&m_header, m_data, sizeof(m_header)); 1719 1720 if (m_header.HeaderLength - VK_UUID_SIZE != 16) 1721 TCU_THROW(TestError, "Invalid header size!"); 1722 1723 if (m_header.HeaderVersion != 1) 1724 TCU_THROW(TestError, "Invalid header version!"); 1725 1726 if (m_header.VendorID != m_context.getDeviceProperties().vendorID) 1727 TCU_THROW(TestError, "Invalid header vendor ID!"); 1728 1729 if (m_header.DeviceID != m_context.getDeviceProperties().deviceID) 1730 TCU_THROW(TestError, "Invalid header device ID!"); 1731 1732 if (deMemCmp(&m_header.PipelineCacheUUID, &m_context.getDeviceProperties().pipelineCacheUUID, VK_UUID_SIZE) != 0) 1733 TCU_THROW(TestError, "Invalid header pipeline cache UUID!"); 1734 } 1735 } 1736 1737 CacheHeaderTestInstance::~CacheHeaderTestInstance (void) 1738 { 1739 delete[] m_data; 1740 } 1741 1742 class InvalidSizeTest : public GraphicsCacheTest 1743 { 1744 public: 1745 InvalidSizeTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param); 1746 virtual ~InvalidSizeTest (void) {} 1747 virtual TestInstance* createInstance (Context& context) const; 1748 }; 1749 1750 InvalidSizeTest::InvalidSizeTest (tcu::TestContext& testContext, const std::string& name, const std::string& description, const CacheTestParam* param) 1751 : GraphicsCacheTest(testContext, name, description, param) 1752 { 1753 } 1754 1755 class InvalidSizeTestInstance : public GraphicsCacheTestInstance 1756 { 1757 public: 1758 InvalidSizeTestInstance (Context& context, const CacheTestParam* param); 1759 virtual ~InvalidSizeTestInstance (void); 1760 protected: 1761 deUint8* m_data; 1762 deUint8* m_zeroBlock; 1763 }; 1764 1765 TestInstance* InvalidSizeTest::createInstance (Context& context) const 1766 { 1767 return new InvalidSizeTestInstance(context, &m_param); 1768 } 1769 1770 InvalidSizeTestInstance::InvalidSizeTestInstance (Context& context, const CacheTestParam* param) 1771 : GraphicsCacheTestInstance (context, param) 1772 , m_data (DE_NULL) 1773 , m_zeroBlock (DE_NULL) 1774 { 1775 const DeviceInterface& vk = m_context.getDeviceInterface(); 1776 const VkDevice vkDevice = m_context.getDevice(); 1777 1778 // Create more pipeline caches 1779 try 1780 { 1781 // Create a cache with init data from m_cache 1782 size_t dataSize = 0u; 1783 size_t savedDataSize = 0u; 1784 VK_CHECK(vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, DE_NULL)); 1785 savedDataSize = dataSize; 1786 1787 // If the value of dataSize is less than the maximum size that can be retrieved by the pipeline cache, 1788 // at most pDataSize bytes will be written to pData, and vkGetPipelineCacheData will return VK_INCOMPLETE. 1789 dataSize--; 1790 1791 m_data = new deUint8[savedDataSize]; 1792 deMemset(m_data, 0, savedDataSize); 1793 DE_ASSERT(m_data); 1794 if (vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data) != VK_INCOMPLETE) 1795 TCU_THROW(TestError, "GetPipelineCacheData should return VK_INCOMPLETE state!"); 1796 1797 delete[] m_data; 1798 m_data = DE_NULL; 1799 1800 // If the value of dataSize is less than what is necessary to store the header, 1801 // nothing will be written to pData and zero will be written to dataSize. 1802 dataSize = 16 + VK_UUID_SIZE - 1; 1803 1804 m_data = new deUint8[savedDataSize]; 1805 deMemset(m_data, 0, savedDataSize); 1806 DE_ASSERT(m_data); 1807 if (vk.getPipelineCacheData(vkDevice, *m_cache, (deUintptr*)&dataSize, (void*)m_data) != VK_INCOMPLETE) 1808 TCU_THROW(TestError, "GetPipelineCacheData should return VK_INCOMPLETE state!"); 1809 1810 m_zeroBlock = new deUint8[savedDataSize]; 1811 deMemset(m_zeroBlock, 0, savedDataSize); 1812 if (deMemCmp(m_data, m_zeroBlock, savedDataSize) != 0 || dataSize != 0) 1813 TCU_THROW(TestError, "Data needs to be empty and data size should be 0 when invalid size is passed to GetPipelineCacheData!"); 1814 } 1815 catch (...) 1816 { 1817 delete[] m_data; 1818 delete[] m_zeroBlock; 1819 throw; 1820 } 1821 } 1822 1823 InvalidSizeTestInstance::~InvalidSizeTestInstance (void) 1824 { 1825 delete[] m_data; 1826 delete[] m_zeroBlock; 1827 } 1828 1829 } // anonymous 1830 1831 tcu::TestCaseGroup* createCacheTests (tcu::TestContext& testCtx) 1832 { 1833 1834 de::MovePtr<tcu::TestCaseGroup> cacheTests (new tcu::TestCaseGroup(testCtx, "cache", "pipeline cache tests")); 1835 1836 // Graphics Pipeline Tests 1837 { 1838 de::MovePtr<tcu::TestCaseGroup> graphicsTests (new tcu::TestCaseGroup(testCtx, "graphics_tests", "Test pipeline cache with graphics pipeline.")); 1839 1840 const VkShaderStageFlagBits testParamShaders0[] = 1841 { 1842 VK_SHADER_STAGE_VERTEX_BIT, 1843 VK_SHADER_STAGE_FRAGMENT_BIT, 1844 }; 1845 const VkShaderStageFlagBits testParamShaders1[] = 1846 { 1847 VK_SHADER_STAGE_VERTEX_BIT, 1848 VK_SHADER_STAGE_GEOMETRY_BIT, 1849 VK_SHADER_STAGE_FRAGMENT_BIT, 1850 }; 1851 const VkShaderStageFlagBits testParamShaders2[] = 1852 { 1853 VK_SHADER_STAGE_VERTEX_BIT, 1854 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 1855 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 1856 VK_SHADER_STAGE_FRAGMENT_BIT, 1857 }; 1858 const CacheTestParam testParams[] = 1859 { 1860 CacheTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0)), 1861 CacheTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1)), 1862 CacheTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2)), 1863 }; 1864 1865 for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++) 1866 graphicsTests->addChild(newTestCase<GraphicsCacheTest>(testCtx, &testParams[i])); 1867 1868 cacheTests->addChild(graphicsTests.release()); 1869 } 1870 1871 // Graphics Pipeline Tests 1872 { 1873 de::MovePtr<tcu::TestCaseGroup> graphicsTests(new tcu::TestCaseGroup(testCtx, "pipeline_from_get_data", "Test pipeline cache with graphics pipeline.")); 1874 1875 const VkShaderStageFlagBits testParamShaders0[] = 1876 { 1877 VK_SHADER_STAGE_VERTEX_BIT, 1878 VK_SHADER_STAGE_FRAGMENT_BIT, 1879 }; 1880 const VkShaderStageFlagBits testParamShaders1[] = 1881 { 1882 VK_SHADER_STAGE_VERTEX_BIT, 1883 VK_SHADER_STAGE_GEOMETRY_BIT, 1884 VK_SHADER_STAGE_FRAGMENT_BIT, 1885 }; 1886 const VkShaderStageFlagBits testParamShaders2[] = 1887 { 1888 VK_SHADER_STAGE_VERTEX_BIT, 1889 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 1890 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 1891 VK_SHADER_STAGE_FRAGMENT_BIT, 1892 }; 1893 const CacheTestParam testParams[] = 1894 { 1895 CacheTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0)), 1896 CacheTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1)), 1897 CacheTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2)), 1898 }; 1899 1900 for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++) 1901 graphicsTests->addChild(newTestCase<PipelineFromCacheTest>(testCtx, &testParams[i])); 1902 1903 cacheTests->addChild(graphicsTests.release()); 1904 } 1905 1906 // Graphics Pipeline Tests 1907 { 1908 de::MovePtr<tcu::TestCaseGroup> graphicsTests(new tcu::TestCaseGroup(testCtx, "pipeline_from_incomplete_get_data", "Test pipeline cache with graphics pipeline.")); 1909 1910 const VkShaderStageFlagBits testParamShaders0[] = 1911 { 1912 VK_SHADER_STAGE_VERTEX_BIT, 1913 VK_SHADER_STAGE_FRAGMENT_BIT, 1914 }; 1915 const VkShaderStageFlagBits testParamShaders1[] = 1916 { 1917 VK_SHADER_STAGE_VERTEX_BIT, 1918 VK_SHADER_STAGE_GEOMETRY_BIT, 1919 VK_SHADER_STAGE_FRAGMENT_BIT, 1920 }; 1921 const VkShaderStageFlagBits testParamShaders2[] = 1922 { 1923 VK_SHADER_STAGE_VERTEX_BIT, 1924 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 1925 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 1926 VK_SHADER_STAGE_FRAGMENT_BIT, 1927 }; 1928 const CacheTestParam testParams[] = 1929 { 1930 CacheTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0)), 1931 CacheTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1)), 1932 CacheTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2)), 1933 }; 1934 1935 for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++) 1936 graphicsTests->addChild(newTestCase<PipelineFromIncompleteCacheTest>(testCtx, &testParams[i])); 1937 1938 cacheTests->addChild(graphicsTests.release()); 1939 } 1940 1941 // Compute Pipeline Tests 1942 { 1943 de::MovePtr<tcu::TestCaseGroup> computeTests (new tcu::TestCaseGroup(testCtx, "compute_tests", "Test pipeline cache with compute pipeline.")); 1944 1945 const VkShaderStageFlagBits testParamShaders0[] = 1946 { 1947 VK_SHADER_STAGE_COMPUTE_BIT, 1948 }; 1949 const CacheTestParam testParams[] = 1950 { 1951 CacheTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0)), 1952 }; 1953 1954 for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++) 1955 computeTests->addChild(newTestCase<ComputeCacheTest>(testCtx, &testParams[i])); 1956 1957 cacheTests->addChild(computeTests.release()); 1958 } 1959 1960 // Misc Tests 1961 { 1962 de::MovePtr<tcu::TestCaseGroup> miscTests (new tcu::TestCaseGroup(testCtx, "misc_tests", "Misc tests that can not be categorized to other group.")); 1963 1964 const VkShaderStageFlagBits testParamShaders[] = 1965 { 1966 VK_SHADER_STAGE_VERTEX_BIT, 1967 VK_SHADER_STAGE_FRAGMENT_BIT, 1968 }; 1969 1970 const CacheTestParam testParam(testParamShaders, DE_LENGTH_OF_ARRAY(testParamShaders)); 1971 miscTests->addChild(new MergeCacheTest(testCtx, 1972 "merge_cache_test", 1973 "Merge the caches test.", 1974 &testParam)); 1975 1976 miscTests->addChild(new CacheHeaderTest(testCtx, 1977 "cache_header_test", 1978 "Cache header test.", 1979 &testParam)); 1980 1981 miscTests->addChild(new InvalidSizeTest(testCtx, 1982 "invalid_size_test", 1983 "Invalid size test.", 1984 &testParam)); 1985 1986 cacheTests->addChild(miscTests.release()); 1987 } 1988 1989 return cacheTests.release(); 1990 } 1991 1992 } // pipeline 1993 1994 } // vkt 1995
