Impkementing stuff needed to run Bloom example

Author: Fletterio

examples_tests

@@ -13,7 +13,7 @@ namespace nbl
 {
 namespace hlsl
 {
-#ifdef __HLSL_VERSION // CPP
+#ifdef __HLSL_VERSION // HLSL
 template<uint32_t StorageClass, typename T>
 using __spv_ptr_t = spirv::pointer_t<StorageClass,T>;
 

include/nbl/builtin/hlsl/fft/utils.hlsl

@@ -34,7 +34,7 @@ struct exchangeValues<SharedMemoryAdaptor, float16_t>
         const bool topHalf = bool(threadID & stride);
         // Pack two halves into a single uint32_t
         uint32_t toExchange = bit_cast<uint32_t, float16_t2 >(topHalf ? float16_t2 (lo.real(), lo.imag()) : float16_t2 (hi.real(), hi.imag()));
-        shuffleXor<SharedMemoryAdaptor, uint32_t>::__call(toExchange, stride, sharedmemAdaptor);
+        shuffleXor<SharedMemoryAdaptor, uint32_t>(toExchange, stride, sharedmemAdaptor);
         float16_t2 exchanged = bit_cast<float16_t2, uint32_t>(toExchange);
         if (topHalf)
         {
@@ -57,7 +57,7 @@ struct exchangeValues<SharedMemoryAdaptor, float32_t>
         const bool topHalf = bool(threadID & stride);
         // pack into `float32_t2` because ternary operator doesn't support structs
         float32_t2 exchanged = topHalf ? float32_t2(lo.real(), lo.imag()) : float32_t2(hi.real(), hi.imag());
-        shuffleXor<SharedMemoryAdaptor, float32_t2>::__call(exchanged, stride, sharedmemAdaptor);
+        shuffleXor<SharedMemoryAdaptor, float32_t2>(exchanged, stride, sharedmemAdaptor);
         if (topHalf)
         {
             lo.real(exchanged.x);
@@ -79,7 +79,7 @@ struct exchangeValues<SharedMemoryAdaptor, float64_t>
         const bool topHalf = bool(threadID & stride);
         // pack into `float64_t2` because ternary operator doesn't support structs
         float64_t2 exchanged = topHalf ? float64_t2(lo.real(), lo.imag()) : float64_t2(hi.real(), hi.imag());                    
-        shuffleXor<SharedMemoryAdaptor, float64_t2 >::__call(exchanged, stride, sharedmemAdaptor);
+        shuffleXor<SharedMemoryAdaptor, float64_t2 >(exchanged, stride, sharedmemAdaptor);
         if (topHalf)
         {
             lo.real(exchanged.x);
@@ -152,6 +152,14 @@ uint32_t getOutputIndex(uint32_t freqIdx)
     return glsl::bitfieldReverse<uint32_t>(bitShiftLeftHigher<FFT_SIZE_LOG_2, FFT_SIZE_LOG_2 - ELEMENTS_PER_INVOCATION_LOG_2 + 1>(freqIdx)) >> (32 - FFT_SIZE_LOG_2);
 }
 
+// Mirrors an index about the Nyquist frequency
+template<uint16_t ElementsPerInvocation, uint32_t WorkgroupSize>
+uint32_t mirror(uint32_t idx)
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t FFT_SIZE = WorkgroupSize * uint32_t(ElementsPerInvocation);
+    return (FFT_SIZE - idx) & (FFT_SIZE - 1);
+}
+
 } //namespace fft
 
 // ----------------------------------- End Utils -----------------------------------------------

include/nbl/builtin/hlsl/functional.hlsl

@@ -2,6 +2,7 @@
 #define _NBL_BUILTIN_HLSL_WORKGROUP_SHUFFLE_INCLUDED_
 
 #include "nbl/builtin/hlsl/memory_accessor.hlsl"
+#include "nbl/builtin/hlsl/functional.hlsl"
 
 // TODO: Add other shuffles
 
@@ -14,26 +15,87 @@ namespace hlsl
 namespace workgroup
 {
 
+// ------------------------------------- Skeletons for implementing other Shuffles --------------------------------
+
 template<typename SharedMemoryAdaptor, typename T>
-struct shuffleXor
+struct Shuffle
+{
+    static void __call(NBL_REF_ARG(T) value, uint32_t storeIdx, uint32_t loadIdx, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    {
+        // TODO: optimization (optional) where we shuffle in the shared memory available (using rounds)
+        sharedmemAdaptor.template set<T>(storeIdx, value);
+
+        // Wait until all writes are done before reading
+        sharedmemAdaptor.workgroupExecutionAndMemoryBarrier();
+
+        sharedmemAdaptor.template get<T>(loadIdx, value);
+    }
+
+    // By default store to threadID in the workgroup
+    static void __call(NBL_REF_ARG(T) value, uint32_t loadIdx, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    {
+        __call(value, uint32_t(SubgroupContiguousIndex()), loadIdx, sharedmemAdaptor);
+    }
+};
+
+template<class UnOp, typename SharedMemoryAdaptor, typename T>
+struct ShuffleUnOp
+{
+    static void __call(NBL_REF_ARG(T) value, uint32_t a, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    {
+        UnOp unop;
+        // TODO: optimization (optional) where we shuffle in the shared memory available (using rounds)
+        sharedmemAdaptor.template set<T>(a, value);
+
+        // Wait until all writes are done before reading
+        sharedmemAdaptor.workgroupExecutionAndMemoryBarrier();
+
+        sharedmemAdaptor.template get<T>(unop(a), value);
+    }
+
+    // By default store to threadID's index and load from unop(threadID) 
+    static void __call(NBL_REF_ARG(T) value, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    {
+        __call(value, uint32_t(SubgroupContiguousIndex()), sharedmemAdaptor);
+    }
+};
+
+template<class BinOp, typename SharedMemoryAdaptor, typename T>
+struct ShuffleBinOp
 {
-    static void __call(NBL_REF_ARG(T) value, uint32_t mask, uint32_t threadID, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    static void __call(NBL_REF_ARG(T) value, uint32_t a, uint32_t b, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
     {
+        BinOp binop;
         // TODO: optimization (optional) where we shuffle in the shared memory available (using rounds)
-        sharedmemAdaptor.template set<T>(threadID, value);
-        
+        sharedmemAdaptor.template set<T>(a, value);
+
         // Wait until all writes are done before reading
         sharedmemAdaptor.workgroupExecutionAndMemoryBarrier();
-    
-        sharedmemAdaptor.template get<T>(threadID ^ mask, value);
+
+        sharedmemAdaptor.template get<T>(binop(a, b), value);
     }
 
-    static void __call(NBL_REF_ARG(T) value, uint32_t mask, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+    // By default first argument of binary op is the thread's ID in the workgroup
+    static void __call(NBL_REF_ARG(T) value, uint32_t b, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
     {
-        __call(value, mask, uint32_t(SubgroupContiguousIndex()), sharedmemAdaptor);
+        __call(value, uint32_t(SubgroupContiguousIndex()), b, sharedmemAdaptor);
     }
 };
 
+// ------------------------------------------ ShuffleXor ---------------------------------------------------------------
+
+template<typename SharedMemoryAdaptor, typename T>
+void shuffleXor(NBL_REF_ARG(T) value, uint32_t threadID, uint32_t mask, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+{
+    return ShuffleBinOp<bit_xor<uint32_t>, SharedMemoryAdaptor, T>::__call(value, threadID, mask, sharedmemAdaptor);
+}
+
+template<typename SharedMemoryAdaptor, typename T>
+void shuffleXor(NBL_REF_ARG(T) value, uint32_t mask, NBL_REF_ARG(SharedMemoryAdaptor) sharedmemAdaptor)
+{
+    return ShuffleBinOp<bit_xor<uint32_t>, SharedMemoryAdaptor, T>::__call(value, mask, sharedmemAdaptor);
+}
+
 }
 }
 }