[UR][Offload] Support compiling on non-CUDA

This makes the dependency on cudadrv optional and ifdefs away the cubin
workaround if it isn't. This isn't sufficient to have HIP devices
compile kernels, but does allow libur_adapter_offload to be built on
said hosts.

In addition, an unused variable error was fixed.

Author: RossBrunton

source/adapters/offload/CMakeLists.txt

@@ -14,7 +14,7 @@ endif()
 
 # For the PTX workaround we need to link with CUDA.
 if (NOT TARGET cudadrv)
-        find_package(CUDA 10.1 REQUIRED)
+        find_package(CUDA 10.1)
         add_library(cudadrv SHARED IMPORTED GLOBAL)
         set_target_properties(
                 cudadrv PROPERTIES 
@@ -49,9 +49,15 @@ target_link_libraries(${TARGET_NAME} PRIVATE
         ${PROJECT_NAME}::common
         ${PROJECT_NAME}::umf
         ${UR_OFFLOAD_INSTALL_DIR}/lib/libLLVMOffload.so
-        cudadrv
 )
 
+if (CUDA_CUDA_LIBRARY)
+    target_link_libraries(${TARGET_NAME}
+        cudadrv
+    )
+    target_compile_definitions(${TARGET_NAME} PRIVATE UR_CUDA_ENABLED=1)
+endif()
+
 target_include_directories(${TARGET_NAME} PRIVATE
         "${UR_OFFLOAD_INCLUDE_DIR}/offload"
         "${CMAKE_CURRENT_SOURCE_DIR}/../../"

source/adapters/offload/adapter.cpp

@@ -46,6 +46,8 @@ ur_result_t ur_adapter_handle_t_::init() {
       },
       this);
 
+  (void)Res;
+
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/offload/program.cpp

@@ -1,12 +1,63 @@
 #include <OffloadAPI.h>
 #include <ur/ur.hpp>
 #include <ur_api.h>
-#include <cuda.h>
 
 #include "context.hpp"
 #include "program.hpp"
 #include "ur2offload.hpp"
 
+#ifdef UR_CUDA_ENABLED
+#include <cuda.h>
+#endif
+
+namespace {
+// Workaround for Offload not supporting PTX binaries. Force CUDA programs
+// to be linked so they end up as CUBIN.
+#ifdef UR_CUDA_ENABLED
+ur_result_t ProgramCreateCudaWorkaround(ur_context_handle_t hContext,
+                                        const uint8_t *Binary, size_t Length,
+                                        ur_program_handle_t *phProgram) {
+  uint8_t *RealBinary;
+  size_t RealLength;
+  CUlinkState State;
+  cuLinkCreate(0, nullptr, nullptr, &State);
+
+  cuLinkAddData(State, CU_JIT_INPUT_PTX, (char *)(Binary), Length, nullptr, 0,
+                nullptr, nullptr);
+
+  void *CuBin = nullptr;
+  size_t CuBinSize = 0;
+  cuLinkComplete(State, &CuBin, &CuBinSize);
+  RealBinary = (uint8_t *)CuBin;
+  RealLength = CuBinSize;
+  fprintf(stderr, "Performed CUDA bin workaround (size = %lu)\n", RealLength);
+
+  ur_program_handle_t Program = new ur_program_handle_t_();
+  auto Res =
+      olCreateProgram(reinterpret_cast<ol_device_handle_t>(hContext->Device),
+                      RealBinary, RealLength, &Program->OffloadProgram);
+
+  // Program owns the linked module now
+  cuLinkDestroy(State);
+  (void)State;
+
+  if (Res != OL_SUCCESS) {
+    delete Program;
+    return offloadResultToUR(Res);
+  }
+
+  *phProgram = Program;
+
+  return UR_RESULT_SUCCESS;
+}
+#else
+ur_result_t ProgramCreateCudaWorkaround(ur_context_handle_t, const uint8_t *,
+                                        size_t, ur_program_handle_t *) {
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+#endif
+} // namespace
+
 UR_APIEXPORT ur_result_t UR_APICALL urProgramCreateWithBinary(
     ur_context_handle_t hContext, uint32_t numDevices,
     ur_device_handle_t *phDevices, size_t *pLengths, const uint8_t **ppBinaries,
@@ -15,45 +66,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramCreateWithBinary(
     return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
   }
 
-  // Workaround for Offload not supporting PTX binaries. Force CUDA programs
-  // to be linked so they end up as CUBIN.
-  uint8_t *RealBinary;
-  size_t RealLength;
   ur_platform_handle_t DevicePlatform;
-  bool DidLink = false;
-  CUlinkState State;
   urDeviceGetInfo(phDevices[0], UR_DEVICE_INFO_PLATFORM,
                   sizeof(ur_platform_handle_t), &DevicePlatform, nullptr);
   ur_platform_backend_t PlatformBackend;
   urPlatformGetInfo(DevicePlatform, UR_PLATFORM_INFO_BACKEND,
                     sizeof(ur_platform_backend_t), &PlatformBackend, nullptr);
   if (PlatformBackend == UR_PLATFORM_BACKEND_CUDA) {
-    cuLinkCreate(0, nullptr, nullptr, &State);
-
-    cuLinkAddData(State, CU_JIT_INPUT_PTX, (char *)(ppBinaries[0]), pLengths[0],
-                  nullptr, 0, nullptr, nullptr);
-
-    void *CuBin = nullptr;
-    size_t CuBinSize = 0;
-    cuLinkComplete(State, &CuBin, &CuBinSize);
-    RealBinary = (uint8_t *)CuBin;
-    RealLength = CuBinSize;
-    DidLink = true;
-    fprintf(stderr, "Performed CUDA bin workaround (size = %lu)\n", RealLength);
-  } else {
-    RealBinary = const_cast<uint8_t *>(ppBinaries[0]);
-    RealLength = pLengths[0];
+    return ProgramCreateCudaWorkaround(hContext, ppBinaries[0], pLengths[0],
+                                       phProgram);
   }
 
+  auto *RealBinary = const_cast<uint8_t *>(ppBinaries[0]);
+
   ur_program_handle_t Program = new ur_program_handle_t_();
   auto Res =
       olCreateProgram(reinterpret_cast<ol_device_handle_t>(hContext->Device),
-                      RealBinary, RealLength, &Program->OffloadProgram);
-
-  // Program owns the linked module now
-  if (DidLink) {
-    cuLinkDestroy(State);
-  }
+                      RealBinary, pLengths[0], &Program->OffloadProgram);
 
   if (Res != OL_SUCCESS) {
     delete Program;
@@ -80,7 +109,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramBuildExp(ur_program_handle_t,
   return UR_RESULT_SUCCESS;
 }
 
-
 UR_APIEXPORT ur_result_t UR_APICALL
 urProgramRetain(ur_program_handle_t hProgram) {
   hProgram->RefCount++;

test/conformance/CMakeLists.txt

@@ -131,7 +131,7 @@ if(UR_DPCXX)
         if(UR_BUILD_ADAPTER_CUDA OR UR_BUILD_ADAPTER_ALL)
             list(APPEND TARGET_TRIPLES "nvptx64-nvidia-cuda")
         endif()
-        if(UR_BUILD_ADAPTER_HIP OR UR_BUILD_ADAPTER_ALL)
+        if(UR_BUILD_ADAPTER_HIP OR UR_BUILD_ADAPTER_OFFLOAD OR UR_BUILD_ADAPTER_ALL)
             list(APPEND TARGET_TRIPLES "amdgcn-amd-amdhsa")
         endif()
     else()