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
  33 #include "deMemory.h"
  34
  35 namespace vkt
  36 {
  37
  38 // Default device utilities
  39
  40 using std::vector;
  41 using namespace vk;
  42
  43 static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
  44 {
  45         const vector<VkQueueFamilyProperties>   queueProps      = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
  46
  47         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
  48         {
  49                 if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps)
  50                         return (deUint32)queueNdx;
  51         }
  52
  53         TCU_THROW(NotSupportedError, "No matching queue found");
  54 }
  55
  56 Move<VkDevice> createDefaultDevice (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, deUint32 queueIndex, const VkPhysicalDeviceFeatures& enabledFeatures)
  57 {
  58         VkDeviceQueueCreateInfo         queueInfo;
  59         VkDeviceCreateInfo                      deviceInfo;
  60         const float                                     queuePriority   = 1.0f;
  61
  62         deMemset(&queueInfo,    0, sizeof(queueInfo));
  63         deMemset(&deviceInfo,   0, sizeof(deviceInfo));
  64
  65         queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
  66         queueInfo.pNext                                                 = DE_NULL;
  67         queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
  68         queueInfo.queueFamilyIndex                              = queueIndex;
  69         queueInfo.queueCount                                    = 1u;
  70         queueInfo.pQueuePriorities                              = &queuePriority;
  71
  72         deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
  73         deviceInfo.pNext                                                = DE_NULL;
  74         deviceInfo.queueCreateInfoCount                 = 1u;
  75         deviceInfo.pQueueCreateInfos                    = &queueInfo;
  76         deviceInfo.enabledExtensionCount                = 0u;
  77         deviceInfo.ppEnabledExtensionNames              = DE_NULL;
  78         deviceInfo.enabledLayerCount                    = 0u;
  79         deviceInfo.ppEnabledLayerNames                  = DE_NULL;
  80         deviceInfo.pEnabledFeatures                             = &enabledFeatures;
  81
  82         return createDevice(vki, physicalDevice, &deviceInfo);
  83 };
  84
  85 class DefaultDevice
  86 {
  87 public:
  88                                                                                 DefaultDevice                                   (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
  89                                                                                 ~DefaultDevice                                  (void);
  90
  91         VkInstance                                                      getInstance                                             (void) const    { return *m_instance;                                   }
  92         const InstanceInterface&                        getInstanceInterface                    (void) const    { return m_instanceInterface;                   }
  93
  94         VkPhysicalDevice                                        getPhysicalDevice                               (void) const    { return m_physicalDevice;                              }
  95         const VkPhysicalDeviceFeatures&         getDeviceFeatures                               (void) const    { return m_deviceFeatures;                              }
  96         VkDevice                                                        getDevice                                               (void) const    { return *m_device;                                             }
  97         const DeviceInterface&                          getDeviceInterface                              (void) const    { return m_deviceInterface;                             }
  98         const VkPhysicalDeviceProperties&       getDeviceProperties                             (void) const    { return m_deviceProperties;                    }
  99
 100         deUint32                                                        getUniversalQueueFamilyIndex    (void) const    { return m_universalQueueFamilyIndex;   }
 101         VkQueue                                                         getUniversalQueue                               (void) const;
 102
 103 private:
 104         static VkPhysicalDeviceFeatures         filterDefaultDeviceFeatures             (const VkPhysicalDeviceFeatures& deviceFeatures);
 105
 106         const Unique<VkInstance>                        m_instance;
 107         const InstanceDriver                            m_instanceInterface;
 108
 109         const VkPhysicalDevice                          m_physicalDevice;
 110
 111         const deUint32                                          m_universalQueueFamilyIndex;
 112         const VkPhysicalDeviceFeatures          m_deviceFeatures;
 113         const VkPhysicalDeviceProperties        m_deviceProperties;
 114
 115         const Unique<VkDevice>                          m_device;
 116         const DeviceDriver                                      m_deviceInterface;
 117 };
 118
 119 DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
 120         : m_instance                                    (createDefaultInstance(vkPlatform))
 121         , m_instanceInterface                   (vkPlatform, *m_instance)
 122         , m_physicalDevice                              (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
 123         , m_universalQueueFamilyIndex   (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
 124         , m_deviceFeatures                              (filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(m_instanceInterface, m_physicalDevice)))
 125         , m_deviceProperties                    (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice)) // \note All supported features are enabled
 126         , m_device                                              (createDefaultDevice(m_instanceInterface, m_physicalDevice, m_universalQueueFamilyIndex, m_deviceFeatures))
 127         , m_deviceInterface                             (m_instanceInterface, *m_device)
 128 {
 129 }
 130
 131 DefaultDevice::~DefaultDevice (void)
 132 {
 133 }
 134
 135 VkQueue DefaultDevice::getUniversalQueue (void) const
 136 {
 137         VkQueue queue   = 0;
 138         m_deviceInterface.getDeviceQueue(*m_device, m_universalQueueFamilyIndex, 0, &queue);
 139         return queue;
 140 }
 141
 142 VkPhysicalDeviceFeatures DefaultDevice::filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
 143 {
 144         VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
 145
 146         // Disable robustness by default, as it has an impact on performance on some HW.
 147         enabledDeviceFeatures.robustBufferAccess = false;
 148
 149         return enabledDeviceFeatures;
 150 }
 151
 152 // Allocator utilities
 153
 154 vk::Allocator* createAllocator (DefaultDevice* device)
 155 {
 156         const VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(device->getInstanceInterface(), device->getPhysicalDevice());
 157
 158         // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
 159         return new SimpleAllocator(device->getDeviceInterface(), device->getDevice(), memoryProperties);
 160 }
 161
 162 // Context
 163
 164 Context::Context (tcu::TestContext&                                                     testCtx,
 165                                   const vk::PlatformInterface&                          platformInterface,
 166                                   vk::ProgramCollection<vk::ProgramBinary>&     progCollection)
 167         : m_testCtx                             (testCtx)
 168         , m_platformInterface   (platformInterface)
 169         , m_progCollection              (progCollection)
 170         , m_device                              (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
 171         , m_allocator                   (createAllocator(m_device.get()))
 172 {
 173 }
 174
 175 Context::~Context (void)
 176 {
 177 }
 178
 179 vk::VkInstance                                          Context::getInstance                                    (void) const { return m_device->getInstance();                                  }
 180 const vk::InstanceInterface&            Context::getInstanceInterface                   (void) const { return m_device->getInstanceInterface();                 }
 181 vk::VkPhysicalDevice                            Context::getPhysicalDevice                              (void) const { return m_device->getPhysicalDevice();                    }
 182 const vk::VkPhysicalDeviceFeatures&     Context::getDeviceFeatures                              (void) const { return m_device->getDeviceFeatures();                    }
 183 const vk::VkPhysicalDeviceProperties&   Context::getDeviceProperties            (void) const { return m_device->getDeviceProperties();                  }
 184 vk::VkDevice                                            Context::getDevice                                              (void) const { return m_device->getDevice();                                    }
 185 const vk::DeviceInterface&                      Context::getDeviceInterface                             (void) const { return m_device->getDeviceInterface();                   }
 186 deUint32                                                        Context::getUniversalQueueFamilyIndex   (void) const { return m_device->getUniversalQueueFamilyIndex(); }
 187 vk::VkQueue                                                     Context::getUniversalQueue                              (void) const { return m_device->getUniversalQueue();                    }
 188 vk::Allocator&                                          Context::getDefaultAllocator                    (void) const { return *m_allocator;                                                             }
 189
 190 // TestCase
 191
 192 void TestCase::initPrograms (SourceCollections&) const
 193 {
 194 }
 195
 196 } // vkt