baked kernel compression - improve coding

Author: RichardGe

Orochi/OrochiUtils.cpp

@@ -794,35 +794,45 @@ void OrochiUtils::launch2D( oroFunction func, int nx, int ny, const void** args,
 	OROASSERT( e == oroSuccess, 0 );
 }
 
-void OrochiUtils::DecompressPrecompiled(std::vector<unsigned char>& out, const unsigned char* compressedInput, size_t compressedInput_sizeByte, size_t uncompressed_sizeByte)
+void OrochiUtils::HandlePrecompiled(std::vector<unsigned char>& out, const CompressedBuffer& buffer)
 {
-	if ( uncompressed_sizeByte > 0 ) // if the input data is actually compressed
-	{
 	#ifdef ORO_LINK_ZSTD
-		out.assign(uncompressed_sizeByte,0);
+		out.assign(buffer.uncompressedSize,0);
 
 		size_t decompressedSize = ZSTD_decompress(    
 			out.data(), // final uncompressed buffer
 			out.size(), // final size
-			compressedInput, // compressed buffer
-			compressedInput_sizeByte // compressed buffer - size
+			buffer.data, // compressed buffer
+			buffer.size // compressed buffer - size
 			);
 
-		if ( decompressedSize != uncompressed_sizeByte )
+		if ( decompressedSize != buffer.uncompressedSize )
 			throw std::runtime_error( "ERROR: ZSTD_decompress FAILED." );
 	#else
-
 		throw std::runtime_error( "ERROR: ZSTD is not part of this build." );
-
 	#endif
+	return;
+}
 
-	}
-	else // if the input data is NOT compressed, buypass this decompress process.
-	{
-		out = std::vector<unsigned char>(compressedInput, compressedInput + compressedInput_sizeByte );
-	}
+
+void OrochiUtils::HandlePrecompiled(std::vector<unsigned char>& out, const RawBuffer& buffer)
+{
+	out = std::vector<unsigned char>(buffer.data, buffer.data + buffer.size );
 	return;
 }
 
 
+void OrochiUtils::HandlePrecompiled(std::vector<unsigned char>& out, const unsigned char* rawData, size_t rawData_sizeByte, std::optional<size_t> uncompressed_sizeByte)
+{
+	if (uncompressed_sizeByte.has_value()) {
+		// if the input buffer is compressed :
+		CompressedBuffer buffer{ rawData, rawData_sizeByte, uncompressed_sizeByte.value() };
+		HandlePrecompiled(out, buffer );
+	} else {
+		// if the input buffer is not compressed
+		RawBuffer buffer{ rawData, rawData_sizeByte };
+		HandlePrecompiled(out, buffer );
+	}
+}
+
 

Orochi/OrochiUtils.h

@@ -27,6 +27,7 @@
 #include <filesystem>
 #include <unordered_map>
 #include <vector>
+#include <optional>
 
 #if defined( GNUC )
 #include <signal.h>
@@ -84,8 +85,19 @@ class OrochiUtils
 	static void launch1D( oroFunction func, int nx, const void** args, int wgSize = 64, unsigned int sharedMemBytes = 0, oroStream stream = 0 );
 	static void launch2D( oroFunction func, int nx, int ny, const void** args, int wgSizeX = 8, int wgSizeY = 8, unsigned int sharedMemBytes = 0, oroStream stream = 0 );
 
-	// if 'uncompressed_sizeByte' is set to 0, it means the input value is not compressed and this function will output the raw buffer.
-	static void DecompressPrecompiled(std::vector<unsigned char>& out, const unsigned char* compressedInput, size_t compressedInput_sizeByte, size_t uncompressed_sizeByte);
+
+	struct CompressedBuffer {
+		const unsigned char* data = nullptr; // compressed data
+		size_t size = 0; // size in byte of 'data'
+		size_t uncompressedSize = 0; // size of byte of the uncompressed data.
+	};
+	struct RawBuffer {
+		const unsigned char* data = nullptr;
+		size_t size = 0;
+	};
+	static void HandlePrecompiled(std::vector<unsigned char>& out, const CompressedBuffer& buffer);
+	static void HandlePrecompiled(std::vector<unsigned char>& out, const RawBuffer& buffer);
+	static void HandlePrecompiled(std::vector<unsigned char>& out, const unsigned char* rawData, size_t rawData_sizeByte, std::optional<size_t> uncompressed_sizeByte=std::nullopt);
 
 	template<typename T>
 	static void malloc( T*& ptr, size_t n )

ParallelPrimitives/RadixSort.cpp

@@ -55,6 +55,7 @@ static const char** RadixSortKernelsIncludes = nullptr;
 const unsigned char oro_compiled_kernels_h[] = "";
 const size_t oro_compiled_kernels_h_size = 0;
 const size_t oro_compiled_kernels_h_size_uncompressed = 0;
+const bool oro_compiled_kernels_h_isCompressed = false;
 #endif
 
 constexpr uint64_t div_round_up64( uint64_t val, uint64_t divisor ) noexcept { return ( val + divisor - 1 ) / divisor; }
@@ -191,7 +192,7 @@ void RadixSort::compileKernels( const std::string& kernelPath, const std::string
 		if constexpr( usePrecompiledAndBakedKernel )
 		{
 			std::vector<unsigned char> binary;
-			OrochiUtils::DecompressPrecompiled(binary, oro_compiled_kernels_h, oro_compiled_kernels_h_size, oro_compiled_kernels_h_size_uncompressed);
+			OrochiUtils::HandlePrecompiled(binary, oro_compiled_kernels_h, oro_compiled_kernels_h_size, oro_compiled_kernels_h_isCompressed ? std::optional<size_t>{oro_compiled_kernels_h_size_uncompressed} : std::nullopt);
 			oroFunctions[record.kernelType] = m_oroutils.getFunctionFromPrecompiledBinary_asData(binary.data(), binary.size(), record.kernelName.c_str() );
 		}
 		else if constexpr( useBakeKernel )

scripts/convert_binary_to_array.py

@@ -10,9 +10,17 @@ def binary_to_c_array(bin_file, array_name, size_BeforeCompression, compression_
     c_array = f'const unsigned char {array_name}[] = {{\n    {hex_array}\n}};\n'
     c_array += f'const size_t {array_name}_size = sizeof({array_name}); // {len(binary_data)}\n'
 
-    if not compression_activated:
-        size_BeforeCompression = 0 # set value to 0 if we are not using compression.
-    c_array += f'const size_t {array_name}_size_uncompressed = {size_BeforeCompression}; // set to 0 if NOT using the ZSTD compression.\n'
+    c_array += f'const size_t {array_name}_size_uncompressed = '
+    if compression_activated:
+        c_array += f'{size_BeforeCompression}; // size of the data in bytes, once it has been uncompressed.\n'
+    else:
+        c_array += f'{array_name}_size; // same than raw buffer, because data is not compressed.\n'
+
+    c_array += f'const bool   {array_name}_isCompressed = '
+    if compression_activated:
+        c_array += f'true;\n'
+    else:
+        c_array += f'false;\n'
     return c_array
 
 if __name__ == "__main__":