--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation.
+ *
+ * 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 Vulkan Memory Model padding access tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktMemoryModelPadding.hpp"
+#include "vktTestCase.hpp"
+
+#include "vkBufferWithMemory.hpp"
+#include "vkBarrierUtil.hpp"
+#include "vkObjUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
+
+#include "deMemory.h"
+
+namespace vkt
+{
+namespace MemoryModel
+{
+
+namespace
+{
+// The structures below match the shader declarations but have explicit padding members at the end so we can check their contents
+// easily after running the shader. Using the std140 layout means structures are aligned to 16 bytes.
+
+// Structure with a 12-byte padding at the end.
+struct Pad12
+{
+ deInt32 a;
+ deUint8 padding[12];
+};
+
+// Structure with an 8-byte padding at the end.
+struct Pad8
+{
+ deInt32 a, b;
+ deUint8 padding[8];
+};
+
+// Structure with a 4-byte padding at the end.
+struct Pad4
+{
+ deInt32 a, b, c;
+ deUint8 padding[4];
+};
+
+// Buffer structure for the input and output buffers.
+struct BufferStructure
+{
+ static constexpr deUint32 kArrayLength = 3u;
+
+ Pad12 subA[kArrayLength];
+ Pad8 subB[kArrayLength];
+ Pad4 subC[kArrayLength];
+
+ // Pre-fill substructures with the given data.
+ BufferStructure (deInt32 a, deInt32 b, deInt32 c, deUint8 paddingByte)
+ {
+ for (deUint32 i = 0; i < kArrayLength; ++i)
+ {
+ subA[i].a = a;
+ subB[i].a = a;
+ subC[i].a = a;
+ subB[i].b = b;
+ subC[i].b = b;
+ subC[i].c = c;
+ deMemset(subA[i].padding, static_cast<int>(paddingByte), sizeof(subA[i].padding));
+ deMemset(subB[i].padding, static_cast<int>(paddingByte), sizeof(subB[i].padding));
+ deMemset(subC[i].padding, static_cast<int>(paddingByte), sizeof(subC[i].padding));
+ }
+ }
+
+ // Pre-fill substructures with zeros.
+ BufferStructure (deUint8 paddingByte)
+ : BufferStructure (0, 0, 0, paddingByte)
+ {}
+
+ // Verify members and padding bytes.
+ bool checkValues (deInt32 a, deInt32 b, deInt32 c, deUint8 paddingByte) const
+ {
+ for (deUint32 i = 0; i < kArrayLength; ++i)
+ {
+ if (subA[i].a != a || subB[i].a != a || subC[i].a != a ||
+ subB[i].b != b || subC[i].b != b ||
+ subC[i].c != c)
+ return false;
+ }
+ return checkPaddingBytes(paddingByte);
+ }
+
+ // Verify padding bytes have a known value.
+ bool checkPaddingBytes (deUint8 value) const
+ {
+ for (deUint32 j = 0; j < kArrayLength; ++j)
+ {
+ for (int i = 0; i < DE_LENGTH_OF_ARRAY(subA[j].padding); ++i)
+ {
+ if (subA[j].padding[i] != value)
+ return false;
+ }
+ for (int i = 0; i < DE_LENGTH_OF_ARRAY(subB[j].padding); ++i)
+ {
+ if (subB[j].padding[i] != value)
+ return false;
+ }
+ for (int i = 0; i < DE_LENGTH_OF_ARRAY(subC[j].padding); ++i)
+ {
+ if (subC[j].padding[i] != value)
+ return false;
+ }
+ }
+ return true;
+ }
+};
+
+class PaddingTest : public vkt::TestCase
+{
+public:
+ PaddingTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description);
+ virtual ~PaddingTest (void) {}
+
+ virtual void initPrograms (vk::SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+ virtual void checkSupport (Context& context) const;
+
+ IterateResult iterate (void) { DE_ASSERT(false); return STOP; } // Deprecated in this module
+};
+
+class PaddingTestInstance : public vkt::TestInstance
+{
+public:
+ PaddingTestInstance (Context& context)
+ : vkt::TestInstance(context)
+ {}
+ virtual ~PaddingTestInstance (void) {}
+
+ virtual tcu::TestStatus iterate (void);
+};
+
+
+PaddingTest::PaddingTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description)
+ : vkt::TestCase(testCtx, name, description)
+{
+}
+
+TestInstance* PaddingTest::createInstance (Context& context) const
+{
+ return new PaddingTestInstance(context);
+}
+
+void PaddingTest::initPrograms (vk::SourceCollections& programCollection) const
+{
+ const std::string arrayLenghtStr = std::to_string(BufferStructure::kArrayLength);
+
+ std::ostringstream shaderSrc;
+ shaderSrc
+ << "#version 450\n"
+ << "#pragma use_vulkan_memory_model\n"
+ << "\n"
+ << "struct A {\n"
+ << " int a;\n"
+ << "};\n"
+ << "\n"
+ << "struct B {\n"
+ << " int a, b;\n"
+ << "};\n"
+ << "\n"
+ << "struct C {\n"
+ << " int a, b, c;\n"
+ << "};\n"
+ << "\n"
+ << "struct BufferStructure {\n"
+ << " A subA[" << arrayLenghtStr << "];\n"
+ << " B subB[" << arrayLenghtStr << "];\n"
+ << " C subC[" << arrayLenghtStr << "];\n"
+ << "};\n"
+ << "\n"
+ << "layout (set=0, binding=0, std140) uniform InputBlock\n"
+ << "{\n"
+ << " BufferStructure inBlock;\n"
+ << "};\n"
+ << "\n"
+ << "layout (set=0, binding=1, std140) buffer OutputBlock\n"
+ << "{\n"
+ << " BufferStructure outBlock;\n"
+ << "};\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << " const uint idx = gl_GlobalInvocationID.x;\n"
+ << " outBlock.subA[idx] = inBlock.subA[idx];\n"
+ << " outBlock.subB[idx] = inBlock.subB[idx];\n"
+ << " outBlock.subC[idx] = inBlock.subC[idx];\n"
+ << "}\n";
+
+ programCollection.glslSources.add("comp") << glu::ComputeSource(shaderSrc.str());
+}
+
+void PaddingTest::checkSupport (Context& context) const
+{
+ context.requireDeviceFunctionality("VK_KHR_vulkan_memory_model");
+ if (!context.getVulkanMemoryModelFeatures().vulkanMemoryModel)
+ {
+ TCU_THROW(NotSupportedError, "Vulkan memory model not supported");
+ }
+}
+
+tcu::TestStatus PaddingTestInstance::iterate (void)
+{
+ const auto& vkd = m_context.getDeviceInterface();
+ const auto device = m_context.getDevice();
+ auto& allocator = m_context.getDefaultAllocator();
+ const auto queue = m_context.getUniversalQueue();
+ const auto queueIndex = m_context.getUniversalQueueFamilyIndex();
+
+ constexpr vk::VkDeviceSize kBufferSize = static_cast<vk::VkDeviceSize>(sizeof(BufferStructure));
+ constexpr deInt32 kA = 1;
+ constexpr deInt32 kB = 2;
+ constexpr deInt32 kC = 3;
+ constexpr deUint8 kInputPaddingByte = 0xFEu;
+ constexpr deUint8 kOutputPaddingByte = 0x7Fu;
+
+ // Create input and output buffers.
+ auto inputBufferInfo = vk::makeBufferCreateInfo(kBufferSize, vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
+ auto outputBufferInfo = vk::makeBufferCreateInfo(kBufferSize, vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
+
+ vk::BufferWithMemory inputBuffer {vkd, device, allocator, inputBufferInfo, vk::MemoryRequirement::HostVisible};
+ vk::BufferWithMemory outputBuffer {vkd, device, allocator, outputBufferInfo, vk::MemoryRequirement::HostVisible};
+
+ // Fill buffers with initial contents.
+ BufferStructure inputValues {kA, kB, kC, kInputPaddingByte};
+ BufferStructure outputInit {kOutputPaddingByte};
+
+ auto& inputAlloc = inputBuffer.getAllocation();
+ auto& outputAlloc = outputBuffer.getAllocation();
+
+ void* inputBufferPtr = static_cast<deUint8*>(inputAlloc.getHostPtr()) + inputAlloc.getOffset();
+ void* outputBufferPtr = static_cast<deUint8*>(outputAlloc.getHostPtr()) + outputAlloc.getOffset();
+
+ deMemcpy(inputBufferPtr, &inputValues, sizeof(inputValues));
+ deMemcpy(outputBufferPtr, &outputInit, sizeof(outputInit));
+
+ vk::flushAlloc(vkd, device, inputAlloc);
+ vk::flushAlloc(vkd, device, outputAlloc);
+
+ // Descriptor set layout.
+ vk::DescriptorSetLayoutBuilder layoutBuilder;
+ layoutBuilder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
+ layoutBuilder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT);
+ auto descriptorSetLayout = layoutBuilder.build(vkd, device);
+
+ // Descriptor pool.
+ vk::DescriptorPoolBuilder poolBuilder;
+ poolBuilder.addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+ poolBuilder.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
+ auto descriptorPool = poolBuilder.build(vkd, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+
+ // Descriptor set.
+ const auto descriptorSet = vk::makeDescriptorSet(vkd, device, descriptorPool.get(), descriptorSetLayout.get());
+
+ // Update descriptor set using the buffers.
+ const auto inputBufferDescriptorInfo = vk::makeDescriptorBufferInfo(inputBuffer.get(), 0ull, VK_WHOLE_SIZE);
+ const auto outputBufferDescriptorInfo = vk::makeDescriptorBufferInfo(outputBuffer.get(), 0ull, VK_WHOLE_SIZE);
+
+ vk::DescriptorSetUpdateBuilder updateBuilder;
+ updateBuilder.writeSingle(descriptorSet.get(), vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &inputBufferDescriptorInfo);
+ updateBuilder.writeSingle(descriptorSet.get(), vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputBufferDescriptorInfo);
+ updateBuilder.update(vkd, device);
+
+ // Create compute pipeline.
+ auto shaderModule = vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("comp"), 0u);
+ auto pipelineLayout = vk::makePipelineLayout(vkd, device, descriptorSetLayout.get());
+
+ const vk::VkComputePipelineCreateInfo pipelineCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+ nullptr,
+ 0u, // flags
+ { // compute shader
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ nullptr, // const void* pNext;
+ 0u, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
+ shaderModule.get(), // VkShaderModule module;
+ "main", // const char* pName;
+ nullptr, // const VkSpecializationInfo* pSpecializationInfo;
+ },
+ pipelineLayout.get(), // layout
+ DE_NULL, // basePipelineHandle
+ 0, // basePipelineIndex
+ };
+ auto pipeline = vk::createComputePipeline(vkd, device, DE_NULL, &pipelineCreateInfo);
+
+ // Synchronization barriers.
+ auto inputBufferHostToDevBarrier = vk::makeBufferMemoryBarrier(vk::VK_ACCESS_HOST_WRITE_BIT, vk::VK_ACCESS_SHADER_READ_BIT, inputBuffer.get(), 0ull, VK_WHOLE_SIZE);
+ auto outputBufferHostToDevBarrier = vk::makeBufferMemoryBarrier(vk::VK_ACCESS_HOST_WRITE_BIT, vk::VK_ACCESS_SHADER_WRITE_BIT, outputBuffer.get(), 0ull, VK_WHOLE_SIZE);
+ auto outputBufferDevToHostBarrier = vk::makeBufferMemoryBarrier(vk::VK_ACCESS_SHADER_WRITE_BIT, vk::VK_ACCESS_HOST_READ_BIT, outputBuffer.get(), 0ull, VK_WHOLE_SIZE);
+
+ // Command buffer.
+ auto cmdPool = vk::makeCommandPool(vkd, device, queueIndex);
+ auto cmdBufferPtr = vk::allocateCommandBuffer(vkd, device, cmdPool.get(), vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ auto cmdBuffer = cmdBufferPtr.get();
+
+ // Record and submit commands.
+ vk::beginCommandBuffer(vkd, cmdBuffer);
+ vkd.cmdBindPipeline(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, pipeline.get());
+ vkd.cmdBindDescriptorSets(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout.get(), 0, 1u, &descriptorSet.get(), 0u, nullptr);
+ vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, nullptr, 1u, &inputBufferHostToDevBarrier, 0u, nullptr);
+ vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, nullptr, 1u, &outputBufferHostToDevBarrier, 0u, nullptr);
+ vkd.cmdDispatch(cmdBuffer, BufferStructure::kArrayLength, 1u, 1u);
+ vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, nullptr, 1u, &outputBufferDevToHostBarrier, 0u, nullptr);
+ vk::endCommandBuffer(vkd, cmdBuffer);
+ vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
+
+ // Verify output buffer contents.
+ vk::invalidateAlloc(vkd, device, outputAlloc);
+ BufferStructure* outputData = reinterpret_cast<BufferStructure*>(outputBufferPtr);
+ return (outputData->checkValues(kA, kB, kC, kOutputPaddingByte) ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Unexpected values in output data"));
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createPaddingTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> paddingGroup(new tcu::TestCaseGroup(testCtx, "padding", "Padding bytes tests"));
+ paddingGroup->addChild(new PaddingTest(testCtx, "test", "Check padding bytes at the end of structures are not touched on copy"));
+
+ return paddingGroup.release();
+}
+
+} // MemoryModel
+} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff