simulation_manager.h

Go to the documentation of this file.

/*
 *  simulation_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 SIMULATION_MANAGER_H
#define SIMULATION_MANAGER_H
 
// C includes:
#include <sys/time.h>
 
// C++ includes:
#include <vector>
 
// Includes from libnestutil:
#include "manager_interface.h"
#include "stopwatch.h"
 
// Includes from nestkernel:
#include "cycle_time_log.h"
#include "nest_time.h"
#include "nest_types.h"
 
 
namespace nest
{
class Node;
 
class SimulationManager : public ManagerInterface
{
public:
  SimulationManager();
 
  void initialize( const bool ) override;
  void finalize( const bool ) override;
  void set_status( const Dictionary& ) override;
  void get_status( Dictionary& ) override;
 
  void assert_valid_simtime( Time const& );
 
  void prepare() override;
 
  void run( Time const& );
 
  void cleanup() override;
 
  bool use_wfr() const;
 
  double get_wfr_comm_interval() const;
 
  double get_wfr_tol() const;
 
  size_t get_wfr_interpolation_order() const;
 
  Time const& get_slice_origin() const;
 
  Time const get_previous_slice_origin() const;
 
  Time const get_time() const;
 
  bool has_been_simulated() const;
 
  bool has_been_prepared() const;
 
  size_t get_slice() const;
 
  // TODO: Precisely how defined? Rename!
  Time const& get_clock() const;
 
  Time run_duration() const;
 
  Time run_start_time() const;
 
  Time run_end_time() const;
 
  // TODO: rename / precisely how defined?
  long get_from_step() const;
 
  // TODO: rename / precisely how defined?
  long get_to_step() const;
 
  void update_connection_infrastructure( const size_t tid );
 
  virtual void reset_timers_for_preparation();
 
  virtual void reset_timers_for_dynamics();
 
  Time get_eprop_update_interval() const;
  Time get_eprop_learning_window() const;
  bool get_eprop_reset_neurons_on_update() const;
 
private:
  void call_update_();  
  void update_();       
  bool wfr_update_( Node* );
  void advance_time_();    
  void print_progress_();  
 
  Time clock_;                      
  long slice_;                      
  long to_do_;                      
  long to_do_total_;                
  long from_step_;                  
  long to_step_;                    
  timeval t_slice_begin_;           
  timeval t_slice_end_;             
  long t_real_;                     
  bool prepared_;                   
  bool simulating_;                 
  bool simulated_;                  
  bool inconsistent_state_;         
  bool print_time_;                 
  bool use_wfr_;                    
  double wfr_comm_interval_;        
  double wfr_tol_;                  
  long wfr_max_iterations_;         
  size_t wfr_interpolation_order_;  
  double update_time_limit_;        
  double min_update_time_;          
  double max_update_time_;          
 
  // private stop watches for benchmarking purposes
  Stopwatch< StopwatchGranularity::Normal, StopwatchParallelism::MasterOnly > sw_simulate_;
  Stopwatch< StopwatchGranularity::Normal, StopwatchParallelism::Threaded > sw_communicate_prepare_;
  // intended for internal core developers, not for use in the public API
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > sw_gather_spike_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::MasterOnly > sw_gather_secondary_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::Threaded > sw_update_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::Threaded > sw_gather_target_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::Threaded > sw_deliver_spike_data_;
  Stopwatch< StopwatchGranularity::Detailed, StopwatchParallelism::Threaded > sw_deliver_secondary_data_;
 
#ifdef CYCLE_TIMERS
  CycleTimeLog cycle_time_log_;
#endif
 
  double eprop_update_interval_;
  double eprop_learning_window_;
  bool eprop_reset_neurons_on_update_;
};
 
inline Time const&
SimulationManager::get_slice_origin() const
{
  return clock_;
}
 
inline Time const
SimulationManager::get_time() const
{
  assert( not simulating_ );
  return clock_ + Time::step( from_step_ );
}
 
inline bool
SimulationManager::has_been_simulated() const
{
  return simulated_;
}
 
inline bool
SimulationManager::has_been_prepared() const
{
  return prepared_;
}
 
inline size_t
SimulationManager::get_slice() const
{
  return slice_;
}
 
inline Time const&
SimulationManager::get_clock() const
{
  return clock_;
}
 
inline Time
SimulationManager::run_duration() const
{
  return to_do_total_ * Time::get_resolution();
}
 
inline Time
SimulationManager::run_start_time() const
{
  assert( not simulating_ );  // implicit due to using get_time()
  return get_time() - ( to_do_total_ - to_do_ ) * Time::get_resolution();
}
 
inline Time
SimulationManager::run_end_time() const
{
  assert( not simulating_ );  // implicit due to using get_time()
  return ( get_time().get_steps() + to_do_ ) * Time::get_resolution();
}
 
inline long
SimulationManager::get_from_step() const
{
  return from_step_;
}
 
inline long
SimulationManager::get_to_step() const
{
  return to_step_;
}
 
inline bool
SimulationManager::use_wfr() const
{
  return use_wfr_;
}
 
inline double
SimulationManager::get_wfr_comm_interval() const
{
  return wfr_comm_interval_;
}
 
inline double
SimulationManager::get_wfr_tol() const
{
  return wfr_tol_;
}
 
inline size_t
SimulationManager::get_wfr_interpolation_order() const
{
  return wfr_interpolation_order_;
}
 
inline Time
SimulationManager::get_eprop_update_interval() const
{
  return Time::ms( eprop_update_interval_ );
}
 
inline Time
SimulationManager::get_eprop_learning_window() const
{
  return Time::ms( eprop_learning_window_ );
}
 
inline bool
SimulationManager::get_eprop_reset_neurons_on_update() const
{
  return eprop_reset_neurons_on_update_;
}
 
}
 
 
#endif /* #ifndef SIMULATION_MANAGER_H */