event_delivery_manager.h

Go to the documentation of this file.

/*
 *  event_delivery_manager.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 EVENT_DELIVERY_MANAGER_H
#define EVENT_DELIVERY_MANAGER_H
 
// C++ includes:
#include <cassert>
#include <limits>
#include <vector>
 
// Includes from libnestutil:
#include "manager_interface.h"
#include "stopwatch.h"
 
// Includes from nestkernel:
#include "buffer_resize_log.h"
#include "event.h"
#include "mpi_manager.h"  // OffGridSpike
#include "nest_time.h"
#include "nest_types.h"
#include "node.h"
#include "per_thread_bool_indicator.h"
#include "secondary_event.h"
#include "spike_data.h"
#include "target_table.h"
#include "vp_manager.h"
 
 
namespace nest
{
typedef MPIManager::OffGridSpike OffGridSpike;
 
class TargetData;
class SendBufferPosition;
class TargetSendBufferPosition;
 
 
class EventDeliveryManager : public ManagerInterface
{
public:
  EventDeliveryManager();
  ~EventDeliveryManager() override;
 
  void initialize( const bool ) override;
  void finalize( const bool ) override;
  void set_status( const Dictionary& ) override;
  void get_status( Dictionary& ) override;
 
  template < class EventT >
  void send( Node& source, EventT& e, const long lag = 0 );
 
  void send_secondary( Node& source, SecondaryEvent& e );
 
  void send_local( size_t t, Node& source, Event& e );
 
  void send_remote( size_t tid, SpikeEvent&, const long lag = 0 );
 
  void send_off_grid_remote( size_t tid, SpikeEvent& e, const long lag = 0 );
 
  void send_to_node( Event& e );
 
  bool get_off_grid_communication() const;
 
  void set_off_grid_communication( bool off_grid_spiking );
 
  size_t write_toggle() const;
 
  size_t read_toggle() const;
 
  long get_modulo( long d );
 
 
  long get_slice_modulo( long d );
 
  void configure_spike_data_buffers();
 
  void configure_spike_register();
 
  void resize_send_recv_buffers_target_data();
 
  void configure_secondary_buffers();
 
  void gather_spike_data();
 
  void gather_target_data( const size_t tid );
 
  void gather_target_data_compressed( const size_t tid );
 
 
  void deliver_events( const size_t tid );
 
  void gather_secondary_target_data();
 
  void write_done_marker_secondary_events_( const bool done );
 
  void gather_secondary_events( const bool done );
 
  bool deliver_secondary_events( const size_t tid, const bool called_from_wfr_update );
 
  void update_moduli();
 
  void init_moduli();
 
  virtual void reset_counters();
 
  virtual void reset_timers_for_preparation();
 
  virtual void reset_timers_for_dynamics();
 
#ifdef CYCLE_TIMERS
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > get_sw_communicate_spike_data() const;
 
  size_t get_local_spike_counter() const;
#endif
 
private:
  template < typename SpikeDataT >
  void gather_spike_data_( std::vector< SpikeDataT >& send_buffer, std::vector< SpikeDataT >& recv_buffer );
 
  void resize_send_recv_buffers_spike_data_();
 
  template < typename SpikeDataWithRankT, typename SpikeDataT >
  void collocate_spike_data_buffers_( SendBufferPosition& send_buffer_position,
    std::vector< std::vector< SpikeDataWithRankT >* >& spike_register,
    std::vector< SpikeDataT >& send_buffer,
    std::vector< size_t >& num_spikes_per_rank );
 
  template < typename SpikeDataT >
  void set_end_marker_( const SendBufferPosition& send_buffer_position,
    std::vector< SpikeDataT >& send_buffer,
    size_t local_max_spikes_per_rank );
 
  template < typename SpikeDataT >
  void reset_complete_marker_spike_data_( const SendBufferPosition& send_buffer_position,
    std::vector< SpikeDataT >& send_buffer ) const;
 
  template < typename SpikeDataT >
  size_t get_global_max_spikes_per_rank_( const SendBufferPosition& send_buffer_position,
    std::vector< SpikeDataT >& recv_buffer ) const;
 
 
  template < typename SpikeDataT >
  void deliver_events_( const size_t tid, const std::vector< SpikeDataT >& recv_buffer );
 
  void reset_spike_register_( const size_t tid );
 
  static bool is_marked_for_removal_( const Target& target );
 
  bool collocate_target_data_buffers_( const size_t tid,
    const AssignedRanks& assigned_ranks,
    TargetSendBufferPosition& send_buffer_position );
 
  bool collocate_target_data_buffers_compressed_( const size_t tid,
    const AssignedRanks& assigned_ranks,
    TargetSendBufferPosition& send_buffer_position );
 
  void set_complete_marker_target_data_( const AssignedRanks& assigned_ranks,
    const TargetSendBufferPosition& send_buffer_position );
 
  bool distribute_target_data_buffers_( const size_t tid );
 
  template < class EventT >
  void send_local_( Node& source, EventT& e, const long lag );
  void send_local_( Node& source, SecondaryEvent& e, const long lag );
 
  //--------------------------------------------------//
 
  bool off_grid_spiking_;  
 
  std::vector< long > moduli_;
 
  std::vector< long > slice_moduli_;
 
  std::vector< std::vector< SpikeDataWithRank >* > emitted_spikes_register_;
 
  std::vector< std::vector< OffGridSpikeDataWithRank >* > off_grid_emitted_spikes_register_;
 
  std::vector< unsigned int > send_buffer_secondary_events_;
  std::vector< unsigned int > recv_buffer_secondary_events_;
 
  std::vector< unsigned long > local_spike_counter_;
 
  std::vector< SpikeData > send_buffer_spike_data_;
  std::vector< SpikeData > recv_buffer_spike_data_;
  std::vector< OffGridSpikeData > send_buffer_off_grid_spike_data_;
  std::vector< OffGridSpikeData > recv_buffer_off_grid_spike_data_;
 
  std::vector< TargetData > send_buffer_target_data_;
  std::vector< TargetData > recv_buffer_target_data_;
 
  bool buffer_size_target_data_has_changed_;
 
  size_t global_max_spikes_per_rank_;
 
  double send_recv_buffer_shrink_limit_;  
  double send_recv_buffer_shrink_spare_;  
  double send_recv_buffer_grow_extra_;    
 
  BufferResizeLog send_recv_buffer_resize_log_;
 
  PerThreadBoolIndicator gather_completed_checker_;
 
  // private stop watches for benchmarking purposes
  // (intended for internal core developers, not for use in the public API)
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > sw_collocate_spike_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > sw_communicate_spike_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > sw_communicate_target_data_;
};
 
inline void
EventDeliveryManager::reset_spike_register_( const size_t tid )
{
  emitted_spikes_register_[ tid ]->clear();
  off_grid_emitted_spikes_register_[ tid ]->clear();
}
 
inline bool
EventDeliveryManager::is_marked_for_removal_( const Target& target )
{
  return target.is_processed();
}
 
inline void
EventDeliveryManager::send_to_node( Event& e )
{
  e();
}
 
inline bool
EventDeliveryManager::get_off_grid_communication() const
{
  return off_grid_spiking_;
}
 
inline void
EventDeliveryManager::set_off_grid_communication( bool off_grid_spiking )
{
  off_grid_spiking_ = off_grid_spiking;
}
 
inline size_t
EventDeliveryManager::read_toggle() const
{
  // define in terms of write_toggle() to ensure consistency
  return 1 - write_toggle();
}
 
inline long
EventDeliveryManager::get_modulo( long d )
{
  // Note, here d may be 0, since bin 0 represents the "current" time
  // when all events due are read out.
  assert( static_cast< std::vector< long >::size_type >( d ) < moduli_.size() );
 
  return moduli_[ d ];
}
 
inline long
EventDeliveryManager::get_slice_modulo( long d )
{
  // Note, here d may be 0, since bin 0 represents the "current" time
  // when all events due are read out.
  assert( static_cast< std::vector< long >::size_type >( d ) < slice_moduli_.size() );
 
  return slice_moduli_[ d ];
}
 
}  // namespace nest
 
#endif /* EVENT_DELIVERY_MANAGER_H */