Lines Matching defs:const
67 static const deUint32 RENDER_SIZE_WIDTH = 16u;
68 static const deUint32 RENDER_SIZE_HEIGHT = 16u;
69 static const VkColorComponentFlags COLOR_COMPONENTS_NO_RED = VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
70 static const VkGraphicsPipelineLibraryFlagBitsEXT GRAPHICS_PIPELINE_LIBRARY_FLAGS[] =
77 static const VkGraphicsPipelineLibraryFlagsEXT ALL_GRAPHICS_PIPELINE_LIBRARY_FLAGS = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT)
111 inline UVec4 ivec2uvec (const IVec4& ivec)
122 inline std::string getTestName (const PipelineTreeConfiguration& pipelineTreeConfiguration)
127 for (const auto& node: pipelineTreeConfiguration)
164 static const VkGraphicsPipelineLibraryFlagsEXT subsetRequiresRenderPass = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT)
173 inline VkGraphicsPipelineLibraryCreateInfoEXT makeGraphicsPipelineLibraryCreateInfo (const VkGraphicsPipelineLibraryFlagsEXT flags)
175 const VkGraphicsPipelineLibraryCreateInfoEXT graphicsPipelineLibraryCreateInfo =
185 inline VkPipelineLibraryCreateInfoKHR makePipelineLibraryCreateInfo (const std::vector<VkPipeline>& pipelineLibraries)
187 const deUint32 libraryCount = static_cast<deUint32>(pipelineLibraries.size());
188 const VkPipeline* libraries = de::dataOrNull(pipelineLibraries);
189 const VkPipelineLibraryCreateInfoKHR pipelineLibraryCreateInfo =
192 DE_NULL, // const void* pNext;
194 libraries, // const VkPipeline* pLibraries;
200 inline std::string getGraphicsPipelineLibraryFlagsString (const VkGraphicsPipelineLibraryFlagsEXT flags)
215 VkImageCreateInfo makeColorImageCreateInfo (const VkFormat format, const deUint32 width, const deUint32 height)
217 const VkImageUsageFlags usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
218 const VkImageCreateInfo imageInfo =
221 DE_NULL, // const void* pNext;
233 DE_NULL, // const deUint32* pQueueFamilyIndices;
242 const VkComponentMapping components =
249 const VkImageSubresourceRange subresourceRange =
257 const VkImageViewCreateInfo result =
260 DE_NULL, // const void* pNext;
272 VkImageCreateInfo makeDepthImageCreateInfo (const VkFormat format, const deUint32 width, const deUint32 height)
274 const VkImageUsageFlags usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
275 const VkImageCreateInfo imageInfo =
278 DE_NULL, // const void* pNext;
290 DE_NULL, // const deUint32* pQueueFamilyIndices;
297 const VkFramebufferCreateInfo makeFramebufferCreateInfo (const VkRenderPass renderPass,
298 const deUint32 attachmentCount,
299 const VkImageView* attachments,
300 const deUint32 width,
301 const deUint32 height)
303 const VkFramebufferCreateInfo result =
306 DE_NULL, // const void* pNext;
310 attachments, // const VkImageView* pAttachments;
319 const VkPipelineMultisampleStateCreateInfo makePipelineMultisampleStateCreateInfo (void)
321 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo =
324 DE_NULL, // const void* pNext;
329 DE_NULL, // const VkSampleMask* pSampleMask;
385 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo
388 DE_NULL, // const void* pNext;
391 &graphicsPipelineCreateInfo.m_vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
393 &graphicsPipelineCreateInfo.m_vertexInputAttributeDescription, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
395 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo
398 DE_NULL, // const void* pNext;
412 const VkSpecializationInfo* specializationInfo = DE_NULL)
414 const ProgramBinary& shaderBinary = context.getBinaryCollection().get("vert");
422 DE_NULL, // const void* pNext;
425 (deUint32*)shaderBinary.getBinary(), // const deUint32* pCode;
430 const DeviceInterface& vk = context.getDeviceInterface();
431 const VkDevice device = context.getDevice();
436 const void* pNext = delayedShaderCreate
439 const VkShaderModule shaderModule = delayedShaderCreate
442 const VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfo =
445 pNext, // const void* pNext;
449 "main", // const char* pName;
450 specializationInfo // const VkSpecializationInfo* pSpecializationInfo;
456 const VkViewport viewport = makeViewport(RENDER_SIZE_WIDTH, RENDER_SIZE_HEIGHT);
457 const VkRect2D scissor = makeRect2D(3 * RENDER_SIZE_WIDTH / 4, RENDER_SIZE_HEIGHT);
458 const VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo =
461 DE_NULL, // const void* pNext;
464 &viewport, // const VkViewport* pViewports;
466 &scissor // const VkRect2D* pScissors;
468 const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo =
471 DE_NULL, // const void* pNext;
496 const VkSpecializationInfo* specializationInfo = DE_NULL)
498 const ProgramBinary& shaderBinary = context.getBinaryCollection().get("frag");
506 DE_NULL, // const void* pNext;
509 (deUint32*)shaderBinary.getBinary(), // const deUint32* pCode;
514 const DeviceInterface& vk = context.getDeviceInterface();
515 const VkDevice device = context.getDevice();
520 const void* pNext = delayedShaderCreate
523 const VkShaderModule shaderModule = delayedShaderCreate
526 const VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfo =
529 pNext, // const void* pNext;
533 "main", // const char* pName;
534 specializationInfo // const VkSpecializationInfo* pSpecializationInfo;
541 const VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo =
544 DE_NULL, // const void* pNext;
581 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo = makePipelineMultisampleStateCreateInfo();
594 const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState =
605 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo =
608 DE_NULL, // const void* pNext;
613 &pipelineColorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
621 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo = makePipelineMultisampleStateCreateInfo();
650 const TestParams& data);
659 Move<VkDescriptorSetLayout> createDescriptorSetLayout (const VkBuffer vertShaderBuffer,
660 const VkBuffer fragShaderBuffer);
661 Move<VkDescriptorSet> createDescriptorSet (const VkDescriptorPool pool,
662 const VkDescriptorSetLayout layout,
663 const VkBuffer vertShaderBuffer,
664 const VkBuffer fragShaderBuffer);
665 bool verifyColorImage (const tcu::ConstPixelBufferAccess& pba);
666 bool verifyDepthImage (const tcu::ConstPixelBufferAccess& pba);
668 const bool optimize,
669 const bool delayedShaderCreate);
677 PipelineLibraryTestInstance::PipelineLibraryTestInstance (Context& context, const TestParams& data)
709 const DeviceInterface& vk = m_context.getDeviceInterface();
710 const VkDevice device = m_context.getDevice();
712 const size_t bufferDataSize = de::dataSize(m_vertexData);
713 const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(bufferDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
724 const DeviceInterface& vk = m_context.getDeviceInterface();
725 const VkDevice device = m_context.getDevice();
727 const size_t bufferDataSize = de::dataSize(m_zCoordData);
728 const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(bufferDataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
739 const DeviceInterface& vk = m_context.getDeviceInterface();
740 const VkDevice device = m_context.getDevice();
742 const size_t bufferDataSize = de::dataSize(m_paletteData);
743 const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(bufferDataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
754 const DeviceInterface& vk = m_context.getDeviceInterface();
755 const VkDevice device = m_context.getDevice();
762 Move<VkDescriptorSetLayout> PipelineLibraryTestInstance::createDescriptorSetLayout (const VkBuffer vertShaderBuffer,
763 const VkBuffer fragShaderBuffer)
765 const DeviceInterface& vk = m_context.getDeviceInterface();
766 const VkDevice device = m_context.getDevice();
778 Move<VkDescriptorSet> PipelineLibraryTestInstance::createDescriptorSet (const VkDescriptorPool pool,
779 const VkDescriptorSetLayout layout,
780 const VkBuffer vertShaderBuffer,
781 const VkBuffer fragShaderBuffer)
783 const DeviceInterface& vk = m_context.getDeviceInterface();
784 const VkDevice device = m_context.getDevice();
785 const VkDescriptorSetAllocateInfo allocInfo =
788 DE_NULL, // const void* pNext;
791 &layout // const VkDescriptorSetLayout* pSetLayouts;
798 const VkDeviceSize vertShaderBufferSize = de::dataSize(m_zCoordData);
799 const VkDescriptorBufferInfo vertShaderBufferInfo = makeDescriptorBufferInfo(vertShaderBuffer, 0u, vertShaderBufferSize);
806 const VkDeviceSize fragShaderBufferSize = de::dataSize(m_paletteData);
807 const VkDescriptorBufferInfo fragShaderBufferInfo = makeDescriptorBufferInfo(fragShaderBuffer, 0u, fragShaderBufferSize);
817 VkFormat getSupportedDepthFormat(const InstanceInterface &vk, const VkPhysicalDevice physicalDevice)
821 const VkFormat DepthFormats[] =
829 for (const auto format: DepthFormats)
841 const bool optimize,
842 const bool delayedShaderCreate)
844 const DeviceInterface& vk = m_context.getDeviceInterface();
845 const VkDevice device = m_context.getDevice();
846 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
849 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
850 const VkFormat depthFormat = getSupportedDepthFormat(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
851 const VkGraphicsPipelineLibraryFlagsEXT vertPipelineFlags = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT);
852 const VkGraphicsPipelineLibraryFlagsEXT fragPipelineFlags = static_cast<VkGraphicsPipelineLibraryFlagsEXT>(VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT);
853 const VkGraphicsPipelineLibraryFlagsEXT samePipelineFlags = vertPipelineFlags | fragPipelineFlags;
854 const deInt32 nodeNdxLast = static_cast<deInt32>(runtimePipelineTreeConfiguration.size()) - 1;
855 const Move<VkRenderPass> renderPass = makeRenderPass(vk, device, colorFormat, depthFormat);
856 const de::MovePtr<BufferWithMemory> zCoordBuffer = makeZCoordBuffer();
857 const de::MovePtr<BufferWithMemory> paletteBuffer = makePaletteBuffer();
858 const Move<VkDescriptorPool> descriptorPool = createDescriptorPool();
860 const Move<VkDescriptorSetLayout> descriptorSetLayoutVert = createDescriptorSetLayout(**zCoordBuffer, DE_NULL);
861 const Move<VkDescriptorSetLayout> descriptorSetLayoutFrag = createDescriptorSetLayout(DE_NULL, **paletteBuffer);
862 const Move<VkDescriptorSetLayout> descriptorSetLayoutBoth = createDescriptorSetLayout(**zCoordBuffer, **paletteBuffer);
863 const Move<VkDescriptorSet> descriptorSetVert = createDescriptorSet(*descriptorPool, *descriptorSetLayoutVert, **zCoordBuffer, DE_NULL);
864 const Move<VkDescriptorSet> descriptorSetFrag = createDescriptorSet(*descriptorPool, *descriptorSetLayoutFrag, DE_NULL , **paletteBuffer);
876 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
877 const Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
878 const Move<VkPipelineLayout> pipelineLayoutSame = makePipelineLayout(vk, device, 2, vecLayoutBoth, pipelineLayoutCreateFlag);
887 const bool buildLibrary = (nodeNdx != 0);
888 const VkPipelineCreateFlags pipelineCreateFlags = calcPipelineCreateFlags(optimize, buildLibrary);
889 const VkGraphicsPipelineLibraryFlagsEXT subtreeGraphicsPipelineLibraryFlags = node.subtreeGraphicsPipelineLibraryFlags | node.graphicsPipelineLibraryFlags;
890 const bool samePipelineLayout = samePipelineFlags == (samePipelineFlags & subtreeGraphicsPipelineLibraryFlags);
891 const bool vertPipelineLayout = vertPipelineFlags == (vertPipelineFlags & subtreeGraphicsPipelineLibraryFlags);
892 const bool fragPipelineLayout = fragPipelineFlags == (fragPipelineFlags & subtreeGraphicsPipelineLibraryFlags);
907 const VkPipelineLayout pipelineLayout = samePipelineLayout ? *pipelineLayoutSame
911 const VkRenderPass renderPassHandle = getRenderPass(node.graphicsPipelineLibraryFlags, *renderPass);
916 for (const auto subsetFlag: GRAPHICS_PIPELINE_LIBRARY_FLAGS)
942 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo = makePipelineMultisampleStateCreateInfo();
985 const tcu::UVec2 renderSize = { RENDER_SIZE_WIDTH, RENDER_SIZE_HEIGHT };
986 const VkRect2D renderArea = makeRect2D(renderSize.x(), renderSize.y());
987 const de::MovePtr<BufferWithMemory> vertexBuffer = makeVertexBuffer();
988 const deUint32 vertexCount = static_cast<deUint32>(m_vertexData.size());
989 const VkDeviceSize vertexBufferOffset = 0;
990 const Vec4 colorClearColor (0.0f, 0.0f, 0.0f, 1.0f);
991 const VkImageCreateInfo colorImageCreateInfo = makeColorImageCreateInfo(colorFormat, renderSize.x(), renderSize.y());
992 const ImageWithMemory colorImage (vk, device, allocator, colorImageCreateInfo, MemoryRequirement::Any);
993 const VkImageViewCreateInfo colorImageViewCreateInfo = makeImageViewCreateInfo(*colorImage, colorFormat, static_cast<VkImageAspectFlags>(VK_IMAGE_ASPECT_COLOR_BIT));
994 const Move<VkImageView> colorImageView = createImageView(vk, device, &colorImageViewCreateInfo);
995 const VkImageCreateInfo depthImageCreateInfo = makeDepthImageCreateInfo(depthFormat, renderSize.x(), renderSize.y());
996 const ImageWithMemory depthImage (vk, device, allocator, depthImageCreateInfo, MemoryRequirement::Any);
997 const VkImageViewCreateInfo depthImageViewCreateInfo = makeImageViewCreateInfo(*depthImage, depthFormat, static_cast<VkImageAspectFlags>(VK_IMAGE_ASPECT_DEPTH_BIT));
998 const Move<VkImageView> depthImageView = createImageView(vk, device, &depthImageViewCreateInfo);
999 const float depthClearDepth = 1.0f;
1000 const deUint32 depthClearStencil = 0u;
1001 const VkDeviceSize colorBufferDataSize = static_cast<VkDeviceSize>(renderSize.x() * renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat)));
1002 const VkBufferCreateInfo colorBufferCreateInfo = makeBufferCreateInfo(colorBufferDataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1003 const BufferWithMemory colorBuffer (vk, device, allocator, colorBufferCreateInfo, MemoryRequirement::HostVisible);
1004 const VkDeviceSize depthBufferDataSize = static_cast<VkDeviceSize>(renderSize.x() * renderSize.y() * tcu::getPixelSize(mapVkFormat(depthFormat)));
1005 const VkBufferCreateInfo depthBufferCreateInfo = makeBufferCreateInfo(depthBufferDataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1006 const BufferWithMemory depthBuffer (vk, device, allocator, depthBufferCreateInfo, MemoryRequirement::HostVisible);
1007 const VkImageView attachments[] = { *colorImageView, *depthImageView };
1008 const VkFramebufferCreateInfo framebufferCreateInfo = makeFramebufferCreateInfo(*renderPass, DE_LENGTH_OF_ARRAY(attachments), attachments, renderSize.x(), renderSize.y());
1009 const Move<VkFramebuffer> framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
1022 const tcu::IVec2 size = { (deInt32)renderSize.x(), (deInt32)renderSize.y() };
1032 const tcu::ConstPixelBufferAccess colorPixelAccess(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1, colorBuffer.getAllocation().getHostPtr());
1033 const tcu::ConstPixelBufferAccess depthPixelAccess(mapVkFormat(depthFormat), renderSize.x(), renderSize.y(), 1, depthBuffer.getAllocation().getHostPtr());
1053 bool PipelineLibraryTestInstance::verifyColorImage (const ConstPixelBufferAccess& pba)
1058 const int horzEdge = 3 * reference.getWidth() / 4;
1059 const int vertEdge = reference.getHeight() / 2;
1060 const UVec4 green = ivec2uvec(RGBA::green().toIVec());
1061 const UVec4 blue = ivec2uvec(RGBA::blue().toIVec());
1062 const UVec4 black = ivec2uvec(RGBA::black().toIVec());
1083 bool PipelineLibraryTestInstance::verifyDepthImage (const ConstPixelBufferAccess& pba)
1086 const VkFormat compareFormat = VK_FORMAT_R8_UNORM;
1091 const int horzEdge = 3 * reference.getWidth() / 4;
1092 const int diagonalEdge = (reference.getWidth() + reference.getHeight()) / 2 - 1;
1093 const UVec4 red100 = ivec2uvec(RGBA::red().toIVec());
1094 const UVec4 red025 = UVec4(red100[0] / 4, red100[1] / 4, red100[2] / 4, red100[3]);
1095 const UVec4 red075 = UVec4(3 * red100[0] / 4, 3 * red100[1] / 4, 3 * red100[2] / 4, red100[3]);
1100 const UVec4 pix(static_cast<deUint32>(static_cast<float>(red100[0]) * pba.getPixDepth(x, y)), 0, 0, 0);
1133 const auto graphicsPipelineLibraryFlagsBegin = graphicsPipelineLibraryFlags;
1134 const auto graphicsPipelineLibraryFlagsEnd = graphicsPipelineLibraryFlags + DE_LENGTH_OF_ARRAY(graphicsPipelineLibraryFlags);
1147 const deUint32 shaderCount = m_data.pipelineTreeConfiguration[nodeNdx].shaderCount;
1180 const RuntimePipelineTreeNode& node = runtimePipelineTreeConfiguration[nodeNdx];
1210 PipelineLibraryTestCase (tcu::TestContext& context, const char* name, const TestParams data);
1213 virtual void checkSupport (Context& context) const;
1214 virtual void initPrograms (SourceCollections& programCollection) const;
1215 virtual TestInstance* createInstance (Context& context) const;
1220 PipelineLibraryTestCase::PipelineLibraryTestCase (tcu::TestContext& context, const char* name, const TestParams data)
1230 void PipelineLibraryTestCase::checkSupport (Context& context) const
1244 const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& graphicsPipelineLibraryFeaturesEXT = context.getGraphicsPipelineLibraryFeaturesEXT();
1251 void PipelineLibraryTestCase::initPrograms (SourceCollections& programCollection) const
1268 " const float z = gl_VertexIndex < 3 ? z_coord.x : z_coord.y;\n"
1285 " const int middle = " + de::toString(RENDER_SIZE_HEIGHT / 2) + ";\n"
1292 TestInstance* PipelineLibraryTestCase::createInstance (Context& context) const
1323 const MiscTestParams& params);
1336 const tcu::IVec2 point;
1337 const tcu::IVec4 color;
1339 tcu::TestStatus verifyResult (const std::vector<VerificationData>& verificationData,
1340 const tcu::ConstPixelBufferAccess& colorPixelAccess) const;
1344 const VkFormat m_colorFormat;
1345 const Vec4 m_colorClearColor;
1346 const VkRect2D m_renderArea;
1358 PipelineLibraryMiscTestInstance::PipelineLibraryMiscTestInstance(Context& context, const MiscTestParams& params)
1369 const DeviceInterface& vk = m_context.getDeviceInterface();
1370 const VkDevice device = m_context.getDevice();
1374 const VkImageCreateInfo colorImageCreateInfo = makeColorImageCreateInfo(m_colorFormat, m_renderArea.extent.width, m_renderArea.extent.height);
1376 const VkImageViewCreateInfo colorImageViewCreateInfo = makeImageViewCreateInfo(**m_colorImage, m_colorFormat, static_cast<VkImageAspectFlags>(VK_IMAGE_ASPECT_COLOR_BIT));
1377 const Move<VkImageView> colorImageView = createImageView(vk, device, &colorImageViewCreateInfo);
1381 const VkFramebufferCreateInfo framebufferCreateInfo = makeFramebufferCreateInfo(*m_renderPass, 1u, &*colorImageView, m_renderArea.extent.width, m_renderArea.extent.height);
1385 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1407 const DeviceInterface& vk = m_context.getDeviceInterface();
1408 const VkDevice device = m_context.getDevice();
1411 const VkDeviceSize colorBufferDataSize = static_cast<VkDeviceSize>(m_renderArea.extent.width * m_renderArea.extent.height * tcu::getPixelSize(mapVkFormat(m_colorFormat)));
1412 const VkBufferCreateInfo colorBufferCreateInfo = makeBufferCreateInfo(colorBufferDataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1413 const BufferWithMemory colorBuffer (vk, device, allocator, colorBufferCreateInfo, MemoryRequirement::HostVisible);
1416 const VkBufferCreateInfo uniformBufferCreateInfo = makeBufferCreateInfo(uniformBufferDataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
1420 const tcu::Vec4 uniformBuffData[]
1433 const deUint32 maxBitsCount = 8 * sizeof(m_testParams.layoutsBits);
1512 const VkDescriptorBufferInfo vertShaderBufferInfo = makeDescriptorBufferInfo(**uniformBuffer[0], 0u, uniformBufferDataSize);
1525 const VkDescriptorBufferInfo fragShaderBufferInfo = makeDescriptorBufferInfo(**uniformBuffer[1], 0u, uniformBufferDataSize);
1539 const deUint32 commonPipelinePartFlags = deUint32(VK_PIPELINE_CREATE_LIBRARY_BIT_KHR);
1578 const VkImageMemoryBarrier initialImageBarrier = makeImageMemoryBarrier(
1611 const tcu::IVec2 size { (deInt32)m_renderArea.extent.width, (deInt32)m_renderArea.extent.height };
1618 const tcu::ConstPixelBufferAccess colorPixelAccess(mapVkFormat(m_colorFormat), m_renderArea.extent.width, m_renderArea.extent.height, 1, colorBuffer.getAllocation().getHostPtr());
1623 const std::vector<VerificationData> verificationData
1638 const DeviceInterface& vk = m_context.getDeviceInterface();
1639 const VkDevice device = m_context.getDevice();
1642 const VkDeviceSize colorBufferDataSize = static_cast<VkDeviceSize>(m_renderArea.extent.width * m_renderArea.extent.height * tcu::getPixelSize(mapVkFormat(m_colorFormat)));
1643 const VkBufferCreateInfo colorBufferCreateInfo = makeBufferCreateInfo(colorBufferDataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1644 const BufferWithMemory colorBuffer(vk, device, allocator, colorBufferCreateInfo, MemoryRequirement::HostVisible);
1646 const tcu::Vec4 uniformBuffData { 0.0f, 0.20f, 0.6f, 0.75f };
1648 const VkBufferCreateInfo uniformBufferCreateInfo = makeBufferCreateInfo(uniformBufferDataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
1670 const VkDescriptorBufferInfo shaderBufferInfo = makeDescriptorBufferInfo(**uniformBuffer, 0u, uniformBufferDataSize);
1696 const VkImageMemoryBarrier initialImageBarrier = makeImageMemoryBarrier(
1707 const VkBufferMemoryBarrier initialBufferBarrier = makeBufferMemoryBarrier(
1724 const tcu::IVec2 size{ (deInt32)m_renderArea.extent.width, (deInt32)m_renderArea.extent.height };
1731 const tcu::ConstPixelBufferAccess colorPixelAccess(mapVkFormat(m_colorFormat), m_renderArea.extent.width, m_renderArea.extent.height, 1, colorBuffer.getAllocation().getHostPtr());
1743 const std::vector<VerificationData> verificationData
1755 const DeviceInterface& vk = m_context.getDeviceInterface();
1756 const VkDevice device = m_context.getDevice();
1759 const VkDeviceSize colorBufferDataSize = static_cast<VkDeviceSize>(m_renderArea.extent.width * m_renderArea.extent.height * tcu::getPixelSize(mapVkFormat(m_colorFormat)));
1760 const VkBufferCreateInfo colorBufferCreateInfo = makeBufferCreateInfo(colorBufferDataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1761 const BufferWithMemory colorBuffer (vk, device, allocator, colorBufferCreateInfo, MemoryRequirement::HostVisible);
1764 const VkBufferCreateInfo uniformBufferCreateInfo = makeBufferCreateInfo(uniformBufferDataSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
1769 const tcu::Vec4 uniformBuffData[3]
1834 const VkDescriptorBufferInfo shaderBufferAInfo = makeDescriptorBufferInfo(**uniformBuffer[0], 0u, uniformBufferDataSize);
1835 const VkDescriptorBufferInfo shaderBufferBInfo = makeDescriptorBufferInfo(**uniformBuffer[1], 0u, uniformBufferDataSize);
1836 const VkDescriptorBufferInfo shaderBufferCInfo = makeDescriptorBufferInfo(**uniformBuffer[2], 0u, uniformBufferDataSize);
1891 const VkImageMemoryBarrier initialImageBarrier = makeImageMemoryBarrier(
1921 const tcu::IVec2 size{ (deInt32)m_renderArea.extent.width, (deInt32)m_renderArea.extent.height };
1928 const tcu::ConstPixelBufferAccess colorPixelAccess(mapVkFormat(m_colorFormat), m_renderArea.extent.width, m_renderArea.extent.height, 1, colorBuffer.getAllocation().getHostPtr());
1933 const std::vector<VerificationData> verificationData
1944 const deUint32 uniqueLibrariesCount = 2u;
1945 const deUint32 pipelinesCount = 4u * uniqueLibrariesCount;
1947 const DeviceInterface& vk = m_context.getDeviceInterface();
1948 const VkDevice device = m_context.getDevice();
1968 const uint32_t vertexRandSpecConsts[] = { rnd.getUint32() * 2, rnd.getUint32() * 2 };
1969 const uint32_t fragmentRandSpecConsts[] = { rnd.getUint32() * 2, rnd.getUint32() * 2 };
1971 const VkSpecializationMapEntry entry =
1978 const VkSpecializationInfo vertexSpecializationInfos[] =
1982 &entry, // const VkSpecializationMapEntry* pMapEntries;
1984 &vertexRandSpecConsts[0] // const void* pData;
1988 &entry, // const VkSpecializationMapEntry* pMapEntries;
1990 &vertexRandSpecConsts[1] // const void* pData;
1994 const VkSpecializationInfo fragmentSpecializationInfos[] =
1998 &entry, // const VkSpecializationMapEntry* pMapEntries;
2000 &fragmentRandSpecConsts[0] // const void* pData;
2004 &entry, // const VkSpecializationMapEntry* pMapEntries;
2006 &fragmentRandSpecConsts[1] // const void* pData;
2048 const auto& vertexInputData = pipelinePartData[ vertexInputIndex];
2049 const auto& preRasterizationData = pipelinePartData[ uniqueLibrariesCount + preRasterizationIndex];
2050 const auto& fragmentStateData = pipelinePartData[2 * uniqueLibrariesCount + fragmentStateIndex];
2051 const auto& fragmentOutputData = pipelinePartData[3 * uniqueLibrariesCount + fragmentOutputIndex];
2070 const auto linkingTime = std::chrono::high_resolution_clock::now() - timeStart;
2071 const auto creationTime = preRasterizationData.creationDuration + fragmentStateData.creationDuration;
2089 tcu::TestStatus PipelineLibraryMiscTestInstance::verifyResult(const std::vector<VerificationData>& verificationData, const tcu::ConstPixelBufferAccess& colorPixelAccess) const
2091 const deInt32 epsilon = 1;
2092 for (const auto& v : verificationData)
2094 const IVec4 pixel = colorPixelAccess.getPixelInt(v.point.x(), v.point.y());
2095 const IVec4 diff = pixel - v.color;
2100 const Vec4 pixelBias(0.0f);
2101 const Vec4 pixelScale(1.0f);
2138 void addModule (const std::string& moduleName, VkShaderStageFlagBits stage);
2139 void recordShaderToHostBarrier (VkPipelineStageFlagBits pipelineStage) const;
2145 const DeviceInterface& m_vkd;
2146 const VkDevice m_device;
2148 const uint32_t m_queueIndex;
2149 const VkQueue m_queue;
2167 const auto descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
2168 const auto poolFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
2182 const auto outputBufferSize = static_cast<VkDeviceSize>(de::dataSize(m_outVector));
2183 const auto outputBufferCreateInfo = makeBufferCreateInfo(outputBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
2187 const auto outputBufferDescInfo = makeDescriptorBufferInfo(m_outputBuffer->get(), 0ull, outputBufferSize);
2193 void PipelineLibraryShaderModuleInfoInstance::addModule (const std::string& moduleName, VkShaderStageFlagBits stage)
2195 const auto& binary = m_context.getBinaryCollection().get(moduleName);
2197 const VkShaderModuleCreateInfo modInfo =
2200 nullptr, // const void* pNext;
2203 reinterpret_cast<const uint32_t*>(binary.getBinary()), // const uint32_t* pCode;
2208 const VkPipelineShaderStageCreateInfo stageInfo =
2211 nullptr, // const void* pNext;
2215 "main", // const char* pName;
2216 nullptr, // const VkSpecializationInfo* pSpecializationInfo;
2227 void PipelineLibraryShaderModuleInfoInstance::recordShaderToHostBarrier (VkPipelineStageFlagBits pipelineStage) const
2229 const auto postWriteBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
2271 const auto stage = VK_SHADER_STAGE_COMPUTE_BIT;
2272 const auto bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
2278 const auto pipelineLayout = makePipelineLayout(m_vkd, m_device, m_setLayout.get());
2280 const VkComputePipelineCreateInfo pipelineCreateInfo =
2283 nullptr, // const void* pNext;
2291 const auto pipeline = createComputePipeline(m_vkd, m_device, DE_NULL, &pipelineCreateInfo);
2322 const auto stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
2323 const auto bindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
2329 const auto pipelineLayout = makePipelineLayout(m_vkd, m_device, m_setLayout.get());
2331 const VkRayTracingShaderGroupCreateInfoKHR shaderGroupInfo =
2334 nullptr, // const void* pNext;
2340 nullptr, // const void* pShaderGroupCaptureReplayHandle;
2343 const VkPipelineCreateFlags createFlags = (m_withLibrary ? static_cast<VkPipelineCreateFlags>(VK_PIPELINE_CREATE_LIBRARY_BIT_KHR) : 0u);
2344 const VkRayTracingPipelineInterfaceCreateInfoKHR libIfaceInfo = initVulkanStructure();
2345 const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryIface = (m_withLibrary ? &libIfaceInfo : nullptr);
2347 const VkRayTracingPipelineCreateInfoKHR pipelineCreateInfo =
2350 nullptr, // const void* pNext;
2353 de::dataOrNull(m_pipelineStageInfos), // const VkPipelineShaderStageCreateInfo* pStages;
2355 &shaderGroupInfo, // const VkRayTracingShaderGroupCreateInfoKHR* pGroups;
2357 nullptr, // const VkPipelineLibraryCreateInfoKHR* pLibraryInfo;
2358 pLibraryIface, // const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface;
2359 nullptr, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2372 const VkPipelineLibraryCreateInfoKHR libraryInfo =
2375 nullptr, // const void* pNext;
2377 &pipelineLib.get(), // const VkPipeline* pLibraries;
2380 const VkRayTracingPipelineCreateInfoKHR nonLibCreateInfo =
2383 nullptr, // const void* pNext;
2386 nullptr, // const VkPipelineShaderStageCreateInfo* pStages;
2388 nullptr, // const VkRayTracingShaderGroupCreateInfoKHR* pGroups;
2390 &libraryInfo, // const VkPipelineLibraryCreateInfoKHR* pLibraryInfo;
2391 pLibraryIface, // const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface;
2392 nullptr, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2405 const auto rtProperties = makeRayTracingProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
2406 const auto rtHandleSize = rtProperties->getShaderGroupHandleSize();
2407 const auto sbtSize = static_cast<VkDeviceSize>(rtHandleSize);
2408 const auto sbtMemReqs = (MemoryRequirement::HostVisible | MemoryRequirement::DeviceAddress);
2409 const auto sbtCreateInfo = makeBufferCreateInfo(sbtSize, VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
2449 const auto ctx = m_context.getContextCommonData();
2450 const tcu::IVec3 colorExtent (1, 1, 1);
2451 const auto imageExtent = makeExtent3D(colorExtent);
2452 const auto colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
2453 const auto tcuFormat = mapVkFormat(colorFormat);
2454 const auto colorUsage = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
2455 const auto colorSRR = makeDefaultImageSubresourceRange();
2456 const auto colorSRL = makeDefaultImageSubresourceLayers();
2460 const auto colorView = makeImageView(ctx.vkd, ctx.device, colorBuffer.getImage(), VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorSRR);
2463 const auto verificationBufferSize = static_cast<VkDeviceSize>(colorExtent.x() * colorExtent.y() * colorExtent.z() * tcu::getPixelSize(tcuFormat));
2464 const auto verificationBufferInfo = makeBufferCreateInfo(verificationBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
2469 const auto pipelineLayout = makePipelineLayout(ctx.vkd, ctx.device);
2471 const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo = initVulkanStructure();
2475 const std::vector<VkViewport> viewports (1u, makeViewport(imageExtent));
2476 const std::vector<VkRect2D> scissors (1u, makeRect2D(imageExtent));
2478 const auto& binaries = m_context.getBinaryCollection();
2479 const auto vertModule = createShaderModule(ctx.vkd, ctx.device, binaries.get("vert"));
2480 const auto fragModule = createShaderModule(ctx.vkd, ctx.device, binaries.get("frag"));
2490 const VkPipelineViewportStateCreateInfo viewportStateInfo =
2493 nullptr, // const void* pNext;
2496 de::dataOrNull(viewports), // const VkViewport* pViewports;
2498 de::dataOrNull(scissors), // const VkRect2D* pScissors;
2501 const VkPipelineRasterizationStateCreateInfo rasterizationStateInfo =
2504 nullptr, // const void* pNext;
2518 const VkPipelineMultisampleStateCreateInfo multisampleStateInfo =
2521 nullptr, // const void* pNext;
2526 nullptr, // const VkSampleMask* pSampleMask;
2531 const VkPipelineDepthStencilStateCreateInfo depthStencilStateInfo = initVulkanStructure();
2533 const VkColorComponentFlags colorComponentFlags = (VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT);
2535 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
2547 const VkPipelineColorBlendStateCreateInfo colorBlendStateInfo =
2550 nullptr, // const void* pNext;
2555 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2565 const VkPipelineCreateFlags libCreationFlags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR;
2566 const VkPipelineCreateFlags linkFlags = 0u;
2592 const auto vertShaderInfo = makePipelineShaderStageCreateInfo(VK_SHADER_STAGE_VERTEX_BIT, vertModule.get());
2610 const auto fragShaderInfo = makePipelineShaderStageCreateInfo(VK_SHADER_STAGE_FRAGMENT_BIT, fragModule.get());
2631 const std::vector<VkPipeline> libraryHandles
2647 const auto pipeline = createGraphicsPipeline(ctx.vkd, ctx.device, DE_NULL, &linkedPipelineInfo);
2650 const auto cmdBuffer = cmd.cmdBuffer.get();
2652 const auto clearValue = makeClearValueColorF32(0.0f, 0.0f, 0.0f, 1.0f);
2656 const auto preRenderBarrier = makeImageMemoryBarrier(0u, (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),
2666 const auto color2Transfer = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
2670 const auto copyRegion = makeBufferImageCopy(imageExtent, colorSRL);
2673 const auto transfer2Host = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
2682 const tcu::Vec4 expectedColor (0.0f, 0.0f, 1.0f, 1.0f); // Must match frag shader.
2683 const tcu::Vec4 threshold (0.0f, 0.0f, 0.0f, 0.0f);
2695 PipelineLibraryMiscTestCase (tcu::TestContext& context, const char* name, const MiscTestParams data);
2698 void checkSupport (Context& context) const;
2699 void initPrograms (SourceCollections& programCollection) const;
2700 TestInstance* createInstance (Context& context) const;
2706 PipelineLibraryMiscTestCase::PipelineLibraryMiscTestCase(tcu::TestContext& context, const char* name, const MiscTestParams params)
2712 void PipelineLibraryMiscTestCase::checkSupport(Context& context) const
2730 void PipelineLibraryMiscTestCase::initPrograms(SourceCollections& programCollection) const
2758 const deUint32 maxBitsCount = 8 * sizeof(m_testParams.layoutsBits);
2791 " const float x = (v.x+v.z*((gl_VertexIndex & 2)>>1));\n"
2792 " const float y = (v.y+v.w* (gl_VertexIndex % 2));\n"
2830 " const vec4 v = valueA + valueC;\n"
2831 " const float x = (v.x+v.z*((gl_VertexIndex & 2)>>1));\n"
2832 " const float y = (v.y+v.w* (gl_VertexIndex % 2));\n"
2866 "layout(constant_id = 0) const int random = 0;\n\n"
2877 "layout(constant_id = 0) const int random = 0;\n\n"
2901 const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
2948 TestInstance* PipelineLibraryMiscTestCase::createInstance(Context& context) const
2967 const int R = -1;
2968 const PipelineTreeConfiguration pipelineTreeConfiguration[] =
3067 const bool delayedShaderCreate = (libConfigNdx != 0);
3068 const TestParams testParams =
3075 const std::string testName = getTestName(pipelineTreeConfiguration[libConfigNdx]);
3087 const TestParams testParams
3118 const std::vector<const char*> bindNullDescriptorCombinations
3133 for (const char* name : bindNullDescriptorCombinations)