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

#include "config.h"

#include <algorithm>
#include <functional>
#include <vector>

#include "nest.h"
#include "scheduler.h"

namespace nest
{
  class SliceRingBuffer {
  public:
    
    SliceRingBuffer();
    
    void add_spike(const delay rel_delivery, const long_t stamp,
           const double ps_offset, const double weight);
    
    void add_refractory(const long_t stamp, const double_t ps_offset);

    void prepare_delivery();

    void discard_events();

    bool get_next_spike(const long_t req_stamp, 
            double_t& ps_offset, double_t& weight,
            bool& end_of_refract);

    void clear();

    void resize();

  private:        

    struct SpikeInfo {
      SpikeInfo(long_t stamp, double_t ps_offset, double_t 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_t   stamp_;     //<! spike's time stamp
      double_t ps_offset_; //<! spike offset is PS sense
      double_t weight_;    //<! spike weight
    };

    std::vector<std::vector<SpikeInfo> > queue_;

    std::vector<SpikeInfo> * deliver_;  

    SpikeInfo  refract_;  

  };
  
  inline
  void SliceRingBuffer::add_spike(const delay rel_delivery, const long_t stamp,
                  const double ps_offset, const double weight)
  {
    const delay idx = Scheduler::get_slice_modulo(rel_delivery);
    assert((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_t stamp, const double_t 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_t>::max());

    refract_.stamp_ = stamp;
    refract_.ps_offset_= ps_offset;
  }

  inline
  bool SliceRingBuffer::get_next_spike(const long_t req_stamp, 
                       double_t& ps_offset, double_t& weight,
                                       bool& end_of_refract)
  {
    end_of_refract = false;
    if ( deliver_->empty() || refract_ <= deliver_->back() )
      if ( refract_.stamp_ == req_stamp )  
    { // if relies on stamp_==long_t::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_t>::max();
      return true;
    }
      else
    return false;
    else if ( deliver_->back().stamp_ == req_stamp )
      {
    // we have an event to deliver, register its offset
    ps_offset = deliver_->back().ps_offset_;

    // accumulate weights of all spikes with same stamp
    // AND offset
    weight    = 0.0;  // accumulate weights of all
    while ( !deliver_->empty()
        && deliver_->back().ps_offset_ == ps_offset 
        && 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_t stamp, double_t ps_offset, 
                    double_t 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 !(*this > b);
  }

  inline
  bool SliceRingBuffer::SpikeInfo::operator>(const SpikeInfo& b) const
  {
    return stamp_ == b.stamp_ ? ps_offset_ < b.ps_offset_ : stamp_ > b.stamp_;
  }

}

#endif