pdu_buffer_pool.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "pdu_types.h"
#include "pdu_decoder.h"
 
#include <kcenon/common/utils/object_pool.h>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
 
namespace kcenon::pacs::network {
 
struct pdu_pool_statistics {
    std::atomic<uint64_t> total_acquisitions{0};
    std::atomic<uint64_t> pool_hits{0};
    std::atomic<uint64_t> pool_misses{0};
    std::atomic<uint64_t> total_releases{0};
    std::atomic<uint64_t> total_bytes_allocated{0};
 
    [[nodiscard]] auto hit_ratio() const noexcept -> double {
        const uint64_t total = total_acquisitions.load(std::memory_order_relaxed);
        if (total == 0) {
            return 0.0;
        }
        return static_cast<double>(pool_hits.load(std::memory_order_relaxed))
               / static_cast<double>(total);
    }
 
    void reset() noexcept {
        total_acquisitions.store(0, std::memory_order_relaxed);
        pool_hits.store(0, std::memory_order_relaxed);
        pool_misses.store(0, std::memory_order_relaxed);
        total_releases.store(0, std::memory_order_relaxed);
        total_bytes_allocated.store(0, std::memory_order_relaxed);
    }
};
 
class pooled_buffer {
public:
    pooled_buffer() = default;
 
    void clear() noexcept { data_.clear(); }
 
    void resize(std::size_t new_size) { data_.resize(new_size); }
 
    void reserve(std::size_t capacity) { data_.reserve(capacity); }
 
    [[nodiscard]] auto size() const noexcept -> std::size_t {
        return data_.size();
    }
 
    [[nodiscard]] auto capacity() const noexcept -> std::size_t {
        return data_.capacity();
    }
 
    [[nodiscard]] auto data() noexcept -> uint8_t* { return data_.data(); }
 
    [[nodiscard]] auto data() const noexcept -> const uint8_t* {
        return data_.data();
    }
 
    [[nodiscard]] auto vector() noexcept -> std::vector<uint8_t>& {
        return data_;
    }
 
    [[nodiscard]] auto vector() const noexcept -> const std::vector<uint8_t>& {
        return data_;
    }
 
    [[nodiscard]] auto operator[](std::size_t index) -> uint8_t& {
        return data_[index];
    }
 
    [[nodiscard]] auto operator[](std::size_t index) const -> const uint8_t& {
        return data_[index];
    }
 
private:
    std::vector<uint8_t> data_;
};
 
template <typename T>
class tracked_pdu_pool {
public:
    using pool_type = kcenon::common::utils::ObjectPool<T>;
    using unique_ptr_type = std::unique_ptr<T, std::function<void(T*)>>;
 
    explicit tracked_pdu_pool(std::size_t initial_size = 64)
        : pool_(initial_size) {
        pool_.reserve(initial_size);
    }
 
    template <typename... Args>
    auto acquire(Args&&... args) -> unique_ptr_type {
        bool reused = false;
        auto ptr = pool_.acquire(&reused, std::forward<Args>(args)...);
 
        stats_.total_acquisitions.fetch_add(1, std::memory_order_relaxed);
        if (reused) {
            stats_.pool_hits.fetch_add(1, std::memory_order_relaxed);
        } else {
            stats_.pool_misses.fetch_add(1, std::memory_order_relaxed);
        }
 
        return ptr;
    }
 
    [[nodiscard]] auto statistics() const noexcept -> const pdu_pool_statistics& {
        return stats_;
    }
 
    [[nodiscard]] auto available() const -> std::size_t {
        return pool_.available();
    }
 
    void reserve(std::size_t count) {
        pool_.reserve(count);
    }
 
    void clear() {
        pool_.clear();
    }
 
private:
    pool_type pool_;
    pdu_pool_statistics stats_;
};
 
class pdu_buffer_pool {
public:
    static constexpr std::size_t DEFAULT_BUFFER_POOL_SIZE = 256;
    static constexpr std::size_t DEFAULT_PDV_POOL_SIZE = 128;
    static constexpr std::size_t DEFAULT_PDATA_POOL_SIZE = 64;
 
    static auto get() noexcept -> pdu_buffer_pool&;
 
    auto acquire_buffer()
        -> tracked_pdu_pool<pooled_buffer>::unique_ptr_type;
 
    auto acquire_pdv(uint8_t context_id = 0, bool is_command = false,
                     bool is_last = true)
        -> tracked_pdu_pool<presentation_data_value>::unique_ptr_type;
 
    auto acquire_p_data_tf()
        -> tracked_pdu_pool<p_data_tf_pdu>::unique_ptr_type;
 
    [[nodiscard]] auto buffer_statistics() const noexcept
        -> const pdu_pool_statistics&;
 
    [[nodiscard]] auto pdv_statistics() const noexcept
        -> const pdu_pool_statistics&;
 
    [[nodiscard]] auto p_data_statistics() const noexcept
        -> const pdu_pool_statistics&;
 
    void reserve_buffers(std::size_t count);
 
    void reserve_pdvs(std::size_t count);
 
    void clear_all();
 
    void reset_statistics();
 
    // Non-copyable, non-movable
    pdu_buffer_pool(const pdu_buffer_pool&) = delete;
    pdu_buffer_pool(pdu_buffer_pool&&) = delete;
    auto operator=(const pdu_buffer_pool&) -> pdu_buffer_pool& = delete;
    auto operator=(pdu_buffer_pool&&) -> pdu_buffer_pool& = delete;
 
private:
    pdu_buffer_pool();
    ~pdu_buffer_pool() = default;
 
    tracked_pdu_pool<pooled_buffer> buffer_pool_;
    tracked_pdu_pool<presentation_data_value> pdv_pool_;
    tracked_pdu_pool<p_data_tf_pdu> p_data_pool_;
};
 
// ============================================================================
// Convenience Factory Functions
// ============================================================================
 
[[nodiscard]] inline auto make_pooled_pdu_buffer()
    -> tracked_pdu_pool<pooled_buffer>::unique_ptr_type {
    return pdu_buffer_pool::get().acquire_buffer();
}
 
[[nodiscard]] inline auto make_pooled_pdu_buffer(std::size_t size)
    -> tracked_pdu_pool<pooled_buffer>::unique_ptr_type {
    auto buffer = pdu_buffer_pool::get().acquire_buffer();
    buffer->resize(size);
    return buffer;
}
 
[[nodiscard]] inline auto make_pooled_pdv(uint8_t context_id = 0,
                                          bool is_command = false,
                                          bool is_last = true)
    -> tracked_pdu_pool<presentation_data_value>::unique_ptr_type {
    return pdu_buffer_pool::get().acquire_pdv(context_id, is_command, is_last);
}
 
[[nodiscard]] inline auto make_pooled_p_data_tf()
    -> tracked_pdu_pool<p_data_tf_pdu>::unique_ptr_type {
    return pdu_buffer_pool::get().acquire_p_data_tf();
}
 
}  // namespace kcenon::pacs::network