forked from OSchip/llvm-project
257 lines
10 KiB
CMake
257 lines
10 KiB
CMake
##===----------------------------------------------------------------------===##
|
|
#
|
|
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
# See https://llvm.org/LICENSE.txt for license information.
|
|
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
#
|
|
##===----------------------------------------------------------------------===##
|
|
#
|
|
# Build the NVPTX (CUDA) Device RTL if the CUDA tools are available
|
|
#
|
|
##===----------------------------------------------------------------------===##
|
|
|
|
# By default we will build NVPTX deviceRTL on a CUDA free system
|
|
set(LIBOMPTARGET_BUILD_NVPTX_BCLIB TRUE CACHE BOOL
|
|
"Whether build NVPTX deviceRTL on CUDA free system.")
|
|
|
|
if (NOT (LIBOMPTARGET_DEP_CUDA_FOUND OR LIBOMPTARGET_BUILD_NVPTX_BCLIB))
|
|
libomptarget_say("Not building NVPTX deviceRTL by default on CUDA free system.")
|
|
return()
|
|
endif()
|
|
|
|
if (NOT LIBOMPTARGET_LLVM_INCLUDE_DIRS)
|
|
libomptarget_say("Not building NVPTX device RTL: Missing definition for LIBOMPTARGET_LLVM_INCLUDE_DIRS")
|
|
return()
|
|
endif()
|
|
|
|
# Check if we can create an LLVM bitcode implementation of the runtime library
|
|
# that could be inlined in the user application. For that we need to find
|
|
# a Clang compiler capable of compiling our CUDA files to LLVM bitcode and
|
|
# an LLVM linker.
|
|
set(LIBOMPTARGET_NVPTX_CUDA_COMPILER "" CACHE STRING
|
|
"Location of a CUDA compiler capable of emitting LLVM bitcode.")
|
|
set(LIBOMPTARGET_NVPTX_BC_LINKER "" CACHE STRING
|
|
"Location of a linker capable of linking LLVM bitcode objects.")
|
|
|
|
if (NOT LIBOMPTARGET_NVPTX_CUDA_COMPILER STREQUAL "")
|
|
set(cuda_compiler ${LIBOMPTARGET_NVPTX_CUDA_COMPILER})
|
|
elseif (LLVM_TOOL_CLANG_BUILD AND NOT CMAKE_CROSSCOMPILING)
|
|
# Compile the deviceRTL with the clang that is built in the project.
|
|
set(cuda_compiler "$<TARGET_FILE:clang>")
|
|
elseif(${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
|
|
# Compile the device runtime with the compiler that OpenMP is built with.
|
|
# This is the case with LLVM_ENABLE_RUNTIMES=openmp.
|
|
# FIXME: This is unreliable; the compiler can be on older version of clang
|
|
# that does not support compiling CUDA, or only an older version of it. The
|
|
# risk is especially high on sytems where clang is the default compiler
|
|
# (MacOS, BSDs). LLVM_ENABLE_RUNTIMES=openmp should itself set
|
|
# LIBOMPTARGET_NVPTX_CUDA_COMPILER instead.
|
|
set(cuda_compiler ${CMAKE_C_COMPILER})
|
|
else()
|
|
libomptarget_say("Not building NVPTX deviceRTL: clang not found")
|
|
return()
|
|
endif()
|
|
|
|
# Get compiler directory to try to locate a suitable linker.
|
|
get_filename_component(compiler_dir ${cuda_compiler} DIRECTORY)
|
|
set(llvm_link "${compiler_dir}/llvm-link")
|
|
|
|
if (NOT LIBOMPTARGET_NVPTX_BC_LINKER STREQUAL "")
|
|
set(bc_linker ${LIBOMPTARGET_NVPTX_BC_LINKER})
|
|
elseif (EXISTS ${llvm_link})
|
|
# Try to use the linker consistent with the CUDA compiler unless explicitly
|
|
# set to a different linker.
|
|
set(bc_linker ${llvm_link})
|
|
elseif (NOT OPENMP_STANDALONE_BUILD AND NOT CMAKE_CROSSCOMPILING)
|
|
# Use the linker also built in the same project.
|
|
set(bc_linker "$<TARGET_FILE:llvm-link>")
|
|
else()
|
|
libomptarget_say("Not building NVPTX deviceRTL: llvm-link not found")
|
|
return()
|
|
endif()
|
|
|
|
# TODO: This part needs to be refined when libomptarget is going to support
|
|
# Windows!
|
|
# TODO: This part can also be removed if we can change the clang driver to make
|
|
# it support device only compilation.
|
|
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
|
|
set(aux_triple x86_64-unknown-linux-gnu)
|
|
elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "ppc64le")
|
|
set(aux_triple powerpc64le-unknown-linux-gnu)
|
|
elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
|
|
set(aux_triple aarch64-unknown-linux-gnu)
|
|
else()
|
|
libomptarget_say("Not building CUDA offloading device RTL: unknown host arch: ${CMAKE_HOST_SYSTEM_PROCESSOR}")
|
|
return()
|
|
endif()
|
|
|
|
get_filename_component(devicertl_base_directory
|
|
${CMAKE_CURRENT_SOURCE_DIR}
|
|
DIRECTORY)
|
|
set(devicertl_common_directory
|
|
${devicertl_base_directory}/common)
|
|
set(devicertl_nvptx_directory
|
|
${devicertl_base_directory}/nvptx)
|
|
|
|
set(all_capabilities 35 37 50 52 53 60 61 62 70 72 75 80 86)
|
|
|
|
set(LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES ${all_capabilities} CACHE STRING
|
|
"List of CUDA Compute Capabilities to be used to compile the NVPTX device RTL.")
|
|
string(TOLOWER ${LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES} LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES)
|
|
|
|
if (LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES STREQUAL "all")
|
|
set(nvptx_sm_list ${all_capabilities})
|
|
elseif(LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES STREQUAL "auto")
|
|
if (NOT LIBOMPTARGET_DEP_CUDA_FOUND)
|
|
libomptarget_error_say("[NVPTX] Cannot auto detect compute capability as CUDA not found.")
|
|
endif()
|
|
set(nvptx_sm_list ${LIBOMPTARGET_DEP_CUDA_ARCH})
|
|
else()
|
|
string(REPLACE "," ";" nvptx_sm_list "${LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES}")
|
|
endif()
|
|
|
|
# If user set LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES to empty, we disable the
|
|
# build.
|
|
if (NOT nvptx_sm_list)
|
|
libomptarget_say("Not building CUDA offloading device RTL: empty compute capability list")
|
|
return()
|
|
endif()
|
|
|
|
# Check all SM values
|
|
foreach(sm ${nvptx_sm_list})
|
|
if (NOT ${sm} IN_LIST all_capabilities)
|
|
libomptarget_warning_say("[NVPTX] Compute capability ${sm} is not supported. Make sure clang can work with it.")
|
|
endif()
|
|
endforeach()
|
|
|
|
# Override default MAX_SM in src/target_impl.h if requested
|
|
if (DEFINED LIBOMPTARGET_NVPTX_MAX_SM)
|
|
set(MAX_SM_DEFINITION "-DMAX_SM=${LIBOMPTARGET_NVPTX_MAX_SM}")
|
|
endif()
|
|
|
|
# Activate RTL message dumps if requested by the user.
|
|
set(LIBOMPTARGET_NVPTX_DEBUG FALSE CACHE BOOL
|
|
"Activate NVPTX device RTL debug messages.")
|
|
|
|
if ("${cuda_compiler}" STREQUAL "$<TARGET_FILE:clang>")
|
|
libomptarget_say("Building CUDA LLVM bitcode offloading device RTL using in-tree clang.")
|
|
else ()
|
|
libomptarget_say("Building CUDA LLVM bitcode offloading device RTL using ${cuda_compiler}")
|
|
endif ()
|
|
|
|
set(cuda_src_files
|
|
${devicertl_common_directory}/src/cancel.cu
|
|
${devicertl_common_directory}/src/critical.cu
|
|
${devicertl_common_directory}/src/data_sharing.cu
|
|
${devicertl_common_directory}/src/libcall.cu
|
|
${devicertl_common_directory}/src/loop.cu
|
|
${devicertl_common_directory}/src/omp_data.cu
|
|
${devicertl_common_directory}/src/omptarget.cu
|
|
${devicertl_common_directory}/src/parallel.cu
|
|
${devicertl_common_directory}/src/reduction.cu
|
|
${devicertl_common_directory}/src/support.cu
|
|
${devicertl_common_directory}/src/sync.cu
|
|
${devicertl_common_directory}/src/task.cu
|
|
${devicertl_common_directory}/src/shuffle.cpp
|
|
src/target_impl.cu
|
|
)
|
|
|
|
# Prepend -I to each list element
|
|
set (LIBOMPTARGET_LLVM_INCLUDE_DIRS_NVPTX "${LIBOMPTARGET_LLVM_INCLUDE_DIRS}")
|
|
list(TRANSFORM LIBOMPTARGET_LLVM_INCLUDE_DIRS_NVPTX PREPEND "-I")
|
|
|
|
# Set flags for LLVM Bitcode compilation.
|
|
set(bc_flags -S -x c++ -O1 -std=c++14
|
|
-mllvm -openmp-opt-disable
|
|
-ffreestanding
|
|
-target nvptx64
|
|
-Xclang -emit-llvm-bc
|
|
-Xclang -aux-triple -Xclang ${aux_triple}
|
|
-fopenmp -fopenmp-cuda-mode -Xclang -fopenmp-is-device
|
|
-Xclang -target-feature -Xclang +ptx61
|
|
-D__CUDACC__
|
|
-I${devicertl_base_directory}
|
|
-I${devicertl_common_directory}/include
|
|
-I${devicertl_nvptx_directory}/src
|
|
-I${devicertl_base_directory}/../include
|
|
${LIBOMPTARGET_LLVM_INCLUDE_DIRS_NVPTX})
|
|
|
|
if(${LIBOMPTARGET_NVPTX_DEBUG})
|
|
list(APPEND bc_flags -DOMPTARGET_NVPTX_DEBUG=-1 -g)
|
|
else()
|
|
list(APPEND bc_flags -DOMPTARGET_NVPTX_DEBUG=0)
|
|
endif()
|
|
|
|
# Create target to build all Bitcode libraries.
|
|
add_custom_target(omptarget-nvptx-bc)
|
|
|
|
# Generate a Bitcode library for all the compute capabilities the user requested
|
|
foreach(sm ${nvptx_sm_list})
|
|
set(cuda_flags -Xclang -target-cpu -Xclang sm_${sm} "-D__CUDA_ARCH__=${sm}0")
|
|
set(bc_files "")
|
|
foreach(src ${cuda_src_files})
|
|
get_filename_component(infile ${src} ABSOLUTE)
|
|
get_filename_component(outfile ${src} NAME)
|
|
set(outfile "${outfile}-sm_${sm}.bc")
|
|
|
|
add_custom_command(OUTPUT ${outfile}
|
|
COMMAND ${cuda_compiler} ${bc_flags}
|
|
${cuda_flags} ${MAX_SM_DEFINITION} ${infile} -o ${outfile}
|
|
DEPENDS ${infile}
|
|
IMPLICIT_DEPENDS CXX ${infile}
|
|
COMMENT "Building LLVM bitcode ${outfile}"
|
|
VERBATIM
|
|
)
|
|
if("${cuda_compiler}" STREQUAL "$<TARGET_FILE:clang>")
|
|
# Add a file-level dependency to ensure that clang is up-to-date.
|
|
# By default, add_custom_command only builds clang if the
|
|
# executable is missing.
|
|
add_custom_command(OUTPUT ${outfile}
|
|
DEPENDS clang
|
|
APPEND
|
|
)
|
|
endif()
|
|
set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${outfile})
|
|
|
|
list(APPEND bc_files ${outfile})
|
|
endforeach()
|
|
|
|
set(bclib_name "libomptarget-nvptx-sm_${sm}.bc")
|
|
|
|
# Link to a bitcode library.
|
|
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name}
|
|
COMMAND ${bc_linker}
|
|
-o ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name} ${bc_files}
|
|
DEPENDS ${bc_files}
|
|
COMMENT "Linking LLVM bitcode ${bclib_name}"
|
|
)
|
|
if("${bc_linker}" STREQUAL "$<TARGET_FILE:llvm-link>")
|
|
# Add a file-level dependency to ensure that llvm-link is up-to-date.
|
|
# By default, add_custom_command only builds llvm-link if the
|
|
# executable is missing.
|
|
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name}
|
|
DEPENDS llvm-link
|
|
APPEND
|
|
)
|
|
endif()
|
|
set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${bclib_name})
|
|
|
|
set(bclib_target_name "omptarget-nvptx-sm_${sm}-bc")
|
|
|
|
add_custom_target(${bclib_target_name} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name})
|
|
add_dependencies(omptarget-nvptx-bc ${bclib_target_name})
|
|
|
|
# Copy library to destination.
|
|
add_custom_command(TARGET ${bclib_target_name} POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name}
|
|
${LIBOMPTARGET_LIBRARY_DIR})
|
|
|
|
# Install bitcode library under the lib destination folder.
|
|
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${bclib_name} DESTINATION "${OPENMP_INSTALL_LIBDIR}")
|
|
endforeach()
|
|
|
|
# Test will be enabled if the building machine supports CUDA
|
|
if (LIBOMPTARGET_DEP_CUDA_FOUND)
|
|
add_subdirectory(test)
|
|
endif()
|