connection_manager.h

Go to the documentation of this file.

/*
 *  connection_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 CONNECTION_MANAGER_H
#define CONNECTION_MANAGER_H
 
// C++ includes:
#include <string>
 
// Includes from libnestutil:
#include "manager_interface.h"
#include "stopwatch.h"
 
// Includes from nestkernel:
#include "conn_builder.h"
#include "connection_id.h"
#include "connector_base.h"
#include "nest_time.h"
#include "nest_timeconverter.h"
#include "nest_types.h"
#include "node_collection.h"
#include "per_thread_bool_indicator.h"
#include "send_buffer_position.h"
#include "source_table.h"
#include "spike_data.h"
#include "target_table.h"
#include "target_table_devices.h"
 
 
namespace nest
{
class GenericBipartiteConnBuilderFactory;
class GenericThirdConnBuilderFactory;
class spikecounter;
class Node;
class Event;
class SecondaryEvent;
class DelayChecker;
class GrowthCurve;
class SpikeData;
 
class ConnectionManager : public ManagerInterface
{
  friend class SimulationManager;  // update_delay_extrema_
public:
  enum ConnectionType
  {
    CONNECT,
    CONNECT_FROM_DEVICE,
    CONNECT_TO_DEVICE,
    NO_CONNECTION
  };
 
  ConnectionManager();
  ~ConnectionManager() override;
 
  void initialize( const bool ) override;
  void finalize( const bool ) override;
  void set_status( const Dictionary& ) override;
  void get_status( Dictionary& ) override;
 
  bool valid_connection_rule( std::string );
 
  void compute_target_data_buffer_size();
  void compute_compressed_secondary_recv_buffer_positions( const size_t tid );
  void collect_compressed_spike_data( const size_t tid );
  void clear_compressed_spike_data_map();
 
  template < typename ConnBuilder >
  void register_conn_builder( const std::string& name );
 
  template < typename ThirdConnBuilder >
  void register_third_conn_builder( const std::string& name );
 
  BipartiteConnBuilder* get_conn_builder( const std::string& name,
    NodeCollectionPTR sources,
    NodeCollectionPTR targets,
    ThirdOutBuilder* third_out,
    const Dictionary& conn_spec,
    const std::vector< Dictionary >& syn_specs );
 
  ThirdOutBuilder* get_third_conn_builder( const std::string& name,
    NodeCollectionPTR sources,
    NodeCollectionPTR targets,
    ThirdInBuilder* third_in,
    const Dictionary& conn_spec,
    const std::vector< Dictionary >& syn_specs );
 
  void connect( NodeCollectionPTR sources,
    NodeCollectionPTR targets,
    const Dictionary& conn_spec,
    const std::vector< Dictionary >& syn_specs );
 
  void connect( const size_t snode_id,
    Node* target,
    size_t target_thread,
    const synindex syn_id,
    const Dictionary& params,
    const double delay = numerics::nan,
    const double weight = numerics::nan );
 
  bool connect( const size_t snode_id, const size_t target, const Dictionary& params, const synindex syn_id );
 
  void connect_arrays( const long* sources,
    const long* targets,
    const double* weights,
    const double* delays,
    const std::vector< std::string >& p_keys,
    const double* p_values,
    size_t n,
    const std::string& syn_model );
 
  void connect_sonata( const Dictionary& graph_specs, const long hyberslab_size );
 
  void connect_tripartite( NodeCollectionPTR sources,
    NodeCollectionPTR targets,
    NodeCollectionPTR third,
    const Dictionary& connectivity,
    const Dictionary& third_connectivity,
    const std::map< std::string, std::vector< Dictionary > >& synapse_specs );
 
  size_t find_connection( const size_t tid, const synindex syn_id, const size_t snode_id, const size_t tnode_id );
 
  void disconnect( const size_t tid, const synindex syn_id, const size_t snode_id, const size_t tnode_id );
 
  ConnectionType connection_required( Node*& source, Node*& target, size_t tid );
 
  // aka conndatum GetStatus
  Dictionary get_synapse_status( const size_t source_node_id,
    const size_t target_node_id,
    const size_t tid,
    const synindex syn_id,
    const size_t lcid ) const;
 
  // aka conndatum SetStatus
  void set_synapse_status( const size_t source_node_id,
    const size_t target_node_id,
    const size_t tid,
    const synindex syn_id,
    const size_t lcid,
    const Dictionary& dict );
 
  std::deque< ConnectionID > get_connections( const Dictionary& params );
 
  void get_connections( std::deque< ConnectionID >& connectome,
    NodeCollectionPTR source,
    NodeCollectionPTR target,
    synindex syn_id,
    long synapse_label ) const;
 
  size_t get_num_connections() const;
 
  size_t get_num_connections( const synindex syn_id ) const;
 
  void get_sources( const std::vector< size_t >& targets,
    const size_t syn_id,
    std::vector< std::vector< size_t > >& sources );
 
  void get_targets( const std::vector< size_t >& sources,
    const size_t syn_id,
    const std::string& post_synaptic_element,
    std::vector< std::vector< size_t > >& targets );
 
  const std::vector< Target >& get_remote_targets_of_local_node( const size_t tid, const size_t lid ) const;
 
  size_t get_target_node_id( const size_t tid, const synindex syn_id, const size_t lcid ) const;
 
  bool get_device_connected( size_t tid, size_t lcid ) const;
  void
  trigger_update_weight( const long vt_node_id, const std::vector< spikecounter >& dopa_spikes, const double t_trig );
 
  long get_min_delay() const;
 
  long get_max_delay() const;
 
  bool get_user_set_delay_extrema() const;
 
  void send( const size_t tid,
    const synindex syn_id,
    const size_t lcid,
    const std::vector< ConnectorModel* >& cm,
    Event& e );
 
  void send_to_devices( const size_t tid, const size_t source_node_id, Event& e );
  void send_to_devices( const size_t tid, const size_t source_node_id, SecondaryEvent& e );
 
  void send_from_device( const size_t tid, const size_t ldid, Event& e );
 
  void send_local( size_t t, Node& source, Event& e );
 
  void calibrate( const TimeConverter& );
 
  DelayChecker& get_delay_checker();
 
  void clean_source_table( const size_t tid );
 
  void clear_source_table( const size_t tid );
 
  bool get_keep_source_table() const;
 
  bool is_source_table_cleared() const;
 
  void prepare_target_table( const size_t tid );
 
  void resize_target_table_devices_to_number_of_neurons();
 
  void resize_target_table_devices_to_number_of_synapse_types();
 
  bool get_next_target_data( const size_t tid,
    const size_t rank_start,
    const size_t rank_end,
    size_t& target_rank,
    TargetData& next_target_data );
 
  bool fill_target_buffer( const size_t tid,
    const size_t rank_start,
    const size_t rank_end,
    std::vector< TargetData >& send_buffer_target_data,
    TargetSendBufferPosition& send_buffer_position );
 
  void reject_last_target_data( const size_t tid );
 
  void save_source_table_entry_point( const size_t tid );
 
  void reset_source_table_entry_point( const size_t tid );
 
  void restore_source_table_entry_point( const size_t tid );
 
  void add_target( const size_t tid, const size_t target_rank, const TargetData& target_data );
 
  bool use_compressed_spikes() const;
 
  void sort_connections( const size_t tid );
 
  bool connections_have_changed() const;
 
  void set_connections_have_changed();
 
  void unset_connections_have_changed();
 
  void restructure_connection_tables( const size_t tid );
 
  void
  set_source_has_more_targets( const size_t tid, const synindex syn_id, const size_t lcid, const bool more_targets );
 
  void no_targets_to_process( const size_t tid );
 
  const std::vector< size_t >&
  get_secondary_send_buffer_positions( const size_t tid, const size_t lid, const synindex syn_id ) const;
 
  size_t get_secondary_recv_buffer_position( const size_t tid, const synindex syn_id, const size_t lcid ) const;
 
  bool deliver_secondary_events( const size_t tid,
    const bool called_from_wfr_update,
    std::vector< unsigned int >& recv_buffer );
 
  void compress_secondary_send_buffer_pos( const size_t tid );
 
  void resize_connections();
 
  void sync_has_primary_connections();
 
  void check_secondary_connections_exist();
 
  bool has_primary_connections() const;
 
  bool secondary_connections_exist() const;
 
  size_t get_source_node_id( const size_t tid, const synindex syn_id, const size_t lcid );
 
  double get_stdp_eps() const;
 
  void set_stdp_eps( const double stdp_eps );
 
  // public stop watch for benchmarking purposes
  // start and stop in high-level connect functions in nestmodule.cpp and nest.cpp
  Stopwatch< StopwatchGranularity::Normal, StopwatchParallelism::MasterOnly > sw_construction_connect;
 
  const std::vector< SpikeData >& get_compressed_spike_data( const synindex syn_id, const size_t idx );
 
  void initialize_iteration_state();
 
private:
  size_t get_num_target_data( const size_t tid ) const;
 
  size_t get_num_connections_( const size_t tid, const synindex syn_id ) const;
 
  void get_connections_( const size_t tid,
    std::deque< ConnectionID >& connectome,
    NodeCollectionPTR source,
    NodeCollectionPTR target,
    synindex syn_id,
    long synapse_label ) const;
  void get_connections_to_targets_( const size_t tid,
    std::deque< ConnectionID >& connectome,
    NodeCollectionPTR source,
    NodeCollectionPTR target,
    synindex syn_id,
    long synapse_label ) const;
  void get_connections_from_sources_( const size_t tid,
    std::deque< ConnectionID >& connectome,
    NodeCollectionPTR source,
    NodeCollectionPTR target,
    synindex syn_id,
    long synapse_label ) const;
 
  void get_source_node_ids_( const size_t tid,
    const synindex syn_id,
    const size_t tnode_id,
    std::vector< size_t >& sources );
 
  void remove_disabled_connections_( const size_t tid );
 
  void split_to_neuron_device_vectors_( const size_t tid,
    NodeCollectionPTR nodecollection,
    std::vector< size_t >& neuron_node_ids,
    std::vector< size_t >& device_node_ids ) const;
 
  void update_delay_extrema_();
 
  const Time get_min_delay_time_() const;
 
  const Time get_max_delay_time_() const;
 
  void delete_connections_();
 
  void connect_( Node& source,
    Node& target,
    const size_t s_node_id,
    const size_t tid,
    const synindex syn_id,
    const Dictionary& params,
    const double delay = numerics::nan,
    const double weight = numerics::nan );
 
  void connect_to_device_( Node& source,
    Node& target,
    const size_t s_node_id,
    const size_t tid,
    const synindex syn_id,
    const Dictionary& params,
    const double delay = NAN,
    const double weight = NAN );
 
  void connect_from_device_( Node& source,
    Node& target,
    const size_t tid,
    const synindex syn_id,
    const Dictionary& params,
    const double delay = NAN,
    const double weight = NAN );
 
  void increase_connection_count( const size_t tid, const synindex syn_id );
 
  std::vector< std::vector< ConnectorBase* > > connections_;
 
  SourceTable source_table_;
 
  std::vector< std::vector< std::vector< SpikeData > > > compressed_spike_data_;
 
  std::vector< std::vector< std::vector< size_t > > > secondary_recv_buffer_pos_;
 
  std::map< size_t, size_t > buffer_pos_of_source_node_id_syn_id_;
 
  TargetTable target_table_;
 
  TargetTableDevices target_table_devices_;
 
  std::vector< DelayChecker > delay_checkers_;
 
  std::vector< std::vector< size_t > > num_connections_;
 
  Dictionary connruledict_;  
 
  std::vector< GenericBipartiteConnBuilderFactory* > connbuilder_factories_;
 
  Dictionary thirdconnruledict_;  
 
  std::vector< GenericThirdConnBuilderFactory* > thirdconnbuilder_factories_;
 
  long min_delay_;  
 
  long max_delay_;  
 
  bool keep_source_table_;
 
  bool connections_have_changed_;
 
  bool get_connections_has_been_called_;
 
  bool use_compressed_spikes_;
 
  bool has_primary_connections_;
 
  PerThreadBoolIndicator check_primary_connections_;
 
  bool secondary_connections_exist_;
 
  PerThreadBoolIndicator check_secondary_connections_;
 
  double stdp_eps_;
 
  std::vector< std::pair< size_t, std::map< size_t, CSDMapEntry >::const_iterator > > iteration_state_;
};
 
inline bool
ConnectionManager::valid_connection_rule( std::string rule_name )
{
  return connruledict_.known( rule_name );
}
 
inline long
ConnectionManager::get_min_delay() const
{
  return min_delay_;
}
 
inline long
ConnectionManager::get_max_delay() const
{
  return max_delay_;
}
 
inline void
ConnectionManager::clean_source_table( const size_t tid )
{
  if ( not keep_source_table_ )
  {
    source_table_.clean( tid );
  }
}
 
inline void
ConnectionManager::clear_source_table( const size_t tid )
{
  if ( not keep_source_table_ )
  {
    source_table_.clear( tid );
  }
}
 
inline bool
ConnectionManager::get_keep_source_table() const
{
  return keep_source_table_;
}
 
inline bool
ConnectionManager::is_source_table_cleared() const
{
  return source_table_.is_cleared();
}
 
inline void
ConnectionManager::resize_target_table_devices_to_number_of_neurons()
{
  target_table_devices_.resize_to_number_of_neurons();
}
 
inline void
ConnectionManager::resize_target_table_devices_to_number_of_synapse_types()
{
  target_table_devices_.resize_to_number_of_synapse_types();
}
 
inline void
ConnectionManager::reject_last_target_data( const size_t tid )
{
  source_table_.reject_last_target_data( tid );
}
 
inline void
ConnectionManager::save_source_table_entry_point( const size_t tid )
{
  source_table_.save_entry_point( tid );
}
 
inline void
ConnectionManager::no_targets_to_process( const size_t tid )
{
  source_table_.no_targets_to_process( tid );
}
 
inline void
ConnectionManager::reset_source_table_entry_point( const size_t tid )
{
  source_table_.reset_entry_point( tid );
}
 
inline void
ConnectionManager::restore_source_table_entry_point( const size_t tid )
{
  source_table_.restore_entry_point( tid );
}
 
inline void
ConnectionManager::prepare_target_table( const size_t tid )
{
  target_table_.prepare( tid );
}
 
inline const std::vector< Target >&
ConnectionManager::get_remote_targets_of_local_node( const size_t tid, const size_t lid ) const
{
  return target_table_.get_targets( tid, lid );
}
 
inline bool
ConnectionManager::connections_have_changed() const
{
  return connections_have_changed_;
}
 
inline void
ConnectionManager::add_target( const size_t tid, const size_t target_rank, const TargetData& target_data )
{
  target_table_.add_target( tid, target_rank, target_data );
}
 
inline bool
ConnectionManager::get_next_target_data( const size_t tid,
  const size_t rank_start,
  const size_t rank_end,
  size_t& target_rank,
  TargetData& next_target_data )
{
  return source_table_.get_next_target_data( tid, rank_start, rank_end, target_rank, next_target_data );
}
 
inline const std::vector< size_t >&
ConnectionManager::get_secondary_send_buffer_positions( const size_t tid,
  const size_t lid,
  const synindex syn_id ) const
{
  return target_table_.get_secondary_send_buffer_positions( tid, lid, syn_id );
}
 
inline size_t
ConnectionManager::get_secondary_recv_buffer_position( const size_t tid,
  const synindex syn_id,
  const size_t lcid ) const
{
  return secondary_recv_buffer_pos_[ tid ][ syn_id ][ lcid ];
}
 
inline size_t
ConnectionManager::get_num_connections_( const size_t tid, const synindex syn_id ) const
{
  return connections_[ tid ][ syn_id ]->size();
}
 
inline size_t
ConnectionManager::get_source_node_id( const size_t tid, const synindex syn_index, const size_t lcid )
{
  return source_table_.get_node_id( tid, syn_index, lcid );
}
 
inline bool
ConnectionManager::has_primary_connections() const
{
  return has_primary_connections_;
}
 
inline bool
ConnectionManager::secondary_connections_exist() const
{
  return secondary_connections_exist_;
}
 
inline bool
ConnectionManager::use_compressed_spikes() const
{
  return use_compressed_spikes_;
}
 
inline double
ConnectionManager::get_stdp_eps() const
{
  return stdp_eps_;
}
 
inline size_t
ConnectionManager::get_target_node_id( const size_t tid, const synindex syn_id, const size_t lcid ) const
{
  return connections_[ tid ][ syn_id ]->get_target_node_id( tid, lcid );
}
 
inline bool
ConnectionManager::get_device_connected( const size_t tid, const size_t lcid ) const
{
  return target_table_devices_.is_device_connected( tid, lcid );
}
 
inline void
ConnectionManager::send( const size_t tid,
  const synindex syn_id,
  const size_t lcid,
  const std::vector< ConnectorModel* >& cm,
  Event& e )
{
  connections_[ tid ][ syn_id ]->send( tid, lcid, cm, e );
}
 
inline void
ConnectionManager::restructure_connection_tables( const size_t tid )
{
  assert( not source_table_.is_cleared() );
  target_table_.clear( tid );
  source_table_.reset_processed_flags( tid );
}
 
inline void
ConnectionManager::set_source_has_more_targets( const size_t tid,
  const synindex syn_id,
  const size_t lcid,
  const bool more_targets )
{
  connections_[ tid ][ syn_id ]->set_source_has_more_targets( lcid, more_targets );
}
 
inline const std::vector< SpikeData >&
ConnectionManager::get_compressed_spike_data( const synindex syn_id, const size_t idx )
{
  return compressed_spike_data_[ syn_id ][ idx ];
}
 
inline void
ConnectionManager::clear_compressed_spike_data_map()
{
  source_table_.clear_compressed_spike_data_map();
}
 
}  // namespace nest
 
#endif /* CONNECTION_MANAGER_H */