#include <TTASimulationController.hh>

Inheritance diagram for TTASimulationController:

Collaboration diagram for TTASimulationController:

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

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

virtual	~TTASimulationController ()

virtual void	step (double count=1)=0

virtual void	next (int count=1)=0

virtual void	run ()=0

virtual void	runUntil (UIntWord address)=0

virtual void	reset ()=0

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

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

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

virtual void	prepareToStop (StopReason reason)

virtual unsigned int	stopReasonCount () const

virtual StopReason	stopReason (unsigned int index) const

virtual SimulationStatus	state () const

virtual InstructionAddress	programCounter () const =0

virtual InstructionAddress	lastExecutedInstruction (int coreId=-1) const

virtual ClockCycleCount	clockCount () 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

Protected Types
typedef std::set< StopReason >	StopReasonContainer
	The container type for reasons why simulation stop was requested.

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

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

Protected Attributes
SimulatorFrontend &	frontend_
	Reference to the simulator frontend.

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

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

bool	stopRequested_
	Flag indicating that simulation should stop.

StopReasonContainer	stopReasons_
	The set of reasons the simulation was stopped.

SimulationStatus	state_
	The current state of the simulation.

ClockCycleCount	clockCount_
	How many clock cycles have been simulated.

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

InstructionAddress	initialPC_
	The address of the first executed instruction.

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

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

Detailed Description

An abstract interface class for controlling the simulation

Owns and is the main client of the machine state model.

Definition at line 69 of file TTASimulationController.hh.

Member Typedef Documentation

◆ StopReasonContainer

typedef std::set<StopReason> TTASimulationController::StopReasonContainer

protected

The container type for reasons why simulation stop was requested.

Definition at line 132 of file TTASimulationController.hh.

Member Enumeration Documentation

◆ SimulationStatus

enum TTASimulationController::SimulationStatus

The states of simulation.

Enumerator
STA_INITIALIZING	Simulation is being initialized.
STA_INITIALIZED	Simulation initialized and ready to run.
STA_RUNNING	A run command (run, stepi, until...) given.
STA_STOPPED	Simulation stopped for some reason.
STA_FINISHED	Simulation ended after executing the last instruction.

Definition at line 72 of file TTASimulationController.hh.

                          {
        STA_INITIALIZING,///< Simulation is being initialized.
        STA_INITIALIZED, ///< Simulation initialized and ready to run.
        STA_RUNNING,     ///< A run command (run, stepi, until...) given.
        STA_STOPPED,     ///< Simulation stopped for some reason.
        STA_FINISHED     
        ///< Simulation ended after executing the last instruction.
    };

Constructor & Destructor Documentation

◆ TTASimulationController() [1/2]

TTASimulationController::TTASimulationController	(	SimulatorFrontend &	frontend,
		const TTAMachine::Machine &	machine,
		const TTAProgram::Program &	program
	)

Constructor.

Exceptions

Exception Exceptions while building the simulation models are thrown forward.

Definition at line 60 of file TTASimulationController.cc.

                            :
    frontend_(frontend),
    sourceMachine_(machine), program_(program),
    state_(STA_INITIALIZING), clockCount_(0),
    lastExecutedInstruction_(1),
    initialPC_(program.entryAddress().location()),
    automaticFinishImpossible_(true),
    firstIllegalInstructionIndex_(UINT_MAX) {
}

◆ ~TTASimulationController()

TTASimulationController::~TTASimulationController ( )

virtual

Destructor.

Definition at line 76 of file TTASimulationController.cc.

76 {

77}

◆ TTASimulationController() [2/2]

TTASimulationController::TTASimulationController ( const TTASimulationController & )

protected

Copying not allowed.

Member Function Documentation

◆ automaticFinishImpossible()

bool TTASimulationController::automaticFinishImpossible ( ) const

virtual

Returns true in case simulation cannot be finished automatically.

In order for this method to return false, it means that while initializing the SimulationController, a probable ending point in the program was detected and it is possible that when running the simulation it is possible to finish it automatically at that position. If this method returns true it is impossible to finish simulation automatically.

Returns: True if it's not possible to end simulation automatically.

Definition at line 197 of file TTASimulationController.cc.

                                                         {
    return automaticFinishImpossible_;
}

References automaticFinishImpossible_.

Referenced by SimulatorFrontend::automaticFinishImpossible().

◆ clockCount()

ClockCycleCount TTASimulationController::clockCount ( ) const

virtual

Returns the count of clock cycles simulated.

Returns: Count of simulated clock cycles.

Reimplemented in CompiledSimController.

Definition at line 161 of file TTASimulationController.cc.

                                          {
    return clockCount_;
}

References clockCount_.

Referenced by SimulatorFrontend::cycleCount(), ExecutionTracker::handleEvent(), StopPointManager::handleEvent(), and StopPointManager::stopCausingStopPointCount().

◆ findProgramExitPoints()

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

virtual

Initializes the variables that are used in programEnded() to evaluate whether the simulated program has simulated to its end.

Parameters

program	The simulated program.
machine	The simulated machine.

Definition at line 209 of file TTASimulationController.cc.

                                            {
    std::set<InstructionAddress> exitPoints;
 
    /* Set return points to be all the returns from the first executed
       procedure. When control returns from that (usually the crt0(),
       start(), or main()), we should stop simulation. This is for
       convenience of simulating unmodified benchmark programs without
       having infinite loops etc. */
 
    // find the entry procedure
    Address entryAddr = program.entryAddress();
    Procedure* entryProc = NULL;
    for(int i = 0; i < program.procedureCount(); i++) {
        Procedure& currProc = program.procedure(i);
 
        if (currProc.startAddress().location() <= entryAddr.location() &&
            currProc.endAddress().location() > entryAddr.location()) {
            entryProc = &currProc;
            break;
        }
    }
 
    if (entryProc == NULL)
        throw IllegalProgram(
            __FILE__, __LINE__, __func__,
            "The entry point of the program does not point to a procedure.");
 
    // If __exit procedure exists, the first instruction in it is set
    // as an exit point.
    for(int i = 0; i < program.procedureCount(); i++) {
        Procedure &currProc = program.procedure(i);
        if (currProc.name() == "_exit" || currProc.name() == "__exit") {
            exitPoints.insert(currProc.firstInstruction().address().location());
            automaticFinishImpossible_ = false;
       }
    }
 
    const int delaySlots = machine.controlUnit()->delaySlots();
    // check instructions of entry procedure if they are "ra ->jump.1"
    for (int i = 0; i < entryProc->instructionCount(); ++i) {
 
        const Instruction& currInstr = entryProc->instructionAtIndex(i);
 
        // check if the instruction has a return move
        for (int m = 0; m < currInstr.moveCount(); ++m) {
 
            const Move& currMove = currInstr.move(m);
 
            if (currMove.isReturn()) {
                // set an exit point at the return + delay slots to allow
                // executing the delay slot code of the final return
                unsigned exitDelay = static_cast<unsigned>(
                    i + machine.controlUnit()->delaySlots());
                if (exitDelay <= entryProc->endAddress().location()) {
                    exitPoints.insert(
                        entryProc->instructionAtIndex(i + delaySlots).
                        address().location());
 
                    automaticFinishImpossible_ = false;
                }
                break; // check the next instruction
            }
        }
    }
 
    /*  In case the last instruction of the first procedure is *not*
        a jump and it's the last procedure in the program, set it as an exit
        point too (after executing the instruction we should stop simulation
        because there's nothing sensible to execute next). This is to allow
        simulating some obscure assembler programs that do not loop
        forever but just fall through the first procedure after done.
 
        The detection in that case is done by comparing the PC+1 to
        firstIllegalInstructionIndex_. */
 
    if (program.procedureCount() == 1) {
        // such assembly programs are usually stored in one procedure
        automaticFinishImpossible_ = false;
    }
    firstIllegalInstructionIndex_ =
        program.lastInstruction().address().location() + 1;
 
    return exitPoints;
}

References __func__, TTAProgram::Instruction::address(), automaticFinishImpossible_, TTAMachine::Machine::controlUnit(), TTAMachine::ControlUnit::delaySlots(), TTAProgram::CodeSnippet::endAddress(), firstIllegalInstructionIndex_, TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Move::isReturn(), TTAProgram::Address::location(), machine, TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAProgram::Procedure::name(), program, and TTAProgram::CodeSnippet::startAddress().

Referenced by CompiledSimulation::CompiledSimulation(), SimulationController::findExitPoints(), CompiledSimCodeGenerator::generateSimulationCode(), and RemoteController::RemoteController().

Here is the call graph for this function:

◆ frontend()

SimulatorFrontend & TTASimulationController::frontend ( )

virtual

Returns the simulator frontend.

Returns: A reference to the simulator frontend.

Definition at line 181 of file TTASimulationController.cc.

                                  {
    return frontend_;
}

References frontend_.

Referenced by ExecutionTracker::ExecutionTracker(), memorySystem(), SimulationController::SimulationController(), and ExecutionTracker::~ExecutionTracker().

◆ FUPortValue()

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

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::FUPortValue().

◆ immediateUnitRegisterValue()

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

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::immediateUnitRegisterValue().

◆ lastExecutedInstruction()

InstructionAddress TTASimulationController::lastExecutedInstruction ( int coreId = -1 ) const

virtual

Returns the address of the last executed instruction.

Returns: Address of the last executed instruction.

Definition at line 147 of file TTASimulationController.cc.

                                                                 {
    if (coreId == -1) {
        return lastExecutedInstruction_[frontend_.selectedCore()];
    } else {
        return lastExecutedInstruction_[coreId];
    }
}

References frontend_, lastExecutedInstruction_, and SimulatorFrontend::selectedCore().

Referenced by ExecutionTracker::handleEvent(), and SimulatorFrontend::lastExecutedInstruction().

Here is the call graph for this function:

◆ memorySystem()

MemorySystem & TTASimulationController::memorySystem ( int coreId = -1 )

virtual

Returns a reference to the memory system.

Returns: A reference to the memory system.

Definition at line 171 of file TTASimulationController.cc.

                                                {
    return frontend().memorySystem(coreId);
}

References frontend(), and SimulatorFrontend::memorySystem().

Referenced by OTASimulationController::advanceMachineCycle(), SimulatorFrontend::initializeDataMemories(), CompiledSimController::reset(), and SimulationController::simulateCycle().

Here is the call graph for this function:

◆ next()

virtual void TTASimulationController::next ( int count = 1 )

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::next().

◆ operator=()

TTASimulationController & TTASimulationController::operator= ( const TTASimulationController & )

protected

Assignment not allowed.

◆ prepareToStop()

void TTASimulationController::prepareToStop ( StopReason reason )

virtual

Get ready to return control to the client.

Functions name is has "prepare" in its name even though it always is able to stop the simulation. The reason for this is that it does not stop the simulation in the middle of simulating a clock cycle, but after the current clock cycle is simulated.

Parameters

reason The reason why simulation should be stopped.

Reimplemented in CompiledSimController.

Definition at line 90 of file TTASimulationController.cc.

                                                        {
    stopRequested_ = true;
    stopReasons_.insert(reason);
}

References stopReasons_, and stopRequested_.

Referenced by StopPointManager::handleEvent(), SimulationController::next(), CompiledSimController::prepareToStop(), SimulatorFrontend::prepareToStop(), SimulationController::runUntil(), OTASimulationController::simulateCycle(), SimulationController::simulateCycle(), and SimulationController::step().

◆ programCounter()

virtual InstructionAddress TTASimulationController::programCounter ( ) const

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::programCounter().

◆ registerFileValue()

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

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::registerFileValue().

◆ reset()

virtual void TTASimulationController::reset ( )

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::killSimulation().

◆ run()

virtual void TTASimulationController::run ( )

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::run().

◆ runUntil()

virtual void TTASimulationController::runUntil ( UIntWord address )

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::runUntil().

◆ state()

TTASimulationController::SimulationStatus TTASimulationController::state ( ) const

virtual

Returns the state of the simulation.

Returns: The state of the simulation.

Definition at line 137 of file TTASimulationController.cc.

                                     {
    return state_;
}

References state_.

Referenced by SimulatorFrontend::hasSimulationEnded(), SimulatorFrontend::isSimulationInitialized(), SimulatorFrontend::isSimulationRunning(), and SimulatorFrontend::isSimulationStopped().

◆ step()

virtual void TTASimulationController::step ( double count = 1 )

pure virtual

Implemented in CompiledSimController, CustomDBGController, SimulationController, TCEDBGController, and RemoteController.

Referenced by SimulatorFrontend::step().

◆ stopReason()

StopReason TTASimulationController::stopReason ( unsigned int index ) const

virtual

Returns the stop reason with the given index.

Parameters

index The wanted index.

Returns: The stop reason at the given index.

Exceptions

OutOfRange If the given index is out of range.

Definition at line 113 of file TTASimulationController.cc.

                                                            {
    if (index >= stopReasonCount()) {
        throw OutOfRange(
            __FILE__, __LINE__, __func__, "Stop reason index out of range.");
    }
    StopReasonContainer::const_iterator i = stopReasons_.begin();
    unsigned int count = 0;
    while (i != stopReasons_.end()) {
        if (index == count) {
            return (*i);
        }
        ++count;
        ++i;
    }
    // dummy to stop compiler from warning
    throw 0;
}

References __func__, stopReasonCount(), and stopReasons_.

Referenced by SimulatorFrontend::stopReason().

Here is the call graph for this function:

◆ stopReasonCount()

unsigned int TTASimulationController::stopReasonCount ( ) const

virtual

Returns the count of stop reasons.

Returns: The count of stop reasons.

Definition at line 101 of file TTASimulationController.cc.

                                               {
    return stopReasons_.size();
}

References stopReasons_.

Referenced by stopReason(), and SimulatorFrontend::stopReasonCount().

Member Data Documentation

◆ automaticFinishImpossible_

bool TTASimulationController::automaticFinishImpossible_

mutableprotected

If this is true, simulation cannot be finished automatically.

Definition at line 155 of file TTASimulationController.hh.

Referenced by automaticFinishImpossible(), and findProgramExitPoints().

◆ clockCount_

ClockCycleCount TTASimulationController::clockCount_

protected

How many clock cycles have been simulated.

Definition at line 149 of file TTASimulationController.hh.

Referenced by clockCount(), CompiledSimController::reset(), SimulationController::reset(), OTASimulationController::simulateCycle(), SimulationController::simulateCycle(), and SimulationController::SimulationController().

◆ firstIllegalInstructionIndex_

InstructionAddress TTASimulationController::firstIllegalInstructionIndex_

mutableprotected

The index of the first illegal instruction in the instruction sequence.

Definition at line 158 of file TTASimulationController.hh.

Referenced by findProgramExitPoints(), OTASimulationController::simulateCycle(), and SimulationController::simulateCycle().

◆ frontend_

SimulatorFrontend& TTASimulationController::frontend_

protected

Reference to the simulator frontend.

Definition at line 135 of file TTASimulationController.hh.

◆ initialPC_

InstructionAddress TTASimulationController::initialPC_

protected

The address of the first executed instruction.

Definition at line 153 of file TTASimulationController.hh.

Referenced by SimulationController::reset().

◆ lastExecutedInstruction_

std::vector<InstructionAddress> TTASimulationController::lastExecutedInstruction_

protected

The address of the last executed instruction.

Definition at line 151 of file TTASimulationController.hh.

Referenced by lastExecutedInstruction(), OTASimulationController::simulateCycle(), and SimulationController::simulateCycle().

◆ program_

const TTAProgram::Program& TTASimulationController::program_

protected

Program object model of the simulated program.

Definition at line 139 of file TTASimulationController.hh.

Referenced by RemoteController::loadIMemImage(), SimulationController::next(), CompiledSimController::program(), and CompiledSimController::reset().

◆ sourceMachine_

const TTAMachine::Machine& TTASimulationController::sourceMachine_

protected

The simulated Machine Object Model.

Definition at line 137 of file TTASimulationController.hh.

Referenced by RemoteController::loadIMemImage(), CompiledSimController::registerFileValue(), SimulationController::registerFileValue(), and CompiledSimController::reset().

◆ state_

SimulationStatus TTASimulationController::state_

protected

The current state of the simulation.

Definition at line 147 of file TTASimulationController.hh.

Referenced by CompiledSimController::next(), SimulationController::next(), CompiledSimController::reset(), SimulationController::reset(), CompiledSimController::run(), SimulationController::run(), CompiledSimController::runUntil(), SimulationController::runUntil(), OTASimulationController::simulateCycle(), SimulationController::simulateCycle(), state(), CompiledSimController::step(), and SimulationController::step().

◆ stopReasons_

StopReasonContainer TTASimulationController::stopReasons_

protected

The set of reasons the simulation was stopped.

Definition at line 144 of file TTASimulationController.hh.

Referenced by CompiledSimController::next(), SimulationController::next(), prepareToStop(), CompiledSimController::run(), SimulationController::run(), CompiledSimController::runUntil(), SimulationController::runUntil(), CompiledSimController::step(), SimulationController::step(), stopReason(), and stopReasonCount().

◆ stopRequested_

bool TTASimulationController::stopRequested_

protected

Flag indicating that simulation should stop.

Definition at line 142 of file TTASimulationController.hh.

Referenced by CompiledSimController::next(), SimulationController::next(), prepareToStop(), CompiledSimController::reset(), SimulationController::reset(), CompiledSimController::run(), SimulationController::run(), CompiledSimController::runUntil(), SimulationController::runUntil(), OTASimulationController::simulateCycle(), SimulationController::simulateCycle(), CompiledSimController::step(), and SimulationController::step().

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ StopReasonContainer

Member Enumeration Documentation

◆ SimulationStatus

Constructor & Destructor Documentation

◆ TTASimulationController() [1/2]

◆ ~TTASimulationController()

◆ TTASimulationController() [2/2]

Member Function Documentation

◆ automaticFinishImpossible()

◆ clockCount()

◆ findProgramExitPoints()

◆ frontend()

◆ FUPortValue()

◆ immediateUnitRegisterValue()

◆ lastExecutedInstruction()

◆ memorySystem()

◆ next()

◆ operator=()

◆ prepareToStop()

◆ programCounter()

◆ registerFileValue()

◆ reset()

◆ run()

◆ runUntil()

◆ state()

◆ step()

◆ stopReason()

◆ stopReasonCount()

Member Data Documentation

◆ automaticFinishImpossible_

◆ clockCount_

◆ firstIllegalInstructionIndex_

◆ frontend_

◆ initialPC_

◆ lastExecutedInstruction_

◆ program_

◆ sourceMachine_

◆ state_

◆ stopReasons_

◆ stopRequested_