System.h

Go to the documentation of this file.

/* 
* Copyright 2014-2018 Friedemann Zenke
*
* This file is part of Auryn, a simulation package for plastic
* spiking neural networks.
* 
* Auryn 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 3 of the License, or
* (at your option) any later version.
* 
* Auryn 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 Auryn.  If not, see <http://www.gnu.org/licenses/>.
*
* If you are using Auryn or parts of it for your work please cite:
* Zenke, F. and Gerstner, W., 2014. Limits to high-speed simulations 
* of spiking neural networks using general-purpose computers. 
* Front Neuroinform 8, 76. doi: 10.3389/fninf.2014.00076
*/

#ifndef SYSTEM_H_
#define SYSTEM_H_

#include "auryn_definitions.h"
#include "AurynVector.h"
#include "Device.h"
#include "SpikingGroup.h"
#include "Connection.h"
#include "Checker.h"
#include "AurynVersion.h"


#ifdef AURYN_CODE_USE_MPI
#include <boost/mpi.hpp>
#include "SyncBuffer.h"
#endif //AURYN_CODE_USE_MPI

#include <ctime>
#include <vector>

#include <boost/progress.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_int_distribution.hpp>

#define PROGRESSBAR_DEFAULT_UPDATE_INTERVAL 1000
#define LOGGER_MARK_INTERVAL (10000*1000) // 1000s

namespace auryn {

// class SpikingGroup; // forward declaration
// class Connection; // forward declaration
        
        class System
        {

        private:
                AurynTime clock;
#ifdef AURYN_CODE_USE_MPI
                mpi::communicator * mpicom;
                SyncBuffer * syncbuffer;
#endif // AURYN_CODE_USE_MPI

                unsigned int mpi_size_;
                unsigned int mpi_rank_;

                std::string simulation_name;

                std::vector<SpikingGroup *> spiking_groups;
                std::vector<Connection *> connections;
                std::vector<Device *> devices;
                std::vector<Checker *> checkers;

                string outputdir;

                boost::mt19937 seed_gen; 
                boost::random::uniform_int_distribution<> * seed_dist;
                boost::variate_generator<boost::mt19937&, boost::random::uniform_int_distribution<> > * seed_die;

                double simulation_time_realtime_ratio;

                double last_elapsed_time;

                time_t t_sys_start;

                int online_rate_monitor_id;
                SpikingGroup * online_rate_monitor_target;
                double online_rate_monitor_tau;
                double online_rate_monitor_mul;
                double online_rate_monitor_state;

                void evolve_online_rate_monitor();

                std::string get_nice_time ( AurynTime clk );    

                void progressbar ( double fraction, AurynTime clk );    

                bool run(AurynTime starttime, AurynTime stoptime, AurynFloat total_time, bool checking=true);

                void sync();

                void evolve();

                void propagate();


                void evolve_connections();

                void execute_devices();

                bool execute_checkers();

                void step();

                void sync_prepare();

                void init();
                void free();

        public:
                bool quiet;

                AurynVersion build;

                unsigned int progressbar_update_interval;

#ifdef AURYN_CODE_USE_MPI

                System(mpi::communicator * communicator);
#else

                System();
#endif // AURYN_CODE_USE_MPI

                void set_simulation_name(std::string name);

                std::string get_simulation_name();

                void set_output_dir(std::string path);

                virtual ~System();


                void set_online_rate_monitor_target( SpikingGroup * group = NULL );

                void set_online_rate_monitor_id( unsigned int id=0 );

                void set_online_rate_monitor_tau( AurynDouble tau=100e-3 );

                double get_last_elapsed_time();

                double get_total_elapsed_time();

                void save_network_state(std::string basename);

                void load_network_state(std::string basename);

                void save_network_state_text(std::string basename);


                void flush_devices();


                void register_spiking_group(SpikingGroup * spiking_group);

                void register_connection(Connection * connection);

                void register_device(Device * device);

                void register_checker(Checker * checker);


                bool run(AurynFloat simulation_time, bool checking=true);

                bool run_chunk(AurynFloat chunk_time, AurynFloat interval_start, AurynFloat interval_end, bool checking=true);

                AurynDouble get_time();

                AurynTime get_clock();

                AurynTime * get_clock_ptr();

                AurynLong get_total_neurons();

                AurynDouble get_total_effective_load();

                AurynLong get_total_synapses();

                string fn(std::string extension);


                string fn(std::string name, std::string extension);

                string fn(std::string name, NeuronID index, std::string extension);


#ifdef AURYN_CODE_USE_MPI
                mpi::communicator * get_com();
#endif // AURYN_CODE_USE_MPI

                unsigned int mpi_size();

                unsigned int mpi_rank();

                void  set_master_seed( unsigned int seed = 123);

                unsigned int get_seed();

                unsigned int get_synced_seed();

#ifdef CODE_COLLECT_SYNC_TIMING_STATS
                AurynDouble deltaT;
                AurynDouble measurement_start;
                AurynDouble get_relative_sync_time();
                AurynDouble get_sync_time();
                AurynDouble get_elapsed_wall_time();
                void reset_sync_time();
#endif

        };
} // end of namespace brackets

#endif /*SYSTEM_H_*/