1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2019 The Khronos Group Inc.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief Vulkan Decriptor Indexing Tests
22 *//*--------------------------------------------------------------------*/
32 #include "vktDescriptorSetsIndexingTests.hpp"
34 #include "vkBuilderUtil.hpp"
35 #include "vkCmdUtil.hpp"
37 #include "vkObjUtil.hpp"
38 #include "vkPlatform.hpp"
39 #include "vkPrograms.hpp"
40 #include "vkQueryUtil.hpp"
41 #include "vkTypeUtil.hpp"
43 #include "tcuTestLog.hpp"
44 #include "tcuResource.hpp"
45 #include "tcuImageCompare.hpp"
46 #include "tcuCommandLine.hpp"
47 #include "tcuStringTemplate.hpp"
48 #include "tcuSurface.hpp"
49 #include "tcuVectorUtil.hpp"
51 #include "deRandom.hpp"
53 #include "deStringUtil.hpp"
57 namespace DescriptorIndexing
64 using tcu::TestStatus;
65 using tcu::PixelBufferAccess;
68 #define RESOLUTION_width 64
69 #define RESOLUTION_height 64
70 static const VkExtent3D RESOLUTION = { RESOLUTION_width, RESOLUTION_height, 1 };
72 #define MAX_DESCRIPTORS 4200
73 #define FUZZY_COMPARE DE_FALSE
74 #define CMP_THRESHOLD 0.02f
76 #define BINDING_Undefined 0
77 #define BINDING_UniformBuffer 1
78 #define BINDING_StorageBuffer 2
79 #define BINDING_UniformTexelBuffer 3
80 #define BINDING_StorageTexelBuffer 4
81 #define BINDING_Sampler 5
82 #define BINDING_SampledImage 6
83 #define BINDING_CombinedImageSampler 7
84 #define BINDING_UniformBufferDynamic 8
85 #define BINDING_StorageBufferDynamic 9
86 #define BINDING_InputAttachment 10
87 #define BINDING_StorageImage 11
88 #define BINDING_DescriptorEnumerator 12
90 static const VkExtent3D smallImageExtent = { 4, 4, 1 };
91 static const VkExtent3D bigImageExtent = { 32, 32, 1 };
92 static const VkDescriptorType VK_DESCRIPTOR_TYPE_UNDEFINED = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
94 template<deUint32 BindingNumber>
97 static const deUint32 binding = BindingNumber;
100 struct BindingUniformBuffer : Binding<BINDING_UniformBuffer>
108 struct BindingStorageBuffer : Binding<BINDING_StorageBuffer>
117 struct TestCaseParams
119 VkDescriptorType descriptorType; // used only to distinguish test class instance
120 VkShaderStageFlags stageFlags; // used only to build a proper program
121 VkExtent3D frameResolution; // target frame buffer resolution
122 bool updateAfterBind; // whether a test will use update after bind feature
123 bool calculateInLoop; // perform calculation in a loop
124 bool usesMipMaps; // this makes a sense and affects in image test cases only
125 deBool fuzzyComparison; // if true then a test will use fuzzy comparison, otherwise float threshold
126 float thresholdValue; // a threshold that will be used for both, float and fuzzy comparisons
131 VkShaderStageFlags stageFlags;
132 VkDescriptorType descriptorType;
133 deUint32 descriptorBinding;
134 VkDescriptorType additionalDescriptorType;
135 deUint32 additionalDescriptorBinding;
136 bool copyBuffersToImages;
137 bool allowVertexStoring;
138 VkExtent3D frameResolution;
139 bool updateAfterBind;
140 bool calculateInLoop;
142 deBool fuzzyComparison;
143 float thresholdValue;
145 TestParams (VkShaderStageFlags stageFlags_,
146 VkDescriptorType descriptorType_,
147 deUint32 descriptorBinding_,
148 VkDescriptorType additionalDescriptorType_,
149 deUint32 additionalDescriptorBinding_,
150 bool copyBuffersToImages_,
151 bool allowVertexStoring_,
152 const TestCaseParams& caseParams)
153 : stageFlags (stageFlags_)
154 , descriptorType (descriptorType_)
155 , descriptorBinding (descriptorBinding_)
156 , additionalDescriptorType (additionalDescriptorType_)
157 , additionalDescriptorBinding (additionalDescriptorBinding_)
158 , copyBuffersToImages (copyBuffersToImages_)
159 , allowVertexStoring (allowVertexStoring_)
160 , frameResolution (caseParams.frameResolution)
161 , updateAfterBind (caseParams.updateAfterBind)
162 , calculateInLoop (caseParams.calculateInLoop)
163 , usesMipMaps (caseParams.usesMipMaps)
164 , fuzzyComparison (caseParams.fuzzyComparison ? true : false)
165 , thresholdValue (caseParams.thresholdValue)
170 struct DescriptorEnumerator
172 ut::BufferHandleAllocSp buffer;
173 ut::BufferViewSp bufferView;
174 VkDeviceSize bufferSize;
176 Move<VkDescriptorSetLayout> descriptorSetLayout;
177 Move<VkDescriptorPool> descriptorPool;
178 Move<VkDescriptorSet> descriptorSet;
180 void init(const vkt::Context& context, deUint32 vertexCount, deUint32 availableDescriptorCount);
181 void update(const vkt::Context& context);
184 struct IterateCommonVariables
186 // An amount of descriptors of a given type available on the platform
187 deUint32 availableDescriptorCount;
188 // An amount of valid descriptors that have connected a buffers to them
189 deUint32 validDescriptorCount;
190 // As the name suggests, sometimes it is used as invocationCount
191 deUint32 vertexCount;
193 VkDeviceSize dataAlignment;
197 DescriptorEnumerator descriptorEnumerator;
199 ut::BufferHandleAllocSp vertexAttributesBuffer;
200 ut::BufferHandleAllocSp descriptorsBuffer;
201 std::vector<VkDescriptorBufferInfo> descriptorsBufferInfos;
202 std::vector<ut::BufferViewSp> descriptorsBufferViews;
203 std::vector<ut::ImageViewSp> descriptorImageViews;
204 std::vector<ut::SamplerSp> descriptorSamplers;
205 std::vector<ut::ImageHandleAllocSp> descriptorsImages;
206 ut::FrameBufferSp frameBuffer;
208 Move<VkDescriptorSetLayout> descriptorSetLayout;
209 Move<VkDescriptorPool> descriptorPool;
210 Move<VkDescriptorSet> descriptorSet;
211 Move<VkPipelineLayout> pipelineLayout;
212 Move<VkRenderPass> renderPass;
213 Move<VkPipeline> pipeline;
214 Move<VkCommandBuffer> commandBuffer;
217 class CommonDescriptorInstance : public TestInstance
220 CommonDescriptorInstance (Context& context,
221 const TestParams& testParams);
223 deUint32 computeAvailableDescriptorCount (VkDescriptorType descriptorType) const;
225 Move<VkDescriptorSetLayout> createDescriptorSetLayout (deUint32& descriptorCount) const;
227 Move<VkDescriptorPool> createDescriptorPool (deUint32 descriptorCount) const;
229 Move<VkDescriptorSet> createDescriptorSet (VkDescriptorPool dsPool,
230 VkDescriptorSetLayout dsLayout) const;
234 typedef tcu::Vec4 vec4;
235 typedef tcu::Vec2 vec2;
236 typedef tcu::IVec4 ivec4;
240 attributes& operator()(const vec4& pos)
244 normalpos.x() = (pos.x() + 1.0f) / 2.0f;
245 normalpos.y() = (pos.y() + 1.0f) / 2.0f;
250 void createVertexAttributeBuffer (ut::BufferHandleAllocSp& buffer,
251 deUint32 availableDescriptorCount) const;
253 static std::string substBinding (deUint32 binding,
256 const char* name = DE_NULL);
258 static const char* getVertexShaderProlog (void);
260 static const char* getFragmentShaderProlog (void);
262 static const char* getShaderEpilog (void);
264 static bool performWritesInVertex (VkDescriptorType descriptorType);
266 static bool performWritesInVertex (VkDescriptorType descriptorType,
267 const Context& context);
268 static std::string getShaderSource (VkShaderStageFlagBits shaderType,
269 const TestCaseParams& testCaseParams,
270 bool allowVertexStoring);
272 static std::string getColorAccess (VkDescriptorType descriptorType,
273 const char* indexVariableName,
276 static std::string getFragmentReturnSource (const std::string& colorAccess);
278 static std::string getFragmentLoopSource (const std::string& colorAccess1,
279 const std::string& colorAccess2);
281 virtual Move<VkRenderPass> createRenderPass (const IterateCommonVariables& variables);
288 VkPushConstantRange makePushConstantRange (void) const;
290 Move<VkPipelineLayout> createPipelineLayout (const std::vector<VkDescriptorSetLayout>& descriptorSetLayouts) const;
292 // Creates graphics or compute pipeline and appropriate shaders' modules according the testCaseParams.stageFlags
293 // In the case of compute pipeline renderPass parameter is ignored.
294 // Viewport will be created with a width and a height taken from testCaseParam.fragResolution.
295 Move<VkPipeline> createPipeline (VkPipelineLayout pipelineLayout,
296 VkRenderPass renderPass);
298 virtual void createFramebuffer (ut::FrameBufferSp& frameBuffer,
299 VkRenderPass renderPass,
300 const IterateCommonVariables& variables);
302 // Creates one big stagging buffer cutted out on chunks that can accomodate an element of elementSize size
303 VkDeviceSize createBuffers (std::vector<VkDescriptorBufferInfo>& bufferInfos,
304 ut::BufferHandleAllocSp& buffer,
305 deUint32 elementCount,
306 deUint32 elementSize,
307 VkDeviceSize alignment,
308 VkBufferUsageFlags bufferUsage);
310 // Creates and binds an imagesCount of images with given parameters.
311 // Additionally creates stagging buffer for their data and PixelBufferAccess for particular images.
312 VkDeviceSize createImages (std::vector<ut::ImageHandleAllocSp>& images,
313 std::vector<VkDescriptorBufferInfo>& bufferInfos,
314 ut::BufferHandleAllocSp& buffer,
315 VkBufferUsageFlags bufferUsage,
316 const VkExtent3D& imageExtent,
317 VkFormat imageFormat,
318 VkImageLayout imageLayout,
320 bool withMipMaps = false);
322 void createBuffersViews (std::vector<ut::BufferViewSp>& views,
323 const std::vector<VkDescriptorBufferInfo>& bufferInfos,
326 void createImagesViews (std::vector<ut::ImageViewSp>& views,
327 const std::vector<ut::ImageHandleAllocSp>& images,
330 virtual void copyBuffersToImages (IterateCommonVariables& variables);
332 virtual void copyImagesToBuffers (IterateCommonVariables& variables);
334 PixelBufferAccess getPixelAccess (deUint32 imageIndex,
335 const VkExtent3D& imageExtent,
336 VkFormat imageFormat,
337 const std::vector<VkDescriptorBufferInfo>& bufferInfos,
338 const ut::BufferHandleAllocSp& buffer,
339 deUint32 mipLevel = 0u) const;
341 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables) = 0;
343 virtual void updateDescriptors (IterateCommonVariables& variables);
345 virtual void iterateCollectResults (ut::UpdatablePixelBufferAccessPtr& result,
346 const IterateCommonVariables& variables,
349 void iterateCommandSetup (IterateCommonVariables& variables);
351 void iterateCommandBegin (IterateCommonVariables& variables,
352 bool firstPass = true);
354 void iterateCommandEnd (IterateCommonVariables& variables,
355 ut::UpdatablePixelBufferAccessPtr& programResult,
356 ut::UpdatablePixelBufferAccessPtr& referenceResult,
357 bool collectBeforeSubmit = true);
359 bool iterateVerifyResults (IterateCommonVariables& variables,
360 ut::UpdatablePixelBufferAccessPtr programResult,
361 ut::UpdatablePixelBufferAccessPtr referenceResult);
363 Move<VkCommandBuffer> createCmdBuffer (void);
365 void commandBindPipeline (VkCommandBuffer commandBuffer,
366 VkPipeline pipeline);
368 void commandBindVertexAttributes (VkCommandBuffer commandBuffer,
369 const ut::BufferHandleAllocSp& vertexAttributesBuffer);
371 void commandBindDescriptorSets (VkCommandBuffer commandBuffer,
372 VkPipelineLayout pipelineLayout,
373 VkDescriptorSet descriptorSet,
374 deUint32 descriptorSetIndex);
376 void commandReadFrameBuffer (ut::BufferHandleAllocSp& content,
377 VkCommandBuffer commandBuffer,
378 const ut::FrameBufferSp& frameBuffer);
379 ut::UpdatablePixelBufferAccessPtr
380 commandReadFrameBuffer (VkCommandBuffer commandBuffer,
381 const ut::FrameBufferSp& frameBuffer);
383 Move<VkFence> commandSubmit (VkCommandBuffer commandBuffer);
385 virtual bool verifyVertexWriteResults (IterateCommonVariables& variables);
388 virtual tcu::TestStatus iterate (void);
391 const VkDevice m_vkd;
392 const DeviceInterface& m_vki;
393 Allocator& m_allocator;
394 const VkQueue m_queue;
395 const deUint32 m_queueFamilyIndex;
396 const Move<VkCommandPool> m_commandPool;
397 const VkFormat m_colorFormat;
398 const TestParams m_testParams;
399 static const tcu::Vec4 m_clearColor;
400 const std::vector<float> m_colorScheme;
401 const deUint32 m_schemeSize;
405 Move<VkPipeline> createGraphicsPipeline (VkPipelineLayout pipelineLayout,
406 VkRenderPass renderPass);
408 Move<VkPipeline> createComputePipeline (VkPipelineLayout pipelineLayout);
410 int constructShaderModules (void);
412 static std::vector<float> createColorScheme();
414 Move<VkShaderModule> m_vertexModule;
415 Move<VkShaderModule> m_fragmentModule;
416 Move<VkShaderModule> m_computeModule;
418 const tcu::Vec4 CommonDescriptorInstance::m_clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
420 void DescriptorEnumerator::init (const vkt::Context& context, deUint32 vertexCount, deUint32 availableDescriptorCount)
422 const VkDevice device = context.getDevice();
423 const DeviceInterface& deviceInterface = context.getDeviceInterface();
425 const VkFormat imageFormat = VK_FORMAT_R32G32B32A32_SINT;
426 typedef ut::mapVkFormat2Type<imageFormat>::type pixelType;
427 const VkDeviceSize dataSize = vertexCount * sizeof(pixelType);
428 const std::vector<deUint32> primes = ut::generatePrimes(availableDescriptorCount);
429 const deUint32 primeCount = static_cast<deUint32>(primes.size());
431 std::vector<pixelType> data(vertexCount);
432 // e.g. 2,3,5,7,11,13,2,3,5,7,...
433 for (deUint32 idx = 0; idx < vertexCount; ++idx)
435 data[idx].x() = static_cast<pixelType::Element>(primes[idx % primeCount]);
436 data[idx].y() = static_cast<pixelType::Element>(idx);
439 bufferSize = ut::createBufferAndBind(buffer, context, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, dataSize);
440 deMemcpy(buffer->alloc->getHostPtr(), data.data(), static_cast<size_t>(dataSize));
442 const VkBufferViewCreateInfo bufferViewCreateInfo =
444 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // sType
447 *(buffer.get()->buffer), // buffer
448 imageFormat, // format
453 bufferView = ut::BufferViewSp(new Move<VkBufferView>(vk::createBufferView(deviceInterface, device, &bufferViewCreateInfo)));
455 const VkDescriptorSetLayoutBinding binding =
457 BINDING_DescriptorEnumerator, // binding
458 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, // descriptorType
459 1u, // descriptorCount
460 VK_SHADER_STAGE_ALL, // stageFlags
461 DE_NULL, // pImmutableSamplers
464 const VkDescriptorSetLayoutCreateInfo layoutCreateInfo =
466 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
470 &binding, // pBindings
473 descriptorSetLayout = vk::createDescriptorSetLayout(deviceInterface, device, &layoutCreateInfo);
474 descriptorPool = DescriptorPoolBuilder().addType(binding.descriptorType)
475 .build(deviceInterface, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
477 const VkDescriptorSetAllocateInfo dsAllocInfo =
479 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType
481 *descriptorPool, // descriptorPool
482 1u, // descriptorSetCount
483 &(*descriptorSetLayout) // pSetLayouts
486 descriptorSet = vk::allocateDescriptorSet(deviceInterface, device, &dsAllocInfo);
489 void DescriptorEnumerator::update (const vkt::Context& context)
491 const VkDescriptorBufferInfo bufferInfo =
493 *(buffer.get()->buffer), // buffer
498 const VkWriteDescriptorSet writeInfo =
500 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
502 *descriptorSet, // dstSet
503 BINDING_DescriptorEnumerator, // dstBinding
504 0u, // dstArrayElement
505 1u, // descriptorCount
506 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, // descriptorType
507 DE_NULL, // pImageInfo
508 &bufferInfo, // pBufferInfo
509 &(**bufferView), // pTexelBufferView
512 context.getDeviceInterface().updateDescriptorSets(context.getDevice(), 1u, &writeInfo, 0u, DE_NULL);
515 CommonDescriptorInstance::CommonDescriptorInstance (Context& context,
516 const TestParams& testParams)
517 : TestInstance (context)
518 , m_vkd (context.getDevice())
519 , m_vki (context.getDeviceInterface())
520 , m_allocator (context.getDefaultAllocator())
521 , m_queue (context.getUniversalQueue())
522 , m_queueFamilyIndex(context.getUniversalQueueFamilyIndex())
523 , m_commandPool (vk::createCommandPool(m_vki, m_vkd, (VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT), m_queueFamilyIndex))
524 , m_colorFormat (VK_FORMAT_R32G32B32A32_SFLOAT)
525 , m_testParams (testParams)
526 , m_colorScheme (createColorScheme())
527 , m_schemeSize (static_cast<deUint32>(m_colorScheme.size()))
531 deUint32 CommonDescriptorInstance::computeAvailableDescriptorCount (VkDescriptorType descriptorType) const
533 DE_UNREF(descriptorType);
534 const deUint32 vertexCount = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
535 const deUint32 availableDescriptorsOnDevice = ut::DeviceProperties(m_context).computeMaxPerStageDescriptorCount(m_testParams.descriptorType, m_testParams.updateAfterBind);
536 return deMinu32(deMinu32(vertexCount, availableDescriptorsOnDevice), MAX_DESCRIPTORS);
539 Move<VkDescriptorSetLayout> CommonDescriptorInstance::createDescriptorSetLayout (deUint32& descriptorCount) const
541 descriptorCount = computeAvailableDescriptorCount(m_testParams.descriptorType);
543 bool optional = (m_testParams.additionalDescriptorBinding != BINDING_Undefined) && (m_testParams.additionalDescriptorType != VK_DESCRIPTOR_TYPE_UNDEFINED);
545 const VkDescriptorSetLayoutBinding bindings[] =
548 m_testParams.descriptorBinding, // binding
549 m_testParams.descriptorType, // descriptorType
550 descriptorCount, // descriptorCount
551 m_testParams.stageFlags, // stageFlags
552 DE_NULL, // pImmutableSamplers
555 m_testParams.additionalDescriptorBinding, // binding
556 m_testParams.additionalDescriptorType, // descriptorType
557 1, // descriptorCount
558 m_testParams.stageFlags, // stageFlags
559 DE_NULL, // pImmutableSamplers
563 const VkDescriptorBindingFlagsEXT bindingFlagUpdateAfterBind =
564 m_testParams.updateAfterBind ? VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT : 0;
566 const VkDescriptorBindingFlagsEXT bindingFlagsExt[] =
568 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | bindingFlagUpdateAfterBind,
569 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | bindingFlagUpdateAfterBind
572 const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT bindingCreateInfoExt =
574 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
576 optional ? 2u : 1u, // bindingCount
577 bindingFlagsExt, // pBindingFlags
580 const VkDescriptorSetLayoutCreateFlags layoutCreateFlags =
581 m_testParams.updateAfterBind ? VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT : 0;
583 const VkDescriptorSetLayoutCreateInfo layoutCreateInfo =
585 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
586 &bindingCreateInfoExt, // pNext
587 layoutCreateFlags, // flags
588 optional ? 2u : 1u, // bindingCount
589 bindings, // pBindings
592 return vk::createDescriptorSetLayout(m_vki, m_vkd, &layoutCreateInfo);
595 Move<VkDescriptorPool> CommonDescriptorInstance::createDescriptorPool (deUint32 descriptorCount) const
597 const VkDescriptorPoolCreateFlags pcf = m_testParams.updateAfterBind ? VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT : 0;
599 DescriptorPoolBuilder builder;
601 builder.addType(m_testParams.descriptorType, descriptorCount);
603 if (m_testParams.additionalDescriptorType != VK_DESCRIPTOR_TYPE_UNDEFINED && m_testParams.additionalDescriptorBinding != BINDING_Undefined)
605 builder.addType(m_testParams.additionalDescriptorType, 1);
608 return builder.build(m_vki, m_vkd, (VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT | pcf), 1u);
611 Move<VkDescriptorSet> CommonDescriptorInstance::createDescriptorSet (VkDescriptorPool dsPool,
612 VkDescriptorSetLayout dsLayout) const
614 const VkDescriptorSetAllocateInfo dsAllocInfo =
616 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType;
618 dsPool, // descriptorPool;
619 1u, // descriptorSetCount
620 &dsLayout // pSetLayouts
623 return vk::allocateDescriptorSet(m_vki, m_vkd, &dsAllocInfo);
626 void CommonDescriptorInstance::createVertexAttributeBuffer (ut::BufferHandleAllocSp& buffer,
627 deUint32 availableDescriptorCount) const
632 const deUint32 invocationCount = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
633 const std::vector<Vec4> vertices = ut::createVertices(m_testParams.frameResolution.width, m_testParams.frameResolution.height, xSize, ySize);
634 const std::vector<deUint32> primes = ut::generatePrimes(availableDescriptorCount);
635 const deUint32 primeCount = static_cast<deUint32>(primes.size());
637 std::vector<attributes> data(vertices.size());
638 std::transform(vertices.begin(), vertices.end(), data.begin(), attributes());
640 for (deUint32 invIdx = 0; invIdx < invocationCount; ++invIdx)
642 // r: 2,3,5,7,11,13,2,3,5,7,...
643 data[invIdx].index.x() = primes[invIdx % primeCount];
645 // b: x index in texel coordinate
646 data[invIdx].index.z() = invIdx % m_testParams.frameResolution.width;
648 //a: y index in texel coordinate
649 data[invIdx].index.w() = invIdx / m_testParams.frameResolution.width;
652 // g: 0,0,2,3,0,5,0,7,0,0,0,11,0,13,...
653 for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
655 const deUint32 prime = primes[primeIdx];
656 DE_ASSERT(prime < invocationCount);
657 data[prime].index.y() = prime;
660 const VkDeviceSize dataSize = data.size() * sizeof(attributes);
662 VkDeviceSize deviceSize = ut::createBufferAndBind(buffer, m_context, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, dataSize);
664 deMemcpy(buffer->alloc->getHostPtr(), data.data(), static_cast<size_t>(deviceSize));
666 vk::flushAlloc(m_vki, m_vkd, *buffer->alloc);
669 std::string CommonDescriptorInstance::substBinding (deUint32 binding,
674 std::map<std::string, std::string> vars;
675 vars["?"] = de::toString(binding);
676 vars["*"] = (0 == count) ? "" : de::toString(count);
677 vars["VAR"] = (DE_NULL == name) ? "data" : name;
678 return tcu::StringTemplate(str).specialize(vars);
681 const char* CommonDescriptorInstance::getVertexShaderProlog (void)
684 "layout(location = 0) in vec4 in_position; \n"
685 "layout(location = 1) in vec2 in_normalpos; \n"
686 "layout(location = 2) in ivec4 index; \n"
687 "layout(location = 0) out vec4 position; \n"
688 "layout(location = 1) out vec2 normalpos; \n"
689 "layout(location = 2) out int vIndex; \n"
690 "layout(location = 3) out int rIndex; \n"
691 "layout(location = 4) out int gIndex; \n"
692 "layout(location = 5) out int bIndex; \n"
693 "layout(location = 6) out int aIndex; \n"
696 " gl_PointSize = 0.2f; \n"
697 " position = in_position; \n"
698 " normalpos = in_normalpos; \n"
699 " gl_Position = position; \n"
700 " vIndex = gl_VertexIndex; \n"
701 " rIndex = index.x; \n"
702 " gIndex = index.y; \n"
703 " bIndex = index.z; \n"
704 " aIndex = index.w; \n";
707 const char* CommonDescriptorInstance::getFragmentShaderProlog (void)
710 "layout(location = 0) out vec4 FragColor; \n"
711 "layout(location = 0) in flat vec4 position; \n"
712 "layout(location = 1) in flat vec2 normalpos; \n"
713 "layout(location = 2) in flat int vIndex; \n"
714 "layout(location = 3) in flat int rIndex; \n"
715 "layout(location = 4) in flat int gIndex; \n"
716 "layout(location = 5) in flat int bIndex; \n"
717 "layout(location = 6) in flat int aIndex; \n"
722 const char* CommonDescriptorInstance::getShaderEpilog (void)
727 int CommonDescriptorInstance::constructShaderModules (void)
730 tcu::TestLog& log = m_context.getTestContext().getLog();
732 if (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
735 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_COMPUTE_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, false);
736 m_computeModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
738 if (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT)
741 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
742 m_fragmentModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
743 log << tcu::TestLog::Message << "Finally used fragment shader: " << name << '\n' << tcu::TestLog::EndMessage;
745 if (m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT)
748 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
749 m_vertexModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
750 log << tcu::TestLog::Message << "Finally used vertex shader: " << name << '\n' << tcu::TestLog::EndMessage;
753 DE_ASSERT(result > 0);
758 Move<VkRenderPass> CommonDescriptorInstance::createRenderPass (const IterateCommonVariables& variables)
761 if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
763 // Use VK_ATTACHMENT_LOAD_OP_LOAD to make the utility function select initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
764 return vk::makeRenderPass(m_vki, m_vkd, m_colorFormat, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD);
766 return Move<VkRenderPass>();
769 VkPushConstantRange CommonDescriptorInstance::makePushConstantRange (void) const
771 const VkPushConstantRange pcr =
773 m_testParams.stageFlags, // stageFlags
775 static_cast<deUint32>(sizeof(push_constant)) // size
780 Move<VkPipelineLayout> CommonDescriptorInstance::createPipelineLayout (const std::vector<VkDescriptorSetLayout>& descriptorSetLayouts) const
782 const VkPushConstantRange pcr = makePushConstantRange();
784 const VkPipelineLayoutCreateInfo createInfo =
786 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
788 (VkPipelineLayoutCreateFlags)0, // flags
789 static_cast<deUint32>(descriptorSetLayouts.size()), // setLayoutCount
790 descriptorSetLayouts.data(), // pSetLayouts;
791 m_testParams.calculateInLoop ? 1u : 0u, // pushConstantRangeCount
792 m_testParams.calculateInLoop ? &pcr : DE_NULL, // pPushConstantRanges
795 return vk::createPipelineLayout(m_vki, m_vkd, &createInfo);
798 void CommonDescriptorInstance::createFramebuffer (ut::FrameBufferSp& frameBuffer,
799 VkRenderPass renderPass,
800 const IterateCommonVariables& variables)
803 ut::createFrameBuffer(frameBuffer, m_context, m_testParams.frameResolution, m_colorFormat, renderPass);
806 Move<VkPipeline> CommonDescriptorInstance::createPipeline (VkPipelineLayout pipelineLayout,
807 VkRenderPass renderPass)
808 { DE_ASSERT(VK_SHADER_STAGE_ALL != m_testParams.stageFlags);
810 constructShaderModules();
812 return (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
813 ? createComputePipeline(pipelineLayout)
814 : createGraphicsPipeline(pipelineLayout, renderPass);
817 Move<VkPipeline> CommonDescriptorInstance::createComputePipeline (VkPipelineLayout pipelineLayout)
819 const VkPipelineShaderStageCreateInfo shaderStaegCreateInfo =
821 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
823 (VkPipelineShaderStageCreateFlags)0, // flags
824 VK_SHADER_STAGE_COMPUTE_BIT, // stage
825 *m_computeModule, // module
827 (VkSpecializationInfo*)DE_NULL // pSpecializationInfo
830 const VkComputePipelineCreateInfo pipelineCreateInfo =
832 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
835 shaderStaegCreateInfo, // stage
836 pipelineLayout, // layout
837 (VkPipeline)0, // basePipelineHandle
838 0u, // basePipelineIndex
840 return vk::createComputePipeline(m_vki, m_vkd, (VkPipelineCache)0u, &pipelineCreateInfo);
843 Move<VkPipeline> CommonDescriptorInstance::createGraphicsPipeline (VkPipelineLayout pipelineLayout,
844 VkRenderPass renderPass)
846 const VkVertexInputBindingDescription bindingDescriptions[] =
850 sizeof(attributes), // stride
851 VK_VERTEX_INPUT_RATE_VERTEX, // inputRate
855 const VkVertexInputAttributeDescription attributeDescriptions[] =
860 ut::mapType2vkFormat<attributes::vec4>::value, // format
866 ut::mapType2vkFormat<attributes::vec2>::value, // format
867 static_cast<deUint32>(sizeof(attributes::vec4)) // offset
872 ut::mapType2vkFormat<attributes::ivec4>::value, // format
873 static_cast<deUint32>(sizeof(attributes::vec2)
874 + sizeof(attributes::vec4)) // offset
878 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
880 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
882 (VkPipelineVertexInputStateCreateFlags)0, // flags
883 DE_LENGTH_OF_ARRAY(bindingDescriptions), // vertexBindingDescriptionCount
884 bindingDescriptions, // pVertexBindingDescriptions
885 DE_LENGTH_OF_ARRAY(attributeDescriptions), // vertexAttributeDescriptionCount
886 attributeDescriptions // pVertexAttributeDescriptions
889 const VkDynamicState dynamicStates[] =
891 VK_DYNAMIC_STATE_SCISSOR
894 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
896 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // sType
899 DE_LENGTH_OF_ARRAY(dynamicStates), // dynamicStateCount
900 dynamicStates // pDynamicStates
903 const std::vector<VkViewport> viewports (1, makeViewport(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
904 const std::vector<VkRect2D> scissors (1, makeRect2D(0u, 0u));
906 DE_ASSERT(m_vertexModule && m_fragmentModule);
908 return vk::makeGraphicsPipeline(
911 pipelineLayout, // pipelineLayout
912 *m_vertexModule, // vertexShaderModule
913 DE_NULL, // tessellationControlModule
914 DE_NULL, // tessellationEvalModule
915 DE_NULL, // geometryShaderModule
916 *m_fragmentModule, // fragmentShaderModule
917 renderPass, // renderPass
918 viewports, // viewports
919 scissors, // scissors
920 VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // topology
922 0U, // patchControlPoints
923 &vertexInputStateCreateInfo, // vertexInputStateCreateInfo
924 nullptr, // rasterizationStateCreateInfo
925 nullptr, // multisampleStateCreateInfo
926 nullptr, // depthStencilStateCreateInfo
927 nullptr, // colorBlendStateCreateInfo
928 &dynamicStateCreateInfo); // dynamicStateCreateInfo
931 VkDeviceSize CommonDescriptorInstance::createBuffers (std::vector<VkDescriptorBufferInfo>& bufferInfos,
932 ut::BufferHandleAllocSp& buffer,
933 deUint32 elementCount,
934 deUint32 elementSize,
935 VkDeviceSize alignment,
936 VkBufferUsageFlags bufferUsage)
938 const VkDeviceSize roundedSize = deAlign64(elementSize, alignment);
939 VkDeviceSize bufferSize = ut::createBufferAndBind(buffer, m_context, bufferUsage, (roundedSize * elementCount));
941 for (deUint32 elementIdx = 0; elementIdx < elementCount; ++elementIdx)
943 const VkDescriptorBufferInfo bufferInfo =
945 *buffer.get()->buffer, //buffer;
946 elementIdx * roundedSize, //offset;
947 elementSize, // range;
950 bufferInfos.push_back(bufferInfo);
956 VkDeviceSize CommonDescriptorInstance::createImages (std::vector<ut::ImageHandleAllocSp>& images,
957 std::vector<VkDescriptorBufferInfo>& bufferInfos,
958 ut::BufferHandleAllocSp& buffer,
959 VkBufferUsageFlags bufferUsage,
960 const VkExtent3D& imageExtent,
961 VkFormat imageFormat,
962 VkImageLayout imageLayout,
967 const deUint32 imageSize = ut::computeImageSize(imageExtent, imageFormat, withMipMaps);
969 const VkDeviceSize bufferSize = createBuffers(bufferInfos, buffer, imageCount, imageSize, sizeof(tcu::Vec4), bufferUsage);
971 for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
973 ut::ImageHandleAllocSp image;
974 ut::createImageAndBind(image, m_context, imageFormat, imageExtent, imageLayout, withMipMaps);
975 images.push_back(image);
981 void CommonDescriptorInstance::createBuffersViews (std::vector<ut::BufferViewSp>& views,
982 const std::vector<VkDescriptorBufferInfo>& bufferInfos,
985 const deUint32 infoCount = static_cast<deUint32>(bufferInfos.size());
986 for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
988 const VkDescriptorBufferInfo& bufferInfo = bufferInfos[infoIdx];
989 const VkBufferViewCreateInfo bufferViewInfo =
991 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // sType
993 (VkBufferViewCreateFlags)0, // flags
994 bufferInfo.buffer, // buffer
996 bufferInfo.offset, // offset
997 bufferInfo.range // range;
999 views.push_back(ut::BufferViewSp(new Move<VkBufferView>(vk::createBufferView(m_vki, m_vkd, &bufferViewInfo))));
1003 void CommonDescriptorInstance::createImagesViews (std::vector<ut::ImageViewSp>& views,
1004 const std::vector<ut::ImageHandleAllocSp>& images,
1007 const deUint32 imageCount = static_cast<deUint32>(images.size());
1008 for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
1010 const VkImageViewCreateInfo createInfo =
1012 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
1014 (VkImageViewCreateFlags)0, // flags
1015 *images[imageIdx]->image, // image
1016 VK_IMAGE_VIEW_TYPE_2D, // viewType
1018 vk::makeComponentMappingRGBA(), // components
1020 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1021 (deUint32)0, // baseMipLevel
1022 images[imageIdx]->levels, // mipLevels
1023 (deUint32)0, // baseArrayLayer
1024 (deUint32)1u, // arraySize
1027 views.push_back(ut::ImageViewSp(new Move<VkImageView>(vk::createImageView(m_vki, m_vkd, &createInfo))));
1031 void CommonDescriptorInstance::copyBuffersToImages (IterateCommonVariables& variables)
1033 const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1034 DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1035 const VkPipelineStageFlagBits dstStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1036 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1037 : VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
1038 for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1040 ut::recordCopyBufferToImage(
1041 *variables.commandBuffer, // commandBuffer
1043 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // srcStageMask
1044 dstStageMask, // dstStageMask
1045 variables.descriptorsBufferInfos[infoIdx], // bufferInfo
1046 *(variables.descriptorsImages[infoIdx]->image), // image
1047 variables.descriptorsImages[infoIdx]->extent, // imageExtent
1048 variables.descriptorsImages[infoIdx]->format, // imageFormat
1049 VK_IMAGE_LAYOUT_UNDEFINED, // oldImageLayout
1050 VK_IMAGE_LAYOUT_GENERAL, // newImageLayout
1051 variables.descriptorsImages[infoIdx]->levels); // mipLevelCount
1055 void CommonDescriptorInstance::copyImagesToBuffers (IterateCommonVariables& variables)
1057 const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1058 DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1059 const VkPipelineStageFlagBits srcStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1060 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1061 : VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1063 for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1065 ut::recordCopyImageToBuffer(
1066 *variables.commandBuffer, // commandBuffer
1068 srcStageMask, // srcStageMask
1069 VK_PIPELINE_STAGE_HOST_BIT, // dstStageMask
1070 *(variables.descriptorsImages[infoIdx]->image), // image
1071 variables.descriptorsImages[infoIdx]->extent, // imageExtent
1072 variables.descriptorsImages[infoIdx]->format, // imageFormat
1073 VK_IMAGE_LAYOUT_GENERAL, // oldImageLayout
1074 VK_IMAGE_LAYOUT_GENERAL, // newImageLayout
1075 variables.descriptorsBufferInfos[infoIdx]); // bufferInfo
1079 PixelBufferAccess CommonDescriptorInstance::getPixelAccess (deUint32 imageIndex,
1080 const VkExtent3D& imageExtent,
1081 VkFormat imageFormat,
1082 const std::vector<VkDescriptorBufferInfo>& bufferInfos,
1083 const ut::BufferHandleAllocSp& buffer,
1084 deUint32 mipLevel) const
1086 DE_ASSERT(bufferInfos[imageIndex].buffer == *buffer.get()->buffer);
1087 DE_ASSERT(ut::computeImageSize(imageExtent, imageFormat, true, (mipLevel ? ut::maxDeUint32 : 0)) <= bufferInfos[imageIndex].range);
1088 DE_ASSERT(imageExtent.width >> mipLevel);
1089 DE_ASSERT(imageExtent.height >> mipLevel);
1091 deUint32 mipOffset = 0;
1093 for (deUint32 level = 0; mipLevel && level < mipLevel; ++level)
1095 mipOffset += ut::computeImageSize(imageExtent, imageFormat, true, level);
1098 unsigned char* hostPtr = static_cast<unsigned char*>(buffer->alloc->getHostPtr());
1099 unsigned char* data = hostPtr + bufferInfos[imageIndex].offset + mipOffset;
1100 return tcu::PixelBufferAccess(vk::mapVkFormat(imageFormat), (imageExtent.width >> mipLevel), (imageExtent.height >> mipLevel), imageExtent.depth, data);
1103 void CommonDescriptorInstance::updateDescriptors (IterateCommonVariables& variables)
1105 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
1106 const deUint32 primeCount = static_cast<deUint32>(primes.size());
1108 for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
1110 const VkDescriptorBufferInfo* pBufferInfo = DE_NULL;
1111 const VkDescriptorImageInfo* pImageInfo = DE_NULL;
1112 const VkBufferView* pTexelBufferView = DE_NULL;
1114 VkDescriptorImageInfo imageInfo =
1116 static_cast<VkSampler>(0),
1117 static_cast<VkImageView>(0),
1118 VK_IMAGE_LAYOUT_GENERAL
1121 switch (m_testParams.descriptorType)
1123 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1124 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1125 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1126 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1127 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1128 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1130 pBufferInfo = &variables.descriptorsBufferInfos[primeIdx];
1131 switch (m_testParams.descriptorType)
1133 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1134 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1135 pTexelBufferView = &(**variables.descriptorsBufferViews[primeIdx]);
1143 case VK_DESCRIPTOR_TYPE_SAMPLER:
1144 imageInfo.sampler = **variables.descriptorSamplers[primeIdx];
1145 pImageInfo = &imageInfo;
1148 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1149 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1150 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1151 imageInfo.imageView = **variables.descriptorImageViews[primeIdx];
1152 pImageInfo = &imageInfo;
1158 const VkWriteDescriptorSet writeInfo =
1160 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
1162 *variables.descriptorSet, // descriptorSet
1163 m_testParams.descriptorBinding, // descriptorBinding;
1164 primes[primeIdx], // elementIndex
1165 1u, // descriptorCount
1166 m_testParams.descriptorType, // descriptorType
1167 pImageInfo, // pImageInfo
1168 pBufferInfo, // pBufferInfo
1169 pTexelBufferView // pTexelBufferView
1172 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
1176 void CommonDescriptorInstance::iterateCommandSetup (IterateCommonVariables& variables)
1178 variables.dataAlignment = 0;
1180 variables.renderArea.offset.x = 0;
1181 variables.renderArea.offset.y = 0;
1182 variables.renderArea.extent.width = m_testParams.frameResolution.width;
1183 variables.renderArea.extent.height = m_testParams.frameResolution.height;
1185 variables.vertexCount = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
1187 variables.lowerBound = 0;
1188 variables.upperBound = variables.vertexCount;
1190 variables.descriptorSetLayout = createDescriptorSetLayout(variables.availableDescriptorCount);
1191 variables.validDescriptorCount = ut::computePrimeCount(variables.availableDescriptorCount);
1192 variables.descriptorPool = createDescriptorPool(variables.availableDescriptorCount);
1193 variables.descriptorSet = createDescriptorSet(*variables.descriptorPool, *variables.descriptorSetLayout);
1195 std::vector<VkDescriptorSetLayout> descriptorSetLayouts;
1196 descriptorSetLayouts.push_back(*variables.descriptorSetLayout);
1197 if (m_testParams.calculateInLoop)
1199 variables.descriptorEnumerator.init(m_context, variables.vertexCount, variables.availableDescriptorCount);
1200 descriptorSetLayouts.push_back(*variables.descriptorEnumerator.descriptorSetLayout);
1203 variables.pipelineLayout = createPipelineLayout(descriptorSetLayouts);
1205 createAndPopulateDescriptors (variables);
1207 variables.renderPass = createRenderPass(variables);
1208 variables.pipeline = createPipeline(*variables.pipelineLayout, *variables.renderPass);
1210 variables.commandBuffer = createCmdBuffer();
1212 if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1214 createVertexAttributeBuffer (variables.vertexAttributesBuffer, variables.availableDescriptorCount);
1215 createFramebuffer (variables.frameBuffer, *variables.renderPass, variables);
1218 if (m_testParams.calculateInLoop)
1220 variables.descriptorEnumerator.update(m_context);
1223 if (!m_testParams.updateAfterBind)
1225 updateDescriptors (variables);
1230 void CommonDescriptorInstance::iterateCommandBegin (IterateCommonVariables& variables, bool firstPass)
1232 vk::beginCommandBuffer (m_vki, *variables.commandBuffer);
1234 // Clear color attachment, and transition it to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1235 if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1237 const VkImageMemoryBarrier preImageBarrier =
1239 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
1240 DE_NULL, // const void* pNext
1241 0u, // VkAccessFlags srcAccessMask
1242 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1243 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
1244 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout
1245 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
1246 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
1247 *variables.frameBuffer->image->image, // VkImage image
1249 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
1250 0u, // uint32_t baseMipLevel
1251 VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
1252 0u, // uint32_t baseArray
1253 VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
1257 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1258 (VkDependencyFlags)0,
1259 0, (const VkMemoryBarrier*)DE_NULL,
1260 0, (const VkBufferMemoryBarrier*)DE_NULL,
1261 1, &preImageBarrier);
1263 const VkClearColorValue clearColorValue = makeClearValueColor(m_clearColor).color;
1266 m_vki.cmdClearColorImage(*variables.commandBuffer, *variables.frameBuffer->image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColorValue, 1, &preImageBarrier.subresourceRange);
1268 const VkImageMemoryBarrier postImageBarrier =
1270 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
1271 DE_NULL, // const void* pNext
1272 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
1273 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
1274 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout
1275 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout
1276 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
1277 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
1278 *variables.frameBuffer->image->image, // VkImage image
1280 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
1281 0u, // uint32_t baseMipLevel
1282 VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
1283 0u, // uint32_t baseArray
1284 VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
1288 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
1289 (VkDependencyFlags)0,
1290 0, (const VkMemoryBarrier*)DE_NULL,
1291 0, (const VkBufferMemoryBarrier*)DE_NULL,
1292 1, &postImageBarrier);
1296 if (m_testParams.calculateInLoop)
1299 deRandom_init(&rnd, static_cast<deUint32>(m_testParams.descriptorType));
1300 const deUint32 quarter = variables.vertexCount / 4;
1302 variables.lowerBound = deRandom_getUint32(&rnd) % quarter;
1303 variables.upperBound = (deRandom_getUint32(&rnd) % quarter) + (3 * quarter);
1305 const push_constant pc =
1307 static_cast<deInt32>(variables.lowerBound),
1308 static_cast<deInt32>(variables.upperBound)
1311 m_vki.cmdPushConstants(*variables.commandBuffer, *variables.pipelineLayout, m_testParams.stageFlags, 0u, static_cast<deUint32>(sizeof(pc)), &pc);
1314 if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1316 commandBindVertexAttributes (*variables.commandBuffer, variables.vertexAttributesBuffer);
1319 if (m_testParams.calculateInLoop)
1321 commandBindDescriptorSets(*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorEnumerator.descriptorSet, 1);
1324 if (!ut::isDynamicDescriptor(m_testParams.descriptorType))
1326 commandBindDescriptorSets (*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorSet, 0);
1329 commandBindPipeline (*variables.commandBuffer, *variables.pipeline);
1332 tcu::TestStatus CommonDescriptorInstance::iterate (void)
1334 IterateCommonVariables v;
1335 ut::UpdatablePixelBufferAccessPtr programResult;
1336 ut::UpdatablePixelBufferAccessPtr referenceResult;
1338 bool firstPass = true;
1340 iterateCommandSetup (v);
1342 v.renderArea.extent.width = m_testParams.frameResolution.width/4;
1343 v.renderArea.extent.height = m_testParams.frameResolution.height/4;
1345 for (int x = 0; x < 4; x++)
1346 for (int y= 0; y < 4; y++)
1348 iterateCommandBegin (v, firstPass);
1350 if (true == firstPass && true == m_testParams.copyBuffersToImages)
1352 copyBuffersToImages (v);
1357 if (true == m_testParams.updateAfterBind)
1359 updateDescriptors (v);
1362 v.renderArea.offset.x = x * m_testParams.frameResolution.width/4;
1363 v.renderArea.offset.y = y * m_testParams.frameResolution.height/4;
1365 vk::VkRect2D scissor = makeRect2D(v.renderArea.offset.x, v.renderArea.offset.y, v.renderArea.extent.width, v.renderArea.extent.height);
1366 m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
1368 vk::beginRenderPass (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
1369 m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
1370 vk::endRenderPass (m_vki, *v.commandBuffer);
1372 iterateCommandEnd(v, programResult, referenceResult);
1375 return ( iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
1378 std::vector<float> CommonDescriptorInstance::createColorScheme (void)
1380 std::vector<float> cs;
1382 for (int i = 0; i < 10; ++i)
1384 cs.push_back(1.0f / float(divider));
1390 void CommonDescriptorInstance::iterateCommandEnd (IterateCommonVariables& variables,
1391 ut::UpdatablePixelBufferAccessPtr& programResult,
1392 ut::UpdatablePixelBufferAccessPtr& referenceResult,
1393 bool collectBeforeSubmit)
1395 if (collectBeforeSubmit)
1397 iterateCollectResults(programResult, variables, true);
1398 iterateCollectResults(referenceResult, variables, false);
1401 VK_CHECK(m_vki.endCommandBuffer(*variables.commandBuffer));
1402 Move<VkFence> fence = commandSubmit(*variables.commandBuffer);
1403 m_vki.waitForFences(m_vkd, 1, &(*fence), DE_TRUE, ~0ull);
1405 if (false == collectBeforeSubmit)
1407 iterateCollectResults(programResult, variables, true);
1408 iterateCollectResults(referenceResult, variables, false);
1412 bool CommonDescriptorInstance::iterateVerifyResults (IterateCommonVariables& variables,
1413 ut::UpdatablePixelBufferAccessPtr programResult,
1414 ut::UpdatablePixelBufferAccessPtr referenceResult)
1416 bool result = false;
1417 if (m_testParams.fuzzyComparison)
1419 result = tcu::fuzzyCompare(m_context.getTestContext().getLog(),
1420 "Fuzzy Compare", "Comparison result", *referenceResult.get(), *programResult.get(), 0.02f, tcu::COMPARE_LOG_EVERYTHING);
1424 result = tcu::floatThresholdCompare(m_context.getTestContext().getLog(),
1425 "Float Threshold Compare", "Comparison result", *referenceResult.get(), *programResult.get(), tcu::Vec4(0.02f, 0.02f, 0.02f, 0.02f), tcu::COMPARE_LOG_EVERYTHING);
1428 if (m_testParams.allowVertexStoring)
1430 result = verifyVertexWriteResults(variables);
1436 void CommonDescriptorInstance::iterateCollectResults (ut::UpdatablePixelBufferAccessPtr& result,
1437 const IterateCommonVariables& variables,
1442 result = commandReadFrameBuffer(*variables.commandBuffer, variables.frameBuffer);
1446 result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution));
1448 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
1450 for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
1452 const float component = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
1453 result->setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
1459 Move<VkCommandBuffer> CommonDescriptorInstance::createCmdBuffer (void)
1461 return vk::allocateCommandBuffer(m_vki, m_vkd, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1464 Move<VkFence> CommonDescriptorInstance::commandSubmit (VkCommandBuffer cmd)
1466 Move<VkFence> fence(vk::createFence(m_vki, m_vkd));
1468 const VkSubmitInfo submitInfo =
1470 VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
1472 0u, // waitSemaphoreCount
1473 static_cast<VkSemaphore*>(DE_NULL), // pWaitSemaphores
1474 static_cast<const VkPipelineStageFlags*>(DE_NULL), // pWaitDstStageMask
1475 1u, // commandBufferCount
1476 &cmd, // pCommandBuffers
1477 0u, // signalSemaphoreCount
1478 static_cast<VkSemaphore*>(DE_NULL) // pSignalSemaphores
1481 VK_CHECK(m_vki.queueSubmit(m_queue, 1u, &submitInfo, *fence));
1486 bool CommonDescriptorInstance::verifyVertexWriteResults(IterateCommonVariables& variables)
1488 DE_UNREF(variables);
1492 void CommonDescriptorInstance::commandBindPipeline (VkCommandBuffer commandBuffer,
1493 VkPipeline pipeline)
1495 const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1496 m_vki.cmdBindPipeline(commandBuffer, pipelineBindingPoint, pipeline);
1499 void CommonDescriptorInstance::commandBindVertexAttributes (VkCommandBuffer commandBuffer,
1500 const ut::BufferHandleAllocSp& vertexAttributesBuffer)
1502 const VkDeviceSize offsets[] = { 0u };
1503 const VkBuffer buffers[] = { *vertexAttributesBuffer->buffer };
1504 m_vki.cmdBindVertexBuffers(commandBuffer, 0u, 1u, buffers, offsets);
1507 void CommonDescriptorInstance::commandBindDescriptorSets (VkCommandBuffer commandBuffer,
1508 VkPipelineLayout pipelineLayout,
1509 VkDescriptorSet descriptorSet,
1510 deUint32 descriptorSetIndex)
1512 const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1513 m_vki.cmdBindDescriptorSets(commandBuffer, pipelineBindingPoint, pipelineLayout, descriptorSetIndex, 1u, &descriptorSet, 0u, static_cast<deUint32*>(DE_NULL));
1516 ut::UpdatablePixelBufferAccessPtr
1517 CommonDescriptorInstance::commandReadFrameBuffer (VkCommandBuffer commandBuffer,
1518 const ut::FrameBufferSp& frameBuffer)
1520 ut::BufferHandleAllocSp frameBufferContent;
1521 commandReadFrameBuffer(frameBufferContent, commandBuffer, frameBuffer);
1522 return ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessBuffer(
1523 m_vkd, m_vki, vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution,
1524 de::SharedPtr< Move<VkBuffer> >(new Move<VkBuffer>(frameBufferContent->buffer)),
1525 de::SharedPtr< de::MovePtr<Allocation> >(new de::MovePtr<Allocation>(frameBufferContent->alloc))));
1528 void CommonDescriptorInstance::commandReadFrameBuffer (ut::BufferHandleAllocSp& content,
1529 VkCommandBuffer commandBuffer,
1530 const ut::FrameBufferSp& frameBuffer)
1532 Move<VkBuffer> buffer;
1533 de::MovePtr<Allocation> allocation;
1535 const VkDeviceSize bufferSize = ut::computeImageSize(frameBuffer->image);
1537 // create a buffer and an host allocation for it
1539 const VkBufferCreateInfo bufferCreateInfo =
1541 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
1545 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
1546 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
1547 1u, // queueFamilyIndexCoun
1548 &m_queueFamilyIndex // pQueueFamilyIndices
1551 buffer = vk::createBuffer(m_vki, m_vkd, &bufferCreateInfo);
1552 const VkMemoryRequirements memRequirements(vk::getBufferMemoryRequirements(m_vki, m_vkd, *buffer));
1553 allocation = m_allocator.allocate(memRequirements, MemoryRequirement::HostVisible);
1555 VK_CHECK(m_vki.bindBufferMemory(m_vkd, *buffer, allocation->getMemory(), allocation->getOffset()));
1558 const VkImage& image = *frameBuffer->image->image;
1560 VkImageSubresourceRange subresourceRange =
1562 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1565 0u, // baseArrayLayer
1569 const VkImageMemoryBarrier barrierBefore =
1571 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
1573 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // srcAccessMask;
1574 VK_ACCESS_TRANSFER_READ_BIT, // dstAccessMask;
1575 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout
1576 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout;
1577 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
1578 VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex;
1580 subresourceRange // subresourceRange;
1583 const VkBufferImageCopy copyRegion =
1586 frameBuffer->image->extent.width, // bufferRowLength
1587 frameBuffer->image->extent.height, // bufferImageHeight
1588 { // VkImageSubresourceLayers
1589 VK_IMAGE_ASPECT_COLOR_BIT, // aspect
1591 0u, // baseArrayLayer
1594 { 0, 0, 0 }, // imageOffset
1595 frameBuffer->image->extent // imageExtent
1598 const VkBufferMemoryBarrier bufferBarrier =
1600 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType;
1602 VK_ACCESS_TRANSFER_WRITE_BIT, // srcAccessMask;
1603 VK_ACCESS_HOST_READ_BIT, // dstAccessMask;
1604 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
1605 VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex;
1611 const VkImageMemoryBarrier barrierAfter =
1613 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
1615 VK_ACCESS_TRANSFER_READ_BIT, // srcAccessMask;
1616 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // dstAccessMask;
1617 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // oldLayout;
1618 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout;
1619 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
1620 VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex;
1622 subresourceRange // subresourceRange
1626 m_vki.cmdPipelineBarrier(commandBuffer, // commandBuffer
1627 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, // srcStageMask, dstStageMask
1628 (VkDependencyFlags)0, // dependencyFlags
1629 0u, DE_NULL, // memoryBarrierCount, pMemoryBarriers
1630 0u, DE_NULL, // bufferBarrierCount, pBufferBarriers
1631 1u, &barrierBefore); // imageBarrierCount, pImageBarriers
1633 m_vki.cmdCopyImageToBuffer(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, ©Region);
1635 m_vki.cmdPipelineBarrier(commandBuffer,
1636 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
1637 (VkDependencyFlags)0,
1642 content = ut::BufferHandleAllocSp(new ut::BufferHandleAlloc(buffer, allocation));
1645 std::string CommonDescriptorInstance::getColorAccess (VkDescriptorType descriptorType,
1646 const char* indexVariableName,
1650 std::map<std::string, std::string> vars;
1651 vars["INDEX"] = indexVariableName;
1653 switch (descriptorType)
1655 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1656 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1657 text = "data[nonuniformEXT(${INDEX})].c";
1659 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1660 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1661 text = "data[nonuniformEXT(${INDEX})].cold";
1663 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1664 text = "subpassLoad(data[nonuniformEXT(${INDEX})]).rgba";
1666 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1667 text = "texelFetch(data[nonuniformEXT(${INDEX})], 0)";
1669 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1670 text = "imageLoad(data[nonuniformEXT(${INDEX})], 0)";
1672 case VK_DESCRIPTOR_TYPE_SAMPLER:
1674 ? "textureLod(sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos, 1)"
1675 : "texture( sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos )";
1677 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1679 ? "textureLod( sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0), textureQueryLevels(sampler2D(data[nonuniformEXT(${INDEX})], samp[0]))-1)"
1680 : "texture( sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0) )";
1682 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1684 ? "textureLod( data[nonuniformEXT(${INDEX})], uvec2(0,0), textureQueryLevels(data[nonuniformEXT(${INDEX})])-1)"
1685 : "texture( data[nonuniformEXT(${INDEX})], uvec2(0,0) )";
1688 TCU_THROW(InternalError, "Not implemented descriptor type");
1691 return tcu::StringTemplate(text).specialize(vars);
1694 std::string CommonDescriptorInstance::getFragmentReturnSource (const std::string& colorAccess)
1696 return " FragColor = " + colorAccess + ";\n";
1699 std::string CommonDescriptorInstance::getFragmentLoopSource (const std::string& colorAccess1,
1700 const std::string& colorAccess2)
1702 std::map < std::string, std::string > vars;
1703 vars["COLOR_ACCESS_1"] = colorAccess1;
1704 vars["COLOR_ACCESS_2"] = colorAccess2;
1707 " vec4 sumClr1 = vec4(0,0,0,0); \n"
1708 " vec4 sumClr2 = vec4(0,0,0,0); \n"
1709 " for (int i = pc.lowerBound; i < pc.upperBound; ++i) \n"
1711 " int loopIdx = texelFetch(iter, i).x; \n"
1712 " sumClr1 += ${COLOR_ACCESS_2} + ${COLOR_ACCESS_1}; \n"
1713 " sumClr2 += ${COLOR_ACCESS_2}; \n"
1715 " FragColor = vec4(((sumClr1 - sumClr2) / float(pc.upperBound - pc.lowerBound)).rgb, 1); \n";
1717 return tcu::StringTemplate(s).specialize(vars);
1720 bool CommonDescriptorInstance::performWritesInVertex (VkDescriptorType descriptorType)
1722 bool result = false;
1724 switch (descriptorType)
1726 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1727 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1728 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1739 bool CommonDescriptorInstance::performWritesInVertex (VkDescriptorType descriptorType,
1740 const Context& context)
1742 bool result = false;
1744 ut::DeviceProperties dp (context);
1745 const VkPhysicalDeviceFeatures& feats = dp.physicalDeviceFeatures();
1747 if (feats.vertexPipelineStoresAndAtomics != DE_FALSE)
1749 result = CommonDescriptorInstance::performWritesInVertex(descriptorType);
1755 std::string CommonDescriptorInstance::getShaderSource (VkShaderStageFlagBits shaderType,
1756 const TestCaseParams& testCaseParams,
1757 bool allowVertexStoring)
1759 std::stringstream s;
1761 s << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << '\n';
1762 s << "#extension GL_EXT_nonuniform_qualifier : require \n";
1764 if (testCaseParams.calculateInLoop)
1766 s << "layout(push_constant) uniform Block { int lowerBound, upperBound; } pc;\n";
1767 s << substBinding(BINDING_DescriptorEnumerator,
1768 "layout(set=1,binding=${?}) uniform isamplerBuffer iter; \n");
1771 switch (testCaseParams.descriptorType)
1773 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1774 s << substBinding(BINDING_StorageBuffer,
1775 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1777 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1778 s << substBinding(BINDING_StorageBufferDynamic,
1779 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1781 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1782 s << substBinding(BINDING_UniformBuffer,
1783 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1785 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1786 s << substBinding(BINDING_UniformBufferDynamic,
1787 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1789 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1790 s << substBinding(BINDING_StorageTexelBuffer,
1791 "layout(set=0,binding=${?},rgba32f) uniform imageBuffer data[];\n");
1793 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1794 s << "#extension GL_EXT_texture_buffer : require \n";
1795 s << substBinding(BINDING_UniformTexelBuffer,
1796 "layout(set=0,binding=${?}) uniform samplerBuffer data[];\n");
1798 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1799 // Left for the consistent of code.
1800 // Header is set one swicth below
1802 case VK_DESCRIPTOR_TYPE_SAMPLER:
1803 s << "#extension GL_EXT_texture_buffer : require \n";
1804 s << substBinding(BINDING_SampledImage,
1805 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n", 1, "tex");
1806 s << substBinding(BINDING_Sampler,
1807 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n");
1809 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1810 s << "#extension GL_EXT_texture_buffer : require \n";
1811 s << substBinding(BINDING_Sampler,
1812 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n", 1, "samp");
1813 s << substBinding(BINDING_SampledImage,
1814 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n");
1816 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1817 s << "#extension GL_EXT_texture_buffer : require \n";
1818 s << substBinding(BINDING_CombinedImageSampler,
1819 "layout(set=0,binding=${?}) uniform sampler2D data[];\n");
1821 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1822 s << "layout(local_size_x=1,local_size_y=1,local_size_z=1) in; \n";
1823 s << substBinding(BINDING_StorageImage + 1,
1824 "layout(r32ui,set=0,binding=${?}) uniform uimage2D idxs; \n");
1825 s << substBinding(BINDING_StorageImage,
1826 "layout(r32ui,set=0,binding=${?}) uniform uimage2D data[]; \n");
1829 TCU_THROW(InternalError, "Not implemented descriptor type");
1834 case VK_SHADER_STAGE_VERTEX_BIT: s << getVertexShaderProlog(); break;
1835 case VK_SHADER_STAGE_FRAGMENT_BIT:
1837 if (testCaseParams.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1839 s << substBinding(BINDING_InputAttachment,
1840 "layout(input_attachment_index=1,set=0,binding=${?}) uniform subpassInput data[]; \n");
1842 s << getFragmentShaderProlog();
1845 case VK_SHADER_STAGE_COMPUTE_BIT:
1848 TCU_THROW(InternalError, "Not implemented shader stage");
1853 case VK_SHADER_STAGE_VERTEX_BIT:
1855 switch (testCaseParams.descriptorType)
1857 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1858 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1859 if (allowVertexStoring)
1860 s << " if (gIndex != 0) data[nonuniformEXT(gIndex)].cnew = data[nonuniformEXT(rIndex)].cold; \n";
1862 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1863 if (allowVertexStoring)
1864 s << " if (gIndex != 0) imageStore(data[nonuniformEXT(gIndex)], 1, imageLoad(data[nonuniformEXT(rIndex)], 0)); \n";
1866 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1867 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1868 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1869 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1870 case VK_DESCRIPTOR_TYPE_SAMPLER:
1871 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1872 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1876 TCU_THROW(InternalError, "Not implemented descriptor type");
1881 case VK_SHADER_STAGE_FRAGMENT_BIT:
1883 switch (testCaseParams.descriptorType)
1885 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1886 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1887 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1889 if (testCaseParams.calculateInLoop)
1890 s << getFragmentLoopSource(
1891 getColorAccess(testCaseParams.descriptorType, "rIndex", false),
1892 getColorAccess(testCaseParams.descriptorType, "loopIdx", false));
1894 s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", false));
1897 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1898 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1899 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1900 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1901 case VK_DESCRIPTOR_TYPE_SAMPLER:
1902 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1903 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1904 if (testCaseParams.calculateInLoop)
1905 s << getFragmentLoopSource(
1906 getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps),
1907 getColorAccess(testCaseParams.descriptorType, "loopIdx", testCaseParams.usesMipMaps));
1909 s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps));
1911 default: TCU_THROW(InternalError, "Not implemented descriptor type");
1916 case VK_SHADER_STAGE_COMPUTE_BIT: // VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
1917 s << "void main(void)\n{\n";
1918 if (testCaseParams.calculateInLoop)
1919 s << " for (int i = pc.lowerBound; i < pc.upperBound; ++i) \n"
1920 " imageAtomicAdd(data[nonuniformEXT(texelFetch(iter, i).x)], ivec2(0, 0), 1); \n";
1922 s << " uvec4 c = imageLoad(idxs, ivec2(gl_WorkGroupID.x, gl_WorkGroupID.y)); \n"
1923 " imageAtomicAdd( data[nonuniformEXT(c.r)], ivec2(0, 0), 1); \n";
1926 default: TCU_THROW(InternalError, "Not implemented shader stage");
1929 s << getShaderEpilog();
1934 class StorageBufferInstance : virtual public CommonDescriptorInstance
1937 StorageBufferInstance (Context& context,
1938 const TestCaseParams& testCaseParams);
1940 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
1942 virtual bool verifyVertexWriteResults (IterateCommonVariables& variables);
1945 StorageBufferInstance::StorageBufferInstance (Context& context,
1946 const TestCaseParams& testCaseParams)
1947 : CommonDescriptorInstance(context,
1948 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
1949 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1950 BINDING_StorageBuffer,
1951 VK_DESCRIPTOR_TYPE_UNDEFINED,
1954 performWritesInVertex(testCaseParams.descriptorType, context),
1959 void StorageBufferInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
1961 BindingStorageBuffer::Data data;
1963 bool vertexStores = false;
1965 ut::DeviceProperties dp(m_context);
1966 vertexStores = dp.physicalDeviceFeatures().vertexPipelineStoresAndAtomics != DE_FALSE;
1968 const deUint32 alignment = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minStorageBufferOffsetAlignment);
1969 createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1971 unsigned char* buffer = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1972 for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
1974 const float component = m_colorScheme[infoIdx % m_schemeSize];
1975 const tcu::Vec4 color (component, component, component, 1.0f);
1976 VkDescriptorBufferInfo& info = variables.descriptorsBufferInfos[infoIdx];
1977 data.cnew = vertexStores ? m_clearColor : color;
1980 deMemcpy(buffer + info.offset, &data, sizeof(data));
1982 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
1984 variables.dataAlignment = deAlign64(sizeof(data), alignment);
1987 bool StorageBufferInstance::verifyVertexWriteResults (IterateCommonVariables& variables)
1989 const tcu::Vec4 threshold (0.002f, 0.002f, 0.002f, 0.002f);
1990 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
1992 unsigned char* buffer = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1993 BindingStorageBuffer::Data data;
1994 for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
1996 const deUint32 prime = primes[primeIdx];
1997 const float component = m_colorScheme[(prime % variables.validDescriptorCount) % m_schemeSize];
1998 const tcu::Vec4 referenceValue(component, component, component, 1.0f);
2000 VkDescriptorBufferInfo& info = variables.descriptorsBufferInfos[primeIdx];
2001 deMemcpy(&data, buffer + info.offset, sizeof(data));
2002 const tcu::Vec4 realValue = data.cnew;
2004 const tcu::Vec4 diff = tcu::absDiff(referenceValue, realValue);
2005 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
2011 class UniformBufferInstance : virtual public CommonDescriptorInstance
2014 UniformBufferInstance (Context& context,
2015 const TestCaseParams& testCaseParams);
2017 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2020 UniformBufferInstance::UniformBufferInstance (Context& context,
2021 const TestCaseParams& testCaseParams)
2022 : CommonDescriptorInstance(context,
2023 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2024 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
2025 BINDING_UniformBuffer,
2026 VK_DESCRIPTOR_TYPE_UNDEFINED,
2029 performWritesInVertex(testCaseParams.descriptorType, context),
2034 void UniformBufferInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2036 BindingUniformBuffer::Data data;
2038 const deUint32 alignment = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minUniformBufferOffsetAlignment);
2039 createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
2041 unsigned char* buffer = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
2042 for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
2044 const float component = m_colorScheme[infoIdx % m_schemeSize];
2045 VkDescriptorBufferInfo& info = variables.descriptorsBufferInfos[infoIdx];
2046 data.c = tcu::Vec4(component, component, component, 1.0f);
2047 deMemcpy(buffer + info.offset, &data, sizeof(data));
2049 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2051 variables.dataAlignment = deAlign64(sizeof(data), alignment);
2054 class StorageTexelInstance : public CommonDescriptorInstance
2057 StorageTexelInstance (Context& context,
2058 const TestCaseParams& testCaseParams);
2060 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2062 virtual bool verifyVertexWriteResults (IterateCommonVariables& variables);
2065 StorageTexelInstance::StorageTexelInstance (Context& context,
2066 const TestCaseParams& testCaseParams)
2067 : CommonDescriptorInstance(context,
2068 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2069 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
2070 BINDING_StorageTexelBuffer,
2071 VK_DESCRIPTOR_TYPE_UNDEFINED,
2074 performWritesInVertex(testCaseParams.descriptorType, context),
2079 void StorageTexelInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2081 const VkExtent3D imageExtent = { 4, 4, 1 };
2082 const deUint32 imageSize = ut::computeImageSize(imageExtent, m_colorFormat);
2084 createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
2085 createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2087 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2089 const float component = m_colorScheme[imageIdx % m_schemeSize];
2090 const PixelBufferAccess pa = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2092 tcu::clear(pa, m_clearColor);
2093 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2095 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2098 bool StorageTexelInstance::verifyVertexWriteResults(IterateCommonVariables& variables)
2100 const VkExtent3D imageExtent = { 4, 4, 1 };
2101 const tcu::Vec4 threshold (0.002f, 0.002f, 0.002f, 0.002f);
2102 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2104 for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
2106 const deUint32 prime = primes[primeIdx];
2107 const float component = m_colorScheme[( prime % variables.validDescriptorCount ) % m_schemeSize];
2108 const tcu::Vec4 referenceValue(component, component, component, 1.0f);
2110 const PixelBufferAccess pa = getPixelAccess(primeIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2111 const tcu::Vec4 realValue = pa.getPixel(1, 0);
2113 const tcu::Vec4 diff = tcu::absDiff(referenceValue, realValue);
2114 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
2120 class UniformTexelInstance : public CommonDescriptorInstance
2123 UniformTexelInstance (Context& context,
2124 const TestCaseParams& testCaseParams);
2126 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2129 UniformTexelInstance::UniformTexelInstance (Context& context,
2130 const TestCaseParams& testCaseParams)
2131 : CommonDescriptorInstance(context,
2132 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2133 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
2134 BINDING_UniformTexelBuffer,
2135 VK_DESCRIPTOR_TYPE_UNDEFINED,
2138 performWritesInVertex(testCaseParams.descriptorType, context),
2143 void UniformTexelInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2145 const VkExtent3D imageExtent = { 4, 4, 1 };
2146 const deUint32 imageSize = ut::computeImageSize(imageExtent, m_colorFormat);
2148 createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
2149 createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2151 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2153 const float component = m_colorScheme[imageIdx % m_schemeSize];
2154 const PixelBufferAccess pa = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2156 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2158 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2161 class DynamicBuffersInstance : virtual public CommonDescriptorInstance
2164 DynamicBuffersInstance (Context& context,
2165 const TestParams& testParams)
2166 : CommonDescriptorInstance(context, testParams) {}
2169 virtual tcu::TestStatus iterate (void);
2170 virtual void updateDescriptors (IterateCommonVariables& variables);
2173 void DynamicBuffersInstance::updateDescriptors (IterateCommonVariables& variables)
2175 DE_ASSERT(variables.dataAlignment);
2177 VkDescriptorBufferInfo bufferInfo =
2179 *variables.descriptorsBuffer.get()->buffer,
2180 0, // always 0, it will be taken from pDynamicOffsets
2181 variables.dataAlignment
2184 VkWriteDescriptorSet updateInfo =
2186 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
2188 *variables.descriptorSet, // descriptorSet
2189 m_testParams.descriptorBinding, // descriptorBinding;
2190 0, // to be set in below loop // dstArrayElement
2191 1u, // descriptorCount
2192 m_testParams.descriptorType, // descriptorType
2193 DE_NULL, // pImageInfo
2194 &bufferInfo, // pBufferInfo
2195 DE_NULL // pTexelBufferView
2198 deUint32 descIdx = 0;
2199 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2200 for (deUint32 validIdx = 0; validIdx < variables.validDescriptorCount; ++validIdx)
2202 for (; descIdx < primes[validIdx]; ++descIdx)
2204 updateInfo.dstArrayElement = descIdx;
2205 m_vki.updateDescriptorSets (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2208 updateInfo.dstArrayElement = primes[validIdx];
2209 m_vki.updateDescriptorSets (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2213 for (; descIdx < variables.availableDescriptorCount; ++descIdx)
2215 updateInfo.dstArrayElement = descIdx;
2216 m_vki.updateDescriptorSets(m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2220 tcu::TestStatus DynamicBuffersInstance::iterate (void)
2222 IterateCommonVariables v;
2223 iterateCommandSetup (v);
2225 ut::UpdatablePixelBufferAccessPtr programResult;
2226 ut::UpdatablePixelBufferAccessPtr referenceResult;
2227 bool firstPass = true;
2229 DE_ASSERT(v.dataAlignment);
2231 std::vector<deUint32> dynamicOffsets;
2233 deUint32 descIdx = 0;
2234 const std::vector<deUint32> primes = ut::generatePrimes(v.availableDescriptorCount);
2235 for (deUint32 validIdx = 0; validIdx < v.validDescriptorCount; ++validIdx)
2237 for (; descIdx < primes[validIdx]; ++descIdx)
2239 dynamicOffsets.push_back(0);
2242 dynamicOffsets.push_back(static_cast<deUint32>(validIdx * v.dataAlignment));
2246 for (; descIdx < v.availableDescriptorCount; ++descIdx)
2248 dynamicOffsets.push_back(0);
2251 // Unfortunatelly not lees and not more, only exactly
2252 DE_ASSERT(dynamicOffsets.size() == v.availableDescriptorCount);
2254 const VkDescriptorSet descriptorSets[] = { *v.descriptorSet };
2256 v.renderArea.extent.width = m_testParams.frameResolution.width/4;
2257 v.renderArea.extent.height = m_testParams.frameResolution.height/4;
2259 for (int x = 0; x < 4; x++)
2260 for (int y= 0; y < 4; y++)
2263 v.renderArea.offset.x = x * m_testParams.frameResolution.width/4;
2264 v.renderArea.offset.y = y * m_testParams.frameResolution.height/4;
2266 iterateCommandBegin (v, firstPass);
2269 m_vki.cmdBindDescriptorSets(
2270 *v.commandBuffer, // commandBuffer
2271 VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
2272 *v.pipelineLayout, // layout
2274 DE_LENGTH_OF_ARRAY(descriptorSets), // descriptorSetCount
2275 descriptorSets, // pDescriptorSets
2276 v.availableDescriptorCount, // dynamicOffsetCount
2277 dynamicOffsets.data()); // pDynamicOffsets
2279 vk::VkRect2D scissor = makeRect2D(v.renderArea.offset.x, v.renderArea.offset.y, v.renderArea.extent.width, v.renderArea.extent.height);
2280 m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
2282 vk::beginRenderPass (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
2283 m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
2284 vk::endRenderPass (m_vki, *v.commandBuffer);
2286 iterateCommandEnd(v, programResult, referenceResult);
2289 return (iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
2292 class DynamicStorageBufferInstance : public DynamicBuffersInstance, public StorageBufferInstance
2295 DynamicStorageBufferInstance (Context& context,
2296 const TestCaseParams& testCaseParams);
2297 tcu::TestStatus iterate (void);
2298 void createAndPopulateDescriptors (IterateCommonVariables& variables);
2299 void updateDescriptors (IterateCommonVariables& variables);
2300 bool verifyVertexWriteResults (IterateCommonVariables& variables);
2303 DynamicStorageBufferInstance::DynamicStorageBufferInstance (Context& context,
2304 const TestCaseParams& testCaseParams)
2305 : CommonDescriptorInstance(context,
2306 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2307 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
2308 BINDING_StorageBufferDynamic,
2309 VK_DESCRIPTOR_TYPE_UNDEFINED,
2312 performWritesInVertex(testCaseParams.descriptorType, context),
2314 DynamicBuffersInstance(context, m_testParams), StorageBufferInstance(context, testCaseParams)
2318 tcu::TestStatus DynamicStorageBufferInstance::iterate(void)
2320 return DynamicBuffersInstance::iterate();
2323 void DynamicStorageBufferInstance::createAndPopulateDescriptors(IterateCommonVariables& variables)
2325 StorageBufferInstance::createAndPopulateDescriptors(variables);
2328 void DynamicStorageBufferInstance::updateDescriptors(IterateCommonVariables& variables)
2330 DynamicBuffersInstance::updateDescriptors(variables);
2333 bool DynamicStorageBufferInstance::verifyVertexWriteResults(IterateCommonVariables& variables)
2335 return StorageBufferInstance::verifyVertexWriteResults(variables);
2338 class DynamicUniformBufferInstance : public DynamicBuffersInstance, public UniformBufferInstance
2341 DynamicUniformBufferInstance (Context& context,
2342 const TestCaseParams& testCaseParams);
2343 tcu::TestStatus iterate(void);
2344 void createAndPopulateDescriptors(IterateCommonVariables& variables);
2345 void updateDescriptors(IterateCommonVariables& variables);
2348 DynamicUniformBufferInstance::DynamicUniformBufferInstance (Context& context,
2349 const TestCaseParams& testCaseParams)
2350 : CommonDescriptorInstance(context,
2351 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2352 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
2353 BINDING_UniformBufferDynamic,
2354 VK_DESCRIPTOR_TYPE_UNDEFINED,
2357 performWritesInVertex(testCaseParams.descriptorType, context),
2359 DynamicBuffersInstance(context, m_testParams), UniformBufferInstance(context, testCaseParams)
2363 tcu::TestStatus DynamicUniformBufferInstance::iterate(void)
2365 return DynamicBuffersInstance::iterate();
2368 void DynamicUniformBufferInstance::createAndPopulateDescriptors(IterateCommonVariables& variables)
2370 UniformBufferInstance::createAndPopulateDescriptors(variables);
2373 void DynamicUniformBufferInstance::updateDescriptors(IterateCommonVariables& variables)
2375 DynamicBuffersInstance::updateDescriptors(variables);
2378 class InputAttachmentInstance : public CommonDescriptorInstance
2381 InputAttachmentInstance (Context& context,
2382 const TestCaseParams& testCaseParams);
2384 virtual Move<VkRenderPass> createRenderPass (const IterateCommonVariables& variables);
2385 virtual void createFramebuffer (ut::FrameBufferSp& frameBuffer,
2386 VkRenderPass renderPass,
2387 const IterateCommonVariables& variables);
2388 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2391 InputAttachmentInstance::InputAttachmentInstance (Context& context,
2392 const TestCaseParams& testCaseParams)
2393 : CommonDescriptorInstance(context,
2394 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2395 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2396 BINDING_InputAttachment,
2397 VK_DESCRIPTOR_TYPE_UNDEFINED,
2400 performWritesInVertex(testCaseParams.descriptorType, context),
2405 void InputAttachmentInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2407 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2408 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, m_testParams.frameResolution, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2409 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2411 for (deUint32 descriptorIdx = 0; descriptorIdx < variables.validDescriptorCount; ++descriptorIdx)
2413 const float component = m_colorScheme[descriptorIdx % m_schemeSize];
2414 const tcu::PixelBufferAccess pa = getPixelAccess(descriptorIdx, m_testParams.frameResolution, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2415 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2417 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2420 Move<VkRenderPass> InputAttachmentInstance::createRenderPass (const IterateCommonVariables& variables)
2422 std::vector<VkAttachmentDescription> attachmentDescriptions;
2423 std::vector<VkAttachmentReference> inputAttachmentRefs;
2425 const VkAttachmentDescription colorAttachmentDescription =
2427 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
2428 m_colorFormat, // VkFormat format;
2429 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
2430 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
2431 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2432 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
2433 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
2434 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
2435 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
2437 const VkAttachmentReference colorAttachmentRef =
2439 0u, // deUint32 attachment;
2440 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2442 attachmentDescriptions.push_back(colorAttachmentDescription);
2444 // build input atachments
2446 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2447 const deUint32 inputCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2448 for (deUint32 inputIdx = 0; inputIdx < inputCount; ++inputIdx)
2450 // primes holds the indices of input attachments for shader binding 10 which has input_attachment_index=1
2451 deUint32 nextInputAttachmentIndex = primes[inputIdx] + 1;
2453 // Fill up the subpass description's input attachments with unused attachments forming gaps to the next referenced attachment
2454 for (deUint32 unusedIdx = static_cast<deUint32>(inputAttachmentRefs.size()); unusedIdx < nextInputAttachmentIndex; ++unusedIdx)
2456 const VkAttachmentReference inputAttachmentRef =
2458 VK_ATTACHMENT_UNUSED, // deUint32 attachment;
2459 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
2462 inputAttachmentRefs.push_back(inputAttachmentRef);
2465 const VkAttachmentDescription inputAttachmentDescription =
2467 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, // VkAttachmentDescriptionFlags flags;
2468 variables.descriptorsImages[inputIdx]->format, // VkFormat format;
2469 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
2470 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
2471 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2472 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
2473 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
2474 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
2475 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
2478 const VkAttachmentReference inputAttachmentRef =
2480 inputIdx + 1, // deUint32 attachment;
2481 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
2484 inputAttachmentRefs.push_back(inputAttachmentRef);
2485 attachmentDescriptions.push_back(inputAttachmentDescription);
2489 const VkSubpassDescription subpassDescription =
2491 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
2492 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2493 static_cast<deUint32>(inputAttachmentRefs.size()), // deUint32 inputAttachmentCount;
2494 inputAttachmentRefs.data(), // const VkAttachmentReference* pInputAttachments;
2495 1u, // deUint32 colorAttachmentCount;
2496 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments;
2497 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2498 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
2499 0u, // deUint32 preserveAttachmentCount;
2500 DE_NULL // const deUint32* pPreserveAttachments;
2503 const VkRenderPassCreateInfo renderPassInfo =
2505 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
2506 DE_NULL, // const void* pNext;
2507 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
2508 static_cast<deUint32>(attachmentDescriptions.size()), // deUint32 attachmentCount;
2509 attachmentDescriptions.data(), // const VkAttachmentDescription* pAttachments;
2510 1u, // deUint32 subpassCount;
2511 &subpassDescription, // const VkSubpassDescription* pSubpasses;
2512 0u, // deUint32 dependencyCount;
2513 DE_NULL // const VkSubpassDependency* pDependencies;
2516 return vk::createRenderPass(m_vki, m_vkd, &renderPassInfo);
2519 void InputAttachmentInstance::createFramebuffer (ut::FrameBufferSp& frameBuffer,
2520 VkRenderPass renderPass,
2521 const IterateCommonVariables& variables)
2523 std::vector<VkImageView> inputAttachments;
2524 const deUint32 viewCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2525 inputAttachments.resize(viewCount);
2526 for (deUint32 viewIdx = 0; viewIdx < viewCount; ++viewIdx)
2528 inputAttachments[viewIdx] = **variables.descriptorImageViews[viewIdx];
2530 ut::createFrameBuffer(frameBuffer, m_context, m_testParams.frameResolution, m_colorFormat, renderPass, viewCount, inputAttachments.data());
2533 class SamplerInstance : public CommonDescriptorInstance
2536 SamplerInstance (Context& context,
2537 const TestCaseParams& testCaseParams);
2539 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2540 virtual void updateDescriptors (IterateCommonVariables& variables);
2543 SamplerInstance::SamplerInstance (Context& context,
2544 const TestCaseParams& testCaseParams)
2545 : CommonDescriptorInstance(context,
2546 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2547 VK_DESCRIPTOR_TYPE_SAMPLER,
2549 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2550 BINDING_SampledImage,
2552 performWritesInVertex(testCaseParams.descriptorType, context),
2557 void SamplerInstance::updateDescriptors (IterateCommonVariables& variables)
2559 DE_ASSERT(variables.descriptorsImages.size() == 1);
2560 DE_ASSERT(variables.descriptorImageViews.size() == 1);
2561 DE_ASSERT(variables.descriptorsBufferInfos.size() == 1);
2562 DE_ASSERT(m_testParams.additionalDescriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
2563 DE_ASSERT(variables.descriptorSamplers.size() == variables.validDescriptorCount);
2567 const VkDescriptorImageInfo imageInfo =
2569 static_cast<VkSampler>(0),
2570 **variables.descriptorImageViews[0],
2571 VK_IMAGE_LAYOUT_GENERAL
2574 const VkWriteDescriptorSet writeInfo =
2576 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
2578 *variables.descriptorSet, // descriptorSet
2579 BINDING_SampledImage, // descriptorBinding;
2581 1u, // descriptorCount
2582 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
2583 &imageInfo, // pImageInfo
2584 DE_NULL, // pBufferInfo
2585 DE_NULL // pTexelBufferView
2588 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2592 CommonDescriptorInstance::updateDescriptors(variables);
2595 void SamplerInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2597 DE_ASSERT(variables.descriptorsImages.size() == 0);
2598 DE_ASSERT(variables.descriptorImageViews.size() == 0);
2599 DE_ASSERT(variables.descriptorsBufferInfos.size() == 0);
2600 DE_ASSERT(variables.descriptorSamplers.size() == 0);
2602 // create and populate an image
2604 VkExtent3D imageExtent = m_testParams.frameResolution;
2605 if (m_testParams.usesMipMaps)
2607 imageExtent.width *= 2;
2608 imageExtent.height *= 2;
2611 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2612 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
2613 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2615 PixelBufferAccess pa = getPixelAccess(0, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, m_testParams.usesMipMaps ? 1 : 0);
2617 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
2619 for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
2621 const float component = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
2622 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
2626 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2629 const tcu::Sampler sampler(
2630 tcu::Sampler::CLAMP_TO_BORDER, // wrapS
2631 tcu::Sampler::CLAMP_TO_BORDER, // wrapT
2632 tcu::Sampler::CLAMP_TO_BORDER, // wrapR
2633 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // minFilter
2634 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // magFilter
2635 0.0f, // lodTreshold
2636 true); // normalizeCoords
2637 const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2638 variables.descriptorSamplers.resize(variables.validDescriptorCount);
2640 for (deUint32 samplerIdx = 0; samplerIdx < variables.validDescriptorCount; ++samplerIdx)
2642 variables.descriptorSamplers[samplerIdx] = ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo)));
2646 class SampledImageInstance : public CommonDescriptorInstance
2649 SampledImageInstance (Context& context,
2650 const TestCaseParams& testCaseParams);
2652 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2653 virtual void updateDescriptors (IterateCommonVariables& variables);
2656 SampledImageInstance::SampledImageInstance (Context& context,
2657 const TestCaseParams& testCaseParams)
2658 : CommonDescriptorInstance(context,
2659 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2660 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2661 BINDING_SampledImage,
2662 VK_DESCRIPTOR_TYPE_SAMPLER,
2665 performWritesInVertex(testCaseParams.descriptorType, context),
2670 void SampledImageInstance::updateDescriptors (IterateCommonVariables& variables)
2672 DE_ASSERT(variables.descriptorSamplers.size() == 1);
2673 DE_ASSERT(variables.descriptorsImages.size() == variables.validDescriptorCount);
2674 DE_ASSERT(variables.descriptorImageViews.size() == variables.validDescriptorCount);
2675 DE_ASSERT(variables.descriptorsBufferInfos.size() == variables.validDescriptorCount);
2679 const VkDescriptorImageInfo samplerInfo =
2681 **variables.descriptorSamplers[0],
2682 static_cast<VkImageView>(0),
2683 static_cast<VkImageLayout>(0)
2686 const VkWriteDescriptorSet writeInfo =
2688 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
2690 *variables.descriptorSet, // descriptorSet
2691 BINDING_Sampler, // descriptorBinding;
2693 1u, // descriptorCount
2694 VK_DESCRIPTOR_TYPE_SAMPLER, // descriptorType
2695 &samplerInfo, // pImageInfo
2696 DE_NULL, // pBufferInfo
2697 DE_NULL // pTexelBufferView
2700 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2704 CommonDescriptorInstance::updateDescriptors(variables);
2707 void SampledImageInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2709 DE_ASSERT(variables.descriptorSamplers.size() == 0);
2710 DE_ASSERT(variables.descriptorsImages.size() == 0);
2711 DE_ASSERT(variables.descriptorImageViews.size() == 0);
2712 DE_ASSERT(variables.descriptorsBufferInfos.size() == 0);
2714 // create an only one sampler for all images
2716 const tcu::Sampler sampler(
2717 tcu::Sampler::CLAMP_TO_BORDER, // wrapS
2718 tcu::Sampler::CLAMP_TO_BORDER, // wrapT
2719 tcu::Sampler::CLAMP_TO_BORDER, // wrapR
2720 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // minFilter
2721 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // magFilter
2722 0.0f, // lodTreshold
2723 true); // normalizeCoords
2724 const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2725 variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2728 const VkExtent3D& imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2730 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2731 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2732 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2734 PixelBufferAccess pixelAccess;
2735 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2737 const float component = m_colorScheme[imageIdx % m_schemeSize];
2739 if (m_testParams.usesMipMaps)
2741 const deUint32 mipCount = ut::computeMipMapCount(imageExtent);
2742 DE_ASSERT(mipCount >= 2);
2743 for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2745 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2746 tcu::clear(pixelAccess, m_clearColor);
2749 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2750 pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2754 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2755 pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2758 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2761 class CombinedImageInstance : public CommonDescriptorInstance
2764 CombinedImageInstance (Context& context,
2765 const TestCaseParams& testCaseParams);
2767 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2768 virtual void updateDescriptors (IterateCommonVariables& variables);
2771 CombinedImageInstance::CombinedImageInstance (Context& context,
2772 const TestCaseParams& testCaseParams)
2773 : CommonDescriptorInstance(context,
2774 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2775 testCaseParams.descriptorType,
2776 BINDING_CombinedImageSampler,
2777 VK_DESCRIPTOR_TYPE_UNDEFINED,
2780 performWritesInVertex(testCaseParams.descriptorType),
2785 void CombinedImageInstance::updateDescriptors (IterateCommonVariables& variables)
2787 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2788 const deUint32 primeCount = static_cast<deUint32>(primes.size());
2790 DE_ASSERT(variables.descriptorSamplers.size() == 1);
2791 DE_ASSERT(variables.descriptorsImages.size() == primeCount);
2792 DE_ASSERT(variables.descriptorImageViews.size() == primeCount);
2793 DE_ASSERT(variables.descriptorsBufferInfos.size() == primeCount);
2795 for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
2797 const VkDescriptorImageInfo imageInfo =
2799 **variables.descriptorSamplers[0],
2800 **variables.descriptorImageViews[primeIdx],
2801 VK_IMAGE_LAYOUT_GENERAL
2804 const VkWriteDescriptorSet writeInfo =
2806 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
2808 *variables.descriptorSet, // descriptorSet
2809 BINDING_CombinedImageSampler, // descriptorBinding;
2810 primes[primeIdx], // elementIndex
2811 1u, // descriptorCount
2812 m_testParams.descriptorType, // descriptorType
2813 &imageInfo, // pImageInfo
2814 DE_NULL, // pBufferInfo
2815 DE_NULL // pTexelBufferView
2818 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2822 void CombinedImageInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2824 DE_ASSERT(variables.descriptorSamplers.size() == 0);
2825 DE_ASSERT(variables.descriptorsImages.size() == 0);
2826 DE_ASSERT(variables.descriptorImageViews.size() == 0);
2827 DE_ASSERT(variables.descriptorsBufferInfos.size() == 0);
2828 DE_ASSERT(variables.descriptorSamplers.size() == 0);
2830 const tcu::Sampler sampler(
2831 tcu::Sampler::CLAMP_TO_BORDER, // wrapS
2832 tcu::Sampler::CLAMP_TO_BORDER, // wrapT
2833 tcu::Sampler::CLAMP_TO_BORDER, // wrapR
2834 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // minFilter
2835 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // magFilter
2836 0.0f, // lodTreshold
2837 true); // normalizeCoords
2838 const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2839 variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2841 const VkExtent3D& imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2842 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
2843 imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2844 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2846 PixelBufferAccess pixelAccess;
2847 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2849 const float component = m_colorScheme[imageIdx % m_schemeSize];
2851 if (m_testParams.usesMipMaps)
2853 const deUint32 mipCount = ut::computeMipMapCount(imageExtent);
2854 DE_ASSERT(mipCount >= 2);
2855 for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2857 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2858 tcu::clear(pixelAccess, m_clearColor);
2861 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2862 pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2866 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2867 pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2871 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2874 class StorageImageInstance : public CommonDescriptorInstance
2877 StorageImageInstance (Context& context,
2878 const TestCaseParams& testCaseParams);
2880 virtual tcu::TestStatus iterate (void);
2881 virtual void createAndPopulateDescriptors (IterateCommonVariables& variables);
2882 virtual void updateDescriptors (IterateCommonVariables& variables);
2883 virtual void iterateCollectResults (ut::UpdatablePixelBufferAccessPtr& result,
2884 const IterateCommonVariables& variables,
2886 ut::BufferHandleAllocSp m_buffer;
2887 const deUint32 m_fillColor;
2888 typedef deUint32 m_imageFormat_t;
2891 StorageImageInstance::StorageImageInstance (Context& context,
2892 const TestCaseParams& testCaseParams)
2893 : CommonDescriptorInstance(context,
2894 TestParams (VK_SHADER_STAGE_COMPUTE_BIT,
2895 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2896 BINDING_StorageImage,
2897 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2898 (BINDING_StorageImage + 1),
2900 performWritesInVertex(testCaseParams.descriptorType, context),
2907 void StorageImageInstance::updateDescriptors (IterateCommonVariables& variables)
2909 // update image at last index
2911 VkDescriptorImageInfo imageInfo =
2913 static_cast<VkSampler>(0),
2914 **variables.descriptorImageViews[variables.validDescriptorCount],
2915 VK_IMAGE_LAYOUT_GENERAL
2918 const VkWriteDescriptorSet writeInfo =
2920 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
2922 *variables.descriptorSet, // descriptorSet
2923 m_testParams.additionalDescriptorBinding, // descriptorBinding;
2925 1u, // descriptorCount
2926 m_testParams.additionalDescriptorType, // descriptorType
2927 &imageInfo, // pImageInfo
2928 DE_NULL, // pBufferInfo
2929 DE_NULL // pTexelBufferView
2932 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2935 // update rest images
2936 CommonDescriptorInstance::updateDescriptors(variables);
2939 void StorageImageInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
2941 const VkFormat imageFormat = ut::mapType2vkFormat<m_imageFormat_t>::value;
2942 const VkBufferUsageFlags bufferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
2944 // create descriptor buffer, images and views
2946 const VkExtent3D imageExtent = { 4, 4, 1 };
2948 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2949 bufferUsage, imageExtent, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2951 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2953 const PixelBufferAccess pa = getPixelAccess(imageIdx, imageExtent, imageFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2954 tcu::clear(pa, tcu::UVec4(m_fillColor));
2956 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2959 // create additional image that will be used as index container
2961 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, m_buffer,
2962 bufferUsage, m_testParams.frameResolution, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1);
2965 const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2966 const PixelBufferAccess pa = getPixelAccess(variables.validDescriptorCount, m_testParams.frameResolution, imageFormat, variables.descriptorsBufferInfos, m_buffer);
2967 for (deUint32 y = 0, pixel = 0; y < m_testParams.frameResolution.height; ++y)
2969 for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixel)
2971 const deUint32 component = primes[pixel % variables.validDescriptorCount];
2972 pa.setPixel(tcu::UVec4(component), x, y);
2977 vk::flushAlloc(m_vki, m_vkd, *m_buffer->alloc);
2980 // create views for all previously created images
2981 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, imageFormat);
2984 tcu::TestStatus StorageImageInstance::iterate (void)
2986 IterateCommonVariables v;
2987 iterateCommandSetup (v);
2988 iterateCommandBegin (v);
2990 ut::UpdatablePixelBufferAccessPtr programResult;
2991 ut::UpdatablePixelBufferAccessPtr referenceResult;
2993 if (m_testParams.updateAfterBind)
2995 updateDescriptors (v);
2998 copyBuffersToImages (v);
3000 m_vki.cmdDispatch (*v.commandBuffer,
3001 m_testParams.calculateInLoop ? 1 : v.renderArea.extent.width,
3002 m_testParams.calculateInLoop ? 1 : v.renderArea.extent.height,
3005 copyImagesToBuffers (v);
3007 iterateCommandEnd(v, programResult, referenceResult, false);
3009 return ( iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
3012 void StorageImageInstance::iterateCollectResults (ut::UpdatablePixelBufferAccessPtr& result,
3013 const IterateCommonVariables& variables,
3016 result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(
3017 vk::mapVkFormat(ut::mapType2vkFormat<m_imageFormat_t>::value), m_testParams.frameResolution));
3018 const PixelBufferAccess& dst = *result.get();
3022 vk::invalidateAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
3023 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
3025 for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
3027 const deUint32 imageIdx = pixelNum % variables.validDescriptorCount;
3028 const PixelBufferAccess src = getPixelAccess(imageIdx,
3029 variables.descriptorsImages[imageIdx]->extent, variables.descriptorsImages[imageIdx]->format,
3030 variables.descriptorsBufferInfos, variables.descriptorsBuffer);
3031 dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(src.getPixelT<m_imageFormat_t>(0, 0).x()), x, y);
3037 std::vector<m_imageFormat_t> inc(variables.validDescriptorCount, m_fillColor);
3039 for (deUint32 invIdx = variables.lowerBound; invIdx < variables.upperBound; ++invIdx)
3041 ++inc[invIdx % variables.validDescriptorCount];
3044 for (deUint32 invIdx = 0; invIdx < variables.vertexCount; ++invIdx)
3046 const deUint32 row = invIdx / m_testParams.frameResolution.width;
3047 const deUint32 col = invIdx % m_testParams.frameResolution.width;
3048 const m_imageFormat_t color = inc[invIdx % variables.validDescriptorCount];
3049 dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(color), col, row);
3054 class DescriptorIndexingTestCase : public TestCase
3056 const TestCaseParams m_testCaseParams;
3058 DescriptorIndexingTestCase (tcu::TestContext &context, const char *name, const char *description, const TestCaseParams& testCaseParams)
3059 : TestCase(context, name, description)
3060 , m_testCaseParams(testCaseParams)
3064 vkt::TestInstance* createInstance (vkt::Context& context) const // override
3066 switch (m_testCaseParams.descriptorType)
3068 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3069 return new StorageBufferInstance (context, m_testCaseParams);
3070 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3071 return new UniformBufferInstance (context, m_testCaseParams);
3072 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3073 return new StorageTexelInstance (context, m_testCaseParams);
3074 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3075 return new UniformTexelInstance (context, m_testCaseParams);
3076 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3077 return new DynamicStorageBufferInstance (context, m_testCaseParams);
3078 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3079 return new DynamicUniformBufferInstance (context, m_testCaseParams);
3080 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3081 return new InputAttachmentInstance (context, m_testCaseParams);
3082 case VK_DESCRIPTOR_TYPE_SAMPLER:
3083 return new SamplerInstance (context, m_testCaseParams);
3084 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3085 return new SampledImageInstance (context, m_testCaseParams);
3086 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3087 return new CombinedImageInstance (context, m_testCaseParams);
3088 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3089 return new StorageImageInstance (context, m_testCaseParams);
3091 TCU_THROW(InternalError, "Unknown Descriptor Type");
3096 virtual void checkSupport (vkt::Context& context) const
3098 context.requireDeviceExtension("VK_EXT_descriptor_indexing");
3100 const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = context.getDescriptorIndexingFeatures();
3102 switch (m_testCaseParams.descriptorType)
3104 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3105 if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3106 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer descriptor arrays is not supported.");
3108 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageBufferUpdateAfterBind)
3109 TCU_THROW(NotSupportedError, "Update after bind for storage buffer descriptors is not supported.");
3111 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3112 if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3113 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform buffer descriptor arrays is not supported.");
3115 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformBufferUpdateAfterBind)
3116 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer descriptors is not supported.");
3118 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3119 if (!(feats.shaderStorageTexelBufferArrayNonUniformIndexing))
3120 TCU_THROW(NotSupportedError, "Non-uniform indexing for storage texel buffer descriptor arrays is not supported.");
3122 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageTexelBufferUpdateAfterBind)
3123 TCU_THROW(NotSupportedError, "Update after bind for storage texel buffer descriptors is not supported.");
3125 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3126 if (!(feats.shaderUniformTexelBufferArrayNonUniformIndexing))
3127 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform texel buffer descriptor arrays is not supported.");
3129 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformTexelBufferUpdateAfterBind)
3130 TCU_THROW(NotSupportedError, "Update after bind for uniform texel buffer descriptors is not supported.");
3132 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3133 if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3134 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer dynamic descriptor arrays is not supported.");
3136 if (m_testCaseParams.updateAfterBind)
3137 TCU_THROW(NotSupportedError, "Update after bind for storage buffer dynamic descriptors is not supported.");
3139 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3140 if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3141 TCU_THROW(NotSupportedError, "Non-uniform indexing over uniform buffer dynamic descriptor arrays is not supported.");
3143 if (m_testCaseParams.updateAfterBind)
3144 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer dynamic descriptors is not supported.");
3146 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3147 if (!(feats.shaderInputAttachmentArrayNonUniformIndexing))
3148 TCU_THROW(NotSupportedError, "Non-uniform indexing over input attachment descriptor arrays is not supported.");
3150 if (m_testCaseParams.updateAfterBind)
3151 TCU_THROW(NotSupportedError, "Update after bind for input attachment descriptors is not supported.");
3153 case VK_DESCRIPTOR_TYPE_SAMPLER:
3154 if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3155 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampler descriptor arrays is not supported.");
3157 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3158 TCU_THROW(NotSupportedError, "Update after bind for sampler descriptors is not supported.");
3160 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3161 if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3162 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampled image descriptor arrays is not supported.");
3164 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3165 TCU_THROW(NotSupportedError, "Update after bind for sampled image descriptors is not supported.");
3167 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3168 if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3169 TCU_THROW(NotSupportedError, "Non-uniform indexing over combined image sampler descriptor arrays is not supported.");
3171 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3172 TCU_THROW(NotSupportedError, "Update after bind for combined image sampler descriptors is not supported.");
3174 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3175 if (!(feats.shaderStorageImageArrayNonUniformIndexing))
3176 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage image descriptor arrays is not supported.");
3178 if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageImageUpdateAfterBind)
3179 TCU_THROW(NotSupportedError, "Update after bind for storage image descriptors is not supported.");
3182 DE_FATAL("Unknown Descriptor Type");
3187 virtual void initPrograms (SourceCollections& programCollection) const
3189 std::string(*genShaderSource)(VkShaderStageFlagBits, const TestCaseParams&, bool) = &CommonDescriptorInstance::getShaderSource;
3191 if (VK_SHADER_STAGE_VERTEX_BIT & m_testCaseParams.stageFlags)
3193 programCollection.glslSources.add(
3194 ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3195 << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, false));
3197 if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3199 programCollection.glslSources.add(
3200 ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3201 << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, true));
3204 if (VK_SHADER_STAGE_FRAGMENT_BIT & m_testCaseParams.stageFlags)
3206 programCollection.glslSources.add(
3207 ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3208 << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, false));
3210 if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3212 programCollection.glslSources.add(
3213 ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3214 << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, true));
3217 if (VK_SHADER_STAGE_COMPUTE_BIT & m_testCaseParams.stageFlags)
3219 programCollection.glslSources.add(
3220 ut::buildShaderName(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3221 << glu::ComputeSource((*genShaderSource)(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams, false));
3226 } // - unnamed namespace
3228 void descriptorIndexingDescriptorSetsCreateTests (tcu::TestCaseGroup* group)
3233 const char* description;
3234 TestCaseParams params;
3237 tcu::TestContext& context(group->getTestContext());
3239 TestCaseInfo casesAfterBindAndLoop[] =
3242 "storage_buffer", "Regular Storage Buffer Descriptors",
3244 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
3245 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3247 false, // updateAfterBind
3248 false, // calculateInLoop
3249 false, // useMipMaps
3250 FUZZY_COMPARE, CMP_THRESHOLD
3254 "storage_texel_buffer", "Storage Texel Buffer Descriptors",
3256 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
3257 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3259 false, // updateAfterBind
3260 false, // calculateInLoop
3261 false, // useMipMaps
3262 FUZZY_COMPARE, CMP_THRESHOLD
3266 "uniform_texel_buffer", "Uniform Texel Buffer Descriptors",
3268 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
3269 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3271 false, // updateAfterBind,
3272 false, // calculateInLoop
3273 false, // usesMipMaps
3274 FUZZY_COMPARE, CMP_THRESHOLD
3278 "storage_image", "Storage Image Descriptors",
3280 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
3281 VK_SHADER_STAGE_COMPUTE_BIT,
3283 false, // updateAfterBind
3284 false, // calculateInLoop
3285 false, // useMipMaps
3286 FUZZY_COMPARE, CMP_THRESHOLD
3291 for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3293 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3295 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoop); ++caseIdx)
3297 TestCaseInfo& info (casesAfterBindAndLoop[caseIdx]);
3298 std::string caseName (info.name);
3299 std::string caseDescription (info.description);
3300 TestCaseParams params (info.params);
3302 caseName += (updateAfterBind ? "_after_bind" : "");
3303 caseName += (calculateInLoop ? "_in_loop" : "");
3305 caseDescription += (updateAfterBind ? " After Bind" : "");
3306 caseDescription += (calculateInLoop ? " In Loop" : "");
3308 params.updateAfterBind = updateAfterBind ? true : false;
3309 params.calculateInLoop = calculateInLoop ? true : false;
3311 group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3316 TestCaseInfo casesAfterBindAndLoopAndLOD[] =
3319 "sampler", "Sampler Descriptors",
3321 VK_DESCRIPTOR_TYPE_SAMPLER,
3322 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3324 false, // updateAfterBind
3325 false, // calculateInLoop
3326 false, // usesMipMaps
3327 FUZZY_COMPARE, CMP_THRESHOLD
3331 "sampled_image", "Sampled Image Descriptors",
3333 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
3334 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3336 false, // updateAfterBind
3337 false, // calculateInLoop
3338 false, // usesMipMaps
3339 FUZZY_COMPARE, CMP_THRESHOLD
3343 "combined_image_sampler", "Combined Image Sampler Descriptors",
3345 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
3346 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3348 false, // updateAfterBind
3349 false, // calculateInLoop
3350 false, // usesMipMaps
3351 FUZZY_COMPARE, CMP_THRESHOLD
3356 for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3358 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3360 for (int usesMipMaps = 0; usesMipMaps < 2; ++usesMipMaps)
3362 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoopAndLOD); ++caseIdx)
3364 TestCaseInfo& info (casesAfterBindAndLoopAndLOD[caseIdx]);
3365 std::string caseName (info.name);
3366 std::string caseDescription (info.description);
3367 TestCaseParams params (info.params);
3369 caseName += (updateAfterBind ? "_after_bind" : "");
3370 caseName += (calculateInLoop ? "_in_loop" : "");
3371 caseName += (usesMipMaps ? "_with_lod" : "");
3373 caseDescription += (updateAfterBind ? " After Bind" : "");
3374 caseDescription += (calculateInLoop ? " In Loop" : "");
3375 caseDescription += (usesMipMaps ? " Use LOD" : "");
3377 params.updateAfterBind = updateAfterBind ? true : false;
3378 params.calculateInLoop = calculateInLoop ? true : false;
3379 params.usesMipMaps = usesMipMaps ? true : false;
3381 group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3387 TestCaseInfo casesNonAfterBindAndLoop[] =
3390 "uniform_buffer", "Regular Uniform Buffer Descriptors",
3392 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
3393 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3395 false, // updateAfterBind
3396 false, // calculateInLoop
3397 false, // usesMipMaps
3398 FUZZY_COMPARE, CMP_THRESHOLD
3402 "storage_buffer_dynamic", "Dynamic Storage Buffer Descriptors",
3404 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
3405 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3407 false, // updateAfterBind
3408 false, // calculateInLoop
3409 false, // useMipMaps
3410 FUZZY_COMPARE, CMP_THRESHOLD
3414 "uniform_buffer_dynamic", "Dynamic Uniform Buffer Descriptors",
3416 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
3417 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3419 false, // updateAfterBind
3420 false, // calculateInLoop
3421 false, // useMipMaps
3422 FUZZY_COMPARE, CMP_THRESHOLD
3426 "input_attachment", "Input Attachment Descriptors",
3428 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
3429 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3431 false, // updateAfterBind
3432 false, // calculateInLoop
3433 false, // useMipMaps
3434 FUZZY_COMPARE, CMP_THRESHOLD
3439 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3441 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesNonAfterBindAndLoop); ++caseIdx)
3443 TestCaseInfo& info(casesNonAfterBindAndLoop[caseIdx]);
3444 std::string caseName(info.name);
3445 std::string caseDescription(info.description);
3446 TestCaseParams params(info.params);
3448 caseName += (calculateInLoop ? "_in_loop" : "");
3450 caseDescription += (calculateInLoop ? " In Loop" : "");
3452 params.calculateInLoop = calculateInLoop ? true : false;
3454 group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3459 } // - DescriptorIndexing