[SYCL][Bindless][2/4] Add experimental implementation of SYCL bindless images extension (#10112)

# Experimental Implementation of SYCL Bindless Images Extension

This commit stands as the second commit of four to make code review
easier, implementing revision 4 of the [bindless images extension
proposal](intel/llvm#9842).

## Scope

This PR covers changes made to the PI and the UR. This includes

- Extending PI with extension functions
- Updating UR FetchContent commit and implementing [UR bindless images
experimental
features](https://oneapi-src.github.io/unified-runtime/core/EXP-BINDLESS-IMAGES.html)
on the CUDA adaptor

## Following Split PRs

- [3/4] Implement the user-facing SYCL extension
- [4/4] Add tests

## Authors

Co-authored-by: Isaac Ault <[email protected]>
Co-authored-by: Hugh Bird <[email protected]>
Co-authored-by: Duncan Brawley <[email protected]>
Co-authored-by: Przemek Malon <[email protected]>
Co-authored-by: Chedy Najjar <[email protected]>
Co-authored-by: Sean Stirling <[email protected]>
Co-authored-by: Peter Zuzek <[email protected]>

Author: 7 people

common.cpp

@@ -62,6 +62,29 @@ ur_result_t checkErrorUR(CUresult Result, const char *Function, int Line,
   throw mapErrorUR(Result);
 }
 
+ur_result_t checkErrorUR(ur_result_t Result, const char *Function, int Line,
+                         const char *File) {
+  if (Result == UR_RESULT_SUCCESS) {
+    return UR_RESULT_SUCCESS;
+  }
+
+  if (std::getenv("SYCL_PI_SUPPRESS_ERROR_MESSAGE") == nullptr) {
+    std::stringstream SS;
+    SS << "\nUR ERROR:"
+       << "\n\tValue:           " << Result
+       << "\n\tFunction:        " << Function << "\n\tSource Location: " << File
+       << ":" << Line << "\n"
+       << std::endl;
+    std::cerr << SS.str();
+  }
+
+  if (std::getenv("PI_CUDA_ABORT") != nullptr) {
+    std::abort();
+  }
+
+  throw Result;
+}
+
 std::string getCudaVersionString() {
   int driver_version = 0;
   cuDriverGetVersion(&driver_version);

common.hpp

@@ -22,6 +22,9 @@ ur_result_t mapErrorUR(CUresult Result);
 ur_result_t checkErrorUR(CUresult Result, const char *Function, int Line,
                          const char *File);
 
+ur_result_t checkErrorUR(ur_result_t Result, const char *Function, int Line,
+                         const char *File);
+
 #define UR_CHECK_ERROR(Result)                                                 \
   checkErrorUR(Result, __func__, __LINE__, __FILE__)
 

device.cpp

@@ -871,6 +871,89 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES: {
     return ReturnValue(int32_t{1});
   }
+  case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP: {
+    // On CUDA bindless images are supported.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP: {
+    // On CUDA bindless images can be backed by shared (managed) USM.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP: {
+    // On CUDA 1D bindless image USM is not supported.
+    // More specifically, linear filtering is not supported.
+    return ReturnValue(false);
+  }
+  case UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP: {
+    // On CUDA 2D bindless image USM is supported.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP: {
+    int32_t tex_pitch_align = 0;
+    detail::ur::assertion(
+        cuDeviceGetAttribute(&tex_pitch_align,
+                             CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT,
+                             hDevice->get()) == CUDA_SUCCESS);
+    return ReturnValue(tex_pitch_align);
+  }
+  case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP: {
+    int32_t tex_max_linear_width = 0;
+    detail::ur::assertion(
+        cuDeviceGetAttribute(&tex_max_linear_width,
+                             CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH,
+                             hDevice->get()) == CUDA_SUCCESS);
+    return ReturnValue(tex_max_linear_width);
+  }
+  case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP: {
+    int32_t tex_max_linear_height = 0;
+    detail::ur::assertion(
+        cuDeviceGetAttribute(
+            &tex_max_linear_height,
+            CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT,
+            hDevice->get()) == CUDA_SUCCESS);
+    return ReturnValue(tex_max_linear_height);
+  }
+  case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP: {
+    int32_t tex_max_linear_pitch = 0;
+    detail::ur::assertion(
+        cuDeviceGetAttribute(&tex_max_linear_pitch,
+                             CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH,
+                             hDevice->get()) == CUDA_SUCCESS);
+    return ReturnValue(tex_max_linear_pitch);
+  }
+  case UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP: {
+    // CUDA supports mipmaps.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP: {
+    // CUDA supports anisotropic filtering.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP: {
+    // CUDA has no query for this, but documentation states max value is 16.
+    return ReturnValue(16.f);
+  }
+  case UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP: {
+    // CUDA supports creation of images from individual mipmap levels.
+    return ReturnValue(true);
+  }
+
+  case UR_DEVICE_INFO_INTEROP_MEMORY_IMPORT_SUPPORT_EXP: {
+    // CUDA supports importing external memory.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_INTEROP_MEMORY_EXPORT_SUPPORT_EXP: {
+    // CUDA does not support exporting it's own device memory.
+    return ReturnValue(false);
+  }
+  case UR_DEVICE_INFO_INTEROP_SEMAPHORE_IMPORT_SUPPORT_EXP: {
+    // CUDA supports importing external semaphores.
+    return ReturnValue(true);
+  }
+  case UR_DEVICE_INFO_INTEROP_SEMAPHORE_EXPORT_SUPPORT_EXP: {
+    // CUDA does not support exporting semaphores or events.
+    return ReturnValue(false);
+  }
   case UR_DEVICE_INFO_DEVICE_ID: {
     int Value = 0;
     detail::ur::assertion(

enqueue.cpp

@@ -6,6 +6,7 @@
 //
 //===-----------------------------------------------------------------===//
 
+#include "enqueue.hpp"
 #include "common.hpp"
 #include "context.hpp"
 #include "event.hpp"

enqueue.hpp

@@ -0,0 +1,16 @@
+//===--------- enqueue.hpp - CUDA Adapter ----------------------------===//
+//
+// 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
+//
+//===-----------------------------------------------------------------===//
+#pragma once
+
+#include <cassert>
+#include <cuda.h>
+#include <ur_api.h>
+
+ur_result_t enqueueEventsWait(ur_queue_handle_t CommandQueue, CUstream Stream,
+                              uint32_t NumEventsInWaitList,
+                              const ur_event_handle_t *EventWaitList);