[SYCL] Remove fallback profiling (#18303)

Remove the fallback queue profiling. This seems no longer relevant, and
if it is, should be handled inside UR anyway.

---------

Signed-off-by: James Brodman <james.brodman@intel.com>

Author: jbrodman

sycl/source/detail/device_global_map_entry.cpp

@@ -79,8 +79,7 @@ DeviceGlobalUSMMem &DeviceGlobalMapEntry::getOrAllocateDeviceGlobalUSM(
                                 reinterpret_cast<uintptr_t>(MDeviceGlobalPtr) +
                                 sizeof(MDeviceGlobalPtr)),
                             QueueImpl, MDeviceGlobalTSize, NewAlloc.MPtr,
-                            std::vector<ur_event_handle_t>{}, &InitEvent,
-                            nullptr);
+                            std::vector<ur_event_handle_t>{}, &InitEvent);
     NewAlloc.MInitEvent = InitEvent;
   }
 

sycl/source/detail/device_impl.cpp

@@ -881,14 +881,6 @@ uint64_t device_impl::getCurrentDeviceTime() {
   return MDeviceHostBaseTime.first + Diff;
 }
 
-bool device_impl::isGetDeviceAndHostTimerSupported() {
-  const auto &Adapter = getAdapter();
-  uint64_t DeviceTime = 0, HostTime = 0;
-  auto Result = Adapter->call_nocheck<UrApiKind::urDeviceGetGlobalTimestamps>(
-      MDevice, &DeviceTime, &HostTime);
-  return Result != UR_RESULT_ERROR_INVALID_OPERATION;
-}
-
 bool device_impl::extOneapiCanBuild(
     ext::oneapi::experimental::source_language Language) {
   try {

sycl/source/detail/device_impl.hpp

@@ -280,10 +280,6 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
   /// @throw sycl::feature_not_supported if feature is not supported on device
   uint64_t getCurrentDeviceTime();
 
-  /// Check clGetDeviceAndHostTimer is available for fallback profiling
-
-  bool isGetDeviceAndHostTimerSupported();
-
   /// Get the backend of this device
   backend getBackend() const { return MPlatform->getBackend(); }
 

sycl/source/detail/event_impl.cpp

@@ -160,9 +160,7 @@ event_impl::event_impl(ur_event_handle_t Event, const context &SyclContext)
 }
 
 event_impl::event_impl(const QueueImplPtr &Queue)
-    : MQueue{Queue}, MIsProfilingEnabled{!Queue || Queue->MIsProfilingEnabled},
-      MFallbackProfiling{MIsProfilingEnabled && Queue &&
-                         Queue->isProfilingFallback()} {
+    : MQueue{Queue}, MIsProfilingEnabled{!Queue || Queue->MIsProfilingEnabled} {
   if (Queue)
     this->setContextImpl(Queue->getContextImplPtr());
   else {
@@ -181,7 +179,6 @@ event_impl::event_impl(const QueueImplPtr &Queue)
 void event_impl::setQueue(const QueueImplPtr &Queue) {
   MQueue = Queue;
   MIsProfilingEnabled = Queue->MIsProfilingEnabled;
-  MFallbackProfiling = MIsProfilingEnabled && Queue->isProfilingFallback();
 
   // TODO After setting the queue, the event is no longer default
   // constructed. Consider a design change which would allow
@@ -348,17 +345,8 @@ event_impl::get_profiling_info<info::event_profiling::command_start>() {
   if (!MIsHostEvent) {
     auto Handle = getHandle();
     if (Handle) {
-      auto StartTime =
-          get_event_profiling_info<info::event_profiling::command_start>(
-              Handle, this->getAdapter());
-      if (!MFallbackProfiling) {
-        return StartTime;
-      } else {
-        auto DeviceBaseTime =
-            get_event_profiling_info<info::event_profiling::command_submit>(
-                Handle, this->getAdapter());
-        return MHostBaseTime - DeviceBaseTime + StartTime;
-      }
+      return get_event_profiling_info<info::event_profiling::command_start>(
+          Handle, this->getAdapter());
     }
     return 0;
   }
@@ -376,17 +364,8 @@ uint64_t event_impl::get_profiling_info<info::event_profiling::command_end>() {
   if (!MIsHostEvent) {
     auto Handle = this->getHandle();
     if (Handle) {
-      auto EndTime =
-          get_event_profiling_info<info::event_profiling::command_end>(
-              Handle, this->getAdapter());
-      if (!MFallbackProfiling) {
-        return EndTime;
-      } else {
-        auto DeviceBaseTime =
-            get_event_profiling_info<info::event_profiling::command_submit>(
-                Handle, this->getAdapter());
-        return MHostBaseTime - DeviceBaseTime + EndTime;
-      }
+      return get_event_profiling_info<info::event_profiling::command_end>(
+          Handle, this->getAdapter());
     }
     return 0;
   }
@@ -587,40 +566,27 @@ void event_impl::cleanDepEventsThroughOneLevel() {
 void event_impl::setSubmissionTime() {
   if (!MIsProfilingEnabled && !MProfilingTagEvent)
     return;
-  if (!MFallbackProfiling) {
-    if (QueueImplPtr Queue = MQueue.lock()) {
-      try {
-        MSubmitTime = Queue->getDeviceImpl().getCurrentDeviceTime();
-      } catch (sycl::exception &e) {
-        if (e.code() == sycl::errc::feature_not_supported)
-          throw sycl::exception(
-              make_error_code(errc::profiling),
-              std::string("Unable to get command group submission time: ") +
-                  e.what());
-        std::rethrow_exception(std::current_exception());
-      }
-    } else {
-      // Returning host time
-      using namespace std::chrono;
-      MSubmitTime =
-          duration_cast<nanoseconds>(steady_clock::now().time_since_epoch())
-              .count();
+
+  if (QueueImplPtr Queue = MQueue.lock()) {
+    try {
+      MSubmitTime = Queue->getDeviceImpl().getCurrentDeviceTime();
+    } catch (sycl::exception &e) {
+      if (e.code() == sycl::errc::feature_not_supported)
+        throw sycl::exception(
+            make_error_code(errc::profiling),
+            std::string("Unable to get command group submission time: ") +
+                e.what());
+      std::rethrow_exception(std::current_exception());
     }
   } else {
-    // Capture the host timestamp for a return value of function call
-    // <info::event_profiling::command_submit>. See MFallbackProfiling
-    MSubmitTime = getTimestamp();
+    // Returning host time
+    using namespace std::chrono;
+    MSubmitTime =
+        duration_cast<nanoseconds>(steady_clock::now().time_since_epoch())
+            .count();
   }
 }
 
-void event_impl::setHostEnqueueTime() {
-  if (!MIsProfilingEnabled || !MFallbackProfiling)
-    return;
-  // Capture a host timestamp to use normalize profiling time in
-  // <command_start> and <command_end>. See MFallbackProfiling
-  MHostBaseTime = getTimestamp();
-}
-
 uint64_t event_impl::getSubmissionTime() { return MSubmitTime; }
 
 bool event_impl::isCompleted() {

sycl/source/detail/event_impl.hpp

@@ -255,10 +255,6 @@ class event_impl {
   /// submission time for the command associated with this event.
   void setSubmissionTime();
 
-  /// Calling this function to capture the host timestamp to use
-  /// profiling base time. See MFallbackProfiling
-  void setHostEnqueueTime();
-
   /// @return Submission time for command associated with this event
   uint64_t getSubmissionTime();
 
@@ -365,13 +361,11 @@ class event_impl {
   std::atomic<ur_event_handle_t> MEvent = nullptr;
   // Stores submission time of command associated with event
   uint64_t MSubmitTime = 0;
-  uint64_t MHostBaseTime = 0;
   ContextImplPtr MContext;
   std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
   void *MCommand = nullptr;
   std::weak_ptr<queue_impl> MQueue;
   bool MIsProfilingEnabled = false;
-  bool MFallbackProfiling = false;
 
   std::weak_ptr<queue_impl> MWorkerQueue;
   std::weak_ptr<queue_impl> MSubmittedQueue;

sycl/source/detail/graph_impl.cpp

@@ -1043,7 +1043,6 @@ exec_graph_impl::enqueue(const std::shared_ptr<sycl::detail::queue_impl> &Queue,
       // enqueue it directly
       if (CGData.MRequirements.empty() && CGData.MEvents.empty()) {
         NewEvent->setSubmissionTime();
-        NewEvent->setHostEnqueueTime();
         ur_result_t Res =
             Queue->getAdapter()
                 ->call_nocheck<