external/vulkancts/modules/vulkan/api/vktApiDescriptorPoolTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Descriptor pool tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktApiDescriptorPoolTests.hpp"
  25 #include "vktTestCaseUtil.hpp"
  26
  27 #include "vkDefs.hpp"
  28 #include "vkRef.hpp"
  29 #include "vkRefUtil.hpp"
  30 #include "vkPlatform.hpp"
  31 #include "vkDeviceUtil.hpp"
  32
  33 #include "tcuCommandLine.hpp"
  34 #include "tcuTestLog.hpp"
  35 #include "tcuPlatform.hpp"
  36
  37 #include "deUniquePtr.hpp"
  38 #include "deSharedPtr.hpp"
  39 #include "deInt32.h"
  40 #include "deSTLUtil.hpp"
  41
  42 namespace vkt
  43 {
  44 namespace api
  45 {
  46
  47 namespace
  48 {
  49
  50 using namespace std;
  51 using namespace vk;
  52
  53 tcu::TestStatus resetDescriptorPoolTest (Context& context, deUint32 numIterations)
  54 {
  55         const deUint32                          numDescriptorSetsPerIter = 2048;
  56         const DeviceInterface&          vkd                                              = context.getDeviceInterface();
  57         const VkDevice                          device                                   = context.getDevice();
  58
  59         const VkDescriptorPoolSize descriptorPoolSize =
  60         {
  61                 VK_DESCRIPTOR_TYPE_SAMPLER, // type
  62                 numDescriptorSetsPerIter        // descriptorCount
  63         };
  64
  65         // \todo [2016-05-24 collinbaker] Test with flag VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
  66         const VkDescriptorPoolCreateInfo descriptorPoolInfo =
  67         {
  68                 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,  // sType
  69                 NULL,                                                                                   // pNext
  70                 0,                                                                                              // flags
  71                 numDescriptorSetsPerIter,                                               // maxSets
  72                 1,                                                                                              // poolSizeCount
  73                 &descriptorPoolSize                                                             // pPoolSizes
  74         };
  75
  76         {
  77                 const Unique<VkDescriptorPool> descriptorPool(
  78                         createDescriptorPool(vkd, device,
  79                                                                  &descriptorPoolInfo));
  80
  81                 const VkDescriptorSetLayoutBinding descriptorSetLayoutBinding =
  82                 {
  83                         0,                                                      // binding
  84                         VK_DESCRIPTOR_TYPE_SAMPLER, // descriptorType
  85                         1,                                                      // descriptorCount
  86                         VK_SHADER_STAGE_ALL,            // stageFlags
  87                         NULL                                            // pImmutableSamplers
  88                 };
  89
  90                 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo =
  91                 {
  92                         VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,    // sType
  93                         NULL,                                                                                                   // pNext
  94                         0,                                                                                                              // flags
  95                         1,                                                                                                              // bindingCount
  96                         &descriptorSetLayoutBinding                                                             // pBindings
  97                 };
  98
  99                 {
 100                         typedef de::SharedPtr<Unique<VkDescriptorSetLayout> > DescriptorSetLayoutPtr;
 101
 102                         vector<DescriptorSetLayoutPtr> descriptorSetLayouts;
 103                         descriptorSetLayouts.reserve(numDescriptorSetsPerIter);
 104
 105                         for (deUint32 ndx = 0; ndx < numDescriptorSetsPerIter; ++ndx)
 106                         {
 107                                 descriptorSetLayouts.push_back(
 108                                         DescriptorSetLayoutPtr(
 109                                                 new Unique<VkDescriptorSetLayout>(
 110                                                         createDescriptorSetLayout(vkd, device,
 111                                                                                                           &descriptorSetLayoutInfo))));
 112                         }
 113
 114                         vector<VkDescriptorSetLayout> descriptorSetLayoutsRaw(numDescriptorSetsPerIter);
 115
 116                         for (deUint32 ndx = 0; ndx < numDescriptorSetsPerIter; ++ndx)
 117                         {
 118                                 descriptorSetLayoutsRaw[ndx] = **descriptorSetLayouts[ndx];
 119                         }
 120
 121                         const VkDescriptorSetAllocateInfo descriptorSetInfo =
 122                         {
 123                                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType
 124                                 NULL,                                                                                   // pNext
 125                                 *descriptorPool,                                                                // descriptorPool
 126                                 numDescriptorSetsPerIter,                                               // descriptorSetCount
 127                                 &descriptorSetLayoutsRaw[0]                                             // pSetLayouts
 128                         };
 129
 130                         vector<VkDescriptorSet> testSets(numDescriptorSetsPerIter);
 131
 132                         for (deUint32 ndx = 0; ndx < numIterations; ++ndx)
 133                         {
 134                                 // The test should crash in this loop at some point if there is a memory leak
 135                                 VK_CHECK(vkd.allocateDescriptorSets(device, &descriptorSetInfo, &testSets[0]));
 136                                 VK_CHECK(vkd.resetDescriptorPool(device, *descriptorPool, 0));
 137                         }
 138
 139                 }
 140         }
 141
 142         // If it didn't crash, pass
 143         return tcu::TestStatus::pass("Pass");
 144 }
 145
 146 tcu::TestStatus outOfPoolMemoryTest (Context& context)
 147 {
 148         const DeviceInterface&  vkd                                                     = context.getDeviceInterface();
 149         const VkDevice                  device                                          = context.getDevice();
 150         const bool                              expectOutOfPoolMemoryError      = de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1");
 151         deUint32                                numErrorsReturned                       = 0;
 152
 153         const struct FailureCase
 154         {
 155                 deUint32        poolDescriptorCount;            //!< total number of descriptors (of a given type) in the descriptor pool
 156                 deUint32        poolMaxSets;                            //!< max number of descriptor sets that can be allocated from the pool
 157                 deUint32        bindingCount;                           //!< number of bindings per descriptor set layout
 158                 deUint32        bindingDescriptorCount;         //!< number of descriptors in a binding (array size) (in all bindings)
 159                 deUint32        descriptorSetCount;                     //!< number of descriptor sets to allocate
 160                 string          description;                            //!< the log message for this failure condition
 161         } failureCases[] =
 162         {
 163                 //      pool                    pool            binding         binding         alloc set
 164                 //      descr. count    max sets        count           array size      count
 165                 {       4u,                             2u,                     1u,                     1u,                     3u,             "Out of descriptor sets",                                                                                       },
 166                 {       3u,                             4u,                     1u,                     1u,                     4u,             "Out of descriptors (due to the number of sets)",                                       },
 167                 {       2u,                             1u,                     3u,                     1u,                     1u,             "Out of descriptors (due to the number of bindings)",                           },
 168                 {       3u,                             2u,                     1u,                     2u,                     2u,             "Out of descriptors (due to descriptor array size)",                            },
 169                 {       5u,                             1u,                     2u,                     3u,                     1u,             "Out of descriptors (due to descriptor array size in all bindings)",},
 170         };
 171
 172         context.getTestContext().getLog()
 173                 << tcu::TestLog::Message
 174                 << "Creating a descriptor pool with insufficient resources. Descriptor set allocation is likely to fail."
 175                 << tcu::TestLog::EndMessage;
 176
 177         for (deUint32 failureCaseNdx = 0u; failureCaseNdx < DE_LENGTH_OF_ARRAY(failureCases); ++failureCaseNdx)
 178         {
 179                 const FailureCase& params = failureCases[failureCaseNdx];
 180                 context.getTestContext().getLog() << tcu::TestLog::Message << "Checking: " << params.description << tcu::TestLog::EndMessage;
 181
 182                 for (VkDescriptorType   descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
 183                                                                 descriptorType < VK_DESCRIPTOR_TYPE_LAST;
 184                                                                 descriptorType = static_cast<VkDescriptorType>(descriptorType + 1))
 185                 {
 186                         context.getTestContext().getLog() << tcu::TestLog::Message << "- " << getDescriptorTypeName(descriptorType) << tcu::TestLog::EndMessage;
 187
 188                         const VkDescriptorPoolSize                                      descriptorPoolSize =
 189                         {
 190                                 descriptorType,                                                                                         // type
 191                                 params.poolDescriptorCount,                                                                     // descriptorCount
 192                         };
 193
 194                         const VkDescriptorPoolCreateInfo                        descriptorPoolCreateInfo =
 195                         {
 196                                 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,                          // VkStructureType                sType;
 197                                 DE_NULL,                                                                                                        // const void*                    pNext;
 198                                 (VkDescriptorPoolCreateFlags)0,                                                         // VkDescriptorPoolCreateFlags    flags;
 199                                 params.poolMaxSets,                                                                                     // uint32_t                       maxSets;
 200                                 1u,                                                                                                                     // uint32_t                       poolSizeCount;
 201                                 &descriptorPoolSize,                                                                            // const VkDescriptorPoolSize*    pPoolSizes;
 202                         };
 203
 204                         const Unique<VkDescriptorPool>                          descriptorPool(createDescriptorPool(vkd, device, &descriptorPoolCreateInfo));
 205
 206                         const VkDescriptorSetLayoutBinding                      descriptorSetLayoutBinding =
 207                         {
 208                                 0u,                                                                                                                     // uint32_t              binding;
 209                                 descriptorType,                                                                                         // VkDescriptorType      descriptorType;
 210                                 params.bindingDescriptorCount,                                                          // uint32_t              descriptorCount;
 211                                 VK_SHADER_STAGE_ALL,                                                                            // VkShaderStageFlags    stageFlags;
 212                                 DE_NULL,                                                                                                        // const VkSampler*      pImmutableSamplers;
 213                         };
 214
 215                         const vector<VkDescriptorSetLayoutBinding>      descriptorSetLayoutBindings (params.bindingCount, descriptorSetLayoutBinding);
 216                         const VkDescriptorSetLayoutCreateInfo           descriptorSetLayoutInfo =
 217                         {
 218                                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,            // VkStructureType                        sType;
 219                                 DE_NULL,                                                                                                        // const void*                            pNext;
 220                                 (VkDescriptorSetLayoutCreateFlags)0,                                            // VkDescriptorSetLayoutCreateFlags       flags;
 221                                 static_cast<deUint32>(descriptorSetLayoutBindings.size()),      // uint32_t                               bindingCount;
 222                                 &descriptorSetLayoutBindings[0],                                                        // const VkDescriptorSetLayoutBinding*    pBindings;
 223                         };
 224
 225                         const Unique<VkDescriptorSetLayout>                     descriptorSetLayout     (createDescriptorSetLayout(vkd, device, &descriptorSetLayoutInfo));
 226                         const vector<VkDescriptorSetLayout>                     rawSetLayouts           (params.descriptorSetCount, *descriptorSetLayout);
 227                         vector<VkDescriptorSet>                                         rawDescriptorSets       (params.descriptorSetCount, DE_NULL);
 228
 229                         const VkDescriptorSetAllocateInfo                       descriptorSetAllocateInfo =
 230                         {
 231                                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,                         // VkStructureType                 sType;
 232                                 DE_NULL,                                                                                                        // const void*                     pNext;
 233                                 *descriptorPool,                                                                                        // VkDescriptorPool                descriptorPool;
 234                                 static_cast<deUint32>(rawSetLayouts.size()),                            // uint32_t                        descriptorSetCount;
 235                                 &rawSetLayouts[0],                                                                                      // const VkDescriptorSetLayout*    pSetLayouts;
 236                         };
 237
 238                         const VkResult result = vkd.allocateDescriptorSets(device, &descriptorSetAllocateInfo, &rawDescriptorSets[0]);
 239
 240                         if (result != VK_SUCCESS)
 241                         {
 242                                 ++numErrorsReturned;
 243
 244                                 if (expectOutOfPoolMemoryError && result != VK_ERROR_OUT_OF_POOL_MEMORY_KHR)
 245                                         return tcu::TestStatus::fail("Expected VK_ERROR_OUT_OF_POOL_MEMORY_KHR but got " + string(getResultName(result)) + " instead");
 246                         }
 247                         else
 248                                 context.getTestContext().getLog() << tcu::TestLog::Message << "  Allocation was successful anyway" << tcu::TestLog::EndMessage;
 249                 }
 250         }
 251
 252         if (numErrorsReturned == 0u)
 253                 return tcu::TestStatus::pass("Not validated");
 254         else
 255                 return tcu::TestStatus::pass("Pass");
 256 }
 257
 258 } // anonymous
 259
 260 tcu::TestCaseGroup* createDescriptorPoolTests (tcu::TestContext& testCtx)
 261 {
 262         const deUint32 numIterationsHigh = 4096;
 263
 264         de::MovePtr<tcu::TestCaseGroup> descriptorPoolTests(
 265                 new tcu::TestCaseGroup(testCtx, "descriptor_pool", "Descriptor Pool Tests"));
 266
 267         addFunctionCase(descriptorPoolTests.get(),
 268                                         "repeated_reset_short",
 269                                         "Test 2 cycles of vkAllocateDescriptorSets and vkResetDescriptorPool (should pass)",
 270                                         resetDescriptorPoolTest, 2U);
 271         addFunctionCase(descriptorPoolTests.get(),
 272                                         "repeated_reset_long",
 273                                         "Test many cycles of vkAllocateDescriptorSets and vkResetDescriptorPool",
 274                                         resetDescriptorPoolTest, numIterationsHigh);
 275         addFunctionCase(descriptorPoolTests.get(),
 276                                         "out_of_pool_memory",
 277                                         "Test that when we run out of descriptors a correct error code is returned",
 278                                         outOfPoolMemoryTest);
 279
 280         return descriptorPoolTests.release();
 281 }
 282
 283 } // api
 284 } // vkt