182 lines
5.1 KiB
C++
182 lines
5.1 KiB
C++
#pragma once
|
|
|
|
#include "lib/utils/bts_no_copy.h"
|
|
#include <type_traits>
|
|
#include <atomic>
|
|
#include <tuple>
|
|
#include <vector>
|
|
#include <google/protobuf/repeated_field.h>
|
|
|
|
namespace bts {
|
|
namespace utils {
|
|
|
|
/*
|
|
* WaitFreeQueue defines a circular buffer in the given space (which may be shared memory and should probably be at least 1mb)
|
|
* There may only be *one* writer thread which can write without *any* back pressure
|
|
* There may be any number of readers which must poll to read new values.
|
|
|
|
* If the reader does not poll quickly enough it can be overrun by the writer in which case it does not see
|
|
* the lost values. In this case the overrun is detected and the read cursor re-syncronizes with the queue
|
|
* and returns the full current state along with the reset flag.
|
|
|
|
* This class is optimized first for never blocking the writer. Latency and throughput are seconday but will probably be pretty good.
|
|
*/
|
|
|
|
template <class T>
|
|
class WaitFreeQueue
|
|
{
|
|
typedef int64_t position;
|
|
const static position invalid_id = -1;
|
|
// Store up to 4 per cache line
|
|
struct ALIGNED_(16) Entry {
|
|
Entry() : id(invalid_id), value() {}
|
|
std::atomic<position> id;
|
|
T value;
|
|
|
|
Entry& operator=(const Entry& other) {
|
|
set(other.value, other.id.load(std::memory_order_acquire));
|
|
return *this;
|
|
}
|
|
|
|
void set(const T& other, position new_id) {
|
|
id.store(invalid_id, std::memory_order_release);
|
|
value = other;
|
|
id.store(new_id, std::memory_order_release);
|
|
}
|
|
|
|
bool try_read(T& result, position& out_id) const {
|
|
out_id = invalid_id;
|
|
auto curid = id.load(std::memory_order_acquire);
|
|
if (curid == invalid_id) return false;
|
|
result = value;
|
|
out_id = curid;
|
|
// The read is only valid if the id is unchanged
|
|
return (curid == id.load(std::memory_order_acquire));
|
|
}
|
|
|
|
};
|
|
|
|
public:
|
|
WaitFreeQueue(void* buffer, size_t size_bytes, bool writer=false) :
|
|
_pos(0),
|
|
_size(size_bytes / sizeof(Entry)),
|
|
_writer(writer),
|
|
_buffer((Entry*)buffer) {
|
|
// Initialize the buffer using the entry constructor
|
|
if (writer) {
|
|
memset(buffer,0,size_bytes);
|
|
for (size_t x = 0; x < _size; ++x) {
|
|
_buffer[x] = *( new (_buffer+x) Entry() );
|
|
}
|
|
}
|
|
}
|
|
|
|
~WaitFreeQueue() {
|
|
// Mark the whole buffer as invalid
|
|
if (_writer) {
|
|
for (size_t x = 0; x < _size; ++x) {
|
|
_buffer[x].id = invalid_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
void push(const T& t) {
|
|
entry(_pos).set(t, _pos);
|
|
++_pos;
|
|
}
|
|
|
|
class Cursor
|
|
{
|
|
const WaitFreeQueue<T>& _owner;
|
|
position _pos;
|
|
public:
|
|
Cursor(const WaitFreeQueue& owner) :
|
|
_owner(owner), _pos(0)
|
|
{}
|
|
Cursor(const WaitFreeQueue& owner, position pos) :
|
|
_owner(owner), _pos(pos) {}
|
|
public:
|
|
size_t read(std::vector<T>& result, bool* p_overrun=nullptr) {
|
|
T temp;
|
|
size_t count = 0;
|
|
bool overrun;
|
|
if (p_overrun) { *p_overrun = false; }
|
|
while(pop(temp, overrun)) {
|
|
result.push_back(temp);
|
|
++count;
|
|
}
|
|
if (overrun) {
|
|
// Attempt to re-sync with the queue
|
|
result.clear();
|
|
_pos = invalid_id;
|
|
_pos = _owner.entry(0).id.load();
|
|
if (_pos == invalid_id) { _pos = 0; } // If we attempted to jump to the head somehow
|
|
if (p_overrun) { *p_overrun = true; }
|
|
return read(result);
|
|
}
|
|
return count;
|
|
}
|
|
size_t read(google::protobuf::RepeatedPtrField<T>& result, bool* p_overrun = nullptr) {
|
|
T temp;
|
|
size_t count = 0;
|
|
bool overrun;
|
|
if (p_overrun) { *p_overrun = false; }
|
|
while(pop(temp, overrun)) {
|
|
result.Add()->CopyFrom(temp);
|
|
++count;
|
|
}
|
|
if (overrun) {
|
|
// Attempt to re-sync with the queue
|
|
result.Clear();
|
|
_pos = invalid_id;
|
|
_pos = _owner.entry(0).id.load();
|
|
if (_pos == invalid_id) { _pos = 0; } // If we attempted to jump to the head somehow
|
|
if (p_overrun) { *p_overrun = true; }
|
|
return read(result);
|
|
}
|
|
return count;
|
|
}
|
|
// Attempt to read the next value and detect writer overrun
|
|
bool pop(T& result, bool& overrun) {
|
|
overrun = false;
|
|
const Entry& entry = _owner.entry(_pos);
|
|
// If the next entry is what we expect we can read it
|
|
position id;
|
|
if (entry.try_read(result, id)) {
|
|
if (id == _pos) {
|
|
_pos++;
|
|
return true;
|
|
}
|
|
if (id > _pos) {
|
|
overrun = true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
position current_position() { return _pos; }
|
|
};
|
|
|
|
const Cursor get_cursor() const {
|
|
return Cursor(*this);
|
|
}
|
|
|
|
private:
|
|
position _pos;
|
|
size_t _size;
|
|
bool _writer;
|
|
Entry* _buffer;
|
|
|
|
Entry& entry(position index) {
|
|
return _buffer[index % _size];
|
|
}
|
|
const Entry& entry(position index) const {
|
|
return _buffer[index % _size];
|
|
}
|
|
|
|
BTS_NO_COPY(WaitFreeQueue);
|
|
};
|
|
|
|
}}//namespace
|
|
|