external/vulkancts/modules/vulkan/vktTestCase.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 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 Vulkan test case base classes
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktTestCase.hpp"
  25
  26 #include "vkRef.hpp"
  27 #include "vkRefUtil.hpp"
  28 #include "vkQueryUtil.hpp"
  29 #include "vkDeviceUtil.hpp"
  30 #include "vkMemUtil.hpp"
  31 #include "vkPlatform.hpp"
  32 #include "vkDebugReportUtil.hpp"
  33
  34 #include "tcuCommandLine.hpp"
  35
  36 #include "deSTLUtil.hpp"
  37 #include "deMemory.h"
  38
  39 namespace vkt
  40 {
  41
  42 // Default device utilities
  43
  44 using std::vector;
  45 using std::string;
  46 using namespace vk;
  47
  48 namespace
  49 {
  50
  51 vector<string> getValidationLayers (const vector<VkLayerProperties>& supportedLayers)
  52 {
  53         static const char*      s_magicLayer            = "VK_LAYER_LUNARG_standard_validation";
  54         static const char*      s_defaultLayers[]       =
  55         {
  56                 "VK_LAYER_GOOGLE_threading",
  57                 "VK_LAYER_LUNARG_parameter_validation",
  58                 "VK_LAYER_LUNARG_device_limits",
  59                 "VK_LAYER_LUNARG_object_tracker",
  60                 "VK_LAYER_LUNARG_image",
  61                 "VK_LAYER_LUNARG_core_validation",
  62                 "VK_LAYER_LUNARG_swapchain",
  63                 "VK_LAYER_GOOGLE_unique_objects"
  64         };
  65
  66         vector<string>          enabledLayers;
  67
  68         if (isLayerSupported(supportedLayers, RequiredLayer(s_magicLayer)))
  69                 enabledLayers.push_back(s_magicLayer);
  70         else
  71         {
  72                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_defaultLayers); ++ndx)
  73                 {
  74                         if (isLayerSupported(supportedLayers, RequiredLayer(s_defaultLayers[ndx])))
  75                                 enabledLayers.push_back(s_defaultLayers[ndx]);
  76                 }
  77         }
  78
  79         return enabledLayers;
  80 }
  81
  82 vector<string> getValidationLayers (const PlatformInterface& vkp)
  83 {
  84         return getValidationLayers(enumerateInstanceLayerProperties(vkp));
  85 }
  86
  87 vector<string> getValidationLayers (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
  88 {
  89         return getValidationLayers(enumerateDeviceLayerProperties(vki, physicalDevice));
  90 }
  91
  92 vector<string> filterExtensions(const vector<VkExtensionProperties>& deviceExtensions)
  93 {
  94         vector<string>  enabledExtensions;
  95         const char*             extensionGroups[] =
  96         {
  97                 "VK_KHR_",
  98                 "VK_EXT_",
  99                 "VK_KHX_"
 100         };
 101
 102         for (size_t deviceExtNdx = 0; deviceExtNdx < deviceExtensions.size(); deviceExtNdx++)
 103         {
 104                 for (int extGroupNdx = 0; extGroupNdx < DE_LENGTH_OF_ARRAY(extensionGroups); extGroupNdx++)
 105                 {
 106                         if (deStringBeginsWith(deviceExtensions[deviceExtNdx].extensionName, extensionGroups[extGroupNdx]))
 107                                 enabledExtensions.push_back(deviceExtensions[deviceExtNdx].extensionName);
 108                 }
 109         }
 110
 111         return enabledExtensions;
 112 }
 113
 114 Move<VkInstance> createInstance (const PlatformInterface& vkp, const vector<string>& enabledExtensions, const tcu::CommandLine& cmdLine)
 115 {
 116         const bool                                                      isValidationEnabled     = cmdLine.isValidationEnabled();
 117         vector<string>                                          enabledLayers;
 118
 119         if (isValidationEnabled)
 120         {
 121                 if (!isDebugReportSupported(vkp))
 122                         TCU_THROW(NotSupportedError, "VK_EXT_debug_report is not supported");
 123
 124                 enabledLayers = getValidationLayers(vkp);
 125                 if (enabledLayers.empty())
 126                         TCU_THROW(NotSupportedError, "No validation layers found");
 127         }
 128
 129         return createDefaultInstance(vkp, enabledLayers, enabledExtensions);
 130 }
 131
 132 static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
 133 {
 134         const vector<VkQueueFamilyProperties>   queueProps      = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
 135
 136         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 137         {
 138                 if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps)
 139                         return (deUint32)queueNdx;
 140         }
 141
 142         TCU_THROW(NotSupportedError, "No matching queue found");
 143 }
 144
 145 Move<VkDevice> createDefaultDevice (const InstanceInterface&                    vki,
 146                                                                         VkPhysicalDevice                                        physicalDevice,
 147                                                                         deUint32                                                        queueIndex,
 148                                                                         const VkPhysicalDeviceFeatures2KHR&     enabledFeatures,
 149                                                                         const vector<string>&                           enabledExtensions,
 150                                                                         const tcu::CommandLine&                         cmdLine)
 151 {
 152         VkDeviceQueueCreateInfo         queueInfo;
 153         VkDeviceCreateInfo                      deviceInfo;
 154         vector<string>                          enabledLayers;
 155         vector<const char*>                     layerPtrs;
 156         vector<const char*>                     extensionPtrs;
 157         const float                                     queuePriority   = 1.0f;
 158
 159         deMemset(&queueInfo,    0, sizeof(queueInfo));
 160         deMemset(&deviceInfo,   0, sizeof(deviceInfo));
 161
 162         if (cmdLine.isValidationEnabled())
 163         {
 164                 enabledLayers = getValidationLayers(vki, physicalDevice);
 165                 if (enabledLayers.empty())
 166                         TCU_THROW(NotSupportedError, "No validation layers found");
 167         }
 168
 169         layerPtrs.resize(enabledLayers.size());
 170
 171         for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
 172                 layerPtrs[ndx] = enabledLayers[ndx].c_str();
 173
 174         extensionPtrs.resize(enabledExtensions.size());
 175
 176         for (size_t ndx = 0; ndx < enabledExtensions.size(); ++ndx)
 177                 extensionPtrs[ndx] = enabledExtensions[ndx].c_str();
 178
 179         // VK_KHR_get_physical_device_propeties2 is used if enabledFeatures.pNext != 0
 180
 181         queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 182         queueInfo.pNext                                                 = enabledFeatures.pNext ? &enabledFeatures : DE_NULL;
 183         queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
 184         queueInfo.queueFamilyIndex                              = queueIndex;
 185         queueInfo.queueCount                                    = 1u;
 186         queueInfo.pQueuePriorities                              = &queuePriority;
 187
 188         deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 189         deviceInfo.pNext                                                = DE_NULL;
 190         deviceInfo.queueCreateInfoCount                 = 1u;
 191         deviceInfo.pQueueCreateInfos                    = &queueInfo;
 192         deviceInfo.enabledExtensionCount                = (deUint32)extensionPtrs.size();
 193         deviceInfo.ppEnabledExtensionNames              = (extensionPtrs.empty() ? DE_NULL : &extensionPtrs[0]);
 194         deviceInfo.enabledLayerCount                    = (deUint32)layerPtrs.size();
 195         deviceInfo.ppEnabledLayerNames                  = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
 196         deviceInfo.pEnabledFeatures                             = enabledFeatures.pNext ? DE_NULL : &enabledFeatures.features;
 197
 198         return createDevice(vki, physicalDevice, &deviceInfo);
 199 };
 200
 201 bool isPhysicalDeviceFeatures2Supported (const vector<string>& instanceExtensions)
 202 {
 203         return de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2");
 204 }
 205
 206 struct DeviceFeatures
 207 {
 208         VkPhysicalDeviceFeatures2KHR                                            coreFeatures;
 209         VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR       samplerYCbCrConversionFeatures;
 210
 211         DeviceFeatures (const InstanceInterface&        vki,
 212                                         VkPhysicalDevice                        physicalDevice,
 213                                         const vector<string>&           instanceExtensions,
 214                                         const vector<string>&           deviceExtensions)
 215         {
 216                 void**  curExtPoint             = &coreFeatures.pNext;
 217
 218                 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
 219                 deMemset(&samplerYCbCrConversionFeatures, 0, sizeof(samplerYCbCrConversionFeatures));
 220
 221                 coreFeatures.sType                                              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
 222                 samplerYCbCrConversionFeatures.sType    = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
 223
 224                 if (isPhysicalDeviceFeatures2Supported(instanceExtensions))
 225                 {
 226                         if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_sampler_ycbcr_conversion"))
 227                         {
 228                                 *curExtPoint = &samplerYCbCrConversionFeatures;
 229                                 curExtPoint = &samplerYCbCrConversionFeatures.pNext;
 230                         }
 231
 232                         vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &coreFeatures);
 233                 }
 234                 else
 235                         coreFeatures.features = getPhysicalDeviceFeatures(vki, physicalDevice);
 236
 237                 // Disable robustness by default, as it has an impact on performance on some HW.
 238                 coreFeatures.features.robustBufferAccess = false;
 239         }
 240 };
 241
 242 } // anonymous
 243
 244 class DefaultDevice
 245 {
 246 public:
 247                                                                                 DefaultDevice                                   (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
 248                                                                                 ~DefaultDevice                                  (void);
 249
 250         VkInstance                                                      getInstance                                             (void) const    { return *m_instance;                                                           }
 251         const InstanceInterface&                        getInstanceInterface                    (void) const    { return m_instanceInterface;                                           }
 252         const vector<string>&                           getInstanceExtensions                   (void) const    { return m_instanceExtensions;                                          }
 253
 254         VkPhysicalDevice                                        getPhysicalDevice                               (void) const    { return m_physicalDevice;                                                      }
 255         const VkPhysicalDeviceFeatures&         getDeviceFeatures                               (void) const    { return m_deviceFeatures.coreFeatures.features;        }
 256         const VkPhysicalDeviceFeatures2KHR&     getDeviceFeatures2                              (void) const    { return m_deviceFeatures.coreFeatures;                         }
 257         VkDevice                                                        getDevice                                               (void) const    { return *m_device;                                                                     }
 258         const DeviceInterface&                          getDeviceInterface                              (void) const    { return m_deviceInterface;                                                     }
 259         const VkPhysicalDeviceProperties&       getDeviceProperties                             (void) const    { return m_deviceProperties;                                            }
 260         const vector<string>&                           getDeviceExtensions                             (void) const    { return m_deviceExtensions;                                            }
 261
 262         deUint32                                                        getUniversalQueueFamilyIndex    (void) const    { return m_universalQueueFamilyIndex;                           }
 263         VkQueue                                                         getUniversalQueue                               (void) const;
 264
 265 private:
 266         static VkPhysicalDeviceFeatures         filterDefaultDeviceFeatures             (const VkPhysicalDeviceFeatures& deviceFeatures);
 267
 268         const vector<string>                            m_instanceExtensions;
 269         const Unique<VkInstance>                        m_instance;
 270         const InstanceDriver                            m_instanceInterface;
 271
 272         const VkPhysicalDevice                          m_physicalDevice;
 273
 274         const deUint32                                          m_universalQueueFamilyIndex;
 275         const vector<string>                            m_deviceExtensions;
 276         const DeviceFeatures                            m_deviceFeatures;
 277         const VkPhysicalDeviceProperties        m_deviceProperties;
 278
 279         const Unique<VkDevice>                          m_device;
 280         const DeviceDriver                                      m_deviceInterface;
 281 };
 282
 283 DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
 284         : m_instanceExtensions                  (filterExtensions(enumerateInstanceExtensionProperties(vkPlatform, DE_NULL)))
 285         , m_instance                                    (createInstance(vkPlatform, m_instanceExtensions, cmdLine))
 286         , m_instanceInterface                   (vkPlatform, *m_instance)
 287         , m_physicalDevice                              (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
 288         , m_universalQueueFamilyIndex   (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
 289         , m_deviceExtensions                    (filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)))
 290         , m_deviceFeatures                              (m_instanceInterface, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
 291         , m_deviceProperties                    (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
 292         , m_device                                              (createDefaultDevice(m_instanceInterface,
 293                                                                                                                  m_physicalDevice,
 294                                                                                                                  m_universalQueueFamilyIndex,
 295                                                                                                                  m_deviceFeatures.coreFeatures,
 296                                                                                                                  m_deviceExtensions,
 297                                                                                                                  cmdLine))
 298         , m_deviceInterface                             (m_instanceInterface, *m_device)
 299 {
 300 }
 301
 302 DefaultDevice::~DefaultDevice (void)
 303 {
 304 }
 305
 306 VkQueue DefaultDevice::getUniversalQueue (void) const
 307 {
 308         return getDeviceQueue(m_deviceInterface, *m_device, m_universalQueueFamilyIndex, 0);
 309 }
 310
 311 namespace
 312 {
 313
 314 // Allocator utilities
 315
 316 vk::Allocator* createAllocator (DefaultDevice* device)
 317 {
 318         const VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(device->getInstanceInterface(), device->getPhysicalDevice());
 319
 320         // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
 321         return new SimpleAllocator(device->getDeviceInterface(), device->getDevice(), memoryProperties);
 322 }
 323
 324 } // anonymous
 325
 326 // Context
 327
 328 Context::Context (tcu::TestContext&                                                     testCtx,
 329                                   const vk::PlatformInterface&                          platformInterface,
 330                                   vk::ProgramCollection<vk::ProgramBinary>&     progCollection)
 331         : m_testCtx                             (testCtx)
 332         , m_platformInterface   (platformInterface)
 333         , m_progCollection              (progCollection)
 334         , m_device                              (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
 335         , m_allocator                   (createAllocator(m_device.get()))
 336 {
 337 }
 338
 339 Context::~Context (void)
 340 {
 341 }
 342
 343 const vector<string>&                                   Context::getInstanceExtensions                  (void) const { return m_device->getInstanceExtensions();                }
 344 vk::VkInstance                                                  Context::getInstance                                    (void) const { return m_device->getInstance();                                  }
 345 const vk::InstanceInterface&                    Context::getInstanceInterface                   (void) const { return m_device->getInstanceInterface();                 }
 346 vk::VkPhysicalDevice                                    Context::getPhysicalDevice                              (void) const { return m_device->getPhysicalDevice();                    }
 347 const vk::VkPhysicalDeviceFeatures&             Context::getDeviceFeatures                              (void) const { return m_device->getDeviceFeatures();                    }
 348 const vk::VkPhysicalDeviceFeatures2KHR& Context::getDeviceFeatures2                             (void) const { return m_device->getDeviceFeatures2();                   }
 349 const vk::VkPhysicalDeviceProperties&   Context::getDeviceProperties                    (void) const { return m_device->getDeviceProperties();                  }
 350 const vector<string>&                                   Context::getDeviceExtensions                    (void) const { return m_device->getDeviceExtensions();                  }
 351 vk::VkDevice                                                    Context::getDevice                                              (void) const { return m_device->getDevice();                                    }
 352 const vk::DeviceInterface&                              Context::getDeviceInterface                             (void) const { return m_device->getDeviceInterface();                   }
 353 deUint32                                                                Context::getUniversalQueueFamilyIndex   (void) const { return m_device->getUniversalQueueFamilyIndex(); }
 354 vk::VkQueue                                                             Context::getUniversalQueue                              (void) const { return m_device->getUniversalQueue();                    }
 355 vk::Allocator&                                                  Context::getDefaultAllocator                    (void) const { return *m_allocator;                                                             }
 356
 357 // TestCase
 358
 359 void TestCase::initPrograms (SourceCollections&) const
 360 {
 361 }
 362
 363 } // vkt