Merge remote-tracking branch 'origin/member_test'

devshgraphicsprogramming · devshgraphicsprogramming · commit de27e515b509 · 2024-01-10T11:55:27.000+01:00
Also get rid of NBL_REPEAT
diff --git a/examples_tests b/examples_tests
@@ -1 +1 @@
-Subproject commit 65edcec2222ceb3096a7974d74ab2848e1ace49e
+Subproject commit ac58cc85cae5cf698cd4ca35e42b3ae311bbc961
diff --git a/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl b/include/nbl/builtin/hlsl/device_capabilities_traits.hlsl
@@ -7,15 +7,44 @@
 #include <nbl/builtin/hlsl/member_test_macros.hlsl>
 
 #ifdef __HLSL_VERSION
+
+NBL_GENERATE_MEMBER_TESTER(shaderFloat64);
+NBL_GENERATE_MEMBER_TESTER(shaderDrawParameters);
+NBL_GENERATE_MEMBER_TESTER(subgroupArithmetic);
+NBL_GENERATE_MEMBER_TESTER(fragmentShaderPixelInterlock);
+NBL_GENERATE_MEMBER_TESTER(maxOptimallyResidentWorkgroupInvocations);
+
+#define NBL_GENERATE_GET_OR_DEFAULT(field, ty, default) \
+template<typename S, bool = has_member_##field<S>::value> struct get_or_default_##field : integral_constant<ty,S::field> {}; \
+template<typename S> struct get_or_default_##field<S,false> : integral_constant<ty,default> {};
+
 namespace nbl
 {
 namespace hlsl
 {
+
+namespace impl
+{
+NBL_GENERATE_GET_OR_DEFAULT(shaderFloat64, bool, false);
+NBL_GENERATE_GET_OR_DEFAULT(shaderDrawParameters, bool, false);
+NBL_GENERATE_GET_OR_DEFAULT(subgroupArithmetic, bool, false);
+NBL_GENERATE_GET_OR_DEFAULT(fragmentShaderPixelInterlock, bool, false);
+NBL_GENERATE_GET_OR_DEFAULT(maxOptimallyResidentWorkgroupInvocations, uint16_t, 0);
+}
+
+
 template<typename device_capabilities>
 struct device_capabilities_traits
 {
-    // TODO: check for members and default them to sane things, only do the 5 members in CJITIncludeLoader.cpp struct, we'll do the rest on `vulkan_1_3` branch with Nahim
+    NBL_CONSTEXPR_STATIC_INLINE bool shaderFloat64                                = impl::get_or_default_shaderFloat64<device_capabilities>::value;
+    NBL_CONSTEXPR_STATIC_INLINE bool shaderDrawParameters                         = impl::get_or_default_shaderDrawParameters<device_capabilities>::value;
+    NBL_CONSTEXPR_STATIC_INLINE bool subgroupArithmetic                           = impl::get_or_default_subgroupArithmetic<device_capabilities>::value;
+    NBL_CONSTEXPR_STATIC_INLINE bool fragmentShaderPixelInterlock                 = impl::get_or_default_fragmentShaderPixelInterlock<device_capabilities>::value;
+    NBL_CONSTEXPR_STATIC_INLINE uint16_t maxOptimallyResidentWorkgroupInvocations = impl::get_or_default_maxOptimallyResidentWorkgroupInvocations<device_capabilities>::value;
 };
+
+#undef NBL_GENERATE_GET_OR_DEFAULT
+
 }
 }
 #endif
diff --git a/include/nbl/builtin/hlsl/member_test_macros.hlsl b/include/nbl/builtin/hlsl/member_test_macros.hlsl
@@ -5,6 +5,7 @@
 #define _NBL_BUILTIN_HLSL_MEMBER_TEST_MACROS_INCLUDED_
 
 #include <nbl/builtin/hlsl/type_traits.hlsl>
+#include <boost/preprocessor.hpp>
 
 #ifdef __HLSL_VERSION
 
@@ -16,19 +17,11 @@ namespace hlsl
 namespace impl
 {
 
-template<class T, bool C>
-struct is_const_helper : bool_constant<C>
-{
-    using type = T;
-    NBL_CONSTEXPR_STATIC_INLINE bool is_constant = is_const<T>::value;
-};
-
 enum e_member_presence
 {
-    absent = 0,
-    non_static = 1,
-    as_static = 2,
-    static_constexpr = 3,
+    is_present = 1<<0,
+    is_static  = 1<<1,
+    is_const   = 1<<2,
 };
 
 template<class T>
@@ -54,16 +47,17 @@ namespace hlsl \
 { \
 namespace impl { \
 template<class T, class=void>  \
-struct is_static_member_##a: false_type {NBL_CONSTEXPR_STATIC_INLINE bool is_constant = false; }; \
+struct is_static_member_##a: false_type { }; \
 template<class T>  \
-struct is_static_member_##a<T,typename enable_if<!is_same<decltype(T::a),void>::value,void>::type>: is_const_helper<decltype(T::a), true> {}; \
+struct is_static_member_##a<T,typename enable_if<!is_same<decltype(T::a),void>::value,void>::type> : true_type {  }; \
 template<class T, class=void> \
-struct is_member_##a: false_type {NBL_CONSTEXPR_STATIC_INLINE bool is_constant = false;}; \
+struct is_member_##a: false_type { using type = void; }; \
 template<class T> \
-struct is_member_##a<T,typename enable_if<!is_same<decltype(declval<T>().a),void>::value,void>::type> : is_const_helper<decltype(declval<T>().a), true>{}; \
+struct is_member_##a<T,typename enable_if<!is_same<decltype(declval<T>().a),void>::value,void>::type> : true_type { using type = decltype(declval<T>().a); }; \
 } \
 template<class T> \
-struct has_member_##a {  NBL_CONSTEXPR_STATIC_INLINE e_member_presence value = (e_member_presence)(impl::is_member_##a<T>::value + impl::is_static_member_##a<T>::value + impl::is_static_member_##a<T>::is_constant); }; \
+struct has_member_##a {  NBL_CONSTEXPR_STATIC_INLINE e_member_presence value = (e_member_presence)(impl::is_member_##a<T>::value + 2*impl::is_static_member_##a<T>::value + 4*is_const<typename impl::is_member_##a<T>::type>::value); }; \
+template<class T, class F> struct has_member_##a##_with_type : bool_constant<has_member_##a<T>::value && is_same<typename impl::is_member_##a<T>::type, F>::value> {}; \
 } \
 }
 
@@ -74,60 +68,30 @@ NBL_GENERATE_MEMBER_TESTER(z)
 NBL_GENERATE_MEMBER_TESTER(w)
 
 
-// Even though it should work for some reason tests fail
-// proof it works : https://godbolt.org/z/EzPWGnTPb
 
-#define CAT(x, y) x##y
-#define TYPE_DECLARE(n) typename Arg##n
-#define TYPE_DECLARE_DEFAULT(n) TYPE_DECLARE(n)=void
-#define TYPE_FWD(n) Arg##n
-#define DECLVAL_DECLARE(n) impl::declval<Arg##n>()
-
-#define FOR_EACH0(fn)  
-#define FOR_EACH1(fn) fn(1)
-#define FOR_EACH2(fn) fn(2), FOR_EACH1(fn)
-#define FOR_EACH3(fn) fn(3), FOR_EACH2(fn)
-#define FOR_EACH4(fn) fn(4), FOR_EACH3(fn)
-#define FOR_EACH(fn, n) CAT(FOR_EACH, n)(fn)
-
-#define GENERATE_STATIC_METHOD_TESTER_SPEC0(x) \
-template<class T> \
-struct has_static_method_##x<T, typename make_void<decltype(T::x())>::type> : true_type \
-{ \
-    using return_type = decltype(T::x()); \
-    NBL_CONSTEXPR_STATIC_INLINE uint arg_count = 0; \
-}; 
+#define NBL_TYPE_DECLARE(z, n, x) BOOST_PP_COMMA_IF(x) typename Arg##n
+#define NBL_TYPE_DECLARE_DEFAULT(z, n, x) BOOST_PP_COMMA_IF(x) typename Arg##n=void
+#define NBL_TYPE_FWD(z, n, x) BOOST_PP_COMMA_IF(x) Arg##n
+#define NBL_DECLVAL_DECLARE(z, n, x) impl::declval<Arg##n>() BOOST_PP_COMMA_IF(BOOST_PP_NOT_EQUAL(BOOST_PP_INC(n), x))
 
-#define GENERATE_STATIC_METHOD_TESTER_SPEC(x, n) \
-template<class T, FOR_EACH(TYPE_DECLARE, n)> \
-struct has_static_method_##x<T, FOR_EACH(TYPE_FWD, n), typename make_void<decltype(T::x(FOR_EACH(DECLVAL_DECLARE, n)))>::type> : true_type \
+#define GENERATE_STATIC_METHOD_TESTER_SPEC(z, n, x) \
+template<class T BOOST_PP_REPEAT(n, NBL_TYPE_DECLARE, n)> \
+struct has_static_method_##x<T BOOST_PP_REPEAT(n, NBL_TYPE_FWD, n), typename make_void<decltype(T::x(BOOST_PP_REPEAT(n, NBL_DECLVAL_DECLARE, n)))>::type> : true_type \
 { \
-    using return_type = decltype(T::x(FOR_EACH(DECLVAL_DECLARE, n))); \
+    using return_type = decltype(T::x(BOOST_PP_REPEAT(n, NBL_DECLVAL_DECLARE, n))); \
     NBL_CONSTEXPR_STATIC_INLINE uint arg_count = n; \
 }; 
 
-#define GENERATE_STATIC_METHOD_TESTER(x) \
-template<typename T, FOR_EACH(TYPE_DECLARE_DEFAULT, 4), class=void> \
+#define GENERATE_STATIC_METHOD_TESTER(x, n) \
+template<typename T BOOST_PP_REPEAT(n, NBL_TYPE_DECLARE_DEFAULT, n), class=void> \
 struct has_static_method_##x : false_type {}; \
-GENERATE_STATIC_METHOD_TESTER_SPEC0(x)  \
-GENERATE_STATIC_METHOD_TESTER_SPEC(x, 1)  \
-GENERATE_STATIC_METHOD_TESTER_SPEC(x, 2)  \
-GENERATE_STATIC_METHOD_TESTER_SPEC(x, 3)  \
-GENERATE_STATIC_METHOD_TESTER_SPEC(x, 4) 
-
-#define GENERATE_METHOD_TESTER_SPEC0(x) \
-template<class T> \
-struct has_method_##x<T, typename make_void<decltype(impl::declval<T>().x())>::type> : impl::if_2_else_1<impl::has_static_method_##x<T>::value> \
-{ \
-    using return_type = decltype(impl::declval<T>().x()); \
-    NBL_CONSTEXPR_STATIC_INLINE uint arg_count = 0; \
-}; 
+BOOST_PP_REPEAT(n, GENERATE_STATIC_METHOD_TESTER_SPEC, x)
 
-#define GENERATE_METHOD_TESTER_SPEC(x, n) \
-template<class T, FOR_EACH(TYPE_DECLARE, n)> \
-struct has_method_##x<T, FOR_EACH(TYPE_FWD, n), typename make_void<decltype(impl::declval<T>().x(FOR_EACH(DECLVAL_DECLARE, n)))>::type> : impl::if_2_else_1<impl::has_static_method_##x<T,FOR_EACH(TYPE_FWD, n)>::value> \
+#define GENERATE_METHOD_TESTER_SPEC(z, n, x) \
+template<class T BOOST_PP_REPEAT(n, NBL_TYPE_DECLARE, n)> \
+struct has_method_##x<T BOOST_PP_REPEAT(n, NBL_TYPE_FWD, n), typename make_void<decltype(impl::declval<T>().x(BOOST_PP_REPEAT(n, NBL_DECLVAL_DECLARE, n)))>::type> : impl::if_2_else_1<impl::has_static_method_##x<T BOOST_PP_REPEAT(n, NBL_TYPE_FWD, n)>::value> \
 { \
-    using return_type = decltype(impl::declval<T>().x(FOR_EACH(DECLVAL_DECLARE, n))); \
+    using return_type = decltype(impl::declval<T>().x(BOOST_PP_REPEAT(n, NBL_DECLVAL_DECLARE, n))); \
     NBL_CONSTEXPR_STATIC_INLINE uint arg_count = n; \
 }; 
 
@@ -147,14 +111,10 @@ struct has_method_##x<T, FOR_EACH(TYPE_FWD, n), typename make_void<decltype(impl
 #define GENERATE_METHOD_TESTER(x) \
 namespace nbl { \
 namespace hlsl { \
-namespace impl { GENERATE_STATIC_METHOD_TESTER(x) } \
-template<typename T, FOR_EACH(TYPE_DECLARE_DEFAULT, 4), class=void> \
+namespace impl { GENERATE_STATIC_METHOD_TESTER(x, 4) } \
+template<typename T BOOST_PP_REPEAT(4, NBL_TYPE_DECLARE_DEFAULT, 4), class=void> \
 struct has_method_##x : false_type {}; \
-GENERATE_METHOD_TESTER_SPEC0(x) \
-GENERATE_METHOD_TESTER_SPEC(x, 1) \
-GENERATE_METHOD_TESTER_SPEC(x, 2) \
-GENERATE_METHOD_TESTER_SPEC(x, 3) \
-GENERATE_METHOD_TESTER_SPEC(x, 4) \
+BOOST_PP_REPEAT(4, GENERATE_METHOD_TESTER_SPEC, x) \
 }}
 
 
diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl
@@ -18,7 +18,6 @@ template<typename T>
 [[vk::ext_instruction( spv::OpGroupNonUniformShuffle )]]
 T groupShuffle(uint32_t executionScope, T value, uint32_t invocationId);
 
-#ifdef NBL_GL_KHR_shader_subgroup_shuffle_relative
 template<typename T>
 [[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]]
 [[vk::ext_instruction( spv::OpGroupNonUniformShuffleUp )]]
@@ -28,7 +27,7 @@ template<typename T>
 [[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]]
 [[vk::ext_instruction( spv::OpGroupNonUniformShuffleDown )]]
 T groupShuffleDown(uint32_t executionScope, T value, uint32_t delta);
-#endif
+
 }
 }
 }
diff --git a/include/nbl/builtin/hlsl/subgroup/arithmetic_portability.hlsl b/include/nbl/builtin/hlsl/subgroup/arithmetic_portability.hlsl
@@ -5,10 +5,10 @@
 #define _NBL_BUILTIN_HLSL_SUBGROUP_ARITHMETIC_PORTABILITY_INCLUDED_
 
 
-#include "nbl/builtin/hlsl/subgroup/basic.hlsl"
+#include "nbl/builtin/hlsl/device_capabilities_traits.hlsl"
 
+#include "nbl/builtin/hlsl/subgroup/basic.hlsl"
 #include "nbl/builtin/hlsl/subgroup/arithmetic_portability_impl.hlsl"
-#include "nbl/builtin/hlsl/jit/device_capabilities.hlsl"
 
 
 namespace nbl
@@ -18,16 +18,12 @@ namespace hlsl
 namespace subgroup
 {
 
-// TODO: change to alias using template when DXC finally fixes SPIR-V codegen impartity
-//template<class Binop, class device_capability_traits/*=TODO: Atil give us the traits so we can default with `void`!*/>
-//struct reduction : impl::reduction<Binop,device_capability_traits::subgroupArithmetic> {};
-
-template<class Binop>
-struct reduction : impl::reduction<Binop,nbl::hlsl::jit::device_capabilities::subgroupArithmetic> {};
-template<class Binop>
-struct inclusive_scan : impl::inclusive_scan<Binop,nbl::hlsl::jit::device_capabilities::subgroupArithmetic> {};
-template<class Binop>
-struct exclusive_scan : impl::exclusive_scan<Binop,nbl::hlsl::jit::device_capabilities::subgroupArithmetic> {};
+template<class Binop, class device_capabilities=void>
+struct reduction : impl::reduction<Binop,device_capabilities_traits<device_capabilities>::subgroupArithmetic> {};
+template<class Binop, class device_capabilities=void>
+struct inclusive_scan : impl::inclusive_scan<Binop,device_capabilities_traits<device_capabilities>::subgroupArithmetic> {};
+template<class Binop, class device_capabilities=void>
+struct exclusive_scan : impl::exclusive_scan<Binop,device_capabilities_traits<device_capabilities>::subgroupArithmetic> {};
 
 }
 }
diff --git a/include/nbl/builtin/hlsl/workgroup/arithmetic.hlsl b/include/nbl/builtin/hlsl/workgroup/arithmetic.hlsl
@@ -22,43 +22,43 @@ namespace workgroup
 //#define NBL_ALIAS_CALL_OPERATOR_TO_STATIC_IMPL(OPTIONAL_TEMPLATE,RETURN_TYPE,/*tuples of argument types and names*/...)
 //#define NBL_ALIAS_TEMPLATED_CALL_OPERATOR_TO_IMPL(TEMPLATE,RETURN_TYPE,/*tuples of argument types and names*/...)
 
-template<class BinOp, uint16_t ItemCount>
+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>
 struct reduction
 {
     using type_t = typename BinOp::type_t;
 
     template<class Accessor>
     static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)
     {
-        impl::reduce<BinOp,ItemCount> fn;
+        impl::reduce<BinOp,ItemCount,device_capabilities> fn;
         fn.template __call<Accessor>(value,accessor);
         accessor.workgroupExecutionAndMemoryBarrier();
         return Broadcast<type_t,Accessor>(fn.lastLevelScan,accessor,fn.lastInvocationInLevel);
     }
 };
 
-template<class BinOp, uint16_t ItemCount>
+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>
 struct inclusive_scan
 {
     using type_t = typename BinOp::type_t;
 
     template<class Accessor>
     static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)
     {
-        impl::scan<BinOp,false,ItemCount> fn;
+        impl::scan<BinOp,false,ItemCount,device_capabilities> fn;
         return fn.template __call<Accessor>(value,accessor);
     }
 };
 
-template<class BinOp, uint16_t ItemCount>
+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>
 struct exclusive_scan
 {
     using type_t = typename BinOp::type_t;
 
     template<class Accessor>
     static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)
     {
-        impl::scan<BinOp,true,ItemCount> fn;
+        impl::scan<BinOp,true,ItemCount,device_capabilities> fn;
         return fn.template __call<Accessor>(value,accessor);
     }
 };
@@ -94,15 +94,15 @@ uint16_t ballotCountedBitDWORD(NBL_REF_ARG(BallotAccessor) ballotAccessor)
     return 0;
 }
 
-template<bool Exclusive, uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>
+template<bool Exclusive, uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities>
 uint16_t ballotScanBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)
 {
     const uint16_t subgroupIndex = SubgroupContiguousIndex();
     const uint16_t bitfieldIndex = impl::getDWORD(subgroupIndex);
     const uint32_t localBitfield = ballotAccessor.get(bitfieldIndex);
 
     static const uint16_t DWORDCount = impl::ballot_dword_count<ItemCount>::value;
-    uint32_t count = exclusive_scan<plus<uint32_t>,DWORDCount>::template __call<ArithmeticAccessor>(
+    uint32_t count = exclusive_scan<plus<uint32_t>,DWORDCount,device_capabilities>::template __call<ArithmeticAccessor>(
         ballotCountedBitDWORD<ItemCount,BallotAccessor>(ballotAccessor),
         arithmeticAccessor
     );
@@ -115,26 +115,26 @@ uint16_t ballotScanBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_
 }
 }
 
-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>
+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>
 uint16_t ballotBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)
 {
     static const uint16_t DWORDCount = impl::ballot_dword_count<ItemCount>::value;
-    return uint16_t(reduction<plus<uint32_t>,DWORDCount>::template __call<ArithmeticAccessor>(
+    return uint16_t(reduction<plus<uint32_t>,DWORDCount,device_capabilities>::template __call<ArithmeticAccessor>(
         impl::ballotCountedBitDWORD<ItemCount,BallotAccessor>(ballotAccessor),
         arithmeticAccessor
     ));
 }
 
-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>
+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>
 uint16_t ballotInclusiveBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)
 {
-    return impl::ballotScanBitCount<false,ItemCount,BallotAccessor,ArithmeticAccessor>(ballotAccessor,arithmeticAccessor);
+    return impl::ballotScanBitCount<false,ItemCount,BallotAccessor,ArithmeticAccessor,device_capabilities>(ballotAccessor,arithmeticAccessor);
 }
 
-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>
+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>
 uint16_t ballotExclusiveBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)
 {
-    return impl::ballotScanBitCount<true,ItemCount,BallotAccessor,ArithmeticAccessor>(ballotAccessor,arithmeticAccessor);
+    return impl::ballotScanBitCount<true,ItemCount,BallotAccessor,ArithmeticAccessor,device_capabilities>(ballotAccessor,arithmeticAccessor);
 }
 
 }
diff --git a/include/nbl/builtin/hlsl/workgroup/shared_scan.hlsl b/include/nbl/builtin/hlsl/workgroup/shared_scan.hlsl
@@ -18,7 +18,7 @@ namespace workgroup
 
 namespace impl
 {
-template<class BinOp, uint16_t ItemCount>
+template<class BinOp, uint16_t ItemCount, class device_capabilities>
 struct reduce
 {
     using type_t = typename BinOp::type_t;
@@ -29,7 +29,7 @@ struct reduce
         const uint16_t lastInvocation = ItemCount-1;
         const uint16_t subgroupMask = uint16_t(glsl::gl_SubgroupSize()-1u);
 
-        subgroup::inclusive_scan<BinOp> subgroupOp;
+        subgroup::inclusive_scan<BinOp,device_capabilities> subgroupOp;
 
         lastInvocationInLevel = lastInvocation;
         scanLoadIndex = SubgroupContiguousIndex();
@@ -78,10 +78,10 @@ struct reduce
     bool participate;
 };
 
-template<class BinOp, bool Exclusive, uint16_t ItemCount>
+template<class BinOp, bool Exclusive, uint16_t ItemCount, class device_capabilities>
 struct scan// : reduce<BinOp,ItemCount> https://github.com/microsoft/DirectXShaderCompiler/issues/5966
 {
-    using base_t = reduce<BinOp,ItemCount>;
+    using base_t = reduce<BinOp,ItemCount,device_capabilities>;
     base_t __base;
     using type_t = typename base_t::type_t;
 

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ template<typename T>`
`18`	`18`	`[[vk::ext_instruction( spv::OpGroupNonUniformShuffle )]]`
`19`	`19`	`T groupShuffle(uint32_t executionScope, T value, uint32_t invocationId);`
`20`	`20`
`21`		`-#ifdef NBL_GL_KHR_shader_subgroup_shuffle_relative`
`22`	`21`	`template<typename T>`
`23`	`22`	`[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]]`
`24`	`23`	`[[vk::ext_instruction( spv::OpGroupNonUniformShuffleUp )]]`
`@@ -28,7 +27,7 @@ template<typename T>`
`28`	`27`	`[[vk::ext_capability( spv::CapabilityGroupNonUniformShuffleRelative )]]`
`29`	`28`	`[[vk::ext_instruction( spv::OpGroupNonUniformShuffleDown )]]`
`30`	`29`	`T groupShuffleDown(uint32_t executionScope, T value, uint32_t delta);`
`31`		`-#endif`
	`30`	`+`
`32`	`31`	`}`
`33`	`32`	`}`
`34`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,43 +22,43 @@ namespace workgroup`
`22`	`22`	`//#define NBL_ALIAS_CALL_OPERATOR_TO_STATIC_IMPL(OPTIONAL_TEMPLATE,RETURN_TYPE,/tuples of argument types and names/...)`
`23`	`23`	`//#define NBL_ALIAS_TEMPLATED_CALL_OPERATOR_TO_IMPL(TEMPLATE,RETURN_TYPE,/tuples of argument types and names/...)`
`24`	`24`
`25`		`-template<class BinOp, uint16_t ItemCount>`
	`25`	`+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>`
`26`	`26`	`struct reduction`
`27`	`27`	`{`
`28`	`28`	`using type_t = typename BinOp::type_t;`
`29`	`29`
`30`	`30`	`template<class Accessor>`
`31`	`31`	`static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)`
`32`	`32`	`{`
`33`		`- impl::reduce<BinOp,ItemCount> fn;`
	`33`	`+ impl::reduce<BinOp,ItemCount,device_capabilities> fn;`
`34`	`34`	`fn.template __call<Accessor>(value,accessor);`
`35`	`35`	`accessor.workgroupExecutionAndMemoryBarrier();`
`36`	`36`	`return Broadcast<type_t,Accessor>(fn.lastLevelScan,accessor,fn.lastInvocationInLevel);`
`37`	`37`	`}`
`38`	`38`	`};`
`39`	`39`
`40`		`-template<class BinOp, uint16_t ItemCount>`
	`40`	`+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>`
`41`	`41`	`struct inclusive_scan`
`42`	`42`	`{`
`43`	`43`	`using type_t = typename BinOp::type_t;`
`44`	`44`
`45`	`45`	`template<class Accessor>`
`46`	`46`	`static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)`
`47`	`47`	`{`
`48`		`- impl::scan<BinOp,false,ItemCount> fn;`
	`48`	`+ impl::scan<BinOp,false,ItemCount,device_capabilities> fn;`
`49`	`49`	`return fn.template __call<Accessor>(value,accessor);`
`50`	`50`	`}`
`51`	`51`	`};`
`52`	`52`
`53`		`-template<class BinOp, uint16_t ItemCount>`
	`53`	`+template<class BinOp, uint16_t ItemCount, class device_capabilities=void>`
`54`	`54`	`struct exclusive_scan`
`55`	`55`	`{`
`56`	`56`	`using type_t = typename BinOp::type_t;`
`57`	`57`
`58`	`58`	`template<class Accessor>`
`59`	`59`	`static type_t __call(NBL_CONST_REF_ARG(type_t) value, NBL_REF_ARG(Accessor) accessor)`
`60`	`60`	`{`
`61`		`- impl::scan<BinOp,true,ItemCount> fn;`
	`61`	`+ impl::scan<BinOp,true,ItemCount,device_capabilities> fn;`
`62`	`62`	`return fn.template __call<Accessor>(value,accessor);`
`63`	`63`	`}`
`64`	`64`	`};`
`@@ -94,15 +94,15 @@ uint16_t ballotCountedBitDWORD(NBL_REF_ARG(BallotAccessor) ballotAccessor)`
`94`	`94`	`return 0;`
`95`	`95`	`}`
`96`	`96`
`97`		`-template<bool Exclusive, uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>`
	`97`	`+template<bool Exclusive, uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities>`
`98`	`98`	`uint16_t ballotScanBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)`
`99`	`99`	`{`
`100`	`100`	`const uint16_t subgroupIndex = SubgroupContiguousIndex();`
`101`	`101`	`const uint16_t bitfieldIndex = impl::getDWORD(subgroupIndex);`
`102`	`102`	`const uint32_t localBitfield = ballotAccessor.get(bitfieldIndex);`
`103`	`103`
`104`	`104`	`static const uint16_t DWORDCount = impl::ballot_dword_count<ItemCount>::value;`
`105`		`- uint32_t count = exclusive_scan<plus<uint32_t>,DWORDCount>::template __call<ArithmeticAccessor>(`
	`105`	`+ uint32_t count = exclusive_scan<plus<uint32_t>,DWORDCount,device_capabilities>::template __call<ArithmeticAccessor>(`
`106`	`106`	`ballotCountedBitDWORD<ItemCount,BallotAccessor>(ballotAccessor),`
`107`	`107`	`arithmeticAccessor`
`108`	`108`	`);`
`@@ -115,26 +115,26 @@ uint16_t ballotScanBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>`
	`118`	`+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>`
`119`	`119`	`uint16_t ballotBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)`
`120`	`120`	`{`
`121`	`121`	`static const uint16_t DWORDCount = impl::ballot_dword_count<ItemCount>::value;`
`122`		`- return uint16_t(reduction<plus<uint32_t>,DWORDCount>::template __call<ArithmeticAccessor>(`
	`122`	`+ return uint16_t(reduction<plus<uint32_t>,DWORDCount,device_capabilities>::template __call<ArithmeticAccessor>(`
`123`	`123`	`impl::ballotCountedBitDWORD<ItemCount,BallotAccessor>(ballotAccessor),`
`124`	`124`	`arithmeticAccessor`
`125`	`125`	`));`
`126`	`126`	`}`
`127`	`127`
`128`		`-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>`
	`128`	`+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>`
`129`	`129`	`uint16_t ballotInclusiveBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)`
`130`	`130`	`{`
`131`		`- return impl::ballotScanBitCount<false,ItemCount,BallotAccessor,ArithmeticAccessor>(ballotAccessor,arithmeticAccessor);`
	`131`	`+ return impl::ballotScanBitCount<false,ItemCount,BallotAccessor,ArithmeticAccessor,device_capabilities>(ballotAccessor,arithmeticAccessor);`
`132`	`132`	`}`
`133`	`133`
`134`		`-template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor>`
	`134`	`+template<uint16_t ItemCount, class BallotAccessor, class ArithmeticAccessor, class device_capabilities=void>`
`135`	`135`	`uint16_t ballotExclusiveBitCount(NBL_REF_ARG(BallotAccessor) ballotAccessor, NBL_REF_ARG(ArithmeticAccessor) arithmeticAccessor)`
`136`	`136`	`{`
`137`		`- return impl::ballotScanBitCount<true,ItemCount,BallotAccessor,ArithmeticAccessor>(ballotAccessor,arithmeticAccessor);`
	`137`	`+ return impl::ballotScanBitCount<true,ItemCount,BallotAccessor,ArithmeticAccessor,device_capabilities>(ballotAccessor,arithmeticAccessor);`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`}`