CompiledSimCodeGenerator Class Reference

#include <CompiledSimCodeGenerator.hh>

Collaboration diagram for CompiledSimCodeGenerator:

Classes
struct	DelayedAssignment

Public Types
typedef std::set< std::string >	StringSet
	A type for std::string sets.
typedef std::map< InstructionAddress, InstructionAddress >	AddressMap
	A type for storing address-to-address combinations.

Public Member Functions
	CompiledSimCodeGenerator (const TTAMachine::Machine &machine, const TTAProgram::Program &program, const TTASimulationController &controller, bool fuResourceConflictDetection, bool handleCycleEnd, bool dynamicCompilation, bool basicBlockPerFile=false, bool functionPerFile=true, const TCEString &globalSymbolPrefix="")
virtual	~CompiledSimCodeGenerator ()
virtual void	generateToDirectory (const std::string &dirName)
virtual StringSet	createdFiles () const
virtual AddressMap	basicBlocks () const
virtual ProcedureBBRelations	procedureBBRelations () const

Static Public Member Functions
static TCETools::CIStringSet	supportedMemoryOperations ()

Private Types
typedef std::multimap< std::string, std::string >	OperationSymbolDeclarations
	A type for operation symbol declarations: 1=op.name 2=op.symbol.
typedef std::multimap< int, DelayedAssignment >	DelayedAssignments
	FU Result writes.
typedef std::map< std::string, int >	FUResultWrites
typedef std::map< std::string, int >	SimValueSymbolDeclarations
	Type for SimValue symbol declarations: string=symbolname, int=width.
typedef std::map< std::string, int >	GuardPipeline

Private Member Functions
	CompiledSimCodeGenerator (const CompiledSimCodeGenerator &)
	Copying not allowed.
CompiledSimCodeGenerator &	operator= (const CompiledSimCodeGenerator &)
	Assignment not allowed.
void	generateConstructorParameters ()
void	generateHeaderAndMainCode ()
void	generateConstructorCode ()
void	generateSimulationCode ()
void	findBasicBlocks () const
void	generateProcedureCode (const TTAProgram::Procedure &procedure)
void	generateShutdownCode (InstructionAddress address)
void	generateFUOutputUpdater ()
void	generateSimulationGetter ()
std::string	generateHaltCode (const std::string &message="")
void	generateAdvanceClockCode ()
void	updateDeclaredSymbolsList ()
void	updateSymbolsMap ()
void	generateSymbolDeclarations ()
void	generateJumpTableCode ()
void	generateMakefile ()
void	addDeclaredSymbol (const std::string &name, int width)
void	addUsedRFSymbols ()
std::string	handleJump (const TTAMachine::HWOperation &op)
std::string	handleOperation (const TTAMachine::HWOperation &op)
std::string	handleOperationWithoutDag (const TTAMachine::HWOperation &op)
std::string	detectConflicts (const TTAMachine::HWOperation &op)
std::string	generateGuardRead (const TTAProgram::Move &move)
std::string	generateGuardCondition (const TTAProgram::Move &move)
void	generateInstruction (const TTAProgram::Instruction &instruction)
std::string	generateTriggerCode (const TTAMachine::HWOperation &op)
std::string	generateStoreTrigger (const TTAMachine::HWOperation &op)
std::string	generateLoadTrigger (const TTAMachine::HWOperation &op)
bool	handleRegisterWrite (const std::string &regSymbolName, std::ostream &stream)
std::string	guardPipelineTopSymbol (const TTAMachine::RegisterGuard &guard)
void	generateGuardPipelineVariables (std::ostream &stream)
void	generateGuardPipelineAdvance (std::ostream &stream)
std::string	generateAddFUResult (const TTAMachine::FUPort &resultPort, const std::string &value, int latency)
std::string	generateFUResultRead (const std::string &destination, const std::string &resultSymbol)
int	maxLatency () const
std::vector< TTAMachine::Port * >	fuOutputPorts (const TTAMachine::FunctionUnit &fu) const

Static Private Member Functions
static bool	isStoreOperation (const std::string &opName)
static bool	isLoadOperation (const std::string &opName)

Private Attributes
const TTAMachine::Machine &	machine_
	The machine used for simulation.
const TTAProgram::Program &	program_
	The simulated program.
const TTASimulationController &	simController_
	The simulator frontend.
const TTAMachine::ControlUnit &	gcu_
	GCU.
bool	handleCycleEnd_
	Should we let frontend handle each cycle end.
bool	dynamicCompilation_
	Is this a dynamic compiled simulation?
bool	basicBlockPerFile_
	Should the generator generate only one basic block per code file.
bool	functionPerFile_
	Should the generator start with a new file after function end.
SimValueSymbolDeclarations	declaredSymbols_
	A list of all symbols that are declared after the program code is ready.
StringSet	declaredFunctions_
	A set of all the declared functions.
StringSet	createdFiles_
	A list of the code files created during the process.
OperationSymbolDeclarations	usedOperations_
	A list of used operations.
int	instructionNumber_
	Absolute instruction # being processed.
int	instructionCounter_
	Istruction counter for checking how many instructions to put per file.
int	moveCounter_
	How many moves have we been through with?
bool	isProcedureBegin_
	Are we at the beginning of a new procedure?
const TTAProgram::Procedure *	currentProcedure_
	Pointer to the current Procedure being processed.
InstructionAddress	lastInstructionOfBB_
	last instruction of the current basic block
std::string	lastGuardBool_
	name of the last used guard variable
std::map< std::string, std::string >	usedGuardSymbols_
	Temporary list of the used guard bool symbols per instruction.
std::set< InstructionAddress >	exitPoints_
	Program exit point addresses.
AddressMap	bbStarts_
	The basic block map referred by start of the block as a key.
AddressMap	bbEnds_
	The basic block map referred by end of the block as a key.
ProcedureBBRelations	procedureBBRelations_
	Basic blocks relations to procedures and vice versa.
DelayedAssignments	delayedFUResultWrites_
	Delayed FU Result assignments.
FUResultWrites	lastFUWrites_
	Last known FU result writes.
OperationPool	operationPool_
	The operation pool.
std::string	targetDirectory_
	Directory where to write the source files of the engine.
std::string	className_
	Name of the class to be created.
std::string	headerFile_
	Header filename.
std::string	mainFile_
	Main source filename. This includes the constructor and the simulateCycle().
std::fstream	currentFile_
	Current file being processed.
std::string	currentFileName_
	Name of the current file being processed.
std::ostream *	os_
	Current output stream i.e. the above file.
CompiledSimSymbolGenerator	symbolGen_
	The symbol generator.
ConflictDetectionCodeGenerator	conflictDetectionGenerator_
	Conflict detection code generator.
unsigned	maxInstructionsPerFile_
	Maximum number of instructions per engine source code file, computed from the instruction width (bus count) to control simulation engine code size explosion with wider simulated machines.
unsigned	maxInstructionsPerSimulationFunction_
	Max for each simulation function.
GuardPipeline	guardPipeline_
bool	needGuardPipeline_
TCEString	globalSymbolSuffix_

Detailed Description

A class that generates C/C++ code from the given POM and MOM

Used for the compiled simulation

Definition at line 99 of file CompiledSimCodeGenerator.hh.

Member Typedef Documentation

AddressMap

typedef std::map<InstructionAddress, InstructionAddress> CompiledSimCodeGenerator::AddressMap

A type for storing address-to-address combinations.

Definition at line 104 of file CompiledSimCodeGenerator.hh.

DelayedAssignments

typedef std::multimap<int, DelayedAssignment> CompiledSimCodeGenerator::DelayedAssignments

private

FU Result writes.

Definition at line 148 of file CompiledSimCodeGenerator.hh.

FUResultWrites

typedef std::map<std::string, int> CompiledSimCodeGenerator::FUResultWrites

private

Definition at line 149 of file CompiledSimCodeGenerator.hh.

GuardPipeline

typedef std::map<std::string, int> CompiledSimCodeGenerator::GuardPipeline

private

Definition at line 300 of file CompiledSimCodeGenerator.hh.

OperationSymbolDeclarations

typedef std::multimap<std::string, std::string> CompiledSimCodeGenerator::OperationSymbolDeclarations

private

A type for operation symbol declarations: 1=op.name 2=op.symbol.

Definition at line 145 of file CompiledSimCodeGenerator.hh.

SimValueSymbolDeclarations

typedef std::map<std::string, int> CompiledSimCodeGenerator::SimValueSymbolDeclarations

private

Type for SimValue symbol declarations: string=symbolname, int=width.

Definition at line 226 of file CompiledSimCodeGenerator.hh.

StringSet

typedef std::set<std::string> CompiledSimCodeGenerator::StringSet

A type for std::string sets.

Definition at line 102 of file CompiledSimCodeGenerator.hh.

Constructor & Destructor Documentation

CompiledSimCodeGenerator() [1/2]

CompiledSimCodeGenerator::CompiledSimCodeGenerator	(	const TTAMachine::Machine &	machine,
		const TTAProgram::Program &	program,
		const TTASimulationController &	controller,
		bool	fuResourceConflictDetection,
		bool	handleCycleEnd,
		bool	dynamicCompilation,
		bool	basicBlockPerFile = false,
		bool	functionPerFile = true,
		const TCEString &	globalSymbolSuffix = ""
	)

The constructor

Gets the settings for compiled simulation code generation.

Parameters

machine	The machine to run the simulation on
program	The simulated program
controller	Compiled Simulation controller
fuResourceConflictDetection	is the conflict detection on?
handleCycleEnd	should we let frontend handle each cycle end
basicBlockPerFile	Should we generate only one BB per code file?

Definition at line 160 of file CompiledSimCodeGenerator.cc.

                                         :
    machine_(machine), program_(program), simController_(controller),
    gcu_(*machine.controlUnit()),
    handleCycleEnd_(handleCycleEnd),
    dynamicCompilation_(dynamicCompilation),
    basicBlockPerFile_(basicBlockPerFile),
    functionPerFile_(functionPerFile),
    instructionNumber_(0), instructionCounter_(0),
    moveCounter_(0),                      
    isProcedureBegin_(true), currentProcedure_(0),
    lastInstructionOfBB_(0),
    className_(TCEString("CompiledSimulationEngine_") + globalSymbolSuffix),
    os_(NULL), symbolGen_(globalSymbolSuffix),
    conflictDetectionGenerator_(
        machine_, symbolGen_, fuResourceConflictDetection),
    needGuardPipeline_(false), globalSymbolSuffix_(globalSymbolSuffix) {
 
    // this should result in roughly 100K-400K .cpp files
    maxInstructionsPerFile_ = 2000 / machine.busNavigator().count();
    // roughly 300-600 c++ lines per simulation function
    maxInstructionsPerSimulationFunction_ = 500 / machine.busNavigator().count();
 
// Create the guardpipeline.
 
    if (MachineInfo::longestGuardLatency(machine) > 1) {
        needGuardPipeline_ = true;
 
        int ggLatency = machine.controlUnit()->globalGuardLatency();
        
        const TTAMachine::Machine::BusNavigator busNav =
            machine.busNavigator();
        
        for (int i = 0; i < busNav.count(); i++) {
            const TTAMachine::Bus* bus = busNav.item(i);
            for (int j = 0; j < bus->guardCount(); j++) {
                Guard* guard = bus->guard(j);
                RegisterGuard* rg = dynamic_cast<RegisterGuard*>(guard);
                if (rg != NULL) {
                    const RegisterFile* rf = rg->registerFile();
                    int rgLat = rg->registerFile()->guardLatency();
                    string symbolName = 
                        symbolGen_.registerSymbol(*rf, rg->registerIndex());
                    guardPipeline_[symbolName] = ggLatency + rgLat + 1;
                }
            }
        }
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::ControlUnit::globalGuardLatency(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::RegisterFile::guardLatency(), guardPipeline_, TTAMachine::Machine::Navigator< ComponentType >::item(), MachineInfo::longestGuardLatency(), machine, maxInstructionsPerFile_, maxInstructionsPerSimulationFunction_, needGuardPipeline_, TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), CompiledSimSymbolGenerator::registerSymbol(), and symbolGen_.

Here is the call graph for this function:

~CompiledSimCodeGenerator()

CompiledSimCodeGenerator::~CompiledSimCodeGenerator ( )

virtual

The destructor

Definition at line 221 of file CompiledSimCodeGenerator.cc.

                                                    {    
}

CompiledSimCodeGenerator() [2/2]

CompiledSimCodeGenerator::CompiledSimCodeGenerator ( const CompiledSimCodeGenerator &  )

private

Copying not allowed.

Member Function Documentation

addDeclaredSymbol()

void CompiledSimCodeGenerator::addDeclaredSymbol ( const std::string &  name, int  width  )

private

Adds a new declared symbol to the map

Parameters

name	name of the symbol
width	SimValue width

Definition at line 909 of file CompiledSimCodeGenerator.cc.

                                                                         {
    declaredSymbols_[name] = width;
}

References declaredSymbols_.

Referenced by generateHeaderAndMainCode().

addUsedRFSymbols()

void CompiledSimCodeGenerator::addUsedRFSymbols ( )

private

basicBlocks()

CompiledSimCodeGenerator::AddressMap CompiledSimCodeGenerator::basicBlocks ( ) const

virtual

Returns a list of basic blocks of the program

Returns

a list of basic blocks of the program

Definition at line 317 of file CompiledSimCodeGenerator.cc.

                                            {
    if (bbStarts_.empty()) {
        findBasicBlocks();
    }
    return bbEnds_;
}

References bbEnds_, bbStarts_, and findBasicBlocks().

Referenced by CompiledSimController::reset().

Here is the call graph for this function:

createdFiles()

CompiledSimCodeGenerator::StringSet CompiledSimCodeGenerator::createdFiles ( ) const

virtual

Returns a list of the created .cpp filenames

Returns

a list of the created .cpp filenames

Definition at line 307 of file CompiledSimCodeGenerator.cc.

                                             {
    return createdFiles_;
}

References createdFiles_.

detectConflicts()

std::string CompiledSimCodeGenerator::detectConflicts ( const TTAMachine::HWOperation &  op )

private

findBasicBlocks()

void CompiledSimCodeGenerator::findBasicBlocks ( ) const

private

Finds all basic blocks of the program and stores them in two std::maps

Big basic blocks are split to smaller ones to reduce the engine compilation memory consumption.

Definition at line 621 of file CompiledSimCodeGenerator.cc.

                                                {
    for (int i = 0; i < program_.procedureCount(); ++i) {
        ControlFlowGraph cfg(program_.procedure(i));
        for (int i = 0; i < cfg.nodeCount(); ++i) {
            BasicBlockNode& node = cfg.node(i);
            if (!node.isNormalBB()) continue;
 
            InstructionAddress blockStart = node.originalStartAddress();
            const InstructionAddress end = node.originalEndAddress();
 
            if (end - blockStart > maxInstructionsPerSimulationFunction_) {
                // split the real basic block to smaller ones in case
                // there are too many instructions (huge basic blocks might 
                // explode the engine compiler memory consumption)
                InstructionAddress blockEnd = blockStart;
#if 0
                Application::logStream()
                    << "splitting a bb " << blockStart << " to " << end 
                    << " with size " << end - blockStart << std::endl;
#endif
                for (; blockStart < end; blockStart = blockEnd + 1) {
                    blockEnd =
                        std::min(
                            blockStart + maxInstructionsPerSimulationFunction_,
                            end);
 
                    // we must ensure that the branch and its delay slots
                    // end up in the same block due to the way guard 
                    // reads are handled as local variables in the simulation 
                    // func
                    if (blockEnd + machine_.controlUnit()->delaySlots() >= end) {
                        blockEnd = end;
                    }
                    
                    bbEnds_[blockEnd] = blockStart;
                    bbStarts_[blockStart] = blockEnd;
#if 0
                    Application::logStream()
                        << "small block: " << blockStart << " to " 
                        << blockEnd << std::endl;
#endif
                }
                // the "leftover" block:
 
                
                blockStart = blockEnd + 1;
                if (blockStart <= end) {
#if 0
                    Application::logStream()
                        << "leftover block: " << blockStart << " to " 
                        << end << std::endl;
#endif
                    bbEnds_[end] = blockStart;
                    bbStarts_[blockStart] = end;
                }
            } else {
                bbEnds_[end] = blockStart;            
                bbStarts_[blockStart] = end;                
            }
        }
    }
}

References bbEnds_, bbStarts_, TTAMachine::Machine::controlUnit(), TTAMachine::ControlUnit::delaySlots(), BasicBlockNode::isNormalBB(), Application::logStream(), machine_, maxInstructionsPerSimulationFunction_, BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), BasicBlockNode::originalEndAddress(), BasicBlockNode::originalStartAddress(), TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), and program_.

Referenced by basicBlocks(), and generateSimulationCode().

Here is the call graph for this function:

fuOutputPorts()

std::vector< TTAMachine::Port * > CompiledSimCodeGenerator::fuOutputPorts ( const TTAMachine::FunctionUnit &  fu ) const

private

Returns the output ports of a function unit

Parameters

fu	The function unit

Returns

A vector of output ports of a function unit

Definition at line 1788 of file CompiledSimCodeGenerator.cc.

                                            {
    std::vector<TTAMachine::Port*> ports;
    for (int i = 0; i < fu.portCount(); ++i) {
        if (fu.port(i)->isOutput()) {
            ports.push_back(fu.port(i));
        }
    }
    return ports;
}

References TTAMachine::Port::isOutput(), TTAMachine::FunctionUnit::port(), and TTAMachine::Unit::portCount().

Referenced by generateFUOutputUpdater(), generateHeaderAndMainCode(), and updateDeclaredSymbolsList().

Here is the call graph for this function:

generateAddFUResult()

std::string CompiledSimCodeGenerator::generateAddFUResult ( const TTAMachine::FUPort &  resultPort, const std::string &  value, int  latency  )

private

Generates code for adding a result to FU's output port

Handles static latency simulation in case it is possible, otherwise reverts back to older dynamic model.

The case this function tracks is the following:

1) Instruction address > basic block start + latency 2) Trigger not inside a guard 3) Result must be ready in the same basic block 4) No overlapping writes of any kind

Parameters

resultPort	FU result port to set the value to
value	value to set as a result
latency	latency of the operation

Returns

the generated code for putting the results.

Definition at line 1682 of file CompiledSimCodeGenerator.cc.

                 {
        
    std::stringstream ss;
    const FunctionUnit& fu = *resultPort.parentUnit();
    const int writeTime = instructionNumber_ + latency;
    
    AddressMap::iterator bbEnd = bbEnds_.lower_bound(instructionNumber_);
    
    const bool resultInSameBasicBlock = bbEnd->first ==
        bbEnds_.lower_bound(writeTime)->first;
    
    const int bbStart = bbEnd->second;
    bool staticSimulationPossible = false;
    const std::string destination = symbolGen_.portSymbol(resultPort);
    
    int lastWrite = 0;
    if (lastFUWrites_.find(destination) != lastFUWrites_.end()) {
        lastWrite = lastFUWrites_[destination];
    }
 
    // If no more pending results are coming outside or inside the basic block,
    // no guard of any kind and result will be ready in the same basic block,
    // then static latency simulation can be done.
    if ((writeTime >= bbStart + fu.maxLatency())
        && lastGuardBool_.empty() && resultInSameBasicBlock 
        && (writeTime > lastWrite)) {
        staticSimulationPossible = true;
        
        for (int i = instructionNumber_ + 1; i < writeTime 
             && staticSimulationPossible; ++i) {
 
            Instruction& instr = program_.instructionAt(i);
            for (int j = 0; j < instr.moveCount(); ++j) {
                if ((instr.move(j).isTriggering() && fu.name() 
                    == instr.move(j).destination().functionUnit().name()) || 
                     (instr.move(j).source().isGPR() && 
                     instr.move(j).source().port().name()==resultPort.name())) {
                    staticSimulationPossible = false;
                    break;
                }
            }
        }
    }
 
    if (staticSimulationPossible) { // Add a new delayed assignment
        DelayedAssignment assignment = { value, destination, 
            symbolGen_.FUResultSymbol(resultPort) };
        delayedFUResultWrites_.insert(std::make_pair(writeTime, assignment));
    } else { // revert to old dynamic FU result model
        ss << "engine.addFUResult(" << symbolGen_.FUResultSymbol(resultPort)
           << ", " << "engine.cycleCount_, " << value << ", " << latency << ");";
        if (writeTime > lastWrite) {
            lastFUWrites_[destination] = writeTime;
        }
    }
    
    return ss.str();
}

References bbEnds_, delayedFUResultWrites_, TTAProgram::Move::destination(), TTAProgram::Terminal::functionUnit(), CompiledSimSymbolGenerator::FUResultSymbol(), TTAProgram::Program::instructionAt(), instructionNumber_, TTAProgram::Terminal::isGPR(), TTAProgram::Move::isTriggering(), lastFUWrites_, lastGuardBool_, TTAMachine::FunctionUnit::maxLatency(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAMachine::BaseFUPort::parentUnit(), TTAProgram::Terminal::port(), CompiledSimSymbolGenerator::portSymbol(), program_, TTAProgram::Move::source(), and symbolGen_.

Referenced by generateLoadTrigger(), generateTriggerCode(), and handleOperationWithoutDag().

Here is the call graph for this function:

generateAdvanceClockCode()

void CompiledSimCodeGenerator::generateAdvanceClockCode ( )

private

Generates code for advancing clocks of various items per cycle

Definition at line 783 of file CompiledSimCodeGenerator.cc.

                                                        {
    *os_ << endl << "void inline advanceClocks() {" << endl;
    if (needGuardPipeline_) {
        generateGuardPipelineAdvance(*os_);
    }
    *os_ << conflictDetectionGenerator_.advanceClockCode();
         
    *os_ << endl << "}" << endl;
}

References ConflictDetectionCodeGenerator::advanceClockCode(), conflictDetectionGenerator_, generateGuardPipelineAdvance(), needGuardPipeline_, and os_.

Referenced by generateHeaderAndMainCode().

Here is the call graph for this function:

generateConstructorCode()

void CompiledSimCodeGenerator::generateConstructorCode ( )

private

Generates code for the class constructor in the main .cpp file.

Definition at line 513 of file CompiledSimCodeGenerator.cc.

                                                  {
 
    const string DS = FileSystem::DIRECTORY_SEPARATOR;    
    currentFile_.open((targetDirectory_ + DS + mainFile_).c_str(), fstream::out);
    createdFiles_.insert(mainFile_);
    os_ = &currentFile_;
    
    symbolGen_.disablePrefix();
 
    *os_ << "#include \"" << headerFile_ << "\"" << endl << endl;
    
    // generate forward declarations for simulate functions
    for (AddressMap::const_iterator it = bbStarts_.begin();
            it != bbStarts_.end(); ++it) {
            *os_ << "\t" << "extern \"C\" EXPORT void "
                 << symbolGen_.basicBlockSymbol(it->first) 
                 << "(void*);" << endl;
    }
    
    *os_ << "EXPORT " << className_ << "::";
    
    generateConstructorParameters();
        
    *os_ << " : " << endl
         << "CompiledSimulation(machine, entryAddress, lastInstruction, "
         << "frontend, controller, memorySystem, dynamicCompilation, "
         << "procedureBBRelations),"
         << endl;
    
    updateDeclaredSymbolsList();
    updateSymbolsMap();
    
    const Machine::FunctionUnitNavigator& fus = 
        machine_.functionUnitNavigator();    
    for (int i = 0; i < fus.count(); i++) {
        const FunctionUnit& fu = *fus.item(i);
        std::string context = symbolGen_.operationContextSymbol(fu);
        
        *os_ << "\t" << context << ".setCycleCountVariable(cycleCount_);"
             << endl;
        // Create a state for each operation
        for (int j = 0; j < fu.operationCount(); ++j) {
            std::string operation = symbolGen_.operationSymbol(
                fu.operation(j)->name(), fu);
            
            *os_ << "\t" << operation << ".createState(" << context << ");" 
                 << endl;
        }
 
        // Set a Memory for the context
        if (fu.addressSpace() != NULL) {
            *os_ << "\t" << context << ".setMemory(&" 
                 << symbolGen_.DAMemorySymbol(fu) << ");" << endl;
        }
    }
    
    generateJumpTableCode();
    
    *os_ << conflictDetectionGenerator_.extraInitialization()
         << "}" << endl << endl;
    
    // generate simulateCycle() method
    *os_ << "// Simulation code:" << endl
         << "EXPORT void " << className_  << "::simulateCycle() {" 
         << endl << endl;
 
    // Create a jump dispatcher for accessing each basic block start
    *os_ << "\t// jump dispatcher" << endl
         << "\tjumpTargetFunc_ = getSimulateFunction(jumpTarget_);" << endl
         << "\t(jumpTargetFunc_)(this);" << endl << endl;
    
    *os_ << conflictDetectionGenerator_.notifyOfConflicts()
         << "}" << endl << endl;
    
    generateSimulationGetter(); 
    generateFUOutputUpdater();    
}

References TTAMachine::FunctionUnit::addressSpace(), CompiledSimSymbolGenerator::basicBlockSymbol(), bbStarts_, className_, conflictDetectionGenerator_, TTAMachine::Machine::Navigator< ComponentType >::count(), createdFiles_, currentFile_, CompiledSimSymbolGenerator::DAMemorySymbol(), FileSystem::DIRECTORY_SEPARATOR, CompiledSimSymbolGenerator::disablePrefix(), DS, ConflictDetectionCodeGenerator::extraInitialization(), TTAMachine::Machine::functionUnitNavigator(), generateConstructorParameters(), generateFUOutputUpdater(), generateJumpTableCode(), generateSimulationGetter(), headerFile_, TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, mainFile_, TTAMachine::HWOperation::name(), ConflictDetectionCodeGenerator::notifyOfConflicts(), TTAMachine::FunctionUnit::operation(), CompiledSimSymbolGenerator::operationContextSymbol(), TTAMachine::FunctionUnit::operationCount(), CompiledSimSymbolGenerator::operationSymbol(), os_, symbolGen_, targetDirectory_, updateDeclaredSymbolsList(), and updateSymbolsMap().

Referenced by generateHeaderAndMainCode().

Here is the call graph for this function:

generateConstructorParameters()

void CompiledSimCodeGenerator::generateConstructorParameters ( )

private

Generates the parameter list for the constructor.

Definition at line 497 of file CompiledSimCodeGenerator.cc.

                                                        {
    *os_ << className_ 
         << "(const TTAMachine::Machine& machine," << endl
         << "InstructionAddress entryAddress," << endl
         << "InstructionAddress lastInstruction," << endl
         << "SimulatorFrontend& frontend," << endl
         << "CompiledSimController& controller," << endl
         << "MemorySystem& memorySystem," << endl
         << "bool dynamicCompilation,"
         << "ProcedureBBRelations& procedureBBRelations)";
}

References className_, and os_.

Referenced by generateConstructorCode(), and generateHeaderAndMainCode().

generateFUOutputUpdater()

void CompiledSimCodeGenerator::generateFUOutputUpdater ( )

private

Generates a function that is used to update all FU outputs from the "result buffer".

Definition at line 721 of file CompiledSimCodeGenerator.cc.

                                                  {
    // use C-style functions only! (C++ name mangling complicates stuff)
    *os_ << "/* Updates all FU outputs to correct the visible machine state */" << endl
         << "extern \"C\" EXPORT void updateFUOutputs_" 
         << globalSymbolSuffix_ << "("
         << className_ << "& engine) {" << endl;
 
    const Machine::FunctionUnitNavigator& fus = machine_.functionUnitNavigator();    
    for (int i = 0; i < fus.count(); ++i) {
        const FunctionUnit& fu = *fus.item(i);
        std::vector<Port*> outPorts = fuOutputPorts(fu);
        for (size_t j = 0; j < outPorts.size(); ++j) {
            symbolGen_.enablePrefix("engine.");
            *os_ << "\t" << generateFUResultRead(
                symbolGen_.portSymbol(*outPorts.at(j)), 
                symbolGen_.FUResultSymbol(*outPorts.at(j)));
        }
    }
 
    *os_
        << "}" << endl
        << endl;
}

References className_, TTAMachine::Machine::Navigator< ComponentType >::count(), CompiledSimSymbolGenerator::enablePrefix(), TTAMachine::Machine::functionUnitNavigator(), fuOutputPorts(), CompiledSimSymbolGenerator::FUResultSymbol(), generateFUResultRead(), globalSymbolSuffix_, TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, os_, CompiledSimSymbolGenerator::portSymbol(), and symbolGen_.

Referenced by generateConstructorCode().

Here is the call graph for this function:

generateFUResultRead()

std::string CompiledSimCodeGenerator::generateFUResultRead ( const std::string &  destination, const std::string &  resultSymbol  )

private

Generates code for reading FU results from result symbol to result port

Parameters

destination	destination port symbol
resultSymbol	results symbol

Returns

generated code for getting the result

Definition at line 1752 of file CompiledSimCodeGenerator.cc.

                                   {
    std::stringstream ss;
    
    ss << "engine.FUResult(" << destination << ", " << resultSymbol
       << ", engine.cycleCount_);" << endl;
    
    return ss.str();
}

Referenced by generateFUOutputUpdater(), and generateInstruction().

generateGuardCondition()

string CompiledSimCodeGenerator::generateGuardCondition ( const TTAProgram::Move &  move )

private

Generates the condition simulation code for a guarded move.

Parameters

move	guarded move

Returns

a std::string containing generated code for the guard check

Definition at line 1089 of file CompiledSimCodeGenerator.cc.

                                {
        
    std::stringstream ss;
    string guardSymbolName;
    
    const TTAMachine::Guard& guard = move.guard().guard();
    
    // Find out the guard type
    if (dynamic_cast<const RegisterGuard*>(&guard) != NULL) {
        const RegisterGuard& rg = dynamic_cast<const RegisterGuard&>(guard);
        const RegisterFile& rf = *rg.registerFile();
        guardSymbolName = symbolGen_.registerSymbol(rf, rg.registerIndex());        
    } else if (dynamic_cast<const PortGuard*>(&guard) != NULL) {
        const PortGuard& pg = dynamic_cast<const PortGuard&>(guard);
        guardSymbolName = symbolGen_.portSymbol(*pg.port());
    } else {
        ss << endl << "#error unknown guard type!" << endl;
    }
    
    lastGuardBool_ = "";
        
    // Make sure to create only one bool per guard read and store the symbol
    if (usedGuardSymbols_.find(guardSymbolName) == usedGuardSymbols_.end()) {
        lastGuardBool_ = symbolGen_.guardBoolSymbol();
        usedGuardSymbols_[guardSymbolName] = lastGuardBool_;
    } else {
        lastGuardBool_ = usedGuardSymbols_[guardSymbolName];
    }
    
    // Handle inverted guards
    ss << endl << "if (";
    if (guard.isInverted()) {
        lastGuardBool_ = "!" + lastGuardBool_;
    }
    ss << lastGuardBool_ << ") { ";
    
    return ss.str();
}

References TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), CompiledSimSymbolGenerator::guardBoolSymbol(), TTAMachine::Guard::isInverted(), lastGuardBool_, TTAMachine::PortGuard::port(), CompiledSimSymbolGenerator::portSymbol(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), CompiledSimSymbolGenerator::registerSymbol(), symbolGen_, and usedGuardSymbols_.

Referenced by generateInstruction().

Here is the call graph for this function:

generateGuardPipelineAdvance()

void CompiledSimCodeGenerator::generateGuardPipelineAdvance ( std::ostream &  stream )

private

Definition at line 1799 of file CompiledSimCodeGenerator.cc.

                        {
    for (GuardPipeline::iterator i = guardPipeline_.begin(); 
         i != guardPipeline_.end(); i++) {
        const std::string& regName = i->first;
        for (int j = i->second -1 ; j > 0; j--) {
            stream  << "guard_pipeline_" << regName << "_" << j << " = "
                    << "guard_pipeline_" << regName << "_" << j -1 
                    << ";" << std::endl;
        }
    }
}

References guardPipeline_.

Referenced by generateAdvanceClockCode().

generateGuardPipelineVariables()

void CompiledSimCodeGenerator::generateGuardPipelineVariables ( std::ostream &  stream )

private

Definition at line 1812 of file CompiledSimCodeGenerator.cc.

                        {
    for (GuardPipeline::iterator i = guardPipeline_.begin(); 
         i != guardPipeline_.end(); i++) {
        const std::string& regName = i->first;
        for (int j = 0; j < i->second ; j++) {
            stream  << "bool guard_pipeline_" + regName << "_" << j << 
                ";" << std::endl;
        }
    }
}

References guardPipeline_.

Referenced by generateHeaderAndMainCode().

generateGuardRead()

string CompiledSimCodeGenerator::generateGuardRead ( const TTAProgram::Move &  move )

private

Generates code for reading a guard value before an instruction with moves guarded with the value is simulated.

Parameters

move	guarded move

Returns

a std::string containing generated code for the guard check

Definition at line 1035 of file CompiledSimCodeGenerator.cc.

                                {
        
    std::stringstream ss;
    string guardSymbolName;
    
    const TTAMachine::Guard& guard = move.guard().guard();
    
    const TTAMachine::RegisterGuard* rg = 
        dynamic_cast<const RegisterGuard*>(&guard);
    // Find out the guard type
    if (rg != NULL) {
        const RegisterGuard& rg = dynamic_cast<const RegisterGuard&>(guard);
        const RegisterFile& rf = *rg.registerFile();
        guardSymbolName = symbolGen_.registerSymbol(rf, rg.registerIndex());        
    } else if (dynamic_cast<const PortGuard*>(&guard) != NULL) {
        const PortGuard& pg = dynamic_cast<const PortGuard&>(guard);
        guardSymbolName = symbolGen_.portSymbol(*pg.port());
    } else {
        ss << endl << "#error unknown guard type!" << endl;
    }
    
    lastGuardBool_ = "";
        
    // Make sure to create only one bool per guard read and store the symbol
    if (usedGuardSymbols_.find(guardSymbolName) == usedGuardSymbols_.end()) {
 
        // read from the guard pipeline? then use the pipeline ar directly
        if (needGuardPipeline_ && rg != NULL) {
            std::string guardSym = guardPipelineTopSymbol(*rg);
            lastGuardBool_ = usedGuardSymbols_[guardSymbolName] = guardSym;
        } else {
            lastGuardBool_ = symbolGen_.guardBoolSymbol();
            usedGuardSymbols_[guardSymbolName] = lastGuardBool_;
 
            // red from the register.
            ss << "const bool " << lastGuardBool_ << 
                " = !(MathTools::fastZeroExtendTo(" 
               << guardSymbolName << ".uIntWordValue(), " <<
                guardSymbolName << ".width()) == 0u);";
        }
    } else {
        lastGuardBool_ = usedGuardSymbols_[guardSymbolName];
    }
    return ss.str();
}

References TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), CompiledSimSymbolGenerator::guardBoolSymbol(), guardPipelineTopSymbol(), lastGuardBool_, needGuardPipeline_, TTAMachine::PortGuard::port(), CompiledSimSymbolGenerator::portSymbol(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), CompiledSimSymbolGenerator::registerSymbol(), symbolGen_, and usedGuardSymbols_.

Referenced by generateInstruction().

Here is the call graph for this function:

generateHaltCode()

string CompiledSimCodeGenerator::generateHaltCode ( const std::string &  message = "" )

private

Generates code for halting the simulation

Parameters

message

Reason for the halt

Returns

generated code for halting the simulation

Definition at line 775 of file CompiledSimCodeGenerator.cc.

                                                                {
    return std::string("\thaltSimulation(__FILE__, __LINE__, __FUNCTION__, \""
       + message + "\");\n");
}

generateHeaderAndMainCode()

void CompiledSimCodeGenerator::generateHeaderAndMainCode ( )

private

Creates a header file to be used for all the .cpp files and the main source file which includes the constructor and the main simulation loop.

Initializes all variables required by the simulation

Sets up new SimValue variables for all the FUs, registers, FU pipeline stages and so on. Variables are created as member variables.

Definition at line 345 of file CompiledSimCodeGenerator.cc.

                                                    {
 
    // Open a new file for the header
    const string DS = FileSystem::DIRECTORY_SEPARATOR;
    currentFileName_ = targetDirectory_ + DS + headerFile_; 
    currentFile_.open(currentFileName_.c_str(), fstream::out);
    os_ = &currentFile_;
    
    symbolGen_.disablePrefix();
    
    // Generate includes
    *os_ << "// " << className_ << " Generated automatically by ttasim" << endl
         << "#ifndef _AUTO_GENERATED_COMPILED_SIMULATION_H_" << endl
         << "#define _AUTO_GENERATED_COMPILED_SIMULATION_H_" << endl
         << "#include \"SimValue.hh\"" << endl
         << "#include \"DirectAccessMemory.hh\"" << endl
         << "#include \"OSAL.hh\"" << endl
         << "#include \"Operation.hh\"" << endl
         << "#include \"OperationPool.hh\"" << endl
         << "#include \"OperationContext.hh\"" << endl
         << "#include \"CompiledSimulation.hh\"" << endl
         << "#include \"BaseType.hh\"" << endl
     << "#include \"MathTools.hh\"" << endl
         << conflictDetectionGenerator_.includes() << endl
         << endl;
    
    // Open up class declaration and define some extra member variables
    *os_ << "class " << className_ << ";" << endl << endl;
    *os_ << "class " << className_ << " : public CompiledSimulation {" << endl
         << "public:" << endl;
 
    // Declare all FUs
    const Machine::FunctionUnitNavigator& fus = machine_.functionUnitNavigator();
    for (int i = 0; i < fus.count(); ++i) {
        const FunctionUnit& fu = *fus.item(i);
        
        // FU Ports
        for (int j = 0; j < fu.operationPortCount(); ++j) {
            const FUPort& port = *fu.operationPort(j);
            addDeclaredSymbol(symbolGen_.portSymbol(port), port.width());    
        }                
    
        // Conflict detectors
        if (conflictDetectionGenerator_.conflictDetectionEnabled()) {
            *os_ << conflictDetectionGenerator_.symbolDeclaration(fu);
        }
 
        // Operation contexts
        *os_ << "\t" << "OperationContext " 
             << symbolGen_.operationContextSymbol(fu) << ";" << endl;
        
        // Address spaces
        if (fu.addressSpace() != NULL) {
             *os_ << "\t" << "DirectAccessMemory& " 
                  << symbolGen_.DAMemorySymbol(*fus.item(i)) << ";" 
                  << endl;
        }
        
        // All operations of the FU
        for (int j = 0; j < fu.operationCount(); ++j) {
            string opName = fu.operation(j)->name();
            *os_ << "\t" << "Operation& " 
                 << symbolGen_.operationSymbol(opName, fu) << ";" << endl;
            
            usedOperations_.insert(
                std::make_pair(opName, symbolGen_.operationSymbol(opName, fu)));
        }
        
        // FU output results
        std::vector<Port*> outPorts = fuOutputPorts(fu);
        for (size_t j = 0; j < outPorts.size(); ++j) {
            *os_ << "\t" << "FUResultType " 
                 << symbolGen_.FUResultSymbol(*outPorts.at(j)) 
                 << ";" << endl;
        }
    }
    *os_ << endl;
    
    // GCU
    ControlUnit* gcu = machine_.controlUnit();
    if (gcu) {
        for (int i = 0; i < gcu->specialRegisterPortCount(); ++i) {
            SpecialRegisterPort& port = *gcu->specialRegisterPort(i);
            addDeclaredSymbol(symbolGen_.portSymbol(port), port.width());
        }
        for (int i = 0; i < gcu->operationPortCount(); ++i) {
            FUPort& port = *gcu->operationPort(i);
            addDeclaredSymbol(symbolGen_.portSymbol(port), port.width());
        }
    }
    
    // Declare all IUs    
    const Machine::ImmediateUnitNavigator& ius = 
        machine_.immediateUnitNavigator();
    for (int i = 0; i < ius.count(); ++i) {
        const ImmediateUnit& iu = *ius.item(i);
        for (int j = 0; j < iu.numberOfRegisters(); ++j) {
            addDeclaredSymbol(symbolGen_.immediateRegisterSymbol(iu, j), 
                iu.width());
        }
    }
    
    // Register files
    const Machine::RegisterFileNavigator& rfs = 
        machine_.registerFileNavigator();
    for (int i = 0; i < rfs.count(); ++i) {
        const RegisterFile& rf = *rfs.item(i);
        for (int j = 0; j < rf.numberOfRegisters(); ++j) {
            addDeclaredSymbol(symbolGen_.registerSymbol(rf, j), 
                              rf.width());
        }
    }
    
    // Buses
    const Machine::BusNavigator& buses = machine_.busNavigator();
    for (int i = 0; i < buses.count(); ++i) {
        const Bus& bus = *buses.item(i);
        addDeclaredSymbol(symbolGen_.busSymbol(bus), bus.width());
    }
    
    // guard pipeline
    if (needGuardPipeline_) {
        generateGuardPipelineVariables(*os_);
    }
 
    generateSymbolDeclarations();
    generateConstructorParameters();
    *os_ << ";" << endl;
 
    generateAdvanceClockCode();
    
    // Generate dummy destructor
    *os_ << "EXPORT virtual ~" << className_ << "() { }" << endl << endl;
    *os_ << "EXPORT virtual void simulateCycle();" << endl << endl << "}; // end class" << endl;
 
    *os_ << "extern \"C\" EXPORT void updateFUOutputs_" 
         << globalSymbolSuffix_ << "(" << className_ << "&);" << endl;
 
    *os_ << endl << endl << "#endif // include once" << endl << endl;
 
    // header written
    currentFile_.close();
    currentFileName_.clear();
    os_ = NULL;
 
    generateConstructorCode();
}

References addDeclaredSymbol(), TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::busNavigator(), CompiledSimSymbolGenerator::busSymbol(), className_, ConflictDetectionCodeGenerator::conflictDetectionEnabled(), conflictDetectionGenerator_, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), currentFile_, currentFileName_, CompiledSimSymbolGenerator::DAMemorySymbol(), FileSystem::DIRECTORY_SEPARATOR, CompiledSimSymbolGenerator::disablePrefix(), DS, TTAMachine::Machine::functionUnitNavigator(), fuOutputPorts(), CompiledSimSymbolGenerator::FUResultSymbol(), generateAdvanceClockCode(), generateConstructorCode(), generateConstructorParameters(), generateGuardPipelineVariables(), generateSymbolDeclarations(), globalSymbolSuffix_, headerFile_, CompiledSimSymbolGenerator::immediateRegisterSymbol(), TTAMachine::Machine::immediateUnitNavigator(), ConflictDetectionCodeGenerator::includes(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::HWOperation::name(), needGuardPipeline_, TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::FunctionUnit::operation(), CompiledSimSymbolGenerator::operationContextSymbol(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), CompiledSimSymbolGenerator::operationSymbol(), os_, CompiledSimSymbolGenerator::portSymbol(), TTAMachine::Machine::registerFileNavigator(), CompiledSimSymbolGenerator::registerSymbol(), TTAMachine::ControlUnit::specialRegisterPort(), TTAMachine::ControlUnit::specialRegisterPortCount(), ConflictDetectionCodeGenerator::symbolDeclaration(), symbolGen_, targetDirectory_, usedOperations_, TTAMachine::BaseFUPort::width(), TTAMachine::BaseRegisterFile::width(), and TTAMachine::Bus::width().

Referenced by generateToDirectory().

Here is the call graph for this function:

generateInstruction()

void CompiledSimCodeGenerator::generateInstruction ( const TTAProgram::Instruction &  instruction )

private

Generates simulation code of the given instruction

Parameters

instruction

instruction to generate the code from

Definition at line 1136 of file CompiledSimCodeGenerator.cc.

                                                                            {
 
    InstructionAddress address = instruction.address().location();
    usedGuardSymbols_.clear();
    
    // Are we at the start of a new basic block?
    if (bbStarts_.find(address) != bbStarts_.end()) {
        // Should we start with a new file?
        if (instructionCounter_ <= 0 || basicBlockPerFile_ ||
            (functionPerFile_ && isProcedureBegin_)) {
            instructionCounter_ = maxInstructionsPerFile_;
            
            if (currentFile_.is_open()) {
                currentFile_.close();
            }
            
            // Generate a new file to begin to work with
            const string DS = FileSystem::DIRECTORY_SEPARATOR;
            currentFileName_ = targetDirectory_ + DS 
                + symbolGen_.basicBlockSymbol(address) + ".cpp";
            currentFile_.open(currentFileName_.c_str(), fstream::out);
            createdFiles_.insert(currentFileName_);
            os_ = &currentFile_;
            *os_ << "// " << className_ 
                 << " Generated automatically by ttasim" << endl
                 << "#include \"" << headerFile_ << "\"" << endl << endl;
        }
        
        lastInstructionOfBB_ = bbStarts_.find(address)->second;
        declaredFunctions_.insert(symbolGen_.basicBlockSymbol(address));
        
        // Save basic block<->procedure related information
        InstructionAddress procedureStart = currentProcedure_->
            startAddress().location();
        procedureBBRelations_.procedureStart[address] = procedureStart;
        procedureBBRelations_.basicBlockFiles[address] = currentFileName_;
        procedureBBRelations_.basicBlockStarts.insert(std::make_pair(
            procedureStart, address));
 
        // Start a new C++ function for the basic block
        if (isProcedureBegin_) {
            *os_ << "/* Procedure " << currentProcedure_->name() 
                 << " */" << endl;
        }   
        *os_ << endl << "extern \"C\" EXPORT void "
             << symbolGen_.basicBlockSymbol(address)
             << "(void* eng) {" << endl;
        *os_ << className_ << "& engine = *(" << className_ << "*)eng;" << endl;
        symbolGen_.enablePrefix("engine.");
        lastFUWrites_.clear();
 
        // initialize jump target to next BB.
        int bbEndAddr = -1;
        for (int addr = address; bbEndAddr == -1; addr++) {
            if (AssocTools::containsKey(bbEnds_, addr)) {
                bbEndAddr = addr;
            }
        }        
        
        *os_ << "/* First instruction of BB - initialize address of next BB"
             << " */" << endl;
        *os_ << "engine.jumpTarget_ = " << bbEndAddr + 1 << ";" << endl;
    }
 
    *os_ << endl << "/* Instruction " << instructionNumber_ << " */" << endl;
    
    // Advance clocks of the conflict detectors
    if (conflictDetectionGenerator_.conflictDetectionEnabled() ||
        needGuardPipeline_) {
        *os_ << "engine.advanceClocks();" << endl;  
    }
    
    // Do immediate assignments per instruction for FU ports
    for (int i = 0; i < instruction.immediateCount(); ++i) {
        const Immediate& immediate = instruction.immediate(i);
            
        if (!immediate.destination().isFUPort()) {
            continue;
        }
 
        *os_ << symbolGen_.immediateRegisterSymbol(immediate.destination());
        int value = immediate.value().value().unsignedValue();
        *os_  << " = " << value << "u;";
    }
    
    // Get FU Results if there are any ready
    std::set<std::string> gotResults; // used to get FU results only once/instr.
    DelayedAssignments::iterator it = 
        delayedFUResultWrites_.find(instructionNumber_);
    while (it != delayedFUResultWrites_.end()) {
        *os_ << "engine.clearFUResults(" << it->second.fuResultSymbol << ");" << endl;
        *os_ << it->second.targetSymbol << " = " << it->second.sourceSymbol 
             << ";" << std::endl;        
        gotResults.insert(it->second.targetSymbol);
        delayedFUResultWrites_.erase(it);
        it = delayedFUResultWrites_.find(instructionNumber_);
    }
    
    bool endGuardBracket = false;
    
    // Do moves
    std::vector<CompiledSimMove> lateMoves; // moves with buses
 
    // generate the possible guard value reads before the
    // actual moves
    for (int i = 0; i < instruction.moveCount(); ++i) {
        const Move& move = instruction.move(i);
        if (!move.isUnconditional()) {
            *os_ << generateGuardRead(move) << std::endl;
        }
    }
 
    for (int i = 0; i < instruction.moveCount(); ++i, moveCounter_++) {
        const Move& move = instruction.move(i);
        string moveSource = symbolGen_.moveOperandSymbol(
            move.source(), move);
        string moveDestination = symbolGen_.moveOperandSymbol(
            move.destination(), move);
        
        lastGuardBool_.clear();
 
        if (move.source().isFUPort() && gotResults.find(moveSource) == gotResults.end() &&  
            dynamic_cast<const ControlUnit*>(&move.source().functionUnit()) == NULL) {
            *os_ 
                << generateFUResultRead(
                    moveSource, symbolGen_.FUResultSymbol(move.source().port())) 
                << endl;
            gotResults.insert(moveSource);
        }
        
        if (!move.isUnconditional()) { // has a guard?
            *os_ << generateGuardCondition(move);
            endGuardBracket = true;
        }
 
   // increase move count if the move is guarded or it is an exit point
        if (!move.isUnconditional() || exitPoints_.find(
            instruction.address().location()) != exitPoints_.end()) {
            *os_ << " ++engine.moveExecCounts_[" << moveCounter_ << "]; ";
        }
        
        // Find all moves that depend on others i.e. those moves that have to
        // be done last.
        bool dependingMove = false;
        for (int j = instruction.moveCount() - 1; j > 0 && i != j; --j) {
            if (moveDestination == symbolGen_.moveOperandSymbol(
                instruction.move(j).source(), move)) {
                dependingMove = true;
                CompiledSimMove lateMove(move, lastGuardBool_, symbolGen_);
                lateMoves.push_back(lateMove);
                *os_ << lateMove.copyToBusCode();
            }
        }
        
        // Assign the values directly instead of through 
        // the SimValue assignment in case:
        if ((move.source().isGPR() || move.source().isFUPort() 
             || move.source().isImmediateRegister()) &&
            (move.source().port().width() <= static_cast<int>(sizeof(UIntWord)*8)) &&
            move.source().port().width() == move.destination().port().width()) {
            if (move.source().isImmediateRegister() && move.source().immediateUnit().signExtends()) {
                moveSource += ".sIntWordValue()";
            } else {
                moveSource += ".uIntWordValue()";
            }
        }
 
        if (!dependingMove) {
            *os_ << moveDestination << " = " << moveSource << "; ";
            if (needGuardPipeline_) {
                handleRegisterWrite(moveDestination, *os_);
            }
        }
        
        if (endGuardBracket) {
            *os_ << "}";
            endGuardBracket = false;
        }
    }
    
    endGuardBracket = false;
    
    // Do moves with triggers, except stores.
    for (int i = 0; i < instruction.moveCount(); ++i) {
        const Move& move = instruction.move(i);
        if (!move.isTriggering()) {
            continue;
        }
        
        const TerminalFUPort& tfup = 
            static_cast<const TerminalFUPort&>(move.destination());
        const HWOperation& hwOperation = *tfup.hwOperation();
 
        if (isStoreOperation(hwOperation.name())) {
            continue;
        }
 
        string moveSource = symbolGen_.moveOperandSymbol(
            move.source(), move);
        string moveDestination = symbolGen_.moveOperandSymbol(
            move.destination(), move);
        
        if (!move.isUnconditional()) { // has a guard?
            *os_ << generateGuardCondition(move);
            endGuardBracket = true;
        }
        
        if (move.source().isFUPort() && gotResults.find(moveSource) == 
            gotResults.end() && dynamic_cast<const ControlUnit*>(
                &move.source().functionUnit()) == NULL) {
            *os_ 
                << generateFUResultRead(
                    moveDestination, 
                    symbolGen_.FUResultSymbol(move.source().port()))
                 << endl;
 
            gotResults.insert(
                symbolGen_.moveOperandSymbol(move.source(), move));
        }
        
        *os_ << handleOperation(hwOperation)
             << conflictDetectionGenerator_.detectConflicts(hwOperation);
 
        if (endGuardBracket) {
            *os_ << "}" << endl;
            endGuardBracket = false;
        }
    } // end for
 
 
 
 
    // Do moves with store triggers.
    for (int i = 0; i < instruction.moveCount(); ++i) {
        const Move& move = instruction.move(i);
        if (!move.isTriggering()) {
            continue;
        }
        
        const TerminalFUPort& tfup = 
            static_cast<const TerminalFUPort&>(move.destination());
        const HWOperation& hwOperation = *tfup.hwOperation();
 
        if (!isStoreOperation(hwOperation.name())) {
            continue;
        }
 
        string moveSource = symbolGen_.moveOperandSymbol(
            move.source(), move);
        string moveDestination = symbolGen_.moveOperandSymbol(
            move.destination(), move);
        
        if (!move.isUnconditional()) { // has a guard?
            *os_ << generateGuardCondition(move);
            endGuardBracket = true;
        }
        
        if (move.source().isFUPort() && gotResults.find(moveSource) == 
            gotResults.end() && dynamic_cast<const ControlUnit*>(
                &move.source().functionUnit()) == NULL) {
            *os_ 
                << generateFUResultRead(
                    moveDestination, 
                    symbolGen_.FUResultSymbol(move.source().port()))
                 << endl;
 
            gotResults.insert(
                symbolGen_.moveOperandSymbol(move.source(), move));
        }
        
        *os_ << handleOperation(hwOperation)
             << conflictDetectionGenerator_.detectConflicts(hwOperation);
 
        if (endGuardBracket) {
            *os_ << "}" << endl;
            endGuardBracket = false;
        }
    } // end for
 
 
    
    // Do immediate assignments for everything else
    for (int i = 0; i < instruction.immediateCount(); ++i) {
        const Immediate& immediate = instruction.immediate(i);
           
        if (immediate.destination().isFUPort()) {
            continue;
        }
 
        *os_ << symbolGen_.immediateRegisterSymbol(immediate.destination());
        if (immediate.destination().immediateUnit().signExtends()) {
            int value = immediate.value().value().intValue();
            *os_  << " = SIntWord("<< value << ");";
        } else {
            unsigned int value = immediate.value().value().unsignedValue();
            *os_  << " = " << value << "u;";
        }
    }
    
    // Do bus moves
    for (std::vector<CompiledSimMove>::const_iterator it = lateMoves.begin();
        it != lateMoves.end(); ++it) {
        *os_ << it->copyFromBusCode();
        if (needGuardPipeline_) {
            if (it->destination().isGPR()) {
                handleRegisterWrite(
                    symbolGen_.registerSymbol(it->destination()), *os_);
            }
        }
    }
 
    // No operation?
    if (instruction.moveCount() == 0 && instruction.immediateCount() == 0) {
        *os_ << "/* NOP */" << endl;
    }
    
    // Let frontend handle cycle end?
    if (handleCycleEnd_) {
        *os_ << "engine.cycleEnd();" << endl;
    }
 
    *os_ << "engine.cycleCount_++;" << endl;
    
    AddressMap::iterator bbEnd = bbEnds_.find(address);
    
    // Increase basic block execution count
    if (bbEnd != bbEnds_.end()) {
        InstructionAddress bbStart = 
            bbEnds_.lower_bound(instructionNumber_)->second;
        *os_ << "++engine.bbExecCounts_[" << bbStart << "];" << endl;
    }
    
    // generate exit code if this is a return instruction
    if (exitPoints_.find(address) != exitPoints_.end()) {
        generateShutdownCode(address);
    }
 
    // Create code for a possible exit after the basic block
    if (bbEnd != bbEnds_.end()) {
        *os_ 
            << "if (engine.cycleCount_ >= engine.cyclesToSimulate_) {" << endl
            << "\t" << "engine.stopRequested_ = true;" << endl 
            << "\t" << "updateFUOutputs_" << globalSymbolSuffix_ 
            << "(engine);" << endl
            << "}" << endl; 
 
        *os_ << "{ engine.programCounter_ = engine.jumpTarget_; "
             << "engine.lastExecutedInstruction_ = " << address 
             << "; return; }" << endl;
        // Generate shutdown code after the last instruction
        if (address == program_.lastInstruction().address().location()) {
            generateShutdownCode(address);
        }
        
         *os_ << endl << "} /* end function */" << endl << endl;
    }
}

References TTAProgram::Instruction::address(), ProcedureBBRelations::basicBlockFiles, basicBlockPerFile_, ProcedureBBRelations::basicBlockStarts, CompiledSimSymbolGenerator::basicBlockSymbol(), bbEnds_, bbStarts_, className_, ConflictDetectionCodeGenerator::conflictDetectionEnabled(), conflictDetectionGenerator_, AssocTools::containsKey(), CompiledSimMove::copyToBusCode(), createdFiles_, currentFile_, currentFileName_, currentProcedure_, declaredFunctions_, delayedFUResultWrites_, TTAProgram::Immediate::destination(), TTAProgram::Move::destination(), ConflictDetectionCodeGenerator::detectConflicts(), FileSystem::DIRECTORY_SEPARATOR, DS, CompiledSimSymbolGenerator::enablePrefix(), exitPoints_, functionPerFile_, TTAProgram::Terminal::functionUnit(), CompiledSimSymbolGenerator::FUResultSymbol(), generateFUResultRead(), generateGuardCondition(), generateGuardRead(), generateShutdownCode(), globalSymbolSuffix_, handleCycleEnd_, handleOperation(), handleRegisterWrite(), headerFile_, TTAProgram::TerminalFUPort::hwOperation(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), CompiledSimSymbolGenerator::immediateRegisterSymbol(), TTAProgram::Terminal::immediateUnit(), instructionCounter_, instructionNumber_, SimValue::intValue(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediateRegister(), isProcedureBegin_, isStoreOperation(), TTAProgram::Move::isTriggering(), TTAProgram::Move::isUnconditional(), lastFUWrites_, lastGuardBool_, TTAProgram::Program::lastInstruction(), lastInstructionOfBB_, TTAProgram::Address::location(), maxInstructionsPerFile_, TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), moveCounter_, CompiledSimSymbolGenerator::moveOperandSymbol(), TTAMachine::HWOperation::name(), TTAProgram::Procedure::name(), needGuardPipeline_, os_, TTAProgram::Terminal::port(), procedureBBRelations_, ProcedureBBRelations::procedureStart, program_, CompiledSimSymbolGenerator::registerSymbol(), TTAMachine::ImmediateUnit::signExtends(), TTAProgram::Move::source(), symbolGen_, targetDirectory_, SimValue::unsignedValue(), usedGuardSymbols_, TTAProgram::Immediate::value(), TTAProgram::TerminalImmediate::value(), and TTAMachine::Port::width().

Referenced by generateProcedureCode().

Here is the call graph for this function:

generateJumpTableCode()

void CompiledSimCodeGenerator::generateJumpTableCode ( )

private

Generates code that updates the jump table and finds out all the basic blocks

Definition at line 889 of file CompiledSimCodeGenerator.cc.

                                                {
    *os_ << "\t" << "resizeJumpTable(lastInstruction_ + 1);" << endl;
 
    // If static simulation, set all jump targets in the constructor.
    if (!dynamicCompilation_) {
        for (AddressMap::const_iterator it = bbStarts_.begin();
            it != bbStarts_.end(); ++it) {
            *os_ << "\t" << "setJumpTargetFunction(" << it->first << ", &"
                << symbolGen_.basicBlockSymbol(it->first) << ");" << endl;
        }
    }
}

References CompiledSimSymbolGenerator::basicBlockSymbol(), bbStarts_, dynamicCompilation_, os_, and symbolGen_.

Referenced by generateConstructorCode().

Here is the call graph for this function:

generateLoadTrigger()

string CompiledSimCodeGenerator::generateLoadTrigger ( const TTAMachine::HWOperation &  op )

private

Generates a faster version of specific load triggers

Parameters

op	The load operation (either ldw, ldq, ldh, ldhu, or ldqu)

Definition at line 1617 of file CompiledSimCodeGenerator.cc.

                                     {
    const FunctionUnit& fu = *op.parentUnit();
    std::stringstream ss;
    string address = symbolGen_.portSymbol(*op.port(1)) + ".uLongWordValue()";
    string memory = symbolGen_.DAMemorySymbol(op.parentUnit()->name());
    string MAUSize = Conversion::toString(fu.addressSpace()->width());
    string method;
    string extensionMode = "SIGN_EXTEND";
    string resultSignExtend;
    string temp = symbolGen_.generateTempVariable();
 
    const MemoryOperationDescription& memOpDesc = supportedMemoryOps.at(
        op.name());
    method = "fastRead";
    if (memOpDesc.mauCount > 1) {
        method += std::to_string(memOpDesc.mauCount) + "MAUs";
        if (memOpDesc.mauOrder == MAUOrder::littleEndian) {
            method += "LE";
        } else { // big-endian
            method += "BE";
        }
    } else {
        method += "MAU";
    }
 
    if (memOpDesc.extensionMode == ExtensionMode::sign) {
        extensionMode = "SIGN_EXTEND";
    } else {
        extensionMode = "ZERO_EXTEND";
    }
 
    resultSignExtend = temp + " = " + extensionMode
        + "(" + temp + ", (" + MAUSize + "*"
        + std::to_string(memOpDesc.mauCount) +"));";
 
    ss << "ULongWord " << temp << "; " << memory + "." << method << "("
       << address << ", " << temp << "); ";
 
    ss << resultSignExtend << " ";
 
    ss << generateAddFUResult(*op.port(2), temp, op.latency());
    
    return ss.str();
}

References TTAMachine::FunctionUnit::addressSpace(), CompiledSimSymbolGenerator::DAMemorySymbol(), generateAddFUResult(), CompiledSimSymbolGenerator::generateTempVariable(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::HWOperation::parentUnit(), TTAMachine::HWOperation::port(), CompiledSimSymbolGenerator::portSymbol(), symbolGen_, Conversion::toString(), and TTAMachine::AddressSpace::width().

Referenced by generateTriggerCode().

Here is the call graph for this function:

generateMakefile()

void CompiledSimCodeGenerator::generateMakefile ( )

private

Generates a Makefile for compiling the simulation engine.

Definition at line 245 of file CompiledSimCodeGenerator.cc.

                                           {
 
    currentFileName_ =
        targetDirectory_ + FileSystem::DIRECTORY_SEPARATOR + "Makefile";
 
    std::ofstream makefile(currentFileName_.c_str());
    std::vector<std::string> includePaths = Environment::includeDirPaths();
    std::string includes;
    for (std::vector<std::string>::iterator it = includePaths.begin(); 
        it != includePaths.end(); ++it) {
        includes += "-I" + *it + " ";
    }
 
    makefile 
        << "sources = $(wildcard *.cpp)" << endl
        << "objects = $(patsubst %.cpp,%.o,$(sources))" << endl
        << "dobjects = $(patsubst %.cpp,%.so,$(sources))" << endl
        << "includes = " << includes << endl
        << "soflags = " << CompiledSimCompiler::COMPILED_SIM_SO_FLAGS << endl 
            
        // use because ccache doesn't like changing directory paths
        // (in a preprocessor comment)
        << "cppflags = " << CompiledSimCompiler::COMPILED_SIM_CPP_FLAGS << endl
        << endl
        
        << "all: CompiledSimulationEngine.so" << endl << endl
 
        << "CompiledSimulationEngine.so: CompiledSimulationEngine.hh.gch "
        << "$(dobjects) CompiledSimulationEngine.cc" << endl
        << "\t#@echo Compiling CompiledSimulationEngine.so" << endl
        << "\t$(CC) $(cppflags) -O0 $(includes) CompiledSimulationEngine.cc "
        << "-c -o CompiledSimulationEngine.o" << endl 
        << "\t$(CC) $(soflags) CompiledSimulationEngine.o -o CompiledSimulationEngine.so"
        << endl << endl
        << "$(dobjects): %.so: %.cpp CompiledSimulationEngine.hh.gch" << endl
 
        // compile and link phases separately to allow distributed compilation
        // thru distcc
        << "\t$(CC) -c $(cppflags) $(opt_flags) $(includes) $< -o $@.o" << endl
        << "\t$(CC) $(soflags) $(opt_flags) -lgcc $@.o -o $@" << endl
        << "\t@rm -f $@.so.o" << endl
        << endl
            
        // use precompiled headers for more speed
        << "CompiledSimulationEngine.hh.gch:" << endl
        << "\t$(CC) $(cppflags) $(opt_flags) $(includes) "
        << "-xc++-header CompiledSimulationEngine.hh" << endl
        << endl
            
        << "clean:" << endl
        << "\t@rm -f $(dobjects) CompiledSimulationEngine.so CompiledSimulationEngine.hh.gch" << endl;
    
    makefile.close();
    currentFileName_.clear();
}

References CompiledSimCompiler::COMPILED_SIM_CPP_FLAGS, CompiledSimCompiler::COMPILED_SIM_SO_FLAGS, currentFileName_, FileSystem::DIRECTORY_SEPARATOR, Environment::includeDirPaths(), and targetDirectory_.

Referenced by generateToDirectory().

Here is the call graph for this function:

generateProcedureCode()

void CompiledSimCodeGenerator::generateProcedureCode ( const TTAProgram::Procedure &  procedure )

private

Generates code for each instruction in a procedure

Parameters

procedure

the procedure to generate code from

Exceptions

InstanceNotFound

if the first instruction wasn't found

Definition at line 691 of file CompiledSimCodeGenerator.cc.

                                                                          {
    currentProcedure_ = &procedure;
    isProcedureBegin_ = true;
    for (int i = 0; i < procedure.instructionCount(); i++) {
        Instruction& instruction = procedure.instructionAtIndex(i);
        generateInstruction(instruction);
        instructionNumber_++;
        instructionCounter_--;
        isProcedureBegin_ = false;
    }
}

References currentProcedure_, generateInstruction(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), instructionCounter_, instructionNumber_, and isProcedureBegin_.

Referenced by generateSimulationCode().

Here is the call graph for this function:

generateShutdownCode()

void CompiledSimCodeGenerator::generateShutdownCode ( InstructionAddress  address )

private

Generates shutdown code for the given instruction address

Parameters

address

Address location of the instruction. Will be saved in the PC

Definition at line 710 of file CompiledSimCodeGenerator.cc.

                                                                         {
    *os_ << "/* PROGRAM EXIT */" << endl
         << "engine.programCounter_ = " << address << ";" << endl
         << "engine.isFinished_ = true; return;" << endl;
}

References os_.

Referenced by generateInstruction().

generateSimulationCode()

void CompiledSimCodeGenerator::generateSimulationCode ( )

private

Generates the simulateCycle() function that is called outside the .so file

The generated function simulates one basic block at a time by calling the according basic block methods.

Definition at line 598 of file CompiledSimCodeGenerator.cc.

                                                 {
    
    findBasicBlocks();
    exitPoints_ = simController_.findProgramExitPoints(program_, machine_);
 
    // generate code for all procedures
    for (int i = 0; i < program_.procedureCount(); ++i) {
        generateProcedureCode(program_.procedure(i));
    }
 
    // Close the last file
    currentFile_.close();
    currentFileName_.clear();
    os_ = NULL;
}

References currentFile_, currentFileName_, exitPoints_, findBasicBlocks(), TTASimulationController::findProgramExitPoints(), generateProcedureCode(), machine_, os_, TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), program_, and simController_.

Referenced by generateToDirectory().

Here is the call graph for this function:

generateSimulationGetter()

void CompiledSimCodeGenerator::generateSimulationGetter ( )

private

Generates code for a C function that returns an instance of the compiled sim

Definition at line 749 of file CompiledSimCodeGenerator.cc.

                                                   {
    // use C-style functions only! (C++ name mangling complicates stuff)
    *os_ << "/* Class getter function */" << endl
         << "extern \"C\" EXPORT CompiledSimulation* "  
         << "getSimulation_" << globalSymbolSuffix_ << "(" << endl
         << "\tconst TTAMachine::Machine& machine," << endl
         << "\tInstructionAddress entryAddress," << endl
         << "\tInstructionAddress lastInstruction," << endl
         << "\tSimulatorFrontend& frontend," << endl
         << "\tCompiledSimController& controller," << endl
         << "\tMemorySystem& memorySystem," << endl
         << "\tbool dynamicCompilation," << endl
         << "\tProcedureBBRelations& procedureBBRelations) {" << endl
         << "\treturn new " << className_
         << "(machine, entryAddress, lastInstruction, frontend, controller, "
         << "memorySystem, dynamicCompilation, procedureBBRelations); "
         << endl << "}" << endl << endl; // 2x end-of-line in the end of file
}

References className_, globalSymbolSuffix_, and os_.

Referenced by generateConstructorCode().

generateStoreTrigger()

string CompiledSimCodeGenerator::generateStoreTrigger ( const TTAMachine::HWOperation &  op )

private

Generates a faster version of specific store triggers

Parameters

o	The store operation (either stw, sth or stq)

Definition at line 1588 of file CompiledSimCodeGenerator.cc.

                                     {
    string address = symbolGen_.portSymbol(*op.port(1)) + ".uIntWordValue()";
    string dataToWrite = symbolGen_.portSymbol(*op.port(2)) + ".uIntWordValue()";
    string memory = symbolGen_.DAMemorySymbol(op.parentUnit()->name());
    string method;
 
    const MemoryOperationDescription& memOpDesc = supportedMemoryOps.at(
        op.name());
    method = "fastWrite";
    if (memOpDesc.mauCount > 1) {
        method += std::to_string(memOpDesc.mauCount) + "MAUs";
        if (memOpDesc.mauOrder == MAUOrder::littleEndian) {
            method += "LE";
        } else { // big-endian
            method += "BE";
        }
    } else {
        method += "MAU";
    }
    
    return memory + "." + method + "(" + address + ", " + dataToWrite + ");";
}

References CompiledSimSymbolGenerator::DAMemorySymbol(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::HWOperation::parentUnit(), TTAMachine::HWOperation::port(), CompiledSimSymbolGenerator::portSymbol(), and symbolGen_.

Referenced by generateTriggerCode().

Here is the call graph for this function:

generateSymbolDeclarations()

void CompiledSimCodeGenerator::generateSymbolDeclarations ( )

private

Generates declarations for all the symbols in the declared symbols -list

(SimValues, bool guards...)

Definition at line 874 of file CompiledSimCodeGenerator.cc.

                                                     {
    
    symbolGen_.disablePrefix();
    
    for (SimValueSymbolDeclarations::const_iterator it = 
        declaredSymbols_.begin(); it != declaredSymbols_.end(); ++it) {
            *os_ << "\t" << "SimValue " << it->first << ";" << endl;
    }
    *os_ << endl;
}

References declaredSymbols_, CompiledSimSymbolGenerator::disablePrefix(), os_, and symbolGen_.

Referenced by generateHeaderAndMainCode().

Here is the call graph for this function:

generateToDirectory()

void CompiledSimCodeGenerator::generateToDirectory ( const std::string &  dirName )

virtual

Generates compiled simulation code to the given directory.

Parameters

directory

Directory where all the code is to be generated at

Exceptions

IOException

if the directory could not be opened for writing

Definition at line 231 of file CompiledSimCodeGenerator.cc.

                                                                     {
    targetDirectory_ = directory;
    headerFile_ = "CompiledSimulationEngine.hh";
    mainFile_ = "CompiledSimulationEngine.cc";
 
    generateMakefile();
    generateSimulationCode();
    generateHeaderAndMainCode();
}

References generateHeaderAndMainCode(), generateMakefile(), generateSimulationCode(), headerFile_, mainFile_, and targetDirectory_.

Referenced by CompiledSimController::reset().

Here is the call graph for this function:

generateTriggerCode()

string CompiledSimCodeGenerator::generateTriggerCode ( const TTAMachine::HWOperation &  op )

private

Generates code for calling triggered operations

Parameters

op	The operation to be triggered

Returns

A string containing the generated C++ code

Definition at line 1501 of file CompiledSimCodeGenerator.cc.

                                     {
    
    vector<string> operands;
    string source = "EXEC_OPERATION(";
       
    // grab all operands and initialize them to the operand table
    for (int i = 1; op.port(i) != NULL; ++i) {
        if (op.port(i)->isInput()) {
            operands.push_back(symbolGen_.portSymbol(*op.port(i)));
        } else {
            operands.push_back(std::string("outputvalue")+Conversion::toString(i));
        }
    }
    
    if (isStoreOperation(op.name())) {
        return generateStoreTrigger(op);
    } else if (isLoadOperation(op.name())) {
        return generateLoadTrigger(op);
    }
    OperationDAG* dag = &operationPool_.operation(op.name().c_str()).dag(0);
 
    std::string simCode = 
        OperationDAGConverter::createSimulationCode(*dag, &operands);
 
    for (int i = 1, tmp = 1; op.port(i) != NULL; ++i) {
        if (op.port(i)->isOutput()) {
 
            std::string outValueStr;
            // add output values as delayed assignments
            std::string outputStr = std::string("outputvalue") + Conversion::toString(i);
            size_t ovLen = outputStr.length() + 3;
            while (simCode.find(outputStr + " = ") != string::npos) {
                std::size_t begin = simCode.find(outputStr+" = ");
                std::size_t end = simCode.find(";", begin);
                outValueStr = simCode.substr(begin+ovLen,(end-begin-ovLen));
                simCode.erase(begin, end-begin);
            }
 
            if (outValueStr.empty()) {
                std::string msg = "Machine has bound outport not used by op: ";
                msg += op.name();
                msg += " port index: ";
                msg += Conversion::toString(i);
                throw IllegalMachine(__FILE__,__LINE__,__func__,msg);
            }
 
            // generate new unique name for it
            string tempVariable = symbolGen_.generateTempVariable();
 
            if (simCode.find(outValueStr) == string::npos) {
                continue;
            }
 
            while(simCode.find(outValueStr) != string::npos) {
                string::iterator it = simCode.begin() + simCode.find(outValueStr);
                simCode.replace(it, it + outValueStr.length(), tempVariable);
            }
            
            simCode.append("\n" + generateAddFUResult(*op.port(i), 
                tempVariable, op.latency()));
            tmp++;
        } // end isOutput
    } // end for
 
    // fix the names of the tmp[n] values to unique ones so there can be 
    // multiple in same BB.
    while (simCode.find("SimValue tmp") != string::npos) {
        std::size_t begin = simCode.find("SimValue tmp");
        std::size_t end = simCode.find(";", begin);
        std::string tmpName = simCode.substr(begin+9,(end-begin-9));
        string tempVariable = symbolGen_.generateTempVariable();
 
        while(simCode.find(tmpName) != string::npos) {
            string::iterator it = simCode.begin() + simCode.find(tmpName);
            simCode.replace(it,it + tmpName.length(), tempVariable);
        }
    }
 
    return simCode;
}

References __func__, OperationDAGConverter::createSimulationCode(), Operation::dag(), generateAddFUResult(), generateLoadTrigger(), generateStoreTrigger(), CompiledSimSymbolGenerator::generateTempVariable(), TTAMachine::Port::isInput(), isLoadOperation(), TTAMachine::Port::isOutput(), isStoreOperation(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), OperationPool::operation(), operationPool_, TTAMachine::HWOperation::port(), CompiledSimSymbolGenerator::portSymbol(), symbolGen_, and Conversion::toString().

Referenced by handleOperation().

Here is the call graph for this function:

guardPipelineTopSymbol()

std::string CompiledSimCodeGenerator::guardPipelineTopSymbol ( const TTAMachine::RegisterGuard &  guard )

private

Definition at line 1824 of file CompiledSimCodeGenerator.cc.

                                       {
    const RegisterFile* rf = rg.registerFile();
    std::string regName = "RF_"  + rf->name() + "_" + 
        Conversion::toString(rg.registerIndex());
    GuardPipeline::iterator i = guardPipeline_.find(regName);
    assert(i!= guardPipeline_.end());
    return "engine.guard_pipeline_RF_" + 
        DisassemblyRegister::registerName(*rf, rg.registerIndex(), '_') +
        "_" + Conversion::toString(i->second -1);
}

References assert, guardPipeline_, TTAMachine::Component::name(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), DisassemblyRegister::registerName(), and Conversion::toString().

Referenced by generateGuardRead().

Here is the call graph for this function:

handleJump()

string CompiledSimCodeGenerator::handleJump ( const TTAMachine::HWOperation &  op )

private

Generates code for a jump operation

Parameters

op	A jump or call operation

Returns

A std::string containing generated code for the jump call

Definition at line 921 of file CompiledSimCodeGenerator.cc.

                                                                    {
    assert(op.name() == "call" || op.name() == "jump");
    
    std::stringstream ss;
    ss << "engine.jumpTarget_ = " 
       << symbolGen_.portSymbol(*op.port(1)) << ".sIntWordValue();";
    if (op.name() == "call") { // save return address
        ss << symbolGen_.returnAddressSymbol(gcu_) << " = " 
           << instructionNumber_ + gcu_.delaySlots() + 1 << "u;" << endl;
    }
    return ss.str();
}

References assert, TTAMachine::ControlUnit::delaySlots(), gcu_, instructionNumber_, TTAMachine::HWOperation::name(), TTAMachine::HWOperation::port(), CompiledSimSymbolGenerator::portSymbol(), CompiledSimSymbolGenerator::returnAddressSymbol(), and symbolGen_.

Referenced by handleOperation(), and handleOperationWithoutDag().

Here is the call graph for this function:

handleOperation()

string CompiledSimCodeGenerator::handleOperation ( const TTAMachine::HWOperation &  op )

private

Generates code for a triggered operation.

Parameters

op	The triggered operation

Returns

A std::string containing generated code for the operation call

Todo:

maybe use IsCall & IsControlFlowOperation.

Definition at line 941 of file CompiledSimCodeGenerator.cc.

                                                                         {
    std::stringstream ss;
                     
    ss << endl << "/* Operation: " << op.name() << ", latency: "
       << op.latency() << " */" << endl;
    
    if (operationPool_.operation(op.name().c_str()).dagCount() <= 0) {
        ss << handleOperationWithoutDag(op);
    } else {
        /// @todo maybe use IsCall & IsControlFlowOperation.
        if (op.name() != "jump" && op.name() != "call") {
            ss << "#define context "
               << symbolGen_.operationContextSymbol(*op.parentUnit())
               << endl
               << "#define opPool_ engine.operationPool_" << endl
               << generateTriggerCode(op) << endl
               << "#undef context" << endl
               << "#undef opPool_" << endl
               << endl;
        } else { // simulate a jump
            ss << handleJump(op);
        }
    }
    return ss.str();
}

References Operation::dagCount(), generateTriggerCode(), handleJump(), handleOperationWithoutDag(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), OperationPool::operation(), CompiledSimSymbolGenerator::operationContextSymbol(), operationPool_, TTAMachine::HWOperation::parentUnit(), and symbolGen_.

Referenced by generateInstruction().

Here is the call graph for this function:

handleOperationWithoutDag()

string CompiledSimCodeGenerator::handleOperationWithoutDag ( const TTAMachine::HWOperation &  op )

private

Generates code for a triggered operation that has no DAG available

Parameters

op	The triggered operation

Returns

A std::string containing generated code for the operation call

Todo:

maybe use IsCall & IsControlFlowOperation.

Definition at line 974 of file CompiledSimCodeGenerator.cc.

                                     {
    std::stringstream ss;        
 
    std::vector<string> operandSymbols;
    string operandTable = symbolGen_.generateTempVariable();
    
    // Generate symbols for each operand, and temporaries for output operands
    for (int i = 1; op.port(i) != NULL; ++i) {
        if (op.port(i)->isOutput()) {
            string outputSymbol = symbolGen_.generateTempVariable();
            operandSymbols.push_back(outputSymbol);
            ss << "SimValue " << outputSymbol 
               << "(" << op.port(i)->width() << ");" << endl;
        } else { // input port
            string inputSymbol = symbolGen_.portSymbol(*op.port(i));
            operandSymbols.push_back(inputSymbol);
        }
    }
    
    // Add operand symbols to the operand table
    ss << "SimValue* " << operandTable << "[] = {";
    for (size_t i = 0; i < operandSymbols.size(); ++i) {
      ss << "&" << operandSymbols.at(i);
      if (i < operandSymbols.size() - 1) {
          ss << ",";
      }
      ss << " ";
    }
    ss << "};";
    
    // call simulateTrigger with the previously generated operand table
    /// @todo maybe use IsCall & IsControlFlowOperation.
    if (op.name() != "jump" && op.name() != "call") {
        ss << symbolGen_.operationSymbol(op.name(), *op.parentUnit())
           << ".simulateTrigger(" << operandTable << ", "
           << symbolGen_.operationContextSymbol(*op.parentUnit())
           << "); ";
               
        // add output values as delayed assignments
        for (int i = 1; op.port(i) != NULL; ++i) {
            if (op.port(i)->isOutput()) {
                ss << generateAddFUResult(*op.port(i), operandSymbols.at(i - 1), 
                    op.latency());
            }
        }
    } else { // simulate a jump
        ss << handleJump(op);
    }
 
    return ss.str();
}

References generateAddFUResult(), CompiledSimSymbolGenerator::generateTempVariable(), handleJump(), TTAMachine::Port::isOutput(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), CompiledSimSymbolGenerator::operationContextSymbol(), CompiledSimSymbolGenerator::operationSymbol(), TTAMachine::HWOperation::parentUnit(), TTAMachine::HWOperation::port(), CompiledSimSymbolGenerator::portSymbol(), symbolGen_, and TTAMachine::BaseFUPort::width().

Referenced by handleOperation().

Here is the call graph for this function:

handleRegisterWrite()

bool CompiledSimCodeGenerator::handleRegisterWrite ( const std::string &  regSymbolName, std::ostream &  stream  )

private

Definition at line 1838 of file CompiledSimCodeGenerator.cc.

                                                        {
    std::string tmpString;
    std::string tmpString2;
 
    const string tmpRef1 = regSymbolName;
 
    // drop ".engine" from beginning
    // if found, copy to tmp and take ref to tmp. not found, ref to original
    const string& tmpRef2 = (tmpRef1.find("engine.") == 0) ? 
        tmpString2 = tmpRef1.substr(7) : 
        tmpRef1;
 
    GuardPipeline::iterator i = guardPipeline_.find(tmpRef2);
    if ( i != guardPipeline_.end()) {
        stream << "engine.guard_pipeline_" << tmpRef2 << "_0 " 
               << " = !(MathTools::fastZeroExtendTo(" 
               << tmpRef1 << ".uIntWordValue(), "
               << tmpRef1 << ".width()) == 0u);" << std::endl;
        return true;
    }
    return false;
}

References guardPipeline_.

Referenced by generateInstruction().

isLoadOperation()

bool CompiledSimCodeGenerator::isLoadOperation ( const std::string &  opName )

staticprivate

Definition at line 1886 of file CompiledSimCodeGenerator.cc.

                                                                 {
    auto it = supportedMemoryOps.find(opName);
    if (it == supportedMemoryOps.end()) return false;
 
    return (it->second.accessMode == AccessMode::read);
}

Referenced by generateTriggerCode().

isStoreOperation()

bool CompiledSimCodeGenerator::isStoreOperation ( const std::string &  opName )

staticprivate

Definition at line 1878 of file CompiledSimCodeGenerator.cc.

                                                                  {
    auto it = supportedMemoryOps.find(opName);
    if (it == supportedMemoryOps.end()) return false;
 
    return (it->second.accessMode == AccessMode::write);
}

Referenced by generateInstruction(), and generateTriggerCode().

maxLatency()

int CompiledSimCodeGenerator::maxLatency ( ) const

private

Returns the maximum possible latency from the FUs & GCU

Returns

the maximum possible latency from the FUs & GCU

Definition at line 1769 of file CompiledSimCodeGenerator.cc.

                                           {    
    const Machine::FunctionUnitNavigator& fus = machine_.functionUnitNavigator();    
    int maxLatency = machine_.controlUnit()->globalGuardLatency();
    for (int i = 0; i < fus.count(); ++i) {
        if (maxLatency < fus.item(i)->maxLatency()) {
            maxLatency = fus.item(i)->maxLatency();
        }
    }
    return maxLatency;
}

References TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::ControlUnit::globalGuardLatency(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, and maxLatency().

Referenced by maxLatency().

Here is the call graph for this function:

operator=()

CompiledSimCodeGenerator & CompiledSimCodeGenerator::operator= ( const CompiledSimCodeGenerator &  )

private

Assignment not allowed.

procedureBBRelations()

ProcedureBBRelations CompiledSimCodeGenerator::procedureBBRelations ( ) const

virtual

Returns a struct of basic blocks and their corresponding code files

Returns

a struct of basic blocks and their corresponding code files

Definition at line 330 of file CompiledSimCodeGenerator.cc.

                                                     {
    return procedureBBRelations_;
}

References procedureBBRelations_.

Referenced by CompiledSimController::reset().

supportedMemoryOperations()

TCETools::CIStringSet CompiledSimCodeGenerator::supportedMemoryOperations ( )

static

Returns list of all supported memory accessing operations for compiled simulation.

Definition at line 1868 of file CompiledSimCodeGenerator.cc.

                                                    {
    TCETools::CIStringSet result;
    for (auto& pair : supportedMemoryOps) {
        result.insert(pair.first);
    }
    return result;
}

updateDeclaredSymbolsList()

void CompiledSimCodeGenerator::updateDeclaredSymbolsList ( )

private

Updates the declared symbols list after the program code is generated.

Generates constructor calls for each declared symbol.

Definition at line 799 of file CompiledSimCodeGenerator.cc.

                                                    {
    
    symbolGen_.disablePrefix();
        
    // Constructor calls for SimValues
    for (SimValueSymbolDeclarations::iterator it = declaredSymbols_.begin();
        it != declaredSymbols_.end(); ++it) {
        *os_ << "\t";
        if (it != declaredSymbols_.begin()) {
            *os_ << ",";
        }
        *os_ << it->first << "(" << Conversion::toString(it->second) 
             << ")" << endl;
    }
    if (!declaredSymbols_.empty()) {
        *os_ << endl;
    }
 
    // Operations
    for (OperationSymbolDeclarations::iterator it = usedOperations_.begin();
         it != usedOperations_.end(); ++it) {
        *os_ << "\t," << it->second
             << "(operationPool_.operation(\"" << it->first << "\"))" << endl;
    }
    if (!usedOperations_.empty()) {
        *os_ << endl;
    }
    
    // FU result symbols
    const Machine::FunctionUnitNavigator& fus = machine_.functionUnitNavigator();    
    for (int i = 0; i < fus.count(); ++i) {
        const FunctionUnit& fu = *fus.item(i);
        std::vector<Port*> outPorts = fuOutputPorts(fu);
        for (size_t j = 0; j < outPorts.size(); ++j) {
            *os_ << "\t," << symbolGen_.FUResultSymbol(*outPorts.at(j)) 
                 << "(" << Conversion::toString(fu.maxLatency()+1) << ")";
            *os_ << endl;
        }
    }
    if (fus.count() > 0) {
        *os_ << endl;
    }
    // Conflict detectors
    *os_ << conflictDetectionGenerator_.updateSymbolDeclarations() << endl;
 
    // DirectAccessMemories
    for (int i = 0; i < fus.count(); i++) {
        const FunctionUnit & fu = *fus.item(i);
        if (fu.addressSpace() != NULL) {
            *os_ << "\t," << symbolGen_.DAMemorySymbol(fu) 
                 << "(FUMemory(\"" << fu.name() << "\"))" << endl;
        }
    }
    *os_ << " {" << endl;
}

References TTAMachine::FunctionUnit::addressSpace(), conflictDetectionGenerator_, TTAMachine::Machine::Navigator< ComponentType >::count(), CompiledSimSymbolGenerator::DAMemorySymbol(), declaredSymbols_, CompiledSimSymbolGenerator::disablePrefix(), TTAMachine::Machine::functionUnitNavigator(), fuOutputPorts(), CompiledSimSymbolGenerator::FUResultSymbol(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TTAMachine::FunctionUnit::maxLatency(), TTAMachine::Component::name(), os_, symbolGen_, Conversion::toString(), ConflictDetectionCodeGenerator::updateSymbolDeclarations(), and usedOperations_.

Referenced by generateConstructorCode().

Here is the call graph for this function:

updateSymbolsMap()

void CompiledSimCodeGenerator::updateSymbolsMap ( )

private

Updates the Symbols map of the CompiledSimulation class

Definition at line 859 of file CompiledSimCodeGenerator.cc.

                                           {
    for (SimValueSymbolDeclarations::const_iterator it =
        declaredSymbols_.begin(); it != declaredSymbols_.end(); ++it) {
        string symbolName = it->first;
        *os_ << "\t" << "addSymbol(\"" << symbolName << "\", " 
             << symbolName << ");" << endl;
    }
}

References declaredSymbols_, and os_.

Referenced by generateConstructorCode().

Member Data Documentation

basicBlockPerFile_

bool CompiledSimCodeGenerator::basicBlockPerFile_

private

Should the generator generate only one basic block per code file.

Definition at line 221 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

bbEnds_

AddressMap CompiledSimCodeGenerator::bbEnds_

mutableprivate

The basic block map referred by end of the block as a key.

Definition at line 260 of file CompiledSimCodeGenerator.hh.

Referenced by basicBlocks(), findBasicBlocks(), generateAddFUResult(), and generateInstruction().

bbStarts_

AddressMap CompiledSimCodeGenerator::bbStarts_

mutableprivate

The basic block map referred by start of the block as a key.

Definition at line 258 of file CompiledSimCodeGenerator.hh.

Referenced by basicBlocks(), findBasicBlocks(), generateConstructorCode(), generateInstruction(), and generateJumpTableCode().

className_

std::string CompiledSimCodeGenerator::className_

private

Name of the class to be created.

Definition at line 274 of file CompiledSimCodeGenerator.hh.

Referenced by generateConstructorCode(), generateConstructorParameters(), generateFUOutputUpdater(), generateHeaderAndMainCode(), generateInstruction(), and generateSimulationGetter().

conflictDetectionGenerator_

ConflictDetectionCodeGenerator CompiledSimCodeGenerator::conflictDetectionGenerator_

private

Conflict detection code generator.

Definition at line 290 of file CompiledSimCodeGenerator.hh.

Referenced by generateAdvanceClockCode(), generateConstructorCode(), generateHeaderAndMainCode(), generateInstruction(), and updateDeclaredSymbolsList().

createdFiles_

StringSet CompiledSimCodeGenerator::createdFiles_

private

A list of the code files created during the process.

Definition at line 233 of file CompiledSimCodeGenerator.hh.

Referenced by createdFiles(), generateConstructorCode(), and generateInstruction().

currentFile_

std::fstream CompiledSimCodeGenerator::currentFile_

private

Current file being processed.

Definition at line 280 of file CompiledSimCodeGenerator.hh.

Referenced by generateConstructorCode(), generateHeaderAndMainCode(), generateInstruction(), and generateSimulationCode().

currentFileName_

std::string CompiledSimCodeGenerator::currentFileName_

private

Name of the current file being processed.

Definition at line 282 of file CompiledSimCodeGenerator.hh.

Referenced by generateHeaderAndMainCode(), generateInstruction(), generateMakefile(), and generateSimulationCode().

currentProcedure_

const TTAProgram::Procedure* CompiledSimCodeGenerator::currentProcedure_

private

Pointer to the current Procedure being processed.

Definition at line 246 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction(), and generateProcedureCode().

declaredFunctions_

StringSet CompiledSimCodeGenerator::declaredFunctions_

private

A set of all the declared functions.

Definition at line 231 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

declaredSymbols_

SimValueSymbolDeclarations CompiledSimCodeGenerator::declaredSymbols_

private

A list of all symbols that are declared after the program code is ready.

Definition at line 228 of file CompiledSimCodeGenerator.hh.

Referenced by addDeclaredSymbol(), generateSymbolDeclarations(), updateDeclaredSymbolsList(), and updateSymbolsMap().

delayedFUResultWrites_

DelayedAssignments CompiledSimCodeGenerator::delayedFUResultWrites_

private

Delayed FU Result assignments.

Definition at line 264 of file CompiledSimCodeGenerator.hh.

Referenced by generateAddFUResult(), and generateInstruction().

dynamicCompilation_

bool CompiledSimCodeGenerator::dynamicCompilation_

private

Is this a dynamic compiled simulation?

Definition at line 219 of file CompiledSimCodeGenerator.hh.

Referenced by generateJumpTableCode().

exitPoints_

std::set<InstructionAddress> CompiledSimCodeGenerator::exitPoints_

private

Program exit point addresses.

Definition at line 255 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction(), and generateSimulationCode().

functionPerFile_

bool CompiledSimCodeGenerator::functionPerFile_

private

Should the generator start with a new file after function end.

Definition at line 223 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

gcu_

const TTAMachine::ControlUnit& CompiledSimCodeGenerator::gcu_

private

GCU.

Definition at line 214 of file CompiledSimCodeGenerator.hh.

Referenced by handleJump().

globalSymbolSuffix_

TCEString CompiledSimCodeGenerator::globalSymbolSuffix_

private

Definition at line 305 of file CompiledSimCodeGenerator.hh.

Referenced by generateFUOutputUpdater(), generateHeaderAndMainCode(), generateInstruction(), and generateSimulationGetter().

guardPipeline_

GuardPipeline CompiledSimCodeGenerator::guardPipeline_

private

Definition at line 301 of file CompiledSimCodeGenerator.hh.

Referenced by CompiledSimCodeGenerator(), generateGuardPipelineAdvance(), generateGuardPipelineVariables(), guardPipelineTopSymbol(), and handleRegisterWrite().

handleCycleEnd_

bool CompiledSimCodeGenerator::handleCycleEnd_

private

Should we let frontend handle each cycle end.

Definition at line 217 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

headerFile_

std::string CompiledSimCodeGenerator::headerFile_

private

Header filename.

Definition at line 276 of file CompiledSimCodeGenerator.hh.

Referenced by generateConstructorCode(), generateHeaderAndMainCode(), generateInstruction(), and generateToDirectory().

instructionCounter_

int CompiledSimCodeGenerator::instructionCounter_

private

Istruction counter for checking how many instructions to put per file.

Definition at line 240 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction(), and generateProcedureCode().

instructionNumber_

int CompiledSimCodeGenerator::instructionNumber_

private

Absolute instruction # being processed.

Definition at line 238 of file CompiledSimCodeGenerator.hh.

Referenced by generateAddFUResult(), generateInstruction(), generateProcedureCode(), and handleJump().

isProcedureBegin_

bool CompiledSimCodeGenerator::isProcedureBegin_

private

Are we at the beginning of a new procedure?

Definition at line 244 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction(), and generateProcedureCode().

lastFUWrites_

FUResultWrites CompiledSimCodeGenerator::lastFUWrites_

private

Last known FU result writes.

Definition at line 266 of file CompiledSimCodeGenerator.hh.

Referenced by generateAddFUResult(), and generateInstruction().

lastGuardBool_

std::string CompiledSimCodeGenerator::lastGuardBool_

private

name of the last used guard variable

Definition at line 251 of file CompiledSimCodeGenerator.hh.

Referenced by generateAddFUResult(), generateGuardCondition(), generateGuardRead(), and generateInstruction().

lastInstructionOfBB_

InstructionAddress CompiledSimCodeGenerator::lastInstructionOfBB_

private

last instruction of the current basic block

Definition at line 249 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

machine_

const TTAMachine::Machine& CompiledSimCodeGenerator::machine_

private

The machine used for simulation.

Definition at line 208 of file CompiledSimCodeGenerator.hh.

Referenced by findBasicBlocks(), generateConstructorCode(), generateFUOutputUpdater(), generateHeaderAndMainCode(), generateSimulationCode(), maxLatency(), and updateDeclaredSymbolsList().

mainFile_

std::string CompiledSimCodeGenerator::mainFile_

private

Main source filename. This includes the constructor and the simulateCycle().

Definition at line 278 of file CompiledSimCodeGenerator.hh.

Referenced by generateConstructorCode(), and generateToDirectory().

maxInstructionsPerFile_

unsigned CompiledSimCodeGenerator::maxInstructionsPerFile_

private

Maximum number of instructions per engine source code file, computed from the instruction width (bus count) to control simulation engine code size explosion with wider simulated machines.

Definition at line 296 of file CompiledSimCodeGenerator.hh.

Referenced by CompiledSimCodeGenerator(), and generateInstruction().

maxInstructionsPerSimulationFunction_

unsigned CompiledSimCodeGenerator::maxInstructionsPerSimulationFunction_

private

Max for each simulation function.

Definition at line 298 of file CompiledSimCodeGenerator.hh.

Referenced by CompiledSimCodeGenerator(), and findBasicBlocks().

moveCounter_

int CompiledSimCodeGenerator::moveCounter_

private

How many moves have we been through with?

Definition at line 242 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction().

needGuardPipeline_

bool CompiledSimCodeGenerator::needGuardPipeline_

private

Definition at line 303 of file CompiledSimCodeGenerator.hh.

Referenced by CompiledSimCodeGenerator(), generateAdvanceClockCode(), generateGuardRead(), generateHeaderAndMainCode(), and generateInstruction().

operationPool_

OperationPool CompiledSimCodeGenerator::operationPool_

private

The operation pool.

Definition at line 269 of file CompiledSimCodeGenerator.hh.

Referenced by generateTriggerCode(), and handleOperation().

os_

std::ostream* CompiledSimCodeGenerator::os_

private

Current output stream i.e. the above file.

Definition at line 284 of file CompiledSimCodeGenerator.hh.

Referenced by generateAdvanceClockCode(), generateConstructorCode(), generateConstructorParameters(), generateFUOutputUpdater(), generateHeaderAndMainCode(), generateInstruction(), generateJumpTableCode(), generateShutdownCode(), generateSimulationCode(), generateSimulationGetter(), generateSymbolDeclarations(), updateDeclaredSymbolsList(), and updateSymbolsMap().

procedureBBRelations_

ProcedureBBRelations CompiledSimCodeGenerator::procedureBBRelations_

private

Basic blocks relations to procedures and vice versa.

Definition at line 262 of file CompiledSimCodeGenerator.hh.

Referenced by generateInstruction(), and procedureBBRelations().

program_

const TTAProgram::Program& CompiledSimCodeGenerator::program_

private

The simulated program.

Definition at line 210 of file CompiledSimCodeGenerator.hh.

Referenced by findBasicBlocks(), generateAddFUResult(), generateInstruction(), and generateSimulationCode().

simController_

const TTASimulationController& CompiledSimCodeGenerator::simController_

private

The simulator frontend.

Definition at line 212 of file CompiledSimCodeGenerator.hh.

Referenced by generateSimulationCode().

symbolGen_

CompiledSimSymbolGenerator CompiledSimCodeGenerator::symbolGen_

private

The symbol generator.

Definition at line 287 of file CompiledSimCodeGenerator.hh.

Referenced by CompiledSimCodeGenerator(), generateAddFUResult(), generateConstructorCode(), generateFUOutputUpdater(), generateGuardCondition(), generateGuardRead(), generateHeaderAndMainCode(), generateInstruction(), generateJumpTableCode(), generateLoadTrigger(), generateStoreTrigger(), generateSymbolDeclarations(), generateTriggerCode(), handleJump(), handleOperation(), handleOperationWithoutDag(), and updateDeclaredSymbolsList().

targetDirectory_

std::string CompiledSimCodeGenerator::targetDirectory_

private

Directory where to write the source files of the engine.

Definition at line 272 of file CompiledSimCodeGenerator.hh.

Referenced by generateConstructorCode(), generateHeaderAndMainCode(), generateInstruction(), generateMakefile(), and generateToDirectory().

usedGuardSymbols_

std::map<std::string, std::string> CompiledSimCodeGenerator::usedGuardSymbols_

private

Temporary list of the used guard bool symbols per instruction.

Definition at line 253 of file CompiledSimCodeGenerator.hh.

Referenced by generateGuardCondition(), generateGuardRead(), and generateInstruction().

usedOperations_

OperationSymbolDeclarations CompiledSimCodeGenerator::usedOperations_

private

A list of used operations.

Definition at line 235 of file CompiledSimCodeGenerator.hh.

Referenced by generateHeaderAndMainCode(), and updateDeclaredSymbolsList().

---

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

• CompiledSimCodeGenerator.hh
• CompiledSimCodeGenerator.cc