Updating compilation options

Author: meistdan

ParallelPrimitives/RadixSort.cpp

@@ -5,40 +5,66 @@
 #include <iostream>
 #include <numeric>
 
-#if defined( ORO_PP_LOAD_FROM_STRING )
-
+// if ORO_PP_LOAD_FROM_STRING &&     ORO_PRECOMPILED -> we load the precompiled/baked kernels.
+// if ORO_PP_LOAD_FROM_STRING && NOT ORO_PRECOMPILED -> we load the baked source code kernels (from Kernels.h / KernelArgs.h)
+#if !defined( ORO_PRECOMPILED ) && defined( ORO_PP_LOAD_FROM_STRING )
 // Note: the include order must be in this particular form.
 // clang-format off
 #include <ParallelPrimitives/cache/Kernels.h>
 #include <ParallelPrimitives/cache/KernelArgs.h>
 // clang-format on
+#else
+// if Kernels.h / KernelArgs.h are not included, declare nullptr strings
+static const char* hip_RadixSortKernels = nullptr;
+namespace hip
+{
+static const char** RadixSortKernelsArgs = nullptr;
+static const char** RadixSortKernelsIncludes = nullptr;
+} // namespace hip
 #endif
 
 #if defined( __GNUC__ )
 #include <dlfcn.h>
 #endif
 
+#if defined( ORO_PRECOMPILED ) && defined( ORO_PP_LOAD_FROM_STRING )
+#include <ParallelPrimitives/cache/oro_compiled_kernels.h> // generate this header with 'convert_binary_to_array.py'
+#else
+const unsigned char oro_compiled_kernels_h[] = "";
+const size_t oro_compiled_kernels_h_size = 0;
+#endif
+
 constexpr uint64_t div_round_up64( uint64_t val, uint64_t divisor ) noexcept { return ( val + divisor - 1 ) / divisor; }
 constexpr uint64_t next_multiple64( uint64_t val, uint64_t divisor ) noexcept { return div_round_up64( val, divisor ) * divisor; }
 
 namespace
 {
+
+// if those 2 preprocessors are enabled, this activates the 'usePrecompiledAndBakedKernel' mode.
+#if defined( ORO_PRECOMPILED ) && defined( ORO_PP_LOAD_FROM_STRING )
+
+// this flag means that we bake the precompiled kernels
+constexpr auto usePrecompiledAndBakedKernel = true;
+
+constexpr auto useBitCode = false;
+constexpr auto useBakeKernel = false;
+
+#else
+
+constexpr auto usePrecompiledAndBakedKernel = false;
+
 #if defined( ORO_PRECOMPILED )
-constexpr auto useBitCode = true;
+constexpr auto useBitCode = true;	 // this flag means we use the bitcode file
 #else
 constexpr auto useBitCode = false;
 #endif
 
 #if defined( ORO_PP_LOAD_FROM_STRING )
-constexpr auto useBakeKernel = true;
+constexpr auto useBakeKernel = true; // this flag means we use the HIP source code embeded in the binary ( as a string )
 #else
 constexpr auto useBakeKernel = false;
-static const char* hip_RadixSortKernels = nullptr;
-namespace hip
-{
-static const char** RadixSortKernelsArgs = nullptr;
-static const char** RadixSortKernelsIncludes = nullptr;
-} // namespace hip
+#endif
+
 #endif
 
 static_assert( !( useBitCode && useBakeKernel ), "useBitCode and useBakeKernel cannot coexist" );
@@ -138,11 +164,15 @@ void RadixSort::compileKernels( const std::string& kernelPath, const std::string
 
 	for( const auto& record : records )
 	{
-#if defined( ORO_PP_LOAD_FROM_STRING )
-		oroFunctions[record.kernelType] = oroutils.getFunctionFromString( device, hip_RadixSortKernels, currentKernelPath.c_str(), record.kernelName.c_str(), &opts, 1, hip::RadixSortKernelsArgs, hip::RadixSortKernelsIncludes );
-#else
-
-		if constexpr( useBitCode )
+		if constexpr( usePrecompiledAndBakedKernel ) 
+		{ 
+			oroFunctions[record.kernelType] = m_oroutils.getFunctionFromPrecompiledBinary_asData( oro_compiled_kernels_h, oro_compiled_kernels_h_size, record.kernelName.c_str() ); 
+		}
+		else if constexpr( useBakeKernel )
+		{
+			oroFunctions[record.kernelType] = m_oroutils.getFunctionFromString( m_device, hip_RadixSortKernels, currentKernelPath.c_str(), record.kernelName.c_str(), &opts, 1, hip::RadixSortKernelsArgs, hip::RadixSortKernelsIncludes );
+		}
+		else if constexpr( useBitCode )
 		{
 			oroFunctions[record.kernelType] = m_oroutils.getFunctionFromPrecompiledBinary( binaryPath.c_str(), record.kernelName.c_str() );
 		}
@@ -151,7 +181,6 @@ void RadixSort::compileKernels( const std::string& kernelPath, const std::string
 			oroFunctions[record.kernelType] = m_oroutils.getFunctionFromFile( m_device, currentKernelPath.c_str(), record.kernelName.c_str(), &opts );
 		}
 
-#endif
 		if( m_flags == Flag::LOG )
 		{
 			printKernelInfo( record.kernelName, oroFunctions[record.kernelType] );