Merge pull request #23 from GPUOpen-LibrariesAndSDKs/next-release-2

Update to 2.5

Author: RichardGe

.gitignore

@@ -14,3 +14,4 @@ hiprt/hiprtew.h
 hiprt/cache/Kernels.h
 hiprt/cache/KernelArgs.h
 PUBLIC_OUT/
+hiprt/impl/bvh_build_array.h

CMakeLists.txt

@@ -1,16 +1,31 @@
 cmake_minimum_required(VERSION 3.10)
 project(hiprt)
 
+#
 # Options
-option(BAKE_KERNEL "Enable the use of encrypted and baked kernels" OFF)
-option(BITCODE "Enable bitcode linking" OFF)
+#
+
+# Only one of those 3 flags should be ON at a time, or none. Multiple flags ON are untested and may cause issues.
+option(BAKE_KERNEL "Enable the use of encrypted and baked kernels source code" OFF)
+option(BAKE_COMPILED_KERNEL "If enabled, the kernels will be compiled and embedded as a buffer inside the binary. if you do that, you should also enable the flag 'PRECOMPILE'" OFF)
+option(BITCODE "Enable bitcode linking: when running the program, it's expected to find precompiled kernels as external files." OFF)
+
 option(PRECOMPILE "Precompile kernels" OFF)
 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)
 
 
+
+find_program(PYTHON_EXECUTABLE
+	NAMES python
+	PATHS /usr/bin /usr/local/bin /opt/local/bin
+)
+message(STATUS "Python path = ${PYTHON_EXECUTABLE}")
+
+
+
 # GENERATE_BAKE_KERNEL is enabled by default if we use the flags 'BAKE_KERNEL' or 'BITCODE'.
 # It can be forced to OFF, but in this case, some building functions from the HIPRT API, like hiprtBuildTraceKernelsFromBitcode will fail.
 if(BAKE_KERNEL OR BITCODE)
@@ -34,6 +49,7 @@ add_definitions(-DGTEST_HAS_TR1_TUPLE=0)
 
 
 
+
 # Functions
 function(copy_dir src_dir dst_dir pattern)
 	file(GLOB_RECURSE files "${src_dir}/${pattern}")
@@ -183,6 +199,10 @@ function(get_hip_sdk_version result)
 endfunction()
 
 
+# fill the HIP_VERSION_STR variable, it will look like: "6.2"
+get_hip_sdk_version(HIP_VERSION_STR)
+message(STATUS "HIP_VERSION_STR = ${HIP_VERSION_STR}")
+
 
 function(write_version_info in_file header_file version_file version_str_out)
 
@@ -228,7 +248,6 @@ function(write_version_info in_file header_file version_file version_str_out)
 	string(REPLACE "@HIPRT_API_VERSION@" "${HIPRT_API_VERSION}" header_content "${header_content}")
 
 	# Get HIP SDK version and replace placeholder
-	get_hip_sdk_version(HIP_VERSION_STR)
 	string(REPLACE "@HIP_VERSION_STR@" "\"${HIP_VERSION_STR}\"" header_content "${header_content}")
 
 	# Write the modified content to the header file
@@ -325,23 +344,51 @@ if(HIPRT_PREFER_HIP_5)
 endif()
 
 
-# precompile kernels
+# precompile kernels:
 if(PRECOMPILE)
 	execute_process(
-		COMMAND python compile.py --nvidia --hipSdkPath ${HIP_PATH}
+		COMMAND ${PYTHON_EXECUTABLE} compile.py --nvidia --hipSdkPath ${HIP_PATH}
 		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/scripts/bitcodes
 		)
-
+		
 	if(NOT NO_UNITTEST)
 		execute_process(
-			COMMAND python precompile_bitcode.py --nvidia --hipSdkPath ${HIP_PATH}
+			COMMAND ${PYTHON_EXECUTABLE} precompile_bitcode.py --nvidia --hipSdkPath ${HIP_PATH}
 			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/scripts/bitcodes
 			)
 	endif()
+	
 
 endif()
 
 
+
+# convert the binary to a buffer that will be embeded inside the binary
+# it's expected the step 'PRECOMPILE' has been executed.
+if ( BAKE_COMPILED_KERNEL )
+	
+	message(">> Generate embedded precompiled")
+	
+	set(PYTHON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Orochi/scripts/convert_binary_to_array.py")
+
+	set(KERNEL_HIPRT_COMP "${BASE_OUTPUT_DIR}/${CMAKE_BUILD_TYPE}/hiprt${version_str_}_${HIP_VERSION_STR}_amd.hipfb")
+	set(KERNEL_HIPRT_H "${CMAKE_CURRENT_SOURCE_DIR}/hiprt/impl/bvh_build_array.h")
+	execute_process(
+		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_HIPRT_COMP} ${KERNEL_HIPRT_H}
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		)
+
+	set(KERNEL_OROCHI_COMP "${BASE_OUTPUT_DIR}/${CMAKE_BUILD_TYPE}/oro_compiled_kernels.hipfb")
+	set(KERNEL_OROCHI_H "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Orochi/ParallelPrimitives/cache/oro_compiled_kernels.h")
+	execute_process(
+		COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_FILE} ${KERNEL_OROCHI_COMP} ${KERNEL_OROCHI_H}
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		)
+
+endif()
+
+
+
 if(BAKE_KERNEL OR GENERATE_BAKE_KERNEL)
 	message(">> BakeKernel Executed")
 	if(WIN32)
@@ -368,6 +415,17 @@ if(BAKE_KERNEL OR GENERATE_BAKE_KERNEL)
 
 endif()
 
+
+
+if ( BAKE_COMPILED_KERNEL )
+	# 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)
+	
+	#enable the 'BAKE_COMPILED_KERNEL' on HIPRT: 
+	target_compile_definitions(${HIPRT_NAME} PRIVATE HIPRT_BAKE_COMPILED_KERNEL )
+endif()
+
+
 if(BAKE_KERNEL)
 	target_compile_definitions(${HIPRT_NAME} PRIVATE HIPRT_LOAD_FROM_STRING ORO_PP_LOAD_FROM_STRING)
 endif()

contrib/Orochi/.gitignore

@@ -25,3 +25,7 @@ build/
 result.xml
 UnitTest/bitcodes/*.fatbin
 Test/SimpleD3D12/cache/**
+
+ParallelPrimitives/cache/KernelArgs.h
+ParallelPrimitives/cache/Kernels.h
+ParallelPrimitives/cache/oro_compiled_kernels.h

contrib/Orochi/Orochi/OrochiUtils.cpp

@@ -558,6 +558,41 @@ oroFunction OrochiUtils::getFunctionFromString( oroDevice device, const char* so
 	return f;
 }
 
+oroFunction OrochiUtils::getFunctionFromPrecompiledBinary_asData( const unsigned char* precompData, size_t dataSizeInBytes, const std::string& funcName )
+{
+	std::lock_guard<std::recursive_mutex> lock( m_mutex );
+
+	const std::string cacheName = OrochiUtilsImpl::getCacheName( "___BAKED_BIN___", funcName );
+	if( m_kernelMap.find( cacheName.c_str() ) != m_kernelMap.end() )
+	{
+		return m_kernelMap[cacheName].function;
+	}
+
+	oroModule module = nullptr;
+	oroError e = oroModuleLoadData( &module, precompData );
+	if ( e != oroSuccess )
+	{
+		// add some verbose info to help debugging missing data
+		printf("oroModuleLoadData FAILED (error = %d) loading baked precomp data: %s\n", e, funcName.c_str());
+		return nullptr;
+	}
+
+	oroFunction functionOut{};
+	e = oroModuleGetFunction( &functionOut, module, funcName.c_str() );
+	if ( e != oroSuccess )
+	{
+		// add some verbose info to help debugging missing data
+		printf("oroModuleGetFunction FAILED (error = %d) loading baked precomp data: %s\n", e, funcName.c_str());
+		return nullptr;
+	}
+	OROASSERT( e == oroSuccess, 0 );
+
+	m_kernelMap[cacheName].function = functionOut;
+	m_kernelMap[cacheName].module = module;
+
+	return functionOut;
+}
+
 oroFunction OrochiUtils::getFunctionFromPrecompiledBinary( const std::string& path, const std::string& funcName )
 {
 	std::lock_guard<std::recursive_mutex> lock( m_mutex );

contrib/Orochi/Orochi/OrochiUtils.h

@@ -69,6 +69,10 @@ class OrochiUtils
 
 	oroFunction getFunctionFromPrecompiledBinary( const std::string& path, const std::string& funcName );
 
+	// this function is like 'getFunctionFromPrecompiledBinary' but instead of giving a path to a file, we give the data directly.
+	// ( use the script convert_binary_to_array.py to convert the .hipfb to a C-array. )
+	oroFunction getFunctionFromPrecompiledBinary_asData( const unsigned char* data, size_t dataSizeInBytes, const std::string& funcName );
+
 	oroFunction getFunctionFromFile( oroDevice device, const char* path, const char* funcName, std::vector<const char*>* opts );
 	oroFunction getFunctionFromString( oroDevice device, const char* source, const char* path, const char* funcName, std::vector<const char*>* opts, int numHeaders, const char** headers, const char** includeNames );
 	oroFunction getFunction( oroDevice device, const char* code, const char* path, const char* funcName, std::vector<const char*>* opts, int numHeaders = 0, const char** headers = 0, const char** includeNames = 0, oroModule* loadedModule = 0 );

contrib/Orochi/ParallelPrimitives/RadixSort.cpp

@@ -40,24 +40,47 @@
 #include <dlfcn.h>
 #endif
 
-namespace
-{
-#if defined( ORO_PRECOMPILED )
-constexpr auto useBitCode = true;
+#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
-constexpr auto useBitCode = false;
+const unsigned char oro_compiled_kernels_h[] = "";
+const size_t oro_compiled_kernels_h_size = 0;
 #endif
 
-#if defined( ORO_PP_LOAD_FROM_STRING )
-constexpr auto useBakeKernel = true;
-#else
-constexpr auto useBakeKernel = false;
-static const char* hip_RadixSortKernels = nullptr;
-namespace hip
+namespace
 {
-static const char** RadixSortKernelsArgs = nullptr;
-static const char** RadixSortKernelsIncludes = nullptr;
-} // namespace hip
+
+// 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; // 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; // 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" );
@@ -211,9 +234,14 @@ void RadixSort::compileKernels( const std::string& kernelPath, const std::string
 	opts.push_back( sort_block_size_param.c_str() );
 	opts.push_back( sort_num_warps_param.c_str() );
 
+
 	for( const auto& record : records )
 	{
-		if constexpr( useBakeKernel )
+		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 );
 		}
@@ -231,6 +259,8 @@ void RadixSort::compileKernels( const std::string& kernelPath, const std::string
 			printKernelInfo( record.kernelName, oroFunctions[record.kernelType] );
 		}
 	}
+
+	return;
 }
 
 int RadixSort::calculateWGsToExecute( const int blockSize ) const noexcept

contrib/Orochi/scripts/convert_binary_to_array.py

@@ -0,0 +1,27 @@
+# convert_binary_to_header.py
+import sys
+from pathlib import Path
+
+def binary_to_c_array(bin_file, array_name):
+    with open(bin_file, 'rb') as f:
+        binary_data = f.read()
+
+    hex_array = ', '.join(f'0x{b:02x}' for b in binary_data)
+    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});\n'
+    return c_array
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print(f"Usage: {sys.argv[0]} <input_binary_file> <output_header_file>")
+        sys.exit(1)
+
+    bin_file = sys.argv[1]
+    header_file_path = sys.argv[2]
+    header_file = Path(header_file_path).name
+    array_name = header_file.replace('.', '_')
+
+    c_array = binary_to_c_array(bin_file, array_name)
+    with open(header_file_path, 'w') as f:
+        f.write("// generated by convert_binary_to_header.py\n")
+        f.write(c_array)

hiprt/hiprt_device.h

@@ -545,7 +545,7 @@ HIPRT_DEVICE hiprtFrameMatrix hiprtGetWorldToObjectFrameMatrix( hiprtScene scene
  * \param instanceID Instance ID.
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtPointObjectToWorld( hiprtFloat3 point, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
+HIPRT_DEVICE float3 hiprtPointObjectToWorld( float3 point, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
 
 /** \brief Transforms a point from the world space to the object space.
  *
@@ -554,7 +554,7 @@ HIPRT_DEVICE hiprtFloat3 hiprtPointObjectToWorld( hiprtFloat3 point, hiprtScene
  * \param instanceID Instance ID.
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtPointWorldToObject( hiprtFloat3 point, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
+HIPRT_DEVICE float3 hiprtPointWorldToObject( float3 point, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
 
 /** \brief Transforms a vector from the object space to the world space.
  *
@@ -563,8 +563,7 @@ HIPRT_DEVICE hiprtFloat3 hiprtPointWorldToObject( hiprtFloat3 point, hiprtScene
  * \param instanceID Instance ID.
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3
-hiprtVectorObjectToWorld( hiprtFloat3 vector, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
+HIPRT_DEVICE float3 hiprtVectorObjectToWorld( float3 vector, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
 
 /** \brief Transforms a vector from the world space to the object space.
  *
@@ -573,8 +572,7 @@ hiprtVectorObjectToWorld( hiprtFloat3 vector, hiprtScene scene, uint32_t instanc
  * \param instanceID Instance ID.
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3
-hiprtVectorWorldToObject( hiprtFloat3 vector, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
+HIPRT_DEVICE float3 hiprtVectorWorldToObject( float3 vector, hiprtScene scene, uint32_t instanceID, float time = 0.0f );
 
 /** \brief Returns the object to world transformation for a given instance and time in the form of the SRT frame.
  *
@@ -619,8 +617,8 @@ HIPRT_DEVICE hiprtFrameMatrix hiprtGetWorldToObjectFrameMatrix(
  * \param instanceIDs Instance IDs (multi-level instancing).
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtPointObjectToWorld(
-	hiprtFloat3 point, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
+HIPRT_DEVICE float3 hiprtPointObjectToWorld(
+	float3 point, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
 
 /** \brief Transforms a point from the world space to the object space.
  *
@@ -629,8 +627,8 @@ HIPRT_DEVICE hiprtFloat3 hiprtPointObjectToWorld(
  * \param instanceIDs Instance IDs (multi-level instancing).
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtPointWorldToObject(
-	hiprtFloat3 point, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
+HIPRT_DEVICE float3 hiprtPointWorldToObject(
+	float3 point, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
 
 /** \brief Transforms a vector from the object space to the world space.
  *
@@ -639,8 +637,8 @@ HIPRT_DEVICE hiprtFloat3 hiprtPointWorldToObject(
  * \param instanceIDs Instance IDs (multi-level instancing).
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtVectorObjectToWorld(
-	hiprtFloat3 vector, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
+HIPRT_DEVICE float3 hiprtVectorObjectToWorld(
+	float3 vector, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
 
 /** \brief Transforms a vector from the world space to the object space.
  *
@@ -649,5 +647,5 @@ HIPRT_DEVICE hiprtFloat3 hiprtVectorObjectToWorld(
  * \param instanceIDs Instance IDs (multi-level instancing).
  * \param time The time.
  */
-HIPRT_DEVICE hiprtFloat3 hiprtVectorWorldToObject(
-	hiprtFloat3 vector, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );
+HIPRT_DEVICE float3 hiprtVectorWorldToObject(
+	float3 vector, hiprtScene scene, const uint32_t ( &instanceIDs )[hiprtMaxInstanceLevels], float time = 0.0f );