1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2018 The Khronos Group Inc.
6 * Copyright (c) 2018 Google Inc.
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 tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktApiPipelineTests.hpp"
26 #include "vktTestCaseUtil.hpp"
27
28 #include "deUniquePtr.hpp"
29 #include "vkMemUtil.hpp"
30 #include "vkRefUtil.hpp"
31 #include "vkPrograms.hpp"
32 #include "vkQueryUtil.hpp"
33 #include "vkTypeUtil.hpp"
34 #include "vkCmdUtil.hpp"
35 #include "vkObjUtil.hpp"
36 #include "vkBarrierUtil.hpp"
37 #include "vkBufferWithMemory.hpp"
38 #include "vkBuilderUtil.hpp"
39 #include "vkImageUtil.hpp"
40 #include "tcuTestLog.hpp"
41
42 #include <vector>
43 #include <sstream>
44
45 namespace vkt
46 {
47 namespace api
48 {
49
50 namespace
51 {
52
53 using namespace std;
54 using namespace vk;
55
getRenderTargetFormat(const InstanceInterface & vk,const VkPhysicalDevice & device)56 VkFormat getRenderTargetFormat (const InstanceInterface& vk, const VkPhysicalDevice& device)
57 {
58 const VkFormatFeatureFlags featureFlags = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
59 VkFormatProperties formatProperties;
60
61 vk.getPhysicalDeviceFormatProperties(device, VK_FORMAT_B8G8R8A8_UNORM, &formatProperties);
62
63 if ((formatProperties.linearTilingFeatures & featureFlags) || (formatProperties.optimalTilingFeatures & featureFlags))
64 return VK_FORMAT_B8G8R8A8_UNORM;
65
66 vk.getPhysicalDeviceFormatProperties(device, VK_FORMAT_R8G8B8A8_UNORM, &formatProperties);
67
68 if ((formatProperties.linearTilingFeatures & featureFlags) || formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)
69 return VK_FORMAT_R8G8B8A8_UNORM;
70
71 TCU_THROW(NotSupportedError, "Device does not support VK_FORMAT_B8G8R8A8_UNORM nor VK_FORMAT_R8G8B8A8_UNORM");
72
73 return VK_FORMAT_UNDEFINED;
74 }
75
createCommandBuffer(const DeviceInterface & vkd,VkDevice device,VkCommandPool commandPool)76 Move<VkCommandBuffer> createCommandBuffer (const DeviceInterface& vkd, VkDevice device, VkCommandPool commandPool)
77 {
78 const VkCommandBufferAllocateInfo allocateInfo =
79 {
80 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
81 DE_NULL, // const void* pNext;
82 commandPool, // VkCommandPool commandPool;
83 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
84 1u // deUint32 commandBufferCount;
85 };
86
87 return allocateCommandBuffer(vkd, device, &allocateInfo);
88 }
89
90 enum DrawTriangleMode
91 {
92 DTM_DESTROY_RENDER_PASS_AFTER_CREATING_PIPELINE = 0,
93 DTM_DESTROY_PIPELINE_LAYOUT_AFTER_CREATING_PIPELINE,
94 };
95
drawTriangleTest(Context & context,DrawTriangleMode mode)96 tcu::TestStatus drawTriangleTest (Context& context, DrawTriangleMode mode)
97 {
98 const DeviceInterface& vk = context.getDeviceInterface();
99 const InstanceInterface& vki = context.getInstanceInterface();
100 const VkDevice device = context.getDevice();
101 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
102
103 const VkFormat format = getRenderTargetFormat(vki, physicalDevice);
104 const VkFormatProperties formatProperties (getPhysicalDeviceFormatProperties(vki, physicalDevice, format));
105 const VkImageTiling imageTiling = (formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_LINEAR
106 : (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_OPTIMAL
107 : VK_CORE_IMAGE_TILING_LAST;
108
109 const VkImageCreateInfo attachmentImageCreateInfo =
110 {
111 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
112 DE_NULL, // const void* pNext;
113 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
114 VK_IMAGE_TYPE_2D, // VkImageType imageType;
115 format, // VkFormat format;
116 {
117 256u, // deUint32 width;
118 256u, // deUint32 height;
119 1u // deUint32 depth;
120 }, // VkExtent3D extent;
121 1u, // deUint32 mipLevels;
122 1u, // deUint32 arrayLayers;
123 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
124 imageTiling, // VkImageTiling tiling;
125 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
126 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage;
127 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
128 0u, // deUint32 queueFamilyIndexCount;
129 DE_NULL, // const deUint32* pQueueFamilyIndices;
130 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
131 };
132
133 const Unique<VkImage> attachmentImage (createImage(vk, device, &attachmentImageCreateInfo));
134 de::MovePtr<Allocation> attachmentImageMemory = context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, device, *attachmentImage), MemoryRequirement::Any);
135
136 VK_CHECK(vk.bindImageMemory(device, *attachmentImage, attachmentImageMemory->getMemory(), attachmentImageMemory->getOffset()));
137
138 const tcu::TextureFormat resultFormat = mapVkFormat(format);
139 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(resultFormat.getPixelSize() * 256 * 256);
140 const VkBufferCreateInfo readImageBufferParams
141 {
142 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
143 DE_NULL, // const void* pNext;
144 0u, // VkBufferCreateFlags flags;
145 imageSizeBytes, // VkDeviceSize size;
146 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
147 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
148 0u, // deUint32 queueFamilyCount;
149 DE_NULL, // const deUint32* pQueueFamilyIndices;
150 };
151 const Unique<VkBuffer> readImageBuffer(createBuffer(vk, device, &readImageBufferParams));
152 const de::UniquePtr<Allocation> readImageBufferMemory(context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, device, *readImageBuffer), MemoryRequirement::HostVisible));
153
154 VK_CHECK(vk.bindBufferMemory(device, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
155
156 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
157
158 const VkCommandPoolCreateInfo commandPoolParams =
159 {
160 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
161 DE_NULL, // const void* pNext;
162 (VkCommandPoolCreateFlags)0u, // VkCommandPoolCreateFlags flags;
163 queueFamilyIndex // deUint32 queueFamilyIndex;
164 };
165
166 const Unique<VkCommandPool> commandPool (createCommandPool(vk, device, &commandPoolParams, DE_NULL));
167 const Unique<VkCommandBuffer> commandBuffer (createCommandBuffer(vk, device, commandPool.get()));
168
169 const VkCommandBufferBeginInfo commandBufferBeginInfo =
170 {
171 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
172 DE_NULL, // const void* pNext;
173 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
174 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
175 };
176
177 VK_CHECK(vk.beginCommandBuffer(commandBuffer.get(), &commandBufferBeginInfo));
178
179 const VkAttachmentDescription attachmentDescription =
180 {
181 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
182 format, // VkFormat format;
183 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
184 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
185 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
186 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
187 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
188 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
189 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
190 };
191
192 const VkAttachmentReference attachmentReference =
193 {
194 0u, // deUint32 attachment;
195 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
196 };
197
198 const VkSubpassDescription subpassDescription =
199 {
200 (VkSubpassDescriptionFlags)0u, // VkSubpassDescriptionFlags flags;
201 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
202 0u, // deUint32 inputAttachmentCount
203 DE_NULL, // const VkAttachmentReference* pInputAttachments
204 1u, // deUint32 colorAttachmentCount
205 &attachmentReference, // const VkAttachmentReference* pColorAttachments
206 DE_NULL, // const VkAttachmentReference* pResolveAttachments
207 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
208 0u, // deUint32 preserveAttachmentCount
209 DE_NULL // const deUint32* pPreserveAttachments
210 };
211
212 const VkRenderPassCreateInfo renderPassCreateInfo =
213 {
214 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
215 DE_NULL, // const void* pNext;
216 (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags;
217 1u, // deUint32 attachmentCount
218 &attachmentDescription, // const VkAttachmentDescription* pAttachments
219 1u, // deUint32 subpassCount
220 &subpassDescription, // const VkSubpassDescription* pSubpasses
221 0u, // deUint32 dependencyCount
222 DE_NULL // const VkSubpassDependency* pDependencies
223 };
224
225 // When testing renderpass lifetime - create two compatible renderpasses, otherwise use just renderPassB
226 VkRenderPass renderPassA;
227 if (DTM_DESTROY_RENDER_PASS_AFTER_CREATING_PIPELINE == mode)
228 VK_CHECK(vk.createRenderPass(device, &renderPassCreateInfo, DE_NULL, &renderPassA));
229
230 const Move<VkRenderPass> renderPassB (createRenderPass(vk, device, &renderPassCreateInfo));
231
232 const VkImageViewCreateInfo attachmentImageViewCreateInfo =
233 {
234 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
235 DE_NULL, // const void* pNext;
236 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
237 attachmentImage.get(), // VkImage image;
238 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
239 format, // VkFormat format;
240 {
241 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
242 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
243 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
244 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
245 }, // VkComponentMapping components;
246 {
247 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
248 0u, // deUint32 baseMipLevel;
249 1u, // deUint32 levelCount;
250 0u, // deUint32 baseArrayLayer;
251 1u // deUint32 layerCount;
252 } // VkImageSubresourceRange subresourceRange;
253 };
254
255 const Unique<VkImageView> attachmentImageView (createImageView(vk, device, &attachmentImageViewCreateInfo));
256
257 const VkFramebufferCreateInfo framebufferCreateInfo =
258 {
259 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
260 DE_NULL, // const void* pNext;
261 (VkFramebufferCreateFlags)0u, // VkFramebufferCreateFlags flags;
262 renderPassB.get(), // VkRenderPass renderPass;
263 1u, // deUint32 attachmentCount;
264 &attachmentImageView.get(), // const VkImageView* pAttachments;
265 256u, // deUint32 width;
266 256u, // deUint32 height;
267 1u // deUint32 layers;
268 };
269
270 const Unique<VkFramebuffer> frameBuffer (createFramebuffer(vk, device, &framebufferCreateInfo));
271
272 const Unique<VkShaderModule> vertexShaderModule (createShaderModule(vk, device, context.getBinaryCollection().get("vertex"), 0));
273 const Unique<VkShaderModule> fragmentShaderModule (createShaderModule(vk, device, context.getBinaryCollection().get("fragment"), 0));
274
275 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
276 {
277 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
278 DE_NULL, // const void* pNext;
279 (VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
280 0u, // deUint32 setLayoutCount;
281 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
282 0u, // deUint32 pushConstantRangeCount;
283 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
284 };
285
286 Move<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, device, &pipelineLayoutCreateInfo));
287
288 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
289 {
290 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
291 DE_NULL, // const void* pNext;
292 (VkPipelineVertexInputStateCreateFlags)0u, // VkPipelineVertexInputStateCreateFlags flags;
293 0u, // deUint32 vertexBindingDescriptionCount;
294 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
295 0u, // deUint32 vertexAttributeDescriptionCount;
296 DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
297 };
298
299 const VkViewport viewport =
300 {
301 0.0f, // float x;
302 0.0f, // float y;
303 64.0f, // float width;
304 64.0f, // float height;
305 0.0f, // float minDepth;
306 0.0f, // float maxDepth;
307 };
308
309 const std::vector<VkViewport> viewports (1, viewport);
310 const std::vector<VkRect2D> scissors (1, makeRect2D(0, 0, 64u, 64u));
311
312 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
313 {
314 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
315 DE_NULL, // const void* pNext;
316 (VkPipelineRasterizationStateCreateFlags)0u, // VkPipelineRasterizationStateCreateFlags flags;
317 VK_FALSE, // VkBool32 depthClampEnable;
318 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
319 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
320 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
321 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
322 VK_FALSE, // VkBool32 depthBiasEnable;
323 0.0f, // float depthBiasConstantFactor;
324 0.0f, // float depthBiasClamp;
325 0.0f, // float depthBiasSlopeFactor;
326 1.0f // float lineWidth;
327 };
328
329 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
330 {
331 VK_FALSE, // VkBool32 blendEnable;
332 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
333 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
334 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
335 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
336 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
337 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
338 (VkColorComponentFlags)0xF // VkColorComponentFlags colorWriteMask;
339 };
340
341 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
342 {
343 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
344 DE_NULL, // const void* pNext;
345 (VkPipelineColorBlendStateCreateFlags)0u, // VkPipelineColorBlendStateCreateFlags flags;
346 VK_FALSE, // VkBool32 logicOpEnable;
347 VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp;
348 1u, // deUint32 attachmentCount;
349 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
350 { 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4];
351 };
352
353 VkRenderPass renderPassUsedForPipeline = *renderPassB;
354 if (DTM_DESTROY_RENDER_PASS_AFTER_CREATING_PIPELINE == mode)
355 renderPassUsedForPipeline = renderPassA;
356
357 const Unique<VkPipeline> graphicsPipeline (makeGraphicsPipeline(vk, // const DeviceInterface& vk
358 device, // const VkDevice device
359 *pipelineLayout, // const VkPipelineLayout pipelineLayout
360 *vertexShaderModule, // const VkShaderModule vertexShaderModule
361 DE_NULL, // const VkShaderModule tessellationControlModule
362 DE_NULL, // const VkShaderModule tessellationEvalModule
363 DE_NULL, // const VkShaderModule geometryShaderModule
364 *fragmentShaderModule, // const VkShaderModule fragmentShaderModule
365 renderPassUsedForPipeline, // const VkRenderPass renderPass
366 viewports, // const std::vector<VkViewport>& viewports
367 scissors, // const std::vector<VkRect2D>& scissors
368 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // const VkPrimitiveTopology topology
369 0u, // const deUint32 subpass
370 0u, // const deUint32 patchControlPoints
371 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
372 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
373 DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
374 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
375 &colorBlendStateCreateInfo)); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
376
377 if (DTM_DESTROY_PIPELINE_LAYOUT_AFTER_CREATING_PIPELINE == mode)
378 pipelineLayout = decltype(pipelineLayout)();
379
380 beginRenderPass(vk, *commandBuffer, renderPassB.get(), frameBuffer.get(), makeRect2D(0, 0, 256u, 256u), tcu::Vec4(0.25f, 0.25f, 0.25f, 0.0f));
381
382 vk.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline.get());
383
384 // Destroy the renderpass that was used to create the graphics pipeline
385 if (DTM_DESTROY_RENDER_PASS_AFTER_CREATING_PIPELINE == mode)
386 vk.destroyRenderPass(device, renderPassA, DE_NULL);
387
388 vk.cmdDraw(*commandBuffer, 3u, 1u, 0u, 0u);
389
390 endRenderPass(vk, *commandBuffer);
391
392 // Copy image to buffer
393 {
394 copyImageToBuffer(vk, *commandBuffer, *attachmentImage, *readImageBuffer, tcu::IVec2(256, 256));
395 }
396
397 VK_CHECK(vk.endCommandBuffer(*commandBuffer));
398
399 const VkSubmitInfo submitInfo =
400 {
401 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
402 DE_NULL, // const void* pNext;
403 0u, // deUint32 waitSemaphoreCount;
404 DE_NULL, // const VkSemaphore* pWaitSemaphores;
405 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
406 1u, // deUint32 commandBufferCount;
407 &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
408 0u, // deUint32 signalSemaphoreCount;
409 DE_NULL // const VkSemaphore* pSignalSemaphores;
410 };
411
412 vk::VkQueue queue = context.getUniversalQueue();
413
414 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
415 VK_CHECK(vk.queueWaitIdle(queue));
416 VK_CHECK(vk.deviceWaitIdle(device));
417
418 invalidateAlloc(vk, device, *readImageBufferMemory);
419 const tcu::ConstPixelBufferAccess resultAccess(resultFormat, 256, 256, 1, readImageBufferMemory->getHostPtr());
420
421 // check just one pixel
422 tcu::Vec4 pixel = resultAccess.getPixel(1, 1);
423 if ((pixel.x() < 0.9f) || (pixel.y() > 0.1f) || (pixel.z() > 0.1f) || (pixel.w() < 0.9f))
424 return tcu::TestStatus::fail("Fail");
425
426 tcu::TestLog& log = context.getTestContext().getLog();
427 log << tcu::TestLog::ImageSet("Image verification", "")
428 << tcu::TestLog::Image("Result", "Result", resultAccess, tcu::Vec4(1.0f), tcu::Vec4(0.0f))
429 << tcu::TestLog::EndImageSet;
430
431 return tcu::TestStatus::pass("Pass");
432 }
433
renderpassLifetimeTest(Context & context)434 tcu::TestStatus renderpassLifetimeTest(Context& context)
435 {
436 return drawTriangleTest(context, DTM_DESTROY_RENDER_PASS_AFTER_CREATING_PIPELINE);
437 }
438
createDrawTriangleSource(SourceCollections & dst)439 void createDrawTriangleSource (SourceCollections& dst)
440 {
441 dst.glslSources.add("vertex") << glu::VertexSource(
442 "#version 310 es\n"
443 "void main (void)\n"
444 "{\n"
445 " gl_Position = vec4(float(1 - 2 * int(gl_VertexIndex != 1)),\n"
446 " float(1 - 2 * int(gl_VertexIndex > 0)), 0.0, 1.0);\n"
447 "}\n");
448
449 dst.glslSources.add("fragment") << glu::FragmentSource(
450 "#version 310 es\n"
451 "layout (location = 0) out highp vec4 color;\n"
452 "void main (void)\n"
453 "{\n"
454 " color = vec4(1.0, 0.0, 0.0, 1.0);\n"
455 "}\n");
456 }
457
changeColorAttachmentImageLayout(const DeviceInterface & vk,VkCommandBuffer commandBuffer,VkImage image)458 void changeColorAttachmentImageLayout (const DeviceInterface& vk, VkCommandBuffer commandBuffer, VkImage image)
459 {
460 const VkImageMemoryBarrier imageMemoryBarrier =
461 {
462 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
463 DE_NULL, // const void* pNext;
464 (VkAccessFlags)0u, // VkAccessFlags srcAccessMask;
465 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
466 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
467 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
468 0u, // deUint32 srcQueueFamilyIndex;
469 0u, // deUint32 dstQueueFamilyIndex;
470 image, // VkImage image;
471 {
472 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
473 0u, // deUint32 baseMipLevel;
474 1u, // deUint32 levelCount;
475 0u, // deUint32 baseArrayLayer;(
476 1u // deUint32 layerCount;
477 } // VkImageSubresourceRange subresourceRange;
478 };
479
480 vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlagBits)0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageMemoryBarrier);
481 }
482
createSimpleRenderPass(const DeviceInterface & vk,const VkDevice & device,VkFormat format,VkAttachmentLoadOp loadOp,VkAttachmentLoadOp stencilLoadOp,VkAttachmentStoreOp stencilStoreOp,VkImageLayout layout)483 Move<VkRenderPass> createSimpleRenderPass (const DeviceInterface& vk, const VkDevice& device, VkFormat format, VkAttachmentLoadOp loadOp, VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp, VkImageLayout layout)
484 {
485 const VkAttachmentDescription attachmentDescription =
486 {
487 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
488 format, // VkFormat format;
489 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
490 loadOp, // VkAttachmentLoadOp loadOp;
491 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
492 stencilLoadOp, // VkAttachmentLoadOp stencilLoadOp;
493 stencilStoreOp, // VkAttachmentStoreOp stencilStoreOp;
494 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
495 layout // VkImageLayout finalLayout;
496 };
497
498 const VkAttachmentReference attachmentReference =
499 {
500 0u, // deUint32 attachment;
501 layout // VkImageLayout layout;
502 };
503
504 const VkSubpassDescription subpassDescription =
505 {
506 (VkSubpassDescriptionFlags)0u, // VkSubpassDescriptionFlags flags;
507 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
508 0u, // deUint32 inputAttachmentCount
509 DE_NULL, // const VkAttachmentReference* pInputAttachments
510 1u, // deUint32 colorAttachmentCount
511 &attachmentReference, // const VkAttachmentReference* pColorAttachments
512 DE_NULL, // const VkAttachmentReference* pResolveAttachments
513 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
514 0u, // deUint32 preserveAttachmentCount
515 DE_NULL // const deUint32* pPreserveAttachments
516 };
517
518 const VkRenderPassCreateInfo renderPassCreateInfo =
519 {
520 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
521 DE_NULL, // const void* pNext;
522 (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags;
523 1u, // deUint32 attachmentCount
524 &attachmentDescription, // const VkAttachmentDescription* pAttachments
525 1u, // deUint32 subpassCount
526 &subpassDescription, // const VkSubpassDescription* pSubpasses
527 0u, // deUint32 dependencyCount
528 DE_NULL // const VkSubpassDependency* pDependencies
529 };
530
531 return createRenderPass(vk, device, &renderPassCreateInfo);
532 }
533
534 // This test has the same functionality as VkLayerTest.RenderPassInUseDestroyedSignaled
framebufferCompatibleRenderPassTest(Context & context)535 tcu::TestStatus framebufferCompatibleRenderPassTest (Context& context)
536 {
537 const DeviceInterface& vk = context.getDeviceInterface();
538 const InstanceInterface& vki = context.getInstanceInterface();
539 const VkDevice device = context.getDevice();
540 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
541 const VkQueue queue = context.getUniversalQueue();
542 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
543
544 const VkCommandPoolCreateInfo commandPoolParams =
545 {
546 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
547 DE_NULL, // const void* pNext;
548 (VkCommandPoolCreateFlags)0u, // VkCommandPoolCreateFlags flags;
549 queueFamilyIndex // deUint32 queueFamilyIndex;
550 };
551
552 const Unique<VkCommandPool> commandPool (createCommandPool(vk, device, &commandPoolParams, DE_NULL));
553 const Unique<VkCommandBuffer> commandBuffer (createCommandBuffer(vk, device, commandPool.get()));
554
555 const VkCommandBufferBeginInfo commandBufferBeginInfo =
556 {
557 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
558 DE_NULL, // const void* pNext;
559 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
560 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
561 };
562
563 VK_CHECK(vk.beginCommandBuffer(commandBuffer.get(), &commandBufferBeginInfo));
564
565 const VkFormat format = getRenderTargetFormat(vki, physicalDevice);
566 const VkFormatProperties formatProperties (getPhysicalDeviceFormatProperties(vki, physicalDevice, format));
567 const VkImageTiling imageTiling = (formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_LINEAR
568 : (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_OPTIMAL
569 : VK_CORE_IMAGE_TILING_LAST;
570
571 const VkImageCreateInfo imageCreateInfo =
572 {
573 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
574 DE_NULL, // const void* pNext;
575 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
576 VK_IMAGE_TYPE_2D, // VkImageType imageType;
577 format, // VkFormat format;
578 {
579 256u, // deUint32 width;
580 256u, // deUint32 height;
581 1u // deUint32 depth;
582 }, // VkExtent3D extent;
583 1u, // deUint32 mipLevels;
584 1u, // deUint32 arrayLayers;
585 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
586 imageTiling, // VkImageTiling tiling;
587 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
588 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
589 0u, // deUint32 queueFamilyIndexCount;
590 DE_NULL, // const deUint32* pQueueFamilyIndices;
591 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
592 };
593
594 const Unique<VkImage> attachmentImage (createImage(vk, device, &imageCreateInfo));
595 de::MovePtr<Allocation> attachmentImageMemory = context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, device, *attachmentImage), MemoryRequirement::Any);
596
597 VK_CHECK(vk.bindImageMemory(device, *attachmentImage, attachmentImageMemory->getMemory(), attachmentImageMemory->getOffset()));
598
599 changeColorAttachmentImageLayout(vk, commandBuffer.get(), attachmentImage.get());
600
601 const VkImageViewCreateInfo imageViewCreateInfo =
602 {
603 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
604 DE_NULL, // const void* pNext;
605 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
606 attachmentImage.get(), // VkImage image;
607 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
608 format, // VkFormat format;
609 {
610 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
611 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
612 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
613 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
614 }, // VkComponentMapping components;
615 {
616 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
617 0u, // deUint32 baseMipLevel;
618 1u, // deUint32 levelCount;
619 0u, // deUint32 baseArrayLayer;
620 1u // deUint32 layerCount;
621 } // VkImageSubresourceRange subresourceRange;
622 };
623
624 const Unique<VkImageView> attachmentImageView (createImageView(vk, device, &imageViewCreateInfo));
625
626 Unique<VkRenderPass> renderPassA (createSimpleRenderPass(vk, device, format,
627 VK_ATTACHMENT_LOAD_OP_CLEAR,
628 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
629 VK_ATTACHMENT_STORE_OP_DONT_CARE,
630 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
631
632 // Create framebuffer using the first render pass
633 const VkFramebufferCreateInfo framebufferCreateInfo =
634 {
635 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
636 DE_NULL, // const void* pNext;
637 (VkFramebufferCreateFlags)0u, // VkFramebufferCreateFlags flags;
638 renderPassA.get(), // VkRenderPass renderPass;
639 1u, // deUint32 attachmentCount;
640 &attachmentImageView.get(), // const VkImageView* pAttachments;
641 256u, // deUint32 width;
642 256u, // deUint32 height;
643 1u // deUint32 layers;
644 };
645
646 const Unique<VkFramebuffer> frameBuffer (createFramebuffer(vk, device, &framebufferCreateInfo));
647
648 const Unique<VkRenderPass> renderPassB (createSimpleRenderPass(vk, device, format,
649 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
650 VK_ATTACHMENT_LOAD_OP_LOAD,
651 VK_ATTACHMENT_STORE_OP_STORE,
652 VK_IMAGE_LAYOUT_GENERAL));
653
654 beginRenderPass(vk, commandBuffer.get(), renderPassB.get(), frameBuffer.get(), makeRect2D(0, 0, 0u, 0u));
655 endRenderPass(vk, commandBuffer.get());
656
657 VK_CHECK(vk.endCommandBuffer(commandBuffer.get()));
658
659 const VkSubmitInfo submitInfo =
660 {
661 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
662 DE_NULL, // const void* pNext;
663 0u, // deUint32 waitSemaphoreCount;
664 DE_NULL, // const VkSemaphore* pWaitSemaphores;
665 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
666 1u, // deUint32 commandBufferCount;
667 &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
668 0u, // deUint32 signalSemaphoreCount;
669 DE_NULL // const VkSemaphore* pSignalSemaphores;
670 };
671
672 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
673 VK_CHECK(vk.queueWaitIdle(queue));
674
675 // Test should always pass
676 return tcu::TestStatus::pass("Pass");
677 }
678
getDescriptorSetLayout(const DeviceInterface & vk,const VkDevice & device,deUint32 bindingCount,const VkDescriptorSetLayoutBinding * layoutBindings)679 Move<VkDescriptorSetLayout> getDescriptorSetLayout (const DeviceInterface& vk, const VkDevice& device, deUint32 bindingCount, const VkDescriptorSetLayoutBinding* layoutBindings)
680 {
681 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
682 {
683 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
684 DE_NULL, // const void* pNext;
685 (VkDescriptorSetLayoutCreateFlags)0u, // VkDescriptorSetLayoutCreateFlags flags;
686 bindingCount, // deUint32 bindingCount;
687 layoutBindings // const VkDescriptorSetLayoutBinding* pBindings;
688 };
689
690 return createDescriptorSetLayout(vk, device, &descriptorSetLayoutCreateInfo);
691 }
692
getDescriptorSet(const DeviceInterface & vk,const VkDevice & device,VkDescriptorPool descriptorPool,VkDescriptorSetLayout setLayout)693 VkDescriptorSet getDescriptorSet (const DeviceInterface& vk, const VkDevice& device, VkDescriptorPool descriptorPool, VkDescriptorSetLayout setLayout)
694 {
695 const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo =
696 {
697 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
698 DE_NULL, // const void* pNext;
699 descriptorPool, // VkDescriptorPool descriptorPool;
700 1u, // deUint32 descriptorSetCount;
701 &setLayout // const VkDescriptorSetLayout* pSetLayouts;
702 };
703
704 VkDescriptorSet descriptorSet;
705 VK_CHECK(vk.allocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet));
706
707 return descriptorSet;
708 }
709
getPipelineLayout(const DeviceInterface & vk,const VkDevice & device,deUint32 setLayoutCount,const VkDescriptorSetLayout * setLayouts)710 Move<VkPipelineLayout> getPipelineLayout (const DeviceInterface& vk, const VkDevice& device, deUint32 setLayoutCount, const VkDescriptorSetLayout* setLayouts)
711 {
712 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
713 {
714 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
715 DE_NULL, // const void* pNext;
716 (VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
717 setLayoutCount, // deUint32 setLayoutCount;
718 setLayouts, // const VkDescriptorSetLayout* pSetLayouts;
719 0u, // deUint32 pushConstantRangeCount;
720 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
721 };
722
723 return createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
724 }
725
createSimpleGraphicsPipeline(const DeviceInterface & vk,const VkDevice & device,deUint32 numShaderStages,const VkPipelineShaderStageCreateInfo * shaderStageCreateInfos,VkPipelineLayout pipelineLayout,VkRenderPass renderPass,de::SharedPtr<vk::ResourceInterface> resourceInterface)726 Move<VkPipeline> createSimpleGraphicsPipeline (const DeviceInterface& vk, const VkDevice& device, deUint32 numShaderStages, const VkPipelineShaderStageCreateInfo* shaderStageCreateInfos, VkPipelineLayout pipelineLayout, VkRenderPass renderPass, de::SharedPtr<vk::ResourceInterface> resourceInterface)
727 {
728 #ifndef CTS_USES_VULKANSC
729 DE_UNREF(resourceInterface);
730 #endif // CTS_USES_VULKANSC
731 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
732 {
733 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
734 DE_NULL, // const void* pNext;
735 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
736 0u, // deUint32 vertexBindingDescriptionCount;
737 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
738 0u, // deUint32 vertexAttributeDescriptionCount;
739 DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
740 };
741
742 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
743 {
744 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
745 DE_NULL, // const void* pNext;
746 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
747 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology;
748 VK_FALSE // VkBool32 primitiveRestartEnable;
749 };
750
751 const VkPipelineViewportStateCreateInfo viewPortStateCreateInfo =
752 {
753 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
754 DE_NULL, // const void* pNext;
755 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
756 1, // deUint32 viewportCount;
757 DE_NULL, // const VkViewport* pViewports;
758 1, // deUint32 scissorCount;
759 DE_NULL // const VkRect2D* pScissors;
760 };
761
762 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
763 {
764 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
765 DE_NULL, // const void* pNext;
766 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
767 VK_FALSE, // VkBool32 depthClampEnable;
768 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
769 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
770 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
771 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
772 VK_FALSE, // VkBool32 depthBiasEnable;
773 0.0f, // float depthBiasConstantFactor;
774 0.0f, // float depthBiasClamp;
775 0.0f, // float depthBiasSlopeFactor;
776 1.0f // float lineWidth;
777 };
778
779 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
780 {
781 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
782 DE_NULL, // const void* pNext;
783 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
784 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
785 VK_FALSE, // VkBool32 sampleShadingEnable;
786 0.0f, // float minSampleShading;
787 DE_NULL, // const VkSampleMask* pSampleMask;
788 VK_FALSE, // VkBool32 alphaToCoverageEnable;
789 VK_FALSE // VkBool32 alphaToOneEnable;
790 };
791
792 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
793 {
794 VK_FALSE, // VkBool32 blendEnable;
795 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
796 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
797 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
798 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
799 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
800 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
801 (VkColorComponentFlags)0xFu // VkColorComponentFlags colorWriteMask;
802 };
803
804 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
805 {
806 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
807 DE_NULL, // const void* pNext;
808 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
809 DE_FALSE, // VkBool32 logicOpEnable;
810 VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp;
811 1, // deUint32 attachmentCount;
812 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
813 { 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4];
814 };
815
816 const VkDynamicState dynamicStates[] =
817 {
818 VK_DYNAMIC_STATE_VIEWPORT,
819 VK_DYNAMIC_STATE_SCISSOR
820 };
821
822 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
823 {
824 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
825 DE_NULL, // const void* pNext;
826 (VkPipelineDynamicStateCreateFlags)0u, // VkPipelineDynamicStateCreateFlags flags;
827 DE_LENGTH_OF_ARRAY(dynamicStates), // deUint32 dynamicStateCount;
828 dynamicStates // const VkDynamicState* pDynamicStates;
829 };
830
831 const VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo =
832 {
833 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
834 DE_NULL, // const void* pNext;
835 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
836 numShaderStages, // deUint32 stageCount;
837 shaderStageCreateInfos, // const VkPipelineShaderStageCreateInfo* pStages;
838 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
839 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
840 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
841 &viewPortStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
842 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
843 &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
844 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
845 &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
846 &dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
847 pipelineLayout, // VkPipelineLayout layout;
848 renderPass, // VkRenderPass renderPass;
849 0u, // deUint32 subpass;
850 DE_NULL, // VkPipeline basePipelineHandle;
851 0 // int basePipelineIndex;
852 };
853
854 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
855 {
856 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
857 DE_NULL, // const void* pNext;
858 #ifndef CTS_USES_VULKANSC
859 (VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
860 0, // size_t initialDataSize;
861 DE_NULL // const void* pInitialData;
862 #else
863 VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT |
864 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT, // VkPipelineCacheCreateFlags flags;
865 resourceInterface->getCacheDataSize(), // deUintptr initialDataSize;
866 resourceInterface->getCacheData() // const void* pInitialData;
867 #endif // CTS_USES_VULKANSC
868 };
869
870 const Unique<VkPipelineCache> pipelineCache (createPipelineCache(vk, device, &pipelineCacheCreateInfo));
871
872 return createGraphicsPipeline(vk, device, pipelineCache.get(), &graphicsPipelineCreateInfo);
873 }
874
pipelineLayoutLifetimeTest(Context & context,VkPipelineBindPoint bindPoint)875 tcu::TestStatus pipelineLayoutLifetimeTest (Context& context, VkPipelineBindPoint bindPoint)
876 {
877 const DeviceInterface& vk = context.getDeviceInterface();
878 const InstanceInterface& vki = context.getInstanceInterface();
879 const VkDevice device = context.getDevice();
880 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
881 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
882 const bool isGraphics = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS);
883
884 const VkCommandPoolCreateInfo commandPoolParams =
885 {
886 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
887 DE_NULL, // const void* pNext;
888 (VkCommandPoolCreateFlags)0u, // VkCommandPoolCreateFlags flags;
889 queueFamilyIndex // deUint32 queueFamilyIndex;
890 };
891
892 const Unique<VkCommandPool> commandPool (createCommandPool(vk, device, &commandPoolParams, DE_NULL));
893 const Unique<VkCommandBuffer> commandBuffer (createCommandBuffer(vk, device, commandPool.get()));
894
895 // Begin command buffer.
896 {
897 const VkCommandBufferBeginInfo commandBufferBeginInfo =
898 {
899 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
900 DE_NULL, // const void* pNext;
901 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
902 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
903 };
904
905 VK_CHECK(vk.beginCommandBuffer(commandBuffer.get(), &commandBufferBeginInfo));
906 }
907
908 // These will only be used for graphics pipelines.
909 Move<VkImage> attachmentImage;
910 de::MovePtr<Allocation> attachmentImageMemory;
911 Move<VkImageView> attachmentImageView;
912 Move<VkRenderPass> renderPass;
913 Move<VkFramebuffer> frameBuffer;
914
915 if (isGraphics)
916 {
917 // Create image, render pass and framebuffer.
918 const VkFormat format = getRenderTargetFormat(vki, physicalDevice);
919 const VkFormatProperties formatProperties (getPhysicalDeviceFormatProperties(vki, physicalDevice, format));
920 const VkImageTiling imageTiling = (formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_LINEAR
921 : (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) ? VK_IMAGE_TILING_OPTIMAL
922 : VK_CORE_IMAGE_TILING_LAST;
923
924 const VkImageCreateInfo imageCreateInfo =
925 {
926 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
927 DE_NULL, // const void* pNext;
928 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
929 VK_IMAGE_TYPE_2D, // VkImageType imageType;
930 format, // VkFormat format;
931 {
932 256u, // deUint32 width;
933 256u, // deUint32 height;
934 1u // deUint32 depth;
935 }, // VkExtent3D extent;
936 1u, // deUint32 mipLevels;
937 1u, // deUint32 arrayLayers;
938 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
939 imageTiling, // VkImageTiling tiling;
940 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
941 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
942 0u, // deUint32 queueFamilyIndexCount;
943 DE_NULL, // const deUint32* pQueueFamilyIndices;
944 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
945 };
946
947 attachmentImage = createImage(vk, device, &imageCreateInfo);
948 attachmentImageMemory = context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, device, *attachmentImage), MemoryRequirement::Any);
949
950 VK_CHECK(vk.bindImageMemory(device, *attachmentImage, attachmentImageMemory->getMemory(), attachmentImageMemory->getOffset()));
951
952 changeColorAttachmentImageLayout(vk, commandBuffer.get(), attachmentImage.get());
953
954 const VkImageViewCreateInfo imageViewCreateInfo =
955 {
956 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
957 DE_NULL, // const void* pNext;
958 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
959 attachmentImage.get(), // VkImage image;
960 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
961 format, // VkFormat format;
962 {
963 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
964 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
965 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
966 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
967 }, // VkComponentMapping components;
968 {
969 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
970 0u, // deUint32 baseMipLevel;
971 1u, // deUint32 levelCount;
972 0u, // deUint32 baseArrayLayer;
973 1u // deUint32 layerCount;
974 } // VkImageSubresourceRange subresourceRange;
975 };
976
977 attachmentImageView = createImageView(vk, device, &imageViewCreateInfo);
978 renderPass = createSimpleRenderPass(vk, device, format,
979 VK_ATTACHMENT_LOAD_OP_CLEAR,
980 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
981 VK_ATTACHMENT_STORE_OP_DONT_CARE,
982 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
983
984 const VkFramebufferCreateInfo framebufferCreateInfo =
985 {
986 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
987 DE_NULL, // const void* pNext;
988 (VkFramebufferCreateFlags)0u, // VkFramebufferCreateFlags flags;
989 renderPass.get(), // VkRenderPass renderPass;
990 1u, // deUint32 attachmentCount;
991 &attachmentImageView.get(), // const VkImageView* pAttachments;
992 256u, // deUint32 width;
993 256u, // deUint32 height;
994 1u // deUint32 layers;
995 };
996
997 frameBuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
998 }
999
1000 const VkDescriptorPoolSize descriptorPoolSizes[] =
1001 {
1002 {
1003 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // VkDescriptorType type;
1004 10 // deUint32 descriptorCount;
1005 },
1006 {
1007 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // VkDescriptorType type;
1008 2 // deUint32 descriptorCount;
1009 },
1010 {
1011 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, // VkDescriptorType type;
1012 2 // deUint32 descriptorCount;
1013 }
1014 };
1015
1016 const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
1017 {
1018 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
1019 DE_NULL, // const void* pNext;
1020 (VkDescriptorPoolCreateFlags)0u, // VkDescriptorPoolCreateFlags flags;
1021 (isGraphics ? 3u : 5u), // deUint32 maxSets;
1022 DE_LENGTH_OF_ARRAY(descriptorPoolSizes), // deUint32 poolSizeCount;
1023 descriptorPoolSizes // const VkDescriptorPoolSize* pPoolSizes;
1024 };
1025
1026 Move<VkDescriptorPool> descriptorPool = createDescriptorPool(vk, device, &descriptorPoolCreateInfo, DE_NULL);
1027
1028 const VkDescriptorSetLayoutBinding setLayoutBindingA[] =
1029 {
1030 {
1031 0, // deUint32 binding;
1032 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // VkDescriptorType descriptorType;
1033 5, // deUint32 descriptorCount;
1034 VK_SHADER_STAGE_ALL, // VkShaderStageFlags stageFlags;
1035 DE_NULL // const VkSampler* pImmutableSamplers;
1036 }
1037 };
1038
1039 const VkShaderStageFlags shaderStage = (isGraphics ? VK_SHADER_STAGE_FRAGMENT_BIT : VK_SHADER_STAGE_COMPUTE_BIT);
1040
1041 const VkDescriptorSetLayoutBinding setLayoutBindingB[] =
1042 {
1043 {
1044 0, // deUint32 binding;
1045 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // VkDescriptorType descriptorType;
1046 5, // deUint32 descriptorCount;
1047 (VkShaderStageFlags)shaderStage, // VkShaderStageFlags stageFlags;
1048 DE_NULL // const VkSampler* pImmutableSamplers;
1049 }
1050 };
1051
1052 const VkDescriptorSetLayoutBinding setLayoutBindingC[] =
1053 {
1054 {
1055 0, // deUint32 binding;
1056 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // VkDescriptorType descriptorType;
1057 2, // deUint32 descriptorCount;
1058 VK_SHADER_STAGE_ALL, // VkShaderStageFlags stageFlags;
1059 DE_NULL // const VkSampler* pImmutableSamplers;
1060 },
1061 {
1062 1, // deUint32 binding;
1063 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, // VkDescriptorType descriptorType;
1064 2, // deUint32 descriptorCount;
1065 VK_SHADER_STAGE_ALL, // VkShaderStageFlags stageFlags;
1066 DE_NULL // const VkSampler* pImmutableSamplers;
1067 }
1068 };
1069
1070 const Move<VkDescriptorSetLayout> descriptorSetLayouts[] =
1071 {
1072 getDescriptorSetLayout(vk, device, DE_LENGTH_OF_ARRAY(setLayoutBindingA), setLayoutBindingA),
1073 getDescriptorSetLayout(vk, device, DE_LENGTH_OF_ARRAY(setLayoutBindingB), setLayoutBindingB),
1074 getDescriptorSetLayout(vk, device, DE_LENGTH_OF_ARRAY(setLayoutBindingC), setLayoutBindingC)
1075 };
1076
1077 const VkDescriptorSetLayout setLayoutHandlesAC[] =
1078 {
1079 descriptorSetLayouts[0].get(),
1080 descriptorSetLayouts[2].get()
1081 };
1082
1083 const VkDescriptorSetLayout setLayoutHandlesB[] =
1084 {
1085 descriptorSetLayouts[1].get()
1086 };
1087
1088 const VkDescriptorSetLayout setLayoutHandlesBC[] =
1089 {
1090 descriptorSetLayouts[1].get(),
1091 descriptorSetLayouts[2].get()
1092 };
1093
1094 const VkDescriptorSet descriptorSets[] =
1095 {
1096 getDescriptorSet(vk, device, descriptorPool.get(), descriptorSetLayouts[0].get()),
1097 getDescriptorSet(vk, device, descriptorPool.get(), descriptorSetLayouts[1].get()),
1098 getDescriptorSet(vk, device, descriptorPool.get(), descriptorSetLayouts[2].get())
1099 };
1100
1101 const VkDescriptorSet setHandlesAC[] =
1102 {
1103 descriptorSets[0],
1104 descriptorSets[2]
1105 };
1106
1107 const VkDescriptorSet setHandlesC[] =
1108 {
1109 descriptorSets[2]
1110 };
1111
1112 const Unique<VkPipelineLayout> pipelineLayoutAC (getPipelineLayout(vk, device, DE_LENGTH_OF_ARRAY(setLayoutHandlesAC), setLayoutHandlesAC));
1113 const Unique<VkPipelineLayout> pipelineLayoutBC (getPipelineLayout(vk, device, DE_LENGTH_OF_ARRAY(setLayoutHandlesBC), setLayoutHandlesBC));
1114
1115 VkPipelineLayout pipelineLayoutB;
1116 {
1117 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1118 {
1119 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1120 DE_NULL, // const void* pNext;
1121 (VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
1122 DE_LENGTH_OF_ARRAY(setLayoutHandlesB), // deUint32 setLayoutCount;
1123 setLayoutHandlesB, // const VkDescriptorSetLayout* pSetLayouts;
1124 0u, // deUint32 pushConstantRangeCount;
1125 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
1126 };
1127
1128 VK_CHECK(vk.createPipelineLayout(device, &pipelineLayoutCreateInfo, DE_NULL, &pipelineLayoutB));
1129 }
1130
1131 std::vector<Move<VkShaderModule>> shaderModules;
1132 Move<VkPipeline> pipeline;
1133
1134 if (isGraphics)
1135 {
1136 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("vertex"), 0));
1137 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("fragment"), 0));
1138
1139 const VkPipelineShaderStageCreateInfo shaderStageCreateInfos[] =
1140 {
1141 {
1142 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1143 DE_NULL, // const void* pNext;
1144 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1145 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1146 shaderModules[0].get(), // VkShaderModule shader;
1147 "main", // const char* pName;
1148 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1149 },
1150 {
1151 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1152 DE_NULL, // const void* pNext;
1153 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1154 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1155 shaderModules[1].get(), // VkShaderModule shader;
1156 "main", // const char* pName;
1157 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1158 }
1159 };
1160
1161 pipeline = createSimpleGraphicsPipeline(vk, device, DE_LENGTH_OF_ARRAY(shaderStageCreateInfos), shaderStageCreateInfos, pipelineLayoutB, renderPass.get(), context.getResourceInterface());
1162 }
1163 else
1164 {
1165 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("compute"), 0));
1166
1167 const VkPipelineShaderStageCreateInfo shaderStageCreateInfo =
1168 {
1169 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1170 DE_NULL, // const void* pNext;
1171 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1172 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1173 shaderModules[0].get(), // VkShaderModule shader;
1174 "main", // const char* pName;
1175 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1176 };
1177
1178 const VkComputePipelineCreateInfo computePipelineCreateInfo =
1179 {
1180 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1181 DE_NULL, // const void* pNext
1182 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags
1183 shaderStageCreateInfo, // VkPipelineShaderStageCreateInfo stage
1184 pipelineLayoutB, // VkPipelineLayout layout
1185 DE_NULL, // VkPipeline basePipelineHandle
1186 0 // int basePipelineIndex
1187 };
1188
1189 pipeline = createComputePipeline(vk, device, DE_NULL, &computePipelineCreateInfo);
1190 }
1191
1192 if (isGraphics)
1193 {
1194 beginRenderPass(vk, commandBuffer.get(), renderPass.get(), frameBuffer.get(), makeRect2D(0, 0, 256u, 256u), tcu::Vec4(0.25f, 0.25f, 0.25f, 0.0f));
1195 }
1196 vk.cmdBindPipeline(commandBuffer.get(), bindPoint, pipeline.get());
1197
1198 // Destroy the pipeline layout that was used to create the pipeline
1199 vk.destroyPipelineLayout(device, pipelineLayoutB, DE_NULL);
1200
1201 vk.cmdBindDescriptorSets(commandBuffer.get(), bindPoint, pipelineLayoutAC.get(), 0u, DE_LENGTH_OF_ARRAY(setHandlesAC), setHandlesAC, 0u, DE_NULL);
1202 vk.cmdBindDescriptorSets(commandBuffer.get(), bindPoint, pipelineLayoutBC.get(), 1u, DE_LENGTH_OF_ARRAY(setHandlesC), setHandlesC, 0u, DE_NULL);
1203
1204 if (isGraphics)
1205 {
1206 const VkViewport viewport =
1207 {
1208 0.0f, // float x;
1209 0.0f, // float y;
1210 16.0f, // float width;
1211 16.0f, // float height;
1212 0.0f, // float minDepth;
1213 1.0f // float maxDepth;
1214 };
1215
1216 const VkRect2D scissor =
1217 {
1218 { 0u, 0u }, // VkOffset2D offset;
1219 { 16u, 16u } // VkExtent2D extent;
1220 };
1221
1222 vk.cmdSetViewport(commandBuffer.get(), 0u, 1u, &viewport);
1223 vk.cmdSetScissor(commandBuffer.get(), 0u, 1u, &scissor);
1224 }
1225
1226 vk.cmdBindDescriptorSets(commandBuffer.get(), bindPoint, pipelineLayoutAC.get(), 0u, DE_LENGTH_OF_ARRAY(setHandlesAC), setHandlesAC, 0u, DE_NULL);
1227
1228 // Test should always pass
1229 return tcu::TestStatus::pass("Pass");
1230 }
1231
createPipelineLayoutLifetimeGraphicsSource(SourceCollections & dst)1232 void createPipelineLayoutLifetimeGraphicsSource (SourceCollections& dst)
1233 {
1234 dst.glslSources.add("vertex") << glu::VertexSource(
1235 "#version 450\n"
1236 "\n"
1237 "void main (void)\n"
1238 "{\n"
1239 " gl_Position = vec4(1);\n"
1240 "}\n");
1241
1242 dst.glslSources.add("fragment") << glu::FragmentSource(
1243 "#version 450\n"
1244 "\n"
1245 "layout(location=0) out vec4 x;\n"
1246 "layout(set=0) layout(binding=0) uniform foo { int x; int y; } bar;\n"
1247 "void main (void)\n"
1248 "{\n"
1249 " x = vec4(bar.y);\n"
1250 "}\n");
1251 }
1252
1253 // This test has the same functionality as VkLayerTest.DescriptorSetCompatibility
pipelineLayoutLifetimeGraphicsTest(Context & context)1254 tcu::TestStatus pipelineLayoutLifetimeGraphicsTest (Context& context)
1255 {
1256 return pipelineLayoutLifetimeTest(context, VK_PIPELINE_BIND_POINT_GRAPHICS);
1257 }
1258
createPipelineLayoutLifetimeComputeSource(SourceCollections & dst)1259 void createPipelineLayoutLifetimeComputeSource (SourceCollections& dst)
1260 {
1261 dst.glslSources.add("compute") << glu::ComputeSource(
1262 "#version 450\n"
1263 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
1264 "layout(set=0) layout(binding=0) uniform foo { int x; int y; } bar;\n"
1265 "void main (void)\n"
1266 "{\n"
1267 " vec4 x = vec4(bar.y);\n"
1268 "}\n");
1269 }
1270
pipelineLayoutLifetimeComputeTest(Context & context)1271 tcu::TestStatus pipelineLayoutLifetimeComputeTest (Context& context)
1272 {
1273 return pipelineLayoutLifetimeTest(context, VK_PIPELINE_BIND_POINT_COMPUTE);
1274 }
1275
checkSupport(Context & context)1276 void checkSupport (Context& context)
1277 {
1278 const InstanceInterface& vki = context.getInstanceInterface();
1279 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1280
1281 // Throws exception if not supported
1282 getRenderTargetFormat(vki, physicalDevice);
1283 }
1284
destroyEarlyComputeSource(SourceCollections & programs)1285 void destroyEarlyComputeSource(SourceCollections& programs)
1286 {
1287 std::string comp =
1288 "#version 450\n"
1289 "layout (local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
1290 "layout (constant_id=0) const uint flag = 0;\n"
1291 "layout (push_constant, std430) uniform PushConstants {\n"
1292 " uint base;\n"
1293 "};\n"
1294 "layout (set=0, binding=0, std430) buffer Block {\n"
1295 " uint data[];\n"
1296 "};\n"
1297 "\n"
1298 "void main() {\n"
1299 " if (flag != 0u) {\n"
1300 " uint idx = gl_GlobalInvocationID.x;\n"
1301 " data[idx] = data[idx] + base + idx;\n"
1302 " }\n"
1303 "}\n";
1304
1305 programs.glslSources.add("comp") << glu::ComputeSource(comp);
1306 }
1307
checkMaintenance4Support(Context & context)1308 void checkMaintenance4Support(Context& context)
1309 {
1310 context.requireDeviceFunctionality("VK_KHR_maintenance4");
1311 }
1312
1313 enum DestroyPipelineLayoutMode
1314 {
1315 DPLM_DESTROY_AFTER_END_COMMAND_BUFFER = 0,
1316 DPLM_DESTROY_AFTER_CREATE_COMPUTE_PIPELINES,
1317 };
1318
destroyEarlyTest(Context & context,DestroyPipelineLayoutMode mode)1319 tcu::TestStatus destroyEarlyTest (Context& context, DestroyPipelineLayoutMode mode)
1320 {
1321 const auto& vkd = context.getDeviceInterface();
1322 const auto device = context.getDevice();
1323 auto& alloc = context.getDefaultAllocator();
1324 const auto queue = context.getUniversalQueue();
1325 const auto qIndex = context.getUniversalQueueFamilyIndex();
1326
1327 const deUint32 kBufferElements = 100u;
1328 const deUint32 kBufferSize = kBufferElements * sizeof(deUint32);
1329 const auto kBufferSizeDS = static_cast<VkDeviceSize>(kBufferSize);
1330 const deUint32 kInitialValue = 50u;
1331 const deUint32 kFlagValue = 1u;
1332 const deUint32 kBaseValue = 75u;
1333
1334 // Allocate and prepare buffer.
1335 const auto bufferInfo = vk::makeBufferCreateInfo(kBufferSizeDS, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1336 vk::BufferWithMemory buffer (vkd, device, alloc, bufferInfo, vk::MemoryRequirement::HostVisible);
1337 auto& bufferAlloc = buffer.getAllocation();
1338 void* bufferPtr = bufferAlloc.getHostPtr();
1339 {
1340 const std::vector<deUint32> bufferValues (kBufferElements, kInitialValue);
1341 deMemcpy(bufferPtr, bufferValues.data(), kBufferSize);
1342 vk::flushAlloc(vkd, device, bufferAlloc);
1343 }
1344
1345 // Descriptor set layout.
1346 vk::DescriptorSetLayoutBuilder layoutBuilder;
1347 layoutBuilder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
1348 const auto descriptorSetLayout = layoutBuilder.build(vkd, device);
1349
1350 // Pipeline layout.
1351 const auto pushConstantRange = vk::makePushConstantRange(vk::VK_SHADER_STAGE_COMPUTE_BIT, 0u, static_cast<deUint32>(sizeof(kBaseValue)));
1352
1353 const vk::VkPipelineLayoutCreateInfo pipelineLayoutInfo =
1354 {
1355 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1356 nullptr, // const void* pNext;
1357 0u, // VkPipelineLayoutCreateFlags flags;
1358 1u, // deUint32 setLayoutCount;
1359 &descriptorSetLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
1360 1u, // deUint32 pushConstantRangeCount;
1361 &pushConstantRange, // const VkPushConstantRange* pPushConstantRanges;
1362 };
1363
1364 auto pipelineLayout = vk::createPipelineLayout(vkd, device, &pipelineLayoutInfo);
1365
1366 // Shader module.
1367 const auto shaderModule = vk::createShaderModule(vkd, device, context.getBinaryCollection().get("comp"), 0u);
1368
1369 // Pipeline, with shader and specialization info.
1370 const auto specConstantSize = static_cast<deUintptr>(sizeof(kFlagValue));
1371
1372 const vk::VkSpecializationMapEntry mapEntry =
1373 {
1374 0u, // deUint32 constantID;
1375 0u, // deUint32 offset;
1376 specConstantSize, // deUintptr size;
1377 };
1378
1379 const vk::VkSpecializationInfo specializationInfo =
1380 {
1381 1u, // deUint32 mapEntryCount;
1382 &mapEntry, // const VkSpecializationMapEntry* pMapEntries;
1383 specConstantSize, // deUintptr dataSize;
1384 &kFlagValue, // const void* pData;
1385 };
1386
1387 const VkPipelineShaderStageCreateInfo shaderInfo =
1388 {
1389 vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1390 nullptr, // const void* pNext;
1391 0u, // VkPipelineShaderStageCreateFlags flags;
1392 vk::VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1393 shaderModule.get(), // VkShaderModule module;
1394 "main", // const char* pName;
1395 &specializationInfo, // const VkSpecializationInfo* pSpecializationInfo;
1396 };
1397 const vk::VkComputePipelineCreateInfo pipelineInfo =
1398 {
1399 vk::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1400 nullptr, // const void* pNext;
1401 0u, // VkPipelineCreateFlags flags;
1402 shaderInfo, // VkPipelineShaderStageCreateInfo stage;
1403 pipelineLayout.get(), // VkPipelineLayout layout;
1404 DE_NULL, // VkPipeline basePipelineHandle;
1405 0, // deInt32 basePipelineIndex;
1406 };
1407
1408 const auto pipeline = vk::createComputePipeline(vkd, device, DE_NULL, &pipelineInfo);
1409
1410 // Delete pipeline layout just after creating pipeline - this is what the test is for
1411 if (DPLM_DESTROY_AFTER_CREATE_COMPUTE_PIPELINES == mode)
1412 pipelineLayout = decltype(pipelineLayout)();
1413
1414 // Descriptor set.
1415 vk::DescriptorPoolBuilder descriptorPoolBuilder;
1416 descriptorPoolBuilder.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
1417 const auto descriptorPool = descriptorPoolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
1418 const auto descriptorSet = vk::makeDescriptorSet(vkd, device, descriptorPool.get(), descriptorSetLayout.get());
1419
1420 // Update descriptor set with buffer.
1421 vk::DescriptorSetUpdateBuilder updateBuilder;
1422 const auto descriptorInfo = vk::makeDescriptorBufferInfo(buffer.get(), static_cast<VkDeviceSize>(0), kBufferSizeDS);
1423 updateBuilder.writeSingle(descriptorSet.get(), vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorInfo);
1424 updateBuilder.update(vkd, device);
1425
1426 // Prepare command buffer.
1427 const auto cmdPool = vk::makeCommandPool(vkd, device, qIndex);
1428 const auto cmdBufferPtr = vk::allocateCommandBuffer(vkd, device, cmdPool.get(), vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1429 const auto cmdBuffer = cmdBufferPtr.get();
1430 const auto barrier = vk::makeMemoryBarrier(vk::VK_ACCESS_SHADER_WRITE_BIT, vk::VK_ACCESS_HOST_READ_BIT);
1431
1432 // Create new pipeline layout that will be used during dispatch
1433 if (DPLM_DESTROY_AFTER_CREATE_COMPUTE_PIPELINES == mode)
1434 pipelineLayout = vk::createPipelineLayout(vkd, device, &pipelineLayoutInfo);
1435
1436 vk::beginCommandBuffer(vkd, cmdBuffer);
1437 vkd.cmdBindPipeline(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, pipeline.get());
1438 vkd.cmdBindDescriptorSets(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout.get(), 0u, 1u, &descriptorSet.get(), 0u, nullptr);
1439 vkd.cmdPushConstants(cmdBuffer, pipelineLayout.get(), vk::VK_SHADER_STAGE_COMPUTE_BIT, 0u, static_cast<deUint32>(sizeof(kBaseValue)), &kBaseValue);
1440 vkd.cmdDispatch(cmdBuffer, kBufferElements, 1u, 1u);
1441 vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u, 1u, &barrier, 0u, nullptr, 0u, nullptr);
1442 vk::endCommandBuffer(vkd, cmdBuffer);
1443
1444 // Delete pipeline layout just after recording command buffer - this is what the test is for
1445 if (DPLM_DESTROY_AFTER_END_COMMAND_BUFFER == mode)
1446 pipelineLayout = decltype(pipelineLayout)();
1447
1448 // Submit commands.
1449 vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
1450
1451 // Check buffer.
1452 vk::invalidateAlloc(vkd, device, bufferAlloc);
1453 std::vector<deUint32> outputData (kBufferElements);
1454 deMemcpy(outputData.data(), bufferPtr, kBufferSize);
1455
1456 for (deUint32 i = 0; i < kBufferElements; ++i)
1457 {
1458 // This matches what the shader should calculate.
1459 const auto expectedValue = kInitialValue + kBaseValue + i;
1460 if (outputData[i] != expectedValue)
1461 {
1462 std::ostringstream msg;
1463 msg << "Unexpected value at buffer position " << i << ": expected " << expectedValue << " but found " << outputData[i];
1464 return tcu::TestStatus::fail(msg.str());
1465 }
1466 }
1467
1468 return tcu::TestStatus::pass("Pass");
1469 }
1470
destroyAfterEndCommndBufferTest(Context & context)1471 tcu::TestStatus destroyAfterEndCommndBufferTest(Context& context)
1472 {
1473 return destroyEarlyTest(context, DPLM_DESTROY_AFTER_END_COMMAND_BUFFER);
1474 }
1475
destroyAfterCreateComputePipelineTest(Context & context)1476 tcu::TestStatus destroyAfterCreateComputePipelineTest(Context& context)
1477 {
1478 return destroyEarlyTest(context, DPLM_DESTROY_AFTER_CREATE_COMPUTE_PIPELINES);
1479 }
1480
destroyAfterCreateGraphicsPipelineTest(Context & context)1481 tcu::TestStatus destroyAfterCreateGraphicsPipelineTest(Context& context)
1482 {
1483 return drawTriangleTest(context, DTM_DESTROY_PIPELINE_LAYOUT_AFTER_CREATING_PIPELINE);
1484 }
1485
1486 #ifndef CTS_USES_VULKANSC
1487
createSimpleGraphicsPipelineInvalidPointers(const DeviceInterface & vk,const VkDevice & device,deUint32 numShaderStages,const VkPipelineShaderStageCreateInfo * shaderStageCreateInfos,VkPipelineLayout pipelineLayout,VkRenderPass renderPass,de::SharedPtr<vk::ResourceInterface> resourceInterface)1488 Move<VkPipeline> createSimpleGraphicsPipelineInvalidPointers (const DeviceInterface& vk, const VkDevice& device, deUint32 numShaderStages, const VkPipelineShaderStageCreateInfo* shaderStageCreateInfos, VkPipelineLayout pipelineLayout, VkRenderPass renderPass, de::SharedPtr<vk::ResourceInterface> resourceInterface)
1489 {
1490 #ifndef CTS_USES_VULKANSC
1491 DE_UNREF(resourceInterface);
1492 #endif // CTS_USES_VULKANSC
1493
1494 const void *invalidPointer = reinterpret_cast<void*>(~(0));
1495
1496 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
1497 {
1498 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1499 DE_NULL, // const void* pNext;
1500 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1501 0u, // deUint32 vertexBindingDescriptionCount;
1502 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1503 0u, // deUint32 vertexAttributeDescriptionCount;
1504 (const VkVertexInputAttributeDescription*)invalidPointer // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1505 };
1506
1507 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
1508 {
1509 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1510 DE_NULL, // const void* pNext;
1511 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1512 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology;
1513 VK_FALSE // VkBool32 primitiveRestartEnable;
1514 };
1515
1516 // Disable rasterization to test unused structs
1517 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
1518 {
1519 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1520 DE_NULL, // const void* pNext;
1521 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1522 VK_FALSE, // VkBool32 depthClampEnable;
1523 VK_TRUE, // VkBool32 rasterizerDiscardEnable;
1524 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1525 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
1526 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
1527 VK_FALSE, // VkBool32 depthBiasEnable;
1528 0.0f, // float depthBiasConstantFactor;
1529 0.0f, // float depthBiasClamp;
1530 0.0f, // float depthBiasSlopeFactor;
1531 1.0f // float lineWidth;
1532 };
1533
1534 const VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo =
1535 {
1536 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1537 DE_NULL, // const void* pNext;
1538 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1539 numShaderStages, // deUint32 stageCount;
1540 shaderStageCreateInfos, // const VkPipelineShaderStageCreateInfo* pStages;
1541 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1542 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1543 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1544 (const VkPipelineViewportStateCreateInfo*)invalidPointer, // const VkPipelineViewportStateCreateInfo* pViewportState;
1545 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1546 (const VkPipelineMultisampleStateCreateInfo*)invalidPointer, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1547 (const VkPipelineDepthStencilStateCreateInfo*)invalidPointer, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1548 (const VkPipelineColorBlendStateCreateInfo*)invalidPointer, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1549 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1550 pipelineLayout, // VkPipelineLayout layout;
1551 renderPass, // VkRenderPass renderPass;
1552 0u, // deUint32 subpass;
1553 DE_NULL, // VkPipeline basePipelineHandle;
1554 0 // int basePipelineIndex;
1555 };
1556
1557 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
1558 {
1559 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
1560 DE_NULL, // const void* pNext;
1561 #ifndef CTS_USES_VULKANSC
1562 (VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
1563 0, // size_t initialDataSize;
1564 DE_NULL // const void* pInitialData;
1565 #else
1566 VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT |
1567 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT, // VkPipelineCacheCreateFlags flags;
1568 resourceInterface->getCacheDataSize(), // deUintptr initialDataSize;
1569 invalidPointer // const void* pInitialData;
1570 #endif // CTS_USES_VULKANSC
1571 };
1572
1573 const Unique<VkPipelineCache> pipelineCache (createPipelineCache(vk, device, &pipelineCacheCreateInfo));
1574
1575 return createGraphicsPipeline(vk, device, pipelineCache.get(), &graphicsPipelineCreateInfo);
1576 }
1577
pipelineInvalidPointersUnusedStructsTest(Context & context,VkPipelineBindPoint bindPoint)1578 tcu::TestStatus pipelineInvalidPointersUnusedStructsTest (Context& context, VkPipelineBindPoint bindPoint)
1579 {
1580 const DeviceInterface& vk = context.getDeviceInterface();
1581 const VkDevice device = context.getDevice();
1582 const VkQueue queue = context.getUniversalQueue();
1583 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1584 const bool isGraphics = (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS);
1585 const void *invalidPointer = reinterpret_cast<void*>(~(0));
1586
1587 const VkCommandPoolCreateInfo commandPoolParams =
1588 {
1589 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
1590 DE_NULL, // const void* pNext;
1591 (VkCommandPoolCreateFlags)0u, // VkCommandPoolCreateFlags flags;
1592 queueFamilyIndex // deUint32 queueFamilyIndex;
1593 };
1594
1595 const Unique<VkCommandPool> commandPool (createCommandPool(vk, device, &commandPoolParams, DE_NULL));
1596 const Unique<VkCommandBuffer> commandBuffer (createCommandBuffer(vk, device, commandPool.get()));
1597
1598 // Begin command buffer.
1599 {
1600 const VkCommandBufferBeginInfo commandBufferBeginInfo =
1601 {
1602 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1603 DE_NULL, // const void* pNext;
1604 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1605 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
1606 };
1607
1608 VK_CHECK(vk.beginCommandBuffer(commandBuffer.get(), &commandBufferBeginInfo));
1609 }
1610
1611 // These will only be used for graphics pipelines.
1612 Move<VkRenderPass> renderPass;
1613 Move<VkFramebuffer> frameBuffer;
1614
1615 {
1616 const VkSubpassDescription subpassDescription =
1617 {
1618 (VkSubpassDescriptionFlags)0u, // VkSubpassDescriptionFlags flags;
1619 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
1620 0u, // deUint32 inputAttachmentCount
1621 (const VkAttachmentReference*)invalidPointer, // const VkAttachmentReference* pInputAttachments
1622 0u, // deUint32 colorAttachmentCount
1623 (const VkAttachmentReference*)invalidPointer, // const VkAttachmentReference* pColorAttachments
1624 DE_NULL, // const VkAttachmentReference* pResolveAttachments
1625 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
1626 0u, // deUint32 preserveAttachmentCount
1627 (const deUint32*)invalidPointer // const deUint32* pPreserveAttachments
1628 };
1629
1630 const VkRenderPassCreateInfo renderPassCreateInfo =
1631 {
1632 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
1633 DE_NULL, // const void* pNext;
1634 (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags;
1635 0u, // deUint32 attachmentCount
1636 (const VkAttachmentDescription*)invalidPointer, // const VkAttachmentDescription* pAttachments
1637 1u, // deUint32 subpassCount
1638 &subpassDescription, // const VkSubpassDescription* pSubpasses
1639 0u, // deUint32 dependencyCount
1640 (const VkSubpassDependency*)invalidPointer // const VkSubpassDependency* pDependencies
1641 };
1642 renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
1643
1644 const VkFramebufferCreateInfo framebufferCreateInfo =
1645 {
1646 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1647 DE_NULL, // const void* pNext;
1648 (VkFramebufferCreateFlags)0u, // VkFramebufferCreateFlags flags;
1649 renderPass.get(), // VkRenderPass renderPass;
1650 0u, // deUint32 attachmentCount;
1651 (const VkImageView*)invalidPointer, // const VkImageView* pAttachments;
1652 256u, // deUint32 width;
1653 256u, // deUint32 height;
1654 1u // deUint32 layers;
1655 };
1656
1657 frameBuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
1658 }
1659
1660 Move<VkPipelineLayout> pipelineLayout;
1661 {
1662 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1663 {
1664 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1665 DE_NULL, // const void* pNext;
1666 (VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
1667 0u, // deUint32 setLayoutCount;
1668 (const VkDescriptorSetLayout*)invalidPointer, // const VkDescriptorSetLayout* pSetLayouts;
1669 0u, // deUint32 pushConstantRangeCount;
1670 (const VkPushConstantRange*)invalidPointer // const VkPushConstantRange* pPushConstantRanges;
1671 };
1672
1673 pipelineLayout = vk::createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
1674 }
1675
1676 std::vector<Move<VkShaderModule>> shaderModules;
1677 Move<VkPipeline> pipeline;
1678
1679 if (isGraphics)
1680 {
1681 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("vertex"), 0));
1682 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("fragment"), 0));
1683
1684 const VkPipelineShaderStageCreateInfo shaderStageCreateInfos[] =
1685 {
1686 {
1687 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1688 DE_NULL, // const void* pNext;
1689 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1690 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1691 shaderModules[0].get(), // VkShaderModule shader;
1692 "main", // const char* pName;
1693 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1694 },
1695 {
1696 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1697 DE_NULL, // const void* pNext;
1698 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1699 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1700 shaderModules[1].get(), // VkShaderModule shader;
1701 "main", // const char* pName;
1702 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1703 }
1704 };
1705
1706 pipeline = createSimpleGraphicsPipelineInvalidPointers(vk, device, DE_LENGTH_OF_ARRAY(shaderStageCreateInfos), shaderStageCreateInfos, *pipelineLayout, renderPass.get(), context.getResourceInterface());
1707 }
1708 else
1709 {
1710 shaderModules.push_back(createShaderModule(vk, device, context.getBinaryCollection().get("compute"), 0));
1711
1712 const VkPipelineShaderStageCreateInfo shaderStageCreateInfo =
1713 {
1714 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1715 DE_NULL, // const void* pNext;
1716 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1717 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1718 shaderModules[0].get(), // VkShaderModule shader;
1719 "main", // const char* pName;
1720 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1721 };
1722
1723 const VkComputePipelineCreateInfo computePipelineCreateInfo =
1724 {
1725 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1726 DE_NULL, // const void* pNext
1727 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags
1728 shaderStageCreateInfo, // VkPipelineShaderStageCreateInfo stage
1729 *pipelineLayout, // VkPipelineLayout layout
1730 DE_NULL, // VkPipeline basePipelineHandle
1731 0 // int basePipelineIndex
1732 };
1733
1734 pipeline = createComputePipeline(vk, device, DE_NULL, &computePipelineCreateInfo);
1735 }
1736
1737 if (isGraphics)
1738 {
1739 beginRenderPass(vk, commandBuffer.get(), renderPass.get(), frameBuffer.get(), makeRect2D(0, 0, 256u, 256u), tcu::Vec4(0.25f, 0.25f, 0.25f, 0.0f));
1740 }
1741 vk.cmdBindPipeline(commandBuffer.get(), bindPoint, pipeline.get());
1742
1743 if (isGraphics)
1744 {
1745 vk.cmdDraw(commandBuffer.get(), 1u, 1u, 0u, 0u);
1746 vk.cmdEndRenderPass(commandBuffer.get());
1747 }
1748 else
1749 {
1750 vk.cmdDispatch(commandBuffer.get(), 1u, 1u, 1u);
1751 }
1752 vk.endCommandBuffer(commandBuffer.get());
1753
1754 const VkSubmitInfo submitInfo =
1755 {
1756 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
1757 DE_NULL, // const void* pNext;
1758 0u, // deUint32 waitSemaphoreCount;
1759 DE_NULL, // const VkSemaphore* pWaitSemaphores;
1760 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
1761 1u, // deUint32 commandBufferCount;
1762 &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
1763 0u, // deUint32 signalSemaphoreCount;
1764 DE_NULL // const VkSemaphore* pSignalSemaphores;
1765 };
1766
1767 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
1768 VK_CHECK(vk.queueWaitIdle(queue));
1769
1770 // Test should always pass
1771 return tcu::TestStatus::pass("Pass");
1772 }
1773
createPipelineInvalidPointersUnusedStructsGraphicsSource(SourceCollections & dst)1774 void createPipelineInvalidPointersUnusedStructsGraphicsSource (SourceCollections& dst)
1775 {
1776 dst.glslSources.add("vertex") << glu::VertexSource(
1777 "#version 450\n"
1778 "\n"
1779 "void main (void)\n"
1780 "{\n"
1781 " gl_Position = vec4(1.0f);\n"
1782 "}\n");
1783
1784 dst.glslSources.add("fragment") << glu::FragmentSource(
1785 "#version 450\n"
1786 "\n"
1787 "void main (void)\n"
1788 "{\n"
1789 "}\n");
1790 }
1791
pipelineInvalidPointersUnusedStructsGraphicsTest(Context & context)1792 tcu::TestStatus pipelineInvalidPointersUnusedStructsGraphicsTest (Context& context)
1793 {
1794 return pipelineInvalidPointersUnusedStructsTest(context, VK_PIPELINE_BIND_POINT_GRAPHICS);
1795 }
1796
createPipelineInvalidPointersUnusedStructsComputeSource(SourceCollections & dst)1797 void createPipelineInvalidPointersUnusedStructsComputeSource (SourceCollections& dst)
1798 {
1799 dst.glslSources.add("compute") << glu::ComputeSource(
1800 "#version 450\n"
1801 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
1802 "void main (void)\n"
1803 "{\n"
1804 "}\n");
1805 }
1806
pipelineInvalidPointersUnusedStructsComputeTest(Context & context)1807 tcu::TestStatus pipelineInvalidPointersUnusedStructsComputeTest (Context& context)
1808 {
1809 return pipelineInvalidPointersUnusedStructsTest(context, VK_PIPELINE_BIND_POINT_COMPUTE);
1810 }
1811
1812 #endif // CTS_USES_VULKANSC
1813
createrenderpassTests(tcu::TestContext & testCtx)1814 tcu::TestCaseGroup* createrenderpassTests (tcu::TestContext& testCtx)
1815 {
1816 de::MovePtr<tcu::TestCaseGroup> renderPassTests(new tcu::TestCaseGroup(testCtx, "renderpass", "Renderpass tests"));
1817
1818 addFunctionCaseWithPrograms(renderPassTests.get(), "destroy_pipeline_renderpass", "Draw after destroying the renderpass used to create a pipeline", checkSupport, createDrawTriangleSource, renderpassLifetimeTest);
1819 addFunctionCase(renderPassTests.get(), "framebuffer_compatible_renderpass", "Use a render pass with a framebuffer that was created using another compatible render pass", checkSupport, framebufferCompatibleRenderPassTest);
1820
1821 return renderPassTests.release();
1822 }
1823
createPipelineLayoutLifetimeTests(tcu::TestContext & testCtx)1824 tcu::TestCaseGroup* createPipelineLayoutLifetimeTests (tcu::TestContext& testCtx)
1825 {
1826 de::MovePtr<tcu::TestCaseGroup> pipelineLayoutLifetimeTests(new tcu::TestCaseGroup(testCtx, "lifetime", "Pipeline layout lifetime tests"));
1827
1828 addFunctionCaseWithPrograms(pipelineLayoutLifetimeTests.get(), "graphics", "Test pipeline layout lifetime in graphics pipeline", checkSupport, createPipelineLayoutLifetimeGraphicsSource, pipelineLayoutLifetimeGraphicsTest);
1829 addFunctionCaseWithPrograms(pipelineLayoutLifetimeTests.get(), "compute", "Test pipeline layout lifetime in compute pipeline", checkSupport, createPipelineLayoutLifetimeComputeSource, pipelineLayoutLifetimeComputeTest);
1830 addFunctionCaseWithPrograms(pipelineLayoutLifetimeTests.get(), "destroy_after_end", "Test destroying the pipeline layout after vkEndCommandBuffer", destroyEarlyComputeSource, destroyAfterEndCommndBufferTest);
1831 addFunctionCaseWithPrograms(pipelineLayoutLifetimeTests.get(), "destroy_after_compute_pipeline_construction", "Test destroying the pipeline layout after compute pipeline creation", checkMaintenance4Support, destroyEarlyComputeSource, destroyAfterCreateComputePipelineTest);
1832 addFunctionCaseWithPrograms(pipelineLayoutLifetimeTests.get(), "destroy_after_graphics_pipeline_construction", "Test destroying the pipeline layout after graphics pipeline creation", checkMaintenance4Support, createDrawTriangleSource, destroyAfterCreateGraphicsPipelineTest);
1833
1834 return pipelineLayoutLifetimeTests.release();
1835 }
1836
createPipelineLayoutTests(tcu::TestContext & testCtx)1837 tcu::TestCaseGroup* createPipelineLayoutTests (tcu::TestContext& testCtx)
1838 {
1839 de::MovePtr<tcu::TestCaseGroup> pipelineLayoutTests(new tcu::TestCaseGroup(testCtx, "pipeline_layout", "Pipeline layout tests"));
1840
1841 pipelineLayoutTests->addChild(createPipelineLayoutLifetimeTests(testCtx));
1842
1843 return pipelineLayoutTests.release();
1844 }
1845
1846 #ifndef CTS_USES_VULKANSC
createPipelineInvalidPointersUnusedStructsTests(tcu::TestContext & testCtx)1847 tcu::TestCaseGroup* createPipelineInvalidPointersUnusedStructsTests (tcu::TestContext& testCtx)
1848 {
1849 de::MovePtr<tcu::TestCaseGroup> pipelineInvalidPointersUnusedStructsTests(new tcu::TestCaseGroup(testCtx, "pipeline_invalid_pointers_unused_structs", "Create pipelines with invalid pointers for unused structs"));
1850
1851 addFunctionCaseWithPrograms(pipelineInvalidPointersUnusedStructsTests.get(), "graphics", "Test structs when creating a graphics pipeline", checkSupport, createPipelineInvalidPointersUnusedStructsGraphicsSource, pipelineInvalidPointersUnusedStructsGraphicsTest);
1852 addFunctionCaseWithPrograms(pipelineInvalidPointersUnusedStructsTests.get(), "compute", "Test structs when creating a compute pipeline", checkSupport, createPipelineInvalidPointersUnusedStructsComputeSource, pipelineInvalidPointersUnusedStructsComputeTest);
1853
1854 return pipelineInvalidPointersUnusedStructsTests.release();
1855 }
1856 #endif // CTS_USES_VULKANSC
1857
1858 } // anonymous
1859
createPipelineTests(tcu::TestContext & testCtx)1860 tcu::TestCaseGroup* createPipelineTests (tcu::TestContext& testCtx)
1861 {
1862 de::MovePtr<tcu::TestCaseGroup> pipelineTests(new tcu::TestCaseGroup(testCtx, "pipeline", "Pipeline tests"));
1863
1864 pipelineTests->addChild(createrenderpassTests(testCtx));
1865 pipelineTests->addChild(createPipelineLayoutTests(testCtx));
1866 #ifndef CTS_USES_VULKANSC
1867 pipelineTests->addChild(createPipelineInvalidPointersUnusedStructsTests(testCtx));
1868 #endif // CTS_USES_VULKANSC
1869
1870 return pipelineTests.release();
1871 }
1872
1873 } // api
1874 } // vkt
1875