ManagedBuffer.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Framework/SharedBuffer.hpp>
#include <memory> //shared_ptr
#include <atomic>
#include <cassert>

namespace Pothos {

class BufferManager;
class BufferChunk;
class BufferAccumulator;

class POTHOS_API ManagedBuffer
{
public:

    ManagedBuffer(void);

    ManagedBuffer(const SharedBuffer &buff);

    explicit operator bool(void) const;

    void reset(void);

    void reset(std::shared_ptr<BufferManager> manager, const SharedBuffer &buff, const size_t slabIndex = 0);

    const SharedBuffer &getBuffer(void) const;

    size_t getSlabIndex(void) const;

    ~ManagedBuffer(void);

    ManagedBuffer(const ManagedBuffer &obj);

    ManagedBuffer(ManagedBuffer &&obj) noexcept;

    ManagedBuffer &operator=(const ManagedBuffer &obj);

    ManagedBuffer &operator=(ManagedBuffer &&obj);

    std::shared_ptr<BufferManager> getBufferManager(void) const;

    bool operator<(const ManagedBuffer &) const;

    bool unique(void) const;

    size_t useCount(void) const;

    void setNextBuffer(const ManagedBuffer &next);

    ManagedBuffer getNextBuffer(void) const;

private:
    friend BufferChunk;
    friend BufferAccumulator;
    struct Impl; Impl *_impl;
    ManagedBuffer(Impl *impl);
    POTHOS_API friend bool operator==(const ManagedBuffer &lhs, const ManagedBuffer &rhs);
};

inline bool operator==(const ManagedBuffer &lhs, const ManagedBuffer &rhs);

} //namespace Pothos

struct Pothos::ManagedBuffer::Impl
{
    Impl(void);

    std::atomic<int> counter;
    std::weak_ptr<BufferManager> weakManager;
    SharedBuffer buffer;
    size_t slabIndex;
    Pothos::ManagedBuffer::Impl *nextBuffer;

    void incr(void)
    {
        counter.fetch_add(1, std::memory_order_relaxed);
    }

    void decr(void)
    {
        //decrement the counter, and handle the last ref case
        if (counter.fetch_sub(1, std::memory_order_release) == 1)
        {
            std::atomic_thread_fence(std::memory_order_acquire);
            this->cleanup();
        }
    }

    void cleanup(void);
};

inline Pothos::ManagedBuffer::ManagedBuffer(void):
    _impl(nullptr)
{
    return;
}

inline Pothos::ManagedBuffer::operator bool(void) const
{
    return _impl != nullptr;
}

inline void Pothos::ManagedBuffer::reset(void)
{
    if (_impl != nullptr) _impl->decr();
    _impl = nullptr;
}

inline const Pothos::SharedBuffer &Pothos::ManagedBuffer::getBuffer(void) const
{
    if (_impl == nullptr) return SharedBuffer::null();
    return _impl->buffer;
}

inline size_t Pothos::ManagedBuffer::getSlabIndex(void) const
{
    assert(*this);
    return _impl->slabIndex;
}

inline Pothos::ManagedBuffer::~ManagedBuffer(void)
{
    if (_impl != nullptr) _impl->decr();
}

inline Pothos::ManagedBuffer::ManagedBuffer(const ManagedBuffer &obj):
    _impl(obj._impl)
{
    if (_impl != nullptr) _impl->incr();
}

inline Pothos::ManagedBuffer::ManagedBuffer(ManagedBuffer &&obj) noexcept:
    _impl(obj._impl)
{
    obj._impl = nullptr;
}

inline Pothos::ManagedBuffer &Pothos::ManagedBuffer::operator=(const ManagedBuffer &obj)
{
    if (_impl != nullptr) _impl->decr();
    this->_impl = obj._impl;
    if (_impl != nullptr) _impl->incr();
    return *this;
}

inline Pothos::ManagedBuffer &Pothos::ManagedBuffer::operator=(ManagedBuffer &&obj)
{
    if (_impl != nullptr) _impl->decr();
    this->_impl = obj._impl;
    obj._impl = nullptr;
    return *this;
}

inline std::shared_ptr<Pothos::BufferManager> Pothos::ManagedBuffer::getBufferManager(void) const
{
    assert(*this);
    return _impl->weakManager.lock();
}

inline bool Pothos::ManagedBuffer::operator<(const ManagedBuffer &rhs) const
{
    return _impl < rhs._impl;
}

inline bool Pothos::ManagedBuffer::unique(void) const
{
    if (_impl == nullptr) return false;
    return _impl->counter.load(std::memory_order_relaxed) == 1;
}

inline size_t Pothos::ManagedBuffer::useCount(void) const
{
    if (_impl == nullptr) return 0;
    return _impl->counter.load(std::memory_order_relaxed);
}

inline void Pothos::ManagedBuffer::setNextBuffer(const ManagedBuffer &next)
{
    assert(*this);
    _impl->nextBuffer = next._impl;
}

inline Pothos::ManagedBuffer Pothos::ManagedBuffer::getNextBuffer(void) const
{
    assert(*this);
    return Pothos::ManagedBuffer(_impl->nextBuffer);
}

inline Pothos::ManagedBuffer::ManagedBuffer(Impl *impl):
    _impl(impl)
{
    if (_impl != nullptr) _impl->incr();
}

inline bool Pothos::operator==(const ManagedBuffer &lhs, const ManagedBuffer &rhs)
{
    return lhs._impl == rhs._impl;
}