Run constructor Run wait and run start hook for temporal sharing usecase (Xilinx#9721)

* Add run_constructor XDP hook in xrt::run for per-run plugin callbacks

Call xrt_core::xdp::run_constructor from the xrt::run constructor,
passing the run pointer and hw_context_impl pointer. The hook
dispatches to aie::profile::run_constructor via dlsym-registered
callback (aieProfileRunConstructor), gated on get_aie_profile().
This enables XDP plugins to attach per-run resources at run
construction time.

Made-with: Cursor

* Pass run UID through run_constructor hook for CT filename

Thread the run_impl::get_uid() value as a uint32_t through the
entire hook chain so the per-run CT file is named with the actual
run UID (e.g. aie_profile_ctx_1_run_3.ct), matching the dtrace
dump naming convention (dtrace_dump_ctx_1_run_3_<timestamp>.py).

Made-with: Cursor

* Thread kernel_name and elf_handle through run_constructor XDP hook

Pass kernel name and ELF handle (from xrt::module) through the
run_constructor callback chain so the AIE profile plugin can extract
SAVE_TIMESTAMP locations directly from the ELF at run construction time.

Made-with: Cursor

* XRT: Wire AIE dtrace config and load xdp_aie_dtrace_plugin_xdna

Expose Debug.aie_dtrace and AIE_dtrace_settings (interval, tile- and
graph-based interface tile metrics) in config_reader.h for xrt.ini.

Register the xdp_aie_dtrace_plugin_xdna module loader in profile.cpp
when the XDP VE2 build supplies that shared library.

Bump the src/runtime_src/xdp submodule to pick up the AIE dtrace plugin
and related XDP profile changes.

Made-with: Cursor

* Remove AIE_profile_settings.dtrace_debug config reader

Delete get_aie_profile_settings_dtrace_debug(); AIE dtrace uses
Debug.aie_dtrace only (xdp submodule).

Made-with: Cursor

* Wire AIE dtrace run start and run wait hooks from xrt::run

Add xrt_core::xdp::run_start and run_wait APIs and load aieDtraceRunStart /
aieDtraceRunWait from the dtrace plugin when aie_dtrace is enabled.

Call run_start before kernel submit from xrt::run::start, and run_wait after
xrt::run::wait / wait2 return. Use const_cast for wait paths because wait is
const.

Bump src/runtime_src/xdp submodule to include the plugin exports and hooks.

Made-with: Cursor

* xdp: aie_profile drops CT writer and bandwidth metrics

Bump src/runtime_src/xdp to include aie_profile cleanup (remove
AieProfileCTWriter, ddr/read/write_bandwidth handling, and generateCTForRun).

Made-with: Cursor

* xdp: bump submodule for aie_profile CT bandwidth metric cleanup

Points src/runtime_src/xdp at commit adding METRIC_* bandwidth constants,
isInterfaceTileBandwidthMetricSet(), and VE2 AieProfileCTWriter updates.

Made-with: Cursor

* Revert "xdp: bump submodule for aie_profile CT bandwidth metric cleanup"

This reverts commit befc23e.

* xdp: bump submodule (revert a0d7280 CT writer / bandwidth drop)

Made-with: Cursor

* xdp: route run_constructor to AIE dtrace only

Remove aie::profile run_constructor callback registration and the
get_aie_profile() branch in xrt_core::xdp::run_constructor. Per-run setup is
handled solely by the aie_dtrace plugin when enabled.

Submodule src/runtime_src/xdp: AIE profile VE2 CT writer removal and related
cleanup (see submodule commit).

Made-with: Cursor

* Update xdp submodule for aie_dtrace CT writer UC column handling

Points xdp at commit that derives UC spans from aiebu op_loc and extends
the last UC through the maximum configured counter column.

Made-with: Cursor

* Update latest xdp submodule

Signed-off-by: Garima Dhaked <[email protected]>

* xdp: Compile run hooks only for VE2 XDNA builds

Guard run_constructor, run_start, and run_wait hooks with
XDP_VE2_BUILD preprocessor conditional to exclude this code
from non-VE2 builds. These hooks are only needed for AIE dtrace
functionality on VE2 XDNA platforms.

Changes:
- Wrap aie::dtrace namespace in profile.cpp with #ifdef XDP_VE2_BUILD
- Wrap run hook functions in xrt_core::xdp namespace with same guard
- Add XDP_VE2_BUILD compile definition to core_common_api_library_objects
  in CMakeLists.txt for VE2 builds
- Guard run hook calls in xrt_kernel.cpp (run constructor, start, wait)
- Update copyright year in profile.h

Made-with: Cursor

* Reverted the changed copyright comment in previous checkin

Signed-off-by: Garima Dhaked <[email protected]>

* xdp: refactor run hooks to use run_info struct with runtime aie_dtrace check

Replace compile-time XDP_VE2_BUILD guards with runtime aie_dtrace config check
for run_constructor, run_start, and run_wait hooks. Introduce run_info struct
to encapsulate hook arguments and add make_run_info helper for cleaner call sites.

Made-with: Cursor

* Reverted the changed copyright comment in previous checkin

Signed-off-by: Garima Dhaked <[email protected]>

* xdp: refactor run hooks to use run_info struct with runtime aie_dtrace check

Replace compile-time XDP_VE2_BUILD guards with runtime aie_dtrace config check
for run_constructor, run_start, and run_wait hooks. Introduce run_info struct
to encapsulate hook arguments and add make_run_info helper in profile.h for
cleaner call sites.

Remove XDP_VE2_BUILD compile definition from CMakeLists.txt since hooks are
now controlled at runtime via aie_dtrace config.

Made-with: Cursor

* DCO Remediation Commit for Garima Dhaked and Jyotheeswar Ganne

I, Garima Dhaked <[email protected]>, hereby add my Signed-off-by to this
commit and all preceding commits in this pull request that were authored by me.

This remediation covers the following commits by Garima Dhaked:

6d09bc8 xdp: refactor run hooks to use run_info struct with runtime aie_dtrace check
ab6e2a7 xdp: refactor run hooks to use run_info struct with runtime aie_dtrace check
9129d2a xdp: Compile run hooks only for VE2 XDNA builds
4e88252 Update xdp submodule for aie_dtrace CT writer UC column handling
a2fa7ca xdp: route run_constructor to AIE dtrace only
1fcd5b3 xdp: bump submodule (revert a0d7280 CT writer / bandwidth drop)
339e681 Revert "xdp: bump submodule for aie_profile CT bandwidth metric cleanup"
befc23e xdp: bump submodule for aie_profile CT bandwidth metric cleanup
50b4d53 xdp: aie_profile drops CT writer and bandwidth metrics
02335bc Wire AIE dtrace run start and run wait hooks from xrt::run
5572676 Remove AIE_profile_settings.dtrace_debug config reader
9c455aa XRT: Wire AIE dtrace config and load xdp_aie_dtrace_plugin_xdna

Signed-off-by: Garima Dhaked <[email protected]>

I, Jyotheeswar Ganne <[email protected]>, hereby add my Signed-off-by to
this commit and all preceding commits in this pull request that were authored by me.

This remediation covers the following commits by Jyotheeswar Ganne:

21b8c68 Thread kernel_name and elf_handle through run_constructor XDP hook
ae60a20 Pass run UID through run_constructor hook for CT filename
b441e2b Add run_constructor XDP hook in xrt::run for per-run plugin callbacks

Signed-off-by: Jyotheeswar Ganne <[email protected]>
Made-with: Cursor

* xdp: simplify dtrace run hooks with direct xrt::run API

Refactor the dtrace run hooks to simplify call sites in xrt_kernel.cpp
by moving all run info extraction logic into profile.cpp.

Changes:
- Add run-level accessor functions to kernel_int.h (get_run_uid,
  get_run_hwctx, get_run_kernel_name, get_run_module, get_run_state)
- Simplify run_constructor, run_start, and run_wait to take xrt::run
  directly instead of run_info struct
- Remove run_info struct and make_run_info helper from profile.h
- Move config check and info extraction into profile.cpp

Call sites in xrt_kernel.cpp are now simplified to:
  xrt_core::xdp::run_constructor(*this);
  xrt_core::xdp::run_start(*this);
  xrt_core::xdp::run_wait(*this);

Signed-off-by: Garima Dhaked <[email protected]>
Made-with: Cursor

* xdp: add implementation-level XDP profiling hooks

Move XDP profiling hooks for run_start and run_wait from the public
xrt::run API level to the internal run_impl implementation level.
This ensures these hooks are called regardless of whether the C++ API
or C API is used.

The run_constructor hook remains at the xrt::run API level because the
XDP plugin needs to call methods on the xrt::run object (specifically
set_dtrace_control_file).

Changes:
- Add xrt_kernel_data struct with ert_state field for run state
- Add implementation-level XDP hooks:
  - run_start(const xrt_kernel_data&)
  - run_wait(const xrt_kernel_data&)
- Add get_xdp_kernel_data() helper to run_impl class
- Call run_start and run_wait hooks from run_impl methods
- Keep run_constructor at xrt::run level (requires xrt::run object)
- Remove unused run_wait(const xrt::run&) overload and get_run_state()

This enables XDP profiling for run_start and run_wait when using the
C API (xrtRunStart, xrtRunWait) which calls run_impl methods directly.

Signed-off-by: Garima Dhaked <[email protected]>
Made-with: Cursor

* xrt: refactor XDP run hooks to use run_impl handles

    Refactor XDP profiling hooks to operate at the handle level (run_impl*)
    rather than requiring xrt::run objects. This provides consistency with
    how other XDP hooks work in the codebase.

* updated xdp submodule to 4f426595bb2f38e8a3ea1df10744eccd0559597d commit

Signed-off-by: Garima Dhaked <[email protected]>

* xrt: simplify XDP run hooks to accept run_impl pointer directly

Refactor the XDP profiling hooks (run_constructor, run_start, run_wait)
to accept const xrt::run_impl* instead of xrt_kernel_data struct. This
simplifies the API and moves data extraction into the callback functions
themselves, avoiding unnecessary work when callbacks are not registered.

Changes:
- Update profile.h/cpp: Change hook signatures to take run_impl*
- Update kernel_int.h: Replace xrt::run overload with run_impl* version
- Update xrt_kernel.cpp: Simplify call sites to pass 'this' directly
- Add get_xdp_kernel_data(run_impl*) to extract kernel data internally
- Populate ert_state in xrt_kernel_data via run_impl->state()

The aie::dtrace namespace functions now check if callbacks are registered
before extracting kernel data, improving efficiency when profiling is
disabled.

Signed-off-by: Garima Dhaked <[email protected]>
Made-with: Cursor

* xrt: remove unused get_xdp_kernel_data() private method from run_impl

Remove the unused private get_xdp_kernel_data() member function from
run_impl class. This function is no longer needed since XDP profiling
hooks now use the exported xrt_core::kernel_int::get_xdp_kernel_data()
function that takes a run_impl pointer directly.

Signed-off-by: Garima Dhaked <[email protected]>
Made-with: Cursor

* xrt: remove unused header includes from kernel_int.h

Remove unnecessary header includes that are not used in kernel_int.h:
- xrt_module.h: not referenced in the header
- xrt_hw_context.h: already included transitively via xrt_kernel.h
- ert.h: not referenced in the header

Signed-off-by: Garima Dhaked <[email protected]>
Made-with: Cursor

* Removed trace points from set_dtace_control_file()

Signed-off-by: Garima Dhaked <[email protected]>

---------

Signed-off-by: Garima Dhaked <[email protected]>
Signed-off-by: Jyotheeswar Ganne <[email protected]>
Co-authored-by: Jyotheeswar Ganne <[email protected]>

Author: garimadhaked

src/runtime_src/core/common/api/kernel_int.h

@@ -17,8 +17,13 @@
 
 #include <bitset>
 #include <cstdint>
+#include <string>
 #include <vector>
 
+namespace xrt_core::xdp {
+struct xrt_kernel_data;
+}
+
 namespace xrt_core { namespace kernel_int {
 
 // Provide access to kdma command based BO copy Used by xrt::bo::copy.
@@ -96,6 +101,17 @@ get_hw_ctx(const xrt::run&);
 xrt::kernel
 create_kernel_from_implementation(const xrt::kernel_impl* kernel_impl);
 
+// Fill XDP kernel data from a run_impl pointer for profiling hooks
+XRT_CORE_COMMON_EXPORT
+void
+get_xdp_kernel_data(const xrt::run_impl* run_impl, xrt_core::xdp::xrt_kernel_data* data);
+
+// Set dtrace control file on a run_impl handle
+// This is used by XDP profiling to set the CT file without requiring xrt::run
+XRT_CORE_COMMON_EXPORT
+void
+set_dtrace_control_file(xrt::run_impl* run_impl, const std::string& path);
+
 }} // kernel_int, xrt_core
 
 #endif

src/runtime_src/core/common/api/xrt_kernel.cpp

@@ -47,6 +47,7 @@
 #include "core/common/trace.h"
 #include "core/common/usage_metrics.h"
 #include "core/common/xclbin_parser.h"
+#include "core/common/xdp/profile.h"
 
 #include <boost/format.hpp>
 
@@ -2471,6 +2472,9 @@ class run_impl : public std::enable_shared_from_this<run_impl>
     , uid(create_uid())
   {
     XRT_DEBUGF("run_impl::run_impl(%d)\n" , uid);
+
+    // XDP run_constructor hook
+    xrt_core::xdp::run_constructor(this);
   }
 
   // Clones a run impl, so that the clone can be executed concurrently
@@ -2783,6 +2787,9 @@ class run_impl : public std::enable_shared_from_this<run_impl>
 
     prep_start();
 
+    // XDP profiling hook - called immediately before run is submitted
+    xrt_core::xdp::run_start(this);
+
     // log kernel start info
     // This is in critical path, we need to reduce log overhead
     // as much as possible, passing kernel impl pointer instead of
@@ -2884,6 +2891,9 @@ class run_impl : public std::enable_shared_from_this<run_impl>
       state = cmd->wait();
     }
 
+    // XDP profiling hook - called after wait completes
+    xrt_core::xdp::run_wait(this);
+
     dump_logs(true); // dump required logs
 
     return state;
@@ -2936,6 +2946,9 @@ class run_impl : public std::enable_shared_from_this<run_impl>
       state = cmd->wait();
     }
 
+    // XDP profiling hook - called after wait completes
+    xrt_core::xdp::run_wait(this);
+
     // dump required logs
     dump_logs(true);
 
@@ -4220,8 +4233,24 @@ create_kernel_from_implementation(const xrt::kernel_impl* kernel_impl)
   return xrt::kernel(const_cast<xrt::kernel_impl*>(kernel_impl)->get_shared_ptr()); // NOLINT
 }
 
-} // xrt_core::kernel_int
+void
+get_xdp_kernel_data(const xrt::run_impl* run_impl, xrt_core::xdp::xrt_kernel_data* data)
+{
+  auto kernel = run_impl->get_kernel();
+  data->uid = run_impl->get_uid();
+  data->name = kernel->get_name();
+  data->hwctx = kernel->get_hw_context();
+  data->mod = kernel->get_module();
+  data->ert_state = static_cast<int>(run_impl->state());
+}
+
+void
+set_dtrace_control_file(xrt::run_impl* run_impl, const std::string& path)
+{
+  run_impl->set_dtrace_control_file(path);
+}
 
+} // xrt_core::kernel_int
 
 ////////////////////////////////////////////////////////////////
 // xrt_kernel C++ API implmentations (xrt_kernel.h)

src/runtime_src/core/common/config_reader.h

@@ -174,6 +174,13 @@ get_aie_profile()
   return value;
 }
 
+inline bool
+get_aie_dtrace()
+{
+  static bool value = detail::get_bool_value("Debug.aie_dtrace", false);
+  return value;
+}
+
 inline bool
 get_aie_debug()
 {
@@ -965,10 +972,27 @@ get_aie_profile_settings_start_iteration()
   return value;
 }
 
-inline bool
-get_aie_profile_settings_dtrace_debug()
+// Configurations under AIE_dtrace_settings (bandwidth / CT for Debug.aie_dtrace; no aie_profile CSV)
+inline unsigned int
+get_aie_dtrace_settings_interval_us()
+{
+  static unsigned int value = detail::get_uint_value("AIE_dtrace_settings.interval_us", 1000);
+  return value;
+}
+
+inline std::string
+get_aie_dtrace_settings_graph_based_interface_tile_metrics()
+{
+  static std::string value =
+      detail::get_string_value("AIE_dtrace_settings.graph_based_interface_tile_metrics", "");
+  return value;
+}
+
+inline std::string
+get_aie_dtrace_settings_tile_based_interface_tile_metrics()
 {
-  static bool value = detail::get_bool_value("AIE_profile_settings.dtrace_debug", "false");
+  static std::string value =
+      detail::get_string_value("AIE_dtrace_settings.tile_based_interface_tile_metrics", "");
   return value;
 }
 

src/runtime_src/core/common/xdp/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(core_common_xdp_profile_objects OBJECT
 target_include_directories(core_common_xdp_profile_objects
   PRIVATE
   ${XRT_SOURCE_DIR}/runtime_src
+  ${XRT_SOURCE_DIR}/runtime_src/core/common/elf
   )
 
 # Compile defintions when building npu, alveo, or legacy xrt

src/runtime_src/core/common/xdp/profile.cpp

@@ -3,10 +3,14 @@
 #define XRT_CORE_COMMON_SOURCE
 #include "core/common/xdp/profile.h"
 
+#include "core/common/api/kernel_int.h"
+#include "core/common/api/module_int.h"
 #include "core/common/config_reader.h"
 #include "core/common/dlfcn.h"
 #include "core/common/module_loader.h"
 #include "core/common/message.h"
+#include "core/include/xrt/xrt_kernel.h"
+
 #include <cstring>
 #include <functional>
 #include <sstream>
@@ -145,6 +149,100 @@ end_poll(void* handle)
 
 } // end namespace xrt_core::xdp::aie::profile
 
+namespace xrt_core::xdp::aie::dtrace {
+
+std::function<void(void*, bool)> update_device_cb;
+std::function<void(void*)> end_poll_cb;
+std::function<void(void*, void*, uint32_t, const char*, void*)> run_constructor_cb;
+std::function<void(void*, void*, uint32_t, const char*)> run_start_cb;
+std::function<void(void*, void*, uint32_t, const char*, int)> run_wait_cb;
+
+void
+register_callbacks(void* handle)
+{
+  using ftype = void (*)(void*);
+  using utype = void (*)(void*, bool);
+  using rctype = void (*)(void*, void*, uint32_t, const char*, void*);
+  using rsctype = void (*)(void*, void*, uint32_t, const char*);
+  using rwctype = void (*)(void*, void*, uint32_t, const char*, int);
+
+  update_device_cb = reinterpret_cast<utype>(xrt_core::dlsym(handle, "updateAIEDtraceDevice"));
+  end_poll_cb = reinterpret_cast<ftype>(xrt_core::dlsym(handle, "endAIEDtracePoll"));
+  run_constructor_cb = reinterpret_cast<rctype>(xrt_core::dlsym(handle, "aieDtraceRunConstructor"));
+  run_start_cb = reinterpret_cast<rsctype>(xrt_core::dlsym(handle, "aieDtraceRunStart"));
+  run_wait_cb = reinterpret_cast<rwctype>(xrt_core::dlsym(handle, "aieDtraceRunWait"));
+}
+
+void
+load_xdna()
+{
+  static xrt_core::module_loader xdp_aie_dtrace_loader("xdp_aie_dtrace_plugin_xdna",
+                                                       register_callbacks,
+                                                       warning_callbacks_empty);
+}
+
+void
+load()
+{
+  load_xdna();
+}
+
+void
+update_device(void* handle, bool hw_context_flow)
+{
+  if (update_device_cb)
+    update_device_cb(handle, hw_context_flow);
+}
+
+void
+end_poll(void* handle)
+{
+  if (end_poll_cb)
+    end_poll_cb(handle);
+}
+
+void
+run_constructor(xrt::run_impl* run_impl)
+{
+  if (run_constructor_cb) {
+    xrt_kernel_data data{};
+    xrt_core::kernel_int::get_xdp_kernel_data(run_impl, &data);
+    auto elf_hdl = data.mod ? xrt_core::module_int::get_elf_handle(data.mod) : nullptr;
+    run_constructor_cb(run_impl,
+                       data.hwctx.get_handle().get(),
+                       data.uid,
+                       data.name.c_str(),
+                       elf_hdl.get());
+  }
+}
+
+void
+run_start(const xrt::run_impl* run_impl)
+{
+  if (run_start_cb) {
+    xrt_kernel_data data{};
+    xrt_core::kernel_int::get_xdp_kernel_data(run_impl, &data);
+    run_start_cb(nullptr, data.hwctx.get_handle().get(),
+                 data.uid,
+                 data.name.c_str());
+  }
+}
+
+void
+run_wait(const xrt::run_impl* run_impl)
+{
+  if (run_wait_cb) {
+    xrt_kernel_data data{};
+    xrt_core::kernel_int::get_xdp_kernel_data(run_impl, &data);
+    run_wait_cb(nullptr, data.hwctx.get_handle().get(),
+                data.uid,
+                data.name.c_str(),
+                data.ert_state);
+  }
+}
+
+} // end namespace xrt_core::xdp::aie::dtrace
+
 namespace xrt_core::xdp::aie::debug {
 
 std::function<void (void*)> update_device_cb;
@@ -533,6 +631,7 @@ update_device(void* handle, bool hw_context_flow)
   #ifdef _WIN32
   if (xrt_core::config::get_ml_timeline()
       || xrt_core::config::get_aie_profile()
+      || xrt_core::config::get_aie_dtrace()
       || xrt_core::config::get_aie_trace()
       || xrt_core::config::get_aie_debug()
       || xrt_core::config::get_aie_halt()
@@ -662,6 +761,20 @@ update_device(void* handle, bool hw_context_flow)
            handle,
 	 	      hw_context_flow);
 
+  load_once_and_update(xrt_core::config::get_aie_dtrace,
+           []() {
+            if (xrt_core::config::get_xdp_mode() == "xdna") {
+              xrt_core::message::send(xrt_core::message::severity_level::debug, "XRT",
+                "xdp_mode is XDNA; loading AIE dtrace plugin for XDNA device.");
+              xrt_core::xdp::aie::dtrace::load_xdna();
+            }
+           },
+           xrt_core::xdp::aie::dtrace::update_device,
+           "Failed to load AIE dtrace library. Caught exception ",
+           "Failed to setup for AIE dtrace. Caught exception ",
+           handle,
+           hw_context_flow);
+
 #else
 
   load_once_and_update(  
@@ -730,6 +843,8 @@ finish_flush_device(void* handle)
     xrt_core::xdp::aie::halt::finish_flush_device(handle);
   if (xrt_core::config::get_aie_profile())
     xrt_core::xdp::aie::profile::end_poll(handle);
+  if (xrt_core::config::get_aie_dtrace())
+    xrt_core::xdp::aie::dtrace::end_poll(handle);
   if (xrt_core::config::get_aie_trace())
     xrt_core::xdp::aie::trace::end_trace(handle);
   if (xrt_core::config::get_aie_debug())
@@ -751,6 +866,8 @@ finish_flush_device(void* handle)
     xrt_core::xdp::ml_timeline::finish_flush_device(handle);
   if (xrt_core::config::get_aie_profile())
     xrt_core::xdp::aie::profile::end_poll(handle);
+  if (xrt_core::config::get_aie_dtrace())
+    xrt_core::xdp::aie::dtrace::end_poll(handle);
 
 #else
 
@@ -771,4 +888,31 @@ finish_flush_device(void* handle)
 #endif
 }
 
+void
+run_constructor(xrt::run_impl* run_impl)
+{
+  if (!xrt_core::config::get_aie_dtrace())
+    return;
+
+  xrt_core::xdp::aie::dtrace::run_constructor(run_impl);
+}
+
+void
+run_start(const xrt::run_impl* run_impl)
+{
+  if (!xrt_core::config::get_aie_dtrace())
+    return;
+
+  xrt_core::xdp::aie::dtrace::run_start(run_impl);
+}
+
+void
+run_wait(const xrt::run_impl* run_impl)
+{
+  if (!xrt_core::config::get_aie_dtrace())
+    return;
+
+  xrt_core::xdp::aie::dtrace::run_wait(run_impl);
+}
+
 } // end namespace xrt_core::xdp