AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
develop
rocm-systems/projects/rocr-runtime/rocrtst/samples/CMakeLists.txt
T
shwetakhatri-amd 0835f2e75a rocrtst: Updated CMakeFiles to find_package instead of hardcoded (#2095) 
* rocrtst: Updated CMakeFiles to find_package instead of hardcoded

This is to support TheROCK build environment

* rocrtst: Fix CMake to use find_package() instead of hardcoded ENV paths

Fixed CMake style issues from previos first commit's code review

* rocrtst: Fix rocrtst NUMA dependency detection to use find_package

Also added handling of missing headers

* rocrtst: Fix NUMA and hwloc detection for cross-platform builds

---------

Co-authored-by: Shweta Khatri <shweta.khatri@amd.com>
2025-12-10 16:16:25 -05:00

337 lines
10 KiB
CMake
Executable File
Raw Permalink Blame History

#
# Minimum version of cmake required
#
cmake_minimum_required(VERSION 2.8.0)
#
# GCC 4.8 or higher compiler required.
#
#
# Required Defines on cmake command line
#
# 1) Set location of ROCR header files
#
# ROCM_DIR="Root for RocM install"
#
# 2) Set ROCRTST_BLD_TYPE to either "Debug" or "Release".
# If not set, the default value is "Debug" is bound.
#
# ROCRTST_BLD_TYPE=Debug or ROCRTST_BLD_TYPE=Release
#
# 3) Set ROCRTST_BLD_BITS to either "32" or "64"
# If not set, the default value of "64" is bound.
#
# ROCRTST_BLD_BITS=32 or ROCRTST_BLD_BITS=64
#
# 4) Set TARGET_DEVICES to indicate gpu types for kernel
# builds (e.g., "gfx803;gfx900; ...")
#
# Building rocrtst Suite
#
# 1) Create build folder e.g. "rocrtst/build" - any name will do
# 2) Cd into build folder
# 3) Run "cmake .."
# 4) Run "make"
#
cmake_minimum_required(VERSION 3.5.0)
# Set Name for Samples Project
#
set(PROJECT_NAME "sample64")
project (${PROJECT_NAME})
set(DEFAULT_TARGET "gfx803")
#############################
# COMMON AREA
#############################
#
# Currently support for Windows platform is not present
#
if(WIN32)
message("This sample is not supported on Windows platform")
return()
endif()
#
# Process input variables
#
# Required Defines first:
find_package(hsa-runtime64 REQUIRED )
message(STATUS "HSA Runtime found at ${hsa-runtime64_DIR} ")
if (DEFINED LLVM_DIR)
set(CLANG ${LLVM_DIR}/clang)
if (NOT EXISTS ${CLANG})
# SPK temp until Jenkins script input is corrected.
set (CLANG ${OPENCL_DIR}/bin/clang)
if (NOT EXISTS ${CLANG})
message("ERROR: path to clang (${CLANG}) is not valid. Is define LLVM_DIR correct?")
return()
endif()
endif()
else()
message("WARNING: LLVM_DIR define is not set. Kernels will not be built.")
endif()
if (DEFINED OPENCL_DIR)
set(OPENCL_INC_DIR ${OPENCL_DIR}/include)
set(OPENCL_LIB_DIR ${OPENCL_DIR}/lib)
else()
message("WARNING: OPENCL_DIR define is not set. Kernels will not be built.")
endif()
if (DEFINED OPENCL_VER)
set(OPENCL_VER ${OPENCL_VER})
else()
message("OPENCL_VER define is not set. Using default")
set(OPENCL_VER "2.0")
endif()
if(NOT EXISTS "${OPENCL_INC_DIR}/opencl-c.h")
set(OPENCL_INC_DIR "${OPENCL_DIR}/../../../external/llvm-project/clang/lib/Headers/")
if(NOT EXISTS "${OPENCL_INC_DIR}/opencl-c.h")
message(WARNING "opencl-c.h not found.")
endif()
endif()
if (NOT DEFINED TARGET_DEVICES)
message("WARNING: No targets devices provided on command line")
message(" e.g., cmake -DTARGET_DEVICES=\"gfx803;gfx900;gfx...\" ..")
message(" Using default target of $DEFAULT_TARGET")
list(APPEND TARGET_DEVICES "gfx803")
endif()
string(TOLOWER "${ROCRTST_BLD_TYPE}" tmp)
if("${tmp}" STREQUAL release)
set(BUILD_TYPE "Release")
set(ISDEBUG 0)
else()
set(BUILD_TYPE "Debug")
set(ISDEBUG 1)
endif()
# Find AMD Device Libraries (bitcode files) using find_package or manual search
find_package(AMDDeviceLibs QUIET CONFIG)
if(AMDDeviceLibs_FOUND)
# Use the package-provided location
message(STATUS "Found AMDDeviceLibs via CONFIG")
# Try to get the bitcode directory from any target
if(TARGET AMDDeviceLibs::oclc_isa_version_803)
get_target_property(DEVICE_LIBS_LOCATION AMDDeviceLibs::oclc_isa_version_803 IMPORTED_LOCATION)
get_filename_component(BITCODE_DIR "${DEVICE_LIBS_LOCATION}" DIRECTORY)
elseif(TARGET AMDDeviceLibs::oclc_isa_version_900)
get_target_property(DEVICE_LIBS_LOCATION AMDDeviceLibs::oclc_isa_version_900 IMPORTED_LOCATION)
get_filename_component(BITCODE_DIR "${DEVICE_LIBS_LOCATION}" DIRECTORY)
else()
# Fallback to manual search even if package was found
set(AMDDeviceLibs_FOUND FALSE)
endif()
endif()
if(NOT AMDDeviceLibs_FOUND)
# Fallback: search relative to LLVM installation
message(STATUS "Searching for AMD Device Libraries manually...")
# First try to find LLVM if not already found
if(NOT DEFINED LLVM_LIBRARY_DIR)
find_package(LLVM QUIET CONFIG)
if(LLVM_FOUND)
message(STATUS "Found LLVM: ${LLVM_PACKAGE_VERSION}")
endif()
endif()
find_path(BITCODE_DIR
NAMES "opencl.bc" "opencl.amdgcn.bc" "oclc_isa_version_803.bc"
HINTS
"${LLVM_LIBRARY_DIR}/amdgcn/bitcode"
"${LLVM_LIBRARY_DIR}/../amdgcn/bitcode"
"${CMAKE_INSTALL_PREFIX}/amdgcn/bitcode"
"${CMAKE_INSTALL_PREFIX}/lib/amdgcn/bitcode"
"${CMAKE_PREFIX_PATH}/amdgcn/bitcode"
"${CMAKE_PREFIX_PATH}/lib/amdgcn/bitcode"
NO_DEFAULT_PATH
)
if(NOT BITCODE_DIR)
message(FATAL_ERROR
"AMD Device Libraries (bitcode) not found!\n"
"Searched locations:\n"
" ${LLVM_LIBRARY_DIR}/amdgcn/bitcode\n"
" ${LLVM_LIBRARY_DIR}/../amdgcn/bitcode\n"
" ${CMAKE_INSTALL_PREFIX}/amdgcn/bitcode\n"
" ${CMAKE_INSTALL_PREFIX}/lib/amdgcn/bitcode\n"
"Please ensure device-libs are built and installed.")
endif()
endif()
message(STATUS "Samples - Found Device Libraries: ${BITCODE_DIR}")
# Validate bitcode files exist
if(NOT EXISTS "${BITCODE_DIR}")
message(FATAL_ERROR "BITCODE_DIR does not exist: ${BITCODE_DIR}")
endif()
#
# Print out the build configuration being used:
#
# Build Src directory
# Build Binary directory
# Build Type: Debug Vs Release, 32 Vs 64
# Compiler Version, etc
#
message("")
message("Build Configuration:")
message("-------------IS64BIT: " ${IS64BIT})
message("-----------BuildType: " ${BUILD_TYPE})
message("------------Compiler: " ${CMAKE_CXX_COMPILER})
message("-------------Version: " ${CMAKE_CXX_COMPILER_VERSION})
message("--------Proj Src Dir: " ${PROJECT_SOURCE_DIR})
message("--------Proj Bld Dir: " ${PROJECT_BINARY_DIR})
message("--------Proj Lib Dir: " ${PROJECT_BINARY_DIR}/lib)
message("--------Proj Exe Dir: " ${PROJECT_BINARY_DIR}/bin)
message("------Target Devices: ${TARGET_DEVICES}")
message("----------Clang path: " ${CLANG})
message("----------OpenCL Dir: " ${OPENCL_DIR})
message("-------OpenCL version " ${OPENCL_VER})
message("")
#
# Set the build type based on user input
#
set(CMAKE_BUILD_TYPE ${BUILD_TYPE})
#
# Flag to enable / disable verbose output.
#
SET( CMAKE_VERBOSE_MAKEFILE on )
#
# Compiler pre-processor definitions.
#
# Define MACRO "DEBUG" if build type is "Debug"
if(${BUILD_TYPE} STREQUAL "Debug")
add_definitions(-DDEBUG)
endif()
#add_definitions(-D__linux__)
add_definitions(-DLITTLEENDIAN_CPU=1)
#
# Linux Compiler options
#
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-math-errno")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-threadsafe-statics")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmerge-all-constants")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fms-extensions")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64")
#
# Add compiler flags to include symbol information for debug builds
#
if(ISDEBUG)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb -O0")
endif()
message("ISDEBUG STEP:Done")
include_directories("${OPENCL_DIR}/include")
# Use this function to build any samples that have kernels to be built
function(process_sample S_NAME TARG_DEV HAS_KERNEL)
set(KERNEL_DIR ${PROJECT_BINARY_DIR}/${TARG_DEV})
set(SNAME_KERNEL "${S_NAME}_kernels.hsaco")
set(TARG_NAME "${S_NAME}_hsaco.${TARG_DEV}")
set (HSACO_TARG_LIST ${HSACO_TARG_LIST} ${TARG_NAME}
CACHE INTERNAL HSACO_TARG_LIST)
if (${HAS_KERNEL})
# Build the kernel
separate_arguments(CLANG_ARG_LIST UNIX_COMMAND
"-x cl -target amdgcn-amd-amdhsa -Xclang -finclude-default-header -mcpu=${TARG_DEV} ${BITCODE_ARGS} -cl-std=CL${OPENCL_VER} ${CL_FILE_LIST} -o ${KERNEL_DIR}/${SNAME_KERNEL}")
add_custom_target("${TARG_NAME}" ${CLANG} ${CLANG_ARG_LIST} COMMAND
${CMAKE_COMMAND} -E create_symlink
"../${SNAME_EXE}" "${KERNEL_DIR}/${SNAME_EXE}"
COMMENT "BUILDING KERNEL..."
VERBATIM)
else()
# No kernel to build, but we need to set up symlinks; we'll use the hsaco
# targ name, even though we aren't building an hsaco
add_custom_target("${TARG_NAME}"
${CMAKE_COMMAND} -E create_symlink
"../${SNAME_EXE}" "${KERNEL_DIR}/${SNAME_EXE}"
COMMENT "NO KERNEL TO BUILD; SYMLINK ONLY..."
VERBATIM)
endif()
endfunction(process_sample)
function(build_sample_for_devices S_NAME HAS_KERNEL)
set(SNAME_EXE "${S_NAME}")
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/${S_NAME} S_NAME_SOURCES)
add_executable(${SNAME_EXE} ${S_NAME_SOURCES})
target_link_libraries(${SNAME_EXE} hsa-runtime64::hsa-runtime64 c stdc++ dl pthread rt)
set(HSACO_TARG_LIST PARENT_SCOPE)
foreach(t ${TARGET_DEVICES})
process_sample(${S_NAME} ${t} ${HAS_KERNEL})
endforeach(t)
endfunction(build_sample_for_devices)
function(add_symlink_to_exe DST)
foreach(td ${TARGET_DEVICES})
endforeach(td)
endfunction(add_symlink_to_exe)
# Make directories for each possible target device
foreach(td ${TARGET_DEVICES})
file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${td})
endforeach(td)
###########################
# SAMPLE SPECIFIC SECTION
###########################
set (HSACO_TARG_LIST "" CACHE INTERNAL HSACO_TARG_LIST)
set(KERN_SUFFIX "kernels.hsaco")
# Check if device-libs bitcode is following old or new layout
if(EXISTS "${BITCODE_DIR}/opencl.amdgcn.bc")
set(BITCODE_ARGS "-nogpulib
-Xclang -mlink-bitcode-file -Xclang ${BITCODE_DIR}/opencl.amdgcn.bc
-Xclang -mlink-bitcode-file -Xclang ${BITCODE_DIR}/ockl.amdgcn.bc
-Xclang -mlink-bitcode-file -Xclang ${BITCODE_DIR}/ocml.amdgcn.bc")
else()
set(BITCODE_ARGS "--hip-device-lib-path=${BITCODE_DIR}")
endif()
set(CL_FILE_LIST
"${PROJECT_SOURCE_DIR}/binary_search/binary_search_kernels.cl")
build_sample_for_devices("binary_search" TRUE)
# RocR Info
build_sample_for_devices("rocrinfo" FALSE)
# IPC
build_sample_for_devices("ipc" FALSE)
# Async Mem. Copy
build_sample_for_devices("async_mem_copy" FALSE)
add_custom_target(sample_kernels DEPENDS ${HSACO_TARG_LIST})
install(TARGETS ${SAMPLE_EXE}
ARCHIVE DESTINATION ${PROJECT_BINARY_DIR}/lib
LIBRARY DESTINATION ${PROJECT_BINARY_DIR}/lib
RUNTIME DESTINATION ${PROJECT_BINARY_DIR}/bin)
Reference in New Issue View Git Blame Copy Permalink