XRT Application Capture and Replay

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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
-// Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2026 Advanced Micro Devices, Inc. All rights reserved.
 //
-#ifndef _XRT_COMMON_BO_INT_H_
-#define _XRT_COMMON_BO_INT_H_
+#ifndef XRT_COMMON_BO_INT_H_
+#define XRT_COMMON_BO_INT_H_
 
 // This file defines implementation extensions to the XRT BO APIs.
 #include "core/common/config.h"
@@ -97,6 +97,13 @@ XRT_CORE_COMMON_EXPORT
 void
 unconfig_bo(const xrt::bo& bo, const xrt_core::hwctx_handle* ctx_handle = nullptr);
 
+// get_bo_from_impl() - Convert impl to xrt::bo
+//
+// The argument impl is created from a shared ptr, this function wraps
+// the impl in that shared_ptr.
+xrt::bo
+get_bo_from_impl(const xrt::bo_impl*);
+
 } // bo_int, xrt_core
 
 #endif

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

@@ -14,7 +14,7 @@
 // Provide access to xrt::xclbin data that is not directly exposed
 // to end users via xrt::xclbin.   These functions are used by
 // XRT core implementation.
-namespace xrt_core { namespace hw_context_int {
+namespace xrt_core::hw_context_int {
 
 // Get the core_device from this context
 // Exported for xdp access
@@ -51,6 +51,11 @@ create_hw_context_from_implementation(void* hwctx_impl);
 xrt::elf
 get_elf(const xrt::hw_context& hwctx, const std::string& kname);
 
+// get_config_elfs() - Return list of configuration elfs for hwctx
+// In non-elf flow, this function return empty set.
+std::vector<xrt::elf>
+get_config_elfs(const xrt::hw_context& hwctx);
+
 // Get the partition size (number of columns).  May not be available
 // in xclbin mode.
 XRT_CORE_COMMON_EXPORT
@@ -98,15 +103,16 @@ XRT_CORE_COMMON_EXPORT
 xrt::hw_context::qos_type
 get_qos_map(const xrt::hw_context& hwctx);
 
-// Get the configuration parameters from the hw context.
-// The returned map contains key-value pairs
-// key: string, value: string for both QoS-related settings and
-// other hw context configuration parameters.
-// Throws std::runtime_error if the context currently does not store cfg_type
+// get_cfg_map() - Get the configuration parameters
+//
+// The returned map contains string to string key-value pairs both
+// QoS-related settings and other hw context configuration parameters.
+// If hwctx was configured with string to integral key-value pairs,
+// then the integral values are converted to strings.
 XRT_CORE_COMMON_EXPORT
 xrt::hw_context::cfg_type
 get_cfg_map(const xrt::hw_context& hwctx);
 
-}} // hw_context_int, xrt_core
+} // xrt_core::hw_context_int
 
 #endif

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) 2020 Xilinx, Inc
-// Copyright (C) 2022 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2022-2026 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Xilinx Runtime (XRT) Experimental APIs
 
@@ -24,7 +24,7 @@ namespace xrt_core::xdp {
 struct xrt_kernel_data;
 }
 
-namespace xrt_core { namespace kernel_int {
+namespace xrt_core::kernel_int {
 
 // Provide access to kdma command based BO copy Used by xrt::bo::copy.
 // Arguably this should implemented by by shim->copy_bo, but must wait
@@ -88,18 +88,41 @@ XRT_CORE_COMMON_EXPORT
 size_t
 get_regmap_size(const xrt::kernel& kernel);
 
-// Get hw ctx using which this kernel is created
+// get_instance_name() - Get the kernel instance name
+// Return the name used to create the kernel before it is stripped to
+// remove instance identifier part.  In xclbin flow, this name is not
+// necessarily an instance name, but in ELF flow it uniquely
+// identifies a kernel instance.
+std::string
+get_instance_name(const xrt::kernel&);
+
+// get_hwctx() - Get hwctx in which this kernel is created
 xrt::hw_context
-get_hw_ctx(const xrt::kernel& kernel);
+get_hwctx(const xrt::kernel& kernel);
+
+// get_ctrlcode() - Get kernel ctrlcode
+// For kernels created from legacy xrt::module
+xrt::elf
+get_ctrlcode(const xrt::kernel&);
 
-// Get hw ctx using which this kernel is created
+// get_hwctx() - Get hwctx in which the run kernel is created
+XRT_CORE_COMMON_EXPORT
 xrt::hw_context
-get_hw_ctx(const xrt::run&);
+get_hwctx(const xrt::run&);
 
-// Allows the creation of the kernel object from a kernel_impl pointer
-// This is used for logging usage mertrics
+// get_kernel() - Get xrt::kernel fron which run is created
 xrt::kernel
-create_kernel_from_implementation(const xrt::kernel_impl* kernel_impl);
+get_kernel(const xrt::run&);
+
+// get_kernel_from_impl() - wrap impl in an xrt::kernel
+// Returns xrt::kernel created from shared kernel_impl.
+xrt::kernel
+get_kernel_from_impl(const xrt::kernel_impl* kernel_impl);
+
+// get_run_from_impl() - wrap impl in an xrt::run
+// Returns xrt::run created from shared run_impl.
+xrt::run
+get_run_from_impl(const xrt::run_impl*);
 
 // Fill XDP kernel data from a run_impl pointer for profiling hooks
 XRT_CORE_COMMON_EXPORT
@@ -112,6 +135,6 @@ XRT_CORE_COMMON_EXPORT
 void
 set_dtrace_control_file(xrt::run_impl* run_impl, const std::string& path);
 
-}} // kernel_int, xrt_core
+} // xrt_core::kernel_int
 
 #endif

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

@@ -1,16 +1,17 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- * Copyright (C) 2021 Xilinx, Inc. All rights reserved.
- */
-#ifndef _XRT_COMMON_XCLBIN_INT_H_
-#define _XRT_COMMON_XCLBIN_INT_H_
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2021 Xilinx, Inc. All rights reserved.
+// Copyright (C) 2026 Advanced Micro Devices, Inc. All rights reserved.
+#ifndef XRT_COMMON_XCLBIN_INT_H_
+#define XRT_COMMON_XCLBIN_INT_H_
 
 // This file defines implementation extensions to the XRT XCLBIN APIs.
 #include "core/include/xrt/experimental/xrt_xclbin.h"
 
 #include "core/common/config.h"
 #include "core/common/xclbin_parser.h"
 
+#include "xrt/detail/span.h"
+
 #include <cstring>
 #include <string>
 #include <vector>
@@ -20,6 +21,9 @@
 // XRT core implementation.
 namespace xrt_core { namespace xclbin_int {
 
+template<typename T>
+using span = xrt::detail::span<T>;
+
 // get_axlf() - Retrieve complete axlf from handle
 const axlf*
 get_axlf(xrtXclbinHandle);
@@ -41,6 +45,10 @@ get_axlf_sections(const xrt::xclbin& xclbin, axlf_section_kind kind);
 std::vector<char>
 read_xclbin(const std::string& fnm);
 
+// get_xclbin_data() - Access raw xclbin data
+span<const char>
+get_xclbin_data(const xrt::xclbin&);
+
 // get_properties() - Get kernel properties
 XRT_CORE_COMMON_EXPORT
 const xrt_core::xclbin::kernel_properties&

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) 2020-2022 Xilinx, Inc
-// Copyright (C) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2022-2026 Advanced Micro Devices, Inc. All rights reserved.
 
 // This file implements XRT BO APIs as declared in
 // core/include/experimental/xrt_bo.h
@@ -30,6 +30,7 @@
 #include "core/common/unistd.h"
 #include "core/common/xclbin_parser.h"
 
+#include "core/common/runner/capture.h"
 #include "core/common/shim/buffer_handle.h"
 #include "core/common/shim/shared_handle.h"
 
@@ -199,7 +200,7 @@ namespace xrt {
 //
 // Life time of buffers are managed through shared pointers.
 // A buffer is freed when last references is released.
-class bo_impl
+class bo_impl : public std::enable_shared_from_this<bo_impl>
 {
 public:
   using export_handle = xrt_core::shared_handle::export_handle;
@@ -246,6 +247,18 @@ class bo_impl
     : size(sz)
   {}
 
+  std::shared_ptr<bo_impl>
+  get_shared_ptr()
+  {
+    return shared_from_this();
+  }
+
+  std::shared_ptr<bo_impl>
+  get_mutable_shared_ptr() const
+  {
+    return std::const_pointer_cast<bo_impl>(shared_from_this());
+  }
+
   // Managed handle shared with another bo_impl
   bo_impl(device_type dev, std::shared_ptr<xrt_core::buffer_handle> bhdl, size_t sz)
     : device(std::move(dev))
@@ -482,6 +495,8 @@ class bo_impl
     // if (get_flags() != bo::flags::host_only)
     handle->sync(static_cast<xrt_core::buffer_handle::direction>(dir), sz, offset);
     m_usage_logger->log_buffer_sync(device->get_device_id(), device.get_hwctx_handle(), sz, dir);
+
+    XRT_REPLAY_CAPTURE(bo_sync, this, static_cast<int>(dir));
   }
 
   virtual uint64_t
@@ -957,6 +972,8 @@ class buffer_sub : public bo_impl
 
     // sync through parent buffer, which handles nodma case also
     m_parent->sync(dir, sz, off);
+
+    XRT_REPLAY_CAPTURE(bo_sync, this, static_cast<int>(dir));
   }
 };
 
@@ -1804,6 +1821,13 @@ unconfig_bo(const xrt::bo& bo, const xrt_core::hwctx_handle* ctx_handle)
     : bo_impl->get_handle()->unconfig(bo_impl->get_hwctx_handle());
 }
 
+xrt::bo
+get_bo_from_impl(const xrt::bo_impl* bo_impl)
+{
+  return bo_impl->get_mutable_shared_ptr();
+}
+
+
 } // xrt_core::bo_int
 
 ////////////////////////////////////////////////////////////////

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

@@ -14,6 +14,7 @@
 #include "core/common/message.h"
 #include "core/common/trace.h"
 #include "core/common/xclbin_parser.h"
+#include "core/common/runner/capture.h"
 
 #include <boost/interprocess/streams/bufferstream.hpp>
 #include <elfio/elfio.hpp>
@@ -220,6 +221,7 @@ load_elfio(std::istream& stream)
   ELFIO::elfio elfio;
   if (!elfio.load(stream))
     throw std::runtime_error("not a valid ELF stream");
+
   return elfio;
 }
 
@@ -231,6 +233,7 @@ load_elfio(const void* data, size_t size)
   boost::interprocess::ibufferstream istr(static_cast<const char*>(data), size);
   if (!elfio.load(istr))
     throw std::runtime_error("not valid ELF data");
+
   return elfio;
 }
 
@@ -1512,22 +1515,34 @@ valid_or_error(const std::shared_ptr<elf_impl>& handle)
 elf::
 elf(const std::string& fnm)
   : detail::pimpl<elf_impl>{create_elf_impl(load_elfio(fnm), fnm)}
-{}
+{
+  // ELFIO cannot be post dumped. Track elf_impl to elf data
+  XRT_REPLAY_CAPTURE(elf_ctor, handle.get(), fnm);
+}
 
 elf::
 elf(std::istream& stream)
   : detail::pimpl<elf_impl>{create_elf_impl(load_elfio(stream))}
-{}
+{
+  // ELFIO cannot be post dumped. Track elf_impl to elf data
+  XRT_REPLAY_CAPTURE(elf_ctor, handle.get(), stream);
+}
 
 elf::
 elf(const void* data, size_t size)
   : detail::pimpl<elf_impl>{create_elf_impl(load_elfio(data, size))}
-{}
+{
+  // ELFIO cannot be post dumped. Track elf_impl to elf data
+  XRT_REPLAY_CAPTURE(elf_ctor, handle.get(), data, size);
+}
 
 elf::
 elf(const std::string_view& sv)
   : detail::pimpl<elf_impl>{create_elf_impl(load_elfio(sv.data(), sv.size()))}
-{}
+{
+  // ELFIO cannot be post dumped. Track elf_impl to elf data
+  XRT_REPLAY_CAPTURE(elf_ctor, handle.get(), sv.data(), sv.size());
+}
 
 xrt::uuid
 elf::