--- /dev/null
+/*------------------------------------------------------------------------
+ * 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
projects / platform / upstream / VK-GL-CTS.git / commitdiff