external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesBase.hpp

   1 #ifndef _VKTSPARSERESOURCESBASE_HPP
   2 #define _VKTSPARSERESOURCESBASE_HPP
   3 /*------------------------------------------------------------------------
   4  * Vulkan Conformance Tests
   5  * ------------------------
   6  *
   7  * Copyright (c) 2016 The Khronos Group 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  vktSparseResourcesBase.hpp
  23  * \brief Sparse Resources Base Instance
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "vkDefs.hpp"
  27 #include "vktTestCase.hpp"
  28 #include "vktCustomInstancesDevices.hpp"
  29 #include "vkRef.hpp"
  30 #include "vkPlatform.hpp"
  31 #include "deUniquePtr.hpp"
  32 #include "tcuCommandLine.hpp"
  33
  34 #include <map>
  35 #include <vector>
  36
  37 namespace vkt
  38 {
  39 namespace sparse
  40 {
  41
  42 struct Queue
  43 {
  44         vk::VkQueue     queueHandle;
  45         deUint32        queueFamilyIndex;
  46         deUint32        queueIndex;
  47 };
  48
  49 struct QueueRequirements
  50 {
  51         QueueRequirements(const vk::VkQueueFlags qFlags, const deUint32 qCount)
  52                 : queueFlags(qFlags)
  53                 , queueCount(qCount)
  54         {}
  55
  56         vk::VkQueueFlags        queueFlags;
  57         deUint32                        queueCount;
  58 };
  59
  60 class SparseResourcesBaseInstance : public TestInstance
  61 {
  62 public:
  63         SparseResourcesBaseInstance (Context &context, bool useDeviceGroups = false)
  64                 : TestInstance                  (context)
  65                 , m_numPhysicalDevices  (1)
  66                 , m_useDeviceGroups             (useDeviceGroups)
  67         {
  68                 const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
  69                 m_deviceGroupIdx                                = cmdLine.getVKDeviceGroupId() - 1;
  70         }
  71         bool                    usingDeviceGroups               ()                                                      { return m_useDeviceGroups; }
  72
  73 protected:
  74         typedef std::vector<QueueRequirements>                          QueueRequirementsVec;
  75
  76         deUint32                                                                                        m_numPhysicalDevices;
  77
  78         void                                                                                            createDeviceSupportingQueues    (const QueueRequirementsVec& queueRequirements);
  79         const Queue&                                                                            getQueue                                                (const vk::VkQueueFlags queueFlags, const deUint32 queueIndex) const;
  80         const vk::DeviceInterface&                                                      getDeviceInterface                              (void) const            { return *m_deviceDriver; }
  81         vk::VkDevice                                                                            getDevice                                               (void) const            { return *m_logicalDevice; }
  82         vk::Allocator&                                                                          getAllocator                                    (void)                          { return *m_allocator; }
  83         vk::VkPhysicalDevice                                                            getPhysicalDevice                               (deUint32 i = 0)        { return m_physicalDevices[i];}
  84
  85 private:
  86         bool                                                                                            m_useDeviceGroups;
  87         deUint32                                                                                        m_deviceGroupIdx;
  88         CustomInstance                                                                          m_deviceGroupInstance;
  89         std::vector<vk::VkPhysicalDevice>                                       m_physicalDevices;
  90         std::map<vk::VkQueueFlags, std::vector<Queue> >         m_queues;
  91         de::MovePtr<vk::DeviceDriver>                                           m_deviceDriver;
  92         vk::Move<vk::VkDevice>                                                          m_logicalDevice;
  93         de::MovePtr<vk::Allocator>                                                      m_allocator;
  94 };
  95
  96 } // sparse
  97 } // vkt
  98
  99 #endif // _VKTSPARSERESOURCESBASE_HPP