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