concurrent_fifo.hpp

Go to the documentation of this file.

 
#ifndef __LIBFF_COMMON_CONCURRENT_FIFO_HPP__
#define __LIBFF_COMMON_CONCURRENT_FIFO_HPP__
 
#include <atomic>
#include <stddef.h>
 
namespace libff
{
 
template<typename T> class concurrent_fifo_spsc
{
public:
    concurrent_fifo_spsc() = delete;
    concurrent_fifo_spsc(const concurrent_fifo_spsc &) = delete;
    concurrent_fifo_spsc &operator=(const concurrent_fifo_spsc &) = delete;
 
    concurrent_fifo_spsc(size_t capacity);
    ~concurrent_fifo_spsc();
 
    size_t capacity() const;
 
    T *try_enqueue_begin();
 
    T *enqueue_begin_wait();
 
    void enqueue_end();
 
    const T *try_dequeue_begin();
 
    const T *dequeue_begin_wait();
 
    void dequeue_end();
 
protected:
    const size_t _capacity;
 
    T *const _buffer;
 
    size_t _producer_next_idx;
    std::atomic<size_t> _producer_num_produced;
 
    size_t _consumer_next_idx;
    std::atomic<size_t> _consumer_num_consumed;
};
 
template<typename T> class concurrent_buffer_fifo_spsc
{
public:
    concurrent_buffer_fifo_spsc() = delete;
    concurrent_buffer_fifo_spsc(const concurrent_buffer_fifo_spsc &) = delete;
    concurrent_buffer_fifo_spsc &operator=(
        const concurrent_buffer_fifo_spsc &) = delete;
 
    concurrent_buffer_fifo_spsc(
        size_t num_buffers, size_t num_entries_per_buffer);
    ~concurrent_buffer_fifo_spsc();
 
    T *try_enqueue_begin();
 
    T *enqueue_begin_wait();
 
    void enqueue_end();
 
    const T *try_dequeue_begin();
 
    const T *dequeue_begin_wait();
 
    void dequeue_end();
 
protected:
    T *enqueue_next_buffer(T **const buffer_ptr);
 
    concurrent_fifo_spsc<T *> _queue;
    const size_t _entries_per_buffer;
    T **const _buffers;
    size_t _next_buffer_idx;
};
 
} // namespace libff
 
#include "libff/common/concurrent_fifo.tcc"
 
#endif // __LIBFF_COMMON_CONCURRENT_FIFO_HPP__