| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2019 The Khronos Group Inc. |
| * Copyright (c) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Cube image with misaligned baseArrayLayer tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktImageMisalignedCubeTests.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vktImageTestsUtil.hpp" |
| #include "vktImageTexture.hpp" |
| |
| #include "vkDefs.hpp" |
| #include "vkRef.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vkPlatform.hpp" |
| #include "vkPrograms.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkObjUtil.hpp" |
| #include "vkTypeUtil.hpp" |
| |
| #include "deUniquePtr.hpp" |
| #include "deStringUtil.hpp" |
| #include "deMath.h" |
| |
| #include <string> |
| |
| using namespace vk; |
| |
| namespace vkt |
| { |
| namespace image |
| { |
| namespace |
| { |
| |
| inline VkImageCreateInfo makeImageCreateInfo (const tcu::IVec3& size, const VkFormat format) |
| { |
| const VkImageUsageFlags usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| const VkImageCreateInfo imageParams = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, // VkImageCreateFlags flags; |
| VK_IMAGE_TYPE_2D, // VkImageType imageType; |
| format, // VkFormat format; |
| makeExtent3D(size.x(), size.y(), 1u), // VkExtent3D extent; |
| 1u, // deUint32 mipLevels; |
| (deUint32)size.z(), // deUint32 arrayLayers; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; |
| VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; |
| usage, // VkImageUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 0u, // deUint32 queueFamilyIndexCount; |
| DE_NULL, // const deUint32* pQueueFamilyIndices; |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; |
| }; |
| |
| return imageParams; |
| } |
| |
| void fillBuffer (const DeviceInterface& vk, const VkDevice device, const Allocation& alloc, const VkDeviceSize offset, const VkDeviceSize size, const VkFormat format, const tcu::Vec4& color) |
| { |
| const tcu::TextureFormat textureFormat = mapVkFormat(format); |
| const deUint32 colorPixelSize = static_cast<deUint32>(tcu::getPixelSize(textureFormat)); |
| tcu::TextureLevel colorPixelBuffer (textureFormat, 1, 1); |
| tcu::PixelBufferAccess colorPixel (colorPixelBuffer); |
| |
| colorPixel.setPixel(color, 0, 0); |
| |
| const deUint8* src = static_cast<deUint8*>(colorPixel.getDataPtr()); |
| deUint8* dstBase = static_cast<deUint8*>(alloc.getHostPtr()); |
| deUint8* dst = &dstBase[offset]; |
| |
| for (deUint32 pixelPos = 0; pixelPos < size; pixelPos += colorPixelSize) |
| deMemcpy(&dst[pixelPos], src, colorPixelSize); |
| |
| flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset() + offset, size); |
| } |
| |
| VkBufferImageCopy makeBufferImageCopy (const vk::VkDeviceSize& bufferOffset, |
| const vk::VkImageSubresourceLayers& imageSubresource, |
| const vk::VkOffset3D& imageOffset, |
| const vk::VkExtent3D& imageExtent) |
| { |
| const VkBufferImageCopy copyParams = |
| { |
| bufferOffset, // VkDeviceSize bufferOffset; |
| 0u, // deUint32 bufferRowLength; |
| 0u, // deUint32 bufferImageHeight; |
| imageSubresource, // VkImageSubresourceLayers imageSubresource; |
| imageOffset, // VkOffset3D imageOffset; |
| imageExtent, // VkExtent3D imageExtent; |
| }; |
| return copyParams; |
| } |
| |
| //! Interpret the memory as IVec4 |
| inline tcu::Vec4 readVec4 (const void* const data, const deUint32 ndx) |
| { |
| const float* const p = reinterpret_cast<const float*>(data); |
| const deUint32 ofs = 4 * ndx; |
| |
| return tcu::Vec4(p[ofs+0], p[ofs+1], p[ofs+2], p[ofs+3]); |
| } |
| |
| class MisalignedCubeTestInstance : public TestInstance |
| { |
| public: |
| MisalignedCubeTestInstance (Context& context, |
| const tcu::IVec3& size, |
| const VkFormat format); |
| tcu::TestStatus iterate (void); |
| |
| private: |
| const tcu::IVec3& m_size; |
| const VkFormat m_format; |
| }; |
| |
| MisalignedCubeTestInstance::MisalignedCubeTestInstance (Context& context, const tcu::IVec3& size, const VkFormat format) |
| : TestInstance (context) |
| , m_size (size) |
| , m_format (format) |
| { |
| } |
| |
| tcu::TestStatus MisalignedCubeTestInstance::iterate (void) |
| { |
| DE_ASSERT(de::inRange(m_size.z(), 6, 16)); |
| DE_ASSERT(m_format == VK_FORMAT_R8G8B8A8_UNORM); |
| |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| const VkQueue queue = m_context.getUniversalQueue(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| const deUint32 numLayers = m_size.z(); |
| const deUint32 cube0LayerStart = 0; |
| const deUint32 cube1LayerStart = numLayers - 6u; |
| const VkDeviceSize resultBufferSizeBytes = 2 * 6 * 4 * sizeof(float); // vec4[6] in shader |
| const VkExtent3D imageExtent = makeExtent3D(m_size.x(), m_size.y(), 1u); |
| const deUint32 pixelSize = static_cast<deUint32>(tcu::getPixelSize(mapVkFormat(m_format))); |
| const deUint32 layerSize = imageExtent.width * imageExtent.height * pixelSize; |
| const float eps = 1.0f / float(2 * 256); |
| |
| const VkBufferCreateInfo resultBufferCreateInfo = makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); |
| de::MovePtr<Buffer> resultBuffer = de::MovePtr<Buffer>(new Buffer(vk, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible)); |
| const Allocation& resultBufferAlloc = resultBuffer->getAllocation(); |
| const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_size, m_format); |
| de::MovePtr<Image> image = de::MovePtr<Image>(new Image(vk, device, allocator, imageCreateInfo, MemoryRequirement::Any)); |
| const VkImageSubresourceRange imageSubresourceRange0 = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, cube0LayerStart, 6u); |
| Move<VkImageView> imageView0 = makeImageView(vk, device, image->get(), VK_IMAGE_VIEW_TYPE_CUBE, m_format, imageSubresourceRange0); |
| const VkImageSubresourceRange imageSubresourceRange1 = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, cube1LayerStart, 6u); |
| Move<VkImageView> imageView1 = makeImageView(vk, device, image->get(), VK_IMAGE_VIEW_TYPE_CUBE, m_format, imageSubresourceRange1); |
| |
| Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder() |
| .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) |
| .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) |
| .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT) |
| .build(vk, device); |
| Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder() |
| .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) |
| .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) |
| .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) |
| .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); |
| Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout); |
| const VkDescriptorImageInfo descriptorImageInfo0 = makeDescriptorImageInfo(DE_NULL, *imageView0, VK_IMAGE_LAYOUT_GENERAL); |
| const VkDescriptorImageInfo descriptorImageInfo1 = makeDescriptorImageInfo(DE_NULL, *imageView1, VK_IMAGE_LAYOUT_GENERAL); |
| const VkDescriptorBufferInfo descriptorBufferInfo = makeDescriptorBufferInfo(resultBuffer->get(), 0ull, resultBufferSizeBytes); |
| |
| const Move<VkShaderModule> shaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0); |
| const Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vk, device, *descriptorSetLayout); |
| const Move<VkPipeline> pipeline = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule); |
| const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex); |
| const Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); |
| |
| const VkDeviceSize clearBufferSize = layerSize * numLayers; |
| const Move<VkBuffer> clearBuffer = makeBuffer(vk, device, clearBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT); |
| const de::MovePtr<Allocation> clearBufferAlloc = bindBuffer(vk, device, allocator, *clearBuffer, MemoryRequirement::HostVisible); |
| const VkImageSubresourceRange clearSubresRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, numLayers); |
| const VkImageMemoryBarrier clearBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, |
| VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, |
| image->get(), clearSubresRange); |
| const VkImageMemoryBarrier preShaderImageBarrier = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, |
| VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, |
| image->get(), clearSubresRange); |
| const VkBufferMemoryBarrier postShaderBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, |
| resultBuffer->get(), 0ull, VK_WHOLE_SIZE); |
| bool result = true; |
| |
| DescriptorSetUpdateBuilder() |
| .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo0) |
| .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo1) |
| .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo) |
| .update(vk, device); |
| |
| beginCommandBuffer(vk, *cmdBuffer); |
| |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline); |
| vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL); |
| |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &clearBarrier); |
| |
| // Clear layers with predefined values |
| for (deUint32 layerNdx = 0; layerNdx < numLayers; ++layerNdx) |
| { |
| const float componentValue = float(16 * layerNdx) / 255.0f; |
| const tcu::Vec4 clearColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f); |
| const VkDeviceSize bufferOffset = layerNdx * layerSize; |
| const VkImageSubresourceLayers imageSubresource = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, layerNdx, 1u); |
| const VkBufferImageCopy bufferImageCopyRegion = makeBufferImageCopy(bufferOffset, imageSubresource, makeOffset3D(0u, 0u, 0u), imageExtent); |
| |
| fillBuffer(vk, device, *clearBufferAlloc, bufferOffset, layerSize, m_format, clearColor); |
| |
| vk.cmdCopyBufferToImage(*cmdBuffer, *clearBuffer, image->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &bufferImageCopyRegion); |
| } |
| |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &preShaderImageBarrier); |
| |
| vk.cmdDispatch(*cmdBuffer, 1, 1, 1); |
| |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, DE_NULL, 1, &postShaderBarrier, 0, DE_NULL); |
| |
| endCommandBuffer(vk, *cmdBuffer); |
| |
| submitCommandsAndWait(vk, device, queue, *cmdBuffer); |
| |
| invalidateAlloc(vk, device, resultBufferAlloc); |
| |
| // Check cube 0 |
| for (deUint32 layerNdx = 0; layerNdx < 6; ++layerNdx) |
| { |
| const deUint32 layerUsed = cube0LayerStart + layerNdx; |
| const float componentValue = float(16 * layerUsed) / 255.0f; |
| const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f); |
| const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx); |
| const tcu::Vec4 delta = expectedColor - resultColor; |
| |
| if (deFloatAbs(delta.x()) > eps || deFloatAbs(delta.y()) > eps || deFloatAbs(delta.z()) > eps || deFloatAbs(delta.w()) > eps) |
| result = false; |
| } |
| |
| // Check cube 1 |
| for (deUint32 layerNdx = 0; layerNdx < 6; ++layerNdx) |
| { |
| const deUint32 layerUsed = cube1LayerStart + layerNdx; |
| const float componentValue = float(16 * layerUsed) / 255.0f; |
| const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f); |
| const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx + 6u); |
| const tcu::Vec4 delta = expectedColor - resultColor; |
| |
| if (deFloatAbs(delta.x()) > eps || deFloatAbs(delta.y()) > eps || deFloatAbs(delta.z()) > eps || deFloatAbs(delta.w()) > eps) |
| result = false; |
| } |
| |
| if (result) |
| return tcu::TestStatus::pass("pass"); |
| else |
| return tcu::TestStatus::fail("fail"); |
| } |
| |
| class MisalignedCubeTest : public TestCase |
| { |
| public: |
| MisalignedCubeTest (tcu::TestContext& testCtx, |
| const std::string& name, |
| const std::string& description, |
| const tcu::IVec3& size, |
| const VkFormat format); |
| |
| void initPrograms (SourceCollections& programCollection) const; |
| TestInstance* createInstance (Context& context) const; |
| |
| private: |
| const tcu::IVec3 m_size; |
| const VkFormat m_format; |
| }; |
| |
| MisalignedCubeTest::MisalignedCubeTest (tcu::TestContext& testCtx, |
| const std::string& name, |
| const std::string& description, |
| const tcu::IVec3& size, |
| const VkFormat format) |
| : TestCase (testCtx, name, description) |
| , m_size (size) |
| , m_format (format) |
| { |
| } |
| |
| void MisalignedCubeTest::initPrograms (SourceCollections& programCollection) const |
| { |
| const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_format)); |
| |
| std::ostringstream src; |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" |
| << "\n" |
| << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" |
| << "layout (binding = 0, " << formatQualifierStr << ") " << "readonly uniform highp imageCube u_cubeImage0;\n" |
| << "layout (binding = 1, " << formatQualifierStr << ") " << "readonly uniform highp imageCube u_cubeImage1;\n" |
| << "layout (binding = 2) writeonly buffer Output\n" |
| << "{\n" |
| << " vec4 cube0_color0;\n" |
| << " vec4 cube0_color1;\n" |
| << " vec4 cube0_color2;\n" |
| << " vec4 cube0_color3;\n" |
| << " vec4 cube0_color4;\n" |
| << " vec4 cube0_color5;\n" |
| << " vec4 cube1_color0;\n" |
| << " vec4 cube1_color1;\n" |
| << " vec4 cube1_color2;\n" |
| << " vec4 cube1_color3;\n" |
| << " vec4 cube1_color4;\n" |
| << " vec4 cube1_color5;\n" |
| << "} sb_out;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " sb_out.cube0_color0 = imageLoad(u_cubeImage0, ivec3(1, 1, 0));\n" |
| << " sb_out.cube0_color1 = imageLoad(u_cubeImage0, ivec3(1, 1, 1));\n" |
| << " sb_out.cube0_color2 = imageLoad(u_cubeImage0, ivec3(1, 1, 2));\n" |
| << " sb_out.cube0_color3 = imageLoad(u_cubeImage0, ivec3(1, 1, 3));\n" |
| << " sb_out.cube0_color4 = imageLoad(u_cubeImage0, ivec3(1, 1, 4));\n" |
| << " sb_out.cube0_color5 = imageLoad(u_cubeImage0, ivec3(1, 1, 5));\n" |
| << " sb_out.cube1_color0 = imageLoad(u_cubeImage1, ivec3(1, 1, 0));\n" |
| << " sb_out.cube1_color1 = imageLoad(u_cubeImage1, ivec3(1, 1, 1));\n" |
| << " sb_out.cube1_color2 = imageLoad(u_cubeImage1, ivec3(1, 1, 2));\n" |
| << " sb_out.cube1_color3 = imageLoad(u_cubeImage1, ivec3(1, 1, 3));\n" |
| << " sb_out.cube1_color4 = imageLoad(u_cubeImage1, ivec3(1, 1, 4));\n" |
| << " sb_out.cube1_color5 = imageLoad(u_cubeImage1, ivec3(1, 1, 5));\n" |
| << "}\n"; |
| |
| programCollection.glslSources.add("comp") << glu::ComputeSource(src.str()); |
| } |
| |
| TestInstance* MisalignedCubeTest::createInstance (Context& context) const |
| { |
| return new MisalignedCubeTestInstance(context, m_size, m_format); |
| } |
| |
| //! Base sizes used to generate actual imager sizes in the test. |
| static const tcu::IVec3 s_baseImageSizes[] = |
| { |
| tcu::IVec3(16, 16, 7), |
| tcu::IVec3(16, 16, 8), |
| tcu::IVec3(16, 16, 9), |
| tcu::IVec3(16, 16, 10), |
| tcu::IVec3(16, 16, 11), |
| }; |
| |
| } // anonymous ns |
| |
| tcu::TestCaseGroup* createMisalignedCubeTests (tcu::TestContext& testCtx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "misaligned_cube", "Cube image with misaligned baseArrayLayer test cases")); |
| |
| const VkFormat format = VK_FORMAT_R8G8B8A8_UNORM; |
| |
| for (int imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(s_baseImageSizes); ++imageSizeNdx) |
| { |
| const tcu::IVec3 size = s_baseImageSizes[imageSizeNdx]; |
| |
| testGroup->addChild(new MisalignedCubeTest(testCtx, de::toString(size.z()), "", size, format)); |
| } |
| |
| return testGroup.release(); |
| } |
| |
| } // image |
| } // vkt |