Update to 3.0.9df32e7

Author: RichardGe

.clang-format

@@ -2,7 +2,6 @@ BasedOnStyle: LLVM
 IndentWidth: 4
 TabWidth: 4
 UseTab: Always
-BreakBeforeBraces: Custom
 ColumnLimit: 128
 AllowShortBlocksOnASingleLine: false
 AllowShortIfStatementsOnASingleLine: true

.gitignore

@@ -15,3 +15,4 @@ hiprt/cache/Kernels.h
 hiprt/cache/KernelArgs.h
 PUBLIC_OUT/
 hiprt/impl/bvh_build_array.h
+scripts/bitcodes/__pycache__/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "contrib/zstd"]
+	path = contrib/zstd
+	url = https://github.com/facebook/zstd.git

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.19)   # at least 3.19 in order to have the compression-level in Zstd
 project(hiprt)
 
 #
@@ -15,6 +15,7 @@ option(HIPRTEW "Use hiprtew" OFF)
 option(NO_ENCRYPT "Don't encrypt kernel source and binaries" OFF)
 option(NO_UNITTEST "Don't build unit tests" OFF)
 option(HIPRT_PREFER_HIP_5 "Prefer HIP 5" OFF)
+option(COMPILED_COMPRESSION "enable compression of compiled kernels" ON) # this argument is only used if BAKE_COMPILED_KERNEL is enabled -- advised to let it 'ON' as it's the path tested by the HIPRT team.
 
 option(FORCE_DISABLE_CUDA "By default Cuda support is automatically added if a Cuda install is detected. Turn this flag to ON to force Cuda to be disabled." OFF)
 
@@ -388,6 +389,10 @@ set(KERNEL_HIPRT_COMP    "${BASE_OUTPUT_DIR}/${CMAKE_BUILD_TYPE}/hiprt${version_
 set(KERNEL_UNITTEST_COMP "${BASE_OUTPUT_DIR}/${CMAKE_BUILD_TYPE}/hiprt${version_str_}_${HIP_VERSION_STR}_precompiled_bitcode_${KERNEL_OS_POSTFIX}.hipfb")   # example:  hiprt02005_6.2_precompiled_bitcode_win.hipfb
 set(KERNEL_OROCHI_COMP "${BASE_OUTPUT_DIR}/${CMAKE_BUILD_TYPE}/oro_compiled_kernels.hipfb")
 
+# temp files: compiled kernel, compressed.
+set(KERNEL_HIPRT_COMP_COMPRESSED  "${CMAKE_BINARY_DIR}/hiprt${version_str_}_${HIP_VERSION_STR}_amd.zstd" )
+set(KERNEL_OROCHI_COMP_COMPRESSED  "${CMAKE_BINARY_DIR}/oro_compiled_kernels.zstd" )
+
 
 # precompile kernels:
 if(PRECOMPILE)
@@ -479,11 +484,16 @@ if ( BAKE_COMPILED_KERNEL )
 
 	set(PYTHON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Orochi/scripts/convert_binary_to_array.py")
 
+	set(ARCHIVE_SCRIPT  "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Orochi/scripts/create_archive.cmake")
+	
 	# HIPRT binary
 	set(KERNEL_HIPRT_H "${CMAKE_CURRENT_SOURCE_DIR}/hiprt/impl/bvh_build_array.h")
 	add_custom_command(
 		OUTPUT ${KERNEL_HIPRT_H}
-		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_HIPRT_COMP} ${KERNEL_HIPRT_H}
+		# 1) Create the Zstd archive
+		COMMAND	${CMAKE_COMMAND}  -DINPUT_FILE=${KERNEL_HIPRT_COMP} -DOUTPUT_FILE=${KERNEL_HIPRT_COMP_COMPRESSED} -DDO_COMPRESS=${COMPILED_COMPRESSION}  -P ${ARCHIVE_SCRIPT}
+		# 2) Run the Python converter on that archive
+		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_HIPRT_COMP} ${KERNEL_HIPRT_COMP_COMPRESSED} ${KERNEL_HIPRT_H} ${COMPILED_COMPRESSION}
 		DEPENDS ${KERNEL_HIPRT_COMP}  # Ensure compile.py has already run.
 		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
 		COMMENT "Converting HIPRT compiled kernel to header"
@@ -494,7 +504,10 @@ if ( BAKE_COMPILED_KERNEL )
 	set(KERNEL_OROCHI_H "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Orochi/ParallelPrimitives/cache/oro_compiled_kernels.h")
 	add_custom_command(
 		OUTPUT ${KERNEL_OROCHI_H}
-		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_OROCHI_COMP} ${KERNEL_OROCHI_H}
+		# 1) Create the Zstd archive
+		COMMAND	${CMAKE_COMMAND}  -DINPUT_FILE=${KERNEL_OROCHI_COMP} -DOUTPUT_FILE=${KERNEL_OROCHI_COMP_COMPRESSED} -DDO_COMPRESS=${COMPILED_COMPRESSION}  -P ${ARCHIVE_SCRIPT}
+		# 2) Run the Python converter on that archive
+		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_OROCHI_COMP} ${KERNEL_OROCHI_COMP_COMPRESSED} ${KERNEL_OROCHI_H} ${COMPILED_COMPRESSION}
 		DEPENDS ${KERNEL_OROCHI_COMP}  # Ensure compile.py has already run.
 		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
 		COMMENT "Converting Orochi compiled kernel to header"
@@ -533,8 +546,40 @@ endif()
 
 
 if ( BAKE_COMPILED_KERNEL )
+
+
+	if ( COMPILED_COMPRESSION )
+		#  Gather minimal Zstd sources
+		file(GLOB ZSTD_SRCS
+			contrib/zstd/lib/common/*.c
+			contrib/zstd/lib/decompress/*.c
+			)
+
+		#  Build a static lib zstd_embedded
+		add_library(zstd_embedded STATIC
+			${ZSTD_SRCS}
+		)
+
+		#  Include Zstd headers
+		target_include_directories(zstd_embedded
+			PUBLIC
+			contrib/zstd/lib
+		)
+		
+		set_target_properties(zstd_embedded PROPERTIES POSITION_INDEPENDENT_CODE ON)  # -fPIC
+		target_compile_definitions(zstd_embedded PRIVATE ZSTD_DISABLE_ASM)  # disable ASM for easier build
+
+		#  Link against zstd_embedded
+		target_link_libraries(${HIPRT_NAME}   zstd_embedded )
+		
+		# the 'ORO_LINK_ZSTD' flag enables use of ZSTD API in the source code.
+		target_compile_definitions(${HIPRT_NAME} PRIVATE ORO_LINK_ZSTD)
+	endif()
+
+
+
 	# enable the 'BAKE_COMPILED_KERNEL' on Orochi:  this mode is activated by adding those 2 defines.
-	target_compile_definitions(${HIPRT_NAME} PRIVATE ORO_PP_LOAD_FROM_STRING ORO_PRECOMPILED)
+	target_compile_definitions(${HIPRT_NAME} PRIVATE ORO_PP_LOAD_FROM_STRING HIPRT_BITCODE_LINKING ORO_PRECOMPILED)
 
 	#enable the 'BAKE_COMPILED_KERNEL' on HIPRT: 
 	target_compile_definitions(${HIPRT_NAME} PRIVATE HIPRT_BAKE_COMPILED_KERNEL )
@@ -592,12 +637,17 @@ if(PRECOMPILE AND NOT BAKE_COMPILED_KERNEL)
 			DESTINATION bin)
 endif()
 
+
+
+
+
+
 # Project: Unit Test
 if(NOT NO_UNITTEST)
 
 	add_executable(unittest)
 
-	if(BITCODE)
+	if(BITCODE OR BAKE_COMPILED_KERNEL)
 		target_compile_definitions(unittest PRIVATE HIPRT_BITCODE_LINKING)
 	endif()
 	if(WIN32)

contrib/Orochi/Orochi/Orochi.cpp

@@ -1219,6 +1219,21 @@ oroError OROAPI oroCtxGetCurrent(oroCtx* pctx)
 		if ( e != hipSuccess )
 			return hip2oro(e);
 	}
+
+	// externally initialized context 
+	if( s_oroCtxs.count( ctxt->m_ptr ) == 0 && ctxt->m_ptr )
+	{
+		ioroCtx_t* c = new ioroCtx_t;
+		c->m_ptr = ctxt->m_ptr;
+		c->setApi( s_api );
+		s_oroCtxs[ctxt->m_ptr] = c;
+	}
+
+	if (s_oroCtxs.count(ctxt->m_ptr) == 0)
+	{
+		return oroErrorNotReady;
+	}
+
 	( *pctx ) = s_oroCtxs[ctxt->m_ptr];
 	delete ctxt;
 	return oroSuccess;
@@ -2627,11 +2642,11 @@ oroError_t OROAPI oroModuleLaunchCooperativeKernelMultiDevice(oroFunctionLaunchP
 		hipModuleLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags)     );
 	return oroErrorUnknown;
 }
-oroError_t OROAPI oroModuleLaunchKernel(oroFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, oroStream_t stream, void ** kernelParams, void ** extra)
+oroError_t OROAPI oroModuleLaunchKernel(oroFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, oroStream_t stream, const void* const* kernelParams, const void* const* extra)
 {
 	__ORO_FUNC(
 		CU4ORO::hipModuleLaunchKernel_cu4oro(__ORO_FORCE_CAST(CU4ORO::hipFunction_t,f), __ORO_FORCE_CAST(unsigned int,gridDimX), __ORO_FORCE_CAST(unsigned int,gridDimY), __ORO_FORCE_CAST(unsigned int,gridDimZ), __ORO_FORCE_CAST(unsigned int,blockDimX), __ORO_FORCE_CAST(unsigned int,blockDimY), __ORO_FORCE_CAST(unsigned int,blockDimZ), __ORO_FORCE_CAST(unsigned int,sharedMemBytes), __ORO_FORCE_CAST(CU4ORO::hipStream_t,stream), __ORO_FORCE_CAST(void **,kernelParams), __ORO_FORCE_CAST(void **,extra)),
-		hipModuleLaunchKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, stream, kernelParams, extra)     );
+		hipModuleLaunchKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, stream, __ORO_FORCE_CAST(void**, kernelParams), __ORO_FORCE_CAST(void**, extra))     );
 	return oroErrorUnknown;
 }
 oroError_t OROAPI oroModuleLoad(oroModule_t * module, const char * fname)

contrib/Orochi/Orochi/Orochi.h

@@ -991,7 +991,7 @@ oroError_t OROAPI oroModuleGetGlobal(oroDeviceptr_t * dptr, size_t * bytes, oroM
 oroError_t OROAPI oroModuleGetTexRef(textureReference ** texRef, oroModule_t hmod, const char * name);
 oroError_t OROAPI oroModuleLaunchCooperativeKernel(oroFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, oroStream_t stream, void ** kernelParams);
 oroError_t OROAPI oroModuleLaunchCooperativeKernelMultiDevice(oroFunctionLaunchParams * launchParamsList, unsigned int numDevices, unsigned int flags);
-oroError_t OROAPI oroModuleLaunchKernel(oroFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, oroStream_t stream, void ** kernelParams, void ** extra);
+oroError_t OROAPI oroModuleLaunchKernel(oroFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, oroStream_t stream, const void* const* kernelParams, const void* const* extra);
 oroError_t OROAPI oroModuleLoad(oroModule_t * module, const char * fname);
 oroError_t OROAPI oroModuleLoadData(oroModule_t * module, const void * image);
 oroError_t OROAPI oroModuleLoadDataEx(oroModule_t * module, const void * image, unsigned int numOptions, oroJitOption * options, void ** optionValues);

contrib/Orochi/Orochi/OrochiUtils.cpp

@@ -36,6 +36,10 @@
 #include <sys/stat.h>
 #endif
 
+#ifdef ORO_LINK_ZSTD
+#include <contrib/zstd/lib/zstd.h>
+#endif
+
 inline std::wstring utf8_to_wstring( const std::string& str )
 {
 	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> myconv;
@@ -790,3 +794,45 @@ void OrochiUtils::launch2D( oroFunction func, int nx, int ny, const void** args,
 	OROASSERT( e == oroSuccess, 0 );
 }
 
+void OrochiUtils::HandlePrecompiled(std::vector<unsigned char>& out, const CompressedBuffer& buffer)
+{
+	#ifdef ORO_LINK_ZSTD
+		out.assign(buffer.uncompressedSize,0);
+
+		size_t decompressedSize = ZSTD_decompress(    
+			out.data(), // final uncompressed buffer
+			out.size(), // final size
+			buffer.data, // compressed buffer
+			buffer.size // compressed buffer - size
+			);
+		
+		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;
+}
+
+
+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 );
+	}
+}
+
+

contrib/Orochi/Orochi/OrochiUtils.h

@@ -27,6 +27,7 @@
 #include <filesystem>
 #include <unordered_map>
 #include <vector>
+#include <optional>
 
 #if defined( GNUC )
 #include <signal.h>
@@ -83,6 +84,20 @@ class OrochiUtils
 	static void getModule( oroDevice device, const char* code, const char* path, std::vector<const char*>* optsIn, const char* funcName, oroModule* moduleOut );
 	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 );
+	
+
+	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 )