1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2021 The Khronos Group Inc.
6 *
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
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
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.
18 *
19 *//*!
20 * \file
21 * \brief VkDeviceObjectReservationCreateInfo tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktDeviceObjectReservationTests.hpp"
25
26 #include <vector>
27 #include <string>
28
29 #include "tcuTestCase.hpp"
30
31 #include "vkDefs.hpp"
32 #include "vkDeviceUtil.hpp"
33 #include "vkQueryUtil.hpp"
34 #include "vkSafetyCriticalUtil.hpp"
35 #include "vkImageWithMemory.hpp"
36 #include "vkBufferWithMemory.hpp"
37 #include "vkObjUtil.hpp"
38
39 #include "vktTestCaseUtil.hpp"
40 #include "vktCustomInstancesDevices.hpp"
41
42 using namespace vk;
43
44 namespace vkt
45 {
46 namespace sc
47 {
48 namespace
49 {
50
51 enum TestMaxValues
52 {
53 TMV_UNDEFINED = 0,
54 TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT,
55 TMV_MAX_IMAGEVIEW_MIPLEVELS,
56 TMV_MAX_IMAGEVIEW_ARRAYLAYERS,
57 TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS,
58 TMV_MAX_OCCLUSION_QUERIES_PER_POOL,
59 TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL,
60 TMV_MAX_TIMESTAMP_QUERIES_PER_POOL
61 };
62
63 const uint32_t VERIFYMAXVALUES_OBJECT_COUNT = 5U;
64 const uint32_t VERIFYMAXVALUES_ARRAYLAYERS = 8U;
65 const uint32_t VERIFYMAXVALUES_MIPLEVELS = 5U;
66
67 enum TestRequestCounts
68 {
69 TRC_UNDEFINED = 0,
70 TRC_SEMAPHORE,
71 TRC_COMMAND_BUFFER,
72 TRC_FENCE,
73 TRC_DEVICE_MEMORY,
74 TRC_BUFFER,
75 TRC_IMAGE,
76 TRC_EVENT,
77 TRC_QUERY_POOL,
78 TRC_BUFFER_VIEW,
79 TRC_IMAGE_VIEW,
80 TRC_LAYERED_IMAGE_VIEW,
81 TRC_PIPELINE_LAYOUT,
82 TRC_RENDER_PASS,
83 TRC_GRAPHICS_PIPELINE,
84 TRC_COMPUTE_PIPELINE,
85 TRC_DESCRIPTORSET_LAYOUT,
86 TRC_SAMPLER,
87 TRC_DESCRIPTOR_POOL,
88 TRC_DESCRIPTORSET,
89 TRC_FRAMEBUFFER,
90 TRC_COMMANDPOOL,
91 TRC_SAMPLERYCBCRCONVERSION,
92 TRC_SURFACE,
93 TRC_SWAPCHAIN,
94 TRC_DISPLAY_MODE,
95 };
96
97 enum TestPoolSizes
98 {
99 PST_UNDEFINED = 0,
100 PST_NONE,
101 PST_ZERO,
102 PST_TOO_SMALL_SIZE,
103 PST_ONE_FITS,
104 PST_MULTIPLE_FIT,
105 };
106
107 struct TestParams
108 {
TestParamsvkt::sc::__anon093e97bb0111::TestParams109 TestParams(const TestMaxValues &testMaxValues_ = TMV_UNDEFINED,
110 const TestRequestCounts &testRequestCounts_ = TRC_UNDEFINED,
111 const TestPoolSizes &testPoolSizeType_ = PST_UNDEFINED)
112 : testMaxValues{testMaxValues_}
113 , testRequestCounts{testRequestCounts_}
114 , testPoolSizeType{testPoolSizeType_}
115 {
116 }
117 TestMaxValues testMaxValues;
118 TestRequestCounts testRequestCounts;
119 TestPoolSizes testPoolSizeType;
120 };
121
122 typedef de::SharedPtr<Unique<VkSemaphore>> SemaphoreSp;
123 typedef de::SharedPtr<Unique<VkCommandBuffer>> CommandBufferSp;
124 typedef de::SharedPtr<Unique<VkFence>> FenceSp;
125 typedef de::SharedPtr<Unique<VkDeviceMemory>> DeviceMemorySp;
126 typedef de::SharedPtr<Unique<VkBuffer>> BufferSp;
127 typedef de::SharedPtr<Unique<VkImage>> ImageSp;
128 typedef de::SharedPtr<Unique<VkEvent>> EventSp;
129 typedef de::SharedPtr<Unique<VkQueryPool>> QueryPoolSp;
130 typedef de::SharedPtr<Unique<VkBufferView>> BufferViewSp;
131 typedef de::SharedPtr<Unique<VkImageView>> ImageViewSp;
132 typedef de::SharedPtr<Unique<VkPipelineLayout>> PipelineLayoutSp;
133 typedef de::SharedPtr<Unique<VkRenderPass>> RenderPassSp;
134 typedef de::SharedPtr<Unique<VkPipeline>> PipelineSp;
135 typedef de::SharedPtr<Unique<VkDescriptorSetLayout>> DescriptorSetLayoutSp;
136 typedef de::SharedPtr<Unique<VkSampler>> SamplerSp;
137 typedef de::SharedPtr<Unique<VkDescriptorPool>> DescriptorPoolSp;
138 typedef de::SharedPtr<Unique<VkDescriptorSet>> DescriptorSetSp;
139 typedef de::SharedPtr<Unique<VkFramebuffer>> FramebufferSp;
140 typedef de::SharedPtr<Unique<VkCommandPool>> CommandPoolSp;
141 typedef de::SharedPtr<Unique<VkSamplerYcbcrConversion>> SamplerYcbcrConversionSp;
142 //typedef de::SharedPtr<Unique<VkSurfaceKHR>> SurfaceSp;
143 //typedef de::SharedPtr<Unique<VkSwapchainKHR>> SwapchainSp;
144 //typedef de::SharedPtr<Unique<VkDisplayModeKHR>> DisplayModeSp;
145 typedef de::SharedPtr<Unique<VkSubpassDescription>> SubpassDescriptionSp;
146 typedef de::SharedPtr<Unique<VkAttachmentDescription>> AttachmentDescriptionSp;
147
createSemaphores(const DeviceInterface & vkd,const VkDevice device,std::vector<SemaphoreSp>::iterator begin,std::vector<SemaphoreSp>::iterator end)148 void createSemaphores(const DeviceInterface &vkd, const VkDevice device, std::vector<SemaphoreSp>::iterator begin,
149 std::vector<SemaphoreSp>::iterator end)
150 {
151 for (std::vector<SemaphoreSp>::iterator it = begin; it != end; ++it)
152 *it = SemaphoreSp(new Unique<VkSemaphore>(createSemaphore(vkd, device)));
153 }
154
createCommandBuffers(const DeviceInterface & vkd,const VkDevice device,const VkCommandPool commandPool,std::vector<CommandBufferSp>::iterator begin,std::vector<CommandBufferSp>::iterator end)155 void createCommandBuffers(const DeviceInterface &vkd, const VkDevice device, const VkCommandPool commandPool,
156 std::vector<CommandBufferSp>::iterator begin, std::vector<CommandBufferSp>::iterator end)
157 {
158 for (std::vector<CommandBufferSp>::iterator it = begin; it != end; ++it)
159 {
160 const vk::VkCommandBufferAllocateInfo commandBufferAI = {
161 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
162 DE_NULL, // pNext
163 commandPool, // commandPool
164 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
165 1u // commandBufferCount
166 };
167 *it = CommandBufferSp(new Unique<VkCommandBuffer>(allocateCommandBuffer(vkd, device, &commandBufferAI)));
168 }
169 }
170
createFences(const DeviceInterface & vkd,const VkDevice device,std::vector<FenceSp>::iterator begin,std::vector<FenceSp>::iterator end)171 void createFences(const DeviceInterface &vkd, const VkDevice device, std::vector<FenceSp>::iterator begin,
172 std::vector<FenceSp>::iterator end)
173 {
174 for (std::vector<FenceSp>::iterator it = begin; it != end; ++it)
175 {
176 const VkFenceCreateInfo fenceCI = {
177 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType
178 DE_NULL, // const void* pNext
179 0u // VkFenceCreateFlags flags
180 };
181 *it = FenceSp(new Unique<VkFence>(createFence(vkd, device, &fenceCI)));
182 }
183 }
184
allocateDeviceMemory(const DeviceInterface & vkd,const VkDevice device,VkDeviceSize size,std::vector<DeviceMemorySp>::iterator begin,std::vector<DeviceMemorySp>::iterator end)185 void allocateDeviceMemory(const DeviceInterface &vkd, const VkDevice device, VkDeviceSize size,
186 std::vector<DeviceMemorySp>::iterator begin, std::vector<DeviceMemorySp>::iterator end)
187 {
188 for (std::vector<DeviceMemorySp>::iterator it = begin; it != end; ++it)
189 {
190 VkMemoryAllocateInfo alloc = {
191 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType
192 DE_NULL, // pNext
193 size, // allocationSize
194 0U // memoryTypeIndex;
195 };
196 *it = DeviceMemorySp(new Unique<VkDeviceMemory>(allocateMemory(vkd, device, &alloc)));
197 }
198 }
199
createBuffers(const DeviceInterface & vkd,const VkDevice device,VkDeviceSize size,std::vector<BufferSp>::iterator begin,std::vector<BufferSp>::iterator end)200 void createBuffers(const DeviceInterface &vkd, const VkDevice device, VkDeviceSize size,
201 std::vector<BufferSp>::iterator begin, std::vector<BufferSp>::iterator end)
202 {
203 uint32_t queueFamilyIndex = 0u;
204 for (std::vector<BufferSp>::iterator it = begin; it != end; ++it)
205 {
206 const VkBufferCreateInfo bufferCI = {
207 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
208 DE_NULL, // pNext
209 0u, // flags
210 size, // size
211 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, // usage
212 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
213 1u, // queueFamilyIndexCount
214 &queueFamilyIndex, // pQueueFamilyIndices
215 };
216 *it = BufferSp(new Unique<VkBuffer>(createBuffer(vkd, device, &bufferCI)));
217 }
218 }
219
createImages(const DeviceInterface & vkd,const VkDevice device,uint32_t size,std::vector<ImageSp>::iterator begin,std::vector<ImageSp>::iterator end)220 void createImages(const DeviceInterface &vkd, const VkDevice device, uint32_t size,
221 std::vector<ImageSp>::iterator begin, std::vector<ImageSp>::iterator end)
222 {
223 uint32_t queueFamilyIndex = 0u;
224 for (std::vector<ImageSp>::iterator it = begin; it != end; ++it)
225 {
226 const VkImageCreateInfo imageCI = {
227 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType
228 DE_NULL, // const void* pNext
229 (VkImageCreateFlags)0u, // VkImageCreateFlags flags
230 VK_IMAGE_TYPE_2D, // VkImageType imageType
231 VK_FORMAT_R8_UNORM, // VkFormat format
232 {
233 size, // uint32_t width
234 size, // uint32_t height
235 1u // uint32_t depth
236 }, // VkExtent3D extent
237 1u, // uint32_t mipLevels
238 1u, // uint32_t arrayLayers
239 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
240 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling
241 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage
242 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
243 1u, // uint32_t queueFamilyIndexCount
244 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices
245 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout
246 };
247 *it = ImageSp(new Unique<VkImage>(createImage(vkd, device, &imageCI)));
248 }
249 }
250
createEvents(const DeviceInterface & vkd,const VkDevice device,std::vector<EventSp>::iterator begin,std::vector<EventSp>::iterator end)251 void createEvents(const DeviceInterface &vkd, const VkDevice device, std::vector<EventSp>::iterator begin,
252 std::vector<EventSp>::iterator end)
253 {
254 for (std::vector<EventSp>::iterator it = begin; it != end; ++it)
255 *it = EventSp(new Unique<VkEvent>(createEvent(vkd, device)));
256 }
257
createQueryPools(const DeviceInterface & vkd,const VkDevice device,std::vector<QueryPoolSp>::iterator begin,std::vector<QueryPoolSp>::iterator end)258 void createQueryPools(const DeviceInterface &vkd, const VkDevice device, std::vector<QueryPoolSp>::iterator begin,
259 std::vector<QueryPoolSp>::iterator end)
260 {
261 for (std::vector<QueryPoolSp>::iterator it = begin; it != end; ++it)
262 {
263 const VkQueryPoolCreateInfo queryPoolCI = {
264 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType
265 DE_NULL, // const void* pNext
266 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags
267 VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType
268 1u, // uint32_t queryCount
269 0u, // VkQueryPipelineStatisticFlags pipelineStatistics
270 };
271 *it = QueryPoolSp(new Unique<VkQueryPool>(createQueryPool(vkd, device, &queryPoolCI)));
272 }
273 }
274
createBufferViews(const DeviceInterface & vkd,const VkDevice device,const VkBuffer buffer,const VkDeviceSize size,std::vector<BufferViewSp>::iterator begin,std::vector<BufferViewSp>::iterator end)275 void createBufferViews(const DeviceInterface &vkd, const VkDevice device, const VkBuffer buffer,
276 const VkDeviceSize size, std::vector<BufferViewSp>::iterator begin,
277 std::vector<BufferViewSp>::iterator end)
278 {
279 for (std::vector<BufferViewSp>::iterator it = begin; it != end; ++it)
280 {
281 const VkBufferViewCreateInfo bufferViewCI = {
282 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType
283 DE_NULL, // const void* pNext
284 0u, // VkBufferViewCreateFlags flags
285 buffer, // VkBuffer buffer
286 VK_FORMAT_R8_UNORM, // VkFormat format
287 0ull, // VkDeviceSize offset
288 size // VkDeviceSize range
289 };
290 *it = BufferViewSp(new Unique<VkBufferView>(createBufferView(vkd, device, &bufferViewCI)));
291 }
292 }
293
createImageViews(const DeviceInterface & vkd,const VkDevice device,const VkImage image,const VkFormat format,std::vector<ImageViewSp>::iterator begin,std::vector<ImageViewSp>::iterator end)294 void createImageViews(const DeviceInterface &vkd, const VkDevice device, const VkImage image, const VkFormat format,
295 std::vector<ImageViewSp>::iterator begin, std::vector<ImageViewSp>::iterator end)
296 {
297 for (std::vector<ImageViewSp>::iterator it = begin; it != end; ++it)
298 {
299 VkComponentMapping componentMapping{VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
300 VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
301 VkImageViewCreateInfo imageViewCI = {
302 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType
303 DE_NULL, // const void* pNext
304 0u, // VkImageViewCreateFlags flags
305 image, // VkImage image
306 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType
307 format, // VkFormat format
308 componentMapping, // VkComponentMapping components
309 {VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u}, // VkImageSubresourceRange subresourceRange
310 };
311 *it = ImageViewSp(new Unique<VkImageView>(createImageView(vkd, device, &imageViewCI)));
312 }
313 }
314
createPipelineLayouts(const DeviceInterface & vkd,const VkDevice device,std::vector<PipelineLayoutSp>::iterator begin,std::vector<PipelineLayoutSp>::iterator end)315 void createPipelineLayouts(const DeviceInterface &vkd, const VkDevice device,
316 std::vector<PipelineLayoutSp>::iterator begin, std::vector<PipelineLayoutSp>::iterator end)
317 {
318 for (std::vector<PipelineLayoutSp>::iterator it = begin; it != end; ++it)
319 {
320 const VkPipelineLayoutCreateInfo pipelineLayoutCI = {
321 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
322 DE_NULL, // const void* pNext
323 0u, // VkPipelineLayoutCreateFlags flags
324 0u, // uint32_t setLayoutCount
325 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts
326 0u, // uint32_t pushConstantRangeCount
327 DE_NULL // const VkPushConstantRange* pPushConstantRanges
328 };
329 *it = PipelineLayoutSp(new Unique<VkPipelineLayout>(createPipelineLayout(vkd, device, &pipelineLayoutCI)));
330 }
331 }
332
createRenderPasses(const DeviceInterface & vkd,const VkDevice device,VkAttachmentDescription * colorAttachment,std::vector<RenderPassSp>::iterator begin,std::vector<RenderPassSp>::iterator end)333 void createRenderPasses(const DeviceInterface &vkd, const VkDevice device, VkAttachmentDescription *colorAttachment,
334 std::vector<RenderPassSp>::iterator begin, std::vector<RenderPassSp>::iterator end)
335 {
336 for (std::vector<RenderPassSp>::iterator it = begin; it != end; ++it)
337 {
338 const VkAttachmentReference colorAttachmentRef = {
339 0u, // uint32_t attachment
340 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout
341 };
342
343 const VkSubpassDescription subpassDescription = {
344 0u, // VkSubpassDescriptionFlags flags
345 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
346 0u, // uint32_t inputAttachmentCount
347 DE_NULL, // const VkAttachmentReference* pInputAttachments
348 1u, // uint32_t colorAttachmentCount
349 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments
350 DE_NULL, // const VkAttachmentReference* pResolveAttachments
351 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
352 0u, // uint32_t preserveAttachmentCount
353 DE_NULL // const uint32_t* pPreserveAttachments
354 };
355
356 const VkRenderPassCreateInfo renderPassCI = {
357 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType
358 DE_NULL, // const void* pNext
359 0u, // VkRenderPassCreateFlags flags
360 1u, // uint32_t attachmentCount
361 colorAttachment, // const VkAttachmentDescription* pAttachments
362 1u, // uint32_t subpassCount
363 &subpassDescription, // const VkSubpassDescription* pSubpasses
364 0u, // uint32_t dependencyCount
365 DE_NULL // const VkSubpassDependency* pDependencies
366 };
367 *it = RenderPassSp(new Unique<VkRenderPass>(createRenderPass(vkd, device, &renderPassCI)));
368 }
369 }
370
createGraphicsPipelines(const DeviceInterface & vkd,const VkDevice device,VkShaderModule vertexShaderModule,VkShaderModule fragmentShaderModule,VkRenderPass renderPass,VkPipelineLayout pipelineLayout,VkDeviceSize poolEntrySize,de::SharedPtr<vk::ResourceInterface> resourceInterface,std::vector<PipelineSp>::iterator begin,std::vector<PipelineSp>::iterator end)371 void createGraphicsPipelines(const DeviceInterface &vkd, const VkDevice device, VkShaderModule vertexShaderModule,
372 VkShaderModule fragmentShaderModule, VkRenderPass renderPass,
373 VkPipelineLayout pipelineLayout, VkDeviceSize poolEntrySize,
374 de::SharedPtr<vk::ResourceInterface> resourceInterface,
375 std::vector<PipelineSp>::iterator begin, std::vector<PipelineSp>::iterator end)
376 {
377 std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos;
378 shaderStageCreateInfos.push_back({
379 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
380 DE_NULL, // const void* pNext;
381 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
382 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
383 vertexShaderModule, // VkShaderModule shader;
384 "main", // const char* pName;
385 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
386 });
387
388 shaderStageCreateInfos.push_back({
389 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
390 DE_NULL, // const void* pNext;
391 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
392 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
393 fragmentShaderModule, // VkShaderModule shader;
394 "main", // const char* pName;
395 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
396 });
397
398 for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
399 {
400 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo = {
401 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
402 DE_NULL, // const void* pNext;
403 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
404 0u, // uint32_t vertexBindingDescriptionCount;
405 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
406 0u, // uint32_t vertexAttributeDescriptionCount;
407 DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
408 };
409
410 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo = {
411 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
412 DE_NULL, // const void* pNext;
413 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
414 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology;
415 VK_FALSE // VkBool32 primitiveRestartEnable;
416 };
417
418 const VkPipelineViewportStateCreateInfo viewPortStateCreateInfo = {
419 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
420 DE_NULL, // const void* pNext;
421 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
422 1, // uint32_t viewportCount;
423 DE_NULL, // const VkViewport* pViewports;
424 1, // uint32_t scissorCount;
425 DE_NULL // const VkRect2D* pScissors;
426 };
427
428 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo = {
429 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
430 DE_NULL, // const void* pNext;
431 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
432 VK_FALSE, // VkBool32 depthClampEnable;
433 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
434 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
435 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
436 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
437 VK_FALSE, // VkBool32 depthBiasEnable;
438 0.0f, // float depthBiasConstantFactor;
439 0.0f, // float depthBiasClamp;
440 0.0f, // float depthBiasSlopeFactor;
441 1.0f // float lineWidth;
442 };
443
444 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo = {
445 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
446 DE_NULL, // const void* pNext;
447 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
448 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
449 VK_FALSE, // VkBool32 sampleShadingEnable;
450 0.0f, // float minSampleShading;
451 DE_NULL, // const VkSampleMask* pSampleMask;
452 VK_FALSE, // VkBool32 alphaToCoverageEnable;
453 VK_FALSE // VkBool32 alphaToOneEnable;
454 };
455
456 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = {
457 VK_FALSE, // VkBool32 blendEnable;
458 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
459 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
460 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
461 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
462 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
463 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
464 (VkColorComponentFlags)0xFu // VkColorComponentFlags colorWriteMask;
465 };
466
467 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo = {
468 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
469 DE_NULL, // const void* pNext;
470 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
471 false, // VkBool32 logicOpEnable;
472 VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp;
473 1, // uint32_t attachmentCount;
474 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
475 {1.0f, 1.0f, 1.0f, 1.0f} // float blendConstants[4];
476 };
477
478 const VkDynamicState dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
479
480 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo = {
481 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
482 DE_NULL, // const void* pNext;
483 (VkPipelineDynamicStateCreateFlags)0u, // VkPipelineDynamicStateCreateFlags flags;
484 DE_LENGTH_OF_ARRAY(dynamicStates), // uint32_t dynamicStateCount;
485 dynamicStates // const VkDynamicState* pDynamicStates;
486 };
487
488 VkGraphicsPipelineCreateInfo graphicsPipelineCI = {
489 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
490 DE_NULL, // const void* pNext;
491 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
492 uint32_t(shaderStageCreateInfos.size()), // uint32_t stageCount;
493 shaderStageCreateInfos.data(), // const VkPipelineShaderStageCreateInfo* pStages;
494 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
495 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
496 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
497 &viewPortStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
498 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
499 &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
500 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
501 &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
502 &dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
503 pipelineLayout, // VkPipelineLayout layout;
504 renderPass, // VkRenderPass renderPass;
505 0u, // uint32_t subpass;
506 DE_NULL, // VkPipeline basePipelineHandle;
507 0 // int basePipelineIndex;
508 };
509
510 // we have to ensure that proper poolEntrySize is used
511 VkPipelineOfflineCreateInfo pipelineOfflineCreateInfo;
512 if (poolEntrySize != 0u)
513 {
514 pipelineOfflineCreateInfo = resetPipelineOfflineCreateInfo();
515 std::size_t hashValue =
516 calculateGraphicsPipelineHash(graphicsPipelineCI, resourceInterface->getObjectHashes());
517 memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
518 pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
519 graphicsPipelineCI.pNext = &pipelineOfflineCreateInfo;
520 }
521
522 *it = PipelineSp(
523 new Unique<VkPipeline>(createGraphicsPipeline(vkd, device, (VkPipelineCache)0u, &graphicsPipelineCI)));
524 }
525 }
526
createComputePipelines(const DeviceInterface & vkd,const VkDevice device,VkShaderModule shaderModule,VkPipelineLayout pipelineLayout,VkDeviceSize poolEntrySize,de::SharedPtr<vk::ResourceInterface> resourceInterface,std::vector<PipelineSp>::iterator begin,std::vector<PipelineSp>::iterator end)527 void createComputePipelines(const DeviceInterface &vkd, const VkDevice device, VkShaderModule shaderModule,
528 VkPipelineLayout pipelineLayout, VkDeviceSize poolEntrySize,
529 de::SharedPtr<vk::ResourceInterface> resourceInterface,
530 std::vector<PipelineSp>::iterator begin, std::vector<PipelineSp>::iterator end)
531 {
532 for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
533 {
534 VkPipelineShaderStageCreateInfo shaderStageCreateInfo = {
535 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
536 DE_NULL, // const void* pNext;
537 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
538 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
539 shaderModule, // VkShaderModule shader;
540 "main", // const char* pName;
541 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
542 };
543
544 VkComputePipelineCreateInfo computePipelineCI = {
545 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType
546 DE_NULL, // const void* pNext
547 0u, // VkPipelineCreateFlags flags
548 shaderStageCreateInfo, // VkPipelineShaderStageCreateInfo stage
549 pipelineLayout, // VkPipelineLayout layout
550 (vk::VkPipeline)0, // VkPipeline basePipelineHandle
551 0u, // int32_t basePipelineIndex
552 };
553
554 // we have to ensure that proper poolEntrySize is used
555 VkPipelineOfflineCreateInfo pipelineOfflineCreateInfo;
556 if (poolEntrySize != 0u)
557 {
558 pipelineOfflineCreateInfo = resetPipelineOfflineCreateInfo();
559 std::size_t hashValue =
560 calculateComputePipelineHash(computePipelineCI, resourceInterface->getObjectHashes());
561 memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
562 pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
563 computePipelineCI.pNext = &pipelineOfflineCreateInfo;
564 }
565
566 *it = PipelineSp(
567 new Unique<VkPipeline>(createComputePipeline(vkd, device, (VkPipelineCache)0u, &computePipelineCI)));
568 }
569 }
570
createDescriptorSetLayouts(const DeviceInterface & vkd,const VkDevice device,std::vector<DescriptorSetLayoutSp>::iterator begin,std::vector<DescriptorSetLayoutSp>::iterator end)571 void createDescriptorSetLayouts(const DeviceInterface &vkd, const VkDevice device,
572 std::vector<DescriptorSetLayoutSp>::iterator begin,
573 std::vector<DescriptorSetLayoutSp>::iterator end)
574 {
575 for (std::vector<DescriptorSetLayoutSp>::iterator it = begin; it != end; ++it)
576 {
577 const VkDescriptorSetLayoutBinding descriptorSetLayoutBinding = {
578 0, // binding
579 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // descriptorType
580 1u, // descriptorCount
581 VK_SHADER_STAGE_ALL, // stageFlags
582 NULL // pImmutableSamplers
583 };
584
585 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI = {
586 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
587 NULL, // pNext
588 (VkDescriptorSetLayoutCreateFlags)0u, // flags
589 1u, // bindingCount
590 &descriptorSetLayoutBinding // pBindings
591 };
592 *it = DescriptorSetLayoutSp(
593 new Unique<VkDescriptorSetLayout>(createDescriptorSetLayout(vkd, device, &descriptorSetLayoutCI)));
594 }
595 }
596
createSamplers(const DeviceInterface & vkd,const VkDevice device,std::vector<SamplerSp>::iterator begin,std::vector<SamplerSp>::iterator end)597 void createSamplers(const DeviceInterface &vkd, const VkDevice device, std::vector<SamplerSp>::iterator begin,
598 std::vector<SamplerSp>::iterator end)
599 {
600 for (std::vector<SamplerSp>::iterator it = begin; it != end; ++it)
601 {
602 const VkSamplerCreateInfo samplerCI = {
603 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, //VkStructureType sType
604 DE_NULL, //const void* pNext
605 0u, //VkSamplerCreateFlags flags
606 VK_FILTER_NEAREST, //VkFilter magFilter
607 VK_FILTER_NEAREST, //VkFilter minFilter
608 VK_SAMPLER_MIPMAP_MODE_NEAREST, //VkSamplerMipmapMode mipmapMode
609 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeU
610 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeV
611 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeW
612 0.0f, //float mipLodBias
613 VK_FALSE, //VkBool32 anisotropyEnable
614 1.0f, //float maxAnisotropy
615 VK_FALSE, //VkBool32 compareEnable
616 VK_COMPARE_OP_EQUAL, //VkCompareOp compareOp
617 0.0f, //float minLod
618 0.0f, //float maxLod
619 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, //VkBorderColor borderColor
620 VK_TRUE, //VkBool32 unnormalizedCoordinates
621 };
622 *it = SamplerSp(new Unique<VkSampler>(createSampler(vkd, device, &samplerCI)));
623 }
624 }
625
createDescriptorPools(const DeviceInterface & vkd,const VkDevice device,uint32_t maxSets,std::vector<DescriptorPoolSp>::iterator begin,std::vector<DescriptorPoolSp>::iterator end)626 void createDescriptorPools(const DeviceInterface &vkd, const VkDevice device, uint32_t maxSets,
627 std::vector<DescriptorPoolSp>::iterator begin, std::vector<DescriptorPoolSp>::iterator end)
628 {
629 for (std::vector<DescriptorPoolSp>::iterator it = begin; it != end; ++it)
630 {
631 const VkDescriptorPoolSize poolSizes = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u};
632 const VkDescriptorPoolCreateInfo descriptorPoolCI = {
633 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // sType
634 DE_NULL, // pNext
635 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, // flags
636 maxSets, // maxSets
637 1u, // poolSizeCount
638 &poolSizes, // pPoolSizes
639 };
640 *it = DescriptorPoolSp(new Unique<VkDescriptorPool>(createDescriptorPool(vkd, device, &descriptorPoolCI)));
641 }
642 }
643
createDescriptorSets(const DeviceInterface & vkd,const VkDevice device,const VkDescriptorPool descriptorPool,const VkDescriptorSetLayout setLayout,std::vector<DescriptorSetSp>::iterator begin,std::vector<DescriptorSetSp>::iterator end)644 void createDescriptorSets(const DeviceInterface &vkd, const VkDevice device, const VkDescriptorPool descriptorPool,
645 const VkDescriptorSetLayout setLayout, std::vector<DescriptorSetSp>::iterator begin,
646 std::vector<DescriptorSetSp>::iterator end)
647 {
648 for (std::vector<DescriptorSetSp>::iterator it = begin; it != end; ++it)
649 {
650 const VkDescriptorSetAllocateInfo descriptorSetAI = {
651 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType
652 DE_NULL, // const void* pNext
653 descriptorPool, // VkDescriptorPool descriptorPool
654 1u, // uint32_t descriptorSetCount
655 &setLayout // const VkDescriptorSetLayout* pSetLayouts
656 };
657 *it = DescriptorSetSp(new Unique<VkDescriptorSet>(allocateDescriptorSet(vkd, device, &descriptorSetAI)));
658 }
659 }
660
createFramebuffers(const DeviceInterface & vkd,const VkDevice device,const VkRenderPass renderPass,const VkImageView imageView,std::vector<FramebufferSp>::iterator begin,std::vector<FramebufferSp>::iterator end)661 void createFramebuffers(const DeviceInterface &vkd, const VkDevice device, const VkRenderPass renderPass,
662 const VkImageView imageView, std::vector<FramebufferSp>::iterator begin,
663 std::vector<FramebufferSp>::iterator end)
664 {
665 for (std::vector<FramebufferSp>::iterator it = begin; it != end; ++it)
666 {
667 const VkFramebufferCreateInfo framebufferCi = {
668 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType
669 DE_NULL, // const void* pNext
670 0u, // VkFramebufferCreateFlags flags
671 renderPass, // VkRenderPass renderPass
672 1u, // uint32_t attachmentCount
673 &imageView, // const VkImageView* pAttachments
674 8u, // uint32_t width
675 8u, // uint32_t height
676 1u // uint32_t layers
677 };
678
679 *it = FramebufferSp(new Unique<VkFramebuffer>(createFramebuffer(vkd, device, &framebufferCi)));
680 }
681 }
682
createCommandPools(const DeviceInterface & vkd,const VkDevice device,std::vector<CommandPoolSp>::iterator begin,std::vector<CommandPoolSp>::iterator end)683 void createCommandPools(const DeviceInterface &vkd, const VkDevice device, std::vector<CommandPoolSp>::iterator begin,
684 std::vector<CommandPoolSp>::iterator end)
685 {
686 for (std::vector<CommandPoolSp>::iterator it = begin; it != end; ++it)
687 {
688 const VkCommandPoolCreateInfo commandPoolCI = {
689 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
690 DE_NULL, // pNext
691 0u, // flags
692 0u, // queueFamilyIndex
693 };
694 *it = CommandPoolSp(new Unique<VkCommandPool>(createCommandPool(vkd, device, &commandPoolCI)));
695 }
696 }
697
createSamplerYcbcrConversions(const DeviceInterface & vkd,const VkDevice device,std::vector<SamplerYcbcrConversionSp>::iterator begin,std::vector<SamplerYcbcrConversionSp>::iterator end)698 void createSamplerYcbcrConversions(const DeviceInterface &vkd, const VkDevice device,
699 std::vector<SamplerYcbcrConversionSp>::iterator begin,
700 std::vector<SamplerYcbcrConversionSp>::iterator end)
701 {
702 for (std::vector<SamplerYcbcrConversionSp>::iterator it = begin; it != end; ++it)
703 {
704 const VkSamplerYcbcrConversionCreateInfo ycbcrConversionCI = {
705 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, // sType
706 DE_NULL, // pNext
707 VK_FORMAT_G8B8G8R8_422_UNORM, // format
708 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, // ycbcrModel
709 VK_SAMPLER_YCBCR_RANGE_ITU_FULL, // ycbcrRange
710 {
711 VK_COMPONENT_SWIZZLE_IDENTITY, // r
712 VK_COMPONENT_SWIZZLE_IDENTITY, // g
713 VK_COMPONENT_SWIZZLE_IDENTITY, // b
714 VK_COMPONENT_SWIZZLE_IDENTITY, // a
715 }, // components
716 VK_CHROMA_LOCATION_MIDPOINT, // xChromaOffset
717 VK_CHROMA_LOCATION_MIDPOINT, // yChromaOffset
718 VK_FILTER_NEAREST, // chromaFilter
719 VK_FALSE, // forceExplicitReconstruction
720 };
721 *it = SamplerYcbcrConversionSp(
722 new Unique<VkSamplerYcbcrConversion>(createSamplerYcbcrConversion(vkd, device, &ycbcrConversionCI)));
723 }
724 }
725
726 // Base class for all VkDeviceObjectReservationCreateInfo tests.
727 // Creates a device with 0 for all "max" values / and "RequestCounts"
728 class DeviceObjectReservationInstance : public vkt::TestInstance
729 {
730 public:
731 DeviceObjectReservationInstance(Context &context, const TestParams &testParams_);
732 tcu::TestStatus iterate(void) override;
733
734 virtual Move<VkDevice> createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
735 VkDeviceObjectReservationCreateInfo &objectInfo,
736 VkPhysicalDeviceVulkanSC10Features &sc10Features);
737 virtual void performTest(const DeviceInterface &vkd, VkDevice device);
738 virtual bool verifyTestResults(const DeviceInterface &vkd, VkDevice device);
739
740 protected:
741 TestParams testParams;
742 vkt::CustomInstance instance;
743 VkPhysicalDevice physicalDevice;
744 };
745
DeviceObjectReservationInstance(Context & context,const TestParams & testParams_)746 DeviceObjectReservationInstance::DeviceObjectReservationInstance(Context &context, const TestParams &testParams_)
747 : vkt::TestInstance(context)
748 , testParams(testParams_)
749 , instance(vkt::createCustomInstanceFromContext(context))
750 , physicalDevice(chooseDevice(instance.getDriver(), instance, context.getTestContext().getCommandLine()))
751 {
752 }
753
iterate(void)754 tcu::TestStatus DeviceObjectReservationInstance::iterate(void)
755 {
756 const float queuePriority = 1.0f;
757
758 const VkDeviceQueueCreateInfo deviceQueueCI = {
759 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
760 DE_NULL, // pNext
761 (VkDeviceQueueCreateFlags)0u, // flags
762 0, //queueFamilyIndex;
763 1, //queueCount;
764 &queuePriority, //pQueuePriorities;
765 };
766
767 VkDeviceCreateInfo deviceCreateInfo = {
768 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType;
769 DE_NULL, // pNext;
770 (VkDeviceCreateFlags)0u, // flags
771 1, // queueRecordCount;
772 &deviceQueueCI, // pRequestedQueues;
773 0, // layerCount;
774 DE_NULL, // ppEnabledLayerNames;
775 0, // extensionCount;
776 DE_NULL, // ppEnabledExtensionNames;
777 DE_NULL, // pEnabledFeatures;
778 };
779
780 void *pNext = DE_NULL;
781
782 VkDeviceObjectReservationCreateInfo objectInfo = resetDeviceObjectReservationCreateInfo();
783 objectInfo.pipelineCacheRequestCount = 1u;
784 objectInfo.pNext = pNext;
785 pNext = &objectInfo;
786
787 VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
788 sc10Features.pNext = pNext;
789 pNext = &sc10Features;
790
791 deviceCreateInfo.pNext = pNext;
792
793 Move<VkDevice> device = createTestDevice(deviceCreateInfo, objectInfo, sc10Features);
794 de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter> deviceDriver = de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter>(
795 new DeviceDriverSC(m_context.getPlatformInterface(), instance, *device,
796 m_context.getTestContext().getCommandLine(), m_context.getResourceInterface(),
797 m_context.getDeviceVulkanSC10Properties(), m_context.getDeviceProperties(),
798 m_context.getUsedApiVersion()),
799 DeinitDeviceDeleter(m_context.getResourceInterface().get(), *device));
800
801 performTest(*deviceDriver, *device);
802
803 const VkQueue queue = getDeviceQueue(*deviceDriver, *device, 0, 0);
804 VK_CHECK(deviceDriver->queueWaitIdle(queue));
805
806 if (!verifyTestResults(*deviceDriver, *device))
807 return tcu::TestStatus::fail("Failed");
808 return tcu::TestStatus::pass("Pass");
809 }
810
createTestDevice(VkDeviceCreateInfo & deviceCreateInfo,VkDeviceObjectReservationCreateInfo & objectInfo,VkPhysicalDeviceVulkanSC10Features & sc10Features)811 Move<VkDevice> DeviceObjectReservationInstance::createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
812 VkDeviceObjectReservationCreateInfo &objectInfo,
813 VkPhysicalDeviceVulkanSC10Features &sc10Features)
814 {
815 DE_UNREF(sc10Features);
816
817 // perform any non pipeline operations - create 2 semaphores
818 objectInfo.semaphoreRequestCount = 2u;
819
820 return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(),
821 m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice,
822 &deviceCreateInfo);
823 }
824
performTest(const DeviceInterface & vkd,VkDevice device)825 void DeviceObjectReservationInstance::performTest(const DeviceInterface &vkd, VkDevice device)
826 {
827 std::vector<SemaphoreSp> semaphores(2u);
828 createSemaphores(vkd, device, begin(semaphores), end(semaphores));
829 }
830
verifyTestResults(const DeviceInterface & vkd,VkDevice device)831 bool DeviceObjectReservationInstance::verifyTestResults(const DeviceInterface &vkd, VkDevice device)
832 {
833 DE_UNREF(vkd);
834 DE_UNREF(device);
835 return true;
836 }
837
838 // Creates device with multiple VkDeviceObjectReservationCreateInfo and ensures that the limits of an individual VkDeviceObjectReservationCreateInfo can be exceeded.
839 class MultipleReservation : public DeviceObjectReservationInstance
840 {
841 public:
MultipleReservation(Context & context,const TestParams & testParams_)842 MultipleReservation(Context &context, const TestParams &testParams_)
843 : DeviceObjectReservationInstance(context, testParams_)
844 {
845 }
createTestDevice(VkDeviceCreateInfo & deviceCreateInfo,VkDeviceObjectReservationCreateInfo & objectInfo,VkPhysicalDeviceVulkanSC10Features & sc10Features)846 Move<VkDevice> createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
847 VkDeviceObjectReservationCreateInfo &objectInfo,
848 VkPhysicalDeviceVulkanSC10Features &sc10Features) override
849 {
850 DE_UNREF(sc10Features);
851
852 VkDeviceObjectReservationCreateInfo thirdObjectInfo = resetDeviceObjectReservationCreateInfo();
853 thirdObjectInfo.deviceMemoryRequestCount = 2;
854
855 VkDeviceObjectReservationCreateInfo secondObjectInfo = resetDeviceObjectReservationCreateInfo();
856 secondObjectInfo.deviceMemoryRequestCount = 2;
857 secondObjectInfo.pNext = &thirdObjectInfo;
858
859 objectInfo.deviceMemoryRequestCount = 2;
860 objectInfo.pNext = &secondObjectInfo;
861
862 return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(),
863 m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice,
864 &deviceCreateInfo);
865 }
866
performTest(const DeviceInterface & vkd,VkDevice device)867 void performTest(const DeviceInterface &vkd, VkDevice device) override
868 {
869 std::vector<VkDeviceMemory> memoryObjects(6, (VkDeviceMemory)0);
870 for (size_t ndx = 0; ndx < 6; ndx++)
871 {
872 VkMemoryAllocateInfo alloc = {
873 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType
874 DE_NULL, // pNext
875 128U, // allocationSize
876 0U // memoryTypeIndex;
877 };
878
879 VK_CHECK(vkd.allocateMemory(device, &alloc, (const VkAllocationCallbacks *)DE_NULL, &memoryObjects[ndx]));
880
881 TCU_CHECK(!!memoryObjects[ndx]);
882 }
883 }
884 };
885
checkSupportVerifyMaxValues(vkt::Context & context,TestParams testParams)886 void checkSupportVerifyMaxValues(vkt::Context &context, TestParams testParams)
887 {
888 if (testParams.testMaxValues == TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL &&
889 context.getDeviceFeatures().pipelineStatisticsQuery == VK_FALSE)
890 TCU_THROW(NotSupportedError, "pipelineStatisticsQuery is not supported");
891 }
892
893 // For each of the various resource "max" values, create resources that exercise the maximum values requested
894
895 class VerifyMaxValues : public DeviceObjectReservationInstance
896 {
897 public:
VerifyMaxValues(Context & context,const TestParams & testParams_)898 VerifyMaxValues(Context &context, const TestParams &testParams_)
899 : DeviceObjectReservationInstance(context, testParams_)
900 {
901 }
createTestDevice(VkDeviceCreateInfo & deviceCreateInfo,VkDeviceObjectReservationCreateInfo & objectInfo,VkPhysicalDeviceVulkanSC10Features & sc10Features)902 Move<VkDevice> createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
903 VkDeviceObjectReservationCreateInfo &objectInfo,
904 VkPhysicalDeviceVulkanSC10Features &sc10Features) override
905 {
906 DE_UNREF(sc10Features);
907 switch (testParams.testMaxValues)
908 {
909 case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
910 objectInfo.descriptorSetLayoutBindingLimit = VERIFYMAXVALUES_OBJECT_COUNT + 1u;
911 objectInfo.descriptorSetLayoutBindingRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
912 objectInfo.descriptorSetLayoutRequestCount = 1u;
913 break;
914 case TMV_MAX_IMAGEVIEW_MIPLEVELS:
915 objectInfo.maxImageViewMipLevels = VERIFYMAXVALUES_MIPLEVELS;
916 objectInfo.maxImageViewArrayLayers = 1u;
917 objectInfo.imageRequestCount = 1u;
918 objectInfo.deviceMemoryRequestCount = 1u;
919 break;
920 case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
921 objectInfo.maxImageViewMipLevels = 1u;
922 objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
923 objectInfo.imageRequestCount = 1u;
924 objectInfo.deviceMemoryRequestCount = 1u;
925 break;
926 case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
927 objectInfo.maxLayeredImageViewMipLevels = VERIFYMAXVALUES_MIPLEVELS;
928 objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
929 objectInfo.imageRequestCount = 1u;
930 objectInfo.deviceMemoryRequestCount = 1u;
931 break;
932 case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
933 objectInfo.maxOcclusionQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
934 objectInfo.queryPoolRequestCount = 1u;
935 break;
936 case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
937 objectInfo.maxPipelineStatisticsQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
938 objectInfo.queryPoolRequestCount = 1u;
939 break;
940 case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
941 objectInfo.maxTimestampQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
942 objectInfo.queryPoolRequestCount = 1u;
943 break;
944 default:
945 TCU_THROW(InternalError, "Unsupported max value");
946 }
947
948 return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(),
949 m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice,
950 &deviceCreateInfo);
951 }
952
performTest(const DeviceInterface & vkd,VkDevice device)953 void performTest(const DeviceInterface &vkd, VkDevice device) override
954 {
955 SimpleAllocator allocator(vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
956 de::MovePtr<ImageWithMemory> image;
957 Move<VkQueryPool> queryPool;
958 Move<VkDescriptorSetLayout> descriptorSetLayout;
959 uint32_t queueFamilyIndex = 0u;
960
961 switch (testParams.testMaxValues)
962 {
963 case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
964 {
965 const VkDescriptorSetLayoutBinding binding = {
966 VERIFYMAXVALUES_OBJECT_COUNT, // binding
967 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
968 1u, // descriptorCount
969 VK_SHADER_STAGE_ALL, // stageFlags
970 DE_NULL, // pImmutableSamplers
971 };
972
973 const VkDescriptorSetLayoutCreateInfo layoutCreateInfo = {
974 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
975 DE_NULL, // pNext
976 0u, // flags
977 1u, // bindingCount
978 &binding, // pBindings
979 };
980 descriptorSetLayout = createDescriptorSetLayout(vkd, device, &layoutCreateInfo);
981 break;
982 }
983 case TMV_MAX_IMAGEVIEW_MIPLEVELS:
984 {
985 const VkImageCreateInfo imageCreateInfo = {
986 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
987 DE_NULL, // const void* pNext;
988 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
989 VK_IMAGE_TYPE_2D, // VkImageType imageType;
990 VK_FORMAT_R8_UNORM, // VkFormat format;
991 {
992 1 << VERIFYMAXVALUES_MIPLEVELS, // uint32_t width;
993 1 << VERIFYMAXVALUES_MIPLEVELS, // uint32_t height;
994 1u // uint32_t depth;
995 }, // VkExtent3D extent;
996 VERIFYMAXVALUES_MIPLEVELS, // uint32_t mipLevels;
997 1u, // uint32_t arrayLayers;
998 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
999 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1000 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
1001 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1002 1u, // uint32_t queueFamilyIndexCount;
1003 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1004 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1005 };
1006 image = de::MovePtr<ImageWithMemory>(
1007 new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1008 break;
1009 }
1010 case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
1011 {
1012 const VkImageCreateInfo imageCreateInfo = {
1013 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1014 DE_NULL, // const void* pNext;
1015 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1016 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1017 VK_FORMAT_R8_UNORM, // VkFormat format;
1018 {
1019 16U, // uint32_t width;
1020 16U, // uint32_t height;
1021 1u // uint32_t depth;
1022 }, // VkExtent3D extent;
1023 1u, // uint32_t mipLevels;
1024 VERIFYMAXVALUES_ARRAYLAYERS, // uint32_t arrayLayers;
1025 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1026 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1027 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
1028 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1029 1u, // uint32_t queueFamilyIndexCount;
1030 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1031 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1032 };
1033 image = de::MovePtr<ImageWithMemory>(
1034 new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1035 break;
1036 }
1037 case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
1038 {
1039 const VkImageCreateInfo imageCreateInfo = {
1040 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1041 DE_NULL, // const void* pNext;
1042 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1043 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1044 VK_FORMAT_R8_UNORM, // VkFormat format;
1045 {
1046 1 << VERIFYMAXVALUES_MIPLEVELS, // uint32_t width;
1047 1 << VERIFYMAXVALUES_MIPLEVELS, // uint32_t height;
1048 1u // uint32_t depth;
1049 }, // VkExtent3D extent;
1050 VERIFYMAXVALUES_MIPLEVELS, // uint32_t mipLevels;
1051 VERIFYMAXVALUES_ARRAYLAYERS, // uint32_t arrayLayers;
1052 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1053 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1054 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
1055 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1056 1u, // uint32_t queueFamilyIndexCount;
1057 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1058 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1059 };
1060 image = de::MovePtr<ImageWithMemory>(
1061 new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1062 break;
1063 }
1064 case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
1065 {
1066 const VkQueryPoolCreateInfo queryPoolCreateInfo = {
1067 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
1068 DE_NULL, // const void* pNext;
1069 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
1070 VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType;
1071 VERIFYMAXVALUES_OBJECT_COUNT, // uint32_t queryCount;
1072 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
1073 };
1074 queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
1075 break;
1076 }
1077 case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
1078 {
1079 const VkQueryPoolCreateInfo queryPoolCreateInfo = {
1080 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
1081 DE_NULL, // const void* pNext;
1082 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
1083 VK_QUERY_TYPE_PIPELINE_STATISTICS, // VkQueryType queryType;
1084 VERIFYMAXVALUES_OBJECT_COUNT, // uint32_t queryCount;
1085 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
1086 };
1087 queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
1088 break;
1089 }
1090 case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
1091 {
1092 const VkQueryPoolCreateInfo queryPoolCreateInfo = {
1093 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
1094 DE_NULL, // const void* pNext;
1095 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
1096 VK_QUERY_TYPE_TIMESTAMP, // VkQueryType queryType;
1097 VERIFYMAXVALUES_OBJECT_COUNT, // uint32_t queryCount;
1098 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
1099 };
1100 queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
1101 break;
1102 }
1103 default:
1104 TCU_THROW(InternalError, "Unsupported max value");
1105 }
1106 }
1107 };
1108
checkSupportVerifyRequestCounts(vkt::Context & context,TestParams testParams)1109 void checkSupportVerifyRequestCounts(vkt::Context &context, TestParams testParams)
1110 {
1111 if (testParams.testRequestCounts == TRC_SAMPLERYCBCRCONVERSION &&
1112 context.getDeviceVulkan11Features().samplerYcbcrConversion == VK_FALSE)
1113 TCU_THROW(NotSupportedError, "samplerYcbcrConversion is not supported");
1114 }
1115
1116 // create programs for VerifyRequestCounts tests
1117 struct ProgramsVerifyLimits
1118 {
initvkt::sc::__anon093e97bb0111::ProgramsVerifyLimits1119 void init(SourceCollections &dst, TestParams testParams) const
1120 {
1121 if (testParams.testRequestCounts == TRC_GRAPHICS_PIPELINE || testParams.testPoolSizeType != PST_UNDEFINED)
1122 {
1123 dst.glslSources.add("vertex") << glu::VertexSource("#version 450\n"
1124 "\n"
1125 "void main (void)\n"
1126 "{\n"
1127 " gl_Position = vec4(0);\n"
1128 "}\n");
1129 dst.glslSources.add("fragment") << glu::FragmentSource("#version 450\n"
1130 "\n"
1131 "layout(location=0) out vec4 x;\n"
1132 "void main (void)\n"
1133 "{\n"
1134 " x = vec4(1);\n"
1135 "}\n");
1136 }
1137 else if (testParams.testRequestCounts == TRC_COMPUTE_PIPELINE)
1138 {
1139 dst.glslSources.add("compute")
1140 << glu::ComputeSource("#version 450\n"
1141 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
1142 "void main (void)\n"
1143 "{\n"
1144 " uvec4 x = uvec4(0);\n"
1145 "}\n");
1146 }
1147 }
1148 };
1149
1150 // For each of the various resource "max" values, create resources that exercise the maximum values requested
1151 class VerifyRequestCounts : public DeviceObjectReservationInstance
1152 {
1153 public:
VerifyRequestCounts(Context & context,const TestParams & testParams_)1154 VerifyRequestCounts(Context &context, const TestParams &testParams_)
1155 : DeviceObjectReservationInstance(context, testParams_)
1156 {
1157 }
1158
createTestDevice(VkDeviceCreateInfo & deviceCreateInfo,VkDeviceObjectReservationCreateInfo & objectInfo,VkPhysicalDeviceVulkanSC10Features & sc10Features)1159 Move<VkDevice> createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
1160 VkDeviceObjectReservationCreateInfo &objectInfo,
1161 VkPhysicalDeviceVulkanSC10Features &sc10Features) override
1162 {
1163 DE_UNREF(sc10Features);
1164
1165 std::vector<VkPipelinePoolSize> poolSizes;
1166 VkDeviceSize pipelineDefaultSize =
1167 VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
1168
1169 switch (testParams.testRequestCounts)
1170 {
1171 case TRC_SEMAPHORE:
1172 objectInfo.semaphoreRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1173 break;
1174 case TRC_COMMAND_BUFFER:
1175 objectInfo.commandPoolRequestCount = 1u;
1176 objectInfo.commandBufferRequestCount =
1177 2 * VERIFYMAXVALUES_OBJECT_COUNT + (VERIFYMAXVALUES_OBJECT_COUNT - VERIFYMAXVALUES_OBJECT_COUNT / 2);
1178 break;
1179 case TRC_FENCE:
1180 objectInfo.fenceRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1181 break;
1182 case TRC_DEVICE_MEMORY:
1183 objectInfo.deviceMemoryRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1184 break;
1185 case TRC_BUFFER:
1186 objectInfo.bufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1187 break;
1188 case TRC_IMAGE:
1189 objectInfo.imageRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1190 objectInfo.maxImageViewMipLevels = 1u;
1191 objectInfo.maxImageViewArrayLayers = 1u;
1192 break;
1193 case TRC_EVENT:
1194 objectInfo.eventRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1195 break;
1196 case TRC_QUERY_POOL:
1197 objectInfo.queryPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1198 break;
1199 case TRC_BUFFER_VIEW:
1200 objectInfo.deviceMemoryRequestCount = 1u;
1201 objectInfo.bufferRequestCount = 1u;
1202 objectInfo.bufferViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1203 break;
1204 case TRC_IMAGE_VIEW:
1205 objectInfo.deviceMemoryRequestCount = 1u;
1206 objectInfo.imageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1207 objectInfo.imageRequestCount = 1u;
1208 objectInfo.maxImageViewMipLevels = 1u;
1209 objectInfo.maxImageViewArrayLayers = 1u;
1210 break;
1211 case TRC_LAYERED_IMAGE_VIEW:
1212 objectInfo.deviceMemoryRequestCount = 1u;
1213 objectInfo.imageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1214 objectInfo.layeredImageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1215 objectInfo.imageRequestCount = 1u;
1216 objectInfo.maxImageViewMipLevels = 1u;
1217 objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
1218 break;
1219 case TRC_PIPELINE_LAYOUT:
1220 objectInfo.pipelineLayoutRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1221 break;
1222 case TRC_RENDER_PASS:
1223 objectInfo.renderPassRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1224 objectInfo.subpassDescriptionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1225 objectInfo.attachmentDescriptionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1226 break;
1227 case TRC_GRAPHICS_PIPELINE:
1228 objectInfo.pipelineLayoutRequestCount = 1u;
1229 objectInfo.renderPassRequestCount = 1u;
1230 objectInfo.subpassDescriptionRequestCount = 1u;
1231 objectInfo.attachmentDescriptionRequestCount = 1u;
1232 objectInfo.graphicsPipelineRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1233 poolSizes.push_back(
1234 {VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT});
1235 break;
1236 case TRC_COMPUTE_PIPELINE:
1237 objectInfo.pipelineLayoutRequestCount = 1u;
1238 objectInfo.computePipelineRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1239 poolSizes.push_back(
1240 {VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT});
1241 break;
1242 case TRC_DESCRIPTORSET_LAYOUT:
1243 objectInfo.descriptorSetLayoutRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1244 objectInfo.descriptorSetLayoutBindingRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1245 objectInfo.descriptorSetLayoutBindingLimit = 2u;
1246 break;
1247 case TRC_SAMPLER:
1248 objectInfo.samplerRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1249 break;
1250 case TRC_DESCRIPTOR_POOL:
1251 objectInfo.descriptorPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1252 break;
1253 case TRC_DESCRIPTORSET:
1254 objectInfo.descriptorSetLayoutRequestCount = 1u;
1255 objectInfo.descriptorSetLayoutBindingRequestCount = 1u;
1256 objectInfo.descriptorSetLayoutBindingLimit = 2u;
1257 objectInfo.descriptorPoolRequestCount = 1u;
1258 objectInfo.descriptorSetRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1259 break;
1260 case TRC_FRAMEBUFFER:
1261 objectInfo.deviceMemoryRequestCount = 1u;
1262 objectInfo.imageViewRequestCount = 1u;
1263 objectInfo.imageRequestCount = 1u;
1264 objectInfo.maxImageViewMipLevels = 1u;
1265 objectInfo.maxImageViewArrayLayers = 1u;
1266 objectInfo.renderPassRequestCount = 1u;
1267 objectInfo.subpassDescriptionRequestCount = 1u;
1268 objectInfo.attachmentDescriptionRequestCount = 1u;
1269 objectInfo.framebufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1270 break;
1271 case TRC_COMMANDPOOL:
1272 objectInfo.commandPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1273 objectInfo.commandBufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1274 break;
1275 case TRC_SAMPLERYCBCRCONVERSION:
1276 objectInfo.samplerYcbcrConversionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1277 break;
1278 // case TRC_SURFACE:
1279 // objectInfo.surfaceRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1280 // break;
1281 // case TRC_SWAPCHAIN:
1282 // objectInfo.swapchainRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1283 // break;
1284 // case TRC_DISPLAY_MODE:
1285 // objectInfo.displayModeRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
1286 // break;
1287 default:
1288 TCU_THROW(InternalError, "Unsupported request count");
1289 }
1290
1291 objectInfo.pipelinePoolSizeCount = uint32_t(poolSizes.size());
1292 objectInfo.pPipelinePoolSizes = poolSizes.empty() ? DE_NULL : poolSizes.data();
1293
1294 return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(),
1295 m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice,
1296 &deviceCreateInfo);
1297 }
1298
performTest(const DeviceInterface & vkd,VkDevice device)1299 void performTest(const DeviceInterface &vkd, VkDevice device) override
1300 {
1301 SimpleAllocator allocator(vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
1302 VkDeviceSize pipelineDefaultSize =
1303 VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
1304 uint32_t queueFamilyIndex = 0u;
1305
1306 switch (testParams.testRequestCounts)
1307 {
1308 case TRC_SEMAPHORE:
1309 {
1310 std::vector<SemaphoreSp> semaphores(VERIFYMAXVALUES_OBJECT_COUNT);
1311 createSemaphores(vkd, device, begin(semaphores), end(semaphores));
1312 std::fill(begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores), SemaphoreSp());
1313 createSemaphores(vkd, device, begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores));
1314 std::fill(begin(semaphores), end(semaphores), SemaphoreSp());
1315 createSemaphores(vkd, device, begin(semaphores), end(semaphores));
1316 break;
1317 }
1318 case TRC_COMMAND_BUFFER:
1319 {
1320 std::vector<CommandPoolSp> commandPools(1u);
1321 createCommandPools(vkd, device, begin(commandPools), end(commandPools));
1322
1323 std::vector<CommandBufferSp> commandBuffers(VERIFYMAXVALUES_OBJECT_COUNT);
1324 createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
1325 std::fill(begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers), CommandBufferSp());
1326 createCommandBuffers(vkd, device, commandPools[0]->get(),
1327 begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers));
1328 std::fill(begin(commandBuffers), end(commandBuffers), CommandBufferSp());
1329 createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
1330 break;
1331 }
1332 case TRC_FENCE:
1333 {
1334 std::vector<FenceSp> fences(VERIFYMAXVALUES_OBJECT_COUNT);
1335 createFences(vkd, device, begin(fences), end(fences));
1336 std::fill(begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences), FenceSp());
1337 createFences(vkd, device, begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences));
1338 std::fill(begin(fences), end(fences), FenceSp());
1339 createFences(vkd, device, begin(fences), end(fences));
1340 break;
1341 }
1342 case TRC_DEVICE_MEMORY:
1343 {
1344 std::vector<DeviceMemorySp> mems(VERIFYMAXVALUES_OBJECT_COUNT);
1345 allocateDeviceMemory(vkd, device, 16U, begin(mems), end(mems));
1346 break;
1347 }
1348 case TRC_BUFFER:
1349 {
1350 std::vector<BufferSp> buffers(VERIFYMAXVALUES_OBJECT_COUNT);
1351 createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
1352 std::fill(begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers), BufferSp());
1353 createBuffers(vkd, device, 32ull, begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers));
1354 std::fill(begin(buffers), end(buffers), BufferSp());
1355 createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
1356 break;
1357 }
1358 case TRC_IMAGE:
1359 {
1360 std::vector<ImageSp> images(VERIFYMAXVALUES_OBJECT_COUNT);
1361 createImages(vkd, device, 16u, begin(images), end(images));
1362 std::fill(begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images), ImageSp());
1363 createImages(vkd, device, 16u, begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images));
1364 std::fill(begin(images), end(images), ImageSp());
1365 createImages(vkd, device, 16u, begin(images), end(images));
1366 break;
1367 }
1368 case TRC_EVENT:
1369 {
1370 std::vector<EventSp> events(VERIFYMAXVALUES_OBJECT_COUNT);
1371 createEvents(vkd, device, begin(events), end(events));
1372 std::fill(begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events), EventSp());
1373 createEvents(vkd, device, begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events));
1374 std::fill(begin(events), end(events), EventSp());
1375 createEvents(vkd, device, begin(events), end(events));
1376 break;
1377 }
1378 case TRC_QUERY_POOL:
1379 {
1380 std::vector<QueryPoolSp> queryPools(VERIFYMAXVALUES_OBJECT_COUNT);
1381 createQueryPools(vkd, device, begin(queryPools), end(queryPools));
1382 break;
1383 }
1384 case TRC_BUFFER_VIEW:
1385 {
1386 const VkBufferCreateInfo bufferCI = makeBufferCreateInfo(128ull, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
1387 BufferWithMemory buffer(vkd, device, allocator, bufferCI, MemoryRequirement::HostVisible);
1388
1389 std::vector<BufferViewSp> bufferViews(VERIFYMAXVALUES_OBJECT_COUNT);
1390 createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
1391 std::fill(begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(bufferViews), BufferViewSp());
1392 createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2,
1393 end(bufferViews));
1394 std::fill(begin(bufferViews), end(bufferViews), BufferViewSp());
1395 createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
1396 break;
1397 }
1398 case TRC_IMAGE_VIEW:
1399 {
1400 const VkImageCreateInfo imageCI = {
1401 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1402 DE_NULL, // const void* pNext;
1403 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1404 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1405 VK_FORMAT_R8_UNORM, // VkFormat format;
1406 {
1407 8u, // uint32_t width;
1408 8u, // uint32_t height;
1409 1u // uint32_t depth;
1410 }, // VkExtent3D extent;
1411 1u, // uint32_t mipLevels;
1412 1u, // uint32_t arrayLayers;
1413 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1414 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1415 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
1416 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1417 1u, // uint32_t queueFamilyIndexCount;
1418 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1419 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1420 };
1421 ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
1422
1423 std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
1424 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM, begin(imageViews), end(imageViews));
1425 std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
1426 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM,
1427 begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
1428 std::fill(begin(imageViews), end(imageViews), ImageViewSp());
1429 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM, begin(imageViews), end(imageViews));
1430 break;
1431 }
1432 case TRC_LAYERED_IMAGE_VIEW:
1433 {
1434 const VkImageCreateInfo imageCI = {
1435 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1436 DE_NULL, // const void* pNext;
1437 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1438 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1439 VK_FORMAT_R8_UNORM, // VkFormat format;
1440 {
1441 8u, // uint32_t width;
1442 8u, // uint32_t height;
1443 1u // uint32_t depth;
1444 }, // VkExtent3D extent;
1445 1u, // uint32_t mipLevels;
1446 VERIFYMAXVALUES_ARRAYLAYERS, // uint32_t arrayLayers;
1447 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1448 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1449 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
1450 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1451 1u, // uint32_t queueFamilyIndexCount;
1452 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1453 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1454 };
1455 ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
1456
1457 std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
1458 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM, begin(imageViews), end(imageViews));
1459 std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
1460 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM,
1461 begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
1462 std::fill(begin(imageViews), end(imageViews), ImageViewSp());
1463 createImageViews(vkd, device, image.get(), VK_FORMAT_R8_UNORM, begin(imageViews), end(imageViews));
1464 break;
1465 }
1466 case TRC_PIPELINE_LAYOUT:
1467 {
1468 std::vector<PipelineLayoutSp> pipelineLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
1469 createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
1470 std::fill(begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelineLayouts),
1471 PipelineLayoutSp());
1472 createPipelineLayouts(vkd, device, begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2,
1473 end(pipelineLayouts));
1474 std::fill(begin(pipelineLayouts), end(pipelineLayouts), PipelineLayoutSp());
1475 createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
1476 break;
1477 }
1478 case TRC_RENDER_PASS:
1479 {
1480 VkAttachmentDescription attachmentDescription = {
1481 0u, // VkAttachmentDescriptionFlags flags;
1482 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
1483 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1484 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
1485 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
1486 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1487 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1488 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1489 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
1490 };
1491
1492 std::vector<RenderPassSp> renderPasses(VERIFYMAXVALUES_OBJECT_COUNT);
1493 createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
1494 std::fill(begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses), RenderPassSp());
1495 createRenderPasses(vkd, device, &attachmentDescription,
1496 begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses));
1497 std::fill(begin(renderPasses), end(renderPasses), RenderPassSp());
1498 createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
1499 break;
1500 }
1501 case TRC_GRAPHICS_PIPELINE:
1502 {
1503 VkAttachmentDescription attachmentDescription = {
1504 0u, // VkAttachmentDescriptionFlags flags;
1505 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
1506 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1507 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
1508 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
1509 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1510 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1511 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1512 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
1513 };
1514 std::vector<RenderPassSp> renderPasses(1u);
1515 createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
1516 std::vector<PipelineLayoutSp> pipelineLayouts(1u);
1517 createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
1518 Move<VkShaderModule> vertexShaderModule =
1519 createShaderModule(vkd, device, m_context.getBinaryCollection().get("vertex"), 0u);
1520 Move<VkShaderModule> fragmentShaderModule =
1521 createShaderModule(vkd, device, m_context.getBinaryCollection().get("fragment"), 0u);
1522
1523 std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
1524 createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(),
1525 renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1526 m_context.getResourceInterface(), begin(pipelines), end(pipelines));
1527
1528 if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
1529 {
1530 std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
1531 createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(),
1532 renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1533 m_context.getResourceInterface(),
1534 begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
1535 std::fill(begin(pipelines), end(pipelines), PipelineSp());
1536 createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(),
1537 renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1538 m_context.getResourceInterface(), begin(pipelines), end(pipelines));
1539 }
1540
1541 break;
1542 }
1543 case TRC_COMPUTE_PIPELINE:
1544 {
1545 std::vector<PipelineLayoutSp> pipelineLayouts(1u);
1546 createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
1547 Move<VkShaderModule> shaderModule =
1548 createShaderModule(vkd, device, m_context.getBinaryCollection().get("compute"), 0u);
1549
1550 std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
1551 createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1552 m_context.getResourceInterface(), begin(pipelines), end(pipelines));
1553
1554 if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
1555 {
1556 std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
1557 createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1558 m_context.getResourceInterface(),
1559 begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
1560 std::fill(begin(pipelines), end(pipelines), PipelineSp());
1561 createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize,
1562 m_context.getResourceInterface(), begin(pipelines), end(pipelines));
1563 }
1564 break;
1565 }
1566 case TRC_DESCRIPTORSET_LAYOUT:
1567 {
1568 std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
1569 createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
1570 std::fill(begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSetLayouts),
1571 DescriptorSetLayoutSp());
1572 createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2,
1573 end(descriptorSetLayouts));
1574 std::fill(begin(descriptorSetLayouts), end(descriptorSetLayouts), DescriptorSetLayoutSp());
1575 createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
1576 break;
1577 }
1578 case TRC_SAMPLER:
1579 {
1580 std::vector<SamplerSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
1581 createSamplers(vkd, device, begin(samplers), end(samplers));
1582 std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerSp());
1583 createSamplers(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers));
1584 std::fill(begin(samplers), end(samplers), SamplerSp());
1585 createSamplers(vkd, device, begin(samplers), end(samplers));
1586 break;
1587 }
1588 case TRC_DESCRIPTOR_POOL:
1589 {
1590 std::vector<DescriptorPoolSp> descriptorPools(VERIFYMAXVALUES_OBJECT_COUNT);
1591 createDescriptorPools(vkd, device, 1u, begin(descriptorPools), end(descriptorPools));
1592 break;
1593 }
1594 case TRC_DESCRIPTORSET:
1595 {
1596 std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(1u);
1597 createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
1598 std::vector<DescriptorPoolSp> descriptorPools(1u);
1599 createDescriptorPools(vkd, device, VERIFYMAXVALUES_OBJECT_COUNT, begin(descriptorPools),
1600 end(descriptorPools));
1601
1602 std::vector<DescriptorSetSp> descriptorSets(VERIFYMAXVALUES_OBJECT_COUNT);
1603 createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(),
1604 begin(descriptorSets), end(descriptorSets));
1605 if (m_context.getDeviceVulkanSC10Properties().recycleDescriptorSetMemory)
1606 {
1607 std::fill(begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets),
1608 DescriptorSetSp());
1609 createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(),
1610 begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets));
1611 std::fill(begin(descriptorSets), end(descriptorSets), DescriptorSetSp());
1612 createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(),
1613 begin(descriptorSets), end(descriptorSets));
1614 }
1615 break;
1616 }
1617 case TRC_FRAMEBUFFER:
1618 {
1619 VkImageCreateInfo imageCI = {
1620 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType
1621 DE_NULL, // const void* pNext
1622 (VkImageCreateFlags)0u, // VkImageCreateFlags flags
1623 VK_IMAGE_TYPE_2D, // VkImageType imageType
1624 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format
1625 {
1626 8u, // uint32_t width
1627 8u, // uint32_t height
1628 1u // uint32_t depth
1629 }, // VkExtent3D extent
1630 1u, // uint32_t mipLevels
1631 1u, // uint32_t arrayLayers
1632 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
1633 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling
1634 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
1635 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1636 1u, // uint32_t queueFamilyIndexCount;
1637 &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1638 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1639 };
1640 ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
1641
1642 VkAttachmentDescription attachmentDescription = {
1643 0u, // VkAttachmentDescriptionFlags flags;
1644 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
1645 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1646 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
1647 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
1648 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1649 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1650 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1651 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
1652 };
1653
1654 std::vector<RenderPassSp> renderPasses(1u);
1655 createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
1656
1657 std::vector<ImageViewSp> imageViews(1u);
1658 createImageViews(vkd, device, image.get(), VK_FORMAT_R8G8B8A8_UNORM, begin(imageViews), end(imageViews));
1659
1660 std::vector<FramebufferSp> framebuffers(VERIFYMAXVALUES_OBJECT_COUNT);
1661 createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers),
1662 end(framebuffers));
1663 std::fill(begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers), FramebufferSp());
1664 createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(),
1665 begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers));
1666 std::fill(begin(framebuffers), end(framebuffers), FramebufferSp());
1667 createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers),
1668 end(framebuffers));
1669 break;
1670 }
1671 case TRC_COMMANDPOOL:
1672 {
1673 std::vector<CommandPoolSp> commandPools(VERIFYMAXVALUES_OBJECT_COUNT);
1674 createCommandPools(vkd, device, begin(commandPools), end(commandPools));
1675 break;
1676 }
1677 case TRC_SAMPLERYCBCRCONVERSION:
1678 {
1679 std::vector<SamplerYcbcrConversionSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
1680 createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
1681 std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerYcbcrConversionSp());
1682 createSamplerYcbcrConversions(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2,
1683 end(samplers));
1684 std::fill(begin(samplers), end(samplers), SamplerYcbcrConversionSp());
1685 createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
1686 break;
1687 }
1688 // case TRC_SURFACE:
1689 // break;
1690 // case TRC_SWAPCHAIN:
1691 // break;
1692 // case TRC_DISPLAY_MODE:
1693 // break;
1694 default:
1695 TCU_THROW(InternalError, "Unsupported max value");
1696 }
1697 }
1698 };
1699
1700 // test pipeline pool sizes
1701 class VerifyPipelinePoolSizes : public DeviceObjectReservationInstance
1702 {
1703 public:
VerifyPipelinePoolSizes(Context & context,const TestParams & testParams_)1704 VerifyPipelinePoolSizes(Context &context, const TestParams &testParams_)
1705 : DeviceObjectReservationInstance(context, testParams_)
1706 {
1707 }
1708
createTestDevice(VkDeviceCreateInfo & deviceCreateInfo,VkDeviceObjectReservationCreateInfo & objectInfo,VkPhysicalDeviceVulkanSC10Features & sc10Features)1709 Move<VkDevice> createTestDevice(VkDeviceCreateInfo &deviceCreateInfo,
1710 VkDeviceObjectReservationCreateInfo &objectInfo,
1711 VkPhysicalDeviceVulkanSC10Features &sc10Features) override
1712 {
1713 DE_UNREF(sc10Features);
1714
1715 std::vector<VkPipelinePoolSize> poolSizes;
1716
1717 const VkDeviceSize psTooSmall = 64u;
1718 const VkDeviceSize psForOnePipeline =
1719 VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
1720
1721 switch (testParams.testPoolSizeType)
1722 {
1723 case PST_NONE:
1724 objectInfo.graphicsPipelineRequestCount = 1u;
1725 break;
1726 case PST_ZERO:
1727 objectInfo.graphicsPipelineRequestCount = 1u;
1728 poolSizes.push_back({VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, 0u, 1u});
1729 break;
1730 case PST_TOO_SMALL_SIZE:
1731 poolSizes.push_back({VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psTooSmall, 1u});
1732 objectInfo.graphicsPipelineRequestCount = 1u;
1733 break;
1734 case PST_ONE_FITS:
1735 poolSizes.push_back({VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 1u});
1736 objectInfo.graphicsPipelineRequestCount = 1u;
1737 break;
1738 case PST_MULTIPLE_FIT:
1739 poolSizes.push_back({VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 16u});
1740 objectInfo.graphicsPipelineRequestCount = 16u;
1741 break;
1742 default:
1743 TCU_THROW(InternalError, "Unsupported pool size type");
1744 }
1745
1746 objectInfo.pipelinePoolSizeCount = uint32_t(poolSizes.size());
1747 objectInfo.pPipelinePoolSizes = poolSizes.empty() ? DE_NULL : poolSizes.data();
1748 objectInfo.pipelineLayoutRequestCount = 1u;
1749 objectInfo.renderPassRequestCount = 1u;
1750 objectInfo.subpassDescriptionRequestCount = 1u;
1751 objectInfo.attachmentDescriptionRequestCount = 1u;
1752
1753 return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(),
1754 m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice,
1755 &deviceCreateInfo);
1756 }
1757
performTest(const DeviceInterface & vk,VkDevice device)1758 void performTest(const DeviceInterface &vk, VkDevice device) override
1759 {
1760 const vk::PlatformInterface &vkp = m_context.getPlatformInterface();
1761 const InstanceInterface &vki = instance.getDriver();
1762
1763 Move<VkShaderModule> vertexShader =
1764 createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), 0);
1765 Move<VkShaderModule> fragmentShader =
1766 createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), 0);
1767
1768 std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos = {
1769 {
1770 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1771 DE_NULL, // const void* pNext;
1772 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1773 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1774 *vertexShader, // VkShaderModule shader;
1775 "main", // const char* pName;
1776 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1777 },
1778 {
1779 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1780 DE_NULL, // const void* pNext;
1781 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1782 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1783 *fragmentShader, // VkShaderModule shader;
1784 "main", // const char* pName;
1785 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1786 }};
1787
1788 VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo;
1789 VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo;
1790 VkPipelineViewportStateCreateInfo viewPortStateCreateInfo;
1791 VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo;
1792 VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo;
1793 VkPipelineColorBlendAttachmentState colorBlendAttachmentState;
1794 VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo;
1795 VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo;
1796 std::vector<VkDynamicState> dynamicStates = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
1797
1798 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
1799 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1800 DE_NULL, // const void* pNext;
1801 (VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
1802 0u, // uint32_t setLayoutCount;
1803 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
1804 0u, // uint32_t pushConstantRangeCount;
1805 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
1806 };
1807 Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
1808
1809 const VkFormat format = getRenderTargetFormat(vki, physicalDevice);
1810
1811 VkAttachmentDescription attachmentDescription;
1812 VkAttachmentReference attachmentReference;
1813 VkSubpassDescription subpassDescription;
1814 VkRenderPassCreateInfo renderPassCreateInfo =
1815 prepareSimpleRenderPassCI(format, attachmentDescription, attachmentReference, subpassDescription);
1816 Move<VkRenderPass> renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
1817
1818 VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo = prepareSimpleGraphicsPipelineCI(
1819 vertexInputStateCreateInfo, shaderStageCreateInfos, inputAssemblyStateCreateInfo, viewPortStateCreateInfo,
1820 rasterizationStateCreateInfo, multisampleStateCreateInfo, colorBlendAttachmentState,
1821 colorBlendStateCreateInfo, dynamicStateCreateInfo, dynamicStates, *pipelineLayout, *renderPass);
1822
1823 // create custom VkPipelineIdentifierInfo
1824 VkPipelineOfflineCreateInfo pipelineID = resetPipelineOfflineCreateInfo();
1825 applyPipelineIdentifier(pipelineID, "ID_DR_PS_00");
1826 pipelineID.pNext = graphicsPipelineCreateInfo.pNext;
1827 graphicsPipelineCreateInfo.pNext = &pipelineID;
1828
1829 if (m_context.getTestContext().getCommandLine().isSubProcess())
1830 {
1831 pipelineID.poolEntrySize =
1832 VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
1833 }
1834
1835 std::size_t pipelineCount = 0u;
1836 switch (testParams.testPoolSizeType)
1837 {
1838 case PST_NONE:
1839 case PST_ZERO:
1840 case PST_TOO_SMALL_SIZE:
1841 case PST_ONE_FITS:
1842 pipelineCount = 1u;
1843 break;
1844 case PST_MULTIPLE_FIT:
1845 pipelineCount = 16u;
1846 break;
1847 default:
1848 TCU_THROW(InternalError, "Unsupported pool size type");
1849 };
1850
1851 if (!m_context.getTestContext().getCommandLine().isSubProcess())
1852 {
1853 std::vector<Move<VkPipeline>> pipelines;
1854 for (uint32_t i = 0; i < pipelineCount; ++i)
1855 pipelines.emplace_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
1856 return;
1857 }
1858
1859 GetDeviceProcAddrFunc getDeviceProcAddrFunc =
1860 (GetDeviceProcAddrFunc)vkp.getInstanceProcAddr(instance, "vkGetDeviceProcAddr");
1861 CreateGraphicsPipelinesFunc createGraphicsPipelinesFunc =
1862 (CreateGraphicsPipelinesFunc)getDeviceProcAddrFunc(device, "vkCreateGraphicsPipelines");
1863 DestroyPipelineFunc destroyPipelineFunc =
1864 (DestroyPipelineFunc)getDeviceProcAddrFunc(device, "vkDestroyPipeline");
1865 VkPipelineCache pipelineCache = m_context.getResourceInterface()->getPipelineCache(device);
1866 std::vector<VkPipeline> pipelines(pipelineCount, VkPipeline(DE_NULL));
1867 uint32_t iterations = m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory ? 1u : 4u;
1868
1869 // if recyclePipelineMemory is set then we are able to create the same pipelines again
1870 for (uint32_t iter = 0; iter < iterations; ++iter)
1871 {
1872 for (uint32_t i = 0; i < pipelineCount; ++i)
1873 {
1874 VkResult result = createGraphicsPipelinesFunc(device, pipelineCache, 1u, &graphicsPipelineCreateInfo,
1875 DE_NULL, &pipelines[i]);
1876 results.push_back(result);
1877 if (result != VK_SUCCESS)
1878 {
1879 for (uint32_t j = 0; j < pipelineCount; ++j)
1880 if (pipelines[j].getInternal() != DE_NULL)
1881 destroyPipelineFunc(device, pipelines[j], DE_NULL);
1882 return;
1883 }
1884 }
1885
1886 for (uint32_t i = 0; i < pipelineCount; ++i)
1887 {
1888 destroyPipelineFunc(device, pipelines[i], DE_NULL);
1889 pipelines[i] = VkPipeline(DE_NULL);
1890 }
1891 }
1892 }
1893
verifyTestResults(const DeviceInterface & vkd,VkDevice device)1894 bool verifyTestResults(const DeviceInterface &vkd, VkDevice device) override
1895 {
1896 DE_UNREF(vkd);
1897 DE_UNREF(device);
1898
1899 if (!m_context.getTestContext().getCommandLine().isSubProcess())
1900 return true;
1901
1902 switch (testParams.testPoolSizeType)
1903 {
1904 case PST_NONE:
1905 case PST_ZERO:
1906 case PST_TOO_SMALL_SIZE:
1907 return (results.back() == VK_ERROR_OUT_OF_POOL_MEMORY);
1908 case PST_ONE_FITS:
1909 return (results.back() == VK_SUCCESS);
1910 case PST_MULTIPLE_FIT:
1911 return (results.back() == VK_SUCCESS);
1912 default:
1913 TCU_THROW(InternalError, "Unsupported pool size type");
1914 };
1915 return true;
1916 }
1917
1918 std::vector<VkResult> results;
1919 };
1920
1921 } // namespace
1922
createDeviceObjectReservationTests(tcu::TestContext & testCtx)1923 tcu::TestCaseGroup *createDeviceObjectReservationTests(tcu::TestContext &testCtx)
1924 {
1925 // Tests verifying VkDeviceObjectReservationCreateInfo
1926 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "device_object_reservation"));
1927
1928 // add basic tests
1929 {
1930 de::MovePtr<tcu::TestCaseGroup> basicGroup(new tcu::TestCaseGroup(group->getTestContext(), "basic"));
1931
1932 basicGroup->addChild(
1933 new InstanceFactory1<DeviceObjectReservationInstance, TestParams>(testCtx, "create_device", TestParams()));
1934 basicGroup->addChild(new InstanceFactory1<MultipleReservation, TestParams>(
1935 testCtx, "multiple_device_object_reservation", TestParams()));
1936
1937 group->addChild(basicGroup.release());
1938 }
1939
1940 // add tests verifying device limits
1941 {
1942 de::MovePtr<tcu::TestCaseGroup> limitGroup(new tcu::TestCaseGroup(group->getTestContext(), "limits"));
1943 struct TestMaxValuesData
1944 {
1945 TestMaxValues testMaxValues;
1946 const char *name;
1947 } testMaxValues[] = {
1948 {TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT, "descriptor_set_layout_binding_limit"},
1949 {TMV_MAX_IMAGEVIEW_MIPLEVELS, "max_imageview_miplevels"},
1950 {TMV_MAX_IMAGEVIEW_ARRAYLAYERS, "max_imageview_arraylayers"},
1951 {TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS, "max_layeredimageview_miplevels"},
1952 {TMV_MAX_OCCLUSION_QUERIES_PER_POOL, "max_occlusion_queries_per_pool"},
1953 {TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL, "max_pipelinestatistics_queries_per_pool"},
1954 {TMV_MAX_TIMESTAMP_QUERIES_PER_POOL, "max_timestamp_queries_per_pool"},
1955 };
1956 {
1957 de::MovePtr<tcu::TestCaseGroup> maxValGroup(new tcu::TestCaseGroup(group->getTestContext(), "max_values"));
1958
1959 for (int32_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMaxValues); ndx++)
1960 {
1961 TestParams testParams{testMaxValues[ndx].testMaxValues, TRC_UNDEFINED};
1962 maxValGroup->addChild(
1963 new InstanceFactory1WithSupport<VerifyMaxValues, TestParams, FunctionSupport1<TestParams>>(
1964 testCtx, testMaxValues[ndx].name, testParams,
1965 typename FunctionSupport1<TestParams>::Args(checkSupportVerifyMaxValues, testParams)));
1966 }
1967
1968 limitGroup->addChild(maxValGroup.release());
1969 }
1970
1971 struct TestRequestCountData
1972 {
1973 TestRequestCounts requestCount;
1974 const char *name;
1975 } testRequestCounts[] = {
1976 {TRC_SEMAPHORE, "semaphore"},
1977 {TRC_COMMAND_BUFFER, "command_buffer"},
1978 {TRC_FENCE, "fence"},
1979 {TRC_DEVICE_MEMORY, "device_memory"},
1980 {TRC_BUFFER, "buffer"},
1981 {TRC_IMAGE, "image"},
1982 {TRC_EVENT, "event"},
1983 {TRC_QUERY_POOL, "query_pool"},
1984 {TRC_BUFFER_VIEW, "buffer_view"},
1985 {TRC_IMAGE_VIEW, "image_view"},
1986 {TRC_LAYERED_IMAGE_VIEW, "layered_image_view"},
1987 {TRC_PIPELINE_LAYOUT, "pipeline_layout"},
1988 {TRC_RENDER_PASS, "render_pass"},
1989 {TRC_GRAPHICS_PIPELINE, "graphics_pipeline"},
1990 {TRC_COMPUTE_PIPELINE, "compute_pipeline"},
1991 {TRC_DESCRIPTORSET_LAYOUT, "descriptorset_layout"},
1992 {TRC_SAMPLER, "sampler"},
1993 {TRC_DESCRIPTOR_POOL, "descriptor_pool"},
1994 {TRC_DESCRIPTORSET, "descriptorset"},
1995 {TRC_FRAMEBUFFER, "framebuffer"},
1996 {TRC_COMMANDPOOL, "commandpool"},
1997 {TRC_SAMPLERYCBCRCONVERSION, "samplerycbcrconversion"},
1998 // { TRC_SURFACE, "surface" },
1999 // { TRC_SWAPCHAIN, "swapchain" },
2000 // { TRC_DISPLAY_MODE, "display_mode" },
2001 };
2002 {
2003 de::MovePtr<tcu::TestCaseGroup> requestCountGroup(
2004 new tcu::TestCaseGroup(group->getTestContext(), "request_count"));
2005
2006 for (int32_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testRequestCounts); ndx++)
2007 {
2008 TestParams testParams{TMV_UNDEFINED, testRequestCounts[ndx].requestCount};
2009 requestCountGroup->addChild(
2010 new InstanceFactory1WithSupport<VerifyRequestCounts, TestParams, FunctionSupport1<TestParams>,
2011 ProgramsVerifyLimits>(
2012 testCtx, testRequestCounts[ndx].name, ProgramsVerifyLimits(), testParams,
2013 typename FunctionSupport1<TestParams>::Args(checkSupportVerifyRequestCounts, testParams)));
2014 }
2015
2016 limitGroup->addChild(requestCountGroup.release());
2017 }
2018
2019 group->addChild(limitGroup.release());
2020 }
2021
2022 // add tests verifying pipeline pool sizes
2023 {
2024 de::MovePtr<tcu::TestCaseGroup> ppsGroup(new tcu::TestCaseGroup(group->getTestContext(), "pipeline_pool_size"));
2025
2026 struct PoolSizesData
2027 {
2028 TestPoolSizes type;
2029 const char *name;
2030 } poolSizes[] = {
2031 {PST_NONE, "none"},
2032 {PST_ZERO, "zero"},
2033 {PST_TOO_SMALL_SIZE, "too_small_size"},
2034 {PST_ONE_FITS, "one_fits"},
2035 {PST_MULTIPLE_FIT, "multiple_fit"},
2036 };
2037
2038 for (int32_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(poolSizes); ndx++)
2039 {
2040 TestParams testParams(TMV_UNDEFINED, TRC_UNDEFINED, poolSizes[ndx].type);
2041
2042 ppsGroup->addChild(new InstanceFactory1<VerifyPipelinePoolSizes, TestParams, ProgramsVerifyLimits>(
2043 testCtx, poolSizes[ndx].name, ProgramsVerifyLimits(), testParams));
2044 }
2045
2046 group->addChild(ppsGroup.release());
2047 }
2048
2049 return group.release();
2050 }
2051
2052 } // namespace sc
2053
2054 } // namespace vkt
2055