io_ring_buffer.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_IO_RING_BUFFER_HPP
#define JOIN_CORE_IO_RING_BUFFER_HPP
 
// libjoin.
#include <join/allocator.hpp>
#include <join/error.hpp>
#include <join/function.hpp>
#include <join/memory.hpp>
#include <join/utils.hpp>
 
// C++.
#include <atomic>
 
// Libraries.
#ifdef JOIN_HAS_IO_URING
#include <liburing.h>
#endif
 
namespace join
{
    class IoRingBuffer
    {
    public:
#ifdef JOIN_HAS_IO_URING
        explicit IoRingBuffer (io_uring* ring) noexcept
        : _uring (ring)
        {
        }
#else
        IoRingBuffer () noexcept = default;
#endif
 
        IoRingBuffer (const IoRingBuffer& other) = delete;
 
        IoRingBuffer& operator= (const IoRingBuffer& other) = delete;
 
        ~IoRingBuffer ()
        {
            unregisterBuffer ();
        }
 
        template <size_t Count, size_t Size>
        int registerBuffer (uint16_t group, LocalMem::Allocator<Count, Size>& arena);
 
        int unregisterBuffer () noexcept;
 
#ifndef JOIN_HAS_IO_URING
        int select () noexcept;
#endif
 
        void recycle (uint16_t bid) noexcept;
 
        void bind () noexcept
        {
            _armed.fetch_add (1, std::memory_order_relaxed);
        }
 
        void unbind () noexcept
        {
            _armed.fetch_sub (1, std::memory_order_release);
        }
 
        bool armed () const noexcept
        {
            return _armed.load (std::memory_order_acquire) != 0;
        }
 
        void* get (uint16_t bid) const noexcept
        {
            return _base + (bid * _size);
        }
 
        uint16_t group () const noexcept
        {
            return _group;
        }
 
        uint32_t size () const noexcept
        {
            return _size;
        }
 
        uint16_t count () const noexcept
        {
            return _count;
        }
 
    private:
        static constexpr uint16_t _none = UINT16_MAX;
 
#ifdef JOIN_HAS_IO_URING
        io_uring* _uring = nullptr;
 
        LocalMem _mapping;
 
        io_uring_buf_ring* _ring = nullptr;
#else
        uint16_t _free = _none;
#endif
 
        char* _base = nullptr;
 
        Function<void ()> _release;
 
        uint32_t _size = 0;
 
        uint16_t _count = 0;
 
        uint16_t _group = 0;
 
        std::atomic<uint32_t> _armed{0};
    };
}
 
#ifdef JOIN_HAS_IO_URING
#include "io_ring_buffer_uring.hpp"
#else
#include "io_ring_buffer_epoll.hpp"
#endif
 
#endif