[SYCL][XPTI] Pass plugin information to subscribers (#4121)

This patch makes the following additional information available to XPTI subscribers.
All streams:
- Actual major and minor versions of SYCL runtime (instead of dummy values) as well as their string variant.

`sycl.pi.debug` stream:
- Backend type, which is defined as a `uint8_t` value of `sycl::backend` enum.
- Pointer to PI plugin to provide some degree of application flow variance (e.g. query additional info about device, USM pointers, memory, etc).

sycl/include/CL/sycl/detail/pi.hpp

@@ -189,8 +189,10 @@ void emitFunctionEndTrace(uint64_t CorrelationID, const char *FName);
 /// \param FuncID is the API hash ID from PiApiID type trait.
 /// \param FName The name of the PI API call.
 /// \param ArgsData is a pointer to packed function call arguments.
+/// \param Plugin is the plugin, which is used to make call.
 uint64_t emitFunctionWithArgsBeginTrace(uint32_t FuncID, const char *FName,
- unsigned char *ArgsData);
+ unsigned char *ArgsData,
+ pi_plugin Plugin);
 
 /// Notifies XPTI subscribers about PI function call result.
 ///
@@ -200,9 +202,10 @@ uint64_t emitFunctionWithArgsBeginTrace(uint32_t FuncID, const char *FName,
 /// \param FName The name of the PI API call.
 /// \param ArgsData is a pointer to packed function call arguments.
 /// \param Result is function call result value.
+/// \param Plugin is the plugin, which is used to make call.
 void emitFunctionWithArgsEndTrace(uint64_t CorrelationID, uint32_t FuncID,
  const char *FName, unsigned char *ArgsData,
- pi_result Result);
+ pi_result Result, pi_plugin Plugin);
 
 // A wrapper for passing around byte array properties
 class ByteArray {

sycl/source/detail/pi.cpp

@@ -17,6 +17,7 @@
 #include <CL/sycl/detail/device_filter.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <CL/sycl/detail/stl_type_traits.hpp>
+#include <CL/sycl/version.hpp>
 #include <detail/config.hpp>
 #include <detail/global_handler.hpp>
 #include <detail/plugin.hpp>
@@ -36,6 +37,10 @@
 #include "xpti_trace_framework.h"
 #endif
 
+#define STR(x) #x
+#define SYCL_VERSION_STR \
+ "sycl " STR(__LIBSYCL_MAJOR_VERSION) "." STR(__LIBSYCL_MINOR_VERSION)
+
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
@@ -50,9 +55,9 @@ xpti_td *GPICallEvent = nullptr;
 xpti_td *GPIArgCallEvent = nullptr;
 /// Constants being used as placeholder until one is able to reliably get the
 /// version of the SYCL runtime
-constexpr uint32_t GMajVer = 1;
-constexpr uint32_t GMinVer = 0;
-constexpr const char *GVerStr = "sycl 1.0";
+constexpr uint32_t GMajVer = __LIBSYCL_MAJOR_VERSION;
+constexpr uint32_t GMinVer = __LIBSYCL_MINOR_VERSION;
+constexpr const char *GVerStr = SYCL_VERSION_STR;
 #endif // XPTI_ENABLE_INSTRUMENTATION
 
 template <cl::sycl::backend BE>
@@ -138,15 +143,16 @@ void emitFunctionEndTrace(uint64_t CorrelationID, const char *FName) {
 }
 
 uint64_t emitFunctionWithArgsBeginTrace(uint32_t FuncID, const char *FuncName,
- unsigned char *ArgsData) {
+ unsigned char *ArgsData,
+ pi_plugin Plugin) {
  uint64_t CorrelationID = 0;
 #ifdef XPTI_ENABLE_INSTRUMENTATION
  if (xptiTraceEnabled()) {
  uint8_t StreamID = xptiRegisterStream(SYCL_PIDEBUGCALL_STREAM_NAME);
  CorrelationID = xptiGetUniqueId();
 
  xpti::function_with_args_t Payload{FuncID, FuncName, ArgsData, nullptr,
- nullptr};
+ &Plugin};
 
  xptiNotifySubscribers(
  StreamID, (uint16_t)xpti::trace_point_type_t::function_with_args_begin,
@@ -158,13 +164,13 @@ uint64_t emitFunctionWithArgsBeginTrace(uint32_t FuncID, const char *FuncName,
 
 void emitFunctionWithArgsEndTrace(uint64_t CorrelationID, uint32_t FuncID,
  const char *FuncName, unsigned char *ArgsData,
- pi_result Result) {
+ pi_result Result, pi_plugin Plugin) {
 #ifdef XPTI_ENABLE_INSTRUMENTATION
  if (xptiTraceEnabled()) {
  uint8_t StreamID = xptiRegisterStream(SYCL_PIDEBUGCALL_STREAM_NAME);
 
  xpti::function_with_args_t Payload{FuncID, FuncName, ArgsData, &Result,
- nullptr};
+ &Plugin};
 
  xptiNotifySubscribers(
  StreamID, (uint16_t)xpti::trace_point_type_t::function_with_args_end,

sycl/source/detail/plugin.hpp

@@ -144,7 +144,7 @@ class plugin {
  auto ArgsData =
  packCallArguments<PiApiOffset>(std::forward<ArgsT>(Args)...);
  uint64_t CorrelationIDWithArgs = pi::emitFunctionWithArgsBeginTrace(
- static_cast<uint32_t>(PiApiOffset), PIFnName, ArgsData.data());
+ static_cast<uint32_t>(PiApiOffset), PIFnName, ArgsData.data(), MPlugin);
 #endif
  RT::PiResult R;
  if (pi::trace(pi::TraceLevel::PI_TRACE_CALLS)) {
@@ -165,7 +165,7 @@ class plugin {
  pi::emitFunctionEndTrace(CorrelationID, PIFnName);
  pi::emitFunctionWithArgsEndTrace(CorrelationIDWithArgs,
  static_cast<uint32_t>(PiApiOffset),
- PIFnName, ArgsData.data(), R);
+ PIFnName, ArgsData.data(), R, MPlugin);
 #endif
  return R;
  }

sycl/tools/pi-trace/pi_trace.cpp

@@ -51,12 +51,13 @@ XPTI_CALLBACK_API void xptiTraceInit(unsigned int /*major_version*/,
  tpCallback);
 
 #define _PI_API(api) \
- ArgHandler.set##_##api([](auto &&... Args) { \
- std::cout << "---> " << #api << "(" \
- << "\n"; \
- sycl::detail::pi::printArgs(Args...); \
- std::cout << ") ---> "; \
- });
+ ArgHandler.set##_##api( \
+ [](const pi_plugin &, std::optional<pi_result>, auto &&... Args) { \
+ std::cout << "---> " << #api << "(" \
+ << "\n"; \
+ sycl::detail::pi::printArgs(Args...); \
+ std::cout << ") ---> "; \
+ });
 #include <CL/sycl/detail/pi.def>
 #undef _PI_API
  }
@@ -77,8 +78,10 @@ XPTI_CALLBACK_API void tpCallback(uint16_t TraceType,
 
  const auto *Data =
  static_cast<const xpti::function_with_args_t *>(UserData);
+ const auto *Plugin = static_cast<pi_plugin *>(Data->user_data);
 
- ArgHandler.handle(Data->function_id, Data->args_data);
+ ArgHandler.handle(Data->function_id, *Plugin, std::nullopt,
+ Data->args_data);
  std::cout << *static_cast<pi_result *>(Data->ret_data) << "\n";
  }
 }

sycl/tools/xpti_helpers/pi_arguments_handler.hpp

@@ -1,4 +1,5 @@
 //==---------- pi_arguments_handler.hpp - PI call arguments handler --------==//
+// i
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -12,6 +13,7 @@
 #include <CL/sycl/detail/type_traits.hpp>
 
 #include <functional>
+#include <optional>
 #include <tuple>
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -41,7 +43,8 @@ inline TupleT unpack(char *Data,
 template <typename T> struct to_function {};
 
 template <typename... Args> struct to_function<std::tuple<Args...>> {
- using type = std::function<void(Args...)>;
+ using type =
+ std::function<void(const pi_plugin &, std::optional<pi_result>, Args...)>;
 };
 
 /// PiArgumentsHandler is a helper class to process incoming XPTI function call
@@ -59,10 +62,11 @@ template <typename... Args> struct to_function<std::tuple<Args...>> {
 /// See sycl/tools/pi-trace/ for an example.
 class PiArgumentsHandler {
 public:
- void handle(uint32_t ID, void *ArgsData) {
+ void handle(uint32_t ID, const pi_plugin &Plugin,
+ std::optional<pi_result> Result, void *ArgsData) {
 #define _PI_API(api) \
  if (ID == static_cast<uint32_t>(detail::PiApiKind::api)) { \
- MHandler##_##api(ArgsData);  \
+ MHandler##_##api(Plugin, Result, ArgsData); \
  return; \
  }
 #include <CL/sycl/detail/pi.def>
@@ -73,21 +77,27 @@ class PiArgumentsHandler {
  void set##_##api( \
  const typename to_function<typename detail::function_traits<decltype( \
  api)>::args_type>::type &Handler) { \
- MHandler##_##api = [Handler](void *Data) { \
+ MHandler##_##api = [Handler](const pi_plugin &Plugin, \
+ std::optional<pi_result> Res, void *Data) { \
  using TupleT = \
  typename detail::function_traits<decltype(api)>::args_type; \
  TupleT Tuple = unpack<TupleT>( \
  (char *)Data, \
  std::make_index_sequence<std::tuple_size<TupleT>::value>{}); \
- std::apply(Handler, Tuple); \
+ const auto Wrapper = [&Plugin, Res, Handler](auto &... Args) { \
+ Handler(Plugin, Res, Args...); \
+ }; \
+ std::apply(Wrapper, Tuple); \
  }; \
  }
 #include <CL/sycl/detail/pi.def>
 #undef _PI_API
 
 private:
 #define _PI_API(api) \
- std::function<void(void *)> MHandler##_##api = [](void *) {};
+ std::function<void(const pi_plugin &, std::optional<pi_result>, void *)> \
+ MHandler##_##api = \
+ [](const pi_plugin &, std::optional<pi_result>, void *) {};
 #include <CL/sycl/detail/pi.def>
 #undef _PI_API
 };

sycl/unittests/pi/pi_arguments_handler.cpp

@@ -20,21 +20,23 @@ TEST(PiArgumentsHandlerTest, CanUnpackArguments) {
  const pi_uint32 NumPlatforms = 42;
  pi_platform *Platforms = new pi_platform[NumPlatforms];
 
- Handler.set_piPlatformsGet(
- [&](pi_uint32 NP, pi_platform *Plts, pi_uint32 *Ret) {
- EXPECT_EQ(NP, NumPlatforms);
- EXPECT_EQ(Platforms, Plts);
- EXPECT_EQ(Ret, nullptr);
- });
+ Handler.set_piPlatformsGet([&](const pi_plugin &, std::optional<pi_result>,
+ pi_uint32 NP, pi_platform *Plts,
+ pi_uint32 *Ret) {
+ EXPECT_EQ(NP, NumPlatforms);
+ EXPECT_EQ(Platforms, Plts);
+ EXPECT_EQ(Ret, nullptr);
+ });
 
  constexpr size_t Size = sizeof(pi_uint32) + 2 * sizeof(void *);
  std::array<unsigned char, Size> Data{0};
  *reinterpret_cast<pi_uint32 *>(Data.data()) = NumPlatforms;
  *reinterpret_cast<pi_platform **>(Data.data() + sizeof(pi_uint32)) =
  Platforms;
 
+ pi_plugin Plugin{};
  uint32_t ID = static_cast<uint32_t>(sycl::detail::PiApiKind::piPlatformsGet);
- Handler.handle(ID, Data.data());
+ Handler.handle(ID, Plugin, std::nullopt, Data.data());
 
  delete[] Platforms;
 }