external/openglcts/modules/common/subgroups/glcSubgroupsTestsUtils.hpp - third_party/vulkan-cts - Git at Google

 #ifndef _GLCSUBGROUPSTESTSUTILS_HPP
 #define _GLCSUBGROUPSTESTSUTILS_HPP
 /*------------------------------------------------------------------------
  * OpenGL Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2017-2019 The Khronos Group Inc.
  * Copyright (c) 2017 Codeplay Software Ltd.
  * Copyright (c) 2019 NVIDIA 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 Subgroups tests utility classes
  */ /*--------------------------------------------------------------------*/

 #include "deDefs.hpp"
 #include "deSTLUtil.hpp"
 #include "deStringUtil.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"
 #include "glwDefs.hpp"
 #include "tcuDefs.hpp"
 #include "tcuTestCase.hpp"
 #include "glcTestCase.hpp"
 #include "glcSpirvUtils.hpp"

 #include "tcuFormatUtil.hpp"
 #include "tcuTestLog.hpp"
 #include "tcuVectorUtil.hpp"

 #include "gluShaderUtil.hpp"
 #include "gluContextInfo.hpp"

 #include "deSharedPtr.hpp"
 #include "deUniquePtr.hpp"

 #include <string>

 namespace glc
 {

 enum ShaderType
 {
 	SHADER_TYPE_GLSL = 0,
 	SHADER_TYPE_SPIRV,

 	SHADER_TYPE_LAST
 };

 template<typename Program>
 class ProgramCollection
 {
 public:
 								ProgramCollection	(void);
 								~ProgramCollection	(void);

 	void						clear				(void);

 	Program&					add					(const std::string& name);
 	void						add					(const std::string& name, de::MovePtr<Program>& program);

 	bool						contains			(const std::string& name) const;
 	const Program&				get					(const std::string& name) const;

 	class Iterator
 	{
 	private:
 		typedef typename std::map<std::string, Program*>::const_iterator	IteratorImpl;

 	public:
 		explicit			Iterator	(const IteratorImpl& i) : m_impl(i) {}

 		Iterator&			operator++	(void)			{ ++m_impl; return *this;	}
 		const Program&		operator*	(void) const	{ return getProgram();		}

 		const std::string&	getName		(void) const	{ return m_impl->first;		}
 		const Program&		getProgram	(void) const	{ return *m_impl->second;	}

 		bool				operator==	(const Iterator& other) const	{ return m_impl == other.m_impl;	}
 		bool				operator!=	(const Iterator& other) const	{ return m_impl != other.m_impl;	}

 	private:

 		IteratorImpl	m_impl;
 	};

 	Iterator					begin				(void) const { return Iterator(m_programs.begin());	}
 	Iterator					end					(void) const { return Iterator(m_programs.end());	}

 	bool						empty				(void) const { return m_programs.empty();			}

 private:
 	typedef std::map<std::string, Program*>	ProgramMap;

 	ProgramMap					m_programs;
 };

 template<typename Program>
 ProgramCollection<Program>::ProgramCollection (void)
 {
 }

 template<typename Program>
 ProgramCollection<Program>::~ProgramCollection (void)
 {
 	clear();
 }

 template<typename Program>
 void ProgramCollection<Program>::clear (void)
 {
 	for (typename ProgramMap::const_iterator i = m_programs.begin(); i != m_programs.end(); ++i)
 		delete i->second;
 	m_programs.clear();
 }

 template<typename Program>
 Program& ProgramCollection<Program>::add (const std::string& name)
 {
 	DE_ASSERT(!contains(name));
 	de::MovePtr<Program> prog = de::newMovePtr<Program>();
 	m_programs[name] = prog.get();
 	prog.release();
 	return *m_programs[name];
 }

 template<typename Program>
 void ProgramCollection<Program>::add (const std::string& name, de::MovePtr<Program>& program)
 {
 	DE_ASSERT(!contains(name));
 	m_programs[name] = program.get();
 	program.release();
 }

 template<typename Program>
 bool ProgramCollection<Program>::contains (const std::string& name) const
 {
 	return de::contains(m_programs, name);
 }

 template<typename Program>
 const Program& ProgramCollection<Program>::get (const std::string& name) const
 {
 	DE_ASSERT(contains(name));
 	return *m_programs.find(name)->second;
 }

 struct GlslSource
 {
 	std::vector<std::string>	sources[glu::SHADERTYPE_LAST];

 	GlslSource&					operator<< (const glu::ShaderSource& shaderSource)
 	{
 		sources[shaderSource.shaderType].push_back(shaderSource.source);
 		return *this;
 	}
 };

 typedef ProgramCollection<GlslSource>		SourceCollections;


 class Context
 {
 public:
 	Context (deqp::Context& deqpCtx)
 		: m_deqpCtx(deqpCtx)
 		, m_sourceCollection()
 		, m_glslVersion(glu::getContextTypeGLSLVersion(m_deqpCtx.getRenderContext().getType()))
 		, m_shaderType(SHADER_TYPE_GLSL)
 		{}
 	~Context (void) {}
 	deqp::Context&			getDeqpContext		(void) const { return m_deqpCtx; }
 	SourceCollections&		getSourceCollection (void) { return m_sourceCollection; }
 	glu::GLSLVersion		getGLSLVersion		(void) { return m_glslVersion; }
 	ShaderType				getShaderType		(void) { return m_shaderType; }
 	void					setShaderType		(ShaderType type) { m_shaderType = type; }

 protected:
 	deqp::Context&		m_deqpCtx;
 	SourceCollections	m_sourceCollection;
 	glu::GLSLVersion	m_glslVersion;
 	ShaderType			m_shaderType;
 };

 namespace subgroups
 {

 template<typename Arg0>
 class SubgroupFactory : public deqp::TestCase
 {
 public:
 	//void initPrograms(SourceCollections& programCollection, CaseDefinition caseDef)
 	typedef void (*InitFunction)(SourceCollections& programCollection, Arg0 arg0);
 	//void supportedCheck (Context& context, CaseDefinition caseDef)
 	typedef void (*SupportFunction)(Context& context, Arg0 arg0);
 	//tcu::TestStatus test(Context& context, const CaseDefinition caseDef)
 	typedef tcu::TestStatus (*TestFunction)(Context& context, const Arg0 arg0);

 	/* Public methods */
 	SubgroupFactory(deqp::Context& context, tcu::TestNodeType type, const std::string& name, const std::string& desc,
 		SupportFunction suppFunc, InitFunction initFunc, TestFunction testFunc, Arg0 arg0)
 		: TestCase(context, type, name.c_str(), desc.c_str())
 		, m_supportedFunc(suppFunc)
 		, m_initFunc(initFunc)
 		, m_testFunc(testFunc)
 		, m_arg0(arg0)
 		, m_glcContext(m_context)
 	{}

 	void init()
 	{
 		m_supportedFunc(m_glcContext, m_arg0);

 		m_initFunc(m_glcContext.getSourceCollection(), m_arg0);
 	}

 	void deinit()
 	{
 		// nothing to do
 	}

 	tcu::TestNode::IterateResult iterate()
 	{
 		DE_ASSERT(m_testFunc);
 		tcu::TestLog& log = m_testCtx.getLog();

 		try {
 			// do SPIRV version of tests if supported
 			log << tcu::TestLog::Message << "SPIRV pass beginning..." << tcu::TestLog::EndMessage;
 			spirvUtils::checkGlSpirvSupported(m_glcContext.getDeqpContext());

 			m_glcContext.setShaderType(SHADER_TYPE_SPIRV);

 			const tcu::TestStatus result = m_testFunc(m_glcContext, m_arg0);
 			if (result.isComplete())
 			{
 				DE_ASSERT(m_testCtx.getTestResult() == QP_TEST_RESULT_LAST);
 				if (result.getCode() == QP_TEST_RESULT_PASS)
 				{
 					log << tcu::TestLog::Message << "SPIRV pass completed successfully ("
 						<< result.getDescription() << ")." << tcu::TestLog::EndMessage;
 				} else {
 					// test failed - log result and stop
 					m_testCtx.setTestResult(result.getCode(), result.getDescription().c_str());
 					return tcu::TestNode::STOP;
 				}
 			}
 		} catch(tcu::NotSupportedError& e)
 		{
 			log << tcu::TestLog::Message << "SPIRV pass skipped ("
 						<< e.getMessage() << ")." << tcu::TestLog::EndMessage;
 		}

 		// do GLSL version of the tests
 		log << tcu::TestLog::Message << "GLSL pass beginning..." << tcu::TestLog::EndMessage;
 		m_glcContext.setShaderType(SHADER_TYPE_GLSL);
 		const tcu::TestStatus result = m_testFunc(m_glcContext, m_arg0);

 		if (result.isComplete())
 		{
 			DE_ASSERT(m_testCtx.getTestResult() == QP_TEST_RESULT_LAST);
 			log << tcu::TestLog::Message << "GLSL pass completed successfully ("
 				<< result.getDescription() << ")." << tcu::TestLog::EndMessage;
 			m_testCtx.setTestResult(result.getCode(), result.getDescription().c_str());
 			return tcu::TestNode::STOP;
 		}

 		return tcu::TestNode::CONTINUE;
 	}

 	static void addFunctionCaseWithPrograms (deqp::TestCaseGroup*				group,
 								  const std::string&							name,
 								  const std::string&							desc,
 								  SupportFunction								suppFunc,
 								  InitFunction									initFunc,
 								  TestFunction									testFunc,
 								  Arg0											arg0)
 	{
 		group->addChild(new SubgroupFactory(group->getContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, suppFunc, initFunc, testFunc, arg0));
 	}

 private:
 	SupportFunction		m_supportedFunc;
 	InitFunction		m_initFunc;
 	TestFunction		m_testFunc;
 	Arg0				m_arg0;

 	Context				m_glcContext;
 };


 typedef enum ShaderStageFlags
 {
 	SHADER_STAGE_VERTEX_BIT = GL_VERTEX_SHADER_BIT,
 	SHADER_STAGE_FRAGMENT_BIT = GL_FRAGMENT_SHADER_BIT,
 	SHADER_STAGE_GEOMETRY_BIT = GL_GEOMETRY_SHADER_BIT,
 	SHADER_STAGE_TESS_CONTROL_BIT = GL_TESS_CONTROL_SHADER_BIT,
 	SHADER_STAGE_TESS_EVALUATION_BIT = GL_TESS_EVALUATION_SHADER_BIT,
 	SHADER_STAGE_COMPUTE_BIT = GL_COMPUTE_SHADER_BIT,
 	SHADER_STAGE_ALL_GRAPHICS = (SHADER_STAGE_VERTEX_BIT | SHADER_STAGE_FRAGMENT_BIT | SHADER_STAGE_GEOMETRY_BIT |
 								 SHADER_STAGE_TESS_CONTROL_BIT | SHADER_STAGE_TESS_EVALUATION_BIT ),
 	SHADER_STAGE_ALL_VALID = (SHADER_STAGE_ALL_GRAPHICS | SHADER_STAGE_COMPUTE_BIT),
 } ShaderStageFlags;

 typedef enum SubgroupFeatureFlags
 {
     SUBGROUP_FEATURE_BASIC_BIT = GL_SUBGROUP_FEATURE_BASIC_BIT_KHR,
     SUBGROUP_FEATURE_VOTE_BIT = GL_SUBGROUP_FEATURE_VOTE_BIT_KHR,
     SUBGROUP_FEATURE_ARITHMETIC_BIT = GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR,
     SUBGROUP_FEATURE_BALLOT_BIT = GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR,
     SUBGROUP_FEATURE_SHUFFLE_BIT = GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR,
     SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR,
     SUBGROUP_FEATURE_CLUSTERED_BIT = GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR,
     SUBGROUP_FEATURE_QUAD_BIT = GL_SUBGROUP_FEATURE_QUAD_BIT_KHR,
     SUBGROUP_FEATURE_PARTITIONED_BIT_NV = GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV,
 	SUBGROUP_FEATURE_ALL_VALID = (SUBGROUP_FEATURE_BASIC_BIT | SUBGROUP_FEATURE_VOTE_BIT | SUBGROUP_FEATURE_ARITHMETIC_BIT |
 								  SUBGROUP_FEATURE_BALLOT_BIT | SUBGROUP_FEATURE_SHUFFLE_BIT | SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT |
 								  SUBGROUP_FEATURE_CLUSTERED_BIT | SUBGROUP_FEATURE_QUAD_BIT | SUBGROUP_FEATURE_PARTITIONED_BIT_NV),
 } SubgroupFeatureFlags;

 typedef enum Format
 {
 	FORMAT_UNDEFINED = 0,
 	FORMAT_R32_SINT = GL_R32I,
 	FORMAT_R32_UINT = GL_R32UI,
 	FORMAT_R32G32_SINT = GL_RG32I,
 	FORMAT_R32G32_UINT = GL_RG32UI,
 	FORMAT_R32G32B32_SINT = GL_RGB32I,
 	FORMAT_R32G32B32_UINT = GL_RGB32UI,
 	FORMAT_R32G32B32A32_SINT = GL_RGBA32I,
 	FORMAT_R32G32B32A32_UINT = GL_RGBA32UI,
 	FORMAT_R32_SFLOAT = GL_R32F,
 	FORMAT_R32G32_SFLOAT = GL_RG32F,
 	FORMAT_R32G32B32_SFLOAT = GL_RGB32F,
 	FORMAT_R32G32B32A32_SFLOAT = GL_RGBA32F,
 	FORMAT_R64_SFLOAT = 0x6000,
 	FORMAT_R64G64_SFLOAT,
 	FORMAT_R64G64B64_SFLOAT,
 	FORMAT_R64G64B64A64_SFLOAT,
 	FORMAT_R32_BOOL = 0x6100,
 	FORMAT_R32G32_BOOL,
 	FORMAT_R32G32B32_BOOL,
 	FORMAT_R32G32B32A32_BOOL,
 } Format;

 typedef enum DescriptorType
 {
 	DESCRIPTOR_TYPE_UNIFORM_BUFFER = GL_UNIFORM_BUFFER,
 	DESCRIPTOR_TYPE_STORAGE_BUFFER = GL_SHADER_STORAGE_BUFFER,
 	DESCRIPTOR_TYPE_STORAGE_IMAGE  = GL_TEXTURE_2D,
 } DescriptorType;

 // A struct to represent input data to a shader
 struct SSBOData
 {
 	SSBOData() :
 		initializeType	(InitializeNone),
 		layout			(LayoutStd140),
 		format			(FORMAT_UNDEFINED),
 		numElements		(0),
 		isImage			(false),
 		binding			(0u),
 		stages			((ShaderStageFlags)0u)
 	{}

 	enum InputDataInitializeType
 	{
 		InitializeNone = 0,
 		InitializeNonZero,
 		InitializeZero,
 	} initializeType;

 	enum InputDataLayoutType
 	{
 		LayoutStd140 = 0,
 		LayoutStd430,
 		LayoutPacked,
 	} layout;

 	Format						format;
 	deUint64					numElements;
 	bool						isImage;
 	deUint32					binding;
 	ShaderStageFlags			stages;
 };

 std::string getSharedMemoryBallotHelper();

 deUint32 getSubgroupSize(Context& context);

 deUint32 maxSupportedSubgroupSize();

 std::string getShaderStageName(ShaderStageFlags stage);

 std::string getSubgroupFeatureName(SubgroupFeatureFlags bit);

 void addNoSubgroupShader (SourceCollections& programCollection);

 std::string getVertShaderForStage(ShaderStageFlags stage);

 bool isSubgroupSupported(Context& context);

 bool areSubgroupOperationsSupportedForStage(
 	Context& context, ShaderStageFlags stage);

 bool areSubgroupOperationsRequiredForStage(ShaderStageFlags stage);

 bool isSubgroupFeatureSupportedForDevice(Context& context, SubgroupFeatureFlags bit);

 bool isFragmentSSBOSupportedForDevice(Context& context);

 bool isVertexSSBOSupportedForDevice(Context& context);

 bool isImageSupportedForStageOnDevice(Context& context, const ShaderStageFlags stage);

 bool isDoubleSupportedForDevice(Context& context);

 bool isDoubleFormat(Format format);

 std::string getFormatNameForGLSL(Format format);

 void addGeometryShadersFromTemplate (const std::string& glslTemplate, SourceCollections& collection);

 void setVertexShaderFrameBuffer (SourceCollections& programCollection);

 void setFragmentShaderFrameBuffer (SourceCollections& programCollection);

 void setFragmentShaderFrameBuffer (SourceCollections& programCollection);

 void setTesCtrlShaderFrameBuffer (SourceCollections& programCollection);

 void setTesEvalShaderFrameBuffer (SourceCollections& programCollection);

 bool check(std::vector<const void*> datas,
 	deUint32 width, deUint32 ref);

 bool checkCompute(std::vector<const void*> datas,
 	const deUint32 numWorkgroups[3], const deUint32 localSize[3],
 	deUint32 ref);

 tcu::TestStatus makeTessellationEvaluationFrameBufferTest(Context& context, Format format,
 	SSBOData* extraData, deUint32 extraDataCount,
 	bool (*checkResult)(std::vector<const void*> datas, deUint32 width, deUint32 subgroupSize),
 	const ShaderStageFlags shaderStage = SHADER_STAGE_ALL_GRAPHICS);

 tcu::TestStatus makeGeometryFrameBufferTest(Context& context, Format format, SSBOData* extraData,
 	deUint32 extraDataCount,
 	bool (*checkResult)(std::vector<const void*> datas, deUint32 width, deUint32 subgroupSize));

 tcu::TestStatus allStages(Context& context, Format format,
 	SSBOData* extraData, deUint32 extraDataCount,
 	bool (*checkResult)(std::vector<const void*> datas, deUint32 width, deUint32 subgroupSize),
 	const ShaderStageFlags shaderStage);

 tcu::TestStatus makeVertexFrameBufferTest(Context& context, Format format,
 	SSBOData* extraData, deUint32 extraDataCount,
 	bool (*checkResult)(std::vector<const void*> datas, deUint32 width, deUint32 subgroupSize));

 tcu::TestStatus makeFragmentFrameBufferTest(Context& context, Format format,
 	SSBOData* extraData, deUint32 extraDataCount,
 	bool (*checkResult)(std::vector<const void*> datas, deUint32 width,
 									 deUint32 height, deUint32 subgroupSize));

 tcu::TestStatus makeComputeTest(
 	Context& context, Format format, SSBOData* inputs,
 	deUint32 inputsCount,
 	bool (*checkResult)(std::vector<const void*> datas,
 		const deUint32 numWorkgroups[3], const deUint32 localSize[3],
 		deUint32 subgroupSize));
 } // subgroups
 } // glc

 #endif // _GLCSUBGROUPSTESTSUTILS_HPP
	#ifndef _GLCSUBGROUPSTESTSUTILS_HPP
	#define _GLCSUBGROUPSTESTSUTILS_HPP
	/*------------------------------------------------------------------------
	* OpenGL Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2017-2019 The Khronos Group Inc.
	* Copyright (c) 2017 Codeplay Software Ltd.
	* Copyright (c) 2019 NVIDIA 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 Subgroups tests utility classes
	/ /--------------------------------------------------------------------*/

	#include "deDefs.hpp"
	#include "deSTLUtil.hpp"
	#include "deStringUtil.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"
	#include "glwDefs.hpp"
	#include "tcuDefs.hpp"
	#include "tcuTestCase.hpp"
	#include "glcTestCase.hpp"
	#include "glcSpirvUtils.hpp"

	#include "tcuFormatUtil.hpp"
	#include "tcuTestLog.hpp"
	#include "tcuVectorUtil.hpp"

	#include "gluShaderUtil.hpp"
	#include "gluContextInfo.hpp"

	#include "deSharedPtr.hpp"
	#include "deUniquePtr.hpp"

	#include <string>

	namespace glc
	{

	enum ShaderType
	{
	SHADER_TYPE_GLSL = 0,
	SHADER_TYPE_SPIRV,

	SHADER_TYPE_LAST
	};

	template<typename Program>
	class ProgramCollection
	{
	public:
	ProgramCollection (void);
	~ProgramCollection (void);

	void clear (void);

	Program& add (const std::string& name);
	void add (const std::string& name, de::MovePtr<Program>& program);

	bool contains (const std::string& name) const;
	const Program& get (const std::string& name) const;

	class Iterator
	{
	private:
	typedef typename std::map<std::string, Program*>::const_iterator IteratorImpl;

	public:
	explicit Iterator (const IteratorImpl& i) : m_impl(i) {}

	Iterator& operator++ (void) { ++m_impl; return *this; }
	const Program& operator* (void) const { return getProgram(); }

	const std::string& getName (void) const { return m_impl->first; }
	const Program& getProgram (void) const { return *m_impl->second; }

	bool operator== (const Iterator& other) const { return m_impl == other.m_impl; }
	bool operator!= (const Iterator& other) const { return m_impl != other.m_impl; }

	private:

	IteratorImpl m_impl;
	};

	Iterator begin (void) const { return Iterator(m_programs.begin()); }
	Iterator end (void) const { return Iterator(m_programs.end()); }

	bool empty (void) const { return m_programs.empty(); }

	private:
	typedef std::map<std::string, Program*> ProgramMap;

	ProgramMap m_programs;
	};

	template<typename Program>
	ProgramCollection<Program>::ProgramCollection (void)
	{
	}

	template<typename Program>
	ProgramCollection<Program>::~ProgramCollection (void)
	{
	clear();
	}

	template<typename Program>
	void ProgramCollection<Program>::clear (void)
	{
	for (typename ProgramMap::const_iterator i = m_programs.begin(); i != m_programs.end(); ++i)
	delete i->second;
	m_programs.clear();
	}

	template<typename Program>
	Program& ProgramCollection<Program>::add (const std::string& name)
	{
	DE_ASSERT(!contains(name));
	de::MovePtr<Program> prog = de::newMovePtr<Program>();
	m_programs[name] = prog.get();
	prog.release();
	return *m_programs[name];
	}

	template<typename Program>
	void ProgramCollection<Program>::add (const std::string& name, de::MovePtr<Program>& program)
	{
	DE_ASSERT(!contains(name));
	m_programs[name] = program.get();
	program.release();
	}

	template<typename Program>
	bool ProgramCollection<Program>::contains (const std::string& name) const
	{
	return de::contains(m_programs, name);
	}

	template<typename Program>
	const Program& ProgramCollection<Program>::get (const std::string& name) const
	{
	DE_ASSERT(contains(name));
	return *m_programs.find(name)->second;
	}

	struct GlslSource
	{
	std::vector<std::string> sources[glu::SHADERTYPE_LAST];

	GlslSource& operator<< (const glu::ShaderSource& shaderSource)
	{
	sources[shaderSource.shaderType].push_back(shaderSource.source);
	return *this;
	}
	};

	typedef ProgramCollection<GlslSource> SourceCollections;


	class Context
	{
	public:
	Context (deqp::Context& deqpCtx)
	: m_deqpCtx(deqpCtx)
	, m_sourceCollection()
	, m_glslVersion(glu::getContextTypeGLSLVersion(m_deqpCtx.getRenderContext().getType()))
	, m_shaderType(SHADER_TYPE_GLSL)
	{}
	~Context (void) {}
	deqp::Context& getDeqpContext (void) const { return m_deqpCtx; }
	SourceCollections& getSourceCollection (void) { return m_sourceCollection; }
	glu::GLSLVersion getGLSLVersion (void) { return m_glslVersion; }
	ShaderType getShaderType (void) { return m_shaderType; }
	void setShaderType (ShaderType type) { m_shaderType = type; }

	protected:
	deqp::Context& m_deqpCtx;
	SourceCollections m_sourceCollection;
	glu::GLSLVersion m_glslVersion;
	ShaderType m_shaderType;
	};

	namespace subgroups
	{

	template<typename Arg0>
	class SubgroupFactory : public deqp::TestCase
	{
	public:
	//void initPrograms(SourceCollections& programCollection, CaseDefinition caseDef)
	typedef void (*InitFunction)(SourceCollections& programCollection, Arg0 arg0);
	//void supportedCheck (Context& context, CaseDefinition caseDef)
	typedef void (*SupportFunction)(Context& context, Arg0 arg0);
	//tcu::TestStatus test(Context& context, const CaseDefinition caseDef)
	typedef tcu::TestStatus (*TestFunction)(Context& context, const Arg0 arg0);

	/* Public methods */
	SubgroupFactory(deqp::Context& context, tcu::TestNodeType type, const std::string& name, const std::string& desc,
	SupportFunction suppFunc, InitFunction initFunc, TestFunction testFunc, Arg0 arg0)
	: TestCase(context, type, name.c_str(), desc.c_str())
	, m_supportedFunc(suppFunc)
	, m_initFunc(initFunc)
	, m_testFunc(testFunc)
	, m_arg0(arg0)
	, m_glcContext(m_context)
	{}

	void init()
	{
	m_supportedFunc(m_glcContext, m_arg0);

	m_initFunc(m_glcContext.getSourceCollection(), m_arg0);
	}

	void deinit()
	{
	// nothing to do
	}

	tcu::TestNode::IterateResult iterate()
	{
	DE_ASSERT(m_testFunc);
	tcu::TestLog& log = m_testCtx.getLog();

	try {
	// do SPIRV version of tests if supported
	log << tcu::TestLog::Message << "SPIRV pass beginning..." << tcu::TestLog::EndMessage;
	spirvUtils::checkGlSpirvSupported(m_glcContext.getDeqpContext());

	m_glcContext.setShaderType(SHADER_TYPE_SPIRV);

	const tcu::TestStatus result = m_testFunc(m_glcContext, m_arg0);
	if (result.isComplete())
	{
	DE_ASSERT(m_testCtx.getTestResult() == QP_TEST_RESULT_LAST);
	if (result.getCode() == QP_TEST_RESULT_PASS)
	{
	log << tcu::TestLog::Message << "SPIRV pass completed successfully ("
	<< result.getDescription() << ")." << tcu::TestLog::EndMessage;
	} else {
	// test failed - log result and stop
	m_testCtx.setTestResult(result.getCode(), result.getDescription().c_str());
	return tcu::TestNode::STOP;
	}
	}
	} catch(tcu::NotSupportedError& e)
	{
	log << tcu::TestLog::Message << "SPIRV pass skipped ("
	<< e.getMessage() << ")." << tcu::TestLog::EndMessage;
	}

	// do GLSL version of the tests
	log << tcu::TestLog::Message << "GLSL pass beginning..." << tcu::TestLog::EndMessage;
	m_glcContext.setShaderType(SHADER_TYPE_GLSL);
	const tcu::TestStatus result = m_testFunc(m_glcContext, m_arg0);

	if (result.isComplete())
	{
	DE_ASSERT(m_testCtx.getTestResult() == QP_TEST_RESULT_LAST);
	log << tcu::TestLog::Message << "GLSL pass completed successfully ("
	<< result.getDescription() << ")." << tcu::TestLog::EndMessage;
	m_testCtx.setTestResult(result.getCode(), result.getDescription().c_str());
	return tcu::TestNode::STOP;
	}

	return tcu::TestNode::CONTINUE;
	}

	static void addFunctionCaseWithPrograms (deqp::TestCaseGroup* group,
	const std::string& name,
	const std::string& desc,
	SupportFunction suppFunc,
	InitFunction initFunc,
	TestFunction testFunc,
	Arg0 arg0)
	{
	group->addChild(new SubgroupFactory(group->getContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, suppFunc, initFunc, testFunc, arg0));
	}

	private:
	SupportFunction m_supportedFunc;
	InitFunction m_initFunc;
	TestFunction m_testFunc;
	Arg0 m_arg0;

	Context m_glcContext;
	};


	typedef enum ShaderStageFlags
	{
	SHADER_STAGE_VERTEX_BIT = GL_VERTEX_SHADER_BIT,
	SHADER_STAGE_FRAGMENT_BIT = GL_FRAGMENT_SHADER_BIT,
	SHADER_STAGE_GEOMETRY_BIT = GL_GEOMETRY_SHADER_BIT,
	SHADER_STAGE_TESS_CONTROL_BIT = GL_TESS_CONTROL_SHADER_BIT,
	SHADER_STAGE_TESS_EVALUATION_BIT = GL_TESS_EVALUATION_SHADER_BIT,
	SHADER_STAGE_COMPUTE_BIT = GL_COMPUTE_SHADER_BIT,
	SHADER_STAGE_ALL_GRAPHICS = (SHADER_STAGE_VERTEX_BIT \| SHADER_STAGE_FRAGMENT_BIT \| SHADER_STAGE_GEOMETRY_BIT \|
	SHADER_STAGE_TESS_CONTROL_BIT \| SHADER_STAGE_TESS_EVALUATION_BIT ),
	SHADER_STAGE_ALL_VALID = (SHADER_STAGE_ALL_GRAPHICS \| SHADER_STAGE_COMPUTE_BIT),
	} ShaderStageFlags;

	typedef enum SubgroupFeatureFlags
	{
	SUBGROUP_FEATURE_BASIC_BIT = GL_SUBGROUP_FEATURE_BASIC_BIT_KHR,
	SUBGROUP_FEATURE_VOTE_BIT = GL_SUBGROUP_FEATURE_VOTE_BIT_KHR,
	SUBGROUP_FEATURE_ARITHMETIC_BIT = GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR,
	SUBGROUP_FEATURE_BALLOT_BIT = GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR,
	SUBGROUP_FEATURE_SHUFFLE_BIT = GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR,
	SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR,
	SUBGROUP_FEATURE_CLUSTERED_BIT = GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR,
	SUBGROUP_FEATURE_QUAD_BIT = GL_SUBGROUP_FEATURE_QUAD_BIT_KHR,
	SUBGROUP_FEATURE_PARTITIONED_BIT_NV = GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV,
	SUBGROUP_FEATURE_ALL_VALID = (SUBGROUP_FEATURE_BASIC_BIT \| SUBGROUP_FEATURE_VOTE_BIT \| SUBGROUP_FEATURE_ARITHMETIC_BIT \|
	SUBGROUP_FEATURE_BALLOT_BIT \| SUBGROUP_FEATURE_SHUFFLE_BIT \| SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT \|
	SUBGROUP_FEATURE_CLUSTERED_BIT \| SUBGROUP_FEATURE_QUAD_BIT \| SUBGROUP_FEATURE_PARTITIONED_BIT_NV),
	} SubgroupFeatureFlags;

	typedef enum Format
	{
	FORMAT_UNDEFINED = 0,
	FORMAT_R32_SINT = GL_R32I,
	FORMAT_R32_UINT = GL_R32UI,
	FORMAT_R32G32_SINT = GL_RG32I,
	FORMAT_R32G32_UINT = GL_RG32UI,
	FORMAT_R32G32B32_SINT = GL_RGB32I,
	FORMAT_R32G32B32_UINT = GL_RGB32UI,
	FORMAT_R32G32B32A32_SINT = GL_RGBA32I,
	FORMAT_R32G32B32A32_UINT = GL_RGBA32UI,
	FORMAT_R32_SFLOAT = GL_R32F,
	FORMAT_R32G32_SFLOAT = GL_RG32F,
	FORMAT_R32G32B32_SFLOAT = GL_RGB32F,
	FORMAT_R32G32B32A32_SFLOAT = GL_RGBA32F,
	FORMAT_R64_SFLOAT = 0x6000,
	FORMAT_R64G64_SFLOAT,
	FORMAT_R64G64B64_SFLOAT,
	FORMAT_R64G64B64A64_SFLOAT,
	FORMAT_R32_BOOL = 0x6100,
	FORMAT_R32G32_BOOL,
	FORMAT_R32G32B32_BOOL,
	FORMAT_R32G32B32A32_BOOL,
	} Format;

	typedef enum DescriptorType
	{
	DESCRIPTOR_TYPE_UNIFORM_BUFFER = GL_UNIFORM_BUFFER,
	DESCRIPTOR_TYPE_STORAGE_BUFFER = GL_SHADER_STORAGE_BUFFER,
	DESCRIPTOR_TYPE_STORAGE_IMAGE = GL_TEXTURE_2D,
	} DescriptorType;

	// A struct to represent input data to a shader
	struct SSBOData
	{
	SSBOData() :
	initializeType (InitializeNone),
	layout (LayoutStd140),
	format (FORMAT_UNDEFINED),
	numElements (0),
	isImage (false),
	binding (0u),
	stages ((ShaderStageFlags)0u)
	{}

	enum InputDataInitializeType
	{
	InitializeNone = 0,
	InitializeNonZero,
	InitializeZero,
	} initializeType;

	enum InputDataLayoutType
	{
	LayoutStd140 = 0,
	LayoutStd430,
	LayoutPacked,
	} layout;

	Format format;
	deUint64 numElements;
	bool isImage;
	deUint32 binding;
	ShaderStageFlags stages;
	};

	std::string getSharedMemoryBallotHelper();

	deUint32 getSubgroupSize(Context& context);

	deUint32 maxSupportedSubgroupSize();

	std::string getShaderStageName(ShaderStageFlags stage);

	std::string getSubgroupFeatureName(SubgroupFeatureFlags bit);

	void addNoSubgroupShader (SourceCollections& programCollection);

	std::string getVertShaderForStage(ShaderStageFlags stage);

	bool isSubgroupSupported(Context& context);

	bool areSubgroupOperationsSupportedForStage(
	Context& context, ShaderStageFlags stage);

	bool areSubgroupOperationsRequiredForStage(ShaderStageFlags stage);

	bool isSubgroupFeatureSupportedForDevice(Context& context, SubgroupFeatureFlags bit);

	bool isFragmentSSBOSupportedForDevice(Context& context);

	bool isVertexSSBOSupportedForDevice(Context& context);

	bool isImageSupportedForStageOnDevice(Context& context, const ShaderStageFlags stage);

	bool isDoubleSupportedForDevice(Context& context);

	bool isDoubleFormat(Format format);

	std::string getFormatNameForGLSL(Format format);

	void addGeometryShadersFromTemplate (const std::string& glslTemplate, SourceCollections& collection);

	void setVertexShaderFrameBuffer (SourceCollections& programCollection);

	void setFragmentShaderFrameBuffer (SourceCollections& programCollection);

	void setFragmentShaderFrameBuffer (SourceCollections& programCollection);

	void setTesCtrlShaderFrameBuffer (SourceCollections& programCollection);

	void setTesEvalShaderFrameBuffer (SourceCollections& programCollection);

	bool check(std::vector<const void*> datas,
	deUint32 width, deUint32 ref);

	bool checkCompute(std::vector<const void*> datas,
	const deUint32 numWorkgroups[3], const deUint32 localSize[3],
	deUint32 ref);

	tcu::TestStatus makeTessellationEvaluationFrameBufferTest(Context& context, Format format,
	SSBOData* extraData, deUint32 extraDataCount,
	bool (checkResult)(std::vector<const void> datas, deUint32 width, deUint32 subgroupSize),
	const ShaderStageFlags shaderStage = SHADER_STAGE_ALL_GRAPHICS);

	tcu::TestStatus makeGeometryFrameBufferTest(Context& context, Format format, SSBOData* extraData,
	deUint32 extraDataCount,
	bool (checkResult)(std::vector<const void> datas, deUint32 width, deUint32 subgroupSize));

	tcu::TestStatus allStages(Context& context, Format format,
	SSBOData* extraData, deUint32 extraDataCount,
	bool (checkResult)(std::vector<const void> datas, deUint32 width, deUint32 subgroupSize),
	const ShaderStageFlags shaderStage);

	tcu::TestStatus makeVertexFrameBufferTest(Context& context, Format format,
	SSBOData* extraData, deUint32 extraDataCount,
	bool (checkResult)(std::vector<const void> datas, deUint32 width, deUint32 subgroupSize));

	tcu::TestStatus makeFragmentFrameBufferTest(Context& context, Format format,
	SSBOData* extraData, deUint32 extraDataCount,
	bool (checkResult)(std::vector<const void> datas, deUint32 width,
	deUint32 height, deUint32 subgroupSize));

	tcu::TestStatus makeComputeTest(
	Context& context, Format format, SSBOData* inputs,
	deUint32 inputsCount,
	bool (checkResult)(std::vector<const void> datas,
	const deUint32 numWorkgroups[3], const deUint32 localSize[3],
	deUint32 subgroupSize));
	} // subgroups
	} // glc

	#endif // _GLCSUBGROUPSTESTSUTILS_HPP