Skinning data benchmark test case 5 (subgroups)

Crisspl · Crisspl · commit c6b0347abf46 · 2020-10-08T17:41:26.000+02:00
Using our brand new spirv-cross contribution
Warning: I've had to explicitely set compilation to SPIR-V 1.5 in IGLSLCompiler, i think we have to talk about possible implications
Works fine, but i didnt run actual benchmark. Renderdoc crashes on it though :c
diff --git a/examples_tests/31.SkinningDataBenchmark/5.vert b/examples_tests/31.SkinningDataBenchmark/5.vert
@@ -0,0 +1,126 @@
+#include "common.glsl"
+
+#extension GL_KHR_shader_subgroup_ballot : require
+
+struct BoneData
+{
+    mat4 boneMatrix;
+    mat4x3 normalMatrix;
+};
+
+layout(std430, set = 0, binding = 0, row_major) readonly buffer BoneMatrices_struct
+{
+    BoneData data[];
+} boneSSBO_structs;
+layout(std430, set = 0, binding = 1) readonly buffer BoneMatrices_dword
+{
+    uint data[];
+} boneSSBO_dwords;
+
+#ifndef BENCHMARK
+layout(location = 0) in vec3 pos;
+layout(location = 3) in vec3 normal;
+layout(location = 0) out vec3 vNormal;
+#endif
+layout(location = 4) in uint boneID;
+
+#define OBJ_DWORDS 32 // sizeof(BoneData), must be PoT
+struct BoneData_dword
+{
+    uint data[OBJ_DWORDS];
+};
+BoneData toBoneData(in BoneData_dword bone)
+{
+    BoneData retval;
+    //tpose because it was loaded as row_major
+    //one-liner because glslang doesnt support multiline preproc definitions
+#define GET_BONE_MATRIX_COL(c) retval.boneMatrix[c].x = uintBitsToFloat(bone.data[c]);retval.boneMatrix[c].y = uintBitsToFloat(bone.data[c+4]);retval.boneMatrix[c].z = uintBitsToFloat(bone.data[c+8]);retval.boneMatrix[c].w = uintBitsToFloat(bone.data[c+12])
+    
+    GET_BONE_MATRIX_COL(0);
+    GET_BONE_MATRIX_COL(1);
+    GET_BONE_MATRIX_COL(2);
+    GET_BONE_MATRIX_COL(3);
+
+    //tpose because it was loaded as row_major
+    //one-liner because glslang doesnt support multiline preproc definitions
+#define GET_NORMAL_MATRIX_COL(c) retval.normalMatrix[c].x = uintBitsToFloat(bone.data[16+c]);retval.normalMatrix[c].y = uintBitsToFloat(bone.data[16+c+4]);retval.normalMatrix[c].z = uintBitsToFloat(bone.data[16+c+8])
+
+    GET_NORMAL_MATRIX_COL(0);
+    GET_NORMAL_MATRIX_COL(1);
+    GET_NORMAL_MATRIX_COL(2);
+    GET_NORMAL_MATRIX_COL(3);
+
+    return retval;
+}
+#define COALESCING_DWORDS_LOG2 4 // GCN can fetch only 64bytes in a single request
+#define SUBGROUP_THRESH 16
+
+BoneData getBone(uint _boneID)
+{
+//#ifdef IRR_GL_KHR_shader_subgroup_basic_size
+  // if a set of invocations are active without gaps we can do a fast path
+  const uvec4 activeMask = subgroupBallot(true);
+  const int incr = int(subgroupBallotBitCount(activeMask));
+  const int incrLog2 = int(subgroupBallotFindMSB(activeMask));
+  if ((0x1<<incrLog2)==incr && incrLog2>=COALESCING_DWORDS_LOG2) // contiguous segment of active warps is required
+  {
+    BoneData_dword retval;
+    uint boneID = _boneID*uint(OBJ_DWORDS);
+
+    // basically fetch bones for one target invocation at a time
+    uvec2 outstandingLoadsMask = activeMask.xy;
+    // maybe unroll a few times manually
+    while (any(notEqual(outstandingLoadsMask,uvec2(0u))))
+    {
+		// more work required to make this work with gl_SubgroupSize > OBJ_DWORDS but good enough to benchmark
+        uint subgroupBoneID = subgroupBroadcast(boneID,subgroupBallotFindLSB(uvec4(outstandingLoadsMask,0u,0u)));
+        bool willLoadBone = subgroupBoneID==boneID;
+        outstandingLoadsMask ^= subgroupBallot(willLoadBone).xy;
+        
+	
+		uint dynamically_uniform_addr = boneID+gl_SubgroupInvocationID;
+		// use all SIMD lanes to load but then only some to read from subgroup registers
+		uint tmp = boneSSBO_dwords.data[dynamically_uniform_addr];
+		const bool notEnoughInvocations = incrLog2<OBJ_DWORDS;
+
+		if (willLoadBone)
+		{
+		  int oit=0, iit=0;
+		  for (int j=0; j<SUBGROUP_THRESH; j++)
+			retval.data[oit++] = subgroupBroadcast(tmp,iit++);
+		}
+		if (notEnoughInvocations)
+		{
+		  tmp = boneSSBO_dwords.data[dynamically_uniform_addr+incr];
+		}
+		if (willLoadBone)
+		{
+		  int oit=SUBGROUP_THRESH, iit=notEnoughInvocations ? SUBGROUP_THRESH:0;
+		  for (int j=0; j<SUBGROUP_THRESH; j++)
+			retval.data[oit++] = subgroupBroadcast(tmp,iit++);
+		}
+    }
+
+    return toBoneData(retval);
+  }
+  else
+//#endif
+  return boneSSBO_structs.data[_boneID];
+}
+
+void main()
+{
+#ifdef BENCHMARK
+    const vec3 pos = vec3(1.0, 2.0, 3.0);
+    const vec3 normal = vec3(1.0, 2.0, 3.0);
+#endif
+    BoneData bone = getBone(boneID);
+#ifndef BENCHMARK
+    gl_Position = bone.boneMatrix * vec4(pos, 1.0);
+    vNormal = mat3(bone.normalMatrix) * normalize(normal);
+#else
+    gl_Position = bone.boneMatrix * vec4(pos, 1.0);
+    gl_Position.xyz += mat3(bone.normalMatrix) * normal;
+#endif
+
+}
diff --git a/examples_tests/31.SkinningDataBenchmark/benchmark_5.vert b/examples_tests/31.SkinningDataBenchmark/benchmark_5.vert
@@ -0,0 +1,3 @@
+#version 460 core
+#define BENCHMARK
+#include "5.vert"
diff --git a/examples_tests/31.SkinningDataBenchmark/common.glsl b/examples_tests/31.SkinningDataBenchmark/common.glsl
@@ -1,7 +1,10 @@
+#ifdef __cplusplus
+#define uint uint32_t
+#endif
 #define MAX_OBJ_CNT 3000
 #define MAX_BONE_CNT 37
-#define MAT_MAX_CNT (MAX_OBJ_CNT * MAX_BONE_CNT)
-#define BONE_VEC_MAX_CNT (MAT_MAX_CNT * 4)
-#define NORM_VEC_MAX_CNT (MAT_MAX_CNT * 3)
-#define BONE_COMP_MAX_CNT (MAT_MAX_CNT * 16)
-#define NORM_COMP_MAX_CNT (MAT_MAX_CNT * 9)
+#define MAT_MAX_CNT uint (MAX_OBJ_CNT * MAX_BONE_CNT)
+#define BONE_VEC_MAX_CNT uint (MAT_MAX_CNT * 4)
+#define NORM_VEC_MAX_CNT uint (MAT_MAX_CNT * 3)
+#define BONE_COMP_MAX_CNT uint (MAT_MAX_CNT * 16)
+#define NORM_COMP_MAX_CNT uint (MAT_MAX_CNT * 9)
diff --git a/examples_tests/31.SkinningDataBenchmark/main.cpp b/examples_tests/31.SkinningDataBenchmark/main.cpp
@@ -79,6 +79,9 @@ IFrameBuffer* createDepthOnlyFrameBuffer(video::IVideoDriver* driver)
     return frameBuffer;
 }
 
+constexpr uint32_t TEST_CASE_COUNT = 5u;
+constexpr uint32_t TEST_CASE_SUBGROUPS = 4u;
+
 int main()
 {
     // create device with full flexibility over creation parameters
@@ -117,14 +120,16 @@ int main()
     auto vertexShaderBundle_2 = am->getAsset("../test_2.vert", lp);
     auto vertexShaderBundle_3 = am->getAsset("../test_3.vert", lp);
     auto vertexShaderBundle_4 = am->getAsset("../test_4.vert", lp);
+    auto vertexShaderBundle_5 = am->getAsset("../test_5.vert", lp);
 #else
     auto vertexShaderBundle_1 = am->getAsset("../benchmark_1.vert", lp);
     auto vertexShaderBundle_2 = am->getAsset("../benchmark_2.vert", lp);
     auto vertexShaderBundle_3 = am->getAsset("../benchmark_3.vert", lp);
     auto vertexShaderBundle_4 = am->getAsset("../benchmark_4.vert", lp);
+    auto vertexShaderBundle_5 = am->getAsset("../benchmark_5.vert", lp);
 #endif
     auto fragShaderBundle = am->getAsset("../dirLight.frag", lp);
-    ICPUSpecializedShader* shaders[4][2];
+    ICPUSpecializedShader* shaders[TEST_CASE_COUNT][2];
     shaders[0][0] = IAsset::castDown<ICPUSpecializedShader>(vertexShaderBundle_1.getContents().begin()->get());
     shaders[0][1] = IAsset::castDown<ICPUSpecializedShader>(fragShaderBundle.getContents().begin()->get());
     shaders[1][0] = IAsset::castDown<ICPUSpecializedShader>(vertexShaderBundle_2.getContents().begin()->get());
@@ -133,6 +138,8 @@ int main()
     shaders[2][1] = IAsset::castDown<ICPUSpecializedShader>(fragShaderBundle.getContents().begin()->get());
     shaders[3][0] = IAsset::castDown<ICPUSpecializedShader>(vertexShaderBundle_4.getContents().begin()->get());
     shaders[3][1] = IAsset::castDown<ICPUSpecializedShader>(fragShaderBundle.getContents().begin()->get());
+    shaders[4][0] = IAsset::castDown<ICPUSpecializedShader>(vertexShaderBundle_5.getContents().begin()->get());
+    shaders[4][1] = IAsset::castDown<ICPUSpecializedShader>(fragShaderBundle.getContents().begin()->get());
 
     core::vector<uint16_t> boneMatMaxCnt;
 
@@ -320,7 +327,7 @@ int main()
         core::matrix4SIMD boneMatrix;
         core::matrix3x4SIMD normalMatrix;
     };
-    core::smart_refctd_ptr<IGPUBuffer> drawDataBuffer[4];
+    core::smart_refctd_ptr<IGPUBuffer> drawDataBuffer[TEST_CASE_COUNT];
     vector<core::matrix3x4SIMD> translationMatrices_2(diskCount);
     core::vector<core::matrix4SIMD> boneMatrices(boneMatrixCnt);
     core::vector<core::matrix3x4SIMD> normalMatrices(boneMatrixCnt);
@@ -350,6 +357,8 @@ int main()
 
         //as floats
         drawDataBuffer[3] = driver->createDeviceLocalGPUBufferOnDedMem((BONE_COMP_MAX_CNT + NORM_COMP_MAX_CNT) * sizeof(float));
+
+        drawDataBuffer[TEST_CASE_SUBGROUPS] = drawDataBuffer[0];
     }
 
     
@@ -367,9 +376,10 @@ int main()
         uint32_t matrixOffsets[16];
     };
 
-    core::smart_refctd_ptr<IGPUPipelineLayout> gpuPipelineLayout[4];
-    core::smart_refctd_ptr<IGPURenderpassIndependentPipeline> gpuPipeline[4];
-    core::smart_refctd_ptr<IGPUDescriptorSet> descriptorSet[4];
+    //TODO
+    core::smart_refctd_ptr<IGPUPipelineLayout> gpuPipelineLayout[TEST_CASE_COUNT];
+    core::smart_refctd_ptr<IGPURenderpassIndependentPipeline> gpuPipeline[TEST_CASE_COUNT];
+    core::smart_refctd_ptr<IGPUDescriptorSet> descriptorSet[TEST_CASE_COUNT];
 
     Shader3PushConstants s3pc;
     s3pc.matrixOffsets = core::vector4du32_SIMD(0u, boneMatrixCnt, boneMatrixCnt * 2, boneMatrixCnt * 3);
@@ -379,42 +389,50 @@ int main()
         s4pc.matrixOffsets[i] = i * boneMatrixCnt;
 
     {
-        asset::SPushConstantRange range[4] = {
+        asset::SPushConstantRange range[TEST_CASE_COUNT] = {
             asset::ISpecializedShader::ESS_UNKNOWN, 0u, 0u,
             asset::ISpecializedShader::ESS_UNKNOWN, 0u, 0u,
             asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(Shader3PushConstants),
-            asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(Shader4PushConstants)
+            asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(Shader4PushConstants),
+            asset::ISpecializedShader::ESS_UNKNOWN, 0u, 0u
         };
 
-        for (uint32_t i = 0u; i < 4u; i++)
+        //TODO
+        for (uint32_t i = 0u; i < TEST_CASE_COUNT; i++)
         {
             core::smart_refctd_ptr<IGPUDescriptorSetLayout> layout;
             {
-                video::IGPUDescriptorSetLayout::SBinding b[1];
+                video::IGPUDescriptorSetLayout::SBinding b[2];
                 b[0].binding = 0u;
                 b[0].count = 1u;
                 b[0].type = EDT_STORAGE_BUFFER;
+                b[1] = b[0];
+                b[1].binding = 1u;
 
-                layout = driver->createGPUDescriptorSetLayout(b, b + 1);
+                uint32_t count = i == TEST_CASE_SUBGROUPS ? 2u : 1u;
+                layout = driver->createGPUDescriptorSetLayout(b, b + count);
             }
 
             descriptorSet[i] = driver->createGPUDescriptorSet(core::smart_refctd_ptr(layout));
             {
-                video::IGPUDescriptorSet::SWriteDescriptorSet w;
-                w.binding = 0u;
-                w.arrayElement = 0u;
-                w.count = 1u;
-                w.descriptorType = EDT_STORAGE_BUFFER;
-                w.dstSet = descriptorSet[i].get();
+                video::IGPUDescriptorSet::SWriteDescriptorSet w[2];
+                w[0].binding = 0u;
+                w[0].arrayElement = 0u;
+                w[0].count = 1u;
+                w[0].descriptorType = EDT_STORAGE_BUFFER;
+                w[0].dstSet = descriptorSet[i].get();
+                w[1] = w[0];
 
                 video::IGPUDescriptorSet::SDescriptorInfo info;
                 info.buffer.offset = 0u;
                 info.buffer.size = drawDataBuffer[i]->getSize();
                 info.desc = drawDataBuffer[i];
 
-                w.info = &info;
+                w[0].info = &info;
+                w[1].info = &info;
 
-                driver->updateDescriptorSets(1u, &w, 0u, nullptr);
+                uint32_t count = i == TEST_CASE_SUBGROUPS ? 2u : 1u;
+                driver->updateDescriptorSets(count, w, 0u, nullptr);
             }
             
             auto gpuShaders = driver->getGPUObjectsFromAssets(shaders[i], shaders[i] + 2);
@@ -520,8 +538,9 @@ int main()
     {
         switch (caseID)
         {
-        case 0:
-        case 1:
+        case 0: [[fallthrough]];
+        case 1: [[fallthrough]];
+        case TEST_CASE_SUBGROUPS:
         break;
         case 2:
             driver->pushConstants(gpuPipelineLayout[2].get(), asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(Shader3PushConstants), &s3pc);
@@ -538,7 +557,8 @@ int main()
     {
         switch (caseID)
         {
-        case 0:
+        case 0: [[fallthrough]];
+        case TEST_CASE_SUBGROUPS:
         {
             const size_t matricesByteSize = sizeof(BoneNormalMatPair) * boneAndNormalMatrices.size();
 
@@ -591,7 +611,7 @@ int main()
 
     constexpr uint32_t iterationCnt = 1000u;
     constexpr uint32_t warmupIterationCnt = iterationCnt / 10u;
-    for (uint32_t caseID = 0u; caseID < 4u; caseID++)
+    for (uint32_t caseID = 0u; caseID < TEST_CASE_COUNT; caseID++)
     {
         os::Printer::print(std::string("Benchmark for case nr. " + std::to_string(caseID)));
 
diff --git a/examples_tests/31.SkinningDataBenchmark/test_5.vert b/examples_tests/31.SkinningDataBenchmark/test_5.vert
@@ -0,0 +1,3 @@
+#version 460 core
+#include "5.vert"
+
diff --git a/src/irr/asset/IGLSLCompiler.cpp b/src/irr/asset/IGLSLCompiler.cpp
@@ -21,6 +21,8 @@ namespace irr
 namespace asset
 {
 
+static constexpr shaderc_spirv_version TARGET_SPIRV_VERSION = shaderc_spirv_version_1_5;
+
 IGLSLCompiler::IGLSLCompiler(io::IFileSystem* _fs) : m_inclHandler(core::make_smart_refctd_ptr<CIncludeHandler>(_fs)), m_fs(_fs)
 {
     //m_inclHandler->addBuiltinIncludeLoader(core::make_smart_refctd_ptr<asset::CGLSLScanBuiltinIncludeLoader>());
@@ -37,6 +39,7 @@ core::smart_refctd_ptr<ICPUBuffer> IGLSLCompiler::compileSPIRVFromGLSL(const cha
 
     shaderc::Compiler comp;
     shaderc::CompileOptions options;//default options
+    options.SetTargetSpirv(TARGET_SPIRV_VERSION);
     const shaderc_shader_kind stage = _stage==ISpecializedShader::ESS_UNKNOWN ? shaderc_glsl_infer_from_source : ESStoShadercEnum(_stage);
     const size_t glsl_len = strlen(_glslCode);
     if (_genDebugInfo)
@@ -222,7 +225,8 @@ core::smart_refctd_ptr<ICPUShader> IGLSLCompiler::resolveIncludeDirectives(std::
 {
     impl::disableAllDirectivesExceptIncludes(glslCode);//all "#", except those in "#include"/"#version"/"#pragma shader_stage(...)", replaced with `PREPROC_DIRECTIVE_DISABLER`
     shaderc::Compiler comp;
-    shaderc::CompileOptions options;//default options
+    shaderc::CompileOptions options;
+    options.SetTargetSpirv(TARGET_SPIRV_VERSION);
     options.SetIncluder(std::make_unique<impl::Includer>(m_inclHandler.get(), m_fs, _maxSelfInclusionCnt+1u));//custom #include handler
     const shaderc_shader_kind stage = _stage==ISpecializedShader::ESS_UNKNOWN ? shaderc_glsl_infer_from_source : ESStoShadercEnum(_stage);
     auto res = comp.PreprocessGlsl(glslCode, stage, _originFilepath, options);

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+#version 460 core`
	`2`	`+#define BENCHMARK`
	`3`	`+#include "5.vert"`