diff --git a/sycl/include/CL/sycl/detail/usm_impl.hpp b/sycl/include/CL/sycl/detail/usm_impl.hpp
index 8be99fede9059..ebe71674f6d5d 100644
--- a/sycl/include/CL/sycl/detail/usm_impl.hpp
+++ b/sycl/include/CL/sycl/detail/usm_impl.hpp
@@ -7,6 +7,7 @@
 // ===--------------------------------------------------------------------=== //
 #pragma once
 
+#include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/usm/usm_enums.hpp>
 
@@ -17,13 +18,16 @@ namespace usm {
 
 __SYCL_EXPORT void *alignedAlloc(size_t Alignment, size_t Bytes,
                                  const context &Ctxt, const device &Dev,
-                                 cl::sycl::usm::alloc Kind);
+                                 cl::sycl::usm::alloc Kind,
+                                 const code_location &CL);
 
 __SYCL_EXPORT void *alignedAllocHost(size_t Alignment, size_t Bytes,
                                      const context &Ctxt,
-                                     cl::sycl::usm::alloc Kind);
+                                     cl::sycl::usm::alloc Kind,
+                                     const code_location &CL);
 
-__SYCL_EXPORT void free(void *Ptr, const context &Ctxt);
+__SYCL_EXPORT void free(void *Ptr, const context &Ctxt,
+                        const code_location &CL);
 
 } // namespace usm
 } // namespace detail
diff --git a/sycl/include/CL/sycl/usm.hpp b/sycl/include/CL/sycl/usm.hpp
index ba91029144fb5..6b4542e7f2ee0 100644
--- a/sycl/include/CL/sycl/usm.hpp
+++ b/sycl/include/CL/sycl/usm.hpp
@@ -18,205 +18,269 @@ namespace sycl {
 ///
 // Explicit USM
 ///
-__SYCL_EXPORT void *malloc_device(size_t size, const device &dev,
-                                  const context &ctxt);
-__SYCL_EXPORT void *malloc_device(size_t size, const device &dev,
-                                  const context &ctxt,
-                                  const property_list &propList);
-__SYCL_EXPORT void *malloc_device(size_t size, const queue &q);
-__SYCL_EXPORT void *malloc_device(size_t size, const queue &q,
-                                  const property_list &propList);
-
-__SYCL_EXPORT void *aligned_alloc_device(size_t alignment, size_t size,
-                                         const device &dev,
-                                         const context &ctxt);
-__SYCL_EXPORT void *aligned_alloc_device(size_t alignment, size_t size,
-                                         const device &dev, const context &ctxt,
-                                         const property_list &propList);
-__SYCL_EXPORT void *aligned_alloc_device(size_t alignment, size_t size,
-                                         const queue &q);
-__SYCL_EXPORT void *aligned_alloc_device(size_t alignment, size_t size,
-                                         const queue &q,
-                                         const property_list &propList);
-
-__SYCL_EXPORT void free(void *ptr, const context &ctxt);
-__SYCL_EXPORT void free(void *ptr, const queue &q);
+__SYCL_EXPORT void *malloc_device(
+    size_t size, const device &dev, const context &ctxt,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_device(
+    size_t size, const device &dev, const context &ctxt,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_device(
+    size_t size, const queue &q,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_device(
+    size_t size, const queue &q, const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void *aligned_alloc_device(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_device(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_device(
+    size_t alignment, size_t size, const queue &q,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_device(
+    size_t alignment, size_t size, const queue &q,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void
+free(void *ptr, const context &ctxt,
+     const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void
+free(void *ptr, const queue &q,
+     const detail::code_location CL = detail::code_location::current());
 
 ///
 // Restricted USM
 ///
-__SYCL_EXPORT void *malloc_host(size_t size, const context &ctxt);
-__SYCL_EXPORT void *malloc_host(size_t size, const context &ctxt,
-                                const property_list &propList);
-__SYCL_EXPORT void *malloc_host(size_t size, const queue &q);
-__SYCL_EXPORT void *malloc_host(size_t size, const queue &q,
-                                const property_list &propList);
-
-__SYCL_EXPORT void *malloc_shared(size_t size, const device &dev,
-                                  const context &ctxt);
-__SYCL_EXPORT void *malloc_shared(size_t size, const device &dev,
-                                  const context &ctxt,
-                                  const property_list &propList);
-__SYCL_EXPORT void *malloc_shared(size_t size, const queue &q);
-__SYCL_EXPORT void *malloc_shared(size_t size, const queue &q,
-                                  const property_list &propList);
-
-__SYCL_EXPORT void *aligned_alloc_host(size_t alignment, size_t size,
-                                       const context &ctxt);
-__SYCL_EXPORT void *aligned_alloc_host(size_t alignment, size_t size,
-                                       const context &ctxt,
-                                       const property_list &propList);
-__SYCL_EXPORT void *aligned_alloc_host(size_t alignment, size_t size,
-                                       const queue &q);
-__SYCL_EXPORT void *aligned_alloc_host(size_t alignment, size_t size,
-                                       const queue &q,
-                                       const property_list &propList);
-
-__SYCL_EXPORT void *aligned_alloc_shared(size_t alignment, size_t size,
-                                         const device &dev,
-                                         const context &ctxt);
-__SYCL_EXPORT void *aligned_alloc_shared(size_t alignment, size_t size,
-                                         const device &dev, const context &ctxt,
-                                         const property_list &propList);
-__SYCL_EXPORT void *aligned_alloc_shared(size_t alignment, size_t size,
-                                         const queue &q);
-__SYCL_EXPORT void *aligned_alloc_shared(size_t alignment, size_t size,
-                                         const queue &q,
-                                         const property_list &propList);
+__SYCL_EXPORT void *
+malloc_host(size_t size, const context &ctxt,
+            const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc_host(size_t size, const context &ctxt, const property_list &propList,
+            const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc_host(size_t size, const queue &q,
+            const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc_host(size_t size, const queue &q, const property_list &propList,
+            const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void *malloc_shared(
+    size_t size, const device &dev, const context &ctxt,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_shared(
+    size_t size, const device &dev, const context &ctxt,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_shared(
+    size_t size, const queue &q,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *malloc_shared(
+    size_t size, const queue &q, const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void *aligned_alloc_host(
+    size_t alignment, size_t size, const context &ctxt,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_host(
+    size_t alignment, size_t size, const context &ctxt,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_host(
+    size_t alignment, size_t size, const queue &q,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_host(
+    size_t alignment, size_t size, const queue &q,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void *aligned_alloc_shared(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_shared(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_shared(
+    size_t alignment, size_t size, const queue &q,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc_shared(
+    size_t alignment, size_t size, const queue &q,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
 
 ///
 // single form
 ///
-__SYCL_EXPORT void *malloc(size_t size, const device &dev, const context &ctxt,
-                           usm::alloc kind);
-__SYCL_EXPORT void *malloc(size_t size, const device &dev, const context &ctxt,
-                           usm::alloc kind, const property_list &propList);
-__SYCL_EXPORT void *malloc(size_t size, const queue &q, usm::alloc kind);
-__SYCL_EXPORT void *malloc(size_t size, const queue &q, usm::alloc kind,
-                           const property_list &propList);
-
-__SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size,
-                                  const device &dev, const context &ctxt,
-                                  usm::alloc kind);
-__SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size,
-                                  const device &dev, const context &ctxt,
-                                  usm::alloc kind,
-                                  const property_list &propList);
-__SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size, const queue &q,
-                                  usm::alloc kind);
-__SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size, const queue &q,
-                                  usm::alloc kind,
-                                  const property_list &propList);
+__SYCL_EXPORT void *
+malloc(size_t size, const device &dev, const context &ctxt, usm::alloc kind,
+       const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc(size_t size, const device &dev, const context &ctxt, usm::alloc kind,
+       const property_list &propList,
+       const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc(size_t size, const queue &q, usm::alloc kind,
+       const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *
+malloc(size_t size, const queue &q, usm::alloc kind,
+       const property_list &propList,
+       const detail::code_location CL = detail::code_location::current());
+
+__SYCL_EXPORT void *aligned_alloc(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    usm::alloc kind,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc(
+    size_t alignment, size_t size, const device &dev, const context &ctxt,
+    usm::alloc kind, const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc(
+    size_t alignment, size_t size, const queue &q, usm::alloc kind,
+    const detail::code_location CL = detail::code_location::current());
+__SYCL_EXPORT void *aligned_alloc(
+    size_t alignment, size_t size, const queue &q, usm::alloc kind,
+    const property_list &propList,
+    const detail::code_location CL = detail::code_location::current());
 
 ///
 // Template forms
 ///
 template <typename T>
-T *malloc_device(size_t Count, const device &Dev, const context &Ctxt,
-                 const property_list &PropList = {}) {
+T *malloc_device(
+    size_t Count, const device &Dev, const context &Ctxt,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return static_cast<T *>(
-      malloc_device(Count * sizeof(T), Dev, Ctxt, PropList));
+      malloc_device(Count * sizeof(T), Dev, Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *malloc_device(size_t Count, const queue &Q,
-                 const property_list &PropList = {}) {
-  return malloc_device<T>(Count, Q.get_device(), Q.get_context(), PropList);
+T *malloc_device(
+    size_t Count, const queue &Q, const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return malloc_device<T>(Count, Q.get_device(), Q.get_context(), PropList, CL);
 }
 
 template <typename T>
-T *aligned_alloc_device(size_t Alignment, size_t Count, const device &Dev,
-                        const context &Ctxt,
-                        const property_list &PropList = {}) {
-  return static_cast<T *>(
-      aligned_alloc_device(Alignment, Count * sizeof(T), Dev, Ctxt, PropList));
+T *aligned_alloc_device(
+    size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return static_cast<T *>(aligned_alloc_device(Alignment, Count * sizeof(T),
+                                               Dev, Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *aligned_alloc_device(size_t Alignment, size_t Count, const queue &Q,
-                        const property_list &PropList = {}) {
+T *aligned_alloc_device(
+    size_t Alignment, size_t Count, const queue &Q,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return aligned_alloc_device<T>(Alignment, Count, Q.get_device(),
-                                 Q.get_context(), PropList);
+                                 Q.get_context(), PropList, CL);
 }
 
 template <typename T>
-T *malloc_host(size_t Count, const context &Ctxt,
-               const property_list &PropList = {}) {
-  return static_cast<T *>(malloc_host(Count * sizeof(T), Ctxt, PropList));
+T *malloc_host(
+    size_t Count, const context &Ctxt, const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return static_cast<T *>(malloc_host(Count * sizeof(T), Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *malloc_host(size_t Count, const queue &Q,
-               const property_list &PropList = {}) {
-  return malloc_host<T>(Count, Q.get_context(), PropList);
+T *malloc_host(
+    size_t Count, const queue &Q, const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return malloc_host<T>(Count, Q.get_context(), PropList, CL);
 }
 
 template <typename T>
-T *malloc_shared(size_t Count, const device &Dev, const context &Ctxt,
-                 const property_list &PropList = {}) {
+T *malloc_shared(
+    size_t Count, const device &Dev, const context &Ctxt,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return static_cast<T *>(
-      malloc_shared(Count * sizeof(T), Dev, Ctxt, PropList));
+      malloc_shared(Count * sizeof(T), Dev, Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *malloc_shared(size_t Count, const queue &Q,
-                 const property_list &PropList = {}) {
-  return malloc_shared<T>(Count, Q.get_device(), Q.get_context(), PropList);
+T *malloc_shared(
+    size_t Count, const queue &Q, const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return malloc_shared<T>(Count, Q.get_device(), Q.get_context(), PropList, CL);
 }
 
 template <typename T>
-T *aligned_alloc_host(size_t Alignment, size_t Count, const context &Ctxt,
-                      const property_list &PropList = {}) {
+T *aligned_alloc_host(
+    size_t Alignment, size_t Count, const context &Ctxt,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return static_cast<T *>(
-      aligned_alloc_host(Alignment, Count * sizeof(T), Ctxt, PropList));
+      aligned_alloc_host(Alignment, Count * sizeof(T), Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *aligned_alloc_host(size_t Alignment, size_t Count, const queue &Q,
-                      const property_list &PropList = {}) {
-  return aligned_alloc_host<T>(Alignment, Count, Q.get_context(), PropList);
+T *aligned_alloc_host(
+    size_t Alignment, size_t Count, const queue &Q,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return aligned_alloc_host<T>(Alignment, Count, Q.get_context(), PropList, CL);
 }
 
 template <typename T>
-T *aligned_alloc_shared(size_t Alignment, size_t Count, const device &Dev,
-                        const context &Ctxt,
-                        const property_list &PropList = {}) {
-  return static_cast<T *>(
-      aligned_alloc_shared(Alignment, Count * sizeof(T), Dev, Ctxt, PropList));
+T *aligned_alloc_shared(
+    size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return static_cast<T *>(aligned_alloc_shared(Alignment, Count * sizeof(T),
+                                               Dev, Ctxt, PropList, CL));
 }
 
 template <typename T>
-T *aligned_alloc_shared(size_t Alignment, size_t Count, const queue &Q,
-                        const property_list &PropList = {}) {
+T *aligned_alloc_shared(
+    size_t Alignment, size_t Count, const queue &Q,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return aligned_alloc_shared<T>(Alignment, Count, Q.get_device(),
-                                 Q.get_context(), PropList);
+                                 Q.get_context(), PropList, CL);
 }
 
 template <typename T>
 T *malloc(size_t Count, const device &Dev, const context &Ctxt, usm::alloc Kind,
-          const property_list &PropList = {}) {
-  return static_cast<T *>(malloc(Count * sizeof(T), Dev, Ctxt, Kind, PropList));
+          const property_list &PropList = {},
+          const detail::code_location CL = detail::code_location::current()) {
+  return static_cast<T *>(
+      malloc(Count * sizeof(T), Dev, Ctxt, Kind, PropList, CL));
 }
 
 template <typename T>
 T *malloc(size_t Count, const queue &Q, usm::alloc Kind,
-          const property_list &PropList = {}) {
-  return malloc<T>(Count, Q.get_device(), Q.get_context(), Kind, PropList);
+          const property_list &PropList = {},
+          const detail::code_location CL = detail::code_location::current()) {
+  return malloc<T>(Count, Q.get_device(), Q.get_context(), Kind, PropList, CL);
 }
 
 template <typename T>
-T *aligned_alloc(size_t Alignment, size_t Count, const device &Dev,
-                 const context &Ctxt, usm::alloc Kind,
-                 const property_list &PropList = {}) {
-  return static_cast<T *>(
-      aligned_alloc(Alignment, Count * sizeof(T), Dev, Ctxt, Kind, PropList));
+T *aligned_alloc(
+    size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
+    usm::alloc Kind, const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
+  return static_cast<T *>(aligned_alloc(Alignment, Count * sizeof(T), Dev, Ctxt,
+                                        Kind, PropList, CL));
 }
 
 template <typename T>
-T *aligned_alloc(size_t Alignment, size_t Count, const queue &Q,
-                 usm::alloc Kind, const property_list &PropList = {}) {
+T *aligned_alloc(
+    size_t Alignment, size_t Count, const queue &Q, usm::alloc Kind,
+    const property_list &PropList = {},
+    const detail::code_location CL = detail::code_location::current()) {
   return aligned_alloc<T>(Alignment, Count, Q.get_device(), Q.get_context(),
-                          Kind, PropList);
+                          Kind, PropList, CL);
 }
 
 // Pointer queries
diff --git a/sycl/include/CL/sycl/usm/usm_allocator.hpp b/sycl/include/CL/sycl/usm/usm_allocator.hpp
index 9bcc63d521e13..6fff25ddbded5 100644
--- a/sycl/include/CL/sycl/usm/usm_allocator.hpp
+++ b/sycl/include/CL/sycl/usm/usm_allocator.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 #include <CL/sycl/context.hpp>
+#include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/exception.hpp>
@@ -24,8 +25,10 @@ namespace sycl {
 __SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size,
                                   const device &dev, const context &ctxt,
                                   usm::alloc kind,
-                                  const property_list &propList);
-__SYCL_EXPORT void free(void *ptr, const context &ctxt);
+                                  const property_list &propList,
+                                  const detail::code_location CL);
+__SYCL_EXPORT void free(void *ptr, const context &ctxt,
+                        const detail::code_location CL);
 
 template <typename T, usm::alloc AllocKind, size_t Alignment = alignof(T)>
 class usm_allocator {
@@ -74,11 +77,12 @@ class usm_allocator {
   /// Allocates memory.
   ///
   /// \param NumberOfElements is a count of elements to allocate memory for.
-  T *allocate(size_t NumberOfElements) {
+  T *allocate(size_t NumberOfElements, const detail::code_location CL =
+                                           detail::code_location::current()) {
 
     auto Result = reinterpret_cast<T *>(
         aligned_alloc(getAlignment(), NumberOfElements * sizeof(value_type),
-                      MDevice, MContext, AllocKind, MPropList));
+                      MDevice, MContext, AllocKind, MPropList, CL));
     if (!Result) {
       throw memory_allocation_error();
     }
@@ -89,9 +93,11 @@ class usm_allocator {
   ///
   /// \param Ptr is a pointer to memory being deallocated.
   /// \param Size is a number of elements previously passed to allocate.
-  void deallocate(T *Ptr, size_t) {
+  void deallocate(
+      T *Ptr, size_t,
+      const detail::code_location CL = detail::code_location::current()) {
     if (Ptr) {
-      free(Ptr, MContext);
+      free(Ptr, MContext, CL);
     }
   }
 
diff --git a/sycl/source/detail/usm/usm_impl.cpp b/sycl/source/detail/usm/usm_impl.cpp
index 54d530c5ca3cd..0650877131c50 100644
--- a/sycl/source/detail/usm/usm_impl.cpp
+++ b/sycl/source/detail/usm/usm_impl.cpp
@@ -15,6 +15,25 @@
 #include <detail/queue_impl.hpp>
 
 #include <cstdlib>
+#include <memory>
+
+#ifdef XPTI_ENABLE_INSTRUMENTATION
+// Include the headers necessary for emitting
+// traces using the trace framework
+#include "xpti/xpti_trace_framework.hpp"
+
+#define XPTI_CREATE_TRACEPOINT(CL)                                             \
+  std::unique_ptr<xpti::framework::tracepoint_t> _TP(nullptr);                 \
+  if (xptiTraceEnabled()) {                                                    \
+    xpti::payload_t Payload{CL.functionName(), CL.fileName(),                  \
+                            static_cast<int>(CL.lineNumber()),                 \
+                            static_cast<int>(CL.columnNumber()), nullptr};     \
+    _TP = std::make_unique<xpti::framework::tracepoint_t>(&Payload);           \
+  }                                                                            \
+  (void)_TP;
+#else
+#define XPTI_CREATE_TRACEPOINT(CL)
+#endif
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
@@ -25,7 +44,8 @@ namespace detail {
 namespace usm {
 
 void *alignedAllocHost(size_t Alignment, size_t Size, const context &Ctxt,
-                       alloc Kind) {
+                       alloc Kind, const detail::code_location &CL) {
+  XPTI_CREATE_TRACEPOINT(CL);
   void *RetVal = nullptr;
   if (Size == 0)
     return nullptr;
@@ -72,7 +92,9 @@ void *alignedAllocHost(size_t Alignment, size_t Size, const context &Ctxt,
 }
 
 void *alignedAlloc(size_t Alignment, size_t Size, const context &Ctxt,
-                   const device &Dev, alloc Kind) {
+                   const device &Dev, alloc Kind,
+                   const detail::code_location &CL) {
+  XPTI_CREATE_TRACEPOINT(CL);
   void *RetVal = nullptr;
   if (Size == 0)
     return nullptr;
@@ -129,7 +151,8 @@ void *alignedAlloc(size_t Alignment, size_t Size, const context &Ctxt,
   return RetVal;
 }
 
-void free(void *Ptr, const context &Ctxt) {
+void free(void *Ptr, const context &Ctxt, const detail::code_location &CL) {
+  XPTI_CREATE_TRACEPOINT(CL);
   if (Ptr == nullptr)
     return;
   if (Ctxt.is_host()) {
@@ -143,182 +166,232 @@ void free(void *Ptr, const context &Ctxt) {
   }
 }
 
+// For ABI compatibility
+// TODO remove once ABI breakages are allowed.
+__SYCL_EXPORT void *alignedAllocHost(size_t Alignment, size_t Size,
+                                     const context &Ctxt, alloc Kind) {
+  return alignedAllocHost(Alignment, Size, Ctxt, Kind, detail::code_location{});
+}
+
+__SYCL_EXPORT void free(void *Ptr, const context &Ctxt) {
+  detail::usm::free(Ptr, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void *alignedAlloc(size_t Alignment, size_t Size,
+                                 const context &Ctxt, const device &Dev,
+                                 alloc Kind) {
+  return alignedAlloc(Alignment, Size, Ctxt, Dev, Kind,
+                      detail::code_location{});
+}
+
 } // namespace usm
 } // namespace detail
 
-void *malloc_device(size_t Size, const device &Dev, const context &Ctxt) {
-  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::device);
+void *malloc_device(size_t Size, const device &Dev, const context &Ctxt,
+                    const detail::code_location CL) {
+  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::device, CL);
 }
 
 void *malloc_device(size_t Size, const device &Dev, const context &Ctxt,
-                    const property_list &) {
-  return malloc_device(Size, Dev, Ctxt);
+                    const property_list &, const detail::code_location CL) {
+  return malloc_device(Size, Dev, Ctxt, CL);
 }
 
-void *malloc_device(size_t Size, const queue &Q) {
-  return malloc_device(Size, Q.get_device(), Q.get_context());
+void *malloc_device(size_t Size, const queue &Q,
+                    const detail::code_location CL) {
+  return malloc_device(Size, Q.get_device(), Q.get_context(), CL);
 }
 
-void *malloc_device(size_t Size, const queue &Q,
-                    const property_list &PropList) {
-  return malloc_device(Size, Q.get_device(), Q.get_context(), PropList);
+void *malloc_device(size_t Size, const queue &Q, const property_list &PropList,
+                    const detail::code_location CL) {
+  return malloc_device(Size, Q.get_device(), Q.get_context(), PropList, CL);
 }
 
 void *aligned_alloc_device(size_t Alignment, size_t Size, const device &Dev,
-                           const context &Ctxt) {
-  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::device);
+                           const context &Ctxt,
+                           const detail::code_location CL) {
+  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::device,
+                                   CL);
 }
 
 void *aligned_alloc_device(size_t Alignment, size_t Size, const device &Dev,
-                           const context &Ctxt, const property_list &) {
-  return aligned_alloc_device(Alignment, Size, Dev, Ctxt);
+                           const context &Ctxt, const property_list &,
+                           const detail::code_location CL) {
+  return aligned_alloc_device(Alignment, Size, Dev, Ctxt, CL);
 }
 
-void *aligned_alloc_device(size_t Alignment, size_t Size, const queue &Q) {
-  return aligned_alloc_device(Alignment, Size, Q.get_device(), Q.get_context());
+void *aligned_alloc_device(size_t Alignment, size_t Size, const queue &Q,
+                           const detail::code_location CL) {
+  return aligned_alloc_device(Alignment, Size, Q.get_device(), Q.get_context(),
+                              CL);
 }
 
 void *aligned_alloc_device(size_t Alignment, size_t Size, const queue &Q,
-                           const property_list &PropList) {
+                           const property_list &PropList,
+                           const detail::code_location CL) {
   return aligned_alloc_device(Alignment, Size, Q.get_device(), Q.get_context(),
-                              PropList);
+                              PropList, CL);
 }
 
-void free(void *ptr, const context &Ctxt) {
-  return detail::usm::free(ptr, Ctxt);
+void free(void *ptr, const context &Ctxt, const detail::code_location CL) {
+  return detail::usm::free(ptr, Ctxt, CL);
 }
 
-void free(void *ptr, const queue &Q) { return free(ptr, Q.get_context()); }
+void free(void *ptr, const queue &Q, const detail::code_location CL) {
+  return free(ptr, Q.get_context(), CL);
+}
 
 ///
 // Restricted USM
 ///
-void *malloc_host(size_t Size, const context &Ctxt) {
-  return detail::usm::alignedAllocHost(0, Size, Ctxt, alloc::host);
+void *malloc_host(size_t Size, const context &Ctxt,
+                  const detail::code_location CL) {
+  return detail::usm::alignedAllocHost(0, Size, Ctxt, alloc::host, CL);
 }
 
-void *malloc_host(size_t Size, const context &Ctxt, const property_list &) {
-  return malloc_host(Size, Ctxt);
+void *malloc_host(size_t Size, const context &Ctxt, const property_list &,
+                  const detail::code_location CL) {
+  return malloc_host(Size, Ctxt, CL);
 }
 
-void *malloc_host(size_t Size, const queue &Q) {
-  return malloc_host(Size, Q.get_context());
+void *malloc_host(size_t Size, const queue &Q, const detail::code_location CL) {
+  return malloc_host(Size, Q.get_context(), CL);
 }
 
-void *malloc_host(size_t Size, const queue &Q, const property_list &PropList) {
-  return malloc_host(Size, Q.get_context(), PropList);
+void *malloc_host(size_t Size, const queue &Q, const property_list &PropList,
+                  const detail::code_location CL) {
+  return malloc_host(Size, Q.get_context(), PropList, CL);
 }
 
-void *malloc_shared(size_t Size, const device &Dev, const context &Ctxt) {
-  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::shared);
+void *malloc_shared(size_t Size, const device &Dev, const context &Ctxt,
+                    const detail::code_location CL) {
+  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::shared, CL);
 }
 
 void *malloc_shared(size_t Size, const device &Dev, const context &Ctxt,
-                    const property_list &) {
-  return malloc_shared(Size, Dev, Ctxt);
+                    const property_list &, const detail::code_location CL) {
+  return malloc_shared(Size, Dev, Ctxt, CL);
 }
 
-void *malloc_shared(size_t Size, const queue &Q) {
-  return malloc_shared(Size, Q.get_device(), Q.get_context());
+void *malloc_shared(size_t Size, const queue &Q,
+                    const detail::code_location CL) {
+  return malloc_shared(Size, Q.get_device(), Q.get_context(), CL);
 }
 
-void *malloc_shared(size_t Size, const queue &Q,
-                    const property_list &PropList) {
-  return malloc_shared(Size, Q.get_device(), Q.get_context(), PropList);
+void *malloc_shared(size_t Size, const queue &Q, const property_list &PropList,
+                    const detail::code_location CL) {
+  return malloc_shared(Size, Q.get_device(), Q.get_context(), PropList, CL);
 }
 
-void *aligned_alloc_host(size_t Alignment, size_t Size, const context &Ctxt) {
-  return detail::usm::alignedAllocHost(Alignment, Size, Ctxt, alloc::host);
+void *aligned_alloc_host(size_t Alignment, size_t Size, const context &Ctxt,
+                         const detail::code_location CL) {
+  return detail::usm::alignedAllocHost(Alignment, Size, Ctxt, alloc::host, CL);
 }
 
 void *aligned_alloc_host(size_t Alignment, size_t Size, const context &Ctxt,
-                         const property_list &) {
-  return aligned_alloc_host(Alignment, Size, Ctxt);
+                         const property_list &,
+                         const detail::code_location CL) {
+  return aligned_alloc_host(Alignment, Size, Ctxt, CL);
 }
 
-void *aligned_alloc_host(size_t Alignment, size_t Size, const queue &Q) {
-  return aligned_alloc_host(Alignment, Size, Q.get_context());
+void *aligned_alloc_host(size_t Alignment, size_t Size, const queue &Q,
+                         const detail::code_location CL) {
+  return aligned_alloc_host(Alignment, Size, Q.get_context(), CL);
 }
 
 void *aligned_alloc_host(size_t Alignment, size_t Size, const queue &Q,
-                         const property_list &PropList) {
-  return aligned_alloc_host(Alignment, Size, Q.get_context(), PropList);
+                         const property_list &PropList,
+                         const detail::code_location CL) {
+  return aligned_alloc_host(Alignment, Size, Q.get_context(), PropList, CL);
 }
 
 void *aligned_alloc_shared(size_t Alignment, size_t Size, const device &Dev,
-                           const context &Ctxt) {
-  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::shared);
+                           const context &Ctxt,
+                           const detail::code_location CL) {
+  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::shared,
+                                   CL);
 }
 
 void *aligned_alloc_shared(size_t Alignment, size_t Size, const device &Dev,
-                           const context &Ctxt, const property_list &) {
-  return aligned_alloc_shared(Alignment, Size, Dev, Ctxt);
+                           const context &Ctxt, const property_list &,
+                           const detail::code_location CL) {
+  return aligned_alloc_shared(Alignment, Size, Dev, Ctxt, CL);
 }
 
-void *aligned_alloc_shared(size_t Alignment, size_t Size, const queue &Q) {
-  return aligned_alloc_shared(Alignment, Size, Q.get_device(), Q.get_context());
+void *aligned_alloc_shared(size_t Alignment, size_t Size, const queue &Q,
+                           const detail::code_location CL) {
+  return aligned_alloc_shared(Alignment, Size, Q.get_device(), Q.get_context(),
+                              CL);
 }
 
 void *aligned_alloc_shared(size_t Alignment, size_t Size, const queue &Q,
-                           const property_list &PropList) {
+                           const property_list &PropList,
+                           const detail::code_location CL) {
   return aligned_alloc_shared(Alignment, Size, Q.get_device(), Q.get_context(),
-                              PropList);
+                              PropList, CL);
 }
 
 // single form
 
-void *malloc(size_t Size, const device &Dev, const context &Ctxt, alloc Kind) {
+void *malloc(size_t Size, const device &Dev, const context &Ctxt, alloc Kind,
+             const detail::code_location CL) {
   void *RetVal = nullptr;
 
   if (Kind == alloc::host) {
-    RetVal = detail::usm::alignedAllocHost(0, Size, Ctxt, Kind);
+    RetVal = detail::usm::alignedAllocHost(0, Size, Ctxt, Kind, CL);
   } else {
-    RetVal = detail::usm::alignedAlloc(0, Size, Ctxt, Dev, Kind);
+    RetVal = detail::usm::alignedAlloc(0, Size, Ctxt, Dev, Kind, CL);
   }
 
   return RetVal;
 }
 
 void *malloc(size_t Size, const device &Dev, const context &Ctxt, alloc Kind,
-             const property_list &) {
-  return malloc(Size, Dev, Ctxt, Kind);
+             const property_list &, const detail::code_location CL) {
+  return malloc(Size, Dev, Ctxt, Kind, CL);
 }
 
-void *malloc(size_t Size, const queue &Q, alloc Kind) {
-  return malloc(Size, Q.get_device(), Q.get_context(), Kind);
+void *malloc(size_t Size, const queue &Q, alloc Kind,
+             const detail::code_location CL) {
+  return malloc(Size, Q.get_device(), Q.get_context(), Kind, CL);
 }
 
 void *malloc(size_t Size, const queue &Q, alloc Kind,
-             const property_list &PropList) {
-  return malloc(Size, Q.get_device(), Q.get_context(), Kind, PropList);
+             const property_list &PropList, const detail::code_location CL) {
+  return malloc(Size, Q.get_device(), Q.get_context(), Kind, PropList, CL);
 }
 
 void *aligned_alloc(size_t Alignment, size_t Size, const device &Dev,
-                    const context &Ctxt, alloc Kind) {
+                    const context &Ctxt, alloc Kind,
+                    const detail::code_location CL) {
   void *RetVal = nullptr;
 
   if (Kind == alloc::host) {
-    RetVal = detail::usm::alignedAllocHost(Alignment, Size, Ctxt, Kind);
+    RetVal = detail::usm::alignedAllocHost(Alignment, Size, Ctxt, Kind, CL);
   } else {
-    RetVal = detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, Kind);
+    RetVal = detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, Kind, CL);
   }
 
   return RetVal;
 }
 
 void *aligned_alloc(size_t Alignment, size_t Size, const device &Dev,
-                    const context &Ctxt, alloc Kind, const property_list &) {
-  return aligned_alloc(Alignment, Size, Dev, Ctxt, Kind);
+                    const context &Ctxt, alloc Kind, const property_list &,
+                    const detail::code_location CL) {
+  return aligned_alloc(Alignment, Size, Dev, Ctxt, Kind, CL);
 }
 
-void *aligned_alloc(size_t Alignment, size_t Size, const queue &Q, alloc Kind) {
-  return aligned_alloc(Alignment, Size, Q.get_device(), Q.get_context(), Kind);
+void *aligned_alloc(size_t Alignment, size_t Size, const queue &Q, alloc Kind,
+                    const detail::code_location CL) {
+  return aligned_alloc(Alignment, Size, Q.get_device(), Q.get_context(), Kind,
+                       CL);
 }
 
 void *aligned_alloc(size_t Alignment, size_t Size, const queue &Q, alloc Kind,
-                    const property_list &PropList) {
+                    const property_list &PropList,
+                    const detail::code_location CL) {
   return aligned_alloc(Alignment, Size, Q.get_device(), Q.get_context(), Kind,
-                       PropList);
+                       PropList, CL);
 }
 
 // Pointer queries
@@ -416,5 +489,227 @@ device get_pointer_device(const void *Ptr, const context &Ctxt) {
                       PI_INVALID_OPERATION);
 }
 
+// For ABI compatibility
+
+__SYCL_EXPORT void *malloc_device(size_t Size, const device &Dev,
+                                  const context &Ctxt) {
+  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::device,
+                                   detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_device(size_t Size, const device &Dev,
+                                  const context &Ctxt, const property_list &) {
+  return malloc_device(Size, Dev, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_device(size_t Size, const queue &Q) {
+  return malloc_device(Size, Q.get_device(), Q.get_context(),
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_device(size_t Size, const queue &Q,
+                                  const property_list &PropList) {
+  return malloc_device(Size, Q.get_device(), Q.get_context(), PropList,
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_device(size_t Alignment, size_t Size,
+                                         const device &Dev,
+                                         const context &Ctxt) {
+  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::device,
+                                   detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_device(size_t Alignment, size_t Size,
+                                         const device &Dev, const context &Ctxt,
+                                         const property_list &) {
+  return aligned_alloc_device(Alignment, Size, Dev, Ctxt,
+                              detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_device(size_t Alignment, size_t Size,
+                                         const queue &Q) {
+  return aligned_alloc_device(Alignment, Size, Q.get_device(), Q.get_context(),
+                              detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_device(size_t Alignment, size_t Size,
+                                         const queue &Q,
+                                         const property_list &PropList) {
+  return aligned_alloc_device(Alignment, Size, Q.get_device(), Q.get_context(),
+                              PropList, detail::code_location{});
+}
+
+__SYCL_EXPORT void free(void *ptr, const context &Ctxt) {
+  return detail::usm::free(ptr, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void free(void *ptr, const queue &Q) {
+  return free(ptr, Q.get_context(), detail::code_location{});
+}
+
+///
+// Restricted USM
+///
+__SYCL_EXPORT void *malloc_host(size_t Size, const context &Ctxt) {
+  return detail::usm::alignedAllocHost(0, Size, Ctxt, alloc::host,
+                                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_host(size_t Size, const context &Ctxt,
+                                const property_list &) {
+  return malloc_host(Size, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_host(size_t Size, const queue &Q) {
+  return malloc_host(Size, Q.get_context(), detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_host(size_t Size, const queue &Q,
+                                const property_list &PropList) {
+  return malloc_host(Size, Q.get_context(), PropList, detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_shared(size_t Size, const device &Dev,
+                                  const context &Ctxt) {
+  return detail::usm::alignedAlloc(0, Size, Ctxt, Dev, alloc::shared,
+                                   detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_shared(size_t Size, const device &Dev,
+                                  const context &Ctxt, const property_list &) {
+  return malloc_shared(Size, Dev, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_shared(size_t Size, const queue &Q) {
+  return malloc_shared(Size, Q.get_device(), Q.get_context(),
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc_shared(size_t Size, const queue &Q,
+                                  const property_list &PropList) {
+  return malloc_shared(Size, Q.get_device(), Q.get_context(), PropList,
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_host(size_t Alignment, size_t Size,
+                                       const context &Ctxt) {
+  return detail::usm::alignedAllocHost(Alignment, Size, Ctxt, alloc::host,
+                                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_host(size_t Alignment, size_t Size,
+                                       const context &Ctxt,
+                                       const property_list &) {
+  return aligned_alloc_host(Alignment, Size, Ctxt, detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_host(size_t Alignment, size_t Size,
+                                       const queue &Q) {
+  return aligned_alloc_host(Alignment, Size, Q.get_context(),
+                            detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_host(size_t Alignment, size_t Size,
+                                       const queue &Q,
+                                       const property_list &PropList) {
+  return aligned_alloc_host(Alignment, Size, Q.get_context(), PropList,
+                            detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_shared(size_t Alignment, size_t Size,
+                                         const device &Dev,
+                                         const context &Ctxt) {
+  return detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, alloc::shared,
+                                   detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_shared(size_t Alignment, size_t Size,
+                                         const device &Dev, const context &Ctxt,
+                                         const property_list &) {
+  return aligned_alloc_shared(Alignment, Size, Dev, Ctxt,
+                              detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_shared(size_t Alignment, size_t Size,
+                                         const queue &Q) {
+  return aligned_alloc_shared(Alignment, Size, Q.get_device(), Q.get_context(),
+                              detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc_shared(size_t Alignment, size_t Size,
+                                         const queue &Q,
+                                         const property_list &PropList) {
+  return aligned_alloc_shared(Alignment, Size, Q.get_device(), Q.get_context(),
+                              PropList, detail::code_location{});
+}
+
+// single form
+
+__SYCL_EXPORT void *malloc(size_t Size, const device &Dev, const context &Ctxt,
+                           alloc Kind) {
+  void *RetVal = nullptr;
+
+  if (Kind == alloc::host) {
+    RetVal = detail::usm::alignedAllocHost(0, Size, Ctxt, Kind,
+                                           detail::code_location{});
+  } else {
+    RetVal = detail::usm::alignedAlloc(0, Size, Ctxt, Dev, Kind,
+                                       detail::code_location{});
+  }
+
+  return RetVal;
+}
+
+__SYCL_EXPORT void *malloc(size_t Size, const device &Dev, const context &Ctxt,
+                           alloc Kind, const property_list &) {
+  return malloc(Size, Dev, Ctxt, Kind, detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc(size_t Size, const queue &Q, alloc Kind) {
+  return malloc(Size, Q.get_device(), Q.get_context(), Kind,
+                detail::code_location{});
+}
+
+__SYCL_EXPORT void *malloc(size_t Size, const queue &Q, alloc Kind,
+                           const property_list &PropList) {
+  return malloc(Size, Q.get_device(), Q.get_context(), Kind, PropList,
+                detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc(size_t Alignment, size_t Size,
+                                  const device &Dev, const context &Ctxt,
+                                  alloc Kind) {
+  void *RetVal = nullptr;
+
+  if (Kind == alloc::host) {
+    RetVal = detail::usm::alignedAllocHost(Alignment, Size, Ctxt, Kind,
+                                           detail::code_location{});
+  } else {
+    RetVal = detail::usm::alignedAlloc(Alignment, Size, Ctxt, Dev, Kind,
+                                       detail::code_location{});
+  }
+
+  return RetVal;
+}
+
+__SYCL_EXPORT void *aligned_alloc(size_t Alignment, size_t Size,
+                                  const device &Dev, const context &Ctxt,
+                                  alloc Kind, const property_list &) {
+  return aligned_alloc(Alignment, Size, Dev, Ctxt, Kind,
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc(size_t Alignment, size_t Size, const queue &Q,
+                                  alloc Kind) {
+  return aligned_alloc(Alignment, Size, Q.get_device(), Q.get_context(), Kind,
+                       detail::code_location{});
+}
+
+__SYCL_EXPORT void *aligned_alloc(size_t Alignment, size_t Size, const queue &Q,
+                                  alloc Kind, const property_list &PropList) {
+  return aligned_alloc(Alignment, Size, Q.get_device(), Q.get_context(), Kind,
+                       PropList, detail::code_location{});
+}
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)
diff --git a/sycl/test/abi/sycl_symbols_linux.dump b/sycl/test/abi/sycl_symbols_linux.dump
index 5a09898241d83..15a7e9e55e3e4 100644
--- a/sycl/test/abi/sycl_symbols_linux.dump
+++ b/sycl/test/abi/sycl_symbols_linux.dump
@@ -3620,21 +3620,37 @@ _ZN2cl4sycl10level_zero12make_contextERKSt6vectorINS0_6deviceESaIS3_EEmb
 _ZN2cl4sycl10level_zero12make_programERKNS0_7contextEm
 _ZN2cl4sycl10level_zero13make_platformEm
 _ZN2cl4sycl11malloc_hostEmRKNS0_5queueE
+_ZN2cl4sycl11malloc_hostEmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl11malloc_hostEmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl11malloc_hostEmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl11malloc_hostEmRKNS0_7contextE
+_ZN2cl4sycl11malloc_hostEmRKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl11malloc_hostEmRKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl11malloc_hostEmRKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13aligned_allocEmmRKNS0_5queueENS0_3usm5allocE
+_ZN2cl4sycl13aligned_allocEmmRKNS0_5queueENS0_3usm5allocENS0_6detail13code_locationE
 _ZN2cl4sycl13aligned_allocEmmRKNS0_5queueENS0_3usm5allocERKNS0_13property_listE
+_ZN2cl4sycl13aligned_allocEmmRKNS0_5queueENS0_3usm5allocERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13aligned_allocEmmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocE
+_ZN2cl4sycl13aligned_allocEmmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocENS0_6detail13code_locationE
 _ZN2cl4sycl13aligned_allocEmmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocERKNS0_13property_listE
+_ZN2cl4sycl13aligned_allocEmmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_deviceEmRKNS0_5queueE
+_ZN2cl4sycl13malloc_deviceEmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_deviceEmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl13malloc_deviceEmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_deviceEmRKNS0_6deviceERKNS0_7contextE
+_ZN2cl4sycl13malloc_deviceEmRKNS0_6deviceERKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_deviceEmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl13malloc_deviceEmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_sharedEmRKNS0_5queueE
+_ZN2cl4sycl13malloc_sharedEmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_sharedEmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl13malloc_sharedEmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_sharedEmRKNS0_6deviceERKNS0_7contextE
+_ZN2cl4sycl13malloc_sharedEmRKNS0_6deviceERKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl13malloc_sharedEmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl13malloc_sharedEmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl13sycl_categoryEv
 _ZN2cl4sycl14exception_list5ClearEv
 _ZN2cl4sycl14exception_list8PushBackEONSt15__exception_ptr13exception_ptrE
@@ -3643,18 +3659,30 @@ _ZN2cl4sycl14get_kernel_idsEv
 _ZN2cl4sycl15make_error_codeENS0_4errcE
 _ZN2cl4sycl16get_pointer_typeEPKvRKNS0_7contextE
 _ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_5queueE
+_ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_7contextE
+_ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl18aligned_alloc_hostEmmRKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl18get_pointer_deviceEPKvRKNS0_7contextE
 _ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_5queueE
+_ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_6deviceERKNS0_7contextE
+_ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_6deviceERKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl20aligned_alloc_deviceEmmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_5queueE
+_ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_5queueERKNS0_13property_listE
+_ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_5queueERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_6deviceERKNS0_7contextE
+_ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_6deviceERKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listE
+_ZN2cl4sycl20aligned_alloc_sharedEmmRKNS0_6deviceERKNS0_7contextERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl3ext5intel12experimental15online_compilerILNS3_15source_languageE0EE7compileIJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISE_EEEEES8_IhSaIhEERKSE_DpRKT_
 _ZN2cl4sycl3ext5intel12experimental15online_compilerILNS3_15source_languageE1EE7compileIJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISE_EEEEES8_IhSaIhEERKSE_DpRKT_
 _ZN2cl4sycl3ext5intel15online_compilerILNS2_15source_languageE0EE7compileIJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISD_EEEEES7_IhSaIhEERKSD_DpRKT_
@@ -3673,7 +3701,9 @@ _ZN2cl4sycl3ext6oneapi6detail16reduGetMaxWGSizeESt10shared_ptrINS0_6detail10queu
 _ZN2cl4sycl3ext6oneapi6detail17reduComputeWGSizeEmmRm
 _ZN2cl4sycl3ext6oneapi6detail33reduGetMaxNumConcurrentWorkGroupsESt10shared_ptrINS0_6detail10queue_implEE
 _ZN2cl4sycl4freeEPvRKNS0_5queueE
+_ZN2cl4sycl4freeEPvRKNS0_5queueENS0_6detail13code_locationE
 _ZN2cl4sycl4freeEPvRKNS0_7contextE
+_ZN2cl4sycl4freeEPvRKNS0_7contextENS0_6detail13code_locationE
 _ZN2cl4sycl5INTEL15online_compilerILNS1_15source_languageE0EE7compileIJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISC_EEEEES6_IhSaIhEERKSC_DpRKT_
 _ZN2cl4sycl5INTEL15online_compilerILNS1_15source_languageE1EE7compileIJSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISC_EEEEES6_IhSaIhEERKSC_DpRKT_
 _ZN2cl4sycl5event13get_wait_listEv
@@ -3897,6 +3927,9 @@ _ZN2cl4sycl6detail2pi9getPluginILNS0_7backendE1EEERKNS1_6pluginEv
 _ZN2cl4sycl6detail2pi9getPluginILNS0_7backendE2EEERKNS1_6pluginEv
 _ZN2cl4sycl6detail2pi9getPluginILNS0_7backendE5EEERKNS1_6pluginEv
 _ZN2cl4sycl6detail36get_empty_interop_kernel_bundle_implERKNS0_7contextERKSt6vectorINS0_6deviceESaIS6_EE
+_ZN2cl4sycl6detail3usm12alignedAllocEmmRKNS0_7contextERKNS0_6deviceENS0_3usm5allocE
+_ZN2cl4sycl6detail3usm16alignedAllocHostEmmRKNS0_7contextENS0_3usm5allocE
+_ZN2cl4sycl6detail3usm4freeEPvRKNS0_7contextE
 _ZN2cl4sycl6detail6OSUtil10getDirNameB5cxx11EPKc
 _ZN2cl4sycl6detail6OSUtil11alignedFreeEPv
 _ZN2cl4sycl6detail6OSUtil12alignedAllocEmm
@@ -3919,9 +3952,13 @@ _ZN2cl4sycl6kernelC1ESt10shared_ptrINS0_6detail11kernel_implEE
 _ZN2cl4sycl6kernelC2EP10_cl_kernelRKNS0_7contextE
 _ZN2cl4sycl6kernelC2ESt10shared_ptrINS0_6detail11kernel_implEE
 _ZN2cl4sycl6mallocEmRKNS0_5queueENS0_3usm5allocE
+_ZN2cl4sycl6mallocEmRKNS0_5queueENS0_3usm5allocENS0_6detail13code_locationE
 _ZN2cl4sycl6mallocEmRKNS0_5queueENS0_3usm5allocERKNS0_13property_listE
+_ZN2cl4sycl6mallocEmRKNS0_5queueENS0_3usm5allocERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl6mallocEmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocE
+_ZN2cl4sycl6mallocEmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocENS0_6detail13code_locationE
 _ZN2cl4sycl6mallocEmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocERKNS0_13property_listE
+_ZN2cl4sycl6mallocEmRKNS0_6deviceERKNS0_7contextENS0_3usm5allocERKNS0_13property_listENS0_6detail13code_locationE
 _ZN2cl4sycl6opencl10make_queueERKNS0_7contextEm
 _ZN2cl4sycl6opencl11make_deviceEm
 _ZN2cl4sycl6opencl12make_contextEm
diff --git a/sycl/test/abi/sycl_symbols_windows.dump b/sycl/test/abi/sycl_symbols_windows.dump
index b1a8849344d2e..786b52a911e0e 100644
--- a/sycl/test/abi/sycl_symbols_windows.dump
+++ b/sycl/test/abi/sycl_symbols_windows.dump
@@ -207,6 +207,7 @@
 ??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@context@sycl@cl@@QEBA?AVuse_primary_context@0property@cuda@oneapi@ext@12@XZ
 ??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@program@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
 ??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@sampler@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
+??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@stream@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
 ??$get_property@Vuse_primary_context@cuda@context@property@sycl@cl@@@context@sycl@cl@@QEBA?AVuse_primary_context@cuda@0property@12@XZ
 ??$get_property@Vuse_primary_context@cuda@context@property@sycl@cl@@@program@sycl@cl@@QEBA?AVuse_primary_context@cuda@context@property@12@XZ
 ??$get_property@Vuse_primary_context@cuda@context@property@sycl@cl@@@sampler@sycl@cl@@QEBA?AVuse_primary_context@cuda@context@property@12@XZ
@@ -265,13 +266,9 @@
 ??$has_property@Vuse_pinned_host_memory@buffer@property@oneapi@ext@sycl@cl@@@program@sycl@cl@@QEBA_NXZ
 ??$has_property@Vuse_pinned_host_memory@buffer@property@oneapi@ext@sycl@cl@@@sampler@sycl@cl@@QEBA_NXZ
 ??$has_property@Vuse_pinned_host_memory@buffer@property@oneapi@ext@sycl@cl@@@stream@sycl@cl@@QEBA_NXZ
-??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@context@sycl@cl@@QEBA?AVuse_primary_context@0property@cuda@oneapi@ext@12@XZ
 ??$has_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@context@sycl@cl@@QEBA_NXZ
-??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@program@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
 ??$has_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@program@sycl@cl@@QEBA_NXZ
-??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@sampler@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
 ??$has_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@sampler@sycl@cl@@QEBA_NXZ
-??$get_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@stream@sycl@cl@@QEBA?AVuse_primary_context@context@property@cuda@oneapi@ext@12@XZ
 ??$has_property@Vuse_primary_context@context@property@cuda@oneapi@ext@sycl@cl@@@stream@sycl@cl@@QEBA_NXZ
 ??$has_property@Vuse_primary_context@cuda@context@property@sycl@cl@@@context@sycl@cl@@QEBA_NXZ
 ??$has_property@Vuse_primary_context@cuda@context@property@sycl@cl@@@program@sycl@cl@@QEBA_NXZ
@@ -1096,23 +1093,41 @@
 ?advise_usm@MemoryManager@detail@sycl@cl@@SAXPEBXV?$shared_ptr@Vqueue_impl@detail@sycl@cl@@@std@@_KW4_pi_mem_advice@@V?$vector@PEAU_pi_event@@V?$allocator@PEAU_pi_event@@@std@@@6@AEAPEAU_pi_event@@@Z
 ?advise_usm@MemoryManager@detail@sycl@cl@@SAXPEBXV?$shared_ptr@Vqueue_impl@detail@sycl@cl@@@std@@_KW4_pi_mem_advice@@V?$vector@PEAU_pi_event@@V?$allocator@PEAU_pi_event@@@std@@@6@PEAPEAU_pi_event@@@Z
 ?alignedAlloc@OSUtil@detail@sycl@cl@@SAPEAX_K0@Z
+?alignedAlloc@usm@detail@sycl@cl@@YAPEAX_K0AEBVcontext@34@AEBVdevice@34@W4alloc@134@@Z
+?alignedAllocHost@usm@detail@sycl@cl@@YAPEAX_K0AEBVcontext@34@W4alloc@134@@Z
 ?alignedFree@OSUtil@detail@sycl@cl@@SAXPEAX@Z
 ?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@@Z
 ?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@AEBVproperty_list@12@@Z
+?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@Ucode_location@detail@12@@Z
 ?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVqueue@12@W4alloc@usm@12@@Z
 ?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVqueue@12@W4alloc@usm@12@AEBVproperty_list@12@@Z
+?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVqueue@12@W4alloc@usm@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc@sycl@cl@@YAPEAX_K0AEBVqueue@12@W4alloc@usm@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@@Z
 ?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@@Z
+?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVqueue@12@@Z
 ?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@@Z
+?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_device@sycl@cl@@YAPEAX_K0AEBVqueue@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVcontext@12@@Z
 ?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVcontext@12@AEBVproperty_list@12@@Z
+?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVcontext@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVqueue@12@@Z
 ?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@@Z
+?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_host@sycl@cl@@YAPEAX_K0AEBVqueue@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@@Z
 ?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@@Z
+?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVdevice@12@AEBVcontext@12@Ucode_location@detail@12@@Z
 ?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVqueue@12@@Z
 ?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@@Z
+?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?aligned_alloc_shared@sycl@cl@@YAPEAX_K0AEBVqueue@12@Ucode_location@detail@12@@Z
 ?allocate@MemoryManager@detail@sycl@cl@@SAPEAXV?$shared_ptr@Vcontext_impl@detail@sycl@cl@@@std@@PEAVSYCLMemObjI@234@_NPEAXV?$vector@V?$shared_ptr@Vevent_impl@detail@sycl@cl@@@std@@V?$allocator@V?$shared_ptr@Vevent_impl@detail@sycl@cl@@@std@@@2@@6@AEAPEAU_pi_event@@@Z
 ?allocateBufferObject@MemoryManager@detail@sycl@cl@@SAPEAXV?$shared_ptr@Vcontext_impl@detail@sycl@cl@@@std@@PEAX_N_KAEBVproperty_list@34@@Z
 ?allocateHostMem@SYCLMemObjT@detail@sycl@cl@@UEAAPEAXXZ
@@ -2083,7 +2098,10 @@
 ?fract@__host_std@cl@@YAMMPEAM@Z
 ?fract@__host_std@cl@@YANNPEAN@Z
 ?free@sycl@cl@@YAXPEAXAEBVcontext@12@@Z
+?free@sycl@cl@@YAXPEAXAEBVcontext@12@Ucode_location@detail@12@@Z
 ?free@sycl@cl@@YAXPEAXAEBVqueue@12@@Z
+?free@sycl@cl@@YAXPEAXAEBVqueue@12@Ucode_location@detail@12@@Z
+?free@usm@detail@sycl@cl@@YAXPEAXAEBVcontext@34@@Z
 ?frexp@__host_std@cl@@YA?AV?$vec@M$00@sycl@2@V342@PEAV?$vec@H$00@42@@Z
 ?frexp@__host_std@cl@@YA?AV?$vec@M$01@sycl@2@V342@PEAV?$vec@H$01@42@@Z
 ?frexp@__host_std@cl@@YA?AV?$vec@M$02@sycl@2@V342@PEAV?$vec@H$02@42@@Z
@@ -2678,20 +2696,36 @@
 ?make_queue@opencl@sycl@cl@@YA?AVqueue@23@AEBVcontext@23@_K@Z
 ?malloc@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@@Z
 ?malloc@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@AEBVproperty_list@12@@Z
+?malloc@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@W4alloc@usm@12@Ucode_location@detail@12@@Z
 ?malloc@sycl@cl@@YAPEAX_KAEBVqueue@12@W4alloc@usm@12@@Z
 ?malloc@sycl@cl@@YAPEAX_KAEBVqueue@12@W4alloc@usm@12@AEBVproperty_list@12@@Z
+?malloc@sycl@cl@@YAPEAX_KAEBVqueue@12@W4alloc@usm@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc@sycl@cl@@YAPEAX_KAEBVqueue@12@W4alloc@usm@12@Ucode_location@detail@12@@Z
 ?malloc_device@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@@Z
 ?malloc_device@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@@Z
+?malloc_device@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_device@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@Ucode_location@detail@12@@Z
 ?malloc_device@sycl@cl@@YAPEAX_KAEBVqueue@12@@Z
 ?malloc_device@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@@Z
+?malloc_device@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_device@sycl@cl@@YAPEAX_KAEBVqueue@12@Ucode_location@detail@12@@Z
 ?malloc_host@sycl@cl@@YAPEAX_KAEBVcontext@12@@Z
 ?malloc_host@sycl@cl@@YAPEAX_KAEBVcontext@12@AEBVproperty_list@12@@Z
+?malloc_host@sycl@cl@@YAPEAX_KAEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_host@sycl@cl@@YAPEAX_KAEBVcontext@12@Ucode_location@detail@12@@Z
 ?malloc_host@sycl@cl@@YAPEAX_KAEBVqueue@12@@Z
 ?malloc_host@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@@Z
+?malloc_host@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_host@sycl@cl@@YAPEAX_KAEBVqueue@12@Ucode_location@detail@12@@Z
 ?malloc_shared@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@@Z
 ?malloc_shared@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@@Z
+?malloc_shared@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_shared@sycl@cl@@YAPEAX_KAEBVdevice@12@AEBVcontext@12@Ucode_location@detail@12@@Z
 ?malloc_shared@sycl@cl@@YAPEAX_KAEBVqueue@12@@Z
 ?malloc_shared@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@@Z
+?malloc_shared@sycl@cl@@YAPEAX_KAEBVqueue@12@AEBVproperty_list@12@Ucode_location@detail@12@@Z
+?malloc_shared@sycl@cl@@YAPEAX_KAEBVqueue@12@Ucode_location@detail@12@@Z
 ?map@MemoryManager@detail@sycl@cl@@SAPEAXPEAVSYCLMemObjI@234@PEAXV?$shared_ptr@Vqueue_impl@detail@sycl@cl@@@std@@W4mode@access@34@IV?$range@$02@34@4V?$id@$02@34@IV?$vector@PEAU_pi_event@@V?$allocator@PEAU_pi_event@@@std@@@7@AEAPEAU_pi_event@@@Z
 ?maxmag@__host_std@cl@@YA?AV?$vec@M$00@sycl@2@V342@0@Z
 ?maxmag@__host_std@cl@@YA?AV?$vec@M$01@sycl@2@V342@0@Z
diff --git a/xpti/include/xpti/xpti_trace_framework.h b/xpti/include/xpti/xpti_trace_framework.h
index d45c47fc47f14..12454cd4f2c6e 100644
--- a/xpti/include/xpti/xpti_trace_framework.h
+++ b/xpti/include/xpti/xpti_trace_framework.h
@@ -75,6 +75,21 @@ XPTI_EXPORT_API xpti::result_t xptiInitialize(const char *stream, uint32_t maj,
 /// @return None
 XPTI_EXPORT_API void xptiFinalize(const char *stream);
 
+/// @brief Returns universal ID
+/// @details Universal ID is a 64 bit value, that can be used to correlate
+/// events from different software layers. It is generated once for top SW layer
+/// and then re-used by subsequent layers to identify original source code
+/// location. This value is stored in thread-local storage.
+XPTI_EXPORT_API uint64_t xptiGetUniversalId();
+
+/// @brief Update universal ID value
+/// @detail Save new universal ID value to thread-local storage. This function
+/// is typically called by xpti::framework::tracepoint_t constructor when
+/// updating tracepoint information. See xptiGetUniversalId() for more info
+/// about universal IDs.
+/// @param uid Unique 64 bit identifier.
+XPTI_EXPORT_API void xptiSetUniversalId(uint64_t uid);
+
 /// @brief Generates a unique ID
 /// @details When a tool is subscribing to the event stream and wants to
 /// generate task IDs that do not collide with unique IDs currently being
@@ -433,6 +448,8 @@ typedef xpti::result_t (*xpti_framework_finalize_t)();
 typedef xpti::result_t (*xpti_initialize_t)(const char *, uint32_t, uint32_t,
                                             const char *);
 typedef void (*xpti_finalize_t)(const char *);
+typedef uint64_t (*xpti_get_universal_id_t)();
+typedef void (*xpti_set_universal_id_t)(uint64_t uid);
 typedef uint64_t (*xpti_get_unique_id_t)();
 typedef xpti::string_id_t (*xpti_register_string_t)(const char *, char **);
 typedef const char *(*xpti_lookup_string_t)(xpti::string_id_t);
diff --git a/xpti/include/xpti/xpti_trace_framework.hpp b/xpti/include/xpti/xpti_trace_framework.hpp
index fcd4c80c4668f..75f4b09af8a1a 100644
--- a/xpti/include/xpti/xpti_trace_framework.hpp
+++ b/xpti/include/xpti/xpti_trace_framework.hpp
@@ -15,6 +15,7 @@
 
 #include "xpti/xpti_data_types.h"
 #include "xpti/xpti_trace_framework.h"
+#include "xpti_trace_framework.h"
 
 #if defined(_WIN32) || defined(_WIN64)
 #include <string>
@@ -306,7 +307,6 @@ struct finally {
 } // namespace utils
 
 namespace framework {
-static thread_local uint64_t g_tls_uid = xpti::invalid_uid;
 constexpr uint16_t signal = (uint16_t)xpti::trace_point_type_t::signal;
 constexpr uint16_t graph_create =
     (uint16_t)xpti::trace_point_type_t::graph_create;
@@ -427,7 +427,7 @@ class tracepoint_t {
     if (p) {
       // We expect the payload input has been populated with the information
       // available at that time
-      uint64_t uid = g_tls_uid;
+      uint64_t uid = xptiGetUniversalId();
       if (uid != xpti::invalid_uid) {
         // We already have a parent SW layer that has a tracepoint defined
         m_payload = xptiQueryPayloadByUID(uid);
@@ -435,7 +435,7 @@ class tracepoint_t {
         m_top = true;
         uid = xptiRegisterPayload(p);
         if (uid != xpti::invalid_uid) {
-          g_tls_uid = uid;
+          xptiSetUniversalId(uid);
           m_payload = xptiQueryPayloadByUID(uid);
         }
       }
@@ -443,7 +443,7 @@ class tracepoint_t {
   }
   ~tracepoint_t() {
     if (m_top) {
-      g_tls_uid = xpti::invalid_uid;
+      xptiSetUniversalId(xpti::invalid_uid);
     }
   }
 
diff --git a/xpti/src/xpti_proxy.cpp b/xpti/src/xpti_proxy.cpp
index 6fe78c274e2a4..ad07862368539 100644
--- a/xpti/src/xpti_proxy.cpp
+++ b/xpti/src/xpti_proxy.cpp
@@ -18,6 +18,8 @@ enum functions_t {
   XPTI_FRAMEWORK_FINALIZE,
   XPTI_INITIALIZE,
   XPTI_FINALIZE,
+  XPTI_GET_UNIVERSAL_ID,
+  XPTI_SET_UNIVERSAL_ID,
   XPTI_GET_UNIQUE_ID,
   XPTI_REGISTER_STRING,
   XPTI_LOOKUP_STRING,
@@ -49,6 +51,8 @@ class ProxyLoader {
       {XPTI_FRAMEWORK_FINALIZE, "xptiFrameworkFinalize"},
       {XPTI_INITIALIZE, "xptiInitialize"},
       {XPTI_FINALIZE, "xptiFinalize"},
+      {XPTI_GET_UNIVERSAL_ID, "xptiGetUniversalId"},
+      {XPTI_SET_UNIVERSAL_ID, "xptiSetUniversalId"},
       {XPTI_GET_UNIQUE_ID, "xptiGetUniqueId"},
       {XPTI_REGISTER_STRING, "xptiRegisterString"},
       {XPTI_LOOKUP_STRING, "xptiLookupString"},
@@ -208,6 +212,27 @@ XPTI_EXPORT_API void xptiFinalize(const char *stream) {
   }
 }
 
+XPTI_EXPORT_API uint64_t xptiGetUniversalId() {
+  if (xpti::ProxyLoader::instance().noErrors()) {
+    auto f =
+        xpti::ProxyLoader::instance().functionByIndex(XPTI_GET_UNIVERSAL_ID);
+    if (f) {
+      return (*reinterpret_cast<xpti_get_universal_id_t>(f))();
+    }
+  }
+  return xpti::invalid_id;
+}
+
+XPTI_EXPORT_API void xptiSetUniversalId(uint64_t uid) {
+  if (xpti::ProxyLoader::instance().noErrors()) {
+    auto f =
+        xpti::ProxyLoader::instance().functionByIndex(XPTI_SET_UNIVERSAL_ID);
+    if (f) {
+      return (*reinterpret_cast<xpti_set_universal_id_t>(f))(uid);
+    }
+  }
+}
+
 XPTI_EXPORT_API uint64_t xptiGetUniqueId() {
   if (xpti::ProxyLoader::instance().noErrors()) {
     auto f = xpti::ProxyLoader::instance().functionByIndex(XPTI_GET_UNIQUE_ID);
diff --git a/xptifw/src/xpti_trace_framework.cpp b/xptifw/src/xpti_trace_framework.cpp
index 7b97a4125fcdf..081dc073f55f1 100644
--- a/xptifw/src/xpti_trace_framework.cpp
+++ b/xptifw/src/xpti_trace_framework.cpp
@@ -45,6 +45,8 @@ static_assert(
     std::is_trivially_destructible<xpti::utils::PlatformHelper>::value,
     "PlatformHelper is not trivial");
 
+static thread_local uint64_t g_tls_uid = xpti::invalid_uid;
+
 namespace xpti {
 constexpr const char *env_subscribers = "XPTI_SUBSCRIBERS";
 xpti::utils::PlatformHelper g_helper;
@@ -829,6 +831,10 @@ class Framework {
 
   inline uint64_t makeUniqueID() { return MTracepoints.makeUniqueID(); }
 
+  uint64_t getUniversalID() const noexcept { return g_tls_uid; }
+
+  void setUniversalID(uint64_t uid) noexcept { g_tls_uid = uid; }
+
   xpti::result_t addMetadata(xpti::trace_event_data_t *Event, const char *Key,
                              const char *Value) {
     return MTracepoints.addMetadata(Event, Key, Value);
@@ -1063,6 +1069,14 @@ XPTI_EXPORT_API void xptiFrameworkFinalize() {
   }
 }
 
+XPTI_EXPORT_API uint64_t xptiGetUniversalId() {
+  return xpti::Framework::instance().getUniversalID();
+}
+
+XPTI_EXPORT_API void xptiSetUniversalId(uint64_t uid) {
+  xpti::Framework::instance().setUniversalID(uid);
+}
+
 XPTI_EXPORT_API uint16_t
 xptiRegisterUserDefinedTracePoint(const char *ToolName, uint8_t UserDefinedTP) {
   uint8_t ToolID = xpti::Framework::instance().registerVendor(ToolName);