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 "deMemory.h"
  37
  38 namespace vkt
  39 {
  40
  41 // Default device utilities
  42
  43 using std::vector;
  44 using std::string;
  45 using namespace vk;
  46
  47 vector<string> getValidationLayers (const vector<VkLayerProperties>& supportedLayers)
  48 {
  49         static const char*      s_magicLayer            = "VK_LAYER_LUNARG_standard_validation";
  50         static const char*      s_defaultLayers[]       =
  51         {
  52                 "VK_LAYER_GOOGLE_threading",
  53                 "VK_LAYER_LUNARG_parameter_validation",
  54                 "VK_LAYER_LUNARG_device_limits",
  55                 "VK_LAYER_LUNARG_object_tracker",
  56                 "VK_LAYER_LUNARG_image",
  57                 "VK_LAYER_LUNARG_core_validation",
  58                 "VK_LAYER_LUNARG_swapchain",
  59                 "VK_LAYER_GOOGLE_unique_objects"
  60         };
  61
  62         vector<string>          enabledLayers;
  63
  64         if (isLayerSupported(supportedLayers, RequiredLayer(s_magicLayer)))
  65                 enabledLayers.push_back(s_magicLayer);
  66         else
  67         {
  68                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_defaultLayers); ++ndx)
  69                 {
  70                         if (isLayerSupported(supportedLayers, RequiredLayer(s_defaultLayers[ndx])))
  71                                 enabledLayers.push_back(s_defaultLayers[ndx]);
  72                 }
  73         }
  74
  75         return enabledLayers;
  76 }
  77
  78 vector<string> getValidationLayers (const PlatformInterface& vkp)
  79 {
  80         return getValidationLayers(enumerateInstanceLayerProperties(vkp));
  81 }
  82
  83 vector<string> getValidationLayers (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
  84 {
  85         return getValidationLayers(enumerateDeviceLayerProperties(vki, physicalDevice));
  86 }
  87
  88 Move<VkInstance> createInstance (const PlatformInterface& vkp, const tcu::CommandLine& cmdLine)
  89 {
  90         const bool              isValidationEnabled     = cmdLine.isValidationEnabled();
  91         vector<string>  enabledExtensions;
  92         vector<string>  enabledLayers;
  93
  94         if (isValidationEnabled)
  95         {
  96                 if (isDebugReportSupported(vkp))
  97                         enabledExtensions.push_back("VK_EXT_debug_report");
  98                 else
  99                         TCU_THROW(NotSupportedError, "VK_EXT_debug_report is not supported");
 100
 101                 enabledLayers = getValidationLayers(vkp);
 102                 if (enabledLayers.empty())
 103                         TCU_THROW(NotSupportedError, "No validation layers found");
 104         }
 105
 106         return createDefaultInstance(vkp, enabledLayers, enabledExtensions);
 107 }
 108
 109 static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
 110 {
 111         const vector<VkQueueFamilyProperties>   queueProps      = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
 112
 113         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
 114         {
 115                 if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps)
 116                         return (deUint32)queueNdx;
 117         }
 118
 119         TCU_THROW(NotSupportedError, "No matching queue found");
 120 }
 121
 122 Move<VkDevice> createDefaultDevice (const InstanceInterface&            vki,
 123                                                                         VkPhysicalDevice                                physicalDevice,
 124                                                                         deUint32                                                queueIndex,
 125                                                                         const VkPhysicalDeviceFeatures& enabledFeatures,
 126                                                                         const vector<string>&                   enabledExtensions,
 127                                                                         const tcu::CommandLine&                 cmdLine)
 128 {
 129         VkDeviceQueueCreateInfo         queueInfo;
 130         VkDeviceCreateInfo                      deviceInfo;
 131         vector<string>                          enabledLayers;
 132         vector<const char*>                     layerPtrs;
 133         vector<const char*>                     extensionPtrs;
 134         const float                                     queuePriority   = 1.0f;
 135
 136         deMemset(&queueInfo,    0, sizeof(queueInfo));
 137         deMemset(&deviceInfo,   0, sizeof(deviceInfo));
 138
 139         if (cmdLine.isValidationEnabled())
 140         {
 141                 enabledLayers = getValidationLayers(vki, physicalDevice);
 142                 if (enabledLayers.empty())
 143                         TCU_THROW(NotSupportedError, "No validation layers found");
 144         }
 145
 146         layerPtrs.resize(enabledLayers.size());
 147
 148         for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
 149                 layerPtrs[ndx] = enabledLayers[ndx].c_str();
 150
 151         extensionPtrs.resize(enabledExtensions.size());
 152
 153         for (size_t ndx = 0; ndx < enabledExtensions.size(); ++ndx)
 154                 extensionPtrs[ndx] = enabledExtensions[ndx].c_str();
 155
 156         queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 157         queueInfo.pNext                                                 = DE_NULL;
 158         queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
 159         queueInfo.queueFamilyIndex                              = queueIndex;
 160         queueInfo.queueCount                                    = 1u;
 161         queueInfo.pQueuePriorities                              = &queuePriority;
 162
 163         deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 164         deviceInfo.pNext                                                = DE_NULL;
 165         deviceInfo.queueCreateInfoCount                 = 1u;
 166         deviceInfo.pQueueCreateInfos                    = &queueInfo;
 167         deviceInfo.enabledExtensionCount                = (deUint32)extensionPtrs.size();
 168         deviceInfo.ppEnabledExtensionNames              = (extensionPtrs.empty() ? DE_NULL : &extensionPtrs[0]);
 169         deviceInfo.enabledLayerCount                    = (deUint32)layerPtrs.size();
 170         deviceInfo.ppEnabledLayerNames                  = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
 171         deviceInfo.pEnabledFeatures                             = &enabledFeatures;
 172
 173         return createDevice(vki, physicalDevice, &deviceInfo);
 174 };
 175
 176 class DefaultDevice
 177 {
 178 public:
 179                                                                                 DefaultDevice                                   (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
 180                                                                                 ~DefaultDevice                                  (void);
 181
 182         VkInstance                                                      getInstance                                             (void) const    { return *m_instance;                                   }
 183         const InstanceInterface&                        getInstanceInterface                    (void) const    { return m_instanceInterface;                   }
 184
 185         VkPhysicalDevice                                        getPhysicalDevice                               (void) const    { return m_physicalDevice;                              }
 186         const VkPhysicalDeviceFeatures&         getDeviceFeatures                               (void) const    { return m_deviceFeatures;                              }
 187         VkDevice                                                        getDevice                                               (void) const    { return *m_device;                                             }
 188         const DeviceInterface&                          getDeviceInterface                              (void) const    { return m_deviceInterface;                             }
 189         const VkPhysicalDeviceProperties&       getDeviceProperties                             (void) const    { return m_deviceProperties;                    }
 190         const vector<string>&                           getDeviceExtensions                             (void) const    { return m_deviceExtensions;                    }
 191
 192         deUint32                                                        getUniversalQueueFamilyIndex    (void) const    { return m_universalQueueFamilyIndex;   }
 193         VkQueue                                                         getUniversalQueue                               (void) const;
 194
 195 private:
 196         static VkPhysicalDeviceFeatures         filterDefaultDeviceFeatures             (const VkPhysicalDeviceFeatures& deviceFeatures);
 197         static vector<string>                           filterDefaultDeviceExtensions   (const vector<VkExtensionProperties>& deviceExtensions);
 198
 199         const Unique<VkInstance>                        m_instance;
 200         const InstanceDriver                            m_instanceInterface;
 201
 202         const VkPhysicalDevice                          m_physicalDevice;
 203
 204         const deUint32                                          m_universalQueueFamilyIndex;
 205         const VkPhysicalDeviceFeatures          m_deviceFeatures;
 206         const VkPhysicalDeviceProperties        m_deviceProperties;
 207         const vector<string>                            m_deviceExtensions;
 208
 209         const Unique<VkDevice>                          m_device;
 210         const DeviceDriver                                      m_deviceInterface;
 211 };
 212
 213 DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
 214         : m_instance                                    (createInstance(vkPlatform, cmdLine))
 215         , m_instanceInterface                   (vkPlatform, *m_instance)
 216         , m_physicalDevice                              (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
 217         , m_universalQueueFamilyIndex   (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
 218         , m_deviceFeatures                              (filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(m_instanceInterface, m_physicalDevice)))
 219         , m_deviceProperties                    (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
 220         , m_deviceExtensions                    (filterDefaultDeviceExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)))
 221         , m_device                                              (createDefaultDevice(m_instanceInterface, m_physicalDevice, m_universalQueueFamilyIndex, m_deviceFeatures, m_deviceExtensions, cmdLine))
 222         , m_deviceInterface                             (m_instanceInterface, *m_device)
 223 {
 224 }
 225
 226 DefaultDevice::~DefaultDevice (void)
 227 {
 228 }
 229
 230 VkQueue DefaultDevice::getUniversalQueue (void) const
 231 {
 232         VkQueue queue   = 0;
 233         m_deviceInterface.getDeviceQueue(*m_device, m_universalQueueFamilyIndex, 0, &queue);
 234         return queue;
 235 }
 236
 237 VkPhysicalDeviceFeatures DefaultDevice::filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
 238 {
 239         VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
 240
 241         // Disable robustness by default, as it has an impact on performance on some HW.
 242         enabledDeviceFeatures.robustBufferAccess = false;
 243
 244         return enabledDeviceFeatures;
 245 }
 246
 247 vector<string> DefaultDevice::filterDefaultDeviceExtensions (const vector<VkExtensionProperties>& deviceExtensions)
 248 {
 249         vector<string> enabledExtensions;
 250
 251         // The only extension we enable always (when supported) is
 252         // VK_KHR_sampler_mirror_clamp_to_edge that is defined in
 253         // the core spec and supported widely.
 254         const char* const       mirrorClampToEdgeExt    = "VK_KHR_sampler_mirror_clamp_to_edge";
 255         if (vk::isExtensionSupported(deviceExtensions, vk::RequiredExtension(mirrorClampToEdgeExt)))
 256                 enabledExtensions.push_back(mirrorClampToEdgeExt);
 257
 258         return enabledExtensions;
 259 }
 260
 261 // Allocator utilities
 262
 263 vk::Allocator* createAllocator (DefaultDevice* device)
 264 {
 265         const VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(device->getInstanceInterface(), device->getPhysicalDevice());
 266
 267         // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
 268         return new SimpleAllocator(device->getDeviceInterface(), device->getDevice(), memoryProperties);
 269 }
 270
 271 // Context
 272
 273 Context::Context (tcu::TestContext&                                                     testCtx,
 274                                   const vk::PlatformInterface&                          platformInterface,
 275                                   vk::ProgramCollection<vk::ProgramBinary>&     progCollection)
 276         : m_testCtx                             (testCtx)
 277         , m_platformInterface   (platformInterface)
 278         , m_progCollection              (progCollection)
 279         , m_device                              (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
 280         , m_allocator                   (createAllocator(m_device.get()))
 281 {
 282 }
 283
 284 Context::~Context (void)
 285 {
 286 }
 287
 288 vk::VkInstance                                                  Context::getInstance                                    (void) const { return m_device->getInstance();                                  }
 289 const vk::InstanceInterface&                    Context::getInstanceInterface                   (void) const { return m_device->getInstanceInterface();                 }
 290 vk::VkPhysicalDevice                                    Context::getPhysicalDevice                              (void) const { return m_device->getPhysicalDevice();                    }
 291 const vk::VkPhysicalDeviceFeatures&             Context::getDeviceFeatures                              (void) const { return m_device->getDeviceFeatures();                    }
 292 const vk::VkPhysicalDeviceProperties&   Context::getDeviceProperties                    (void) const { return m_device->getDeviceProperties();                  }
 293 const vector<string>&                                   Context::getDeviceExtensions                    (void) const { return m_device->getDeviceExtensions();                  }
 294 vk::VkDevice                                                    Context::getDevice                                              (void) const { return m_device->getDevice();                                    }
 295 const vk::DeviceInterface&                              Context::getDeviceInterface                             (void) const { return m_device->getDeviceInterface();                   }
 296 deUint32                                                                Context::getUniversalQueueFamilyIndex   (void) const { return m_device->getUniversalQueueFamilyIndex(); }
 297 vk::VkQueue                                                             Context::getUniversalQueue                              (void) const { return m_device->getUniversalQueue();                    }
 298 vk::Allocator&                                                  Context::getDefaultAllocator                    (void) const { return *m_allocator;                                                             }
 299
 300 // TestCase
 301
 302 void TestCase::initPrograms (SourceCollections&) const
 303 {
 304 }
 305
 306 } // vkt