node_manager.h

Go to the documentation of this file.

/*
 *  node_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 NODE_MANAGER_H
#define NODE_MANAGER_H
 
// C++ includes:
#include <vector>
 
// Includes from libnestutil:
#include "manager_interface.h"
#include "stopwatch.h"
 
// Includes from nestkernel:
#include "conn_builder.h"
#include "nest_types.h"
#include "node_collection.h"
#include "sparse_node_array.h"
 
 
namespace nest
{
 
class Node;
class Model;
 
class NodeManager : public ManagerInterface
{
public:
  NodeManager();
  ~NodeManager() override;
 
  void initialize( const bool ) override;
  void finalize( const bool ) override;
  void set_status( const Dictionary& ) override;
  void get_status( Dictionary& ) override;
 
  Dictionary get_status( size_t );
 
  void set_status( size_t, const Dictionary& );
 
  NodeCollectionPTR add_node( size_t m, long n = 1 );
 
  NodeCollectionPTR get_nodes( const Dictionary& dict, const bool local_only );
 
  size_t size() const;
 
  size_t get_max_num_local_nodes() const;
 
  size_t get_num_thread_local_devices( size_t t ) const;
 
  void print( std::ostream& ) const;
 
  bool is_local_node( Node* ) const;
 
  bool is_local_node_id( size_t node_id ) const;
 
  Node* get_node_or_proxy( size_t node_id, size_t tid );
 
  Node* get_node_or_proxy( size_t );
 
  Node* get_mpi_local_node_or_device_head( size_t );
 
  std::vector< Node* > get_thread_siblings( size_t n ) const;
 
  void update_thread_local_node_data();
 
  bool thread_local_data_is_up_to_date() const;
 
  Node* thread_lid_to_node( size_t t, targetindex thread_local_id ) const;
 
  const std::vector< Node* >& get_wfr_nodes_on_thread( size_t ) const;
 
  void prepare_nodes();
 
  size_t
  get_num_active_nodes()
  {
    return num_active_nodes_;
  };
 
  void post_run_cleanup();
 
  void finalize_nodes();
 
  bool wfr_is_used() const;
 
  void check_wfr_use();
 
  const SparseNodeArray& get_local_nodes( size_t ) const;
 
  bool have_nodes_changed() const;
  void set_have_nodes_changed( const bool changed );
 
  NodeCollectionPTR node_id_to_node_collection( const size_t node_id ) const;
 
  NodeCollectionPTR node_id_to_node_collection( Node* node ) const;
 
private:
  void init_();
  void destruct_nodes_();
 
  void set_status_single_node_( Node&, const Dictionary&, bool clear_flags = true );
 
  void prepare_node_( Node* );
 
  void add_neurons_( Model& model, size_t min_node_id, size_t max_node_id );
 
  void add_devices_( Model& model, size_t min_node_id, size_t max_node_id );
 
  void add_music_nodes_( Model& model, size_t min_node_id, size_t max_node_id );
 
  void append_node_collection_( NodeCollectionPTR ncp );
 
  void clear_node_collection_container();
 
private:
  std::vector< SparseNodeArray > local_nodes_;
 
  std::vector< NodeCollectionPTR > node_collection_container_;  
 
  std::vector< size_t >
    node_collection_last_;  
 
  std::vector< std::vector< Node* > > wfr_nodes_vec_;  
  bool wfr_is_used_;                                   
 
  size_t size_last_local_data_update_;  
  size_t num_active_nodes_;             
 
  std::vector< size_t > num_thread_local_devices_;  
 
  bool have_nodes_changed_;  
 
  std::vector< std::exception_ptr > exceptions_raised_;
 
  // private stop watch for benchmarking purposes
  Stopwatch< StopwatchGranularity::Normal, StopwatchParallelism::MasterOnly > sw_construction_create_;
};
 
inline size_t
NodeManager::size() const
{
  return local_nodes_[ 0 ].get_max_node_id();
}
 
inline Node*
NodeManager::thread_lid_to_node( size_t t, targetindex thread_local_id ) const
{
  return local_nodes_[ t ].get_node_by_index( thread_local_id );
}
 
inline const std::vector< Node* >&
NodeManager::get_wfr_nodes_on_thread( size_t t ) const
{
  return wfr_nodes_vec_.at( t );
}
 
inline bool
NodeManager::wfr_is_used() const
{
  return wfr_is_used_;
}
 
inline const SparseNodeArray&
NodeManager::get_local_nodes( size_t t ) const
{
  return local_nodes_[ t ];
}
 
inline bool
NodeManager::have_nodes_changed() const
{
  return have_nodes_changed_;
}
 
inline void
NodeManager::set_have_nodes_changed( const bool changed )
{
  have_nodes_changed_ = changed;
}
 
inline bool
NodeManager::thread_local_data_is_up_to_date() const
{
  // Our logic assumes that we never delete nodes from a network
  assert( size() >= size_last_local_data_update_ );
 
  return size() == size_last_local_data_update_;
}
 
}  // namespace
 
#endif /* NODE_MANAGER_H */