Address comments on PR

rbramand-xilinx · rbramand-xilinx · commit 90dd121d5224 · 2026-04-17T09:14:55.000-06:00
Signed-off-by: rahul &lt;rbramand@amd.com&gt;
diff --git a/src/runtime_src/core/common/api/elf_int.h b/src/runtime_src/core/common/api/elf_int.h
@@ -342,7 +342,7 @@ class elf_impl
   parse_custom_sections(const std::vector<uint32_t>& custom_section_ids);
 
 public:
-  virtual ~elf_impl();
+  virtual ~elf_impl() = default;
 
   // Base class managed through shared_ptr - no copy/move
   elf_impl(const elf_impl&) = delete;
diff --git a/src/runtime_src/core/common/api/xrt_bo.cpp b/src/runtime_src/core/common/api/xrt_bo.cpp
@@ -289,10 +289,7 @@ class bo_impl
     , size(sz)
   {}
 
-  virtual ~bo_impl()
-  {
-    XRT_TRACE_POINT_LOG(xrt_bo_dtor);
-  }
+  virtual ~bo_impl() = default;
 
   bo_impl(const bo_impl&) = delete;
   bo_impl(bo_impl&&) = delete;
@@ -1087,7 +1084,7 @@ alloc_bo(const device_type& device, size_t sz, xrtBufferFlags flags, xrtMemoryGr
 static std::shared_ptr<xrt::bo_impl>
 alloc_kbuf(const device_type& device, size_t sz, xrtBufferFlags flags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_kbuf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_kbuf);
   auto handle = alloc_bo(device, sz, flags, grp);
   auto boh = std::make_shared<xrt::buffer_kbuf>(device, std::move(handle), sz);
   boh->get_usage_logger()->log_buffer_info_construct(device->get_device_id(), sz, device.get_hwctx_handle());
@@ -1097,7 +1094,7 @@ alloc_kbuf(const device_type& device, size_t sz, xrtBufferFlags flags, xrtMemory
 static std::shared_ptr<xrt::bo_impl>
 alloc_ubuf(const device_type& device, void* userptr, size_t sz, xrtBufferFlags flags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_ubuf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_ubuf);
   // On NoDMA platforms a userptr would require userspace management
   // of specified userptr with extra memcpy on sync and copy.  If
   // supported then it would hide inefficient application code, so
@@ -1119,7 +1116,7 @@ alloc_ubuf(const device_type& device, void* userptr, size_t sz, xrtBufferFlags f
 static std::shared_ptr<xrt::bo_impl>
 alloc_hbuf(const device_type& device, xrt_core::aligned_ptr_type&& hbuf, size_t sz, xrtBufferFlags flags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_hbuf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_hbuf);
   auto handle =  alloc_bo(device, hbuf.get(), sz, flags, grp);
   auto boh = std::make_shared<xrt::buffer_hbuf>(device, std::move(handle), sz, std::move(hbuf));
   boh->get_usage_logger()->log_buffer_info_construct(device->get_device_id(), sz, device.get_hwctx_handle());
@@ -1129,7 +1126,7 @@ alloc_hbuf(const device_type& device, xrt_core::aligned_ptr_type&& hbuf, size_t
 static std::shared_ptr<xrt::bo_impl>
 alloc_dbuf(const device_type& device, size_t sz, xrtBufferFlags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_dbuf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_dbuf);
   auto handle = alloc_bo(device, sz, XCL_BO_FLAGS_DEV_ONLY, grp);
   auto boh = std::make_shared<xrt::buffer_dbuf>(device, std::move(handle), sz);
   boh->get_usage_logger()->log_buffer_info_construct(device->get_device_id(), sz, device.get_hwctx_handle());
@@ -1139,7 +1136,7 @@ alloc_dbuf(const device_type& device, size_t sz, xrtBufferFlags, xrtMemoryGroup
 static std::shared_ptr<xrt::bo_impl>
 alloc_nodma(const device_type& device, size_t sz, xrtBufferFlags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_nodma_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_nodma);
   constexpr size_t align = 64;
   if (sz % align)
     throw xrt_core::error(EINVAL, "Invalid buffer size '" + std::to_string(sz) +
@@ -1186,21 +1183,21 @@ alloc(const device_type& device, size_t sz, xrtBufferFlags flags, xrtMemoryGroup
 static std::shared_ptr<xrt::bo_impl>
 alloc_xbuf(const device_type& device, xcl_buffer_handle xhdl)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_xbuf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_xbuf);
   return std::make_shared<xrt::buffer_xbuf>(device, xhdl);
 }
 
 static std::shared_ptr<xrt::bo_impl>
 alloc_userptr(const device_type& device, void* userptr, size_t sz, xrtBufferFlags flags, xrtMemoryGroup grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_userptr_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_userptr);
   return alloc_ubuf(device, userptr, sz, flags, grp);
 }
 
 static std::shared_ptr<xrt::bo_impl>
 alloc_import(const device_type& device, xrt::bo_impl::export_handle ehdl)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_import_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_import);
   auto boh = std::make_shared<xrt::buffer_import>(device, ehdl);
   boh->get_usage_logger()->log_buffer_info_construct(device->get_device_id(), boh->get_size(), device.get_hwctx_handle());
   return boh;
@@ -1209,7 +1206,7 @@ alloc_import(const device_type& device, xrt::bo_impl::export_handle ehdl)
 static std::shared_ptr<xrt::bo_impl>
 alloc_import_from_pid(const device_type& device, xrt::pid_type pid, xrt::bo_impl::export_handle ehdl)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_import_from_pid_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_import_from_pid);
   auto boh = std::make_shared<xrt::buffer_import>(device, pid, ehdl);
   boh->get_usage_logger()->log_buffer_info_construct(device->get_device_id(),
                                                      boh->get_size(),
@@ -1220,7 +1217,7 @@ alloc_import_from_pid(const device_type& device, xrt::pid_type pid, xrt::bo_impl
 static std::shared_ptr<xrt::bo_impl>
 alloc_sub(const std::shared_ptr<xrt::bo_impl>& parent, size_t size, size_t offset)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_sub_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_sub);
   auto boh = std::make_shared<xrt::buffer_sub>(parent, size, offset);
   boh->get_usage_logger()->log_buffer_info_construct(boh->get_core_device()->get_device_id(),
                                                      boh->get_size(),
@@ -1232,7 +1229,7 @@ alloc_sub(const std::shared_ptr<xrt::bo_impl>& parent, size_t size, size_t offse
 static std::shared_ptr<xrt::bo_impl>
 alloc_clone(const std::shared_ptr<xrt::bo_impl>& src, xrt::memory_group grp)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_clone_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_bo_alloc_clone);
   // Same device and flags as src bo
   auto device = src->get_device();
   auto xflags = static_cast<xrtBufferFlags>(src->get_flags());
diff --git a/src/runtime_src/core/common/api/xrt_device.cpp b/src/runtime_src/core/common/api/xrt_device.cpp
@@ -55,7 +55,7 @@ send_exception_message(const char* msg)
 static std::shared_ptr<xrt_core::device>
 alloc_device_index(unsigned int index)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_device_index_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_device_alloc_index);
   auto dev = xrt_core::get_userpf_device(index);
 
   dev->get_usage_logger()->log_device_info(dev.get());
@@ -66,7 +66,7 @@ alloc_device_index(unsigned int index)
 static std::shared_ptr<xrt_core::device>
 alloc_device_handle(xclDeviceHandle dhdl)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_device_handle_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_device_alloc_handle);
   return xrt_core::get_userpf_device(dhdl) ;
 }
 
diff --git a/src/runtime_src/core/common/api/xrt_elf.cpp b/src/runtime_src/core/common/api/xrt_elf.cpp
@@ -333,12 +333,6 @@ elf_impl(ELFIO::elfio&& elfio, elf::platform platform)
   , m_platform{platform}
 {}
 
-elf_impl::
-~elf_impl()
-{
-  XRT_TRACE_POINT_LOG(xrt_elf_dtor);
-}
-
 // Get symbol information from .symtab at given index
 elf_impl::symbol_info
 elf_impl::
@@ -1438,7 +1432,7 @@ namespace {
 static std::shared_ptr<xrt::elf_impl>
 create_elf_impl(ELFIO::elfio&& elfio)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_elf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_elf_create_impl);
   auto os_abi = elfio.get_os_abi();
 
   switch (os_abi) {
diff --git a/src/runtime_src/core/common/api/xrt_hw_context.cpp b/src/runtime_src/core/common/api/xrt_hw_context.cpp
@@ -232,6 +232,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>
   static std::unique_ptr<uc_log_buffer>
   init_uc_log_buf(const std::shared_ptr<xrt_core::device>& device, xrt_core::hwctx_handle* ctx_hdl)
   {
+    XRT_TRACE_POINT_SCOPE(xrt_hw_context_init_uc_log_buf);
     // If uc log buffer is not supported then this function returns nullptr
     static auto uc_log_enabled = xrt_core::config::get_uc_log();
     if (!ctx_hdl || !uc_log_enabled)
@@ -347,6 +348,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>
   void
   add_config(const xrt::elf& elf)
   {
+    XRT_TRACE_POINT_SCOPE(xrt_hw_context_add_config);
     auto part_size = elf.get_partition_size();
 
     // create hw ctx handle if not already created
@@ -409,6 +411,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>
   void
   dump_uc_log_buffer()
   {
+    XRT_TRACE_POINT_SCOPE(xrt_hw_context_dump_uc_log_buffer);
     if (!m_uc_log_buf)
       return;
 
@@ -537,6 +540,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>
   void
   dump_scratchpad_mem()
   {
+    XRT_TRACE_POINT_SCOPE(xrt_hw_context_dump_scratchpad_mem);
     if (m_scratchpad_buf.size() == 0) {
       xrt_core::message::send(xrt_core::message::severity_level::debug, "xrt_hw_context",
                               "preemption scratchpad memory is not available");
@@ -728,23 +732,23 @@ template<typename Cfg>
 static std::shared_ptr<hw_context_impl>
 alloc_hwctx_from_cfg(const xrt::device& device, const xrt::uuid& xclbin_id, Cfg&& cfg)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_hw_context_cfg_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_cfg);
   return post_alloc_hwctx(std::make_shared<hw_context_impl>(
       device.get_handle(), xclbin_id, hwctx_cfg_storage{std::forward<Cfg>(cfg)}));
 }
 
 static std::shared_ptr<hw_context_impl>
 alloc_hwctx_from_mode(const xrt::device& device, const xrt::uuid& xclbin_id, xrt::hw_context::access_mode mode)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_hw_context_mode_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_mode);
   return post_alloc_hwctx(std::make_shared<hw_context_impl>(device.get_handle(), xclbin_id, mode));
 }
 
 template<typename Cfg>
 static std::shared_ptr<hw_context_impl>
 alloc_empty_hwctx(const xrt::device& device, Cfg&& cfg, xrt::hw_context::access_mode mode)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_hw_context_empty_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_empty);
   return post_alloc_hwctx(std::make_shared<hw_context_impl>(
       device.get_handle(), hwctx_cfg_storage{std::forward<Cfg>(cfg)}, mode));
 }
@@ -754,7 +758,7 @@ static std::shared_ptr<hw_context_impl>
 alloc_hwctx_from_elf(const xrt::device& device, const xrt::elf& elf, Cfg&& cfg,
                      xrt::hw_context::access_mode mode)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_hw_context_elf_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_elf);
   return post_alloc_hwctx(std::make_shared<hw_context_impl>(
       device.get_handle(), elf, hwctx_cfg_storage{std::forward<Cfg>(cfg)}, mode));
 }
diff --git a/src/runtime_src/core/common/api/xrt_kernel.cpp b/src/runtime_src/core/common/api/xrt_kernel.cpp
@@ -1842,7 +1842,6 @@ class kernel_impl : public std::enable_shared_from_this<kernel_impl>
   ~kernel_impl()
   {
     XRT_DEBUGF("kernel_impl::~kernel_impl(%d)\n" , uid);
-    XRT_TRACE_POINT_LOG(xrt_kernel_dtor);
   }
 
   kernel_impl(const kernel_impl&) = delete;
@@ -2497,7 +2496,6 @@ class run_impl : public std::enable_shared_from_this<run_impl>
   virtual
   ~run_impl()
   {
-    XRT_TRACE_POINT_LOG(xrt_run_dtor);
     // It is a fatal error to destruct a run_impl while its command is
     // still in progress.  But only abort if there are no live
     // exception objects.
@@ -3680,7 +3678,6 @@ class runlist_impl
 
   ~runlist_impl()
   {
-    XRT_TRACE_POINT_LOG(xrt_runlist_dtor);
     // Make sure all run objects are severed from this list
     try {
       clear_runs();
@@ -3951,7 +3948,7 @@ get_run_update(xrtRunHandle rhdl)
 static std::unique_ptr<xrt::run_impl>
 alloc_run(const std::shared_ptr<xrt::kernel_impl>& khdl)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_run_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_run_alloc);
   return khdl->has_mailbox()
     ? std::make_unique<xrt::mailbox_impl>(khdl)
     : std::make_unique<xrt::run_impl>(khdl);
@@ -3963,7 +3960,7 @@ alloc_kernel(const std::shared_ptr<device_type>& dev,
 	     const std::string& name,
 	     xrt::kernel::cu_access_mode mode)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_kernel_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc);
   auto amode = hwctx_access_mode(mode);  // legacy access mode to hwctx qos
   return std::make_shared<xrt::kernel_impl>(dev, xrt::hw_context{dev->get_xrt_device(), xclbin_id, amode}, xrt::module{}, name);
 }
@@ -3973,7 +3970,7 @@ alloc_kernel_from_ctx(const std::shared_ptr<device_type>& dev,
                       const xrt::hw_context& hwctx,
                       const std::string& name)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_kernel_ctx_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_ctx);
   // Delegating constructor with no module
   return std::make_shared<xrt::kernel_impl>(dev, hwctx, xrt::module{}, name);
 }
@@ -3984,7 +3981,7 @@ alloc_kernel_from_module(const std::shared_ptr<device_type>& dev,
                          const xrt::module& module,
                          const std::string& name)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_kernel_module_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_module);
   return std::make_shared<xrt::kernel_impl>(dev, hwctx, module, name);
 }
 
@@ -3993,7 +3990,7 @@ alloc_kernel_from_name(const std::shared_ptr<device_type>& dev,
                        const xrt::hw_context& hwctx,
                        const std::string& name)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_kernel_name_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_name);
   return std::make_shared<xrt::kernel_impl>(dev, hwctx, name);
 }
 
@@ -4246,6 +4243,7 @@ void
 run::
 set_dtrace_control_file(const std::string& path)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_run_set_dtrace_control_file);
   handle->set_dtrace_control_file(path);
 }
 
@@ -4332,20 +4330,23 @@ void
 run::
 set_arg_at_index(int index, const void* value, size_t bytes)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_run_set_arg_value);
   handle->set_arg_at_index(index, value, bytes);
 }
 
 void
 run::
 set_arg_at_index(int index, const xrt::bo& glb)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_run_set_arg_bo);
   handle->set_arg_at_index(index, glb);
 }
 
 void
 run::
 update_arg_at_index(int index, const void* value, size_t bytes)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_run_update_arg_value);
   auto upd = get_run_update(handle.get());
   upd->update_arg_at_index(index, value, bytes);
 }
@@ -4354,6 +4355,7 @@ void
 run::
 update_arg_at_index(int index, const xrt::bo& glb)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_run_update_arg_bo);
   auto upd = get_run_update(handle.get());
   upd->update_arg_at_index(index, glb);
 }
@@ -4523,7 +4525,7 @@ set_read_range(const xrt::kernel& kernel, uint32_t start, uint32_t size)
 static std::shared_ptr<runlist_impl>
 alloc_runlist(xrt::hw_context hwctx)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_runlist_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_runlist_alloc);
   return std::make_shared<runlist_impl>(std::move(hwctx));
 }
 
@@ -4542,6 +4544,7 @@ void
 runlist::
 add(const xrt::run& run)
 {
+  XRT_TRACE_POINT_SCOPE(xrt_runlist_add);
   if (!handle)
     throw xrt_core::error("cannot add run object to uninitialized runlist");
 
diff --git a/src/runtime_src/core/common/api/xrt_module.cpp b/src/runtime_src/core/common/api/xrt_module.cpp
@@ -90,10 +90,7 @@ class module_impl
     , m_name(std::move(name))
   {}
 
-  virtual ~module_impl()
-  {
-    XRT_TRACE_POINT_LOG(xrt_module_dtor);
-  }
+  virtual ~module_impl() = default;
 
   // Base class managed through shared_ptr - no copy/move
   module_impl(const module_impl&) = delete;
@@ -1143,14 +1140,14 @@ class module_run_aie_gen2_plus : public module_run
 static std::shared_ptr<module_impl>
 alloc_module_impl(const xrt::elf& elf)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_module_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_module_alloc_impl);
   return std::make_shared<module_impl>(elf);
 }
 
 static std::shared_ptr<module_impl>
 alloc_module_impl(const xrt::elf& elf, std::string name)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_module_name_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_module_alloc_impl_with_name);
   return std::make_shared<module_impl>(elf, std::move(name));
 }
 
@@ -1194,7 +1191,7 @@ xrt::module
 create_module_run(const xrt::elf& elf, const xrt::hw_context& hwctx,
                   uint32_t ctrl_code_id, const xrt::bo& ctrlpkt_bo)
 {
-  XRT_TRACE_POINT_SCOPE(xrt_module_run_ctor);
+  XRT_TRACE_POINT_SCOPE(xrt_module_run);
   auto platform = elf.get_platform();
   switch (platform) {
   case xrt::elf::platform::aie2p:

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ send_exception_message(const char* msg)`
`55`	`55`	`static std::shared_ptr<xrt_core::device>`
`56`	`56`	`alloc_device_index(unsigned int index)`
`57`	`57`	`{`
`58`		`- XRT_TRACE_POINT_SCOPE(xrt_device_index_ctor);`
	`58`	`+ XRT_TRACE_POINT_SCOPE(xrt_device_alloc_index);`
`59`	`59`	`auto dev = xrt_core::get_userpf_device(index);`
`60`	`60`
`61`	`61`	`dev->get_usage_logger()->log_device_info(dev.get());`
`@@ -66,7 +66,7 @@ alloc_device_index(unsigned int index)`
`66`	`66`	`static std::shared_ptr<xrt_core::device>`
`67`	`67`	`alloc_device_handle(xclDeviceHandle dhdl)`
`68`	`68`	`{`
`69`		`- XRT_TRACE_POINT_SCOPE(xrt_device_handle_ctor);`
	`69`	`+ XRT_TRACE_POINT_SCOPE(xrt_device_alloc_handle);`
`70`	`70`	`return xrt_core::get_userpf_device(dhdl) ;`
`71`	`71`	`}`
`72`	`72`
Original file line number	Diff line number	Diff line change
`@@ -232,6 +232,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>`
`232`	`232`	`static std::unique_ptr<uc_log_buffer>`
`233`	`233`	`init_uc_log_buf(const std::shared_ptr<xrt_core::device>& device, xrt_core::hwctx_handle* ctx_hdl)`
`234`	`234`	`{`
	`235`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_init_uc_log_buf);`
`235`	`236`	`// If uc log buffer is not supported then this function returns nullptr`
`236`	`237`	`static auto uc_log_enabled = xrt_core::config::get_uc_log();`
`237`	`238`	`if (!ctx_hdl \|\| !uc_log_enabled)`
`@@ -347,6 +348,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>`
`347`	`348`	`void`
`348`	`349`	`add_config(const xrt::elf& elf)`
`349`	`350`	`{`
	`351`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_add_config);`
`350`	`352`	`auto part_size = elf.get_partition_size();`
`351`	`353`
`352`	`354`	`// create hw ctx handle if not already created`
`@@ -409,6 +411,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>`
`409`	`411`	`void`
`410`	`412`	`dump_uc_log_buffer()`
`411`	`413`	`{`
	`414`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_dump_uc_log_buffer);`
`412`	`415`	`if (!m_uc_log_buf)`
`413`	`416`	`return;`
`414`	`417`
`@@ -537,6 +540,7 @@ class hw_context_impl : public std::enable_shared_from_this<hw_context_impl>`
`537`	`540`	`void`
`538`	`541`	`dump_scratchpad_mem()`
`539`	`542`	`{`
	`543`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_dump_scratchpad_mem);`
`540`	`544`	`if (m_scratchpad_buf.size() == 0) {`
`541`	`545`	`xrt_core::message::send(xrt_core::message::severity_level::debug, "xrt_hw_context",`
`542`	`546`	`"preemption scratchpad memory is not available");`
`@@ -728,23 +732,23 @@ template<typename Cfg>`
`728`	`732`	`static std::shared_ptr<hw_context_impl>`
`729`	`733`	`alloc_hwctx_from_cfg(const xrt::device& device, const xrt::uuid& xclbin_id, Cfg&& cfg)`
`730`	`734`	`{`
`731`		`- XRT_TRACE_POINT_SCOPE(xrt_hw_context_cfg_ctor);`
	`735`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_cfg);`
`732`	`736`	`return post_alloc_hwctx(std::make_shared<hw_context_impl>(`
`733`	`737`	`device.get_handle(), xclbin_id, hwctx_cfg_storage{std::forward<Cfg>(cfg)}));`
`734`	`738`	`}`
`735`	`739`
`736`	`740`	`static std::shared_ptr<hw_context_impl>`
`737`	`741`	`alloc_hwctx_from_mode(const xrt::device& device, const xrt::uuid& xclbin_id, xrt::hw_context::access_mode mode)`
`738`	`742`	`{`
`739`		`- XRT_TRACE_POINT_SCOPE(xrt_hw_context_mode_ctor);`
	`743`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_mode);`
`740`	`744`	`return post_alloc_hwctx(std::make_shared<hw_context_impl>(device.get_handle(), xclbin_id, mode));`
`741`	`745`	`}`
`742`	`746`
`743`	`747`	`template<typename Cfg>`
`744`	`748`	`static std::shared_ptr<hw_context_impl>`
`745`	`749`	`alloc_empty_hwctx(const xrt::device& device, Cfg&& cfg, xrt::hw_context::access_mode mode)`
`746`	`750`	`{`
`747`		`- XRT_TRACE_POINT_SCOPE(xrt_hw_context_empty_ctor);`
	`751`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_empty);`
`748`	`752`	`return post_alloc_hwctx(std::make_shared<hw_context_impl>(`
`749`	`753`	`device.get_handle(), hwctx_cfg_storage{std::forward<Cfg>(cfg)}, mode));`
`750`	`754`	`}`
`@@ -754,7 +758,7 @@ static std::shared_ptr<hw_context_impl>`
`754`	`758`	`alloc_hwctx_from_elf(const xrt::device& device, const xrt::elf& elf, Cfg&& cfg,`
`755`	`759`	`xrt::hw_context::access_mode mode)`
`756`	`760`	`{`
`757`		`- XRT_TRACE_POINT_SCOPE(xrt_hw_context_elf_ctor);`
	`761`	`+ XRT_TRACE_POINT_SCOPE(xrt_hw_context_alloc_from_elf);`
`758`	`762`	`return post_alloc_hwctx(std::make_shared<hw_context_impl>(`
`759`	`763`	`device.get_handle(), elf, hwctx_cfg_storage{std::forward<Cfg>(cfg)}, mode));`
`760`	`764`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1842,7 +1842,6 @@ class kernel_impl : public std::enable_shared_from_this<kernel_impl>`
`1842`	`1842`	`~kernel_impl()`
`1843`	`1843`	`{`
`1844`	`1844`	`XRT_DEBUGF("kernel_impl::~kernel_impl(%d)\n" , uid);`
`1845`		`- XRT_TRACE_POINT_LOG(xrt_kernel_dtor);`
`1846`	`1845`	`}`
`1847`	`1846`
`1848`	`1847`	`kernel_impl(const kernel_impl&) = delete;`
`@@ -2497,7 +2496,6 @@ class run_impl : public std::enable_shared_from_this<run_impl>`
`2497`	`2496`	`virtual`
`2498`	`2497`	`~run_impl()`
`2499`	`2498`	`{`
`2500`		`- XRT_TRACE_POINT_LOG(xrt_run_dtor);`
`2501`	`2499`	`// It is a fatal error to destruct a run_impl while its command is`
`2502`	`2500`	`// still in progress. But only abort if there are no live`
`2503`	`2501`	`// exception objects.`
`@@ -3680,7 +3678,6 @@ class runlist_impl`
`3680`	`3678`
`3681`	`3679`	`~runlist_impl()`
`3682`	`3680`	`{`
`3683`		`- XRT_TRACE_POINT_LOG(xrt_runlist_dtor);`
`3684`	`3681`	`// Make sure all run objects are severed from this list`
`3685`	`3682`	`try {`
`3686`	`3683`	`clear_runs();`
`@@ -3951,7 +3948,7 @@ get_run_update(xrtRunHandle rhdl)`
`3951`	`3948`	`static std::unique_ptr<xrt::run_impl>`
`3952`	`3949`	`alloc_run(const std::shared_ptr<xrt::kernel_impl>& khdl)`
`3953`	`3950`	`{`
`3954`		`- XRT_TRACE_POINT_SCOPE(xrt_run_ctor);`
	`3951`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_alloc);`
`3955`	`3952`	`return khdl->has_mailbox()`
`3956`	`3953`	`? std::make_unique<xrt::mailbox_impl>(khdl)`
`3957`	`3954`	`: std::make_unique<xrt::run_impl>(khdl);`
`@@ -3963,7 +3960,7 @@ alloc_kernel(const std::shared_ptr<device_type>& dev,`
`3963`	`3960`	`const std::string& name,`
`3964`	`3961`	`xrt::kernel::cu_access_mode mode)`
`3965`	`3962`	`{`
`3966`		`- XRT_TRACE_POINT_SCOPE(xrt_kernel_ctor);`
	`3963`	`+ XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc);`
`3967`	`3964`	`auto amode = hwctx_access_mode(mode); // legacy access mode to hwctx qos`
`3968`	`3965`	`return std::make_shared<xrt::kernel_impl>(dev, xrt::hw_context{dev->get_xrt_device(), xclbin_id, amode}, xrt::module{}, name);`
`3969`	`3966`	`}`
`@@ -3973,7 +3970,7 @@ alloc_kernel_from_ctx(const std::shared_ptr<device_type>& dev,`
`3973`	`3970`	`const xrt::hw_context& hwctx,`
`3974`	`3971`	`const std::string& name)`
`3975`	`3972`	`{`
`3976`		`- XRT_TRACE_POINT_SCOPE(xrt_kernel_ctx_ctor);`
	`3973`	`+ XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_ctx);`
`3977`	`3974`	`// Delegating constructor with no module`
`3978`	`3975`	`return std::make_shared<xrt::kernel_impl>(dev, hwctx, xrt::module{}, name);`
`3979`	`3976`	`}`
`@@ -3984,7 +3981,7 @@ alloc_kernel_from_module(const std::shared_ptr<device_type>& dev,`
`3984`	`3981`	`const xrt::module& module,`
`3985`	`3982`	`const std::string& name)`
`3986`	`3983`	`{`
`3987`		`- XRT_TRACE_POINT_SCOPE(xrt_kernel_module_ctor);`
	`3984`	`+ XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_module);`
`3988`	`3985`	`return std::make_shared<xrt::kernel_impl>(dev, hwctx, module, name);`
`3989`	`3986`	`}`
`3990`	`3987`
`@@ -3993,7 +3990,7 @@ alloc_kernel_from_name(const std::shared_ptr<device_type>& dev,`
`3993`	`3990`	`const xrt::hw_context& hwctx,`
`3994`	`3991`	`const std::string& name)`
`3995`	`3992`	`{`
`3996`		`- XRT_TRACE_POINT_SCOPE(xrt_kernel_name_ctor);`
	`3993`	`+ XRT_TRACE_POINT_SCOPE(xrt_kernel_alloc_from_name);`
`3997`	`3994`	`return std::make_shared<xrt::kernel_impl>(dev, hwctx, name);`
`3998`	`3995`	`}`
`3999`	`3996`
`@@ -4246,6 +4243,7 @@ void`
`4246`	`4243`	`run::`
`4247`	`4244`	`set_dtrace_control_file(const std::string& path)`
`4248`	`4245`	`{`
	`4246`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_set_dtrace_control_file);`
`4249`	`4247`	`handle->set_dtrace_control_file(path);`
`4250`	`4248`	`}`
`4251`	`4249`
`@@ -4332,20 +4330,23 @@ void`
`4332`	`4330`	`run::`
`4333`	`4331`	`set_arg_at_index(int index, const void* value, size_t bytes)`
`4334`	`4332`	`{`
	`4333`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_set_arg_value);`
`4335`	`4334`	`handle->set_arg_at_index(index, value, bytes);`
`4336`	`4335`	`}`
`4337`	`4336`
`4338`	`4337`	`void`
`4339`	`4338`	`run::`
`4340`	`4339`	`set_arg_at_index(int index, const xrt::bo& glb)`
`4341`	`4340`	`{`
	`4341`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_set_arg_bo);`
`4342`	`4342`	`handle->set_arg_at_index(index, glb);`
`4343`	`4343`	`}`
`4344`	`4344`
`4345`	`4345`	`void`
`4346`	`4346`	`run::`
`4347`	`4347`	`update_arg_at_index(int index, const void* value, size_t bytes)`
`4348`	`4348`	`{`
	`4349`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_update_arg_value);`
`4349`	`4350`	`auto upd = get_run_update(handle.get());`
`4350`	`4351`	`upd->update_arg_at_index(index, value, bytes);`
`4351`	`4352`	`}`
`@@ -4354,6 +4355,7 @@ void`
`4354`	`4355`	`run::`
`4355`	`4356`	`update_arg_at_index(int index, const xrt::bo& glb)`
`4356`	`4357`	`{`
	`4358`	`+ XRT_TRACE_POINT_SCOPE(xrt_run_update_arg_bo);`
`4357`	`4359`	`auto upd = get_run_update(handle.get());`
`4358`	`4360`	`upd->update_arg_at_index(index, glb);`
`4359`	`4361`	`}`
`@@ -4523,7 +4525,7 @@ set_read_range(const xrt::kernel& kernel, uint32_t start, uint32_t size)`
`4523`	`4525`	`static std::shared_ptr<runlist_impl>`
`4524`	`4526`	`alloc_runlist(xrt::hw_context hwctx)`
`4525`	`4527`	`{`
`4526`		`- XRT_TRACE_POINT_SCOPE(xrt_runlist_ctor);`
	`4528`	`+ XRT_TRACE_POINT_SCOPE(xrt_runlist_alloc);`
`4527`	`4529`	`return std::make_shared<runlist_impl>(std::move(hwctx));`
`4528`	`4530`	`}`
`4529`	`4531`
`@@ -4542,6 +4544,7 @@ void`
`4542`	`4544`	`runlist::`
`4543`	`4545`	`add(const xrt::run& run)`
`4544`	`4546`	`{`
	`4547`	`+ XRT_TRACE_POINT_SCOPE(xrt_runlist_add);`
`4545`	`4548`	`if (!handle)`
`4546`	`4549`	`throw xrt_core::error("cannot add run object to uninitialized runlist");`
`4547`	`4550`