[SYCL] Fix UserData usage for XPTIScope (#11091)

Aligned node_create usage with
https://github.com/intel/llvm/blob/sycl/sycl/doc/design/SYCLInstrumentationUsingXPTI.md

---------

Signed-off-by: Tikhomirova, Kseniya <[email protected]>

Author: KseniyaTikhomirova

sycl/source/detail/queue_impl.cpp

@@ -67,7 +67,7 @@ event queue_impl::memset(const std::shared_ptr<detail::queue_impl> &Self,
   // information
   XPTIScope PrepareNotify((void *)this,
                           (uint16_t)xpti::trace_point_type_t::node_create,
-                          SYCL_MEM_ALLOC_STREAM_NAME, "queue.memset()");
+                          SYCL_STREAM_NAME, "memory_transfer_node");
   PrepareNotify.addMetadata([&](auto TEvent) {
     xpti::addMetadata(TEvent, "sycl_device",
                       reinterpret_cast<size_t>(
@@ -143,7 +143,7 @@ event queue_impl::memcpy(const std::shared_ptr<detail::queue_impl> &Self,
   // pointer.
   XPTIScope PrepareNotify((void *)this,
                           (uint16_t)xpti::trace_point_type_t::node_create,
-                          SYCL_MEM_ALLOC_STREAM_NAME, "queue.memcpy()");
+                          SYCL_STREAM_NAME, "memory_transfer_node");
   PrepareNotify.addMetadata([&](auto TEvent) {
     xpti::addMetadata(TEvent, "sycl_device",
                       reinterpret_cast<size_t>(

sycl/source/detail/xpti_registry.hpp

@@ -178,17 +178,12 @@ class XPTIScope {
         MTraceType(0) {
     detail::tls_code_loc_t Tls;
     auto TData = Tls.query();
-    // If TLS is not set, we can still genertate universal IDs with user data
-    // and CodePtr information
-    const char *FuncName = UserData;
-    if (TData.functionName())
-      FuncName = TData.functionName();
     // Create a tracepoint object that has a lifetime of this class
-    MTP = new TracePoint(TData.fileName(), FuncName, TData.lineNumber(),
-                         TData.columnNumber(), CodePtr);
-    if (MTraceType == (uint16_t)xpti::trace_point_type_t::graph_create ||
-        MTraceType == (uint16_t)xpti::trace_point_type_t::node_create ||
-        MTraceType == (uint16_t)xpti::trace_point_type_t::edge_create)
+    MTP = new TracePoint(TData.fileName(), TData.functionName(),
+                         TData.lineNumber(), TData.columnNumber(), CodePtr);
+    if (TraceType == (uint16_t)xpti::trace_point_type_t::graph_create ||
+        TraceType == (uint16_t)xpti::trace_point_type_t::node_create ||
+        TraceType == (uint16_t)xpti::trace_point_type_t::edge_create)
       MTP->parent_event(GSYCLGraphEvent);
     // Now if tracing is enabled, create trace events and notify
     if (xptiTraceEnabled() && MTP) {

sycl/test-e2e/XPTI/basic_event_collection_linux.cpp

@@ -34,7 +34,6 @@
 // CHECK-NEXT:   kernel_name : virtual_node[{{.*}}]
 // CHECK-NEXT: Edge create
 // CHECK-NEXT:   event : {{.*}}
-// CHECK-NEXT:   kernel_name : virtual_node[{{.*}}]
 // CHECK-NEXT: Task begin
 // CHECK-DAG:    sym_line_no : {{.*}}
 // CHECK-DAG:    sym_source_file_name : {{.*}}
@@ -62,7 +61,22 @@
 // CHECK-NEXT: Wait begin
 // CHECK-NEXT: PI Call Begin : piEventsWait
 // CHECK-NEXT: Wait end
+// CHECK-NEXT: Node create
+// CHECK-DAG:    memory_size : {{.*}}
+// CHECK-DAG:    dest_memory_ptr : {{.*}}
+// CHECK-DAG:    src_memory_ptr : {{.*}}
+// CHECK-DAG:    sycl_device : {{.*}}
+// CHECK-NEXT: Task begin
+// CHECK-DAG:    memory_size : {{.*}}
+// CHECK-DAG:    dest_memory_ptr : {{.*}}
+// CHECK-DAG:    src_memory_ptr : {{.*}}
+// CHECK-DAG:    sycl_device : {{.*}}
 // CHECK-NEXT: PI Call Begin : piextUSMEnqueueMemcpy
+// CHECK-NEXT: Task end
+// CHECK-DAG:    memory_size : {{.*}}
+// CHECK-DAG:    dest_memory_ptr : {{.*}}
+// CHECK-DAG:    src_memory_ptr : {{.*}}
+// CHECK-DAG:    sycl_device : {{.*}}
 // CHECK-NEXT: PI Call Begin : piEventRelease
 // CHECK-NEXT: Wait begin
 // CHECK:        sycl_device : {{.*}}

sycl/unittests/xpti_trace/NodeCreation.cpp

@@ -88,3 +88,34 @@ TEST_F(NodeCreation, QueueParallelForWithNoGraphNode) {
   EXPECT_EQ(TraceType, xpti::trace_node_create);
   EXPECT_THAT(Message, HasSubstr("TestKernel"));
 }
+
+TEST_F(NodeCreation, QueueMemcpyNode) {
+  sycl::queue Q;
+
+  constexpr int n = 10 * sizeof(double);
+  double HostPtr[n];
+  double *DeviceUSMPtr = (double *)sycl::malloc_device(n, Q);
+  Q.memcpy(DeviceUSMPtr, HostPtr, n).wait();
+  sycl::free(DeviceUSMPtr, Q);
+
+  uint16_t TraceType = 0;
+  std::string Message;
+  ASSERT_TRUE(queryReceivedNotifications(TraceType, Message));
+  EXPECT_EQ(TraceType, xpti::trace_node_create);
+  EXPECT_THAT(Message, HasSubstr("memory_transfer_node"));
+}
+
+TEST_F(NodeCreation, QueueMemsetNode) {
+  sycl::queue Q;
+
+  constexpr int n = 10 * sizeof(double);
+  double *DeviceUSMPtr = (double *)sycl::malloc_device(n, Q);
+  Q.memset(DeviceUSMPtr, 0, n).wait();
+  sycl::free(DeviceUSMPtr, Q);
+
+  uint16_t TraceType = 0;
+  std::string Message;
+  ASSERT_TRUE(queryReceivedNotifications(TraceType, Message));
+  EXPECT_EQ(TraceType, xpti::trace_node_create);
+  EXPECT_THAT(Message, HasSubstr("memory_transfer_node"));
+}

sycl/unittests/xpti_trace/xptitest_subscriber/XPTISubscriber.cpp

@@ -48,14 +48,19 @@ XPTI_CALLBACK_API void testCallback(uint16_t TraceType,
     AggregatedData.append(static_cast<const char *>(UserData));
     GReceivedNotifications.push_back(std::make_pair(TraceType, AggregatedData));
   } else if (TraceType == xpti::trace_node_create) {
-    auto Payload = xptiQueryPayload(Event);
-    xpti::metadata_t *Metadata = xptiQueryMetadata(Event);
-    for (const auto &Item : *Metadata) {
-      std::string_view Key{xptiLookupString(Item.first)};
-      if (Key == "kernel_name") {
-        GReceivedNotifications.push_back(
-            std::make_pair(TraceType, Payload->name));
+    std::string UData(static_cast<const char *>(UserData));
+    if (UData.find("command_group_node") != std::string::npos) {
+      auto Payload = xptiQueryPayload(Event);
+      xpti::metadata_t *Metadata = xptiQueryMetadata(Event);
+      for (const auto &Item : *Metadata) {
+        std::string_view Key{xptiLookupString(Item.first)};
+        if (Key == "kernel_name") {
+          GReceivedNotifications.push_back(
+              std::make_pair(TraceType, UData + std::string(Payload->name)));
+        }
       }
+    } else if (UData.find("memory_transfer_node") != std::string::npos) {
+      GReceivedNotifications.push_back(std::make_pair(TraceType, UData));
     }
   }
 }