Bitonic_Sort

include/nbl/builtin/hlsl/bitonic_sort/common.hlsl

@@ -0,0 +1,53 @@
+#ifndef _NBL_BUILTIN_HLSL_BITONIC_SORT_COMMON_INCLUDED_
+#define _NBL_BUILTIN_HLSL_BITONIC_SORT_COMMON_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/concepts.hlsl>
+#include <nbl/builtin/hlsl/math/intutil.hlsl>
+#include <nbl/builtin/hlsl/utility.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace bitonic_sort
+{
+
+template<typename KeyType, typename ValueType, typename Comparator>
+void compareExchangeWithPartner(
+	bool takeLarger,
+	NBL_REF_ARG(pair<KeyType, ValueType>) loPair,
+	NBL_CONST_REF_ARG(pair<KeyType, ValueType>) partnerLoPair,
+	NBL_REF_ARG(pair<KeyType, ValueType>) hiPair,
+	NBL_CONST_REF_ARG(pair<KeyType, ValueType>) partnerHiPair,
+	NBL_CONST_REF_ARG(Comparator) comp)
+{
+	const bool loSelfSmaller = comp(loPair.first, partnerLoPair.first);
+	const bool takePartnerLo = takeLarger ? loSelfSmaller : !loSelfSmaller;
+	if (takePartnerLo)
+		loPair = partnerLoPair;
+
+	const bool hiSelfSmaller = comp(hiPair.first, partnerHiPair.first);
+	const bool takePartnerHi = takeLarger ? hiSelfSmaller : !hiSelfSmaller;
+	if (takePartnerHi)
+		hiPair = partnerHiPair;
+}
+
+template<typename KeyType, typename ValueType, typename Comparator>
+void compareSwap(
+	bool ascending,
+	NBL_REF_ARG(pair<KeyType, ValueType>) loPair,
+	NBL_REF_ARG(pair<KeyType, ValueType>) hiPair,
+	NBL_CONST_REF_ARG(Comparator) comp)
+{
+	const bool shouldSwap = comp(hiPair.first, loPair.first);
+	const bool doSwap = (shouldSwap == ascending);
+
+	if (doSwap)
+		swap(loPair, hiPair);
+}
+}
+}
+}
+
+#endif

include/nbl/builtin/hlsl/concepts/accessors/bitonic_sort.hlsl

@@ -0,0 +1,31 @@
+#ifndef _NBL_BUILTIN_HLSL_CONCEPTS_ACCESSORS_BITONIC_SORT_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CONCEPTS_ACCESSORS_BITONIC_SORT_INCLUDED_
+
+#include "nbl/builtin/hlsl/concepts/accessors/generic_shared_data.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace workgroup
+{
+namespace bitonic_sort
+{
+// The SharedMemoryAccessor MUST provide the following methods:
+//  * void get(uint32_t index, NBL_REF_ARG(uint32_t) value);
+//  * void set(uint32_t index, in uint32_t value);
+//  * void workgroupExecutionAndMemoryBarrier();
+template<typename T, typename V = uint32_t, typename I = uint32_t>
+NBL_BOOL_CONCEPT BitonicSortSharedMemoryAccessor = concepts::accessors::GenericSharedMemoryAccessor<T, V, I>;
+
+// The Accessor MUST provide the following methods:
+//  * void get(uint32_t index, NBL_REF_ARG(pair<KeyType, ValueType>) value);
+//  * void set(uint32_t index, in pair<KeyType, ValueType> value);
+template<typename T, typename KeyType, typename ValueType, typename I = uint32_t>
+NBL_BOOL_CONCEPT BitonicSortAccessor = concepts::accessors::GenericDataAccessor<T, pair<KeyType, ValueType>, I>;
+
+}
+}
+}
+}
+#endif

include/nbl/builtin/hlsl/memory_accessor.hlsl

@@ -22,18 +22,6 @@ namespace nbl
 {
 namespace hlsl
 {
-
-// TODO: flesh out and move to `nbl/builtin/hlsl/utility.hlsl`
-template<typename T1, typename T2>
-struct pair
-{
-    using first_type = T1;
-    using second_type = T2;
-
-    first_type first;
-    second_type second;
-};
-
 namespace accessor_adaptors
 {
 namespace impl
@@ -227,4 +215,4 @@ struct Offset : impl::OffsetBase<IndexType,_Offset>
 }
 }
 }
-#endif
+#endif

include/nbl/builtin/hlsl/subgroup/bitonic_sort.hlsl

@@ -0,0 +1,83 @@
+#ifndef NBL_BUILTIN_HLSL_SUBGROUP_BITONIC_SORT_INCLUDED
+#define NBL_BUILTIN_HLSL_SUBGROUP_BITONIC_SORT_INCLUDED
+#include "nbl/builtin/hlsl/bitonic_sort/common.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl"
+#include "nbl/builtin/hlsl/functional.hlsl"
+namespace nbl
+{
+namespace hlsl
+{
+namespace subgroup
+{
+
+template<typename KeyType, typename ValueType, typename Comparator = less<KeyType> >
+struct bitonic_sort_config
+{
+	using key_t = KeyType;
+	using value_t = ValueType;
+	using comparator_t = Comparator;
+};
+
+template<typename Config, class device_capabilities = void>
+struct bitonic_sort;
+
+template<typename KeyType, typename ValueType, typename Comparator, class device_capabilities>
+struct bitonic_sort<bitonic_sort_config<KeyType, ValueType, Comparator>, device_capabilities>
+{
+	using config_t = bitonic_sort_config<KeyType, ValueType, Comparator>;
+	using key_t = typename config_t::key_t;
+	using value_t = typename config_t::value_t;
+	using comparator_t = typename config_t::comparator_t;
+
+	static void mergeStage(uint32_t stage, bool bitonicAscending, uint32_t invocationID,
+		NBL_REF_ARG(pair<key_t, value_t>) loPair, NBL_REF_ARG(pair<key_t, value_t>) hiPair)
+	{
+		comparator_t comp;
+
+		[unroll]
+		for (uint32_t pass = 0; pass <= stage; pass++)
+		{
+			const uint32_t stride = 1u << (stage - pass); // Element stride
+			const uint32_t threadStride = stride >> 1;
+			if (threadStride == 0)
+			{
+				// Local compare and swap for stage 0
+				nbl::hlsl::bitonic_sort::compareSwap(bitonicAscending, loPair, hiPair, comp);
+			}
+			else
+			{
+				// Shuffle from partner using XOR
+				const key_t pLoKey = glsl::subgroupShuffleXor<key_t>(loPair.first, threadStride);
+				const value_t pLoVal = glsl::subgroupShuffleXor<value_t>(loPair.second, threadStride);
+				const key_t pHiKey = glsl::subgroupShuffleXor<key_t>(hiPair.first, threadStride);
+				const value_t pHiVal = glsl::subgroupShuffleXor<value_t>(hiPair.second, threadStride);
+
+				const pair<key_t, value_t> partnerLoPair = make_pair(pLoKey, pLoVal);
+				const pair<key_t, value_t> partnerHiPair = make_pair(pHiKey, pHiVal);
+
+				const bool isUpper = bool(invocationID & threadStride);
+				const bool takeLarger = isUpper == bitonicAscending;
+
+				nbl::hlsl::bitonic_sort::compareExchangeWithPartner(takeLarger, loPair, partnerLoPair, hiPair, partnerHiPair, comp);
+			}
+		}
+	}
+
+	static void __call(bool ascending, NBL_REF_ARG(pair<key_t, value_t>) loPair, NBL_REF_ARG(pair<key_t, value_t>) hiPair)
+	{
+		const uint32_t invocationID = glsl::gl_SubgroupInvocationID();
+		const uint32_t subgroupSizeLog2 = glsl::gl_SubgroupSizeLog2();
+		[unroll]
+		for (uint32_t stage = 0; stage <= subgroupSizeLog2; stage++)
+		{
+			const bool bitonicAscending = (stage == subgroupSizeLog2) ? ascending : !bool(invocationID & (1u << stage));
+			mergeStage(stage, bitonicAscending, invocationID, loPair, hiPair);
+		}
+	}
+};
+
+}
+}
+}
+#endif

include/nbl/builtin/hlsl/utility.hlsl

@@ -1,40 +1,70 @@
-// Copyright (C) 2024 - DevSH Graphics Programming Sp. z O.O.
-// This file is part of the "Nabla Engine".
-// For conditions of distribution and use, see copyright notice in nabla.h
-#ifndef _NBL_BUILTIN_HLSL_UTILITY_INCLUDED_
-#define _NBL_BUILTIN_HLSL_UTILITY_INCLUDED_
-
-
-#include <nbl/builtin/hlsl/type_traits.hlsl>
-
-
-// for now we only implement declval
-namespace nbl
-{
-namespace hlsl
-{
-template<typename T>
-const static bool always_true = true;
-#ifndef __HLSL_VERSION
-
-template<class T>
-std::add_rvalue_reference_t<T> declval() noexcept
-{
-	static_assert(false,"Actually calling declval is ill-formed.");
-}
-
-#else
-
-namespace experimental
-{
-
-template<class T>
-T declval() {}
-
-}
-
-#endif
-}
-}
-
-#endif
+// Copyright (C) 2024 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+#ifndef _NBL_BUILTIN_HLSL_UTILITY_INCLUDED_
+#define _NBL_BUILTIN_HLSL_UTILITY_INCLUDED_
+
+
+#include <nbl/builtin/hlsl/type_traits.hlsl>
+
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename T1, typename T2>
+struct pair
+{
+	using first_type = T1;
+	using second_type = T2;
+
+	first_type first;
+	second_type second;
+};
+
+template<typename T1, typename T2>
+pair<T1, T2> make_pair(T1 f, T2 s)
+{
+	pair<T1, T2> p;
+	p.first = f;
+	p.second = s;
+	return p;
+}
+
+template<typename T1, typename T2>
+void swap(NBL_REF_ARG(pair<T1, T2>) a, NBL_REF_ARG(pair<T1, T2>) b)
+{
+	T1 temp_first = a.first;
+	T2 temp_second = a.second;
+	a.first = b.first;
+	a.second = b.second;
+	b.first = temp_first;
+	b.second = temp_second;
+}
+
+template<typename T>
+const static bool always_true = true;
+#ifndef __HLSL_VERSION
+
+template<class T>
+std::add_rvalue_reference_t<T> declval() noexcept
+{
+	static_assert(false,"Actually calling declval is ill-formed.");
+}
+
+#else
+
+namespace experimental
+{
+
+template<class T>
+T declval() {}
+
+}
+
+#endif
+}
+}
+
+#endif