Add 'projects/rocprofiler-sdk/' from commit 'bf0fad1d5406fbc51403ba1aa9621a9d4a9bce2b'

git-subtree-dir: projects/rocprofiler-sdk
git-subtree-mainline: 50a90550e9
git-subtree-split: bf0fad1d54

projects/rocprofiler-sdk/source/lib/common/memory/CMakeLists.txt

@@ -0,0 +1,7 @@
+#
+# add container sources and headers to common library target
+#
+set(memory_headers deleter.hpp pool.hpp pool_allocator.hpp stateless_allocator.hpp)
+set(memory_sources)
+
+target_sources(rocprofiler-sdk-common-library PRIVATE ${memory_sources} ${memory_headers})

projects/rocprofiler-sdk/source/lib/common/memory/deleter.hpp

@@ -0,0 +1,48 @@
+// MIT License
+//
+// Copyright (c) 2023-2025 Advanced Micro Devices, Inc.
+//
+// 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 "lib/common/defines.hpp"
+
+namespace rocprofiler
+{
+namespace common
+{
+namespace memory
+{
+// this type is a template parameter for allocators to execute a function when the allocator
+// destroys an object. In the rocprofiler library, this is used to ensure
+// rocprofiler::registration::finalize is called on the first instance of a data structure being
+// destroyed after main exits
+template <typename Tp>
+struct deleter;
+
+// default deleter type
+template <>
+struct deleter<void>
+{
+    constexpr void operator()() const {}
+};
+}  // namespace memory
+}  // namespace common
+}  // namespace rocprofiler

projects/rocprofiler-sdk/source/lib/common/memory/pool.hpp

@@ -0,0 +1,103 @@
+// MIT License
+//
+// Copyright (c) 2023-2025 Advanced Micro Devices, Inc.
+//
+// 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 "lib/common/defines.hpp"
+#include "lib/common/logging.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <stack>
+#include <stdexcept>
+
+namespace rocprofiler
+{
+namespace common
+{
+namespace memory
+{
+template <size_t BlockSize, size_t ReservedBlocks = 0>
+class pool
+{
+public:
+    explicit pool(size_t size)
+    : m_size(size)
+    {
+        for(size_t i = 0; i < ReservedBlocks; i++)
+        {
+            append();
+        }
+    }
+
+    void* allocate()
+    {
+        if(m_addrs.empty())
+        {
+            append();
+        }
+
+        auto* ptr = m_addrs.top();
+        m_addrs.pop();
+        return ptr;
+    }
+
+    void deallocate(void* ptr) { m_addrs.push(ptr); }
+
+    void rebind(size_t size)
+    {
+        if(!(m_addrs.empty() && m_blocks.empty()))
+        {
+            ROCP_FATAL << "cannot call pool::rebind() after alloc";
+        }
+
+        m_size = size;
+    }
+
+private:
+    // Refill the address stack by allocating another block of memory
+    void append()
+    {
+        auto block      = std::make_unique<uint8_t[]>(BlockSize);
+        auto total_size = BlockSize % m_size == 0 ? BlockSize : BlockSize - m_size;
+
+        // Divide the block into chunks of m_size bytes, and add their addrs
+        for(size_t i = 0; i < total_size; i += m_size)
+        {
+            m_addrs.push(&block.get()[i]);
+        }
+
+        // Keep the memory of the block alive by adding it to our stack
+        m_blocks.push(std::move(block));
+    }
+
+private:
+    size_t                                 m_size   = {};
+    std::stack<void*>                      m_addrs  = {};
+    std::stack<std::unique_ptr<uint8_t[]>> m_blocks = {};
+};
+
+}  // namespace memory
+}  // namespace common
+}  // namespace rocprofiler

projects/rocprofiler-sdk/source/lib/common/memory/pool_allocator.hpp

@@ -0,0 +1,176 @@
+// MIT License
+//
+// Copyright (c) 2023-2025 Advanced Micro Devices, Inc.
+//
+// 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 "lib/common/defines.hpp"
+#include "lib/common/memory/deleter.hpp"
+#include "lib/common/memory/pool.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <memory>
+
+namespace rocprofiler
+{
+namespace common
+{
+namespace memory
+{
+// template <typename Tp, size_t Alignment, size_t BlockSize, size_t ReservedBlocks, typename
+// DeleterT> pool_allocator<Tp, Alignment, BlockSize, ReservedBlocks, DeleterT>::
+template <typename Tp,
+          size_t Alignment      = 64,
+          size_t BlockSize      = 4096,
+          size_t ReservedBlocks = 0,
+          typename DeleterT     = deleter<void>>
+class pool_allocator
+{
+public:
+    using value_type                             = Tp;
+    using pointer                                = Tp*;
+    using const_pointer                          = const Tp*;
+    using reference                              = Tp&;
+    using const_reference                        = const Tp&;
+    using size_type                              = size_t;
+    using difference_type                        = ptrdiff_t;
+    using propagate_on_container_move_assignment = std::false_type;
+    using is_always_equal                        = value_type;
+
+    pool_allocator() = default;
+
+    // Rebind copy constructor
+    template <typename Up>
+    pool_allocator(const pool_allocator<Up>& rhs);
+
+    pool_allocator(const pool_allocator& rhs)     = default;
+    pool_allocator(pool_allocator&& rhs) noexcept = default;
+    pool_allocator& operator=(const pool_allocator& rhs) = default;
+    pool_allocator& operator=(pool_allocator&& rhs) noexcept = default;
+
+    value_type* allocate(size_t n);
+    void        deallocate(value_type* ptr, size_t n);
+    void        construct(value_type* const _p, const value_type& _v) const;
+    void        construct(value_type* const _p, value_type&& _v) const;
+    void        construct_at(value_type* const _p, const value_type& _v) const;
+    void        construct_at(value_type* const _p, value_type&& _v) const;
+    void        destroy(value_type* const _p) const;
+    void        destroy_at(value_type* const _p) const;
+
+    template <typename Up>
+    struct rebind
+    {
+        using other = pool_allocator<Up, Alignment, BlockSize, ReservedBlocks>;
+    };
+
+private:
+    using pool_type = pool<BlockSize, ReservedBlocks>;
+
+    std::shared_ptr<pool_type> m_pool = std::make_shared<pool_type>(sizeof(value_type));
+};
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
+template <typename Up>
+pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::pool_allocator(
+    const pool_allocator<Up>& rhs)
+: m_pool{rhs.m_pool}
+{
+    m_pool->rebind(sizeof(value_type));
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
+typename pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::value_type*
+pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::allocate(size_t n)
+{
+    if(n > 1)
+    {
+        return static_cast<value_type*>(::aligned_alloc(AlignV, sizeof(value_type) * n));
+    }
+
+    return static_cast<value_type*>(m_pool->allocate());
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::deallocate(value_type* ptr, size_t n)
+{
+    DeleterT{}();
+    if(n > 1)
+    {
+        ::free(ptr);
+        return;
+    }
+
+    m_pool->deallocate(ptr);
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct(value_type* const _p,
+                                                                    const value_type& _v) const
+{
+    ::new((void*) _p) value_type{_v};
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct(value_type* const _p,
+                                                                    value_type&&      _v) const
+{
+    ::new((void*) _p) value_type{std::move(_v)};
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct_at(value_type* const _p,
+                                                                       const value_type& _v) const
+{
+    ::new((void*) _p) value_type{_v};
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct_at(value_type* const _p,
+                                                                       value_type&&      _v) const
+{
+    ::new((void*) _p) value_type{std::move(_v)};
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::destroy(value_type* const _p) const
+{
+    DeleterT{}();
+    _p->~value_type();
+}
+
+template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
+void
+pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::destroy_at(value_type* const _p) const
+{
+    DeleterT{}();
+    _p->~value_type();
+}
+}  // namespace memory
+}  // namespace common
+}  // namespace rocprofiler

projects/rocprofiler-sdk/source/lib/common/memory/stateless_allocator.hpp

@@ -0,0 +1,183 @@
+// MIT License
+//
+// Copyright (c) 2023-2025 Advanced Micro Devices, Inc.
+//
+// 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 "lib/common/defines.hpp"
+#include "lib/common/memory/deleter.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <new>
+#include <stdexcept>
+
+namespace rocprofiler
+{
+namespace common
+{
+namespace memory
+{
+template <typename Tp, size_t Alignment = 64, typename DeleterT = deleter<void>>
+class stateless_allocator
+{
+public:
+    using value_type                             = Tp;
+    using pointer                                = Tp*;
+    using const_pointer                          = const Tp*;
+    using reference                              = Tp&;
+    using const_reference                        = const Tp&;
+    using size_type                              = size_t;
+    using difference_type                        = ptrdiff_t;
+    using propagate_on_container_move_assignment = std::true_type;
+
+    template <typename Up>
+    struct rebind
+    {
+        using other = stateless_allocator<Up, Alignment, DeleterT>;
+    };
+
+    stateless_allocator()                                   = default;
+    stateless_allocator(const stateless_allocator& rhs)     = default;
+    stateless_allocator(stateless_allocator&& rhs) noexcept = default;
+    stateless_allocator& operator=(const stateless_allocator& rhs) = default;
+    stateless_allocator& operator=(stateless_allocator&& rhs) noexcept = default;
+
+    template <typename Up>
+    stateless_allocator(const stateless_allocator<Up, Alignment, DeleterT>& rhs);
+
+    static Tp*  allocate(size_t n);
+    static void deallocate(Tp* ptr, size_t n);
+    static void construct(value_type* const _p, const value_type& _v);
+    static void construct(value_type* const _p, value_type&& _v);
+    static void construct_at(value_type* const _p, const value_type& _v);
+    static void construct_at(value_type* const _p, value_type&& _v);
+    static void destroy(value_type* const _p);
+    static void destroy_at(value_type* const _p);
+};
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+template <typename Up>
+stateless_allocator<Tp, Alignment, DeleterT>::stateless_allocator(
+    const stateless_allocator<Up, Alignment, DeleterT>& rhs)
+{
+    (void) rhs;
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+Tp*
+stateless_allocator<Tp, Alignment, DeleterT>::allocate(size_t n)
+{
+    constexpr auto alignment_v = Alignment / sizeof(void*);
+    Tp*            ptr         = nullptr;
+
+    if constexpr(sizeof(Tp) >= alignment_v && sizeof(Tp) % alignment_v == 0)
+        ptr = static_cast<Tp*>(::aligned_alloc(Alignment / sizeof(void*), sizeof(Tp) * n));
+    else
+        ptr = static_cast<Tp*>(::malloc(sizeof(Tp) * n));
+
+    if(ptr) return ptr;
+
+    throw std::bad_alloc{};
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::deallocate(Tp* ptr, size_t n)
+{
+    (void) n;
+    ::free(ptr);
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::construct(value_type* const _p, const value_type& _v)
+{
+    ::new((void*) _p) value_type{_v};
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::construct(value_type* const _p, value_type&& _v)
+{
+    ::new((void*) _p) value_type{std::move(_v)};
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::construct_at(value_type* const _p,
+                                                           const value_type& _v)
+{
+    ::new((void*) _p) value_type{_v};
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::construct_at(value_type* const _p, value_type&& _v)
+{
+    ::new((void*) _p) value_type{std::move(_v)};
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::destroy(value_type* const _p)
+{
+    DeleterT{}();
+    _p->~value_type();
+}
+
+template <typename Tp, size_t Alignment, typename DeleterT>
+void
+stateless_allocator<Tp, Alignment, DeleterT>::destroy_at(value_type* const _p)
+{
+    DeleterT{}();
+    _p->~value_type();
+}
+
+template <typename LhsTp,
+          size_t LhsAlignment,
+          typename LhsDeleterT,
+          typename RhsTp,
+          size_t RhsAlignment,
+          typename RhsDeleterT>
+constexpr bool
+operator==(const stateless_allocator<LhsTp, LhsAlignment, LhsDeleterT>&,
+           const stateless_allocator<RhsTp, RhsAlignment, RhsDeleterT>&)
+{
+    return true;
+}
+
+template <typename LhsTp,
+          size_t LhsAlignment,
+          typename LhsDeleterT,
+          typename RhsTp,
+          size_t RhsAlignment,
+          typename RhsDeleterT>
+constexpr bool
+operator!=(const stateless_allocator<LhsTp, LhsAlignment, LhsDeleterT>&,
+           const stateless_allocator<RhsTp, RhsAlignment, RhsDeleterT>&)
+{
+    return false;
+}
+}  // namespace memory
+}  // namespace common
+}  // namespace rocprofiler