external/vulkancts/modules/vulkan/memory_model/vktMemoryModelPadding.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * 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
	/*------------------------------------------------------------------------
	* 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