Changed naming nad removed boolean var

Author: keyradical

source/adapters/cuda/event.cpp

@@ -55,7 +55,7 @@ ur_result_t ur_event_handle_t_::start() {
 
   try {
     if (Queue->URFlags & UR_QUEUE_FLAG_PROFILING_ENABLE || isTimestampEvent()) {
-      UR_CHECK_ERROR(cuEventRecord(EvQueued, Queue->getProfilingStream()));
+      UR_CHECK_ERROR(cuEventRecord(EvQueued, Queue->getHostSubmitTimeStream()));
       UR_CHECK_ERROR(cuEventRecord(EvStart, Stream));
     }
   } catch (ur_result_t Err) {

source/adapters/cuda/queue.cpp

@@ -201,9 +201,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueRelease(ur_queue_handle_t hQueue) {
       UR_CHECK_ERROR(cuStreamDestroy(S));
     });
 
-    if (hQueue->IsProfStreamCreated) {
-      UR_CHECK_ERROR(cuStreamSynchronize(hQueue->getProfilingStream()));
-      UR_CHECK_ERROR(cuStreamDestroy(hQueue->getProfilingStream()));
+    if (hQueue->getHostSubmitTimeStream() != CUstream{0}) {
+      UR_CHECK_ERROR(cuStreamSynchronize(hQueue->getHostSubmitTimeStream()));
+      UR_CHECK_ERROR(cuStreamDestroy(hQueue->getHostSubmitTimeStream()));
     }
 
     return UR_RESULT_SUCCESS;

source/adapters/cuda/queue.hpp

@@ -29,10 +29,9 @@ struct ur_queue_handle_t_ {
 
   std::vector<native_type> ComputeStreams;
   std::vector<native_type> TransferStreams;
-  // Stream used solely when profiling is enabled
-  native_type ProfStream;
-  bool IsProfStreamCreated{false};
-  std::once_flag ProfStreamFlag;
+  // Stream used for recording EvQueue. It is created only if profiling is
+  // enabled - either for the queue or per event.
+  native_type HostSubmitTimeStream{0};
   // delay_compute_ keeps track of which streams have been recently reused and
   // their next use should be delayed. If a stream has been recently reused it
   // will be skipped the next time it would be selected round-robin style. When
@@ -108,14 +107,14 @@ struct ur_queue_handle_t_ {
   // Function which creates the profiling stream. Called only if profiling is
   // enabled.
   void createProfilingStream() {
-    std::call_once(ProfStreamFlag, [&]() {
-      UR_CHECK_ERROR(
-          cuStreamCreateWithPriority(&ProfStream, CU_STREAM_NON_BLOCKING, 0));
-      IsProfStreamCreated = true;
+    static std::once_flag HostSubmitTimeStreamFlag;
+    std::call_once(HostSubmitTimeStreamFlag, [&]() {
+      UR_CHECK_ERROR(cuStreamCreateWithPriority(&HostSubmitTimeStream,
+                                                CU_STREAM_NON_BLOCKING, 0));
     });
   }
 
-  native_type getProfilingStream() { return ProfStream; }
+  native_type getHostSubmitTimeStream() { return HostSubmitTimeStream; }
 
   bool hasBeenSynchronized(uint32_t StreamToken) {
     // stream token not associated with one of the compute streams

source/adapters/hip/event.cpp

@@ -50,7 +50,8 @@ ur_result_t ur_event_handle_t_::start() {
 
   try {
     if (Queue->URFlags & UR_QUEUE_FLAG_PROFILING_ENABLE || isTimestampEvent()) {
-      UR_CHECK_ERROR(hipEventRecord(EvQueued, Queue->getProfilingStream()));
+      UR_CHECK_ERROR(
+          hipEventRecord(EvQueued, Queue->getHostSubmitTimeStream()));
       UR_CHECK_ERROR(hipEventRecord(EvStart, Stream));
     }
   } catch (ur_result_t Error) {

source/adapters/hip/queue.cpp

@@ -222,9 +222,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueRelease(ur_queue_handle_t hQueue) {
       UR_CHECK_ERROR(hipStreamDestroy(S));
     });
 
-    if (hQueue->IsProfStreamCreated) {
-      UR_CHECK_ERROR(hipStreamSynchronize(hQueue->getProfilingStream()));
-      UR_CHECK_ERROR(hipStreamDestroy(hQueue->getProfilingStream()));
+    if (hQueue->getHostSubmitTimeStream() != hipStream_t{0}) {
+      UR_CHECK_ERROR(hipStreamSynchronize(hQueue->getHostSubmitTimeStream()));
+      UR_CHECK_ERROR(hipStreamDestroy(hQueue->getHostSubmitTimeStream()));
     }
 
     return UR_RESULT_SUCCESS;

source/adapters/hip/queue.hpp

@@ -25,10 +25,9 @@ struct ur_queue_handle_t_ {
 
   std::vector<native_type> ComputeStreams;
   std::vector<native_type> TransferStreams;
-  // Stream used solely when profiling is enabled
-  native_type ProfStream;
-  bool IsProfStreamCreated{false};
-  std::once_flag ProfStreamFlag;
+  // Stream used for recording EvQueue. It is created only if profiling is
+  // enabled - either for the queue or per event.
+  native_type HostSubmitTimeStream{0};
   // DelayCompute keeps track of which streams have been recently reused and
   // their next use should be delayed. If a stream has been recently reused it
   // will be skipped the next time it would be selected round-robin style. When
@@ -105,13 +104,13 @@ struct ur_queue_handle_t_ {
   // Function which creates the profiling stream. Called only if profiling is
   // enabled.
   void createProfilingStream() {
-    std::call_once(ProfStreamFlag, [&]() {
-      UR_CHECK_ERROR(
-          hipStreamCreateWithFlags(&ProfStream, hipStreamNonBlocking));
-      IsProfStreamCreated = true;
+    static std::once_flag HostSubmitTimeStreamFlag;
+    std::call_once(HostSubmitTimeStreamFlag, [&]() {
+      UR_CHECK_ERROR(hipStreamCreateWithFlags(&HostSubmitTimeStream,
+                                              hipStreamNonBlocking));
     });
   }
-  native_type getProfilingStream() { return ProfStream; }
+  native_type getHostSubmitTimeStream() { return HostSubmitTimeStream; }
 
   bool hasBeenSynchronized(uint32_t StreamToken) {
     // stream token not associated with one of the compute streams