Merge pull request #24 from Devsh-Graphics-Programming/ballot-test

Ballot test

Author: devshgraphicsprogramming

examples_tests/48.ArithmeticUnitTest/main.cpp

@@ -18,7 +18,7 @@ struct and
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = ~0ull; // this should be a reinterpret cast
 
 	inline T operator()(T left, T right) { return left & right; }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "and";
 };
 template<typename T>
@@ -28,7 +28,7 @@ struct xor
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = 0ull; // this should be a reinterpret cast
 
 	inline T operator()(T left, T right) { return left ^ right; }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "xor";
 };
 template<typename T>
@@ -38,7 +38,7 @@ struct or
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = 0ull; // this should be a reinterpret cast
 
 	inline T operator()(T left, T right) { return left | right; }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "or";
 };
 template<typename T>
@@ -48,7 +48,7 @@ struct add
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = T(0);
 
 	inline T operator()(T left, T right) { return left + right; }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "add";
 };
 template<typename T>
@@ -58,7 +58,7 @@ struct mul
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = T(1);
 
 	inline T operator()(T left, T right) { return left * right; }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "mul";
 };
 template<typename T>
@@ -68,7 +68,7 @@ struct min
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = std::numeric_limits<T>::max();
 
 	inline T operator()(T left, T right) { return std::min<T>(left, right); }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "min";
 };
 template<typename T>
@@ -78,9 +78,11 @@ struct max
 	_NBL_STATIC_INLINE_CONSTEXPR T IdentityElement = std::numeric_limits<T>::lowest();
 
 	inline T operator()(T left, T right) { return std::max<T>(left, right); }
-
+	_NBL_STATIC_INLINE_CONSTEXPR bool runOPonFirst = false;
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "max";
 };
+template<typename T>
+struct ballot : add<T> {};
 
 
 //subgroup method emulations on the CPU, to verify the results of the GPU methods
@@ -111,7 +113,6 @@ struct emulatedSubgroupReduction : emulatedSubgroupCommon<emulatedSubgroupReduct
 			red = OP()(red,subgroupData[i]);
 		std::fill(outSubgroupData,outSubgroupData+clampedSubgroupSize,red);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "subgroup reduction";
 };
 template<class OP>
@@ -125,7 +126,6 @@ struct emulatedSubgroupScanExclusive : emulatedSubgroupCommon<emulatedSubgroupSc
 		for (auto i=1u; i<clampedSubgroupSize; i++)
 			outSubgroupData[i] = OP()(outSubgroupData[i-1u],subgroupData[i-1u]);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "subgroup exclusive scan";
 };
 template<class OP>
@@ -139,7 +139,6 @@ struct emulatedSubgroupScanInclusive : emulatedSubgroupCommon<emulatedSubgroupSc
 		for (auto i=1u; i<clampedSubgroupSize; i++)
 			outSubgroupData[i] = OP()(outSubgroupData[i-1u],subgroupData[i]);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "subgroup inclusive scan";
 };
 
@@ -151,12 +150,11 @@ struct emulatedWorkgroupReduction
 
 	inline void operator()(type_t* outputData, const type_t* workgroupData, uint32_t workgroupSize, uint32_t subgroupSize)
 	{
-		type_t red = workgroupData[0];
+		type_t red = OP::runOPonFirst ? OP()(0, workgroupData[0]) : workgroupData[0];
 		for (auto i=1u; i<workgroupSize; i++)
 			red = OP()(red,workgroupData[i]);
 		std::fill(outputData,outputData+workgroupSize,red);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "workgroup reduction";
 };
 template<class OP>
@@ -170,7 +168,6 @@ struct emulatedWorkgroupScanExclusive
 		for (auto i=1u; i<workgroupSize; i++)
 			outputData[i] = OP()(outputData[i-1u],workgroupData[i-1u]);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "workgroup exclusive scan";
 };
 template<class OP>
@@ -184,14 +181,14 @@ struct emulatedWorkgroupScanInclusive
 		for (auto i=1u; i<workgroupSize; i++)
 			outputData[i] = OP()(outputData[i-1u],workgroupData[i]);
 	}
-
 	_NBL_STATIC_INLINE_CONSTEXPR const char* name = "workgroup inclusive scan";
 };
 
 
 #include "common.glsl"
 constexpr uint32_t kBufferSize = BUFFER_DWORD_COUNT*sizeof(uint32_t);
 
+
 //returns true if result matches
 template<template<class> class Arithmetic, template<class> class OP>
 bool validateResults(video::IVideoDriver* driver, const uint32_t* inputData, const uint32_t workgroupSize, const uint32_t workgroupCount, video::IGPUBuffer* bufferToDownload)
@@ -228,18 +225,27 @@ bool validateResults(video::IVideoDriver* driver, const uint32_t* inputData, con
 		// now check if the data obtained has valid values
 		constexpr uint32_t subgroupSize = 4u;
 		uint32_t* tmp = new uint32_t[workgroupSize];
+		uint32_t* ballotInput = new uint32_t[workgroupSize];
 		for (uint32_t workgroupID=0u; success&&workgroupID<workgroupCount; workgroupID++)
 		{
 			const auto workgroupOffset = workgroupID*workgroupSize;
-			Arithmetic<OP<uint32_t>>()(tmp,inputData+workgroupOffset,workgroupSize,subgroupSize);
+			if constexpr (std::is_same_v<OP<uint32_t>,ballot<uint32_t>>)
+			{
+				for (auto i=0u; i<workgroupSize; i++)
+					ballotInput[i] = inputData[i+workgroupOffset]&0x1u;
+				Arithmetic<OP<uint32_t>>()(tmp,ballotInput,workgroupSize,subgroupSize);
+			}
+			else
+				Arithmetic<OP<uint32_t>>()(tmp,inputData+workgroupOffset,workgroupSize,subgroupSize);
 			for (uint32_t localInvocationIndex=0u; localInvocationIndex<workgroupSize; localInvocationIndex++)
 			if (tmp[localInvocationIndex]!=dataFromBuffer[workgroupOffset+localInvocationIndex])
 			{
-				os::Printer::log("Failed test #" + std::to_string(workgroupSize) + " (" + Arithmetic<OP<uint32_t>>::name + ")  (" + OP<uint32_t>::name + ")", ELL_ERROR);
+				os::Printer::log("Failed test #" + std::to_string(workgroupSize) + " (" + Arithmetic<OP<uint32_t>>::name + ")  (" + OP<uint32_t>::name + ") Expected "+ std::to_string(tmp[localInvocationIndex])+ " got " + std::to_string(dataFromBuffer[workgroupOffset + localInvocationIndex]), ELL_ERROR);
 				success = false;
 				break;
 			}
 		}
+		delete[] ballotInput;
 		delete[] tmp;
 	}
 	else
@@ -250,7 +256,7 @@ bool validateResults(video::IVideoDriver* driver, const uint32_t* inputData, con
 
 }
 template<template<class> class Arithmetic>
-bool runTest(video::IVideoDriver* driver, video::IGPUComputePipeline* pipeline, const video::IGPUDescriptorSet* ds, const uint32_t* inputData, const uint32_t workgroupSize, core::smart_refctd_ptr<IGPUBuffer>* const buffers)
+bool runTest(video::IVideoDriver* driver, video::IGPUComputePipeline* pipeline, const video::IGPUDescriptorSet* ds, const uint32_t* inputData, const uint32_t workgroupSize, core::smart_refctd_ptr<IGPUBuffer>* const buffers, bool is_workgroup_test = false)
 {
 	driver->bindComputePipeline(pipeline);
 	driver->bindDescriptorSets(video::EPBP_COMPUTE,pipeline->getLayout(),0u,1u,&ds,nullptr);
@@ -265,6 +271,11 @@ bool runTest(video::IVideoDriver* driver, video::IGPUComputePipeline* pipeline,
 	passed = validateResults<Arithmetic,mul>(driver, inputData, workgroupSize, workgroupCount, buffers[4].get())&&passed;
 	passed = validateResults<Arithmetic,::min>(driver, inputData, workgroupSize, workgroupCount, buffers[5].get())&&passed;
 	passed = validateResults<Arithmetic,::max>(driver, inputData, workgroupSize, workgroupCount, buffers[6].get())&&passed;
+	if(is_workgroup_test)
+	{
+		passed = validateResults<Arithmetic,ballot>(driver, inputData, workgroupSize, workgroupCount, buffers[7].get()) && passed;
+	}
+
 	return passed;
 }
 
@@ -300,43 +311,41 @@ int main()
 	}
 	auto gpuinputDataBuffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(kBufferSize, inputData);
 
-	//create 7 buffers.
-	core::smart_refctd_ptr<IGPUBuffer> buffers[7];
-	for (size_t i = 0; i < 7; i++)
+	//create 8 buffers.
+	constexpr const int outputBufferCount = 8;
+	constexpr const int totalBufferCount = outputBufferCount+1;
+
+	core::smart_refctd_ptr<IGPUBuffer> buffers[outputBufferCount];
+	for (size_t i = 0; i < outputBufferCount; i++)
 	{
 		buffers[i] = driver->createDeviceLocalGPUBufferOnDedMem(kBufferSize);
 	}
 
-	IGPUDescriptorSetLayout::SBinding binding[8] = {
-		{0u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},	//input with randomized numbers
-		{1u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{2u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{3u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{4u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{5u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{6u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-		{7u,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr},
-	};
-	auto gpuDSLayout = driver->createGPUDescriptorSetLayout(binding, binding + 8);
-	constexpr uint32_t pushconstantSize = 64u;
+	IGPUDescriptorSetLayout::SBinding binding[totalBufferCount];
+	for (uint32_t i = 0u; i < totalBufferCount; i++)
+	{
+		binding[i] = { i,EDT_STORAGE_BUFFER,1u,IGPUSpecializedShader::ESS_COMPUTE,nullptr };
+	}
+	auto gpuDSLayout = driver->createGPUDescriptorSetLayout(binding, binding + totalBufferCount);
+	constexpr uint32_t pushconstantSize = 8u* totalBufferCount;
 	SPushConstantRange pcRange[1] = { IGPUSpecializedShader::ESS_COMPUTE,0u,pushconstantSize };
 	auto pipelineLayout = driver->createGPUPipelineLayout(pcRange, pcRange + pushconstantSize, core::smart_refctd_ptr(gpuDSLayout));
 
 	auto descriptorSet = driver->createGPUDescriptorSet(core::smart_refctd_ptr(gpuDSLayout));
 	{
-		IGPUDescriptorSet::SDescriptorInfo infos[8];
+		IGPUDescriptorSet::SDescriptorInfo infos[totalBufferCount];
 		infos[0].desc = gpuinputDataBuffer;
 		infos[0].buffer = { 0u,kBufferSize };
-		for (uint32_t i=1u; i<=7u; i++)
+		for (uint32_t i=1u; i<= outputBufferCount; i++)
 		{
 			infos[i].desc = buffers[i - 1];
 			infos[i].buffer = { 0u,kBufferSize };
 
 		}
-		IGPUDescriptorSet::SWriteDescriptorSet writes[8];
-		for (uint32_t i=0u; i<8u; i++)
+		IGPUDescriptorSet::SWriteDescriptorSet writes[totalBufferCount];
+		for (uint32_t i=0u; i< totalBufferCount; i++)
 			writes[i] = { descriptorSet.get(),i,0u,1u,EDT_STORAGE_BUFFER,infos + i };
-		driver->updateDescriptorSets(8, writes, 0u, nullptr);
+		driver->updateDescriptorSets(totalBufferCount, writes, 0u, nullptr);
 	}
 	struct GLSLCodeWithWorkgroup {
 		uint32_t workgroup_definition_position;
@@ -391,9 +400,9 @@ int main()
 		passed = runTest<emulatedSubgroupReduction>(driver,pipelines[0u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
 		passed = runTest<emulatedSubgroupScanExclusive>(driver,pipelines[1u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
 		passed = runTest<emulatedSubgroupScanInclusive>(driver,pipelines[2u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
-		passed = runTest<emulatedWorkgroupReduction>(driver,pipelines[3u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
-		passed = runTest<emulatedWorkgroupScanExclusive>(driver,pipelines[4u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
-		passed = runTest<emulatedWorkgroupScanInclusive>(driver,pipelines[5u].get(),descriptorSet.get(),inputData,workgroupSize,buffers)&&passed;
+		passed = runTest<emulatedWorkgroupReduction>(driver,pipelines[3u].get(),descriptorSet.get(),inputData,workgroupSize,buffers,true)&&passed;
+		passed = runTest<emulatedWorkgroupScanExclusive>(driver,pipelines[4u].get(),descriptorSet.get(),inputData,workgroupSize,buffers, true)&&passed;
+		passed = runTest<emulatedWorkgroupScanInclusive>(driver,pipelines[5u].get(),descriptorSet.get(),inputData,workgroupSize,buffers, true)&&passed;
 
 		if (passed)
 			os::Printer::log("Passed test #" + std::to_string(workgroupSize), ELL_INFORMATION);

examples_tests/48.ArithmeticUnitTest/shaderCommon.glsl

@@ -33,4 +33,8 @@ layout(set = 0, binding = 6, std430) writeonly buffer outmin
 layout(set = 0, binding = 7, std430) writeonly buffer outmax
 {
     uint maxOutput[];
+};
+layout(set = 0, binding = 8, std430) writeonly buffer outbitcount
+{
+    uint bitCountOutput[];
 };

examples_tests/48.ArithmeticUnitTest/testWorkgroupExclusive.comp

@@ -13,4 +13,7 @@ void main()
 	multOutput[gl_GlobalInvocationID.x] = nbl_glsl_workgroupExclusiveMul(sourceVal);
 	minOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupExclusiveMin(sourceVal);
 	maxOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupExclusiveMax(sourceVal);
+	nbl_glsl_workgroupBallot((sourceVal&0x1u)==0x1u);
+	bitCountOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupBallotExclusiveBitCount();
+
 }

examples_tests/48.ArithmeticUnitTest/testWorkgroupInclusive.comp

@@ -13,4 +13,6 @@ void main()
 	multOutput[gl_GlobalInvocationID.x] = nbl_glsl_workgroupInclusiveMul(sourceVal);
 	minOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupInclusiveMin(sourceVal);
 	maxOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupInclusiveMax(sourceVal);
+	nbl_glsl_workgroupBallot((sourceVal&0x1u)==0x1u);
+	bitCountOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupBallotInclusiveBitCount();
 }

examples_tests/48.ArithmeticUnitTest/testWorkgroupReduce.comp

@@ -13,4 +13,7 @@ void main()
 	multOutput[gl_GlobalInvocationID.x] = nbl_glsl_workgroupMul(sourceVal);
 	minOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupMin(sourceVal);
 	maxOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupMax(sourceVal);
+	nbl_glsl_workgroupBallot((sourceVal&0x1u)==0x1u);
+	bitCountOutput [gl_GlobalInvocationID.x] = nbl_glsl_workgroupBallotBitCount();
+
 }

examples_tests/48.ArithmeticUnitTest/workgroupCommon.glsl

@@ -1,3 +1,10 @@
 #include "shaderCommon.glsl"
 
-#include "nbl/builtin/glsl/workgroup/arithmetic.glsl"
+// ORDER OF INCLUDES MATTERS !!!!!
+// first the feature that requires the most shared memory should be included
+// anyway when one is using more than 2 features that rely on shared memory,
+// they should declare the shared memory of appropriate size by themselves.
+// But in this unit test we don't because we need to test if the default
+// sizing macros actually work for all workgroup sizes.
+#include <nbl/builtin/glsl/workgroup/arithmetic.glsl>
+#include <nbl/builtin/glsl/workgroup/ballot.glsl>

include/nbl/builtin/glsl/workgroup/ballot.glsl

@@ -273,7 +273,7 @@ uint nbl_glsl_workgroupBallotScanBitCount_impl(in bool exclusive)
 		barrier();
 	}
 
-	const uint mask = 0xffffffffu>>((exclusive ? 32u:31u)-(gl_LocalInvocationIndex&31u));
+	const uint mask = (exclusive ? 0x7fffffffu:0xffffffffu)>>(31u-(gl_LocalInvocationIndex&31u));
 	return globalCount+bitCount(localBitfield&mask);
 }