Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-17 20:52:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup.

Browse Source
This commit is contained in:
Branimir Karadžić
2017-02-18 13:31:49 -08:00
parent a342c225cc
commit 2923fe8ad1
2 changed files with 345 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
include/bx/inline/ringbuffer.inl Normal file
View File

@@ -0,0 +1,275 @@
/*
* Copyright 2010-2017 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bx#license-bsd-2-clause
*/
#ifndef BX_RINGBUFFER_H_HEADER_GUARD
# error "Must be included from bx/ringbuffer.h!"
#endif // BX_RINGBUFFER_H_HEADER_GUARD
namespace bx
{
inline RingBufferControl::RingBufferControl(uint32_t _size)
: m_size(_size)
, m_current(0)
, m_write(0)
, m_read(0)
{
}
inline RingBufferControl::~RingBufferControl()
{
}
inline uint32_t RingBufferControl::available() const
{
return distance(m_read, m_current);
}
inline uint32_t RingBufferControl::consume(uint32_t _size)
{
const uint32_t maxSize = distance(m_read, m_current);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_read, size);
const uint32_t read = uint32_mod(advance, m_size);
m_read = read;
return size;
}
inline uint32_t RingBufferControl::reserve(uint32_t _size)
{
const uint32_t dist = distance(m_write, m_read)-1;
const uint32_t maxSize = uint32_sels(dist, m_size-1, dist);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_write, size);
const uint32_t write = uint32_mod(advance, m_size);
m_write = write;
return size;
}
inline uint32_t RingBufferControl::commit(uint32_t _size)
{
const uint32_t maxSize = distance(m_current, m_write);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_current, size);
const uint32_t current = uint32_mod(advance, m_size);
m_current = current;
return size;
}
inline uint32_t RingBufferControl::distance(uint32_t _from, uint32_t _to) const
{
const uint32_t diff = uint32_sub(_to, _from);
const uint32_t le = uint32_add(m_size, diff);
const uint32_t result = uint32_sels(diff, le, diff);
return result;
}
inline void RingBufferControl::reset()
{
m_current = 0;
m_write = 0;
m_read = 0;
}
inline SpScRingBufferControl::SpScRingBufferControl(uint32_t _size)
: m_size(_size)
, m_current(0)
, m_write(0)
, m_read(0)
{
}
inline SpScRingBufferControl::~SpScRingBufferControl()
{
}
inline uint32_t SpScRingBufferControl::available() const
{
return distance(m_read, m_current);
}
inline uint32_t SpScRingBufferControl::consume(uint32_t _size)
{
const uint32_t maxSize = distance(m_read, m_current);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_read, size);
const uint32_t read = uint32_mod(advance, m_size);
m_read = read;
return size;
}
inline uint32_t SpScRingBufferControl::reserve(uint32_t _size)
{
const uint32_t dist = distance(m_write, m_read)-1;
const uint32_t maxSize = uint32_sels(dist, m_size-1, dist);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_write, size);
const uint32_t write = uint32_mod(advance, m_size);
m_write = write;
return size;
}
inline uint32_t SpScRingBufferControl::commit(uint32_t _size)
{
const uint32_t maxSize = distance(m_current, m_write);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_current, size);
const uint32_t current = uint32_mod(advance, m_size);
// must commit all memory writes before moving m_current pointer
// once m_current pointer moves data is used by consumer thread
memoryBarrier();
m_current = current;
return size;
}
inline uint32_t SpScRingBufferControl::distance(uint32_t _from, uint32_t _to) const
{
const uint32_t diff = uint32_sub(_to, _from);
const uint32_t le = uint32_add(m_size, diff);
const uint32_t result = uint32_sels(diff, le, diff);
return result;
}
inline void SpScRingBufferControl::reset()
{
m_current = 0;
m_write = 0;
m_read = 0;
}
template <typename ControlT>
inline ReadRingBufferT<ControlT>::ReadRingBufferT(ControlT& _control, const char* _buffer, uint32_t _size)
: m_control(_control)
, m_read(_control.m_read)
, m_end(m_read+_size)
, m_size(_size)
, m_buffer(_buffer)
{
BX_CHECK(_control.available() >= _size, "%d >= %d", _control.available(), _size);
}
template <typename ControlT>
inline ReadRingBufferT<ControlT>::~ReadRingBufferT()
{
}
template <typename ControlT>
inline void ReadRingBufferT<ControlT>::end()
{
m_control.consume(m_size);
}
template <typename ControlT>
inline void ReadRingBufferT<ControlT>::read(char* _data, uint32_t _len)
{
const uint32_t eof = (m_read + _len) % m_control.m_size;
uint32_t wrap = 0;
const char* from = &m_buffer[m_read];
if (eof < m_read)
{
wrap = m_control.m_size - m_read;
memCopy(_data, from, wrap);
_data += wrap;
from = (const char*)&m_buffer[0];
}
memCopy(_data, from, _len-wrap);
m_read = eof;
}
template <typename ControlT>
inline void ReadRingBufferT<ControlT>::skip(uint32_t _len)
{
m_read += _len;
m_read %= m_control.m_size;
}
template <typename ControlT>
inline WriteRingBufferT<ControlT>::WriteRingBufferT(ControlT& _control, char* _buffer, uint32_t _size)
: m_control(_control)
, m_size(_size)
, m_buffer(_buffer)
{
uint32_t size = m_control.reserve(_size);
BX_UNUSED(size);
BX_CHECK(size == _size, "%d == %d", size, _size);
m_write = m_control.m_current;
m_end = m_write+_size;
}
template <typename ControlT>
inline WriteRingBufferT<ControlT>::~WriteRingBufferT()
{
}
template <typename ControlT>
inline void WriteRingBufferT<ControlT>::end()
{
m_control.commit(m_size);
}
template <typename ControlT>
inline void WriteRingBufferT<ControlT>::write(const char* _data, uint32_t _len)
{
const uint32_t eof = (m_write + _len) % m_control.m_size;
uint32_t wrap = 0;
char* to = &m_buffer[m_write];
if (eof < m_write)
{
wrap = m_control.m_size - m_write;
memCopy(to, _data, wrap);
_data += wrap;
to = (char*)&m_buffer[0];
}
memCopy(to, _data, _len-wrap);
m_write = eof;
}
template <typename ControlT>
inline void WriteRingBufferT<ControlT>::write(ReadRingBufferT<ControlT>& _read, uint32_t _len)
{
const uint32_t eof = (_read.m_read + _len) % _read.m_control.m_size;
uint32_t wrap = 0;
const char* from = &_read.m_buffer[_read.m_read];
if (eof < _read.m_read)
{
wrap = _read.m_control.m_size - _read.m_read;
write(from, wrap);
from = (const char*)&_read.m_buffer[0];
}
write(from, _len-wrap);
_read.m_read = eof;
}
template <typename ControlT>
inline void WriteRingBufferT<ControlT>::skip(uint32_t _len)
{
m_write += _len;
m_write %= m_control.m_size;
}
} // namespace bx

299
include/bx/ringbuffer.h
View File

@@ -12,6 +12,7 @@
namespace bx
{
///
class RingBufferControl
{
BX_CLASS(RingBufferControl
@@ -20,75 +21,29 @@ namespace bx
);
public:
RingBufferControl(uint32_t _size)
: m_size(_size)
, m_current(0)
, m_write(0)
, m_read(0)
{
}
///
RingBufferControl(uint32_t _size);
~RingBufferControl()
{
}
///
~RingBufferControl();
uint32_t available() const
{
return distance(m_read, m_current);
}
///
uint32_t available() const;
uint32_t consume(uint32_t _size) // consumer only
{
const uint32_t maxSize = distance(m_read, m_current);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_read, size);
const uint32_t read = uint32_mod(advance, m_size);
m_read = read;
return size;
}
///
uint32_t consume(uint32_t _size); // consumer only
uint32_t reserve(uint32_t _size) // producer only
{
const uint32_t dist = distance(m_write, m_read)-1;
const uint32_t maxSize = uint32_sels(dist, m_size-1, dist);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_write, size);
const uint32_t write = uint32_mod(advance, m_size);
m_write = write;
return size;
}
///
uint32_t reserve(uint32_t _size); // producer only
uint32_t commit(uint32_t _size) // producer only
{
const uint32_t maxSize = distance(m_current, m_write);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_current, size);
const uint32_t current = uint32_mod(advance, m_size);
m_current = current;
return size;
}
///
uint32_t commit(uint32_t _size); // producer only
uint32_t distance(uint32_t _from, uint32_t _to) const // both
{
const uint32_t diff = uint32_sub(_to, _from);
const uint32_t le = uint32_add(m_size, diff);
const uint32_t result = uint32_sels(diff, le, diff);
///
uint32_t distance(uint32_t _from, uint32_t _to) const; // both
return result;
}
void reset()
{
m_current = 0;
m_write = 0;
m_read = 0;
}
///
void reset();
const uint32_t m_size;
uint32_t m_current;
@@ -96,6 +51,7 @@ namespace bx
uint32_t m_read;
};
///
class SpScRingBufferControl
{
BX_CLASS(SpScRingBufferControl
@@ -104,79 +60,29 @@ namespace bx
);
public:
SpScRingBufferControl(uint32_t _size)
: m_size(_size)
, m_current(0)
, m_write(0)
, m_read(0)
{
}
///
SpScRingBufferControl(uint32_t _size);
~SpScRingBufferControl()
{
}
///
~SpScRingBufferControl();
uint32_t available() const
{
return distance(m_read, m_current);
}
///
uint32_t available() const;
uint32_t consume(uint32_t _size) // consumer only
{
const uint32_t maxSize = distance(m_read, m_current);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_read, size);
const uint32_t read = uint32_mod(advance, m_size);
m_read = read;
return size;
}
///
uint32_t consume(uint32_t _size); // consumer only
uint32_t reserve(uint32_t _size) // producer only
{
const uint32_t dist = distance(m_write, m_read)-1;
const uint32_t maxSize = uint32_sels(dist, m_size-1, dist);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_write, size);
const uint32_t write = uint32_mod(advance, m_size);
m_write = write;
return size;
}
///
uint32_t reserve(uint32_t _size); // producer only
uint32_t commit(uint32_t _size) // producer only
{
const uint32_t maxSize = distance(m_current, m_write);
const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff);
const uint32_t test = uint32_sub(sizeNoSign, maxSize);
const uint32_t size = uint32_sels(test, _size, maxSize);
const uint32_t advance = uint32_add(m_current, size);
const uint32_t current = uint32_mod(advance, m_size);
///
uint32_t commit(uint32_t _size); // producer only
// must commit all memory writes before moving m_current pointer
// once m_current pointer moves data is used by consumer thread
memoryBarrier();
m_current = current;
return size;
}
///
uint32_t distance(uint32_t _from, uint32_t _to) const; // both
uint32_t distance(uint32_t _from, uint32_t _to) const // both
{
const uint32_t diff = uint32_sub(_to, _from);
const uint32_t le = uint32_add(m_size, diff);
const uint32_t result = uint32_sels(diff, le, diff);
return result;
}
void reset()
{
m_current = 0;
m_write = 0;
m_read = 0;
}
///
void reset();
const uint32_t m_size;
uint32_t m_current;
@@ -184,7 +90,8 @@ namespace bx
uint32_t m_read;
};
template <typename Control>
///
template <typename ControlT>
class ReadRingBufferT
{
BX_CLASS(ReadRingBufferT
@@ -194,65 +101,40 @@ namespace bx
);
public:
ReadRingBufferT(Control& _control, const char* _buffer, uint32_t _size)
: m_control(_control)
, m_read(_control.m_read)
, m_end(m_read+_size)
, m_size(_size)
, m_buffer(_buffer)
{
BX_CHECK(_control.available() >= _size, "%d >= %d", _control.available(), _size);
}
///
ReadRingBufferT(ControlT& _control, const char* _buffer, uint32_t _size);
~ReadRingBufferT()
{
}
///
~ReadRingBufferT();
void end()
{
m_control.consume(m_size);
}
///
void end();
void read(char* _data, uint32_t _len)
{
const uint32_t eof = (m_read + _len) % m_control.m_size;
uint32_t wrap = 0;
const char* from = &m_buffer[m_read];
///
void read(char* _data, uint32_t _len);
if (eof < m_read)
{
wrap = m_control.m_size - m_read;
memCopy(_data, from, wrap);
_data += wrap;
from = (const char*)&m_buffer[0];
}
memCopy(_data, from, _len-wrap);
m_read = eof;
}
void skip(uint32_t _len)
{
m_read += _len;
m_read %= m_control.m_size;
}
///
void skip(uint32_t _len);
private:
template <typename Ty>
friend class WriteRingBufferT;
Control& m_control;
ControlT& m_control;
uint32_t m_read;
uint32_t m_end;
const uint32_t m_size;
const char* m_buffer;
};
///
typedef ReadRingBufferT<RingBufferControl> ReadRingBuffer;
///
typedef ReadRingBufferT<SpScRingBufferControl> SpScReadRingBuffer;
template <typename Control>
///
template <typename ControlT>
class WriteRingBufferT
{
BX_CLASS(WriteRingBufferT
@@ -262,81 +144,40 @@ namespace bx
);
public:
WriteRingBufferT(Control& _control, char* _buffer, uint32_t _size)
: m_control(_control)
, m_size(_size)
, m_buffer(_buffer)
{
uint32_t size = m_control.reserve(_size);
BX_UNUSED(size);
BX_CHECK(size == _size, "%d == %d", size, _size);
m_write = m_control.m_current;
m_end = m_write+_size;
}
///
WriteRingBufferT(ControlT& _control, char* _buffer, uint32_t _size);
~WriteRingBufferT()
{
}
///
~WriteRingBufferT();
void end()
{
m_control.commit(m_size);
}
///
void end();
void write(const char* _data, uint32_t _len)
{
const uint32_t eof = (m_write + _len) % m_control.m_size;
uint32_t wrap = 0;
char* to = &m_buffer[m_write];
///
void write(const char* _data, uint32_t _len);
if (eof < m_write)
{
wrap = m_control.m_size - m_write;
memCopy(to, _data, wrap);
_data += wrap;
to = (char*)&m_buffer[0];
}
///
void write(ReadRingBufferT<ControlT>& _read, uint32_t _len);
memCopy(to, _data, _len-wrap);
m_write = eof;
}
void write(ReadRingBufferT<Control>& _read, uint32_t _len)
{
const uint32_t eof = (_read.m_read + _len) % _read.m_control.m_size;
uint32_t wrap = 0;
const char* from = &_read.m_buffer[_read.m_read];
if (eof < _read.m_read)
{
wrap = _read.m_control.m_size - _read.m_read;
write(from, wrap);
from = (const char*)&_read.m_buffer[0];
}
write(from, _len-wrap);
_read.m_read = eof;
}
void skip(uint32_t _len)
{
m_write += _len;
m_write %= m_control.m_size;
}
///
void skip(uint32_t _len);
private:
Control& m_control;
ControlT& m_control;
uint32_t m_write;
uint32_t m_end;
const uint32_t m_size;
char* m_buffer;
};
///
typedef WriteRingBufferT<RingBufferControl> WriteRingBuffer;
///
typedef WriteRingBufferT<SpScRingBufferControl> SpScWriteRingBuffer;
} // namespace bx
#include "inline/ringbuffer.inl"
#endif // BX_RINGBUFFER_H_HEADER_GUARD