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: SparseShaderIntrinsicsCaseBase(tcu::TestContext & testCtx,const std::string & name,const SpirVFunction function,const ImageType imageType,const tcu::UVec3 & imageSize,const vk::VkFormat format)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 checkSupport(Context & context) const122 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: SparseShaderIntrinsicsInstanceBase(Context & context,const SpirVFunction function,const ImageType imageType,const tcu::UVec3 & imageSize,const vk::VkFormat format)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 virtual void checkSupport (vk::VkImageCreateInfo imageSparseInfo) const; 175 176 protected: 177 const SpirVFunction m_function; 178 const ImageType m_imageType; 179 const tcu::UVec3 m_imageSize; 180 const vk::VkFormat m_format; 181 const tcu::TextureFormat m_residencyFormat; 182 183 typedef de::SharedPtr< vk::Unique<vk::VkPipeline> > SharedVkPipeline; 184 std::vector<SharedVkPipeline> pipelines; 185 vk::Move<vk::VkPipelineLayout> pipelineLayout; 186 187 typedef de::SharedPtr< vk::Unique<vk::VkImageView> > SharedVkImageView; 188 std::vector<SharedVkImageView> imageSparseViews; 189 std::vector<SharedVkImageView> imageTexelsViews; 190 std::vector<SharedVkImageView> imageResidencyViews; 191 192 vk::Move<vk::VkDescriptorPool> descriptorPool; 193 194 typedef de::SharedPtr< vk::Unique<vk::VkDescriptorSet> > SharedVkDescriptorSet; 195 std::vector<SharedVkDescriptorSet> descriptorSets; 196 }; 197 198 } // sparse 199 } // vkt 200 201 #endif // _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP 202