#include <CompiledSimController.hh>

Inheritance diagram for CompiledSimController:

Collaboration diagram for CompiledSimController:

Public Types
typedef CompiledSimulation *()	SimulationGetterFunction(const TTAMachine::Machine &machine, InstructionAddress entryAddress, InstructionAddress lastInstruction, SimulatorFrontend &frontend, CompiledSimController &controller, MemorySystem &memorySystem, bool dynamicCompilation, ProcedureBBRelations &procedureBBRelations)
	Function type for the getSimulation() function. More...

Public Types inherited from TTASimulationController
enum	SimulationStatus { STA_INITIALIZING, STA_INITIALIZED, STA_RUNNING, STA_STOPPED, STA_FINISHED }
	The states of simulation. More...

Public Member Functions
	CompiledSimController (SimulatorFrontend &frontend, const TTAMachine::Machine &machine, const TTAProgram::Program &program, bool leaveDirty=false)

virtual	~CompiledSimController ()

virtual void	step (double count=1)

virtual void	next (int count=1)

virtual void	run ()

virtual void	runUntil (UIntWord address)

virtual void	reset ()

virtual InstructionAddress	programCounter () const

virtual InstructionAddress	lastExecutedInstruction () const

virtual ClockCycleCount	clockCount () const

virtual boost::shared_ptr< CompiledSimulation >	compiledSimulation ()

virtual void	deleteGeneratedFiles ()

virtual std::string	registerFileValue (const std::string &rfName, int registerIndex=-1)

virtual SimValue	immediateUnitRegisterValue (const std::string &iuName, int index=-1)

virtual SimValue	FUPortValue (const std::string &fuName, const std::string &portName)

virtual void	prepareToStop (StopReason reason)

InstructionAddress	basicBlockStart (InstructionAddress address) const

const TTAProgram::Program &	program () const

Public Member Functions inherited from TTASimulationController
	TTASimulationController (SimulatorFrontend &frontend, const TTAMachine::Machine &machine, const TTAProgram::Program &program)

virtual	~TTASimulationController ()

virtual unsigned int	stopReasonCount () const

virtual StopReason	stopReason (unsigned int index) const

virtual SimulationStatus	state () const

virtual InstructionAddress	lastExecutedInstruction (int coreId=-1) const

virtual MemorySystem &	memorySystem (int coreId=-1)

virtual SimulatorFrontend &	frontend ()

virtual bool	automaticFinishImpossible () const

virtual std::set< InstructionAddress >	findProgramExitPoints (const TTAProgram::Program &program, const TTAMachine::Machine &machine) const

Private Member Functions
	CompiledSimController (const CompiledSimController &)
	Copying not allowed. More...

CompiledSimController &	operator= (const CompiledSimController &)
	Assignment not allowed. More...

Private Attributes
PluginTools	pluginTools_
	Used for loading the compiled simulation plugin. More...

boost::shared_ptr< CompiledSimulation >	simulation_
	Pointer to the loaded simulation. More...

std::string	compiledSimulationPath_
	Path to the generated simulation files. More...

bool	leaveDirty_
	True, if the simulation should leave all the generated code files. More...

CompiledSimCodeGenerator::AddressMap	basicBlocks_
	A map containing the basic blocks' start..end pairs. More...

ProcedureBBRelations	procedureBBRelations_
	A struct for tracking basic blocks and their relation to their procedures. More...

int	instanceId_
	The unique identifier for this simulation engine. Used for enabling multiple compiled engines in the same process while still having ccache hits (which would not happen when using the object address as the id). More...

Additional Inherited Members
Protected Types inherited from TTASimulationController
typedef std::set< StopReason >	StopReasonContainer
	The container type for reasons why simulation stop was requested. More...

Protected Member Functions inherited from TTASimulationController
	TTASimulationController (const TTASimulationController &)
	Copying not allowed. More...

TTASimulationController &	operator= (const TTASimulationController &)
	Assignment not allowed. More...

Protected Attributes inherited from TTASimulationController
SimulatorFrontend &	frontend_
	Reference to the simulator frontend. More...

const TTAMachine::Machine &	sourceMachine_
	The simulated Machine Object Model. More...

const TTAProgram::Program &	program_
	Program object model of the simulated program. More...

bool	stopRequested_
	Flag indicating that simulation should stop. More...

StopReasonContainer	stopReasons_
	The set of reasons the simulation was stopped. More...

SimulationStatus	state_
	The current state of the simulation. More...

ClockCycleCount	clockCount_
	How many clock cycles have been simulated. More...

std::vector< InstructionAddress >	lastExecutedInstruction_
	The address of the last executed instruction. More...

InstructionAddress	initialPC_
	The address of the first executed instruction. More...

bool	automaticFinishImpossible_
	If this is true, simulation cannot be finished automatically. More...

InstructionAddress	firstIllegalInstructionIndex_
	The index of the first illegal instruction in the instruction sequence. More...

Detailed Description

A Simulation controller that uses the compiled simulation techniques.

Definition at line 52 of file CompiledSimController.hh.

Member Typedef Documentation

◆ SimulationGetterFunction

typedef CompiledSimulation*() CompiledSimController::SimulationGetterFunction(const TTAMachine::Machine &machine, InstructionAddress entryAddress, InstructionAddress lastInstruction, SimulatorFrontend &frontend, CompiledSimController &controller, MemorySystem &memorySystem, bool dynamicCompilation, ProcedureBBRelations &procedureBBRelations)

Function type for the getSimulation() function.

Definition at line 81 of file CompiledSimController.hh.

Constructor & Destructor Documentation

◆ CompiledSimController() [1/2]

CompiledSimController::CompiledSimController	(	SimulatorFrontend &	frontend,
		const TTAMachine::Machine &	machine,
		const TTAProgram::Program &	program,
		bool	leaveDirty = `false`
	)

The constructor

Parameters

frontend	Simulator frontend
machine	The machine model
program	The program to be simulated
leaveDirty	Set to true in case the engine should not clean up the source files to the engine (in /tmp) after finishing, e.g., for debugging purposes.

Definition at line 68 of file CompiledSimController.cc.

                                                        : 
     TTASimulationController(frontend, machine, program),
     pluginTools_(true, false), compiledSimulationPath_(""), 
     leaveDirty_(leaveDirty) {
  
 #ifdef DEBUG_COMPILED_SIMULATION
     leaveDirty_ = true;
 #endif
  
     // Make the symbols unique in case we use more than one
     // simulator engines in the same process.
     static int instanceCount = 0;
     instanceId_ = instanceCount;
  
     // Note, this is not thread safe. Thus, the engines should be
     // initialized sequentially.
     ++instanceCount;
  
     reset();
 }

References instanceId_, leaveDirty_, and reset().

Here is the call graph for this function:

◆ ~CompiledSimController()

CompiledSimController::~CompiledSimController ( )

virtual

The destructor

Definition at line 94 of file CompiledSimController.cc.

                                               {
     deleteGeneratedFiles();
 }

References deleteGeneratedFiles().

Here is the call graph for this function:

◆ CompiledSimController() [2/2]

CompiledSimController::CompiledSimController ( const CompiledSimController & )

private

Copying not allowed.

Member Function Documentation

◆ basicBlockStart()

InstructionAddress CompiledSimController::basicBlockStart ( InstructionAddress address ) const

Returns the start of the basic block containing address

Parameters

address

Returns: instruction address of the basic block start

Definition at line 385 of file CompiledSimController.cc.

                                                                        {
     return basicBlocks_.lower_bound(address)->second;
 }

References basicBlocks_.

Referenced by CompiledSimulation::basicBlockStart(), and runUntil().

◆ clockCount()

ClockCycleCount CompiledSimController::clockCount ( ) const

virtual

Returns the count of clock cycles simulated.

Returns: Count of simulated clock cycles.

Reimplemented from TTASimulationController.

Definition at line 345 of file CompiledSimController.cc.

                                         {
     if (simulation_) {
         return simulation_->cycleCount();
     } else {
         return 0;
     }
 }

References simulation_.

◆ compiledSimulation()

boost::shared_ptr< CompiledSimulation > CompiledSimController::compiledSimulation ( )

virtual

Returns a pointer to the current CompiledSimulation object

Returns: A pointer to the current CompiledSimulation object

Definition at line 359 of file CompiledSimController.cc.

                                           {
     return simulation_;
 }

References simulation_.

Referenced by FUPortValue(), immediateUnitRegisterValue(), prepareToStop(), registerFileValue(), and SimulatorFrontend::utilizationStatistics().

◆ deleteGeneratedFiles()

void CompiledSimController::deleteGeneratedFiles ( )

virtual

Will delete all generated code files if leaveDirty_ is not set

Definition at line 367 of file CompiledSimController.cc.

                                             {
     if (leaveDirty_) {
         return;
     }
     
     if (FileSystem::fileExists(compiledSimulationPath_) 
         && compiledSimulationPath_ != "") {
         FileSystem::removeFileOrDirectory(compiledSimulationPath_);
     }
 }

References compiledSimulationPath_, FileSystem::fileExists(), leaveDirty_, and FileSystem::removeFileOrDirectory().

Referenced by reset(), and ~CompiledSimController().

Here is the call graph for this function:

◆ FUPortValue()

SimValue CompiledSimController::FUPortValue	(	const std::string &	fuName,
		const std::string &	portName
	)

virtual

Returns a FU port's value

Parameters

fuName	name of the function unit
portIndex	Index of the port

Returns: A FU port's value

Implements TTASimulationController.

Definition at line 460 of file CompiledSimController.cc.

                                {
     return compiledSimulation()->FUPortValue(fuName.c_str(), portName.c_str());
 }

References compiledSimulation().

Here is the call graph for this function:

◆ immediateUnitRegisterValue()

SimValue CompiledSimController::immediateUnitRegisterValue	(	const std::string &	iuName,
		int	index = `-1`
	)

virtual

Returns the current value of a IU register

Parameters

iuName	name of the immediate unit
index	index of the register

Returns: Current value of a IU register

Implements TTASimulationController.

Definition at line 445 of file CompiledSimController.cc.

                {
     return compiledSimulation()->immediateUnitRegisterValue(iuName.c_str(),
         index);
 }

References compiledSimulation().

Here is the call graph for this function:

◆ lastExecutedInstruction()

InstructionAddress CompiledSimController::lastExecutedInstruction ( ) const

virtual

Returns the address of the last executed instruction.

Returns: The address of the last executed instruction

Definition at line 335 of file CompiledSimController.cc.

                                                      {
     return simulation_->lastExecutedInstruction();
 }

References simulation_.

◆ next()

void CompiledSimController::next ( int count = 1 )

virtual

Advances simulation by a given amout of steps and skip procedure calls.,

@Note The accuracy of this function is one basic block!

Implements TTASimulationController.

Definition at line 138 of file CompiledSimController.cc.

                                      {
     assert(state_ == STA_STOPPED || state_ == STA_INITIALIZED);
     stopReasons_.clear();
     state_ = STA_RUNNING;
     stopRequested_ = false;
     
     try {
         simulation_->next(count);
     } catch (const Exception& e) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }  catch(...) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }
     
     prepareToStop(SRE_AFTER_STEPPING);
  
     if (simulation_->isFinished()) { 
         state_ = STA_FINISHED;
     } else {
         state_ = STA_STOPPED;
     }
  
     frontend_.eventHandler().handleEvent(
         SimulationEventHandler::SE_SIMULATION_STOPPED);
 }

Here is the call graph for this function:

◆ operator=()

CompiledSimController& CompiledSimController::operator= ( const CompiledSimController & )

private

Assignment not allowed.

◆ prepareToStop()

void CompiledSimController::prepareToStop ( StopReason reason )

virtual

Sends a stop request to the simulation controller and compiled simulation

Parameters

reason The stop reason

Reimplemented from TTASimulationController.

Definition at line 472 of file CompiledSimController.cc.

                                                       {
     TTASimulationController::prepareToStop(reason);
     compiledSimulation()->requestToStop();
 }

References compiledSimulation(), and TTASimulationController::prepareToStop().

Referenced by next(), run(), runUntil(), and step().

Here is the call graph for this function:

◆ program()

const TTAProgram::Program & CompiledSimController::program ( ) const

Returns the program model

Returns: the program model

Definition at line 394 of file CompiledSimController.cc.

                                      {
     return program_;
 }

References TTASimulationController::program_.

Referenced by CompiledSimulation::CompiledSimulation(), and CompiledSimulation::moveExecutionCount().

◆ programCounter()

InstructionAddress CompiledSimController::programCounter ( ) const

virtual

Returns the program counter value.

Returns: Program counter value.

Implements TTASimulationController.

Definition at line 325 of file CompiledSimController.cc.

                                             {
     return simulation_->programCounter();
 }

References simulation_.

◆ registerFileValue()

std::string CompiledSimController::registerFileValue	(	const std::string &	rfName,
		int	registerIndex = `-1`
	)

virtual

Returns a string containing the value(s) of the register file

Parameters

rfName	name of the register file to search for
registerIndex	index of the register. if -1, all registers are listed

Returns: A string containing the value(s) of the register file

Exceptions

InstanceNotFound If the register cannot be found.

Implements TTASimulationController.

Definition at line 407 of file CompiledSimController.cc.

                                                 {
     std::string stringValue("");
  
     if (registerIndex >= 0) {
         stringValue += compiledSimulation()->
             registerFileValue(rfName.c_str(), registerIndex).hexValue();
     } else {
         Machine::RegisterFileNavigator navigator = 
             sourceMachine_.registerFileNavigator();
         RegisterFile& rf = *navigator.item(rfName);
         
         bool firstReg = true;
         for (int i = 0; i < rf.numberOfRegisters(); ++i) {
             if (!firstReg) 
                 stringValue += "\n";
             const std::string registerName = 
                 rfName + "." + Conversion::toString(i);
  
             SimValue value = compiledSimulation()->
                 registerFileValue(rfName.c_str(), i);
             stringValue += registerName + " " + value.hexValue();
  
             firstReg = false;
         }
     }
     
     return stringValue;
 }

References compiledSimulation(), SimValue::hexValue(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Machine::registerFileNavigator(), TTASimulationController::sourceMachine_, and Conversion::toString().

Here is the call graph for this function:

◆ reset()

void CompiledSimController::reset ( )

virtual

Resets the simulation so it can be started from the beginning.

Resets everything to initial values (program counter, clock cycles etc.)

Implements TTASimulationController.

Definition at line 243 of file CompiledSimController.cc.

                              {
     
     state_ = STA_INITIALIZING;
     stopRequested_ = false;
     clockCount_ = 0;
     
     deleteGeneratedFiles();
         
     compiledSimulationPath_ = FileSystem::createTempDirectory();
     if (compiledSimulationPath_ == "") {
         Application::logStream() 
             << "Cannot create temporary path "
             << "for the generated simulation code!" << endl;
         return;
     }
  
     // Generate all simulation code at once
     CompiledSimCodeGenerator generator(
         sourceMachine_, program_, *this,
         frontend_.fuResourceConflictDetection(),
         frontend_.executionTracing() || frontend_.procedureTransferTracing(),
         !frontend_.staticCompilation(), 
         false, !frontend_.staticCompilation(),
         Conversion::toString(instanceId_));
  
     CATCH_ANY(generator.generateToDirectory(compiledSimulationPath_));
 #ifdef DEBUG_COMPILED_SIMULATION
     std::cerr << "Generated compiled simulation sources to: '"
               << compiledSimulationPath_ << "'" << std::endl;
 #endif
     basicBlocks_ = generator.basicBlocks();
     procedureBBRelations_ = generator.procedureBBRelations();
  
     CompiledSimCompiler compiler;
     
     // Compile everything when using static compiled simulation
     if (frontend_.staticCompilation()) {
         if (compiler.compileDirectory(compiledSimulationPath_, "", false) 
             != 0) {
             Application::logStream() << "Compilation aborted." << endl;
             return;
         }
     } else { // Compile main engine file
         compiler.compileToSO(compiledSimulationPath_ 
             + FileSystem::DIRECTORY_SEPARATOR + "CompiledSimulationEngine.cc");
         
         // Precompile the simulation header
         compiler.compileFile(compiledSimulationPath_ 
             + FileSystem::DIRECTORY_SEPARATOR + "CompiledSimulationEngine.hh", 
             "-xc++-header", ".gch");
     }
  
     SimulationGetterFunction* simulationGetter = NULL;
     pluginTools_.addSearchPath(compiledSimulationPath_);
  
     // register individual simulation functions
     std::vector<std::string> sos;
     FileSystem::globPath(compiledSimulationPath_ + "/simulate_*.so", sos);
     for (std::size_t i = 0; i < sos.size(); ++i) {
         const std::string& so = FileSystem::fileOfPath(sos.at(i));
         pluginTools_.registerModule(so);
     }
  
     // register simulation getter function symbol
     pluginTools_.registerModule("CompiledSimulationEngine.so");
     pluginTools_.importSymbol(
          "getSimulation_" + Conversion::toString(instanceId_), simulationGetter);
     simulation_.reset(
         simulationGetter(sourceMachine_, program_.entryAddress().location(),
             program_.lastInstruction().address().location(), 
             frontend_, *this, memorySystem(0), !frontend_.staticCompilation(), 
             procedureBBRelations_));
     
     state_ = STA_INITIALIZED;
 }

Referenced by CompiledSimController().

Here is the call graph for this function:

◆ run()

void CompiledSimController::run ( )

virtual

Advances the simulation until the program ends

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 173 of file CompiledSimController.cc.

                            {
     stopRequested_ = false;
     stopReasons_.clear();
     state_ = STA_RUNNING;
     
     // Run the program
     try {
         simulation_->run();
     } catch (const Exception& e) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }  catch(...) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }
  
     if (simulation_->isFinished()) { 
         state_ = STA_FINISHED;
     } else {
         state_ = STA_STOPPED;
     }
  
     frontend_.eventHandler().handleEvent(
         SimulationEventHandler::SE_SIMULATION_STOPPED);
 }

References SimulatorFrontend::eventHandler(), TTASimulationController::frontend_, Informer::handleEvent(), prepareToStop(), SimulationEventHandler::SE_SIMULATION_STOPPED, simulation_, SRE_RUNTIME_ERROR, TTASimulationController::STA_FINISHED, TTASimulationController::STA_RUNNING, TTASimulationController::STA_STOPPED, TTASimulationController::state_, TTASimulationController::stopReasons_, and TTASimulationController::stopRequested_.

Here is the call graph for this function:

◆ runUntil()

void CompiledSimController::runUntil ( UIntWord address )

virtual

Advances the simulation until a given address is reached.

@Note The accuracy of this function is one basic block!

Parameters

address the address after the simulation execution should end

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 209 of file CompiledSimController.cc.

                                                 {
     stopRequested_ = false;
     stopReasons_.clear();
     state_ = STA_RUNNING;
     address = basicBlockStart(address); // find nearest bb start
     
     try {
         simulation_->runUntil(address);
     } catch (const Exception& e) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }  catch(...) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }
     
     prepareToStop(SRE_AFTER_UNTIL);
  
     if (simulation_->isFinished()) { 
         state_ = STA_FINISHED;
     } else {
         state_ = STA_STOPPED;
     }
  
     frontend_.eventHandler().handleEvent(
         SimulationEventHandler::SE_SIMULATION_STOPPED);
 }

References basicBlockStart(), SimulatorFrontend::eventHandler(), TTASimulationController::frontend_, Informer::handleEvent(), prepareToStop(), SimulationEventHandler::SE_SIMULATION_STOPPED, simulation_, SRE_AFTER_UNTIL, SRE_RUNTIME_ERROR, TTASimulationController::STA_FINISHED, TTASimulationController::STA_RUNNING, TTASimulationController::STA_STOPPED, TTASimulationController::state_, TTASimulationController::stopReasons_, and TTASimulationController::stopRequested_.

Here is the call graph for this function:

◆ step()

void CompiledSimController::step ( double count = 1 )

virtual

Advances simulation by given amount of cycles

@Note The accuracy of this function is one basic block!

Implements TTASimulationController.

Definition at line 104 of file CompiledSimController.cc.

                                         {
     assert(state_ == STA_STOPPED || state_ == STA_INITIALIZED);
     stopReasons_.clear();
     state_ = STA_RUNNING;
     stopRequested_ = false;
     
     try {
         simulation_->step(count);
     }  catch (const Exception& e) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     } catch(...) {
         prepareToStop(SRE_RUNTIME_ERROR);
         return;
     }
     
     prepareToStop(SRE_AFTER_STEPPING);
  
     if (simulation_->isFinished()) { 
         state_ = STA_FINISHED;
     } else {
         state_ = STA_STOPPED;
     }
  
     frontend_.eventHandler().handleEvent(
         SimulationEventHandler::SE_SIMULATION_STOPPED);
 }

Here is the call graph for this function:

Member Data Documentation

◆ basicBlocks_

CompiledSimCodeGenerator::AddressMap CompiledSimController::basicBlocks_

private

A map containing the basic blocks' start..end pairs.

Definition at line 126 of file CompiledSimController.hh.

Referenced by basicBlockStart(), and reset().

◆ compiledSimulationPath_

std::string CompiledSimController::compiledSimulationPath_

private

Path to the generated simulation files.

Definition at line 120 of file CompiledSimController.hh.

Referenced by deleteGeneratedFiles(), and reset().

◆ instanceId_

int CompiledSimController::instanceId_

private

The unique identifier for this simulation engine. Used for enabling multiple compiled engines in the same process while still having ccache hits (which would not happen when using the object address as the id).

Definition at line 133 of file CompiledSimController.hh.

Referenced by CompiledSimController(), and reset().

◆ leaveDirty_

bool CompiledSimController::leaveDirty_

private

True, if the simulation should leave all the generated code files.

Definition at line 123 of file CompiledSimController.hh.

Referenced by CompiledSimController(), and deleteGeneratedFiles().

◆ pluginTools_

PluginTools CompiledSimController::pluginTools_

private

Used for loading the compiled simulation plugin.

Definition at line 114 of file CompiledSimController.hh.

Referenced by reset().

◆ procedureBBRelations_

ProcedureBBRelations CompiledSimController::procedureBBRelations_

private

A struct for tracking basic blocks and their relation to their procedures.

Definition at line 128 of file CompiledSimController.hh.

Referenced by reset().

◆ simulation_

boost::shared_ptr<CompiledSimulation> CompiledSimController::simulation_

private

Pointer to the loaded simulation.

Definition at line 117 of file CompiledSimController.hh.

Referenced by clockCount(), compiledSimulation(), lastExecutedInstruction(), next(), programCounter(), reset(), run(), runUntil(), and step().

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SimulationGetterFunction

Constructor & Destructor Documentation

◆ CompiledSimController() [1/2]

◆ ~CompiledSimController()

◆ CompiledSimController() [2/2]

Member Function Documentation

◆ basicBlockStart()

◆ clockCount()

◆ compiledSimulation()

◆ deleteGeneratedFiles()

◆ FUPortValue()

◆ immediateUnitRegisterValue()

◆ lastExecutedInstruction()

◆ next()

◆ operator=()

◆ prepareToStop()

◆ program()

◆ programCounter()

◆ registerFileValue()

◆ reset()

◆ run()

◆ runUntil()

◆ step()

Member Data Documentation

◆ basicBlocks_

◆ compiledSimulationPath_

◆ instanceId_

◆ leaveDirty_

◆ pluginTools_

◆ procedureBBRelations_

◆ simulation_