Introduce ur.call.debug stream for tracepoints with source info

Author: againull

sycl/tools/sycl-trace/collector.cpp

@@ -180,7 +180,8 @@ XPTI_CALLBACK_API void xptiTraceInit(unsigned int /*major_version*/,
                                      unsigned int /*minor_version*/,
                                      const char * /*version_str*/,
                                      const char *StreamName) {
-  if (std::string_view(StreamName) == "ur.call" &&
+  if ((std::string_view(StreamName) == "ur.call" ||
+       std::string_view(StreamName) == "ur.call.debug") &&
       std::getenv("SYCL_TRACE_UR_ENABLE")) {
     urPrintersInit();
     uint16_t StreamID = xptiRegisterStream(StreamName);
@@ -237,7 +238,8 @@ XPTI_CALLBACK_API void xptiTraceInit(unsigned int /*major_version*/,
 }
 
 XPTI_CALLBACK_API void xptiTraceFinish(const char *StreamName) {
-  if (std::string_view(StreamName) == "ur.call" &&
+  if ((std::string_view(StreamName) == "ur.call" ||
+       std::string_view(StreamName) == "ur.call.debug") &&
       std::getenv("SYCL_TRACE_UR_ENABLE"))
     urPrintersFinish();
 #ifdef SYCL_HAS_LEVEL_ZERO

unified-runtime/source/loader/layers/tracing/ur_tracing_layer.cpp

@@ -24,6 +24,7 @@ namespace ur_tracing_layer {
 context_t *getContext() { return context_t::get_direct(); }
 
 constexpr auto CALL_STREAM_NAME = "ur.call";
+constexpr auto DEBUG_CALL_STREAM_NAME = "ur.call.debug";
 constexpr auto STREAM_VER_MAJOR = UR_MAJOR_VERSION(UR_API_VERSION_CURRENT);
 constexpr auto STREAM_VER_MINOR = UR_MINOR_VERSION(UR_API_VERSION_CURRENT);
 
@@ -51,10 +52,13 @@ context_t::context_t() : logger(logger::create_logger("tracing", true, true)) {
   this->xptiContextManager = xptiContextManagerGet();
 
   call_stream_id = xptiRegisterStream(CALL_STREAM_NAME);
+  debug_call_stream_id = xptiRegisterStream(DEBUG_CALL_STREAM_NAME);
   std::ostringstream streamv;
   streamv << STREAM_VER_MAJOR << "." << STREAM_VER_MINOR;
   xptiInitialize(CALL_STREAM_NAME, STREAM_VER_MAJOR, STREAM_VER_MINOR,
                  streamv.str().data());
+  xptiInitialize(DEBUG_CALL_STREAM_NAME, STREAM_VER_MAJOR, STREAM_VER_MINOR,
+                 streamv.str().data());
   // Create global event for all UR API calls.
   xpti_tracepoint_t *Event =
       xptiCreateTracepoint("Unified Runtime call", nullptr, 0, 0, (void *)this);
@@ -66,35 +70,36 @@ context_t::context_t() : logger(logger::create_logger("tracing", true, true)) {
 void context_t::notify(uint16_t trace_type, uint32_t id, const char *name,
                        void *args, ur_result_t *resultp, uint64_t instance) {
   xpti::function_with_args_t payload{id, name, args, resultp, nullptr};
-  // Use global event for all UR API calls
-  xptiNotifySubscribers(call_stream_id, trace_type, nullptr, activeEvent,
-                        instance, &payload);
+  if (xptiCheckTraceEnabled(debug_call_stream_id)) {
+    xptiNotifySubscribers(debug_call_stream_id, trace_type, nullptr,
+                          activeEvent, instance, &payload);
+  } else {
+    // Use global event for all UR API calls
+    if (xptiCheckTraceEnabled(call_stream_id))
+      xptiNotifySubscribers(call_stream_id, trace_type, nullptr, activeEvent,
+                            instance, &payload);
+  }
 }
 
 uint64_t context_t::notify_begin(uint32_t id, const char *name, void *args) {
-  // we use UINT64_MAX as a special value that means "tracing disabled",
-  // so that we don't have to repeat this check in notify_end.
-  if (!xptiCheckTraceEnabled(call_stream_id)) {
+  if (xptiCheckTraceEnabled(debug_call_stream_id)) {
+    // Create a new tracepoint with code location info for each UR API call.
+    // This adds significant overhead to the tracing toolchain, so do this only
+    // if there are debug stream subscribers.
+    if (auto loc = codelocData.get_codeloc()) {
+      xpti_tracepoint_t *Event = xptiCreateTracepoint(
+          loc->functionName, loc->sourceFile, loc->lineNumber,
+          loc->columnNumber, (void *)this);
+      activeEvent = Event ? Event->event_ref() : nullptr;
+    }
+  } else if (xptiCheckTraceEnabled(call_stream_id)) {
+    // Otherwise use global event for all UR API calls.
+    activeEvent = GURCallEvent;
+  } else {
+    // We use UINT64_MAX as a special value that means "tracing disabled",
+    // so that we don't have to repeat this check in notify_end.
     return UINT64_MAX;
   }
-
-  //  Previous implementation created a new event for each UR API call. This
-  //  adds significant overhead to the tracing toolchain. Replacing the
-  //  previous code with a single global event for all UR API calls:
-  //
-  //  PREVIOUS CODE:
-  //  if (auto loc = codelocData.get_codeloc()) {
-  //    xpti::payload_t payload =
-  //        xpti::payload_t(loc->functionName, loc->sourceFile, loc->lineNumber,
-  //                        loc->columnNumber, nullptr);
-  //    uint64_t InstanceNumber{};
-  //    activeEvent =
-  //        xptiMakeEvent("Unified Runtime call", &payload,
-  //        xpti::trace_graph_event,
-  //                      xpti_at::active, &InstanceNumber);
-  //  }
-
-  activeEvent = GURCallEvent;
   uint64_t instance = xptiGetUniqueId();
   notify((uint16_t)xpti::trace_point_type_t::function_with_args_begin, id, name,
          args, nullptr, instance);

unified-runtime/source/loader/layers/tracing/ur_tracing_layer.hpp

@@ -48,6 +48,7 @@ class __urdlllocal context_t : public proxy_layer_context_t,
   void notify(uint16_t trace_type, uint32_t id, const char *name, void *args,
               ur_result_t *resultp, uint64_t instance);
   uint8_t call_stream_id;
+  uint8_t debug_call_stream_id;
 
   inline static const std::string name = "UR_LAYER_TRACING";