#include <SimulatorFrontend.hh>

Inheritance diagram for SimulatorFrontend:

Collaboration diagram for SimulatorFrontend:

Public Types
enum	RuntimeErrorSeverity { RES_MINOR , RES_FATAL }
	The severities of runtime errors. More...

enum	SimulationType { SIM_NORMAL , SIM_COMPILED , SIM_REMOTE , SIM_CUSTOM , SIM_OTA }
	Which type of simulation this SimulatorFrontend controls or connects to. More...

Public Member Functions
	SimulatorFrontend (SimulationType backend=SIM_NORMAL)

virtual	~SimulatorFrontend ()

virtual void	loadProgram (const std::string &fileName)

virtual void	loadMachine (const std::string &fileName)

void	loadProgram (const TTAProgram::Program &program)

void	loadMachine (const TTAMachine::Machine &machine)

void	loadProcessorConfiguration (const std::string &fileName)

const TTAMachine::Machine &	machine () const

const TTAProgram::Program &	program () const

const SimValue &	stateValue (std::string searchString)

StateData &	state (std::string searchString)

MachineState &	machineState (int core=-1)

virtual void	next (int count=1)

virtual void	step (double count=1)

virtual void	run ()

virtual void	runUntil (UIntWord address)

void	prepareToStop (StopReason reason)

unsigned int	stopReasonCount () const

StopReason	stopReason (unsigned int index) const

bool	stoppedByUser () const

virtual void	killSimulation ()

StopPointManager &	stopPointManager ()

MemorySystem &	memorySystem (int coreId=-1)

bool	isSimulationInitialized () const

bool	isSimulationRunning () const

bool	isSimulationStopped () const

bool	isProgramLoaded () const

bool	isMachineLoaded () const

bool	hasSimulationEnded () const

bool	isCompiledSimulation () const

bool	isTCEDebugger () const

bool	isCustomDebugger () const

void	setCompiledSimulationLeaveDirty (bool dirty)

bool	executionTracing () const

bool	busTracing () const

bool	rfAccessTracing () const

bool	procedureTransferTracing () const

bool	profileDataSaving () const

bool	utilizationDataSaving () const

bool	staticCompilation () const

const RFAccessTracker &	rfAccessTracker () const

void	setCompiledSimulation (bool value)

void	setExecutionTracing (bool value)

void	setBusTracing (bool value)

void	setRFAccessTracing (bool value)

void	setProcedureTransferTracing (bool value)

void	setProfileDataSaving (bool value)

void	setUtilizationDataSaving (bool value)

void	forceTraceDBFileName (const std::string &fileName)

void	setTimeout (unsigned int value)

void	setStaticCompilation (bool value)

std::ostream &	outputStream ()

void	setOutputStream (std::ostream &stream)

std::string	disassembleInstruction (UIntWord instructionAddress) const

std::string	programLocationDescription () const

InstructionAddress	programCounter () const

virtual InstructionAddress	lastExecutedInstruction (int coreId=-1) const

ClockCycleCount	cycleCount () const

const TTAProgram::Procedure &	currentProcedure () const

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)

StateData &	findRegister (const std::string &rfName, int registerIndex)

StateData &	findBooleanRegister ()

StateData &	findPort (const std::string &fuName, const std::string &portName)

const UtilizationStats &	utilizationStatistics (int core=-1)

const ExecutableInstruction &	lastExecInstruction () const

const ExecutableInstruction &	executableInstructionAt (InstructionAddress address) const

bool	automaticFinishImpossible () const

void	setFUResourceConflictDetection (bool value)

bool	fuResourceConflictDetection () const

void	setNextInstructionPrinting (bool value)

bool	nextInstructionPrinting () const

void	setSimulationTimeStatistics (bool value)

bool	simulationTimeStatistics () const

ExecutionTrace *	lastTraceDB (int core=-1)

void	setMemoryAccessTracking (bool value)

bool	memoryAccessTracking () const

void	finishSimulation ()

void	setZeroFillMemoriesOnReset (bool val)

void	setDetailedSimulation (bool val)

CycleCount	lastRunCycleCount () const

SimulationEventHandler &	eventHandler ()

double	lastRunTime () const

void	reportSimulatedProgramError (RuntimeErrorSeverity severity, const std::string &description)

std::string	programErrorReport (RuntimeErrorSeverity severity, std::size_t index)

std::size_t	programErrorReportCount (RuntimeErrorSeverity severity)

void	clearProgramErrorReports ()

int	selectedCore () const

void	selectCore (int core)

bool	compareState (SimulatorFrontend &other, std::ostream *differences=NULL)

std::size_t	callHistoryLength () const

void	setCallHistoryLength (std::size_t length)

const CallPathTracker &	callPathTracker (int core=-1) const

void	initializeDataMemories (const TTAMachine::AddressSpace *onlyOne=NULL)

Protected Types
typedef std::pair< RuntimeErrorSeverity, std::string >	ProgramErrorDescription
	A type for storing a program error description.

typedef std::vector< ProgramErrorDescription >	ProgramErrorDescriptionList
	Container for simulated program error descriptions.

Protected Member Functions
virtual void	initializeSimulation ()

void	initializeTracing ()

void	initializeDisassembler () const

void	initializeMemorySystem ()

void	setControllerForMemories (RemoteController *con)

bool	hasStopReason (StopReason reason) const

void	startTimer ()

void	stopTimer ()

void	setupCallHistoryTracking ()

Protected Attributes
const TTAMachine::Machine *	currentMachine_
	Machine to run simulation with.

TTASimulationController *	simCon_
	If simulation is initialized, this contains a pointer to the simulation controller.

bool	machineOwnedByFrontend_
	Is the machine owned by SimulatorFrontend or by the client?

const TTAProgram::Program *	currentProgram_
	Program to be simulated.

std::string	programFileName_
	The source file of the program to be simulated. Used to generate the file name of the trace data base.

bool	programOwnedByFrontend_
	Is the program owned by SimulatorFrontend or by the client?

SimulationType	currentBackend_
	Type of "backend" this Frontend has.

POMDisassembler *	disassembler_
	The disassembler used to print out instructions. This is initialized on demand.

bool	executionTracing_
	Is execution tracing, i.e., storing the executed instruction addresses to the trace database, enabled.

bool	busTracing_
	Is bus tracing, i.e., storing the values of buses in each clock cycle enabled.

bool	rfAccessTracing_
	Is register file (concurrent) access tracking enabled.

bool	procedureTransferTracing_
	Is procedure transfer access tracking enabled.

bool	saveProfileData_
	Is saving of profile data to TraceDB enabled.

bool	saveUtilizationData_
	Is saving of utilization data to TraceDB enabled.

std::vector< ExecutionTrace * >	traceDBs_
	The database to use for execution trace data.

std::vector< bool >	traceDBOwned_
	Whether traceDB at index is owned by simulator (or taken away by client using lastTraceDB())

std::vector< ExecutionTracker * >	executionTrackers_
	The simple execution tracker for storing trace of executed instructions.

std::vector< BusTracker * >	busTrackers_
	The tracker for saving bus trace.

std::vector< RFAccessTracker * >	rfAccessTrackers_
	The register file access tracker.

std::vector< ProcedureTransferTracker * >	procedureTransferTrackers_
	The procedure transfer tracker.

StopPointManager *	stopPointManager_
	The breakpoint manager to be used to bookkeep breakpoints.

std::vector< UtilizationStats * >	utilizationStats_
	Processor utilization statistics.

TPEF::Binary *	tpef_
	The source TPEF file.

bool	fuResourceConflictDetection_
	If this is enabled before initialization, FU resource conflicts are detected (slows down simulation).

bool	printNextInstruction_
	If true, the next simulated instructions is printed to stdout when simulation stops.

bool	printSimulationTimeStatistics_
	True if the simulation time statistics should be printed out.

bool	staticCompilation_
	True if the compiled simulation should use static compilation.

bool	traceFileNameSetByUser_
	Flag that indicates is the trace file name set by user.

std::ostream *	outputStream_
	Default output stream.

bool	memoryAccessTracking_
	If this is enabled before initialization, memory access tracking is enabled. (slows down simulation)

SimulationEventHandler *	eventHandler_
	Per simulation instance of SimulationEventHandler.

ClockCycleCount	lastRunCycleCount_
	The cycle count of the last non-interrupted simulation phase.

double	lastRunTime_
	The wall clock time of the last non-interrupted simulation phase in seconds.

std::time_t	startTime_
	The time of the last simulation start. Used to compute simulation speed.

CycleCount	startCycleCount_
	The cycle count when the latest simulation was started. Used to compute simulation speed.

unsigned int	simulationTimeout_
	Simulation timeout in seconds.

ProgramErrorDescriptionList	programErrorReports_
	Runtime error reports.

bool	leaveCompiledDirty_
	True in case the compilation simulation should not cleanup at destruction the engine source files.

std::size_t	callHistoryLength_
	The length of call history to store in memory for the commands that need it.

std::vector< CallPathTracker * >	callPathTrackers_
	The call path trackers for each core, in case tracking is enabled.

std::string	forcedTraceDBFileName_
	If set, forces the SQLite filename of trace DB to this name.

std::vector< MemorySystem * >	memorySystems_
	The simulation models of the memories in the currently loaded machine for each core.

bool	zeroFillMemoriesOnReset_
	Set to true in case the memories should be set to zero at reset.

bool	detailedSimulation_
	Set to true in case should build a detailed model which simulates FU stages, possibly with an external system-level model.

Friends
void	timeoutThread (unsigned int timeout, SimulatorFrontend *simFE)

Detailed Description

Frontend to simulator functionality.

User interfaces use this class as the access point to simulation functionality. It acts as a "facade" hiding the complexity of simulator engine. Error messages of exceptions thrown by the methods of this class are generated using SimulatorTextGenerator, thus they can be used in user interfaces directly.

Definition at line 88 of file SimulatorFrontend.hh.

Member Typedef Documentation

◆ ProgramErrorDescription

typedef std::pair<RuntimeErrorSeverity, std::string> SimulatorFrontend::ProgramErrorDescription

protected

A type for storing a program error description.

Definition at line 287 of file SimulatorFrontend.hh.

◆ ProgramErrorDescriptionList

typedef std::vector<ProgramErrorDescription> SimulatorFrontend::ProgramErrorDescriptionList

protected

Container for simulated program error descriptions.

Definition at line 289 of file SimulatorFrontend.hh.

Member Enumeration Documentation

◆ RuntimeErrorSeverity

enum SimulatorFrontend::RuntimeErrorSeverity

The severities of runtime errors.

Enumerator
RES_MINOR	Minor runtime error, no abort necessary.
RES_FATAL	Fatal runtime error, there is a serious error in the simulated program, thus it makes no sense to go on with the simulation.

Definition at line 92 of file SimulatorFrontend.hh.

                 {
        RES_MINOR, ///< Minor runtime error, no abort necessary.
        RES_FATAL  ///< Fatal runtime error, there is a serious error in the
                   /// simulated program, thus it makes no sense to go on
                   /// with the simulation.
    } RuntimeErrorSeverity;

◆ SimulationType

enum SimulatorFrontend::SimulationType

Which type of simulation this SimulatorFrontend controls or connects to.

Enumerator
SIM_NORMAL	Default, interpreted simulation (debugging engine).
SIM_COMPILED	Compiled, faster simulation.
SIM_REMOTE	Remote debugger, not a simulator at all.
SIM_CUSTOM	User-implemented remote HW debugger.
SIM_OTA	Simulation with operation-triggered implicit data transports.

Definition at line 100 of file SimulatorFrontend.hh.

                 {
        SIM_NORMAL,   ///< Default, interpreted simulation (debugging engine).
        SIM_COMPILED, ///< Compiled, faster simulation.
        SIM_REMOTE,   ///< Remote debugger, not a simulator at all
        SIM_CUSTOM,   ///< User-implemented remote HW debugger
        SIM_OTA       ///< Simulation with operation-triggered implicit data
                      ///  transports.
    } SimulationType;

Constructor & Destructor Documentation

◆ SimulatorFrontend()

SimulatorFrontend::SimulatorFrontend ( SimulationType backendType = SIM_NORMAL )

Constructor.

Definition at line 120 of file SimulatorFrontend.cc.

                                                               : 
    currentMachine_(NULL), simCon_(NULL),
    machineOwnedByFrontend_(false), currentProgram_(NULL), 
    programFileName_(""), programOwnedByFrontend_(false), 
    currentBackend_(backendType),
    disassembler_(NULL), executionTracing_(false),
    busTracing_(false), 
    rfAccessTracing_(false), procedureTransferTracing_(false), 
    saveProfileData_(false), saveUtilizationData_(false),
    stopPointManager_(NULL), tpef_(NULL),
    fuResourceConflictDetection_(true),
    printNextInstruction_(true), printSimulationTimeStatistics_(false),
    staticCompilation_(true), traceFileNameSetByUser_(false), outputStream_(0),
    memoryAccessTracking_(false), eventHandler_(NULL), lastRunCycleCount_(0),
    lastRunTime_(0.0), simulationTimeout_(0), leaveCompiledDirty_(false),
    callHistoryLength_(0), zeroFillMemoriesOnReset_(true) {
 
    if (backendType == SIM_COMPILED) {
        setCompiledSimulation(true);
        setFUResourceConflictDetection(false); // disabled by default
        SimulatorToolbox::textGenerator().generateCompiledSimTexts();
    } else {
        setCompiledSimulation(false);
    }
}

References SimulatorTextGenerator::generateCompiledSimTexts(), setCompiledSimulation(), setFUResourceConflictDetection(), SIM_COMPILED, and SimulatorToolbox::textGenerator().

Here is the call graph for this function:

◆ ~SimulatorFrontend()

SimulatorFrontend::~SimulatorFrontend ( )

virtual

Destructor.

Definition at line 149 of file SimulatorFrontend.cc.

                                      {
 
    finishSimulation();
 
    if (machineOwnedByFrontend_) {
        delete currentMachine_;
        currentMachine_ = NULL;
    }
 
    if (programOwnedByFrontend_) {
        delete currentProgram_;
        currentProgram_ = NULL;
        programFileName_ = "";
    }
 
    delete disassembler_;
    disassembler_ = NULL;
    delete simCon_;
    simCon_ = NULL;
    delete stopPointManager_;
    stopPointManager_ = NULL;
    delete tpef_;
    tpef_ = NULL;
    delete eventHandler_;
    eventHandler_ = NULL;
    delete simCon_;
    simCon_ = NULL;
    SequenceTools::deleteAllItems(memorySystems_);
 
    clearProgramErrorReports();
    
}

References clearProgramErrorReports(), currentMachine_, currentProgram_, SequenceTools::deleteAllItems(), disassembler_, eventHandler_, finishSimulation(), machineOwnedByFrontend_, memorySystems_, programFileName_, programOwnedByFrontend_, simCon_, stopPointManager_, and tpef_.

Here is the call graph for this function:

Member Function Documentation

◆ automaticFinishImpossible()

bool SimulatorFrontend::automaticFinishImpossible ( ) const

Returns true in case simulation with the currently loaded program cannot be finished automatically.

In order for this method to return false, it means that while loading the simulated program, 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 2230 of file SimulatorFrontend.cc.

                                                   {
    return simCon_ != NULL && simCon_->automaticFinishImpossible();
}

References TTASimulationController::automaticFinishImpossible(), and simCon_.

Referenced by ProgCommand::execute().

Here is the call graph for this function:

◆ busTracing()

bool SimulatorFrontend::busTracing ( ) const

Returns true in case bus tracing is enabled.

Returns: True in case bus tracing is enabled.

Definition at line 1808 of file SimulatorFrontend.cc.

                                    {
    return busTracing_;
}

References busTracing_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ callHistoryLength()

std::size_t SimulatorFrontend::callHistoryLength ( ) const

inline

Definition at line 266 of file SimulatorFrontend.hh.

266{ return callHistoryLength_; }

References callHistoryLength_.

Referenced by BackTraceCommand::execute().

◆ callPathTracker()

const CallPathTracker & SimulatorFrontend::callPathTracker ( int core = -1 ) const

Definition at line 2393 of file SimulatorFrontend.cc.

                                                 { 
    assert(callPathTrackers_.size() > 0);
    if (core == -1) {
        return *callPathTrackers_.at(selectedCore());
    } else {
        return *callPathTrackers_.at(core);
    }   
}

References assert, callPathTrackers_, and selectedCore().

Referenced by BackTraceCommand::execute().

Here is the call graph for this function:

◆ clearProgramErrorReports()

void SimulatorFrontend::clearProgramErrorReports ( )

Clears the runtime error report list.

Definition at line 2360 of file SimulatorFrontend.cc.

                                            {
    programErrorReports_.clear();
}

References programErrorReports_.

Referenced by RuntimeErrorReporter::handleEvent(), ProximRuntimeErrorHandler::handleEvent(), and ~SimulatorFrontend().

◆ compareState()

bool SimulatorFrontend::compareState	(	SimulatorFrontend &	other,
		std::ostream *	differences = `NULL`
	)

Compares the states of two simulator engines.

This is useful in debugging bugs in an simulator engine implementation. It assumes the engines have been stepped equal amount of instruction cycles and, thus, the TTA programmer visible context should be equal.

Parameters

other	A frontend to the other engine to compare this one to.
differences	An optional output stream where to output information of the possible differences.

Returns: true in case the states are equal, false otherwise.

Definition at line 2415 of file SimulatorFrontend.cc.

                                                       {
 
    static InstructionAddress previousPC = 0;
 
    if (programCounter() != other.programCounter()) {
        if (differences != NULL) 
            *differences
                << "SIMULATION ERROR DETECTED (PCs DIFFER)" << std::endl
                << "--------------------------------------" << std::endl
                << "      cycle: " << cycleCount() << std::endl
                << " other's PC: " << other.programCounter() << std::endl
                << "   this' PC: " << programCounter() << std::endl;
        return false;
    }
 
    bool errorLocationPrinted = false;
    bool equal = true;
 
    const TTAMachine::Machine::RegisterFileNavigator& rfNav = 
        machine().registerFileNavigator();
    for (int i = 0; i < rfNav.count(); ++i) {
        TTAMachine::RegisterFile& rf = *rfNav.item(i);
        for (int reg = 0; reg < rf.size(); ++reg) {
            std::string thisReg = 
                registerFileValue(rf.name(), reg);
            std::string otherReg =
                other.registerFileValue(rf.name(), reg);
            if (thisReg != otherReg) {
                equal = false;
                if (!errorLocationPrinted && differences != NULL) {
                    std::string procedureName =
                        (dynamic_cast<TTAProgram::Procedure&>(
                            program().instructionAt(programCounter()).parent())).name();
 
                    *differences
                        << "DIFFERING REGISTER FILE VALUES" << std::endl
                        << "------------------------------" << std::endl
                        << "      cycle: " << cycleCount() << std::endl
                        << "         PC: " << programCounter() << std::endl
                        << "previous PC: " << previousPC << std::endl
                        << "   function: " << procedureName << std::endl
                        << "disassembly around previous PC:" << std::endl;
                    int start = 
                        std::max(0, (int)previousPC - 5);
                    int end = previousPC + 5;
                    for (int instr = start; instr <= end; ++instr) {
                        if (instr == (int)previousPC)
                            *differences << "==> ";
                        *differences
                            << POMDisassembler::disassemble(
                                program().instructionAt(instr), 
                                true)
                            << std::endl;
                    }
                    errorLocationPrinted = true;
                }
                if (differences != NULL) 
                    *differences
                        << rf.name() << "." << reg << ": "
                        << thisReg << " (this) vs. " 
                        << otherReg << " (other)" << std::endl;
            }
        } 
    }
 
    errorLocationPrinted = false;
 
    const TTAMachine::Machine::FunctionUnitNavigator& fuNav = 
        machine().functionUnitNavigator();
    for (int i = 0; i < fuNav.count(); ++i) {
        TTAMachine::FunctionUnit& fu = *fuNav.item(i);
 
        for (int port = 0; port < fu.portCount(); ++port) {
            // skip output ports as compiled sim is not exact with them at BB boundaries
            if (fu.port(port)->isOutput())
                continue; 
            std::string portName = fu.port(port)->name();
            DisassemblyFUPort portString(fu.name(), portName);
            SimValue thisReg = 
                FUPortValue(fu.name(), portName);
            SimValue otherReg = 
                other.FUPortValue(fu.name(), portName);
            if (thisReg.intValue() != otherReg.intValue()) {
                equal = false;
                if (!errorLocationPrinted && differences != NULL) {
                    std::string procedureName =
                        (dynamic_cast<TTAProgram::Procedure&>(
                            program().instructionAt(programCounter()).parent())).name();
 
                    *differences 
                        << "DIFFERING FUNCTION UNIT PORT VALUES" << std::endl
                        << "-----------------------------------" << std::endl
                        << "      cycle: " << cycleCount() << std::endl
                        << "         PC: " << programCounter() << std::endl
                        << "previous PC: " << previousPC << std::endl
                        << "   function: " << procedureName << std::endl
                        << "disassembly around previous PC:" << std::endl;
                    int start = 
                        std::max(0, (int)previousPC - 5);
                    int end = previousPC + 5;
                    for (int instr = start; instr <= end; ++instr) {
                        if (instr == (int)previousPC)
                            *differences << "==> ";
                        *differences
                                << POMDisassembler::disassemble(
                                    program().instructionAt(instr), true)
                                << std::endl;
                    }
                    errorLocationPrinted = true;
                }
                if (differences != NULL)
                    *differences
                        << portString.toString() <<  ": "
                        << thisReg.intValue() << " (this) vs. " 
                        << otherReg.intValue() << " (other)" << std::endl;
            }
            
        }
 
 
    }
 
    previousPC = programCounter();
 
    return equal;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), cycleCount(), POMDisassembler::disassemble(), TTAMachine::Machine::functionUnitNavigator(), FUPortValue(), TTAProgram::Program::instructionAt(), SimValue::intValue(), TTAMachine::Port::isOutput(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAProgram::Instruction::parent(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), program(), programCounter(), TTAMachine::Machine::registerFileNavigator(), registerFileValue(), TTAMachine::BaseRegisterFile::size(), and DisassemblyFUPort::toString().

Referenced by tandemSimulate().

Here is the call graph for this function:

◆ currentProcedure()

const Procedure & SimulatorFrontend::currentProcedure ( ) const

Returns the current procedure.

The current procedure is expected to be the nearest procedure behind the program counter.

Returns: The current procedure.

Todo:: Throw exception if simulation is not initialized

Definition at line 1210 of file SimulatorFrontend.cc.

                                          {
    assert(simCon_ != NULL);
    assert(currentProgram_ != NULL);  
    InstructionAddress address = programCounter();
    if (address > currentProgram_->lastInstruction().address().location()) {
        return currentProgram_->lastProcedure();
    } else {
        return dynamic_cast<const Procedure&>(
            currentProgram_->instructionAt(programCounter()).parent());
    }
}

References TTAProgram::Instruction::address(), assert, currentProgram_, TTAProgram::Program::instructionAt(), TTAProgram::Program::lastInstruction(), TTAProgram::Program::lastProcedure(), TTAProgram::Address::location(), TTAProgram::Instruction::parent(), programCounter(), and simCon_.

Referenced by DisassembleCommand::execute().

Here is the call graph for this function:

◆ cycleCount()

ClockCycleCount SimulatorFrontend::cycleCount ( ) const

Returns the current count of simulated cycles.

Returns: The count of cycles.

Todo:: Throw exception if simulation is not initialized

Definition at line 1194 of file SimulatorFrontend.cc.

                                    {
    assert(simCon_ != NULL);
    return simCon_->clockCount();
}

References assert, TTASimulationController::clockCount(), and simCon_.

Referenced by compareState(), SimpleSimulatorFrontend::cycleCount(), ProximBusDetailsCmd::Do(), ProximSocketDetailsCmd::Do(), InfoProcCommand::execute(), finishSimulation(), BusTracker::handleEvent(), ProcedureTransferTracker::handleEvent(), RuntimeErrorReporter::handleEvent(), Watch::isTriggered(), DisasmExecPercentageAttrProvider::moveCellAttr(), ProximStopDialog::onUpdate(), ProximMachineStateWindow::setUtilizationHighlights(), DesignSpaceExplorer::simulate(), startTimer(), stopTimer(), tandemSimulate(), and ProximMainFrame::updateSimulationStatus().

Here is the call graph for this function:

◆ disassembleInstruction()

std::string SimulatorFrontend::disassembleInstruction ( UIntWord instructionAddress ) const

Returns the disassembly of instruction at given address.

Parameters

instructionAddress Address (index) of the instruction wanted to disassemble.

Returns: Disassembly of an instruction.

Todo:: print all labels associated at address

Definition at line 1073 of file SimulatorFrontend.cc.

                                                                           {
 
    const Instruction& theInstruction =
        currentProgram_->instructionAt(instructionAddress);
    const Procedure& currentProc = dynamic_cast<const Procedure&>(
        theInstruction.parent());
 
    bool firstInstructionInProcedure = 
        (currentProc.startAddress().location() == instructionAddress);
 
    std::string disassembly = "";
 
    /// @todo print all labels associated at address
 
    if (firstInstructionInProcedure) {
        disassembly += "\n" + currentProc.name() + ":\n";
    }
 
    initializeDisassembler();
 
    disassembly +=
        Conversion::toString(instructionAddress) + ":\t\t" +
        disassembler_->disassembleInstruction(theInstruction);
    return disassembly;
}

References currentProgram_, POMDisassembler::disassembleInstruction(), disassembler_, initializeDisassembler(), TTAProgram::Program::instructionAt(), TTAProgram::Address::location(), TTAProgram::Procedure::name(), TTAProgram::Instruction::parent(), TTAProgram::CodeSnippet::startAddress(), and Conversion::toString().

Referenced by DisassembleCommand::execute().

Here is the call graph for this function:

◆ eventHandler()

SimulationEventHandler & SimulatorFrontend::eventHandler ( )

Returns the instance of SimulationEventHandler.

Returns: The instance of SimulationEventHandler.

Todo:: This should probably be an inline function as it used to be in the SimulatorToolbox class...

Definition at line 2260 of file SimulatorFrontend.cc.

                                {
    if (eventHandler_ == NULL) {
        eventHandler_ = new SimulationEventHandler();
    }
    return *eventHandler_;
}

References eventHandler_.

Referenced by BusTracker::BusTracker(), BusTracker::BusTracker(), CompiledSimulation::cycleEnd(), ExecutionTracker::ExecutionTracker(), initializeSimulation(), CompiledSimController::next(), SimulationController::next(), ProcedureTransferTracker::ProcedureTransferTracker(), ProcedureTransferTracker::ProcedureTransferTracker(), ProximRuntimeErrorHandler::ProximRuntimeErrorHandler(), MemoryProxy::read(), SimpleSimulatorFrontend::registerEventListener(), reportSimulatedProgramError(), RFAccessTracker::RFAccessTracker(), CompiledSimController::run(), SimulationController::run(), RuntimeErrorReporter::RuntimeErrorReporter(), CompiledSimController::runUntil(), SimulationController::runUntil(), OTASimulationController::simulateCycle(), SimulationController::simulateCycle(), CompiledSimController::step(), SimulationController::step(), SimpleSimulatorFrontend::unregisterEventListener(), MemoryProxy::write(), BusTracker::~BusTracker(), ExecutionTracker::~ExecutionTracker(), ProcedureTransferTracker::~ProcedureTransferTracker(), ProximRuntimeErrorHandler::~ProximRuntimeErrorHandler(), RFAccessTracker::~RFAccessTracker(), and RuntimeErrorReporter::~RuntimeErrorReporter().

◆ executableInstructionAt()

const ExecutableInstruction & SimulatorFrontend::executableInstructionAt ( InstructionAddress address ) const

Returns reference to the instruction at given address.

Returns: Instruction at the given address.

Definition at line 2208 of file SimulatorFrontend.cc.

                                      {
 
    assert(simCon_ != NULL);
    const InstructionMemory& memory = dynamic_cast<SimulationController*>(
        simCon_)->instructionMemory();
    return memory.instructionAtConst(address);
}

References assert, InstructionMemory::instructionAtConst(), and simCon_.

Referenced by DisasmExecPercentageAttrProvider::moveCellAttr(), DisasmTopCountAttrProvider::moveCellAttr(), DesignSpaceExplorer::simulate(), and DisasmTopCountAttrProvider::updateTopCountTable().

Here is the call graph for this function:

◆ executionTracing()

bool SimulatorFrontend::executionTracing ( ) const

Returns true in case execution tracing is enabled.

Returns: True in case execution tracing is enabled.

Definition at line 1798 of file SimulatorFrontend.cc.

                                          {
    return executionTracing_;
}

References executionTracing_.

Referenced by SimulatorSettingsDialog::onOK(), CompiledSimController::reset(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ findBooleanRegister()

StateData & SimulatorFrontend::findBooleanRegister ( )

Finds the state connected to the boolean register.

Currently boolean register is expected to be the first register in a register file with only one register of width 1.

Todo:: Improve evaluation when the correct way is known.

Returns: State connected to the bool register.

Exceptions

InstanceNotFound If bool register cannot be found.

Definition at line 709 of file SimulatorFrontend.cc.

                                       {
    assert(currentMachine_ != NULL);
 
    Machine::RegisterFileNavigator navigator = 
        currentMachine_->registerFileNavigator();
    
    // go through all the register files in the machine
    for (int i = 0; i < navigator.count(); ++i) {
        RegisterFile* rf = navigator.item(i);
        if (rf->width() == 1 && rf->numberOfRegisters() == 1) {
            RegisterFileState& rfState = 
                machineState().registerFileState(rf->name());
            return rfState.registerState(0);
        }
    }
 
    throw InstanceNotFound(
        __FILE__, __LINE__, __func__, "No boolean register found.");
}

References __func__, assert, TTAMachine::Machine::Navigator< ComponentType >::count(), currentMachine_, TTAMachine::Machine::Navigator< ComponentType >::item(), machineState(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Machine::registerFileNavigator(), MachineState::registerFileState(), RegisterFileState::registerState(), and TTAMachine::BaseRegisterFile::width().

Referenced by state().

Here is the call graph for this function:

◆ findPort()

StateData & SimulatorFrontend::findPort	(	const std::string &	fuName,
		const std::string &	portName
	)

Finds the port using a search string.

The search string supported currently is of format {function unit name].{port name}.

Parameters

fuName	The name of the operation or the function unit.
portName	The name of the operand or the port.

Returns: State connected to the register.

Exceptions

InstanceNotFound If the register cannot be found.

Todo:: Get the list of control operations from GCU instead of hard coding like this

Definition at line 819 of file SimulatorFrontend.cc.

                                                        {
    assert(currentMachine_ != NULL);
 
    const std::string exceptionMessage =
        std::string("No port ") + fuName + "." + portName + " found.";
 
    // first try to fetch the port from GCU
    PortState& foundState = 
        machineState().portState(
            portName, currentMachine_->controlUnit()->name());
    
    if (&foundState != &NullPortState::instance()) {
        return foundState;
    }
 
    /// @todo Get the list of control operations from GCU instead of
    /// hard coding like this
    if (StringTools::ciEqual(fuName, "call") ||
        StringTools::ciEqual(fuName, "jump")) {
 
        // we'll try converting the port name to an operand number
        int operandNumber = -1;
        try {
            operandNumber = Conversion::toInt(portName);
        } catch (const NumberFormatException&) {
            // portName was not a number, we cannot find it in the
            // GCU for sure
            throw InstanceNotFound(
                __FILE__, __LINE__, __func__, exceptionMessage);
        }
 
        // it's a control flow operand, we should get the port from GCU
        return machineState().portState(
            currentMachine_->controlUnit()->operation(fuName)->port(
                operandNumber)->name(), 
            currentMachine_->controlUnit()->name());
    }
 
    return machineState().portState(
        StringTools::stringToLower(portName), 
        StringTools::stringToLower(fuName));
    throw InstanceNotFound(
        __FILE__, __LINE__, __func__, exceptionMessage);
}

References __func__, assert, StringTools::ciEqual(), TTAMachine::Machine::controlUnit(), currentMachine_, NullPortState::instance(), machineState(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::port(), MachineState::portState(), StringTools::stringToLower(), and Conversion::toInt().

Referenced by state().

Here is the call graph for this function:

◆ findRegister()

StateData & SimulatorFrontend::findRegister	(	const std::string &	rfName,
		int	registerIndex
	)

Finds the state connected to a register.

Todo:: Improve evaluation when the parallel assembler syntax is known.

Parameters

rfName	The name of the register file.
registerIndex	Index of the register in the register file.

Returns: State connected to the register.

Exceptions

InstanceNotFound If the register cannot be found.

Definition at line 785 of file SimulatorFrontend.cc.

                                                                          {
    assert(currentMachine_ != NULL);
 
    Machine::RegisterFileNavigator navigator = 
        currentMachine_->registerFileNavigator();
 
    std::string regFileName = rfName;
    if (!navigator.hasItem(rfName)) {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__, 
            "Register file " + rfName + " not found.");
    }
    try {
        return machineState().registerFileState(
            regFileName).registerState(registerIndex);
    } catch (const OutOfRange&) {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__, 
            "Register index out of range");
    }
}

References __func__, assert, currentMachine_, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), machineState(), TTAMachine::Machine::registerFileNavigator(), MachineState::registerFileState(), and RegisterFileState::registerState().

Referenced by SimulationController::registerFileValue().

Here is the call graph for this function:

◆ finishSimulation()

void SimulatorFrontend::finishSimulation ( )

Finishes the currently running simulation.

Flushes any simulation traces etc., but does not unload nor dealloacate the loaded machine and the program. This is to allow restarting the simulation without needing to reinitialize the machine and program.

Definition at line 1538 of file SimulatorFrontend.cc.

                                    {
 
    if (simCon_ == NULL)
        return;
 
    SequenceTools::deleteAllItems(executionTrackers_);
    if (traceDBs_.size() == 0)
        return;
 
    for (int core = 0; core < 1; ++core) {
            // flush the concurrent RF access trace data
        ExecutionTrace* traceDB = traceDBs_.at(core);
        if (rfAccessTracing_) {
            RFAccessTracker* rfAccessTracker = rfAccessTrackers_.at(core);
            assert(rfAccessTracker != NULL);
            const RFAccessTracker::ConcurrentRFAccessIndex& accesses =
                rfAccessTracker->accessDataBase();
            for (RFAccessTracker::ConcurrentRFAccessIndex::const_iterator i = 
                     accesses.begin(); i != accesses.end(); ++i) {
                const RFAccessTracker::ConcurrentRFAccess& access = (*i).first;
                const std::string& rfName = access.get<0>();
                const std::size_t& reads = access.get<2>();
                const std::size_t& writes = access.get<1>();
                const ClockCycleCount& count = (*i).second;
                traceDB->addConcurrentRegisterFileAccessCount(
                    rfName, reads, writes, count);
            }
        }
 
        if (saveUtilizationData_) {
            const UtilizationStats& stats = utilizationStatistics(core);
            // save the function unit operation execution counts
            const TTAMachine::Machine::FunctionUnitNavigator& fuNav = 
                machine().functionUnitNavigator();
            for (int i = 0; i <= fuNav.count(); ++i) {
                TTAMachine::FunctionUnit* fu = NULL;
                if (i < fuNav.count())
                    fu = fuNav.item(i);
                else
                    fu = machine().controlUnit();
                assert(fu != NULL);
                const ClockCycleCount totalTriggersOfFU = 
                    stats.triggerCount(fu->name());
 
                if (totalTriggersOfFU == 0)
                    continue;
 
                for (int j = 0; j < fu->operationCount(); ++j) {
                    const TTAMachine::HWOperation* op = fu->operation(j);
                    assert(op != NULL);
                    const std::string operationUpper = 
                        StringTools::stringToUpper(op->name());
 
                    const ClockCycleCount executions = 
                        stats.operationExecutions(fu->name(), operationUpper);
 
                    if (executions == 0) 
                        continue;
 
                    traceDB->addFunctionUnitOperationTriggerCount(
                        fu->name(), operationUpper, executions);
                }
            }
 
 
            // save the socket write counts
            const TTAMachine::Machine::SocketNavigator& socketNav = 
                machine().socketNavigator();
            for (int i = 0; i < socketNav.count(); ++i) {
 
                TTAMachine::Socket* socket = socketNav.item(i);
                assert(socket != NULL);
                const ClockCycleCount writes = 
                    stats.socketWrites(socket->name());
                
                traceDB->addSocketWriteCount(socket->name(), writes);
            }            
        
            // save the bus write counts
            const TTAMachine::Machine::BusNavigator& busNav = 
                machine().busNavigator();
            for (int i = 0; i < busNav.count(); ++i) {
                TTAMachine::Bus* bus = busNav.item(i);
                assert(bus != NULL);
                const ClockCycleCount writes = stats.busWrites(bus->name());
                
                traceDB->addBusWriteCount(bus->name(), writes);
            }
 
            // save the register access stats
            const TTAMachine::Machine::RegisterFileNavigator& rfNav = 
                machine().registerFileNavigator();
            for (int i = 0; i < rfNav.count(); ++i) {
                TTAMachine::RegisterFile* rf = rfNav.item(i);
                assert(rf != NULL);
 
                int maxRegs = 0;
                maxRegs = rf->numberOfRegisters();
                for (int reg = 0; reg < maxRegs; ++reg) {
                    ClockCycleCount reads = 
                        stats.registerReads(rf->name(), reg);
                    ClockCycleCount writes = 
                        stats.registerWrites(rf->name(), reg);
                    traceDB->addRegisterAccessCount(
                        rf->name(), reg, reads, writes);
                }
            }            
            
        }
 
        if (saveProfileData_) {
            
            // save the instruction execution counts (profile data)
            const InstructionMemory& instructions = 
                dynamic_cast<SimulationController*>(simCon_)->
                instructionMemory(core);
 
            InstructionAddress firstAddress = 
                InstructionAddress(currentProgram_->startAddress().location());
            InstructionAddress lastAddress = 
                InstructionAddress(
                    currentProgram_->lastInstruction().address().location());
 
            for (InstructionAddress a = firstAddress; a <= lastAddress; ++a) {
                traceDB->addInstructionExecutionCount(
                    a, instructions.instructionAtConst(a).executionCount());
            }
        }
 
        if (procedureTransferTracing_ || saveProfileData_) {
            // save the start addresses of procedures in order to provide
            // possibility for more readable query outputs with traces
            // that include procedure data in them
            for (int i = 0; i < currentProgram_->procedureCount(); ++i) {
                const Procedure& procedure = currentProgram_->procedure(i);
                traceDB->addProcedureAddressRange(
                    procedure.startAddress().location(), 
                    procedure.endAddress().location() - 1, procedure.name());
            }
        }
    
        traceDB->setSimulatedCycleCount(cycleCount());
        
        if (traceDBOwned_[core]) {
            delete traceDBs_[core];
            traceDBs_[core]=NULL;
        }
    }
 
    SequenceTools::deleteAllItems(busTrackers_);
    SequenceTools::deleteAllItems(rfAccessTrackers_);
    SequenceTools::deleteAllItems(procedureTransferTrackers_);
    SequenceTools::deleteAllItems(utilizationStats_);
    SequenceTools::deleteAllItems(callPathTrackers_);
}

References RFAccessTracker::accessDataBase(), ExecutionTrace::addBusWriteCount(), ExecutionTrace::addConcurrentRegisterFileAccessCount(), ExecutionTrace::addFunctionUnitOperationTriggerCount(), ExecutionTrace::addInstructionExecutionCount(), ExecutionTrace::addProcedureAddressRange(), ExecutionTrace::addRegisterAccessCount(), TTAProgram::Instruction::address(), ExecutionTrace::addSocketWriteCount(), assert, TTAMachine::Machine::busNavigator(), busTrackers_, UtilizationStats::busWrites(), callPathTrackers_, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), currentProgram_, cycleCount(), SequenceTools::deleteAllItems(), TTAProgram::CodeSnippet::endAddress(), ExecutableInstruction::executionCount(), executionTrackers_, TTAMachine::Machine::functionUnitNavigator(), InstructionMemory::instructionAtConst(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAProgram::Program::lastInstruction(), TTAProgram::Address::location(), machine(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAProgram::Procedure::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), UtilizationStats::operationExecutions(), TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), procedureTransferTracing_, procedureTransferTrackers_, TTAMachine::Machine::registerFileNavigator(), UtilizationStats::registerReads(), UtilizationStats::registerWrites(), rfAccessTracing_, rfAccessTracker(), rfAccessTrackers_, saveProfileData_, saveUtilizationData_, ExecutionTrace::setSimulatedCycleCount(), simCon_, TTAMachine::Machine::socketNavigator(), UtilizationStats::socketWrites(), TTAProgram::CodeSnippet::startAddress(), TTAProgram::Program::startAddress(), StringTools::stringToUpper(), traceDBOwned_, traceDBs_, UtilizationStats::triggerCount(), utilizationStatistics(), and utilizationStats_.

Referenced by ProximSimulationThread::finishSimulation(), killSimulation(), loadMachine(), loadMachine(), and ~SimulatorFrontend().

Here is the call graph for this function:

◆ forceTraceDBFileName()

void SimulatorFrontend::forceTraceDBFileName ( const std::string & fileName )

inline

Definition at line 177 of file SimulatorFrontend.hh.

                                                         {
        forcedTraceDBFileName_ = fileName;
    }

References forcedTraceDBFileName_.

Referenced by DesignSpaceExplorer::simulate().

◆ FUPortValue()

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

virtual

Returns the current value of a FU port

Parameters

fuName	name of the function unit
portName	name of the FU port

Returns: Current value of a FU port

Definition at line 767 of file SimulatorFrontend.cc.

                                                        {
    assert(currentMachine_ != NULL);
 
    return simCon_->FUPortValue(fuName, portName);
}

References assert, currentMachine_, TTASimulationController::FUPortValue(), and simCon_.

Referenced by compareState(), and InfoPortsCommand::execute().

Here is the call graph for this function:

◆ fuResourceConflictDetection()

bool SimulatorFrontend::fuResourceConflictDetection ( ) const

Returns true if FU resource conflict detection is on, false if not.

Returns: Returns current fu conflict detection setting.

Definition at line 2032 of file SimulatorFrontend.cc.

                                                      {
    return fuResourceConflictDetection_;
}

References fuResourceConflictDetection_.

Referenced by SimulatorSettingsDialog::onOK(), CompiledSimController::reset(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ hasSimulationEnded()

bool SimulatorFrontend::hasSimulationEnded ( ) const

Returns true if the simulation has ended, that is, the last instruction have been executed.

Returns: True if simulation has ended.

Definition at line 1283 of file SimulatorFrontend.cc.

                                            {
    return (simCon_ != NULL &&
            simCon_->state() == SimulationController::STA_FINISHED);
}

References simCon_, TTASimulationController::STA_FINISHED, and TTASimulationController::state().

Referenced by ProximKillCmd::isEnabled(), SimpleSimulatorFrontend::isFinished(), programLocationDescription(), ProximBreakpointWindow::ProximBreakpointWindow(), ProximPortWindow::ProximPortWindow(), ProximRegisterWindow::ProximRegisterWindow(), ProximBreakpointWindow::refreshStopPoints(), SimpleSimulatorFrontend::step(), tandemSimulate(), and ProximMainFrame::updateSimulationStatus().

Here is the call graph for this function:

◆ hasStopReason()

bool SimulatorFrontend::hasStopReason ( StopReason reason ) const

protected

Helper function which tells whether simulation has stopped because of the given reason.

Returns: True if the given reason was one of the reasons the simulation was stopped.

Definition at line 1369 of file SimulatorFrontend.cc.

                                                        {
 
    if (simCon_ == NULL) {
        return false;
    }
 
    for (size_t i = 0; i < stopReasonCount(); ++i) {
        if (stopReason(i) == reason) {
            return true;
        }
    }
    return false;
}

References simCon_, stopReason(), and stopReasonCount().

Referenced by stoppedByUser().

Here is the call graph for this function:

◆ immediateUnitRegisterValue()

SimValue SimulatorFrontend::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

Definition at line 752 of file SimulatorFrontend.cc.

                                        {
    assert(currentMachine_ != NULL);
 
    return simCon_->immediateUnitRegisterValue(iuName, index);
}

References assert, currentMachine_, TTASimulationController::immediateUnitRegisterValue(), and simCon_.

Here is the call graph for this function:

◆ initializeDataMemories()

void SimulatorFrontend::initializeDataMemories ( const TTAMachine::AddressSpace * onlyOne = NULL )

Resets and writes initial data to the memory system stored in simulation controller from loaded TPEF.

Parameters

onlyOne initialize the data memory of the given address space only. If onlyOne is NULL, tries to intialize all data memories.

Definition at line 440 of file SimulatorFrontend.cc.

                                           {
 
    // we need tpef to get the initialization data and simcon to fetch
    // the memory system from
    if (currentProgram_ == NULL || simCon_ == NULL)
        return;
 
    memorySystem().resetAllMemories();
    if (zeroFillMemoriesOnReset_)
        memorySystem().fillAllMemoriesWithZero();
 
    const int dataSections = currentProgram_->dataMemoryCount();
 
    if (dataSections < 0) 
        return;
 
    for (int core = 0; core < 1; ++core) {
        // data memory initialization
        for (int i = 0; i < dataSections; ++i) {
 
            // initialize the data memory
            const DataMemory& data = currentProgram_->dataMemory(i);
            const std::string addressSpaceName = 
                data.addressSpace().name();
 
            try {
                MemorySystem::MemoryPtr dataMemory =
                    simCon_->memorySystem(core).memory(addressSpaceName);
 
                const AddressSpace& addressSpace =
                    simCon_->memorySystem(core).addressSpace(
                        addressSpaceName);
 
                if ((onlyOne != NULL && &addressSpace != onlyOne) ||
                    (addressSpace.isShared() && core != 0)) continue;
 
                for (int d = 0; d < data.dataDefinitionCount(); ++d) {
                    const DataDefinition& def = data.dataDefinition(d);
                    if (!def.isInitialized()) {
                        continue;
                    }
 
                    Address startAddress = def.startAddress();
                    // Check that the defined data is inside the address
                    // space.
                    if (def.startAddress().space().name() !=
                        addressSpaceName ||
                        startAddress.location() < addressSpace.start() ||
                        (startAddress.location() + def.size() - 1)
                        > addressSpace.end()) {
 
                        throw IllegalProgram(
                            __FILE__, __LINE__, __func__,
                            std::string("Initialization data for ") +
                            addressSpace.name() +
                            " is out of address space bounds.");
                    } 
                    for (int m = 0; m < def.size(); m++) {
                        dataMemory->write(
                            startAddress.location() + m, def.MAU(m));
                    }
                }
 
            } catch (const InstanceNotFound& inf) {
                std::string errorMsg = 
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_INPUT_FILE).str();
                if (inf.errorMessage() != "")
                    errorMsg += " Reason: " + inf.errorMessage();
                delete tpef_;
                tpef_ = NULL;
                delete simCon_;
                simCon_ = NULL;
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, errorMsg);
            }
        }
    }
}

References __func__, TTAProgram::DataMemory::addressSpace(), MemorySystem::addressSpace(), currentProgram_, TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), TTAProgram::Program::dataMemory(), TTAProgram::Program::dataMemoryCount(), TTAMachine::AddressSpace::end(), Exception::errorMessage(), MemorySystem::fillAllMemoriesWithZero(), TTAProgram::DataDefinition::isInitialized(), TTAMachine::AddressSpace::isShared(), TTAProgram::Address::location(), TTAProgram::DataDefinition::MAU(), MemorySystem::memory(), memorySystem(), TTASimulationController::memorySystem(), TTAMachine::Component::name(), MemorySystem::resetAllMemories(), simCon_, TTAProgram::DataDefinition::size(), TTAProgram::Address::space(), TTAMachine::AddressSpace::start(), TTAProgram::DataDefinition::startAddress(), Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), tpef_, Texts::TXT_ILLEGAL_INPUT_FILE, and zeroFillMemoriesOnReset_.

Referenced by SimpleSimulatorFrontend::initializeDataMemories(), killSimulation(), loadProgram(), and loadProgram().

Here is the call graph for this function:

◆ initializeDisassembler()

void SimulatorFrontend::initializeDisassembler ( ) const

protected

Initializes the disassembler.

Creates a new POMDisassembler for the loaded program if it was not loaded already.

Definition at line 1152 of file SimulatorFrontend.cc.

                                                {
 
    if (disassembler_ != NULL || currentProgram_ == NULL) {
        // already initialized or no program to disassemble
        return;
    }
    disassembler_ =
        POMDisassembler::disassembler(*currentMachine_, *currentProgram_);
}

References currentMachine_, currentProgram_, POMDisassembler::disassembler(), and disassembler_.

Referenced by disassembleInstruction(), and programLocationDescription().

Here is the call graph for this function:

◆ initializeMemorySystem()

void SimulatorFrontend::initializeMemorySystem ( )

protected

Initializes the memory system according to the address spaces in the loaded machine.

Definition at line 1699 of file SimulatorFrontend.cc.

                                          {
 
    assert (currentMachine_ != NULL);
    const Machine& machine = *currentMachine_;
    MemorySystem* firstMemorySystem = NULL;
 
    for (int core = 0; core < 1; ++core) {
 
        MemorySystem* memorySystem_ = new MemorySystem(machine);
 
        // create a memory system for the loaded machine by going
        // through all address spaces in the machine and create a memory model
        // for each of them, except for the one of GCU's
        Machine::AddressSpaceNavigator nav = machine.addressSpaceNavigator();
 
        std::string controlUnitASName = "";
        if (machine.controlUnit() != NULL &&
            machine.controlUnit()->hasAddressSpace()) {
            controlUnitASName = machine.controlUnit()->addressSpace()->name();
        }
 
        for (int i = 0; i < nav.count(); ++i) {
            const AddressSpace& space = *nav.item(i);
 
            if (space.name() == controlUnitASName)
                continue;
 
            const bool shared = space.isShared();
 
            MemorySystem::MemoryPtr mem;
 
            if (shared && firstMemorySystem != NULL) {
                // the memory model should have been created previously
                // because all cores share the same memory
                mem = firstMemorySystem->memory(space.name());
                assert(mem != NULL);
            } else {
                switch (currentBackend_) {
                case SIM_COMPILED:
                    mem = MemorySystem::MemoryPtr(
                        new DirectAccessMemory(
                            space.start(), space.end(), space.width(), machine.isLittleEndian()));
                    break;
                case SIM_OTA:
                case SIM_NORMAL:
                    mem = MemorySystem::MemoryPtr(
                        new IdealSRAM(
                            space.start(), space.end(), space.width(), machine.isLittleEndian()));
                    break;
                case SIM_REMOTE:
                case SIM_CUSTOM:
                    mem = MemorySystem::MemoryPtr(
                        new RemoteMemory( space, machine.isLittleEndian()));
                    
                    break;
                default:            
                    throw Exception(
                        __FILE__, __LINE__, __func__,
                        "Internal error: memory model not specified");
                }
                // If memory tracking is enabled, memories are wrapped by
                // a proxy that tracks memory access.
                if (memoryAccessTracking_) {
                    mem = MemorySystem::MemoryPtr(
                        new MemoryProxy(*this, mem.get()));
                }
            }
            memorySystem_->addAddressSpace(space, mem, shared);
        }
        memorySystems_.push_back(memorySystem_);
        if (firstMemorySystem == NULL)
            firstMemorySystem = memorySystem_;
    }
}

References __func__, MemorySystem::addAddressSpace(), TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::addressSpaceNavigator(), assert, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), currentBackend_, currentMachine_, TTAMachine::AddressSpace::end(), TTAMachine::FunctionUnit::hasAddressSpace(), TTAMachine::Machine::isLittleEndian(), TTAMachine::AddressSpace::isShared(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), MemorySystem::memory(), memoryAccessTracking_, memorySystems_, TTAMachine::Component::name(), SIM_COMPILED, SIM_CUSTOM, SIM_NORMAL, SIM_OTA, SIM_REMOTE, TTAMachine::AddressSpace::start(), and TTAMachine::AddressSpace::width().

Referenced by loadMachine(), and loadMachine().

Here is the call graph for this function:

◆ initializeSimulation()

void SimulatorFrontend::initializeSimulation ( )

protectedvirtual

Initializes a new simulation.

Creates the SimulationController and initializes the program counter to point to the first executed instruction. Assumes the simulation is not running and the possible old simulation data is freed.

Exceptions

Exception There can be several types of exceptions thrown when building the simulation machine model or the preprocessed program.

Definition at line 657 of file SimulatorFrontend.cc.

                                        {
 
    delete simCon_;
    simCon_ = NULL;
    switch(currentBackend_) {
    case SIM_REMOTE:    
        simCon_ = 
            new TCEDBGController( 
                *this, *currentMachine_, *currentProgram_);
        setControllerForMemories(dynamic_cast<RemoteController*>(simCon_));
        break;
    case SIM_CUSTOM:
        simCon_ = 
            new CustomDBGController(
                *this, *currentMachine_, *currentProgram_);
        setControllerForMemories(dynamic_cast<RemoteController*>(simCon_));
        break;
    case SIM_COMPILED:
        simCon_ =
            new CompiledSimController(
                *this, *currentMachine_, *currentProgram_, 
                leaveCompiledDirty_);
        break;
    case SIM_OTA:
        simCon_ =
            new OTASimulationController(
                *this, *currentMachine_, *currentProgram_);
        break;
    case SIM_NORMAL:
    default:
        simCon_ = 
            new SimulationController(
                *this, *currentMachine_, *currentProgram_, 
                fuResourceConflictDetection_, detailedSimulation_);
    }
        
    delete stopPointManager_;
    stopPointManager_ = new StopPointManager(*simCon_, eventHandler());
}

References currentBackend_, currentMachine_, currentProgram_, detailedSimulation_, eventHandler(), fuResourceConflictDetection_, leaveCompiledDirty_, setControllerForMemories(), SIM_COMPILED, SIM_CUSTOM, SIM_NORMAL, SIM_OTA, SIM_REMOTE, simCon_, and stopPointManager_.

Referenced by loadProgram(), and loadProgram().

Here is the call graph for this function:

◆ initializeTracing()

void SimulatorFrontend::initializeTracing ( )

protected

Initializes the trace database(s).

In case no traces are enabled, this method does nothing. Making multiple calls to this method is not harmful.

Exceptions

IOException In case trace database file could not be accessed.

Note: May throw IOException.

Definition at line 1414 of file SimulatorFrontend.cc.

                                     {
    if (executionTracing_ || rfAccessTracing_ || 
        procedureTransferTracing_ || saveProfileData_ || 
        saveUtilizationData_ || busTracing_) {
 
        int coreCount = 1;
        
        traceDBs_.resize(coreCount, NULL);
        traceDBOwned_.resize(coreCount, true);
        executionTrackers_.resize(coreCount, NULL);
        rfAccessTrackers_.resize(coreCount, NULL);
        procedureTransferTrackers_.resize(coreCount, NULL);
        busTrackers_.resize(coreCount, NULL);
        for (int core = 0; core < 1; ++core) {
 
            ExecutionTrace* traceDB = traceDBs_.at(core);
            // initialize the data base for each core
            if (traceDB == NULL) {
                TCEString traceFileName;
                if (forcedTraceDBFileName_ == "") {
                    // generate the file name
 
                    TCEString coreMarker = "";
                    if (coreCount > 1) {
                        coreMarker << ".core";
                        coreMarker << core;
                    }
                    TCEString fname = programFileName_;
                    if (coreCount > 1) {
                        fname << ".core";
                        fname << core;                        
                    }
                    fname << ".trace";
                    
                    int runningNumber = 1;
                    while (FileSystem::fileExists(fname)) {
                        // append ".n" where n is a running number, in case the
                        // file exists
                        fname = programFileName_;
                        if (coreCount > 1) {
                            fname << ".core";
                            fname << core;                        
                        }
                        fname << ".trace";
                        fname << "." << runningNumber;
                        ++runningNumber;
                    }
                    traceFileName = fname;
                } else {
                    traceFileName = forcedTraceDBFileName_;
                }
 
                /// @note May throw IOException.
                traceDB = ExecutionTrace::open(traceFileName);
                traceDBs_[core] = traceDB;
                traceDBOwned_[core] = true;
            }
 
            ExecutionTracker* executionTracker = executionTrackers_.at(core);
            if (executionTracing_ && executionTracker == NULL) {
                executionTracker = 
                    new ExecutionTracker(*simCon_, *traceDB);
                executionTrackers_[core] = executionTracker;
            }
 
            if (rfAccessTracing_) {
                rfAccessTrackers_[core] = 
                    new RFAccessTracker(
                        *this, 
                        dynamic_cast<SimulationController*>(
                            simCon_)->instructionMemory(core));
            }
            if (procedureTransferTracing_) {
                procedureTransferTrackers_[core] = 
                    new ProcedureTransferTracker(*this, *traceDB);
            }
 
            if (busTracing_) {
                // generate the file name
                TCEString busTraceFileName = programFileName_; 
                if (coreCount > 1)
                    busTraceFileName << ".core" << core;
 
                busTraceFileName << ".bustrace";
 
                int runningNumber = 1;
                while (FileSystem::fileExists(busTraceFileName)) {
                    // append ".n" where n is a running number, in case the
                    // file exists
 
                    busTraceFileName = programFileName_; 
                    if (coreCount > 1)
                        busTraceFileName << ".core" << core;
 
                    busTraceFileName << ".bustrace";
                    busTraceFileName << "." << runningNumber;
                    ++runningNumber;
                } 
        
                std::ostream* busTraceStream =
                    new std::ofstream(busTraceFileName.c_str(), std::ios::out);
                if (!busTraceStream) {
                    std::string errorMessage =
                        "Unable to open bus trace file " + busTraceFileName +
                        " for writing.";
                    throw IOException(
                        __FILE__, __LINE__, __func__, errorMessage);
                }
                busTrackers_[core] = 
                    new BusTracker(*this, busTraceStream);
            }
        }
    }
    setupCallHistoryTracking();
}

References __func__, busTracing_, busTrackers_, executionTracing_, executionTrackers_, FileSystem::fileExists(), forcedTraceDBFileName_, ExecutionTrace::open(), procedureTransferTracing_, procedureTransferTrackers_, programFileName_, rfAccessTracing_, rfAccessTrackers_, saveProfileData_, saveUtilizationData_, setupCallHistoryTracking(), simCon_, traceDBOwned_, and traceDBs_.

Referenced by killSimulation(), loadProgram(), and loadProgram().

Here is the call graph for this function:

◆ isCompiledSimulation()

bool SimulatorFrontend::isCompiledSimulation ( ) const

Returns true if the current simulation engine uses compiled simulation

Returns: true if the current simulation engine uses compiled simulation

Definition at line 1295 of file SimulatorFrontend.cc.

                                              {
    return currentBackend_ == SIM_COMPILED;
}

References currentBackend_, and SIM_COMPILED.

Referenced by loadMachine(), loadMachine(), loadProgram(), SimulatorCLI::SimulatorCLI(), and utilizationStatistics().

◆ isCustomDebugger()

bool SimulatorFrontend::isCustomDebugger ( ) const

Check if we are currently using a custom debugger. This returns true if we are attached to a FPGA or an ASIC with on-circuit debug hardware.

Returns: true if we are using a custom debugger target.

Definition at line 1317 of file SimulatorFrontend.cc.

                                          {
    return currentBackend_ == SIM_CUSTOM;
}

References currentBackend_, and SIM_CUSTOM.

◆ isMachineLoaded()

bool SimulatorFrontend::isMachineLoaded ( ) const

Returns true if a machine has been loaded for the simulation

Returns: True if machine has been loaded.

Definition at line 1250 of file SimulatorFrontend.cc.

                                         {
    return (currentMachine_ != NULL);
}

References currentMachine_.

Referenced by setupCallHistoryTracking().

◆ isProgramLoaded()

bool SimulatorFrontend::isProgramLoaded ( ) const

Returns true if the simulation has been initialized with a program successfully.

Returns: True if simulation has been initialized.

Definition at line 1240 of file SimulatorFrontend.cc.

                                         {
    return (simCon_ != NULL && currentProgram_ != NULL);
}

References currentProgram_, and simCon_.

Referenced by DisasmExecPercentageAttrProvider::moveCellAttr().

◆ isSimulationInitialized()

bool SimulatorFrontend::isSimulationInitialized ( ) const

Returns true if the simulation initialized and ready to run.

Returns: True if simulation is initialized.

Definition at line 1228 of file SimulatorFrontend.cc.

                                                 {
    return (simCon_ != NULL && 
            simCon_->state() == SimulationController::STA_INITIALIZED);
}

References simCon_, TTASimulationController::STA_INITIALIZED, and TTASimulationController::state().

Referenced by ProximFindCmd::Do(), ProximNextICmd::isEnabled(), ProximRunCmd::isEnabled(), ProximStepICmd::isEnabled(), SimpleSimulatorFrontend::isInitialized(), ProximBreakpointWindow::onAddBreakpoint(), ProximBreakpointWindow::onAddWatch(), ProximBreakpointWindow::ProximBreakpointWindow(), ProximPortWindow::ProximPortWindow(), ProximRegisterWindow::ProximRegisterWindow(), ProximBreakpointWindow::refreshStopPoints(), tandemSimulate(), and ProximMainFrame::updateSimulationStatus().

Here is the call graph for this function:

◆ isSimulationRunning()

bool SimulatorFrontend::isSimulationRunning ( ) const

Returns true if the simulation is running.

Returns: True if simulation running.

Definition at line 1260 of file SimulatorFrontend.cc.

                                             {
    return (simCon_ != NULL &&
            simCon_->state() == SimulationController::STA_RUNNING);
}

References simCon_, TTASimulationController::STA_RUNNING, and TTASimulationController::state().

Referenced by ProximFindCmd::Do(), ProximQuitCmd::Do(), ProximSimulationThread::finishSimulation(), ProximSimulationThread::isBusy(), ProximKillCmd::isEnabled(), SimpleSimulatorFrontend::isRunning(), ProximSimulationThread::killSimulation(), ProximBreakpointWindow::onAddBreakpoint(), ProximBreakpointWindow::onAddWatch(), ProximStopDialog::onUpdate(), prepareToStop(), ProximBreakpointWindow::ProximBreakpointWindow(), ProximBreakpointWindow::refreshStopPoints(), TracedSimulatorFrontend::step(), and ProximMainFrame::updateSimulationStatus().

Here is the call graph for this function:

◆ isSimulationStopped()

bool SimulatorFrontend::isSimulationStopped ( ) const

Returns true if the simulation is stopped.

Returns: True if simulation stopped.

Definition at line 1271 of file SimulatorFrontend.cc.

                                             {
    return (simCon_ != NULL &&
            simCon_->state() == SimulationController::STA_STOPPED);
}

References simCon_, TTASimulationController::STA_STOPPED, and TTASimulationController::state().

Referenced by ProximFindCmd::Do(), ProximQuitCmd::Do(), ProximKillCmd::isEnabled(), ProximNextICmd::isEnabled(), ProximResumeCmd::isEnabled(), ProximStepICmd::isEnabled(), SimpleSimulatorFrontend::isStopped(), ProximBreakpointWindow::onAddBreakpoint(), ProximBreakpointWindow::onAddWatch(), ProximBreakpointWindow::ProximBreakpointWindow(), ProximPortWindow::ProximPortWindow(), ProximRegisterWindow::ProximRegisterWindow(), ProximBreakpointWindow::refreshStopPoints(), ProximSimulationThread::requestStop(), and ProximMainFrame::updateSimulationStatus().

Here is the call graph for this function:

◆ isTCEDebugger()

bool SimulatorFrontend::isTCEDebugger ( ) const

Check if we are currently using a TCE built-in debugger. This returns true if we are attached to a FPGA or an ASIC with on-circuit debug hardware.

Returns: true if we are using a TCE debug target.

Definition at line 1306 of file SimulatorFrontend.cc.

                                       {
    return currentBackend_ == SIM_REMOTE;
}

References currentBackend_, and SIM_REMOTE.

◆ killSimulation()

void SimulatorFrontend::killSimulation ( )

virtual

Kills the currently running simulation.

Allows restarting the simulation with the loaded machine and program. Flushes data collected during simulation to the trace file, if tracing is enabled, and reinitializes everything that needs to be reinitialized, such as the data memory initial values.

Reimplemented in TracedSimulatorFrontend.

Definition at line 1784 of file SimulatorFrontend.cc.

                                  {
    finishSimulation();
    simCon_->reset();
    initializeTracing();
    initializeDataMemories();
    lastRunCycleCount_ = 0;
}

References finishSimulation(), initializeDataMemories(), initializeTracing(), lastRunCycleCount_, TTASimulationController::reset(), and simCon_.

Referenced by KillCommand::execute(), TracedSimulatorFrontend::killSimulation(), and DesignSpaceExplorer::simulate().

Here is the call graph for this function:

◆ lastExecInstruction()

const ExecutableInstruction & SimulatorFrontend::lastExecInstruction ( ) const

Returns a reference to the last executed instruction.

Returns: Last instruction executed.

Definition at line 2194 of file SimulatorFrontend.cc.

                                             {
    assert(simCon_ != NULL);
    const InstructionMemory& memory = dynamic_cast<SimulationController*>(
        simCon_)->instructionMemory();
    return memory.instructionAtConst(lastExecutedInstruction());
}

References assert, InstructionMemory::instructionAtConst(), lastExecutedInstruction(), and simCon_.

Referenced by ProximMachineStateWindow::addMoves().

Here is the call graph for this function:

◆ lastExecutedInstruction()

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

virtual

Returns the address of the last executed instruction.

Parameters

coreId Look at the given processor core. If -1, the currently selected core will be used.

Returns: Address of the last executed instruction.

Definition at line 1182 of file SimulatorFrontend.cc.

                                                           {
    assert(simCon_ != NULL);
    return simCon_->lastExecutedInstruction(coreId);
}

References assert, TTASimulationController::lastExecutedInstruction(), and simCon_.

Referenced by ProximMachineStateWindow::addMoves(), ProcedureTransferTracker::handleEvent(), RuntimeErrorReporter::handleEvent(), RFAccessTracker::handleEvent(), and lastExecInstruction().

Here is the call graph for this function:

◆ lastRunCycleCount()

CycleCount SimulatorFrontend::lastRunCycleCount ( ) const

Returns the count of cycles simulated in the last simulation run.

For example, if run was executed and then interrupted by the user or a breakpoint, returns how long the run was in simulation cycles.

Returns: The cycle count.

Definition at line 2276 of file SimulatorFrontend.cc.

                                           {
    return lastRunCycleCount_;
}

References lastRunCycleCount_.

Referenced by SimControlLanguageCommand::printSimulationTime().

◆ lastRunTime()

double SimulatorFrontend::lastRunTime ( ) const

Returns the runtime of the last simulation session in seconds.

For example, if run was executed and then interrupted by the user or a breakpoint, returns how long the run was in wall clock time.

Returns: Simulation wall clock time in seconds.

Definition at line 2289 of file SimulatorFrontend.cc.

                                     {
    return lastRunTime_;
}

References lastRunTime_.

Referenced by SimControlLanguageCommand::printSimulationTime().

◆ lastTraceDB()

ExecutionTrace * SimulatorFrontend::lastTraceDB ( int core = -1 )

Returns the last produced execution trace database.

The ownership of the TraceDB is transferred to the caller. That is, it should delete it after use.

Returns: The traceDB instance.

Definition at line 2243 of file SimulatorFrontend.cc.

                                       {
    if (core == -1) 
        core = selectedCore();
    
    ExecutionTrace* last = traceDBs_[core];
    traceDBOwned_[core] = false;
    return last;
}

References selectedCore(), traceDBOwned_, and traceDBs_.

Referenced by DesignSpaceExplorer::simulate().

Here is the call graph for this function:

◆ loadMachine() [1/2]

void SimulatorFrontend::loadMachine ( const std::string & fileName )

virtual

Loads a new machine to be simulated from an ADF file.

The loaded machine will be owned by SimulatorFrontend and will be deleted by it when not needed anymore.

Parameters

fileName The name of the ADF file to be loaded.

Exceptions

FileNotFound	If the file cannot be found.
SimulationStillRunning	If an old simulation is still running.
IllegalMachine	If the ADF was erroneus.

Reimplemented in TracedSimulatorFrontend.

Definition at line 534 of file SimulatorFrontend.cc.

                                                        {
    SimulatorTextGenerator& textGen = SimulatorToolbox::textGenerator();
 
    if (!FileSystem::fileExists(fileName)) {
        throw FileNotFound(
            __FILE__, __LINE__, __func__, 
            (textGen.text(Texts::TXT_FILE_X_NOT_FOUND) % fileName).str());
    }
 
    if (!FileSystem::fileIsReadable(fileName)) {
        throw IOException(__FILE__, __LINE__, __func__, "File not readable.");
    }
 
    ADFSerializer serializer;
    serializer.setSourceFile(fileName);
 
    const Machine* oldMachine = currentMachine_;
    try {
        currentMachine_ = serializer.readMachine(); 
    } catch (const Exception& e) {
        IllegalMachine ime(
            __FILE__, __LINE__, __func__, 
            textGen.text(Texts::TXT_ILLEGAL_ADF_FILE).str());
        ime.setCause(e);
        throw ime;
    }
    if (machineOwnedByFrontend_) {
        delete oldMachine;
        oldMachine = NULL;
    }
    machineOwnedByFrontend_ = true;
 
    finishSimulation();
    if (programOwnedByFrontend_) {
        delete currentProgram_;
        currentProgram_ = NULL;
    }
    delete simCon_;
    simCon_ = NULL;
 
    // compiled sim does not handle long guard latencies correctly.
    // remove when fixed.
    if (isCompiledSimulation() && 
        (currentMachine_->controlUnit()->globalGuardLatency() > 1 ||
         currentMachine_->is64bit())) {
        setCompiledSimulation(false);
        // TODO: warn about this, when the warning can be ignored
        // by tests.
    }
    SequenceTools::deleteAllItems(memorySystems_);
    initializeMemorySystem();
}

References __func__, TTAMachine::Machine::controlUnit(), currentMachine_, currentProgram_, SequenceTools::deleteAllItems(), FileSystem::fileExists(), FileSystem::fileIsReadable(), finishSimulation(), TTAMachine::ControlUnit::globalGuardLatency(), initializeMemorySystem(), TTAMachine::Machine::is64bit(), isCompiledSimulation(), machineOwnedByFrontend_, memorySystems_, programOwnedByFrontend_, ADFSerializer::readMachine(), Exception::setCause(), setCompiledSimulation(), XMLSerializer::setSourceFile(), simCon_, Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), Texts::TXT_FILE_X_NOT_FOUND, and Texts::TXT_ILLEGAL_ADF_FILE.

Referenced by MachCommand::execute(), TracedSimulatorFrontend::loadMachine(), loadProcessorConfiguration(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), DesignSpaceExplorer::simulate(), and tandemSimulate().

Here is the call graph for this function:

◆ loadMachine() [2/2]

void SimulatorFrontend::loadMachine ( const TTAMachine::Machine & machine )

Loads a new machine to be simulated.

The loaded machine is not owned by SimulatorFrontend and thus won't be deleted by it when not needed anymore.

Parameters

program The machine to be loaded.

Definition at line 227 of file SimulatorFrontend.cc.

                                                     {
    if (currentMachine_ != NULL && machineOwnedByFrontend_) {
        delete currentMachine_;
        currentMachine_ = NULL;
    }
    currentMachine_ = &machine;
    machineOwnedByFrontend_ = false;
 
    finishSimulation();
    if (programOwnedByFrontend_) {
        delete currentProgram_;
        currentProgram_ = NULL;
    }
    delete simCon_;
    simCon_ = NULL;
 
    // compiled sim does not handle long guard latencies nor 64 bits correctly
    // remove when fixed.
    if (isCompiledSimulation() &&
        (machine.controlUnit()->globalGuardLatency() > 1 ||
         machine.is64bit())) {
        setCompiledSimulation(false);
        // TODO: warn about this, when the warning can be ignored
        // by tests.
    }
    SequenceTools::deleteAllItems(memorySystems_);
    initializeMemorySystem();
}

References TTAMachine::Machine::controlUnit(), currentMachine_, currentProgram_, SequenceTools::deleteAllItems(), finishSimulation(), TTAMachine::ControlUnit::globalGuardLatency(), initializeMemorySystem(), TTAMachine::Machine::is64bit(), isCompiledSimulation(), machine(), machineOwnedByFrontend_, memorySystems_, programOwnedByFrontend_, setCompiledSimulation(), and simCon_.

Here is the call graph for this function:

◆ loadProcessorConfiguration()

void SimulatorFrontend::loadProcessorConfiguration ( const std::string & fileName )

Loads a new machine to be simulated from a processor configuration file.

The loaded machine will be owned by SimulatorFrontend and thus be deleted by it when not needed anymore.

Parameters

fileName The name of the PCF to be loaded.

Exceptions

FileNotFound	If the file cannot be found.
SimulationStillRunning	If an old simulation is still running.
IllegalMachine	If the ADF was erroneus.

Definition at line 600 of file SimulatorFrontend.cc.

                                                                       {
    SimulatorTextGenerator& textGen = SimulatorToolbox::textGenerator();
 
    if (!FileSystem::fileExists(fileName)) {
        throw FileNotFound(
            __FILE__, __LINE__, __func__, 
            textGen.text(Texts::TXT_FILE_NOT_FOUND).str());
    }
 
    if (!FileSystem::fileIsReadable(fileName)) {
        throw IOException(__FILE__, __LINE__, __func__, "File not readable.");
    }
 
    std::ifstream inputFile(fileName.c_str());
    ProcessorConfigurationFile pcf(inputFile);
    pcf.setPCFDirectory(FileSystem::directoryOfPath(fileName));
 
    std::string adfName = "";
    try {
        adfName = pcf.architectureName();
    } catch (const KeyNotFound&) {
        throw FileNotFound(
            __FILE__, __LINE__, __func__, 
            textGen.text(Texts::TXT_NO_ADF_DEFINED_IN_PCF).str());
    }
    
    loadMachine(adfName);
}

References __func__, ProcessorConfigurationFile::architectureName(), FileSystem::directoryOfPath(), FileSystem::fileExists(), FileSystem::fileIsReadable(), loadMachine(), ProcessorConfigurationFile::setPCFDirectory(), Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), Texts::TXT_FILE_NOT_FOUND, and Texts::TXT_NO_ADF_DEFINED_IN_PCF.

Referenced by ConfCommand::execute().

Here is the call graph for this function:

◆ loadProgram() [1/2]

void SimulatorFrontend::loadProgram ( const std::string & fileName )

virtual

Loads a new program to be simulated from a TPEF file.

The loaded program will be owned by SimulatorFrontend and thus be deleted by it when not needed anymore.

Parameters

fileName The name of the TPEF file to be loaded.

Exceptions

FileNotFound	If the file cannot be found.
SimulationStillRunning	If an old simulation is still running.
IllegalProgram	If the TPEF was erroneus or the program invalid.
Exception	Any exception thrown while building the simulation models are passed on.

Todo:

Implement after Program builder is done.

Throw when machine is not loaded.

Implement checking for already running simulation.

Reimplemented in TracedSimulatorFrontend.

Definition at line 299 of file SimulatorFrontend.cc.

                                                        {
 
    if (currentMachine_ == NULL)
        throw Exception(
            __FILE__, __LINE__, __func__,
            "Cannot load a program without loading a machine first.");
 
    SimulatorTextGenerator& textGen = SimulatorToolbox::textGenerator();
    
    if (!FileSystem::fileExists(fileName)) {
        throw FileNotFound(
            __FILE__, __LINE__, __func__, 
            textGen.text(Texts::TXT_FILE_NOT_FOUND).str());
    }
 
    if (!FileSystem::fileIsReadable(fileName)) {
        throw IOException(__FILE__, __LINE__, __func__, "File not readable.");
    }
 
    BinaryStream binaryStream(fileName);
 
    const Program* oldProgram = currentProgram_;
 
    try {
        // read to TPEF Handler Module
        tpef_ = BinaryReader::readBinary(binaryStream);
 
        assert(tpef_ != NULL);
        assert(currentMachine_ != NULL);
 
        // convert the loaded TPEF to POM
        TPEFProgramFactory factory(*tpef_, *currentMachine_);
        TTAProgram::Program* program = factory.build();
        program->finalize();
        currentProgram_ = program;
    } catch (const Exception& e) {
        delete tpef_;
        tpef_ = NULL;
        delete simCon_;
        simCon_ = NULL;
        std::string errorMsg = textGen.text(
            Texts::TXT_UNABLE_TO_LOAD_PROGRAM).str();
 
        if (e.errorMessage() != "")
            errorMsg += " " + e.errorMessage();
 
        IllegalProgram illegp(__FILE__, __LINE__, __func__, errorMsg);
        illegp.setCause(e);
        throw illegp;
    }
 
    // Validate the program against the current machine using POMValidator.
    // TODO: this should be refactored -- the loadProgram(Program) is not
    // checking these?
    POMValidator validator(*currentProgram_);
    std::set<POMValidator::ErrorCode> checks;
    checks.insert(POMValidator::CONNECTION_MISSING);
    checks.insert(POMValidator::LONG_IMMEDIATE_NOT_SUPPORTED);
    checks.insert(POMValidator::SIMULATION_NOT_POSSIBLE);
 
    if (isCompiledSimulation()) {
        checks.insert(POMValidator::COMPILED_SIMULATION_NOT_POSSIBLE);
    }
 
#if (!defined(HAVE_CXX11) && !defined(HAVE_CXX0X))
    std::auto_ptr<POMValidatorResults> results(validator.validate(checks));
#else
    std::unique_ptr<POMValidatorResults> results(validator.validate(checks));
#endif
 
    if (results->errorCount() > 0) {
        std::string errorMsg = textGen.text(
            Texts::TXT_UNABLE_TO_LOAD_PROGRAM).str();
        
        for (int i = 0; i < results->errorCount(); i++) {
            errorMsg += "\n" + results->error(i).second;
        }
        
        if (isCompiledSimulation()) {
            // Attempt without compiled simulator
            setCompiledSimulation(false);
            checks.erase(POMValidator::COMPILED_SIMULATION_NOT_POSSIBLE);
            results.reset(validator.validate(checks));
        }
              
        if (results->errorCount() > 0) {
            delete tpef_;
            tpef_ = NULL;
            delete simCon_;
            simCon_ = NULL;
            
            for (int i = 0; i < results->errorCount(); i++) {
                errorMsg += "\n" + results->error(i).second;
            }
 
            throw IllegalProgram(__FILE__, __LINE__, __func__, errorMsg);   
        } else {
            outputStream()
                << errorMsg << std::endl
                << "Warning! Reverting to interpretive simulation engine." 
                << std::endl;
        }
    }
 
    if (programOwnedByFrontend_) {
        delete oldProgram;
        oldProgram = NULL;
    }
 
    delete disassembler_;
    disassembler_ = NULL;
 
    programOwnedByFrontend_ = true;
 
    initializeSimulation();
    initializeDataMemories();
 
    // Dump simulation traces in the same directory as loaded program file
    // or user-defined directory 
    std::string traceDir = Environment::simTraceDirPath();
    if (traceDir == "") {
        programFileName_ = fileName;
    } else {
        programFileName_ =
            traceDir + FileSystem::DIRECTORY_SEPARATOR +
            FileSystem::fileOfPath(fileName);
    }
 
    // tracing can't be enabled before loading program so try to initialize
    // the tracing after program is loaded
    initializeTracing();
}

References __func__, assert, TTAProgram::TPEFProgramFactory::build(), POMValidator::COMPILED_SIMULATION_NOT_POSSIBLE, POMValidator::CONNECTION_MISSING, currentMachine_, currentProgram_, FileSystem::DIRECTORY_SEPARATOR, disassembler_, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileIsReadable(), FileSystem::fileOfPath(), TTAProgram::Program::finalize(), initializeDataMemories(), initializeSimulation(), initializeTracing(), isCompiledSimulation(), POMValidator::LONG_IMMEDIATE_NOT_SUPPORTED, outputStream(), program(), programFileName_, programOwnedByFrontend_, TPEF::BinaryReader::readBinary(), Exception::setCause(), setCompiledSimulation(), simCon_, Environment::simTraceDirPath(), POMValidator::SIMULATION_NOT_POSSIBLE, Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), tpef_, Texts::TXT_FILE_NOT_FOUND, Texts::TXT_UNABLE_TO_LOAD_PROGRAM, and POMValidator::validate().

Referenced by ProgCommand::execute(), SimpleSimulatorFrontend::loadProgram(), TracedSimulatorFrontend::loadProgram(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), DesignSpaceExplorer::simulate(), and tandemSimulate().

Here is the call graph for this function:

◆ loadProgram() [2/2]

void SimulatorFrontend::loadProgram ( const TTAProgram::Program & program )

Loads a new program to be simulated.

The loaded program is not owned by SimulatorFrontend and thus won't be deleted by it when not needed anymore. Simulation is initialized using the previously loaded machine. This function assumes that machine is loaded before calling it. Program is aborted otherwise.

Parameters

program The program to be loaded.

Exceptions

IOException	If tracing is enabled and could not be initialized.
Exception	Any exception thrown while building the simulation models are passed on.

Todo:

Throw when machine is not loaded.

Implement checking for already running simulation.

Definition at line 198 of file SimulatorFrontend.cc.

                                                     {
 
    if (currentMachine_ == NULL)
        throw Exception(
            __FILE__, __LINE__, __func__,
            "Cannot load a program without loading a machine first.");
 
    if (programOwnedByFrontend_) {
        delete currentProgram_;
        currentProgram_ = NULL;
    }
 
    currentProgram_ = &program;
    programOwnedByFrontend_ = false;
 
    initializeSimulation();
    initializeDataMemories();
    initializeTracing();
}

References __func__, currentMachine_, currentProgram_, initializeDataMemories(), initializeSimulation(), initializeTracing(), program(), and programOwnedByFrontend_.

Here is the call graph for this function:

◆ machine()

const Machine & SimulatorFrontend::machine ( ) const

Returns a read-only reference to the currently loaded machine.

Returns: A read-only reference to the currently loaded machine, if none, returns a NullMachine instance.

Definition at line 263 of file SimulatorFrontend.cc.

                                 {
    if (currentMachine_ == NULL) 
        return NullMachine::instance();
    return *currentMachine_;
}

References currentMachine_, and TTAMachine::NullMachine::instance().

Here is the call graph for this function:

◆ machineState()

MachineState & SimulatorFrontend::machineState ( int core = -1 )

Returns a reference to the state model of the currently loaded machine.

Note: : This should be called only for interpretive simulation which uses the SimulationController engine. Asserts if another engine (compiled) is used.

Returns: State model of the simulated machine.

Definition at line 2138 of file SimulatorFrontend.cc.

                                        {
    SimulationController* simCon =
        dynamic_cast<SimulationController*>(simCon_);
    assert(simCon != NULL && "Wrong TTASimulationController implementation.");
    return simCon->machineState(core);
}

References assert, SimulationController::machineState(), and simCon_.

Referenced by ProximBusDetailsCmd::Do(), ProximFUDetailsCmd::Do(), ProximFUPortDetailsCmd::Do(), ProximIUDetailsCmd::Do(), ProximRFDetailsCmd::Do(), InfoSegmentsCommand::execute(), findBooleanRegister(), findPort(), findRegister(), BusTracker::handleEvent(), ProximRegisterWindow::loadImmediateUnit(), ProximRegisterWindow::loadRegisterFile(), SimpleSimulatorFrontend::setOperationSimulator(), and ProximPortWindow::update().

Here is the call graph for this function:

◆ memoryAccessTracking()

bool SimulatorFrontend::memoryAccessTracking ( ) const

Returns true if memory access tracking is enabled.

Returns: Returns current memory access tracking setting.

Definition at line 2057 of file SimulatorFrontend.cc.

                                               {
    return memoryAccessTracking_;
}

References memoryAccessTracking_.

◆ memorySystem()

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

Returns the memory system of the currently loaded machine.

Asserts if no simulation is initialized.

Todo:: Throw instead.

Returns: The used MemorySystem.

Definition at line 2121 of file SimulatorFrontend.cc.

                                          {
    if (coreId == -1)
        return *memorySystems_.at(selectedCore());
    else 
        return *memorySystems_.at(coreId);
}

References memorySystems_, and selectedCore().

Referenced by OTASimulationController::advanceMachineCycle(), MemDumpCommand::execute(), initializeDataMemories(), ProximMemoryWindow::loadMemory(), ProximMemoryWindow::loadProgramMemory(), SimpleSimulatorFrontend::memorySystem(), TTASimulationController::memorySystem(), ProximMemoryWindow::onASChoice(), ProximMemoryWindow::onSimulationStop(), setControllerForMemories(), SimControlLanguageCommand::setMemoryPointer(), SimulationController::simulateCycle(), and SimulationController::SimulationController().

Here is the call graph for this function:

◆ next()

void SimulatorFrontend::next ( int count = 1 )

virtual

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

Parameters

count The number of steps the simulation is advanced.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Todo:: Throw exception if simulation is not initialized.

Reimplemented in TracedSimulatorFrontend.

Definition at line 1052 of file SimulatorFrontend.cc.

                                 {
    assert(simCon_ != NULL);
 
    startTimer();
    boost::thread timeout(boost::bind(timeoutThread, 
        simulationTimeout_, this));
    simCon_->next(count);
    stopTimer();
    
    // invalidate utilization statistics (they are not fresh anymore)
    SequenceTools::deleteAllItems(utilizationStats_);
}

References assert, SequenceTools::deleteAllItems(), TTASimulationController::next(), simCon_, simulationTimeout_, startTimer(), stopTimer(), timeoutThread, and utilizationStats_.

Referenced by NextiCommand::execute(), and TracedSimulatorFrontend::next().

Here is the call graph for this function:

◆ nextInstructionPrinting()

bool SimulatorFrontend::nextInstructionPrinting ( ) const

Returns true if the next simulated instruction will be printed to the simulator console at simulation stop.

Returns: True if the instruction should be printed.

Definition at line 2080 of file SimulatorFrontend.cc.

                                                  {
    return printNextInstruction_;
}

References printNextInstruction_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ outputStream()

std::ostream & SimulatorFrontend::outputStream ( )

Returns the output stream

Returns: the output stream

Definition at line 1987 of file SimulatorFrontend.cc.

                                {
    assert(outputStream_ != 0);
    return *outputStream_;
}

References assert, and outputStream_.

Referenced by loadProgram().

◆ prepareToStop()

void SimulatorFrontend::prepareToStop ( StopReason reason )

Signals the simulator engine to stop simulation after the current simulated clock cycle.

Does nothing if simulation is not initialized or simulation is not running.

Parameters

reason The reason for stopping.

Definition at line 1331 of file SimulatorFrontend.cc.

                                                  {
    if (simCon_ == NULL || !isSimulationRunning()) {
        return;
    }
    simCon_->prepareToStop(reason);
}

References isSimulationRunning(), TTASimulationController::prepareToStop(), and simCon_.

Referenced by SigINTHandler::execute(), SigSegvHandler::execute(), SigFPEHandler::execute(), ProximSimulationThread::finishSimulation(), RuntimeErrorReporter::handleEvent(), ProximRuntimeErrorHandler::handleEvent(), ProximSimulationThread::killSimulation(), ProximStopDialog::onClose(), ProximStopDialog::onStop(), ProximSimulationThread::requestStop(), and SimpleSimulatorFrontend::stop().

Here is the call graph for this function:

◆ procedureTransferTracing()

bool SimulatorFrontend::procedureTransferTracing ( ) const

Returns true in case procedure transfer tracing is enabled.

Returns: True in case procedure transfer tracing is enabled.

Definition at line 1827 of file SimulatorFrontend.cc.

                                                  {
    return procedureTransferTracing_;
}

References procedureTransferTracing_.

Referenced by SimulatorSettingsDialog::onOK(), CompiledSimController::reset(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ profileDataSaving()

bool SimulatorFrontend::profileDataSaving ( ) const

Returns true in case profile data saving is enabled.

Returns: True in case profile data saving is enabled.

Definition at line 1837 of file SimulatorFrontend.cc.

                                           {
    return saveProfileData_;
}

References saveProfileData_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ program()

const Program & SimulatorFrontend::program ( ) const

Returns a read-only reference to the currently loaded program.

Returns: A read-only reference to the currently loaded program, if none, returns a NullProgram instance.

Definition at line 276 of file SimulatorFrontend.cc.

                                 {
    if (currentProgram_ == NULL) 
        return NullProgram::instance();
    return *currentProgram_;
}

References currentProgram_, and TTAProgram::NullProgram::instance().

Referenced by ProximMachineStateWindow::addMoves(), compareState(), BackTraceCommand::execute(), DisassembleCommand::execute(), SymbolAddressCommand::execute(), ProcedureTransferTracker::handleEvent(), RFAccessTracker::handleEvent(), loadProgram(), TracedSimulatorFrontend::loadProgram(), loadProgram(), DisasmExecPercentageAttrProvider::moveCellAttr(), SimControlLanguageCommand::parseDataAddressExpression(), SimControlLanguageCommand::parseInstructionAddressExpression(), ProximToolbox::program(), SimpleSimulatorFrontend::program(), DisasmTopCountAttrProvider::updateTopCountTable(), and utilizationStatistics().

Here is the call graph for this function:

◆ programCounter()

InstructionAddress SimulatorFrontend::programCounter ( ) const

Returns the program counter value.

Returns: Program counter value.

Todo:: Throw exception if simulation is not initialized

Definition at line 1169 of file SimulatorFrontend.cc.

                                        {
    assert(simCon_ != NULL);
    return simCon_->programCounter();
}

References assert, TTASimulationController::programCounter(), and simCon_.

Referenced by compareState(), currentProcedure(), InfoProgramCommand::execute(), RuntimeErrorReporter::handleEvent(), Breakpoint::isTriggered(), SimControlLanguageCommand::parseInstructionAddressExpression(), and programLocationDescription().

Here is the call graph for this function:

◆ programErrorReport()

std::string SimulatorFrontend::programErrorReport	(	RuntimeErrorSeverity	severity,
		std::size_t	index
	)

Returns a program error report with given severity and index.

Parameters

severity	Severity.
index	Index.

Returns: The error report text.

Definition at line 2321 of file SimulatorFrontend.cc.

                                                    {
 
    size_t count = 0;
    for (ProgramErrorDescriptionList::iterator i = 
             programErrorReports_.begin(); i != programErrorReports_.end();
         ++i) {
        if ((*i).first == severity) {
            if (count == index)
                return (*i).second;
            ++count;
        }
    }
    return "";
}

References programErrorReports_.

Referenced by RuntimeErrorReporter::handleEvent(), and ProximRuntimeErrorHandler::handleEvent().

◆ programErrorReportCount()

std::size_t SimulatorFrontend::programErrorReportCount ( RuntimeErrorSeverity severity )

Returns the count of program error reports with given severity.

Parameters

severity The error report severity interested in.

Returns: The count of error reports.

Definition at line 2344 of file SimulatorFrontend.cc.

                                   {
    size_t count = 0;
    for (ProgramErrorDescriptionList::iterator i = 
             programErrorReports_.begin(); i != programErrorReports_.end();
         ++i) {
        if ((*i).first == severity)
            ++count;
    }
    return count;
}

References programErrorReports_.

Referenced by RuntimeErrorReporter::handleEvent(), and ProximRuntimeErrorHandler::handleEvent().

◆ programLocationDescription()

std::string SimulatorFrontend::programLocationDescription ( ) const

Returns a string describing the current location of simulation in the simulated program.

If simulation has ended, returns an empty string.

Returns: A description as defined in Simulator specs.

Definition at line 1108 of file SimulatorFrontend.cc.

                                                    {
 
    if (hasSimulationEnded()) {
        return "";
    }
 
    InstructionAddress instructionAddress = programCounter();
 
    const InstructionAddress programLastAddress =
        currentProgram_->lastProcedure().endAddress().location();
 
    if (instructionAddress >= programLastAddress) {
        return "";
    }
 
    const Instruction& theInstruction =
        currentProgram_->instructionAt(instructionAddress);
    const Procedure& currentProc =
        dynamic_cast<const Procedure&>(theInstruction.parent());
 
    InstructionAddress distanceFromStart =
        instructionAddress - currentProc.startAddress().location();
 
    initializeDisassembler();
 
    std::stringstream tempStream;
 
    tempStream << std::setw(7) << std::right << instructionAddress << " ";
    tempStream 
        << std::setw(30) << std::right << 
        std::string("<") + currentProc.name() + "+" + 
        Conversion::toString(distanceFromStart) + ">" << ": "
        << disassembler_->disassembleInstruction(theInstruction);
 
    return tempStream.str();
}

References currentProgram_, POMDisassembler::disassembleInstruction(), disassembler_, TTAProgram::CodeSnippet::endAddress(), hasSimulationEnded(), initializeDisassembler(), TTAProgram::Program::instructionAt(), TTAProgram::Program::lastProcedure(), TTAProgram::Address::location(), TTAProgram::Procedure::name(), TTAProgram::Instruction::parent(), programCounter(), TTAProgram::CodeSnippet::startAddress(), and Conversion::toString().

Referenced by SimControlLanguageCommand::printNextInstruction().

Here is the call graph for this function:

◆ registerFileValue()

std::string SimulatorFrontend::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.

Definition at line 738 of file SimulatorFrontend.cc.

                                                {
    
    return simCon_->registerFileValue(rfName, registerIndex);
}

References TTASimulationController::registerFileValue(), and simCon_.

Referenced by compareState().

Here is the call graph for this function:

◆ reportSimulatedProgramError()

void SimulatorFrontend::reportSimulatedProgramError	(	RuntimeErrorSeverity	severity,
		const std::string &	description
	)

This method is used to report a runtime error detected in the simulated program.

An SE_RUNTIME_ERROR event is announced after storing the report.

Parameters

eventHandler	Simulation event handler for the error
severity	Severity classification of the runtime error.
description	Textual description of the error.

Definition at line 2304 of file SimulatorFrontend.cc.

                                                                 {
    ProgramErrorDescription report;
    report.first = severity;
    report.second = description;
    programErrorReports_.push_back(report);
    eventHandler().handleEvent(SimulationEventHandler::SE_RUNTIME_ERROR);
}

References eventHandler(), Informer::handleEvent(), programErrorReports_, and SimulationEventHandler::SE_RUNTIME_ERROR.

Referenced by SigSegvHandler::execute(), SigFPEHandler::execute(), OTASimulationController::simulateCycle(), and SimulationController::simulateCycle().

Here is the call graph for this function:

◆ rfAccessTracing()

bool SimulatorFrontend::rfAccessTracing ( ) const

Returns true in case register file access tracing is enabled.

Returns: True in case RF access tracing is enabled.

Definition at line 1818 of file SimulatorFrontend.cc.

                                         {
    return rfAccessTracing_;
}

References rfAccessTracing_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ rfAccessTracker()

const RFAccessTracker & SimulatorFrontend::rfAccessTracker ( ) const

Returns the register file access tracker.

Returns: The register file access tracker.

Exceptions

InstanceNotFound If RF access tracking is not enabled.

Definition at line 1869 of file SimulatorFrontend.cc.

                                         {
    if (rfAccessTrackers_.size() == 0) {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__, "RF access tracing is disabled.");
    }
    return *rfAccessTrackers_.at(0);
}

References __func__, and rfAccessTrackers_.

Referenced by InfoProcCommand::execute(), and finishSimulation().

◆ run()

void SimulatorFrontend::run ( )

virtual

Run simulation until it's stopped for some reason.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Todo:: Throw exception if simulation is not initialized.

Reimplemented in TracedSimulatorFrontend.

Definition at line 997 of file SimulatorFrontend.cc.

                       {
    startTimer();
    boost::thread timeout(
        boost::bind(timeoutThread, simulationTimeout_, this));
    simCon_->run();
    stopTimer();
    SequenceTools::deleteAllItems(utilizationStats_);
}

References SequenceTools::deleteAllItems(), TTASimulationController::run(), simCon_, simulationTimeout_, startTimer(), stopTimer(), timeoutThread, and utilizationStats_.

Referenced by ResumeCommand::execute(), RunCommand::execute(), SimpleSimulatorFrontend::run(), TracedSimulatorFrontend::run(), and DesignSpaceExplorer::simulate().

Here is the call graph for this function:

◆ runUntil()

void SimulatorFrontend::runUntil ( UIntWord address )

virtual

Run simulation until given address.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Todo:: Throw exception if simulation is not initialized.

Reimplemented in TracedSimulatorFrontend.

Definition at line 1014 of file SimulatorFrontend.cc.

                                            {
    startTimer();
    boost::thread timeout(boost::bind(timeoutThread, 
        simulationTimeout_, this));
    simCon_->runUntil(address);
    stopTimer();
    // invalidate utilization statistics (they are not fresh anymore)
    SequenceTools::deleteAllItems(utilizationStats_);
}

References SequenceTools::deleteAllItems(), TTASimulationController::runUntil(), simCon_, simulationTimeout_, startTimer(), stopTimer(), timeoutThread, and utilizationStats_.

Referenced by UntilCommand::execute(), and TracedSimulatorFrontend::runUntil().

Here is the call graph for this function:

◆ selectCore()

void SimulatorFrontend::selectCore ( int core )

inline

Definition at line 259 of file SimulatorFrontend.hh.

                              {
        if (core != 0) {
            abortWithError("WiP.");
        }
    }

References abortWithError.

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

◆ selectedCore()

int SimulatorFrontend::selectedCore ( ) const

inline

Definition at line 256 of file SimulatorFrontend.hh.

                             {
        return 0;
    }

Referenced by callPathTracker(), SimulationController::instructionMemory(), TTASimulationController::lastExecutedInstruction(), lastTraceDB(), SimulationController::machineState(), memorySystem(), SimulationController::programCounter(), SimulationController::selectedInstructionMemory(), SimulationController::selectedMachineState(), and utilizationStatistics().

◆ setBusTracing()

void SimulatorFrontend::setBusTracing ( bool value )

Sets the bus tracing on or off.

Parameters

value Is bus tracing enabled or not.

Definition at line 1910 of file SimulatorFrontend.cc.

                                           {
    busTracing_ = value;
}

References busTracing_.

Referenced by SetBusTrace::execute().

◆ setCallHistoryLength()

void SimulatorFrontend::setCallHistoryLength ( std::size_t length )

Sets the length of the call history stored in memory to be used for the simulator's debugging commands that need it.

Setting this to 0 disables the call history tracking thus speeding up simulation. It's disabled by default.

Definition at line 2372 of file SimulatorFrontend.cc.

                                                        {
    callHistoryLength_ = length;
    setupCallHistoryTracking();
}

References callHistoryLength_, and setupCallHistoryTracking().

Referenced by SetCallHistoryLength::execute().

Here is the call graph for this function:

◆ setCompiledSimulation()

void SimulatorFrontend::setCompiledSimulation ( bool value )

Sets compiled simulation on or off

Parameters

value Is compiled simulation enabled or not.

Definition at line 1883 of file SimulatorFrontend.cc.

                                                   {
    // This legacy function assumes we use a simulator engine, not a
    // remote target.
    if (currentBackend_ == SIM_REMOTE) return;
    if (currentBackend_ == SIM_CUSTOM) return;
    if (value)
        currentBackend_ = SIM_COMPILED;
    else 
        currentBackend_ = SIM_NORMAL;
}

References currentBackend_, SIM_COMPILED, SIM_CUSTOM, SIM_NORMAL, and SIM_REMOTE.

Referenced by loadMachine(), loadMachine(), loadProgram(), and SimulatorFrontend().

◆ setCompiledSimulationLeaveDirty()

void SimulatorFrontend::setCompiledSimulationLeaveDirty ( bool dirty )

inline

Definition at line 156 of file SimulatorFrontend.hh.

                                                     { 
        leaveCompiledDirty_ = dirty;
    }

References leaveCompiledDirty_.

Referenced by tandemSimulate().

◆ setControllerForMemories()

void SimulatorFrontend::setControllerForMemories ( RemoteController * con )

protected

Definition at line 634 of file SimulatorFrontend.cc.

                                                                 {
 
    int num_mems = memorySystem(0).memoryCount();    
    for (int i = 0; i < num_mems; i++) {
        MemorySystem::MemoryPtr memptr = memorySystem(0).memory(i);
        boost::shared_ptr<RemoteMemory> rmem = 
            boost::static_pointer_cast<RemoteMemory>(memptr);
        assert(rmem != NULL && "not a RemoteMemory!");
        rmem->setController(con);    
    }
}

References assert, MemorySystem::memory(), MemorySystem::memoryCount(), and memorySystem().

Referenced by initializeSimulation().

Here is the call graph for this function:

◆ setDetailedSimulation()

void SimulatorFrontend::setDetailedSimulation ( bool val )

inline

Definition at line 237 of file SimulatorFrontend.hh.

238 { detailedSimulation_ = val; }

References detailedSimulation_.

Referenced by SimpleSimulatorFrontend::SimpleSimulatorFrontend().

◆ setExecutionTracing()

void SimulatorFrontend::setExecutionTracing ( bool value )

Sets the execution tracing on or off.

Parameters

value Is execution tracing enabled or not.

Definition at line 1900 of file SimulatorFrontend.cc.

                                                 {
    executionTracing_ = value;
}

References executionTracing_.

Referenced by SetExecutionTrace::execute(), and DesignSpaceExplorer::simulate().

◆ setFUResourceConflictDetection()

void SimulatorFrontend::setFUResourceConflictDetection ( bool value )

Sets the FU resource conflict detection on or off.

NOTE: this affects future simulations only. That is, if a simulation is already initialized (program loaded), the old setting is used for that simulation.

Parameters

value Should the resource conflict detection be used.

Definition at line 2022 of file SimulatorFrontend.cc.

                                                            {
    fuResourceConflictDetection_ = value;
}

References fuResourceConflictDetection_.

Referenced by CompiledSimSetFUConflictDetection::execute(), SetFUConflictDetection::execute(), and SimulatorFrontend().

◆ setMemoryAccessTracking()

void SimulatorFrontend::setMemoryAccessTracking ( bool value )

Sets the memory access tracking on or off.

NOTE: this affects future simulations only. That is, if a simulation is already initialized (program loaded), the old setting is used for that simulation.

Parameters

value Should the memory access tracking be used.

Definition at line 2047 of file SimulatorFrontend.cc.

                                                     {
    memoryAccessTracking_ = value;
}

References memoryAccessTracking_.

Referenced by SetMemoryAccessTracking::execute().

◆ setNextInstructionPrinting()

void SimulatorFrontend::setNextInstructionPrinting ( bool value )

Sets the printing of the next simulated instruction to the console.

The instruction is printed when stopping simulation.

Parameters

value True if the instruction should be printed.

Definition at line 2069 of file SimulatorFrontend.cc.

                                                        {
    printNextInstruction_ = value;
}

References printNextInstruction_.

Referenced by SetNextInstructionPrinting::execute().

◆ setOutputStream()

void SimulatorFrontend::setOutputStream ( std::ostream & stream )

Sets the default output stream

Parameters

stream the output stream

Definition at line 1998 of file SimulatorFrontend.cc.

                                                     {
    outputStream_ = &stream;
}

References outputStream_.

◆ setProcedureTransferTracing()

void SimulatorFrontend::setProcedureTransferTracing ( bool value )

Sets the procedure transfer tracing on or off.

Parameters

value Is procedure transfer tracing on or off.

Definition at line 1930 of file SimulatorFrontend.cc.

                                                         {
    procedureTransferTracing_ = value;
}

References procedureTransferTracing_.

Referenced by SetProcedureTransferTracing::execute().

◆ setProfileDataSaving()

void SimulatorFrontend::setProfileDataSaving ( bool value )

Sets the profile saving on or off.

Parameters

value Is profile saving on or off.

Definition at line 1940 of file SimulatorFrontend.cc.

                                                  {
    saveProfileData_ = value;
}

References saveProfileData_.

Referenced by SetProfileSaving::execute().

◆ setRFAccessTracing()

void SimulatorFrontend::setRFAccessTracing ( bool value )

Sets the register file access tracing on or off.

Parameters

value Is register file access tracing enabled or not.

Definition at line 1920 of file SimulatorFrontend.cc.

                                                {
    rfAccessTracing_ = value;
}

References rfAccessTracing_.

Referenced by SetRFTracking::execute(), and DesignSpaceExplorer::simulate().

◆ setSimulationTimeStatistics()

void SimulatorFrontend::setSimulationTimeStatistics ( bool value )

Sets the printing of simulation time statistics

Parameters

value True if the statistics should be printed out

Definition at line 2088 of file SimulatorFrontend.cc.

                                                              {
    printSimulationTimeStatistics_ = value;
}

References printSimulationTimeStatistics_.

Referenced by SetSimulationTimeStatistics::execute().

◆ setStaticCompilation()

void SimulatorFrontend::setStaticCompilation ( bool value )

Sets the compiled simulator to use static or dynamic compilation.

Has no effect when running interpretive simulation.

Parameters

value new value to be set

Definition at line 1977 of file SimulatorFrontend.cc.

                                                  {
    staticCompilation_ = value;
}

References staticCompilation_.

Referenced by SetStaticCompilation::execute(), and tandemSimulate().

◆ setTimeout()

void SimulatorFrontend::setTimeout ( unsigned int value )

Sets the simulation timeout in seconds. Use zero for no timeout.

Parameters

value Simulation timeout in seconds.

Definition at line 1965 of file SimulatorFrontend.cc.

                                                {
    simulationTimeout_ = value;
}

References simulationTimeout_.

Referenced by SetSimulationTimeout::execute(), and DesignSpaceExplorer::simulate().

◆ setupCallHistoryTracking()

void SimulatorFrontend::setupCallHistoryTracking ( )

protected

Definition at line 2378 of file SimulatorFrontend.cc.

                                            {
    if (callHistoryLength_ == 0 || !isMachineLoaded()) {
        SequenceTools::deleteAllItems(callPathTrackers_);
        return;
    } else {
        for (int core = 0; core < 1; 
             ++core) {
            CallPathTracker* tracker = 
                new CallPathTracker(*this, core, callHistoryLength_);
            callPathTrackers_.push_back(tracker);
        }
    }    
}

References callHistoryLength_, callPathTrackers_, SequenceTools::deleteAllItems(), and isMachineLoaded().

Referenced by initializeTracing(), and setCallHistoryLength().

Here is the call graph for this function:

◆ setUtilizationDataSaving()

void SimulatorFrontend::setUtilizationDataSaving ( bool value )

Sets the utilization data saving on or off.

Parameters

value Is utilization data saving on or off.

Definition at line 2008 of file SimulatorFrontend.cc.

                                                      {
    saveUtilizationData_ = value;
}

References saveUtilizationData_.

Referenced by SetUtilizationSaving::execute(), and DesignSpaceExplorer::simulate().

◆ setZeroFillMemoriesOnReset()

void SimulatorFrontend::setZeroFillMemoriesOnReset ( bool val )

inline

Definition at line 234 of file SimulatorFrontend.hh.

235 { zeroFillMemoriesOnReset_ = val; }

References zeroFillMemoriesOnReset_.

Referenced by SimpleSimulatorFrontend::SimpleSimulatorFrontend(), SimpleSimulatorFrontend::SimpleSimulatorFrontend(), and SimpleSimulatorFrontend::SimpleSimulatorFrontend().

◆ simulationTimeStatistics()

bool SimulatorFrontend::simulationTimeStatistics ( ) const

Returns true if the time statistics are to be printed after a command

Returns: True, if the time statistics are to be printed after a command

Definition at line 2097 of file SimulatorFrontend.cc.

                                                       {
    return printSimulationTimeStatistics_;
}

References printSimulationTimeStatistics_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ startTimer()

void SimulatorFrontend::startTimer ( )

protected

Starts the wall-clock timer.

Definition at line 928 of file SimulatorFrontend.cc.

                              {
    startCycleCount_ = cycleCount();
    startTime_ = time(NULL);
}

References cycleCount(), startCycleCount_, and startTime_.

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

Here is the call graph for this function:

◆ state()

StateData & SimulatorFrontend::state ( std::string searchString )

Tries to locate a readable machine state part using a search string.

See stateValue() for further comment.

Parameters

searchString The string to use in search, e.g., (alu.p3 or add.3).

Returns: The StateData object.

Exceptions

InstanceNotFound In case state couldn't be found using the search string.

Todo:: Parallel fu port access (syntax?)

Definition at line 894 of file SimulatorFrontend.cc.

                                               {
    if (currentMachine_ == NULL) 
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__, "State not found.");
 
    boost::smatch parsed;
    
    if (StringTools::ciEqual(searchString, "bool") ||
        StringTools::ciEqual(searchString, "boolean")) {
        return findBooleanRegister();
    } else 
        if (StringTools::ciEqual(searchString, "ra") ||
            StringTools::ciEqual(searchString, "return-address")) {
            return findPort(
                currentMachine_->controlUnit()->name(),
                currentMachine_->controlUnit()->returnAddressPort()->name());
        } else 
            if (regex_match(
                    searchString, parsed, 
                    SimulatorToolbox::fuPortRegex())) {
                /// @todo Parallel fu port access (syntax?)
                return findPort(parsed[1], parsed[2]);
            }
    
    throw InstanceNotFound(
        __FILE__, __LINE__, __func__, 
        std::string("No state found with the search string '") +
        std::string(searchString) + "'.");
}

References __func__, StringTools::ciEqual(), TTAMachine::Machine::controlUnit(), currentMachine_, findBooleanRegister(), findPort(), SimulatorToolbox::fuPortRegex(), TTAMachine::Component::name(), TTAMachine::Port::name(), and TTAMachine::ControlUnit::returnAddressPort().

Referenced by InfoRegistersCommand::execute(), and stateValue().

Here is the call graph for this function:

◆ stateValue()

const SimValue & SimulatorFrontend::stateValue ( std::string searchString )

Tries to locate a readable machine state part using a search string.

For a syntax of valid search strings, consult the TCE TTA assembler syntax description. All valid sources and destinations except immediate sources are valid search strings.

Parameters

searchString The string to use in search, e.g., (alu.p3).

Returns: Current value of the state (read-only).

Exceptions

InstanceNotFound In case state couldn't be found using the search string.

Definition at line 878 of file SimulatorFrontend.cc.

                                                    {
    return state(searchString).value();
}

References state(), and ReadableState::value().

Here is the call graph for this function:

◆ staticCompilation()

bool SimulatorFrontend::staticCompilation ( ) const

Returns true if the compiled simulation uses static compilation

Returns: true if the compiled simulation uses static compilation

Definition at line 1857 of file SimulatorFrontend.cc.

                                           {
    return staticCompilation_;
}

References staticCompilation_.

Referenced by CompiledSimController::reset().

◆ step()

void SimulatorFrontend::step ( double count = 1 )

virtual

Advance simulation by a given amout of cycles.

Note: Does not create a timeout thread. Does not make sense here as the step() always finishes.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Todo:: Throw exception if simulation is not initialized.

Reimplemented in TracedSimulatorFrontend.

Definition at line 1034 of file SimulatorFrontend.cc.

                                    {
    assert(simCon_ != NULL);
 
    simCon_->step(count);
    // invalidate utilization statistics (they are not fresh anymore)
    SequenceTools::deleteAllItems(utilizationStats_);
}

References assert, SequenceTools::deleteAllItems(), simCon_, TTASimulationController::step(), and utilizationStats_.

Referenced by StepiCommand::execute(), SimpleSimulatorFrontend::step(), TracedSimulatorFrontend::step(), and tandemSimulate().

Here is the call graph for this function:

◆ stoppedByUser()

bool SimulatorFrontend::stoppedByUser ( ) const

Returns true if simulation is stopped because of user set reason, i.e., breakpoint, watchpoint, memory write watchpoint, explicit (ctrl-c) stop, etc.

Also returns true if a runtime error was the reason for stopping, to avoid infinite loops.

Parameters

true	If simulation stopped because of user set stop point.

Definition at line 1394 of file SimulatorFrontend.cc.

                                       {
 
    if (simCon_ == NULL) {
        return false;
    }
 
    return 
        hasStopReason(SRE_BREAKPOINT) || hasStopReason(SRE_USER_REQUESTED) ||
        hasStopReason(SRE_RUNTIME_ERROR);
}

References hasStopReason(), simCon_, SRE_BREAKPOINT, SRE_RUNTIME_ERROR, and SRE_USER_REQUESTED.

Here is the call graph for this function:

◆ stopPointManager()

StopPointManager & SimulatorFrontend::stopPointManager ( )

Returns the StopPointManager.

Asserts if no StopPointManager is initiated.

Returns: The used StopPointManager.

Definition at line 2108 of file SimulatorFrontend.cc.

                                    {
    assert(stopPointManager_ != NULL);
    return *stopPointManager_;
}

References assert, and stopPointManager_.

Referenced by BPCommand::execute(), ConditionCommand::execute(), DeleteBPCommand::execute(), DisableBPCommand::execute(), EnableBPCommand::execute(), IgnoreCommand::execute(), InfoBreakpointsCommand::execute(), TBPCommand::execute(), WatchCommand::execute(), ProximDisassemblyWindow::loadProgram(), ProximDisassemblyWindow::onRightClick(), SimControlLanguageCommand::printBreakpointInfo(), SimControlLanguageCommand::printStopReasons(), ProximBreakpointWindow::refreshStopPoints(), and SimControlLanguageCommand::verifyBreakpointHandles().

◆ stopReason()

StopReason SimulatorFrontend::stopReason ( unsigned int index ) const

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 1356 of file SimulatorFrontend.cc.

                                                      {
    assert(simCon_ != NULL);
    return simCon_->stopReason(index);
}

References assert, simCon_, and TTASimulationController::stopReason().

Referenced by SimpleSimulatorFrontend::hadRuntimeError(), hasStopReason(), SimControlLanguageCommand::printStopReasons(), and tandemSimulate().

Here is the call graph for this function:

◆ stopReasonCount()

unsigned int SimulatorFrontend::stopReasonCount ( ) const

Returns the count of stop reasons.

Returns: The count of stop reasons.

Definition at line 1344 of file SimulatorFrontend.cc.

                                         {
    return (simCon_ != NULL && simCon_->stopReasonCount());
}

References simCon_, and TTASimulationController::stopReasonCount().

Referenced by SimpleSimulatorFrontend::hadRuntimeError(), hasStopReason(), SimControlLanguageCommand::printStopReasons(), and tandemSimulate().

Here is the call graph for this function:

◆ stopTimer()

void SimulatorFrontend::stopTimer ( )

protected

Saves the value of the wall-clock timer initialized with startTimer() to lastRunTime_ and the count of simulated cycles after startTimer() to lastRunCycleCount_.

Definition at line 938 of file SimulatorFrontend.cc.

                             {
    std::time_t now = time(NULL);
    lastRunTime_ = now - startTime_;
    CycleCount cycles = cycleCount();
    lastRunCycleCount_ = cycles - startCycleCount_;
}

References cycleCount(), lastRunCycleCount_, lastRunTime_, startCycleCount_, and startTime_.

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

Here is the call graph for this function:

◆ utilizationDataSaving()

bool SimulatorFrontend::utilizationDataSaving ( ) const

Returns true in case utilization data saving is enabled.

Returns: True in case utilization data saving is enabled.

Definition at line 1847 of file SimulatorFrontend.cc.

                                               {
    return saveUtilizationData_;
}

References saveUtilizationData_.

Referenced by SimulatorSettingsDialog::onOK(), and SimulatorSettingsDialog::TransferDataToWindow().

◆ utilizationStatistics()

const UtilizationStats & SimulatorFrontend::utilizationStatistics ( int core = -1 )

Returns the current utilization statistics of the processor.

Recalculates the statistics in case they are old, that is, simulation has been continued or restarted since it was calculated. Should not be called in case simulation is not initialized!

Todo:: : unimplemented for remote debuggers

Definition at line 2155 of file SimulatorFrontend.cc.

                                                 {
    if (core == -1) 
        core = selectedCore();
 
    utilizationStats_.resize(1);
 
    UtilizationStats* utilizationStats = utilizationStats_.at(core);
 
    if (utilizationStats == NULL) {
        // stats calculation differs slightly for compiled & interpretive sims.
        if (!isCompiledSimulation()) {
            utilizationStats = new UtilizationStats();
            SimulationStatistics stats(
                *currentProgram_, 
                dynamic_cast<SimulationController*>(
                    simCon_)->instructionMemory(core));
            stats.addStatistics(*utilizationStats);
            stats.calculate();
        } else {
            CompiledSimUtilizationStats* compiledSimUtilizationStats =
                new CompiledSimUtilizationStats();
            CompiledSimController& compiledSimCon = 
                dynamic_cast<CompiledSimController&>(*simCon_);
            compiledSimUtilizationStats->calculate(program(), 
                *compiledSimCon.compiledSimulation());
            utilizationStats = compiledSimUtilizationStats;
        }
        utilizationStats_[core] = utilizationStats;
    }
    return *utilizationStats;
}

References SimulationStatistics::addStatistics(), SimulationStatistics::calculate(), CompiledSimUtilizationStats::calculate(), CompiledSimController::compiledSimulation(), currentProgram_, isCompiledSimulation(), program(), selectedCore(), simCon_, and utilizationStats_.

Referenced by ProximBusDetailsCmd::Do(), ProximFUDetailsCmd::Do(), ProximIUDetailsCmd::Do(), ProximRFDetailsCmd::Do(), ProximSocketDetailsCmd::Do(), InfoProcCommand::execute(), InfoStatsCommand::execute(), finishSimulation(), and ProximMachineStateWindow::setUtilizationHighlights().

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ timeoutThread

void timeoutThread	(	unsigned int	timeout,
		SimulatorFrontend *	simFE
	)

friend

A thread function for handling simulation timeout

Parameters

timeout timeout in seconds

Definition at line 951 of file SimulatorFrontend.cc.

                                                              {
    if (timeout == 0) {
        return;
    }
      
    TTASimulationController* simCon = simFE->simCon_;
    boost::xtime xt; 
    boost::xtime xtPoll; 
#if BOOST_VERSION < 105000
    boost::xtime_get(&xt, boost::TIME_UTC);
#else
    /* TIME_UTC was replaced by TIME_UTC_ in boost 1.50, to avoid
     * clashing with a similarly named C11 macro. */
    boost::xtime_get(&xt, boost::TIME_UTC_);
#endif
    unsigned int pollTime = 5; // poll time in seconds
    xtPoll = xt;
    xt.sec += timeout; 
 
    xtPoll.sec += pollTime;
    while (xt.sec > xtPoll.sec) {
        boost::thread::sleep(xtPoll);
        xtPoll.sec += pollTime;
        if (simCon != simFE->simCon_) {
            return;
        }
    }
    boost::thread::sleep(xt);
 
    if (simCon != simFE->simCon_) {
        return;
    }
 
    if (!simFE->hasSimulationEnded()) {
        simFE->prepareToStop(SRE_AFTER_TIMEOUT);
    }
}

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

Member Data Documentation

◆ busTracing_

bool SimulatorFrontend::busTracing_

protected

Is bus tracing, i.e., storing the values of buses in each clock cycle enabled.

Definition at line 315 of file SimulatorFrontend.hh.

Referenced by busTracing(), initializeTracing(), and setBusTracing().

◆ busTrackers_

std::vector<BusTracker*> SimulatorFrontend::busTrackers_

protected

The tracker for saving bus trace.

Definition at line 335 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), and initializeTracing().

◆ callHistoryLength_

std::size_t SimulatorFrontend::callHistoryLength_

protected

The length of call history to store in memory for the commands that need it.

Definition at line 390 of file SimulatorFrontend.hh.

Referenced by callHistoryLength(), setCallHistoryLength(), and setupCallHistoryTracking().

◆ callPathTrackers_

std::vector<CallPathTracker*> SimulatorFrontend::callPathTrackers_

protected

The call path trackers for each core, in case tracking is enabled.

Definition at line 392 of file SimulatorFrontend.hh.

Referenced by callPathTracker(), finishSimulation(), and setupCallHistoryTracking().

◆ currentBackend_

SimulationType SimulatorFrontend::currentBackend_

protected

Type of "backend" this Frontend has.

Definition at line 306 of file SimulatorFrontend.hh.

Referenced by initializeMemorySystem(), initializeSimulation(), isCompiledSimulation(), isCustomDebugger(), isTCEDebugger(), and setCompiledSimulation().

◆ currentMachine_

const TTAMachine::Machine* SimulatorFrontend::currentMachine_

protected

Machine to run simulation with.

Definition at line 292 of file SimulatorFrontend.hh.

Referenced by findBooleanRegister(), findPort(), findRegister(), FUPortValue(), immediateUnitRegisterValue(), initializeDisassembler(), initializeMemorySystem(), initializeSimulation(), isMachineLoaded(), loadMachine(), loadMachine(), loadProgram(), loadProgram(), machine(), state(), and ~SimulatorFrontend().

◆ currentProgram_

const TTAProgram::Program* SimulatorFrontend::currentProgram_

protected

Program to be simulated.

Definition at line 299 of file SimulatorFrontend.hh.

Referenced by currentProcedure(), disassembleInstruction(), finishSimulation(), initializeDataMemories(), initializeDisassembler(), initializeSimulation(), isProgramLoaded(), loadMachine(), loadMachine(), loadProgram(), loadProgram(), program(), programLocationDescription(), utilizationStatistics(), and ~SimulatorFrontend().

◆ detailedSimulation_

bool SimulatorFrontend::detailedSimulation_

protected

Set to true in case should build a detailed model which simulates FU stages, possibly with an external system-level model.

Definition at line 402 of file SimulatorFrontend.hh.

Referenced by initializeSimulation(), and setDetailedSimulation().

◆ disassembler_

POMDisassembler* SimulatorFrontend::disassembler_

mutableprotected

The disassembler used to print out instructions. This is initialized on demand.

Definition at line 309 of file SimulatorFrontend.hh.

Referenced by disassembleInstruction(), initializeDisassembler(), loadProgram(), programLocationDescription(), and ~SimulatorFrontend().

◆ eventHandler_

SimulationEventHandler* SimulatorFrontend::eventHandler_

protected

Per simulation instance of SimulationEventHandler.

Definition at line 370 of file SimulatorFrontend.hh.

Referenced by eventHandler(), and ~SimulatorFrontend().

◆ executionTracing_

bool SimulatorFrontend::executionTracing_

protected

Is execution tracing, i.e., storing the executed instruction addresses to the trace database, enabled.

Definition at line 312 of file SimulatorFrontend.hh.

Referenced by executionTracing(), initializeTracing(), and setExecutionTracing().

◆ executionTrackers_

std::vector<ExecutionTracker*> SimulatorFrontend::executionTrackers_

protected

The simple execution tracker for storing trace of executed instructions.

Definition at line 332 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), and initializeTracing().

◆ forcedTraceDBFileName_

std::string SimulatorFrontend::forcedTraceDBFileName_

protected

If set, forces the SQLite filename of trace DB to this name.

Definition at line 394 of file SimulatorFrontend.hh.

Referenced by forceTraceDBFileName(), and initializeTracing().

◆ fuResourceConflictDetection_

bool SimulatorFrontend::fuResourceConflictDetection_

protected

If this is enabled before initialization, FU resource conflicts are detected (slows down simulation).

Definition at line 353 of file SimulatorFrontend.hh.

Referenced by fuResourceConflictDetection(), initializeSimulation(), and setFUResourceConflictDetection().

◆ lastRunCycleCount_

ClockCycleCount SimulatorFrontend::lastRunCycleCount_

protected

The cycle count of the last non-interrupted simulation phase.

Definition at line 372 of file SimulatorFrontend.hh.

Referenced by killSimulation(), lastRunCycleCount(), and stopTimer().

◆ lastRunTime_

double SimulatorFrontend::lastRunTime_

protected

The wall clock time of the last non-interrupted simulation phase in seconds.

Definition at line 375 of file SimulatorFrontend.hh.

Referenced by lastRunTime(), and stopTimer().

◆ leaveCompiledDirty_

bool SimulatorFrontend::leaveCompiledDirty_

protected

True in case the compilation simulation should not cleanup at destruction the engine source files.

Definition at line 387 of file SimulatorFrontend.hh.

Referenced by initializeSimulation(), and setCompiledSimulationLeaveDirty().

◆ machineOwnedByFrontend_

bool SimulatorFrontend::machineOwnedByFrontend_

protected

Is the machine owned by SimulatorFrontend or by the client?

Definition at line 297 of file SimulatorFrontend.hh.

Referenced by loadMachine(), loadMachine(), and ~SimulatorFrontend().

◆ memoryAccessTracking_

bool SimulatorFrontend::memoryAccessTracking_

protected

If this is enabled before initialization, memory access tracking is enabled. (slows down simulation)

Definition at line 368 of file SimulatorFrontend.hh.

Referenced by initializeMemorySystem(), memoryAccessTracking(), and setMemoryAccessTracking().

◆ memorySystems_

std::vector<MemorySystem*> SimulatorFrontend::memorySystems_

protected

The simulation models of the memories in the currently loaded machine for each core.

Definition at line 397 of file SimulatorFrontend.hh.

Referenced by initializeMemorySystem(), loadMachine(), loadMachine(), memorySystem(), and ~SimulatorFrontend().

◆ outputStream_

std::ostream* SimulatorFrontend::outputStream_

protected

Default output stream.

Definition at line 364 of file SimulatorFrontend.hh.

Referenced by outputStream(), and setOutputStream().

◆ printNextInstruction_

bool SimulatorFrontend::printNextInstruction_

protected

If true, the next simulated instructions is printed to stdout when simulation stops.

Definition at line 356 of file SimulatorFrontend.hh.

Referenced by nextInstructionPrinting(), and setNextInstructionPrinting().

◆ printSimulationTimeStatistics_

bool SimulatorFrontend::printSimulationTimeStatistics_

protected

True if the simulation time statistics should be printed out.

Definition at line 358 of file SimulatorFrontend.hh.

Referenced by setSimulationTimeStatistics(), and simulationTimeStatistics().

◆ procedureTransferTracing_

bool SimulatorFrontend::procedureTransferTracing_

protected

Is procedure transfer access tracking enabled.

Definition at line 319 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), procedureTransferTracing(), and setProcedureTransferTracing().

◆ procedureTransferTrackers_

std::vector<ProcedureTransferTracker*> SimulatorFrontend::procedureTransferTrackers_

protected

The procedure transfer tracker.

Definition at line 341 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), and initializeTracing().

◆ programErrorReports_

ProgramErrorDescriptionList SimulatorFrontend::programErrorReports_

protected

Runtime error reports.

Definition at line 384 of file SimulatorFrontend.hh.

Referenced by clearProgramErrorReports(), programErrorReport(), programErrorReportCount(), and reportSimulatedProgramError().

◆ programFileName_

std::string SimulatorFrontend::programFileName_

protected

The source file of the program to be simulated. Used to generate the file name of the trace data base.

Definition at line 302 of file SimulatorFrontend.hh.

Referenced by initializeTracing(), loadProgram(), and ~SimulatorFrontend().

◆ programOwnedByFrontend_

bool SimulatorFrontend::programOwnedByFrontend_

protected

Is the program owned by SimulatorFrontend or by the client?

Definition at line 304 of file SimulatorFrontend.hh.

Referenced by loadMachine(), loadMachine(), loadProgram(), loadProgram(), and ~SimulatorFrontend().

◆ rfAccessTracing_

bool SimulatorFrontend::rfAccessTracing_

protected

Is register file (concurrent) access tracking enabled.

Definition at line 317 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), rfAccessTracing(), and setRFAccessTracing().

◆ rfAccessTrackers_

std::vector<RFAccessTracker*> SimulatorFrontend::rfAccessTrackers_

protected

The register file access tracker.

Definition at line 338 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), and rfAccessTracker().

◆ saveProfileData_

bool SimulatorFrontend::saveProfileData_

protected

Is saving of profile data to TraceDB enabled.

Definition at line 321 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), profileDataSaving(), and setProfileDataSaving().

◆ saveUtilizationData_

bool SimulatorFrontend::saveUtilizationData_

protected

Is saving of utilization data to TraceDB enabled.

Definition at line 323 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), setUtilizationDataSaving(), and utilizationDataSaving().

◆ simCon_

TTASimulationController* SimulatorFrontend::simCon_

protected

If simulation is initialized, this contains a pointer to the simulation controller.

Definition at line 295 of file SimulatorFrontend.hh.

Referenced by automaticFinishImpossible(), currentProcedure(), cycleCount(), executableInstructionAt(), finishSimulation(), FUPortValue(), hasSimulationEnded(), hasStopReason(), immediateUnitRegisterValue(), initializeDataMemories(), initializeSimulation(), initializeTracing(), isProgramLoaded(), isSimulationInitialized(), isSimulationRunning(), isSimulationStopped(), killSimulation(), lastExecInstruction(), lastExecutedInstruction(), loadMachine(), loadMachine(), loadProgram(), machineState(), next(), prepareToStop(), programCounter(), registerFileValue(), run(), runUntil(), step(), stoppedByUser(), stopReason(), stopReasonCount(), utilizationStatistics(), and ~SimulatorFrontend().

◆ simulationTimeout_

unsigned int SimulatorFrontend::simulationTimeout_

protected

Simulation timeout in seconds.

Definition at line 382 of file SimulatorFrontend.hh.

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

◆ startCycleCount_

CycleCount SimulatorFrontend::startCycleCount_

protected

The cycle count when the latest simulation was started. Used to compute simulation speed.

Definition at line 380 of file SimulatorFrontend.hh.

Referenced by startTimer(), and stopTimer().

◆ startTime_

std::time_t SimulatorFrontend::startTime_

protected

The time of the last simulation start. Used to compute simulation speed.

Definition at line 377 of file SimulatorFrontend.hh.

Referenced by startTimer(), and stopTimer().

◆ staticCompilation_

bool SimulatorFrontend::staticCompilation_

protected

True if the compiled simulation should use static compilation.

Definition at line 360 of file SimulatorFrontend.hh.

Referenced by setStaticCompilation(), and staticCompilation().

◆ stopPointManager_

StopPointManager* SimulatorFrontend::stopPointManager_

protected

The breakpoint manager to be used to bookkeep breakpoints.

Definition at line 344 of file SimulatorFrontend.hh.

Referenced by initializeSimulation(), stopPointManager(), and ~SimulatorFrontend().

◆ tpef_

TPEF::Binary* SimulatorFrontend::tpef_

protected

The source TPEF file.

Definition at line 350 of file SimulatorFrontend.hh.

Referenced by initializeDataMemories(), loadProgram(), and ~SimulatorFrontend().

◆ traceDBOwned_

std::vector<bool> SimulatorFrontend::traceDBOwned_

protected

Whether traceDB at index is owned by simulator (or taken away by client using lastTraceDB())

Definition at line 328 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), and lastTraceDB().

◆ traceDBs_

std::vector<ExecutionTrace*> SimulatorFrontend::traceDBs_

protected

The database to use for execution trace data.

Definition at line 325 of file SimulatorFrontend.hh.

Referenced by finishSimulation(), initializeTracing(), and lastTraceDB().

◆ traceFileNameSetByUser_

bool SimulatorFrontend::traceFileNameSetByUser_

protected

Flag that indicates is the trace file name set by user.

Definition at line 362 of file SimulatorFrontend.hh.

◆ utilizationStats_

std::vector<UtilizationStats*> SimulatorFrontend::utilizationStats_

protected

Processor utilization statistics.

Definition at line 347 of file SimulatorFrontend.hh.

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

◆ zeroFillMemoriesOnReset_

bool SimulatorFrontend::zeroFillMemoriesOnReset_

protected

Set to true in case the memories should be set to zero at reset.

Definition at line 399 of file SimulatorFrontend.hh.

Referenced by initializeDataMemories(), and setZeroFillMemoriesOnReset().

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ProgramErrorDescription

◆ ProgramErrorDescriptionList

Member Enumeration Documentation

◆ RuntimeErrorSeverity

◆ SimulationType

Constructor & Destructor Documentation

◆ SimulatorFrontend()

◆ ~SimulatorFrontend()

Member Function Documentation

◆ automaticFinishImpossible()

◆ busTracing()

◆ callHistoryLength()

◆ callPathTracker()

◆ clearProgramErrorReports()

◆ compareState()

◆ currentProcedure()

◆ cycleCount()

◆ disassembleInstruction()

◆ eventHandler()

◆ executableInstructionAt()

◆ executionTracing()

◆ findBooleanRegister()

◆ findPort()

◆ findRegister()

◆ finishSimulation()

◆ forceTraceDBFileName()

◆ FUPortValue()

◆ fuResourceConflictDetection()

◆ hasSimulationEnded()

◆ hasStopReason()

◆ immediateUnitRegisterValue()

◆ initializeDataMemories()

◆ initializeDisassembler()

◆ initializeMemorySystem()

◆ initializeSimulation()

◆ initializeTracing()

◆ isCompiledSimulation()

◆ isCustomDebugger()

◆ isMachineLoaded()

◆ isProgramLoaded()

◆ isSimulationInitialized()

◆ isSimulationRunning()

◆ isSimulationStopped()

◆ isTCEDebugger()

◆ killSimulation()

◆ lastExecInstruction()

◆ lastExecutedInstruction()

◆ lastRunCycleCount()

◆ lastRunTime()

◆ lastTraceDB()

◆ loadMachine() [1/2]

◆ loadMachine() [2/2]

◆ loadProcessorConfiguration()

◆ loadProgram() [1/2]

◆ loadProgram() [2/2]

◆ machine()

◆ machineState()

◆ memoryAccessTracking()

◆ memorySystem()

◆ next()

◆ nextInstructionPrinting()

◆ outputStream()

◆ prepareToStop()

◆ procedureTransferTracing()

◆ profileDataSaving()

◆ program()

◆ programCounter()

◆ programErrorReport()

◆ programErrorReportCount()

◆ programLocationDescription()

◆ registerFileValue()

◆ reportSimulatedProgramError()