Main control class for a SST Simulation. More...

#include <simulation_impl.h>

Inheritance diagram for SST::Simulation_impl:

Public Types
enum	ShutdownMode_t { SHUTDOWN_CLEAN, SHUTDOWN_SIGNAL, SHUTDOWN_EMERGENCY }

typedef std::map< std::pair < SimTime_t, int >, Clock * >	clockMap_t

typedef std::map< std::pair < SimTime_t, int >, OneShot * >	oneShotMap_t

Public Types inherited from SST::Simulation
enum	Mode_t { UNKNOWN, INIT, RUN, BOTH }
	Type of Run Modes. More...

Public Member Functions
Mode_t	getSimulationMode () const override
	Get the run mode of the simulation (e.g. More...

SimTime_t	getCurrentSimCycle () const override
	Return the current simulation time as a cycle count. More...

SimTime_t	getEndSimCycle () const override
	Return the end simulation time as a cycle count.

int	getCurrentPriority () const override
	Return the current priority.

UnitAlgebra	getElapsedSimTime () const override
	Return the elapsed simulation time as a time.

UnitAlgebra	getFinalSimTime () const override
	Return the end simulation time as a time.

RankInfo	getRank () const override
	Get this instance's parallel rank.

RankInfo	getNumRanks () const override
	Get the number of parallel ranks in the simulation.

std::string &	getOutputDirectory () override
	Returns the output directory of the simulation. More...

virtual void	requireEvent (const std::string &name) override
	Signifies that an event type is required for this simulation Causes the Factory to verify that the required event type can be found. More...

virtual void	printStatus (bool fullStatus) override
	Causes the current status of the simulation to be printed to stderr. More...

virtual double	getRunPhaseElapsedRealTime () const override
	Get the amount of real-time spent executing the run phase of the simulation. More...

virtual double	getInitPhaseElapsedRealTime () const override
	Get the amount of real-time spent executing the init phase of the simulation. More...

virtual double	getCompletePhaseElapsedRealTime () const override
	Get the amount of real-time spent executing the complete phase of the simulation. More...

void	insertActivity (SimTime_t time, Activity *ev)
	Insert an activity to fire at a specified time.

Exit *	getExit () const
	Return the exit event.

void	processGraphInfo (ConfigGraph &graph, const RankInfo &myRank, SimTime_t min_part)
	Processes the ConfigGraph to pull out any need information about relationships among the threads.

int	prepareLinks (ConfigGraph &graph, const RankInfo &myRank, SimTime_t min_part)

int	performWireUp (ConfigGraph &graph, const RankInfo &myRank, SimTime_t min_part)

void	setStopAtCycle (Config *cfg)
	Set cycle count, which, if reached, will cause the simulation to halt. More...

void	initialize ()
	Perform the init() phase of simulation.

void	complete ()
	Perform the complete() phase of simulation.

void	setup ()
	Perform the setup() and run phases of the simulation. More...

void	run ()

void	finish ()

bool	isIndependentThread ()

TimeConverter *	registerOneShot (const std::string &timeDelay, OneShot::HandlerBase *handler, int priority)
	Register a OneShot event to be called after a time delay Note: OneShot cannot be canceled, and will always callback after the timedelay.

TimeConverter *	registerOneShot (const UnitAlgebra &timeDelay, OneShot::HandlerBase *handler, int priority)

const std::vector< SimTime_t > &	getInterThreadLatencies () const

SimTime_t	getInterThreadMinLatency () const

LinkMap *	getComponentLinkMap (ComponentId_t id) const

const ComponentInfoMap &	getComponentInfoMap (void)
	Returns reference to the Component Info Map.

BaseComponent *	getComponent (const ComponentId_t &id) const
	returns the component with the given ID

ComponentInfo *	getComponentInfo (const ComponentId_t &id) const
	returns the ComponentInfo object for the given ID

void	setOutputDirectory (const std::string &outDir)
	Set the output directory for this simulation. More...

bool	isWireUpFinished ()
	Returns true when the Wireup is finished.

uint64_t	getTimeVortexMaxDepth () const

uint64_t	getTimeVortexCurrentDepth () const

uint64_t	getSyncQueueDataSize () const

TimeConverter *	registerClock (const std::string &freq, Clock::HandlerBase *handler, int priority)
	Register a handler to be called on a set frequency.

TimeConverter *	registerClock (const UnitAlgebra &freq, Clock::HandlerBase *handler, int priority)

TimeConverter *	registerClock (TimeConverter tcFreq, Clock::HandlerBase handler, int priority)

void	unregisterClock (TimeConverter tc, Clock::HandlerBase handler, int priority)
	Remove a clock handler from the list of active clock handlers.

Cycle_t	reregisterClock (TimeConverter tc, Clock::HandlerBase handler, int priority)
	Reactivate an existing clock and handler. More...

Cycle_t	getNextClockCycle (TimeConverter *tc, int priority=CLOCKPRIORITY)
	Returns the next Cycle that the TImeConverter would fire. More...

Statistics::StatisticProcessingEngine *	getStatisticsProcessingEngine (void) const
	Return the Statistic Processing Engine associated with this Simulation.

friend	int::main (int argc, char **argv)

	Simulation_impl (Config *config, RankInfo my_rank, RankInfo num_ranks)

	Simulation_impl (Simulation_impl const &)

void	operator= (Simulation_impl const &)

TimeConverter *	minPartToTC (SimTime_t cycles) const
	Get a handle to a TimeConverter. More...

Component *	createComponent (ComponentId_t id, const std::string &name, Params &params)

TimeVortex *	getTimeVortex () const

void	endSimulation (void)
	Normal Shutdown.

void	endSimulation (SimTime_t end)

Static Public Member Functions
static Simulation_impl *	getSimulation ()
	Return a pointer to the singleton instance of the Simulation.

static TimeLord *	getTimeLord (void)
	Return the TimeLord associated with this Simulation.

static Output &	getSimulationOutput ()
	Return the base simulation Output class instance.

static Simulation_impl *	createSimulation (Config *config, RankInfo my_rank, RankInfo num_ranks)
	Create new simulation. More...

static void	shutdown ()
	Used to signify the end of simulation. More...

static void	setSignal (int signal)
	Sets an internal flag for signaling the simulation. More...

static TimeConverter *	getMinPartTC ()

static SimTime_t	getLocalMinimumNextActivityTime ()
	Gets the minimum next activity time across all TimeVortices in the Rank.

static void	resizeBarriers (uint32_t nthr)

static void	emergencyShutdown ()
	Emergency Shutdown Called when a SIGINT or SIGTERM has been seen.

Static Public Member Functions inherited from SST::Simulation
static Simulation *	getSimulation ()
	Return a pointer to the singleton instance of the Simulation. More...

static SharedRegionManager *	getSharedRegionManager ()
	Returns the Simulation's SharedRegionManager.

static TimeLord *	getTimeLord (void)
	Return the TimeLord associated with this Simulation.

static Output &	getSimulationOutput ()
	Return the base simulation Output class instance.

Data Fields
bool	direct_interthread

TimeVortex *	timeVortex

TimeConverter *	threadMinPartTC

Activity *	current_activity

std::vector< SimTime_t >	interThreadLatencies

SimTime_t	interThreadMinLatency

SyncManager *	syncManager

ComponentInfoMap	compInfoMap

clockMap_t	clockMap

oneShotMap_t	oneShotMap

SimulatorHeartbeat *	m_heartbeat

bool	endSim

bool	independent

unsigned int	untimed_phase

volatile sig_atomic_t	lastRecvdSignal

ShutdownMode_t	shutdown_mode

bool	wireUpFinished

Mode_t	runMode

SimTime_t	currentSimCycle

SimTime_t	endSimCycle

int	currentPriority

RankInfo	my_rank

RankInfo	num_ranks

std::string	output_directory

double	run_phase_start_time

double	run_phase_total_time

double	init_phase_start_time

double	init_phase_total_time

double	complete_phase_start_time

double	complete_phase_total_time

Static Public Attributes
static Factory *	factory
	Factory used to generate the simulation components.

static Core::ThreadSafe::Barrier	initBarrier

static Core::ThreadSafe::Barrier	completeBarrier

static Core::ThreadSafe::Barrier	setupBarrier

static Core::ThreadSafe::Barrier	runBarrier

static Core::ThreadSafe::Barrier	exitBarrier

static Core::ThreadSafe::Barrier	finishBarrier

static std::mutex	simulationMutex

static std::map< LinkId_t, Link * >	cross_thread_links

static SimTime_t	minPart

static TimeConverter *	minPartTC = nullptr

static Exit *	m_exit

static std::atomic< int >	untimed_msg_count

static TimeLord	timeLord
	TimeLord of the simulation.

static Output	sim_output
	Output.

static SharedRegionManager *	sharedRegionManager = new SharedRegionManagerImpl()

static std::unordered_map < std::thread::id, Simulation_impl * >	instanceMap

static std::vector < Simulation_impl * >	instanceVec

Friends
class	Link

class	Action

class	Output

class	SyncManager

void	wait_my_turn_start ()

void	wait_my_turn_end ()

Additional Inherited Members
Protected Member Functions inherited from SST::Simulation
	Simulation (Simulation const &)

void	operator= (Simulation const &)

Detailed Description

Main control class for a SST Simulation.

Provides base features for managing the simulation

Member Typedef Documentation

typedef std::map<std::pair<SimTime_t, int>, Clock*> SST::Simulation_impl::clockMap_t

Map of times to clocks

typedef std::map<std::pair<SimTime_t, int>, OneShot*> SST::Simulation_impl::oneShotMap_t

Map of times to OneShots

Member Function Documentation

Simulation_impl * SST::Simulation_impl::createSimulation	(	Config *	config,
		RankInfo	my_rank,
		RankInfo	num_ranks
	)

static

Create new simulation.

Parameters

config	- Configuration of the simulation
my_rank	- Parallel Rank of this simulation object
num_ranks	- How many Ranks are in the simulation

double SST::Simulation_impl::getCompletePhaseElapsedRealTime ( ) const

overridevirtual

Get the amount of real-time spent executing the complete phase of the simulation.

Returns: real-time in seconds spent executing the complete phase

Implements SST::Simulation.

SimTime_t SST::Simulation_impl::getCurrentSimCycle ( ) const

overridevirtual

Return the current simulation time as a cycle count.

Non-static functions.

Implements SST::Simulation.

Referenced by SST::BaseComponent::getCurrentSimCycle(), SST::Exit::refDec(), and SST::Clock::schedule().

double SST::Simulation_impl::getInitPhaseElapsedRealTime ( ) const

overridevirtual

Get the amount of real-time spent executing the init phase of the simulation.

Returns: real-time in seconds spent executing the init phase

Implements SST::Simulation.

Cycle_t SST::Simulation_impl::getNextClockCycle	(	TimeConverter *	tc,
		int	priority = `CLOCKPRIORITY`
	)

Returns the next Cycle that the TImeConverter would fire.

References SST::Output::fatal(), SST::TimeConverter::getFactor(), and SST::Output::STDERR.

Referenced by SST::BaseComponent::getNextClockCycle().

std::string& SST::Simulation_impl::getOutputDirectory ( )

inlineoverridevirtual

Returns the output directory of the simulation.

Returns: Directory in which simulation outputs are placed

Implements SST::Simulation.

double SST::Simulation_impl::getRunPhaseElapsedRealTime ( ) const

overridevirtual

Get the amount of real-time spent executing the run phase of the simulation.

Returns: real-time in seconds spent executing the run phase

Implements SST::Simulation.

Mode_t SST::Simulation_impl::getSimulationMode ( ) const

inlineoverridevirtual

Get the run mode of the simulation (e.g.

init, run, both etc)

Implements SST::Simulation.

TimeConverter * SST::Simulation_impl::minPartToTC ( SimTime_t cycles ) const

Get a handle to a TimeConverter.

Simulation_impl functions.

Parameters

cycles Frequency which is the base of the TimeConverter

Referenced by processGraphInfo().

void SST::Simulation_impl::printStatus ( bool fullStatus )

overridevirtual

Causes the current status of the simulation to be printed to stderr.

Parameters

fullStatus - if true, call printStatus() on all components as well as print the base Simulation's status

Implements SST::Simulation.

References SST::Output::output(), SST::TimeVortex::print(), and SST::Output::STDERR.

void SST::Simulation_impl::requireEvent ( const std::string & name )

overridevirtual

Signifies that an event type is required for this simulation Causes the Factory to verify that the required event type can be found.

Parameters

name	fully qualified libraryName.EventName

Implements SST::Simulation.

References factory, and SST::Factory::RequireEvent().

Cycle_t SST::Simulation_impl::reregisterClock	(	TimeConverter *	tc,
		Clock::HandlerBase *	handler,
		int	priority
	)

Reactivate an existing clock and handler.

Returns: time when handler will next fire

References SST::Output::fatal(), SST::TimeConverter::getFactor(), and SST::Output::STDERR.

Referenced by SST::BaseComponent::reregisterClock().

void SST::Simulation_impl::setOutputDirectory ( const std::string & outDir )

inline

Set the output directory for this simulation.

Parameters

outDir Path of directory to place simulation outputs in

void SST::Simulation_impl::setSignal ( int signal )

static

Sets an internal flag for signaling the simulation.

Used internally

void SST::Simulation_impl::setStopAtCycle ( Config * cfg )

Set cycle count, which, if reached, will cause the simulation to halt.

References SST::TimeLord::getSimCycles(), SST::TimeVortex::insert(), SST::Activity::setDeliveryTime(), SST::Config::stopAtCycle, and timeLord.

void SST::Simulation_impl::setup ( )

Perform the setup() and run phases of the simulation.

References SST::Core::ThreadSafe::Barrier::wait().

void SST::Simulation_impl::shutdown ( )

static

Used to signify the end of simulation.

Cleans up any existing Simulation Objects

The documentation for this class was generated from the following files:

src/sst/core/simulation_impl.h
src/sst/core/simulation.cc

Public Types

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Function Documentation