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 tcu::CommandLine&                 cmdLine)
 127 {
 128         VkDeviceQueueCreateInfo         queueInfo;
 129         VkDeviceCreateInfo                      deviceInfo;
 130         vector<string>                          enabledLayers;
 131         vector<const char*>                     layerPtrs;
 132         const float                                     queuePriority   = 1.0f;
 133
 134         deMemset(&queueInfo,    0, sizeof(queueInfo));
 135         deMemset(&deviceInfo,   0, sizeof(deviceInfo));
 136
 137         if (cmdLine.isValidationEnabled())
 138         {
 139                 enabledLayers = getValidationLayers(vki, physicalDevice);
 140                 if (enabledLayers.empty())
 141                         TCU_THROW(NotSupportedError, "No validation layers found");
 142         }
 143
 144         layerPtrs.resize(enabledLayers.size());
 145
 146         for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
 147                 layerPtrs[ndx] = enabledLayers[ndx].c_str();
 148
 149         queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 150         queueInfo.pNext                                                 = DE_NULL;
 151         queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
 152         queueInfo.queueFamilyIndex                              = queueIndex;
 153         queueInfo.queueCount                                    = 1u;
 154         queueInfo.pQueuePriorities                              = &queuePriority;
 155
 156         deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 157         deviceInfo.pNext                                                = DE_NULL;
 158         deviceInfo.queueCreateInfoCount                 = 1u;
 159         deviceInfo.pQueueCreateInfos                    = &queueInfo;
 160         deviceInfo.enabledExtensionCount                = 0u;
 161         deviceInfo.ppEnabledExtensionNames              = DE_NULL;
 162         deviceInfo.enabledLayerCount                    = (deUint32)layerPtrs.size();
 163         deviceInfo.ppEnabledLayerNames                  = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
 164         deviceInfo.pEnabledFeatures                             = &enabledFeatures;
 165
 166         return createDevice(vki, physicalDevice, &deviceInfo);
 167 };
 168
 169 class DefaultDevice
 170 {
 171 public:
 172                                                                                 DefaultDevice                                   (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
 173                                                                                 ~DefaultDevice                                  (void);
 174
 175         VkInstance                                                      getInstance                                             (void) const    { return *m_instance;                                   }
 176         const InstanceInterface&                        getInstanceInterface                    (void) const    { return m_instanceInterface;                   }
 177
 178         VkPhysicalDevice                                        getPhysicalDevice                               (void) const    { return m_physicalDevice;                              }
 179         const VkPhysicalDeviceFeatures&         getDeviceFeatures                               (void) const    { return m_deviceFeatures;                              }
 180         VkDevice                                                        getDevice                                               (void) const    { return *m_device;                                             }
 181         const DeviceInterface&                          getDeviceInterface                              (void) const    { return m_deviceInterface;                             }
 182         const VkPhysicalDeviceProperties&       getDeviceProperties                             (void) const    { return m_deviceProperties;                    }
 183
 184         deUint32                                                        getUniversalQueueFamilyIndex    (void) const    { return m_universalQueueFamilyIndex;   }
 185         VkQueue                                                         getUniversalQueue                               (void) const;
 186
 187 private:
 188         static VkPhysicalDeviceFeatures         filterDefaultDeviceFeatures             (const VkPhysicalDeviceFeatures& deviceFeatures);
 189
 190         const Unique<VkInstance>                        m_instance;
 191         const InstanceDriver                            m_instanceInterface;
 192
 193         const VkPhysicalDevice                          m_physicalDevice;
 194
 195         const deUint32                                          m_universalQueueFamilyIndex;
 196         const VkPhysicalDeviceFeatures          m_deviceFeatures;
 197         const VkPhysicalDeviceProperties        m_deviceProperties;
 198
 199         const Unique<VkDevice>                          m_device;
 200         const DeviceDriver                                      m_deviceInterface;
 201 };
 202
 203 DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
 204         : m_instance                                    (createInstance(vkPlatform, cmdLine))
 205         , m_instanceInterface                   (vkPlatform, *m_instance)
 206         , m_physicalDevice                              (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
 207         , m_universalQueueFamilyIndex   (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
 208         , m_deviceFeatures                              (filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(m_instanceInterface, m_physicalDevice)))
 209         , m_deviceProperties                    (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
 210         , m_device                                              (createDefaultDevice(m_instanceInterface, m_physicalDevice, m_universalQueueFamilyIndex, m_deviceFeatures, cmdLine))
 211         , m_deviceInterface                             (m_instanceInterface, *m_device)
 212 {
 213 }
 214
 215 DefaultDevice::~DefaultDevice (void)
 216 {
 217 }
 218
 219 VkQueue DefaultDevice::getUniversalQueue (void) const
 220 {
 221         VkQueue queue   = 0;
 222         m_deviceInterface.getDeviceQueue(*m_device, m_universalQueueFamilyIndex, 0, &queue);
 223         return queue;
 224 }
 225
 226 VkPhysicalDeviceFeatures DefaultDevice::filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
 227 {
 228         VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
 229
 230         // Disable robustness by default, as it has an impact on performance on some HW.
 231         enabledDeviceFeatures.robustBufferAccess = false;
 232
 233         return enabledDeviceFeatures;
 234 }
 235
 236 // Allocator utilities
 237
 238 vk::Allocator* createAllocator (DefaultDevice* device)
 239 {
 240         const VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(device->getInstanceInterface(), device->getPhysicalDevice());
 241
 242         // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
 243         return new SimpleAllocator(device->getDeviceInterface(), device->getDevice(), memoryProperties);
 244 }
 245
 246 // Context
 247
 248 Context::Context (tcu::TestContext&                                                     testCtx,
 249                                   const vk::PlatformInterface&                          platformInterface,
 250                                   vk::ProgramCollection<vk::ProgramBinary>&     progCollection)
 251         : m_testCtx                             (testCtx)
 252         , m_platformInterface   (platformInterface)
 253         , m_progCollection              (progCollection)
 254         , m_device                              (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
 255         , m_allocator                   (createAllocator(m_device.get()))
 256 {
 257 }
 258
 259 Context::~Context (void)
 260 {
 261 }
 262
 263 vk::VkInstance                                                  Context::getInstance                                    (void) const { return m_device->getInstance();                                  }
 264 const vk::InstanceInterface&                    Context::getInstanceInterface                   (void) const { return m_device->getInstanceInterface();                 }
 265 vk::VkPhysicalDevice                                    Context::getPhysicalDevice                              (void) const { return m_device->getPhysicalDevice();                    }
 266 const vk::VkPhysicalDeviceFeatures&             Context::getDeviceFeatures                              (void) const { return m_device->getDeviceFeatures();                    }
 267 const vk::VkPhysicalDeviceProperties&   Context::getDeviceProperties                    (void) const { return m_device->getDeviceProperties();                  }
 268 vk::VkDevice                                                    Context::getDevice                                              (void) const { return m_device->getDevice();                                    }
 269 const vk::DeviceInterface&                              Context::getDeviceInterface                             (void) const { return m_device->getDeviceInterface();                   }
 270 deUint32                                                                Context::getUniversalQueueFamilyIndex   (void) const { return m_device->getUniversalQueueFamilyIndex(); }
 271 vk::VkQueue                                                             Context::getUniversalQueue                              (void) const { return m_device->getUniversalQueue();                    }
 272 vk::Allocator&                                                  Context::getDefaultAllocator                    (void) const { return *m_allocator;                                                             }
 273
 274 // TestCase
 275
 276 void TestCase::initPrograms (SourceCollections&) const
 277 {
 278 }
 279
 280 } // vkt