pool_manager.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 "dicom_element.h"
#include "dicom_dataset.h"
 
#include <kcenon/common/utils/object_pool.h>
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
 
namespace kcenon::pacs::core {
 
struct 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};
 
    [[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);
    }
};
 
template <typename T>
class tracked_pool {
public:
    using pool_type = kcenon::common::utils::ObjectPool<T>;
    using unique_ptr_type = std::unique_ptr<T, std::function<void(T*)>>;
 
    explicit tracked_pool(std::size_t initial_size = 32)
        : 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 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_;
    pool_statistics stats_;
};
 
class pool_manager {
public:
    static constexpr std::size_t DEFAULT_ELEMENT_POOL_SIZE = 1024;
    static constexpr std::size_t DEFAULT_DATASET_POOL_SIZE = 128;
 
    static auto get() noexcept -> pool_manager&;
 
    auto acquire_element(dicom_tag tag, encoding::vr_type vr)
        -> tracked_pool<dicom_element>::unique_ptr_type;
 
    auto acquire_dataset()
        -> tracked_pool<dicom_dataset>::unique_ptr_type;
 
    [[nodiscard]] auto element_statistics() const noexcept -> const pool_statistics&;
 
    [[nodiscard]] auto dataset_statistics() const noexcept -> const pool_statistics&;
 
    void reserve_elements(std::size_t count);
 
    void reserve_datasets(std::size_t count);
 
    void clear_all();
 
    void reset_statistics();
 
    // Non-copyable, non-movable
    pool_manager(const pool_manager&) = delete;
    pool_manager(pool_manager&&) = delete;
    auto operator=(const pool_manager&) -> pool_manager& = delete;
    auto operator=(pool_manager&&) -> pool_manager& = delete;
 
private:
    pool_manager();
    ~pool_manager() = default;
 
    tracked_pool<dicom_element> element_pool_;
    tracked_pool<dicom_dataset> dataset_pool_;
};
 
// ============================================================================
// Convenience Factory Functions
// ============================================================================
 
[[nodiscard]] inline auto make_pooled_element(dicom_tag tag, encoding::vr_type vr)
    -> tracked_pool<dicom_element>::unique_ptr_type {
    return pool_manager::get().acquire_element(tag, vr);
}
 
[[nodiscard]] inline auto make_pooled_element(dicom_tag tag, encoding::vr_type vr,
                                              std::string_view value)
    -> tracked_pool<dicom_element>::unique_ptr_type {
    auto elem = pool_manager::get().acquire_element(tag, vr);
    elem->set_string(value);
    return elem;
}
 
[[nodiscard]] inline auto make_pooled_dataset()
    -> tracked_pool<dicom_dataset>::unique_ptr_type {
    return pool_manager::get().acquire_dataset();
}
 
}  // namespace kcenon::pacs::core