[libc] Support setting 'native' GPU architecture for libc

[jhuber6]

Summary

We already use the amdgpu-arch and nvptx-arch tools to determine the
GPU architectures the user's system supports. We can provide
LIBC_GPU_ARCHITECTURES=native to allow users to easily build support
for only the one found on their system. This also cleans up the code
somewhat.

[jhuber6]

Add if incase the tools aren't found for some reason. (This should never reasonably happen).

[tra]

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

Is that a singular architecture, or can we supply a list?

We may want to be able to build for a set of user-specified GPUs and, if I can dream out loud, allow specifying which GPU to run them on, so I could just do niunja check-libc-sm_70 and it would run the tests with CUDA_VISIBLE_DEVICES=<ID of sm_70 GPU>

[jhuber6]

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

Right now it's a singular architecture. The reason for this is because the internal objects used for testing and the ones that will be exported via the libcgpu.a library are separate compilations. Since the existing libc testing architecture only ever expected a single executable, it was easiest to implement it this way. Basically, the libcgpu.a library contains N architectures packed into a single file and the internal testing implementation just builds for one. I don't think it's impossible to support what you're asking, it would just require a lot more CMake.

[tra]

LGTM in general.

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

Can we build a set of per-GPU test executables and then just pick one of them to run libc tests?

[jhuber6]

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

So, libc works by making a bunch of target according to the directories and filename. So we compile some file and create the CMake target libc.src.string.memcmp. We then attach the compiled files to this target via some CMake property. We could potentially just attach several files to different properties and use the list of architectures to pull them out while building the tests. I didn't spend much time on changing it because I figured it would be sufficient to just test a single one at a time. But it would be interesting to be able to test an AMD and NVIDIA GPU at the same time.

[tra]

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

My strawman idea was to, roughly, wrap the part of cmake which generates test targets into a loop iterating over GPUs, which would create the same targets, but with a GPU-specifc suffix, which should in theory make it a largely mechanical change. But I'm also not familiar with the details of libc cmake, so if it's more invasive than that, targeting single arch for tests is fine.
It just looks a bit odd, considering that we do allow targeting multiple GPUs for the library itself. One would assume that we'd want to test multiple GPU variants, too.

[jhuber6]

libc/cmake/modules/prepare_libc_gpu_build.cmake

76

Yeah, it's mostly just a convenience. The test files are built differently, they're intended to be compiled directly to a GPU image and then executed via the loader. The GPU library on the other hand is all LLVM-IR for LTO that's packaged into a fatbinary for the "new driver". It's certainly doable, but it's not very high on my priorities right now.

libc/cmake/modules/prepare_libc_gpu_build.cmake

 if(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   message(FATAL_ERROR
           "libc build: Invalid attempt to set up GPU architectures.")
 endif()
 
 # Set up the target architectures to build the GPU libc for.
 set(all_amdgpu_architectures "gfx700;gfx701;gfx801;gfx803;gfx900;gfx902;gfx906"
                              "gfx908;gfx90a;gfx90c;gfx940;gfx1010;gfx1030"
                              "gfx1031;gfx1032;gfx1033;gfx1034;gfx1035;gfx1036"
                              "gfx1100;gfx1101;gfx1102;gfx1103")
 set(all_nvptx_architectures "sm_35;sm_37;sm_50;sm_52;sm_53;sm_60;sm_61;sm_62"
                             "sm_70;sm_72;sm_75;sm_80;sm_86")
 set(all_gpu_architectures
     "${all_amdgpu_architectures};${all_nvptx_architectures}")
-set(LIBC_GPU_ARCHITECTURES ${all_gpu_architectures} CACHE STRING
+set(LIBC_GPU_ARCHITECTURES "all" CACHE STRING
     "List of GPU architectures to build the libc for.")
-if(LIBC_GPU_ARCHITECTURES STREQUAL "all")
-  set(LIBC_GPU_ARCHITECTURES ${all_gpu_architectures} FORCE)
-endif()
-message(STATUS "Building libc for the following GPU architectures: "
-               "${LIBC_GPU_ARCHITECTURES}")
 
 # Ensure the compiler is a valid clang when building the GPU target.
 set(req_ver "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
 if(NOT (CMAKE_CXX_COMPILER_ID MATCHES "[Cc]lang" AND
         ${CMAKE_CXX_COMPILER_VERSION} VERSION_EQUAL "${req_ver}"))
   message(FATAL_ERROR "Cannot build libc for GPU. CMake compiler "
                       "'${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}' "
                       " is not `Clang ${req_ver}.")
 endif()
 if(NOT LLVM_LIBC_FULL_BUILD)
-  message(STATUS "LLVM_LIBC_FULL_BUILD must be enabled to build libc for GPU. "
-                 "Overriding LLVM_LIBC_FULL_BUILD to ON.")
-  set(LLVM_LIBC_FULL_BUILD ON FORCE)
+  message(FATAL_ERROR "LLVM_LIBC_FULL_BUILD must be enabled to build libc for "
+                      "GPU.")
 endif()
 
+# Identify any locally installed AMD GPUs on the system using 'amdgpu-arch'.
+find_program(LIBC_AMDGPU_ARCH
+             NAMES amdgpu-arch
+             PATHS ${LLVM_BINARY_DIR}/bin /opt/rocm/llvm/bin/)
+
+# Identify any locally installed NVIDIA GPUs on the system using 'nvptx-arch'.
+find_program(LIBC_NVPTX_ARCH
+             NAMES nvptx-arch
+             PATHS ${LLVM_BINARY_DIR}/bin)
+
+# Get the list of all natively supported GPU architectures.
+set(detected_gpu_architectures "")
+foreach(arch_tool ${LIBC_NVPTX_ARCH} ${LIBC_AMDGPU_ARCH})
+  if(arch_tool)
+    execute_process(COMMAND ${arch_tool}
+                    OUTPUT_VARIABLE arch_tool_output
+                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    string(REPLACE "\n" ";" arch_list "${arch_tool_output}")
+    list(APPEND detected_gpu_architectures "${arch_list}")
+  endif()
+endforeach()
+
+if(LIBC_GPU_ARCHITECTURES STREQUAL "all")
+  set(LIBC_GPU_ARCHITECTURES ${all_gpu_architectures})
+elseif(LIBC_GPU_ARCHITECTURES STREQUAL "native")
+  if(NOT detected_gpu_architectures)
+    message(FATAL_ERROR "No GPUs found on the system when using 'native'")
+  endif()
+  set(LIBC_GPU_ARCHITECTURES ${detected_gpu_architectures})
+endif()
+message(STATUS "Building libc for the following GPU architecture(s): "
+               "${LIBC_GPU_ARCHITECTURES}")
+
 # Identify the program used to package multiple images into a single binary.
 find_program(LIBC_CLANG_OFFLOAD_PACKAGER
              NAMES clang-offload-packager
              PATHS ${LLVM_BINARY_DIR}/bin)
 if(NOT LIBC_CLANG_OFFLOAD_PACKAGER)
   message(FATAL_ERROR "Cannot find the 'clang-offload-packager' for the GPU "
                       "build")
 endif()
 
 set(LIBC_GPU_TEST_ARCHITECTURE "" CACHE STRING "Architecture for the GPU tests")
+
+set(gpu_test_architecture "")
 if(LIBC_GPU_TEST_ARCHITECTURE)
-  message(STATUS "Using user-specified GPU architecture for testing "
-                 "'${LIBC_GPU_TEST_ARCHITECTURE}'")
-  if("${LIBC_GPU_TEST_ARCHITECTURE}" IN_LIST all_amdgpu_architectures)
-    set(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU TRUE)
-    set(LIBC_GPU_TARGET_TRIPLE "amdgcn-amd-amdhsa")
-    set(LIBC_GPU_TARGET_ARCHITECTURE "${LIBC_GPU_TEST_ARCHITECTURE}")
-  elseif("${LIBC_GPU_TEST_ARCHITECTURE}" IN_LIST all_nvptx_architectures)
-    set(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX TRUE)
-    set(LIBC_GPU_TARGET_TRIPLE "nvptx64-nvidia-cuda")
-    set(LIBC_GPU_TARGET_ARCHITECTURE "${LIBC_GPU_TEST_ARCHITECTURE}")
-  else()
-    message(FATAL_ERROR 
-            "Unknown GPU architecture '${LIBC_GPU_TARGET_ARCHITECTURE}'")
-  endif()
+  set(gpu_test_architecture ${LIBC_GPU_TEST_ARCHITECTURE})
+  message(STATUS "Using user-specified GPU architecture for testing: "
+                 "'${gpu_test_architecture}'")
+elseif(detected_gpu_architectures)
+  list(GET detected_gpu_architectures 0 gpu_test_architecture)
+  message(STATUS "Using GPU architecture detected on the system for testing: "
+                 "'${gpu_test_architecture}'")
+  message(STATUS "No GPU architecture set for testing. GPU tests will not be "
+                 "availibe. Set 'LIBC_GPU_TEST_ARCHITECTURE' to override.")
   return()
 endif()
 
-# Identify any locally installed AMD GPUs on the system to use for testing.
-find_program(LIBC_AMDGPU_ARCH
-             NAMES amdgpu-arch
-             PATHS ${LLVM_BINARY_DIR}/bin /opt/rocm/llvm/bin/)
-if(LIBC_AMDGPU_ARCH)
-  execute_process(COMMAND ${LIBC_AMDGPU_ARCH}
-                  OUTPUT_VARIABLE LIBC_AMDGPU_ARCH_OUTPUT
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-  string(FIND "${LIBC_AMDGPU_ARCH_OUTPUT}" "\n" first_arch_string)
-  string(SUBSTRING "${LIBC_AMDGPU_ARCH_OUTPUT}" 0 ${first_arch_string}
-         arch_string)
-  if(arch_string)
-    set(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU TRUE)
-    set(LIBC_GPU_TARGET_TRIPLE "amdgcn-amd-amdhsa")
-    set(LIBC_GPU_TARGET_ARCHITECTURE "${arch_string}")
-  endif()
-endif()
-
-if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
-  message(STATUS "Found an installed AMD GPU on the system with target "
-                 "architecture ${LIBC_GPU_TARGET_ARCHITECTURE} ")
-  return()
-endif()
-
-# Identify any locally installed NVIDIA GPUs on the system to use for testing.
-find_program(LIBC_NVPTX_ARCH
-             NAMES nvptx-arch
-             PATHS ${LLVM_BINARY_DIR}/bin)
-if(LIBC_NVPTX_ARCH)
-  execute_process(COMMAND ${LIBC_NVPTX_ARCH}
-                  OUTPUT_VARIABLE LIBC_NVPTX_ARCH_OUTPUT
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-  string(FIND "${LIBC_NVPTX_ARCH_OUTPUT}" "\n" first_arch_string)
-  string(SUBSTRING "${LIBC_NVPTX_ARCH_OUTPUT}" 0 ${first_arch_string}
-         arch_string)
-  if(arch_string)
-    set(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX TRUE)
-    set(LIBC_GPU_TARGET_TRIPLE "nvptx64-nvidia-cuda")
-    set(LIBC_GPU_TARGET_ARCHITECTURE "${arch_string}")
-  endif()
-endif()
-
-if(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
-  message(STATUS "Found an installed NVIDIA GPU on the system with target "
-                 "architecture ${LIBC_GPU_TARGET_ARCHITECTURE} ")
-  return()
+if("${gpu_test_architecture}" IN_LIST all_amdgpu_architectures)
+  set(LIBC_GPU_TARGET_ARCHITECTURE "${gpu_test_architecture}")
+elseif("${gpu_test_architecture}" IN_LIST all_nvptx_architectures)
+  set(LIBC_GPU_TARGET_ARCHITECTURE "${gpu_test_architecture}")
+else()
+  message(FATAL_ERROR "Unknown GPU architecture '${gpu_test_architecture}'")
 endif()