#include <SimulationController.hh>

Inheritance diagram for SimulationController:

Collaboration diagram for SimulationController:

Public Member Functions
	SimulationController (SimulatorFrontend &frontend, const TTAMachine::Machine &machine, const TTAProgram::Program &program, bool fuResourceConflictDetection=true, bool detailedSimulation=false)

virtual	~SimulationController ()

virtual void	step (double count=1)

virtual void	next (int count=1)

virtual void	run ()

virtual void	runUntil (UIntWord address)

virtual void	reset ()

virtual InstructionAddress	programCounter () const

virtual MachineState &	machineState (int core=-1)

virtual const InstructionMemory &	instructionMemory (int core=-1) 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)

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

virtual	~TTASimulationController ()

virtual void	prepareToStop (StopReason reason)

virtual unsigned int	stopReasonCount () const

virtual StopReason	stopReason (unsigned int index) const

virtual SimulationStatus	state () const

virtual InstructionAddress	lastExecutedInstruction (int coreId=-1) const

virtual ClockCycleCount	clockCount () const

virtual MemorySystem &	memorySystem (int coreId=-1)

virtual SimulatorFrontend &	frontend ()

virtual bool	automaticFinishImpossible () const

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

Protected Types
typedef std::vector< MachineState * >	MachineStateContainer

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

Protected Member Functions
virtual bool	simulateCycle ()

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

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

Protected Attributes
MachineStateContainer	machineStates_
	The machine state models for the simulated cores.

std::vector< InstructionMemory * >	instructionMemories_
	The instruction memory models of cores.

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

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

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

bool	stopRequested_
	Flag indicating that simulation should stop.

StopReasonContainer	stopReasons_
	The set of reasons the simulation was stopped.

SimulationStatus	state_
	The current state of the simulation.

ClockCycleCount	clockCount_
	How many clock cycles have been simulated.

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

InstructionAddress	initialPC_
	The address of the first executed instruction.

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

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

Private Member Functions
	SimulationController (const SimulationController &)
	Copying not allowed.

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

void	buildFUResourceConflictDetectors (const TTAMachine::Machine &machine)

void	findExitPoints (const TTAProgram::Program &program, const TTAMachine::Machine &machine)

MachineState &	selectedMachineState ()

InstructionMemory &	selectedInstructionMemory ()

Private Attributes
MultiCoreFUConflictDetectorIndex	fuConflictDetectors_
	The FU resource conflict detectors used to detect conflicts during simulation.

std::vector< FUResourceConflictDetector * >	conflictDetectorVector_
	Resource conflict detectors in a more quickly traversed container.

std::vector< InstructionAddress >	tmpExecutedInstructions_
	Temporary place for lastExecuted Instruction.

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

Detailed Description

Controls the simulation running in stand-alone mode.

Supports also homogeneous multicore simulation when ADF's core-count > 1.

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

Definition at line 46 of file SimulationController.hh.

Member Typedef Documentation

◆ MachineStateContainer

typedef std::vector<MachineState*> SimulationController::MachineStateContainer

protected

Definition at line 87 of file SimulationController.hh.

Constructor & Destructor Documentation

◆ SimulationController() [1/2]

SimulationController::SimulationController	(	SimulatorFrontend &	frontend,
		const TTAMachine::Machine &	machine,
		const TTAProgram::Program &	program,
		bool	fuResourceConflictDetection = `true`,
		bool	detailedSimulation = `false`
	)

Constructor.

Parameters

machine	Machine to be simulated.
memSys	Memory system.
fuResourceConflictDetection	Should the model detect FU resource conflicts.

Exceptions

Exception Exceptions while building the simulation models are thrown forward.

Definition at line 87 of file SimulationController.cc.

                             :
    TTASimulationController(frontend, machine, program),
    tmpExecutedInstructions_(1) {
 
    if (fuResourceConflictDetection)
        buildFUResourceConflictDetectors(machine);
 
    for (int i = 0; i < 1; ++i) {
        frontend_.selectCore(i);
        MachineStateBuilder builder(detailedSimulation);
        MachineState* machineState = NULL;
 
        if (fuResourceConflictDetection) {
            machineState = builder.build(
                machine, frontend.memorySystem(i), fuConflictDetectors_.at(i));
        } else {
            machineState = builder.build(machine, frontend.memorySystem(i));
        }
        // set the real time clock source to be the simulation
        // cycle counter
        for (int i = 0; i < machineState->FUStateCount(); ++i) {
            FUState& fuState = machineState->fuState(i);
            fuState.context().setCycleCountVariable(clockCount_);
        }   
        machineStates_.push_back(machineState);
    }
    frontend_.selectCore(0);
    
    SimProgramBuilder programBuilder;
    for (int i = 0; i < 1; ++i) {
        InstructionMemory* instructionMemory = 
            programBuilder.build(program, *machineStates_[i]);
        instructionMemories_.push_back(instructionMemory);
    }  
 
    findExitPoints(program, machine);
    reset();
}

References MachineStateBuilder::build(), SimProgramBuilder::build(), buildFUResourceConflictDetectors(), TTASimulationController::clockCount_, FUState::context(), findExitPoints(), TTASimulationController::frontend(), TTASimulationController::frontend_, fuConflictDetectors_, MachineState::fuState(), MachineState::FUStateCount(), instructionMemories_, instructionMemory(), machine, machineState(), machineStates_, SimulatorFrontend::memorySystem(), program, reset(), SimulatorFrontend::selectCore(), and OperationContext::setCycleCountVariable().

Here is the call graph for this function:

◆ ~SimulationController()

SimulationController::~SimulationController ( )

virtual

Destructor.

Definition at line 134 of file SimulationController.cc.

                                            {
 
    SequenceTools::deleteAllItems(machineStates_);
    SequenceTools::deleteAllItems(instructionMemories_);
    SequenceTools::deleteAllItems(conflictDetectorVector_);
}

References conflictDetectorVector_, SequenceTools::deleteAllItems(), instructionMemories_, and machineStates_.

Here is the call graph for this function:

◆ SimulationController() [2/2]

SimulationController::SimulationController ( const SimulationController & )

private

Copying not allowed.

Member Function Documentation

◆ buildFUResourceConflictDetectors()

void SimulationController::buildFUResourceConflictDetectors ( const TTAMachine::Machine & machine )

private

Builds the FU resource conflict detectors for each FU in the machine.

Uses the "lazy FSA" detection model.

Definition at line 522 of file SimulationController.cc.

                                      {
 
 
    for (int core = 0; core < 1; ++core) {
        const TTAMachine::Machine::FunctionUnitNavigator nav = 
            machine.functionUnitNavigator();
 
        fuConflictDetectors_.push_back(FUConflictDetectorIndex());
 
        for (int i = 0; i < nav.count(); ++i) {
            const TTAMachine::FunctionUnit& fu = *nav.item(i);
            FUResourceConflictDetector* detector = 
                new FSAFUResourceConflictDetector(fu);
            fuConflictDetectors_[core][fu.name()] = detector;
            conflictDetectorVector_.push_back(detector);
        }
    }
}

References conflictDetectorVector_, TTAMachine::Machine::Navigator< ComponentType >::count(), fuConflictDetectors_, TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, and TTAMachine::Component::name().

Referenced by SimulationController().

Here is the call graph for this function:

◆ findExitPoints()

void SimulationController::findExitPoints	(	const TTAProgram::Program &	program,
		const TTAMachine::Machine &	machine
	)

private

Definition at line 398 of file SimulationController.cc.

                                      {
 
    std::set<InstructionAddress> exitPoints_ =
        findProgramExitPoints(program, machine);
 
    for (std::set<InstructionAddress>::iterator it = exitPoints_.begin();
         it != exitPoints_.end(); ++it) {
        for (std::size_t i = 0; i < instructionMemories_.size(); ++i) {
            instructionMemories_[i]->instructionAt(*it).setExitPoint(true);
        }
    }
}

References TTASimulationController::findProgramExitPoints(), instructionMemories_, machine, and program.

Referenced by SimulationController().

Here is the call graph for this function:

◆ FUPortValue()

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

Implements TTASimulationController.

Definition at line 510 of file SimulationController.cc.

                                                        {
 
    return (selectedMachineState().portState(portName, fuName)).value();
}

References selectedMachineState().

Here is the call graph for this function:

◆ immediateUnitRegisterValue()

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

virtual

Returns the current value of a IU register

Parameters

iuName	name of the immediate unit
index	index of the register

Returns: Current value of a IU register

Implements TTASimulationController.

Definition at line 495 of file SimulationController.cc.

                                        {
 
    return (selectedMachineState().longImmediateUnitState(iuName)).
        registerValue(index);
}

References selectedMachineState().

Here is the call graph for this function:

◆ instructionMemory()

const InstructionMemory & SimulationController::instructionMemory ( int core = -1 ) const

virtual

Definition at line 543 of file SimulationController.cc.

                                                      {
    if (core == -1) core = frontend_.selectedCore();
    return *instructionMemories_.at(core);
}

References TTASimulationController::frontend_, instructionMemories_, and SimulatorFrontend::selectedCore().

Referenced by SimulationController().

Here is the call graph for this function:

◆ machineState()

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

virtual

Returns a reference to the currently selected machine state model.

Definition at line 145 of file SimulationController.cc.

                                           {
    if (core == -1) core = frontend_.selectedCore();
    return *machineStates_.at(core);
}

References TTASimulationController::frontend_, machineStates_, and SimulatorFrontend::selectedCore().

Referenced by OTASimulationController::advanceMachineCycle(), SimulatorFrontend::machineState(), OTASimulationController::simulateCycle(), simulateCycle(), and SimulationController().

Here is the call graph for this function:

◆ next()

void SimulationController::next ( int count = 1 )

virtual

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

Parameters

count Number of steps to simulate.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 297 of file SimulationController.cc.

                                    {
    stopRequested_ = false;
    stopReasons_.clear();
    state_ = STA_RUNNING;
 
    bool inCalledProcedure = false;
    const Procedure& procedureWhereStartedStepping = 
        dynamic_cast<const Procedure&>(
            program_.instructionAt(programCounter()).parent());
 
    int counter = 0;
    while (!stopRequested_ && counter < count) {
 
        // simulate cycles until we come back to the procedure we started
        // simulating from or until the program ends
        do {
            const bool programEnded = !simulateCycle();
 
            if (programEnded) {
                prepareToStop(SRE_AFTER_UNTIL);
            } else {
                const Procedure& currentProcedure =
                    dynamic_cast<const Procedure&>(
                        program_.instructionAt(programCounter()).parent());
                inCalledProcedure = 
                    (&procedureWhereStartedStepping != &currentProcedure);
            }
        } while (inCalledProcedure && !stopRequested_);
        ++counter;
    }
 
    if (counter == count && !inCalledProcedure) {
        prepareToStop(SRE_AFTER_STEPPING);
    }
 
    if (state_ != STA_FINISHED)
        state_ = STA_STOPPED;
 
    frontend_.eventHandler().handleEvent(
        SimulationEventHandler::SE_SIMULATION_STOPPED);
}

Here is the call graph for this function:

◆ operator=()

SimulationController & SimulationController::operator= ( const SimulationController & )

private

Assignment not allowed.

◆ programCounter()

InstructionAddress SimulationController::programCounter ( ) const

virtual

Returns the program counter value of the currently selected core.

Implements TTASimulationController.

Definition at line 444 of file SimulationController.cc.

                                           {
    return machineStates_.at(frontend_.selectedCore())->gcuState().programCounter();
}

References TTASimulationController::frontend_, machineStates_, and SimulatorFrontend::selectedCore().

Referenced by next(), and runUntil().

Here is the call graph for this function:

◆ registerFileValue()

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

virtual

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

Parameters

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

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

Exceptions

InstanceNotFound If the register cannot be found.

Implements TTASimulationController.

Definition at line 457 of file SimulationController.cc.

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

References SimulatorFrontend::findRegister(), TTASimulationController::frontend_, SimValue::hexValue(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Machine::registerFileNavigator(), TTASimulationController::sourceMachine_, Conversion::toString(), and ReadableState::value().

Here is the call graph for this function:

◆ reset()

void SimulationController::reset ( )

virtual

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

Resets the program counter to its initial value, and also clears the instrution execution counts and states of possible FU resource conflict detectors.

Implements TTASimulationController.

Definition at line 421 of file SimulationController.cc.

                            {
 
    state_ = STA_INITIALIZING;
    stopRequested_ = false;
    clockCount_ = 0;
    state_ = STA_INITIALIZED;
 
    for (int core = 0; core < 1; ++core) {
        machineStates_.at(core)->gcuState().programCounter() = initialPC_;
        machineStates_.at(core)->setFinished(false);
        machineStates_.at(core)->resetAllFUs();
        instructionMemories_.at(core)->resetExecutionCounts();
    }
 
    for (std::size_t vec = 0; vec < conflictDetectorVector_.size(); ++vec) {
        conflictDetectorVector_.at(vec)->reset();
    }
}

References TTASimulationController::clockCount_, conflictDetectorVector_, TTASimulationController::initialPC_, instructionMemories_, machineStates_, TTASimulationController::STA_INITIALIZED, TTASimulationController::STA_INITIALIZING, TTASimulationController::state_, and TTASimulationController::stopRequested_.

Referenced by SimulationController().

◆ run()

void SimulationController::run ( )

virtual

Advance simulation until a condition for stopping is enabled.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 346 of file SimulationController.cc.

                          {
    stopRequested_ = false;
    stopReasons_.clear();
    state_ = STA_RUNNING;
 
    while (!stopRequested_) {
        simulateCycle();
    }
    if (state_ != STA_FINISHED)
        state_ = STA_STOPPED;
 
    frontend_.eventHandler().handleEvent(
        SimulationEventHandler::SE_SIMULATION_STOPPED);
}

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

Here is the call graph for this function:

◆ runUntil()

void SimulationController::runUntil ( UIntWord address )

virtual

Advance simulation until given address is reached.

Parameters

address The instruction address to reach.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 369 of file SimulationController.cc.

                                               {
    stopRequested_ = false;
    stopReasons_.clear();
    state_ = STA_RUNNING;
 
    while (!stopRequested_) {
        simulateCycle();
 
        if (state_ == STA_FINISHED)
            return;
 
        if (selectedMachineState().gcuState().programCounter() == address) {
            prepareToStop(SRE_AFTER_UNTIL);
            state_ = STA_STOPPED;
            frontend_.eventHandler().handleEvent(
                SimulationEventHandler::SE_SIMULATION_STOPPED);
            return;
        }
    }
    
    if (state_ != STA_FINISHED) {
        state_ = STA_STOPPED;
    }
    
    frontend_.eventHandler().handleEvent(
        SimulationEventHandler::SE_SIMULATION_STOPPED);
}

References SimulatorFrontend::eventHandler(), TTASimulationController::frontend_, Informer::handleEvent(), TTASimulationController::prepareToStop(), programCounter(), SimulationEventHandler::SE_SIMULATION_STOPPED, selectedMachineState(), simulateCycle(), SRE_AFTER_UNTIL, TTASimulationController::STA_FINISHED, TTASimulationController::STA_RUNNING, TTASimulationController::STA_STOPPED, TTASimulationController::state_, TTASimulationController::stopReasons_, and TTASimulationController::stopRequested_.

Here is the call graph for this function:

◆ selectedInstructionMemory()

InstructionMemory & SimulationController::selectedInstructionMemory ( )

private

Definition at line 554 of file SimulationController.cc.

                                                {
    return *instructionMemories_.at(frontend_.selectedCore());
}

References TTASimulationController::frontend_, instructionMemories_, and SimulatorFrontend::selectedCore().

Here is the call graph for this function:

◆ selectedMachineState()

MachineState & SimulationController::selectedMachineState ( )

private

Definition at line 549 of file SimulationController.cc.

                                           { 
    return *machineStates_.at(frontend_.selectedCore());
}

References TTASimulationController::frontend_, machineStates_, and SimulatorFrontend::selectedCore().

Referenced by FUPortValue(), immediateUnitRegisterValue(), and runUntil().

Here is the call graph for this function:

◆ simulateCycle()

bool SimulationController::simulateCycle ( )

protectedvirtual

Simulates a cycle.

Returns: false in case there are no more instructions to execute, that is, the simulation ended sucessfully, true in case there are more instructions to execute.

Reimplemented in OTASimulationController.

Definition at line 158 of file SimulationController.cc.

                                    {
 
    tmpExecutedInstructions_ = lastExecutedInstruction_;
 
    // The number of cores that have reached the exit function,
    // use this to stop automatically after all of them have
    // called it.
    unsigned finishedCoreCount = 0;
    bool finished = false;
    for (int core = 0; core < 1; ++core) {
        MachineState* machineState = machineStates_[core];
 
        if (machineState->isFinished()) {
            ++finishedCoreCount;
            continue;
        }
        
        GCUState& gcu = machineState->gcuState();
        const InstructionAddress& pc = gcu.programCounter();
 
        MemorySystem* memorySystem = &frontend_.memorySystem(core);
        try {
            machineState->clearBuses();
 
            ExecutableInstruction* instruction = 
                &(instructionMemories_[core]->instructionAt(pc));
 
            instruction->execute();
 
            tmpExecutedInstructions_[core] = pc;
        
            machineState->endClockOfAllFUStates();
 
            if (!gcu.isIdle()) {
                gcu.endClock();
            }
            
            memorySystem->advanceClockOfLocalMemories();
            machineState->advanceClockOfAllFUStates();
 
            ++gcu.programCounter();
            if (!gcu.isIdle())
                gcu.advanceClock();
 
            machineState->advanceClockOfAllGuardStates();
            machineState->advanceClockOfAllLongImmediateUnitStates();
 
            // check if the instruction was a return point from the program or
            // the next executed instruction would be sequentially over the
            // instruction space (PC+1 would overflow out of the program)
            if (instruction->isExitPoint() || 
                gcu.programCounter() == firstIllegalInstructionIndex_) {
                machineState->setFinished();
                ++finishedCoreCount;
            } 
        } catch (const Exception& e) {
            frontend_.selectCore(core);
            frontend_.reportSimulatedProgramError(
                SimulatorFrontend::RES_FATAL,
                e.errorMessage());
            prepareToStop(SRE_RUNTIME_ERROR);
            return false;
        } 
    }
    
    if (finishedCoreCount == 1)
        finished = true;
 
    // assume all cores have identical memory systems, thus it's enough
    // to advance the simulation clock only once for the first core's
    // memory system's shared memory instance
    frontend_.memorySystem(0).advanceClockOfSharedMemories();    
 
    // detect FU pipeline resource conflicts
    size_t conflictDetectorVectorSize = conflictDetectorVector_.size();
    for (std::size_t i = 0; i < conflictDetectorVectorSize; ++i) {
        FUResourceConflictDetector& detector = 
            *conflictDetectorVector_[i];
        if (!detector.isIdle())
            detector.advanceClock();
    }
 
    frontend_.eventHandler().handleEvent(SimulationEventHandler::SE_CYCLE_END);
 
    lastExecutedInstruction_ = tmpExecutedInstructions_;
 
    ++clockCount_;
 
    if (finished) {
        state_ = STA_FINISHED;
        stopRequested_ = true;
        return false;
    }
 
    frontend_.eventHandler().handleEvent(
        SimulationEventHandler::SE_NEW_INSTRUCTION);
    return true;
}

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

Here is the call graph for this function:

◆ step()

void SimulationController::step ( double count = 1 )

virtual

Advance simulation by a given amout of cycles.

Parameters

count The number of cycles the simulation is advanced.

Exceptions

SimulationExecutionError If a runtime error occurs in the simulated program.

Implements TTASimulationController.

Definition at line 265 of file SimulationController.cc.

                                       {
    assert(state_ == STA_STOPPED || state_ == STA_INITIALIZED);
    stopReasons_.clear();
    state_ = STA_RUNNING;
    stopRequested_ = false;
 
    double counter = 0;
    while (counter < count && !stopRequested_) {
        simulateCycle();
        ++counter;
    }
 
    if (counter == count) {
        prepareToStop(SRE_AFTER_STEPPING);
    }
 
    if (state_ != STA_FINISHED)
        state_ = STA_STOPPED;
 
    frontend_.eventHandler().handleEvent(
        SimulationEventHandler::SE_SIMULATION_STOPPED);
}

Here is the call graph for this function:

Member Data Documentation

◆ conflictDetectorVector_

std::vector<FUResourceConflictDetector*> SimulationController::conflictDetectorVector_

private

Resource conflict detectors in a more quickly traversed container.

Definition at line 112 of file SimulationController.hh.

Referenced by buildFUResourceConflictDetectors(), reset(), simulateCycle(), and ~SimulationController().

◆ fuConflictDetectors_

MultiCoreFUConflictDetectorIndex SimulationController::fuConflictDetectors_

private

The FU resource conflict detectors used to detect conflicts during simulation.

Definition at line 110 of file SimulationController.hh.

Referenced by buildFUResourceConflictDetectors(), and SimulationController().

◆ instructionMemories_

std::vector<InstructionMemory*> SimulationController::instructionMemories_

protected

The instruction memory models of cores.

Definition at line 92 of file SimulationController.hh.

Referenced by findExitPoints(), instructionMemory(), reset(), selectedInstructionMemory(), OTASimulationController::simulateCycle(), simulateCycle(), SimulationController(), and ~SimulationController().

◆ machineStates_

MachineStateContainer SimulationController::machineStates_

protected

The machine state models for the simulated cores.

Definition at line 90 of file SimulationController.hh.

Referenced by OTASimulationController::advanceMachineCycle(), machineState(), programCounter(), reset(), selectedMachineState(), OTASimulationController::simulateCycle(), simulateCycle(), SimulationController(), and ~SimulationController().

◆ tmpExecutedInstructions_

std::vector<InstructionAddress> SimulationController::tmpExecutedInstructions_

private

Temporary place for lastExecuted Instruction.

Definition at line 114 of file SimulationController.hh.

Referenced by simulateCycle().

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

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MachineStateContainer

Constructor & Destructor Documentation

◆ SimulationController() [1/2]

◆ ~SimulationController()

◆ SimulationController() [2/2]

Member Function Documentation

◆ buildFUResourceConflictDetectors()

◆ findExitPoints()

◆ FUPortValue()

◆ immediateUnitRegisterValue()

◆ instructionMemory()

◆ machineState()

◆ next()

◆ operator=()

◆ programCounter()

◆ registerFileValue()

◆ reset()

◆ run()

◆ runUntil()

◆ selectedInstructionMemory()

◆ selectedMachineState()

◆ simulateCycle()

◆ step()

Member Data Documentation

◆ conflictDetectorVector_

◆ fuConflictDetectors_

◆ instructionMemories_

◆ machineStates_

◆ tmpExecutedInstructions_