Create stream vectors in queue constructor (#17823)

This patch simplifies the stream queue constructor by using in-class
initialization when appropriate. And uses the constructors to initialize
the stream vectors.

Author: npmiller

source/adapters/cuda/queue.cpp

@@ -86,14 +86,8 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
       }
     }
 
-    std::vector<CUstream> ComputeCuStreams(
-        IsOutOfOrder ? ur_queue_handle_t_::DefaultNumComputeStreams : 1);
-    std::vector<CUstream> TransferCuStreams(
-        IsOutOfOrder ? ur_queue_handle_t_::DefaultNumTransferStreams : 0);
-
     Queue = std::unique_ptr<ur_queue_handle_t_>(new ur_queue_handle_t_{
-        std::move(ComputeCuStreams), std::move(TransferCuStreams), hContext,
-        hDevice, Flags, URFlags, Priority});
+        IsOutOfOrder, hContext, hDevice, Flags, URFlags, Priority});
 
     *phQueue = Queue.release();
 
@@ -205,23 +199,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   else
     die("Unknown cuda stream");
 
-  std::vector<CUstream> ComputeCuStreams(1, CuStream);
-  std::vector<CUstream> TransferCuStreams(0);
-
   auto isNativeHandleOwned =
       pProperties ? pProperties->isNativeHandleOwned : false;
 
-  // Create queue and set num_compute_streams to 1, as computeCuStreams has
-  // valid stream
-  *phQueue = new ur_queue_handle_t_{std::move(ComputeCuStreams),
-                                    std::move(TransferCuStreams),
-                                    hContext,
-                                    hDevice,
-                                    CuFlags,
-                                    Flags,
-                                    /*priority*/ 0,
-                                    /*backend_owns*/ isNativeHandleOwned};
-  (*phQueue)->NumComputeStreams = 1;
+  // Create queue from a native stream
+  *phQueue = new ur_queue_handle_t_{CuStream, hContext, hDevice,
+                                    CuFlags,  Flags,    isNativeHandleOwned};
 
   return UR_RESULT_SUCCESS;
 }

source/adapters/hip/queue.cpp

@@ -75,14 +75,8 @@ urQueueCreate(ur_context_handle_t hContext, ur_device_handle_t hDevice,
         pProps ? pProps->flags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE
                : false;
 
-    std::vector<hipStream_t> ComputeHipStreams(
-        IsOutOfOrder ? ur_queue_handle_t_::DefaultNumComputeStreams : 1);
-    std::vector<hipStream_t> TransferHipStreams(
-        IsOutOfOrder ? ur_queue_handle_t_::DefaultNumTransferStreams : 0);
-
     QueueImpl = std::unique_ptr<ur_queue_handle_t_>(new ur_queue_handle_t_{
-        std::move(ComputeHipStreams), std::move(TransferHipStreams), hContext,
-        hDevice, Flags, URFlags, Priority});
+        IsOutOfOrder, hContext, hDevice, Flags, URFlags, Priority});
 
     *phQueue = QueueImpl.release();
 
@@ -239,23 +233,13 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   else
     die("Unknown hip stream");
 
-  std::vector<hipStream_t> ComputeHIPStreams(1, HIPStream);
-  std::vector<hipStream_t> TransferHIPStreams(0);
-
   auto isNativeHandleOwned =
       pProperties ? pProperties->isNativeHandleOwned : false;
 
   // Create queue and set num_compute_streams to 1, as computeHIPStreams has
   // valid stream
-  *phQueue = new ur_queue_handle_t_{std::move(ComputeHIPStreams),
-                                    std::move(TransferHIPStreams),
-                                    hContext,
-                                    hDevice,
-                                    HIPFlags,
-                                    Flags,
-                                    /*priority*/ 0,
-                                    /*backend_owns*/ isNativeHandleOwned};
-  (*phQueue)->NumComputeStreams = 1;
+  *phQueue = new ur_queue_handle_t_{HIPStream, hContext, hDevice,
+                                    HIPFlags,  Flags,    isNativeHandleOwned};
 
   return UR_RESULT_SUCCESS;
 }

source/common/cuda-hip/stream_queue.hpp

@@ -42,14 +42,14 @@ template <typename ST, int CS, int TS> struct stream_queue_t {
   std::vector<bool> TransferAppliedBarrier;
   ur_context_handle_t_ *Context;
   ur_device_handle_t_ *Device;
-  std::atomic_uint32_t RefCount;
-  std::atomic_uint32_t EventCount;
-  std::atomic_uint32_t ComputeStreamIndex;
-  std::atomic_uint32_t TransferStreamIndex;
-  unsigned int NumComputeStreams;
-  unsigned int NumTransferStreams;
-  unsigned int LastSyncComputeStreams;
-  unsigned int LastSyncTransferStreams;
+  std::atomic_uint32_t RefCount{1};
+  std::atomic_uint32_t EventCount{0};
+  std::atomic_uint32_t ComputeStreamIndex{0};
+  std::atomic_uint32_t TransferStreamIndex{0};
+  unsigned int NumComputeStreams{0};
+  unsigned int NumTransferStreams{0};
+  unsigned int LastSyncComputeStreams{0};
+  unsigned int LastSyncTransferStreams{0};
   unsigned int Flags;
   ur_queue_flags_t URFlags;
   int Priority;
@@ -62,20 +62,29 @@ template <typename ST, int CS, int TS> struct stream_queue_t {
   std::mutex BarrierMutex;
   bool HasOwnership;
 
-  stream_queue_t(std::vector<native_type> &&ComputeStreams,
-                 std::vector<native_type> &&TransferStreams,
-                 ur_context_handle_t_ *Context, ur_device_handle_t_ *Device,
-                 unsigned int Flags, ur_queue_flags_t URFlags, int Priority,
-                 bool BackendOwns = true)
-      : ComputeStreams{std::move(ComputeStreams)},
-        TransferStreams{std::move(TransferStreams)},
+  stream_queue_t(bool IsOutOfOrder, ur_context_handle_t_ *Context,
+                 ur_device_handle_t_ *Device, unsigned int Flags,
+                 ur_queue_flags_t URFlags, int Priority)
+      : ComputeStreams(IsOutOfOrder ? DefaultNumComputeStreams : 1),
+        TransferStreams(IsOutOfOrder ? DefaultNumTransferStreams : 0),
         DelayCompute(this->ComputeStreams.size(), false),
         ComputeAppliedBarrier(this->ComputeStreams.size()),
         TransferAppliedBarrier(this->TransferStreams.size()), Context{Context},
-        Device{Device}, RefCount{1}, EventCount{0}, ComputeStreamIndex{0},
-        TransferStreamIndex{0}, NumComputeStreams{0}, NumTransferStreams{0},
-        LastSyncComputeStreams{0}, LastSyncTransferStreams{0}, Flags(Flags),
-        URFlags(URFlags), Priority(Priority), HasOwnership{BackendOwns} {
+        Device{Device}, Flags(Flags), URFlags(URFlags), Priority(Priority),
+        HasOwnership{true} {
+    urContextRetain(Context);
+  }
+
+  // Create a queue from a native handle
+  stream_queue_t(native_type stream, ur_context_handle_t_ *Context,
+                 ur_device_handle_t_ *Device, unsigned int Flags,
+                 ur_queue_flags_t URFlags, bool BackendOwns)
+      : ComputeStreams(1, stream), TransferStreams(0),
+        DelayCompute(this->ComputeStreams.size(), false),
+        ComputeAppliedBarrier(this->ComputeStreams.size()),
+        TransferAppliedBarrier(this->TransferStreams.size()), Context{Context},
+        Device{Device}, NumComputeStreams{1}, Flags(Flags), URFlags(URFlags),
+        Priority(0), HasOwnership{BackendOwns} {
     urContextRetain(Context);
   }