156 lines
3.5 KiB
C++
156 lines
3.5 KiB
C++
/*
|
|
* \brief Region magic ring buffer
|
|
* \author Emery Hemingway
|
|
* \date 2018-02-01
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2018 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU Affero General Public License version 3.
|
|
*/
|
|
|
|
#ifndef _INCLUDE__GEMS__RING_BUFFER_H_
|
|
#define _INCLUDE__GEMS__RING_BUFFER_H_
|
|
|
|
/* Genode includes */
|
|
#include <base/attached_ram_dataspace.h>
|
|
#include <rm_session/connection.h>
|
|
#include <region_map/client.h>
|
|
#include <dataspace/client.h>
|
|
|
|
namespace Genode {
|
|
template <typename TYPE>
|
|
struct Magic_ring_buffer;
|
|
}
|
|
|
|
/**
|
|
* A ring buffer that uses a single dataspace mapped twice in consecutive
|
|
* regions. This allows any operation that is less or equal to the size of
|
|
* the buffer to be read or written in a single pass.
|
|
*/
|
|
template <typename TYPE>
|
|
class Genode::Magic_ring_buffer
|
|
{
|
|
private:
|
|
|
|
Magic_ring_buffer(Magic_ring_buffer const &);
|
|
Magic_ring_buffer &operator = (Magic_ring_buffer const &);
|
|
|
|
Genode::Env &_env;
|
|
|
|
Ram_dataspace_capability _buffer_ds;
|
|
|
|
size_t const _ds_size = Dataspace_client(_buffer_ds).size();
|
|
size_t const _capacity = _ds_size / sizeof(TYPE);
|
|
|
|
Rm_connection _rm_connection { _env };
|
|
|
|
/* create region map (reserve address space) */
|
|
Region_map_client _rm { _rm_connection.create(_ds_size*2) };
|
|
|
|
/* attach map to global region map */
|
|
TYPE *_buffer = (TYPE *)_env.rm().attach(_rm.dataspace());
|
|
|
|
size_t _wpos = 0;
|
|
size_t _rpos = 0;
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
* Ring capacity of TYPE items
|
|
*/
|
|
size_t capacity() { return _capacity; }
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* \param TYPE Ring item type, size of type must be a
|
|
* power of two and less than the page size
|
|
*
|
|
* \param env Env for dataspace allocation and mapping
|
|
* \param num_bytes Size of ring in bytes, may be rounded up
|
|
* to the next page boundry
|
|
*
|
|
* \throw Region_map::Region_conflict
|
|
* \throw Out_of_ram
|
|
* \throw Out_of_caps
|
|
*
|
|
*/
|
|
Magic_ring_buffer(Genode::Env &env, size_t num_bytes)
|
|
: _env(env), _buffer_ds(_env.pd().alloc(num_bytes))
|
|
{
|
|
if (_ds_size % sizeof(TYPE)) {
|
|
error("Magic_ring_buffer cannot hold unaligned TYPE");
|
|
throw Exception();
|
|
}
|
|
|
|
/* attach buffer dataspace twice into reserved region */
|
|
_rm.attach_at(_buffer_ds, 0, _ds_size);
|
|
_rm.attach_at(_buffer_ds, _ds_size, _ds_size);
|
|
}
|
|
|
|
~Magic_ring_buffer()
|
|
{
|
|
/* detach dataspace from reserved region */
|
|
_rm.detach((addr_t)_ds_size);
|
|
_rm.detach((addr_t)0);
|
|
|
|
/* detach reserved region */
|
|
_env.rm().detach((addr_t)_buffer);
|
|
|
|
/* free buffer */
|
|
_env.ram().free(_buffer_ds);
|
|
}
|
|
|
|
/**
|
|
* Number of items that may be written to ring
|
|
*/
|
|
size_t write_avail() const
|
|
{
|
|
if (_wpos > _rpos)
|
|
return ((_rpos - _wpos + _capacity) % _capacity) - 2;
|
|
else if (_wpos < _rpos)
|
|
return _rpos - _wpos;
|
|
else
|
|
return _capacity - 2;
|
|
}
|
|
|
|
/**
|
|
* Number of items that may be read from ring
|
|
*/
|
|
size_t read_avail() const
|
|
{
|
|
if (_wpos > _rpos)
|
|
return _wpos - _rpos;
|
|
else
|
|
return (_wpos - _rpos + _capacity) % _capacity;
|
|
}
|
|
|
|
/**
|
|
* Pointer to ring write address
|
|
*/
|
|
TYPE *write_addr() const { return &_buffer[_wpos]; }
|
|
|
|
/**
|
|
* Pointer to ring read address
|
|
*/
|
|
TYPE *read_addr() const { return &_buffer[_rpos]; }
|
|
|
|
/**
|
|
* Advance the ring write pointer
|
|
*/
|
|
void fill(size_t items) {
|
|
_wpos = (_wpos+items) % _capacity; }
|
|
|
|
/**
|
|
* Advance the ring read pointer
|
|
*/
|
|
void drain(size_t items) {
|
|
_rpos = (_rpos+items) % _capacity; }
|
|
};
|
|
|
|
#endif
|