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,const std::string & operand)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 checkSupport(Context & context) const124 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: SparseShaderIntrinsicsInstanceBase(Context & context,const SpirVFunction function,const ImageType imageType,const tcu::UVec3 & imageSize,const vk::VkFormat format)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 209