slice_ring_buffer.h

Go to the documentation of this file.

/*
 *  slice_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 SLICE_RING_BUFFER_H
#define SLICE_RING_BUFFER_H
 
// C++ includes:
#include <algorithm>
#include <cassert>
#include <functional>
#include <vector>
 
// Generated includes:
#include "config.h"
 
// Includes from nestkernel:
#include "kernel_manager.h"
#include "nest_types.h"
 
namespace nest
{
 
class SliceRingBuffer
{
public:
  SliceRingBuffer();
 
  void add_spike( const long rel_delivery, const long stamp, const double ps_offset, const double weight );
 
  void add_refractory( const long stamp, const double ps_offset );
 
  void prepare_delivery();
 
  void discard_events();
 
  bool get_next_spike( const long req_stamp,
    bool accumulate_simultaneous,
    double& ps_offset,
    double& weight,
    bool& end_of_refract );
 
  void clear();
 
  void resize();
 
private:
  struct SpikeInfo
  {
    SpikeInfo( long stamp, double ps_offset, double weight );
 
    bool operator<( const SpikeInfo& b ) const;
    bool operator<=( const SpikeInfo& b ) const;
    bool operator>( const SpikeInfo& b ) const;
 
    // data elements must not be const, since heap implementation
    // in DEC STL uses operator=().
    long stamp_;        //<! spike's time stamp
    double ps_offset_;  //<! spike offset is PS sense
    double weight_;     //<! spike weight
  };
 
  std::vector< std::vector< SpikeInfo > > queue_;
 
  std::vector< SpikeInfo >* deliver_;
 
  SpikeInfo refract_;  
};
 
inline void
SliceRingBuffer::add_spike( const long rel_delivery, const long stamp, const double ps_offset, const double weight )
{
  const long idx = kernel().event_delivery_manager.get_slice_modulo( rel_delivery );
  assert( static_cast< size_t >( idx ) < queue_.size() );
  assert( ps_offset >= 0 );
 
  queue_[ idx ].push_back( SpikeInfo( stamp, ps_offset, weight ) );
}
 
inline void
SliceRingBuffer::add_refractory( const long stamp, const double ps_offset )
{
  // We require that only one refractory-return pseudo-event is stored per
  // time step.
  //
  // We guard against violation using assert(): refract_.stamp_ must
  // be equal to the marker value for non-refractoriness. All else would mean
  // that a refractory neuron fired.
  assert( refract_.stamp_ == std::numeric_limits< long >::max() );
 
  refract_.stamp_ = stamp;
  refract_.ps_offset_ = ps_offset;
}
 
inline bool
SliceRingBuffer::get_next_spike( const long req_stamp,
  bool accumulate_simultaneous,
  double& ps_offset,
  double& weight,
  bool& end_of_refract )
{
  end_of_refract = false;
  if ( deliver_->empty() or refract_ <= deliver_->back() )
  {
    if ( refract_.stamp_ == req_stamp )
    {  // if relies on stamp_==long::max() if not refractory
      // return from refractoriness
      ps_offset = refract_.ps_offset_;
      weight = 0;
      end_of_refract = true;
 
      // mark as non-refractory
      refract_.stamp_ = std::numeric_limits< long >::max();
      return true;
    }
    else
    {
      return false;
    }
  }
  else if ( deliver_->back().stamp_ == req_stamp )
  {
    // we have an event to deliver
    ps_offset = deliver_->back().ps_offset_;
    weight = deliver_->back().weight_;
    deliver_->pop_back();
 
    if ( accumulate_simultaneous )
    {
      // add weights of all spikes with same stamp and offset
      while (
        not deliver_->empty() and deliver_->back().ps_offset_ == ps_offset and deliver_->back().stamp_ == req_stamp )
      {
        weight += deliver_->back().weight_;
        deliver_->pop_back();
      }
    }
 
    return true;
  }
  else
  {
    // ensure that we are not blocked by spike from the past, cf #404
    assert( deliver_->back().stamp_ > req_stamp );
    return false;
  }
}
 
inline SliceRingBuffer::SpikeInfo::SpikeInfo( long stamp, double ps_offset, double weight )
  : stamp_( stamp )
  , ps_offset_( ps_offset )
  , weight_( weight )
{
}
 
inline bool
SliceRingBuffer::SpikeInfo::operator<( const SpikeInfo& b ) const
{
  return stamp_ == b.stamp_ ? ps_offset_ > b.ps_offset_ : stamp_ < b.stamp_;
}
 
inline bool
SliceRingBuffer::SpikeInfo::operator<=( const SpikeInfo& b ) const
{
  return not( *this > b );
}
 
inline bool
SliceRingBuffer::SpikeInfo::operator>( const SpikeInfo& b ) const
{
  return stamp_ == b.stamp_ ? ps_offset_ < b.ps_offset_ : stamp_ > b.stamp_;
}
 
}  // namespace nest
 
#endif /* #ifndef SLICE_RING_BUFFER_H */