1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief Synchronization tests utilities
22 *//*--------------------------------------------------------------------*/
24 #include "vktSynchronizationUtil.hpp"
25 #include "vkTypeUtil.hpp"
26 #include "deStringUtil.hpp"
30 namespace synchronization
34 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize,
35 const VkBufferUsageFlags usage)
37 const VkBufferCreateInfo bufferCreateInfo =
39 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
40 DE_NULL, // const void* pNext;
41 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
42 bufferSize, // VkDeviceSize size;
43 usage, // VkBufferUsageFlags usage;
44 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
45 0u, // deUint32 queueFamilyIndexCount;
46 DE_NULL, // const deUint32* pQueueFamilyIndices;
48 return bufferCreateInfo;
51 VkMemoryBarrier makeMemoryBarrier (const VkAccessFlags srcAccessMask,
52 const VkAccessFlags dstAccessMask)
54 const VkMemoryBarrier barrier =
56 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // VkStructureType sType;
57 DE_NULL, // const void* pNext;
58 srcAccessMask, // VkAccessFlags srcAccessMask;
59 dstAccessMask, // VkAccessFlags dstAccessMask;
64 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags srcAccessMask,
65 const VkAccessFlags dstAccessMask,
66 const VkBuffer buffer,
67 const VkDeviceSize offset,
68 const VkDeviceSize bufferSizeBytes)
70 const VkBufferMemoryBarrier barrier =
72 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
73 DE_NULL, // const void* pNext;
74 srcAccessMask, // VkAccessFlags srcAccessMask;
75 dstAccessMask, // VkAccessFlags dstAccessMask;
76 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
77 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
78 buffer, // VkBuffer buffer;
79 offset, // VkDeviceSize offset;
80 bufferSizeBytes, // VkDeviceSize size;
85 VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask,
86 const VkAccessFlags dstAccessMask,
87 const VkImageLayout oldLayout,
88 const VkImageLayout newLayout,
90 const VkImageSubresourceRange subresourceRange)
92 const VkImageMemoryBarrier barrier =
94 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
95 DE_NULL, // const void* pNext;
96 srcAccessMask, // VkAccessFlags outputMask;
97 dstAccessMask, // VkAccessFlags inputMask;
98 oldLayout, // VkImageLayout oldLayout;
99 newLayout, // VkImageLayout newLayout;
100 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
101 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
102 image, // VkImage image;
103 subresourceRange, // VkImageSubresourceRange subresourceRange;
108 Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool)
110 const VkCommandBufferAllocateInfo info =
112 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
113 DE_NULL, // const void* pNext;
114 commandPool, // VkCommandPool commandPool;
115 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
116 1u, // deUint32 commandBufferCount;
118 return allocateCommandBuffer(vk, device, &info);
121 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk,
122 const VkDevice device,
123 const VkDescriptorPool descriptorPool,
124 const VkDescriptorSetLayout setLayout)
126 const VkDescriptorSetAllocateInfo info =
128 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
129 DE_NULL, // const void* pNext;
130 descriptorPool, // VkDescriptorPool descriptorPool;
131 1u, // deUint32 descriptorSetCount;
132 &setLayout, // const VkDescriptorSetLayout* pSetLayouts;
134 return allocateDescriptorSet(vk, device, &info);
137 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk,
138 const VkDevice device,
139 const VkDescriptorSetLayout descriptorSetLayout)
141 const VkPipelineLayoutCreateInfo info =
143 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
144 DE_NULL, // const void* pNext;
145 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
146 1u, // deUint32 setLayoutCount;
147 &descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts;
148 0u, // deUint32 pushConstantRangeCount;
149 DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
151 return createPipelineLayout(vk, device, &info);
154 Move<VkPipelineLayout> makePipelineLayoutWithoutDescriptors (const DeviceInterface& vk,
155 const VkDevice device)
157 const VkPipelineLayoutCreateInfo info =
159 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
160 DE_NULL, // const void* pNext;
161 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
162 0u, // deUint32 setLayoutCount;
163 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
164 0u, // deUint32 pushConstantRangeCount;
165 DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
167 return createPipelineLayout(vk, device, &info);
170 Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk,
171 const VkDevice device,
172 const VkPipelineLayout pipelineLayout,
173 const VkShaderModule shaderModule,
174 const VkSpecializationInfo* specInfo,
175 PipelineCacheData& pipelineCacheData)
177 const VkPipelineShaderStageCreateInfo shaderStageInfo =
179 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
180 DE_NULL, // const void* pNext;
181 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
182 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
183 shaderModule, // VkShaderModule module;
184 "main", // const char* pName;
185 specInfo, // const VkSpecializationInfo* pSpecializationInfo;
187 const VkComputePipelineCreateInfo pipelineInfo =
189 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
190 DE_NULL, // const void* pNext;
191 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
192 shaderStageInfo, // VkPipelineShaderStageCreateInfo stage;
193 pipelineLayout, // VkPipelineLayout layout;
194 DE_NULL, // VkPipeline basePipelineHandle;
195 0, // deInt32 basePipelineIndex;
199 const vk::Unique<vk::VkPipelineCache> pipelineCache (pipelineCacheData.createPipelineCache(vk, device));
200 vk::Move<vk::VkPipeline> pipeline (createComputePipeline(vk, device, *pipelineCache, &pipelineInfo));
202 // Refresh data from cache
203 pipelineCacheData.setFromPipelineCache(vk, device, *pipelineCache);
209 VkImageCreateInfo makeImageCreateInfo (const VkImageType imageType, const VkExtent3D& extent, const VkFormat format, const VkImageUsageFlags usage)
211 const VkImageCreateInfo imageInfo =
213 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
214 DE_NULL, // const void* pNext;
215 (VkImageCreateFlags)0, // VkImageCreateFlags flags;
216 imageType, // VkImageType imageType;
217 format, // VkFormat format;
218 extent, // VkExtent3D extent;
219 1u, // uint32_t mipLevels;
220 1u, // uint32_t arrayLayers;
221 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
222 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
223 usage, // VkImageUsageFlags usage;
224 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
225 0u, // uint32_t queueFamilyIndexCount;
226 DE_NULL, // const uint32_t* pQueueFamilyIndices;
227 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
232 Move<VkImageView> makeImageView (const DeviceInterface& vk,
233 const VkDevice device,
235 const VkImageViewType viewType,
236 const VkFormat format,
237 const VkImageSubresourceRange subresourceRange)
239 const VkImageViewCreateInfo imageViewParams =
241 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
242 DE_NULL, // const void* pNext;
243 (VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags;
244 image, // VkImage image;
245 viewType, // VkImageViewType viewType;
246 format, // VkFormat format;
247 makeComponentMappingRGBA(), // VkComponentMapping components;
248 subresourceRange, // VkImageSubresourceRange subresourceRange;
250 return createImageView(vk, device, &imageViewParams);
253 VkBufferImageCopy makeBufferImageCopy (const VkImageSubresourceLayers subresourceLayers,
254 const VkExtent3D extent)
256 const VkBufferImageCopy copyParams =
258 0ull, // VkDeviceSize bufferOffset;
259 0u, // deUint32 bufferRowLength;
260 0u, // deUint32 bufferImageHeight;
261 subresourceLayers, // VkImageSubresourceLayers imageSubresource;
262 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
263 extent, // VkExtent3D imageExtent;
268 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
270 const VkCommandBufferBeginInfo info =
272 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
273 DE_NULL, // const void* pNext;
274 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
275 DE_NULL, // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
277 VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
280 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
282 VK_CHECK(vk.endCommandBuffer(commandBuffer));
285 void submitCommandsAndWait (const DeviceInterface& vk,
286 const VkDevice device,
288 const VkCommandBuffer commandBuffer)
290 const Unique<VkFence> fence(createFence(vk, device));
292 const VkSubmitInfo submitInfo =
294 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
295 DE_NULL, // const void* pNext;
296 0u, // uint32_t waitSemaphoreCount;
297 DE_NULL, // const VkSemaphore* pWaitSemaphores;
298 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
299 1u, // uint32_t commandBufferCount;
300 &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
301 0u, // uint32_t signalSemaphoreCount;
302 DE_NULL, // const VkSemaphore* pSignalSemaphores;
304 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
305 VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
308 void beginRenderPass (const DeviceInterface& vk,
309 const VkCommandBuffer commandBuffer,
310 const VkRenderPass renderPass,
311 const VkFramebuffer framebuffer,
312 const VkRect2D& renderArea,
313 const tcu::Vec4& clearColor)
315 const VkClearValue clearValue = makeClearValueColor(clearColor);
317 const VkRenderPassBeginInfo renderPassBeginInfo = {
318 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
319 DE_NULL, // const void* pNext;
320 renderPass, // VkRenderPass renderPass;
321 framebuffer, // VkFramebuffer framebuffer;
322 renderArea, // VkRect2D renderArea;
323 1u, // uint32_t clearValueCount;
324 &clearValue, // const VkClearValue* pClearValues;
327 vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
330 void beginRenderPassWithRasterizationDisabled (const DeviceInterface& vk,
331 const VkCommandBuffer commandBuffer,
332 const VkRenderPass renderPass,
333 const VkFramebuffer framebuffer)
335 const VkRect2D renderArea = {{ 0, 0 }, { 0, 0 }};
337 const VkRenderPassBeginInfo renderPassBeginInfo = {
338 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
339 DE_NULL, // const void* pNext;
340 renderPass, // VkRenderPass renderPass;
341 framebuffer, // VkFramebuffer framebuffer;
342 renderArea, // VkRect2D renderArea;
343 0u, // uint32_t clearValueCount;
344 DE_NULL, // const VkClearValue* pClearValues;
347 vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
350 void endRenderPass (const DeviceInterface& vk,
351 const VkCommandBuffer commandBuffer)
353 vk.cmdEndRenderPass(commandBuffer);
356 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
357 const VkDevice device,
358 const VkFormat colorFormat)
360 const VkAttachmentDescription colorAttachmentDescription =
362 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
363 colorFormat, // VkFormat format;
364 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
365 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
366 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
367 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
368 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
369 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
370 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
373 const VkAttachmentReference colorAttachmentReference =
375 0u, // deUint32 attachment;
376 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
379 const VkAttachmentReference depthAttachmentReference =
381 VK_ATTACHMENT_UNUSED, // deUint32 attachment;
382 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout layout;
385 const VkSubpassDescription subpassDescription =
387 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
388 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
389 0u, // deUint32 inputAttachmentCount;
390 DE_NULL, // const VkAttachmentReference* pInputAttachments;
391 1u, // deUint32 colorAttachmentCount;
392 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
393 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
394 &depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment;
395 0u, // deUint32 preserveAttachmentCount;
396 DE_NULL // const deUint32* pPreserveAttachments;
399 const VkRenderPassCreateInfo renderPassInfo =
401 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
402 DE_NULL, // const void* pNext;
403 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
404 1u, // deUint32 attachmentCount;
405 &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments;
406 1u, // deUint32 subpassCount;
407 &subpassDescription, // const VkSubpassDescription* pSubpasses;
408 0u, // deUint32 dependencyCount;
409 DE_NULL // const VkSubpassDependency* pDependencies;
412 return createRenderPass(vk, device, &renderPassInfo);
415 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk,
416 const VkDevice device,
417 const VkRenderPass renderPass,
418 const VkImageView colorAttachment,
419 const deUint32 width,
420 const deUint32 height,
421 const deUint32 layers)
423 const VkFramebufferCreateInfo framebufferInfo = {
424 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
425 DE_NULL, // const void* pNext;
426 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
427 renderPass, // VkRenderPass renderPass;
428 1u, // uint32_t attachmentCount;
429 &colorAttachment, // const VkImageView* pAttachments;
430 width, // uint32_t width;
431 height, // uint32_t height;
432 layers, // uint32_t layers;
435 return createFramebuffer(vk, device, &framebufferInfo);
438 GraphicsPipelineBuilder& GraphicsPipelineBuilder::setShader (const DeviceInterface& vk,
439 const VkDevice device,
440 const VkShaderStageFlagBits stage,
441 const ProgramBinary& binary,
442 const VkSpecializationInfo* specInfo)
444 VkShaderModule module;
447 case (VK_SHADER_STAGE_VERTEX_BIT):
448 DE_ASSERT(m_vertexShaderModule.get() == DE_NULL);
449 m_vertexShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
450 module = *m_vertexShaderModule;
453 case (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT):
454 DE_ASSERT(m_tessControlShaderModule.get() == DE_NULL);
455 m_tessControlShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
456 module = *m_tessControlShaderModule;
459 case (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT):
460 DE_ASSERT(m_tessEvaluationShaderModule.get() == DE_NULL);
461 m_tessEvaluationShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
462 module = *m_tessEvaluationShaderModule;
465 case (VK_SHADER_STAGE_GEOMETRY_BIT):
466 DE_ASSERT(m_geometryShaderModule.get() == DE_NULL);
467 m_geometryShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
468 module = *m_geometryShaderModule;
471 case (VK_SHADER_STAGE_FRAGMENT_BIT):
472 DE_ASSERT(m_fragmentShaderModule.get() == DE_NULL);
473 m_fragmentShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
474 module = *m_fragmentShaderModule;
478 DE_FATAL("Invalid shader stage");
482 const VkPipelineShaderStageCreateInfo pipelineShaderStageInfo =
484 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
485 DE_NULL, // const void* pNext;
486 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
487 stage, // VkShaderStageFlagBits stage;
488 module, // VkShaderModule module;
489 "main", // const char* pName;
490 specInfo, // const VkSpecializationInfo* pSpecializationInfo;
493 m_shaderStageFlags |= stage;
494 m_shaderStages.push_back(pipelineShaderStageInfo);
499 GraphicsPipelineBuilder& GraphicsPipelineBuilder::setVertexInputSingleAttribute (const VkFormat vertexFormat, const deUint32 stride)
501 const VkVertexInputBindingDescription bindingDesc =
503 0u, // uint32_t binding;
504 stride, // uint32_t stride;
505 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
507 const VkVertexInputAttributeDescription attributeDesc =
509 0u, // uint32_t location;
510 0u, // uint32_t binding;
511 vertexFormat, // VkFormat format;
512 0u, // uint32_t offset;
515 m_vertexInputBindings.clear();
516 m_vertexInputBindings.push_back(bindingDesc);
518 m_vertexInputAttributes.clear();
519 m_vertexInputAttributes.push_back(attributeDesc);
525 inline const T* dataPointer (const std::vector<T>& vec)
527 return (vec.size() != 0 ? &vec[0] : DE_NULL);
530 Move<VkPipeline> GraphicsPipelineBuilder::build (const DeviceInterface& vk,
531 const VkDevice device,
532 const VkPipelineLayout pipelineLayout,
533 const VkRenderPass renderPass,
534 PipelineCacheData& pipelineCacheData)
536 const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
538 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
539 DE_NULL, // const void* pNext;
540 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
541 static_cast<deUint32>(m_vertexInputBindings.size()), // uint32_t vertexBindingDescriptionCount;
542 dataPointer(m_vertexInputBindings), // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
543 static_cast<deUint32>(m_vertexInputAttributes.size()), // uint32_t vertexAttributeDescriptionCount;
544 dataPointer(m_vertexInputAttributes), // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
547 const VkPrimitiveTopology topology = (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
548 : m_primitiveTopology;
549 const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
551 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
552 DE_NULL, // const void* pNext;
553 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
554 topology, // VkPrimitiveTopology topology;
555 VK_FALSE, // VkBool32 primitiveRestartEnable;
558 const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo =
560 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
561 DE_NULL, // const void* pNext;
562 (VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags;
563 m_patchControlPoints, // uint32_t patchControlPoints;
566 const VkViewport viewport = makeViewport(
568 static_cast<float>(m_renderSize.x()), static_cast<float>(m_renderSize.y()),
571 const VkRect2D scissor = {
573 makeExtent2D(m_renderSize.x(), m_renderSize.y()),
576 const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
578 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
579 DE_NULL, // const void* pNext;
580 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
581 1u, // uint32_t viewportCount;
582 &viewport, // const VkViewport* pViewports;
583 1u, // uint32_t scissorCount;
584 &scissor, // const VkRect2D* pScissors;
587 const bool isRasterizationDisabled = ((m_shaderStageFlags & VK_SHADER_STAGE_FRAGMENT_BIT) == 0);
588 const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
590 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
591 DE_NULL, // const void* pNext;
592 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
593 VK_FALSE, // VkBool32 depthClampEnable;
594 isRasterizationDisabled, // VkBool32 rasterizerDiscardEnable;
595 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
596 m_cullModeFlags, // VkCullModeFlags cullMode;
597 m_frontFace, // VkFrontFace frontFace;
598 VK_FALSE, // VkBool32 depthBiasEnable;
599 0.0f, // float depthBiasConstantFactor;
600 0.0f, // float depthBiasClamp;
601 0.0f, // float depthBiasSlopeFactor;
602 1.0f, // float lineWidth;
605 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
607 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
608 DE_NULL, // const void* pNext;
609 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
610 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
611 VK_FALSE, // VkBool32 sampleShadingEnable;
612 0.0f, // float minSampleShading;
613 DE_NULL, // const VkSampleMask* pSampleMask;
614 VK_FALSE, // VkBool32 alphaToCoverageEnable;
615 VK_FALSE // VkBool32 alphaToOneEnable;
618 const VkStencilOpState stencilOpState = makeStencilOpState(
619 VK_STENCIL_OP_KEEP, // stencil fail
620 VK_STENCIL_OP_KEEP, // depth & stencil pass
621 VK_STENCIL_OP_KEEP, // depth only fail
622 VK_COMPARE_OP_NEVER, // compare op
627 const VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
629 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
630 DE_NULL, // const void* pNext;
631 (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
632 VK_FALSE, // VkBool32 depthTestEnable;
633 VK_FALSE, // VkBool32 depthWriteEnable;
634 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
635 VK_FALSE, // VkBool32 depthBoundsTestEnable;
636 VK_FALSE, // VkBool32 stencilTestEnable;
637 stencilOpState, // VkStencilOpState front;
638 stencilOpState, // VkStencilOpState back;
639 0.0f, // float minDepthBounds;
640 1.0f, // float maxDepthBounds;
643 const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
644 const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState =
646 m_blendEnable, // VkBool32 blendEnable;
647 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor;
648 VK_BLEND_FACTOR_ONE, // VkBlendFactor dstColorBlendFactor;
649 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
650 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcAlphaBlendFactor;
651 VK_BLEND_FACTOR_ONE, // VkBlendFactor dstAlphaBlendFactor;
652 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
653 colorComponentsAll, // VkColorComponentFlags colorWriteMask;
656 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
658 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
659 DE_NULL, // const void* pNext;
660 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
661 VK_FALSE, // VkBool32 logicOpEnable;
662 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
663 1u, // deUint32 attachmentCount;
664 &pipelineColorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
665 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
668 const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
670 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
671 DE_NULL, // const void* pNext;
672 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
673 static_cast<deUint32>(m_shaderStages.size()), // deUint32 stageCount;
674 &m_shaderStages[0], // const VkPipelineShaderStageCreateInfo* pStages;
675 &vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
676 &pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
677 (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ? &pipelineTessellationStateInfo : DE_NULL), // const VkPipelineTessellationStateCreateInfo* pTessellationState;
678 (isRasterizationDisabled ? DE_NULL : &pipelineViewportStateInfo), // const VkPipelineViewportStateCreateInfo* pViewportState;
679 &pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
680 (isRasterizationDisabled ? DE_NULL : &pipelineMultisampleStateInfo), // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
681 (isRasterizationDisabled ? DE_NULL : &pipelineDepthStencilStateInfo), // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
682 (isRasterizationDisabled ? DE_NULL : &pipelineColorBlendStateInfo), // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
683 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
684 pipelineLayout, // VkPipelineLayout layout;
685 renderPass, // VkRenderPass renderPass;
686 0u, // deUint32 subpass;
687 DE_NULL, // VkPipeline basePipelineHandle;
688 0, // deInt32 basePipelineIndex;
692 const vk::Unique<vk::VkPipelineCache> pipelineCache (pipelineCacheData.createPipelineCache(vk, device));
693 vk::Move<vk::VkPipeline> pipeline (createGraphicsPipeline(vk, device, *pipelineCache, &graphicsPipelineInfo));
695 // Refresh data from cache
696 pipelineCacheData.setFromPipelineCache(vk, device, *pipelineCache);
702 void requireFeatures (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const FeatureFlags flags)
704 const VkPhysicalDeviceFeatures features = getPhysicalDeviceFeatures(vki, physDevice);
706 if (((flags & FEATURE_TESSELLATION_SHADER) != 0) && !features.tessellationShader)
707 throw tcu::NotSupportedError("Tessellation shader not supported");
709 if (((flags & FEATURE_GEOMETRY_SHADER) != 0) && !features.geometryShader)
710 throw tcu::NotSupportedError("Geometry shader not supported");
712 if (((flags & FEATURE_SHADER_FLOAT_64) != 0) && !features.shaderFloat64)
713 throw tcu::NotSupportedError("Double-precision floats not supported");
715 if (((flags & FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS) != 0) && !features.vertexPipelineStoresAndAtomics)
716 throw tcu::NotSupportedError("SSBO and image writes not supported in vertex pipeline");
718 if (((flags & FEATURE_FRAGMENT_STORES_AND_ATOMICS) != 0) && !features.fragmentStoresAndAtomics)
719 throw tcu::NotSupportedError("SSBO and image writes not supported in fragment shader");
721 if (((flags & FEATURE_SHADER_TESSELLATION_AND_GEOMETRY_POINT_SIZE) != 0) && !features.shaderTessellationAndGeometryPointSize)
722 throw tcu::NotSupportedError("Tessellation and geometry shaders don't support PointSize built-in");
724 if (((flags & FEATURE_SHADER_STORAGE_IMAGE_EXTENDED_FORMATS) != 0) && !features.shaderStorageImageExtendedFormats)
725 throw tcu::NotSupportedError("Storage image extended formats not supported");
728 std::string getResourceName (const ResourceDescription& resource)
730 std::ostringstream str;
732 if (resource.type == RESOURCE_TYPE_BUFFER)
733 str << "buffer_" << resource.size.x();
734 else if (resource.type == RESOURCE_TYPE_IMAGE)
736 str << "image_" << resource.size.x()
737 << (resource.size.y() > 0 ? "x" + de::toString(resource.size.y()) : "")
738 << (resource.size.z() > 0 ? "x" + de::toString(resource.size.z()) : "")
739 << "_" << de::toLower(getFormatName(resource.imageFormat)).substr(10);
741 else if (isIndirectBuffer(resource.type))
742 str << "indirect_buffer";
749 bool isIndirectBuffer (const ResourceType type)
753 case RESOURCE_TYPE_INDIRECT_BUFFER_DRAW:
754 case RESOURCE_TYPE_INDIRECT_BUFFER_DRAW_INDEXED:
755 case RESOURCE_TYPE_INDIRECT_BUFFER_DISPATCH:
763 PipelineCacheData::PipelineCacheData (void)
767 PipelineCacheData::~PipelineCacheData (void)
771 vk::Move<VkPipelineCache> PipelineCacheData::createPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device) const
773 const de::ScopedLock dataLock (m_lock);
774 const struct vk::VkPipelineCacheCreateInfo params =
776 vk::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
778 (vk::VkPipelineCacheCreateFlags)0,
779 (deUintptr)m_data.size(),
780 (m_data.empty() ? DE_NULL : &m_data[0])
783 return vk::createPipelineCache(vk, device, ¶ms);
786 void PipelineCacheData::setFromPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineCache pipelineCache)
788 const de::ScopedLock dataLock (m_lock);
789 deUintptr dataSize = 0;
791 VK_CHECK(vk.getPipelineCacheData(device, pipelineCache, &dataSize, DE_NULL));
793 m_data.resize(dataSize);
796 VK_CHECK(vk.getPipelineCacheData(device, pipelineCache, &dataSize, &m_data[0]));