From 90e935c5a069ca869d4ddd001633e29a220b977c Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Mon, 14 Jul 2025 12:57:01 -0400
Subject: [PATCH 01/33] Add rocpd support for  - cpu_frequency  - amd_smi  -
 sampling

---
 .gitmodules                                   |   3 +
 CMakeLists.txt                                |   3 +
 cmake/Packages.cmake                          |  11 +
 cmake/SQLite3.cmake                           |  48 ++
 source/bin/rocprof-sys-avail/avail.cpp        |   3 +-
 source/lib/CMakeLists.txt                     |   1 +
 source/lib/common/CMakeLists.txt              |   2 +
 source/lib/common/md5sum.hpp                  | 469 ++++++++++++
 source/lib/common/traits.hpp                  |  91 +++
 source/lib/core/CMakeLists.txt                |  22 +
 source/lib/core/agent.hpp                     |  49 ++
 source/lib/core/agent_manager.cpp             | 145 ++++
 source/lib/core/agent_manager.hpp             |  67 ++
 source/lib/core/benchmark/benchmark.hpp       | 325 ++++++++
 source/lib/core/benchmark/category.hpp        |  68 ++
 source/lib/core/config.cpp                    |  44 ++
 source/lib/core/config.hpp                    |   6 +
 source/lib/core/gpu.cpp                       |  45 +-
 source/lib/core/node_info.cpp                 |  72 ++
 source/lib/core/node_info.hpp                 |  58 ++
 source/lib/core/rocpd/CMakeLists.txt          |  20 +
 source/lib/core/rocpd/data_processor.cpp      | 671 ++++++++++++++++
 source/lib/core/rocpd/data_processor.hpp      | 252 ++++++
 .../lib/core/rocpd/data_storage/database.cpp  | 170 +++++
 .../lib/core/rocpd/data_storage/database.hpp  | 186 +++++
 .../query_builders/insert_query_builders.hpp  | 126 +++
 .../queries/table_insert_query.hpp            |  57 ++
 .../rocpd/data_storage/schema/data_views.sql  | 722 ++++++++++++++++++
 .../data_storage/schema/marker_views.sql      |   3 +
 .../data_storage/schema/rocpd_indexes.sql     |  45 ++
 .../data_storage/schema/rocpd_tables.sql      | 373 +++++++++
 .../rocpd/data_storage/schema/rocpd_views.sql | 139 ++++
 .../data_storage/schema/summary_views.sql     | 376 +++++++++
 source/lib/core/rocpd/json.cpp                |  99 +++
 source/lib/core/rocpd/json.hpp                |  57 ++
 source/lib/rocprof-sys/library.cpp            |  87 ++-
 source/lib/rocprof-sys/library/amd_smi.cpp    | 397 ++++++----
 .../library/components/backtrace_metrics.cpp  | 266 +++++++
 .../library/components/backtrace_metrics.hpp  |   3 +
 .../library/components/comm_data.cpp          | 444 ++++++++---
 .../library/components/comm_data.hpp          |   2 +-
 source/lib/rocprof-sys/library/cpu_freq.cpp   | 324 ++++++--
 source/lib/rocprof-sys/library/kokkosp.cpp    |  72 ++
 source/lib/rocprof-sys/library/sampling.cpp   | 322 ++++++++
 44 files changed, 6417 insertions(+), 328 deletions(-)
 create mode 100644 cmake/SQLite3.cmake
 create mode 100644 source/lib/common/md5sum.hpp
 create mode 100644 source/lib/common/traits.hpp
 create mode 100644 source/lib/core/agent.hpp
 create mode 100644 source/lib/core/agent_manager.cpp
 create mode 100644 source/lib/core/agent_manager.hpp
 create mode 100644 source/lib/core/benchmark/benchmark.hpp
 create mode 100644 source/lib/core/benchmark/category.hpp
 create mode 100644 source/lib/core/node_info.cpp
 create mode 100644 source/lib/core/node_info.hpp
 create mode 100644 source/lib/core/rocpd/CMakeLists.txt
 create mode 100644 source/lib/core/rocpd/data_processor.cpp
 create mode 100644 source/lib/core/rocpd/data_processor.hpp
 create mode 100644 source/lib/core/rocpd/data_storage/database.cpp
 create mode 100644 source/lib/core/rocpd/data_storage/database.hpp
 create mode 100644 source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
 create mode 100644 source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp
 create mode 100644 source/lib/core/rocpd/data_storage/schema/data_views.sql
 create mode 100644 source/lib/core/rocpd/data_storage/schema/marker_views.sql
 create mode 100644 source/lib/core/rocpd/data_storage/schema/rocpd_indexes.sql
 create mode 100644 source/lib/core/rocpd/data_storage/schema/rocpd_tables.sql
 create mode 100644 source/lib/core/rocpd/data_storage/schema/rocpd_views.sql
 create mode 100644 source/lib/core/rocpd/data_storage/schema/summary_views.sql
 create mode 100644 source/lib/core/rocpd/json.cpp
 create mode 100644 source/lib/core/rocpd/json.hpp

diff --git a/.gitmodules b/.gitmodules
index 4fbeaeebb2..3c35b6582f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -23,3 +23,6 @@
 [submodule "external/pybind11"]
 	path = external/pybind11
 	url = https://github.com/jrmadsen/pybind11.git
+[submodule "external/sqlite"]
+	path = external/sqlite
+	url = https://github.com/sqlite/sqlite.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 04bb87d551..123e04ebc1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -221,6 +221,9 @@ rocprofiler_systems_add_option(ROCPROFSYS_BUILD_CODECOV "Build for code coverage
 rocprofiler_systems_add_option(ROCPROFSYS_INSTALL_PERFETTO_TOOLS
                                "Install perfetto tools (i.e. traced, perfetto, etc.)" OFF
 )
+rocprofiler_systems_add_option(ROCPROFILER_BUILD_SQLITE3
+                               "Enable building sqlite3 library internally" OFF
+)
 
 if(ROCPROFSYS_USE_PAPI)
     rocprofiler_systems_add_option(ROCPROFSYS_BUILD_PAPI "Build PAPI from submodule" ON)
diff --git a/cmake/Packages.cmake b/cmake/Packages.cmake
index f24c2c653a..fd9b302a0b 100644
--- a/cmake/Packages.cmake
+++ b/cmake/Packages.cmake
@@ -53,6 +53,9 @@ rocprofiler_systems_add_interface_library(rocprofiler-systems-python
 rocprofiler_systems_add_interface_library(rocprofiler-systems-perfetto
                                           "Enables Perfetto support"
 )
+rocprofiler_systems_add_interface_library(rocprofiler-systems-sqlite3
+                                          "Use SQLite3 for rocpd data storage"
+)
 rocprofiler_systems_add_interface_library(rocprofiler-systems-timemory
                                           "Provides timemory libraries"
 )
@@ -532,6 +535,14 @@ rocprofiler_systems_checkout_git_submodule(
 
 include(Perfetto)
 
+# ----------------------------------------------------------------------------------------#
+#
+# SQLite3
+#
+# ----------------------------------------------------------------------------------------#
+
+include(SQLite3)
+
 # ----------------------------------------------------------------------------------------#
 #
 # ELFIO
diff --git a/cmake/SQLite3.cmake b/cmake/SQLite3.cmake
new file mode 100644
index 0000000000..44669c3280
--- /dev/null
+++ b/cmake/SQLite3.cmake
@@ -0,0 +1,48 @@
+include_guard(GLOBAL)
+
+if(ROCPROFILER_BUILD_SQLITE3)
+    message(STATUS "Building SQLite3 from source!")
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/external/sqlite
+    )
+    # checkout submodule if not already checked out or clone repo if no .gitmodules file
+    rocprofiler_systems_checkout_git_submodule(
+        RELATIVE_PATH external/sqlite
+        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+        TEST_FILE configure
+        REPO_URL https://github.com/sqlite/sqlite.git
+        REPO_BRANCH "version-3.45.3"
+    )
+
+    find_program(MAKE_COMMAND NAMES make gmake PATH_SUFFIXES bin REQUIRED)
+
+    include(ExternalProject)
+    ExternalProject_Add(
+        rocprofiler-systems-sqlite-build
+        PREFIX ${PROJECT_BINARY_DIR}/external/sqlite/build
+        SOURCE_DIR ${PROJECT_SOURCE_DIR}/external/sqlite
+        BUILD_IN_SOURCE 0
+        CONFIGURE_COMMAND
+            <SOURCE_DIR>/configure --prefix=${PROJECT_BINARY_DIR}/external/sqlite/install
+            --libdir=${PROJECT_BINARY_DIR}/external/sqlite/install/lib --disable-shared
+            --with-tempstore=yes --enable-all --disable-tcl CFLAGS=-O3\ -g1
+        BUILD_COMMAND ${MAKE_COMMAND} install -s
+        INSTALL_COMMAND ""
+    )
+
+    target_link_libraries(
+        rocprofiler-systems-sqlite3
+        INTERFACE
+            $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/external/sqlite/install/lib/libsqlite3.a>
+    )
+    target_include_directories(
+        rocprofiler-systems-sqlite3
+        SYSTEM
+        INTERFACE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/external/sqlite/install/include>
+    )
+    add_dependencies(rocprofiler-systems-sqlite3 rocprofiler-systems-sqlite-build)
+else()
+    message(STATUS "Using system SQLite3 library")
+    find_package(SQLite3 REQUIRED)
+    target_link_libraries(rocprofiler-systems-sqlite3 INTERFACE SQLite::SQLite3)
+endif()
diff --git a/source/bin/rocprof-sys-avail/avail.cpp b/source/bin/rocprof-sys-avail/avail.cpp
index 93128f8651..9313a06fe9 100644
--- a/source/bin/rocprof-sys-avail/avail.cpp
+++ b/source/bin/rocprof-sys-avail/avail.cpp
@@ -118,7 +118,7 @@ write_hw_counter_info(std::ostream&, const array_t<bool, N>& = {},
 namespace
 {
 // initialize HIP before main so that librocprof-sys is not HSA_TOOLS_LIB
-int gpu_count = rocprofsys::gpu::device_count();
+int gpu_count = 0;
 
 // statically allocated shared_ptrs to prevent use after free errors
 auto timemory_manager      = tim::manager::master_instance();
@@ -138,6 +138,7 @@ main(int argc, char** argv)
     tim::unwind::set_bfd_verbose(3);
     tim::set_env("ROCPROFSYS_INIT_TOOLING", "OFF", 1);
     rocprofsys_init_library();
+    gpu_count = rocprofsys::gpu::device_count();
 
     std::set<std::string> _category_options = component_categories{}();
     {
diff --git a/source/lib/CMakeLists.txt b/source/lib/CMakeLists.txt
index 14e81112e7..e6699c833d 100644
--- a/source/lib/CMakeLists.txt
+++ b/source/lib/CMakeLists.txt
@@ -40,6 +40,7 @@ target_link_libraries(
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-compile-options>
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-compile-definitions>
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-perfetto>
+        $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-sqlite3>
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-timemory>
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-elfutils>
         $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-bfd>
diff --git a/source/lib/common/CMakeLists.txt b/source/lib/common/CMakeLists.txt
index d096ebf933..8ea90f2aed 100644
--- a/source/lib/common/CMakeLists.txt
+++ b/source/lib/common/CMakeLists.txt
@@ -26,6 +26,8 @@ target_sources(
         ${CMAKE_CURRENT_SOURCE_DIR}/invoke.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/join.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/setup.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/traits.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/md5sum.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/static_object.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/synchronized.hpp
 )
diff --git a/source/lib/common/md5sum.hpp b/source/lib/common/md5sum.hpp
new file mode 100644
index 0000000000..d0f6f3e1ca
--- /dev/null
+++ b/source/lib/common/md5sum.hpp
@@ -0,0 +1,469 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <string_view>
+#include <type_traits>
+
+#include "traits.hpp"
+
+namespace rocprofsys
+{
+inline namespace common
+{
+
+class md5sum
+{
+public:
+    using size_type                = uint32_t;  // must be 32bit
+    using raw_digest_t             = std::array<uint8_t, 16>;
+    static constexpr int blocksize = 64;
+
+    template <typename Tp, typename... Args>
+    explicit md5sum(Tp&& arg, Args&&... args);
+
+    md5sum()              = default;
+    ~md5sum()             = default;
+    md5sum(const md5sum&) = default;
+    md5sum(md5sum&&)      = default;
+
+    md5sum& operator=(const md5sum&) = default;
+    md5sum& operator=(md5sum&&)      = default;
+
+    md5sum&      update(std::string_view inp);
+    md5sum&      update(const unsigned char* buf, size_type length);
+    md5sum&      update(const char* buf, size_type length);
+    md5sum&      finalize();
+    std::string  hexdigest() const;
+    std::string  hexliteral() const;
+    raw_digest_t rawdigest() const { return digest; }
+
+    template <typename Tp,
+              typename Up = std::enable_if_t<std::is_arithmetic<Tp>::value, int>>
+    md5sum& update(Tp inp);
+
+    friend std::ostream& operator<<(std::ostream&, md5sum md5);
+
+private:
+    void transform(const uint8_t block[blocksize]);
+
+    bool finalized = false;
+    // 64bit counter for number of bits (lo, hi)
+    std::array<uint32_t, 2>        count = { 0, 0 };
+    std::array<uint8_t, blocksize> buffer{};  // overflow bytes from last 64 byte chunk
+    // digest so far, initialized to magic initialization constants.
+    std::array<uint32_t, 4> state = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
+    std::array<uint8_t, 16> digest{};  // result
+};
+
+template <typename Tp, typename... Args>
+md5sum::md5sum(Tp&& arg, Args&&... args)
+{
+    auto _update = [&](auto&& _val) {
+        using value_type =
+            std::remove_reference_t<std::remove_cv_t<std::decay_t<decltype(_val)>>>;
+        static_assert(!std::is_pointer<value_type>::value,
+                      "constructor cannot be called with pointer argument");
+        update(std::forward<decltype(_val)>(_val));
+    };
+
+    _update(std::forward<Tp>(arg));
+    (_update(std::forward<Args>(args)), ...);
+    finalize();
+}
+
+template <typename Tp, typename Up>
+md5sum&
+md5sum::update(Tp inp)
+{
+    static_assert(std::is_arithmetic<Tp>::value, "expected arithmetic type");
+    return update(reinterpret_cast<const char*>(&inp), sizeof(Tp));
+}
+
+template <template <typename, typename...> class ContainerT, typename Tp,
+          typename... TailT>
+std::string
+compute_md5sum(const ContainerT<Tp, TailT...>& inp,
+               std::enable_if_t<traits::is_string_literal_v<Tp>, int>)
+{
+    auto _val = md5sum{};
+    for(const auto& itr : inp)
+        _val.update(std::string_view{ inp });
+    _val.finalize();
+    return _val.hexdigest();
+}
+
+namespace
+{
+
+using size_type = typename md5sum::size_type;
+
+// Constants for md5sumTransform routine.
+constexpr uint32_t S11 = 7;
+constexpr uint32_t S12 = 12;
+constexpr uint32_t S13 = 17;
+constexpr uint32_t S14 = 22;
+constexpr uint32_t S21 = 5;
+constexpr uint32_t S22 = 9;
+constexpr uint32_t S23 = 14;
+constexpr uint32_t S24 = 20;
+constexpr uint32_t S31 = 4;
+constexpr uint32_t S32 = 11;
+constexpr uint32_t S33 = 16;
+constexpr uint32_t S34 = 23;
+constexpr uint32_t S41 = 6;
+constexpr uint32_t S42 = 10;
+constexpr uint32_t S43 = 15;
+constexpr uint32_t S44 = 21;
+
+// low level logic operations
+static inline uint32_t
+F(uint32_t x, uint32_t y, uint32_t z);
+
+static inline uint32_t
+G(uint32_t x, uint32_t y, uint32_t z);
+
+static inline uint32_t
+H(uint32_t x, uint32_t y, uint32_t z);
+
+static inline uint32_t
+I(uint32_t x, uint32_t y, uint32_t z);
+
+static inline uint32_t
+rotate_left(uint32_t x, int n);
+
+static inline void
+FF(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+
+static inline void
+GG(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+
+static inline void
+HH(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+
+static inline void
+II(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+
+// F, G, H and I are basic md5sum functions.
+inline uint32_t
+F(uint32_t x, uint32_t y, uint32_t z)
+{
+    return (x & y) | (~x & z);
+}
+
+inline uint32_t
+G(uint32_t x, uint32_t y, uint32_t z)
+{
+    return (x & z) | (y & ~z);
+}
+
+inline uint32_t
+H(uint32_t x, uint32_t y, uint32_t z)
+{
+    return x ^ y ^ z;
+}
+
+inline uint32_t
+I(uint32_t x, uint32_t y, uint32_t z)
+{
+    return y ^ (x | ~z);
+}
+
+// rotate_left rotates x left n bits.
+inline uint32_t
+rotate_left(uint32_t x, int n)
+{
+    return (x << n) | (x >> (32 - n));
+}
+
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+inline void
+FF(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
+{
+    a = rotate_left(a + F(b, c, d) + x + ac, s) + b;
+}
+
+inline void
+GG(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
+{
+    a = rotate_left(a + G(b, c, d) + x + ac, s) + b;
+}
+
+inline void
+HH(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
+{
+    a = rotate_left(a + H(b, c, d) + x + ac, s) + b;
+}
+
+inline void
+II(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
+{
+    a = rotate_left(a + I(b, c, d) + x + ac, s) + b;
+}
+
+// decodes input (unsigned char) into output (uint32_t). Assumes len is a multiple of 4.
+void
+decode(uint32_t output[], const uint8_t input[], size_type len)
+{
+    for(unsigned int i = 0, j = 0; j < len; i++, j += 4)
+        output[i] = ((uint32_t) input[j]) | (((uint32_t) input[j + 1]) << 8) |
+                    (((uint32_t) input[j + 2]) << 16) | (((uint32_t) input[j + 3]) << 24);
+}
+
+// encodes input (uint32_t) into output (unsigned char). Assumes len is
+// a multiple of 4.
+void
+encode(uint8_t output[], const uint32_t input[], size_type len)
+{
+    for(size_type i = 0, j = 0; j < len; i++, j += 4)
+    {
+        output[j]     = input[i] & 0xff;
+        output[j + 1] = (input[i] >> 8) & 0xff;
+        output[j + 2] = (input[i] >> 16) & 0xff;
+        output[j + 3] = (input[i] >> 24) & 0xff;
+    }
+}
+
+}  // namespace
+
+// apply md5sum algo on a block
+void
+md5sum::transform(const uint8_t block[blocksize])
+{
+    uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+    decode(x, block, blocksize);
+
+    /* Round 1 */
+    FF(a, b, c, d, x[0], S11, 0xd76aa478);  /* 1 */
+    FF(d, a, b, c, x[1], S12, 0xe8c7b756);  /* 2 */
+    FF(c, d, a, b, x[2], S13, 0x242070db);  /* 3 */
+    FF(b, c, d, a, x[3], S14, 0xc1bdceee);  /* 4 */
+    FF(a, b, c, d, x[4], S11, 0xf57c0faf);  /* 5 */
+    FF(d, a, b, c, x[5], S12, 0x4787c62a);  /* 6 */
+    FF(c, d, a, b, x[6], S13, 0xa8304613);  /* 7 */
+    FF(b, c, d, a, x[7], S14, 0xfd469501);  /* 8 */
+    FF(a, b, c, d, x[8], S11, 0x698098d8);  /* 9 */
+    FF(d, a, b, c, x[9], S12, 0x8b44f7af);  /* 10 */
+    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+    /* Round 2 */
+    GG(a, b, c, d, x[1], S21, 0xf61e2562);  /* 17 */
+    GG(d, a, b, c, x[6], S22, 0xc040b340);  /* 18 */
+    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);  /* 20 */
+    GG(a, b, c, d, x[5], S21, 0xd62f105d);  /* 21 */
+    GG(d, a, b, c, x[10], S22, 0x2441453);  /* 22 */
+    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);  /* 24 */
+    GG(a, b, c, d, x[9], S21, 0x21e1cde6);  /* 25 */
+    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+    GG(c, d, a, b, x[3], S23, 0xf4d50d87);  /* 27 */
+    GG(b, c, d, a, x[8], S24, 0x455a14ed);  /* 28 */
+    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+    GG(d, a, b, c, x[2], S22, 0xfcefa3f8);  /* 30 */
+    GG(c, d, a, b, x[7], S23, 0x676f02d9);  /* 31 */
+    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+    /* Round 3 */
+    HH(a, b, c, d, x[5], S31, 0xfffa3942);  /* 33 */
+    HH(d, a, b, c, x[8], S32, 0x8771f681);  /* 34 */
+    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+    HH(a, b, c, d, x[1], S31, 0xa4beea44);  /* 37 */
+    HH(d, a, b, c, x[4], S32, 0x4bdecfa9);  /* 38 */
+    HH(c, d, a, b, x[7], S33, 0xf6bb4b60);  /* 39 */
+    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+    HH(d, a, b, c, x[0], S32, 0xeaa127fa);  /* 42 */
+    HH(c, d, a, b, x[3], S33, 0xd4ef3085);  /* 43 */
+    HH(b, c, d, a, x[6], S34, 0x4881d05);   /* 44 */
+    HH(a, b, c, d, x[9], S31, 0xd9d4d039);  /* 45 */
+    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+    HH(b, c, d, a, x[2], S34, 0xc4ac5665);  /* 48 */
+
+    /* Round 4 */
+    II(a, b, c, d, x[0], S41, 0xf4292244);  /* 49 */
+    II(d, a, b, c, x[7], S42, 0x432aff97);  /* 50 */
+    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+    II(b, c, d, a, x[5], S44, 0xfc93a039);  /* 52 */
+    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+    II(d, a, b, c, x[3], S42, 0x8f0ccc92);  /* 54 */
+    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+    II(b, c, d, a, x[1], S44, 0x85845dd1);  /* 56 */
+    II(a, b, c, d, x[8], S41, 0x6fa87e4f);  /* 57 */
+    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+    II(c, d, a, b, x[6], S43, 0xa3014314);  /* 59 */
+    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+    II(a, b, c, d, x[4], S41, 0xf7537e82);  /* 61 */
+    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+    II(c, d, a, b, x[2], S43, 0x2ad7d2bb);  /* 63 */
+    II(b, c, d, a, x[9], S44, 0xeb86d391);  /* 64 */
+
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+
+    // Zeroize sensitive information.
+    memset(x, 0, sizeof x);
+}
+
+md5sum&
+md5sum::update(std::string_view inp)
+{
+    return update(inp.data(), inp.length());
+}
+
+// md5sum block update operation. Continues an md5sum message-digest
+// operation, processing another message block
+md5sum&
+md5sum::update(const unsigned char input[], size_type length)
+{
+    // compute number of bytes mod 64
+    size_type index = count[0] / 8 % blocksize;
+
+    // Update number of bits
+    if((count[0] += (length << 3)) < (length << 3)) count[1]++;
+    count[1] += (length >> 29);
+
+    // number of bytes we need to fill in buffer
+    size_type firstpart = 64 - index;
+    size_type i         = 0;
+
+    // transform as many times as possible.
+    if(length >= firstpart)
+    {
+        // fill buffer first, transform
+        memcpy(&buffer[index], input, firstpart);
+        transform(buffer.data());
+
+        // transform chunks of blocksize (64 bytes)
+        for(i = firstpart; i + blocksize <= length; i += blocksize)
+            transform(&input[i]);
+
+        index = 0;
+    }
+
+    // buffer remaining input
+    memcpy(&buffer[index], &input[i], length - i);
+
+    return *this;
+}
+
+// for convenience provide a verson with signed char
+md5sum&
+md5sum::update(const char input[], size_type length)
+{
+    return update((const unsigned char*) input, length);
+}
+
+// md5sum finalization. Ends an md5sum message-digest operation, writing the
+// the message digest and zeroizing the context.
+md5sum&
+md5sum::finalize()
+{
+    static unsigned char padding[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                         0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                         0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                         0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                         0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+    if(!finalized)
+    {
+        // Save number of bits
+        unsigned char bits[8];
+        encode(bits, count.data(), 8);
+
+        // pad out to 56 mod 64.
+        size_type index  = count[0] / 8 % 64;
+        size_type padLen = (index < 56) ? (56 - index) : (120 - index);
+        update(padding, padLen);
+
+        // Append length (before padding)
+        update(bits, 8);
+
+        // Store state in digest
+        encode(digest.data(), state.data(), 16);
+
+        // Zeroize sensitive information.
+        memset(buffer.data(), 0, sizeof buffer);
+        memset(count.data(), 0, sizeof count);
+
+        finalized = true;
+    }
+
+    return *this;
+}
+
+// return hex representation of digest as string
+std::string
+md5sum::hexdigest() const
+{
+    if(!finalized) return std::string{};
+
+    char buf[33];
+    for(int i = 0; i < 16; i++)
+        snprintf(buf + i * 2, 3, "%02x", digest[i]);
+    buf[32] = '\0';
+
+    return std::string(buf);
+}
+
+std::string
+md5sum::hexliteral() const
+{
+    if(!finalized) return std::string{};
+
+    auto _oss = std::ostringstream{};
+    _oss << "X'";
+    for(auto itr : rawdigest())
+        _oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(itr);
+    _oss << "'";
+    return _oss.str();
+}
+
+std::ostream&
+operator<<(std::ostream& out, md5sum md5)
+{
+    return out << md5.hexdigest();
+}
+
+std::string
+compute_md5sum(std::string_view inp)
+{
+    return md5sum{ inp }.finalize().hexdigest();
+}
+
+}  // namespace common
+}  // namespace rocprofsys
diff --git a/source/lib/common/traits.hpp b/source/lib/common/traits.hpp
new file mode 100644
index 0000000000..c31da5229d
--- /dev/null
+++ b/source/lib/common/traits.hpp
@@ -0,0 +1,91 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+#include <optional>
+#include <string>
+#include <type_traits>
+
+namespace rocprofsys
+{
+inline namespace common
+{
+namespace traits
+{
+
+template <typename T>
+struct is_string_literal : std::false_type
+{};
+
+template <std::size_t N>
+struct is_string_literal<char[N]> : std::true_type
+{};
+
+template <std::size_t N>
+struct is_string_literal<const char[N]> : std::true_type
+{};
+
+template <>
+struct is_string_literal<std::string_view> : std::true_type
+{};
+
+template <>
+struct is_string_literal<const char*> : std::true_type
+{};
+
+template <>
+struct is_string_literal<char*> : std::true_type
+{};
+
+template <>
+struct is_string_literal<std::string> : std::true_type
+{};
+
+template <>
+struct is_string_literal<const std::string> : std::true_type
+{};
+
+template <>
+struct is_string_literal<const char* const> : std::true_type
+{};
+
+template <>
+struct is_string_literal<char* const> : std::true_type
+{};
+
+template <typename T>
+inline constexpr bool is_string_literal_v = is_string_literal<T>::value;
+
+template <typename T>
+struct is_optional : std::false_type
+{};
+
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type
+{};
+
+template <typename T>
+inline constexpr bool is_optional_v = is_optional<T>::value;
+
+}  // namespace traits
+}  // namespace common
+}  // namespace rocprofsys
diff --git a/source/lib/core/CMakeLists.txt b/source/lib/core/CMakeLists.txt
index b7462c490d..2c1ac07edc 100644
--- a/source/lib/core/CMakeLists.txt
+++ b/source/lib/core/CMakeLists.txt
@@ -22,6 +22,8 @@ set(core_sources
     ${CMAKE_CURRENT_LIST_DIR}/state.cpp
     ${CMAKE_CURRENT_LIST_DIR}/timemory.cpp
     ${CMAKE_CURRENT_LIST_DIR}/utility.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/node_info.cpp
 )
 
 set(core_headers
@@ -46,6 +48,9 @@ set(core_headers
     ${CMAKE_CURRENT_LIST_DIR}/state.hpp
     ${CMAKE_CURRENT_LIST_DIR}/timemory.hpp
     ${CMAKE_CURRENT_LIST_DIR}/utility.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/agent.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/node_info.hpp
 )
 
 add_library(rocprofiler-systems-core-library STATIC)
@@ -61,6 +66,7 @@ target_sources(
 add_subdirectory(binary)
 add_subdirectory(components)
 add_subdirectory(containers)
+add_subdirectory(rocpd)
 
 target_include_directories(
     rocprofiler-systems-core-library
@@ -95,6 +101,22 @@ target_link_libraries(
         $<BUILD_INTERFACE:$<IF:$<BOOL:${ROCPROFSYS_BUILD_LTO}>,rocprofiler-systems::rocprofiler-systems-lto,>>
 )
 
+file(GLOB ROCPD_SCHEMA_FILES "${CMAKE_CURRENT_LIST_DIR}/rocpd/data_storage/schema/*.sql")
+
+foreach(_SRC ${ROCPD_SCHEMA_FILES})
+    cmake_path(GET _SRC FILENAME _BASE)
+    configure_file(
+        ${_SRC}
+        ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/${_BASE}
+        COPYONLY
+    )
+    install(
+        FILES ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/${_BASE}
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}
+        COMPONENT core
+    )
+endforeach()
+
 set_target_properties(
     rocprofiler-systems-core-library
     PROPERTIES OUTPUT_NAME ${BINARY_NAME_PREFIX}-core
diff --git a/source/lib/core/agent.hpp b/source/lib/core/agent.hpp
new file mode 100644
index 0000000000..faa74d7a4c
--- /dev/null
+++ b/source/lib/core/agent.hpp
@@ -0,0 +1,49 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <cstddef>
+#include <rocprofiler-sdk/agent.h>
+
+#if ROCPROFSYS_USE_ROCM > 0
+#    include <amd_smi/amdsmi.h>
+#endif
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+
+struct agent
+{
+    const rocprofiler_agent_v0_t* agent = nullptr;
+    size_t                        device_id{ 0 };
+    size_t                        base_id{ 0 };
+
+#if ROCPROFSYS_USE_ROCM > 0
+    amdsmi_processor_handle smi_handle = nullptr;
+#endif
+};
+
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/agent_manager.cpp b/source/lib/core/agent_manager.cpp
new file mode 100644
index 0000000000..99a26706f4
--- /dev/null
+++ b/source/lib/core/agent_manager.cpp
@@ -0,0 +1,145 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "agent_manager.hpp"
+#include "debug.hpp"
+#include <algorithm>
+#include <iterator>
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+agent_manager&
+agent_manager::get_instance()
+{
+    static agent_manager instance;
+    return instance;
+}
+
+void
+agent_manager::insert_agent(const rocprofiler_agent_v0_t* _agent)
+{
+    ROCPROFSYS_VERBOSE(
+        3, "Inserting agent with device handle: %lu, and agent id: %ld, device type: %s",
+        _agent->id.handle,
+        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? _gpu_agents_cnt : _cpu_agents_cnt),
+        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU"));
+
+    _agents.emplace_back(std::make_shared<agent>(agent{
+        _agent,
+        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? _gpu_agents_cnt++
+                                                    : _cpu_agents_cnt++),
+    }));
+}
+
+const agent&
+agent_manager::get_agent_by_id(size_t device_id, rocprofiler_agent_type_t type) const
+{
+    ROCPROFSYS_VERBOSE(3, "Getting agent for device id: %ld, type %s\n", device_id,
+                       (type == ROCPROFILER_AGENT_TYPE_GPU) ? "GPU" : "CPU");
+    auto _agent =
+        std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
+            return agent_ptr->agent->type == type && agent_ptr->device_id == device_id;
+        });
+    if(_agent == _agents.end())
+    {
+        std::ostringstream oss;
+        oss << "Agent not found for device id: " << device_id
+            << ", type: " << (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+        throw std::out_of_range(oss.str());
+    }
+    return **_agent;
+}
+
+const agent&
+agent_manager::get_agent_by_handle(uint64_t                 device_handle,
+                                   rocprofiler_agent_type_t type) const
+{
+    ROCPROFSYS_VERBOSE(3, "Getting agent for device handle: %ld, type %s\n",
+                       device_handle,
+                       (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU"));
+    auto _agent =
+        std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
+            return agent_ptr->agent->type == type &&
+                   agent_ptr->agent->id.handle == device_handle;
+        });
+    if(_agent == _agents.end())
+    {
+        std::ostringstream oss;
+        oss << "Agent not found for device handle: " << device_handle
+            << ", type: " << (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+        throw std::out_of_range(oss.str());
+    }
+    return **_agent;
+}
+
+const agent&
+agent_manager::get_agent_by_handle(size_t device_handle) const
+{
+    ROCPROFSYS_VERBOSE(3, "Getting agent for device handle: %ld\n", device_handle);
+    auto _agent =
+        std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
+            return agent_ptr->agent->id.handle == device_handle;
+        });
+    if(_agent == _agents.end())
+    {
+        std::ostringstream oss;
+        oss << "Agent not found for device handle: " << device_handle;
+        throw std::out_of_range(oss.str());
+    }
+    return **_agent;
+}
+
+std::vector<std::shared_ptr<agent>>
+agent_manager::get_agents_by_type(rocprofiler_agent_type_t type) const
+{
+    ROCPROFSYS_VERBOSE(3, "Getting agent for device type: %s\n",
+                       type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+
+    std::vector<std::shared_ptr<agent>> agents;
+    std::copy_if(
+        std::begin(_agents), std::end(_agents), std::back_inserter(agents),
+        [&type](const auto& agent_ptr) { return agent_ptr->agent->type == type; });
+    return agents;
+}
+
+std::vector<std::shared_ptr<agent>>
+agent_manager::get_agents() const
+{
+    return _agents;
+}
+
+size_t
+agent_manager::get_gpu_agents_count() const
+{
+    return _gpu_agents_cnt;
+}
+
+size_t
+agent_manager::get_cpu_agents_count() const
+{
+    return _cpu_agents_cnt;
+}
+
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/agent_manager.hpp b/source/lib/core/agent_manager.hpp
new file mode 100644
index 0000000000..0e45d49a94
--- /dev/null
+++ b/source/lib/core/agent_manager.hpp
@@ -0,0 +1,67 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+#include "agent.hpp"
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+
+struct agent_manager
+{
+    static agent_manager& get_instance();
+
+    agent_manager(const agent_manager&)            = delete;
+    agent_manager& operator=(const agent_manager&) = delete;
+    agent_manager(agent_manager&&)                 = delete;
+    agent_manager& operator=(agent_manager&&)      = delete;
+    ~agent_manager()                               = default;
+
+    void insert_agent(const rocprofiler_agent_v0_t* agent);
+
+    const agent& get_agent_by_id(size_t device_id, rocprofiler_agent_type_t type) const;
+    const agent& get_agent_by_handle(size_t                   device_id,
+                                     rocprofiler_agent_type_t type) const;
+    const agent& get_agent_by_handle(size_t device_handle) const;
+
+    std::vector<std::shared_ptr<agent>> get_agents_by_type(
+        rocprofiler_agent_type_t type) const;
+    std::vector<std::shared_ptr<agent>> get_agents() const;
+
+    size_t get_gpu_agents_count() const;
+    size_t get_cpu_agents_count() const;
+
+private:
+    std::vector<std::shared_ptr<agent>> _agents;
+    size_t                              _gpu_agents_cnt{ 0 };
+    size_t                              _cpu_agents_cnt{ 0 };
+    agent_manager() = default;
+};
+
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/benchmark/benchmark.hpp b/source/lib/core/benchmark/benchmark.hpp
new file mode 100644
index 0000000000..63a89352bc
--- /dev/null
+++ b/source/lib/core/benchmark/benchmark.hpp
@@ -0,0 +1,325 @@
+// MIT License
+//
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "core/benchmark/category.hpp"
+#include "core/debug.hpp"
+
+namespace rocprofiler
+{
+namespace benchmark
+{
+namespace
+{
+template <bool enabled, typename category_enum, category_enum... enabled_categories>
+struct benchmark_impl
+{
+    template <category_enum... categories>
+    struct scope
+    {
+        scope(const scope&)            = delete;
+        scope& operator=(const scope&) = delete;
+        ~scope()                       = default;
+
+    protected:
+        scope()                   = default;
+        scope(scope&&)            = default;
+        scope& operator=(scope&&) = default;
+    };
+
+    template <category_enum... categories>
+    static void start()
+    {}
+
+    template <category_enum... categories>
+    static void end()
+    {}
+
+    template <category_enum... categories>
+    [[nodiscard]] static scope<categories...> scoped_trace()
+    {
+        return scope<categories...>{};
+    }
+
+    static void init_from_env(const char* = nullptr) {}
+    static void show_results() {}
+};
+
+template <typename category_enum, category_enum... enabled_categories>
+struct benchmark_impl<true, category_enum, enabled_categories...>
+{
+    static_assert(std::is_enum_v<category_enum>, "category_enum must be an enum");
+
+public:
+    using clock                             = std::chrono::high_resolution_clock;
+    using time_point                        = clock::time_point;
+    static constexpr size_t _max_categories = static_cast<size_t>(category_enum::count);
+
+    template <category_enum... categories>
+    struct scope
+    {
+        friend benchmark_impl;
+
+    public:
+        scope(const scope&)            = delete;
+        scope& operator=(const scope&) = delete;
+        ~scope() { end<categories...>(); }
+
+    protected:
+        scope() { start<categories...>(); }
+
+        scope(scope&&)            = default;
+        scope& operator=(scope&&) = default;
+    };
+
+    template <category_enum... categories>
+    static void start()
+    {
+        const auto      now = clock::now();
+        std::lock_guard lock(m_mutex);
+        (..., (if_compiled<categories>([&] {
+             if(m_enabled.test(to_index(categories)))
+                 m_started[to_index(categories)] = now;
+         })));
+    }
+
+    template <category_enum... categories>
+    static void end()
+    {
+        const auto      end_time = clock::now();
+        std::lock_guard lock(m_mutex);
+        (..., (if_compiled<categories>([&] {
+             if(m_enabled.test(to_index(categories))) end_category(end_time, categories);
+         })));
+    }
+
+    template <category_enum... categories>
+    [[nodiscard]] static scope<categories...> scoped_trace()
+    {
+        return scope<categories...>{};
+    }
+
+    static void init_from_env(const char* envVar = "ROCPROFSYS_BENCHMARK_CATEGORIES")
+    {
+        std::lock_guard lock(m_mutex);
+        const auto*     env = std::getenv(envVar);
+        if(env == nullptr || std::string(env).empty())
+        {
+            ROCPROFSYS_WARNING(
+                1, "No BENCHMARK categories specified in environment variable.\n");
+            return;
+        }
+        std::string        _str(env);
+        std::istringstream ss(_str);
+        std::string        token;
+
+        while(std::getline(ss, token, ','))
+        {
+            token.erase(0, token.find_first_not_of(" \t"));
+            token.erase(token.find_last_not_of(" \t") + 1);
+            for(category_enum cat : compiledCategories)
+            {
+                if(to_string(cat) == token)
+                {
+                    m_enabled.set(to_index(cat));
+                }
+            }
+        }
+    }
+
+    static void show_results()
+    {
+        std::lock_guard                                    lock(m_mutex);
+        std::vector<std::pair<category_enum, result_data>> sorted;
+
+        for(category_enum cat : compiledCategories)
+        {
+            const auto& data = m_results[to_index(cat)];
+            if(data.count > 0)
+            {
+                sorted.emplace_back(cat, data);
+            }
+        }
+
+        std::sort(sorted.begin(), sorted.end(), [](const auto& a, const auto& b) {
+            return a.second.total_time > b.second.total_time;
+        });
+
+        constexpr uint32_t _category = 30;
+        constexpr uint32_t _calls    = 8;
+        constexpr uint32_t _total    = 12;
+        constexpr uint32_t _avg      = 10;
+        constexpr uint32_t _min      = 10;
+        constexpr uint32_t _max      = 10;
+
+        std::cout << "\033[32m"
+                  << std::string(_category + _calls + _total + _avg + _min + _max, '=')
+                  << "\n";
+        std::cout << "Benchmark Results (Sorted by Total Time):\n";
+        std::cout << std::string(_category + _calls + _total + _avg + _min + _max, '-')
+                  << "\n";
+        std::cout << std::left << std::setw(_category) << "Category" << std::right
+                  << std::setw(_calls) << "Calls" << std::setw(_total) << "Total(ms)"
+                  << std::setw(_avg) << "Avg(us)" << std::setw(_min) << "Min(us)"
+                  << std::setw(_max) << "Max(us)" << "\n";
+
+        std::cout << std::string(_category + _calls + _total + _avg + _min + _max, '-')
+                  << "\n";
+
+        for(const auto& [cat, data] : sorted)
+        {
+            double totalMs = static_cast<double>(data.total_time) / 1000.0;
+            double avgUs   = static_cast<double>(data.total_time) / data.count;
+
+            std::cout << std::left << std::setw(_category) << to_string(cat) << std::right
+                      << std::setw(_calls) << data.count << std::setw(_total)
+                      << std::fixed << std::setprecision(3) << totalMs << std::setw(_avg)
+                      << std::fixed << std::setprecision(1) << avgUs << std::setw(_min)
+                      << data.min_time << std::setw(_max) << data.max_time << "\n";
+        }
+
+        std::cout << std::string(_category + _calls + _total + _avg + _min + _max, '=')
+                  << "\033[0m" << "\n\n";
+    }
+
+private:
+    struct result_data
+    {
+        uint64_t total_time = 0;
+        size_t   count      = 0;
+        uint64_t min_time   = std::numeric_limits<uint64_t>::max();
+        uint64_t max_time   = std::numeric_limits<uint64_t>::min();
+
+        void update(uint64_t duration)
+        {
+            total_time += duration;
+            count += 1;
+            if(duration < min_time) min_time = duration;
+            if(duration > max_time) max_time = duration;
+        }
+    };
+
+    static constexpr size_t to_index(category_enum cat)
+    {
+        return static_cast<size_t>(cat);
+    }
+
+    static void end_category(const time_point& end_time, category_enum cat)
+    {
+        const size_t idx = to_index(cat);
+        auto         it  = m_started.find(idx);
+        if(it == m_started.end())
+        {
+            ROCPROFSYS_WARNING(1, "Benchmark error: missing start time for category!\n");
+            return;
+        }
+
+        auto duration =
+            std::chrono::duration_cast<std::chrono::microseconds>(end_time - it->second)
+                .count();
+        m_started.erase(it);
+        m_results[idx].update(duration);
+    }
+
+    template <category_enum Cat, typename Func>
+    static constexpr void if_compiled(Func&& f)
+    {
+        if constexpr(((Cat == enabled_categories) || ...))
+        {
+            f();
+        }
+    }
+
+    static constexpr std::array<category_enum, sizeof...(enabled_categories)>
+        compiledCategories = { enabled_categories... };
+
+    static inline std::unordered_map<size_t, time_point>   m_started;
+    static inline std::array<result_data, _max_categories> m_results{};
+    static inline std::bitset<_max_categories>             m_enabled;
+    static inline std::mutex                               m_mutex;
+};
+
+#ifdef ROCPROFSYS_ENABLE_BENCHMARK
+using _benchmark_impl = benchmark::benchmark_impl<
+    static_cast<bool>(ROCPROFSYS_ENABLE_BENCHMARK), benchmark::category,
+    benchmark::category::kernel_dispatch, benchmark::category::memory_copy,
+    benchmark::category::memory_allocate, benchmark::category::db_entry_kernel_dispatch,
+    benchmark::category::db_entry_memory_copy,
+    benchmark::category::db_entry_memory_allocate,
+    benchmark::category::perfetto_kernel_dispatch,
+    benchmark::category::sdk_tool_buffered_tracing>;
+#else
+using _benchmark_impl = benchmark::benchmark_impl<false, benchmark::category>;
+#endif
+}  // namespace
+
+template <category... categories>
+void
+start()
+{
+    _benchmark_impl::template start<categories...>();
+}
+
+template <category... categories>
+void
+end()
+{
+    _benchmark_impl::template end<categories...>();
+}
+
+template <category... categories>
+[[nodiscard]] auto
+scoped_trace()
+{
+    return _benchmark_impl::template scoped_trace<categories...>();
+}
+
+inline void
+init_from_env(const char* envVar = "BENCHMARK_CATEGORIES")
+{
+    _benchmark_impl::init_from_env(envVar);
+}
+
+inline void
+show_results()
+{
+    _benchmark_impl::show_results();
+}
+
+}  // namespace benchmark
+}  // namespace rocprofiler
diff --git a/source/lib/core/benchmark/category.hpp b/source/lib/core/benchmark/category.hpp
new file mode 100644
index 0000000000..f5a8774508
--- /dev/null
+++ b/source/lib/core/benchmark/category.hpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2018-2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// with the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// * Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimers.
+//
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimers in the
+// documentation and/or other materials provided with the distribution.
+//
+// * Neither the names of Advanced Micro Devices, Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this Software without specific prior written permission.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
+// THE SOFTWARE.
+
+#pragma once
+
+#include <string_view>
+
+namespace rocprofiler
+{
+namespace benchmark
+{
+enum class category
+{
+    kernel_dispatch,
+    db_entry_kernel_dispatch,
+    memory_copy,
+    db_entry_memory_copy,
+    memory_allocate,
+    db_entry_memory_allocate,
+    perfetto_kernel_dispatch,
+    sdk_tool_buffered_tracing,
+    count
+};
+
+constexpr std::string_view
+to_string(category cat)
+{
+    switch(cat)
+    {
+        case category::kernel_dispatch: return "kernel_dispatch";
+        case category::db_entry_kernel_dispatch: return "db_entry_kernel_dispatch";
+        case category::memory_copy: return "memory_copy";
+        case category::memory_allocate: return "memory_allocate";
+        case category::db_entry_memory_copy: return "db_entry_memory_copy";
+        case category::db_entry_memory_allocate: return "db_entry_memory_allocate";
+        case category::perfetto_kernel_dispatch: return "perfetto_kernel_dispatch";
+        case category::sdk_tool_buffered_tracing: return "sdk_tool_buffered_tracing";
+        default: return "unknown";
+    }
+}
+
+}  // namespace benchmark
+}  // namespace rocprofiler
diff --git a/source/lib/core/config.cpp b/source/lib/core/config.cpp
index 6f57706f2f..b8afbd652d 100644
--- a/source/lib/core/config.cpp
+++ b/source/lib/core/config.cpp
@@ -312,6 +312,9 @@ configure_settings(bool _init)
                               "Enable causal profiling analysis", false, "backend",
                               "causal", "analysis");
 
+    ROCPROFSYS_CONFIG_SETTING(bool, "ROCPROFSYS_USE_ROCPD", "Enable rocpd backend", false,
+                              "backend", "rocpd");
+
     ROCPROFSYS_CONFIG_SETTING(bool, "ROCPROFSYS_USE_ROCM",
                               "Enable ROCm API and kernel tracing", true, "backend",
                               "rocm");
@@ -1246,10 +1249,17 @@ configure_signal_handler(const std::shared_ptr<settings>& _config)
     static auto _dyninst_trampoline_signal =
         getenv("DYNINST_SIGNAL_TRAMPOLINE_SIGILL") ? SIGILL : SIGTRAP;
 
+    static auto root_pid =
+        get_env<pid_t>("ROCPROFSYS_ROOT_PROCESS", process::get_id(), false);
     if(_config->get_enable_signal_handler())
     {
         tim::signals::disable_signal_detection();
         signal_settings::enable(sys_signal::Interrupt);
+        auto is_child_process = root_pid != getpid();
+        if(is_child_process)
+        {
+            signal_settings::enable(sys_signal::Terminate);
+        }
         signal_settings::set_exit_action(rocprofsys_exit_action);
         signal_settings::check_environment();
         auto default_signals = signal_settings::get_default();
@@ -2347,6 +2357,40 @@ get_tmpdir()
     return static_cast<tim::tsettings<std::string>&>(*_v->second).get();
 }
 
+std::string
+get_database_absolute_path(std::string_view database_name)
+{
+    const auto* _existing_path = std::getenv("ROCPROFSYS_DATABASE_DIR");
+    auto        _dir = _existing_path ? std::string{ _existing_path } : std::string{};
+    auto        _ext = std::string{ "db" };
+
+    auto _cfg = settings::compose_filename_config{ settings::use_output_suffix(),
+                                                   settings::default_process_suffix(),
+                                                   false, _dir };
+
+    const auto get_path = [](const std::string& path) {
+        size_t last_slash = path.find_last_of("/\\");
+        return (last_slash != std::string::npos) ? path.substr(0, last_slash + 1)
+                                                 : std::string{};
+    };
+
+    auto _val = settings::compose_output_filename(std::string(database_name), _ext, _cfg);
+    _dir      = get_path(_val);
+
+    setenv("ROCPROFSYS_DATABASE_DIR", _dir.c_str(), 1);
+
+    if(!_val.empty() && _val.at(0) != '/')
+        return settings::format(JOIN('/', "%env{PWD}%", _val), get_config()->get_tag());
+    return _val;
+}
+
+bool&
+get_use_rocpd()
+{
+    static auto _v = get_config()->at("ROCPROFSYS_USE_ROCPD");
+    return static_cast<tim::tsettings<bool>&>(*_v).get();
+}
+
 tmp_file::tmp_file(std::string _v)
 : filename{ std::move(_v) }
 {}
diff --git a/source/lib/core/config.hpp b/source/lib/core/config.hpp
index a7e9a8f384..4eabda8aa3 100644
--- a/source/lib/core/config.hpp
+++ b/source/lib/core/config.hpp
@@ -358,6 +358,12 @@ get_use_tmp_files();
 std::string
 get_tmpdir();
 
+std::string
+get_database_absolute_path(std::string_view database_name);
+
+bool&
+get_use_rocpd() ROCPROFSYS_HOT;
+
 struct tmp_file
 {
     tmp_file(std::string);
diff --git a/source/lib/core/gpu.cpp b/source/lib/core/gpu.cpp
index 1070a50657..d6c52cdcdb 100644
--- a/source/lib/core/gpu.cpp
+++ b/source/lib/core/gpu.cpp
@@ -41,6 +41,8 @@
 
 #include <timemory/manager.hpp>
 
+#include "core/agent_manager.hpp"
+
 #if ROCPROFSYS_USE_ROCM > 0
 #    include <amd_smi/amdsmi.h>
 #    include <rocprofiler-sdk/agent.h>
@@ -108,18 +110,18 @@ amdsmi_init()
 }
 #endif  // ROCPROFSYS_USE_ROCM > 0
 
-int32_t
-query_rocm_gpu_agents()
+size_t
+query_rocm_agents()
 {
-    int32_t _dev_cnt = 0;
+    size_t _dev_cnt = 0;
 #if ROCPROFSYS_USE_ROCM > 0
     auto iterator = [](rocprofiler_agent_version_t /*version*/, const void** agents,
                        size_t num_agents, void* user_data) -> rocprofiler_status_t {
-        auto* _cnt = static_cast<int32_t*>(user_data);
+        auto& _agent_mngr = rocpd::agent_manager::get_instance();
         for(size_t i = 0; i < num_agents; ++i)
         {
             const auto* _agent = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
-            if(_agent && _agent->type == ROCPROFILER_AGENT_TYPE_GPU) *_cnt += 1;
+            _agent_mngr.insert_agent(_agent);
         }
         return ROCPROFILER_STATUS_SUCCESS;
     };
@@ -127,15 +129,14 @@ query_rocm_gpu_agents()
     try
     {
         rocprofiler_query_available_agents(ROCPROFILER_AGENT_INFO_VERSION_0, iterator,
-                                           sizeof(rocprofiler_agent_v0_t), &_dev_cnt);
+                                           sizeof(rocprofiler_agent_v0_t), nullptr);
     } catch(std::exception& _e)
     {
         ROCPROFSYS_BASIC_VERBOSE(
-            1, "Exception thrown getting the rocm agents: %s. _dev_cnt=%d\n", _e.what(),
+            1, "Exception thrown getting the rocm agents: %s. _dev_cnt=%ld\n", _e.what(),
             _dev_cnt);
     }
-    // rocprofiler_query_available_agents(ROCPROFILER_AGENT_INFO_VERSION_0, iterator,
-    //                                sizeof(rocprofiler_agent_v0_t), &_dev_cnt);
+    _dev_cnt = rocpd::agent_manager::get_instance().get_gpu_agents_count();
 #endif
     return _dev_cnt;
 }
@@ -145,7 +146,7 @@ int
 device_count()
 {
 #if ROCPROFSYS_USE_ROCM > 0
-    static int _num_devices = query_rocm_gpu_agents();
+    static int _num_devices = query_rocm_agents();
     return _num_devices;
 #else
     return 0;
@@ -173,22 +174,14 @@ add_device_metadata(ArchiveT& ar)
 
 #if ROCPROFSYS_USE_ROCM > 0
     using agent_vec_t = std::vector<rocprofiler_agent_v0_t>;
-
+    auto _gpu_agents  = rocpd::agent_manager::get_instance().get_agents_by_type(
+        ROCPROFILER_AGENT_TYPE_GPU);
     auto _agents_vec = agent_vec_t{};
-    auto iterator    = [](rocprofiler_agent_version_t /*version*/, const void** agents,
-                       size_t num_agents, void* user_data) -> rocprofiler_status_t {
-        auto* _agents_vec_v = static_cast<agent_vec_t*>(user_data);
-        _agents_vec_v->reserve(num_agents);
-        for(size_t i = 0; i < num_agents; ++i)
-        {
-            const auto* _agent = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
-            if(_agent) _agents_vec_v->emplace_back(*_agent);
-        }
-        return ROCPROFILER_STATUS_SUCCESS;
-    };
-    rocprofiler_query_available_agents(ROCPROFILER_AGENT_INFO_VERSION_0, iterator,
-                                       sizeof(rocprofiler_agent_v0_t), &_agents_vec);
 
+    for(auto& agent : _gpu_agents)
+    {
+        _agents_vec.emplace_back(*(agent->agent));
+    }
     ar(make_nvp("rocm_agents", _agents_vec));
 #else
     (void) ar;
@@ -228,6 +221,10 @@ get_processor_handles()
 {
     uint32_t socket_count;
     uint32_t processor_count;
+    processors::processors_list.clear();
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto  gpu_agents = agent_mngr.get_agents_by_type(ROCPROFILER_AGENT_TYPE_GPU);
 
     // Passing nullptr will return us the number of sockets available for read in this
     // system
diff --git a/source/lib/core/node_info.cpp b/source/lib/core/node_info.cpp
new file mode 100644
index 0000000000..47a3a40869
--- /dev/null
+++ b/source/lib/core/node_info.cpp
@@ -0,0 +1,72 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "node_info.hpp"
+#include "debug.hpp"
+
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <sys/utsname.h>
+
+namespace rocprofsys
+{
+
+node_info::node_info()
+{
+    auto ifs = std::ifstream{ "/etc/machine-id" };
+    if(!ifs.is_open())
+    {
+        ROCPROFSYS_WARNING(0, "Error: Unable to open /etc/machine-id!");
+        return;
+    }
+    if(!(ifs >> machine_id) || machine_id.empty())
+    {
+        ROCPROFSYS_WARNING(0, "Error: Unable to read machine ID from /etc/machine-id!");
+    }
+
+    hash = std::hash<std::string>{}(machine_id) % std::numeric_limits<int64_t>::max();
+    id   = hash % std::numeric_limits<size_t>::max();
+
+    struct utsname _sys_info;
+    if(uname(&_sys_info))
+    {
+        ROCPROFSYS_WARNING(0, "Error: Unable to get system information!");
+        return;
+    }
+
+    system_name = _sys_info.sysname;
+    node_name   = _sys_info.nodename;
+    release     = _sys_info.release;
+    version     = _sys_info.version;
+    machine     = _sys_info.machine;
+    domain_name = _sys_info.domainname;
+}
+
+node_info&
+node_info::get_instance()
+{
+    static node_info instance;
+    return instance;
+}
+
+}  // namespace rocprofsys
diff --git a/source/lib/core/node_info.hpp b/source/lib/core/node_info.hpp
new file mode 100644
index 0000000000..b4904e52e7
--- /dev/null
+++ b/source/lib/core/node_info.hpp
@@ -0,0 +1,58 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace rocprofsys
+{
+
+struct node_info
+{
+private:
+    node_info();
+
+public:
+    ~node_info()                               = default;
+    node_info(const node_info&)                = default;
+    node_info(node_info&&) noexcept            = default;
+    node_info& operator=(const node_info&)     = default;
+    node_info& operator=(node_info&&) noexcept = default;
+
+    static node_info& get_instance();
+
+    uint64_t    id          = 0;
+    uint64_t    hash        = 0;
+    std::string machine_id  = {};
+    std::string system_name = {};
+    std::string node_name   = {};
+    std::string release     = {};
+    std::string version     = {};
+    std::string machine     = {};
+    std::string domain_name = {};
+};
+
+const node_info&
+get_node_info();
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/CMakeLists.txt b/source/lib/core/rocpd/CMakeLists.txt
new file mode 100644
index 0000000000..0e4d1a5594
--- /dev/null
+++ b/source/lib/core/rocpd/CMakeLists.txt
@@ -0,0 +1,20 @@
+set(rocpd_sources
+    ${CMAKE_CURRENT_LIST_DIR}/data_processor.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/json.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/data_storage/database.cpp
+)
+
+set(rocpd_headers
+    ${CMAKE_CURRENT_LIST_DIR}/data_processor.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/json.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/data_storage/database.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/data_storage/queries/table_insert_query.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/data_storage/queries/query_builders/insert_query_builders.hpp
+)
+
+target_sources(rocprofiler-systems-core-library PRIVATE ${rocpd_sources} ${rocpd_headers})
+
+target_link_libraries(
+    rocprofiler-systems-core-library
+    PRIVATE $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-sqlite3>
+)
diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
new file mode 100644
index 0000000000..8f3d38263c
--- /dev/null
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -0,0 +1,671 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "data_processor.hpp"
+#include "core/rocpd/data_storage/database.hpp"
+#include "core/rocpd/data_storage/queries/table_insert_query.hpp"
+#include "debug.hpp"
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+data_processor::data_processor()
+{
+    data_storage::database::get_instance().initialize_schema();
+    _upid = data_storage::database::get_instance().get_upid();
+
+    // Initialize event statement
+    initialize_event_stmt();
+    initialize_pmc_event_stmt();
+    initialize_sample_stmt();
+    initialize_region_stmt();
+    initialize_kernel_dispatch_stmt();
+    initialize_memory_copy_stmt();
+    initialize_code_object_stmt();
+    initialize_kernel_symbol_stmt();
+    initialize_metadata();
+    initialize_args_stmt();
+    initialize_memory_alloc_stmt();
+}
+
+data_processor&
+data_processor::get_instance()
+{
+    static data_processor _instance;
+    return _instance;
+}
+
+void
+data_processor::initialize_metadata()
+{
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_metadata_" + _upid)
+            .set_columns("tag", "value")
+            .set_values("upid", _upid)
+            .get_query_string());
+}
+
+size_t
+data_processor::insert_string(const char* str)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    auto                        it = _string_map.find(str);
+    if(it != _string_map.end()) return _string_map.at(str);
+
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_string_" + _upid)
+            .set_columns("guid", "string")
+            .set_values(_upid, str)
+            .get_query_string());
+
+    const auto string_id = data_storage::database::get_instance().get_last_insert_id();
+    _string_map.emplace(str, string_id);
+    return string_id;
+}
+
+void
+data_processor::insert_node_info(size_t node_id, size_t hash, const char* machine_id,
+                                 const char* system_name, const char* hostname,
+                                 const char* release, const char* version,
+                                 const char* hardware_name, const char* domain_name)
+{
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_node_" + _upid)
+            .set_columns("id", "guid", "hash", "machine_id", "system_name", "hostname",
+                         "release", "version", "hardware_name", "domain_name")
+            .set_values(node_id, _upid, hash, machine_id, system_name, hostname, release,
+                        version, hardware_name, domain_name)
+            .get_query_string());
+}
+
+void
+data_processor::insert_process_info(size_t nid, size_t ppid, size_t pid, size_t init,
+                                    size_t fini, size_t start, size_t end,
+                                    const char* command, const char* environment,
+                                    const char* extdata)
+{
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_process_" + _upid)
+            .set_columns("id", "guid", "nid", "ppid", "pid", "init", "fini", "start",
+                         "end", "command", "environment", "extdata")
+            .set_values(pid, _upid, nid, ppid, pid, init, fini, start, end, command,
+                        environment, extdata)
+            .get_query_string());
+}
+
+size_t
+data_processor::insert_agent(size_t node_id, size_t pid, const char* agent_type,
+                             size_t absolute_index, size_t logical_index,
+                             size_t type_index, uint64_t uuid, const char* name,
+                             const char* model_name, const char* vendor_name,
+                             const char* product_name, const char* user_name,
+                             const char* extdata)
+{
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_agent_" + _upid)
+            .set_columns("guid", "nid", "pid", "type", "absolute_index", "logical_index",
+                         "type_index", "uuid", "name", "model_name", "vendor_name",
+                         "product_name", "user_name", "extdata")
+            .set_values(_upid, node_id, pid, agent_type, absolute_index, logical_index,
+                        type_index, uuid, name, model_name, vendor_name, product_name,
+                        user_name, extdata)
+            .get_query_string());
+
+    return data_storage::database::get_instance().get_last_insert_id();
+}
+
+void
+data_processor::insert_track(const char* track_name, size_t node_id, size_t process_id,
+                             std::optional<size_t> thread_id, const char* extdata)
+{
+    if(_tracks.find(track_name) != _tracks.end())
+    {
+        ROCPROFSYS_WARNING(2, "Fail to add track %s, already exist!\n", track_name);
+        return;
+    }
+
+    auto name_id = insert_string(track_name);
+
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_track_" + _upid)
+            .set_columns("guid", "nid", "pid", "tid", "name_id", "extdata")
+            .set_values(_upid, node_id, process_id, thread_id, name_id, extdata)
+            .get_query_string());
+
+    auto track_id       = data_storage::database::get_instance().get_last_insert_id();
+    _tracks[track_name] = track_name_map{ track_id, name_id };
+}
+
+void
+data_processor::insert_pmc_description(
+    size_t node_id, size_t process_id, size_t agent_id, const char* target_arch,
+    size_t event_code, size_t instance_id, const char* name, const char* symbol,
+    const char* description, const char* long_description, const char* component,
+    const char* units, const char* value_type, const char* block, const char* expression,
+    uint32_t is_constant, uint32_t is_derived, const char* extdata)
+{
+    auto it = _pmc_descriptor_map.find({ agent_id, name });
+    if(it != _pmc_descriptor_map.end())
+    {
+        ROCPROFSYS_WARNING(
+            0, "Insert PMC description failed! Error: PMC descriptor already exist!\n");
+        return;
+    }
+    data_storage::queries::table_insert_query query_builder;
+
+    auto query =
+        query_builder.set_table_name("rocpd_info_pmc_" + _upid)
+            .set_columns("guid", "nid", "pid", "agent_id", "target_arch", "event_code",
+                         "instance_id", "name", "symbol", "description",
+                         "long_description", "component", "units", "value_type", "block",
+                         "expression", "is_constant", "is_derived", "extdata")
+            .set_values(_upid, node_id, process_id, agent_id, target_arch, event_code,
+                        instance_id, name, symbol, description, long_description,
+                        component, units, value_type, block, expression, is_constant,
+                        is_derived, extdata)
+            .get_query_string();
+    data_storage::database::get_instance().execute_query(query);
+
+    auto pmc_id = data_storage::database::get_instance().get_last_insert_id();
+    _pmc_descriptor_map.emplace(
+        std::pair<pmc_identifier, size_t>{ { agent_id, name }, pmc_id });
+}
+
+void
+data_processor::insert_pmc_event(size_t event_id, size_t agent_id, const char* pmc_name,
+                                 double value, const char* extdata)
+{
+    ROCPROFSYS_VERBOSE(2,
+                       "Insert PMC event: id %ld, agent id: %ld, pmc name: %s, value: "
+                       "%lf, extdata: %s\n",
+                       event_id, agent_id, pmc_name, value, extdata);
+    auto it = _pmc_descriptor_map.find({ agent_id, pmc_name });
+    if(it == _pmc_descriptor_map.end())
+    {
+        ROCPROFSYS_WARNING(0,
+                           "Insert PMC event failed! Error: non-existing PMC description "
+                           "agent id: %ld, pmc name: %s !\n",
+                           agent_id, pmc_name);
+        return;
+    }
+
+    const auto [_, pmc_description_id] = *it;
+    _insert_pmc_event_statement(_upid.c_str(), event_id, pmc_description_id, value,
+                                extdata);
+}
+
+void
+data_processor::insert_sample(const char* track, uint64_t timestamp, size_t event_id,
+                              const char* extdata)
+{
+    ROCPROFSYS_VERBOSE(
+        3, "Insert sample: track: %s, timestamp: %lu, event id: %ld, extdata: %s\n",
+        track, timestamp, event_id, extdata);
+    auto it = _tracks.find(track);
+    if(it == _tracks.end())
+    {
+        ROCPROFSYS_WARNING(0, "Insert sample failed! Error: Unexisting track %s!\n",
+                           track);
+        return;
+    }
+    auto [_, track_info] = *it;
+    _insert_sample_statement(_upid.c_str(), track_info.track_id, timestamp, event_id,
+                             extdata);
+}
+
+size_t
+data_processor::insert_event(size_t category_id, size_t stack_id, size_t parent_stack_id,
+                             size_t correlation_id, const char* call_stack,
+                             const char* line_info, const char* extdata)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    auto                        it = _category_map.find(category_id);
+    if(it == _category_map.end())
+    {
+        std::ostringstream oss;
+        oss << "Insert event failed! Error: Unknown category id: " << category_id
+            << " for UPID: " << _upid;
+        throw std::runtime_error(oss.str());
+    }
+
+    ROCPROFSYS_VERBOSE(3, "Insert event category id: %ld, string id: %ld\n", category_id,
+                       it->second);
+
+    _insert_event_statement(_upid.c_str(), it->second, stack_id, parent_stack_id,
+                            correlation_id, call_stack, line_info, extdata);
+    return data_storage::database::get_instance().get_last_insert_id();
+}
+
+void
+data_processor::initialize_event_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_event_" + _upid)
+                     .set_columns("guid", "category_id", "stack_id", "parent_stack_id",
+                                  "correlation_id", "call_stack", "line_info", "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_event_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, size_t, size_t,
+                                      const char*, const char*, const char*>(query);
+}
+
+void
+data_processor::initialize_pmc_event_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_pmc_event_" + _upid)
+                     .set_columns("guid", "event_id", "pmc_id", "value", "extdata")
+                     .set_values('?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_pmc_event_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, double, const char*>(
+                query);
+}
+
+void
+data_processor::initialize_sample_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_sample_" + _upid)
+                     .set_columns("guid", "track_id", "timestamp", "event_id", "extdata")
+                     .set_values('?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_sample_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, uint64_t, size_t, const char*>(
+                query);
+}
+
+void
+data_processor::initialize_region_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_region_" + _upid)
+                     .set_columns("guid", "nid", "pid", "tid", "start", "end", "name_id",
+                                  "event_id", "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_region_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, size_t, uint64_t,
+                                      uint64_t, size_t, size_t, const char*>(query);
+}
+
+void
+data_processor::initialize_kernel_dispatch_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_kernel_dispatch_" + _upid)
+                     .set_columns("guid", "nid", "pid", "tid", "agent_id", "kernel_id",
+                                  "dispatch_id", "queue_id", "stream_id", "start", "end",
+                                  "private_segment_size", "group_segment_size",
+                                  "workgroup_size_x", "workgroup_size_y",
+                                  "workgroup_size_z", "grid_size_x", "grid_size_y",
+                                  "grid_size_z", "region_name_id", "event_id", "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+                                 '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_kernel_dispatch_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, size_t, size_t, size_t,
+                                      size_t, size_t, size_t, uint64_t, uint64_t, size_t,
+                                      size_t, size_t, size_t, size_t, size_t, size_t,
+                                      size_t, size_t, size_t, const char*>(query);
+}
+
+void
+data_processor::initialize_memory_copy_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_memory_copy_" + _upid)
+                     .set_columns("guid", "nid", "pid", "tid", "start", "end", "name_id",
+                                  "dst_agent_id", "dst_address", "src_agent_id",
+                                  "src_address", "size", "queue_id", "stream_id",
+                                  "region_name_id", "event_id", "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+                                 '?', '?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_memory_copy_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, size_t, uint64_t,
+                                      uint64_t, size_t, size_t, size_t, size_t, size_t,
+                                      size_t, size_t, size_t, size_t, size_t,
+                                      const char*>(query);
+}
+
+void
+data_processor::initialize_kernel_symbol_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto                                      query =
+        query_builder.set_table_name("rocpd_info_kernel_symbol_" + _upid)
+            .set_columns("id", "guid", "nid", "pid", "code_object_id", "kernel_name",
+                         "display_name", "kernel_object", "kernarg_segment_size",
+                         "kernarg_segment_alignment", "group_segment_size",
+                         "private_segment_size", "sgpr_count", "arch_vgpr_count",
+                         "accum_vgpr_count", "extdata")
+            .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+                        '?', '?', '?')
+            .get_query_string();
+    _insert_kernel_symbol_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<size_t, const char*, size_t, size_t, uint64_t,
+                                      const char*, const char*, uint64_t, uint32_t,
+                                      uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
+                                      uint32_t, const char*>(query);
+}
+
+void
+data_processor::initialize_code_object_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto                                      query =
+        query_builder.set_table_name("rocpd_info_code_object_" + _upid)
+            .set_columns("id", "guid", "nid", "pid", "agent_id", "uri", "load_base",
+                         "load_size", "load_delta", "storage_type", "extdata")
+            .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?')
+            .get_query_string();
+    _insert_code_object_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<size_t, const char*, size_t, size_t, size_t,
+                                      const char*, uint64_t, uint64_t, uint64_t,
+                                      const char*, const char*>(query);
+}
+
+void
+data_processor::initialize_args_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_arg_" + _upid)
+                     .set_columns("guid", "event_id", "position", "type", "name", "value",
+                                  "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_args_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, const char*,
+                                      const char*, const char*, const char*>(query);
+}
+
+void
+data_processor::initialize_memory_alloc_stmt()
+{
+    data_storage::queries::table_insert_query query_builder;
+    auto query = query_builder.set_table_name("rocpd_memory_allocate_" + _upid)
+                     .set_columns("guid", "nid", "pid", "tid", "agent_id", "type",
+                                  "level", "start", "end", "address", "size", "queue_id",
+                                  "stream_id", "event_id", "extdata")
+                     .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+                                 '?', '?', '?', '?')
+                     .get_query_string();
+    _insert_memory_alloc_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<
+                const char*, size_t, size_t, size_t, size_t, const char*, const char*,
+                uint64_t, uint64_t, size_t, size_t, size_t, size_t, size_t, const char*>(
+                query);
+
+    // Statement without agent_id
+    query = query_builder.set_table_name("rocpd_memory_allocate_" + _upid)
+                .set_columns("guid", "nid", "pid", "tid", "type", "level", "start", "end",
+                             "address", "size", "queue_id", "stream_id", "event_id",
+                             "extdata")
+                .set_values('?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+                            '?', '?')
+                .get_query_string();
+    _insert_memory_alloc_no_agent_statement =
+        data_storage::database::get_instance()
+            .create_statment_executor<const char*, size_t, size_t, size_t, const char*,
+                                      const char*, uint64_t, uint64_t, size_t, size_t,
+                                      size_t, size_t, size_t, const char*>(query);
+}
+
+void
+data_processor::insert_args(size_t event_id, size_t position, const char* type,
+                            const char* name, const char* value, const char* extdata)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    _insert_args_statement(_upid.c_str(), event_id, position, type, name, value, extdata);
+}
+
+void
+data_processor::insert_stream_info(size_t stream_id, size_t node_id, size_t process_id,
+                                   const char* name, const char* extdata)
+{
+    if(_stream_ids.count(stream_id) > 0)
+    {
+        // ROCPROFSYS_WARNING(
+        //     1, "Insert stream info failed! Error: Stream ID %ld already exists!\n",
+        //     stream_id);
+        return;
+    }
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_stream_" + _upid)
+            .set_columns("id", "guid", "nid", "pid", "name", "extdata")
+            .set_values(stream_id, _upid, node_id, process_id, name, extdata)
+            .get_query_string());
+    _stream_ids.insert(stream_id);
+}
+
+void
+data_processor::insert_queue_info(size_t queue_id, size_t node_id, size_t process_id,
+                                  const char* name, const char* extdata)
+{
+    if(_queue_ids.count(queue_id) > 0)
+    {
+        // ROCPROFSYS_WARNING(
+        //     1, "Insert queue info failed! Error: Queue ID %ld already exists!\n",
+        //     queue_id);
+        return;
+    }
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_queue_" + _upid)
+            .set_columns("id", "guid", "nid", "pid", "name", "extdata")
+            .set_values(queue_id, _upid, node_id, process_id, name, extdata)
+            .get_query_string());
+    _queue_ids.insert(queue_id);
+}
+
+void
+data_processor::insert_code_object(size_t id, size_t node_id, size_t process_id,
+                                   size_t agent_id, const char* uri, uint64_t ld_base,
+                                   uint64_t ld_size, uint64_t ld_delta,
+                                   const char* storage_type, const char* extdata)
+{
+    if(_code_object_ids.count(id) > 0)
+    {
+        // ROCPROFSYS_WARNING(
+        //     1,
+        //     "Insert code object info failed! Error: Code object ID %ld already
+        //     exists!\n", id);
+        return;
+    }
+    ROCPROFSYS_VERBOSE(2, "Insert code object with ID: %ld\n", id);
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    _insert_code_object_statement(id, _upid.c_str(), node_id, process_id, agent_id, uri,
+                                  ld_base, ld_size, ld_delta, storage_type, extdata);
+
+    _code_object_ids.insert(id);
+}
+
+void
+data_processor::insert_kernel_symbol(
+    size_t id, size_t node_id, size_t process_id, uint64_t code_obj_id, const char* name,
+    const char* display_name, uint32_t kernel_obj, uint32_t kernarg_segmnt_size,
+    uint32_t kernarg_segment_alignment, uint32_t group_segment_size,
+    uint32_t private_segment_size, uint32_t sgrp_count, uint32_t arch_vgrp_count,
+    uint32_t accum_vgrp_count, const char* extdata)
+{
+    if(_kernel_sym_ids.count(id) > 0)
+    {
+        // ROCPROFSYS_WARNING(
+        //     1,
+        //     "Insert kernel symbol failed! Error: Kernel symbol ID %ld already
+        //     exists!\n", id);
+        return;
+    }
+
+    ROCPROFSYS_VERBOSE(2, "Insert kernel symbol: %s with ID: %ld\n", name, id);
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    _insert_kernel_symbol_statement(
+        id, _upid.c_str(), node_id, process_id, code_obj_id, name, display_name,
+        kernel_obj, kernarg_segmnt_size, kernarg_segment_alignment, group_segment_size,
+        private_segment_size, sgrp_count, arch_vgrp_count, accum_vgrp_count, extdata);
+
+    _kernel_sym_ids.insert(id);
+}
+
+void
+data_processor::insert_category(size_t category_id, const char* name)
+{
+    auto it = _category_map.find(category_id);
+    if(it != _category_map.end())
+    {
+        // ROCPROFSYS_WARNING(
+        //     1, "Insert category failed! Error: Category %s already exist!\n", name);
+        return;
+    }
+    auto                        name_id = insert_string(name);
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    ROCPROFSYS_VERBOSE(2, "Insert category: name: %s, id: %ld, name id: %ld\n", name,
+                       category_id, name_id);
+    _category_map.emplace(category_id, name_id);
+}
+
+void
+data_processor::insert_region(size_t node_id, size_t process_id, size_t thread_id,
+                              uint64_t start, uint64_t end, size_t name_id,
+                              size_t event_id, const char* extdata)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+    ROCPROFSYS_VERBOSE(2, "Insert region for event id: %ld\n", event_id);
+
+    _insert_region_statement(_upid.c_str(), node_id, process_id, thread_id, start, end,
+                             name_id, event_id, extdata);
+}
+
+void
+data_processor::insert_kernel_dispatch(
+    size_t node_id, size_t process_id, size_t thread_id, size_t agent_id,
+    size_t kernel_id, size_t dispatch_id, size_t queue_id, size_t stream_id,
+    uint64_t start, uint64_t end, size_t private_segment_size, size_t group_segment_size,
+    size_t workgroup_size_x, size_t workgroup_size_y, size_t workgroup_size_z,
+    size_t grid_size_x, size_t grid_size_y, size_t grid_size_z, size_t region_name_id,
+    size_t event_id, const char* extdata)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+
+    ROCPROFSYS_VERBOSE(2, "Insert kernel dispatch for event id: %ld\n", event_id);
+
+    _insert_kernel_dispatch_statement(
+        _upid.c_str(), node_id, process_id, thread_id, agent_id, kernel_id, dispatch_id,
+        queue_id, stream_id, start, end, private_segment_size, group_segment_size,
+        workgroup_size_x, workgroup_size_y, workgroup_size_z, grid_size_x, grid_size_y,
+        grid_size_z, region_name_id, event_id, extdata);
+}
+
+void
+data_processor::insert_memory_copy(size_t node_id, size_t process_id, size_t thread_id,
+                                   uint64_t start, uint64_t end, size_t name_id,
+                                   size_t dst_agent_id, size_t dst_addr,
+                                   size_t src_agent_id, size_t src_addr, size_t size,
+                                   size_t queue_id, size_t stream_id,
+                                   size_t region_name_id, size_t event_id,
+                                   const char* extdata)
+{
+    std::lock_guard<std::mutex> lock(_data_mutex);
+
+    _insert_memory_copy_statement(_upid.c_str(), node_id, process_id, thread_id, start,
+                                  end, name_id, dst_agent_id, dst_addr, src_agent_id,
+                                  src_addr, size, queue_id, stream_id, region_name_id,
+                                  event_id, extdata);
+}
+
+void
+data_processor::insert_memory_alloc(size_t node_id, size_t process_id, size_t thread_id,
+                                    std::optional<size_t> agent_id, const char* type,
+                                    const char* level, uint64_t start, uint64_t end,
+                                    size_t address, size_t size, size_t queue_id,
+                                    size_t stream_id, size_t event_id,
+                                    const char* extdata)
+{
+    if(agent_id.has_value())
+    {
+        _insert_memory_alloc_statement(_upid.c_str(), node_id, process_id, thread_id,
+                                       agent_id.value(), type, level, start, end, address,
+                                       size, queue_id, stream_id, event_id, extdata);
+    }
+    else
+    {
+        _insert_memory_alloc_no_agent_statement(
+            _upid.c_str(), node_id, process_id, thread_id, type, level, start, end,
+            address, size, queue_id, stream_id, event_id, extdata);
+    }
+}
+
+size_t
+data_processor::insert_thread_info(size_t node_id, size_t parent_process_id,
+                                   size_t process_id, size_t thread_id, const char* name,
+                                   uint64_t start, uint64_t end, const char* extdata)
+{
+    auto it = _thread_id_map.find(thread_id);
+
+    if(it != _thread_id_map.end())
+    {
+        return _thread_id_map.at(thread_id);
+    }
+
+    data_storage::queries::table_insert_query query;
+    data_storage::database::get_instance().execute_query(
+        query.set_table_name("rocpd_info_thread_" + _upid)
+            .set_columns("guid", "nid", "ppid", "pid", "tid", "name", "start", "end",
+                         "extdata")
+            .set_values(_upid.c_str(), node_id, parent_process_id, process_id, thread_id,
+                        name, start, end, extdata)
+            .get_query_string());
+
+    auto thread_idx = data_storage::database::get_instance().get_last_insert_id();
+    _thread_id_map.emplace(thread_id, thread_idx);
+    return thread_idx;
+}
+
+void
+data_processor::flush()
+{
+    // Flush all pending data to the database
+    data_storage::database::get_instance().flush();
+}
+
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_processor.hpp b/source/lib/core/rocpd/data_processor.hpp
new file mode 100644
index 0000000000..0e4782dbb8
--- /dev/null
+++ b/source/lib/core/rocpd/data_processor.hpp
@@ -0,0 +1,252 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+struct data_processor
+{
+    using insert_event_stmt =
+        std::function<void(const char*, size_t, size_t, size_t, size_t, const char*,
+                           const char*, const char*)>;
+    using insert_pmc_event_stms =
+        std::function<void(const char*, size_t, size_t, double, const char*)>;
+    using insert_sample_stmt =
+        std::function<void(const char*, size_t, uint64_t, size_t, const char*)>;
+    using insert_region_stmt =
+        std::function<void(const char*, size_t, size_t, size_t, uint64_t, uint64_t,
+                           size_t, size_t, const char*)>;
+    using insert_kernel_dispatch_stmt       = std::function<void(
+        const char*, size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t,
+        uint64_t, uint64_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t,
+        size_t, size_t, size_t, const char*)>;
+    using insert_memory_copy_stmt           = std::function<void(
+        const char*, size_t, size_t, size_t, uint64_t, uint64_t, size_t, size_t, size_t,
+        size_t, size_t, size_t, size_t, size_t, size_t, size_t, const char*)>;
+    using insert_memory_alloc_stmt          = std::function<void(
+        const char*, size_t, size_t, size_t, size_t, const char*, const char*, uint64_t,
+        uint64_t, size_t, size_t, size_t, size_t, size_t, const char*)>;
+    using insert_memory_alloc_no_agent_stmt = std::function<void(
+        const char*, size_t, size_t, size_t, const char*, const char*, uint64_t, uint64_t,
+        size_t, size_t, size_t, size_t, size_t, const char*)>;
+    using insert_kernel_symbol_stmt =
+        std::function<void(size_t, const char*, size_t, size_t, uint64_t, const char*,
+                           const char*, uint64_t, uint32_t, uint32_t, uint32_t, uint32_t,
+                           uint32_t, uint32_t, uint32_t, const char*)>;
+    using insert_code_object_stmt =
+        std::function<void(size_t, const char*, size_t, size_t, size_t, const char*,
+                           uint64_t, uint64_t, uint64_t, const char*, const char*)>;
+    using insert_args_stmt = std::function<void(const char*, size_t, size_t, const char*,
+                                                const char*, const char*, const char*)>;
+
+private:
+    struct track_name_map
+    {
+        size_t track_id;
+        size_t name_id;
+    };
+
+    struct pmc_identifier
+    {
+        size_t      agent_id;
+        std::string name;
+    };
+
+    struct pmc_identifier_hash
+    {
+        std::size_t operator()(const pmc_identifier& pmc) const noexcept
+        {
+            std::size_t h1 = std::hash<size_t>{}(pmc.agent_id);
+            std::size_t h2 = std::hash<std::string>{}(pmc.name);
+            return h1 ^ (h2 << 1);
+        }
+    };
+
+    struct pmc_identifier_equal
+    {
+        bool operator()(const pmc_identifier& lhs,
+                        const pmc_identifier& rhs) const noexcept
+        {
+            return lhs.agent_id == rhs.agent_id && lhs.name == rhs.name;
+        }
+    };
+
+public:
+    static data_processor& get_instance();
+
+    size_t insert_string(const char* str);
+
+    void insert_node_info(size_t node_id, size_t hash, const char* machine_id,
+                          const char* system_name, const char* hostname,
+                          const char* release, const char* version,
+                          const char* hardware_name, const char* domain_name);
+
+    void insert_process_info(size_t node_id, size_t ppid, size_t pid, size_t init,
+                             size_t fini, size_t start, size_t end, const char* command,
+                             const char* environment = "{}", const char* extdata = "{}");
+
+    size_t insert_agent(size_t node_id, size_t pid, const char* agent_type,
+                        size_t absolute_index, size_t logical_index, size_t type_index,
+                        uint64_t uuid, const char* name, const char* model_name,
+                        const char* vendor_name, const char* product_name,
+                        const char* user_name, const char* extdata = "{}");
+
+    void insert_track(const char* track_name, size_t node_id, size_t process_id,
+                      std::optional<size_t> thread_id, const char* extdata = "{}");
+
+    size_t insert_event(size_t category_id, size_t stack_id, size_t parent_stack_id,
+                        size_t correlation_id, const char* call_stack = "{}",
+                        const char* line_info = "{}", const char* extdata = "{}");
+
+    void insert_pmc_event(size_t event_id, size_t agent_id, const char* pmc_descriptor,
+                          double value, const char* extdata = "{}");
+
+    void insert_pmc_description(size_t node_id, size_t process_id, size_t agent_id,
+                                const char* target_arch, size_t event_code,
+                                size_t instance_id, const char* name, const char* symbol,
+                                const char* description, const char* long_description,
+                                const char* component, const char* units,
+                                const char* value_type, const char* block,
+                                const char* expression, uint32_t is_constant,
+                                uint32_t is_derived, const char* extdata = "{}");
+
+    void insert_sample(const char* track, uint64_t timestamp, size_t event_id,
+                       const char* extdata = "{}");
+
+    void insert_category(size_t category_id, const char* name);
+
+    void insert_region(size_t node_id, size_t process_id, size_t thread_id,
+                       uint64_t start, uint64_t end, size_t name_id, size_t event_id,
+                       const char* extdata = "{}");
+
+    size_t insert_thread_info(size_t node_id, size_t parent_process_id, size_t process_id,
+                              size_t thread_id, const char* name, uint64_t start = 0,
+                              uint64_t end = 0, const char* extdata = "{}");
+
+    void insert_stream_info(size_t stream_id, size_t node_id, size_t process_id,
+                            const char* name, const char* extdata = "{}");
+    void insert_queue_info(size_t queue_id, size_t node_id, size_t process_id,
+                           const char* name, const char* extdata = "{}");
+
+    void insert_kernel_dispatch(size_t node_id, size_t process_id, size_t thread_id,
+                                size_t agent_id, size_t kernel_id, size_t dispatch_id,
+                                size_t queue_id, size_t stream_id, uint64_t start,
+                                uint64_t end, size_t private_segment_size,
+                                size_t group_segment_size, size_t workgroup_size_x,
+                                size_t workgroup_size_y, size_t workgroup_size_z,
+                                size_t grid_size_x, size_t grid_size_y,
+                                size_t grid_size_z, size_t region_name_id,
+                                size_t event_id, const char* extdata = "{}");
+
+    void insert_memory_copy(size_t node_id, size_t process_id, size_t thread_id,
+                            uint64_t start, uint64_t end, size_t name_id,
+                            size_t dst_agent_id, size_t dst_addr, size_t src_agent_id,
+                            size_t src_addr, size_t size, size_t queue_id,
+                            size_t stream_id, size_t region_name_id, size_t event_id,
+                            const char* extdata = "{}");
+
+    void insert_kernel_symbol(size_t id, size_t node_id, size_t process_id,
+                              uint64_t code_obj_id, const char* name,
+                              const char* display_name, uint32_t kernel_obj,
+                              uint32_t kernarg_segmnt_size,
+                              uint32_t kernarg_segment_alignment,
+                              uint32_t group_segment_size, uint32_t private_segment_size,
+                              uint32_t sgrp_count, uint32_t arch_vgrp_count,
+                              uint32_t accum_vgrp_count, const char* extdata = "{}");
+
+    void insert_code_object(size_t id, size_t node_id, size_t process_id, size_t agent_id,
+                            const char* uri, uint64_t ld_base, uint64_t ld_size,
+                            uint64_t ld_delta, const char* storage_type,
+                            const char* extdata = "{}");
+
+    void insert_args(size_t event_id, size_t position, const char* type, const char* name,
+                     const char* value, const char* extdata = "{}");
+
+    void insert_memory_alloc(size_t node_id, size_t process_id, size_t thread_id,
+                             std::optional<size_t> agent_id, const char* type,
+                             const char* level, uint64_t start, uint64_t end,
+                             size_t address, size_t size, size_t queue_id,
+                             size_t stream_id, size_t event_id,
+                             const char* extdata = "{}");
+
+    void flush();
+
+private:
+    data_processor();
+    data_processor(data_processor&)                  = delete;
+    data_processor& operator=(const data_processor&) = delete;
+
+    void initialize_pmc_event_stmt();
+    void initialize_event_stmt();
+    void initialize_sample_stmt();
+    void initialize_region_stmt();
+    void initialize_kernel_dispatch_stmt();
+    void initialize_memory_copy_stmt();
+    void initialize_kernel_symbol_stmt();
+    void initialize_code_object_stmt();
+    void initialize_metadata();
+    void initialize_args_stmt();
+    void initialize_memory_alloc_stmt();
+
+private:
+    std::unordered_map<std::string, track_name_map> _tracks;
+    std::unordered_map<pmc_identifier, size_t, pmc_identifier_hash, pmc_identifier_equal>
+                                            _pmc_descriptor_map;
+    std::unordered_map<size_t, size_t>      _thread_id_map;
+    std::unordered_map<size_t, size_t>      _category_map;
+    std::unordered_map<std::string, size_t> _string_map;
+
+    std::set<uint64_t> _code_object_ids;
+    std::set<uint64_t> _kernel_sym_ids;
+    std::set<uint64_t> _stream_ids;
+    std::set<uint64_t> _queue_ids;
+
+    insert_event_stmt                 _insert_event_statement;
+    insert_pmc_event_stms             _insert_pmc_event_statement;
+    insert_sample_stmt                _insert_sample_statement;
+    insert_region_stmt                _insert_region_statement;
+    insert_kernel_dispatch_stmt       _insert_kernel_dispatch_statement;
+    insert_memory_copy_stmt           _insert_memory_copy_statement;
+    insert_kernel_symbol_stmt         _insert_kernel_symbol_statement;
+    insert_code_object_stmt           _insert_code_object_statement;
+    insert_args_stmt                  _insert_args_statement;
+    insert_memory_alloc_stmt          _insert_memory_alloc_statement;
+    insert_memory_alloc_no_agent_stmt _insert_memory_alloc_no_agent_statement;
+
+    std::string _upid{};
+
+    std::mutex _data_mutex;
+};
+
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
new file mode 100644
index 0000000000..e652807797
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -0,0 +1,170 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "database.hpp"
+#include "common/md5sum.hpp"
+#include "debug.hpp"
+#include "node_info.hpp"
+
+#include <config.hpp>
+#include <filesystem>
+#include <fstream>
+#include <regex>
+#include <timemory/environment/types.hpp>
+#include <unistd.h>
+
+namespace fs = std::filesystem;
+namespace
+{
+void
+create_directory_for_database_file(const std::string& db_file)
+{
+    auto _db_dirname = tim::filepath::dirname(db_file);
+    if(!tim::filepath::direxists(_db_dirname))
+    {
+        tim::filepath::makedir(_db_dirname);
+    }
+}
+}  // namespace
+namespace rocprofsys
+{
+namespace rocpd
+{
+namespace data_storage
+{
+database&
+database::get_instance()
+{
+    static database _instance;
+    return _instance;
+}
+
+database::database()
+{
+    auto db_name     = std::string_view{ "rocpd.db" };
+    auto abs_db_path = rocprofsys::get_database_absolute_path(db_name);
+    create_directory_for_database_file(abs_db_path);
+    ROCPROFSYS_VERBOSE(0, "Database: %s\r\n", abs_db_path.c_str());
+
+    validate_sqlite3_result(sqlite3_open(":memory:", &_sqlite3_db_temp), "",
+                            "database open failed!");
+    validate_sqlite3_result(sqlite3_open(abs_db_path.c_str(), &_sqlite3_db), "",
+                            "database open failed!");
+};
+
+database::~database()
+{
+    sqlite3_close(_sqlite3_db_temp);
+    sqlite3_close(_sqlite3_db);
+}
+
+void
+database::initialize_schema()
+{
+    auto get_file_path = [](const std::string_view filename) {
+        auto _rocprofsys_root = tim::get_env<std::string>(
+            "rocprofiler_systems_ROOT", tim::get_env<std::string>("ROCPROFSYS_ROOT", ""));
+        if(!_rocprofsys_root.empty() && fs::exists(std::string(_rocprofsys_root)))
+        {
+            auto new_file_path = std::string(_rocprofsys_root)
+                                     .append("/share/rocprofiler-systems/")
+                                     .append(filename);
+            if(fs::exists(new_file_path))
+            {
+                return new_file_path;
+            }
+        }
+        return std::string(
+                   "rocprofiler-systems/source/lib/core/rocpd/data_storage/schema/")
+            .append(filename);
+    };
+
+    std::vector<std::string_view> schema_files = { "rocpd_tables.sql", "rocpd_views.sql",
+                                                   "data_views.sql", "marker_views.sql",
+                                                   "summary_views.sql" };
+
+    // Process each schema file
+    for(const auto& schema_file : schema_files)
+    {
+        auto          file_path = get_file_path(schema_file);
+        std::ifstream file(file_path);
+        if(!file.is_open())
+        {
+            throw std::runtime_error(
+                std::string("Failed to open schema file ").append(file_path));
+        }
+
+        std::stringstream ss_query;
+        ss_query << file.rdbuf();
+        std::string query = ss_query.str();
+
+        std::regex upid_pattern("\\{\\{uuid\\}\\}");
+        std::regex view_upid_pattern("\\{\\{view_upid\\}\\}");
+
+        query = std::regex_replace(query, upid_pattern, "_" + get_upid());
+        query = std::regex_replace(query, view_upid_pattern, "");
+
+        validate_sqlite3_result(
+            sqlite3_exec(_sqlite3_db_temp, query.c_str(), 0, 0, 0), query.c_str(),
+            std::string("Invalid schema file, init database failed!").append(file_path));
+        file.close();
+    }
+}
+
+void
+database::execute_query(const std::string& query)
+{
+    validate_sqlite3_result(sqlite3_exec(_sqlite3_db_temp, query.c_str(), 0, 0, 0),
+                            "Failed to execute query - ", query);
+}
+
+std::string
+database::get_upid()
+{
+    static std::string _upid = []() {
+        auto n_info = node_info::get_instance();
+        auto guid   = common::md5sum{ n_info.id, getpid(), getppid() };
+        return guid.hexdigest();
+    }();
+    return _upid;
+}
+
+size_t
+database::get_last_insert_id() const
+{
+    return sqlite3_last_insert_rowid(_sqlite3_db_temp);
+}
+
+void
+database::flush()
+{
+    auto* backup = sqlite3_backup_init(_sqlite3_db, "main", _sqlite3_db_temp, "main");
+    if(backup)
+    {
+        sqlite3_backup_step(backup, -1);  // Copy all pages
+        sqlite3_backup_finish(backup);
+    }
+}
+
+}  // namespace data_storage
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/database.hpp b/source/lib/core/rocpd/data_storage/database.hpp
new file mode 100644
index 0000000000..54e18fbe13
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/database.hpp
@@ -0,0 +1,186 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+#include "common/traits.hpp"
+#include <memory>
+#include <mutex>
+#include <sqlite3.h>
+#include <sstream>
+#include <stdexcept>
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+namespace data_storage
+{
+static std::mutex _mutex;
+
+class database
+{
+public:
+    static database& get_instance();
+
+    database(database&)            = delete;
+    database& operator=(database&) = delete;
+
+    void flush();
+
+    ~database();
+
+private:
+    database();
+
+    template <typename... Args>
+    inline void validate_sqlite3_result(int sqlite3_error_code, const char* query,
+                                        Args&&... args)
+    {
+        std::stringstream ss;
+        ss << "\n===========================================================\n";
+        ss << "Database Error\n";
+        ((ss << args << " "), ...);
+        ss << "\nQuery: " << query << "\n";
+        switch(sqlite3_error_code)
+        {
+            case SQLITE_OK:
+            case SQLITE_DONE: return;
+            case SQLITE_CONSTRAINT:
+            {
+                sqlite3_stmt* stmt;
+
+                ss << "Constraint violation(s): " << "\n";
+
+                sqlite3_exec(_sqlite3_db_temp, "PRAGMA foreign_keys = OFF;", nullptr,
+                             nullptr, nullptr);
+                sqlite3_exec(_sqlite3_db_temp, query, nullptr, nullptr, nullptr);
+                sqlite3_exec(_sqlite3_db_temp, "PRAGMA foreign_keys = ON;", nullptr,
+                             nullptr, nullptr);
+                sqlite3_prepare_v2(_sqlite3_db_temp, "PRAGMA foreign_key_check", -1,
+                                   &stmt, nullptr);
+                int rc = 0;
+                while((rc = sqlite3_step(stmt)) == SQLITE_ROW)
+                {
+                    const char* table  = (const char*) sqlite3_column_text(stmt, 0);
+                    int         rowid  = sqlite3_column_int(stmt, 1);
+                    const char* parent = (const char*) sqlite3_column_text(stmt, 2);
+                    int         fkid   = sqlite3_column_int(stmt, 3);
+
+                    ss << "  - " << "FK Violation - Table: " << (table ? table : "NULL")
+                       << ", RowID: " << rowid
+                       << ", Parent: " << (parent ? parent : "NULL") << ", FKID: " << fkid
+                       << "\n";
+                }
+
+                sqlite3_finalize(stmt);
+            }
+            break;
+            default:
+            {
+            }
+            break;
+        }
+        ss << " [Sqlite3 error: " << sqlite3_errstr(sqlite3_error_code);
+        ss << " (Extended error message: " << sqlite3_errmsg(_sqlite3_db_temp) << ")]";
+        throw std::runtime_error(ss.str());
+    }
+
+public:
+    void initialize_schema();
+
+    void execute_query(const std::string& query);
+
+    size_t get_last_insert_id() const;
+
+    /**
+     * This function prepares an SQLite statement based on the provided SQL query and
+     * returns a lambda that can execute the prepared statement, binding the provided
+     * values to the respective placeholders in the query.
+     */
+    template <typename... Values>
+    auto create_statment_executor(const std::string& query)
+    {
+        sqlite3_stmt* p_stmt;
+        validate_sqlite3_result(
+            sqlite3_prepare_v2(_sqlite3_db_temp, query.c_str(), -1, &p_stmt, nullptr),
+            query.c_str(), "Failed to create statement!");
+        std::shared_ptr<sqlite3_stmt> stmt{ p_stmt, sqlite3_finalize };
+
+        return [stmt, query, this](Values... value) {
+            std::lock_guard lock{ _mutex };
+            int             position   = 1;
+            auto            bind_value = [&](auto value) {
+                using T = decltype(value);
+                if constexpr(std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
+                {
+                    validate_sqlite3_result(
+                        sqlite3_bind_int(stmt.get(), position, value), query.c_str(),
+                        "Failed to bind int32_t/uint32_t! Position: ", position,
+                        ", Value: ", value);
+                }
+                else if constexpr(std::is_same_v<T, int64_t> ||
+                                  std::is_same_v<T, uint64_t>)
+                {
+                    validate_sqlite3_result(
+                        sqlite3_bind_int64(stmt.get(), position, value), query.c_str(),
+                        "Failed to bind int64_t/uint64_t! Position: ", position,
+                        ", Value: ", value);
+                }
+                else if constexpr(std::is_floating_point_v<T>)
+                {
+                    validate_sqlite3_result(
+                        sqlite3_bind_double(stmt.get(), position, value), query.c_str(),
+                        "Failed to bind double! Position: ", position,
+                        ", Value: ", value);
+                }
+                else if constexpr(common::traits::is_string_literal_v<std::decay_t<T>>)
+                {
+                    validate_sqlite3_result(
+                        sqlite3_bind_text(stmt.get(), position, value, -1, SQLITE_STATIC),
+                        query.c_str(), "Failed to bind text! Position: ", position,
+                        ", Value: ", value);
+                }
+                else
+                {
+                    throw std::runtime_error("Unsupported type for binding!");
+                }
+                position++;
+            };
+
+            (bind_value(value), ...);
+
+            validate_sqlite3_result(sqlite3_step(stmt.get()), query.c_str(),
+                                    "Failed to execute step!\n", "Values: ", value...);
+            sqlite3_reset(stmt.get());
+        };
+    }
+
+    static std::string get_upid();
+
+private:
+    sqlite3* _sqlite3_db{ nullptr };
+    sqlite3* _sqlite3_db_temp{ nullptr };
+};
+
+}  // namespace data_storage
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp b/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
new file mode 100644
index 0000000000..e8e1f006bd
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
@@ -0,0 +1,126 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include "common/traits.hpp"
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+namespace data_storage
+{
+namespace queries
+{
+
+namespace query_builders
+{
+
+struct query_value_builder
+{
+    query_value_builder(std::stringstream& ss)
+    : _ss{ ss }
+    {}
+
+    template <typename... Values>
+    query_value_builder& set_values(Values&&... values)
+    {
+        auto i = sizeof...(values);
+        _ss << "( ";
+        ((process_value(values) << (i-- > 1 ? ", " : " ")), ...);
+        _ss << ")";
+        return *this;
+    }
+
+    std::string get_query_string() { return _ss.str(); }
+
+private:
+    template <typename T>
+    std::enable_if_t<common::traits::is_string_literal_v<T>, std::stringstream&>
+    process_value(T& value)
+    {
+        _ss << "\"" << value << "\"";
+        return _ss;
+    }
+
+    template <typename T>
+    std::enable_if_t<common::traits::is_optional_v<std::decay_t<T>>, std::stringstream&>
+    process_value(T& value)
+    {
+        if(value.has_value())
+        {
+            _ss << value.value();
+        }
+        else
+        {
+            _ss << "NULL";
+        }
+        return _ss;
+    }
+
+    template <typename T>
+    std::enable_if_t<!common::traits::is_string_literal_v<T> &&
+                         !common::traits::is_optional_v<std::decay_t<T>>,
+                     std::stringstream&>
+    process_value(T& value)
+    {
+        _ss << value;
+        return _ss;
+    }
+
+private:
+    std::stringstream& _ss;
+};
+
+struct query_columns_builder
+{
+    query_columns_builder(std::stringstream& ss)
+    : _ss{ ss }
+    , _query_value_builder{ _ss }
+    {}
+
+    template <typename... Columns,
+              typename = std::enable_if_t<
+                  (common::traits::is_string_literal<Columns>::value && ...)>>
+    query_value_builder& set_columns(Columns&... columns)
+    {
+        auto i = sizeof...(columns);
+        _ss << "( ";
+        ((_ss << columns << (i-- > 1 ? ", " : " ")), ...) << ") VALUES ";
+        return _query_value_builder;
+    }
+
+private:
+    std::stringstream&  _ss;
+    query_value_builder _query_value_builder;
+};
+
+}  // namespace query_builders
+}  // namespace queries
+}  // namespace data_storage
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp b/source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp
new file mode 100644
index 0000000000..a1159b8fc8
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp
@@ -0,0 +1,57 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include "query_builders/insert_query_builders.hpp"
+
+namespace rocprofsys
+{
+namespace rocpd
+{
+namespace data_storage
+{
+namespace queries
+{
+
+struct table_insert_query
+{
+    table_insert_query()
+    : _query_columns_builder{ _ss }
+    {}
+
+    query_builders::query_columns_builder& set_table_name(const std::string& tableName)
+    {
+        _ss.str("");
+        _ss << "INSERT INTO " << tableName << " ";
+        return _query_columns_builder;
+    }
+
+private:
+    std::stringstream                     _ss;
+    query_builders::query_columns_builder _query_columns_builder;
+};
+
+}  // namespace queries
+}  // namespace data_storage
+}  // namespace rocpd
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/schema/data_views.sql b/source/lib/core/rocpd/data_storage/schema/data_views.sql
new file mode 100644
index 0000000000..868542c99f
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/data_views.sql
@@ -0,0 +1,722 @@
+--
+-- Useful views
+--
+-- Code objects
+CREATE VIEW IF NOT EXISTS
+    `code_objects` AS
+SELECT
+    CO.id,
+    CO.guid,
+    CO.nid,
+    P.pid,
+    A.absolute_index AS agent_abs_index,
+    CO.uri,
+    CO.load_base,
+    CO.load_size,
+    CO.load_delta,
+    CO.storage_type AS storage_type_str,
+    JSON_EXTRACT(CO.extdata, '$.size') AS code_object_size,
+    JSON_EXTRACT(CO.extdata, '$.storage_type') AS storage_type,
+    JSON_EXTRACT(CO.extdata, '$.memory_base') AS memory_base,
+    JSON_EXTRACT(CO.extdata, '$.memory_size') AS memory_size
+FROM
+    `rocpd_info_code_object` CO
+    INNER JOIN `rocpd_info_agent` A ON CO.agent_id = A.id
+    AND CO.guid = A.guid
+    INNER JOIN `rocpd_info_process` P ON CO.pid = P.id
+    AND CO.guid = P.guid;
+
+CREATE VIEW IF NOT EXISTS
+    `kernel_symbols` AS
+SELECT
+    KS.id,
+    KS.guid,
+    KS.nid,
+    P.pid,
+    KS.code_object_id,
+    KS.kernel_name,
+    KS.display_name,
+    KS.kernel_object,
+    KS.kernarg_segment_size,
+    KS.kernarg_segment_alignment,
+    KS.group_segment_size,
+    KS.private_segment_size,
+    KS.sgpr_count,
+    KS.arch_vgpr_count,
+    KS.accum_vgpr_count,
+    JSON_EXTRACT(KS.extdata, '$.size') AS kernel_symbol_size,
+    JSON_EXTRACT(KS.extdata, '$.kernel_id') AS kernel_id,
+    JSON_EXTRACT(KS.extdata, '$.kernel_code_entry_byte_offset') AS kernel_code_entry_byte_offset,
+    JSON_EXTRACT(KS.extdata, '$.formatted_kernel_name') AS formatted_kernel_name,
+    JSON_EXTRACT(KS.extdata, '$.demangled_kernel_name') AS demangled_kernel_name,
+    JSON_EXTRACT(KS.extdata, '$.truncated_kernel_name') AS truncated_kernel_name,
+    JSON_EXTRACT(KS.extdata, '$.kernel_address.handle') AS kernel_address
+FROM
+    `rocpd_info_kernel_symbol` KS
+    INNER JOIN `rocpd_info_process` P ON KS.pid = P.id
+    AND KS.guid = P.guid;
+
+-- Processes
+CREATE VIEW IF NOT EXISTS
+    `processes` AS
+SELECT
+    N.id AS nid,
+    N.machine_id,
+    N.system_name,
+    N.hostname,
+    N.release AS system_release,
+    N.version AS system_version,
+    P.guid,
+    P.ppid,
+    P.pid,
+    P.init,
+    P.start,
+    P.end,
+    P.fini,
+    P.command
+FROM
+    `rocpd_info_process` P
+    INNER JOIN `rocpd_info_node` N ON N.id = P.nid
+    AND N.guid = P.guid;
+
+-- Threads
+CREATE VIEW IF NOT EXISTS
+    `threads` AS
+SELECT
+    N.id AS nid,
+    N.machine_id,
+    N.system_name,
+    N.hostname,
+    N.release AS system_release,
+    N.version AS system_version,
+    P.guid,
+    P.ppid,
+    P.pid,
+    T.tid,
+    T.start,
+    T.end,
+    T.name
+FROM
+    `rocpd_info_thread` T
+    INNER JOIN `rocpd_info_process` P ON P.id = T.pid
+    AND N.guid = T.guid
+    INNER JOIN `rocpd_info_node` N ON N.id = T.nid
+    AND N.guid = T.guid;
+
+-- CPU regions
+CREATE VIEW IF NOT EXISTS
+    `regions` AS
+SELECT
+    R.id,
+    R.guid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    S.string AS name,
+    R.nid,
+    P.pid,
+    T.tid,
+    R.start,
+    R.end,
+    (R.end - R.start) AS duration,
+    R.event_id,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id AS corr_id,
+    E.extdata,
+    E.call_stack,
+    E.line_info
+FROM
+    `rocpd_region` R
+    INNER JOIN `rocpd_event` E ON E.id = R.event_id
+    AND E.guid = R.guid
+    INNER JOIN `rocpd_string` S ON S.id = R.name_id
+    AND S.guid = R.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = R.pid
+    AND P.guid = R.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = R.tid
+    AND T.guid = R.guid;
+
+CREATE VIEW IF NOT EXISTS
+    `region_args` AS
+SELECT
+    R.id,
+    R.guid,
+    R.nid,
+    P.pid,
+    A.type,
+    A.name,
+    A.value
+FROM
+    `rocpd_region` R
+    INNER JOIN `rocpd_event` E ON E.id = R.event_id
+    AND E.guid = R.guid
+    INNER JOIN `rocpd_arg` A ON A.event_id = E.id
+    AND A.guid = R.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = R.pid
+    AND P.guid = R.guid;
+
+--
+-- Samples
+CREATE VIEW IF NOT EXISTS
+    `samples` AS
+SELECT
+    R.id,
+    R.guid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = T.name_id
+            AND RS.guid = T.guid
+    ) AS name,
+    T.nid,
+    P.pid,
+    TH.tid,
+    R.timestamp,
+    R.event_id,
+    E.stack_id AS stack_id,
+    E.parent_stack_id AS parent_stack_id,
+    E.correlation_id AS corr_id,
+    E.extdata AS extdata,
+    E.call_stack AS call_stack,
+    E.line_info AS line_info
+FROM
+    `rocpd_sample` R
+    INNER JOIN `rocpd_track` T ON T.id = R.track_id
+    AND T.guid = R.guid
+    INNER JOIN `rocpd_event` E ON E.id = R.event_id
+    AND E.guid = R.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = T.pid
+    AND P.guid = T.guid
+    INNER JOIN `rocpd_info_thread` TH ON TH.id = T.tid
+    AND TH.guid = T.guid;
+
+--
+-- Provides samples view with the same columns as regions view
+CREATE VIEW IF NOT EXISTS
+    `sample_regions` AS
+SELECT
+    R.id,
+    R.guid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = T.name_id
+            AND RS.guid = T.guid
+    ) AS name,
+    T.nid,
+    P.pid,
+    TH.tid,
+    R.timestamp AS start,
+    R.timestamp AS END,
+    (R.timestamp - R.timestamp) AS duration,
+    R.event_id,
+    E.stack_id AS stack_id,
+    E.parent_stack_id AS parent_stack_id,
+    E.correlation_id AS corr_id,
+    E.extdata AS extdata,
+    E.call_stack AS call_stack,
+    E.line_info AS line_info
+FROM
+    `rocpd_sample` R
+    INNER JOIN `rocpd_track` T ON T.id = R.track_id
+    AND T.guid = R.guid
+    INNER JOIN `rocpd_event` E ON E.id = R.event_id
+    AND E.guid = R.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = T.pid
+    AND P.guid = T.guid
+    INNER JOIN `rocpd_info_thread` TH ON TH.id = T.tid
+    AND TH.guid = T.guid;
+
+--
+-- Provides a unified view of the regions and samples
+CREATE VIEW IF NOT EXISTS
+    `regions_and_samples` AS
+SELECT
+    *
+FROM
+    `regions`
+UNION ALL
+SELECT
+    *
+FROM
+    `sample_regions`;
+
+--
+-- Kernel information
+CREATE VIEW
+    `kernels` AS
+SELECT
+    K.id,
+    K.guid,
+    T.tid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    R.string AS region,
+    S.display_name AS name,
+    K.nid,
+    P.pid,
+    A.absolute_index AS agent_abs_index,
+    A.logical_index AS agent_log_index,
+    A.type_index AS agent_type_index,
+    A.type AS agent_type,
+    S.code_object_id AS code_object_id,
+    K.kernel_id,
+    K.dispatch_id,
+    K.stream_id,
+    K.queue_id,
+    Q.name AS queue,
+    ST.name AS stream,
+    K.start,
+    K.end,
+    (K.end - K.start) AS duration,
+    K.grid_size_x AS grid_x,
+    K.grid_size_y AS grid_y,
+    K.grid_size_z AS grid_z,
+    K.workgroup_size_x AS workgroup_x,
+    K.workgroup_size_y AS workgroup_y,
+    K.workgroup_size_z AS workgroup_z,
+    K.group_segment_size AS lds_size,
+    K.private_segment_size AS scratch_size,
+    S.group_segment_size AS static_lds_size,
+    S.private_segment_size AS static_scratch_size,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id AS corr_id
+FROM
+    `rocpd_kernel_dispatch` K
+    INNER JOIN `rocpd_info_agent` A ON A.id = K.agent_id
+    AND A.guid = K.guid
+    INNER JOIN `rocpd_event` E ON E.id = K.event_id
+    AND E.guid = K.guid
+    INNER JOIN `rocpd_string` R ON R.id = K.region_name_id
+    AND R.guid = K.guid
+    INNER JOIN `rocpd_info_kernel_symbol` S ON S.id = K.kernel_id
+    AND S.guid = K.guid
+    LEFT JOIN `rocpd_info_stream` ST ON ST.id = K.stream_id
+    AND ST.guid = K.guid
+    LEFT JOIN `rocpd_info_queue` Q ON Q.id = K.queue_id
+    AND Q.guid = K.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = Q.pid
+    AND P.guid = Q.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = K.tid
+    AND T.guid = K.guid;
+
+--
+-- Performance Monitoring Counters (PMC)
+CREATE VIEW IF NOT EXISTS
+    `pmc_info` AS
+SELECT
+    PMC_I.id,
+    PMC_I.guid,
+    PMC_I.nid,
+    P.pid,
+    A.absolute_index AS agent_abs_index,
+    PMC_I.is_constant,
+    PMC_I.is_derived,
+    PMC_I.name,
+    PMC_I.description,
+    PMC_I.block,
+    PMC_I.expression
+FROM
+    `rocpd_info_pmc` PMC_I
+    INNER JOIN `rocpd_info_agent` A ON PMC_I.agent_id = A.id
+    AND PMC_I.guid = A.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = PMC_I.pid
+    AND PMC_I.guid = P.guid;
+
+CREATE VIEW IF NOT EXISTS
+    `pmc_events` AS
+SELECT
+    PMC_E.id,
+    PMC_E.guid,
+    PMC_E.pmc_id,
+    E.id AS event_id,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    (
+        SELECT
+            display_name
+        FROM
+            `rocpd_info_kernel_symbol` KS
+        WHERE
+            KS.id = K.kernel_id
+            AND KS.guid = K.guid
+    ) AS name,
+    K.nid,
+    P.pid,
+    K.dispatch_id,
+    K.start,
+    K.end,
+    (K.end - K.start) AS duration,
+    PMC_I.name AS counter_name,
+    PMC_E.value AS counter_value
+FROM
+    `rocpd_pmc_event` PMC_E
+    INNER JOIN `rocpd_info_pmc` PMC_I ON PMC_I.id = PMC_E.pmc_id
+    AND PMC_I.guid = PMC_E.guid
+    INNER JOIN `rocpd_event` E ON E.id = PMC_E.event_id
+    AND E.guid = PMC_E.guid
+    INNER JOIN `rocpd_kernel_dispatch` K ON K.event_id = PMC_E.event_id
+    AND K.guid = PMC_E.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = K.pid
+    AND P.guid = K.guid;
+
+-- events with arguments ---
+CREATE VIEW IF NOT EXISTS
+    `events_args` AS
+SELECT
+    E.id AS event_id,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id,
+    A.position AS arg_position,
+    A.type AS arg_type,
+    A.name AS arg_name,
+    A.value AS arg_value,
+    E.call_stack,
+    E.line_info,
+    A.extdata
+FROM
+    `rocpd_event` E
+    INNER JOIN `rocpd_arg` A ON A.event_id = E.id
+    AND A.guid = E.guid;
+
+-- list of astream arguments enriched by the corresponding stream descriptions
+CREATE VIEW IF NOT EXISTS
+    `stream_args` AS
+SELECT
+    A.id AS argument_id,
+    A.event_id AS event_id,
+    A.position AS arg_position,
+    A.type AS arg_type,
+    A.value AS arg_value,
+    JSON_EXTRACT(A.extdata, '$.stream_id') AS stream_id,
+    S.nid,
+    P.pid,
+    S.name AS stream_name,
+    S.extdata AS extdata
+FROM
+    `rocpd_arg` A
+    INNER JOIN `rocpd_info_stream` S ON JSON_EXTRACT(A.extdata, '$.stream_id') = S.id
+    AND A.guid = S.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = S.pid
+    AND P.guid = S.guid
+WHERE
+    A.name = 'stream';
+
+--
+--
+CREATE VIEW IF NOT EXISTS
+    `memory_copies` AS
+SELECT
+    M.id,
+    M.guid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    M.nid,
+    P.pid,
+    T.tid,
+    M.start,
+    M.end,
+    (M.end - M.start) AS duration,
+    S.string AS name,
+    R.string AS region_name,
+    M.stream_id,
+    M.queue_id,
+    ST.name AS stream_name,
+    Q.name AS queue_name,
+    M.size,
+    dst_agent.name AS dst_device,
+    dst_agent.absolute_index AS dst_agent_abs_index,
+    dst_agent.logical_index AS dst_agent_log_index,
+    dst_agent.type_index AS dst_agent_type_index,
+    dst_agent.type AS dst_agent_type,
+    M.dst_address,
+    src_agent.name AS src_device,
+    src_agent.absolute_index AS src_agent_abs_index,
+    src_agent.logical_index AS src_agent_log_index,
+    src_agent.type_index AS src_agent_type_index,
+    src_agent.type AS src_agent_type,
+    M.src_address,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id AS corr_id
+FROM
+    `rocpd_memory_copy` M
+    INNER JOIN `rocpd_string` S ON S.id = M.name_id
+    AND S.guid = M.guid
+    LEFT JOIN `rocpd_string` R ON R.id = M.region_name_id
+    AND R.guid = M.guid
+    INNER JOIN `rocpd_info_agent` dst_agent ON dst_agent.id = M.dst_agent_id
+    AND dst_agent.guid = M.guid
+    INNER JOIN `rocpd_info_agent` src_agent ON src_agent.id = M.src_agent_id
+    AND src_agent.guid = M.guid
+    LEFT JOIN `rocpd_info_queue` Q ON Q.id = M.queue_id
+    AND Q.guid = M.guid
+    LEFT JOIN `rocpd_info_stream` ST ON ST.id = M.stream_id
+    AND ST.guid = M.guid
+    INNER JOIN `rocpd_event` E ON E.id = M.event_id
+    AND E.guid = M.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = M.pid
+    AND P.guid = M.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = M.tid
+    AND T.guid = M.guid;
+
+--
+--
+CREATE VIEW IF NOT EXISTS
+    `memory_allocations` AS
+SELECT
+    M.id,
+    M.guid,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    M.nid,
+    P.pid,
+    T.tid,
+    M.start,
+    M.end,
+    (M.end - M.start) AS duration,
+    M.type,
+    M.level,
+    A.name AS agent_name,
+    A.absolute_index AS agent_abs_index,
+    A.logical_index AS agent_log_index,
+    A.type_index AS agent_type_index,
+    A.type AS agent_type,
+    M.address,
+    M.size,
+    M.queue_id,
+    Q.name AS queue_name,
+    M.stream_id,
+    ST.name AS stream_name,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id AS corr_id
+FROM
+    `rocpd_memory_allocate` M
+    LEFT JOIN `rocpd_info_agent` A ON M.agent_id = A.id
+    AND M.guid = A.guid
+    LEFT JOIN `rocpd_info_queue` Q ON Q.id = M.queue_id
+    AND Q.guid = M.guid
+    LEFT JOIN `rocpd_info_stream` ST ON ST.id = M.stream_id
+    AND ST.guid = M.guid
+    INNER JOIN `rocpd_event` E ON E.id = M.event_id
+    AND E.guid = M.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = M.pid
+    AND P.guid = M.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = M.tid
+    AND P.guid = M.guid;
+
+--
+--
+CREATE VIEW IF NOT EXISTS
+    `scratch_memory` AS
+SELECT
+    M.id,
+    M.guid,
+    M.nid,
+    P.pid,
+    M.type AS operation,
+    A.name AS agent_name,
+    A.absolute_index AS agent_abs_index,
+    A.logical_index AS agent_log_index,
+    A.type_index AS agent_type_index,
+    A.type AS agent_type,
+    M.queue_id,
+    T.tid,
+    JSON_EXTRACT(M.extdata, '$.flags') AS alloc_flags,
+    M.start,
+    M.end,
+    M.size,
+    M.address,
+    E.correlation_id,
+    E.stack_id,
+    E.parent_stack_id,
+    E.correlation_id AS corr_id,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    E.extdata AS event_extdata
+FROM
+    `rocpd_memory_allocate` M
+    LEFT JOIN `rocpd_info_agent` A ON M.agent_id = A.id
+    AND M.guid = A.guid
+    LEFT JOIN `rocpd_info_queue` Q ON Q.id = M.queue_id
+    AND Q.guid = M.guid
+    INNER JOIN `rocpd_event` E ON E.id = M.event_id
+    AND E.guid = M.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = M.pid
+    AND P.guid = M.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = M.tid
+    AND T.guid = M.guid
+WHERE
+    M.level = 'SCRATCH'
+ORDER BY
+    M.start ASC;
+
+--
+--
+CREATE VIEW IF NOT EXISTS
+    `counters_collection` AS
+SELECT
+    MIN(PMC_E.id) AS id,
+    PMC_E.guid,
+    K.dispatch_id,
+    K.kernel_id,
+    E.id AS event_id,
+    E.correlation_id,
+    E.stack_id,
+    E.parent_stack_id,
+    P.pid,
+    T.tid,
+    K.agent_id,
+    A.absolute_index AS agent_abs_index,
+    A.logical_index AS agent_log_index,
+    A.type_index AS agent_type_index,
+    A.type AS agent_type,
+    K.queue_id,
+    k.grid_size_x AS grid_size_x,
+    k.grid_size_y AS grid_size_y,
+    k.grid_size_z AS grid_size_z,
+    (K.grid_size_x * K.grid_size_y * K.grid_size_z) AS grid_size,
+    S.display_name AS kernel_name,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = K.region_name_id
+            AND RS.guid = K.guid
+    ) AS kernel_region,
+    K.workgroup_size_x AS workgroup_size_x,
+    K.workgroup_size_y AS workgroup_size_y,
+    K.workgroup_size_z AS workgroup_size_z,
+    (K.workgroup_size_x * K.workgroup_size_y * K.workgroup_size_z) AS workgroup_size,
+    K.group_segment_size AS lds_block_size,
+    K.private_segment_size AS scratch_size,
+    S.arch_vgpr_count AS vgpr_count,
+    S.accum_vgpr_count,
+    S.sgpr_count,
+    PMC_I.name AS counter_name,
+    PMC_I.symbol AS counter_symbol,
+    PMC_I.component,
+    PMC_I.description,
+    PMC_I.block,
+    PMC_I.expression,
+    PMC_I.value_type,
+    PMC_I.id AS counter_id,
+    SUM(PMC_E.value) AS value,
+    K.start,
+    K.end,
+    PMC_I.is_constant,
+    PMC_I.is_derived,
+    (K.end - K.start) AS duration,
+    (
+        SELECT
+            string
+        FROM
+            `rocpd_string` RS
+        WHERE
+            RS.id = E.category_id
+            AND RS.guid = E.guid
+    ) AS category,
+    K.nid,
+    E.extdata,
+    S.code_object_id
+FROM
+    `rocpd_pmc_event` PMC_E
+    INNER JOIN `rocpd_info_pmc` PMC_I ON PMC_I.id = PMC_E.pmc_id
+    AND PMC_I.guid = PMC_E.guid
+    INNER JOIN `rocpd_event` E ON E.id = PMC_E.event_id
+    AND E.guid = PMC_E.guid
+    INNER JOIN `rocpd_kernel_dispatch` K ON K.event_id = PMC_E.event_id
+    AND K.guid = PMC_E.guid
+    INNER JOIN `rocpd_info_agent` A ON A.id = K.agent_id
+    AND A.guid = K.guid
+    INNER JOIN `rocpd_info_kernel_symbol` S ON S.id = K.kernel_id
+    AND S.guid = K.guid
+    INNER JOIN `rocpd_info_process` P ON P.id = K.pid
+    AND P.guid = K.guid
+    INNER JOIN `rocpd_info_thread` T ON T.id = K.tid
+    AND T.guid = K.guid
+GROUP BY
+    PMC_E.guid,
+    K.dispatch_id,
+    PMC_I.name,
+    K.agent_id;
diff --git a/source/lib/core/rocpd/data_storage/schema/marker_views.sql b/source/lib/core/rocpd/data_storage/schema/marker_views.sql
new file mode 100644
index 0000000000..9cd821a412
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/marker_views.sql
@@ -0,0 +1,3 @@
+--
+-- Views related to markers
+--
diff --git a/source/lib/core/rocpd/data_storage/schema/rocpd_indexes.sql b/source/lib/core/rocpd/data_storage/schema/rocpd_indexes.sql
new file mode 100644
index 0000000000..43d722ea10
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/rocpd_indexes.sql
@@ -0,0 +1,45 @@
+--
+-- Indexes for the various fields
+--
+
+-- string field
+-- CREATE INDEX `rocpd_string{{uuid}}_string_idx` ON `rocpd_string{{uuid}}` ("string");
+
+-- guid field
+-- CREATE INDEX `rocpd_string{{uuid}}_guid_idx` ON `rocpd_string{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_node{{uuid}}_guid_idx` ON `rocpd_info_node{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_process{{uuid}}_guid_idx` ON `rocpd_info_process{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_thread{{uuid}}_guid_idx` ON `rocpd_info_thread{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_agent{{uuid}}_guid_idx` ON `rocpd_info_agent{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_queue{{uuid}}_guid_idx` ON `rocpd_info_queue{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_stream{{uuid}}_guid_idx` ON `rocpd_info_stream{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_pmc{{uuid}}_guid_idx` ON `rocpd_info_pmc{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_code_object{{uuid}}_guid_idx` ON `rocpd_info_code_object{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_info_kernel_symbol{{uuid}}_guid_idx` ON `rocpd_info_kernel_symbol{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_track{{uuid}}_guid_idx` ON `rocpd_track{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_event{{uuid}}_guid_idx` ON `rocpd_event{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_arg{{uuid}}_guid_idx` ON `rocpd_arg{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_pmc_event{{uuid}}_guid_idx` ON `rocpd_pmc_event{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_region{{uuid}}_guid_idx` ON `rocpd_region{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_sample{{uuid}}_guid_idx` ON `rocpd_sample{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_kernel_dispatch{{uuid}}_guid_idx` ON `rocpd_kernel_dispatch{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_memory_copy{{uuid}}_guid_idx` ON `rocpd_memory_copy{{uuid}}` ("id", "guid");
+-- CREATE INDEX `rocpd_memory_allocate{{uuid}}_guid_idx` ON `rocpd_memory_allocate{{uuid}}` ("id", "guid");
+
+-- CREATE INDEX `rocpd_event{{uuid}}_category_idx` ON `rocpd_event{{uuid}}` ("id", "guid", "category_id");
+-- CREATE INDEX `rocpd_region{{uuid}}_event_idx` ON `rocpd_region{{uuid}}` ("id", "guid", "event_id");
+-- CREATE INDEX `rocpd_region{{uuid}}_name_idx` ON `rocpd_region{{uuid}}` ("id", "guid", "name_id");
+-- CREATE INDEX `rocpd_sample{{uuid}}_event_idx` ON `rocpd_sample{{uuid}}` ("id", "guid", "event_id");
+-- CREATE INDEX `rocpd_sample{{uuid}}_track_idx` ON `rocpd_sample{{uuid}}` ("id", "guid", "track_id");
+-- CREATE INDEX `rocpd_track{{uuid}}_name_idx` ON `rocpd_track{{uuid}}` ("id", "guid", "name_id");
+
+-- CREATE INDEX `rocpd_memory_copy{{uuid}}_guid_nid_pid_idx` ON `rocpd_memory_copy{{uuid}}` ("guid", "nid", "pid");
+-- CREATE INDEX `rocpd_kernel_dispatch{{uuid}}_guid_nid_pid_idx` ON `rocpd_kernel_dispatch{{uuid}}` ("guid", "nid", "pid");
+-- CREATE INDEX `rocpd_region{{uuid}}_guid_idx` ON `rocpd_region{{uuid}}` ("guid", "nid", "pid");
+-- CREATE INDEX `rocpd_sample{{uuid}}_guid_nid_pid_idx` ON `rocpd_sample{{uuid}}` ("guid", "nid", "pid");
+
+-- CREATE INDEX `rocpd_region{{uuid}}_guid_idx` ON `rocpd_region{{uuid}}` ("guid");
+-- CREATE INDEX `rocpd_region{{uuid}}_nid_idx` ON `rocpd_region{{uuid}}` ("nid");
+-- CREATE INDEX `rocpd_region{{uuid}}_pid_idx` ON `rocpd_region{{uuid}}` ("pid");
+-- CREATE INDEX `rocpd_region{{uuid}}_start_idx` ON `rocpd_region{{uuid}}` ("start");
+-- CREATE INDEX `rocpd_region{{uuid}}_end_idx` ON `rocpd_region{{uuid}}` ("end");
diff --git a/source/lib/core/rocpd/data_storage/schema/rocpd_tables.sql b/source/lib/core/rocpd/data_storage/schema/rocpd_tables.sql
new file mode 100644
index 0000000000..65f3c63083
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/rocpd_tables.sql
@@ -0,0 +1,373 @@
+-- Enable foreign key support for cascading
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS
+    "rocpd_metadata{{uuid}}" (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "tag" TEXT NOT NULL,
+        "value" TEXT NOT NULL
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_string{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "string" TEXT NOT NULL UNIQUE ON CONFLICT ABORT
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_node{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "hash" BIGINT NOT NULL UNIQUE,
+        "machine_id" TEXT NOT NULL UNIQUE,
+        "system_name" TEXT,
+        "hostname" TEXT,
+        "release" TEXT,
+        "version" TEXT,
+        "hardware_name" TEXT,
+        "domain_name" TEXT
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_process{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "ppid" INTEGER,
+        "pid" INTEGER NOT NULL,
+        "init" BIGINT,
+        "fini" BIGINT,
+        "start" BIGINT,
+        "end" BIGINT,
+        "command" TEXT,
+        "environment" JSONB DEFAULT "{}" NOT NULL,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_thread{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "ppid" INTEGER,
+        "pid" INTEGER NOT NULL,
+        "tid" INTEGER NOT NULL,
+        "name" TEXT,
+        "start" BIGINT,
+        "end" BIGINT,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_agent{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "type" TEXT CHECK ("type" IN ('CPU', 'GPU')),
+        "absolute_index" INTEGER,
+        "logical_index" INTEGER,
+        "type_index" INTEGER,
+        "uuid" INTEGER,
+        "name" TEXT,
+        "model_name" TEXT,
+        "vendor_name" TEXT,
+        "product_name" TEXT,
+        "user_name" TEXT,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_queue{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "name" TEXT,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_stream{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "name" TEXT,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- 2993533, 2269219937, 2993533
+-- 2993533, 2269219937, 2993533
+-- Performance monitoring counters (PMC) descriptions
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_pmc{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "agent_id" INTEGER,
+        "target_arch" TEXT CHECK ("target_arch" IN ('CPU', 'GPU')),
+        "event_code" INT,
+        "instance_id" INTEGER,
+        "name" TEXT NOT NULL,
+        "symbol" TEXT NOT NULL,
+        "description" TEXT,
+        "long_description" TEXT DEFAULT "",
+        "component" TEXT,
+        "units" TEXT DEFAULT "",
+        "value_type" TEXT CHECK ("value_type" IN ('ABS', 'ACCUM', 'RELATIVE')),
+        "block" TEXT,
+        "expression" TEXT,
+        "is_constant" INTEGER,
+        "is_derived" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_code_object{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "agent_id" INTEGER,
+        "uri" TEXT,
+        "load_base" BIGINT,
+        "load_size" BIGINT,
+        "load_delta" BIGINT,
+        "storage_type" TEXT CHECK ("storage_type" IN ('FILE', 'MEMORY')),
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_info_kernel_symbol{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "code_object_id" INTEGER NOT NULL,
+        "kernel_name" TEXT,
+        "display_name" TEXT,
+        "kernel_object" INTEGER,
+        "kernarg_segment_size" INTEGER,
+        "kernarg_segment_alignment" INTEGER,
+        "group_segment_size" INTEGER,
+        "private_segment_size" INTEGER,
+        "sgpr_count" INTEGER,
+        "arch_vgpr_count" INTEGER,
+        "accum_vgpr_count" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (code_object_id) REFERENCES `rocpd_info_code_object{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Stores repetitive info for samples
+CREATE TABLE IF NOT EXISTS
+    `rocpd_track{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER,
+        "tid" INTEGER,
+        "name_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (tid) REFERENCES `rocpd_info_thread{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (name_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Storage for a region, instant, and counter
+CREATE TABLE IF NOT EXISTS
+    `rocpd_event{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "category_id" INTEGER,
+        "stack_id" INTEGER,
+        "parent_stack_id" INTEGER,
+        "correlation_id" INTEGER,
+        "call_stack" JSONB DEFAULT "{}" NOT NULL,
+        "line_info" JSONB DEFAULT "{}" NOT NULL,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (category_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- stores arguments for events
+CREATE TABLE IF NOT EXISTS
+    `rocpd_arg{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "event_id" INTEGER NOT NULL,
+        "position" INTEGER NOT NULL,
+        "type" TEXT NOT NULL,
+        "name" TEXT NOT NULL,
+        "value" TEXT, -- TODO: discuss make it value_id and integer, refer to string table --
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Region with a start/stop on the same thread (CPU)
+CREATE TABLE IF NOT EXISTS
+    `rocpd_pmc_event{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "event_id" INTEGER,
+        "pmc_id" INTEGER NOT NULL,
+        "value" REAL DEFAULT 0.0,
+        "extdata" JSONB DEFAULT "{}",
+        FOREIGN KEY (pmc_id) REFERENCES `rocpd_info_pmc{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Region with a start/stop on the same thread (CPU)
+CREATE TABLE IF NOT EXISTS
+    `rocpd_region{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "tid" INTEGER NOT NULL,
+        "start" BIGINT NOT NULL,
+        "end" BIGINT NOT NULL,
+        "name_id" INTEGER NOT NULL,
+        "event_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (tid) REFERENCES `rocpd_info_thread{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (name_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Instantaneous sample
+CREATE TABLE IF NOT EXISTS
+    `rocpd_sample{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "track_id" INTEGER NOT NULL,
+        "timestamp" BIGINT NOT NULL,
+        "event_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (track_id) REFERENCES `rocpd_track{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_kernel_dispatch{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "tid" INTEGER,
+        "agent_id" INTEGER NOT NULL,
+        "kernel_id" INTEGER NOT NULL,
+        "dispatch_id" INTEGER NOT NULL,
+        "queue_id" INTEGER NOT NULL,
+        "stream_id" INTEGER NOT NULL,
+        "start" BIGINT NOT NULL,
+        "end" BIGINT NOT NULL,
+        "private_segment_size" INTEGER,
+        "group_segment_size" INTEGER,
+        "workgroup_size_x" INTEGER NOT NULL,
+        "workgroup_size_y" INTEGER NOT NULL,
+        "workgroup_size_z" INTEGER NOT NULL,
+        "grid_size_x" INTEGER NOT NULL,
+        "grid_size_y" INTEGER NOT NULL,
+        "grid_size_z" INTEGER NOT NULL,
+        "region_name_id" INTEGER,
+        "event_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (tid) REFERENCES `rocpd_info_thread{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (kernel_id) REFERENCES `rocpd_info_kernel_symbol{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (queue_id) REFERENCES `rocpd_info_queue{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (stream_id) REFERENCES `rocpd_info_stream{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (region_name_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    `rocpd_memory_copy{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "tid" INTEGER,
+        "start" BIGINT NOT NULL,
+        "end" BIGINT NOT NULL,
+        "name_id" INTEGER NOT NULL,
+        "dst_agent_id" INTEGER,
+        "dst_address" INTEGER,
+        "src_agent_id" INTEGER,
+        "src_address" INTEGER,
+        "size" INTEGER NOT NULL,
+        "queue_id" INTEGER,
+        "stream_id" INTEGER,
+        "region_name_id" INTEGER,
+        "event_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (tid) REFERENCES `rocpd_info_thread{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (name_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (dst_agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (src_agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (stream_id) REFERENCES `rocpd_info_stream{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (queue_id) REFERENCES `rocpd_info_queue{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (region_name_id) REFERENCES `rocpd_string{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+-- Memory allocations (real memory, virtual memory, and scratch memory)
+CREATE TABLE IF NOT EXISTS
+    `rocpd_memory_allocate{{uuid}}` (
+        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        "guid" TEXT DEFAULT "{{guid}}" NOT NULL,
+        "nid" INTEGER NOT NULL,
+        "pid" INTEGER NOT NULL,
+        "tid" INTEGER,
+        "agent_id" INTEGER,
+        "type" TEXT CHECK ("type" IN ('ALLOC', 'FREE', 'REALLOC', 'RECLAIM')),
+        "level" TEXT CHECK ("level" IN ('REAL', 'VIRTUAL', 'SCRATCH')),
+        "start" BIGINT NOT NULL,
+        "end" BIGINT NOT NULL,
+        "address" INTEGER,
+        "size" INTEGER NOT NULL,
+        "queue_id" INTEGER,
+        "stream_id" INTEGER,
+        "event_id" INTEGER,
+        "extdata" JSONB DEFAULT "{}" NOT NULL,
+        FOREIGN KEY (nid) REFERENCES `rocpd_info_node{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (pid) REFERENCES `rocpd_info_process{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (tid) REFERENCES `rocpd_info_thread{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (agent_id) REFERENCES `rocpd_info_agent{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (stream_id) REFERENCES `rocpd_info_stream{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (queue_id) REFERENCES `rocpd_info_queue{{uuid}}` (id) ON UPDATE CASCADE,
+        FOREIGN KEY (event_id) REFERENCES `rocpd_event{{uuid}}` (id) ON UPDATE CASCADE
+    );
+
+INSERT INTO
+    `rocpd_metadata{{uuid}}` ("tag", "value")
+VALUES
+    ("schema_version", "3"),
+    ("uuid", "{{uuid}}"),
+    ("guid", "{{guid}}");
diff --git a/source/lib/core/rocpd/data_storage/schema/rocpd_views.sql b/source/lib/core/rocpd/data_storage/schema/rocpd_views.sql
new file mode 100644
index 0000000000..8eaed1125d
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/rocpd_views.sql
@@ -0,0 +1,139 @@
+CREATE VIEW IF NOT EXISTS
+    `rocpd_metadata` AS
+SELECT
+    *
+FROM
+    `rocpd_metadata{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_string` AS
+SELECT
+    *
+FROM
+    `rocpd_string{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_node` AS
+SELECT
+    *
+FROM
+    `rocpd_info_node{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_process` AS
+SELECT
+    *
+FROM
+    `rocpd_info_process{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_thread` AS
+SELECT
+    *
+FROM
+    `rocpd_info_thread{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_agent` AS
+SELECT
+    *
+FROM
+    `rocpd_info_agent{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_queue` AS
+SELECT
+    *
+FROM
+    `rocpd_info_queue{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_stream` AS
+SELECT
+    *
+FROM
+    `rocpd_info_stream{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_pmc` AS
+SELECT
+    *
+FROM
+    `rocpd_info_pmc{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_code_object` AS
+SELECT
+    *
+FROM
+    `rocpd_info_code_object{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_info_kernel_symbol` AS
+SELECT
+    *
+FROM
+    `rocpd_info_kernel_symbol{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_track` AS
+SELECT
+    *
+FROM
+    `rocpd_track{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_event` AS
+SELECT
+    *
+FROM
+    `rocpd_event{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_arg` AS
+SELECT
+    *
+FROM
+    `rocpd_arg{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_pmc_event` AS
+SELECT
+    *
+FROM
+    `rocpd_pmc_event{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_region` AS
+SELECT
+    *
+FROM
+    `rocpd_region{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_sample` AS
+SELECT
+    *
+FROM
+    `rocpd_sample{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_kernel_dispatch` AS
+SELECT
+    *
+FROM
+    `rocpd_kernel_dispatch{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_memory_copy` AS
+SELECT
+    *
+FROM
+    `rocpd_memory_copy{{uuid}}`;
+
+CREATE VIEW IF NOT EXISTS
+    `rocpd_memory_allocate` AS
+SELECT
+    *
+FROM
+    `rocpd_memory_allocate{{uuid}}`;
diff --git a/source/lib/core/rocpd/data_storage/schema/summary_views.sql b/source/lib/core/rocpd/data_storage/schema/summary_views.sql
new file mode 100644
index 0000000000..3575bf6f55
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/schema/summary_views.sql
@@ -0,0 +1,376 @@
+--
+-- Useful summary views
+--
+--
+-- Sorted list of kernels which consume the most overall time
+CREATE VIEW IF NOT EXISTS
+    `top_kernels` AS
+SELECT
+    S.display_name AS name,
+    COUNT(K.kernel_id) AS total_calls,
+    SUM(K.end - K.start) / 1000.0 AS total_duration,
+    (SUM(K.end - K.start) / COUNT(K.kernel_id)) / 1000.0 AS average,
+    SUM(K.end - K.start) * 100.0 / (
+        SELECT
+            SUM(A.end - A.start)
+        FROM
+            `rocpd_kernel_dispatch` A
+    ) AS percentage
+FROM
+    `rocpd_kernel_dispatch` K
+    INNER JOIN `rocpd_info_kernel_symbol` S ON S.id = K.kernel_id
+    AND S.guid = K.guid
+GROUP BY
+    name
+ORDER BY
+    total_duration DESC;
+
+--
+-- GPU utilization metrics including kernels and memory copy operations
+CREATE VIEW IF NOT EXISTS
+    `busy` AS
+SELECT
+    A.agent_id,
+    AG.type,
+    GpuTime,
+    WallTime,
+    GpuTime * 1.0 / WallTime AS Busy
+FROM
+    (
+        SELECT
+            agent_id,
+            guid,
+            SUM(END - start) AS GpuTime
+        FROM
+            (
+                SELECT
+                    agent_id,
+                    guid,
+                    END,
+                    start
+                FROM
+                    `rocpd_kernel_dispatch`
+                UNION ALL
+                SELECT
+                    dst_agent_id AS agent_id,
+                    guid,
+                    END,
+                    start
+                FROM
+                    `rocpd_memory_copy`
+            )
+        GROUP BY
+            agent_id,
+            guid
+    ) A
+    INNER JOIN (
+        SELECT
+            MAX(END) - MIN(start) AS WallTime
+        FROM
+            (
+                SELECT
+                    END,
+                    start
+                FROM
+                    `rocpd_kernel_dispatch`
+                UNION ALL
+                SELECT
+                    END,
+                    start
+                FROM
+                    `rocpd_memory_copy`
+            )
+    ) W ON 1 = 1
+    INNER JOIN `rocpd_info_agent` AG ON AG.id = A.agent_id
+    AND AG.guid = A.guid;
+
+--
+-- Overall performance summary including kernels and memory copy operations
+CREATE VIEW
+    `top` AS
+SELECT
+    name,
+    COUNT(*) AS total_calls,
+    SUM(duration) / 1000.0 AS total_duration,
+    (SUM(duration) / COUNT(*)) / 1000.0 AS average,
+    SUM(duration) * 100.0 / total_time AS percentage
+FROM
+    (
+        -- Kernel operations
+        SELECT
+            ks.display_name AS name,
+            (kd.end - kd.start) AS duration
+        FROM
+            `rocpd_kernel_dispatch` kd
+            INNER JOIN `rocpd_info_kernel_symbol` ks ON kd.kernel_id = ks.id
+            AND kd.guid = ks.guid
+        UNION ALL
+        -- Memory operations
+        SELECT
+            rs.string AS name,
+            (END - start) AS duration
+        FROM
+            `rocpd_memory_copy` mc
+            INNER JOIN `rocpd_string` rs ON rs.id = mc.name_id
+            AND rs.guid = mc.guid
+        UNION ALL
+        -- Regions
+        SELECT
+            rs.string AS name,
+            (END - start) AS duration
+        FROM
+            `rocpd_region` rr
+            INNER JOIN `rocpd_string` rs ON rs.id = rr.name_id
+            AND rs.guid = rr.guid
+    ) operations
+    CROSS JOIN (
+        SELECT
+            SUM(END - start) AS total_time
+        FROM
+            (
+                SELECT
+                    END,
+                    start
+                FROM
+                    `rocpd_kernel_dispatch`
+                UNION ALL
+                SELECT
+                    END,
+                    start
+                FROM
+                    `rocpd_memory_copy`
+                UNION ALL
+                SELECT
+                    END,
+                    start
+                FROM
+                    `rocpd_region`
+            )
+    ) TOTAL
+GROUP BY
+    name
+ORDER BY
+    total_duration DESC;
+
+-- Kernel summary by name
+CREATE VIEW
+    `kernel_summary` AS
+WITH
+    avg_data AS (
+        SELECT
+            name,
+            AVG(duration) AS avg_duration
+        FROM
+            `kernels`
+        GROUP BY
+            name
+    ),
+    aggregated_data AS (
+        SELECT
+            K.name,
+            COUNT(*) AS calls,
+            SUM(K.duration) AS total_duration,
+            SUM(CAST(K.duration AS REAL) * CAST(K.duration AS REAL)) AS sqr_duration,
+            A.avg_duration AS average_duration,
+            MIN(K.duration) AS min_duration,
+            MAX(K.duration) AS max_duration,
+            SUM(CAST((K.duration - A.avg_duration) AS REAL) * CAST((K.duration - A.avg_duration) AS REAL)) / (COUNT(*) - 1) AS variance_duration,
+            SQRT(
+                SUM(CAST((K.duration - A.avg_duration) AS REAL) * CAST((K.duration - A.avg_duration) AS REAL)) / (COUNT(*) - 1)
+            ) AS std_dev_duration
+        FROM
+            `kernels` K
+            JOIN avg_data A ON K.name = A.name
+        GROUP BY
+            K.name
+    ),
+    total_duration AS (
+        SELECT
+            SUM(total_duration) AS grand_total_duration
+        FROM
+            aggregated_data
+    )
+SELECT
+    AD.name AS name,
+    AD.calls,
+    AD.total_duration AS "DURATION (nsec)",
+    AD.sqr_duration AS "SQR (nsec)",
+    AD.average_duration AS "AVERAGE (nsec)",
+    (CAST(AD.total_duration AS REAL) / TD.grand_total_duration) * 100 AS "PERCENT (INC)",
+    AD.min_duration AS "MIN (nsec)",
+    AD.max_duration AS "MAX (nsec)",
+    AD.variance_duration AS "VARIANCE",
+    AD.std_dev_duration AS "STD_DEV"
+FROM
+    aggregated_data AD
+    CROSS JOIN total_duration TD;
+
+--
+-- Kernel summary by region name
+CREATE VIEW
+    `kernel_summary_region` AS
+WITH
+    avg_data AS (
+        SELECT
+            region,
+            AVG(duration) AS avg_duration
+        FROM
+            `kernels`
+        GROUP BY
+            region
+    ),
+    aggregated_data AS (
+        SELECT
+            K.region AS name,
+            COUNT(*) AS calls,
+            SUM(K.duration) AS total_duration,
+            SUM(CAST(K.duration AS REAL) * CAST(K.duration AS REAL)) AS sqr_duration,
+            A.avg_duration AS average_duration,
+            MIN(K.duration) AS min_duration,
+            MAX(K.duration) AS max_duration,
+            SUM(CAST((K.duration - A.avg_duration) AS REAL) * CAST((K.duration - A.avg_duration) AS REAL)) / (COUNT(*) - 1) AS variance_duration,
+            SQRT(
+                SUM(CAST((K.duration - A.avg_duration) AS REAL) * CAST((K.duration - A.avg_duration) AS REAL)) / (COUNT(*) - 1)
+            ) AS std_dev_duration
+        FROM
+            `kernels` K
+            JOIN avg_data A ON K.region = A.region
+        GROUP BY
+            K.region
+    ),
+    total_duration AS (
+        SELECT
+            SUM(total_duration) AS grand_total_duration
+        FROM
+            aggregated_data
+    )
+SELECT
+    AD.name AS name,
+    AD.calls,
+    AD.total_duration AS "DURATION (nsec)",
+    AD.sqr_duration AS "SQR (nsec)",
+    AD.average_duration AS "AVERAGE (nsec)",
+    (CAST(AD.total_duration AS REAL) / TD.grand_total_duration) * 100 AS "PERCENT (INC)",
+    AD.min_duration AS "MIN (nsec)",
+    AD.max_duration AS "MAX (nsec)",
+    AD.variance_duration AS "VARIANCE",
+    AD.std_dev_duration AS "STD_DEV"
+FROM
+    aggregated_data AD
+    CROSS JOIN total_duration TD;
+
+--
+-- Memory copy summary
+CREATE VIEW
+    `memory_copy_summary` AS
+WITH
+    avg_data AS (
+        SELECT
+            name,
+            AVG(duration) AS avg_duration
+        FROM
+            `memory_copies`
+        GROUP BY
+            name
+    ),
+    aggregated_data AS (
+        SELECT
+            MC.name,
+            COUNT(*) AS calls,
+            SUM(MC.duration) AS total_duration,
+            SUM(CAST(MC.duration AS REAL) * CAST(MC.duration AS REAL)) AS sqr_duration,
+            A.avg_duration AS average_duration,
+            MIN(MC.duration) AS min_duration,
+            MAX(MC.duration) AS max_duration,
+            SUM(
+                CAST((MC.duration - A.avg_duration) AS REAL) * CAST((MC.duration - A.avg_duration) AS REAL)
+            ) / (COUNT(*) - 1) AS variance_duration,
+            SQRT(
+                SUM(
+                    CAST((MC.duration - A.avg_duration) AS REAL) * CAST((MC.duration - A.avg_duration) AS REAL)
+                ) / (COUNT(*) - 1)
+            ) AS std_dev_duration
+        FROM
+            `memory_copies` MC
+            JOIN avg_data A ON MC.name = A.name
+        GROUP BY
+            MC.name
+    ),
+    total_duration AS (
+        SELECT
+            SUM(total_duration) AS grand_total_duration
+        FROM
+            aggregated_data
+    )
+SELECT
+    AD.name AS name,
+    AD.calls,
+    AD.total_duration AS "DURATION (nsec)",
+    AD.sqr_duration AS "SQR (nsec)",
+    AD.average_duration AS "AVERAGE (nsec)",
+    (CAST(AD.total_duration AS REAL) / TD.grand_total_duration) * 100 AS "PERCENT (INC)",
+    AD.min_duration AS "MIN (nsec)",
+    AD.max_duration AS "MAX (nsec)",
+    AD.variance_duration AS "VARIANCE",
+    AD.std_dev_duration AS "STD_DEV"
+FROM
+    aggregated_data AD
+    CROSS JOIN total_duration TD;
+
+--
+-- Memory allocation summary
+CREATE VIEW
+    `memory_allocation_summary` AS
+WITH
+    avg_data AS (
+        SELECT
+            type AS name,
+            AVG(duration) AS avg_duration
+        FROM
+            `memory_allocations`
+        GROUP BY
+            type
+    ),
+    aggregated_data AS (
+        SELECT
+            MA.type AS name,
+            COUNT(*) AS calls,
+            SUM(MA.duration) AS total_duration,
+            SUM(CAST(MA.duration AS REAL) * CAST(MA.duration AS REAL)) AS sqr_duration,
+            A.avg_duration AS average_duration,
+            MIN(MA.duration) AS min_duration,
+            MAX(MA.duration) AS max_duration,
+            SUM(
+                CAST((MA.duration - A.avg_duration) AS REAL) * CAST((MA.duration - A.avg_duration) AS REAL)
+            ) / (COUNT(*) - 1) AS variance_duration,
+            SQRT(
+                SUM(
+                    CAST((MA.duration - A.avg_duration) AS REAL) * CAST((MA.duration - A.avg_duration) AS REAL)
+                ) / (COUNT(*) - 1)
+            ) AS std_dev_duration
+        FROM
+            `memory_allocations` MA
+            JOIN avg_data A ON MA.type = A.name
+        GROUP BY
+            MA.type
+    ),
+    total_duration AS (
+        SELECT
+            SUM(total_duration) AS grand_total_duration
+        FROM
+            aggregated_data
+    )
+SELECT
+    'MEMORY_ALLOCATION_' || AD.name AS name,
+    AD.calls,
+    AD.total_duration AS "DURATION (nsec)",
+    AD.sqr_duration AS "SQR (nsec)",
+    AD.average_duration AS "AVERAGE (nsec)",
+    (CAST(AD.total_duration AS REAL) / TD.grand_total_duration) * 100 AS "PERCENT (INC)",
+    AD.min_duration AS "MIN (nsec)",
+    AD.max_duration AS "MAX (nsec)",
+    AD.variance_duration AS "VARIANCE",
+    AD.std_dev_duration AS "STD_DEV"
+FROM
+    aggregated_data AD
+    CROSS JOIN total_duration TD;
diff --git a/source/lib/core/rocpd/json.cpp b/source/lib/core/rocpd/json.cpp
new file mode 100644
index 0000000000..aa7a81bb3c
--- /dev/null
+++ b/source/lib/core/rocpd/json.cpp
@@ -0,0 +1,99 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "json.hpp"
+#include <sstream>
+
+namespace rocpd
+{
+
+std::shared_ptr<json>
+json::create()
+{
+    return std::shared_ptr<json>(new json());
+}
+
+void
+json::set(const std::string& key, const json_value& value)
+{
+    data[key] = std::make_shared<json_value>(value);
+}
+
+std::string
+json::to_string() const
+{
+    std::ostringstream oss;
+    oss << "{";
+    bool first = true;
+
+    for(const auto& [key, value] : data)
+    {
+        if(!first) oss << ", ";
+        first = false;
+
+        oss << "\"" << key << "\": " << stringify(value);
+    }
+
+    oss << "}";
+    return oss.str();
+}
+
+std::string
+json::stringify(const std::shared_ptr<json_value>& value)
+{
+    std::ostringstream oss;
+    std::visit(
+        [&oss](auto&& arg) {
+            using T = std::decay_t<decltype(arg)>;
+            if constexpr(std::is_same_v<T, std::string>)
+                oss << "\"" << arg << "\"";
+            else if constexpr(std::is_same_v<T, bool>)
+                oss << (arg ? "true" : "false");
+            else if constexpr(std::is_same_v<T, std::nullptr_t>)
+                oss << "null";
+            else if constexpr(std::is_same_v<T, std::vector<json>>)
+            {
+                oss << "[";
+                bool first = true;
+                for(const auto& item : arg)
+                {
+                    if(!first) oss << ", ";
+                    first = false;
+                    oss << item.to_string();
+                }
+                oss << "]";
+            }
+            else if constexpr(std::is_same_v<T, std::shared_ptr<json>>)
+            {
+                oss << arg->to_string();
+            }
+            else
+            {
+                // handle int + double
+                oss << arg;
+            }
+        },
+        *value);
+    return oss.str();
+}
+
+}  // namespace rocpd
diff --git a/source/lib/core/rocpd/json.hpp b/source/lib/core/rocpd/json.hpp
new file mode 100644
index 0000000000..d47eaf4bb0
--- /dev/null
+++ b/source/lib/core/rocpd/json.hpp
@@ -0,0 +1,57 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace rocpd
+{
+
+class json
+{
+public:
+    static std::shared_ptr<json> create();
+
+    using json_value =
+        std::variant<std::string, int, double, long long, bool, std::vector<json>,
+                     std::nullptr_t, std::shared_ptr<json>>;
+
+    void set(const std::string& key, const json_value& value);
+
+    std::string to_string() const;
+
+private:
+    json() = default;
+
+private:
+    static std::string stringify(const std::shared_ptr<json_value>& value);
+
+private:
+    std::unordered_map<std::string, std::shared_ptr<json_value>> data;
+};
+
+}  // namespace rocpd
diff --git a/source/lib/rocprof-sys/library.cpp b/source/lib/rocprof-sys/library.cpp
index ca6e4f6927..527c25f06d 100644
--- a/source/lib/rocprof-sys/library.cpp
+++ b/source/lib/rocprof-sys/library.cpp
@@ -27,6 +27,7 @@
 #include "api.hpp"
 #include "common/setup.hpp"
 #include "common/static_object.hpp"
+#include "core/agent_manager.hpp"
 #include "core/categories.hpp"
 #include "core/components/fwd.hpp"
 #include "core/concepts.hpp"
@@ -37,7 +38,9 @@
 #include "core/dynamic_library.hpp"
 #include "core/gpu.hpp"
 #include "core/locking.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto_fwd.hpp"
+#include "core/rocpd/data_processor.hpp"
 #include "core/timemory.hpp"
 #include "core/utility.hpp"
 #include "library/causal/data.hpp"
@@ -77,6 +80,8 @@
 #include <timemory/utility/join.hpp>
 #include <timemory/utility/procfs/maps.hpp>
 
+#include <rocprofiler-sdk/agent.h>
+
 #include <atomic>
 #include <chrono>
 #include <csignal>
@@ -86,6 +91,7 @@
 #include <pthread.h>
 #include <stdexcept>
 #include <string_view>
+#include <unistd.h>
 #include <utility>
 
 using namespace rocprofsys;
@@ -297,6 +303,60 @@ namespace
 bool                  _set_mpi_called   = false;
 std::function<void()> _preinit_callback = []() { get_preinit_bundle()->start(); };
 
+std::vector<std::string>
+read_command_line(pid_t _pid)
+{
+    auto _cmdline = std::vector<std::string>{};
+    auto fcmdline = std::stringstream{};
+    fcmdline << "/proc/" << _pid << "/cmdline";
+    auto ifs = std::ifstream{ fcmdline.str().c_str() };
+    if(ifs)
+    {
+        std::string sarg;
+        while(std::getline(ifs, sarg, '\0'))
+        {
+            _cmdline.push_back(sarg);
+        }
+        ifs.close();
+    }
+
+    return _cmdline;
+}
+
+void
+rocprofsys_preinit_rocpd()
+{
+    auto&       data_processor = rocpd::data_processor::get_instance();
+    const auto& n_info         = node_info::get_instance();
+    auto        cmd_line       = read_command_line(getpid());
+    auto&       agent_mngr     = rocpd::agent_manager::get_instance();
+
+    if(cmd_line.empty())
+    {
+        cmd_line.emplace_back("rocprofiler-systems");
+    }
+
+    data_processor.insert_node_info(n_info.id, n_info.hash, n_info.machine_id.c_str(),
+                                    n_info.system_name.c_str(), n_info.node_name.c_str(),
+                                    n_info.release.c_str(), n_info.version.c_str(),
+                                    n_info.machine.c_str(), n_info.domain_name.c_str());
+    data_processor.insert_process_info(n_info.id, getppid(), getpid(), 0, 0, 0, 0,
+                                       cmd_line[0].c_str(), "{}");
+
+    const auto& agents = agent_mngr.get_agents();
+    for(const auto& rocpd_agent : agents)
+    {
+        auto _base_id = rocpd::data_processor::get_instance().insert_agent(
+            n_info.id, getpid(),
+            ((rocpd_agent->agent->type == ROCPROFILER_AGENT_TYPE_GPU) ? "GPU" : "CPU"),
+            rocpd_agent->agent->node_id, rocpd_agent->agent->logical_node_id,
+            rocpd_agent->agent->logical_node_type_id, rocpd_agent->agent->device_id,
+            rocpd_agent->agent->name, rocpd_agent->agent->model_name,
+            rocpd_agent->agent->vendor_name, rocpd_agent->agent->product_name, "");
+        rocpd_agent->base_id = _base_id;
+    }
+}
+
 void
 rocprofsys_preinit_hidden()
 {
@@ -423,17 +483,17 @@ rocprofsys_init_tooling_hidden(void)
                                                  { ROCPROFSYS_DEFAULT_ROCM_PATH }) };
 #endif
 
-    static bool _once       = false;
-    static auto _debug_init = get_debug_init();
+    static pid_t _once       = 0;
+    static auto  _debug_init = get_debug_init();
 
     ROCPROFSYS_CONDITIONAL_BASIC_PRINT_F(_debug_init, "State is %s...\n",
                                          std::to_string(get_state()).c_str());
 
-    if(get_state() != State::PreInit || get_state() == State::Init || _once)
+    if(get_state() != State::PreInit || get_state() == State::Init || _once == getpid())
     {
         return false;
     }
-    _once = true;
+    _once = getpid();
 
     ROCPROFSYS_SCOPED_THREAD_STATE(ThreadState::Internal);
 
@@ -460,6 +520,8 @@ rocprofsys_init_tooling_hidden(void)
     auto _dtor = scope::destructor{ []() {
         // if set to finalized, don't continue
         if(get_state() > State::Active) return;
+        if(get_use_rocpd()) rocprofsys_preinit_rocpd();
+
         if(get_use_process_sampling())
         {
             ROCPROFSYS_SCOPED_SAMPLING_ON_CHILD_THREADS(false);
@@ -681,7 +743,6 @@ rocprofsys_finalize_hidden(void)
     threading::remove_callback(&ensure_initialization);
 
     bool _is_child = is_child_process();
-
     set_thread_state(ThreadState::Completed);
 
     // return if not active
@@ -693,6 +754,18 @@ rocprofsys_finalize_hidden(void)
     }
     else if(_is_child)
     {
+#if defined(ROCPROFSYS_USE_ROCM) && ROCPROFSYS_USE_ROCM > 0
+        // Flush buffered traces in case of child process
+        if(get_use_rocm())
+        {
+            ROCPROFSYS_VERBOSE_F(1, "Shutting down ROCm...\n");
+            rocprofiler_sdk::shutdown();
+        }
+#endif
+        if(get_use_rocpd())
+        {
+            rocpd::data_processor::get_instance().flush();
+        }
         set_state(State::Finalized);
         std::quick_exit(EXIT_SUCCESS);
         return;
@@ -983,6 +1056,10 @@ rocprofsys_finalize_hidden(void)
         [](int) {});
 
     common::destroy_static_objects();
+    if(get_use_rocpd())
+    {
+        rocpd::data_processor::get_instance().flush();
+    }
 }
 
 //======================================================================================//
diff --git a/source/lib/rocprof-sys/library/amd_smi.cpp b/source/lib/rocprof-sys/library/amd_smi.cpp
index c699c84830..9e1085d27a 100644
--- a/source/lib/rocprof-sys/library/amd_smi.cpp
+++ b/source/lib/rocprof-sys/library/amd_smi.cpp
@@ -31,12 +31,15 @@
 #endif
 
 #include "library/amd_smi.hpp"
+#include "core/agent_manager.hpp"
 #include "core/common.hpp"
 #include "core/components/fwd.hpp"
 #include "core/config.hpp"
 #include "core/debug.hpp"
 #include "core/gpu.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto.hpp"
+#include "core/rocpd/data_processor.hpp"
 #include "core/state.hpp"
 #include "library/runtime.hpp"
 #include "library/thread_info.hpp"
@@ -49,13 +52,11 @@
 #include <timemory/utility/locking.hpp>
 
 #include <cassert>
-#include <chrono>
-#include <ios>
+#include <optional>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <sys/resource.h>
-#include <thread>
 
 #define ROCPROFSYS_AMD_SMI_CALL(...)                                                     \
     ::rocprofsys::amd_smi::check_error(__FILE__, __LINE__, __VA_ARGS__)
@@ -69,6 +70,116 @@ using sampler_instances = thread_data<bundle_t, category::amd_smi>;
 
 namespace
 {
+int64_t
+get_tid()
+{
+    static thread_local auto _v = threading::get_id();
+    return _v;
+}
+
+rocpd::data_processor&
+get_data_processor()
+{
+    return rocpd::data_processor::get_instance();
+}
+
+void
+rocpd_initialize_category()
+{
+    get_data_processor().insert_category(ROCPROFSYS_CATEGORY_AMD_SMI,
+                                         trait::name<category::amd_smi>::value);
+}
+
+void
+rocpd_initialize_smi_tracks()
+{
+    auto&      data_processor = get_data_processor();
+    auto&      n_info         = node_info::get_instance();
+    const auto thread_id      = std::nullopt;  // Internal thread ID for amd-smi
+
+    data_processor.insert_track(trait::name<category::amd_smi_mm_busy>::value, n_info.id,
+                                getpid(), thread_id);
+    data_processor.insert_track(trait::name<category::amd_smi_power>::value, n_info.id,
+                                getpid(), thread_id);
+    data_processor.insert_track(trait::name<category::amd_smi_temp>::value, n_info.id,
+                                getpid(), thread_id);
+    data_processor.insert_track(trait::name<category::amd_smi_memory_usage>::value,
+                                n_info.id, getpid(), thread_id);
+};
+
+void
+rocpd_initialize_smi_pmc(size_t gpu_id)
+{
+    auto& data_processor = get_data_processor();
+    // find the proper values for a following definitions
+    size_t      EVENT_CODE       = 0;
+    size_t      INSTANCE_ID      = 0;
+    const char* LONG_DESCRIPTION = "";
+    const char* COMPONENT        = "";
+    const char* BLOCK            = "";
+    const char* EXPRESSION       = "";
+    const char* CELSIUS_DEGREES  = "\u00B0C";
+    auto        ni               = node_info::get_instance();
+    const auto* TARGET_ARCH      = "GPU";
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto base_id = agent_mngr.get_agent_by_id(gpu_id, ROCPROFILER_AGENT_TYPE_GPU).base_id;
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::amd_smi_mm_busy>::value, "Busy",
+        trait::name<category::amd_smi_mm_busy>::description, LONG_DESCRIPTION, COMPONENT,
+        "%", "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::amd_smi_temp>::value, "Temp",
+        trait::name<category::amd_smi_temp>::description, LONG_DESCRIPTION, COMPONENT,
+        CELSIUS_DEGREES, "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::amd_smi_power>::value, "Pow",
+        trait::name<category::amd_smi_power>::description, LONG_DESCRIPTION, COMPONENT,
+        "w", "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::amd_smi_memory_usage>::value, "MemUsg",
+        trait::name<category::amd_smi_memory_usage>::description, LONG_DESCRIPTION,
+        COMPONENT, "MB", "ABS", BLOCK, EXPRESSION, 0, 0);
+};
+
+void
+rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings& settings,
+                             uint64_t timestamp, double busy, double temp, double power,
+                             double usage)
+{
+    if(!(settings.busy || settings.temp || settings.power || settings.mem_usage)) return;
+
+    auto& data_processor = get_data_processor();
+    auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_AMD_SMI, 0, 0, 0);
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto  base_id =
+        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_GPU).base_id;
+
+    auto insert_event_and_sample = [&](bool enabled, const char* name, double value) {
+        if(!enabled) return;
+        data_processor.insert_pmc_event(event_id, base_id, name, value);
+        data_processor.insert_sample(name, timestamp, event_id);
+    };
+
+    insert_event_and_sample(settings.busy, trait::name<category::amd_smi_mm_busy>::value,
+                            busy);
+    insert_event_and_sample(settings.temp, trait::name<category::amd_smi_temp>::value,
+                            temp);
+    insert_event_and_sample(settings.power, trait::name<category::amd_smi_power>::value,
+                            power);
+    insert_event_and_sample(settings.mem_usage,
+                            trait::name<category::amd_smi_memory_usage>::value, usage);
+};
+
 auto&
 get_settings(uint32_t _dev_id)
 {
@@ -140,6 +251,8 @@ data::data(uint32_t _dev_id) { sample(_dev_id); }
 void
 data::sample(uint32_t _dev_id)
 {
+    if(is_child_process()) return;
+
     auto _ts = tim::get_clock_real_now<size_t, std::nano>();
     assert(_ts < std::numeric_limits<int64_t>::max());
     amdsmi_gpu_metrics_t _gpu_metrics;
@@ -168,7 +281,6 @@ data::sample(uint32_t _dev_id)
     }
 
     amdsmi_processor_handle sample_handle = gpu::get_handle_from_id(_dev_id);
-
     ROCPROFSYS_AMDSMI_GET(get_settings(m_dev_id).busy, amdsmi_get_gpu_activity,
                           sample_handle, &m_busy_perc);
     ROCPROFSYS_AMDSMI_GET(get_settings(m_dev_id).temp, amdsmi_get_temp_metric,
@@ -276,10 +388,15 @@ config()
                 *_bundle_data.at(i) = unique_ptr_t<bundle_t>{ new bundle_t{} };
         }
     }
-
     data::get_initial().resize(data::device_count);
     for(auto itr : data::device_list)
         data::get_initial().at(itr).sample(itr);
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_category();
+        rocpd_initialize_smi_tracks();
+    }
 }
 
 void
@@ -363,192 +480,194 @@ data::post_process(uint32_t _dev_id)
 
     auto _settings = get_settings(_dev_id);
 
-    auto _process_perfetto = [&]() {
-        constexpr uint8_t AMD_SMI_METRICS_COUNT = 8;
-        auto              _idx = std::array<uint64_t, AMD_SMI_METRICS_COUNT>{};
+    auto use_perfetto = get_use_perfetto();
+    auto use_rocpd    = get_use_rocpd();
+
+    if(use_rocpd)
+    {
+        rocpd_initialize_smi_pmc(_dev_id);
+    }
+
+    for(auto& itr : _amd_smi)
+    {
+        using counter_track = perfetto_counter_track<data>;
+        if(itr.m_dev_id != _dev_id) continue;
+
+        uint64_t _ts = itr.m_ts;
+        if(!_thread_info->is_valid_time(_ts)) continue;
+
+        double _gfxbusy = itr.m_busy_perc.gfx_activity;
+        double _umcbusy = itr.m_busy_perc.umc_activity;
+        double _mmbusy  = itr.m_busy_perc.mm_activity;
+        double _temp    = itr.m_temp;
+        double _power   = itr.m_power.current_socket_power;
+        double _usage   = itr.m_mem_usage / static_cast<double>(units::megabyte);
+
+        auto setup_perfetto_counter_tracks = [&]() {
+            if(counter_track::exists(_dev_id)) return;
+
+            auto addendum = [&](const char* _v) {
+                return JOIN(" ", "GPU", _v, JOIN("", '[', _dev_id, ']'), "(S)");
+            };
+
+            auto addendum_blk = [&](std::size_t _i, const char* _metric,
+                                    std::size_t xcp_idx = SIZE_MAX) {
+                if(xcp_idx != SIZE_MAX)
+                {
+                    return JOIN(
+                        " ", "GPU", JOIN("", '[', _dev_id, ']'), _metric,
+                        JOIN("", "XCP_", xcp_idx, ": [", (_i < 10 ? "0" : ""), _i, ']'),
+                        "(S)");
+                }
+                else
+                {
+                    return JOIN(" ", "GPU", JOIN("", '[', _dev_id, ']'), _metric,
+                                JOIN("", "[", (_i < 10 ? "0" : ""), _i, ']'), "(S)");
+                }
+            };
 
-        {
-            _idx.fill(_idx.size());
-            uint64_t nidx = 0;
             if(_settings.busy)
             {
-                _idx.at(0) = nidx++;  // GFX Busy
-                _idx.at(1) = nidx++;  // UMC Busy
-                _idx.at(2) = nidx++;  // MM Busy
+                counter_track::emplace(_dev_id, addendum("GFX Busy"), "%");
+                counter_track::emplace(_dev_id, addendum("UMC Busy"), "%");
+                counter_track::emplace(_dev_id, addendum("MM Busy"), "%");
             }
-            if(_settings.temp) _idx.at(3) = nidx++;
-            if(_settings.power) _idx.at(4) = nidx++;
-            if(_settings.mem_usage) _idx.at(5) = nidx++;
-            if(_settings.vcn_activity) _idx.at(6) = nidx++;
-            if(_settings.jpeg_activity) _idx.at(7) = nidx++;
-        }
-
-        for(auto& itr : _amd_smi)
-        {
-            using counter_track = perfetto_counter_track<data>;
-            if(itr.m_dev_id != _dev_id) continue;
-            if(!counter_track::exists(_dev_id))
+            if(_settings.temp)
             {
-                auto addendum = [&](const char* _v) {
-                    return JOIN(" ", "GPU", _v, JOIN("", '[', _dev_id, ']'), "(S)");
-                };
-                auto addendum_blk = [&](std::size_t _i, const char* _metric,
-                                        std::size_t xcp_idx = SIZE_MAX) {
-                    if(xcp_idx != SIZE_MAX)
-                    {
-                        return JOIN(" ", "GPU", JOIN("", '[', _dev_id, ']'), _metric,
-                                    JOIN("", "XCP_", xcp_idx, ": [", (_i < 10 ? "0" : ""),
-                                         _i, ']'),
-                                    "(S)");
-                    }
-                    else
-                    {
-                        return JOIN(" ", "GPU", JOIN("", '[', _dev_id, ']'), _metric,
-                                    JOIN("", "[", (_i < 10 ? "0" : ""), _i, ']'), "(S)");
-                    }
-                };
-
-                if(_settings.busy)
+                counter_track::emplace(_dev_id, addendum("Temperature"), "deg C");
+            }
+            if(_settings.power)
+            {
+                counter_track::emplace(_dev_id, addendum("Current Power"), "watts");
+            }
+            if(_settings.mem_usage)
+            {
+                counter_track::emplace(_dev_id, addendum("Memory Usage"), "megabytes");
+            }
+            if(_settings.vcn_activity)
+            {
+                if(itr.m_xcp_metrics.empty())
                 {
-                    counter_track::emplace(_dev_id, addendum("GFX Busy"), "%");
-                    counter_track::emplace(_dev_id, addendum("UMC Busy"), "%");
-                    counter_track::emplace(_dev_id, addendum("MM Busy"), "%");
+                    ROCPROFSYS_VERBOSE(
+                        1, "No VCN activity data collected from device %u\n", _dev_id);
                 }
-                if(_settings.temp)
-                    counter_track::emplace(_dev_id, addendum("Temperature"), "deg C");
-                if(_settings.power)
-                    counter_track::emplace(_dev_id, addendum("Current Power"), "watts");
-                if(_settings.mem_usage)
-                    counter_track::emplace(_dev_id, addendum("Memory Usage"),
-                                           "megabytes");
-                if(_settings.vcn_activity)
+                else if(gpu::is_vcn_activity_supported(_dev_id))
                 {
-                    if(itr.m_xcp_metrics.empty())
-                    {
-                        ROCPROFSYS_VERBOSE(
-                            1, "No VCN activity data collected from device %u\n",
-                            _dev_id);
-                    }
-                    else if(gpu::is_vcn_activity_supported(_dev_id))
+                    // For VCN activity, use simple indexing
+                    for(std::size_t i = 0; i < std::size(itr.m_xcp_metrics[0].vcn_busy);
+                        ++i)
+                        counter_track::emplace(_dev_id, addendum_blk(i, "VCN Activity"),
+                                               "%");
+                }
+                else
+                {
+                    for(std::size_t xcp = 0; xcp < std::size(itr.m_xcp_metrics); ++xcp)
                     {
-                        // For VCN activity, use simple indexing
                         for(std::size_t i = 0;
-                            i < std::size(itr.m_xcp_metrics[0].vcn_busy); ++i)
-                            counter_track::emplace(_dev_id,
-                                                   addendum_blk(i, "VCN Activity"), "%");
-                    }
-                    else
-                    {
-                        for(std::size_t xcp = 0; xcp < std::size(itr.m_xcp_metrics);
-                            ++xcp)
+                            i < std::size(itr.m_xcp_metrics[xcp].vcn_busy); ++i)
                         {
-                            for(std::size_t i = 0;
-                                i < std::size(itr.m_xcp_metrics[xcp].vcn_busy); ++i)
-                            {
-                                counter_track::emplace(
-                                    _dev_id, addendum_blk(i, "VCN Activity", xcp), "%");
-                            }
+                            counter_track::emplace(
+                                _dev_id, addendum_blk(i, "VCN Activity", xcp), "%");
                         }
                     }
                 }
-                if(_settings.jpeg_activity)
+            }
+            if(_settings.jpeg_activity)
+            {
+                if(itr.m_xcp_metrics.empty())
                 {
-                    if(itr.m_xcp_metrics.empty())
-                    {
-                        ROCPROFSYS_VERBOSE(
-                            1, "No JPEG activity data collected from device %u\n",
-                            _dev_id);
-                    }
-                    else if(gpu::is_jpeg_activity_supported(_dev_id))
+                    ROCPROFSYS_VERBOSE(
+                        1, "No JPEG activity data collected from device %u\n", _dev_id);
+                }
+                else if(gpu::is_jpeg_activity_supported(_dev_id))
+                {
+                    for(std::size_t i = 0; i < std::size(itr.m_xcp_metrics[0].jpeg_busy);
+                        ++i)
+                        counter_track::emplace(_dev_id, addendum_blk(i, "JPEG Activity"),
+                                               "%");
+                }
+                else
+                {
+                    for(std::size_t xcp = 0; xcp < std::size(itr.m_xcp_metrics); ++xcp)
                     {
-                        // For JPEG activity, use simple indexing
                         for(std::size_t i = 0;
-                            i < std::size(itr.m_xcp_metrics[0].jpeg_busy); ++i)
-                            counter_track::emplace(_dev_id,
-                                                   addendum_blk(i, "JPEG Activity"), "%");
-                    }
-                    else
-                    {
-                        for(std::size_t xcp = 0; xcp < std::size(itr.m_xcp_metrics);
-                            ++xcp)
-                        {
-                            for(std::size_t i = 0;
-                                i < std::size(itr.m_xcp_metrics[xcp].jpeg_busy); ++i)
-                                counter_track::emplace(
-                                    _dev_id, addendum_blk(i, "JPEG Activity", xcp), "%");
-                        }
+                            i < std::size(itr.m_xcp_metrics[xcp].jpeg_busy); ++i)
+                            counter_track::emplace(
+                                _dev_id, addendum_blk(i, "JPEG Activity", xcp), "%");
                     }
                 }
             }
-            uint64_t _ts = itr.m_ts;
-            if(!_thread_info->is_valid_time(_ts)) continue;
+        };
 
-            double _gfxbusy = itr.m_busy_perc.gfx_activity;
-            double _umcbusy = itr.m_busy_perc.umc_activity;
-            double _mmbusy  = itr.m_busy_perc.mm_activity;
-            double _temp    = itr.m_temp;
-            double _power   = itr.m_power.current_socket_power;
-            double _usage   = itr.m_mem_usage / static_cast<double>(units::megabyte);
+        auto write_perfetto_metrics = [&]() {
+            size_t track_index = 0;
 
             if(_settings.busy)
             {
-                TRACE_COUNTER("device_busy_gfx", counter_track::at(_dev_id, _idx.at(0)),
-                              _ts, _gfxbusy);
-                TRACE_COUNTER("device_busy_umc", counter_track::at(_dev_id, _idx.at(1)),
-                              _ts, _umcbusy);
-                TRACE_COUNTER("device_busy_mm", counter_track::at(_dev_id, _idx.at(2)),
+                TRACE_COUNTER("device_busy_gfx",
+                              counter_track::at(_dev_id, track_index++), _ts, _gfxbusy);
+                TRACE_COUNTER("device_busy_umc",
+                              counter_track::at(_dev_id, track_index++), _ts, _umcbusy);
+                TRACE_COUNTER("device_busy_mm", counter_track::at(_dev_id, track_index++),
                               _ts, _mmbusy);
             }
             if(_settings.temp)
-                TRACE_COUNTER("device_temp", counter_track::at(_dev_id, _idx.at(3)), _ts,
-                              _temp);
+            {
+                TRACE_COUNTER("device_temp", counter_track::at(_dev_id, track_index++),
+                              _ts, _temp);
+            }
             if(_settings.power)
-                TRACE_COUNTER("device_power", counter_track::at(_dev_id, _idx.at(4)), _ts,
-                              _power);
+            {
+                TRACE_COUNTER("device_power", counter_track::at(_dev_id, track_index++),
+                              _ts, _power);
+            }
             if(_settings.mem_usage)
+            {
                 TRACE_COUNTER("device_memory_usage",
-                              counter_track::at(_dev_id, _idx.at(5)), _ts, _usage);
+                              counter_track::at(_dev_id, track_index++), _ts, _usage);
+            }
+
             if(_settings.vcn_activity && !itr.m_xcp_metrics.empty())
             {
-                uint64_t idx = _idx.at(6);
                 // Iterate over all XCPs and their VCN busy/activity values
                 for(const auto& metrics : itr.m_xcp_metrics)
                 {
                     for(const auto& vcn_val : metrics.vcn_busy)
                     {
                         TRACE_COUNTER("device_vcn_activity",
-                                      counter_track::at(_dev_id, idx), _ts, vcn_val);
-                        ++idx;
+                                      counter_track::at(_dev_id, track_index++), _ts,
+                                      vcn_val);
                     }
                 }
             }
 
             if(_settings.jpeg_activity && !itr.m_xcp_metrics.empty())
             {
-                uint64_t idx = _idx.at(7);
-                // Calculate total VCN metrics to properly offset JPEG metrics index
-                if(_settings.vcn_activity)
-                {
-                    size_t total_vcn_metrics = 0;
-                    for(const auto& metrics : itr.m_xcp_metrics)
-                        total_vcn_metrics += metrics.vcn_busy.size();
-                    if(total_vcn_metrics > 0) idx += (total_vcn_metrics - 1);
-                }
                 // Iterate over all XCPs and their JPEG busy/activity values
                 for(const auto& metrics : itr.m_xcp_metrics)
                 {
                     for(const auto& jpeg_val : metrics.jpeg_busy)
                     {
                         TRACE_COUNTER("device_jpeg_activity",
-                                      counter_track::at(_dev_id, idx), _ts, jpeg_val);
-                        ++idx;
+                                      counter_track::at(_dev_id, track_index++), _ts,
+                                      jpeg_val);
                     }
                 }
             }
+        };
+
+        if(use_perfetto)
+        {
+            setup_perfetto_counter_tracks();
+            write_perfetto_metrics();
         }
-    };
 
-    if(get_use_perfetto()) _process_perfetto();
+        if(use_rocpd)
+        {
+            rocpd_process_smi_pmc_events(_dev_id, _settings, _ts, _mmbusy, _temp, _power,
+                                         _usage);
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------//
@@ -573,7 +692,7 @@ setup()
     ROCPROFSYS_VERBOSE_F(0, "AMD SMI version: %u.%u.%u - str: %s.\n", _version.major,
                          _version.minor, _version.release, _version.build);
 
-    data::device_count = gpu::get_processor_count();
+    data::device_count = gpu::device_count();
 
     auto _devices_v = get_sampling_gpus();
     for(auto& itr : _devices_v)
@@ -668,7 +787,6 @@ setup()
         }
 
         is_initialized() = true;
-
         data::setup();
     } catch(std::runtime_error& _e)
     {
@@ -705,7 +823,10 @@ void
 post_process()
 {
     for(auto itr : data::device_list)
+    {
+        ROCPROFSYS_VERBOSE(2, "Post-processing amd-smi data for device: %d", itr);
         data::post_process(itr);
+    }
 }
 
 uint32_t
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index fcc533f2c7..f0afb5f6fa 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -21,10 +21,13 @@
 // SOFTWARE.
 
 #include "library/components/backtrace_metrics.hpp"
+#include "core/agent_manager.hpp"
 #include "core/components/fwd.hpp"
 #include "core/config.hpp"
 #include "core/debug.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto.hpp"
+#include "core/rocpd/data_processor.hpp"
 #include "library/components/ensure_storage.hpp"
 #include "library/ptl.hpp"
 #include "library/runtime.hpp"
@@ -137,6 +140,12 @@ backtrace_metrics::get_hw_counter_labels(int64_t _tid)
     return (_v) ? *_v : std::vector<std::string>{};
 }
 
+rocpd::data_processor&
+get_data_processor()
+{
+    return rocpd::data_processor::get_instance();
+}
+
 void
 backtrace_metrics::start()
 {}
@@ -327,6 +336,229 @@ backtrace_metrics::fini_perfetto(int64_t _tid, valid_array_t _valid)
     }
 }
 
+void
+rocpd_init_categories()
+{
+    static bool _is_initialized = false;
+    if(_is_initialized) return;
+
+    get_data_processor().insert_category(
+        category_enum_id<category::thread_cpu_time>::value,
+        trait::name<category::thread_cpu_time>::value);
+    get_data_processor().insert_category(
+        category_enum_id<category::thread_peak_memory>::value,
+        trait::name<category::thread_peak_memory>::value);
+    get_data_processor().insert_category(
+        category_enum_id<category::thread_context_switch>::value,
+        trait::name<category::thread_context_switch>::value);
+    get_data_processor().insert_category(
+        category_enum_id<category::thread_page_fault>::value,
+        trait::name<category::thread_page_fault>::value);
+    get_data_processor().insert_category(
+        category_enum_id<category::thread_hardware_counter>::value,
+        trait::name<category::thread_hardware_counter>::value);
+
+    _is_initialized = true;
+}
+
+template <typename Category>
+void
+rocpd_init_tracks(int64_t _tid)
+{
+    auto&       data_processor = get_data_processor();
+    auto&       n_info         = node_info::get_instance();
+    const auto& t_info         = thread_info::get(_tid, SequentTID);
+    auto        _tid_name      = JOIN("", '[', _tid, ']');
+
+    auto thread_idx = data_processor.insert_thread_info(
+        n_info.id, getppid(), getpid(), t_info->index_data->system_value,
+        JOIN(" ", "Thread", _tid).c_str(), t_info->get_start(), t_info->get_stop(), "{}");
+
+    if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
+    {
+        // Initialize hw_counter_tracks and create one track for each hardware counter
+        auto _hw_cnt_labels = *get_papi_labels(_tid);
+        for(auto& itr : _hw_cnt_labels)
+        {
+            std::string _desc = tim::papi::get_event_info(itr).short_descr;
+            if(_desc.empty()) _desc = itr;
+            ROCPROFSYS_CI_THROW(_desc.empty(), "Empty description for %s\n", itr.c_str());
+
+            std::string track_name = JOIN(' ', "Thread", _desc, _tid_name, "(S)");
+            data_processor.insert_track(track_name.c_str(), n_info.id, getpid(),
+                                        thread_idx, "{}");
+        }
+    }
+    else
+        data_processor.insert_track(
+            JOIN('_', trait::name<Category>::value, _tid_name).c_str(), n_info.id,
+            getpid(), thread_idx, "{}");
+}
+
+template <typename Category>
+void
+rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t _tid)
+{
+    auto& data_processor = get_data_processor();
+    auto  _tid_name      = JOIN("", '[', _tid, ']');
+
+    size_t      EVENT_CODE       = 0;
+    size_t      INSTANCE_ID      = 0;
+    const char* LONG_DESCRIPTION = "";
+    const char* COMPONENT        = "";
+    const char* BLOCK            = "";
+    const char* EXPRESSION       = "";
+    auto        ni               = node_info::get_instance();
+    const auto  TARGET_ARCH      = "CPU";
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto base_id = agent_mngr.get_agent_by_id(dev_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+
+    if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
+    {
+        auto _hw_cnt_labels = *get_papi_labels(_tid);
+        for(auto& itr : _hw_cnt_labels)
+        {
+            std::string _desc = tim::papi::get_event_info(itr).short_descr;
+            if(_desc.empty()) _desc = itr;
+            ROCPROFSYS_CI_THROW(_desc.empty(), "Empty description for %s\n", itr.c_str());
+
+            std::string track_name = JOIN(' ', "Thread", _desc, _tid_name, "(S)");
+
+            data_processor.insert_pmc_description(
+                ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+                track_name.c_str(), trait::name<Category>::value,
+                trait::name<Category>::description, LONG_DESCRIPTION, COMPONENT, units,
+                "ABS", BLOCK, EXPRESSION, 0, 0);
+        }
+    }
+    else
+        data_processor.insert_pmc_description(
+            ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+            JOIN("_", trait::name<Category>::value, _tid_name).c_str(),
+            trait::name<Category>::value, trait::name<Category>::description,
+            LONG_DESCRIPTION, COMPONENT, units, "ABS", BLOCK, EXPRESSION, 0, 0);
+}
+
+template <typename Category, typename Value>
+void
+rocpd_process_backtrace_metrics_events(const uint32_t device_id, uint64_t timestamp,
+                                       Value value, int64_t _tid)
+{
+    auto& data_processor = get_data_processor();
+    auto  _tid_name      = JOIN("", '[', _tid, ']');
+    auto  event_id =
+        data_processor.insert_event(category_enum_id<Category>::value, 0, 0, 0);
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto  base_id =
+        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+
+    auto insert_event_and_sample = [&](const char* name, double value) {
+        data_processor.insert_pmc_event(event_id, base_id, name, value);
+        data_processor.insert_sample(name, timestamp, event_id);
+    };
+
+    if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
+    {
+        auto        _hw_cnt_labels = *get_papi_labels(_tid);
+        const auto& hw_counters =
+            static_cast<backtrace_metrics::hw_counter_data_t>(value);
+        for(size_t i = 0; i < _hw_cnt_labels.size() && i < hw_counters.size(); ++i)
+        {
+            std::string _desc = tim::papi::get_event_info(_hw_cnt_labels[i]).short_descr;
+            if(_desc.empty()) _desc = _hw_cnt_labels[i];
+            std::string track_name = JOIN(' ', "Thread", _desc, _tid_name, "(S)");
+
+            insert_event_and_sample(track_name.c_str(), hw_counters.at(i));
+        }
+    }
+    else
+        insert_event_and_sample(
+            JOIN("_", trait::name<Category>::value, _tid_name).c_str(), value);
+}
+
+void
+backtrace_metrics::init_rocpd(int64_t _tid, valid_array_t _valid)
+{
+    rocpd_init_categories();
+    if(get_valid(category::thread_cpu_time{}, _valid))
+    {
+        rocpd_init_tracks<category::thread_cpu_time>(_tid);
+        rocpd_initialize_backtrace_metrics_pmc<category::thread_cpu_time>(0, "sec", _tid);
+    }
+    if(get_valid(category::thread_peak_memory{}, _valid))
+    {
+        rocpd_init_tracks<category::thread_peak_memory>(_tid);
+        rocpd_initialize_backtrace_metrics_pmc<category::thread_peak_memory>(0, "MB",
+                                                                             _tid);
+    }
+    if(get_valid(category::thread_context_switch{}, _valid))
+    {
+        rocpd_init_tracks<category::thread_context_switch>(_tid);
+        rocpd_initialize_backtrace_metrics_pmc<category::thread_context_switch>(0, "",
+                                                                                _tid);
+    }
+    if(get_valid(category::thread_page_fault{}, _valid))
+    {
+        rocpd_init_tracks<category::thread_page_fault>(_tid);
+        rocpd_initialize_backtrace_metrics_pmc<category::thread_page_fault>(0, "", _tid);
+    }
+    if(get_valid(type_list<hw_counters>{}, _valid) &&
+       get_valid(category::thread_hardware_counter{}, _valid))
+    {
+        rocpd_init_tracks<category::thread_hardware_counter>(_tid);
+        rocpd_initialize_backtrace_metrics_pmc<category::thread_hardware_counter>(0, "",
+                                                                                  _tid);
+    }
+}
+
+void
+backtrace_metrics::fini_rocpd(int64_t _tid, valid_array_t _valid)
+{
+    const auto& _thread_info = thread_info::get(_tid, SequentTID);
+
+    ROCPROFSYS_CI_THROW(!_thread_info, "Error! missing thread info for tid=%li\n", _tid);
+    if(!_thread_info) return;
+
+    uint64_t _ts = _thread_info->get_stop();
+
+    if(get_valid(category::thread_cpu_time{}, _valid))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_cpu_time, double>(
+            0, _ts, 0, _tid);
+    }
+
+    if(get_valid(category::thread_peak_memory{}, _valid))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, double>(
+            0, _ts, 0, _tid);
+    }
+
+    if(get_valid(category::thread_context_switch{}, _valid))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_context_switch, int64_t>(
+            0, _ts, 0, _tid);
+    }
+
+    if(get_valid(category::thread_page_fault{}, _valid))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_page_fault, int64_t>(
+            0, _ts, 0, _tid);
+    }
+
+    if(get_valid(type_list<hw_counters>{}, _valid) &&
+       get_valid(category::thread_hardware_counter{}, _valid))
+    {
+        auto              _hw_cnt_labels = *get_papi_labels(_tid);
+        hw_counter_data_t zero_counters{};
+        zero_counters.fill(0.0);
+
+        rocpd_process_backtrace_metrics_events<category::thread_hardware_counter,
+                                               hw_counter_data_t>(0, _ts, zero_counters,
+                                                                  _tid);
+    }
+}
+
 backtrace_metrics&
 backtrace_metrics::operator-=(const backtrace_metrics& _rhs)
 {
@@ -407,6 +639,40 @@ backtrace_metrics::post_process_perfetto(int64_t _tid, uint64_t _ts) const
         }
     }
 }
+
+void
+backtrace_metrics::post_process_rocpd(int64_t _tid, uint64_t _ts) const
+{
+    if((*this)(category::thread_cpu_time{}))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_cpu_time, double>(
+            0, _ts, m_cpu / units::sec, _tid);
+    }
+
+    if((*this)(category::thread_peak_memory{}))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, double>(
+            0, _ts, m_mem_peak / units::megabyte, _tid);
+    }
+
+    if((*this)(category::thread_context_switch{}))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, int64_t>(
+            0, _ts, m_ctx_swch, _tid);
+    }
+
+    if((*this)(category::thread_page_fault{}))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, int64_t>(
+            0, _ts, m_page_flt, _tid);
+    }
+    if((*this)(type_list<hw_counters>{}) && (*this)(category::thread_hardware_counter{}))
+    {
+        rocpd_process_backtrace_metrics_events<category::thread_hardware_counter,
+                                               hw_counter_data_t>(0, _ts, m_hw_counter,
+                                                                  _tid);
+    }
+}
 }  // namespace component
 }  // namespace rocprofsys
 
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.hpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.hpp
index c9211aeb23..c7ff288059 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.hpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.hpp
@@ -83,6 +83,8 @@ struct backtrace_metrics : comp::empty_base
     static void                     configure(bool, int64_t _tid = threading::get_id());
     static void                     init_perfetto(int64_t _tid, valid_array_t);
     static void                     fini_perfetto(int64_t _tid, valid_array_t);
+    static void                     init_rocpd(int64_t _tid, valid_array_t);
+    static void                     fini_rocpd(int64_t _tid, valid_array_t);
     static std::vector<std::string> get_hw_counter_labels(int64_t);
 
     template <typename Tp>
@@ -113,6 +115,7 @@ struct backtrace_metrics : comp::empty_base
     const auto& get_hw_counters() const { return m_hw_counter; }
 
     void post_process_perfetto(int64_t _tid, uint64_t _ts) const;
+    void post_process_rocpd(int64_t _tid, uint64_t _ts) const;
 
     backtrace_metrics& operator-=(const backtrace_metrics&);
 
diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index 50b5b437e4..c39f0c084f 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -21,9 +21,13 @@
 // SOFTWARE.
 
 #include "library/components/comm_data.hpp"
+#include "core/agent_manager.hpp"
 #include "core/components/fwd.hpp"
 #include "core/config.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto.hpp"
+#include "core/rocpd/data_processor.hpp"
+#include "core/rocpd/json.hpp"
 #include "library/tracing.hpp"
 
 #include <timemory/backends/mpi.hpp>
@@ -74,6 +78,120 @@ write_perfetto_counter_track(uint64_t _val)
 }
 }  // namespace
 
+namespace
+{
+rocpd::data_processor&
+get_data_processor()
+{
+    return rocpd::data_processor::get_instance();
+}
+
+void
+rocpd_initialize_comm_data_categories()
+{
+    static bool _is_initialized = false;
+    if(_is_initialized) return;
+
+    get_data_processor().insert_category(category_enum_id<category::comm_data>::value,
+                                         trait::name<category::comm_data>::value);
+    get_data_processor().insert_category(category_enum_id<category::mpi>::value,
+                                         trait::name<category::mpi>::value);
+    get_data_processor().insert_category(category_enum_id<category::rocm_rccl>::value,
+                                         trait::name<category::rocm_rccl>::value);
+
+    _is_initialized = true;
+}
+
+template <typename Track>
+void
+rocpd_initialize_track()
+{
+    auto& n_info      = node_info::get_instance();
+    auto  _init_track = [&](const char* label) {
+        ROCPROFSYS_VERBOSE(
+            3, "INSERT_TRACK label: %s, node ID: %d, Process ID: %d, Thread ID: %d",
+            label, n_info.id, getpid(), gettid());
+        get_data_processor().insert_track(label, n_info.id, getpid(), gettid());
+    };
+
+    static std::once_flag _once{};
+    std::call_once(_once, _init_track, Track::label);
+}
+
+void
+rocpd_initialize_comm_data_pmc()
+{
+    [[maybe_unused]] auto& data_processor = get_data_processor();
+    // find the proper values for a following definitions
+    [[maybe_unused]] size_t                EVENT_CODE       = 0;
+    [[maybe_unused]] size_t                INSTANCE_ID      = 0;
+    [[maybe_unused]] constexpr const char* LONG_DESCRIPTION = "";
+    [[maybe_unused]] constexpr const char* COMPONENT        = "";
+    [[maybe_unused]] constexpr const char* BLOCK            = "";
+    [[maybe_unused]] constexpr const char* EXPRESSION       = "";
+    [[maybe_unused]] constexpr const char* MSG              = "bytes";
+    [[maybe_unused]] constexpr const auto* TARGET_ARCH      = "CPU";
+    auto                                   ni               = node_info::get_instance();
+    constexpr const auto                   DEVICE_ID = 0;  // Assuming CPU device ID is 0
+
+    auto&                 agent_mngr = rocpd::agent_manager::get_instance();
+    [[maybe_unused]] auto base_id =
+        agent_mngr.get_agent_by_id(DEVICE_ID, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+
+#if defined(ROCPROFSYS_USE_MPI)
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::mpi>::value, "Tracks MPI communication data sizes",
+        trait::name<category::mpi>::description, LONG_DESCRIPTION, COMPONENT, MSG, "ABS",
+        BLOCK, EXPRESSION, 0, 0);
+#endif
+#if defined(ROCPROFSYS_USE_RCCL)
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::rocm_rccl>::value, "Tracks RCCL communication data sizes",
+        trait::name<category::rocm_rccl>::description, LONG_DESCRIPTION, COMPONENT, MSG,
+        "ABS", BLOCK, EXPRESSION, 0, 0);
+#endif
+}
+
+template <typename Track>
+void
+rocpd_process_cpu_usage_events(const uint32_t device_id, int bytes)
+{
+    auto& data_processor = get_data_processor();
+    auto  event_id       = data_processor.insert_event(
+        category_enum_id<category::comm_data>::value, 0, 0, 0);
+
+    auto& agents = rocpd::agent_manager::get_instance();
+    auto  agent  = agents.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU);
+
+    auto insert_event_and_sample = [&](const char* name, uint64_t timestamp,
+                                       double value) {
+        data_processor.insert_pmc_event(event_id, agent.device_id, name, value);
+        data_processor.insert_sample(name, timestamp, event_id);
+    };
+
+    static std::mutex _mutex{};
+    static uint64_t   value = 0;
+    uint64_t          _now  = 0;
+    {
+        std::unique_lock<std::mutex> _lk{ _mutex };
+        _now  = rocprofsys::tracing::now<uint64_t>();
+        bytes = (value += bytes);
+    }
+
+    insert_event_and_sample(Track::label, _now, bytes);
+}
+
+}  // namespace
+
+void
+comm_data::start()
+{
+    rocpd_initialize_comm_data_categories();
+    rocpd_initialize_comm_data_pmc();
+}
+
 void
 comm_data::preinit()
 {
@@ -84,6 +202,11 @@ void
 comm_data::global_finalize()
 {
     configure();
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_comm_data_categories();
+        rocpd_initialize_comm_data_pmc();
+    }
 }
 
 void
@@ -116,13 +239,22 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, int cou
 
     write_perfetto_counter_track<mpi_send>(count * _size);
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _a{ _name };
-    add(_a, count * _size);
-    tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
-    add(_b, count * _size);
-    add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)), count * _size);
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_send>();
+        rocpd_process_cpu_usage_events<mpi_send>(0, count * _size);
+    }
+
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _a{ _name };
+        add(_a, count * _size);
+        tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
+        add(_b, count * _size);
+        add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)),
+            count * _size);
+    }
 }
 
 // MPI_Recv
@@ -133,15 +265,24 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, void*, int count,
     int _size = mpi_type_size(datatype);
     if(_size == 0) return;
 
-    write_perfetto_counter_track<mpi_recv>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<mpi_recv>(count * _size);
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_recv>();
+        rocpd_process_cpu_usage_events<mpi_recv>(0, count * _size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _a{ _name };
-    add(_a, count * _size);
-    tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
-    add(_b, count * _size);
-    add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _a{ _name };
+        add(_a, count * _size);
+        tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
+        add(_b, count * _size);
+        add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)),
+            count * _size);
+    }
 }
 
 // MPI_Isend
@@ -152,15 +293,24 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, int cou
     int _size = mpi_type_size(datatype);
     if(_size == 0) return;
 
-    write_perfetto_counter_track<mpi_send>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<mpi_send>(count * _size);
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_send>();
+        rocpd_process_cpu_usage_events<mpi_send>(0, count * _size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _a{ _name };
-    add(_a, count * _size);
-    tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
-    add(_b, count * _size);
-    add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _a{ _name };
+        add(_a, count * _size);
+        tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
+        add(_b, count * _size);
+        add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)),
+            count * _size);
+    }
 }
 
 // MPI_Irecv
@@ -171,15 +321,24 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, void*, int count,
     int _size = mpi_type_size(datatype);
     if(_size == 0) return;
 
-    write_perfetto_counter_track<mpi_recv>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<mpi_recv>(count * _size);
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_recv>();
+        rocpd_process_cpu_usage_events<mpi_recv>(0, count * _size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _a{ _name };
-    add(_a, count * _size);
-    tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
-    add(_b, count * _size);
-    add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _a{ _name };
+        add(_a, count * _size);
+        tracker_t _b{ JOIN('/', _name, JOIN('=', "dst", dst)) };
+        add(_b, count * _size);
+        add(JOIN('/', _name, JOIN('=', "dst", dst), JOIN('=', "tag", tag)),
+            count * _size);
+    }
 }
 
 // MPI_Bcast
@@ -190,13 +349,21 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, void*, int count,
     int _size = mpi_type_size(datatype);
     if(_size == 0) return;
 
-    write_perfetto_counter_track<mpi_send>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<mpi_send>(count * _size);
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_send>();
+        rocpd_process_cpu_usage_events<mpi_send>(0, count * _size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, count * _size);
-    add(JOIN('/', _name, JOIN('=', "root", root)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, count * _size);
+        add(JOIN('/', _name, JOIN('=', "root", root)), count * _size);
+    }
 }
 
 // MPI_Allreduce
@@ -207,11 +374,21 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, void*,
     int _size = mpi_type_size(datatype);
     if(_size == 0) return;
 
-    write_perfetto_counter_track<mpi_recv>(count * _size);
-    write_perfetto_counter_track<mpi_send>(count * _size);
+    if(get_use_perfetto())
+    {
+        write_perfetto_counter_track<mpi_recv>(count * _size);
+        write_perfetto_counter_track<mpi_send>(count * _size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    add(_data, count * _size);
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_track<mpi_send>();
+        rocpd_initialize_track<mpi_recv>();
+        rocpd_process_cpu_usage_events<mpi_recv>(0, count * _size);
+        rocpd_process_cpu_usage_events<mpi_send>(0, count * _size);
+    }
+
+    if(rocprofsys::get_use_timemory()) add(_data, count * _size);
 }
 
 // MPI_Sendrecv
@@ -224,30 +401,43 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, int sen
     int _recv_size = mpi_type_size(recvtype);
     if(_send_size == 0 || _recv_size == 0) return;
 
-    write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
-    write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
+    if(get_use_perfetto())
+    {
+        write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
+        write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, sendcount * _send_size + recvcount * _recv_size);
+    if(get_use_rocpd())
     {
-        tracker_t _b{ JOIN('/', _name, "send") };
-        add(_b, sendcount * _send_size);
-        tracker_t _c{ JOIN('/', _name, JOIN('=', "send", dst)) };
-        add(_b, sendcount * _send_size);
-        add(JOIN('/', _name, "send", JOIN('=', "tag", sendtag)), sendcount * _send_size);
-        add(JOIN('/', _name, JOIN('=', "send", dst), JOIN('=', "tag", sendtag)),
-            sendcount * _send_size);
+        rocpd_process_cpu_usage_events<mpi_send>(0, sendcount * _send_size);
+        rocpd_process_cpu_usage_events<mpi_recv>(0, recvcount * _send_size);
     }
+
+    if(rocprofsys::get_use_timemory())
     {
-        tracker_t _b{ JOIN('/', _name, "recv") };
-        add(_b, recvcount * _recv_size);
-        tracker_t _c{ JOIN('/', _name, JOIN('=', "recv", src)) };
-        add(_b, recvcount * _recv_size);
-        add(JOIN('/', _name, "recv", JOIN('=', "tag", recvtag)), recvcount * _recv_size);
-        add(JOIN('/', _name, JOIN('=', "recv", src), JOIN('=', "tag", recvtag)),
-            recvcount * _recv_size);
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, sendcount * _send_size + recvcount * _recv_size);
+        {
+            tracker_t _b{ JOIN('/', _name, "send") };
+            add(_b, sendcount * _send_size);
+            tracker_t _c{ JOIN('/', _name, JOIN('=', "send", dst)) };
+            add(_b, sendcount * _send_size);
+            add(JOIN('/', _name, "send", JOIN('=', "tag", sendtag)),
+                sendcount * _send_size);
+            add(JOIN('/', _name, JOIN('=', "send", dst), JOIN('=', "tag", sendtag)),
+                sendcount * _send_size);
+        }
+        {
+            tracker_t _b{ JOIN('/', _name, "recv") };
+            add(_b, recvcount * _recv_size);
+            tracker_t _c{ JOIN('/', _name, JOIN('=', "recv", src)) };
+            add(_b, recvcount * _recv_size);
+            add(JOIN('/', _name, "recv", JOIN('=', "tag", recvtag)),
+                recvcount * _recv_size);
+            add(JOIN('/', _name, JOIN('=', "recv", src), JOIN('=', "tag", recvtag)),
+                recvcount * _recv_size);
+        }
     }
 }
 
@@ -262,17 +452,28 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, int sen
     int _recv_size = mpi_type_size(recvtype);
     if(_send_size == 0 || _recv_size == 0) return;
 
-    write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
-    write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
-
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, sendcount * _send_size + recvcount * _recv_size);
-    tracker_t _r(JOIN('/', _name, JOIN('=', "root", root)));
-    add(_r, sendcount * _send_size + recvcount * _recv_size);
-    add(JOIN('/', _name, JOIN('=', "root", root), "send"), sendcount * _send_size);
-    add(JOIN('/', _name, JOIN('=', "root", root), "recv"), recvcount * _recv_size);
+    if(get_use_perfetto())
+    {
+        write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
+        write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
+    }
+
+    if(get_use_rocpd())
+    {
+        rocpd_process_cpu_usage_events<mpi_send>(0, sendcount * _send_size);
+        rocpd_process_cpu_usage_events<mpi_recv>(0, recvcount * _send_size);
+    }
+
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, sendcount * _send_size + recvcount * _recv_size);
+        tracker_t _r(JOIN('/', _name, JOIN('=', "root", root)));
+        add(_r, sendcount * _send_size + recvcount * _recv_size);
+        add(JOIN('/', _name, JOIN('=', "root", root), "send"), sendcount * _send_size);
+        add(JOIN('/', _name, JOIN('=', "root", root), "recv"), recvcount * _recv_size);
+    }
 }
 
 // MPI_Alltoall
@@ -285,15 +486,26 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, int sen
     int _recv_size = mpi_type_size(recvtype);
     if(_send_size == 0 || _recv_size == 0) return;
 
-    write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
-    write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
+    if(get_use_perfetto())
+    {
+        write_perfetto_counter_track<mpi_send>(sendcount * _send_size);
+        write_perfetto_counter_track<mpi_recv>(recvcount * _recv_size);
+    }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, sendcount * _send_size + recvcount * _recv_size);
-    add(JOIN('/', _name, "send"), sendcount * _send_size);
-    add(JOIN('/', _name, "recv"), recvcount * _recv_size);
+    if(get_use_rocpd())
+    {
+        rocpd_process_cpu_usage_events<mpi_send>(0, sendcount * _send_size);
+        rocpd_process_cpu_usage_events<mpi_recv>(0, recvcount * _recv_size);
+    }
+
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, sendcount * _send_size + recvcount * _recv_size);
+        add(JOIN('/', _name, "send"), sendcount * _send_size);
+        add(JOIN('/', _name, "recv"), recvcount * _recv_size);
+    }
 }
 #endif
 
@@ -309,13 +521,17 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, const v
     int _size = rccl_type_size(datatype);
     if(_size <= 0) return;
 
-    write_perfetto_counter_track<rccl_recv>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<rccl_recv>(count * _size);
+
+    if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_recv>(0, count * _size);
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, count * _size);
-    add(JOIN('/', _name, JOIN('=', "root", root)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, count * _size);
+        add(JOIN('/', _name, JOIN('=', "root", root)), count * _size);
+    }
 }
 
 // ncclSend
@@ -334,27 +550,32 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, size_t
 
     if(_send_types.count(_data.tool_id) > 0)
     {
-        write_perfetto_counter_track<rccl_send>(count * _size);
+        if(get_use_perfetto()) write_perfetto_counter_track<rccl_send>(count * _size);
+        if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_send>(0, count * _size);
     }
     else if(_recv_types.count(_data.tool_id) > 0)
     {
-        write_perfetto_counter_track<rccl_recv>(count * _size);
+        if(get_use_perfetto()) write_perfetto_counter_track<rccl_recv>(count * _size);
+        if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_recv>(0, count * _size);
     }
     else
     {
         ROCPROFSYS_CI_THROW(true, "RCCL function not handled: %s", _data.tool_id.c_str());
     }
 
-    write_perfetto_counter_track<rccl_recv>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<rccl_recv>(count * _size);
+    if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_recv>(0, count * _size);
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto        _name  = std::string_view{ _data.tool_id };
-    std::string _label = "root";
-    if(_name.find("Send") != std::string::npos) _label = "peer";
+    if(rocprofsys::get_use_timemory())
+    {
+        auto        _name  = std::string_view{ _data.tool_id };
+        std::string _label = "root";
+        if(_name.find("Send") != std::string::npos) _label = "peer";
 
-    tracker_t _t{ _name };
-    add(_t, count * _size);
-    add(JOIN('/', _name, JOIN('=', _label, peer)), count * _size);
+        tracker_t _t{ _name };
+        add(_t, count * _size);
+        add(JOIN('/', _name, JOIN('=', _label, peer)), count * _size);
+    }
 }
 
 // ncclBroadcast
@@ -365,13 +586,16 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, const v
     int _size = rccl_type_size(datatype);
     if(_size <= 0) return;
 
-    write_perfetto_counter_track<rccl_send>(count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<rccl_send>(count * _size);
+    if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_send>(0, count * _size);
 
-    if(!rocprofsys::get_use_timemory()) return;
-    auto      _name = std::string_view{ _data.tool_id };
-    tracker_t _t{ _name };
-    add(_t, count * _size);
-    add(JOIN('/', _data.tool_id, JOIN('=', "root", root)), count * _size);
+    if(rocprofsys::get_use_timemory())
+    {
+        auto      _name = std::string_view{ _data.tool_id };
+        tracker_t _t{ _name };
+        add(_t, count * _size);
+        add(JOIN('/', _data.tool_id, JOIN('=', "root", root)), count * _size);
+    }
 }
 
 // ncclAllReduce
@@ -389,19 +613,20 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, const v
 
     if(_send_types.count(_data.tool_id) > 0)
     {
-        write_perfetto_counter_track<rccl_send>(count * _size);
+        if(get_use_perfetto()) write_perfetto_counter_track<rccl_send>(count * _size);
+        if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_send>(0, count * _size);
     }
     else if(_recv_types.count(_data.tool_id) > 0)
     {
-        write_perfetto_counter_track<rccl_recv>(count * _size);
+        if(get_use_perfetto()) write_perfetto_counter_track<rccl_recv>(count * _size);
+        if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_recv>(0, count * _size);
     }
     else
     {
         ROCPROFSYS_CI_THROW(true, "RCCL function not handled: %s", _data.tool_id.c_str());
     }
 
-    if(!rocprofsys::get_use_timemory()) return;
-    add(_data, count * _size);
+    if(rocprofsys::get_use_timemory()) add(_data, count * _size);
 }
 
 // ncclAllGather
@@ -413,10 +638,9 @@ comm_data::audit(const gotcha_data& _data, audit::incoming, const void*, const v
     int _size = rccl_type_size(datatype);
     if(_size <= 0) return;
 
-    write_perfetto_counter_track<rccl_recv>(count * _size);
-
-    if(!rocprofsys::get_use_timemory()) return;
-    add(_data, count * _size);
+    if(get_use_perfetto()) write_perfetto_counter_track<rccl_recv>(count * _size);
+    if(get_use_rocpd()) rocpd_process_cpu_usage_events<rccl_recv>(0, count * _size);
+    if(rocprofsys::get_use_timemory()) add(_data, count * _size);
 }
 #endif
 }  // namespace component
diff --git a/source/lib/rocprof-sys/library/components/comm_data.hpp b/source/lib/rocprof-sys/library/components/comm_data.hpp
index 93dfac7521..066b3dfd92 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.hpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.hpp
@@ -82,7 +82,7 @@ struct comm_data : base<comm_data, void>
     static void preinit();
     static void configure();
     static void global_finalize();
-    static void start() {}
+    static void start();
     static void stop() {}
 
 #if defined(ROCPROFSYS_USE_MPI)
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index e21058a998..b8c4a72c5d 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -21,15 +21,14 @@
 // SOFTWARE.
 
 #include "library/cpu_freq.hpp"
+#include "core/agent_manager.hpp"
 #include "core/common.hpp"
-#include "core/components/fwd.hpp"
 #include "core/config.hpp"
 #include "core/debug.hpp"
-#include "core/defines.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto.hpp"
-#include "core/timemory.hpp"
+#include "core/rocpd/data_processor.hpp"
 #include "library/components/cpu_freq.hpp"
-#include "library/thread_data.hpp"
 #include "library/thread_info.hpp"
 
 #include <timemory/components/rusage/backends.hpp>
@@ -44,7 +43,6 @@
 #include <sys/resource.h>
 #include <tuple>
 #include <utility>
-#include <vector>
 
 namespace rocprofsys
 {
@@ -65,6 +63,191 @@ init_perfetto_counter_tracks(type_list<Types...>)
 {
     (perfetto_counter_track<Types>::init(), ...);
 }
+
+template <typename Category>
+inline std::string
+get_cpu_freq_track_name(uint64_t cpu_id)
+{
+    return std::string(trait::name<Category>::value) + " [" + std::to_string(cpu_id) +
+           "]";
+}
+
+template <typename Func>
+void
+do_for_enabled_cpus(Func&& func)
+{
+    const auto& enabled_cpus = component::cpu_freq::get_enabled_cpus();
+    for(const auto& cpu : enabled_cpus)
+    {
+        func(cpu);
+    }
+}
+
+rocpd::data_processor&
+get_data_processor()
+{
+    return rocpd::data_processor::get_instance();
+}
+
+void
+rocpd_initialize_cpu_freq_category()
+{
+    get_data_processor().insert_category(ROCPROFSYS_CATEGORY_CPU_FREQ,
+                                         trait::name<category::cpu_freq>::value);
+}
+
+size_t
+rocpd_initialize_thread_info(size_t tid)
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    return data_processor.insert_thread_info(n_info.id, getppid(), getpid(), tid,
+                                             JOIN(" ", "Thread", tid).c_str(), 0, 0,
+                                             "{}");
+}
+
+void
+rocpd_initialize_cpu_freq_tracks(size_t thread_idx)
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    do_for_enabled_cpus([&](size_t cpu_id) {
+        data_processor.insert_track(
+            get_cpu_freq_track_name<category::cpu_freq>(cpu_id).c_str(), n_info.id,
+            getpid(), thread_idx);
+    });
+}
+
+void
+rocpd_initialize_cpu_usage_tracks(size_t thread_idx)
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    data_processor.insert_track(trait::name<category::process_page>::value, n_info.id,
+                                getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_virt>::value, n_info.id,
+                                getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_peak>::value, n_info.id,
+                                getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_context_switch>::value,
+                                n_info.id, getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_page_fault>::value,
+                                n_info.id, getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_user_mode_time>::value,
+                                n_info.id, getpid(), thread_idx);
+    data_processor.insert_track(trait::name<category::process_kernel_mode_time>::value,
+                                n_info.id, getpid(), thread_idx);
+}
+
+void
+rocpd_initialize_cpu_freq_pmc(size_t dev_id)
+{
+    auto& data_processor = get_data_processor();
+    // find the proper values for a following definitions
+    size_t      EVENT_CODE       = 0;
+    size_t      INSTANCE_ID      = 0;
+    const char* LONG_DESCRIPTION = "";
+    const char* COMPONENT        = "";
+    const char* BLOCK            = "";
+    const char* EXPRESSION       = "";
+    const char* MEMORY           = "MB";
+    const char* TIME             = "sec";
+    auto        ni               = node_info::get_instance();
+    const auto* TARGET_ARCH      = "CPU";
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto base_id = agent_mngr.get_agent_by_id(dev_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+
+    do_for_enabled_cpus([&](size_t cpu_id) {
+        data_processor.insert_pmc_description(
+            ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+            get_cpu_freq_track_name<category::cpu_freq>(cpu_id).c_str(), "Frequency",
+            trait::name<category::cpu_freq>::description, LONG_DESCRIPTION, COMPONENT,
+            component::cpu_freq::display_unit().c_str(), "ABS", BLOCK, EXPRESSION, 0, 0);
+    });
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_page>::value, "Memory Usage",
+        trait::name<category::process_page>::description, LONG_DESCRIPTION, COMPONENT,
+        MEMORY, "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_virt>::value, "Virtual Memory Usage",
+        trait::name<category::process_virt>::description, LONG_DESCRIPTION, COMPONENT,
+        MEMORY, "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_peak>::value, "Peak Memory",
+        trait::name<category::process_peak>::description, LONG_DESCRIPTION, COMPONENT,
+        MEMORY, "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_context_switch>::value, "Context Switches",
+        trait::name<category::process_context_switch>::description, LONG_DESCRIPTION,
+        COMPONENT, "", "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_page_fault>::value, "Page Faults",
+        trait::name<category::process_page_fault>::description, LONG_DESCRIPTION,
+        COMPONENT, "", "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_user_mode_time>::value, "User Time",
+        trait::name<category::process_user_mode_time>::description, LONG_DESCRIPTION,
+        COMPONENT, TIME, "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        trait::name<category::process_kernel_mode_time>::value, "Kernel Time",
+        trait::name<category::process_kernel_mode_time>::description, LONG_DESCRIPTION,
+        COMPONENT, TIME, "ABS", BLOCK, EXPRESSION, 0, 0);
+}
+
+void
+rocpd_process_cpu_usage_events(const uint32_t device_id, uint64_t timestamp,
+                               const component::cpu_freq& freq, double mem_page,
+                               double virt_mem_page, double peak_mem,
+                               double context_switch, double page_fault, double user_time,
+                               double kernel_time)
+{
+    auto& data_processor = get_data_processor();
+    auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_CPU_FREQ, 0, 0, 0);
+
+    auto& agent_mngr = rocpd::agent_manager::get_instance();
+    auto  base_id =
+        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+
+    auto insert_event_and_sample = [&](const char* name, double value) {
+        data_processor.insert_pmc_event(event_id, base_id, name, value);
+        data_processor.insert_sample(name, timestamp, event_id);
+    };
+
+    do_for_enabled_cpus([&](size_t cpu_id) {
+        insert_event_and_sample(
+            get_cpu_freq_track_name<category::cpu_freq>(cpu_id).c_str(), freq.at(cpu_id));
+    });
+
+    insert_event_and_sample(trait::name<category::process_page>::value, mem_page);
+    insert_event_and_sample(trait::name<category::process_virt>::value, virt_mem_page);
+    insert_event_and_sample(trait::name<category::process_peak>::value, peak_mem);
+    insert_event_and_sample(trait::name<category::process_context_switch>::value,
+                            context_switch);
+    insert_event_and_sample(trait::name<category::process_page_fault>::value, page_fault);
+    insert_event_and_sample(trait::name<category::process_user_mode_time>::value,
+                            user_time);
+    insert_event_and_sample(trait::name<category::process_kernel_mode_time>::value,
+                            kernel_time);
+}
+
 }  // namespace
 }  // namespace cpu_freq
 }  // namespace rocprofsys
@@ -76,11 +259,14 @@ namespace cpu_freq
 void
 setup()
 {
-    init_perfetto_counter_tracks(
-        type_list<category::cpu_freq, category::process_page, category::process_virt,
-                  category::process_peak, category::process_context_switch,
-                  category::process_page_fault, category::process_user_mode_time,
-                  category::process_kernel_mode_time>{});
+    if(get_use_perfetto())
+    {
+        init_perfetto_counter_tracks(
+            type_list<category::cpu_freq, category::process_page, category::process_virt,
+                      category::process_peak, category::process_context_switch,
+                      category::process_page_fault, category::process_user_mode_time,
+                      category::process_kernel_mode_time>{});
+    }
 }
 
 void
@@ -163,6 +349,29 @@ post_process()
     ROCPROFSYS_VERBOSE(1,
                        "Post-processing %zu cpu frequency and memory usage entries...\n",
                        data.size());
+
+    auto& enabled_cpus = component::cpu_freq::get_enabled_cpus();
+
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_cpu_freq_category();
+        auto thread_idx = rocpd_initialize_thread_info(gettid());
+        rocpd_initialize_cpu_usage_tracks(thread_idx);
+        rocpd_initialize_cpu_freq_tracks(thread_idx);
+
+        // `get_enabled_cpus()` returns the number of cores enabled for monitoring but the
+        // actuall device_id is 0, since there is a single device avaliable. And the
+        // agents seems to be assigned per device basis not per core.
+        // TODO: `get_enabled_cpus()` should be fixed in the future to align with GPU
+        // implementation.
+        auto cpu_agents = rocpd::agent_manager::get_instance().get_agents_by_type(
+            ROCPROFILER_AGENT_TYPE_CPU);
+        for(auto& agent : cpu_agents)
+        {
+            rocpd_initialize_cpu_freq_pmc(agent->device_id);
+        }
+    }
+
     auto _process_frequencies = [](size_t _idx, size_t _offset) {
         using freq_track = perfetto_counter_track<category::cpu_freq>;
 
@@ -191,14 +400,17 @@ post_process()
     };
 
     auto _process_cpu_rusage = []() {
-        config_perfetto_counter_tracks(
-            type_list<category::process_page, category::process_virt,
-                      category::process_peak, category::process_context_switch,
-                      category::process_page_fault, category::process_user_mode_time,
-                      category::process_kernel_mode_time>{},
-            { "Memory Usage", "Virtual Memory Usage", "Peak Memory", "Context Switches",
-              "Page Faults", "User Time", "Kernel Time" },
-            { "MB", "MB", "MB", "", "", "sec", "sec" });
+        if(get_use_perfetto())
+        {
+            config_perfetto_counter_tracks(
+                type_list<category::process_page, category::process_virt,
+                          category::process_peak, category::process_context_switch,
+                          category::process_page_fault, category::process_user_mode_time,
+                          category::process_kernel_mode_time>{},
+                { "Memory Usage", "Virtual Memory Usage", "Peak Memory",
+                  "Context Switches", "Page Faults", "User Time", "Kernel Time" },
+                { "MB", "MB", "MB", "", "", "sec", "sec" });
+        }
 
         const auto& _thread_info = thread_info::get(0, InternalTID);
         ROCPROFSYS_CI_THROW(!_thread_info, "Missing thread info for thread 0");
@@ -209,47 +421,61 @@ post_process()
             uint64_t _ts = std::get<0>(itr);
             if(!_thread_info->is_valid_time(_ts)) continue;
 
-            double   _page = std::get<1>(itr);
-            double   _virt = std::get<2>(itr);
-            double   _peak = std::get<3>(itr);
+            double   _page = std::get<1>(itr) / units::megabyte;
+            double   _virt = std::get<2>(itr) / units::megabyte;
+            double   _peak = std::get<3>(itr) / units::megabyte;
             uint64_t _cntx = std::get<4>(itr);
             uint64_t _flts = std::get<5>(itr);
-            double   _user = std::get<6>(itr);
-            double   _kern = std::get<7>(itr);
-            write_perfetto_counter_track<category::process_page>(_ts,
-                                                                 _page / units::megabyte);
-            write_perfetto_counter_track<category::process_virt>(_ts,
-                                                                 _virt / units::megabyte);
-            write_perfetto_counter_track<category::process_peak>(_ts,
-                                                                 _peak / units::megabyte);
-            write_perfetto_counter_track<category::process_context_switch>(_ts, _cntx);
-            write_perfetto_counter_track<category::process_page_fault>(_ts, _flts);
-            write_perfetto_counter_track<category::process_user_mode_time>(
-                _ts, _user / units::sec);
-            write_perfetto_counter_track<category::process_kernel_mode_time>(
-                _ts, _kern / units::sec);
+            double   _user = std::get<6>(itr) / units::sec;
+            double   _kern = std::get<7>(itr) / units::sec;
+            if(get_use_perfetto())
+            {
+                write_perfetto_counter_track<category::process_page>(_ts, _page);
+                write_perfetto_counter_track<category::process_virt>(_ts, _virt);
+                write_perfetto_counter_track<category::process_peak>(_ts, _peak);
+                write_perfetto_counter_track<category::process_context_switch>(_ts,
+                                                                               _cntx);
+                write_perfetto_counter_track<category::process_page_fault>(_ts, _flts);
+                write_perfetto_counter_track<category::process_user_mode_time>(_ts,
+                                                                               _user);
+                write_perfetto_counter_track<category::process_kernel_mode_time>(_ts,
+                                                                                 _kern);
+            }
+            if(get_use_rocpd())
+            {
+                const auto& freq_data = std::get<8>(itr);
+                rocpd_process_cpu_usage_events(0, _ts, freq_data, _page, _virt, _peak,
+                                               _cntx, _flts, _user, _kern);
+            }
         }
 
-        auto _end_ts = _thread_info->get_stop();
-        write_perfetto_counter_track<category::process_page>(_end_ts, 0.0);
-        write_perfetto_counter_track<category::process_virt>(_end_ts, 0.0);
-        write_perfetto_counter_track<category::process_peak>(_end_ts, 0.0);
-        write_perfetto_counter_track<category::process_context_switch>(_end_ts, 0);
-        write_perfetto_counter_track<category::process_page_fault>(_end_ts, 0);
-        write_perfetto_counter_track<category::process_user_mode_time>(_end_ts, 0.0);
-        write_perfetto_counter_track<category::process_kernel_mode_time>(_end_ts, 0.0);
+        if(get_use_perfetto())
+        {
+            auto _end_ts = _thread_info->get_stop();
+            write_perfetto_counter_track<category::process_page>(_end_ts, 0.0);
+            write_perfetto_counter_track<category::process_virt>(_end_ts, 0.0);
+            write_perfetto_counter_track<category::process_peak>(_end_ts, 0.0);
+            write_perfetto_counter_track<category::process_context_switch>(_end_ts, 0);
+            write_perfetto_counter_track<category::process_page_fault>(_end_ts, 0);
+            write_perfetto_counter_track<category::process_user_mode_time>(_end_ts, 0.0);
+            write_perfetto_counter_track<category::process_kernel_mode_time>(_end_ts,
+                                                                             0.0);
+        }
     };
 
     _process_cpu_rusage();
 
-    auto& enabled_cpu_freqs = component::cpu_freq::get_enabled_cpus();
-    for(auto itr = enabled_cpu_freqs.begin(); itr != enabled_cpu_freqs.end(); ++itr)
+    if(get_use_perfetto())
     {
-        auto _idx    = *itr;
-        auto _offset = std::distance(enabled_cpu_freqs.begin(), itr);
-        _process_frequencies(_idx, _offset);
+        for(auto itr = enabled_cpus.begin(); itr != enabled_cpus.end(); ++itr)
+        {
+            auto _idx    = *itr;
+            auto _offset = std::distance(enabled_cpus.begin(), itr);
+            _process_frequencies(_idx, _offset);
+        }
     }
-    enabled_cpu_freqs.clear();
+    enabled_cpus.clear();
 }
+
 }  // namespace cpu_freq
 }  // namespace rocprofsys
diff --git a/source/lib/rocprof-sys/library/kokkosp.cpp b/source/lib/rocprof-sys/library/kokkosp.cpp
index b74ec5d4a4..6ba03e0344 100644
--- a/source/lib/rocprof-sys/library/kokkosp.cpp
+++ b/source/lib/rocprof-sys/library/kokkosp.cpp
@@ -23,11 +23,15 @@
 #define TIMEMORY_KOKKOSP_POSTFIX ROCPROFSYS_PUBLIC_API
 
 #include "api.hpp"
+#include "core/agent_manager.hpp"
 #include "core/components/fwd.hpp"
 #include "core/config.hpp"
 #include "core/debug.hpp"
 #include "core/defines.hpp"
+#include "core/node_info.hpp"
 #include "core/perfetto.hpp"
+#include "core/rocpd/data_processor.hpp"
+#include "core/rocpd/json.hpp"
 #include "library/components/category_region.hpp"
 #include "library/runtime.hpp"
 
@@ -150,6 +154,51 @@ violates_name_rules(Arg&& _arg, Args&&... _args)
 }
 }  // namespace
 
+namespace
+{
+rocprofsys::rocpd::data_processor&
+get_data_processor()
+{
+    return rocprofsys::rocpd::data_processor::get_instance();
+}
+
+void
+rocpd_initialize_kokkos_category()
+{
+    get_data_processor().insert_category(
+        rocprofsys::category_enum_id<category::kokkos>::value,
+        rocprofsys::trait::name<category::kokkos>::value);
+}
+
+void
+rocpd_initialize_kokos_track()
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = rocprofsys::node_info::get_instance();
+
+    data_processor.insert_track(rocprofsys::trait::name<category::kokkos>::value,
+                                n_info.id, getpid(), gettid());
+}
+
+void
+rocpd_process_kokos_event(const char* name, const char* event_type, const char* target,
+                          uint64_t timestamp_ns)
+{
+    auto& data_processor = get_data_processor();
+    auto  event_metadata = rocpd::json::create();
+
+    event_metadata->set("name", name);
+    event_metadata->set("event_type", event_type);
+    event_metadata->set("target", target);
+
+    auto event_id = data_processor.insert_event(
+        rocprofsys::category_enum_id<category::kokkos>::value, 0, 0, 0, "{}", "{}",
+        event_metadata->to_string().c_str());
+    data_processor.insert_sample(rocprofsys::trait::name<category::kokkos>::value,
+                                 timestamp_ns, event_id, "{}");
+}
+
+}  // namespace
 //--------------------------------------------------------------------------------------//
 
 extern "C"
@@ -256,6 +305,12 @@ extern "C"
             rocprofsys_set_mpi_hidden(false, false);
             rocprofsys_init_hidden(_mode.c_str(), false, _arg0.c_str());
             rocprofsys_push_trace_hidden("kokkos_main");
+
+            if(rocprofsys::get_use_rocpd())
+            {
+                rocpd_initialize_kokkos_category();
+                rocpd_initialize_kokos_track();
+            }
         }
 
         setup_kernel_logger();
@@ -545,6 +600,8 @@ extern "C"
     {
         if(violates_name_rules(label)) return;
 
+        auto timestamp = tim::get_clock_real_now<uint64_t, std::nano>();
+
         ROCPROFSYS_SCOPED_THREAD_STATE(ThreadState::Internal);
         if(rocprofsys::config::get_use_perfetto())
         {
@@ -559,12 +616,20 @@ extern "C"
                 "", label, " [dual_view_sync][", (is_device) ? "device" : "host", "]")));
             kokkosp::profiler_t<kokkosp_region>{ _name }.mark();
         }
+
+        if(rocprofsys::config::get_use_rocpd())
+        {
+            rocpd_process_kokos_event(JOIN(" ", _kp_prefix, label).c_str(),
+                                      "[dual_view_sync]", (is_device) ? "device" : "host",
+                                      timestamp);
+        }
     }
 
     void kokkosp_dual_view_modify(const char* label, const void* const, bool is_device)
     {
         if(violates_name_rules(label)) return;
 
+        auto timestamp = tim::get_clock_real_now<uint64_t, std::nano>();
         ROCPROFSYS_SCOPED_THREAD_STATE(ThreadState::Internal);
         if(rocprofsys::config::get_use_perfetto())
         {
@@ -580,6 +645,13 @@ extern "C"
                                       (is_device) ? "device" : "host", "]")));
             kokkosp::profiler_t<kokkosp_region>{ _name }.mark();
         }
+
+        if(rocprofsys::config::get_use_rocpd())
+        {
+            rocpd_process_kokos_event(JOIN(" ", _kp_prefix, label).c_str(),
+                                      "[dual_view_modify]",
+                                      (is_device) ? "device" : "host", timestamp);
+        }
     }
 
     //----------------------------------------------------------------------------------//
diff --git a/source/lib/rocprof-sys/library/sampling.cpp b/source/lib/rocprof-sys/library/sampling.cpp
index cb2ba13fe6..3fbe02afbd 100644
--- a/source/lib/rocprof-sys/library/sampling.cpp
+++ b/source/lib/rocprof-sys/library/sampling.cpp
@@ -26,7 +26,10 @@
 #include "core/config.hpp"
 #include "core/debug.hpp"
 #include "core/locking.hpp"
+#include "core/node_info.hpp"
 #include "core/perf.hpp"
+#include "core/rocpd/data_processor.hpp"
+#include "core/rocpd/json.hpp"
 #include "core/state.hpp"
 #include "core/utility.hpp"
 #include "library/components/backtrace.hpp"
@@ -153,6 +156,137 @@ namespace
 {
 using sampler_allocator_t = typename sampler_t::allocator_t;
 
+template <typename Category>
+inline std::string
+get_category_track_name(uint64_t tid)
+{
+    return std::string(trait::name<Category>::value) + "_" + std::to_string(tid);
+}
+
+std::string
+generate_call_stack_json(const tim::unwind::processed_entry& stack_entry)
+{
+    auto call_stack = ::rocpd::json::create();
+
+    call_stack->set("name", std::string(demangle(stack_entry.name)));
+    call_stack->set("pc", as_hex(stack_entry.address));
+    call_stack->set("file", std::string(stack_entry.location));
+
+    return call_stack->to_string();
+}
+
+std::string
+generate_line_info_json(const tim::unwind::processed_entry& linfo_entry)
+{
+    auto line_info = ::rocpd::json::create();
+    line_info->set("line_address", as_hex(linfo_entry.line_address));
+    line_info->set("name", std::string(demangle(linfo_entry.name)));
+
+    if(linfo_entry.lineinfo && !linfo_entry.lineinfo.lines.empty())
+    {
+        auto _lines = linfo_entry.lineinfo.lines;
+        std::reverse(_lines.begin(), _lines.end());
+        auto inlined = ::rocpd::json::create();
+        for(size_t _n = 0; _n < _lines.size(); ++_n)
+        {
+            const auto& litr = _lines[_n];
+            inlined->set("name", std::string(demangle(litr.name)));
+            inlined->set("location", std::string(litr.location));
+            inlined->set("line", std::to_string(litr.line));
+        }
+        line_info->set("inlined", inlined);
+    }
+
+    return line_info->to_string();
+}
+
+std::string
+generate_hw_counter_json(int64_t _tid, const backtrace_metrics& metrics)
+{
+    auto extdata = ::rocpd::json::create();
+
+    if(!metrics.get_hw_counters().empty())
+    {
+        auto _labels      = backtrace_metrics::get_hw_counter_labels(_tid);
+        auto _hw_cnt_vals = metrics.get_hw_counters();
+
+        auto hw_counters = ::rocpd::json::create();
+        for(size_t i = 0; i < _labels.size(); ++i)
+        {
+            hw_counters->set(_labels.at(i), _hw_cnt_vals.at(i));
+        }
+
+        extdata->set("hw_counters", hw_counters);
+    }
+
+    return extdata->to_string();
+}
+
+rocpd::data_processor&
+get_data_processor()
+{
+    return rocpd::data_processor::get_instance();
+}
+
+void
+rocpd_initialize_sampling_category()
+{
+    static bool _is_initialized = false;
+    if(_is_initialized) return;
+
+    auto& data_processor = get_data_processor();
+    data_processor.insert_category(ROCPROFSYS_CATEGORY_SAMPLING,
+                                   trait::name<category::sampling>::value);
+    data_processor.insert_category(ROCPROFSYS_CATEGORY_OVERFLOW_SAMPLING,
+                                   trait::name<category::overflow_sampling>::value);
+    data_processor.insert_category(ROCPROFSYS_CATEGORY_TIMER_SAMPLING,
+                                   trait::name<category::timer_sampling>::value);
+
+    _is_initialized = true;
+}
+
+size_t
+rocpd_initilaize_thread_info(size_t tid)
+{
+    const auto& _thread_info = thread_info::get(tid, SequentTID);
+    ROCPROFSYS_CI_THROW(!_thread_info, "No valid thread info for tid=%li\n", tid);
+    if(!_thread_info) return -1;
+
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    return data_processor.insert_thread_info(
+        n_info.id, getppid(), getpid(), _thread_info->index_data->system_value,
+        threading::get_thread_name().c_str(), _thread_info->get_start(),
+        _thread_info->get_stop(), "{}");
+}
+
+void
+rocpd_init_track(const char* track_name, int64_t tid)
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    data_processor.insert_track(track_name, n_info.id, getpid(), tid, "{}");
+}
+
+template <typename Category>
+void
+rocpd_insert_region(size_t thread_id, size_t start_time, size_t end_time, size_t name_id,
+                    const char* track, const char* call_stack = "{}",
+                    const char* line_info = "{}", const char* extdata = "{}")
+{
+    auto& data_processor = get_data_processor();
+    auto& n_info         = node_info::get_instance();
+
+    auto event_id = data_processor.insert_event(category_enum_id<Category>::value, 0, 0,
+                                                0, call_stack, line_info, extdata);
+
+    data_processor.insert_region(n_info.id, getpid(), thread_id, start_time, end_time,
+                                 name_id, event_id);
+    data_processor.insert_sample(track, start_time, event_id);
+}
+
 auto&
 get_sampler_allocators()
 {
@@ -810,6 +944,10 @@ void
 post_process_timemory(int64_t, const std::vector<timer_sampling_data>&,
                       const std::vector<overflow_sampling_data>&);
 
+void
+post_process_rocpd(int64_t _tid, const std::vector<timer_sampling_data>& _timer_data,
+                   const std::vector<overflow_sampling_data>& _overflow_data);
+
 auto static_strings = std::set<std::string>{};
 
 }  // namespace
@@ -988,6 +1126,7 @@ post_process()
 
             if(get_use_perfetto()) post_process_perfetto(i, _timer_data, _overflow_data);
             if(get_use_timemory()) post_process_timemory(i, _timer_data, _overflow_data);
+            if(get_use_rocpd()) post_process_rocpd(i, _timer_data, _overflow_data);
         }
         else
         {
@@ -1540,6 +1679,189 @@ post_process_timemory(int64_t _tid, const std::vector<timer_sampling_data>& _tim
     }
 }
 
+void
+rocpd_post_process_overflow_data(
+    int64_t _tid, const std::vector<overflow_sampling_data>& _overflow_data)
+{
+    auto& data_processor = get_data_processor();
+
+    const auto& _thread_info = thread_info::get(_tid, SequentTID);
+    ROCPROFSYS_CI_THROW(!_thread_info, "No valid thread info for tid=%li\n", _tid);
+    if(!_thread_info) return;
+
+    auto _overflow_event =
+        get_setting_value<std::string>("ROCPROFSYS_SAMPLING_OVERFLOW_EVENT").value_or("");
+
+    if(!_overflow_event.empty() && !_overflow_data.empty())
+    {
+        auto _beg_ns = std::max(_overflow_data.front().m_beg, _thread_info->get_start());
+        auto _end_ns = std::min(_overflow_data.back().m_end, _thread_info->get_stop());
+
+        const auto _overflow_prefix = std::string_view{ "PERF_COUNT_" };
+        const auto _overflow_pos    = _overflow_event.find(_overflow_prefix);
+        if(_overflow_pos != std::string::npos)
+            _overflow_event =
+                _overflow_event.substr(_overflow_pos + _overflow_prefix.length());
+
+        const auto* _main_name =
+            static_strings.emplace(join(" ", _overflow_event, "samples [rocprof-sys]"))
+                .first->c_str();
+        auto main_name_id = data_processor.insert_string(_main_name);
+
+        const auto& _track_name =
+            JOIN(" ", "Thread", _thread_info->index_data->sequent_value, "Overflow",
+                 "(S)", _thread_info->index_data->system_value);
+
+        auto thread_idx = rocpd_initilaize_thread_info(_tid);
+        rocpd_init_track(_track_name.c_str(), thread_idx);
+        rocpd_insert_region<category::overflow_sampling>(
+            thread_idx, _beg_ns, _end_ns, main_name_id, _track_name.c_str());
+
+        for(const auto& itr : _overflow_data)
+        {
+            auto _beg = itr.m_beg;
+            auto _end = itr.m_end;
+
+            if(!_thread_info->is_valid_lifetime({ _beg, _end })) continue;
+
+            for(const auto& iitr : itr.m_stack)
+            {
+                const auto* _name =
+                    static_strings.emplace(demangle(iitr.name)).first->c_str();
+                auto name_id = data_processor.insert_string(_name);
+                rocpd_insert_region<category::overflow_sampling>(
+                    thread_idx, _beg, _end, name_id, _track_name.c_str(),
+                    generate_call_stack_json(iitr).c_str(),
+                    generate_line_info_json(iitr).c_str());
+            }
+        }
+    }
+}
+
+void
+rocpd_post_process_backtrace_metrix(int64_t                                 _tid,
+                                    const std::vector<timer_sampling_data>& _timer_data)
+{
+    auto _valid_metrics = backtrace_metrics::valid_array_t{};
+
+    for(const auto& itr : _timer_data)
+    {
+        _valid_metrics |= itr.m_metrics.get_valid();
+    }
+
+    if(trait::runtime_enabled<backtrace_metrics>::get() && get_use_rocpd())
+    {
+        ROCPROFSYS_VERBOSE(3 || get_debug_sampling(),
+                           "[%li] Post-processing metrics for rocpd...\n", _tid);
+        backtrace_metrics::init_rocpd(_tid, _valid_metrics);
+        for(const auto& itr : _timer_data)
+            itr.m_metrics.post_process_rocpd(_tid, 0.5 * (itr.m_beg + itr.m_end));
+        backtrace_metrics::fini_rocpd(_tid, _valid_metrics);
+    }
+}
+
+void
+rocpd_post_process_timer_data(int64_t                                 _tid,
+                              const std::vector<timer_sampling_data>& _timer_data)
+{
+    auto& data_processor = get_data_processor();
+
+    const auto& _thread_info = thread_info::get(_tid, SequentTID);
+    ROCPROFSYS_CI_THROW(!_thread_info, "No valid thread info for tid=%li\n", _tid);
+    if(!_thread_info) return;
+
+    if(!_timer_data.empty())
+    {
+        rocpd_post_process_backtrace_metrix(_tid, _timer_data);
+
+        auto _beg_ns = std::max(_timer_data.front().m_beg, _thread_info->get_start());
+        auto _end_ns = std::min(_timer_data.back().m_end, _thread_info->get_stop());
+
+        const auto _track_name =
+            JOIN(" ", "Thread", _thread_info->index_data->sequent_value, "(S)",
+                 _thread_info->index_data->system_value);
+
+        auto thread_idx = rocpd_initilaize_thread_info(_tid);
+        rocpd_init_track(_track_name.c_str(), thread_idx);
+        const auto main_name_id = data_processor.insert_string("samples [rocprof-sys]");
+        rocpd_insert_region<category::timer_sampling>(thread_idx, _beg_ns, _end_ns,
+                                                      main_name_id, _track_name.c_str());
+
+        auto _labels = backtrace_metrics::get_hw_counter_labels(_tid);
+        for(const auto& itr : _timer_data)
+        {
+            size_t   _ncount = 0;
+            uint64_t _beg    = itr.m_beg;
+            uint64_t _end    = itr.m_end;
+            if(!_thread_info->is_valid_lifetime({ _beg, _end })) continue;
+
+            for(const auto& iitr : itr.m_stack)
+            {
+                auto _ncur = _ncount++;
+                // the begin/end + HW counters will be same for entire call-stack so only
+                // annotate the top and the bottom functons to keep the data consumption
+                // low
+                bool _include_common = (_ncur == 0 || _ncur + 1 == itr.m_stack.size());
+
+                // Only annotate HW counters when first or last and HW counters are not
+                // empty
+                bool _include_hw =
+                    _include_common && !itr.m_metrics.get_hw_counters().empty();
+
+                std::string hw_counter_json = "{}";
+                if(_include_hw)
+                {
+                    // current values when read
+                    hw_counter_json = generate_hw_counter_json(_tid, itr.m_metrics);
+                }
+
+                if(get_sampling_include_inlines() && iitr.lineinfo)
+                {
+                    auto _lines = iitr.lineinfo.lines;
+                    std::reverse(_lines.begin(), _lines.end());
+                    size_t _n = 0;
+                    for(const auto& litr : _lines)
+                    {
+                        const auto* _name =
+                            static_strings.emplace(demangle(litr.name)).first->c_str();
+                        auto inlined_name_id = data_processor.insert_string(_name);
+
+                        auto inlined_call_stack = ::rocpd::json::create();
+                        inlined_call_stack->set("name", std::string(demangle(litr.name)));
+                        inlined_call_stack->set("location", std::string(litr.location));
+                        inlined_call_stack->set("line", std::to_string(litr.line));
+                        inlined_call_stack->set("inlined", "true");
+
+                        rocpd_insert_region<category::timer_sampling>(
+                            thread_idx, _beg, _end, inlined_name_id, _track_name.c_str(),
+                            inlined_call_stack->to_string().c_str(), "{}",
+                            // Only include HW counters for first inlined function
+                            (_n == 0) ? hw_counter_json.c_str() : "{}");
+                    }
+                }
+                else
+                {
+                    const auto* _name = static_strings.emplace(iitr.name).first->c_str();
+                    const auto  name_id = data_processor.insert_string(_name);
+                    rocpd_insert_region<category::timer_sampling>(
+                        thread_idx, _beg, _end, name_id, _track_name.c_str(),
+                        generate_call_stack_json(iitr).c_str(),
+                        generate_line_info_json(iitr).c_str(), hw_counter_json.c_str());
+                }
+            }
+        }
+    }
+}
+
+void
+post_process_rocpd(int64_t _tid, const std::vector<timer_sampling_data>& _timer_data,
+                   const std::vector<overflow_sampling_data>& _overflow_data)
+{
+    rocpd_initialize_sampling_category();
+    rocpd_post_process_overflow_data(_tid, _overflow_data);
+    rocpd_post_process_timer_data(_tid, _timer_data);
+}
+
 struct sampling_initialization
 {
     static void preinit()

From 42c6f8a6aaf89196ca6f622c808ad30c9bf5f4b2 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Tue, 15 Jul 2025 05:20:16 -0400
Subject: [PATCH 02/33] Fix compile errors, copilot comments

---
 source/lib/core/gpu.cpp                       |  9 +--
 .../library/components/backtrace_metrics.cpp  | 17 +++--
 .../rocprof-sys/library/rocprofiler-sdk.cpp   | 33 +++++++---
 source/lib/rocprof-sys/library/sampling.cpp   | 65 +++++++++----------
 4 files changed, 70 insertions(+), 54 deletions(-)

diff --git a/source/lib/core/gpu.cpp b/source/lib/core/gpu.cpp
index d6c52cdcdb..82957a3f03 100644
--- a/source/lib/core/gpu.cpp
+++ b/source/lib/core/gpu.cpp
@@ -115,13 +115,14 @@ query_rocm_agents()
 {
     size_t _dev_cnt = 0;
 #if ROCPROFSYS_USE_ROCM > 0
-    auto iterator = [](rocprofiler_agent_version_t /*version*/, const void** agents,
-                       size_t num_agents, void* user_data) -> rocprofiler_status_t {
-        auto& _agent_mngr = rocpd::agent_manager::get_instance();
+    auto iterator = []([[maybe_unused]] rocprofiler_agent_version_t version,
+                       const void** agents, size_t num_agents,
+                       [[maybe_unused]] void* user_data) -> rocprofiler_status_t {
+        auto& _agent_manager = rocpd::agent_manager::get_instance();
         for(size_t i = 0; i < num_agents; ++i)
         {
             const auto* _agent = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
-            _agent_mngr.insert_agent(_agent);
+            _agent_manager.insert_agent(_agent);
         }
         return ROCPROFILER_STATUS_SUCCESS;
     };
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index f0afb5f6fa..a5c7d356af 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -643,30 +643,33 @@ backtrace_metrics::post_process_perfetto(int64_t _tid, uint64_t _ts) const
 void
 backtrace_metrics::post_process_rocpd(int64_t _tid, uint64_t _ts) const
 {
-    if((*this)(category::thread_cpu_time{}))
+    auto is_category_enabled = [&](const auto& _category) { return (*this)(_category); };
+
+    if(is_category_enabled(category::thread_cpu_time{}))
     {
         rocpd_process_backtrace_metrics_events<category::thread_cpu_time, double>(
             0, _ts, m_cpu / units::sec, _tid);
     }
 
-    if((*this)(category::thread_peak_memory{}))
+    if(is_category_enabled(category::thread_peak_memory{}))
     {
         rocpd_process_backtrace_metrics_events<category::thread_peak_memory, double>(
             0, _ts, m_mem_peak / units::megabyte, _tid);
     }
 
-    if((*this)(category::thread_context_switch{}))
+    if(is_category_enabled(category::thread_context_switch{}))
     {
-        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, int64_t>(
+        rocpd_process_backtrace_metrics_events<category::thread_context_switch, int64_t>(
             0, _ts, m_ctx_swch, _tid);
     }
 
-    if((*this)(category::thread_page_fault{}))
+    if(is_category_enabled(category::thread_page_fault{}))
     {
-        rocpd_process_backtrace_metrics_events<category::thread_peak_memory, int64_t>(
+        rocpd_process_backtrace_metrics_events<category::thread_page_fault, int64_t>(
             0, _ts, m_page_flt, _tid);
     }
-    if((*this)(type_list<hw_counters>{}) && (*this)(category::thread_hardware_counter{}))
+    if(is_category_enabled(type_list<hw_counters>{}) &&
+       is_category_enabled(category::thread_hardware_counter{}))
     {
         rocpd_process_backtrace_metrics_events<category::thread_hardware_counter,
                                                hw_counter_data_t>(0, _ts, m_hw_counter,
diff --git a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
index e7494f4657..75778fa618 100644
--- a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
+++ b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
@@ -564,6 +564,12 @@ tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
                                     record.kind);
                 break;
             }
+            default:
+            {
+                ROCPROFSYS_CI_ABORT(true, "Unhandled callback record kind: %i\n",
+                                    record.kind);
+                break;
+            }
         }
     }
     else if(record.phase == ROCPROFILER_CALLBACK_PHASE_EXIT)
@@ -664,6 +670,12 @@ tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
                                     record.kind);
                 break;
             }
+            default:
+            {
+                ROCPROFSYS_CI_ABORT(true, "Unhandled callback record kind: %i\n",
+                                    record.kind);
+                break;
+            }
         }
     }
     else if(record.phase == ROCPROFILER_CALLBACK_PHASE_NONE)
@@ -956,10 +968,10 @@ counter_record_callback(rocprofiler_dispatch_counting_service_data_t dispatch_da
             ROCPROFSYS_CONDITIONAL_ABORT_F(
                 !_agent, "unable to find tool agent for agent (id=%zu)\n",
                 _agent_id.handle);
-            ROCPROFSYS_CONDITIONAL_ABORT_F(
-                !_info,
-                "unable to find counter info for counter (id=%zu) on agent (id=%zu)\n",
-                itr.first.handle, _agent_id.handle);
+            ROCPROFSYS_CONDITIONAL_ABORT_F(!_info,
+                                           "unable to find counter info for counter "
+                                           "(id=%zu) on agent (id=%zu)\n",
+                                           itr.first.handle, _agent_id.handle);
 
             auto _dev_id = static_cast<uint32_t>(_agent->device_id);
 
@@ -1132,8 +1144,8 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
 
         // ROCPROFILER_CALL(rocprofiler_configure_external_correlation_id_request_service(
         //     _data->primary_ctx, external_corr_id_request_kinds.data(),
-        //     external_corr_id_request_kinds.size(), external_correlation_id_callback,
-        //     _data));
+        //     external_corr_id_request_kinds.size(),
+        //     external_correlation_id_callback, _data));
     }
 
     if(_buffered_domain.count(ROCPROFILER_BUFFER_TRACING_MEMORY_COPY) > 0)
@@ -1198,8 +1210,9 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
         }
     }
 
-    // throwaway context for handling the profiler control API. If primary_ctx were used,
-    // we would get profiler pause callback but never get profiler resume callback
+    // throwaway context for handling the profiler control API. If primary_ctx were
+    // used, we would get profiler pause callback but never get profiler resume
+    // callback
     {
         auto _local_ctx = rocprofiler_context_id_t{ 0 };
         ROCPROFILER_CALL(rocprofiler_create_context(&_local_ctx));
@@ -1210,8 +1223,8 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
 
     if(!is_valid(_data->primary_ctx))
     {
-        // notify rocprofiler that initialization failed and all the contexts, buffers,
-        // etc. created should be ignored
+        // notify rocprofiler that initialization failed and all the contexts,
+        // buffers, etc. created should be ignored
         return -1;
     }
 
diff --git a/source/lib/rocprof-sys/library/sampling.cpp b/source/lib/rocprof-sys/library/sampling.cpp
index 3fbe02afbd..f074164e4c 100644
--- a/source/lib/rocprof-sys/library/sampling.cpp
+++ b/source/lib/rocprof-sys/library/sampling.cpp
@@ -176,25 +176,24 @@ generate_call_stack_json(const tim::unwind::processed_entry& stack_entry)
 }
 
 std::string
-generate_line_info_json(const tim::unwind::processed_entry& linfo_entry)
+generate_line_info_json(const tim::unwind::processed_entry& line_info_entry)
 {
     auto line_info = ::rocpd::json::create();
-    line_info->set("line_address", as_hex(linfo_entry.line_address));
-    line_info->set("name", std::string(demangle(linfo_entry.name)));
+    line_info->set("line_address", as_hex(line_info_entry.line_address));
+    line_info->set("name", std::string(demangle(line_info_entry.name)));
 
-    if(linfo_entry.lineinfo && !linfo_entry.lineinfo.lines.empty())
+    if(line_info_entry.lineinfo && !line_info_entry.lineinfo.lines.empty())
     {
-        auto _lines = linfo_entry.lineinfo.lines;
+        auto _lines = line_info_entry.lineinfo.lines;
         std::reverse(_lines.begin(), _lines.end());
-        auto inlined = ::rocpd::json::create();
-        for(size_t _n = 0; _n < _lines.size(); ++_n)
+        for(const auto& line : _lines)
         {
-            const auto& litr = _lines[_n];
-            inlined->set("name", std::string(demangle(litr.name)));
-            inlined->set("location", std::string(litr.location));
-            inlined->set("line", std::to_string(litr.line));
+            auto inlined = ::rocpd::json::create();
+            inlined->set("name", std::string(demangle(line.name)));
+            inlined->set("location", std::string(line.location));
+            inlined->set("line", std::to_string(line.line));
+            line_info->set("inlined", inlined);
         }
-        line_info->set("inlined", inlined);
     }
 
     return line_info->to_string();
@@ -246,7 +245,7 @@ rocpd_initialize_sampling_category()
 }
 
 size_t
-rocpd_initilaize_thread_info(size_t tid)
+rocpd_initialize_thread_info(size_t tid)
 {
     const auto& _thread_info = thread_info::get(tid, SequentTID);
     ROCPROFSYS_CI_THROW(!_thread_info, "No valid thread info for tid=%li\n", tid);
@@ -1077,15 +1076,15 @@ post_process()
 
         auto _raw_data    = _sampler->get_data();
         auto _loaded_data = load_offload_buffer(i);
-        for(auto litr : _loaded_data)
+        for(auto line : _loaded_data)
         {
-            while(!litr.is_empty())
+            while(!line.is_empty())
             {
                 auto _v = sampler_bundle_t{};
-                litr.read(&_v);
+                line.read(&_v);
                 _raw_data.emplace_back(std::move(_v));
             }
-            litr.destroy();
+            line.destroy();
         }
 
         ROCPROFSYS_VERBOSE(2 || get_debug_sampling(),
@@ -1344,13 +1343,13 @@ post_process_perfetto(int64_t _tid, const std::vector<timer_sampling_data>& _tim
                                 auto _lines = iitr.lineinfo.lines;
                                 std::reverse(_lines.begin(), _lines.end());
                                 size_t _n = 0;
-                                for(const auto& litr : _lines)
+                                for(const auto& line : _lines)
                                 {
                                     auto _label = JOIN('-', "lineinfo", _n++);
                                     tracing::add_perfetto_annotation(
                                         ctx, _label.c_str(),
-                                        JOIN('@', demangle(litr.name),
-                                             JOIN(':', litr.location, litr.line)));
+                                        JOIN('@', demangle(line.name),
+                                             JOIN(':', line.location, line.line)));
                                 }
                             }
                         }
@@ -1437,11 +1436,11 @@ post_process_perfetto(int64_t _tid, const std::vector<timer_sampling_data>& _tim
                     auto _lines = iitr.lineinfo.lines;
                     std::reverse(_lines.begin(), _lines.end());
                     size_t _n = 0;
-                    for(const auto& litr : _lines)
+                    for(const auto& line : _lines)
                     {
                         const auto* _name =
-                            static_strings.emplace(demangle(litr.name)).first->c_str();
-                        auto _info = JOIN(':', litr.location, litr.line);
+                            static_strings.emplace(demangle(line.name)).first->c_str();
+                        auto _info = JOIN(':', line.location, line.line);
                         tracing::push_perfetto_track(
                             category::timer_sampling{}, _name, _track, _beg,
                             [&](::perfetto::EventContext ctx) {
@@ -1481,13 +1480,13 @@ post_process_perfetto(int64_t _tid, const std::vector<timer_sampling_data>& _tim
                                     auto _lines = iitr.lineinfo.lines;
                                     std::reverse(_lines.begin(), _lines.end());
                                     size_t _n = 0;
-                                    for(const auto& litr : _lines)
+                                    for(const auto& line : _lines)
                                     {
                                         auto _label = JOIN('-', "lineinfo", _n++);
                                         tracing::add_perfetto_annotation(
                                             ctx, _label.c_str(),
-                                            JOIN('@', demangle(litr.name),
-                                                 JOIN(':', litr.location, litr.line)));
+                                            JOIN('@', demangle(line.name),
+                                                 JOIN(':', line.location, line.line)));
                                     }
                                 }
                             }
@@ -1712,7 +1711,7 @@ rocpd_post_process_overflow_data(
             JOIN(" ", "Thread", _thread_info->index_data->sequent_value, "Overflow",
                  "(S)", _thread_info->index_data->system_value);
 
-        auto thread_idx = rocpd_initilaize_thread_info(_tid);
+        auto thread_idx = rocpd_initialize_thread_info(_tid);
         rocpd_init_track(_track_name.c_str(), thread_idx);
         rocpd_insert_region<category::overflow_sampling>(
             thread_idx, _beg_ns, _end_ns, main_name_id, _track_name.c_str());
@@ -1781,7 +1780,7 @@ rocpd_post_process_timer_data(int64_t                                 _tid,
             JOIN(" ", "Thread", _thread_info->index_data->sequent_value, "(S)",
                  _thread_info->index_data->system_value);
 
-        auto thread_idx = rocpd_initilaize_thread_info(_tid);
+        auto thread_idx = rocpd_initialize_thread_info(_tid);
         rocpd_init_track(_track_name.c_str(), thread_idx);
         const auto main_name_id = data_processor.insert_string("samples [rocprof-sys]");
         rocpd_insert_region<category::timer_sampling>(thread_idx, _beg_ns, _end_ns,
@@ -1820,16 +1819,16 @@ rocpd_post_process_timer_data(int64_t                                 _tid,
                     auto _lines = iitr.lineinfo.lines;
                     std::reverse(_lines.begin(), _lines.end());
                     size_t _n = 0;
-                    for(const auto& litr : _lines)
+                    for(const auto& line : _lines)
                     {
                         const auto* _name =
-                            static_strings.emplace(demangle(litr.name)).first->c_str();
+                            static_strings.emplace(demangle(line.name)).first->c_str();
                         auto inlined_name_id = data_processor.insert_string(_name);
 
                         auto inlined_call_stack = ::rocpd::json::create();
-                        inlined_call_stack->set("name", std::string(demangle(litr.name)));
-                        inlined_call_stack->set("location", std::string(litr.location));
-                        inlined_call_stack->set("line", std::to_string(litr.line));
+                        inlined_call_stack->set("name", std::string(demangle(line.name)));
+                        inlined_call_stack->set("location", std::string(line.location));
+                        inlined_call_stack->set("line", std::to_string(line.line));
                         inlined_call_stack->set("inlined", "true");
 
                         rocpd_insert_region<category::timer_sampling>(

From 72f9dbc30f1bf167c1e58c50c95b6ddf7ef8f51f Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Tue, 15 Jul 2025 06:02:53 -0400
Subject: [PATCH 03/33] Fix shadowed variables

---
 .../lib/core/rocpd/data_storage/database.hpp  | 25 ++++++++++---------
 .../library/components/backtrace_metrics.cpp  | 10 ++++----
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/source/lib/core/rocpd/data_storage/database.hpp b/source/lib/core/rocpd/data_storage/database.hpp
index 54e18fbe13..3c36d5598e 100644
--- a/source/lib/core/rocpd/data_storage/database.hpp
+++ b/source/lib/core/rocpd/data_storage/database.hpp
@@ -128,36 +128,37 @@ class database
         return [stmt, query, this](Values... value) {
             std::lock_guard lock{ _mutex };
             int             position   = 1;
-            auto            bind_value = [&](auto value) {
-                using T = decltype(value);
+            auto            bind_value = [&](auto _value) {
+                using T = decltype(_value);
                 if constexpr(std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
                 {
                     validate_sqlite3_result(
-                        sqlite3_bind_int(stmt.get(), position, value), query.c_str(),
+                        sqlite3_bind_int(stmt.get(), position, _value), query.c_str(),
                         "Failed to bind int32_t/uint32_t! Position: ", position,
-                        ", Value: ", value);
+                        ", Value: ", _value);
                 }
                 else if constexpr(std::is_same_v<T, int64_t> ||
                                   std::is_same_v<T, uint64_t>)
                 {
                     validate_sqlite3_result(
-                        sqlite3_bind_int64(stmt.get(), position, value), query.c_str(),
+                        sqlite3_bind_int64(stmt.get(), position, _value), query.c_str(),
                         "Failed to bind int64_t/uint64_t! Position: ", position,
-                        ", Value: ", value);
+                        ", Value: ", _value);
                 }
                 else if constexpr(std::is_floating_point_v<T>)
                 {
                     validate_sqlite3_result(
-                        sqlite3_bind_double(stmt.get(), position, value), query.c_str(),
+                        sqlite3_bind_double(stmt.get(), position, _value), query.c_str(),
                         "Failed to bind double! Position: ", position,
-                        ", Value: ", value);
+                        ", Value: ", _value);
                 }
                 else if constexpr(common::traits::is_string_literal_v<std::decay_t<T>>)
                 {
-                    validate_sqlite3_result(
-                        sqlite3_bind_text(stmt.get(), position, value, -1, SQLITE_STATIC),
-                        query.c_str(), "Failed to bind text! Position: ", position,
-                        ", Value: ", value);
+                    validate_sqlite3_result(sqlite3_bind_text(stmt.get(), position,
+                                                                         _value, -1, SQLITE_STATIC),
+                                                       query.c_str(),
+                                                       "Failed to bind text! Position: ", position,
+                                                       ", Value: ", _value);
                 }
                 else
                 {
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index a5c7d356af..9f3cf813eb 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -453,23 +453,23 @@ rocpd_process_backtrace_metrics_events(const uint32_t device_id, uint64_t timest
     auto  base_id =
         agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
 
-    auto insert_event_and_sample = [&](const char* name, double value) {
-        data_processor.insert_pmc_event(event_id, base_id, name, value);
+    auto insert_event_and_sample = [&](const char* name, double _value) {
+        data_processor.insert_pmc_event(event_id, base_id, name, _value);
         data_processor.insert_sample(name, timestamp, event_id);
     };
 
     if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
     {
         auto        _hw_cnt_labels = *get_papi_labels(_tid);
-        const auto& hw_counters =
+        const auto& _hw_counters =
             static_cast<backtrace_metrics::hw_counter_data_t>(value);
-        for(size_t i = 0; i < _hw_cnt_labels.size() && i < hw_counters.size(); ++i)
+        for(size_t i = 0; i < _hw_cnt_labels.size() && i < _hw_counters.size(); ++i)
         {
             std::string _desc = tim::papi::get_event_info(_hw_cnt_labels[i]).short_descr;
             if(_desc.empty()) _desc = _hw_cnt_labels[i];
             std::string track_name = JOIN(' ', "Thread", _desc, _tid_name, "(S)");
 
-            insert_event_and_sample(track_name.c_str(), hw_counters.at(i));
+            insert_event_and_sample(track_name.c_str(), _hw_counters.at(i));
         }
     }
     else

From a30bc6c9b7975161afdfee5baca2af9656b9c3fa Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Tue, 15 Jul 2025 06:36:10 -0400
Subject: [PATCH 04/33] Fix agent include when ROCM is not used

---
 source/lib/core/agent.hpp                      | 10 +++++-----
 source/lib/core/agent_manager.cpp              |  3 +++
 source/lib/core/agent_manager.hpp              | 17 +++++++++++++++--
 source/lib/rocprof-sys/library.cpp             |  4 +++-
 .../library/rocprofiler-sdk/counters.cpp       | 18 +-----------------
 5 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/source/lib/core/agent.hpp b/source/lib/core/agent.hpp
index faa74d7a4c..b3b5b57fbb 100644
--- a/source/lib/core/agent.hpp
+++ b/source/lib/core/agent.hpp
@@ -23,10 +23,9 @@
 #pragma once
 
 #include <cstddef>
-#include <rocprofiler-sdk/agent.h>
-
 #if ROCPROFSYS_USE_ROCM > 0
 #    include <amd_smi/amdsmi.h>
+#    include <rocprofiler-sdk/agent.h>
 #endif
 
 namespace rocprofsys
@@ -36,10 +35,11 @@ namespace rocpd
 
 struct agent
 {
+#if ROCPROFSYS_USE_ROCM > 0
     const rocprofiler_agent_v0_t* agent = nullptr;
-    size_t                        device_id{ 0 };
-    size_t                        base_id{ 0 };
-
+#endif
+    size_t device_id{ 0 };
+    size_t base_id{ 0 };
 #if ROCPROFSYS_USE_ROCM > 0
     amdsmi_processor_handle smi_handle = nullptr;
 #endif
diff --git a/source/lib/core/agent_manager.cpp b/source/lib/core/agent_manager.cpp
index 99a26706f4..5e19f59e8a 100644
--- a/source/lib/core/agent_manager.cpp
+++ b/source/lib/core/agent_manager.cpp
@@ -36,6 +36,7 @@ agent_manager::get_instance()
     return instance;
 }
 
+#if ROCPROFSYS_USE_ROCM > 0
 void
 agent_manager::insert_agent(const rocprofiler_agent_v0_t* _agent)
 {
@@ -110,6 +111,8 @@ agent_manager::get_agent_by_handle(size_t device_handle) const
     return **_agent;
 }
 
+#endif
+
 std::vector<std::shared_ptr<agent>>
 agent_manager::get_agents_by_type(rocprofiler_agent_type_t type) const
 {
diff --git a/source/lib/core/agent_manager.hpp b/source/lib/core/agent_manager.hpp
index 0e45d49a94..c1f3ea34af 100644
--- a/source/lib/core/agent_manager.hpp
+++ b/source/lib/core/agent_manager.hpp
@@ -27,8 +27,19 @@
 
 #include "agent.hpp"
 
+#if ROCPROFSYS_USE_ROCM <= 0
+typedef enum rocprofiler_agent_type_t  // NOLINT(performance-enum-size)
+{
+    ROCPROFILER_AGENT_TYPE_NONE = 0,  ///< Agent type is unknown
+    ROCPROFILER_AGENT_TYPE_CPU,       ///< Agent type is a CPU
+    ROCPROFILER_AGENT_TYPE_GPU,       ///< Agent type is a GPU
+    ROCPROFILER_AGENT_TYPE_LAST,
+} rocprofiler_agent_type_t;
+#endif
+
 namespace rocprofsys
 {
+
 namespace rocpd
 {
 
@@ -42,15 +53,17 @@ struct agent_manager
     agent_manager& operator=(agent_manager&&)      = delete;
     ~agent_manager()                               = default;
 
-    void insert_agent(const rocprofiler_agent_v0_t* agent);
-
+#if ROCPROFSYS_USE_ROCM > 0
+    void         insert_agent(const rocprofiler_agent_v0_t* agent);
     const agent& get_agent_by_id(size_t device_id, rocprofiler_agent_type_t type) const;
     const agent& get_agent_by_handle(size_t                   device_id,
                                      rocprofiler_agent_type_t type) const;
     const agent& get_agent_by_handle(size_t device_handle) const;
+#endif
 
     std::vector<std::shared_ptr<agent>> get_agents_by_type(
         rocprofiler_agent_type_t type) const;
+
     std::vector<std::shared_ptr<agent>> get_agents() const;
 
     size_t get_gpu_agents_count() const;
diff --git a/source/lib/rocprof-sys/library.cpp b/source/lib/rocprof-sys/library.cpp
index 527c25f06d..e9c5d220a6 100644
--- a/source/lib/rocprof-sys/library.cpp
+++ b/source/lib/rocprof-sys/library.cpp
@@ -80,7 +80,9 @@
 #include <timemory/utility/join.hpp>
 #include <timemory/utility/procfs/maps.hpp>
 
-#include <rocprofiler-sdk/agent.h>
+#if ROCPROFSYS_USE_ROCM > 0
+#    include <rocprofiler-sdk/agent.h>
+#endif
 
 #include <atomic>
 #include <chrono>
diff --git a/source/lib/rocprof-sys/library/rocprofiler-sdk/counters.cpp b/source/lib/rocprof-sys/library/rocprofiler-sdk/counters.cpp
index fe1142e36f..be38cc5e21 100644
--- a/source/lib/rocprof-sys/library/rocprofiler-sdk/counters.cpp
+++ b/source/lib/rocprof-sys/library/rocprofiler-sdk/counters.cpp
@@ -21,26 +21,10 @@
 // SOFTWARE.
 
 #include "library/rocprofiler-sdk/counters.hpp"
-#include "common/synchronized.hpp"
-#include "core/debug.hpp"
-#include "core/timemory.hpp"
 #include "library/rocprofiler-sdk/fwd.hpp"
 
-#include <timemory/utility/types.hpp>
-
-#include <rocprofiler-sdk/agent.h>
-#include <rocprofiler-sdk/buffer_tracing.h>
-#include <rocprofiler-sdk/callback_tracing.h>
-#include <rocprofiler-sdk/cxx/hash.hpp>
-#include <rocprofiler-sdk/cxx/name_info.hpp>
-#include <rocprofiler-sdk/cxx/operators.hpp>
-#include <rocprofiler-sdk/dispatch_counting_service.h>
-#include <rocprofiler-sdk/fwd.h>
-#include <rocprofiler-sdk/registration.h>
-
 #include <memory>
-#include <unordered_map>
-#include <vector>
+#include <timemory/utility/types.hpp>
 
 namespace rocprofsys
 {

From 0f14537a049d565e1b211b5e7914eb05110e56c8 Mon Sep 17 00:00:00 2001
From: Marjan Antic <marantic@amd.com>
Date: Wed, 16 Jul 2025 09:13:20 -0400
Subject: [PATCH 05/33] Refactor agent manager to work when ROCM is disabled

---
 source/lib/core/CMakeLists.txt                |   2 +
 source/lib/core/agent.hpp                     |  22 ++-
 source/lib/core/agent_manager.cpp             |  47 ++---
 source/lib/core/agent_manager.hpp             |  22 +--
 source/lib/core/cpu.cpp                       | 168 ++++++++++++++++++
 source/lib/core/cpu.hpp                       |  57 ++++++
 source/lib/core/gpu.cpp                       |  50 ++++--
 source/lib/rocprof-sys/library.cpp            |  23 ++-
 source/lib/rocprof-sys/library/amd_smi.cpp    |   8 +-
 .../library/components/backtrace_metrics.cpp  |   6 +-
 .../library/components/comm_data.cpp          |   4 +-
 source/lib/rocprof-sys/library/cpu_freq.cpp   |  10 +-
 12 files changed, 339 insertions(+), 80 deletions(-)
 create mode 100644 source/lib/core/cpu.cpp
 create mode 100644 source/lib/core/cpu.hpp

diff --git a/source/lib/core/CMakeLists.txt b/source/lib/core/CMakeLists.txt
index 2c1ac07edc..46c8508634 100644
--- a/source/lib/core/CMakeLists.txt
+++ b/source/lib/core/CMakeLists.txt
@@ -10,6 +10,7 @@ set(core_sources
     ${CMAKE_CURRENT_LIST_DIR}/categories.cpp
     ${CMAKE_CURRENT_LIST_DIR}/config.cpp
     ${CMAKE_CURRENT_LIST_DIR}/constraint.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/cpu.cpp
     ${CMAKE_CURRENT_LIST_DIR}/debug.cpp
     ${CMAKE_CURRENT_LIST_DIR}/dynamic_library.cpp
     ${CMAKE_CURRENT_LIST_DIR}/exception.cpp
@@ -33,6 +34,7 @@ set(core_headers
     ${CMAKE_CURRENT_LIST_DIR}/concepts.hpp
     ${CMAKE_CURRENT_LIST_DIR}/config.hpp
     ${CMAKE_CURRENT_LIST_DIR}/constraint.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/cpu.hpp
     ${CMAKE_CURRENT_LIST_DIR}/debug.hpp
     ${CMAKE_CURRENT_LIST_DIR}/dynamic_library.hpp
     ${CMAKE_CURRENT_LIST_DIR}/exception.hpp
diff --git a/source/lib/core/agent.hpp b/source/lib/core/agent.hpp
index b3b5b57fbb..94e79e5d5c 100644
--- a/source/lib/core/agent.hpp
+++ b/source/lib/core/agent.hpp
@@ -23,6 +23,9 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
+#include <string>
+
 #if ROCPROFSYS_USE_ROCM > 0
 #    include <amd_smi/amdsmi.h>
 #    include <rocprofiler-sdk/agent.h>
@@ -33,11 +36,24 @@ namespace rocprofsys
 namespace rocpd
 {
 
+enum agent_type : uint8_t
+{
+    CPU,  ///< Agent type is a CPU
+    GPU   ///< Agent type is a GPU
+};
+
 struct agent
 {
-#if ROCPROFSYS_USE_ROCM > 0
-    const rocprofiler_agent_v0_t* agent = nullptr;
-#endif
+    agent_type  type;
+    uint64_t    id;
+    uint32_t    node_id;
+    int32_t     logical_node_id;
+    int32_t     logical_node_type_id;
+    std::string name;
+    std::string model_name;
+    std::string vendor_name;
+    std::string product_name;
+
     size_t device_id{ 0 };
     size_t base_id{ 0 };
 #if ROCPROFSYS_USE_ROCM > 0
diff --git a/source/lib/core/agent_manager.cpp b/source/lib/core/agent_manager.cpp
index 5e19f59e8a..c75f9ca96f 100644
--- a/source/lib/core/agent_manager.cpp
+++ b/source/lib/core/agent_manager.cpp
@@ -36,59 +36,51 @@ agent_manager::get_instance()
     return instance;
 }
 
-#if ROCPROFSYS_USE_ROCM > 0
 void
-agent_manager::insert_agent(const rocprofiler_agent_v0_t* _agent)
+agent_manager::insert_agent(agent& _agent)
 {
     ROCPROFSYS_VERBOSE(
         3, "Inserting agent with device handle: %lu, and agent id: %ld, device type: %s",
-        _agent->id.handle,
-        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? _gpu_agents_cnt : _cpu_agents_cnt),
-        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU"));
+        _agent.device_id, (_agent.type == GPU ? _gpu_agents_cnt : _cpu_agents_cnt),
+        (_agent.type == GPU ? "GPU" : "CPU"));
 
-    _agents.emplace_back(std::make_shared<agent>(agent{
-        _agent,
-        (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? _gpu_agents_cnt++
-                                                    : _cpu_agents_cnt++),
-    }));
+    _agent.device_id = (_agent.type == GPU ? _gpu_agents_cnt++ : _cpu_agents_cnt++);
+    _agents.emplace_back(std::make_shared<agent>(_agent));
 }
 
 const agent&
-agent_manager::get_agent_by_id(size_t device_id, rocprofiler_agent_type_t type) const
+agent_manager::get_agent_by_id(size_t device_id, agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device id: %ld, type %s\n", device_id,
-                       (type == ROCPROFILER_AGENT_TYPE_GPU) ? "GPU" : "CPU");
+                       (type == GPU) ? "GPU" : "CPU");
     auto _agent =
         std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
-            return agent_ptr->agent->type == type && agent_ptr->device_id == device_id;
+            return agent_ptr->type == type && agent_ptr->device_id == device_id;
         });
     if(_agent == _agents.end())
     {
         std::ostringstream oss;
         oss << "Agent not found for device id: " << device_id
-            << ", type: " << (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+            << ", type: " << (type == GPU ? "GPU" : "CPU");
         throw std::out_of_range(oss.str());
     }
     return **_agent;
 }
 
 const agent&
-agent_manager::get_agent_by_handle(uint64_t                 device_handle,
-                                   rocprofiler_agent_type_t type) const
+agent_manager::get_agent_by_handle(uint64_t device_handle, agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device handle: %ld, type %s\n",
-                       device_handle,
-                       (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU"));
+                       device_handle, (type == GPU ? "GPU" : "CPU"));
     auto _agent =
         std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
-            return agent_ptr->agent->type == type &&
-                   agent_ptr->agent->id.handle == device_handle;
+            return agent_ptr->type == type && agent_ptr->id == device_handle;
         });
     if(_agent == _agents.end())
     {
         std::ostringstream oss;
         oss << "Agent not found for device handle: " << device_handle
-            << ", type: " << (type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+            << ", type: " << (type == GPU ? "GPU" : "CPU");
         throw std::out_of_range(oss.str());
     }
     return **_agent;
@@ -100,7 +92,7 @@ agent_manager::get_agent_by_handle(size_t device_handle) const
     ROCPROFSYS_VERBOSE(3, "Getting agent for device handle: %ld\n", device_handle);
     auto _agent =
         std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
-            return agent_ptr->agent->id.handle == device_handle;
+            return agent_ptr->id == device_handle;
         });
     if(_agent == _agents.end())
     {
@@ -111,18 +103,15 @@ agent_manager::get_agent_by_handle(size_t device_handle) const
     return **_agent;
 }
 
-#endif
-
 std::vector<std::shared_ptr<agent>>
-agent_manager::get_agents_by_type(rocprofiler_agent_type_t type) const
+agent_manager::get_agents_by_type(agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device type: %s\n",
-                       type == ROCPROFILER_AGENT_TYPE_GPU ? "GPU" : "CPU");
+                       type == GPU ? "GPU" : "CPU");
 
     std::vector<std::shared_ptr<agent>> agents;
-    std::copy_if(
-        std::begin(_agents), std::end(_agents), std::back_inserter(agents),
-        [&type](const auto& agent_ptr) { return agent_ptr->agent->type == type; });
+    std::copy_if(std::begin(_agents), std::end(_agents), std::back_inserter(agents),
+                 [&type](const auto& agent_ptr) { return agent_ptr->type == type; });
     return agents;
 }
 
diff --git a/source/lib/core/agent_manager.hpp b/source/lib/core/agent_manager.hpp
index c1f3ea34af..76f0f6a7bc 100644
--- a/source/lib/core/agent_manager.hpp
+++ b/source/lib/core/agent_manager.hpp
@@ -27,16 +27,6 @@
 
 #include "agent.hpp"
 
-#if ROCPROFSYS_USE_ROCM <= 0
-typedef enum rocprofiler_agent_type_t  // NOLINT(performance-enum-size)
-{
-    ROCPROFILER_AGENT_TYPE_NONE = 0,  ///< Agent type is unknown
-    ROCPROFILER_AGENT_TYPE_CPU,       ///< Agent type is a CPU
-    ROCPROFILER_AGENT_TYPE_GPU,       ///< Agent type is a GPU
-    ROCPROFILER_AGENT_TYPE_LAST,
-} rocprofiler_agent_type_t;
-#endif
-
 namespace rocprofsys
 {
 
@@ -53,16 +43,12 @@ struct agent_manager
     agent_manager& operator=(agent_manager&&)      = delete;
     ~agent_manager()                               = default;
 
-#if ROCPROFSYS_USE_ROCM > 0
-    void         insert_agent(const rocprofiler_agent_v0_t* agent);
-    const agent& get_agent_by_id(size_t device_id, rocprofiler_agent_type_t type) const;
-    const agent& get_agent_by_handle(size_t                   device_id,
-                                     rocprofiler_agent_type_t type) const;
+    void         insert_agent(agent& agent);
+    const agent& get_agent_by_id(size_t device_id, agent_type type) const;
+    const agent& get_agent_by_handle(size_t device_id, agent_type type) const;
     const agent& get_agent_by_handle(size_t device_handle) const;
-#endif
 
-    std::vector<std::shared_ptr<agent>> get_agents_by_type(
-        rocprofiler_agent_type_t type) const;
+    std::vector<std::shared_ptr<agent>> get_agents_by_type(agent_type type) const;
 
     std::vector<std::shared_ptr<agent>> get_agents() const;
 
diff --git a/source/lib/core/cpu.cpp b/source/lib/core/cpu.cpp
new file mode 100644
index 0000000000..52453c9551
--- /dev/null
+++ b/source/lib/core/cpu.cpp
@@ -0,0 +1,168 @@
+#include "cpu.hpp"
+#include "agent_manager.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <fstream>
+#include <functional>
+#include <unordered_map>
+
+namespace rocprofsys
+{
+namespace cpu
+{
+std::vector<cpu_info>
+process_cpu_info_data()
+{
+    std::vector<cpu_info> cpu_data;
+    std::ifstream         cpuinfo_file("/proc/cpuinfo");
+
+    if(!cpuinfo_file.is_open())
+    {
+        return cpu_data;
+    }
+
+    std::string line;
+    cpu_info    current_cpu;
+    bool        has_processor_entry = false;
+
+    auto parse_long = [](const std::string& value) -> long {
+        try
+        {
+            return std::stol(value);
+        } catch(const std::exception&)
+        {
+            return -1;
+        }
+    };
+
+    auto trim_whitespace = [](const std::string& str) -> std::string {
+        size_t start = str.find_first_not_of(" \t");
+        if(start == std::string::npos) return "";
+        size_t end = str.find_last_not_of(" \t");
+        return str.substr(start, end - start + 1);
+    };
+
+    static const std::unordered_map<std::string,
+                                    std::function<void(cpu_info&, const std::string&)>>
+        field_parsers = {
+            { "processor",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.processor = parse_long(val);
+              } },
+            { "cpu family",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.family = parse_long(val);
+              } },
+            { "model",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.model = parse_long(val);
+              } },
+            { "physical id",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.physical_id = parse_long(val);
+              } },
+            { "core id",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.core_id = parse_long(val);
+              } },
+            { "apicid",
+              [&parse_long](cpu_info& cpu, const std::string& val) {
+                  cpu.apicid = parse_long(val);
+              } },
+            { "vendor_id",
+              [](cpu_info& cpu, const std::string& val) { cpu.vendor_id  = val; } },
+            { "model name",
+              [](cpu_info& cpu, const std::string& val) { cpu.model_name = val; } }
+        };
+
+    while(std::getline(cpuinfo_file, line))
+    {
+        if(line.empty())
+        {
+            if(has_processor_entry)
+            {
+                cpu_data.push_back(current_cpu);
+                return cpu_data;  // Return immediately after first core
+            }
+            continue;
+        }
+
+        size_t colon_pos = line.find(':');
+        if(colon_pos == std::string::npos)
+        {
+            continue;
+        }
+
+        std::string key   = trim_whitespace(line.substr(0, colon_pos));
+        std::string value = trim_whitespace(line.substr(colon_pos + 1));
+
+        std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+
+        auto it = field_parsers.find(key);
+        if(it != field_parsers.end())
+        {
+            it->second(current_cpu, value);
+            if(key == "processor")
+            {
+                has_processor_entry = true;
+            }
+        }
+    }
+
+    if(has_processor_entry)
+    {
+        cpu_data.push_back(current_cpu);
+    }
+
+    return cpu_data;
+}
+
+std::vector<cpu_info>
+get_cpu_info()
+{
+    static auto _v = process_cpu_info_data();
+    return _v;
+}
+
+size_t
+device_count()
+{
+    auto cpu_data = get_cpu_info();
+    return cpu_data.size();
+}
+
+void
+query_cpu_agents()
+{
+    int32_t  id_count   = 0;
+    uint32_t node_count = 0;
+    uint32_t cpu_count  = 0;
+
+    if(device_count() == 0)
+    {
+        return;
+    }
+
+    auto& _agent_manager = rocpd::agent_manager::get_instance();
+    auto  cpu_data       = get_cpu_info();
+
+    for(auto& cpu : cpu_data)
+    {
+        auto node_id    = node_count++;
+        auto logical_id = id_count++;
+        auto id         = cpu_count++;
+        auto cur_agent  = rocpd::agent{ rocpd::CPU,
+                                       id,
+                                       node_id,
+                                       logical_id,
+                                       static_cast<int32_t>(id),
+                                       cpu.model_name,
+                                       cpu.model_name,
+                                       cpu.vendor_id,
+                                       "" };
+        _agent_manager.insert_agent(cur_agent);
+    }
+}
+}  // namespace cpu
+}  // namespace rocprofsys
\ No newline at end of file
diff --git a/source/lib/core/cpu.hpp b/source/lib/core/cpu.hpp
new file mode 100644
index 0000000000..7fdb438cf7
--- /dev/null
+++ b/source/lib/core/cpu.hpp
@@ -0,0 +1,57 @@
+// MIT License
+//
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+#include <string>
+#include <vector>
+
+namespace rocprofsys
+{
+namespace cpu
+{
+
+struct cpu_info
+{
+    long        processor   = -1;
+    long        family      = -1;
+    long        model       = -1;
+    long        physical_id = -1;
+    long        core_id     = -1;
+    long        apicid      = -1;
+    std::string vendor_id   = {};
+    std::string model_name  = {};
+};
+
+std::vector<cpu_info>
+process_cpu_info_data();
+
+std::vector<cpu_info>
+get_cpu_info();
+
+size_t
+device_count();
+
+void
+query_cpu_agents();
+
+}  // namespace cpu
+}  // namespace rocprofsys
diff --git a/source/lib/core/gpu.cpp b/source/lib/core/gpu.cpp
index 82957a3f03..9055bedb92 100644
--- a/source/lib/core/gpu.cpp
+++ b/source/lib/core/gpu.cpp
@@ -20,6 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+#include "agent.hpp"
 #define ROCPROFILER_SDK_CEREAL_NAMESPACE_BEGIN                                           \
     namespace tim                                                                        \
     {                                                                                    \
@@ -41,6 +42,8 @@
 
 #include <timemory/manager.hpp>
 
+#include <string>
+
 #include "core/agent_manager.hpp"
 
 #if ROCPROFSYS_USE_ROCM > 0
@@ -121,8 +124,19 @@ query_rocm_agents()
         auto& _agent_manager = rocpd::agent_manager::get_instance();
         for(size_t i = 0; i < num_agents; ++i)
         {
-            const auto* _agent = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
-            _agent_manager.insert_agent(_agent);
+            const auto* _agent    = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
+            auto        cur_agent = rocpd::agent{
+                (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? rocpd::GPU : rocpd::CPU),
+                _agent->device_id,
+                _agent->node_id,
+                _agent->logical_node_id,
+                _agent->logical_node_type_id,
+                std::string(_agent->name),
+                std::string(_agent->vendor_name),
+                std::string(_agent->product_name),
+                std::string(_agent->model_name),
+            };
+            _agent_manager.insert_agent(cur_agent);
         }
         return ROCPROFILER_STATUS_SUCCESS;
     };
@@ -175,14 +189,33 @@ add_device_metadata(ArchiveT& ar)
 
 #if ROCPROFSYS_USE_ROCM > 0
     using agent_vec_t = std::vector<rocprofiler_agent_v0_t>;
-    auto _gpu_agents  = rocpd::agent_manager::get_instance().get_agents_by_type(
-        ROCPROFILER_AGENT_TYPE_GPU);
-    auto _agents_vec = agent_vec_t{};
 
-    for(auto& agent : _gpu_agents)
+    auto iterator_cb = []([[maybe_unused]] rocprofiler_agent_version_t version,
+                          const void** agents, size_t num_agents,
+                          [[maybe_unused]] void* user_data) -> rocprofiler_status_t {
+        auto* agents_vec = static_cast<agent_vec_t*>(user_data);
+        for(size_t i = 0; i < num_agents; ++i)
+        {
+            const auto* _agent = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
+            if(_agent->type == ROCPROFILER_AGENT_TYPE_GPU)
+            {
+                agents_vec->push_back(*_agent);
+            }
+        }
+        return ROCPROFILER_STATUS_SUCCESS;
+    };
+
+    auto _agents_vec = agent_vec_t{};
+    try
     {
-        _agents_vec.emplace_back(*(agent->agent));
+        rocprofiler_query_available_agents(ROCPROFILER_AGENT_INFO_VERSION_0, iterator_cb,
+                                           sizeof(rocprofiler_agent_v0_t), &_agents_vec);
+    } catch(std::exception& _e)
+    {
+        ROCPROFSYS_BASIC_VERBOSE(1, "Exception thrown getting the rocm agents: %s.\n",
+                                 _e.what());
     }
+
     ar(make_nvp("rocm_agents", _agents_vec));
 #else
     (void) ar;
@@ -224,9 +257,6 @@ get_processor_handles()
     uint32_t processor_count;
     processors::processors_list.clear();
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  gpu_agents = agent_mngr.get_agents_by_type(ROCPROFILER_AGENT_TYPE_GPU);
-
     // Passing nullptr will return us the number of sockets available for read in this
     // system
     auto ret = amdsmi_get_socket_handles(&socket_count, nullptr);
diff --git a/source/lib/rocprof-sys/library.cpp b/source/lib/rocprof-sys/library.cpp
index e9c5d220a6..c47e66e94b 100644
--- a/source/lib/rocprof-sys/library.cpp
+++ b/source/lib/rocprof-sys/library.cpp
@@ -27,12 +27,14 @@
 #include "api.hpp"
 #include "common/setup.hpp"
 #include "common/static_object.hpp"
+#include "core/agent.hpp"
 #include "core/agent_manager.hpp"
 #include "core/categories.hpp"
 #include "core/components/fwd.hpp"
 #include "core/concepts.hpp"
 #include "core/config.hpp"
 #include "core/constraint.hpp"
+#include "core/cpu.hpp"
 #include "core/debug.hpp"
 #include "core/defines.hpp"
 #include "core/dynamic_library.hpp"
@@ -349,16 +351,21 @@ rocprofsys_preinit_rocpd()
     for(const auto& rocpd_agent : agents)
     {
         auto _base_id = rocpd::data_processor::get_instance().insert_agent(
-            n_info.id, getpid(),
-            ((rocpd_agent->agent->type == ROCPROFILER_AGENT_TYPE_GPU) ? "GPU" : "CPU"),
-            rocpd_agent->agent->node_id, rocpd_agent->agent->logical_node_id,
-            rocpd_agent->agent->logical_node_type_id, rocpd_agent->agent->device_id,
-            rocpd_agent->agent->name, rocpd_agent->agent->model_name,
-            rocpd_agent->agent->vendor_name, rocpd_agent->agent->product_name, "");
+            n_info.id, getpid(), ((rocpd_agent->type == rocpd::GPU) ? "GPU" : "CPU"),
+            rocpd_agent->node_id, rocpd_agent->logical_node_id,
+            rocpd_agent->logical_node_type_id, rocpd_agent->id, rocpd_agent->name.c_str(),
+            rocpd_agent->model_name.c_str(), rocpd_agent->vendor_name.c_str(),
+            rocpd_agent->product_name.c_str(), "");
         rocpd_agent->base_id = _base_id;
     }
 }
 
+void
+rocprofsys_preinit_cpu_agents()
+{
+    cpu::query_cpu_agents();
+}
+
 void
 rocprofsys_preinit_hidden()
 {
@@ -522,6 +529,10 @@ rocprofsys_init_tooling_hidden(void)
     auto _dtor = scope::destructor{ []() {
         // if set to finalized, don't continue
         if(get_state() > State::Active) return;
+
+#if !(ROCPROFSYS_USE_ROCM > 0)
+        rocprofsys_preinit_cpu_agents();
+#endif
         if(get_use_rocpd()) rocprofsys_preinit_rocpd();
 
         if(get_use_process_sampling())
diff --git a/source/lib/rocprof-sys/library/amd_smi.cpp b/source/lib/rocprof-sys/library/amd_smi.cpp
index 9e1085d27a..8874418b91 100644
--- a/source/lib/rocprof-sys/library/amd_smi.cpp
+++ b/source/lib/rocprof-sys/library/amd_smi.cpp
@@ -26,11 +26,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
 // THE SOFTWARE.
 
+#include "core/agent.hpp"
 #if defined(NDEBUG)
 #    undef NDEBUG
 #endif
 
-#include "library/amd_smi.hpp"
 #include "core/agent_manager.hpp"
 #include "core/common.hpp"
 #include "core/components/fwd.hpp"
@@ -41,6 +41,7 @@
 #include "core/perfetto.hpp"
 #include "core/rocpd/data_processor.hpp"
 #include "core/state.hpp"
+#include "library/amd_smi.hpp"
 #include "library/runtime.hpp"
 #include "library/thread_info.hpp"
 
@@ -123,7 +124,7 @@ rocpd_initialize_smi_pmc(size_t gpu_id)
     const auto* TARGET_ARCH      = "GPU";
 
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto base_id = agent_mngr.get_agent_by_id(gpu_id, ROCPROFILER_AGENT_TYPE_GPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(gpu_id, rocpd::GPU).base_id;
 
     data_processor.insert_pmc_description(
         ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
@@ -161,8 +162,7 @@ rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings&
     auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_AMD_SMI, 0, 0, 0);
 
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id =
-        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_GPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::GPU).base_id;
 
     auto insert_event_and_sample = [&](bool enabled, const char* name, double value) {
         if(!enabled) return;
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index 9f3cf813eb..0f275e8af6 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -21,6 +21,7 @@
 // SOFTWARE.
 
 #include "library/components/backtrace_metrics.hpp"
+#include "core/agent.hpp"
 #include "core/agent_manager.hpp"
 #include "core/components/fwd.hpp"
 #include "core/config.hpp"
@@ -412,7 +413,7 @@ rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t
     const auto  TARGET_ARCH      = "CPU";
 
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto base_id = agent_mngr.get_agent_by_id(dev_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(dev_id, rocpd::CPU).base_id;
 
     if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
     {
@@ -450,8 +451,7 @@ rocpd_process_backtrace_metrics_events(const uint32_t device_id, uint64_t timest
     auto  event_id =
         data_processor.insert_event(category_enum_id<Category>::value, 0, 0, 0);
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id =
-        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::CPU).base_id;
 
     auto insert_event_and_sample = [&](const char* name, double _value) {
         data_processor.insert_pmc_event(event_id, base_id, name, _value);
diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index c39f0c084f..2bdc22a200 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -136,7 +136,7 @@ rocpd_initialize_comm_data_pmc()
 
     auto&                 agent_mngr = rocpd::agent_manager::get_instance();
     [[maybe_unused]] auto base_id =
-        agent_mngr.get_agent_by_id(DEVICE_ID, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+        agent_mngr.get_agent_by_id(DEVICE_ID, rocpd::CPU).base_id;
 
 #if defined(ROCPROFSYS_USE_MPI)
     data_processor.insert_pmc_description(
@@ -163,7 +163,7 @@ rocpd_process_cpu_usage_events(const uint32_t device_id, int bytes)
         category_enum_id<category::comm_data>::value, 0, 0, 0);
 
     auto& agents = rocpd::agent_manager::get_instance();
-    auto  agent  = agents.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU);
+    auto  agent  = agents.get_agent_by_id(device_id, rocpd::CPU);
 
     auto insert_event_and_sample = [&](const char* name, uint64_t timestamp,
                                        double value) {
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index b8c4a72c5d..031b3c1831 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -21,6 +21,7 @@
 // SOFTWARE.
 
 #include "library/cpu_freq.hpp"
+#include "core/agent.hpp"
 #include "core/agent_manager.hpp"
 #include "core/common.hpp"
 #include "core/config.hpp"
@@ -159,7 +160,7 @@ rocpd_initialize_cpu_freq_pmc(size_t dev_id)
     const auto* TARGET_ARCH      = "CPU";
 
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto base_id = agent_mngr.get_agent_by_id(dev_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(dev_id, rocpd::CPU).base_id;
 
     do_for_enabled_cpus([&](size_t cpu_id) {
         data_processor.insert_pmc_description(
@@ -223,8 +224,7 @@ rocpd_process_cpu_usage_events(const uint32_t device_id, uint64_t timestamp,
     auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_CPU_FREQ, 0, 0, 0);
 
     auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id =
-        agent_mngr.get_agent_by_id(device_id, ROCPROFILER_AGENT_TYPE_CPU).base_id;
+    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::CPU).base_id;
 
     auto insert_event_and_sample = [&](const char* name, double value) {
         data_processor.insert_pmc_event(event_id, base_id, name, value);
@@ -364,8 +364,8 @@ post_process()
         // agents seems to be assigned per device basis not per core.
         // TODO: `get_enabled_cpus()` should be fixed in the future to align with GPU
         // implementation.
-        auto cpu_agents = rocpd::agent_manager::get_instance().get_agents_by_type(
-            ROCPROFILER_AGENT_TYPE_CPU);
+        auto cpu_agents =
+            rocpd::agent_manager::get_instance().get_agents_by_type(rocpd::CPU);
         for(auto& agent : cpu_agents)
         {
             rocpd_initialize_cpu_freq_pmc(agent->device_id);

From dbe430ae81f464875531cddf6efad06ae18206d1 Mon Sep 17 00:00:00 2001
From: Marjan Antic <marantic@amd.com>
Date: Thu, 17 Jul 2025 05:33:13 -0400
Subject: [PATCH 06/33] Fix compile errors and typos

---
 source/lib/core/rocpd/data_processor.cpp      |  4 +--
 .../lib/core/rocpd/data_storage/database.cpp  |  2 +-
 source/lib/rocprof-sys/library/amd_smi.cpp    |  6 ++--
 source/lib/rocprof-sys/library/cpu_freq.cpp   | 30 +++++++------------
 4 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 8f3d38263c..61e8c0325b 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -215,7 +215,7 @@ data_processor::insert_pmc_event(size_t event_id, size_t agent_id, const char* p
         return;
     }
 
-    const auto [_, pmc_description_id] = *it;
+    const auto pmc_description_id = it->second;
     _insert_pmc_event_statement(_upid.c_str(), event_id, pmc_description_id, value,
                                 extdata);
 }
@@ -234,7 +234,7 @@ data_processor::insert_sample(const char* track, uint64_t timestamp, size_t even
                            track);
         return;
     }
-    auto [_, track_info] = *it;
+    auto track_info = it->second;
     _insert_sample_statement(_upid.c_str(), track_info.track_id, timestamp, event_id,
                              extdata);
 }
diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index e652807797..dc1bb2e911 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -69,7 +69,7 @@ database::database()
                             "database open failed!");
     validate_sqlite3_result(sqlite3_open(abs_db_path.c_str(), &_sqlite3_db), "",
                             "database open failed!");
-};
+}
 
 database::~database()
 {
diff --git a/source/lib/rocprof-sys/library/amd_smi.cpp b/source/lib/rocprof-sys/library/amd_smi.cpp
index 8874418b91..b628beb8ed 100644
--- a/source/lib/rocprof-sys/library/amd_smi.cpp
+++ b/source/lib/rocprof-sys/library/amd_smi.cpp
@@ -106,7 +106,7 @@ rocpd_initialize_smi_tracks()
                                 getpid(), thread_id);
     data_processor.insert_track(trait::name<category::amd_smi_memory_usage>::value,
                                 n_info.id, getpid(), thread_id);
-};
+}
 
 void
 rocpd_initialize_smi_pmc(size_t gpu_id)
@@ -149,7 +149,7 @@ rocpd_initialize_smi_pmc(size_t gpu_id)
         trait::name<category::amd_smi_memory_usage>::value, "MemUsg",
         trait::name<category::amd_smi_memory_usage>::description, LONG_DESCRIPTION,
         COMPONENT, "MB", "ABS", BLOCK, EXPRESSION, 0, 0);
-};
+}
 
 void
 rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings& settings,
@@ -178,7 +178,7 @@ rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings&
                             power);
     insert_event_and_sample(settings.mem_usage,
                             trait::name<category::amd_smi_memory_usage>::value, usage);
-};
+}
 
 auto&
 get_settings(uint32_t _dev_id)
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index 031b3c1831..37cc6b61f7 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -97,22 +97,12 @@ rocpd_initialize_cpu_freq_category()
                                          trait::name<category::cpu_freq>::value);
 }
 
-size_t
-rocpd_initialize_thread_info(size_t tid)
-{
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
-
-    return data_processor.insert_thread_info(n_info.id, getppid(), getpid(), tid,
-                                             JOIN(" ", "Thread", tid).c_str(), 0, 0,
-                                             "{}");
-}
-
 void
-rocpd_initialize_cpu_freq_tracks(size_t thread_idx)
+rocpd_initialize_cpu_freq_tracks()
 {
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
+    auto&      data_processor = get_data_processor();
+    auto&      n_info         = node_info::get_instance();
+    const auto thread_idx     = std::nullopt;  // Internal thread ID for cpu-freq
 
     do_for_enabled_cpus([&](size_t cpu_id) {
         data_processor.insert_track(
@@ -122,10 +112,11 @@ rocpd_initialize_cpu_freq_tracks(size_t thread_idx)
 }
 
 void
-rocpd_initialize_cpu_usage_tracks(size_t thread_idx)
+rocpd_initialize_cpu_usage_tracks()
 {
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
+    auto&      data_processor = get_data_processor();
+    auto&      n_info         = node_info::get_instance();
+    const auto thread_idx     = std::nullopt;  // Internal thread ID for cpu-freq
 
     data_processor.insert_track(trait::name<category::process_page>::value, n_info.id,
                                 getpid(), thread_idx);
@@ -355,9 +346,8 @@ post_process()
     if(get_use_rocpd())
     {
         rocpd_initialize_cpu_freq_category();
-        auto thread_idx = rocpd_initialize_thread_info(gettid());
-        rocpd_initialize_cpu_usage_tracks(thread_idx);
-        rocpd_initialize_cpu_freq_tracks(thread_idx);
+        rocpd_initialize_cpu_usage_tracks();
+        rocpd_initialize_cpu_freq_tracks();
 
         // `get_enabled_cpus()` returns the number of cores enabled for monitoring but the
         // actuall device_id is 0, since there is a single device avaliable. And the

From f19732b83257921cbad0efe85a16d8b090cd268d Mon Sep 17 00:00:00 2001
From: Marjan Antic <marantic@amd.com>
Date: Thu, 17 Jul 2025 05:33:13 -0400
Subject: [PATCH 07/33] Fix compile errors and typos

---
 source/lib/core/rocpd/data_processor.cpp      |  4 +--
 .../lib/core/rocpd/data_storage/database.cpp  |  2 +-
 source/lib/rocprof-sys/library/amd_smi.cpp    |  6 ++--
 .../library/components/comm_data.cpp          | 29 +++++++++++++-----
 source/lib/rocprof-sys/library/cpu_freq.cpp   | 30 +++++++------------
 source/lib/rocprof-sys/library/kokkosp.cpp    |  4 ++-
 6 files changed, 40 insertions(+), 35 deletions(-)

diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 8f3d38263c..61e8c0325b 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -215,7 +215,7 @@ data_processor::insert_pmc_event(size_t event_id, size_t agent_id, const char* p
         return;
     }
 
-    const auto [_, pmc_description_id] = *it;
+    const auto pmc_description_id = it->second;
     _insert_pmc_event_statement(_upid.c_str(), event_id, pmc_description_id, value,
                                 extdata);
 }
@@ -234,7 +234,7 @@ data_processor::insert_sample(const char* track, uint64_t timestamp, size_t even
                            track);
         return;
     }
-    auto [_, track_info] = *it;
+    auto track_info = it->second;
     _insert_sample_statement(_upid.c_str(), track_info.track_id, timestamp, event_id,
                              extdata);
 }
diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index e652807797..dc1bb2e911 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -69,7 +69,7 @@ database::database()
                             "database open failed!");
     validate_sqlite3_result(sqlite3_open(abs_db_path.c_str(), &_sqlite3_db), "",
                             "database open failed!");
-};
+}
 
 database::~database()
 {
diff --git a/source/lib/rocprof-sys/library/amd_smi.cpp b/source/lib/rocprof-sys/library/amd_smi.cpp
index 8874418b91..b628beb8ed 100644
--- a/source/lib/rocprof-sys/library/amd_smi.cpp
+++ b/source/lib/rocprof-sys/library/amd_smi.cpp
@@ -106,7 +106,7 @@ rocpd_initialize_smi_tracks()
                                 getpid(), thread_id);
     data_processor.insert_track(trait::name<category::amd_smi_memory_usage>::value,
                                 n_info.id, getpid(), thread_id);
-};
+}
 
 void
 rocpd_initialize_smi_pmc(size_t gpu_id)
@@ -149,7 +149,7 @@ rocpd_initialize_smi_pmc(size_t gpu_id)
         trait::name<category::amd_smi_memory_usage>::value, "MemUsg",
         trait::name<category::amd_smi_memory_usage>::description, LONG_DESCRIPTION,
         COMPONENT, "MB", "ABS", BLOCK, EXPRESSION, 0, 0);
-};
+}
 
 void
 rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings& settings,
@@ -178,7 +178,7 @@ rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings&
                             power);
     insert_event_and_sample(settings.mem_usage,
                             trait::name<category::amd_smi_memory_usage>::value, usage);
-};
+}
 
 auto&
 get_settings(uint32_t _dev_id)
diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index 2bdc22a200..83538d197d 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -30,6 +30,7 @@
 #include "core/rocpd/json.hpp"
 #include "library/tracing.hpp"
 
+#include <optional>
 #include <timemory/backends/mpi.hpp>
 #include <timemory/manager.hpp>
 #include <timemory/units.hpp>
@@ -107,11 +108,11 @@ void
 rocpd_initialize_track()
 {
     auto& n_info      = node_info::get_instance();
+    auto  thread_id   = std::nullopt;
     auto  _init_track = [&](const char* label) {
-        ROCPROFSYS_VERBOSE(
-            3, "INSERT_TRACK label: %s, node ID: %d, Process ID: %d, Thread ID: %d",
-            label, n_info.id, getpid(), gettid());
-        get_data_processor().insert_track(label, n_info.id, getpid(), gettid());
+        ROCPROFSYS_VERBOSE(3, "INSERT_TRACK label: %s, node ID: %d, Process ID: %d",
+                            label, n_info.id, getpid());
+        get_data_processor().insert_track(label, n_info.id, getpid(), thread_id);
     };
 
     static std::once_flag _once{};
@@ -140,15 +141,27 @@ rocpd_initialize_comm_data_pmc()
 
 #if defined(ROCPROFSYS_USE_MPI)
     data_processor.insert_pmc_description(
-        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
-        trait::name<category::mpi>::value, "Tracks MPI communication data sizes",
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, mpi_send::label,
+        "Tracks MPI Send communication data sizes",
+        trait::name<category::mpi>::description, LONG_DESCRIPTION, COMPONENT, MSG, "ABS",
+        BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, mpi_recv::label,
+        "Tracks MPI Receive communication data sizes",
         trait::name<category::mpi>::description, LONG_DESCRIPTION, COMPONENT, MSG, "ABS",
         BLOCK, EXPRESSION, 0, 0);
 #endif
 #if defined(ROCPROFSYS_USE_RCCL)
     data_processor.insert_pmc_description(
-        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
-        trait::name<category::rocm_rccl>::value, "Tracks RCCL communication data sizes",
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, rccl_send::label,
+        "Tracks RCCL Send communication data sizes",
+        trait::name<category::rocm_rccl>::description, LONG_DESCRIPTION, COMPONENT, MSG,
+        "ABS", BLOCK, EXPRESSION, 0, 0);
+
+    data_processor.insert_pmc_description(
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, rccl_recv::label,
+        "Tracks RCCL Receive communication data sizes",
         trait::name<category::rocm_rccl>::description, LONG_DESCRIPTION, COMPONENT, MSG,
         "ABS", BLOCK, EXPRESSION, 0, 0);
 #endif
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index 031b3c1831..37cc6b61f7 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -97,22 +97,12 @@ rocpd_initialize_cpu_freq_category()
                                          trait::name<category::cpu_freq>::value);
 }
 
-size_t
-rocpd_initialize_thread_info(size_t tid)
-{
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
-
-    return data_processor.insert_thread_info(n_info.id, getppid(), getpid(), tid,
-                                             JOIN(" ", "Thread", tid).c_str(), 0, 0,
-                                             "{}");
-}
-
 void
-rocpd_initialize_cpu_freq_tracks(size_t thread_idx)
+rocpd_initialize_cpu_freq_tracks()
 {
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
+    auto&      data_processor = get_data_processor();
+    auto&      n_info         = node_info::get_instance();
+    const auto thread_idx     = std::nullopt;  // Internal thread ID for cpu-freq
 
     do_for_enabled_cpus([&](size_t cpu_id) {
         data_processor.insert_track(
@@ -122,10 +112,11 @@ rocpd_initialize_cpu_freq_tracks(size_t thread_idx)
 }
 
 void
-rocpd_initialize_cpu_usage_tracks(size_t thread_idx)
+rocpd_initialize_cpu_usage_tracks()
 {
-    auto& data_processor = get_data_processor();
-    auto& n_info         = node_info::get_instance();
+    auto&      data_processor = get_data_processor();
+    auto&      n_info         = node_info::get_instance();
+    const auto thread_idx     = std::nullopt;  // Internal thread ID for cpu-freq
 
     data_processor.insert_track(trait::name<category::process_page>::value, n_info.id,
                                 getpid(), thread_idx);
@@ -355,9 +346,8 @@ post_process()
     if(get_use_rocpd())
     {
         rocpd_initialize_cpu_freq_category();
-        auto thread_idx = rocpd_initialize_thread_info(gettid());
-        rocpd_initialize_cpu_usage_tracks(thread_idx);
-        rocpd_initialize_cpu_freq_tracks(thread_idx);
+        rocpd_initialize_cpu_usage_tracks();
+        rocpd_initialize_cpu_freq_tracks();
 
         // `get_enabled_cpus()` returns the number of cores enabled for monitoring but the
         // actuall device_id is 0, since there is a single device avaliable. And the
diff --git a/source/lib/rocprof-sys/library/kokkosp.cpp b/source/lib/rocprof-sys/library/kokkosp.cpp
index 6ba03e0344..ab0107bb31 100644
--- a/source/lib/rocprof-sys/library/kokkosp.cpp
+++ b/source/lib/rocprof-sys/library/kokkosp.cpp
@@ -20,6 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+#include <optional>
 #define TIMEMORY_KOKKOSP_POSTFIX ROCPROFSYS_PUBLIC_API
 
 #include "api.hpp"
@@ -175,9 +176,10 @@ rocpd_initialize_kokos_track()
 {
     auto& data_processor = get_data_processor();
     auto& n_info         = rocprofsys::node_info::get_instance();
+    auto  thread_id      = std::nullopt;
 
     data_processor.insert_track(rocprofsys::trait::name<category::kokkos>::value,
-                                n_info.id, getpid(), gettid());
+                                n_info.id, getpid(), thread_id);
 }
 
 void

From 0ce459bf7b33118776dc8f40a073f37f3a6561c1 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Thu, 17 Jul 2025 08:19:30 -0400
Subject: [PATCH 08/33] Move agent and agent_manager from rocpd namespace

---
 source/lib/core/agent.hpp                     |  6 ++--
 source/lib/core/agent_manager.cpp             | 22 +++++++--------
 source/lib/core/agent_manager.hpp             |  4 ---
 source/lib/core/cpu.cpp                       | 22 +++++++--------
 source/lib/core/gpu.cpp                       |  9 +++---
 source/lib/rocprof-sys/library.cpp            | 28 +++++++++----------
 source/lib/rocprof-sys/library/amd_smi.cpp    |  8 +++---
 .../library/components/backtrace_metrics.cpp  | 14 +++++-----
 .../library/components/comm_data.cpp          |  8 +++---
 source/lib/rocprof-sys/library/cpu_freq.cpp   | 10 +++----
 10 files changed, 63 insertions(+), 68 deletions(-)

diff --git a/source/lib/core/agent.hpp b/source/lib/core/agent.hpp
index 94e79e5d5c..0ba4cd480f 100644
--- a/source/lib/core/agent.hpp
+++ b/source/lib/core/agent.hpp
@@ -33,10 +33,8 @@
 
 namespace rocprofsys
 {
-namespace rocpd
-{
 
-enum agent_type : uint8_t
+enum class agent_type : uint8_t
 {
     CPU,  ///< Agent type is a CPU
     GPU   ///< Agent type is a GPU
@@ -61,5 +59,5 @@ struct agent
 #endif
 };
 
-}  // namespace rocpd
+
 }  // namespace rocprofsys
diff --git a/source/lib/core/agent_manager.cpp b/source/lib/core/agent_manager.cpp
index c75f9ca96f..b7086931ee 100644
--- a/source/lib/core/agent_manager.cpp
+++ b/source/lib/core/agent_manager.cpp
@@ -27,8 +27,7 @@
 
 namespace rocprofsys
 {
-namespace rocpd
-{
+
 agent_manager&
 agent_manager::get_instance()
 {
@@ -41,10 +40,12 @@ agent_manager::insert_agent(agent& _agent)
 {
     ROCPROFSYS_VERBOSE(
         3, "Inserting agent with device handle: %lu, and agent id: %ld, device type: %s",
-        _agent.device_id, (_agent.type == GPU ? _gpu_agents_cnt : _cpu_agents_cnt),
-        (_agent.type == GPU ? "GPU" : "CPU"));
+        _agent.device_id,
+        (_agent.type == agent_type::GPU ? _gpu_agents_cnt : _cpu_agents_cnt),
+        (_agent.type == agent_type::GPU ? "GPU" : "CPU"));
 
-    _agent.device_id = (_agent.type == GPU ? _gpu_agents_cnt++ : _cpu_agents_cnt++);
+    _agent.device_id =
+        (_agent.type == agent_type::GPU ? _gpu_agents_cnt++ : _cpu_agents_cnt++);
     _agents.emplace_back(std::make_shared<agent>(_agent));
 }
 
@@ -52,7 +53,7 @@ const agent&
 agent_manager::get_agent_by_id(size_t device_id, agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device id: %ld, type %s\n", device_id,
-                       (type == GPU) ? "GPU" : "CPU");
+                       (type == agent_type::GPU) ? "GPU" : "CPU");
     auto _agent =
         std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
             return agent_ptr->type == type && agent_ptr->device_id == device_id;
@@ -61,7 +62,7 @@ agent_manager::get_agent_by_id(size_t device_id, agent_type type) const
     {
         std::ostringstream oss;
         oss << "Agent not found for device id: " << device_id
-            << ", type: " << (type == GPU ? "GPU" : "CPU");
+            << ", type: " << (type == agent_type::GPU ? "GPU" : "CPU");
         throw std::out_of_range(oss.str());
     }
     return **_agent;
@@ -71,7 +72,7 @@ const agent&
 agent_manager::get_agent_by_handle(uint64_t device_handle, agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device handle: %ld, type %s\n",
-                       device_handle, (type == GPU ? "GPU" : "CPU"));
+                       device_handle, (type == agent_type::GPU ? "GPU" : "CPU"));
     auto _agent =
         std::find_if(_agents.begin(), _agents.end(), [&](const auto& agent_ptr) {
             return agent_ptr->type == type && agent_ptr->id == device_handle;
@@ -80,7 +81,7 @@ agent_manager::get_agent_by_handle(uint64_t device_handle, agent_type type) cons
     {
         std::ostringstream oss;
         oss << "Agent not found for device handle: " << device_handle
-            << ", type: " << (type == GPU ? "GPU" : "CPU");
+            << ", type: " << (type == agent_type::GPU ? "GPU" : "CPU");
         throw std::out_of_range(oss.str());
     }
     return **_agent;
@@ -107,7 +108,7 @@ std::vector<std::shared_ptr<agent>>
 agent_manager::get_agents_by_type(agent_type type) const
 {
     ROCPROFSYS_VERBOSE(3, "Getting agent for device type: %s\n",
-                       type == GPU ? "GPU" : "CPU");
+                       type == agent_type::GPU ? "GPU" : "CPU");
 
     std::vector<std::shared_ptr<agent>> agents;
     std::copy_if(std::begin(_agents), std::end(_agents), std::back_inserter(agents),
@@ -133,5 +134,4 @@ agent_manager::get_cpu_agents_count() const
     return _cpu_agents_cnt;
 }
 
-}  // namespace rocpd
 }  // namespace rocprofsys
diff --git a/source/lib/core/agent_manager.hpp b/source/lib/core/agent_manager.hpp
index 76f0f6a7bc..d49305ad51 100644
--- a/source/lib/core/agent_manager.hpp
+++ b/source/lib/core/agent_manager.hpp
@@ -30,9 +30,6 @@
 namespace rocprofsys
 {
 
-namespace rocpd
-{
-
 struct agent_manager
 {
     static agent_manager& get_instance();
@@ -62,5 +59,4 @@ struct agent_manager
     agent_manager() = default;
 };
 
-}  // namespace rocpd
 }  // namespace rocprofsys
diff --git a/source/lib/core/cpu.cpp b/source/lib/core/cpu.cpp
index 52453c9551..5c63dacfed 100644
--- a/source/lib/core/cpu.cpp
+++ b/source/lib/core/cpu.cpp
@@ -144,7 +144,7 @@ query_cpu_agents()
         return;
     }
 
-    auto& _agent_manager = rocpd::agent_manager::get_instance();
+    auto& _agent_manager = agent_manager::get_instance();
     auto  cpu_data       = get_cpu_info();
 
     for(auto& cpu : cpu_data)
@@ -152,17 +152,17 @@ query_cpu_agents()
         auto node_id    = node_count++;
         auto logical_id = id_count++;
         auto id         = cpu_count++;
-        auto cur_agent  = rocpd::agent{ rocpd::CPU,
-                                       id,
-                                       node_id,
-                                       logical_id,
-                                       static_cast<int32_t>(id),
-                                       cpu.model_name,
-                                       cpu.model_name,
-                                       cpu.vendor_id,
-                                       "" };
+        auto cur_agent  = agent{ agent_type::CPU,
+                                id,
+                                node_id,
+                                logical_id,
+                                static_cast<int32_t>(id),
+                                cpu.model_name,
+                                cpu.model_name,
+                                cpu.vendor_id,
+                                "" };
         _agent_manager.insert_agent(cur_agent);
     }
 }
 }  // namespace cpu
-}  // namespace rocprofsys
\ No newline at end of file
+}  // namespace rocprofsys
diff --git a/source/lib/core/gpu.cpp b/source/lib/core/gpu.cpp
index 9055bedb92..18281448c9 100644
--- a/source/lib/core/gpu.cpp
+++ b/source/lib/core/gpu.cpp
@@ -121,12 +121,13 @@ query_rocm_agents()
     auto iterator = []([[maybe_unused]] rocprofiler_agent_version_t version,
                        const void** agents, size_t num_agents,
                        [[maybe_unused]] void* user_data) -> rocprofiler_status_t {
-        auto& _agent_manager = rocpd::agent_manager::get_instance();
+        auto& _agent_manager = agent_manager::get_instance();
         for(size_t i = 0; i < num_agents; ++i)
         {
             const auto* _agent    = static_cast<const rocprofiler_agent_v0_t*>(agents[i]);
-            auto        cur_agent = rocpd::agent{
-                (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? rocpd::GPU : rocpd::CPU),
+            auto        cur_agent = agent{
+                (_agent->type == ROCPROFILER_AGENT_TYPE_GPU ? agent_type::GPU
+                                                                   : agent_type::CPU),
                 _agent->device_id,
                 _agent->node_id,
                 _agent->logical_node_id,
@@ -151,7 +152,7 @@ query_rocm_agents()
             1, "Exception thrown getting the rocm agents: %s. _dev_cnt=%ld\n", _e.what(),
             _dev_cnt);
     }
-    _dev_cnt = rocpd::agent_manager::get_instance().get_gpu_agents_count();
+    _dev_cnt = agent_manager::get_instance().get_gpu_agents_count();
 #endif
     return _dev_cnt;
 }
diff --git a/source/lib/rocprof-sys/library.cpp b/source/lib/rocprof-sys/library.cpp
index c47e66e94b..73ce499a83 100644
--- a/source/lib/rocprof-sys/library.cpp
+++ b/source/lib/rocprof-sys/library.cpp
@@ -330,28 +330,28 @@ read_command_line(pid_t _pid)
 void
 rocprofsys_preinit_rocpd()
 {
-    auto&       data_processor = rocpd::data_processor::get_instance();
-    const auto& n_info         = node_info::get_instance();
-    auto        cmd_line       = read_command_line(getpid());
-    auto&       agent_mngr     = rocpd::agent_manager::get_instance();
+    auto&       _data_processor = rocpd::data_processor::get_instance();
+    const auto& _n_info         = node_info::get_instance();
+    auto        _cmd_line       = read_command_line(getpid());
+    auto&       _agent_manager     = agent_manager::get_instance();
 
-    if(cmd_line.empty())
+    if(_cmd_line.empty())
     {
-        cmd_line.emplace_back("rocprofiler-systems");
+        _cmd_line.emplace_back("rocprofiler-systems");
     }
 
-    data_processor.insert_node_info(n_info.id, n_info.hash, n_info.machine_id.c_str(),
-                                    n_info.system_name.c_str(), n_info.node_name.c_str(),
-                                    n_info.release.c_str(), n_info.version.c_str(),
-                                    n_info.machine.c_str(), n_info.domain_name.c_str());
-    data_processor.insert_process_info(n_info.id, getppid(), getpid(), 0, 0, 0, 0,
-                                       cmd_line[0].c_str(), "{}");
+    _data_processor.insert_node_info(_n_info.id, _n_info.hash, _n_info.machine_id.c_str(),
+                                    _n_info.system_name.c_str(), _n_info.node_name.c_str(),
+                                    _n_info.release.c_str(), _n_info.version.c_str(),
+                                    _n_info.machine.c_str(), _n_info.domain_name.c_str());
+    _data_processor.insert_process_info(_n_info.id, getppid(), getpid(), 0, 0, 0, 0,
+                                       _cmd_line[0].c_str(), "{}");
 
-    const auto& agents = agent_mngr.get_agents();
+    const auto& agents = _agent_manager.get_agents();
     for(const auto& rocpd_agent : agents)
     {
         auto _base_id = rocpd::data_processor::get_instance().insert_agent(
-            n_info.id, getpid(), ((rocpd_agent->type == rocpd::GPU) ? "GPU" : "CPU"),
+            _n_info.id, getpid(), ((rocpd_agent->type == agent_type::GPU) ? "GPU" : "CPU"),
             rocpd_agent->node_id, rocpd_agent->logical_node_id,
             rocpd_agent->logical_node_type_id, rocpd_agent->id, rocpd_agent->name.c_str(),
             rocpd_agent->model_name.c_str(), rocpd_agent->vendor_name.c_str(),
diff --git a/source/lib/rocprof-sys/library/amd_smi.cpp b/source/lib/rocprof-sys/library/amd_smi.cpp
index b628beb8ed..f52c7cd1d8 100644
--- a/source/lib/rocprof-sys/library/amd_smi.cpp
+++ b/source/lib/rocprof-sys/library/amd_smi.cpp
@@ -123,8 +123,8 @@ rocpd_initialize_smi_pmc(size_t gpu_id)
     auto        ni               = node_info::get_instance();
     const auto* TARGET_ARCH      = "GPU";
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(gpu_id, rocpd::GPU).base_id;
+    auto& _agent_manager = agent_manager::get_instance();
+    auto  base_id = _agent_manager.get_agent_by_id(gpu_id, agent_type::GPU).base_id;
 
     data_processor.insert_pmc_description(
         ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
@@ -161,8 +161,8 @@ rocpd_process_smi_pmc_events(const uint32_t device_id, const amd_smi::settings&
     auto& data_processor = get_data_processor();
     auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_AMD_SMI, 0, 0, 0);
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::GPU).base_id;
+    auto& _agent_manager = agent_manager::get_instance();
+    auto  base_id = _agent_manager.get_agent_by_id(device_id, agent_type::GPU).base_id;
 
     auto insert_event_and_sample = [&](bool enabled, const char* name, double value) {
         if(!enabled) return;
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index 0f275e8af6..a7cbe39734 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -410,10 +410,10 @@ rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t
     const char* BLOCK            = "";
     const char* EXPRESSION       = "";
     auto        ni               = node_info::get_instance();
-    const auto  TARGET_ARCH      = "CPU";
+    const auto*  TARGET_ARCH      = "CPU";
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(dev_id, rocpd::CPU).base_id;
+    auto& _agent_manager = agent_manager::get_instance();
+    auto  _base_id    = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
 
     if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
     {
@@ -427,7 +427,7 @@ rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t
             std::string track_name = JOIN(' ', "Thread", _desc, _tid_name, "(S)");
 
             data_processor.insert_pmc_description(
-                ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+                ni.id, getpid(), _base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
                 track_name.c_str(), trait::name<Category>::value,
                 trait::name<Category>::description, LONG_DESCRIPTION, COMPONENT, units,
                 "ABS", BLOCK, EXPRESSION, 0, 0);
@@ -435,7 +435,7 @@ rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t
     }
     else
         data_processor.insert_pmc_description(
-            ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+            ni.id, getpid(), _base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
             JOIN("_", trait::name<Category>::value, _tid_name).c_str(),
             trait::name<Category>::value, trait::name<Category>::description,
             LONG_DESCRIPTION, COMPONENT, units, "ABS", BLOCK, EXPRESSION, 0, 0);
@@ -450,8 +450,8 @@ rocpd_process_backtrace_metrics_events(const uint32_t device_id, uint64_t timest
     auto  _tid_name      = JOIN("", '[', _tid, ']');
     auto  event_id =
         data_processor.insert_event(category_enum_id<Category>::value, 0, 0, 0);
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::CPU).base_id;
+    auto& agent_mngr = agent_manager::get_instance();
+    auto  base_id    = agent_mngr.get_agent_by_id(device_id, agent_type::CPU).base_id;
 
     auto insert_event_and_sample = [&](const char* name, double _value) {
         data_processor.insert_pmc_event(event_id, base_id, name, _value);
diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index 2bdc22a200..7c5a9ce8ff 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -134,9 +134,9 @@ rocpd_initialize_comm_data_pmc()
     auto                                   ni               = node_info::get_instance();
     constexpr const auto                   DEVICE_ID = 0;  // Assuming CPU device ID is 0
 
-    auto&                 agent_mngr = rocpd::agent_manager::get_instance();
+    auto&                 _agent_manager = agent_manager::get_instance();
     [[maybe_unused]] auto base_id =
-        agent_mngr.get_agent_by_id(DEVICE_ID, rocpd::CPU).base_id;
+        _agent_manager.get_agent_by_id(DEVICE_ID, agent_type::CPU).base_id;
 
 #if defined(ROCPROFSYS_USE_MPI)
     data_processor.insert_pmc_description(
@@ -162,8 +162,8 @@ rocpd_process_cpu_usage_events(const uint32_t device_id, int bytes)
     auto  event_id       = data_processor.insert_event(
         category_enum_id<category::comm_data>::value, 0, 0, 0);
 
-    auto& agents = rocpd::agent_manager::get_instance();
-    auto  agent  = agents.get_agent_by_id(device_id, rocpd::CPU);
+    auto& agents = agent_manager::get_instance();
+    auto  agent  = agents.get_agent_by_id(device_id, agent_type::CPU);
 
     auto insert_event_and_sample = [&](const char* name, uint64_t timestamp,
                                        double value) {
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index 37cc6b61f7..2629dc8cdf 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -150,8 +150,8 @@ rocpd_initialize_cpu_freq_pmc(size_t dev_id)
     auto        ni               = node_info::get_instance();
     const auto* TARGET_ARCH      = "CPU";
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(dev_id, rocpd::CPU).base_id;
+    auto& _agent_manager = agent_manager::get_instance();
+    auto  base_id    = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
 
     do_for_enabled_cpus([&](size_t cpu_id) {
         data_processor.insert_pmc_description(
@@ -214,8 +214,8 @@ rocpd_process_cpu_usage_events(const uint32_t device_id, uint64_t timestamp,
     auto& data_processor = get_data_processor();
     auto  event_id = data_processor.insert_event(ROCPROFSYS_CATEGORY_CPU_FREQ, 0, 0, 0);
 
-    auto& agent_mngr = rocpd::agent_manager::get_instance();
-    auto  base_id    = agent_mngr.get_agent_by_id(device_id, rocpd::CPU).base_id;
+    auto& agent_mngr = agent_manager::get_instance();
+    auto  base_id    = agent_mngr.get_agent_by_id(device_id, agent_type::CPU).base_id;
 
     auto insert_event_and_sample = [&](const char* name, double value) {
         data_processor.insert_pmc_event(event_id, base_id, name, value);
@@ -355,7 +355,7 @@ post_process()
         // TODO: `get_enabled_cpus()` should be fixed in the future to align with GPU
         // implementation.
         auto cpu_agents =
-            rocpd::agent_manager::get_instance().get_agents_by_type(rocpd::CPU);
+            agent_manager::get_instance().get_agents_by_type(agent_type::CPU);
         for(auto& agent : cpu_agents)
         {
             rocpd_initialize_cpu_freq_pmc(agent->device_id);

From 4a49d038b4a70a9ee5b83bb85eee861b81fe806c Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Thu, 17 Jul 2025 09:40:10 -0400
Subject: [PATCH 09/33] Replace std::filepath with a timemory filepath impl

---
 source/lib/core/rocpd/data_storage/database.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index dc1bb2e911..0a2e0409c2 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -26,13 +26,11 @@
 #include "node_info.hpp"
 
 #include <config.hpp>
-#include <filesystem>
 #include <fstream>
 #include <regex>
 #include <timemory/environment/types.hpp>
 #include <unistd.h>
 
-namespace fs = std::filesystem;
 namespace
 {
 void
@@ -83,12 +81,12 @@ database::initialize_schema()
     auto get_file_path = [](const std::string_view filename) {
         auto _rocprofsys_root = tim::get_env<std::string>(
             "rocprofiler_systems_ROOT", tim::get_env<std::string>("ROCPROFSYS_ROOT", ""));
-        if(!_rocprofsys_root.empty() && fs::exists(std::string(_rocprofsys_root)))
+        if(!_rocprofsys_root.empty() && tim::filepath::exists(std::string(_rocprofsys_root)))
         {
             auto new_file_path = std::string(_rocprofsys_root)
                                      .append("/share/rocprofiler-systems/")
                                      .append(filename);
-            if(fs::exists(new_file_path))
+            if(tim::filepath::exists(new_file_path))
             {
                 return new_file_path;
             }

From 5b3e2382523d3c34b27b9d95b35a1153512e4bf6 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Thu, 17 Jul 2025 09:58:24 -0400
Subject: [PATCH 10/33] Fix formatting

---
 source/lib/core/agent.hpp                         |  1 -
 source/lib/core/rocpd/data_storage/database.cpp   |  3 ++-
 source/lib/rocprof-sys/library.cpp                | 15 ++++++++-------
 .../library/components/backtrace_metrics.cpp      |  4 ++--
 source/lib/rocprof-sys/library/cpu_freq.cpp       |  4 ++--
 5 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/source/lib/core/agent.hpp b/source/lib/core/agent.hpp
index 0ba4cd480f..f942e301e5 100644
--- a/source/lib/core/agent.hpp
+++ b/source/lib/core/agent.hpp
@@ -59,5 +59,4 @@ struct agent
 #endif
 };
 
-
 }  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index 0a2e0409c2..08ec74839f 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -81,7 +81,8 @@ database::initialize_schema()
     auto get_file_path = [](const std::string_view filename) {
         auto _rocprofsys_root = tim::get_env<std::string>(
             "rocprofiler_systems_ROOT", tim::get_env<std::string>("ROCPROFSYS_ROOT", ""));
-        if(!_rocprofsys_root.empty() && tim::filepath::exists(std::string(_rocprofsys_root)))
+        if(!_rocprofsys_root.empty() &&
+           tim::filepath::exists(std::string(_rocprofsys_root)))
         {
             auto new_file_path = std::string(_rocprofsys_root)
                                      .append("/share/rocprofiler-systems/")
diff --git a/source/lib/rocprof-sys/library.cpp b/source/lib/rocprof-sys/library.cpp
index 73ce499a83..34984cdb0a 100644
--- a/source/lib/rocprof-sys/library.cpp
+++ b/source/lib/rocprof-sys/library.cpp
@@ -333,25 +333,26 @@ rocprofsys_preinit_rocpd()
     auto&       _data_processor = rocpd::data_processor::get_instance();
     const auto& _n_info         = node_info::get_instance();
     auto        _cmd_line       = read_command_line(getpid());
-    auto&       _agent_manager     = agent_manager::get_instance();
+    auto&       _agent_manager  = agent_manager::get_instance();
 
     if(_cmd_line.empty())
     {
         _cmd_line.emplace_back("rocprofiler-systems");
     }
 
-    _data_processor.insert_node_info(_n_info.id, _n_info.hash, _n_info.machine_id.c_str(),
-                                    _n_info.system_name.c_str(), _n_info.node_name.c_str(),
-                                    _n_info.release.c_str(), _n_info.version.c_str(),
-                                    _n_info.machine.c_str(), _n_info.domain_name.c_str());
+    _data_processor.insert_node_info(
+        _n_info.id, _n_info.hash, _n_info.machine_id.c_str(), _n_info.system_name.c_str(),
+        _n_info.node_name.c_str(), _n_info.release.c_str(), _n_info.version.c_str(),
+        _n_info.machine.c_str(), _n_info.domain_name.c_str());
     _data_processor.insert_process_info(_n_info.id, getppid(), getpid(), 0, 0, 0, 0,
-                                       _cmd_line[0].c_str(), "{}");
+                                        _cmd_line[0].c_str(), "{}");
 
     const auto& agents = _agent_manager.get_agents();
     for(const auto& rocpd_agent : agents)
     {
         auto _base_id = rocpd::data_processor::get_instance().insert_agent(
-            _n_info.id, getpid(), ((rocpd_agent->type == agent_type::GPU) ? "GPU" : "CPU"),
+            _n_info.id, getpid(),
+            ((rocpd_agent->type == agent_type::GPU) ? "GPU" : "CPU"),
             rocpd_agent->node_id, rocpd_agent->logical_node_id,
             rocpd_agent->logical_node_type_id, rocpd_agent->id, rocpd_agent->name.c_str(),
             rocpd_agent->model_name.c_str(), rocpd_agent->vendor_name.c_str(),
diff --git a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
index a7cbe39734..3bcc744db4 100644
--- a/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
+++ b/source/lib/rocprof-sys/library/components/backtrace_metrics.cpp
@@ -410,10 +410,10 @@ rocpd_initialize_backtrace_metrics_pmc(size_t dev_id, const char* units, int64_t
     const char* BLOCK            = "";
     const char* EXPRESSION       = "";
     auto        ni               = node_info::get_instance();
-    const auto*  TARGET_ARCH      = "CPU";
+    const auto* TARGET_ARCH      = "CPU";
 
     auto& _agent_manager = agent_manager::get_instance();
-    auto  _base_id    = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
+    auto  _base_id = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
 
     if constexpr(std::is_same_v<Category, category::thread_hardware_counter>)
     {
diff --git a/source/lib/rocprof-sys/library/cpu_freq.cpp b/source/lib/rocprof-sys/library/cpu_freq.cpp
index 2629dc8cdf..55d84be6ef 100644
--- a/source/lib/rocprof-sys/library/cpu_freq.cpp
+++ b/source/lib/rocprof-sys/library/cpu_freq.cpp
@@ -151,7 +151,7 @@ rocpd_initialize_cpu_freq_pmc(size_t dev_id)
     const auto* TARGET_ARCH      = "CPU";
 
     auto& _agent_manager = agent_manager::get_instance();
-    auto  base_id    = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
+    auto  base_id = _agent_manager.get_agent_by_id(dev_id, agent_type::CPU).base_id;
 
     do_for_enabled_cpus([&](size_t cpu_id) {
         data_processor.insert_pmc_description(
@@ -350,7 +350,7 @@ post_process()
         rocpd_initialize_cpu_freq_tracks();
 
         // `get_enabled_cpus()` returns the number of cores enabled for monitoring but the
-        // actuall device_id is 0, since there is a single device avaliable. And the
+        // actually device_id is 0, since there is a single device available. And the
         // agents seems to be assigned per device basis not per core.
         // TODO: `get_enabled_cpus()` should be fixed in the future to align with GPU
         // implementation.

From 39f3c623b3c1bbe474c60c99904352ba3e595d75 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Thu, 17 Jul 2025 10:50:03 -0400
Subject: [PATCH 11/33] Fix undefined mpi_send

---
 source/lib/rocprof-sys/library/components/comm_data.cpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index c5030d8f77..83d209f4c2 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -27,14 +27,9 @@
 #include "core/node_info.hpp"
 #include "core/perfetto.hpp"
 #include "core/rocpd/data_processor.hpp"
-#include "core/rocpd/json.hpp"
 #include "library/tracing.hpp"
 
-#include <optional>
-#include <timemory/backends/mpi.hpp>
-#include <timemory/manager.hpp>
 #include <timemory/units.hpp>
-#include <timemory/utility/locking.hpp>
 
 namespace rocprofsys
 {
@@ -141,8 +136,8 @@ rocpd_initialize_comm_data_pmc()
 
 #if defined(ROCPROFSYS_USE_MPI)
     data_processor.insert_pmc_description(
-        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, mpi_send::label,
-        "Tracks MPI Send communication data sizes",
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        comm_data::mpi_send::label, "Tracks MPI Send communication data sizes",
         trait::name<category::mpi>::description, LONG_DESCRIPTION, COMPONENT, MSG, "ABS",
         BLOCK, EXPRESSION, 0, 0);
 

From a4c3477b050b8b6d32f9556fb457e33638ecf0c2 Mon Sep 17 00:00:00 2001
From: Milan Radosavljevic <milan.radosavljevic@amd.com>
Date: Fri, 18 Jul 2025 03:18:43 -0400
Subject: [PATCH 12/33] Fix undefined mpi_recv

---
 source/lib/rocprof-sys/library/components/comm_data.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index 83d209f4c2..f0bd89a68c 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -142,8 +142,8 @@ rocpd_initialize_comm_data_pmc()
         BLOCK, EXPRESSION, 0, 0);
 
     data_processor.insert_pmc_description(
-        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID, mpi_recv::label,
-        "Tracks MPI Receive communication data sizes",
+        ni.id, getpid(), base_id, TARGET_ARCH, EVENT_CODE, INSTANCE_ID,
+        comm_data::mpi_recv::label, "Tracks MPI Receive communication data sizes",
         trait::name<category::mpi>::description, LONG_DESCRIPTION, COMPONENT, MSG, "ABS",
         BLOCK, EXPRESSION, 0, 0);
 #endif

From eab5aa313c1706fe3034e45523d63c6f08997157 Mon Sep 17 00:00:00 2001
From: Milan Radosavljevic <milan.radosavljevic@amd.com>
Date: Fri, 18 Jul 2025 05:30:00 -0400
Subject: [PATCH 13/33] Move use_rocpd guard in comm_data

---
 .../lib/rocprof-sys/library/components/comm_data.cpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index f0bd89a68c..c3e8963b50 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -196,8 +196,11 @@ rocpd_process_cpu_usage_events(const uint32_t device_id, int bytes)
 void
 comm_data::start()
 {
-    rocpd_initialize_comm_data_categories();
-    rocpd_initialize_comm_data_pmc();
+    if(get_use_rocpd())
+    {
+        rocpd_initialize_comm_data_categories();
+        rocpd_initialize_comm_data_pmc();
+    }
 }
 
 void
@@ -210,11 +213,6 @@ void
 comm_data::global_finalize()
 {
     configure();
-    if(get_use_rocpd())
-    {
-        rocpd_initialize_comm_data_categories();
-        rocpd_initialize_comm_data_pmc();
-    }
 }
 
 void

From 78b17c59a90ddf18668e66793e1cd71b0b847353 Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Mon, 14 Jul 2025 17:37:47 -0400
Subject: [PATCH 14/33] Adding sqlite-dev to our ci docker images (#280)

---
 docker/Dockerfile.opensuse    | 4 ++--
 docker/Dockerfile.opensuse.ci | 4 ++--
 docker/Dockerfile.rhel        | 5 +++--
 docker/Dockerfile.rhel.ci     | 4 ++--
 docker/Dockerfile.ubuntu      | 6 +++---
 docker/Dockerfile.ubuntu.ci   | 6 +++---
 6 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/docker/Dockerfile.opensuse b/docker/Dockerfile.opensuse
index 9fee2eed9f..8aca6bd599 100644
--- a/docker/Dockerfile.opensuse
+++ b/docker/Dockerfile.opensuse
@@ -24,8 +24,8 @@ RUN zypper --non-interactive update -y && \
     zypper --non-interactive dist-upgrade -y && \
     zypper --non-interactive install -y -t pattern devel_basis && \
     zypper --non-interactive install -y binutils-gold chrpath cmake curl dpkg-devel \
-        gcc-c++ git libdrm-devel libnuma-devel openmpi3-devel python3-pip rpm-build \
-        wget iproute2 && \
+        gcc-c++ git iproute2 libdrm-devel libnuma-devel openmpi3-devel python3-pip rpm-build \
+        sqlite3-devel wget  && \
     python3 -m pip install 'cmake==3.21'
 
 ARG ROCM_VERSION=0.0
diff --git a/docker/Dockerfile.opensuse.ci b/docker/Dockerfile.opensuse.ci
index 18e4fabd7f..915759dbea 100644
--- a/docker/Dockerfile.opensuse.ci
+++ b/docker/Dockerfile.opensuse.ci
@@ -28,8 +28,8 @@ RUN zypper --non-interactive update -y && \
     zypper --non-interactive dist-upgrade -y && \
     zypper --non-interactive install -y -t pattern devel_basis && \
     zypper --non-interactive install -y binutils-gold chrpath cmake curl dpkg-devel \
-        gcc-c++ git libnuma-devel openmpi3-devel papi-devel python3-pip \
-        rpm-build vim wget iproute2 && \
+        gcc-c++ git iproute2 libnuma-devel openmpi3-devel papi-devel python3-pip \
+        rpm-build sqlite3-devel vim wget && \
     zypper --non-interactive clean --all && \
     python3 -m pip install 'cmake==3.21' perfetto
 
diff --git a/docker/Dockerfile.rhel b/docker/Dockerfile.rhel
index ee237a8b60..5d73d1bd90 100644
--- a/docker/Dockerfile.rhel
+++ b/docker/Dockerfile.rhel
@@ -15,8 +15,9 @@ ENV LIBRARY_PATH ${LIBRARY_PATH}:/opt/amdgpu/lib64
 
 RUN yum groupinstall -y "Development Tools" && \
     yum install -y epel-release && crb enable && \
-    yum install -y --allowerasing chrpath cmake curl dpkg-devel libdrm-devel numactl-devel \
-        openmpi-devel papi-devel python3-pip texinfo wget which zlib-devel iproute && \
+    yum install -y --allowerasing chrpath cmake curl dpkg-devel iproute libdrm-devel \
+        numactl-devel openmpi-devel papi-devel python3-pip sqlite-devel texinfo \
+        wget which zlib-devel && \
     yum clean all && \
     python3 -m pip install 'cmake==3.21' && \
     python3 -m pip install 'perfetto'
diff --git a/docker/Dockerfile.rhel.ci b/docker/Dockerfile.rhel.ci
index 9bf000b30b..67f0dd079f 100644
--- a/docker/Dockerfile.rhel.ci
+++ b/docker/Dockerfile.rhel.ci
@@ -19,8 +19,8 @@ ARG NJOBS="8"
 
 RUN yum groupinstall -y "Development Tools" && \
     yum install -y epel-release && crb enable && \
-    yum install -y --allowerasing chrpath cmake curl dpkg-devel numactl-devel \
-        openmpi-devel papi-devel python3-pip texinfo wget which vim zlib-devel iproute && \
+    yum install -y --allowerasing chrpath cmake curl dpkg-devel iproute numactl-devel \
+        openmpi-devel papi-devel python3-pip sqlite-devel texinfo wget which vim zlib-devel && \
     yum clean all && \
     python3 -m pip install 'cmake==3.21' perfetto
 
diff --git a/docker/Dockerfile.ubuntu b/docker/Dockerfile.ubuntu
index f8cfb64315..5ffb31c275 100644
--- a/docker/Dockerfile.ubuntu
+++ b/docker/Dockerfile.ubuntu
@@ -21,9 +21,9 @@ ENV PATH ${HOME}/.local/bin:${PATH}
 RUN apt-get update && \
     apt-get dist-upgrade -y && \
     apt-get install -y apt-utils autoconf autotools-dev bash-completion bison \
-        build-essential chrpath cmake curl flex gettext git-core gnupg2 libnuma1 libopenmpi-dev \
-        libpapi-dev libpfm4-dev librpm-dev libtool libudev1 lsb-release m4 \
-        python3-pip rpm texinfo wget iproute2 && \
+        build-essential chrpath cmake curl flex gettext git-core gnupg2 iproute2 \
+        libnuma1 libopenmpi-dev libpapi-dev libpfm4-dev librpm-dev libsqlite3-dev \
+        libtool libudev1 lsb-release m4 python3-pip rpm texinfo wget && \
     OS_VERSION=$(cat /etc/os-release | grep VERSION_ID | sed 's/=/ /'1 | awk '{print $NF}' | sed 's/"//g') && \
     if [ "${OS_VERSION}" == "24.04" ]; then \
         python3 -m pip install --break-system-packages 'cmake==3.21'; \
diff --git a/docker/Dockerfile.ubuntu.ci b/docker/Dockerfile.ubuntu.ci
index 67b09c0da6..4e8df50917 100644
--- a/docker/Dockerfile.ubuntu.ci
+++ b/docker/Dockerfile.ubuntu.ci
@@ -26,9 +26,9 @@ ENV CMAKE_PREFIX_PATH /usr/local:${CMAKE_PREFIX_PATH}
 RUN apt-get update && \
     apt-get dist-upgrade -y && \
     apt-get install -y autoconf autotools-dev bash-completion bison build-essential \
-        bzip2 chrpath cmake curl environment-modules flex gettext git-core gnupg2 gzip \
-        libiberty-dev libpapi-dev libpfm4-dev libtool locales lsb-release m4 \
-        python3-pip texinfo unzip wget vim zip zlib1g-dev iproute2 && \
+        bzip2 chrpath cmake curl environment-modules flex gettext git-core gnupg2 \
+        gzip iproute2 libiberty-dev libpapi-dev libpfm4-dev libsqlite3-dev libtool \
+        locales lsb-release m4 python3-pip texinfo unzip wget vim zip zlib1g-dev && \
     apt-get autoclean && \
     if [ "${OS_VERSION}" == "24.04" ]; then \
         python3 -m pip install --break-system-packages 'cmake==3.21' perfetto \

From 7f67572d4c33a01abf880773e7dd6b7d7ec722fe Mon Sep 17 00:00:00 2001
From: Sajina PK <Sajina.PuthalathKandy@amd.com>
Date: Mon, 14 Jul 2025 19:23:19 -0400
Subject: [PATCH 15/33] Make CMakeFile fixes to align with rocDecode and
 rocJpeg changes (#281)

---
 examples/jpegdecode/CMakeLists.txt  | 12 ++++++------
 examples/videodecode/CMakeLists.txt | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/examples/jpegdecode/CMakeLists.txt b/examples/jpegdecode/CMakeLists.txt
index 5381ae0987..e92c8f5e34 100644
--- a/examples/jpegdecode/CMakeLists.txt
+++ b/examples/jpegdecode/CMakeLists.txt
@@ -60,7 +60,7 @@ if(ROCPROFSYS_DISABLE_EXAMPLES)
     endif()
 endif()
 
-find_package(ROCJPEG QUIET)
+find_package(rocjpeg QUIET)
 find_package(rocprofiler-register QUIET)
 
 # Copy image files to build directory
@@ -95,7 +95,7 @@ endfunction()
 # threads
 find_package(Threads REQUIRED)
 
-if(HIP_FOUND AND ROCJPEG_FOUND AND Threads_FOUND AND rocprofiler-register_FOUND)
+if(HIP_FOUND AND rocjpeg_FOUND AND Threads_FOUND AND rocprofiler-register_FOUND)
     # HIP
     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} hip::host)
     # threads
@@ -107,9 +107,9 @@ if(HIP_FOUND AND ROCJPEG_FOUND AND Threads_FOUND AND rocprofiler-register_FOUND)
     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} rocprofiler-register::rocprofiler-register)
 
     # rocJPEG
-    message(STATUS "RocJPEG library found: ${ROCJPEG_LIBRARY}")
-    include_directories(${ROCJPEG_INCLUDE_DIR})
-    set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} ${ROCJPEG_LIBRARY})
+    message(STATUS "RocJPEG library found: ${rocjpeg_LIBRARIES}")
+    include_directories(${rocjpeg_INCLUDE_DIR})
+    set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} rocjpeg::rocjpeg)
     list(APPEND SOURCES ${PROJECT_SOURCE_DIR} jpegdecodeperf.cpp)
     add_executable(jpegdecode ${SOURCES})
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++17")
@@ -132,7 +132,7 @@ else()
     if(NOT HIP_FOUND)
         message(FATAL_ERROR "-- ERROR!: HIP Not Found! - please install ROCm and HIP!")
     endif()
-    if(NOT ROCJPEG_FOUND)
+    if(NOT rocjpeg_FOUND)
         message(WARNING "-- ERROR!: rocJPEG Not Found! - please install rocJPEG!")
     endif()
     if(NOT Threads_FOUND)
diff --git a/examples/videodecode/CMakeLists.txt b/examples/videodecode/CMakeLists.txt
index ce1a50a0df..f8e8fcbf09 100644
--- a/examples/videodecode/CMakeLists.txt
+++ b/examples/videodecode/CMakeLists.txt
@@ -54,8 +54,8 @@ function(videodecode_message _MSG_TYPE)
 endfunction()
 
 # Find RocDecode
-find_package(ROCDECODE QUIET)
-if(NOT ROCDECODE_FOUND)
+find_package(rocdecode QUIET)
+if(NOT rocdecode_FOUND)
     videodecode_message(AUTHOR_WARNING "${PROJECT_NAME} skipped. Missing RocDecode...")
     return()
 endif()
@@ -102,7 +102,7 @@ set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIR})
 
 mark_as_advanced(FFMPEG_INCLUDE_DIR AVCODEC_LIBRARY AVFORMAT_LIBRARY AVUTIL_LIBRARY)
 
-if(FFMPEG_FOUND AND ROCDECODE_FOUND)
+if(FFMPEG_FOUND AND rocdecode_FOUND)
     # HIP
     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} hip::host)
 
@@ -116,8 +116,8 @@ if(FFMPEG_FOUND AND ROCDECODE_FOUND)
     endif()
 
     # rocDecode
-    include_directories(${ROCDECODE_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..)
-    set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} ${ROCDECODE_LIBRARY})
+    include_directories(${rocdecode_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..)
+    set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} rocdecode::rocdecode)
 
     # Threads
     set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -155,7 +155,7 @@ else()
     if(NOT FFMPEG_FOUND)
         message(WARNING "-- ERROR!: FFMPEG Not Found! - please install FFMPEG!")
     endif()
-    if(NOT ROCDECODE_FOUND)
+    if(NOT rocdecode_FOUND)
         message(WARNING "-- ERROR!: rocDecode Not Found! - please install rocDecode!")
     endif()
 endif()

From 5ce0a015361404c47c4649dcde640f6a6ea82999 Mon Sep 17 00:00:00 2001
From: darren-amd <Darren.Lao@amd.com>
Date: Mon, 14 Jul 2025 19:31:14 -0400
Subject: [PATCH 16/33] Fix ROCtx event ranges in trace output (#278)

* Fix marker api traces

* Remove space

* Formatting change

* Small change

* Update Changelog

* Add period to changelog

* Update source/lib/rocprof-sys/library/rocprofiler-sdk.cpp

Co-authored-by: David Galiffi <David.Galiffi@amd.com>

* Fix roctx tests

---------

Co-authored-by: David Galiffi <David.Galiffi@amd.com>
---
 CHANGELOG.md                                  |  1 +
 .../rocprof-sys/library/rocprofiler-sdk.cpp   | 30 ++++++++++++++-----
 tests/rocprof-sys-roctx-tests.cmake           | 26 +++++-----------
 3 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c410924e3a..d849c5628e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,6 +24,7 @@ Full documentation for ROCm Systems Profiler is available at [https://rocm.docs.
 - Fixed a build issue with CMake 4.
 - Fixed incorrect kernel names shown for kernel dispatch tracks in Perfetto.
 - Fixed formatting of some output logs.
+- Fixed an issue where ROC-TX ranges were displayed as two separate events instead of a single spanning event.
 
 ## ROCm Systems Profiler 1.0.2 for ROCm 6.4.2
 
diff --git a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
index 75778fa618..a5e0618d8f 100644
--- a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
+++ b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
@@ -222,14 +222,16 @@ save_args(rocprofiler_callback_tracing_kind_t /*kind*/, int32_t /*operation*/,
 auto&
 get_marker_pushed_ranges()
 {
-    static thread_local auto _v = std::vector<tim::hash_value_t>{};
+    static thread_local auto _v =
+        std::vector<std::pair<tim::hash_value_t, rocprofiler_timestamp_t>>{};
     return _v;
 }
 
 auto&
 get_marker_started_ranges()
 {
-    static thread_local auto _v = std::vector<tim::hash_value_t>{};
+    static thread_local auto _v =
+        std::vector<std::pair<tim::hash_value_t, rocprofiler_timestamp_t>>{};
     return _v;
 }
 
@@ -237,8 +239,12 @@ template <typename CategoryT>
 void
 tool_tracing_callback_start(CategoryT, rocprofiler_callback_tracing_record_t record,
                             rocprofiler_user_data_t* /*user_data*/,
-                            rocprofiler_timestamp_t /*ts*/)
+                            rocprofiler_timestamp_t ts)
 {
+    // Required because of how some compilers handle templates. This may result in an
+    // "unused variable" warning.
+    (void) ts;
+
     auto _name = tool_data->callback_tracing_info.at(record.kind, record.operation);
 
     if constexpr(std::is_same<CategoryT, category::rocm_marker_api>::value)
@@ -254,14 +260,14 @@ tool_tracing_callback_start(CategoryT, rocprofiler_callback_tracing_record_t rec
                 {
                     _name      = _data->args.roctxRangePushA.message;
                     auto _hash = tim::add_hash_id(_name);
-                    get_marker_pushed_ranges().emplace_back(_hash);
+                    get_marker_pushed_ranges().emplace_back(_hash, ts);
                     break;
                 }
                 case ROCPROFILER_MARKER_CORE_API_ID_roctxRangeStartA:
                 {
                     _name      = _data->args.roctxRangeStartA.message;
                     auto _hash = tim::add_hash_id(_name);
-                    get_marker_started_ranges().emplace_back(_hash);
+                    get_marker_started_ranges().emplace_back(_hash, ts);
                     break;
                 }
                 case ROCPROFILER_MARKER_CORE_API_ID_roctxMarkA:
@@ -294,6 +300,7 @@ tool_tracing_callback_stop(
 {
     auto _name = tool_data->callback_tracing_info.at(record.kind, record.operation);
 
+    uint64_t begin_ts = user_data->value;
     if constexpr(std::is_same<CategoryT, category::rocm_marker_api>::value)
     {
         if(record.kind == ROCPROFILER_CALLBACK_TRACING_MARKER_CORE_API)
@@ -310,8 +317,9 @@ tool_tracing_callback_stop(
                         "roctxRangePop does not have corresponding roctxRangePush on "
                         "this thread");
 
-                    auto _hash = get_marker_pushed_ranges().back();
+                    auto _hash = get_marker_pushed_ranges().back().first;
                     _name      = tim::get_hash_identifier_fast(_hash);
+                    begin_ts   = get_marker_pushed_ranges().back().second;
                     get_marker_pushed_ranges().pop_back();
                     break;
                 }
@@ -322,8 +330,9 @@ tool_tracing_callback_stop(
                         "roctxRangeStop does not have corresponding roctxRangeStart on "
                         "this thread");
 
-                    auto _hash = get_marker_started_ranges().back();
+                    auto _hash = get_marker_started_ranges().back().first;
                     _name      = tim::get_hash_identifier_fast(_hash);
+                    begin_ts   = get_marker_started_ranges().back().second;
                     get_marker_started_ranges().pop_back();
                     break;
                 }
@@ -332,6 +341,11 @@ tool_tracing_callback_stop(
                     _name = _data->args.roctxMarkA.message;
                     break;
                 }
+                case ROCPROFILER_MARKER_CORE_API_ID_roctxRangePushA:
+                case ROCPROFILER_MARKER_CORE_API_ID_roctxRangeStartA:
+                {
+                    return;
+                }
                 default:
                 {
                     break;
@@ -355,7 +369,7 @@ tool_tracing_callback_stop(
                                                                      &args);
         }
 
-        uint64_t _beg_ts = user_data->value;
+        uint64_t _beg_ts = begin_ts;
         uint64_t _end_ts = ts;
 
         tracing::push_perfetto_ts(
diff --git a/tests/rocprof-sys-roctx-tests.cmake b/tests/rocprof-sys-roctx-tests.cmake
index c8094a12cc..7d6a9337af 100644
--- a/tests/rocprof-sys-roctx-tests.cmake
+++ b/tests/rocprof-sys-roctx-tests.cmake
@@ -39,27 +39,19 @@ rocprofiler_systems_add_test(
 )
 set(ROCTX_LABEL
     roctxMark_GPU_workload
-    roctxRangePushA
-    roctxRangePushA
-    roctxRangeStartA
-    roctxRangeStartA
-    roctxRangePush_HIP_Kernel
-    roctxRangePush_HIP_Kernel
+    roctxRangePush_run_profiling
     roctxRangeStart_GPU_Compute
     roctxRangeStart_GPU_Compute
+    roctxRangePush_HIP_Kernel
+    roctxRangePush_HIP_Kernel
     roctxGetThreadId
     roctxMark_RoctxProfilerPause_End
     roctxMark_Thread_Start
     roctxMark_End
-    roctxRangePush_run_profiling
     roctxMark_Finished_GPU
 )
 
 set(ROCTX_COUNT
-    1
-    2
-    1
-    1
     1
     1
     1
@@ -76,19 +68,15 @@ set(ROCTX_COUNT
 set(ROCTX_DEPTH
     1
     1
+    2
     0
+    3
     1
-    0
-    1
-    0
-    1
-    0
-    1
-    1
+    2
+    2
     0
     0
     1
-    1
 )
 
 rocprofiler_systems_add_validation_test(

From 42fb5b628265d5a651e9cc82cf083517fe245ab2 Mon Sep 17 00:00:00 2001
From: Sajina PK <Sajina.PuthalathKandy@amd.com>
Date: Mon, 14 Jul 2025 21:12:10 -0400
Subject: [PATCH 17/33] Update gotcha submodule from timemory (#277)

* Update gotcha submodule from timemory

* Fix build failure and add copilot suggestions

* Fix formatting errors
---
 .gitmodules                                   |  1 +
 external/timemory                             |  2 +-
 .../components/pthread_create_gotcha.cpp      | 25 ++++++++++++++++++-
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 3c35b6582f..c70439d0ab 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,7 @@
 [submodule "external/timemory"]
 	path = external/timemory
 	url = https://github.com/ROCm/timemory.git
+	branch = rocprofiler-systems
 [submodule "external/perfetto"]
 	path = external/perfetto
 	url = https://github.com/google/perfetto.git
diff --git a/external/timemory b/external/timemory
index 5400e1349c..469eced5c6 160000
--- a/external/timemory
+++ b/external/timemory
@@ -1 +1 @@
-Subproject commit 5400e1349cb3266a1f9c605643c6d4f3871ced47
+Subproject commit 469eced5c690bb7320b88bf7ce93e7333f349aa5
diff --git a/source/lib/rocprof-sys/library/components/pthread_create_gotcha.cpp b/source/lib/rocprof-sys/library/components/pthread_create_gotcha.cpp
index 1e7249d09a..4ab2279696 100644
--- a/source/lib/rocprof-sys/library/components/pthread_create_gotcha.cpp
+++ b/source/lib/rocprof-sys/library/components/pthread_create_gotcha.cpp
@@ -411,7 +411,30 @@ pthread_create_gotcha::shutdown()
         {
             // skip sending signals to internal threads
             if(internal_native_handles.count(itr) != 0) continue;
-            if(pthread_equal(pthread_self(), itr) == 0 && pthread_equal(itr, itr) != 0)
+
+            bool                         has_bundle = false;
+            std::unique_lock<std::mutex> _bundle_lk{ *bundles_mutex };
+            const auto&                  thread_info = thread_info::get(itr);
+            // Check if this thread has a corresponding bundle entry
+            // With the new gotcha update more external threads are tracked
+            // but we only want to send signals to threads that have bundles
+            for(const auto& bundle_itr : *bundles)
+            {
+                try
+                {
+                    if(thread_info && thread_info->index_data &&
+                       bundle_itr.first == thread_info->index_data->sequent_value)
+                    {
+                        has_bundle = true;
+                        break;
+                    }
+                } catch(...)
+                {
+                    continue;
+                }
+            }
+
+            if(has_bundle && pthread_equal(pthread_self(), itr) == 0)
             {
                 ::pthread_kill(itr, shutdown_signal_v);
                 ++_expected_shutdown_signals_delivered;

From fd5b200001498409fb56d372c98a6763005de115 Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Tue, 15 Jul 2025 21:32:43 -0400
Subject: [PATCH 18/33] Remove an undefined submodule from the GOTCHA submodule
 (#285)

A recursive submodule update, `git submodule uppdate --recursive
--init`,
would fail due to an improperly defined and empty submodule in GOTCHA.

Signed-off-by: David Galiffi <David.Galiffi@amd.com>
---
 external/timemory | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/external/timemory b/external/timemory
index 469eced5c6..5780cc73c0 160000
--- a/external/timemory
+++ b/external/timemory
@@ -1 +1 @@
-Subproject commit 469eced5c690bb7320b88bf7ce93e7333f349aa5
+Subproject commit 5780cc73c0f9f97e99b7ef3efdde6a4a26ccf3d0

From 2a391b358a6f46507e587c59317ded152227ea64 Mon Sep 17 00:00:00 2001
From: habajpai-amd <habajpai@amd.com>
Date: Wed, 16 Jul 2025 20:53:50 +0530
Subject: [PATCH 19/33] Add missing <cstring> include for C string functions in
 RCCL tests (#282)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix: Add missing <string.h> include for C string functions in RCCL tests

* Update examples/rccl/rccl-tests/src/common.h

Yes, confirmed—<cstring> alone works in my environment. Updated the PR

Co-authored-by: David Galiffi <David.Galiffi@amd.com>

* clang-format

---------

Co-authored-by: David Galiffi <David.Galiffi@amd.com>
---
 examples/rccl/rccl-tests/src/common.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/rccl/rccl-tests/src/common.h b/examples/rccl/rccl-tests/src/common.h
index d82d2d0da6..2194e4e7af 100644
--- a/examples/rccl/rccl-tests/src/common.h
+++ b/examples/rccl/rccl-tests/src/common.h
@@ -17,11 +17,10 @@
 #endif
 #include "nccl1_compat.h"
 #include "timer.h"
+#include <cstring>
 #include <fstream>
 #include <iostream>
 #include <pthread.h>
-#include <string>
-
 // Ensures backward compatibility for FP8 types in RCCL 2.24.3 and later
 #if NCCL_VERSION_CODE >= NCCL_VERSION(2, 24, 3)
 #    define ncclFp8E4M3 ncclFloat8e4m3

From 8d4fc85509f0a0b60b7005e4267b2f701d275748 Mon Sep 17 00:00:00 2001
From: ajanicijamd <Aleksandar.Janicijevic@amd.com>
Date: Wed, 16 Jul 2025 18:49:22 -0400
Subject: [PATCH 20/33] Add a CMake Presets file (#44)

Adds the following presets:

- `ci` - to match the common CI settings - including tests and asserts
- `debug` - True debug build - include building tests
- `debug-optimized` - include building tests
- `release` - To match the "build-release` script - no tests.

The default build folder will be `${sourceDir}/build/<preset>`.

---------

Co-authored-by: David Galiffi <David.Galiffi@amd.com>
---
 .github/workflows/opensuse.yml     |  2 +
 .github/workflows/redhat.yml       |  2 +
 .github/workflows/ubuntu-focal.yml |  2 +
 .github/workflows/ubuntu-jammy.yml |  2 +
 .github/workflows/ubuntu-noble.yml |  2 +
 CMakePresets.json                  | 94 ++++++++++++++++++++++++++++++
 6 files changed, 104 insertions(+)
 create mode 100644 CMakePresets.json

diff --git a/.github/workflows/opensuse.yml b/.github/workflows/opensuse.yml
index ebbd9eef26..049bec9b7f 100644
--- a/.github/workflows/opensuse.yml
+++ b/.github/workflows/opensuse.yml
@@ -16,6 +16,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
   pull_request:
     branches: [ amd-mainline, amd-staging, release/** ]
     paths-ignore:
@@ -30,6 +31,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/redhat.yml b/.github/workflows/redhat.yml
index 77c1e49a6e..6de49268eb 100644
--- a/.github/workflows/redhat.yml
+++ b/.github/workflows/redhat.yml
@@ -16,6 +16,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
   pull_request:
     branches: [ amd-mainline, amd-staging, release/** ]
     paths-ignore:
@@ -30,6 +31,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/ubuntu-focal.yml b/.github/workflows/ubuntu-focal.yml
index 28d57f9542..be18f9c894 100644
--- a/.github/workflows/ubuntu-focal.yml
+++ b/.github/workflows/ubuntu-focal.yml
@@ -16,6 +16,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
   pull_request:
     branches: [ amd-mainline, amd-staging, release/** ]
     paths-ignore:
@@ -30,6 +31,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/ubuntu-jammy.yml b/.github/workflows/ubuntu-jammy.yml
index aa391520e8..02a21ec52d 100644
--- a/.github/workflows/ubuntu-jammy.yml
+++ b/.github/workflows/ubuntu-jammy.yml
@@ -16,6 +16,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
   pull_request:
     branches: [ amd-mainline, amd-staging, release/** ]
     paths-ignore:
@@ -30,6 +31,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/ubuntu-noble.yml b/.github/workflows/ubuntu-noble.yml
index cf00d96e3a..3544b32b9d 100644
--- a/.github/workflows/ubuntu-noble.yml
+++ b/.github/workflows/ubuntu-noble.yml
@@ -16,6 +16,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
   pull_request:
     branches: [ amd-mainline, amd-staging, release/** ]
     paths-ignore:
@@ -30,6 +31,7 @@ on:
       - '.github/workflows/weekly-mainline-sync.yml'
       - 'docker/**'
       - .wordlist.txt
+      - CMakePresets.json
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/CMakePresets.json b/CMakePresets.json
new file mode 100644
index 0000000000..e1e86a0f75
--- /dev/null
+++ b/CMakePresets.json
@@ -0,0 +1,94 @@
+{
+  "version": 3,
+  "configurePresets": [
+    {
+      "name": "ci",
+      "displayName": "official CI build",
+      "description": "Official CI build parameters",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/ci",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_INSTALL_PREFIX": "/opt/rocprofiler-systems",
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++",
+        "ROCPROFSYS_USE_ROCM": "ON",
+        "ROCPROFSYS_USE_PYTHON": "ON",
+        "ROCPROFSYS_BUILD_DYNINST": "ON",
+        "ROCPROFSYS_BUILD_TBB": "ON",
+        "ROCPROFSYS_BUILD_BOOST": "ON",
+        "ROCPROFSYS_BUILD_ELFUTILS": "ON",
+        "ROCPROFSYS_BUILD_LIBIBERTY": "ON",
+        "ROCPROFSYS_BUILD_TESTING": "ON",
+        "ROCPROFSYS_STRIP_LIBRARIES": "OFF",
+        "ROCPROFSYS_MAX_THREADS": "64",
+        "ROCPROFSYS_BUILD_CI": "ON"
+      }
+    },
+    {
+      "name": "debug",
+      "displayName": "official debug build",
+      "description": "Debug build parameters with tests",
+      "binaryDir": "${sourceDir}/build/debug",
+      "generator": "Ninja",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_INSTALL_PREFIX": "/opt/rocprofiler-systems",
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++",
+        "ROCPROFSYS_USE_ROCM": "ON",
+        "ROCPROFSYS_USE_PYTHON": "ON",
+        "ROCPROFSYS_BUILD_DYNINST": "ON",
+        "ROCPROFSYS_BUILD_TBB": "ON",
+        "ROCPROFSYS_BUILD_BOOST": "ON",
+        "ROCPROFSYS_BUILD_ELFUTILS": "ON",
+        "ROCPROFSYS_BUILD_LIBIBERTY": "ON",
+        "ROCPROFSYS_BUILD_TESTING": "ON",
+        "ROCPROFSYS_STRIP_LIBRARIES": "OFF",
+        "ROCPROFSYS_BUILD_DEBUG": "ON"
+      }
+    },
+    {
+      "name": "debug-optimized",
+      "displayName": "release build with debug info",
+      "description": "Release build with debug info with tests",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/debug-optimized",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
+        "CMAKE_INSTALL_PREFIX": "/opt/rocprofiler-systems",
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++",
+        "ROCPROFSYS_USE_ROCM": "ON",
+        "ROCPROFSYS_USE_PYTHON": "ON",
+        "ROCPROFSYS_BUILD_DYNINST": "ON",
+        "ROCPROFSYS_BUILD_TBB": "ON",
+        "ROCPROFSYS_BUILD_BOOST": "ON",
+        "ROCPROFSYS_BUILD_ELFUTILS": "ON",
+        "ROCPROFSYS_BUILD_LIBIBERTY": "ON",
+        "ROCPROFSYS_BUILD_TESTING": "ON",
+        "ROCPROFSYS_STRIP_LIBRARIES": "OFF"
+      }
+    },
+    {
+      "name": "release",
+      "displayName": "official release build",
+      "description": "Official release build",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/release",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_INSTALL_PREFIX": "/opt/rocprofiler-systems",
+        "CMAKE_C_COMPILER": "gcc",
+        "CMAKE_CXX_COMPILER": "g++",
+        "ROCPROFSYS_USE_ROCM": "ON",
+        "ROCPROFSYS_USE_PYTHON": "ON",
+        "ROCPROFSYS_BUILD_DYNINST": "ON",
+        "ROCPROFSYS_BUILD_TBB": "ON",
+        "ROCPROFSYS_BUILD_BOOST": "ON",
+        "ROCPROFSYS_BUILD_ELFUTILS": "ON",
+        "ROCPROFSYS_BUILD_LIBIBERTY": "ON"
+      }
+    }
+  ]
+}

From 1410eaee493a851f25148442b4498c93da23d586 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Fri, 18 Jul 2025 07:59:13 -0400
Subject: [PATCH 21/33] Benchmark support same category from different threads

---
 source/lib/core/benchmark/benchmark.hpp | 66 ++++++++++++++++++-------
 1 file changed, 47 insertions(+), 19 deletions(-)

diff --git a/source/lib/core/benchmark/benchmark.hpp b/source/lib/core/benchmark/benchmark.hpp
index 63a89352bc..64e4ac4fe6 100644
--- a/source/lib/core/benchmark/benchmark.hpp
+++ b/source/lib/core/benchmark/benchmark.hpp
@@ -34,6 +34,7 @@
 #include <sstream>
 #include <string>
 #include <type_traits>
+#include <unistd.h>
 #include <unordered_map>
 #include <vector>
 
@@ -80,6 +81,28 @@ struct benchmark_impl
     static void show_results() {}
 };
 
+using tid_t = __pid_t;
+struct indexed_category
+{
+    size_t category;
+    tid_t  thread_id;
+
+    friend bool operator==(const indexed_category& lhs, const indexed_category& rhs)
+    {
+        return lhs.category == rhs.category && lhs.thread_id == rhs.thread_id;
+    }
+};
+
+struct indexed_category_hash
+{
+    size_t operator()(const indexed_category& p) const noexcept
+    {
+        std::size_t hash1 = std::hash<size_t>{}(p.category);
+        std::size_t hash2 = std::hash<size_t>{}(p.thread_id);
+        return hash1 ^ (hash2 << 1);
+    }
+};
+
 template <typename category_enum, category_enum... enabled_categories>
 struct benchmark_impl<true, category_enum, enabled_categories...>
 {
@@ -110,21 +133,24 @@ struct benchmark_impl<true, category_enum, enabled_categories...>
     template <category_enum... categories>
     static void start()
     {
-        const auto      now = clock::now();
-        std::lock_guard lock(m_mutex);
-        (..., (if_compiled<categories>([&] {
+        static const thread_local auto _thread_id = gettid();
+        const auto                     now        = clock::now();
+        std::lock_guard                lock(m_mutex);
+        (..., (is_category_defined<categories>([&] {
              if(m_enabled.test(to_index(categories)))
-                 m_started[to_index(categories)] = now;
+                 m_started[{ to_index(categories), _thread_id }] = now;
          })));
     }
 
     template <category_enum... categories>
     static void end()
     {
-        const auto      end_time = clock::now();
-        std::lock_guard lock(m_mutex);
-        (..., (if_compiled<categories>([&] {
-             if(m_enabled.test(to_index(categories))) end_category(end_time, categories);
+        static const thread_local auto _thread_id = getpid();
+        const auto                     _end_time  = clock::now();
+        std::lock_guard                lock(m_mutex);
+        (..., (is_category_defined<categories>([&] {
+             if(m_enabled.test(to_index(categories)))
+                 end_category(_end_time, categories, _thread_id);
          })));
     }
 
@@ -140,8 +166,8 @@ struct benchmark_impl<true, category_enum, enabled_categories...>
         const auto*     env = std::getenv(envVar);
         if(env == nullptr || std::string(env).empty())
         {
-            ROCPROFSYS_WARNING(
-                1, "No BENCHMARK categories specified in environment variable.\n");
+            ROCPROFSYS_WARNING(1, "No BENCHMARK categories specified in environment "
+                                  "variable ROCPROFSYS_BENCHMARK_CATEGORIES.\n");
             return;
         }
         std::string        _str(env);
@@ -239,25 +265,26 @@ struct benchmark_impl<true, category_enum, enabled_categories...>
         return static_cast<size_t>(cat);
     }
 
-    static void end_category(const time_point& end_time, category_enum cat)
+    static void end_category(const time_point& end_time, category_enum cat,
+                             const tid_t thread_id)
     {
-        const size_t idx = to_index(cat);
-        auto         it  = m_started.find(idx);
-        if(it == m_started.end())
+        const size_t _idx = to_index(cat);
+        auto         _it  = m_started.find({ _idx, thread_id });
+        if(_it == m_started.end())
         {
             ROCPROFSYS_WARNING(1, "Benchmark error: missing start time for category!\n");
             return;
         }
 
         auto duration =
-            std::chrono::duration_cast<std::chrono::microseconds>(end_time - it->second)
+            std::chrono::duration_cast<std::chrono::microseconds>(end_time - _it->second)
                 .count();
-        m_started.erase(it);
-        m_results[idx].update(duration);
+        m_started.erase(_it);
+        m_results[_idx].update(duration);
     }
 
     template <category_enum Cat, typename Func>
-    static constexpr void if_compiled(Func&& f)
+    static constexpr void is_category_defined(Func&& f)
     {
         if constexpr(((Cat == enabled_categories) || ...))
         {
@@ -268,7 +295,8 @@ struct benchmark_impl<true, category_enum, enabled_categories...>
     static constexpr std::array<category_enum, sizeof...(enabled_categories)>
         compiledCategories = { enabled_categories... };
 
-    static inline std::unordered_map<size_t, time_point>   m_started;
+    static inline std::unordered_map<indexed_category, time_point, indexed_category_hash>
+                                                           m_started;
     static inline std::array<result_data, _max_categories> m_results{};
     static inline std::bitset<_max_categories>             m_enabled;
     static inline std::mutex                               m_mutex;

From 0449502a611968923cfea241607df8c37839fcc4 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Wed, 23 Jul 2025 11:12:04 -0400
Subject: [PATCH 22/33] Code improvement

---
 source/lib/common/md5sum.hpp                  |   2 +-
 source/lib/common/traits.hpp                  |  40 +++----
 source/lib/core/rocpd/data_processor.cpp      |  57 +++++-----
 .../lib/core/rocpd/data_storage/database.cpp  |   3 +-
 .../lib/core/rocpd/data_storage/database.hpp  | 101 ++++++++++--------
 .../query_builders/insert_query_builders.hpp  |   8 +-
 source/lib/rocprof-sys/library/kokkosp.cpp    |   4 +-
 7 files changed, 113 insertions(+), 102 deletions(-)

diff --git a/source/lib/common/md5sum.hpp b/source/lib/common/md5sum.hpp
index d0f6f3e1ca..6de09280e6 100644
--- a/source/lib/common/md5sum.hpp
+++ b/source/lib/common/md5sum.hpp
@@ -108,7 +108,7 @@ template <template <typename, typename...> class ContainerT, typename Tp,
           typename... TailT>
 std::string
 compute_md5sum(const ContainerT<Tp, TailT...>& inp,
-               std::enable_if_t<traits::is_string_literal_v<Tp>, int>)
+               std::enable_if_t<traits::is_string_literal<Tp>(), int>)
 {
     auto _val = md5sum{};
     for(const auto& itr : inp)
diff --git a/source/lib/common/traits.hpp b/source/lib/common/traits.hpp
index c31da5229d..14c55866e2 100644
--- a/source/lib/common/traits.hpp
+++ b/source/lib/common/traits.hpp
@@ -32,48 +32,40 @@ inline namespace common
 namespace traits
 {
 
+namespace
+{
 template <typename T>
-struct is_string_literal : std::false_type
-{};
-
-template <std::size_t N>
-struct is_string_literal<char[N]> : std::true_type
-{};
-
-template <std::size_t N>
-struct is_string_literal<const char[N]> : std::true_type
-{};
-
-template <>
-struct is_string_literal<std::string_view> : std::true_type
+struct is_string_literal_impl : std::false_type
 {};
 
 template <>
-struct is_string_literal<const char*> : std::true_type
+struct is_string_literal_impl<std::string_view> : std::true_type
 {};
 
 template <>
-struct is_string_literal<char*> : std::true_type
+struct is_string_literal_impl<const char*> : std::true_type
 {};
 
 template <>
-struct is_string_literal<std::string> : std::true_type
+struct is_string_literal_impl<char*> : std::true_type
 {};
 
 template <>
-struct is_string_literal<const std::string> : std::true_type
+struct is_string_literal_impl<std::string> : std::true_type
 {};
 
-template <>
-struct is_string_literal<const char* const> : std::true_type
-{};
+template <typename T>
+inline constexpr bool is_string_literal_impl_v = is_string_literal_impl<T>::value;
 
-template <>
-struct is_string_literal<char* const> : std::true_type
-{};
+}  // namespace
 
 template <typename T>
-inline constexpr bool is_string_literal_v = is_string_literal<T>::value;
+constexpr bool
+is_string_literal()
+{
+    using Tp = std::decay_t<T>;
+    return is_string_literal_impl_v<Tp>;
+}
 
 template <typename T>
 struct is_optional : std::false_type
diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 61e8c0325b..3d05e989b9 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -273,8 +273,8 @@ data_processor::initialize_event_stmt()
                      .get_query_string();
     _insert_event_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, size_t, size_t,
-                                      const char*, const char*, const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, size_t, size_t,
+                                       const char*, const char*, const char*>(query);
 }
 
 void
@@ -287,7 +287,7 @@ data_processor::initialize_pmc_event_stmt()
                      .get_query_string();
     _insert_pmc_event_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, double, const char*>(
+            .create_statement_executor<const char*, size_t, size_t, double, const char*>(
                 query);
 }
 
@@ -301,8 +301,8 @@ data_processor::initialize_sample_stmt()
                      .get_query_string();
     _insert_sample_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, uint64_t, size_t, const char*>(
-                query);
+            .create_statement_executor<const char*, size_t, uint64_t, size_t,
+                                       const char*>(query);
 }
 
 void
@@ -316,8 +316,8 @@ data_processor::initialize_region_stmt()
                      .get_query_string();
     _insert_region_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, size_t, uint64_t,
-                                      uint64_t, size_t, size_t, const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, size_t, uint64_t,
+                                       uint64_t, size_t, size_t, const char*>(query);
 }
 
 void
@@ -336,10 +336,11 @@ data_processor::initialize_kernel_dispatch_stmt()
                      .get_query_string();
     _insert_kernel_dispatch_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, size_t, size_t, size_t,
-                                      size_t, size_t, size_t, uint64_t, uint64_t, size_t,
-                                      size_t, size_t, size_t, size_t, size_t, size_t,
-                                      size_t, size_t, size_t, const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, size_t, size_t,
+                                       size_t, size_t, size_t, size_t, uint64_t, uint64_t,
+                                       size_t, size_t, size_t, size_t, size_t, size_t,
+                                       size_t, size_t, size_t, size_t, const char*>(
+                query);
 }
 
 void
@@ -356,10 +357,10 @@ data_processor::initialize_memory_copy_stmt()
                      .get_query_string();
     _insert_memory_copy_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, size_t, uint64_t,
-                                      uint64_t, size_t, size_t, size_t, size_t, size_t,
-                                      size_t, size_t, size_t, size_t, size_t,
-                                      const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, size_t, uint64_t,
+                                       uint64_t, size_t, size_t, size_t, size_t, size_t,
+                                       size_t, size_t, size_t, size_t, size_t,
+                                       const char*>(query);
 }
 
 void
@@ -378,10 +379,10 @@ data_processor::initialize_kernel_symbol_stmt()
             .get_query_string();
     _insert_kernel_symbol_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<size_t, const char*, size_t, size_t, uint64_t,
-                                      const char*, const char*, uint64_t, uint32_t,
-                                      uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
-                                      uint32_t, const char*>(query);
+            .create_statement_executor<size_t, const char*, size_t, size_t, uint64_t,
+                                       const char*, const char*, uint64_t, uint32_t,
+                                       uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
+                                       uint32_t, const char*>(query);
 }
 
 void
@@ -396,9 +397,9 @@ data_processor::initialize_code_object_stmt()
             .get_query_string();
     _insert_code_object_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<size_t, const char*, size_t, size_t, size_t,
-                                      const char*, uint64_t, uint64_t, uint64_t,
-                                      const char*, const char*>(query);
+            .create_statement_executor<size_t, const char*, size_t, size_t, size_t,
+                                       const char*, uint64_t, uint64_t, uint64_t,
+                                       const char*, const char*>(query);
 }
 
 void
@@ -412,8 +413,8 @@ data_processor::initialize_args_stmt()
                      .get_query_string();
     _insert_args_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, const char*,
-                                      const char*, const char*, const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, const char*,
+                                       const char*, const char*, const char*>(query);
 }
 
 void
@@ -429,7 +430,7 @@ data_processor::initialize_memory_alloc_stmt()
                      .get_query_string();
     _insert_memory_alloc_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<
+            .create_statement_executor<
                 const char*, size_t, size_t, size_t, size_t, const char*, const char*,
                 uint64_t, uint64_t, size_t, size_t, size_t, size_t, size_t, const char*>(
                 query);
@@ -444,9 +445,9 @@ data_processor::initialize_memory_alloc_stmt()
                 .get_query_string();
     _insert_memory_alloc_no_agent_statement =
         data_storage::database::get_instance()
-            .create_statment_executor<const char*, size_t, size_t, size_t, const char*,
-                                      const char*, uint64_t, uint64_t, size_t, size_t,
-                                      size_t, size_t, size_t, const char*>(query);
+            .create_statement_executor<const char*, size_t, size_t, size_t, const char*,
+                                       const char*, uint64_t, uint64_t, size_t, size_t,
+                                       size_t, size_t, size_t, const char*>(query);
 }
 
 void
diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index 08ec74839f..62da125c4d 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -24,6 +24,7 @@
 #include "common/md5sum.hpp"
 #include "debug.hpp"
 #include "node_info.hpp"
+#include "timemory/utility/filepath.hpp"
 
 #include <config.hpp>
 #include <fstream>
@@ -82,7 +83,7 @@ database::initialize_schema()
         auto _rocprofsys_root = tim::get_env<std::string>(
             "rocprofiler_systems_ROOT", tim::get_env<std::string>("ROCPROFSYS_ROOT", ""));
         if(!_rocprofsys_root.empty() &&
-           tim::filepath::exists(std::string(_rocprofsys_root)))
+           tim::filepath::direxists(std::string(_rocprofsys_root)))
         {
             auto new_file_path = std::string(_rocprofsys_root)
                                      .append("/share/rocprofiler-systems/")
diff --git a/source/lib/core/rocpd/data_storage/database.hpp b/source/lib/core/rocpd/data_storage/database.hpp
index 3c36d5598e..2fdcf80825 100644
--- a/source/lib/core/rocpd/data_storage/database.hpp
+++ b/source/lib/core/rocpd/data_storage/database.hpp
@@ -35,7 +35,6 @@ namespace rocpd
 namespace data_storage
 {
 static std::mutex _mutex;
-
 class database
 {
 public:
@@ -104,6 +103,62 @@ class database
         throw std::runtime_error(ss.str());
     }
 
+    template <typename T, std::enable_if_t<!(common::traits::is_string_literal<T>() ||
+                                             std::is_floating_point_v<std::decay_t<T>> ||
+                                             std::is_same_v<std::decay_t<T>, int64_t> ||
+                                             std::is_same_v<std::decay_t<T>, uint64_t> ||
+                                             std::is_same_v<std::decay_t<T>, int32_t> ||
+                                             std::is_same_v<std::decay_t<T>, uint32_t>),
+                                           int> = 0>
+    inline void bind_value([[maybe_unused]] sqlite3_stmt* stmt,
+                           [[maybe_unused]] int position, [[maybe_unused]] T& _value,
+                           [[maybe_unused]] const std::string& query)
+    {
+        throw std::runtime_error("Unsupported type for binding!");
+    }
+
+    template <typename T,
+              std::enable_if_t<common::traits::is_string_literal<T>(), int> = 0>
+    inline void bind_value(sqlite3_stmt* stmt, int position, T&& _value,
+                           const std::string& query)
+    {
+        validate_sqlite3_result(
+            sqlite3_bind_text(stmt, position, _value, -1, SQLITE_STATIC), query.c_str(),
+            "Failed to bind text! Position: ", position, ", Value: ", _value);
+    }
+
+    template <typename T,
+              std::enable_if_t<std::is_floating_point_v<std::decay_t<T>>, int> = 0>
+    inline void bind_value(sqlite3_stmt* stmt, int position, T&& _value,
+                           const std::string& query)
+    {
+        validate_sqlite3_result(
+            sqlite3_bind_double(stmt, position, _value), query.c_str(),
+            "Failed to bind double! Position: ", position, ", Value: ", _value);
+    }
+
+    template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, int64_t> ||
+                                               std::is_same_v<std::decay_t<T>, uint64_t>,
+                                           int> = 0>
+    inline void bind_value(sqlite3_stmt* stmt, int position, T&& _value,
+                           const std::string& query)
+    {
+        validate_sqlite3_result(sqlite3_bind_int64(stmt, position, _value), query.c_str(),
+                                "Failed to bind int64_t/uint64_t! Position: ", position,
+                                ", Value: ", _value);
+    }
+
+    template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, int32_t> ||
+                                               std::is_same_v<std::decay_t<T>, uint32_t>,
+                                           int> = 0>
+    inline void bind_value(sqlite3_stmt* stmt, int position, T&& _value,
+                           const std::string& query)
+    {
+        validate_sqlite3_result(sqlite3_bind_int(stmt, position, _value), query.c_str(),
+                                "Failed to bind int32_t/uint32_t! Position: ", position,
+                                ", Value: ", _value);
+    }
+
 public:
     void initialize_schema();
 
@@ -117,7 +172,7 @@ class database
      * values to the respective placeholders in the query.
      */
     template <typename... Values>
-    auto create_statment_executor(const std::string& query)
+    auto create_statement_executor(const std::string& query)
     {
         sqlite3_stmt* p_stmt;
         validate_sqlite3_result(
@@ -127,47 +182,9 @@ class database
 
         return [stmt, query, this](Values... value) {
             std::lock_guard lock{ _mutex };
-            int             position   = 1;
-            auto            bind_value = [&](auto _value) {
-                using T = decltype(_value);
-                if constexpr(std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
-                {
-                    validate_sqlite3_result(
-                        sqlite3_bind_int(stmt.get(), position, _value), query.c_str(),
-                        "Failed to bind int32_t/uint32_t! Position: ", position,
-                        ", Value: ", _value);
-                }
-                else if constexpr(std::is_same_v<T, int64_t> ||
-                                  std::is_same_v<T, uint64_t>)
-                {
-                    validate_sqlite3_result(
-                        sqlite3_bind_int64(stmt.get(), position, _value), query.c_str(),
-                        "Failed to bind int64_t/uint64_t! Position: ", position,
-                        ", Value: ", _value);
-                }
-                else if constexpr(std::is_floating_point_v<T>)
-                {
-                    validate_sqlite3_result(
-                        sqlite3_bind_double(stmt.get(), position, _value), query.c_str(),
-                        "Failed to bind double! Position: ", position,
-                        ", Value: ", _value);
-                }
-                else if constexpr(common::traits::is_string_literal_v<std::decay_t<T>>)
-                {
-                    validate_sqlite3_result(sqlite3_bind_text(stmt.get(), position,
-                                                                         _value, -1, SQLITE_STATIC),
-                                                       query.c_str(),
-                                                       "Failed to bind text! Position: ", position,
-                                                       ", Value: ", _value);
-                }
-                else
-                {
-                    throw std::runtime_error("Unsupported type for binding!");
-                }
-                position++;
-            };
+            int             position = 1;
 
-            (bind_value(value), ...);
+            ((bind_value(stmt.get(), position++, value, query)), ...);
 
             validate_sqlite3_result(sqlite3_step(stmt.get()), query.c_str(),
                                     "Failed to execute step!\n", "Values: ", value...);
diff --git a/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp b/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
index e8e1f006bd..19898f2308 100644
--- a/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
+++ b/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
@@ -60,7 +60,7 @@ struct query_value_builder
 
 private:
     template <typename T>
-    std::enable_if_t<common::traits::is_string_literal_v<T>, std::stringstream&>
+    std::enable_if_t<common::traits::is_string_literal<T>(), std::stringstream&>
     process_value(T& value)
     {
         _ss << "\"" << value << "\"";
@@ -83,7 +83,7 @@ struct query_value_builder
     }
 
     template <typename T>
-    std::enable_if_t<!common::traits::is_string_literal_v<T> &&
+    std::enable_if_t<!common::traits::is_string_literal<T>() &&
                          !common::traits::is_optional_v<std::decay_t<T>>,
                      std::stringstream&>
     process_value(T& value)
@@ -104,8 +104,8 @@ struct query_columns_builder
     {}
 
     template <typename... Columns,
-              typename = std::enable_if_t<
-                  (common::traits::is_string_literal<Columns>::value && ...)>>
+              typename =
+                  std::enable_if_t<(common::traits::is_string_literal<Columns>() && ...)>>
     query_value_builder& set_columns(Columns&... columns)
     {
         auto i = sizeof...(columns);
diff --git a/source/lib/rocprof-sys/library/kokkosp.cpp b/source/lib/rocprof-sys/library/kokkosp.cpp
index ab0107bb31..6d513fe8f9 100644
--- a/source/lib/rocprof-sys/library/kokkosp.cpp
+++ b/source/lib/rocprof-sys/library/kokkosp.cpp
@@ -172,7 +172,7 @@ rocpd_initialize_kokkos_category()
 }
 
 void
-rocpd_initialize_kokos_track()
+rocpd_initialize_kokkos_track()
 {
     auto& data_processor = get_data_processor();
     auto& n_info         = rocprofsys::node_info::get_instance();
@@ -311,7 +311,7 @@ extern "C"
             if(rocprofsys::get_use_rocpd())
             {
                 rocpd_initialize_kokkos_category();
-                rocpd_initialize_kokos_track();
+                rocpd_initialize_kokkos_track();
             }
         }
 

From b7c82a5fe43d1c56c9f19ac892385ba7ec63b078 Mon Sep 17 00:00:00 2001
From: Aleksandar Djordjevic <aleksandar.djordjevic@amd.com>
Date: Wed, 23 Jul 2025 17:16:24 +0200
Subject: [PATCH 23/33] Update source/lib/core/rocpd/data_storage/database.cpp

---
 source/lib/core/rocpd/data_storage/database.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/lib/core/rocpd/data_storage/database.cpp b/source/lib/core/rocpd/data_storage/database.cpp
index 62da125c4d..d0b6f58778 100644
--- a/source/lib/core/rocpd/data_storage/database.cpp
+++ b/source/lib/core/rocpd/data_storage/database.cpp
@@ -24,12 +24,12 @@
 #include "common/md5sum.hpp"
 #include "debug.hpp"
 #include "node_info.hpp"
-#include "timemory/utility/filepath.hpp"
 
 #include <config.hpp>
 #include <fstream>
 #include <regex>
 #include <timemory/environment/types.hpp>
+#include <timemory/utility/filepath.hpp>
 #include <unistd.h>
 
 namespace

From 8a286227efa5dd1c8b686b98445ed7c22ad21e5e Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Thu, 24 Jul 2025 05:35:25 -0400
Subject: [PATCH 24/33] Add ROCPROFSYS_ENABLE_BENCHMARK option

---
 CMakeLists.txt | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 123e04ebc1..605b070f0d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -224,6 +224,9 @@ rocprofiler_systems_add_option(ROCPROFSYS_INSTALL_PERFETTO_TOOLS
 rocprofiler_systems_add_option(ROCPROFILER_BUILD_SQLITE3
                                "Enable building sqlite3 library internally" OFF
 )
+rocprofiler_systems_add_option(ROCPROFSYS_ENABLE_BENCHMARK
+                               "Enable performance benchmarking capabilities for the project" OFF
+)
 
 if(ROCPROFSYS_USE_PAPI)
     rocprofiler_systems_add_option(ROCPROFSYS_BUILD_PAPI "Build PAPI from submodule" ON)
@@ -331,6 +334,10 @@ if(ROCPROFSYS_BUILD_TESTING OR "$ENV{ROCPROFSYS_CI}" MATCHES "[1-9]+|ON|on|y|yes
     include(CTest)
 endif()
 
+if(ROCPROFSYS_ENABLE_BENCHMARK)
+    add_compile_definitions(-DROCPROFSYS_USE_BENCHMARK=1)
+endif()
+
 # ------------------------------------------------------------------------------#
 #
 # library and executables

From 7a5ba53b633b3887a73dabfe3def26ebf51f2494 Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Thu, 24 Jul 2025 11:15:18 -0400
Subject: [PATCH 25/33] Update CHANGELOGS.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d849c5628e..a9af36ffed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ Full documentation for ROCm Systems Profiler is available at [https://rocm.docs.
 - How-to document for VCN and JPEG activity sampling and tracing.
 - Support for tracing Fortran applications.
 - Support for tracing MPI API in Fortran.
+- Initial support for rocPD database output with the `ROCPROFSYS_USE_ROCPD` configuration setting.
 
 ### Changed
 

From 4dc5da4cda07f70f5e4341137c2b0ced79d3586e Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Thu, 24 Jul 2025 18:17:25 -0400
Subject: [PATCH 26/33] Renamed `rocpd_process_kokos_event` to
 `rocpd_process_kokkos_event`

---
 source/lib/rocprof-sys/library/kokkosp.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/source/lib/rocprof-sys/library/kokkosp.cpp b/source/lib/rocprof-sys/library/kokkosp.cpp
index 6d513fe8f9..b8883b3f08 100644
--- a/source/lib/rocprof-sys/library/kokkosp.cpp
+++ b/source/lib/rocprof-sys/library/kokkosp.cpp
@@ -183,8 +183,8 @@ rocpd_initialize_kokkos_track()
 }
 
 void
-rocpd_process_kokos_event(const char* name, const char* event_type, const char* target,
-                          uint64_t timestamp_ns)
+rocpd_process_kokkos_event(const char* name, const char* event_type, const char* target,
+                           uint64_t timestamp_ns)
 {
     auto& data_processor = get_data_processor();
     auto  event_metadata = rocpd::json::create();
@@ -621,9 +621,9 @@ extern "C"
 
         if(rocprofsys::config::get_use_rocpd())
         {
-            rocpd_process_kokos_event(JOIN(" ", _kp_prefix, label).c_str(),
-                                      "[dual_view_sync]", (is_device) ? "device" : "host",
-                                      timestamp);
+            rocpd_process_kokkos_event(JOIN(" ", _kp_prefix, label).c_str(),
+                                       "[dual_view_sync]",
+                                       (is_device) ? "device" : "host", timestamp);
         }
     }
 
@@ -650,9 +650,9 @@ extern "C"
 
         if(rocprofsys::config::get_use_rocpd())
         {
-            rocpd_process_kokos_event(JOIN(" ", _kp_prefix, label).c_str(),
-                                      "[dual_view_modify]",
-                                      (is_device) ? "device" : "host", timestamp);
+            rocpd_process_kokkos_event(JOIN(" ", _kp_prefix, label).c_str(),
+                                       "[dual_view_modify]",
+                                       (is_device) ? "device" : "host", timestamp);
         }
     }
 

From 08f5579c78834aeeac27b30501c27f974ec33dd8 Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Thu, 24 Jul 2025 18:23:54 -0400
Subject: [PATCH 27/33] Fixed typo

Rename `rocpd_post_process_backtrace_metrix` to `rocpd_post_process_backtrace_metrics`

Signed-off-by: David Galiffi <David.Galiffi@amd.com>
---
 source/lib/rocprof-sys/library/sampling.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/lib/rocprof-sys/library/sampling.cpp b/source/lib/rocprof-sys/library/sampling.cpp
index f074164e4c..7b39501617 100644
--- a/source/lib/rocprof-sys/library/sampling.cpp
+++ b/source/lib/rocprof-sys/library/sampling.cpp
@@ -1738,8 +1738,8 @@ rocpd_post_process_overflow_data(
 }
 
 void
-rocpd_post_process_backtrace_metrix(int64_t                                 _tid,
-                                    const std::vector<timer_sampling_data>& _timer_data)
+rocpd_post_process_backtrace_metrics(int64_t                                 _tid,
+                                     const std::vector<timer_sampling_data>& _timer_data)
 {
     auto _valid_metrics = backtrace_metrics::valid_array_t{};
 
@@ -1771,7 +1771,7 @@ rocpd_post_process_timer_data(int64_t                                 _tid,
 
     if(!_timer_data.empty())
     {
-        rocpd_post_process_backtrace_metrix(_tid, _timer_data);
+        rocpd_post_process_backtrace_metrics(_tid, _timer_data);
 
         auto _beg_ns = std::max(_timer_data.front().m_beg, _thread_info->get_start());
         auto _end_ns = std::min(_timer_data.back().m_end, _thread_info->get_stop());

From 7d066d2026af62a35be739c59fed8ba71b01c04a Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Fri, 25 Jul 2025 09:28:46 -0400
Subject: [PATCH 28/33] Address comments

---
 source/lib/core/CMakeLists.txt                  | 14 +++++++-------
 source/lib/core/benchmark/benchmark.hpp         |  4 ++--
 source/lib/core/benchmark/category.hpp          |  4 ++--
 source/lib/core/rocpd/CMakeLists.txt            |  9 +--------
 source/lib/core/rocpd/data_processor.cpp        |  2 +-
 .../lib/core/rocpd/data_storage/CMakeLists.txt  | 17 +++++++++++++++++
 .../insert_query_builders.hpp                   |  0
 .../{queries => }/table_insert_query.hpp        |  2 +-
 .../library/components/comm_data.cpp            |  5 ++++-
 9 files changed, 35 insertions(+), 22 deletions(-)
 create mode 100644 source/lib/core/rocpd/data_storage/CMakeLists.txt
 rename source/lib/core/rocpd/data_storage/{queries/query_builders => }/insert_query_builders.hpp (100%)
 rename source/lib/core/rocpd/data_storage/{queries => }/table_insert_query.hpp (97%)

diff --git a/source/lib/core/CMakeLists.txt b/source/lib/core/CMakeLists.txt
index 46c8508634..693002a72d 100644
--- a/source/lib/core/CMakeLists.txt
+++ b/source/lib/core/CMakeLists.txt
@@ -6,6 +6,8 @@ configure_file(
 )
 
 set(core_sources
+    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/amd_smi.cpp
     ${CMAKE_CURRENT_LIST_DIR}/argparse.cpp
     ${CMAKE_CURRENT_LIST_DIR}/categories.cpp
     ${CMAKE_CURRENT_LIST_DIR}/config.cpp
@@ -16,18 +18,19 @@ set(core_sources
     ${CMAKE_CURRENT_LIST_DIR}/exception.cpp
     ${CMAKE_CURRENT_LIST_DIR}/gpu.cpp
     ${CMAKE_CURRENT_LIST_DIR}/mproc.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/node_info.cpp
     ${CMAKE_CURRENT_LIST_DIR}/perf.cpp
     ${CMAKE_CURRENT_LIST_DIR}/perfetto.cpp
     ${CMAKE_CURRENT_LIST_DIR}/rocprofiler-sdk.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/amd_smi.cpp
     ${CMAKE_CURRENT_LIST_DIR}/state.cpp
     ${CMAKE_CURRENT_LIST_DIR}/timemory.cpp
     ${CMAKE_CURRENT_LIST_DIR}/utility.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/node_info.cpp
 )
 
 set(core_headers
+    ${CMAKE_CURRENT_LIST_DIR}/agent.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/amd_smi.hpp
     ${CMAKE_CURRENT_LIST_DIR}/argparse.hpp
     ${CMAKE_CURRENT_LIST_DIR}/categories.hpp
     ${CMAKE_CURRENT_LIST_DIR}/common.hpp
@@ -42,17 +45,14 @@ set(core_headers
     ${CMAKE_CURRENT_LIST_DIR}/locking.hpp
     ${CMAKE_CURRENT_LIST_DIR}/mpi.hpp
     ${CMAKE_CURRENT_LIST_DIR}/mproc.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/node_info.hpp
     ${CMAKE_CURRENT_LIST_DIR}/perf.hpp
     ${CMAKE_CURRENT_LIST_DIR}/perfetto.hpp
     ${CMAKE_CURRENT_LIST_DIR}/redirect.hpp
     ${CMAKE_CURRENT_LIST_DIR}/rocprofiler-sdk.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/amd_smi.hpp
     ${CMAKE_CURRENT_LIST_DIR}/state.hpp
     ${CMAKE_CURRENT_LIST_DIR}/timemory.hpp
     ${CMAKE_CURRENT_LIST_DIR}/utility.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/agent.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/agent_manager.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/node_info.hpp
 )
 
 add_library(rocprofiler-systems-core-library STATIC)
diff --git a/source/lib/core/benchmark/benchmark.hpp b/source/lib/core/benchmark/benchmark.hpp
index 64e4ac4fe6..d8173e2098 100644
--- a/source/lib/core/benchmark/benchmark.hpp
+++ b/source/lib/core/benchmark/benchmark.hpp
@@ -41,7 +41,7 @@
 #include "core/benchmark/category.hpp"
 #include "core/debug.hpp"
 
-namespace rocprofiler
+namespace rocprofsys
 {
 namespace benchmark
 {
@@ -350,4 +350,4 @@ show_results()
 }
 
 }  // namespace benchmark
-}  // namespace rocprofiler
+}  // namespace rocprofsys
diff --git a/source/lib/core/benchmark/category.hpp b/source/lib/core/benchmark/category.hpp
index f5a8774508..61afe08e08 100644
--- a/source/lib/core/benchmark/category.hpp
+++ b/source/lib/core/benchmark/category.hpp
@@ -30,7 +30,7 @@
 
 #include <string_view>
 
-namespace rocprofiler
+namespace rocprofsys
 {
 namespace benchmark
 {
@@ -65,4 +65,4 @@ to_string(category cat)
 }
 
 }  // namespace benchmark
-}  // namespace rocprofiler
+}  // namespace rocprofsys
diff --git a/source/lib/core/rocpd/CMakeLists.txt b/source/lib/core/rocpd/CMakeLists.txt
index 0e4d1a5594..f6a6576383 100644
--- a/source/lib/core/rocpd/CMakeLists.txt
+++ b/source/lib/core/rocpd/CMakeLists.txt
@@ -1,20 +1,13 @@
 set(rocpd_sources
     ${CMAKE_CURRENT_LIST_DIR}/data_processor.cpp
     ${CMAKE_CURRENT_LIST_DIR}/json.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/data_storage/database.cpp
 )
 
 set(rocpd_headers
     ${CMAKE_CURRENT_LIST_DIR}/data_processor.hpp
     ${CMAKE_CURRENT_LIST_DIR}/json.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/data_storage/database.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/data_storage/queries/table_insert_query.hpp
-    ${CMAKE_CURRENT_LIST_DIR}/data_storage/queries/query_builders/insert_query_builders.hpp
 )
 
 target_sources(rocprofiler-systems-core-library PRIVATE ${rocpd_sources} ${rocpd_headers})
 
-target_link_libraries(
-    rocprofiler-systems-core-library
-    PRIVATE $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-sqlite3>
-)
+add_subdirectory(data_storage)
diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 3d05e989b9..84927b43e5 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -22,7 +22,7 @@
 
 #include "data_processor.hpp"
 #include "core/rocpd/data_storage/database.hpp"
-#include "core/rocpd/data_storage/queries/table_insert_query.hpp"
+#include "core/rocpd/data_storage/table_insert_query.hpp"
 #include "debug.hpp"
 
 namespace rocprofsys
diff --git a/source/lib/core/rocpd/data_storage/CMakeLists.txt b/source/lib/core/rocpd/data_storage/CMakeLists.txt
new file mode 100644
index 0000000000..dad56e6a85
--- /dev/null
+++ b/source/lib/core/rocpd/data_storage/CMakeLists.txt
@@ -0,0 +1,17 @@
+set(data_storage_sources
+    ${CMAKE_CURRENT_LIST_DIR}/database.cpp
+)
+
+set(data_storage_headers
+    ${CMAKE_CURRENT_LIST_DIR}/database.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/insert_query_builders.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/table_insert_query.hpp
+)
+
+
+target_sources(rocprofiler-systems-core-library PRIVATE ${data_storage_sources})
+
+target_link_libraries(
+    rocprofiler-systems-core-library
+    PRIVATE $<BUILD_INTERFACE:rocprofiler-systems::rocprofiler-systems-sqlite3>
+)
diff --git a/source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp b/source/lib/core/rocpd/data_storage/insert_query_builders.hpp
similarity index 100%
rename from source/lib/core/rocpd/data_storage/queries/query_builders/insert_query_builders.hpp
rename to source/lib/core/rocpd/data_storage/insert_query_builders.hpp
diff --git a/source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp b/source/lib/core/rocpd/data_storage/table_insert_query.hpp
similarity index 97%
rename from source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp
rename to source/lib/core/rocpd/data_storage/table_insert_query.hpp
index a1159b8fc8..c0f0b1912f 100644
--- a/source/lib/core/rocpd/data_storage/queries/table_insert_query.hpp
+++ b/source/lib/core/rocpd/data_storage/table_insert_query.hpp
@@ -22,7 +22,7 @@
 
 #pragma once
 
-#include "query_builders/insert_query_builders.hpp"
+#include "insert_query_builders.hpp"
 
 namespace rocprofsys
 {
diff --git a/source/lib/rocprof-sys/library/components/comm_data.cpp b/source/lib/rocprof-sys/library/components/comm_data.cpp
index c3e8963b50..6625b7ddbe 100644
--- a/source/lib/rocprof-sys/library/components/comm_data.cpp
+++ b/source/lib/rocprof-sys/library/components/comm_data.cpp
@@ -90,11 +90,14 @@ rocpd_initialize_comm_data_categories()
 
     get_data_processor().insert_category(category_enum_id<category::comm_data>::value,
                                          trait::name<category::comm_data>::value);
+#if defined(ROCPROFSYS_USE_MPI)
     get_data_processor().insert_category(category_enum_id<category::mpi>::value,
                                          trait::name<category::mpi>::value);
+#endif
+#if defined(ROCPROFSYS_USE_RCCL)
     get_data_processor().insert_category(category_enum_id<category::rocm_rccl>::value,
                                          trait::name<category::rocm_rccl>::value);
-
+#endif
     _is_initialized = true;
 }
 

From 2ca38d13da6737f846f77a525c07f83a2230b873 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Fri, 25 Jul 2025 09:58:20 -0400
Subject: [PATCH 29/33] Revert examples/jpegdecode/CmakeLists.txt

---
 examples/jpegdecode/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/jpegdecode/CMakeLists.txt b/examples/jpegdecode/CMakeLists.txt
index a8467f6cac..bc1eed1d55 100644
--- a/examples/jpegdecode/CMakeLists.txt
+++ b/examples/jpegdecode/CMakeLists.txt
@@ -146,8 +146,8 @@ if(HIP_FOUND AND rocjpeg_FOUND AND Threads_FOUND AND rocprofiler-register_FOUND)
     # rocprofiler-register
     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} rocprofiler-register::rocprofiler-register)
 
+    # rocJPEG
     message(STATUS "RocJPEG library found: ${rocjpeg_LIBRARY}")
-
     include_directories(${rocjpeg_INCLUDE_DIR})
     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} rocjpeg::rocjpeg)
     list(APPEND SOURCES ${PROJECT_SOURCE_DIR} jpegdecodeperf.cpp)

From 72b71ea47d8fefffaa287819dcd1b56d60c11ca6 Mon Sep 17 00:00:00 2001
From: Aleksandar <aleksandar.djordjevic@amd.com>
Date: Fri, 25 Jul 2025 10:10:14 -0400
Subject: [PATCH 30/33] Revert rocprofiler-sdk.cpp

---
 .../rocprof-sys/library/rocprofiler-sdk.cpp   | 33 ++++++-------------
 1 file changed, 10 insertions(+), 23 deletions(-)

diff --git a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
index a5e0618d8f..26af5b6261 100644
--- a/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
+++ b/source/lib/rocprof-sys/library/rocprofiler-sdk.cpp
@@ -578,12 +578,6 @@ tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
                                     record.kind);
                 break;
             }
-            default:
-            {
-                ROCPROFSYS_CI_ABORT(true, "Unhandled callback record kind: %i\n",
-                                    record.kind);
-                break;
-            }
         }
     }
     else if(record.phase == ROCPROFILER_CALLBACK_PHASE_EXIT)
@@ -684,12 +678,6 @@ tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
                                     record.kind);
                 break;
             }
-            default:
-            {
-                ROCPROFSYS_CI_ABORT(true, "Unhandled callback record kind: %i\n",
-                                    record.kind);
-                break;
-            }
         }
     }
     else if(record.phase == ROCPROFILER_CALLBACK_PHASE_NONE)
@@ -982,10 +970,10 @@ counter_record_callback(rocprofiler_dispatch_counting_service_data_t dispatch_da
             ROCPROFSYS_CONDITIONAL_ABORT_F(
                 !_agent, "unable to find tool agent for agent (id=%zu)\n",
                 _agent_id.handle);
-            ROCPROFSYS_CONDITIONAL_ABORT_F(!_info,
-                                           "unable to find counter info for counter "
-                                           "(id=%zu) on agent (id=%zu)\n",
-                                           itr.first.handle, _agent_id.handle);
+            ROCPROFSYS_CONDITIONAL_ABORT_F(
+                !_info,
+                "unable to find counter info for counter (id=%zu) on agent (id=%zu)\n",
+                itr.first.handle, _agent_id.handle);
 
             auto _dev_id = static_cast<uint32_t>(_agent->device_id);
 
@@ -1158,8 +1146,8 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
 
         // ROCPROFILER_CALL(rocprofiler_configure_external_correlation_id_request_service(
         //     _data->primary_ctx, external_corr_id_request_kinds.data(),
-        //     external_corr_id_request_kinds.size(),
-        //     external_correlation_id_callback, _data));
+        //     external_corr_id_request_kinds.size(), external_correlation_id_callback,
+        //     _data));
     }
 
     if(_buffered_domain.count(ROCPROFILER_BUFFER_TRACING_MEMORY_COPY) > 0)
@@ -1224,9 +1212,8 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
         }
     }
 
-    // throwaway context for handling the profiler control API. If primary_ctx were
-    // used, we would get profiler pause callback but never get profiler resume
-    // callback
+    // throwaway context for handling the profiler control API. If primary_ctx were used,
+    // we would get profiler pause callback but never get profiler resume callback
     {
         auto _local_ctx = rocprofiler_context_id_t{ 0 };
         ROCPROFILER_CALL(rocprofiler_create_context(&_local_ctx));
@@ -1237,8 +1224,8 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* user_data)
 
     if(!is_valid(_data->primary_ctx))
     {
-        // notify rocprofiler that initialization failed and all the contexts,
-        // buffers, etc. created should be ignored
+        // notify rocprofiler that initialization failed and all the contexts, buffers,
+        // etc. created should be ignored
         return -1;
     }
 

From 4b5bf3c6432f0de3777de8788a4126a607de32db Mon Sep 17 00:00:00 2001
From: Aleksandar Djordjevic <aleksandar.djordjevic@amd.com>
Date: Fri, 25 Jul 2025 18:53:58 +0200
Subject: [PATCH 31/33] Update CMakeLists.txt

---
 source/lib/core/rocpd/data_storage/CMakeLists.txt | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/source/lib/core/rocpd/data_storage/CMakeLists.txt b/source/lib/core/rocpd/data_storage/CMakeLists.txt
index dad56e6a85..ad28a39df3 100644
--- a/source/lib/core/rocpd/data_storage/CMakeLists.txt
+++ b/source/lib/core/rocpd/data_storage/CMakeLists.txt
@@ -1,6 +1,4 @@
-set(data_storage_sources
-    ${CMAKE_CURRENT_LIST_DIR}/database.cpp
-)
+set(data_storage_sources ${CMAKE_CURRENT_LIST_DIR}/database.cpp)
 
 set(data_storage_headers
     ${CMAKE_CURRENT_LIST_DIR}/database.hpp
@@ -8,7 +6,6 @@ set(data_storage_headers
     ${CMAKE_CURRENT_LIST_DIR}/table_insert_query.hpp
 )
 
-
 target_sources(rocprofiler-systems-core-library PRIVATE ${data_storage_sources})
 
 target_link_libraries(

From 40874db8f0c89dfc8126aa70044f9ff907cb8ec4 Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Fri, 25 Jul 2025 17:19:05 -0400
Subject: [PATCH 32/33] Update source/lib/core/rocpd/data_processor.cpp

---
 source/lib/core/rocpd/data_processor.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 84927b43e5..14247f52b5 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -174,7 +174,8 @@ data_processor::insert_pmc_description(
     if(it != _pmc_descriptor_map.end())
     {
         ROCPROFSYS_WARNING(
-            0, "Insert PMC description failed! Error: PMC descriptor already exist!\n");
+            0, "Insert PMC description failed! Error: PMC descriptor (name:%s) (ID:%lu) already exist!\n",
+            name, agent_id);
         return;
     }
     data_storage::queries::table_insert_query query_builder;

From 7a429bfd90219ad6f50dee90e61ccae3654f48bc Mon Sep 17 00:00:00 2001
From: David Galiffi <David.Galiffi@amd.com>
Date: Fri, 25 Jul 2025 22:30:23 -0400
Subject: [PATCH 33/33] format source

---
 source/lib/core/rocpd/data_processor.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/source/lib/core/rocpd/data_processor.cpp b/source/lib/core/rocpd/data_processor.cpp
index 14247f52b5..6198aa047c 100644
--- a/source/lib/core/rocpd/data_processor.cpp
+++ b/source/lib/core/rocpd/data_processor.cpp
@@ -173,9 +173,10 @@ data_processor::insert_pmc_description(
     auto it = _pmc_descriptor_map.find({ agent_id, name });
     if(it != _pmc_descriptor_map.end())
     {
-        ROCPROFSYS_WARNING(
-            0, "Insert PMC description failed! Error: PMC descriptor (name:%s) (ID:%lu) already exist!\n",
-            name, agent_id);
+        ROCPROFSYS_WARNING(0,
+                           "Insert PMC description failed! Error: PMC descriptor "
+                           "(name:%s) (ID:%lu) already exist!\n",
+                           name, agent_id);
         return;
     }
     data_storage::queries::table_insert_query query_builder;