external/vulkancts/framework/vulkan/vkPlatform.hpp

   1 #ifndef _VKPLATFORM_HPP
   2 #define _VKPLATFORM_HPP
   3 /*-------------------------------------------------------------------------
   4  * Vulkan CTS Framework
   5  * --------------------
   6  *
   7  * Copyright (c) 2015 Google Inc.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Vulkan platform abstraction.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "vkDefs.hpp"
  27 #include "deUniquePtr.hpp"
  28
  29 #include <ostream>
  30 #include <deSharedPtr.hpp>
  31 #ifdef CTS_USES_VULKANSC
  32 #include <mutex>
  33         #include <vector>
  34         #include <map>
  35         #include "vkResourceInterface.hpp"
  36 #include "tcuCommandLine.hpp"
  37 #endif // CTS_USES_VULKANSC
  38
  39 namespace tcu
  40 {
  41 class FunctionLibrary;
  42 }
  43
  44 namespace vk
  45 {
  46
  47 class Library
  48 {
  49 public:
  50                                                                                 Library                                 (void) {}
  51         virtual                                                         ~Library                                (void) {}
  52
  53         virtual const PlatformInterface&        getPlatformInterface    (void) const = 0;
  54         virtual const tcu::FunctionLibrary&     getFunctionLibrary              (void) const = 0;
  55 };
  56
  57 class PlatformDriver : public PlatformInterface
  58 {
  59 public:
  60                                 PlatformDriver  (const tcu::FunctionLibrary& library);
  61                                 ~PlatformDriver (void);
  62
  63 #include "vkConcretePlatformInterface.inl"
  64
  65                                 virtual GetInstanceProcAddrFunc getGetInstanceProcAddr  () const {
  66                                         return m_vk.getInstanceProcAddr;
  67                                 }
  68
  69 protected:
  70         struct Functions
  71         {
  72 #include "vkPlatformFunctionPointers.inl"
  73         };
  74
  75         Functions       m_vk;
  76 };
  77
  78 class InstanceDriver : public InstanceInterface
  79 {
  80 public:
  81                                                 InstanceDriver          (const PlatformInterface&       platformInterface,
  82                                                                                          VkInstance                                     instance);
  83         virtual                         ~InstanceDriver         (void);
  84
  85 #include "vkConcreteInstanceInterface.inl"
  86
  87 protected:
  88         void                            loadFunctions           (const PlatformInterface&       platformInterface,
  89                                                                                          VkInstance                                     instance);
  90
  91         struct Functions
  92         {
  93 #include "vkInstanceFunctionPointers.inl"
  94         };
  95
  96         Functions       m_vk;
  97 };
  98
  99 #ifdef CTS_USES_VULKANSC
 100
 101 class InstanceDriverSC : public InstanceDriver
 102 {
 103 public:
 104                                                 InstanceDriverSC        (const PlatformInterface&                               platformInterface,
 105                                                                                          VkInstance                                                             instance,
 106                                                                                          const tcu::CommandLine&                                cmdLine,
 107                                                                                          de::SharedPtr<vk::ResourceInterface>   resourceInterface);
 108
 109         virtual VkResult        createDevice            (VkPhysicalDevice                                               physicalDevice,
 110                                                                                          const VkDeviceCreateInfo*                              pCreateInfo,
 111                                                                                          const VkAllocationCallbacks*                   pAllocator,
 112                                                                                          VkDevice*                                                              pDevice) const;
 113 protected:
 114         mutable std::mutex                                              functionMutex;
 115         bool                                                                    m_normalMode;
 116         de::SharedPtr<vk::ResourceInterface>    m_resourceInterface;
 117 };
 118
 119 #endif // CTS_USES_VULKANSC
 120
 121 class DeviceDriver : public DeviceInterface
 122 {
 123 public:
 124                                                 DeviceDriver            (const PlatformInterface&                       platformInterface,
 125                                                                                          VkInstance                                                     instance,
 126                                                                                          VkDevice                                                       device);
 127         virtual                         ~DeviceDriver           (void);
 128
 129 #include "vkConcreteDeviceInterface.inl"
 130
 131 #ifdef CTS_USES_VULKANSC
 132         virtual VkResult        createShaderModule      (VkDevice                                                       device,
 133                                                                                          const VkShaderModuleCreateInfo*        pCreateInfo,
 134                                                                                          const VkAllocationCallbacks*           pAllocator,
 135                                                                                          VkShaderModule*                                        pShaderModule) const;
 136 #endif // CTS_USES_VULKANSC
 137
 138 protected:
 139         struct Functions
 140         {
 141 #include "vkDeviceFunctionPointers.inl"
 142         };
 143
 144         Functions       m_vk;
 145 };
 146
 147 #ifdef CTS_USES_VULKANSC
 148
 149 #define DDSTAT_LOCK() std::lock_guard<std::mutex> statLock(m_resourceInterface->getStatMutex())
 150 #define DDSTAT_HANDLE_CREATE(VAR_NAME,VAR_VALUE) do { m_resourceInterface->getStatCurrent().VAR_NAME += (VAR_VALUE); m_resourceInterface->getStatMax().VAR_NAME = de::max(m_resourceInterface->getStatMax().VAR_NAME, m_resourceInterface->getStatCurrent().VAR_NAME); } while(0)
 151 #define DDSTAT_HANDLE_DESTROY_IF(VAR_VARIABLE,VAR_NAME,VAR_VALUE) if(VAR_VARIABLE.getInternal()!=DE_NULL && m_resourceInterface->isEnabledHandleDestroy()) m_resourceInterface->getStatCurrent().VAR_NAME -= (VAR_VALUE)
 152 #define DDSTAT_HANDLE_DESTROY(VAR_NAME,VAR_VALUE) if( m_resourceInterface->isEnabledHandleDestroy() ) m_resourceInterface->getStatCurrent().VAR_NAME -= (VAR_VALUE)
 153
 154 class DeviceDriverSC : public DeviceDriver
 155 {
 156 public:
 157                                                                                 DeviceDriverSC                                          (const          PlatformInterface&                                      platformInterface,
 158                                                                                                                                                          VkInstance                                                                             instance,
 159                                                                                                                                                          VkDevice                                                                               device,
 160                                                                                                                                                          const tcu::CommandLine&                                                cmdLine,
 161                                                                                                                                                          de::SharedPtr<vk::ResourceInterface>                   resourceInterface,
 162                                                                                                                                                          const VkPhysicalDeviceVulkanSC10Properties&    physicalDeviceVulkanSC10Properties,
 163                                                                                                                                                          const VkPhysicalDeviceProperties&                              physicalDeviceProperties);
 164         virtual                                                         ~DeviceDriverSC                                         (void);
 165
 166 #include "vkConcreteDeviceInterface.inl"
 167
 168         // Functions ending with Handler() and HandlerStat() work only when we gather statistics ( in a main process ).
 169         // Functions ending with HandlerNorm() work in normal mode ( in subprocess, when real test is performed )
 170         // Method createShaderModule() works in both modes, and ResourceInterface is responsible for distinguishing modes
 171         void                                                            destroyDeviceHandler                                    (VkDevice                                                               device,
 172                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator) const;
 173         VkResult                                                        createDescriptorSetLayoutHandlerNorm    (VkDevice                                                               device,
 174                                                                                                                                                                  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
 175                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 176                                                                                                                                                                  VkDescriptorSetLayout*                                 pSetLayout) const;
 177         void                                                            createDescriptorSetLayoutHandlerStat    (VkDevice                                                               device,
 178                                                                                                                                                                  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
 179                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 180                                                                                                                                                                  VkDescriptorSetLayout*                                 pSetLayout) const;
 181         void                                                            destroyDescriptorSetLayoutHandler               (VkDevice                                                               device,
 182                                                                                                                                                                  VkDescriptorSetLayout                                  descriptorSetLayout,
 183                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator) const;
 184         void                                                            allocateDescriptorSetsHandlerStat               (VkDevice                                                               device,
 185                                                                                                                                                                  const VkDescriptorSetAllocateInfo*             pAllocateInfo,
 186                                                                                                                                                                  VkDescriptorSet*                                               pDescriptorSets) const;
 187         void                                                            freeDescriptorSetsHandlerStat                   (VkDevice                                                               device,
 188                                                                                                                                                                  VkDescriptorPool                                               descriptorPool,
 189                                                                                                                                                                  uint32_t                                                               descriptorSetCount,
 190                                                                                                                                                                  const VkDescriptorSet*                                 pDescriptorSets) const;
 191         void                                                            resetDescriptorPoolHandlerStat                  (VkDevice                                                               device,
 192                                                                                                                                                                  VkDescriptorPool                                               descriptorPool,
 193                                                                                                                                                                  VkDescriptorPoolResetFlags                             flags) const;
 194         void                                                            createImageViewHandler                                  (VkDevice                                                               device,
 195                                                                                                                                                                  const VkImageViewCreateInfo*                   pCreateInfo,
 196                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 197                                                                                                                                                                  VkImageView*                                                   pView) const;
 198         void                                                            destroyImageViewHandler                                 (VkDevice                                                               device,
 199                                                                                                                                                                  VkImageView                                                    imageView,
 200                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator) const;
 201         void                                                            createQueryPoolHandler                                  (VkDevice                                                               device,
 202                                                                                                                                                                  const VkQueryPoolCreateInfo*                   pCreateInfo,
 203                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 204                                                                                                                                                                  VkQueryPool*                                                   pQueryPool) const ;
 205         VkResult                                                        createPipelineLayoutHandlerNorm                 (VkDevice                                                               device,
 206                                                                                                                                                                  const VkPipelineLayoutCreateInfo*              pCreateInfo,
 207                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 208                                                                                                                                                                  VkPipelineLayout*                                              pPipelineLayout) const;
 209         void                                                            createPipelineLayoutHandlerStat                 (VkDevice                                                               device,
 210                                                                                                                                                                  const VkPipelineLayoutCreateInfo*              pCreateInfo,
 211                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 212                                                                                                                                                                  VkPipelineLayout*                                              pPipelineLayout) const;
 213         VkResult                                                        createGraphicsPipelinesHandlerNorm              (VkDevice                                                               device,
 214                                                                                                                                                                  VkPipelineCache                                                pipelineCache,
 215                                                                                                                                                                  deUint32                                                               createInfoCount,
 216                                                                                                                                                                  const VkGraphicsPipelineCreateInfo*    pCreateInfos,
 217                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 218                                                                                                                                                                  VkPipeline*                                                    pPipelines) const;
 219         void                                                            createGraphicsPipelinesHandlerStat              (VkDevice                                                               device,
 220                                                                                                                                                                  VkPipelineCache                                                pipelineCache,
 221                                                                                                                                                                  deUint32                                                               createInfoCount,
 222                                                                                                                                                                  const VkGraphicsPipelineCreateInfo*    pCreateInfos,
 223                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 224                                                                                                                                                                  VkPipeline*                                                    pPipelines) const;
 225         VkResult                                                        createComputePipelinesHandlerNorm               (VkDevice                                                               device,
 226                                                                                                                                                                  VkPipelineCache                                                pipelineCache,
 227                                                                                                                                                                  deUint32                                                               createInfoCount,
 228                                                                                                                                                                  const VkComputePipelineCreateInfo*             pCreateInfos,
 229                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 230                                                                                                                                                                  VkPipeline*                                                    pPipelines) const;
 231         void                                                            createComputePipelinesHandlerStat               (VkDevice                                                               device,
 232                                                                                                                                                                  VkPipelineCache                                                pipelineCache,
 233                                                                                                                                                                  deUint32                                                               createInfoCount,
 234                                                                                                                                                                  const VkComputePipelineCreateInfo*             pCreateInfos,
 235                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 236                                                                                                                                                                  VkPipeline*                                                    pPipelines) const;
 237         void                                                            destroyPipelineHandler                                  (VkDevice                                                               device,
 238                                                                                                                                                                  VkPipeline                                                             pipeline,
 239                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator) const;
 240         VkResult                                                        createFramebufferHandlerNorm                    (VkDevice                                                               device,
 241                                                                                                                                                                  const VkFramebufferCreateInfo*                 pCreateInfo,
 242                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 243                                                                                                                                                                  VkFramebuffer*                                                 pFramebuffer) const;
 244         void                                                            createFramebufferHandlerStat                    (VkDevice                                                               device,
 245                                                                                                                                                                  const VkFramebufferCreateInfo*                 pCreateInfo,
 246                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 247                                                                                                                                                                  VkFramebuffer*                                                 pFramebuffer) const;
 248         VkResult                                                        createRenderPassHandlerNorm                             (VkDevice                                                               device,
 249                                                                                                                                                                  const VkRenderPassCreateInfo*                  pCreateInfo,
 250                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 251                                                                                                                                                                  VkRenderPass*                                                  pRenderPass) const;
 252         void                                                            createRenderPassHandlerStat                             (VkDevice                                                               device,
 253                                                                                                                                                                  const VkRenderPassCreateInfo*                  pCreateInfo,
 254                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 255                                                                                                                                                                  VkRenderPass*                                                  pRenderPass) const;
 256         VkResult                                                        createRenderPass2HandlerNorm                    (VkDevice                                                               device,
 257                                                                                                                                                                  const VkRenderPassCreateInfo2*                 pCreateInfo,
 258                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 259                                                                                                                                                                  VkRenderPass*                                                  pRenderPass) const;
 260         void                                                            createRenderPass2HandlerStat                    (VkDevice                                                               device,
 261                                                                                                                                                                  const VkRenderPassCreateInfo2*                 pCreateInfo,
 262                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 263                                                                                                                                                                  VkRenderPass*                                                  pRenderPass) const;
 264         void                                                            destroyRenderPassHandler                                (VkDevice                                                               device,
 265                                                                                                                                                                  VkRenderPass                                                   renderPass,
 266                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator) const;
 267         VkResult                                                        createSamplerHandlerNorm                                (VkDevice                                                               device,
 268                                                                                                                                                                  const VkSamplerCreateInfo*                             pCreateInfo,
 269                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 270                                                                                                                                                                  VkSampler*                                                             pSampler) const;
 271         void                                                            createSamplerHandlerStat                                (VkDevice                                                               device,
 272                                                                                                                                                                  const VkSamplerCreateInfo*                             pCreateInfo,
 273                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 274                                                                                                                                                                  VkSampler*                                                             pSampler) const;
 275         VkResult                                                        createSamplerYcbcrConversionHandlerNorm (VkDevice                                                               device,
 276                                                                                                                                                                  const VkSamplerYcbcrConversionCreateInfo*      pCreateInfo,
 277                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 278                                                                                                                                                                  VkSamplerYcbcrConversion*                              pYcbcrConversion) const;
 279         void                                                            createSamplerYcbcrConversionHandlerStat (VkDevice                                                               device,
 280                                                                                                                                                                  const VkSamplerYcbcrConversionCreateInfo*      pCreateInfo,
 281                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 282                                                                                                                                                                  VkSamplerYcbcrConversion*                              pYcbcrConversion) const;
 283         void                                                            getDescriptorSetLayoutSupportHandler    (VkDevice                                                               device,
 284                                                                                                                                                                  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
 285                                                                                                                                                                  VkDescriptorSetLayoutSupport*                  pSupport) const;
 286         virtual VkResult                                        createShaderModule                                              (VkDevice                                                               device,
 287                                                                                                                                                                  const  VkShaderModuleCreateInfo*               pCreateInfo,
 288                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 289                                                                                                                                                                  VkShaderModule*                                                pShaderModule) const;
 290
 291         VkResult                                                        createCommandPoolHandlerNorm                    (VkDevice                                                               device,
 292                                                                                                                                                                  const VkCommandPoolCreateInfo*                 pCreateInfo,
 293                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 294                                                                                                                                                                  VkCommandPool*                                                 pCommandPool) const;
 295         VkResult                                                        resetCommandPoolHandlerNorm                             (VkDevice                                                               device,
 296                                                                                                                                                                  VkCommandPool                                                  commandPool,
 297                                                                                                                                                                  VkCommandPoolResetFlags                                flags) const;
 298         void                                                            createCommandPoolHandlerStat                    (VkDevice                                                               device,
 299                                                                                                                                                                  const VkCommandPoolCreateInfo*                 pCreateInfo,
 300                                                                                                                                                                  const VkAllocationCallbacks*                   pAllocator,
 301                                                                                                                                                                  VkCommandPool*                                                 pCommandPool) const;
 302         void                                                            resetCommandPoolHandlerStat                             (VkDevice                                                               device,
 303                                                                                                                                                                  VkCommandPool                                                  commandPool,
 304                                                                                                                                                                  VkCommandPoolResetFlags                                flags) const;
 305         void                                                            allocateCommandBuffersHandler                   (VkDevice                                                               device,
 306                                                                                                                                                                  const VkCommandBufferAllocateInfo*             pAllocateInfo,
 307                                                                                                                                                                  VkCommandBuffer*                                               pCommandBuffers) const;
 308         void                                                            freeCommandBuffersHandler                               (VkDevice                                                               device,
 309                                                                                                                                                                  VkCommandPool                                                  commandPool,
 310                                                                                                                                                                  deUint32                                                               commandBufferCount,
 311                                                                                                                                                                  const VkCommandBuffer*                                 pCommandBuffers) const;
 312         void                                                            increaseCommandBufferSize                               (VkCommandBuffer                                                commandBuffer,
 313                                                                                                                                                                  VkDeviceSize                                                   commandSize) const;
 314         void                                                            checkFramebufferSupport                                 (const VkFramebufferCreateInfo*                 pCreateInfo) const;
 315         void                                                            checkRenderPassSupport                                  (deUint32                                                               attachmentCount,
 316                                                                                                                                                                  deUint32                                                               subpassCount,
 317                                                                                                                                                                  deUint32                                                               dependencyCount) const;
 318         void                                                            checkSubpassSupport                                             (deUint32                                                               inputAttachmentCount,
 319                                                                                                                                                                  deUint32                                                               preserveAttachmentCount) const;
 320
 321
 322         de::SharedPtr<ResourceInterface>        gerResourceInterface                                    () const;
 323         void                                                            reset                                                                   () const;
 324
 325 protected:
 326         mutable std::mutex                                                                                                                      functionMutex;
 327         bool                                                                                                                                            m_normalMode;
 328
 329         de::SharedPtr<vk::ResourceInterface>                                                                            m_resourceInterface;
 330
 331         mutable std::vector<deUint8>                                                                                            m_falseMemory;
 332         mutable std::map<VkImageView, VkImageViewCreateInfo>                                            m_imageViews;
 333         mutable std::map<VkDescriptorSetLayout, VkDescriptorSetLayoutCreateInfo>        m_descriptorSetLayouts;
 334         mutable std::map<VkRenderPass, VkRenderPassCreateInfo>                                          m_renderPasses;
 335         mutable std::map<VkRenderPass, VkRenderPassCreateInfo2>                                         m_renderPasses2;
 336         mutable std::map<VkPipeline, VkGraphicsPipelineCreateInfo>                                      m_graphicsPipelines;
 337         mutable std::map<VkPipeline, VkComputePipelineCreateInfo>                                       m_computePipelines;
 338         mutable std::map<VkDescriptorSet, VkDescriptorPool>                                                     m_descriptorSetsInPool;
 339         VkPhysicalDeviceVulkanSC10Properties                                                                            m_physicalDeviceVulkanSC10Properties;
 340         VkPhysicalDeviceProperties                                                                                                      m_physicalDeviceProperties;
 341
 342         VkDeviceSize                                                                                                                            m_commandDefaultSize;
 343         VkDeviceSize                                                                                                                            m_commandBufferMinimumSize;
 344         VkDeviceSize                                                                                                                            m_commandPoolMinimumSize;
 345 };
 346
 347 class DeinitDeviceDeleter : public Deleter<DeviceDriverSC>
 348 {
 349 public:
 350                                                                                 DeinitDeviceDeleter                                     (ResourceInterface* resourceInterface, const VkDevice& device)
 351                 : m_resourceInterface(resourceInterface)
 352                 , m_device(device)
 353         {
 354         }
 355                                                                                 DeinitDeviceDeleter                                     (void)
 356                 : m_resourceInterface(DE_NULL)
 357                 , m_device(DE_NULL)
 358         {}
 359
 360         void                                                            operator()                                                      (DeviceDriverSC* obj) const
 361         {
 362                 if (m_resourceInterface != DE_NULL)
 363                         m_resourceInterface->deinitDevice(m_device);
 364                 delete obj;
 365         }
 366 private:
 367         ResourceInterface*      m_resourceInterface;
 368         VkDevice                        m_device;
 369 };
 370
 371 #endif // CTS_USES_VULKANSC
 372
 373 // Single device driver pointer type which will differ in SC and non-SC mode helping clearing the code
 374 #ifndef CTS_USES_VULKANSC
 375 typedef de::MovePtr<DeviceDriver> DeviceDriverPtr;
 376 #else
 377 typedef de::MovePtr<DeviceDriverSC, vk::DeinitDeviceDeleter> DeviceDriverPtr;
 378 #endif // CTS_USES_VULKANSC
 379
 380 // Defined in vkWsiPlatform.hpp
 381 namespace wsi
 382 {
 383 class Display;
 384 } // wsi
 385
 386 /*--------------------------------------------------------------------*//*!
 387  * \brief Vulkan platform interface
 388  *//*--------------------------------------------------------------------*/
 389 class Platform
 390 {
 391 public:
 392                                                         Platform                        (void) {}
 393                                                         ~Platform                       (void) {}
 394
 395         virtual Library*                createLibrary           (const char* libraryPath) const = 0;
 396         virtual wsi::Display*   createWsiDisplay        (wsi::Type wsiType) const;
 397         virtual bool                    hasDisplay                      (wsi::Type wsiType) const;
 398         virtual void                    describePlatform        (std::ostream& dst) const;
 399 };
 400
 401 } // vk
 402
 403 #endif // _VKPLATFORM_HPP