1 #ifndef _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
2 #define _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
3 /*------------------------------------------------------------------------
4 * Vulkan Conformance Tests
5 * ------------------------
7 * Copyright (c) 2016 The Khronos Group Inc.
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 * \file vktSparseResourcesShaderIntrinsicsBase.hpp
23 * \brief Sparse Resources Shader Intrinsics Base Classes
24 *//*--------------------------------------------------------------------*/
26 #include "tcuDefs.hpp"
27 #include "vktTestCase.hpp"
28 #include "vktTestCaseUtil.hpp"
29 #include "vktSparseResourcesBase.hpp"
30 #include "vktSparseResourcesTestsUtil.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"
45 #include "deStringUtil.hpp"
46 #include "deUniquePtr.hpp"
47 #include "deSharedPtr.hpp"
61 MEMORY_BLOCK_BOUND = 0u,
62 MEMORY_BLOCK_NOT_BOUND = 1u,
63 MEMORY_BLOCK_TYPE_COUNT = 2u
68 MEMORY_BLOCK_BOUND_VALUE = 1u,
69 MEMORY_BLOCK_NOT_BOUND_VALUE = 2u
74 BINDING_IMAGE_SPARSE = 0u,
75 BINDING_IMAGE_TEXELS = 1u,
76 BINDING_IMAGE_RESIDENCY = 2u
83 SPARSE_SAMPLE_EXPLICIT_LOD,
84 SPARSE_SAMPLE_IMPLICIT_LOD,
86 SPARSE_SPIRV_FUNCTION_TYPE_LAST
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);
105 class SparseShaderIntrinsicsCaseBase : public TestCase
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)
122 virtual void checkSupport (Context& context) const
124 const vk::InstanceInterface& instance = context.getInstanceInterface();
125 const vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
127 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY);
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");
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");
139 const SpirVFunction m_function;
140 const ImageType m_imageType;
141 const tcu::UVec3 m_imageSize;
142 const vk::VkFormat m_format;
145 class SparseShaderIntrinsicsInstanceBase : public SparseResourcesBaseInstance
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)
158 , m_residencyFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)
162 tcu::TestStatus iterate (void);
164 virtual vk::VkImageUsageFlags imageSparseUsageFlags (void) const = 0;
165 virtual vk::VkImageUsageFlags imageOutputUsageFlags (void) const = 0;
167 virtual vk::VkQueueFlags getQueueFlags (void) const = 0;
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;
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;
183 typedef de::SharedPtr< vk::Unique<vk::VkPipeline> > SharedVkPipeline;
184 std::vector<SharedVkPipeline> pipelines;
185 vk::Move<vk::VkPipelineLayout> pipelineLayout;
187 typedef de::SharedPtr< vk::Unique<vk::VkImageView> > SharedVkImageView;
188 std::vector<SharedVkImageView> imageSparseViews;
189 std::vector<SharedVkImageView> imageTexelsViews;
190 std::vector<SharedVkImageView> imageResidencyViews;
192 vk::Move<vk::VkDescriptorPool> descriptorPool;
194 typedef de::SharedPtr< vk::Unique<vk::VkDescriptorSet> > SharedVkDescriptorSet;
195 std::vector<SharedVkDescriptorSet> descriptorSets;
201 #endif // _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP