#include <RFAccessTracker.hh>

Inheritance diagram for RFAccessTracker:

Collaboration diagram for RFAccessTracker:

Public Types
typedef boost::tuple< std::string, std::size_t, std::size_t >	ConcurrentRFAccess
	type to be used as a key for storing concurrent access info More...

typedef std::map< ConcurrentRFAccess, ClockCycleCount >	ConcurrentRFAccessIndex
	concurrent accesses and their counts More...

Public Member Functions
	RFAccessTracker (SimulatorFrontend &frontend, const InstructionMemory &instructions)

virtual	~RFAccessTracker ()

virtual void	handleEvent (int event)

ClockCycleCount	concurrentRegisterFileAccessCount (const std::string &rfName, std::size_t concurrentWrites, std::size_t concurrentReads) const

const ConcurrentRFAccessIndex &	accessDataBase () const

Public Member Functions inherited from Listener
	Listener ()

virtual	~Listener ()

virtual void	handleEvent ()

Private Types
typedef hash_map< const char *, boost::tuple< std::size_t, std::size_t > >	RFAccessIndex
	Index for RF accesses in an instruction. More...

Private Attributes
SimulatorFrontend &	frontend_
	the simulator frontend used to access simulation data More...

const InstructionMemory &	instructionExecutions_
	used to access instruction execution data More...

ConcurrentRFAccessIndex	conditionalAccesses_
	conditional register file accesses are counted in this container More...

ConcurrentRFAccessIndex	totalAccesses_
	total (conditional + unconditional) register file accesses are counted in this container More...

RFAccessIndex	accessesInInstruction_
	container used in collecting register accesses in an instruction More...

Detailed Description

Tracks concurrent register file accesses.

Definition at line 52 of file RFAccessTracker.hh.

Member Typedef Documentation

◆ ConcurrentRFAccess

typedef boost::tuple< std::string, std::size_t, std::size_t> RFAccessTracker::ConcurrentRFAccess

type to be used as a key for storing concurrent access info

Definition at line 58 of file RFAccessTracker.hh.

◆ ConcurrentRFAccessIndex

typedef std::map<ConcurrentRFAccess, ClockCycleCount> RFAccessTracker::ConcurrentRFAccessIndex

concurrent accesses and their counts

Definition at line 61 of file RFAccessTracker.hh.

◆ RFAccessIndex

typedef hash_map< const char*, boost::tuple<std::size_t , std::size_t > > RFAccessTracker::RFAccessIndex

private

Index for RF accesses in an instruction.

Definition at line 82 of file RFAccessTracker.hh.

Constructor & Destructor Documentation

◆ RFAccessTracker()

RFAccessTracker::RFAccessTracker	(	SimulatorFrontend &	frontend,
		const InstructionMemory &	instructions
	)

Constructor.

Parameters

frontend	The SimulationFrontend which is used to access simulation data.
instructions	Used to fetch instruction execution counts.

Definition at line 63 of file RFAccessTracker.cc.

                                            : 
     frontend_(frontend), instructionExecutions_(instructions) {
     frontend.eventHandler().registerListener(
         SimulationEventHandler::SE_CYCLE_END, this);
     frontend.eventHandler().registerListener(
         SimulationEventHandler::SE_SIMULATION_STOPPED, this);
 }

References SimulatorFrontend::eventHandler(), Informer::registerListener(), SimulationEventHandler::SE_CYCLE_END, and SimulationEventHandler::SE_SIMULATION_STOPPED.

Here is the call graph for this function:

◆ ~RFAccessTracker()

RFAccessTracker::~RFAccessTracker ( )

virtual

Destructor.

Definition at line 76 of file RFAccessTracker.cc.

                                   {
     frontend_.eventHandler().registerListener(
         SimulationEventHandler::SE_CYCLE_END, this);
     frontend_.eventHandler().unregisterListener(
         SimulationEventHandler::SE_SIMULATION_STOPPED, this);
 }

References SimulatorFrontend::eventHandler(), frontend_, Informer::registerListener(), SimulationEventHandler::SE_CYCLE_END, SimulationEventHandler::SE_SIMULATION_STOPPED, and Informer::unregisterListener().

Here is the call graph for this function:

Member Function Documentation

◆ accessDataBase()

const RFAccessTracker::ConcurrentRFAccessIndex & RFAccessTracker::accessDataBase ( ) const

Returns the access data base.

In case statistics are not up-to-date, finalizes the calculation before returning the index.

Returns: The access data base.

Definition at line 220 of file RFAccessTracker.cc.

                                       {
     return totalAccesses_;
 }

References totalAccesses_.

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

◆ concurrentRegisterFileAccessCount()

ClockCycleCount RFAccessTracker::concurrentRegisterFileAccessCount	(	const std::string &	rfName,
		std::size_t	concurrentWrites,
		std::size_t	concurrentReads
	)		const

Returns the count of clock cycles in which the given register file was written and read concurrently the given times.

Parameters

rfName	Name of the register file.
concurrentWrites	Count of concurrent writes.
concurrentReads	Count of concurrent reads.

Returns: The count of cycles in which the given count of concurrent accesses was made to the given register file.

Definition at line 198 of file RFAccessTracker.cc.

                                      {
     try {
         return MapTools::valueForKey<ClockCycleCount>(
             totalAccesses_, boost::make_tuple(
                 rfName, concurrentWrites, concurrentReads));
     } catch (const Exception& e) {
         return 0;
     }
 }

References totalAccesses_.

◆ handleEvent()

void RFAccessTracker::handleEvent ( int event )

virtual

Counts the concurrent register file accesses of current clock cycle.

Reimplemented from Listener.

Definition at line 87 of file RFAccessTracker.cc.

                                       {
  
     if (event == SimulationEventHandler::SE_SIMULATION_STOPPED) {
  
         // create a final sum stats which includes the conditional and unconditional
         // executions
  
         totalAccesses_.clear();       
  
         const TTAProgram::Program& program = frontend_.program();
         const TTAProgram::Instruction* currentInstruction = 
             &program.instructionAt(program.startAddress().location());
         while (currentInstruction != 
                &TTAProgram::NullInstruction::instance()) {
             
             const ExecutableInstruction& execInstruction = 
                 instructionExecutions_.instructionAtConst(
                     currentInstruction->address().location());
             
             if (!currentInstruction->hasRegisterAccesses() ||
                 currentInstruction->hasConditionalRegisterAccesses() ||
                 execInstruction.executionCount() == 0) {
                 currentInstruction = &program.nextInstruction(*currentInstruction);
                 continue;
             }           
  
             accessesInInstruction_.clear();        
  
             for (int i = 0; i < currentInstruction->moveCount(); ++i) {
                 const TTAProgram::Move& move = currentInstruction->move(i);
                 if (move.source().isGPR()) {
                     ++accessesInInstruction_[
                         move.source().registerFile().name().c_str()].get<1>();
                 }
  
                 if (move.destination().isGPR()) {
                     ++accessesInInstruction_[
                         move.destination().registerFile().name().c_str()].
                         get<0>();
                 }
             }
  
             for (RFAccessIndex::iterator i = accessesInInstruction_.begin();
                  i != accessesInInstruction_.end(); ++i) {
  
                 ConcurrentRFAccess key(
                     (*i).first, (*i).second.get<0>(), (*i).second.get<1>());
                 totalAccesses_[key] += execInstruction.executionCount();
             }
                 
             currentInstruction = &program.nextInstruction(*currentInstruction);
         }
  
         // add the access data of the instruction with the conditional accesses
         ConcurrentRFAccessIndex::iterator i = conditionalAccesses_.begin();
         for (; i != conditionalAccesses_.end(); ++i) {
             ConcurrentRFAccess key = (*i).first;
             totalAccesses_[key] += conditionalAccesses_[key];
         }
  
     } else if (event == SimulationEventHandler::SE_CYCLE_END) {
  
         const InstructionAddress& address = 
             frontend_.lastExecutedInstruction();
         const TTAProgram::Instruction& instruction = 
             frontend_.program().instructionAt(address);
         if (!instruction.hasConditionalRegisterAccesses())
             return;
  
         accessesInInstruction_.clear();
  
         const ExecutableInstruction& execInstruction = 
             instructionExecutions_.instructionAtConst(address);
  
         for (int i = 0; i < instruction.moveCount(); ++i) {
             if (execInstruction.moveSquashed(i))
                 continue;
             const TTAProgram::Move& move = instruction.move(i);
             if (move.source().isGPR()) {
                 ++accessesInInstruction_[
                     move.source().registerFile().name().c_str()].get<1>();
             }
  
             if (move.destination().isGPR()) {
                 ++accessesInInstruction_[
                     move.destination().registerFile().name().c_str()].get<0>();
             }
         }
  
         for (RFAccessIndex::iterator i = accessesInInstruction_.begin();
              i != accessesInInstruction_.end(); ++i) {
             ++conditionalAccesses_[boost::make_tuple(
                                        (*i).first, (*i).second.get<0>(), 
                                        (*i).second.get<1>())];
         }
     } else {
         abortWithError("RFAccessTracker received an unknown event.");
     }
 }

References abortWithError, accessesInInstruction_, TTAProgram::Instruction::address(), conditionalAccesses_, TTAProgram::Move::destination(), ExecutableInstruction::executionCount(), frontend_, TTAProgram::Instruction::hasConditionalRegisterAccesses(), TTAProgram::Instruction::hasRegisterAccesses(), TTAProgram::NullInstruction::instance(), TTAProgram::Program::instructionAt(), InstructionMemory::instructionAtConst(), instructionExecutions_, TTAProgram::Terminal::isGPR(), SimulatorFrontend::lastExecutedInstruction(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), ExecutableInstruction::moveSquashed(), TTAMachine::Component::name(), program, SimulatorFrontend::program(), TTAProgram::Terminal::registerFile(), SimulationEventHandler::SE_CYCLE_END, SimulationEventHandler::SE_SIMULATION_STOPPED, TTAProgram::Move::source(), and totalAccesses_.

Here is the call graph for this function:

Member Data Documentation

◆ accessesInInstruction_

RFAccessIndex RFAccessTracker::accessesInInstruction_

private

container used in collecting register accesses in an instruction

Definition at line 93 of file RFAccessTracker.hh.

Referenced by handleEvent().

◆ conditionalAccesses_

ConcurrentRFAccessIndex RFAccessTracker::conditionalAccesses_

private

conditional register file accesses are counted in this container

Definition at line 88 of file RFAccessTracker.hh.

Referenced by handleEvent().

◆ frontend_

SimulatorFrontend& RFAccessTracker::frontend_

private

the simulator frontend used to access simulation data

Definition at line 84 of file RFAccessTracker.hh.

Referenced by handleEvent(), and ~RFAccessTracker().

◆ instructionExecutions_

const InstructionMemory& RFAccessTracker::instructionExecutions_

private

used to access instruction execution data

Definition at line 86 of file RFAccessTracker.hh.

Referenced by handleEvent().

◆ totalAccesses_

ConcurrentRFAccessIndex RFAccessTracker::totalAccesses_

private

total (conditional + unconditional) register file accesses are counted in this container

Definition at line 91 of file RFAccessTracker.hh.

Referenced by accessDataBase(), concurrentRegisterFileAccessCount(), and handleEvent().

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

Public Types

Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ConcurrentRFAccess

◆ ConcurrentRFAccessIndex

◆ RFAccessIndex

Constructor & Destructor Documentation

◆ RFAccessTracker()

◆ ~RFAccessTracker()

Member Function Documentation

◆ accessDataBase()

◆ concurrentRegisterFileAccessCount()

◆ handleEvent()

Member Data Documentation

◆ accessesInInstruction_

◆ conditionalAccesses_

◆ frontend_

◆ instructionExecutions_

◆ totalAccesses_