UtilizationStats Class Reference

#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.
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.
typedef std::map< std::string, ComponentUtilizationIndex >	FUOperationUtilizationIndex
	Index for connecting function unit and operations implemented in them to utilization counts.
typedef std::map< std::string, RegisterUtilizationIndex >	RFRegisterUtilizationIndex
	Index for connecting register files and register utilization indices in them.

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.
ComponentUtilizationIndex	buses_
	Bus write counts.
ComponentUtilizationIndex	fus_
	Function unit utilizations, i.e., total operation triggerings.
ComponentUtilizationIndex	operations_
	Operation utilizations (started operations).
FUOperationUtilizationIndex	fuOperations_
	Index for operation utilizations for each function unit.
RFRegisterUtilizationIndex	rfAccesses_
	Register read and write data for each register in each register file.
RFRegisterUtilizationIndex	guardRfAccesses_
	Guard register accesses for each register in a RF.
FUOperationUtilizationIndex	guardFUAccesses_
	Guard FU port accesses.
int	highestRegister_
	The highest register index used. This is an uglish way to fetch register access info for sequential simulation.

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.

                                   : highestRegister_(-1) {
}

~UtilizationStats()

UtilizationStats::~UtilizationStats ( )

virtual

Destructor.

Definition at line 60 of file UtilizationStats.cc.

                                    {
}

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_, MapTools::containsKey(), and MapTools::keyForValue().

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::Move::guard(), TTAProgram::MoveGuard::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::Component::name(), TTAMachine::Port::name(), Operation::name(), TTAProgram::Terminal::operation(), operations_, TTAMachine::BaseFUPort::parentUnit(), TTAMachine::PortGuard::port(), TTAProgram::Terminal::port(), TTAMachine::RegisterGuard::registerFile(), TTAProgram::Terminal::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_, and MapTools::keyForValue().

Referenced by InfoProcCommand::execute().

Here is the call graph for this function:

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_, MapTools::keyForValue(), 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_, and MapTools::keyForValue().

Here is the call graph for this function:

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(), MapTools::keyForValue(), 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 MapTools::keyForValue(), rfAccesses_, and MapTools::valueForKey().

Referenced by calculateForInstruction(), ProximIUDetailsCmd::Do(), ProximRFDetailsCmd::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 MapTools::keyForValue(), rfAccesses_, and MapTools::valueForKey().

Referenced by calculateForInstruction(), ProximIUDetailsCmd::Do(), ProximRFDetailsCmd::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(), MapTools::keyForValue(), 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;
}

References MapTools::containsKey(), fus_, and MapTools::keyForValue().

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

Here is the call graph for this function:

Member Data Documentation

buses_

ComponentUtilizationIndex UtilizationStats::buses_

private

Bus write counts.

Definition at line 103 of file UtilizationStats.hh.

Referenced by busWrites(), and calculateForInstruction().

fuOperations_

FUOperationUtilizationIndex UtilizationStats::fuOperations_

private

Index for operation utilizations for each function unit.

Definition at line 109 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and operationExecutions().

fus_

ComponentUtilizationIndex UtilizationStats::fus_

private

Function unit utilizations, i.e., total operation triggerings.

Definition at line 105 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and triggerCount().

guardFUAccesses_

FUOperationUtilizationIndex UtilizationStats::guardFUAccesses_

private

Guard FU port accesses.

Definition at line 116 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), FUGuardAccesses(), and FUGuardAccesses().

guardRfAccesses_

RFRegisterUtilizationIndex UtilizationStats::guardRfAccesses_

private

Guard register accesses for each register in a RF.

Definition at line 114 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and guardRegisterReads().

highestRegister_

int UtilizationStats::highestRegister_

private

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

Definition at line 120 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and highestUsedRegisterIndex().

operations_

ComponentUtilizationIndex UtilizationStats::operations_

private

Operation utilizations (started operations).

Definition at line 107 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and operationExecutions().

rfAccesses_

RFRegisterUtilizationIndex UtilizationStats::rfAccesses_

private

Register read and write data for each register in each register file.

Definition at line 111 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), registerReads(), and registerWrites().

sockets_

ComponentUtilizationIndex UtilizationStats::sockets_

private

Socket write counts.

Definition at line 101 of file UtilizationStats.hh.

Referenced by calculateForInstruction(), and socketWrites().

---

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

• UtilizationStats.hh
• UtilizationStats.cc