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                                                                                          const std::string&                     operand)
 115                 : TestCase(testCtx, name, "")
 116                 , m_function(function)
 117                 , m_imageType(imageType)
 118                 , m_imageSize(imageSize)
 119                 , m_format(format)
 120                 , m_operand(operand)
 121         {
 122         }
 123
 124         virtual void    checkSupport                                    (Context&       context) const
 125         {
 126                 const vk::InstanceInterface&    instance                = context.getInstanceInterface();
 127                 const vk::VkPhysicalDevice              physicalDevice  = context.getPhysicalDevice();
 128
 129                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY);
 130
 131                 // Check if image size does not exceed device limits
 132                 if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
 133                         TCU_THROW(NotSupportedError, "Image size not supported for device");
 134
 135                 // Check if device supports sparse operations for image type
 136                 if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
 137                         TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
 138
 139                 if ((m_operand.find("Nontemporal") != std::string::npos) &&
 140                         (context.getUsedApiVersion() < VK_API_VERSION_1_3))
 141                         TCU_THROW(NotSupportedError, "Vulkan 1.3 or higher is required for this test to run");
 142         }
 143
 144 protected:
 145         const SpirVFunction                     m_function;
 146         const ImageType                         m_imageType;
 147         const tcu::UVec3                        m_imageSize;
 148         const vk::VkFormat                      m_format;
 149         const std::string                       m_operand;
 150 };
 151
 152 class SparseShaderIntrinsicsInstanceBase : public SparseResourcesBaseInstance
 153 {
 154 public:
 155         SparseShaderIntrinsicsInstanceBase              (Context&                                       context,
 156                                                                                          const SpirVFunction            function,
 157                                                                                          const ImageType                        imageType,
 158                                                                                          const tcu::UVec3&                      imageSize,
 159                                                                                          const vk::VkFormat                     format)
 160                 : SparseResourcesBaseInstance(context)
 161                 , m_function(function)
 162                 , m_imageType(imageType)
 163                 , m_imageSize(imageSize)
 164                 , m_format(format)
 165                 , m_residencyFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)
 166         {
 167         }
 168
 169         tcu::TestStatus                                         iterate                                 (void);
 170
 171         virtual vk::VkImageUsageFlags           imageSparseUsageFlags   (void) const = 0;
 172         virtual vk::VkImageUsageFlags           imageOutputUsageFlags   (void) const = 0;
 173
 174         virtual vk::VkQueueFlags                        getQueueFlags                   (void) const = 0;
 175
 176         virtual void                                            recordCommands                  (const vk::VkCommandBuffer              commandBuffer,
 177                                                                                                                                  const vk::VkImageCreateInfo&   imageSparseInfo,
 178                                                                                                                                  const vk::VkImage                              imageSparse,
 179                                                                                                                                  const vk::VkImage                              imageTexels,
 180                                                                                                                                  const vk::VkImage                              imageResidency) = 0;
 181         virtual void                    checkSupport                    (vk::VkImageCreateInfo imageSparseInfo) const;
 182
 183 protected:
 184         const SpirVFunction                     m_function;
 185         const ImageType                         m_imageType;
 186         const tcu::UVec3                        m_imageSize;
 187         const vk::VkFormat                      m_format;
 188         const tcu::TextureFormat        m_residencyFormat;
 189
 190         typedef de::SharedPtr< vk::Unique<vk::VkPipeline> >                     SharedVkPipeline;
 191         std::vector<SharedVkPipeline>                                                           pipelines;
 192         vk::Move<vk::VkPipelineLayout>                                                          pipelineLayout;
 193
 194         typedef de::SharedPtr< vk::Unique<vk::VkImageView> >            SharedVkImageView;
 195         std::vector<SharedVkImageView>                                                          imageSparseViews;
 196         std::vector<SharedVkImageView>                                                          imageTexelsViews;
 197         std::vector<SharedVkImageView>                                                          imageResidencyViews;
 198
 199         vk::Move<vk::VkDescriptorPool>                                                          descriptorPool;
 200
 201         typedef de::SharedPtr< vk::Unique<vk::VkDescriptorSet> >        SharedVkDescriptorSet;
 202         std::vector<SharedVkDescriptorSet>                                                      descriptorSets;
 203 };
 204
 205 } // sparse
 206 } // vkt
 207
 208 #endif // _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP