Merge pull request nest#2522 from med-ayssar/esthetic_changes

Refactor collocate_spike_data_buffers

Author: heplesser

nestkernel/event_delivery_manager.cpp

@@ -46,8 +46,8 @@ EventDeliveryManager::EventDeliveryManager()
   : off_grid_spiking_( false )
   , moduli_()
   , slice_moduli_()
-  , spike_register_()
-  , off_grid_spike_register_()
+  , emitted_spikes_register_()
+  , off_grid_emitted_spike_register_()
   , send_buffer_secondary_events_()
   , recv_buffer_secondary_events_()
   , local_spike_counter_()
@@ -78,8 +78,8 @@ EventDeliveryManager::initialize()
   reset_counters();
   reset_timers_for_preparation();
   reset_timers_for_dynamics();
-  spike_register_.resize( num_threads );
-  off_grid_spike_register_.resize( num_threads );
+  emitted_spikes_register_.resize( num_threads );
+  off_grid_emitted_spike_register_.resize( num_threads );
   gather_completed_checker_.initialize( num_threads, false );
   // Ensures that ResetKernel resets off_grid_spiking_
   off_grid_spiking_ = false;
@@ -90,10 +90,10 @@ EventDeliveryManager::initialize()
 #pragma omp parallel
   {
     const thread tid = kernel().vp_manager.get_thread_id();
-    spike_register_[ tid ].resize( num_threads,
+    emitted_spikes_register_[ tid ].resize( num_threads,
       std::vector< std::vector< Target > >( kernel().connection_manager.get_min_delay(), std::vector< Target >() ) );
 
-    off_grid_spike_register_[ tid ].resize( num_threads,
+    off_grid_emitted_spike_register_[ tid ].resize( num_threads,
       std::vector< std::vector< OffGridTarget > >(
         kernel().connection_manager.get_min_delay(), std::vector< OffGridTarget >() ) );
   } // of omp parallel
@@ -103,8 +103,8 @@ void
 EventDeliveryManager::finalize()
 {
   // clear the spike buffers
-  std::vector< std::vector< std::vector< std::vector< Target > > > >().swap( spike_register_ );
-  std::vector< std::vector< std::vector< std::vector< OffGridTarget > > > >().swap( off_grid_spike_register_ );
+  std::vector< std::vector< std::vector< std::vector< Target > > > >().swap( emitted_spikes_register_ );
+  std::vector< std::vector< std::vector< std::vector< OffGridTarget > > > >().swap( off_grid_emitted_spike_register_ );
 
   send_buffer_secondary_events_.clear();
   recv_buffer_secondary_events_.clear();
@@ -265,10 +265,9 @@ EventDeliveryManager::update_moduli()
 void
 EventDeliveryManager::reset_counters()
 {
-  for ( std::vector< unsigned long >::iterator it = local_spike_counter_.begin(); it != local_spike_counter_.end();
-        ++it )
+  for ( auto& spike_counter : local_spike_counter_ )
   {
-    ( *it ) = 0;
+    spike_counter = 0;
   }
 }
 
@@ -374,13 +373,13 @@ EventDeliveryManager::gather_spike_data_( const thread tid,
 
     // Collocate spikes to send buffer
     const bool collocate_completed =
-      collocate_spike_data_buffers_( tid, assigned_ranks, send_buffer_position, spike_register_, send_buffer );
+      collocate_spike_data_buffers_( tid, assigned_ranks, send_buffer_position, emitted_spikes_register_, send_buffer );
     gather_completed_checker_[ tid ].logical_and( collocate_completed );
 
     if ( off_grid_spiking_ )
     {
       const bool collocate_completed_off_grid = collocate_spike_data_buffers_(
-        tid, assigned_ranks, send_buffer_position, off_grid_spike_register_, send_buffer );
+        tid, assigned_ranks, send_buffer_position, off_grid_emitted_spike_register_, send_buffer );
       gather_completed_checker_[ tid ].logical_and( collocate_completed_off_grid );
     }
 
@@ -467,7 +466,7 @@ bool
 EventDeliveryManager::collocate_spike_data_buffers_( const thread tid,
   const AssignedRanks& assigned_ranks,
   SendBufferPosition& send_buffer_position,
-  std::vector< std::vector< std::vector< std::vector< TargetT > > > >& spike_register,
+  std::vector< std::vector< std::vector< std::vector< TargetT > > > >& emitted_spikes_register,
   std::vector< SpikeDataT >& send_buffer )
 {
   reset_complete_marker_spike_data_( assigned_ranks, send_buffer_position, send_buffer );
@@ -477,24 +476,19 @@ EventDeliveryManager::collocate_spike_data_buffers_( const thread tid,
   bool is_spike_register_empty = true;
 
   // First dimension: loop over writing thread
-  for ( typename std::vector< std::vector< std::vector< std::vector< TargetT > > > >::iterator it =
-          spike_register.begin();
-        it != spike_register.end();
-        ++it )
+  for ( auto& emitted_spikes_per_thread : emitted_spikes_register )
   {
-    // Second dimension: fixed reading thread
+    // Second dimension: Set the reading thread to the current running thread
 
     // Third dimension: loop over lags
-    for ( unsigned int lag = 0; lag < ( *it )[ tid ].size(); ++lag )
+    for ( unsigned int lag = 0; lag < ( emitted_spikes_per_thread )[ tid ].size(); ++lag )
     {
       // Fourth dimension: loop over entries
-      for ( typename std::vector< TargetT >::iterator iiit = ( *it )[ tid ][ lag ].begin();
-            iiit < ( *it )[ tid ][ lag ].end();
-            ++iiit )
+      for ( auto& emitted_spike : ( emitted_spikes_per_thread )[ tid ][ lag ] )
       {
-        assert( not iiit->is_processed() );
+        assert( not emitted_spike.is_processed() );
 
-        const thread rank = iiit->get_rank();
+        const thread rank = emitted_spike.get_rank();
 
         if ( send_buffer_position.is_chunk_filled( rank ) )
         {
@@ -503,16 +497,11 @@ EventDeliveryManager::collocate_spike_data_buffers_( const thread tid,
           {
             return is_spike_register_empty;
           }
-          else
-          {
-            continue;
-          }
         }
         else
         {
-          send_buffer[ send_buffer_position.idx( rank ) ].set(
-            ( *iiit ).get_tid(), ( *iiit ).get_syn_id(), ( *iiit ).get_lcid(), lag, ( *iiit ).get_offset() );
-          ( *iiit ).set_status( TARGET_ID_PROCESSED ); // mark entry for removal
+          send_buffer[ send_buffer_position.idx( rank ) ].set( emitted_spike, lag );
+          emitted_spike.mark_for_removal();
           send_buffer_position.increase( rank );
         }
       }
@@ -597,7 +586,7 @@ EventDeliveryManager::deliver_events_( const thread tid, const std::vector< Spik
 
   // prepare Time objects for every possible time stamp within min_delay_
   std::vector< Time > prepared_timestamps( kernel().connection_manager.get_min_delay() );
-  for ( size_t lag = 0; lag < ( size_t ) kernel().connection_manager.get_min_delay(); ++lag )
+  for ( size_t lag = 0; lag < static_cast< size_t >( kernel().connection_manager.get_min_delay() ); ++lag )
   {
     prepared_timestamps[ lag ] = kernel().simulation_manager.get_clock() + Time::step( lag + 1 );
   }
@@ -876,19 +865,15 @@ nest::EventDeliveryManager::distribute_target_data_buffers_( const thread tid )
 void
 EventDeliveryManager::resize_spike_register_( const thread tid )
 {
-  for ( std::vector< std::vector< std::vector< Target > > >::iterator it = spike_register_[ tid ].begin();
-        it != spike_register_[ tid ].end();
-        ++it )
+  for ( auto& emitted_spikes_for_current_thread : emitted_spikes_register_[ tid ] )
   {
-    it->resize( kernel().connection_manager.get_min_delay(), std::vector< Target >() );
+    emitted_spikes_for_current_thread.resize( kernel().connection_manager.get_min_delay(), std::vector< Target >() );
   }
 
-  for ( std::vector< std::vector< std::vector< OffGridTarget > > >::iterator it =
-          off_grid_spike_register_[ tid ].begin();
-        it != off_grid_spike_register_[ tid ].end();
-        ++it )
+  for ( auto& off_grid_emitted_spike_for_current_thread : off_grid_emitted_spike_register_[ tid ] )
   {
-    it->resize( kernel().connection_manager.get_min_delay(), std::vector< OffGridTarget >() );
+    off_grid_emitted_spike_for_current_thread.resize(
+      kernel().connection_manager.get_min_delay(), std::vector< OffGridTarget >() );
   }
 }
 

nestkernel/event_delivery_manager.h

@@ -391,7 +391,7 @@ class EventDeliveryManager : public ManagerInterface
    * - Third dim: lag
    * - Fourth dim: Target (will be converted in SpikeData)
    */
-  std::vector< std::vector< std::vector< std::vector< Target > > > > spike_register_;
+  std::vector< std::vector< std::vector< std::vector< Target > > > > emitted_spikes_register_;
 
   /**
    * Register for node IDs of precise neurons that spiked. This is a 4-dim
@@ -403,7 +403,7 @@ class EventDeliveryManager : public ManagerInterface
    * - Third dim: lag
    * - Fourth dim: OffGridTarget (will be converted in OffGridSpikeData)
    */
-  std::vector< std::vector< std::vector< std::vector< OffGridTarget > > > > off_grid_spike_register_;
+  std::vector< std::vector< std::vector< std::vector< OffGridTarget > > > > off_grid_emitted_spike_register_;
 
   /**
    * Buffer to collect the secondary events
@@ -447,8 +447,8 @@ class EventDeliveryManager : public ManagerInterface
 inline void
 EventDeliveryManager::reset_spike_register_( const thread tid )
 {
-  for ( std::vector< std::vector< std::vector< Target > > >::iterator it = spike_register_[ tid ].begin();
-        it < spike_register_[ tid ].end();
+  for ( std::vector< std::vector< std::vector< Target > > >::iterator it = emitted_spikes_register_[ tid ].begin();
+        it < emitted_spikes_register_[ tid ].end();
         ++it )
   {
     for ( std::vector< std::vector< Target > >::iterator iit = it->begin(); iit < it->end(); ++iit )
@@ -458,8 +458,8 @@ EventDeliveryManager::reset_spike_register_( const thread tid )
   }
 
   for ( std::vector< std::vector< std::vector< OffGridTarget > > >::iterator it =
-          off_grid_spike_register_[ tid ].begin();
-        it < off_grid_spike_register_[ tid ].end();
+          off_grid_emitted_spike_register_[ tid ].begin();
+        it < off_grid_emitted_spike_register_[ tid ].end();
         ++it )
   {
     for ( std::vector< std::vector< OffGridTarget > >::iterator iit = it->begin(); iit < it->end(); ++iit )
@@ -478,8 +478,8 @@ EventDeliveryManager::is_marked_for_removal_( const Target& target )
 inline void
 EventDeliveryManager::clean_spike_register_( const thread tid )
 {
-  for ( std::vector< std::vector< std::vector< Target > > >::iterator it = spike_register_[ tid ].begin();
-        it < spike_register_[ tid ].end();
+  for ( std::vector< std::vector< std::vector< Target > > >::iterator it = emitted_spikes_register_[ tid ].begin();
+        it < emitted_spikes_register_[ tid ].end();
         ++it )
   {
     for ( std::vector< std::vector< Target > >::iterator iit = it->begin(); iit < it->end(); ++iit )
@@ -489,8 +489,8 @@ EventDeliveryManager::clean_spike_register_( const thread tid )
     }
   }
   for ( std::vector< std::vector< std::vector< OffGridTarget > > >::iterator it =
-          off_grid_spike_register_[ tid ].begin();
-        it < off_grid_spike_register_[ tid ].end();
+          off_grid_emitted_spike_register_[ tid ].begin();
+        it < off_grid_emitted_spike_register_[ tid ].end();
         ++it )
   {
     for ( std::vector< std::vector< OffGridTarget > >::iterator iit = it->begin(); iit < it->end(); ++iit )

nestkernel/event_delivery_manager_impl.h

@@ -114,7 +114,7 @@ EventDeliveryManager::send_remote( thread tid, SpikeEvent& e, const long lag )
     // Unroll spike multiplicity as plastic synapses only handle individual spikes.
     for ( int i = 0; i < e.get_multiplicity(); ++i )
     {
-      spike_register_[ tid ][ assigned_tid ][ lag ].push_back( *it );
+      emitted_spikes_register_[ tid ][ assigned_tid ][ lag ].push_back( *it );
     }
   }
 }
@@ -133,7 +133,7 @@ EventDeliveryManager::send_off_grid_remote( thread tid, SpikeEvent& e, const lon
     // Unroll spike multiplicity as plastic synapses only handle individual spikes.
     for ( int i = 0; i < e.get_multiplicity(); ++i )
     {
-      off_grid_spike_register_[ tid ][ assigned_tid ][ lag ].push_back( OffGridTarget( *it, e.get_offset() ) );
+      off_grid_emitted_spike_register_[ tid ][ assigned_tid ][ lag ].push_back( OffGridTarget( *it, e.get_offset() ) );
     }
   }
 }

nestkernel/spike_data.h

@@ -67,6 +67,9 @@ class SpikeData
 
   void set( const thread tid, const synindex syn_id, const index lcid, const unsigned int lag, const double offset );
 
+  template < class TargetT >
+  void set( const TargetT& target, const unsigned int lag );
+
   /**
    * Returns local connection ID.
    */
@@ -185,6 +188,20 @@ SpikeData::set( const thread tid, const synindex syn_id, const index lcid, const
   syn_id_ = syn_id;
 }
 
+
+template < class TargetT >
+inline void
+SpikeData::set( const TargetT& target, const unsigned int lag )
+{
+  // the assertions in the above function are granted by the TargetT object!
+  assert( lag < MAX_LAG );
+  lcid_ = target.get_lcid();
+  marker_ = SPIKE_DATA_ID_DEFAULT;
+  lag_ = lag;
+  tid_ = target.get_tid();
+  syn_id_ = target.get_syn_id();
+}
+
 inline index
 SpikeData::get_lcid() const
 {
@@ -270,6 +287,9 @@ class OffGridSpikeData : public SpikeData
     const unsigned int lag,
     const double offset );
   void set( const thread tid, const synindex syn_id, const index lcid, const unsigned int lag, const double offset );
+
+  template < class TargetT >
+  void set( const TargetT& target, const unsigned int lag );
   double get_offset() const;
 };
 
@@ -292,6 +312,7 @@ inline OffGridSpikeData::OffGridSpikeData( const thread tid,
 {
 }
 
+
 inline void
 OffGridSpikeData::set( const thread tid,
   const synindex syn_id,
@@ -312,6 +333,15 @@ OffGridSpikeData::set( const thread tid,
   offset_ = offset;
 }
 
+
+template < class TargetT >
+inline void
+OffGridSpikeData::set( const TargetT& target, const unsigned int lag )
+{
+  SpikeData::set( target, lag );
+  offset_ = target.get_offset();
+}
+
 inline double
 OffGridSpikeData::get_offset() const
 {

nestkernel/target.h

@@ -159,6 +159,11 @@ class Target
    * Return offset.
    */
   double get_offset() const;
+
+  /**
+   *  Set the status of the target identifier to processed
+   */
+  void mark_for_removal();
 };
 
 //!< check legal size
@@ -288,6 +293,13 @@ Target::get_offset() const
   return 0;
 }
 
+inline void
+Target::mark_for_removal()
+{
+  set_status( TARGET_ID_PROCESSED );
+}
+
+
 class OffGridTarget : public Target
 {
 private:

nestkernel/target_table.h

@@ -87,8 +87,8 @@ class TargetTable
   void add_target( const thread tid, const thread target_rank, const TargetData& target_data );
 
   /**
-   * Returns all targets of a neuron. Used to fill
-   * EventDeliveryManager::spike_register_.
+   * Returns all targets of a neuron. Used for filling
+   * EventDeliveryManager::emitted_spikes_register_.
    */
   const std::vector< Target >& get_targets( const thread tid, const index lid ) const;