Unit tests and benchmark for subgroup2 and workgroup2 stuff

23_ArithmeticUnitTest/app_resources/common.hlsl → 23_Arithmetic2UnitTest/app_resources/common.hlsl

@@ -1,15 +1,14 @@
 #include "nbl/builtin/hlsl/cpp_compat.hlsl"
 #include "nbl/builtin/hlsl/functional.hlsl"
 
-template<uint32_t kScanElementCount=1024*1024>
-struct Output
+struct PushConstantData
 {
-	NBL_CONSTEXPR_STATIC_INLINE uint32_t ScanElementCount = kScanElementCount;
-
-	uint32_t subgroupSize;
-	uint32_t data[ScanElementCount];
+    uint64_t pInputBuf;
+    uint64_t pOutputBuf[8];
 };
 
+namespace arithmetic
+{
 // Thanks to our unified HLSL/C++ STD lib we're able to remove a whole load of code
 template<typename T>
 struct bit_and : nbl::hlsl::bit_and<T>
@@ -92,5 +91,6 @@ struct ballot : nbl::hlsl::plus<T>
 	static inline constexpr const char* name = "bitcount";
 #endif
 };
+}
 
-#include "nbl/builtin/hlsl/subgroup/basic.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"

23_Arithmetic2UnitTest/app_resources/shaderCommon.hlsl

@@ -0,0 +1,30 @@
+#include "common.hlsl"
+
+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
+{
+#ifdef TEST_NATIVE
+    NBL_CONSTEXPR_STATIC_INLINE bool shaderSubgroupArithmetic = true;
+#else
+    NBL_CONSTEXPR_STATIC_INLINE bool shaderSubgroupArithmetic = false;
+#endif
+};
+
+#ifndef OPERATION
+#error "Define OPERATION!"
+#endif
+
+#ifndef SUBGROUP_SIZE_LOG2
+#error "Define SUBGROUP_SIZE_LOG2!"
+#endif

23_Arithmetic2UnitTest/app_resources/testSubgroup.comp.hlsl

@@ -0,0 +1,55 @@
+#pragma shader_stage(compute)
+
+#define operation_t nbl::hlsl::OPERATION
+
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/subgroup2/arithmetic_portability.hlsl"
+
+#include "shaderCommon.hlsl"
+#include "nbl/builtin/hlsl/workgroup/basic.hlsl"
+
+typedef vector<uint32_t, ITEMS_PER_INVOCATION> type_t;
+
+uint32_t globalIndex()
+{
+    return glsl::gl_WorkGroupID().x*WORKGROUP_SIZE+workgroup::SubgroupContiguousIndex();
+}
+
+template<class Binop, uint32_t N>
+static void subtest(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>;
+
+    const uint64_t outputBufAddr = pc.pOutputBuf[Binop::BindingIndex];
+
+    if (glsl::gl_SubgroupSize()!=1u<<SUBGROUP_SIZE_LOG2)
+        vk::RawBufferStore<uint32_t>(outputBufAddr, glsl::gl_SubgroupSize());
+
+    operation_t<params_t> func;
+    type_t val = func(sourceVal);
+
+    vk::RawBufferStore<type_t>(outputBufAddr + sizeof(uint32_t) + sizeof(type_t) * globalIndex(), val, sizeof(uint32_t));
+}
+
+type_t test()
+{
+    const uint32_t idx = globalIndex();
+    type_t sourceVal = vk::RawBufferLoad<type_t>(pc.pInputBuf + idx * sizeof(type_t));
+
+    subtest<arithmetic::bit_and<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::bit_xor<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::bit_or<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::plus<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::multiplies<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::minimum<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    subtest<arithmetic::maximum<uint32_t>, ITEMS_PER_INVOCATION>(sourceVal);
+    return sourceVal;
+}
+
+[numthreads(WORKGROUP_SIZE,1,1)]
+void main()
+{
+    test();
+}

23_Arithmetic2UnitTest/app_resources/testWorkgroup.comp.hlsl

@@ -0,0 +1,76 @@
+#pragma shader_stage(compute)
+
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/subgroup2/arithmetic_portability.hlsl"
+#include "nbl/builtin/hlsl/workgroup2/arithmetic.hlsl"
+
+static const uint32_t WORKGROUP_SIZE = 1u << WORKGROUP_SIZE_LOG2;
+
+#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
+groupshared uint32_t scratch[mpl::max_v<int16_t,config_t::SharedScratchElementCount,1>];
+
+#include "../../common/include/WorkgroupDataAccessors.hlsl"
+
+static ScratchProxy arithmeticAccessor;
+
+template<class Binop, class device_capabilities>
+struct operation_t
+{
+    using binop_base_t = typename Binop::base_t;
+    using otype_t = typename Binop::type_t;
+
+    // workgroup reduction returns the value of the reduction
+    // workgroup scans do no return anything, but use the data accessor to do the storing directly
+    void operator()()
+    {
+        PreloadedDataProxy<config_t,Binop> dataAccessor = PreloadedDataProxy<config_t,Binop>::create();
+        dataAccessor.preload();
+#if IS_REDUCTION
+        otype_t value =
+#endif
+        OPERATION<config_t,binop_base_t,device_capabilities>::template __call<PreloadedDataProxy<config_t,Binop>, ScratchProxy>(dataAccessor,arithmeticAccessor);
+        // we barrier before because we alias the accessors for Binop
+        arithmeticAccessor.workgroupExecutionAndMemoryBarrier();
+#if IS_REDUCTION
+        [unroll]
+        for (uint32_t i = 0; i < PreloadedDataProxy<config_t,Binop>::PreloadedDataCount; i++)
+            dataAccessor.preloaded[i] = value;
+#endif
+        dataAccessor.unload();
+    }
+};
+
+
+template<class Binop>
+static void subtest()
+{
+    if (glsl::gl_SubgroupSize()!=1u<<SUBGROUP_SIZE_LOG2)
+        vk::RawBufferStore<uint32_t>(pc.pOutputBuf[Binop::BindingIndex], glsl::gl_SubgroupSize());
+
+    operation_t<Binop,device_capabilities> func;
+    func();
+}
+
+void test()
+{
+    subtest<arithmetic::bit_and<uint32_t> >();
+    subtest<arithmetic::bit_xor<uint32_t> >();
+    subtest<arithmetic::bit_or<uint32_t> >();
+    subtest<arithmetic::plus<uint32_t> >();
+    subtest<arithmetic::multiplies<uint32_t> >();
+    subtest<arithmetic::minimum<uint32_t> >();
+    subtest<arithmetic::maximum<uint32_t> >();
+}
+
+[numthreads(WORKGROUP_SIZE,1,1)]
+void main()
+{
+    test();
+}