[OpenMP] Refine CMake code for libomptarget

[tianshilei1992]

Summary

Building libomptarget and its other components, such as deviceRTLs,
plugins, requires LLVM or other functionalities in compiler. They're currently
not handled very well. This patch (or series of patches in the near future)
refines the whole detection code. The basic idea is, if libomptarget cannot be
built due to any reason, it should not block the configuration or compilation of
the whole OpenMP project. Not everyone wants target offloading. This patch is the
first patch to clean logics for libomptarget. It simply does one thing: if
the condition is not met, simply skip libomptarget.

[tianshilei1992]

Move the option to right place

[tianshilei1992]

openmp/libomptarget/plugins/amdgpu/CMakeLists.txt

33

This lines of code are removed because it can only reach here if the requirement is met.

[JonChesterfield]

I don't understand the control flow here. It looks like OPENMP_ENABLE_LIBOMPTARGET = ON, as before, but we now check for LLVM=12 on one path and not on another.

I think you sent an email suggesting we should test whether the compiler can actually build the plugin. LLVM==12 probably isn't a sufficiently robust way to do that.

Can cmake handle passing a pre-made c++ file to the compiler to test if it can build? I'm thinking we could craft one that used variant, various intrinsics etc that are representative of the gpu code runtime.

[tianshilei1992]

In D102587#2762882, @JonChesterfield wrote:

I don't understand the control flow here. It looks like OPENMP_ENABLE_LIBOMPTARGET = ON, as before, but we now check for LLVM=12 on one path and not on another.

So libomptarget is still enabled by default, but it exits immediately if any check doesn’t pass. LLVM 12 here is just to make sure that APIs we’re using is the one we want. My system has LLVM 8. CMake can detect it and use it, but APIs have been changed so it cannot pass compilation.

I think you sent an email suggesting we should test whether the compiler can actually build the plugin. LLVM==12 probably isn't a sufficiently robust way to do that.

Yes, my previous comment actually contains two points, one of which is about the test of compiler for deviceRTLs (which will be covered in another patches), and another one is this. I encountered issues when I just wanted to debug something wrong in libomp. So I just build OpenMP with GCC standalone.

Can cmake handle passing a pre-made c++ file to the compiler to test if it can build? I'm thinking we could craft one that used variant, various intrinsics etc that are representative of the gpu code runtime.

Yes, that’s what I’m gonna do: write a tiny test case and check if the compiler can compile it.

[ye-luo]

openmp/libomptarget/CMakeLists.txt

47

Could you unset cached variable OPENMP_ENABLE_LIBOMPTARGET (in a proper place)? Just to keep CMakeCached consistent.

Since OPENMP_ENABLE_LIBOMPTARGET is not in the current CMakeLists.txt, the unset probably needs to be at openmp/CMakeLists.txt
and the current CMakeLists.txt needs to set a return value signalling libomptarget not being built.

[tianshilei1992]

openmp/libomptarget/CMakeLists.txt

47

I feel that would be not a good direction. IMO, OPENMP_ENABLE_LIBOMPTARGET is just an option which presumably should be set by users. Its only functionality is to tell CMake whether we need to involve libomptarget. As for whether libomptarget can be built successfully, it's out of its control. Even if due to some reasons it is not built, as long as users don't set it to OFF, libomptarget still needs to be involved. For example, after users revolve issues found, it just needs to reconfigure the project instead set the variable to ON explicitly.

openmp/CMakeLists.txt

 # Set up testing infrastructure.
 include(OpenMPTesting)
 
 set(OPENMP_TEST_FLAGS "" CACHE STRING
   "Extra compiler flags to send to the test compiler.")
 set(OPENMP_TEST_OPENMP_FLAGS ${OPENMP_TEST_COMPILER_OPENMP_FLAGS} CACHE STRING
   "OpenMP compiler flag to use for testing OpenMP runtime libraries.")
 
-set(ENABLE_LIBOMPTARGET ON)
-# Currently libomptarget cannot be compiled on Windows or MacOS X.
-# Since the device plugins are only supported on Linux anyway,
-# there is no point in trying to compile libomptarget on other OSes.
-if (APPLE OR WIN32 OR NOT OPENMP_HAVE_STD_CPP14_FLAG)
-  set(ENABLE_LIBOMPTARGET OFF)
-endif()
-
-option(OPENMP_ENABLE_LIBOMPTARGET "Enable building libomptarget for offloading."
-       ${ENABLE_LIBOMPTARGET})
-option(OPENMP_ENABLE_LIBOMPTARGET_PROFILING "Enable time profiling for libomptarget."
-       ${ENABLE_LIBOMPTARGET})
 option(OPENMP_ENABLE_LIBOMP_PROFILING "Enable time profiling for libomp." OFF)
 
 # Build host runtime library, after LIBOMPTARGET variables are set since they are needed
 # to enable time profiling support in the OpenMP runtime.
 add_subdirectory(runtime)
 
+option(OPENMP_ENABLE_LIBOMPTARGET "Enable building libomptarget for offloading." ON)
 if (OPENMP_ENABLE_LIBOMPTARGET)
-  # Check that the library can actually be built.
-  if (APPLE OR WIN32)
-    message(FATAL_ERROR "libomptarget cannot be built on Windows and MacOS X!")
-  elseif (NOT OPENMP_HAVE_STD_CPP14_FLAG)
-    message(FATAL_ERROR "Host compiler must support C++14 to build libomptarget!")
-  endif()
-
   add_subdirectory(libomptarget)
 endif()
 
 set(ENABLE_OMPT_TOOLS ON)
 # Currently tools are not tested well on Windows or MacOS X.
 if (APPLE OR WIN32)
   set(ENABLE_OMPT_TOOLS OFF)
 endif()
 
 option(OPENMP_ENABLE_OMPT_TOOLS "Enable building ompt based tools for OpenMP."
        ${ENABLE_OMPT_TOOLS})
 if (OPENMP_ENABLE_OMPT_TOOLS)
   add_subdirectory(tools)
 endif()
 
-
 # Build documentation
 add_subdirectory(docs)
 
 # Now that we have seen all testsuites, create the check-openmp target.
 construct_check_openmp_target()

openmp/libomptarget/CMakeLists.txt

 set(LIBOMPTARGET_LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBOMPTARGET_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBOMPTARGET_LIBRARY_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBOMPTARGET_LIBRARY_DIR})
 
 # Message utilities.
 include(LibomptargetUtils)
 
+if (APPLE OR WIN32)
+  libomptarget_say("libomptarget can only work on Linux for now. Will not build libomptarget.")
+  return()
+endif()
+
+if (NOT OPENMP_HAVE_STD_CPP14_FLAG)
+  libomptarget_say("Building libomptarget requires the compiler support C++14. Will not build libomptarget.")
+  return()
+endif()
+
 # Get dependencies for the different components of the project.
 include(LibomptargetGetDependencies)
 
-# LLVM source tree is required at build time for libomptarget
+# LLVM source tree is required at build time for libomptarget. If it is missing,
+# libomptarget will not be built.
 if (NOT LIBOMPTARGET_LLVM_INCLUDE_DIRS)
-  message(FATAL_ERROR "Missing definition for LIBOMPTARGET_LLVM_INCLUDE_DIRS")
+  libomptarget_say("Building libomptarget requires LLVM 12.0+ components. Will not build libomptarget.")
+  return()
 endif()
 
 # This is a list of all the targets that are supported/tested right now.
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} aarch64-unknown-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} amdgcn-amd-amdhsa")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} powerpc64le-ibm-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} powerpc64-ibm-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} x86_64-pc-linux-gnu")
if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
   option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" ON)
 else()
   option(LIBOMPTARGET_ENABLE_DEBUG "Allow debug output with the environment variable LIBOMPTARGET_DEBUG=1" OFF)
 endif()
 if(LIBOMPTARGET_ENABLE_DEBUG)
   add_definitions(-DOMPTARGET_DEBUG)
 endif()
 
+option(OPENMP_ENABLE_LIBOMPTARGET_PROFILING "Enable time profiling for libomptarget." ON)
+
 set(LIBOMPTARGET_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 include_directories(${LIBOMPTARGET_INCLUDE_DIR})
 
 # Build target agnostic offloading library.
 set(LIBOMPTARGET_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 add_subdirectory(${LIBOMPTARGET_SRC_DIR})
 
 # Definitions for testing, for reuse when testing libomptarget-nvptx.
 set(LIBOMPTARGET_OPENMP_HEADER_FOLDER "${LIBOMP_INCLUDE_DIR}" CACHE STRING
   "Path to folder containing omp.h")
 set(LIBOMPTARGET_OPENMP_HOST_RTL_FOLDER "${LIBOMP_LIBRARY_DIR}" CACHE STRING
   "Path to folder containing libomp.so, and libLLVMSupport.so with profiling enabled")
 
-
 # Build offloading plugins and device RTLs if they are available.
 add_subdirectory(plugins)
 add_subdirectory(deviceRTLs)
 
 # Add tests.
 add_subdirectory(test)

openmp/libomptarget/cmake/Modules/LibomptargetGetDependencies.cmake

 
 ################################################################################
 # Looking for LLVM...
 ################################################################################
 
 if (OPENMP_STANDALONE_BUILD)
   # Complete LLVM package is required for building libomptarget
   # in an out-of-tree mode.
-  find_package(LLVM REQUIRED)
+  find_package(LLVM 12 QUIET)
+  if (NOT LLVM_FOUND)
+    # Return here directly as if `libomptarget` is not built, there is no reason
+    # to continue finding dependences for deviceRTLs or plugins.
+    return()
+  endif()
+
   message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
   message(STATUS "Using LLVM in: ${LLVM_DIR}")
   list(APPEND LIBOMPTARGET_LLVM_INCLUDE_DIRS ${LLVM_INCLUDE_DIRS})
   list(APPEND CMAKE_MODULE_PATH ${LLVM_CMAKE_DIR})
   include(AddLLVM)
 else()
   list(APPEND LIBOMPTARGET_LLVM_INCLUDE_DIRS
     ${LLVM_MAIN_INCLUDE_DIR} ${LLVM_BINARY_DIR}/include

openmp/libomptarget/plugins/amdgpu/CMakeLists.txt

if(NOT LIBOMPTARGET_DEP_LIBELF_FOUND)
   return()
 endif()
 
 if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64)|(ppc64le)|(aarch64)$" AND CMAKE_SYSTEM_NAME MATCHES "Linux")
   libomptarget_say("Not building AMDGPU plugin: only support AMDGPU in Linux x86_64, ppc64le, or aarch64 hosts.")
   return()
 endif()
 
-if (NOT LIBOMPTARGET_LLVM_INCLUDE_DIRS)
-  libomptarget_say("Not building AMDGPU plugin: Missing definition for LIBOMPTARGET_LLVM_INCLUDE_DIRS")
-  return()
-endif()
-
 libomptarget_say("Building amdgpu offloading plugin")
 
 ################################################################################
 # Define the suffix for the runtime messaging dumps.
 add_definitions(-DTARGET_NAME=AMDGPU)
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc64le)|(aarch64)$")
    add_definitions(-DLITTLEENDIAN_CPU=1)
 endif()