apply reduced macro definitions to benchmark ex

Author: keptsecret

29_Arithmetic2Bench/app_resources/benchmarkSubgroup.comp.hlsl

@@ -4,29 +4,33 @@
 
 #include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
 #include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/subgroup2/arithmetic_params.hlsl"
 #include "nbl/builtin/hlsl/subgroup2/arithmetic_portability.hlsl"
 #include "nbl/builtin/hlsl/random/xoroshiro.hlsl"
 
 #include "shaderCommon.hlsl"
 #include "nbl/builtin/hlsl/workgroup2/basic.hlsl"
 
-typedef vector<uint32_t, ITEMS_PER_INVOCATION> type_t;
+template<class Binop, class device_capabilities>
+using params_t = SUBGROUP_CONFIG_T;
+
+NBL_CONSTEXPR_STATIC_INLINE uint32_t ItemsPerInvocation = params_t<typename arithmetic::plus<uint32_t>::base_t, device_capabilities>::ItemsPerInvocation;
+
+typedef vector<uint32_t, ItemsPerInvocation> type_t;
 
 uint32_t globalIndex()
 {
     return glsl::gl_WorkGroupID().x*WORKGROUP_SIZE+workgroup::SubgroupContiguousIndex();
 }
 
-template<class Binop, uint32_t N>
+template<class Binop>
 static void subbench(NBL_CONST_REF_ARG(type_t) sourceVal)
 {
-    using config_t = subgroup2::Configuration<SUBGROUP_SIZE_LOG2>;
-    using params_t = subgroup2::ArithmeticParams<config_t, typename Binop::base_t, N, device_capabilities>;
     type_t value = sourceVal;
 
     const uint64_t outputBufAddr = pc.pOutputBuf[Binop::BindingIndex];
 
-    operation_t<params_t> func;
+    operation_t<params_t<typename Binop::base_t, device_capabilities> > func;
     // [unroll]
     for (uint32_t i = 0; i < NUM_LOOPS; i++)
         value = func(value);
@@ -36,13 +40,14 @@ static void subbench(NBL_CONST_REF_ARG(type_t) sourceVal)
 
 void benchmark()
 {
+    const uint32_t invocationIndex = globalIndex();
     type_t sourceVal;
     Xoroshiro64Star xoroshiro = Xoroshiro64Star::construct(uint32_t2(invocationIndex,invocationIndex+1));
     [unroll]
-    for (uint16_t i = 0; i < Config::ItemsPerInvocation_0; i++)
+    for (uint16_t i = 0; i < ItemsPerInvocation; i++)
         sourceVal[i] = xoroshiro();
 
-    subbench<arithmetic::plus<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subbench<arithmetic::plus<uint32_t> >(sourceVal);
 }
 
 [numthreads(WORKGROUP_SIZE,1,1)]

29_Arithmetic2Bench/app_resources/benchmarkWorkgroup.comp.hlsl

@@ -6,12 +6,10 @@
 #include "nbl/builtin/hlsl/workgroup2/arithmetic.hlsl"
 #include "nbl/builtin/hlsl/random/xoroshiro.hlsl"
 
-static const uint32_t WORKGROUP_SIZE = 1u << WORKGROUP_SIZE_LOG2;
+using config_t = WORKGROUP_CONFIG_T;
 
 #include "shaderCommon.hlsl"
 
-using config_t = workgroup2::ArithmeticConfiguration<WORKGROUP_SIZE_LOG2, SUBGROUP_SIZE_LOG2, ITEMS_PER_INVOCATION>;
-
 typedef vector<uint32_t, config_t::ItemsPerInvocation_0> type_t;
 
 // final (level 1/2) scan needs to fit in one subgroup exactly
@@ -119,7 +117,7 @@ void benchmark()
 }
 
 
-[numthreads(WORKGROUP_SIZE,1,1)]
+[numthreads(config_t::WorkgroupSize,1,1)]
 void main()
 {
     benchmark();

29_Arithmetic2Bench/app_resources/shaderCommon.hlsl

@@ -3,13 +3,6 @@
 using namespace nbl;
 using namespace hlsl;
 
-// https://github.com/microsoft/DirectXShaderCompiler/issues/6144
-uint32_t3 nbl::hlsl::glsl::gl_WorkGroupSize() {return uint32_t3(WORKGROUP_SIZE,1,1);}
-
-#ifndef ITEMS_PER_INVOCATION
-#error "Define ITEMS_PER_INVOCATION!"
-#endif
-
 [[vk::push_constant]] PushConstantData pc;
 
 struct device_capabilities
@@ -25,10 +18,6 @@ struct device_capabilities
 #error "Define OPERATION!"
 #endif
 
-#ifndef SUBGROUP_SIZE_LOG2
-#error "Define SUBGROUP_SIZE_LOG2!"
-#endif
-
 #ifndef NUM_LOOPS
 #error "Define NUM_LOOPS!"
 #endif

29_Arithmetic2Bench/main.cpp

@@ -3,6 +3,7 @@
 #include "nbl/application_templates/MonoAssetManagerAndBuiltinResourceApplication.hpp"
 #include "app_resources/common.hlsl"
 #include "nbl/builtin/hlsl/workgroup2/arithmetic_config.hlsl"
+#include "nbl/builtin/hlsl/subgroup2/arithmetic_params.hlsl"
 
 using namespace nbl;
 using namespace core;
@@ -549,55 +550,50 @@ class ArithmeticBenchApp final : public examples::SimpleWindowedApplication, pub
 		smart_refctd_ptr<ICPUShader> overriddenUnspecialized;
 		if constexpr (WorkgroupBench)
 		{
-			const std::string definitions[7] = {
+			const std::string definitions[4] = {
 				"workgroup2::" + arith_name,
-				std::to_string(workgroupSizeLog2),
-				std::to_string(itemsPerWG),
-				std::to_string(itemsPerInvoc),
-				std::to_string(subgroupSizeLog2),
+				wgConfig.getConfigTemplateStructString(),
 				std::to_string(numLoops),
 				std::to_string(arith_name=="reduction")
 			};
 
-			const IShaderCompiler::SMacroDefinition defines[8] = {
+			const IShaderCompiler::SMacroDefinition defines[5] = {
 				{ "OPERATION", definitions[0] },
-				{ "WORKGROUP_SIZE_LOG2", definitions[1] },
-				{ "ITEMS_PER_WG", definitions[2] },
-				{ "ITEMS_PER_INVOCATION", definitions[3] },
-				{ "SUBGROUP_SIZE_LOG2", definitions[4] },
-				{ "NUM_LOOPS", definitions[5] },
-				{ "IS_REDUCTION", definitions[6] },
+				{ "WORKGROUP_CONFIG_T", definitions[1] },
+				{ "NUM_LOOPS", definitions[2] },
+				{ "IS_REDUCTION", definitions[3] },
 				{ "TEST_NATIVE", "1" }
 			};
 			if (UseNativeArithmetic)
-				options.preprocessorOptions.extraDefines = { defines, defines + 8 };
+				options.preprocessorOptions.extraDefines = { defines, defines + 5 };
 			else
-				options.preprocessorOptions.extraDefines = { defines, defines + 7 };
+				options.preprocessorOptions.extraDefines = { defines, defines + 4 };
 
 			overriddenUnspecialized = compiler->compileToSPIRV((const char*)source->getContent()->getPointer(), options);
 		}
 		else
 		{
-			const std::string definitions[5] = { 
+			hlsl::subgroup2::SArithmeticParams sgParams;
+			sgParams.init(subgroupSizeLog2, itemsPerInvoc);
+
+			const std::string definitions[4] = { 
 				"subgroup2::" + arith_name,
 				std::to_string(workgroupSize),
-				std::to_string(itemsPerInvoc),
-				std::to_string(subgroupSizeLog2),
+				sgParams.getParamTemplateStructString(),
 				std::to_string(numLoops)
 			};
 
-			const IShaderCompiler::SMacroDefinition defines[6] = {
+			const IShaderCompiler::SMacroDefinition defines[5] = {
 				{ "OPERATION", definitions[0] },
 				{ "WORKGROUP_SIZE", definitions[1] },
-				{ "ITEMS_PER_INVOCATION", definitions[2] },
-				{ "SUBGROUP_SIZE_LOG2", definitions[3] },
-				{ "NUM_LOOPS", definitions[4] },
+				{ "SUBGROUP_CONFIG_T", definitions[2] },
+				{ "NUM_LOOPS", definitions[3] },
 				{ "TEST_NATIVE", "1" }
 			};
 			if (UseNativeArithmetic)
-				options.preprocessorOptions.extraDefines = { defines, defines + 6 };
-			else
 				options.preprocessorOptions.extraDefines = { defines, defines + 5 };
+			else
+				options.preprocessorOptions.extraDefines = { defines, defines + 4 };
 
 			overriddenUnspecialized = compiler->compileToSPIRV((const char*)source->getContent()->getPointer(), options);
 		}