diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index 985c3dc..b70982c 100644
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
@@ -166448,6 +166448,10 @@
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_instance_array
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_instance_array_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_instance_array
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_instance_array_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140_instance_array
@@ -166456,6 +166460,10 @@
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_instance_array
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_instance_array_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_instance_array
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_instance_array_comp_access
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140_comp_access
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140_instance_array
@@ -166847,6 +166855,106 @@
 dEQP-VK.ssbo.layout.random.all_shared_buffer.47
 dEQP-VK.ssbo.layout.random.all_shared_buffer.48
 dEQP-VK.ssbo.layout.random.all_shared_buffer.49
+dEQP-VK.ssbo.layout.random.relaxed.0
+dEQP-VK.ssbo.layout.random.relaxed.1
+dEQP-VK.ssbo.layout.random.relaxed.2
+dEQP-VK.ssbo.layout.random.relaxed.3
+dEQP-VK.ssbo.layout.random.relaxed.4
+dEQP-VK.ssbo.layout.random.relaxed.5
+dEQP-VK.ssbo.layout.random.relaxed.6
+dEQP-VK.ssbo.layout.random.relaxed.7
+dEQP-VK.ssbo.layout.random.relaxed.8
+dEQP-VK.ssbo.layout.random.relaxed.9
+dEQP-VK.ssbo.layout.random.relaxed.10
+dEQP-VK.ssbo.layout.random.relaxed.11
+dEQP-VK.ssbo.layout.random.relaxed.12
+dEQP-VK.ssbo.layout.random.relaxed.13
+dEQP-VK.ssbo.layout.random.relaxed.14
+dEQP-VK.ssbo.layout.random.relaxed.15
+dEQP-VK.ssbo.layout.random.relaxed.16
+dEQP-VK.ssbo.layout.random.relaxed.17
+dEQP-VK.ssbo.layout.random.relaxed.18
+dEQP-VK.ssbo.layout.random.relaxed.19
+dEQP-VK.ssbo.layout.random.relaxed.20
+dEQP-VK.ssbo.layout.random.relaxed.21
+dEQP-VK.ssbo.layout.random.relaxed.22
+dEQP-VK.ssbo.layout.random.relaxed.23
+dEQP-VK.ssbo.layout.random.relaxed.24
+dEQP-VK.ssbo.layout.random.relaxed.25
+dEQP-VK.ssbo.layout.random.relaxed.26
+dEQP-VK.ssbo.layout.random.relaxed.27
+dEQP-VK.ssbo.layout.random.relaxed.28
+dEQP-VK.ssbo.layout.random.relaxed.29
+dEQP-VK.ssbo.layout.random.relaxed.30
+dEQP-VK.ssbo.layout.random.relaxed.31
+dEQP-VK.ssbo.layout.random.relaxed.32
+dEQP-VK.ssbo.layout.random.relaxed.33
+dEQP-VK.ssbo.layout.random.relaxed.34
+dEQP-VK.ssbo.layout.random.relaxed.35
+dEQP-VK.ssbo.layout.random.relaxed.36
+dEQP-VK.ssbo.layout.random.relaxed.37
+dEQP-VK.ssbo.layout.random.relaxed.38
+dEQP-VK.ssbo.layout.random.relaxed.39
+dEQP-VK.ssbo.layout.random.relaxed.40
+dEQP-VK.ssbo.layout.random.relaxed.41
+dEQP-VK.ssbo.layout.random.relaxed.42
+dEQP-VK.ssbo.layout.random.relaxed.43
+dEQP-VK.ssbo.layout.random.relaxed.44
+dEQP-VK.ssbo.layout.random.relaxed.45
+dEQP-VK.ssbo.layout.random.relaxed.46
+dEQP-VK.ssbo.layout.random.relaxed.47
+dEQP-VK.ssbo.layout.random.relaxed.48
+dEQP-VK.ssbo.layout.random.relaxed.49
+dEQP-VK.ssbo.layout.random.relaxed.50
+dEQP-VK.ssbo.layout.random.relaxed.51
+dEQP-VK.ssbo.layout.random.relaxed.52
+dEQP-VK.ssbo.layout.random.relaxed.53
+dEQP-VK.ssbo.layout.random.relaxed.54
+dEQP-VK.ssbo.layout.random.relaxed.55
+dEQP-VK.ssbo.layout.random.relaxed.56
+dEQP-VK.ssbo.layout.random.relaxed.57
+dEQP-VK.ssbo.layout.random.relaxed.58
+dEQP-VK.ssbo.layout.random.relaxed.59
+dEQP-VK.ssbo.layout.random.relaxed.60
+dEQP-VK.ssbo.layout.random.relaxed.61
+dEQP-VK.ssbo.layout.random.relaxed.62
+dEQP-VK.ssbo.layout.random.relaxed.63
+dEQP-VK.ssbo.layout.random.relaxed.64
+dEQP-VK.ssbo.layout.random.relaxed.65
+dEQP-VK.ssbo.layout.random.relaxed.66
+dEQP-VK.ssbo.layout.random.relaxed.67
+dEQP-VK.ssbo.layout.random.relaxed.68
+dEQP-VK.ssbo.layout.random.relaxed.69
+dEQP-VK.ssbo.layout.random.relaxed.70
+dEQP-VK.ssbo.layout.random.relaxed.71
+dEQP-VK.ssbo.layout.random.relaxed.72
+dEQP-VK.ssbo.layout.random.relaxed.73
+dEQP-VK.ssbo.layout.random.relaxed.74
+dEQP-VK.ssbo.layout.random.relaxed.75
+dEQP-VK.ssbo.layout.random.relaxed.76
+dEQP-VK.ssbo.layout.random.relaxed.77
+dEQP-VK.ssbo.layout.random.relaxed.78
+dEQP-VK.ssbo.layout.random.relaxed.79
+dEQP-VK.ssbo.layout.random.relaxed.80
+dEQP-VK.ssbo.layout.random.relaxed.81
+dEQP-VK.ssbo.layout.random.relaxed.82
+dEQP-VK.ssbo.layout.random.relaxed.83
+dEQP-VK.ssbo.layout.random.relaxed.84
+dEQP-VK.ssbo.layout.random.relaxed.85
+dEQP-VK.ssbo.layout.random.relaxed.86
+dEQP-VK.ssbo.layout.random.relaxed.87
+dEQP-VK.ssbo.layout.random.relaxed.88
+dEQP-VK.ssbo.layout.random.relaxed.89
+dEQP-VK.ssbo.layout.random.relaxed.90
+dEQP-VK.ssbo.layout.random.relaxed.91
+dEQP-VK.ssbo.layout.random.relaxed.92
+dEQP-VK.ssbo.layout.random.relaxed.93
+dEQP-VK.ssbo.layout.random.relaxed.94
+dEQP-VK.ssbo.layout.random.relaxed.95
+dEQP-VK.ssbo.layout.random.relaxed.96
+dEQP-VK.ssbo.layout.random.relaxed.97
+dEQP-VK.ssbo.layout.random.relaxed.98
+dEQP-VK.ssbo.layout.random.relaxed.99
 dEQP-VK.query_pool.occlusion_query.basic_conservative
 dEQP-VK.query_pool.occlusion_query.basic_precise
 dEQP-VK.query_pool.occlusion_query.get_results_conservative_size_32_wait_queue_without_availability_draw_points
diff --git a/external/vulkancts/modules/vulkan/ssbo/CMakeLists.txt b/external/vulkancts/modules/vulkan/ssbo/CMakeLists.txt
index 357590f..02be27c 100644
--- a/external/vulkancts/modules/vulkan/ssbo/CMakeLists.txt
+++ b/external/vulkancts/modules/vulkan/ssbo/CMakeLists.txt
@@ -6,7 +6,7 @@
 	vktSSBOLayoutCase.cpp
 	vktSSBOLayoutCase.hpp
 	vktSSBOLayoutTests.cpp
-	vktSSBOLayoutTests.cpp
+	vktSSBOLayoutTests.hpp
 )
 
 set(DEQP_VK_SSBO_LIBS
diff --git a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
index fe8ea1e..c77b90f 100644
--- a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
+++ b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp
@@ -37,9 +37,6 @@
 #include "deMath.h"
 #include "deSharedPtr.hpp"
 
-#include <algorithm>
-#include <map>
-
 #include "vkBuilderUtil.hpp"
 #include "vkMemUtil.hpp"
 #include "vkPrograms.hpp"
@@ -56,7 +53,6 @@
 using tcu::TestLog;
 using std::string;
 using std::vector;
-using std::map;
 using glu::VarType;
 using glu::StructType;
 using glu::StructMember;
@@ -102,15 +98,16 @@
 	: m_name	(name)
 	, m_type	(type)
 	, m_flags	(flags)
+	, m_offset	(~0u)
 {
 }
 
 // BufferBlock implementation.
 
 BufferBlock::BufferBlock (const char* blockName)
-	: m_blockName	(blockName)
-	, m_arraySize	(-1)
-	, m_flags		(0)
+	: m_blockName		(blockName)
+	, m_arraySize		(-1)
+	, m_flags			(0)
 {
 	setArraySize(0);
 }
@@ -338,7 +335,6 @@
 			const int	vecSize		= isRowMajor ? glu::getDataTypeMatrixNumColumns(basicType)
 												 : glu::getDataTypeMatrixNumRows(basicType);
 			const int	vecAlign	= getDataTypeByteAlignment(glu::getDataTypeFloatVec(vecSize));
-
 			return vecAlign;
 		}
 		else
@@ -361,9 +357,43 @@
 	}
 }
 
+int computeRelaxedBlockBaseAlignment (const VarType& type, deUint32 layoutFlags)
+{
+	if (type.isBasicType())
+	{
+		glu::DataType basicType = type.getBasicType();
+
+		if (glu::isDataTypeVector(basicType))
+			return 4;
+
+		if (glu::isDataTypeMatrix(basicType))
+		{
+			const bool	isRowMajor	= !!(layoutFlags & LAYOUT_ROW_MAJOR);
+			const int	vecSize		= isRowMajor ? glu::getDataTypeMatrixNumColumns(basicType)
+												 : glu::getDataTypeMatrixNumRows(basicType);
+			const int	vecAlign	= getDataTypeByteAlignment(glu::getDataTypeFloatVec(vecSize));
+			return vecAlign;
+		}
+		else
+			return getDataTypeByteAlignment(basicType);
+	}
+	else if (type.isArrayType())
+		return computeStd430BaseAlignment(type.getElementType(), layoutFlags);
+	else
+	{
+		DE_ASSERT(type.isStructType());
+
+		int maxBaseAlignment = 0;
+		for (StructType::ConstIterator memberIter = type.getStructPtr()->begin(); memberIter != type.getStructPtr()->end(); memberIter++)
+			maxBaseAlignment = de::max(maxBaseAlignment, computeRelaxedBlockBaseAlignment(memberIter->getType(), layoutFlags));
+
+		return maxBaseAlignment;
+	}
+}
+
 inline deUint32 mergeLayoutFlags (deUint32 prevFlags, deUint32 newFlags)
 {
-	const deUint32	packingMask		= LAYOUT_STD430|LAYOUT_STD140;
+	const deUint32	packingMask		= LAYOUT_STD430|LAYOUT_STD140|LAYOUT_RELAXED;
 	const deUint32	matrixMask		= LAYOUT_ROW_MAJOR|LAYOUT_COLUMN_MAJOR;
 
 	deUint32 mergedFlags = 0;
@@ -374,6 +404,21 @@
 	return mergedFlags;
 }
 
+template <class T>
+bool isPow2(T powerOf2)
+{
+	if (powerOf2 <= 0)
+		return false;
+	return (powerOf2 & (powerOf2 - (T)1)) == (T)0;
+}
+
+template <class T>
+T roundToPow2(T number, int powerOf2)
+{
+	DE_ASSERT(isPow2(powerOf2));
+	return (number + (T)powerOf2 - (T)1) & (T)(~(powerOf2 - 1));
+}
+
 //! Appends all child elements to layout, returns value that should be appended to offset.
 int computeReferenceLayout (
 	BufferLayout&		layout,
@@ -385,9 +430,9 @@
 {
 	// Reference layout uses std430 rules by default. std140 rules are
 	// choosen only for blocks that have std140 layout.
-	const bool	isStd140			= (layoutFlags & LAYOUT_STD140) != 0;
-	const int	baseAlignment		= isStd140 ? computeStd140BaseAlignment(type, layoutFlags)
-											   : computeStd430BaseAlignment(type, layoutFlags);
+	const int	baseAlignment		= (layoutFlags & LAYOUT_STD140)  != 0 ? computeStd140BaseAlignment(type, layoutFlags)		:
+									  (layoutFlags & LAYOUT_RELAXED) != 0 ? computeRelaxedBlockBaseAlignment(type, layoutFlags)	:
+									  computeStd430BaseAlignment(type, layoutFlags);
 	int			curOffset			= deAlign32(baseOffset, baseAlignment);
 	const int	topLevelArraySize	= 1; // Default values
 	const int	topLevelArrayStride	= 0;
@@ -421,6 +466,9 @@
 		}
 		else
 		{
+			if (glu::isDataTypeVector(basicType) && (getDataTypeByteSize(basicType) <= 16 ? curOffset / 16 != (curOffset +  getDataTypeByteSize(basicType) - 1) / 16 : curOffset % 16 != 0) && (layoutFlags & LAYOUT_RELAXED))
+				curOffset = roundToPow2(curOffset, 16);
+
 			// Scalar or vector.
 			entry.offset = curOffset;
 
@@ -513,8 +561,9 @@
 		const string	prefix				= blockPrefix + bufVar.getName() + "[0]";
 		const bool		isStd140			= (blockLayoutFlags & LAYOUT_STD140) != 0;
 		const int		vec4Align			= (int)sizeof(deUint32)*4;
-		const int		baseAlignment		= isStd140 ? computeStd140BaseAlignment(varType, combinedFlags)
-													   : computeStd430BaseAlignment(varType, combinedFlags);
+		const int		baseAlignment		= isStd140									? computeStd140BaseAlignment(varType, combinedFlags)		:
+											(blockLayoutFlags & LAYOUT_RELAXED) != 0	? computeRelaxedBlockBaseAlignment(varType, combinedFlags)	:
+											computeStd430BaseAlignment(varType, combinedFlags);
 		int				curOffset			= deAlign32(baseOffset, baseAlignment);
 		const VarType&	elemType			= varType.getElementType();
 
@@ -598,23 +647,30 @@
 		return computeReferenceLayout(layout, curBlockNdx, baseOffset, blockPrefix + bufVar.getName(), varType, combinedFlags);
 }
 
-void computeReferenceLayout (BufferLayout& layout, const ShaderInterface& interface)
+void computeReferenceLayout (BufferLayout& layout, ShaderInterface& interface)
 {
 	int numBlocks = interface.getNumBlocks();
 
 	for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++)
 	{
-		const BufferBlock&	block			= interface.getBlock(blockNdx);
+		BufferBlock&		block			= interface.getBlock(blockNdx);
 		bool				hasInstanceName	= block.getInstanceName() != DE_NULL;
 		std::string			blockPrefix		= hasInstanceName ? (std::string(block.getBlockName()) + ".") : std::string("");
 		int					curOffset		= 0;
 		int					activeBlockNdx	= (int)layout.blocks.size();
 		int					firstVarNdx		= (int)layout.bufferVars.size();
 
-		for (BufferBlock::const_iterator varIter = block.begin(); varIter != block.end(); varIter++)
+		size_t oldSize	= layout.bufferVars.size();
+		for (BufferBlock::iterator varIter = block.begin(); varIter != block.end(); varIter++)
 		{
-			const BufferVar& bufVar = *varIter;
+			BufferVar& bufVar = *varIter;
 			curOffset += computeReferenceLayout(layout, activeBlockNdx,  blockPrefix, curOffset, bufVar, block.getFlags());
+			if (block.getFlags() & LAYOUT_RELAXED)
+			{
+				DE_ASSERT(!(layout.bufferVars.size() <= oldSize));
+				bufVar.setOffset(layout.bufferVars[oldSize].offset);
+			}
+			oldSize	= layout.bufferVars.size();
 		}
 
 		int	varIndicesEnd	= (int)layout.bufferVars.size();
@@ -833,6 +889,17 @@
 	}
 }
 
+bool usesRelaxedLayout (const ShaderInterface& interface)
+{
+	//If any of blocks has LAYOUT_RELAXED flag
+	for (int ndx = 0; ndx < interface.getNumBlocks(); ++ndx)
+	{
+		if (interface.getBlock(ndx).getFlags() & LAYOUT_RELAXED)
+			return true;
+	}
+	return false;
+}
+
 struct Indent
 {
 	int level;
@@ -849,9 +916,10 @@
 void generateDeclaration (std::ostream& src, const BufferVar& bufferVar, int indentLevel)
 {
 	// \todo [pyry] Qualifiers
-
 	if ((bufferVar.getFlags() & LAYOUT_MASK) != 0)
 		src << "layout(" << LayoutFlagsFmt(bufferVar.getFlags() & LAYOUT_MASK) << ") ";
+	else if (bufferVar.getOffset()!= ~0u)
+		src << "layout(offset = "<<bufferVar.getOffset()<<") ";
 
 	src << glu::declare(bufferVar.getType(), bufferVar.getName(), indentLevel);
 }
@@ -859,7 +927,6 @@
 void generateDeclaration (std::ostream& src, const BufferBlock& block, int bindingPoint)
 {
 	src << "layout(";
-
 	if ((block.getFlags() & LAYOUT_MASK) != 0)
 		src << LayoutFlagsFmt(block.getFlags() & LAYOUT_MASK) << ", ";
 
@@ -873,6 +940,7 @@
 	for (BufferBlock::const_iterator varIter = block.begin(); varIter != block.end(); varIter++)
 	{
 		src << Indent(1);
+
 		generateDeclaration(src, *varIter, 1 /* indent level */);
 		src << ";\n";
 	}
@@ -1256,7 +1324,11 @@
 {
 	std::ostringstream src;
 
-	src << "#version 310 es\n";
+	if (usesRelaxedLayout(interface))
+		src << "#version 450\n";
+	else
+		src << "#version 310 es\n";
+
 	src << "layout(local_size_x = 1) in;\n";
 	src << "\n";
 
@@ -2194,7 +2266,7 @@
 		const int refCount = 1;
 		int resCount = 0;
 
-		resCount = *(const int*)((const deUint8*)acBufferAlloc->getHostPtr());
+		resCount = *((const int*)acBufferAlloc->getHostPtr());
 
 		counterOk = (refCount == resCount);
 		if (!counterOk)
@@ -2233,11 +2305,19 @@
 {
 	DE_ASSERT(!m_computeShaderSrc.empty());
 
-	programCollection.glslSources.add("compute") << glu::ComputeSource(m_computeShaderSrc);
+	if (usesRelaxedLayout(m_interface))
+	{
+		programCollection.glslSources.add("compute") << glu::ComputeSource(m_computeShaderSrc)
+			<< vk::GlslBuildOptions(vk::SPIRV_VERSION_1_0, vk::GlslBuildOptions::FLAG_ALLOW_RELAXED_OFFSETS);
+	}
+	else
+		programCollection.glslSources.add("compute") << glu::ComputeSource(m_computeShaderSrc);
 }
 
 TestInstance* SSBOLayoutCase::createInstance (Context& context) const
 {
+	if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_relaxed_block_layout") && usesRelaxedLayout(m_interface))
+		TCU_THROW(NotSupportedError, "VK_KHR_relaxed_block_layout not supported");
 	return new SSBOLayoutCaseInstance(context, m_bufferMode, m_interface, m_refLayout, m_initialData, m_writeData);
 }
 
@@ -2251,7 +2331,6 @@
 	copyNonWrittenData		(m_interface, m_refLayout, m_initialData.pointers, m_writeData.pointers);
 
 	m_computeShaderSrc = generateComputeShader(m_interface, m_refLayout, m_initialData.pointers, m_writeData.pointers, m_matrixLoadFlag);
-
 }
 
 } // ssbo
diff --git a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.hpp b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.hpp
index fe954dd..7444212 100644
--- a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.hpp
+++ b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.hpp
@@ -49,9 +49,9 @@
 	QUALIFIER_RESTRICT	= (1<<6),
 	QUALIFIER_READONLY	= (1<<7),
 	QUALIFIER_WRITEONLY	= (1<<8),*/
-
 	ACCESS_READ			= (1<<9),	//!< Buffer variable is read in the shader.
 	ACCESS_WRITE		= (1<<10),	//!< Buffer variable is written in the shader.
+	LAYOUT_RELAXED		= (1<<11),	//!< Support VK_KHR_relaxed_block_layout extension
 };
 
 enum MatrixLoadFlags
@@ -65,14 +65,18 @@
 public:
 						BufferVar		(const char* name, const glu::VarType& type, deUint32 flags);
 
-	const char*			getName			(void) const { return m_name.c_str();	}
-	const glu::VarType&	getType			(void) const { return m_type;			}
-	deUint32			getFlags		(void) const { return m_flags;			}
+	const char*			getName			(void) const		{ return m_name.c_str();	}
+	const glu::VarType&	getType			(void) const		{ return m_type;			}
+	deUint32			getFlags		(void) const		{ return m_flags;			}
+	deUint32			getOffset		(void) const		{ return m_offset;			}
+
+	void				setOffset		(deUint32 offset)	{ m_offset = offset;		}
 
 private:
 	std::string			m_name;
 	glu::VarType		m_type;
 	deUint32			m_flags;
+	deUint32			m_offset;
 };
 
 class BufferBlock
@@ -83,24 +87,24 @@
 
 							BufferBlock				(const char* blockName);
 
-	const char*				getBlockName			(void) const { return m_blockName.c_str();		}
-	const char*				getInstanceName			(void) const { return m_instanceName.empty() ? DE_NULL : m_instanceName.c_str();	}
-	bool					isArray					(void) const { return m_arraySize > 0;			}
-	int						getArraySize			(void) const { return m_arraySize;				}
-	deUint32				getFlags				(void) const { return m_flags;					}
+	const char*				getBlockName			(void) const				{ return m_blockName.c_str();										}
+	const char*				getInstanceName			(void) const				{ return m_instanceName.empty() ? DE_NULL : m_instanceName.c_str();	}
+	bool					isArray					(void) const				{ return m_arraySize > 0;											}
+	int						getArraySize			(void) const				{ return m_arraySize;												}
+	deUint32				getFlags				(void) const				{ return m_flags;													}
 
-	void					setInstanceName			(const char* name)			{ m_instanceName = name;			}
-	void					setFlags				(deUint32 flags)			{ m_flags = flags;					}
-	void					addMember				(const BufferVar& var)		{ m_variables.push_back(var);		}
+	void					setInstanceName			(const char* name)			{ m_instanceName = name;											}
+	void					setFlags				(deUint32 flags)			{ m_flags = flags;													}
+	void					addMember				(const BufferVar& var)		{ m_variables.push_back(var);										}
 	void					setArraySize			(int arraySize);
 
-	int						getLastUnsizedArraySize	(int instanceNdx) const		{ return m_lastUnsizedArraySizes[instanceNdx];	}
-	void					setLastUnsizedArraySize	(int instanceNdx, int size)	{ m_lastUnsizedArraySizes[instanceNdx] = size;	}
+	int						getLastUnsizedArraySize	(int instanceNdx) const		{ return m_lastUnsizedArraySizes[instanceNdx];						}
+	void					setLastUnsizedArraySize	(int instanceNdx, int size)	{ m_lastUnsizedArraySizes[instanceNdx] = size;						}
 
-	inline iterator			begin					(void)			{ return m_variables.begin();	}
-	inline const_iterator	begin					(void) const	{ return m_variables.begin();	}
-	inline iterator			end						(void)			{ return m_variables.end();		}
-	inline const_iterator	end						(void) const	{ return m_variables.end();		}
+	inline iterator			begin					(void)						{ return m_variables.begin();										}
+	inline const_iterator	begin					(void) const				{ return m_variables.begin();										}
+	inline iterator			end						(void)						{ return m_variables.end();											}
+	inline const_iterator	end						(void) const				{ return m_variables.end();											}
 
 private:
 	std::string				m_blockName;
@@ -125,6 +129,7 @@
 
 	int								getNumBlocks			(void) const	{ return (int)m_bufferBlocks.size();	}
 	const BufferBlock&				getBlock				(int ndx) const	{ return *m_bufferBlocks[ndx];			}
+	BufferBlock&					getBlock				(int ndx)		{ return *m_bufferBlocks[ndx];			}
 
 private:
 									ShaderInterface			(const ShaderInterface&);
@@ -230,11 +235,12 @@
 	virtual TestInstance*		createInstance				(Context& context) const;
 
 protected:
-	void                        init                        (void);
+	void						init						(void);
 
 	BufferMode					m_bufferMode;
 	ShaderInterface				m_interface;
 	MatrixLoadFlags				m_matrixLoadFlag;
+	std::string					m_computeShaderSrc;
 
 private:
 								SSBOLayoutCase				(const SSBOLayoutCase&);
@@ -243,7 +249,6 @@
 	BufferLayout				m_refLayout;
 	RefDataStorage				m_initialData;	// Initial data stored in buffer.
 	RefDataStorage				m_writeData;		// Data written by compute shader.
-	std::string					m_computeShaderSrc;
 };
 
 } // ssbo
diff --git a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutTests.cpp b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutTests.cpp
index 348e9a1..7098048 100644
--- a/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutTests.cpp
+++ b/external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutTests.cpp
@@ -59,7 +59,8 @@
 	FEATURE_STD430_LAYOUT		= (1<<9),
 	FEATURE_MATRIX_LAYOUT		= (1<<10),	//!< Matrix layout flags.
 	FEATURE_UNSIZED_ARRAYS		= (1<<11),
-	FEATURE_ARRAYS_OF_ARRAYS	= (1<<12)
+	FEATURE_ARRAYS_OF_ARRAYS	= (1<<12),
+	FEATURE_RELAXED_LAYOUT		= (1<<13)
 };
 
 class RandomSSBOLayoutCase : public SSBOLayoutCase
@@ -128,10 +129,18 @@
 
 	// Layout flag candidates.
 	vector<deUint32> layoutFlagCandidates;
-	layoutFlagCandidates.push_back(0);
+
+	if (m_features & FEATURE_STD430_LAYOUT)
+		layoutFlagCandidates.push_back(LAYOUT_STD430);
+
 	if (m_features & FEATURE_STD140_LAYOUT)
 		layoutFlagCandidates.push_back(LAYOUT_STD140);
 
+	if (m_features & FEATURE_RELAXED_LAYOUT)
+		layoutFlagCandidates.push_back(LAYOUT_RELAXED);
+
+	DE_ASSERT(!layoutFlagCandidates.empty());
+
 	layoutFlags |= rnd.choose<deUint32>(layoutFlagCandidates.begin(), layoutFlagCandidates.end());
 
 	if (m_features & FEATURE_MATRIX_LAYOUT)
@@ -614,11 +623,11 @@
 class BlockMultiBasicTypesCase : public SSBOLayoutCase
 {
 public:
-	BlockMultiBasicTypesCase (tcu::TestContext& testCtx, const char* name, const char* description, deUint32 flagsA, deUint32 flagsB, BufferMode bufferMode, int numInstances, MatrixLoadFlags matrixLoadFlag)
-		: SSBOLayoutCase	(testCtx, name, description, bufferMode, matrixLoadFlag)
-		, m_flagsA			(flagsA)
-		, m_flagsB			(flagsB)
-		, m_numInstances	(numInstances)
+	BlockMultiBasicTypesCase	(tcu::TestContext& testCtx, const char* name, const char* description, deUint32 flagsA, deUint32 flagsB, BufferMode bufferMode, int numInstances, MatrixLoadFlags matrixLoadFlag)
+		: SSBOLayoutCase		(testCtx, name, description, bufferMode, matrixLoadFlag)
+		, m_flagsA				(flagsA)
+		, m_flagsB				(flagsB)
+		, m_numInstances		(numInstances)
 	{
 		BufferBlock& blockA = m_interface.allocBlock("BlockA");
 		blockA.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
@@ -1285,6 +1294,18 @@
 					modeGroup->addChild(new BlockMultiBasicTypesCase(m_testCtx, (baseName + "_comp_access").c_str(), "", baseFlags, baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0, LOAD_MATRIX_COMPONENTS));
 				}
 			}
+
+			for (int isArray = 0; isArray < 2; isArray++)
+			{
+				std::string	baseName	= "relaxed_block";
+				deUint32	baseFlags	= LAYOUT_RELAXED;
+
+				if (isArray)
+					baseName += "_instance_array";
+
+				modeGroup->addChild(new BlockMultiBasicTypesCase(m_testCtx, baseName.c_str(),					 "", baseFlags, baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0, LOAD_FULL_MATRIX));
+				modeGroup->addChild(new BlockMultiBasicTypesCase(m_testCtx, (baseName + "_comp_access").c_str(), "", baseFlags, baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0, LOAD_MATRIX_COMPONENTS));
+			}
 		}
 	}
 
@@ -1317,31 +1338,34 @@
 
 	// ssbo.random
 	{
-		const deUint32	allLayouts		= FEATURE_STD140_LAYOUT;
+		const deUint32	allStdLayouts	= FEATURE_STD140_LAYOUT|FEATURE_STD430_LAYOUT;
 		const deUint32	allBasicTypes	= FEATURE_VECTORS|FEATURE_MATRICES;
 		const deUint32	unused			= FEATURE_UNUSED_MEMBERS|FEATURE_UNUSED_VARS;
 		const deUint32	unsized			= FEATURE_UNSIZED_ARRAYS;
 		const deUint32	matFlags		= FEATURE_MATRIX_LAYOUT;
+		const deUint32	allButRelaxed	= ~FEATURE_RELAXED_LAYOUT;
+		const deUint32	allRelaxed		= FEATURE_VECTORS|FEATURE_RELAXED_LAYOUT|FEATURE_INSTANCE_ARRAYS;
 
 		tcu::TestCaseGroup* randomGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random Uniform Block cases");
 		addChild(randomGroup);
 
 		// Basic types.
-		createRandomCaseGroup(randomGroup, m_testCtx, "scalar_types",		"Scalar types only, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused,																			25, 0);
-		createRandomCaseGroup(randomGroup, m_testCtx, "vector_types",		"Scalar and vector types only, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|FEATURE_VECTORS,															25, 25);
-		createRandomCaseGroup(randomGroup, m_testCtx, "basic_types",		"All basic types, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags,													25, 50);
-		createRandomCaseGroup(randomGroup, m_testCtx, "basic_arrays",		"Arrays, per-block buffers",						SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|FEATURE_ARRAYS,									25, 50);
-		createRandomCaseGroup(randomGroup, m_testCtx, "unsized_arrays",		"Unsized arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS,							25, 50);
-		createRandomCaseGroup(randomGroup, m_testCtx, "arrays_of_arrays",	"Arrays of arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,	25, 950);
+		createRandomCaseGroup(randomGroup, m_testCtx, "scalar_types",		"Scalar types only, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused,																			25, 0);
+		createRandomCaseGroup(randomGroup, m_testCtx, "vector_types",		"Scalar and vector types only, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|FEATURE_VECTORS,															25, 25);
+		createRandomCaseGroup(randomGroup, m_testCtx, "basic_types",		"All basic types, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags,													25, 50);
+		createRandomCaseGroup(randomGroup, m_testCtx, "basic_arrays",		"Arrays, per-block buffers",						SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|FEATURE_ARRAYS,									25, 50);
+		createRandomCaseGroup(randomGroup, m_testCtx, "unsized_arrays",		"Unsized arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS,							25, 50);
+		createRandomCaseGroup(randomGroup, m_testCtx, "arrays_of_arrays",	"Arrays of arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,	25, 950);
 
-		createRandomCaseGroup(randomGroup, m_testCtx, "basic_instance_arrays",					"Basic instance arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_INSTANCE_ARRAYS,															25, 75);
-		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs",							"Nested structs, per-block buffers",					SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS,																	25, 100);
-		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_arrays",					"Nested structs, arrays, per-block buffers",			SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,							25, 150);
-		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_instance_arrays",			"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_INSTANCE_ARRAYS,											25, 125);
-		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_arrays_instance_arrays",	"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS|FEATURE_INSTANCE_ARRAYS,	25, 175);
+		createRandomCaseGroup(randomGroup, m_testCtx, "basic_instance_arrays",					"Basic instance arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_INSTANCE_ARRAYS,															25, 75);
+		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs",							"Nested structs, per-block buffers",					SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS,																	25, 100);
+		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_arrays",					"Nested structs, arrays, per-block buffers",			SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,							25, 150);
+		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_instance_arrays",			"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_INSTANCE_ARRAYS,											25, 125);
+		createRandomCaseGroup(randomGroup, m_testCtx, "nested_structs_arrays_instance_arrays",	"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allStdLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS|FEATURE_INSTANCE_ARRAYS,	25, 175);
+		createRandomCaseGroup(randomGroup, m_testCtx, "all_per_block_buffers",	"All random features, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allButRelaxed,	50, 200);
+		createRandomCaseGroup(randomGroup, m_testCtx, "all_shared_buffer",		"All random features, shared buffer",		SSBOLayoutCase::BUFFERMODE_SINGLE,		allButRelaxed,	50, 250);
 
-		createRandomCaseGroup(randomGroup, m_testCtx, "all_per_block_buffers",	"All random features, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	~0u,	50, 200);
-		createRandomCaseGroup(randomGroup, m_testCtx, "all_shared_buffer",		"All random features, shared buffer",		SSBOLayoutCase::BUFFERMODE_SINGLE,		~0u,	50, 250);
+		createRandomCaseGroup(randomGroup, m_testCtx, "relaxed",			"VK_KHR_relaxed_block_layout",				SSBOLayoutCase::BUFFERMODE_SINGLE,		allRelaxed, 100, deInt32Hash(313));
 	}
 }
 
diff --git a/external/vulkancts/mustpass/1.0.2/vk-default.txt b/external/vulkancts/mustpass/1.0.2/vk-default.txt
index b1479c4..2911b71 100644
--- a/external/vulkancts/mustpass/1.0.2/vk-default.txt
+++ b/external/vulkancts/mustpass/1.0.2/vk-default.txt
@@ -166441,6 +166441,10 @@
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_instance_array
 dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.std430_instance_array_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_instance_array
+dEQP-VK.ssbo.layout.multi_basic_types.per_block_buffer.relaxed_block_instance_array_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std140_instance_array
@@ -166449,6 +166453,10 @@
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_comp_access
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_instance_array
 dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.std430_instance_array_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_comp_access
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_instance_array
+dEQP-VK.ssbo.layout.multi_basic_types.single_buffer.relaxed_block_instance_array_comp_access
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140_comp_access
 dEQP-VK.ssbo.layout.multi_nested_struct.per_block_buffer.std140_instance_array
@@ -166840,6 +166848,106 @@
 dEQP-VK.ssbo.layout.random.all_shared_buffer.47
 dEQP-VK.ssbo.layout.random.all_shared_buffer.48
 dEQP-VK.ssbo.layout.random.all_shared_buffer.49
+dEQP-VK.ssbo.layout.random.relaxed.0
+dEQP-VK.ssbo.layout.random.relaxed.1
+dEQP-VK.ssbo.layout.random.relaxed.2
+dEQP-VK.ssbo.layout.random.relaxed.3
+dEQP-VK.ssbo.layout.random.relaxed.4
+dEQP-VK.ssbo.layout.random.relaxed.5
+dEQP-VK.ssbo.layout.random.relaxed.6
+dEQP-VK.ssbo.layout.random.relaxed.7
+dEQP-VK.ssbo.layout.random.relaxed.8
+dEQP-VK.ssbo.layout.random.relaxed.9
+dEQP-VK.ssbo.layout.random.relaxed.10
+dEQP-VK.ssbo.layout.random.relaxed.11
+dEQP-VK.ssbo.layout.random.relaxed.12
+dEQP-VK.ssbo.layout.random.relaxed.13
+dEQP-VK.ssbo.layout.random.relaxed.14
+dEQP-VK.ssbo.layout.random.relaxed.15
+dEQP-VK.ssbo.layout.random.relaxed.16
+dEQP-VK.ssbo.layout.random.relaxed.17
+dEQP-VK.ssbo.layout.random.relaxed.18
+dEQP-VK.ssbo.layout.random.relaxed.19
+dEQP-VK.ssbo.layout.random.relaxed.20
+dEQP-VK.ssbo.layout.random.relaxed.21
+dEQP-VK.ssbo.layout.random.relaxed.22
+dEQP-VK.ssbo.layout.random.relaxed.23
+dEQP-VK.ssbo.layout.random.relaxed.24
+dEQP-VK.ssbo.layout.random.relaxed.25
+dEQP-VK.ssbo.layout.random.relaxed.26
+dEQP-VK.ssbo.layout.random.relaxed.27
+dEQP-VK.ssbo.layout.random.relaxed.28
+dEQP-VK.ssbo.layout.random.relaxed.29
+dEQP-VK.ssbo.layout.random.relaxed.30
+dEQP-VK.ssbo.layout.random.relaxed.31
+dEQP-VK.ssbo.layout.random.relaxed.32
+dEQP-VK.ssbo.layout.random.relaxed.33
+dEQP-VK.ssbo.layout.random.relaxed.34
+dEQP-VK.ssbo.layout.random.relaxed.35
+dEQP-VK.ssbo.layout.random.relaxed.36
+dEQP-VK.ssbo.layout.random.relaxed.37
+dEQP-VK.ssbo.layout.random.relaxed.38
+dEQP-VK.ssbo.layout.random.relaxed.39
+dEQP-VK.ssbo.layout.random.relaxed.40
+dEQP-VK.ssbo.layout.random.relaxed.41
+dEQP-VK.ssbo.layout.random.relaxed.42
+dEQP-VK.ssbo.layout.random.relaxed.43
+dEQP-VK.ssbo.layout.random.relaxed.44
+dEQP-VK.ssbo.layout.random.relaxed.45
+dEQP-VK.ssbo.layout.random.relaxed.46
+dEQP-VK.ssbo.layout.random.relaxed.47
+dEQP-VK.ssbo.layout.random.relaxed.48
+dEQP-VK.ssbo.layout.random.relaxed.49
+dEQP-VK.ssbo.layout.random.relaxed.50
+dEQP-VK.ssbo.layout.random.relaxed.51
+dEQP-VK.ssbo.layout.random.relaxed.52
+dEQP-VK.ssbo.layout.random.relaxed.53
+dEQP-VK.ssbo.layout.random.relaxed.54
+dEQP-VK.ssbo.layout.random.relaxed.55
+dEQP-VK.ssbo.layout.random.relaxed.56
+dEQP-VK.ssbo.layout.random.relaxed.57
+dEQP-VK.ssbo.layout.random.relaxed.58
+dEQP-VK.ssbo.layout.random.relaxed.59
+dEQP-VK.ssbo.layout.random.relaxed.60
+dEQP-VK.ssbo.layout.random.relaxed.61
+dEQP-VK.ssbo.layout.random.relaxed.62
+dEQP-VK.ssbo.layout.random.relaxed.63
+dEQP-VK.ssbo.layout.random.relaxed.64
+dEQP-VK.ssbo.layout.random.relaxed.65
+dEQP-VK.ssbo.layout.random.relaxed.66
+dEQP-VK.ssbo.layout.random.relaxed.67
+dEQP-VK.ssbo.layout.random.relaxed.68
+dEQP-VK.ssbo.layout.random.relaxed.69
+dEQP-VK.ssbo.layout.random.relaxed.70
+dEQP-VK.ssbo.layout.random.relaxed.71
+dEQP-VK.ssbo.layout.random.relaxed.72
+dEQP-VK.ssbo.layout.random.relaxed.73
+dEQP-VK.ssbo.layout.random.relaxed.74
+dEQP-VK.ssbo.layout.random.relaxed.75
+dEQP-VK.ssbo.layout.random.relaxed.76
+dEQP-VK.ssbo.layout.random.relaxed.77
+dEQP-VK.ssbo.layout.random.relaxed.78
+dEQP-VK.ssbo.layout.random.relaxed.79
+dEQP-VK.ssbo.layout.random.relaxed.80
+dEQP-VK.ssbo.layout.random.relaxed.81
+dEQP-VK.ssbo.layout.random.relaxed.82
+dEQP-VK.ssbo.layout.random.relaxed.83
+dEQP-VK.ssbo.layout.random.relaxed.84
+dEQP-VK.ssbo.layout.random.relaxed.85
+dEQP-VK.ssbo.layout.random.relaxed.86
+dEQP-VK.ssbo.layout.random.relaxed.87
+dEQP-VK.ssbo.layout.random.relaxed.88
+dEQP-VK.ssbo.layout.random.relaxed.89
+dEQP-VK.ssbo.layout.random.relaxed.90
+dEQP-VK.ssbo.layout.random.relaxed.91
+dEQP-VK.ssbo.layout.random.relaxed.92
+dEQP-VK.ssbo.layout.random.relaxed.93
+dEQP-VK.ssbo.layout.random.relaxed.94
+dEQP-VK.ssbo.layout.random.relaxed.95
+dEQP-VK.ssbo.layout.random.relaxed.96
+dEQP-VK.ssbo.layout.random.relaxed.97
+dEQP-VK.ssbo.layout.random.relaxed.98
+dEQP-VK.ssbo.layout.random.relaxed.99
 dEQP-VK.query_pool.occlusion_query.basic_conservative
 dEQP-VK.query_pool.occlusion_query.basic_precise
 dEQP-VK.query_pool.occlusion_query.get_results_conservative_size_32_wait_queue_without_availability_draw_points