ring_buffer.h

Go to the documentation of this file.

/*
 *  ring_buffer.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef RING_BUFFER_H
#define RING_BUFFER_H
 
// C++ includes:
#include <array>
#include <list>
#include <vector>
 
// Includes from nestkernel:
#include "kernel_manager.h"
#include "nest_time.h"
#include "nest_types.h"
 
namespace nest
{
 
class RingBuffer
{
public:
  RingBuffer();
 
  void add_value( const long offs, const double );
 
  void set_value( const long offs, const double );
 
  double get_value( const long offs );
 
  double get_value_wfr_update( const long offs );
 
  void clear();
 
  void resize();
 
  size_t
  size() const
  {
    return buffer_.size();
  }
 
private:
  std::vector< double > buffer_;
 
  size_t get_index_( const long d ) const;
};
 
inline void
RingBuffer::add_value( const long offs, const double v )
{
  buffer_[ get_index_( offs ) ] += v;
}
 
inline void
RingBuffer::set_value( const long offs, const double v )
{
  buffer_[ get_index_( offs ) ] = v;
}
 
inline double
RingBuffer::get_value( const long offs )
{
  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
  assert( offs < kernel().connection_manager.get_min_delay() );
 
  // offs == 0 is beginning of slice, but we have to
  // take modulo into account when indexing
  long idx = get_index_( offs );
  double val = buffer_[ idx ];
  buffer_[ idx ] = 0.0;  // clear buffer after reading
  return val;
}
 
inline double
RingBuffer::get_value_wfr_update( const long offs )
{
  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
  assert( offs < kernel().connection_manager.get_min_delay() );
 
  // offs == 0 is beginning of slice, but we have to
  // take modulo into account when indexing
  long idx = get_index_( offs );
  double val = buffer_[ idx ];
  return val;
}
 
inline size_t
RingBuffer::get_index_( const long d ) const
{
  const long idx = kernel().event_delivery_manager.get_modulo( d );
  assert( 0 <= idx );
  assert( static_cast< size_t >( idx ) < buffer_.size() );
  return idx;
}
 
 
class MultRBuffer
{
public:
  MultRBuffer();
 
  void add_value( const long offs, const double );
 
  double get_value( const long offs );
 
  void clear();
 
  void resize();
 
  size_t
  size() const
  {
    return buffer_.size();
  }
 
private:
  std::vector< double > buffer_;
 
  size_t get_index_( const long d ) const;
};
 
inline void
MultRBuffer::add_value( const long offs, const double v )
{
  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
  buffer_[ get_index_( offs ) ] *= v;
}
 
inline double
MultRBuffer::get_value( const long offs )
{
  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
  assert( offs < kernel().connection_manager.get_min_delay() );
 
  // offs == 0 is beginning of slice, but we have to
  // take modulo into account when indexing
  long idx = get_index_( offs );
  double val = buffer_[ idx ];
  buffer_[ idx ] = 0.0;  // clear buffer after reading
  return val;
}
 
inline size_t
MultRBuffer::get_index_( const long d ) const
{
  const long idx = kernel().event_delivery_manager.get_modulo( d );
  assert( 0 <= idx and static_cast< size_t >( idx ) < buffer_.size() );
  return idx;
}
 
 
class ListRingBuffer
{
public:
  ListRingBuffer();
 
  void append_value( const long offs, const double );
 
  std::list< double >& get_list( const long offs );
 
  void clear();
 
  void resize();
 
  size_t
  size() const
  {
    return buffer_.size();
  }
 
private:
  std::vector< std::list< double > > buffer_;
 
  size_t get_index_( const long d ) const;
};
 
inline void
ListRingBuffer::append_value( const long offs, const double v )
{
  buffer_[ get_index_( offs ) ].push_back( v );
}
 
inline std::list< double >&
ListRingBuffer::get_list( const long offs )
{
  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
  assert( offs < kernel().connection_manager.get_min_delay() );
 
  // offs == 0 is beginning of slice, but we have to
  // take modulo into account when indexing
  long idx = get_index_( offs );
  return buffer_[ idx ];
}
 
inline size_t
ListRingBuffer::get_index_( const long d ) const
{
  const long idx = kernel().event_delivery_manager.get_modulo( d );
  assert( 0 <= idx );
  assert( static_cast< size_t >( idx ) < buffer_.size() );
  return idx;
}
 
 
template < unsigned int num_channels >
class MultiChannelInputBuffer
{
public:
  MultiChannelInputBuffer();
 
  void add_value( const size_t slot, const size_t channel, const double value );
 
  const std::array< double, num_channels >& get_values_all_channels( const size_t slot ) const;
  void reset_values_all_channels( const size_t slot );
 
  void clear();
 
  void resize();
 
  size_t size() const;
 
private:
  std::vector< std::array< double, num_channels > > buffer_;
};
 
template < unsigned int num_channels >
inline void
MultiChannelInputBuffer< num_channels >::reset_values_all_channels( const size_t slot )
{
  assert( slot < buffer_.size() );
  buffer_[ slot ].fill( 0.0 );
}
 
template < unsigned int num_channels >
inline void
MultiChannelInputBuffer< num_channels >::add_value( const size_t slot, const size_t channel, const double value )
{
  buffer_[ slot ][ channel ] += value;
}
 
template < unsigned int num_channels >
inline const std::array< double, num_channels >&
MultiChannelInputBuffer< num_channels >::get_values_all_channels( const size_t slot ) const
{
  assert( slot < buffer_.size() );
  return buffer_[ slot ];
}
 
template < unsigned int num_channels >
inline size_t
MultiChannelInputBuffer< num_channels >::size() const
{
  return buffer_.size();
}
 
}  // namespace nest
 
 
#endif /* #ifndef RING_BUFFER_H */