#include <UtilizationStats.hh>

Inheritance diagram for UtilizationStats:

Collaboration diagram for UtilizationStats:

Public Types
typedef std::map< std::string, ClockCycleCount >	ComponentUtilizationIndex
	Index for connecting component names to utilization counts. More...

typedef std::map< int, std::pair< ClockCycleCount, ClockCycleCount > >	RegisterUtilizationIndex
	Index for connecting register indices to utilization counts. The first number in the pair is the count of reads, and the second is the count of writes. More...

typedef std::map< std::string, ComponentUtilizationIndex >	FUOperationUtilizationIndex
	Index for connecting function unit and operations implemented in them to utilization counts. More...

typedef std::map< std::string, RegisterUtilizationIndex >	RFRegisterUtilizationIndex
	Index for connecting register files and register utilization indices in them. More...

Public Member Functions
	UtilizationStats ()

virtual	~UtilizationStats ()

virtual void	calculateForInstruction (const TTAProgram::Instruction &instructionData, const ExecutableInstruction &executionCounts)

ClockCycleCount	busWrites (const std::string &busName) const

ClockCycleCount	socketWrites (const std::string &socketName) const

ClockCycleCount	triggerCount (const std::string &fuName) const

ClockCycleCount	operationExecutions (const std::string &operationName) const

ClockCycleCount	operationExecutions (const std::string &fuName, const std::string &operationName) const

ClockCycleCount	registerReads (const std::string &rfName, int registerIndex) const

ClockCycleCount	guardRegisterReads (const std::string &rfName, int registerIndex) const

ClockCycleCount	registerWrites (const std::string &rfName, int registerIndex) const

ClockCycleCount	FUGuardAccesses (const std::string &fuName, const std::string &fuPort) const

FUOperationUtilizationIndex	FUGuardAccesses () const

int	highestUsedRegisterIndex () const

Public Member Functions inherited from SimulationStatisticsCalculator
	SimulationStatisticsCalculator ()

virtual	~SimulationStatisticsCalculator ()

Private Attributes
ComponentUtilizationIndex	sockets_
	Socket write counts. More...

ComponentUtilizationIndex	buses_
	Bus write counts. More...

ComponentUtilizationIndex	fus_
	Function unit utilizations, i.e., total operation triggerings. More...

ComponentUtilizationIndex	operations_
	Operation utilizations (started operations). More...

FUOperationUtilizationIndex	fuOperations_
	Index for operation utilizations for each function unit. More...

RFRegisterUtilizationIndex	rfAccesses_
	Register read and write data for each register in each register file. More...

RFRegisterUtilizationIndex	guardRfAccesses_
	Guard register accesses for each register in a RF. More...

FUOperationUtilizationIndex	guardFUAccesses_
	Guard FU port accesses. More...

int	highestRegister_
	The highest register index used. This is an uglish way to fetch register access info for sequential simulation. More...

Detailed Description

Calculates processor utilization data from instructions and their execution counts.

Definition at line 50 of file UtilizationStats.hh.

Member Typedef Documentation

◆ ComponentUtilizationIndex

typedef std::map<std::string, ClockCycleCount> UtilizationStats::ComponentUtilizationIndex

Index for connecting component names to utilization counts.

Definition at line 53 of file UtilizationStats.hh.

◆ FUOperationUtilizationIndex

typedef std::map<std::string, ComponentUtilizationIndex> UtilizationStats::FUOperationUtilizationIndex

Index for connecting function unit and operations implemented in them to utilization counts.

Definition at line 62 of file UtilizationStats.hh.

◆ RegisterUtilizationIndex

typedef std::map<int, std::pair<ClockCycleCount, ClockCycleCount> > UtilizationStats::RegisterUtilizationIndex

Index for connecting register indices to utilization counts. The first number in the pair is the count of reads, and the second is the count of writes.

Definition at line 58 of file UtilizationStats.hh.

◆ RFRegisterUtilizationIndex

typedef std::map<std::string, RegisterUtilizationIndex> UtilizationStats::RFRegisterUtilizationIndex

Index for connecting register files and register utilization indices in them.

Definition at line 66 of file UtilizationStats.hh.

Constructor & Destructor Documentation

◆ UtilizationStats()

UtilizationStats::UtilizationStats ( )

Constructor.

Definition at line 54 of file UtilizationStats.cc.

54 : highestRegister_(-1) {

55 }

◆ ~UtilizationStats()

UtilizationStats::~UtilizationStats ( )

virtual

Destructor.

Definition at line 60 of file UtilizationStats.cc.

60 {

61 }

Member Function Documentation

◆ busWrites()

ClockCycleCount UtilizationStats::busWrites ( const std::string & busName ) const

Returns the count of writes to the given bus.

Parameters

busName The name of the bus.

Returns: The count of writes.

Definition at line 192 of file UtilizationStats.cc.

                                                           {
     if (MapTools::containsKey(buses_, busName)) 
         return MapTools::valueForKey<ClockCycleCount>(buses_, busName);
     else 
         return 0;
 }

References buses_, and MapTools::containsKey().

Referenced by ProximBusDetailsCmd::Do(), InfoProcCommand::execute(), SimulatorFrontend::finishSimulation(), and ProximMachineStateWindow::setUtilizationHighlights().

Here is the call graph for this function:

◆ calculateForInstruction()

void UtilizationStats::calculateForInstruction	(	const TTAProgram::Instruction &	instructionData,
		const ExecutableInstruction &	executionCounts
	)

virtual

Accumulates the utilization counts for each machine part used by the instruction.

Note: This function assumes that moves in Instruction and ExecutableInstruction are in same order.

Parameters

instructionData	The instruction.
executionCounts	Execution counts of the instruction.

Implements SimulationStatisticsCalculator.

Definition at line 74 of file UtilizationStats.cc.

                                                   {
  
     // used to make sure output socket utilizations are computed only
     // maximum once per instruction, even though the socket is read by
     // multiple buses
     hash_set<const char*> alreadyRegisteredOutputSockets;
  
     for (int i = 0; i < instructionData.moveCount(); ++i) {
         const TTAProgram::Move& move = instructionData.move(i);
         const ClockCycleCount execCount = 
             executionCounts.moveExecutionCount(i);
  
         // it depends on GCU implementation whether immediate jumps are
         // redirected through bus and sockets or not, let's assume they 
         // are, as they are in current CU implementations, according to Teemu
         buses_[move.bus().name()] += execCount;
  
         // socket utilizations
         if (!move.source().isImmediate() && 
             move.sourceSocket().name() != move.destinationSocket().name() &&
             alreadyRegisteredOutputSockets.find(
                 move.sourceSocket().name().c_str()) ==
             alreadyRegisteredOutputSockets.end()) {
  
             sockets_[move.sourceSocket().name()] += execCount;
             alreadyRegisteredOutputSockets.insert(
                 move.sourceSocket().name().c_str());
         }
         sockets_[move.destinationSocket().name()] += execCount;
  
         // operation utilizations
         if (move.destination().isFUPort() &&
             dynamic_cast<const TTAMachine::BaseFUPort&>(
                 move.destination().port()).isTriggering()) {
             const std::string operationUpper =
                 StringTools::stringToUpper(
                     move.destination().operation().name());
             const std::string fuName =
                 move.destination().functionUnit().name();
             fus_[fuName] += execCount;
             operations_[operationUpper] += execCount;
             fuOperations_[fuName][operationUpper] += execCount;
         }
  
         // register reads 
         if (move.source().isGPR()) {
             const std::string rfName = move.source().registerFile().name();
             const int regIndex = move.source().index();
             if (regIndex > highestRegister_) {
                 highestRegister_ = regIndex;
             }
             rfAccesses_[rfName][regIndex].first = 
                 registerReads(rfName, regIndex) + execCount;
         }
         
         // guarded moves
         if (!move.isUnconditional()) {
             // RF reads
             if (dynamic_cast<const TTAMachine::RegisterGuard*>(
                     &move.guard().guard())) {
                 const TTAMachine::RegisterGuard& moveGuard =
                     dynamic_cast<const TTAMachine::RegisterGuard&>(
                         move.guard().guard());
             
                 const std::string rfName = moveGuard.registerFile()->name();
                 const int regIndex = moveGuard.registerIndex();
                 if (regIndex > highestRegister_)
                     highestRegister_ = regIndex;
             
                 guardRfAccesses_[rfName][regIndex].first =
                     guardRegisterReads(rfName, regIndex) + execCount;
             } else { // FU Port reads
                 if (dynamic_cast<const TTAMachine::PortGuard*>(
                         &move.guard().guard())) {
                     const TTAMachine::PortGuard& moveGuard =
                     dynamic_cast<const TTAMachine::PortGuard&>(
                         move.guard().guard());
                     
                     const TTAMachine::FUPort& port = *moveGuard.port();
                     const std::string fuName = port.parentUnit()->name();
                     guardFUAccesses_[fuName][port.name()] += execCount;
                 }
             }
         }
         
         // immediate register reads
         if (move.source().isImmediateRegister()) {
             const std::string iuName = move.source().immediateUnit().name();
             const int regIndex = move.source().index();
             rfAccesses_[iuName][regIndex].first = 
                 registerReads(iuName, regIndex) + execCount;
             if (regIndex > highestRegister_)
                 highestRegister_ = regIndex;
         } 
  
         // register writes
         if (move.destination().isGPR()) {
             const std::string rfName = 
                 move.destination().registerFile().name();
             const int regIndex = move.destination().index();
             if (regIndex > highestRegister_) {
                 highestRegister_ = regIndex;
             }
             rfAccesses_[rfName][regIndex].second =
                 registerWrites(rfName, regIndex) + execCount;
         }
     }
 }

References TTAProgram::Move::bus(), buses_, TTAProgram::Move::destination(), TTAProgram::Move::destinationSocket(), TTAProgram::Terminal::functionUnit(), fuOperations_, fus_, TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), guardFUAccesses_, guardRegisterReads(), guardRfAccesses_, highestRegister_, TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isImmediateRegister(), TTAMachine::BaseFUPort::isTriggering(), TTAProgram::Move::isUnconditional(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), ExecutableInstruction::moveExecutionCount(), TTAMachine::Port::name(), TTAMachine::Component::name(), Operation::name(), TTAProgram::Terminal::operation(), operations_, TTAMachine::BaseFUPort::parentUnit(), TTAProgram::Terminal::port(), TTAMachine::PortGuard::port(), TTAProgram::Terminal::registerFile(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), registerReads(), registerWrites(), rfAccesses_, sockets_, TTAProgram::Move::source(), TTAProgram::Move::sourceSocket(), and StringTools::stringToUpper().

Referenced by CompiledSimUtilizationStats::calculate().

Here is the call graph for this function:

◆ FUGuardAccesses() [1/2]

UtilizationStats::FUOperationUtilizationIndex UtilizationStats::FUGuardAccesses ( ) const

Returns a map containing the FU port guard accesses

Returns: A map containing the FU port guard accesses

Definition at line 355 of file UtilizationStats.cc.

                                         {
     return guardFUAccesses_;    
 }

References guardFUAccesses_.

◆ FUGuardAccesses() [2/2]

ClockCycleCount UtilizationStats::FUGuardAccesses	(	const std::string &	fuName,
		const std::string &	fuPort
	)		const

Returns number of reads for a single FU port guard

Parameters

fuName	Name of the FU
fuPort	Name of the FU port

Returns: Number of reads for a single FU port guard

Definition at line 336 of file UtilizationStats.cc.

                                    {
         
     try {
         return MapTools::valueForKey<ClockCycleCount>(
             MapTools::valueForKey<ComponentUtilizationIndex>(
                 guardFUAccesses_, fuName), fuPort);
     } catch (const KeyNotFound&) {
         return 0;
     }
 }

References guardFUAccesses_.

Referenced by InfoProcCommand::execute().

◆ guardRegisterReads()

ClockCycleCount UtilizationStats::guardRegisterReads	(	const std::string &	rfName,
		int	registerIndex
	)		const

Returns the count of times the guarded register was read during simulation.

Parameters

rfName	The name of the register file.
registerIndex	The index of the register.

Returns: The count of guarded reads.

Definition at line 292 of file UtilizationStats.cc.

                              {
     try {
         return 
             MapTools::valueForKey<
             std::pair<ClockCycleCount, ClockCycleCount> >(
                 MapTools::valueForKey<RegisterUtilizationIndex>(
                     guardRfAccesses_, rfName), registerIndex).first;
     } catch (const KeyNotFound&) {
         return 0;
     }
 }

References guardRfAccesses_, and MapTools::valueForKey().

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

Here is the call graph for this function:

◆ highestUsedRegisterIndex()

int UtilizationStats::highestUsedRegisterIndex ( ) const

Returns the highest used register index.

This is useful when fetching register access data for sequential simulation.

Returns: The index of the highest index register.

Definition at line 367 of file UtilizationStats.cc.

                                                  {
     return highestRegister_;
 }

References highestRegister_.

◆ operationExecutions() [1/2]

ClockCycleCount UtilizationStats::operationExecutions	(	const std::string &	fuName,
		const std::string &	operationName
	)		const

Returns the total count of given operation executions in given FU.

Parameters

fuName	The name of the function unit.
operationName	The name of the operation.

Returns: The count of executions.

Definition at line 251 of file UtilizationStats.cc.

                                                                    {
     try {
         return MapTools::valueForKey<ClockCycleCount>(
             MapTools::valueForKey<ComponentUtilizationIndex>(
                 fuOperations_, fuName), operationName);
     } catch (const KeyNotFound&) {
         return 0;
     }
 }

References fuOperations_.

◆ operationExecutions() [2/2]

ClockCycleCount UtilizationStats::operationExecutions ( const std::string & operationName ) const

Returns the total count of operation executions.

Parameters

operationName The name of the operation.

Returns: The count of executions.

Definition at line 234 of file UtilizationStats.cc.

                                           {    
     if (MapTools::containsKey(operations_, operationName)) 
         return MapTools::valueForKey<ClockCycleCount>(
             operations_, operationName);
     else 
         return 0;
 }

References MapTools::containsKey(), and operations_.

Referenced by ProximFUDetailsCmd::Do(), InfoProcCommand::execute(), InfoStatsCommand::execute(), and SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ registerReads()

ClockCycleCount UtilizationStats::registerReads	(	const std::string &	rfName,
		int	registerIndex
	)		const

Returns the count of times the given register was read during simulation.

Parameters

rfName	The name of the register file.
registerIndex	The index of the register.

Returns: The count of reads.

Definition at line 270 of file UtilizationStats.cc.

                              {
     try {
         return 
             MapTools::valueForKey<
             std::pair<ClockCycleCount, ClockCycleCount> >(
                 MapTools::valueForKey<RegisterUtilizationIndex>(
                     rfAccesses_, rfName), registerIndex).first;
     } catch (const KeyNotFound&) {
         return 0;
     }
 }

References rfAccesses_, and MapTools::valueForKey().

Referenced by calculateForInstruction(), ProximRFDetailsCmd::Do(), ProximIUDetailsCmd::Do(), InfoProcCommand::execute(), InfoStatsCommand::execute(), and SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ registerWrites()

ClockCycleCount UtilizationStats::registerWrites	(	const std::string &	rfName,
		int	registerIndex
	)		const

Returns the count of times the given register was written during simulation.

Parameters

rfName	The name of the register file.
registerIndex	The index of the register.

Returns: The count of writes.

Definition at line 314 of file UtilizationStats.cc.

                              {
     try {
         return 
             MapTools::valueForKey<
             std::pair<ClockCycleCount, ClockCycleCount> >(
                 MapTools::valueForKey<RegisterUtilizationIndex>(
                     rfAccesses_, rfName), registerIndex).second;
     } catch (const KeyNotFound&) {
         return 0;
     }
 }

References rfAccesses_, and MapTools::valueForKey().

Referenced by calculateForInstruction(), ProximRFDetailsCmd::Do(), ProximIUDetailsCmd::Do(), InfoProcCommand::execute(), InfoStatsCommand::execute(), and SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ socketWrites()

ClockCycleCount UtilizationStats::socketWrites ( const std::string & socketName ) const

Returns the count of writes to the given socket.

Parameters

socketName The name of the socket.

Returns: The count of writes.

Definition at line 206 of file UtilizationStats.cc.

                                                                 {
     if (MapTools::containsKey(sockets_, socketName)) 
         return MapTools::valueForKey<ClockCycleCount>(sockets_, socketName);
     else 
         return 0;
 }

References MapTools::containsKey(), and sockets_.

Referenced by ProximSocketDetailsCmd::Do(), InfoProcCommand::execute(), SimulatorFrontend::finishSimulation(), and ProximMachineStateWindow::setUtilizationHighlights().

Here is the call graph for this function:

◆ triggerCount()

ClockCycleCount UtilizationStats::triggerCount ( const std::string & fuName ) const

Returns the count of operation triggers in given FU.

Parameters

fuName The name of the FU.

Returns: The count of triggers.

Definition at line 220 of file UtilizationStats.cc.

                                                             {
     if (MapTools::containsKey(fus_, fuName)) 
         return MapTools::valueForKey<ClockCycleCount>(fus_, fuName);
     else 
         return 0;
 }