RFAccessTracker Class Reference

#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
typedef std::map< ConcurrentRFAccess, ClockCycleCount >	ConcurrentRFAccessIndex
	concurrent accesses and their counts

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.

Private Attributes
SimulatorFrontend &	frontend_
	the simulator frontend used to access simulation data
const InstructionMemory &	instructionExecutions_
	used to access instruction execution data
ConcurrentRFAccessIndex	conditionalAccesses_
	conditional register file accesses are counted in this container
ConcurrentRFAccessIndex	totalAccesses_
	total (conditional + unconditional) register file accesses are counted in this container
RFAccessIndex	accessesInInstruction_
	container used in collecting register accesses in an instruction

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

Here is the call graph for this function:

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:

• RFAccessTracker.hh
• RFAccessTracker.cc