[SYCL][CUDA] Implement ext_oneapi_queue_priority (#11296)

The E2E test assumes that the device supports priorities (sm_35 or
newer).

Author: al42and

source/adapters/cuda/queue.cpp

@@ -42,8 +42,8 @@ CUstream ur_queue_handle_t_::getNextComputeStream(uint32_t *StreamToken) {
       // The second check is done after mutex is locked so other threads can not
       // change NumComputeStreams after that
       if (NumComputeStreams < ComputeStreams.size()) {
-        UR_CHECK_ERROR(
-            cuStreamCreate(&ComputeStreams[NumComputeStreams++], Flags));
+        UR_CHECK_ERROR(cuStreamCreateWithPriority(
+            &ComputeStreams[NumComputeStreams++], Flags, Priority));
       }
     }
     Token = ComputeStreamIndex++;
@@ -103,8 +103,8 @@ CUstream ur_queue_handle_t_::getNextTransferStream() {
     // The second check is done after mutex is locked so other threads can not
     // change NumTransferStreams after that
     if (NumTransferStreams < TransferStreams.size()) {
-      UR_CHECK_ERROR(
-          cuStreamCreate(&TransferStreams[NumTransferStreams++], Flags));
+      UR_CHECK_ERROR(cuStreamCreateWithPriority(
+          &TransferStreams[NumTransferStreams++], Flags, Priority));
     }
   }
   uint32_t StreamI = TransferStreamIndex++ % TransferStreams.size();
@@ -130,6 +130,8 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
 
     unsigned int Flags = CU_STREAM_NON_BLOCKING;
     ur_queue_flags_t URFlags = 0;
+    // '0' is the default priority, per CUDA Toolkit 12.2 and earlier
+    int Priority = 0;
     bool IsOutOfOrder = false;
     if (pProps && pProps->stype == UR_STRUCTURE_TYPE_QUEUE_PROPERTIES) {
       URFlags = pProps->flags;
@@ -142,6 +144,13 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
       if (URFlags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) {
         IsOutOfOrder = true;
       }
+      if (URFlags & UR_QUEUE_FLAG_PRIORITY_HIGH) {
+        ScopedContext Active(hContext);
+        UR_CHECK_ERROR(cuCtxGetStreamPriorityRange(nullptr, &Priority));
+      } else if (URFlags & UR_QUEUE_FLAG_PRIORITY_LOW) {
+        ScopedContext Active(hContext);
+        UR_CHECK_ERROR(cuCtxGetStreamPriorityRange(&Priority, nullptr));
+      }
     }
 
     std::vector<CUstream> ComputeCuStreams(
@@ -151,7 +160,7 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
 
     Queue = std::unique_ptr<ur_queue_handle_t_>(new ur_queue_handle_t_{
         std::move(ComputeCuStreams), std::move(TransferCuStreams), hContext,
-        hDevice, Flags, URFlags});
+        hDevice, Flags, URFlags, Priority});
 
     *phQueue = Queue.release();
 

source/adapters/cuda/queue.hpp

@@ -49,6 +49,7 @@ struct ur_queue_handle_t_ {
   unsigned int LastSyncTransferStreams;
   unsigned int Flags;
   ur_queue_flags_t URFlags;
+  int Priority;
   // When ComputeStreamSyncMutex and ComputeStreamMutex both need to be
   // locked at the same time, ComputeStreamSyncMutex should be locked first
   // to avoid deadlocks
@@ -61,7 +62,7 @@ struct ur_queue_handle_t_ {
   ur_queue_handle_t_(std::vector<CUstream> &&ComputeStreams,
                      std::vector<CUstream> &&TransferStreams,
                      ur_context_handle_t_ *Context, ur_device_handle_t_ *Device,
-                     unsigned int Flags, ur_queue_flags_t URFlags,
+                     unsigned int Flags, ur_queue_flags_t URFlags, int Priority,
                      bool BackendOwns = true)
       : ComputeStreams{std::move(ComputeStreams)}, TransferStreams{std::move(
                                                        TransferStreams)},
@@ -71,7 +72,7 @@ struct ur_queue_handle_t_ {
         Device{Device}, RefCount{1}, EventCount{0}, ComputeStreamIndex{0},
         TransferStreamIndex{0}, NumComputeStreams{0}, NumTransferStreams{0},
         LastSyncComputeStreams{0}, LastSyncTransferStreams{0}, Flags(Flags),
-        URFlags(URFlags), HasOwnership{BackendOwns} {
+        URFlags(URFlags), Priority(Priority), HasOwnership{BackendOwns} {
     urContextRetain(Context);
     urDeviceRetain(Device);
   }