MultichannelRingbuffer Class Reference

#include <MultichannelRingbuffer.h>

Collaboration diagram for MultichannelRingbuffer:

Public Member Functions
	MultichannelRingbuffer (size_t size, size_t channels)
virtual	~MultichannelRingbuffer ()
size_t	free_size ()
size_t	used_size ()
size_t	capacity ()
void	clear ()
std::vector< void * >	read_head ()
std::vector< void * >	write_head (size_t *writeable)
void	commit (size_t written)
void	read (std::vector< char * > dest, size_t bytes)

Private Attributes
std::vector< char * >	_buffers
size_t	_size
size_t	_channels
size_t	_head
size_t	_used
std::mutex	_mutex

Detailed Description

Definition at line 28 of file MultichannelRingbuffer.h.

Constructor & Destructor Documentation

MultichannelRingbuffer()

MultichannelRingbuffer::MultichannelRingbuffer ( size_t  size, size_t  channels  )

explicit

Definition at line 25 of file MultichannelRingbuffer.cpp.

  : _size( size )
  , _channels( channels )
  , _used( 0 )
  , _head( 0 )
{
  for (auto ch = 0; ch < _channels; ch++) {
    auto buf = (char*)srsran_vec_malloc( _size);
    //auto buf = (char*)malloc(_size);
    if (buf == nullptr) {
      throw "Could not allocate memory";
    }
    _buffers.push_back(buf);
  }
  spdlog::debug("Created {}-channel ringbuffer with size {}", _channels, _size );
}

~MultichannelRingbuffer()

MultichannelRingbuffer::~MultichannelRingbuffer ( )

virtual

Definition at line 42 of file MultichannelRingbuffer.cpp.

{
  for (auto buffer : _buffers) {
    if (buffer) free(buffer);
  }
}

Member Function Documentation

capacity()

size_t MultichannelRingbuffer::capacity ( )

inline

Definition at line 35 of file MultichannelRingbuffer.h.

{ std::lock_guard<std::mutex> lock(_mutex);return _size; }

clear()

void MultichannelRingbuffer::clear ( )

inline

Definition at line 37 of file MultichannelRingbuffer.h.

{std::lock_guard<std::mutex> lock(_mutex); _head = _used = 0; };

commit()

auto MultichannelRingbuffer::commit

(

size_t

written

)

Definition at line 84 of file MultichannelRingbuffer.cpp.

{
  assert(written >= 0);
  assert(written <= free_size());
  std::lock_guard<std::mutex> lock(_mutex);
  _used += written;
//  _mutex.unlock();
}

free_size()

size_t MultichannelRingbuffer::free_size ( )

inline

Definition at line 33 of file MultichannelRingbuffer.h.

{ std::lock_guard<std::mutex> lock(_mutex);  return _size - _used; }

read()

auto MultichannelRingbuffer::read	(	std::vector< char * >	dest,
		size_t	bytes
	)

Definition at line 93 of file MultichannelRingbuffer.cpp.

{
  assert(dest.size() >= _channels);
  assert(size <= used_size());
  assert(size >= 0);
 
  std::lock_guard<std::mutex> lock(_mutex);
  auto end = (_head + size) % _size;
 
  if (end <= _head) {
    auto first_part = _size - _head;
    auto second_part = size - first_part;
    for (auto ch = 0; ch < _channels; ch++) {
      memcpy(dest[ch],              _buffers[ch] + _head, first_part);
      memcpy(dest[ch] + first_part, _buffers[ch],         second_part);
    }
  } else {
    for (auto ch = 0; ch < _channels; ch++) {
      memcpy(dest[ch], _buffers[ch] + _head, size);
    }
  }
  _head = (_head + size) % _size;
  _used -= size;
}

read_head()

auto MultichannelRingbuffer::read_head

(

)

Definition at line 49 of file MultichannelRingbuffer.cpp.

{
//  _mutex.lock();
  std::lock_guard<std::mutex> lock(_mutex);
  std::vector<void*> buffers(_channels, nullptr);
  for (auto ch = 0; ch < _channels; ch++) {
    buffers[ch] = (void*)(_buffers[ch]); // Return the beggining of the buffer;
  }
  _head = 0;
  _used = 0;
  return buffers;
}

used_size()

size_t MultichannelRingbuffer::used_size ( )

inline

Definition at line 34 of file MultichannelRingbuffer.h.

{ std::lock_guard<std::mutex> lock(_mutex); return _used; }

write_head()

auto MultichannelRingbuffer::write_head

(

size_t *

writeable

)

Definition at line 62 of file MultichannelRingbuffer.cpp.

{
//  _mutex.lock();
  std::lock_guard<std::mutex> lock(_mutex);
  std::vector<void*> buffers(_channels, nullptr);
  if (_size == _used) { // In this case we return a nullptr. Because read_head and read functions we should never see a situation where we try to read this returned nullptr. Usually never reach exactly te end of the buffer. 
    *writeable = 0;
  } else {
    auto tail = (_head + _used) % _size;
    if (tail < _head) {
      *writeable = _head - tail;
    } else {
      *writeable = _size - tail;
    }
    for (auto ch = 0; ch < _channels; ch++) {
      buffers[ch] = (void*)(_buffers[ch] + tail);
    }
  }
 
  return buffers;
}

Member Data Documentation

_buffers

std::vector<char*> MultichannelRingbuffer::_buffers

private

Definition at line 46 of file MultichannelRingbuffer.h.

_channels

size_t MultichannelRingbuffer::_channels

private

Definition at line 48 of file MultichannelRingbuffer.h.

_head

size_t MultichannelRingbuffer::_head

private

Definition at line 49 of file MultichannelRingbuffer.h.

_mutex

std::mutex MultichannelRingbuffer::_mutex

private

Definition at line 51 of file MultichannelRingbuffer.h.

_size

size_t MultichannelRingbuffer::_size

private

Definition at line 47 of file MultichannelRingbuffer.h.

_used

size_t MultichannelRingbuffer::_used

private

Definition at line 50 of file MultichannelRingbuffer.h.

---

The documentation for this class was generated from the following files:

• src/MultichannelRingbuffer.h
• src/MultichannelRingbuffer.cpp