- add gl_WorkGroupSize

- add a HLSL `assert`
- clean up everything except for workgroup arithmetic
- reduce reliance on NBL_WORKGROUP_SIZE define

Author: devshgraphicsprogramming

examples_tests

@@ -63,6 +63,7 @@ T atomicCompSwap(NBL_REF_ARG(T) ptr, T comparator, T value)
 // TODO (Future): Its annoying we have to forward declare those, but accessing gl_NumSubgroups and other gl_* values is not yet possible due to https://github.com/microsoft/DirectXShaderCompiler/issues/4217
 // also https://github.com/microsoft/DirectXShaderCompiler/issues/5280
 uint32_t gl_LocalInvocationIndex();
+uint32_t3 gl_WorkGroupSize();
 uint32_t3 gl_GlobalInvocationID();
 uint32_t3 gl_WorkGroupID();
 

include/nbl/builtin/hlsl/glsl_compat/core.hlsl

@@ -6,6 +6,14 @@
 
 #ifdef __HLSL_VERSION 
 #define static_assert(...) _Static_assert(__VA_ARGS__)
+#define assert(expr) \
+{ \
+    bool con = (expr); \
+    do { \
+        [branch] if (!con) \
+          vk::RawBufferStore<uint32_t>(0xdeadbeefBADC0FFbull,0x45u,4u); \
+    } while(!con); \
+} 
 #endif
 
 // basics

include/nbl/builtin/hlsl/macros.h

@@ -14,18 +14,23 @@ namespace hlsl
 {
 namespace workgroup
 {
+
 namespace impl
 {
-uint getDWORD(uint invocation)
+uint16_t getDWORD(uint16_t invocation)
 {
-    return invocation >> 5;
+    uint16_t dword = invocation>>5;
+    assert(dword<((Volume()+31)>>5));
+    return dword; // log2 of sizeof(uint32_t)*8
 }
 
-// uballotBitfieldCount essentially means 'how many DWORDs are needed to store ballots in bitfields, for each invocation of the workgroup'
-// can't use getDWORD because we want the static const to be treated as 'constexpr'
-static const uint uballotBitfieldCount = (_NBL_HLSL_WORKGROUP_SIZE_+31) >> 5; // in case WGSZ is not a multiple of 32 we might miscalculate the DWORDs after the right-shift by 5 which is why we add 31
-
+// essentially means 'how many DWORDs are needed to store ballots in bitfields, for each invocation of `itemCount`
+uint16_t BallotDWORDCount(const uint16_t itemCount)
+{
+    return getDWORD(itemCount+31); // round up, in case all items don't fit in even number of DWORDs
 }
+}
+
 /**
  * Simple ballot function.
  *
@@ -34,42 +39,44 @@ static const uint uballotBitfieldCount = (_NBL_HLSL_WORKGROUP_SIZE_+31) >> 5; //
  * then the Uint will be ...00100000
  * This way we can encode 32 invocations into a single Uint.
  *
- * All Uints are kept in contiguous accessor memory in a shared array.
- * The size of that array is based on the WORKGROUP SIZE. In this case we use uballotBitfieldCount.
+ * All Uints are kept in contiguous accessor memory in an array (shared is best).
+ * The size of that array is based on the ItemCount.
  *
  * For each group of 32 invocations, a DWORD is assigned to the array (i.e. a 32-bit value, in this case Uint).
  * For example, for a workgroup size 128, 4 DWORDs are needed.
  * For each invocation index, we can find its respective DWORD index in the accessor array 
  * by calling the getDWORD function.
  */
-template<class SharedAccessor>
-void ballot(const bool value, NBL_REF_ARG(SharedAccessor) accessor)
+template<class Accessor>
+void ballot(const bool value, NBL_REF_ARG(Accessor) accessor)
 {
-    uint initialize = SubgroupContiguousIndex() < impl::uballotBitfieldCount;
-    if(initialize) {
-        accessor.ballot.set(SubgroupContiguousIndex(), 0u);
-    }
+    const uint32_t index = SubgroupContiguousIndex();
+    const bool initialize = index<BallotDWORDCount(Volume());
+    if (initialize)
+        accessor.set(index,0u);
+    
     accessor.ballot.workgroupExecutionAndMemoryBarrier();
-    if(value) {
-        uint dummy;
-        accessor.ballot.atomicOr(impl::getDWORD(SubgroupContiguousIndex()), 1u<<(SubgroupContiguousIndex()&31u), dummy);
+    if(value)
+    {
+        uint32_t dummy;
+        accessor.atomicOr(impl::getDWORD(index),1u<<(index&31u),dummy);
     }
 }
 
-template<class SharedAccessor>
-bool ballotBitExtract(const uint index, NBL_REF_ARG(SharedAccessor) accessor)
+template<class Accessor>
+bool ballotBitExtract(const uint32_t index, NBL_REF_ARG(Accessor) accessor)
 {
-    return (accessor.ballot.get(impl::getDWORD(index)) & (1u << (index & 31u))) != 0u;
+    return bool(accessor.get(impl::getDWORD(index))&(1u<<(index&31u)));
 }
 
 /**
  * Once we have assigned ballots in the shared array, we can 
  * extract any invocation's ballot value using this function.
  */
-template<class SharedAccessor>
-bool inverseBallot(NBL_REF_ARG(SharedAccessor) accessor)
+template<class Accessor>
+bool inverseBallot(NBL_REF_ARG(Accessor) accessor)
 {
-    return ballotBitExtract<SharedAccessor>(SubgroupContiguousIndex(), accessor);
+    return ballotBitExtract<Accessor>(SubgroupContiguousIndex(),accessor);
 }
 
 }

include/nbl/builtin/hlsl/workgroup/ballot.hlsl

@@ -16,6 +16,12 @@ namespace workgroup
 
 static const uint32_t MaxWorkgroupSizeLog2 = 11;
 static const uint32_t MaxWorkgroupSize = 0x1u<<MaxWorkgroupSizeLog2;
+
+uint32_t Volume()
+{
+    const uint32_t3 dims = glsl::gl_WorkGroupSize();
+    return dims.x*dims.y*dims.z;
+}
 
 uint32_t SubgroupContiguousIndex()
 {

include/nbl/builtin/hlsl/workgroup/basic.hlsl

@@ -21,27 +21,21 @@ namespace workgroup
  * We save the value in the shared array in the uballotBitfieldCount index 
  * and then all invocations access that index.
  */
-template<typename T, class SharedAccessor>
-T Broadcast(const T val, NBL_REF_ARG(SharedAccessor) accessor, const uint id)
+template<typename T, class Accessor>
+T Broadcast(NBL_CONST_REF_ARG(T) val, NBL_REF_ARG(Accessor) accessor, const uint32_t id)
 {
-    if(SubgroupContiguousIndex() == id) {
-        accessor.broadcast.set(impl::uballotBitfieldCount, val);
-    }
+    if(SubgroupContiguousIndex()==id)
+        accessor.set(0,val);
 
-    accessor.broadcast.workgroupExecutionAndMemoryBarrier();
+    accessor.workgroupExecutionAndMemoryBarrier();
 
-    return accessor.broadcast.get(impl::uballotBitfieldCount);
+    return accessor.get(0);
 }
 
-template<typename T, class SharedAccessor>
-T BroadcastFirst(const T val, NBL_REF_ARG(SharedAccessor) accessor)
+template<typename T, class Accessor>
+T BroadcastFirst(NBL_CONST_REF_ARG(T) val, NBL_REF_ARG(Accessor) accessor)
 {
-    if (Elect())
-        accessor.broadcast.set(impl::uballotBitfieldCount, val);
-    
-    accessor.broadcast.workgroupExecutionAndMemoryBarrier();
-    
-    return accessor.broadcast.get(impl::uballotBitfieldCount);
+    return Broadcast(val,0);
 }
 
 }

include/nbl/builtin/hlsl/workgroup/broadcast.hlsl

@@ -7,13 +7,14 @@
 
 #include "nbl/builtin/hlsl/type_traits.hlsl"
 
-// REVIEW-519: Review this whole header and content (whether it should be here or somewhere else)
+
 namespace nbl
 {
 namespace hlsl
 {
 namespace workgroup
 {
+
 namespace impl 
 {
 template<uint32_t N, uint32_t K>
@@ -28,6 +29,20 @@ struct trunc_geom_series<N,K,W,false> : integral_constant<uint32_t,ceil_div<N,W>
 template<uint32_t N, uint32_t K, uint32_t W>
 struct trunc_geom_series<N,K,W,true> : integral_constant<uint32_t,0> {};
 }
+
+template<uint16_t ContiguousItemCount>
+struct scratch_size_ballot
+{
+	NBL_CONSTEXPR_STATIC_INLINE uint16_t value = (ContiguousItemCount+31)>>5;
+};
+
+// you're only writing one element
+NBL_CONSTEXPR_STATIC scratch_size_broadcast = 1u;
+
+// if you know better you can use the actual subgroup size
+template<uint16_t ContiguousItemCount, uint16_t SubgroupSize=subgroup::MinSubgroupSize>
+struct scratch_size_arithmetic : impl::trunc_geom_series<ContiguousItemCount,SubgroupSize> {};
+
 }
 }
 }

include/nbl/builtin/hlsl/workgroup/scratch_sz.hlsl renamed to include/nbl/builtin/hlsl/workgroup/scratch_size.hlsl

@@ -271,7 +271,12 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/basic.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/arithmetic_portability.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/arithmetic_portability_impl.hlsl")
 #workgroup
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/arithmetic.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/basic.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/ballot.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/broadcast.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/scratch_size.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/shared_Scan.hlsl")
 
 
 macro(NBL_ADD_BUILTIN_RESOURCES _TARGET_) # internal & Nabla only, must be added with the macro to properly propagate scope