bufferManager.hpp

Go to the documentation of this file.

#ifndef RTCTK_COMPONENTFRAMEWORK_BUFFERMANAGER_HPP
#define RTCTK_COMPONENTFRAMEWORK_BUFFERMANAGER_HPP
 
#include "numapp/mempolicy.hpp"
#include "rtctk/componentFramework/bufferMonitor.hpp"
#include "rtctk/componentFramework/componentMetricsIf.hpp"
#include "rtctk/componentFramework/exceptions.hpp"
#include <atomic>
#include <boost/lockfree/policies.hpp>
#include <boost/lockfree/stack.hpp>
#include <cstdint>
#include <fmt/core.h>
#include <gsl/span>
#include <gtest/gtest.h>
#include <memory>
#include <optional>
 
namespace rtctk::componentFramework {
 
class NoBufferAvailableException : public RtctkException {
public:
    explicit NoBufferAvailableException(const std::string& buffer_name);
};

class BufferManager {
private:
    class BufferStorage;
 
public:
    using Buffer = gsl::span<uint8_t>;
    class BufferReference {
    public:
        // non-copyable and non-movable
        BufferReference() = delete;
        BufferReference(const BufferReference&) = delete;
        void operator=(const BufferReference&) = delete;
        BufferReference(BufferReference&&) = delete;
        void operator=(BufferReference&&) = delete;

        operator Buffer() const;

        Buffer GetBuffer() const;
 
        ~BufferReference();
        BufferReference(const Buffer buffer, std::shared_ptr<BufferStorage> storage);
 
    private:
        const Buffer m_buffer;
        const std::shared_ptr<BufferStorage> m_storage;
    };
    BufferManager() = delete;
    BufferManager(const size_t buffer_size,
                  ComponentMetricsIf& metrics,
                  const std::string& description,
                  const std::string& prefix,
                  const size_t buffers,
                  const std::optional<numapp::MemPolicy>& policy = {});

    std::shared_ptr<BufferReference> Get();

    std::shared_ptr<BufferReference> BlockingGet();
 
private:
    class BufferStorage {
    public:
        // do not allow copy or default construction
        BufferStorage() = delete;
        BufferStorage(const BufferStorage&) = delete;
        BufferStorage& operator=(const BufferStorage&) = delete;
        BufferStorage(
            size_t buffer_count,
            std::shared_ptr<uint8_t[]> buffer_storage);  // NOLINT(modernize-avoid-c-arrays)
        void Return(Buffer buffer);
        void Add(Buffer buffer);
        std::optional<Buffer> Get();
        size_t Used();
 
    private:
        boost::lockfree::stack<Buffer, boost::lockfree::fixed_sized<true>> m_buffer_stack;
        std::shared_ptr<uint8_t[]> m_buffer_storage;  // NOLINT(modernize-avoid-c-arrays)
        std::atomic<size_t> m_used;
    };
 
    std::shared_ptr<BufferStorage> m_storage;
    const size_t m_buffers;
    BufferMonitor<> m_buffer_monitor;
    const std::string m_description;
 
    FRIEND_TEST(TestBufferManager, Internal);
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_BUFFERMANAGER_HPP