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

   1 #ifndef _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
   2 #define _VKTSPARSERESOURCESSHADERINTRINSICSBASE_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  vktSparseResourcesShaderIntrinsicsBase.hpp
  23  * \brief Sparse Resources Shader Intrinsics Base Classes
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "vktTestCase.hpp"
  28 #include "vktTestCaseUtil.hpp"
  29 #include "vktSparseResourcesBase.hpp"
  30 #include "vktSparseResourcesTestsUtil.hpp"
  31
  32 #include "vkDefs.hpp"
  33 #include "vkRef.hpp"
  34 #include "vkRefUtil.hpp"
  35 #include "vkPlatform.hpp"
  36 #include "vkPrograms.hpp"
  37 #include "vkRefUtil.hpp"
  38 #include "vkMemUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkBuilderUtil.hpp"
  41 #include "vkTypeUtil.hpp"
  42 #include "vkDebugReportUtil.hpp"
  43 #include "tcuTextureUtil.hpp"
  44
  45 #include "deStringUtil.hpp"
  46 #include "deUniquePtr.hpp"
  47 #include "deSharedPtr.hpp"
  48
  49 #include <string>
  50 #include <vector>
  51
  52 #include <deMath.h>
  53
  54 namespace vkt
  55 {
  56 namespace sparse
  57 {
  58
  59 enum
  60 {
  61         MEMORY_BLOCK_BOUND              = 0u,
  62         MEMORY_BLOCK_NOT_BOUND  = 1u,
  63         MEMORY_BLOCK_TYPE_COUNT = 2u
  64 };
  65
  66 enum
  67 {
  68         MEMORY_BLOCK_BOUND_VALUE         = 1u,
  69         MEMORY_BLOCK_NOT_BOUND_VALUE = 2u
  70 };
  71
  72 enum
  73 {
  74         BINDING_IMAGE_SPARSE    = 0u,
  75         BINDING_IMAGE_TEXELS    = 1u,
  76         BINDING_IMAGE_RESIDENCY = 2u
  77 };
  78
  79 enum SpirVFunction
  80 {
  81         SPARSE_FETCH = 0u,
  82         SPARSE_READ,
  83         SPARSE_SAMPLE_EXPLICIT_LOD,
  84         SPARSE_SAMPLE_IMPLICIT_LOD,
  85         SPARSE_GATHER,
  86         SPARSE_SPIRV_FUNCTION_TYPE_LAST
  87 };
  88
  89 std::string getOpTypeImageComponent                     (const tcu::TextureFormat& format);
  90 std::string getOpTypeImageComponent                     (const vk::PlanarFormatDescription& description);
  91 std::string getImageComponentTypeName           (const tcu::TextureFormat& format);
  92 std::string getImageComponentTypeName           (const vk::PlanarFormatDescription& description);
  93 std::string getImageComponentVec4TypeName       (const tcu::TextureFormat& format);
  94 std::string getImageComponentVec4TypeName       (const vk::PlanarFormatDescription& description);
  95 std::string getOpTypeImageSparse                        (const ImageType                        imageType,
  96                                                                                          const tcu::TextureFormat&      format,
  97                                                                                          const std::string&                     componentType,
  98                                                                                          const bool                                     requiresSampler);
  99 std::string getOpTypeImageSparse                        (const ImageType                        imageType,
 100                                                                                          const vk::VkFormat                     format,
 101                                                                                          const std::string&                     componentType,
 102                                                                                          const bool                                     requiresSampler);
 103 std::string getOpTypeImageResidency                     (const ImageType imageType);
 104
 105 class SparseShaderIntrinsicsCaseBase : public TestCase
 106 {
 107 public:
 108         SparseShaderIntrinsicsCaseBase                  (tcu::TestContext&                      testCtx,
 109                                                                                          const std::string&                     name,
 110                                                                                          const SpirVFunction            function,
 111                                                                                          const ImageType                        imageType,
 112                                                                                          const tcu::UVec3&                      imageSize,
 113                                                                                          const vk::VkFormat                     format)
 114                 : TestCase(testCtx, name, "")
 115                 , m_function(function)
 116                 , m_imageType(imageType)
 117                 , m_imageSize(imageSize)
 118                 , m_format(format)
 119         {
 120         }
 121
 122         virtual void    checkSupport                                    (Context&       context) const
 123         {
 124                 const vk::InstanceInterface&    instance                = context.getInstanceInterface();
 125                 const vk::VkPhysicalDevice              physicalDevice  = context.getPhysicalDevice();
 126
 127                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY);
 128
 129                 // Check if image size does not exceed device limits
 130                 if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
 131                         TCU_THROW(NotSupportedError, "Image size not supported for device");
 132
 133                 // Check if device supports sparse operations for image type
 134                 if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
 135                         TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
 136         }
 137
 138 protected:
 139         const SpirVFunction                     m_function;
 140         const ImageType                         m_imageType;
 141         const tcu::UVec3                        m_imageSize;
 142         const vk::VkFormat                      m_format;
 143 };
 144
 145 class SparseShaderIntrinsicsInstanceBase : public SparseResourcesBaseInstance
 146 {
 147 public:
 148         SparseShaderIntrinsicsInstanceBase              (Context&                                       context,
 149                                                                                          const SpirVFunction            function,
 150                                                                                          const ImageType                        imageType,
 151                                                                                          const tcu::UVec3&                      imageSize,
 152                                                                                          const vk::VkFormat                     format)
 153                 : SparseResourcesBaseInstance(context)
 154                 , m_function(function)
 155                 , m_imageType(imageType)
 156                 , m_imageSize(imageSize)
 157                 , m_format(format)
 158                 , m_residencyFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)
 159         {
 160         }
 161
 162         tcu::TestStatus                                         iterate                                 (void);
 163
 164         virtual vk::VkImageUsageFlags           imageSparseUsageFlags   (void) const = 0;
 165         virtual vk::VkImageUsageFlags           imageOutputUsageFlags   (void) const = 0;
 166
 167         virtual vk::VkQueueFlags                        getQueueFlags                   (void) const = 0;
 168
 169         virtual void                                            recordCommands                  (const vk::VkCommandBuffer              commandBuffer,
 170                                                                                                                                  const vk::VkImageCreateInfo&   imageSparseInfo,
 171                                                                                                                                  const vk::VkImage                              imageSparse,
 172                                                                                                                                  const vk::VkImage                              imageTexels,
 173                                                                                                                                  const vk::VkImage                              imageResidency) = 0;
 174 protected:
 175         const SpirVFunction                     m_function;
 176         const ImageType                         m_imageType;
 177         const tcu::UVec3                        m_imageSize;
 178         const vk::VkFormat                      m_format;
 179         const tcu::TextureFormat        m_residencyFormat;
 180
 181         typedef de::SharedPtr< vk::Unique<vk::VkPipeline> >                     SharedVkPipeline;
 182         std::vector<SharedVkPipeline>                                                           pipelines;
 183
 184         typedef de::SharedPtr< vk::Unique<vk::VkImageView> >            SharedVkImageView;
 185         std::vector<SharedVkImageView>                                                          imageSparseViews;
 186         std::vector<SharedVkImageView>                                                          imageTexelsViews;
 187         std::vector<SharedVkImageView>                                                          imageResidencyViews;
 188
 189         vk::Move<vk::VkDescriptorPool>                                                          descriptorPool;
 190
 191         typedef de::SharedPtr< vk::Unique<vk::VkDescriptorSet> >        SharedVkDescriptorSet;
 192         std::vector<SharedVkDescriptorSet>                                                      descriptorSets;
 193 };
 194
 195 } // sparse
 196 } // vkt
 197
 198 #endif // _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP