SimulationStatistics Class Reference

#include <SimulationStatistics.hh>

Collaboration diagram for SimulationStatistics:

Public Member Functions
	SimulationStatistics (const TTAProgram::Program &programData, const InstructionMemory &executionCounts)
virtual	~SimulationStatistics ()
void	addStatistics (SimulationStatisticsCalculator &statisticsType)
void	calculate ()

Private Attributes
std::vector< SimulationStatisticsCalculator * >	statisticsTypes_
	All registered statistics types are stored in this container.
const TTAProgram::Program &	program_
	The program used in calculating the statistics.
const InstructionMemory &	executionCounts_
	The execution counts of instructions and moves in the program.

Detailed Description

Calculates simulation statistics using user-given calculation classes.

Definition at line 48 of file SimulationStatistics.hh.

Constructor & Destructor Documentation

SimulationStatistics()

SimulationStatistics::SimulationStatistics	(	const TTAProgram::Program &	programData,
		const InstructionMemory &	executionCounts
	)

Constructs a new simulation statistics calculation loop.

Parameters

programData	The program the statistics are calculated from.
executionCounts	Execution counts of instructions and moves in the program.

Definition at line 48 of file SimulationStatistics.cc.

                                              :
    program_(programData), executionCounts_(executionCounts) {
}

~SimulationStatistics()

SimulationStatistics::~SimulationStatistics ( )

virtual

Destructor.

Definition at line 58 of file SimulationStatistics.cc.

                                            {
}

Member Function Documentation

addStatistics()

void SimulationStatistics::addStatistics

(

SimulationStatisticsCalculator &

statisticsType

)

Adds a new statistics type to be included in simulation statistics calculation.

Parameters

statisticsType

New statistics type.

Definition at line 68 of file SimulationStatistics.cc.

                                                    {
    statisticsTypes_.push_back(&statisticsType);
}

References statisticsTypes_.

Referenced by SimulatorFrontend::utilizationStatistics().

calculate()

void SimulationStatistics::calculate

(

)

Calculates simulation statistics by going through the program and invoking calculate() for all statistics types.

Definition at line 78 of file SimulationStatistics.cc.

                                {
 
    if (statisticsTypes_.size() == 0)
        return;
 
    const TTAProgram::Instruction* currentInstruction = 
        &program_.instructionAt(program_.startAddress().location());
    while (currentInstruction != &TTAProgram::NullInstruction::instance()) {
 
        // Skip implicit instructions they are processed already (see below).
        if (currentInstruction->size() == 0) {
            currentInstruction = &program_.nextInstruction(*currentInstruction);
            continue;
        }
 
        auto instrAddr = currentInstruction->address().location();
        const ExecutableInstruction& execInstr = 
            executionCounts_.instructionAtConst(instrAddr);
        if (execInstr.executionCount() == 0) {
            currentInstruction = 
                &program_.nextInstruction(*currentInstruction);
            continue;
        }
 
        // First process explicit instruction ...
        for (std::size_t i = 0; i < statisticsTypes_.size(); ++i) {
            statisticsTypes_[i]->calculateForInstruction(
                *currentInstruction, execInstr);
        }
 
        // ... and then the following implicit instructions.
        // FIXME: Potential breakage. Can not know if the executable instruction
        // corresponds to the program instruction. It is now assumed the
        // execution instructions are created and added to executionCounts_ in
        // same order as program instructions currently being traversed.
        const TTAProgram::Instruction* implInstr = &program_.nextInstruction(
            *currentInstruction);
        for (auto& implExecInstr : executionCounts_.implicitInstructionsAt(
            instrAddr)) {
            if (implInstr->size() != 0)
                break;
            for (std::size_t i = 0; i < statisticsTypes_.size(); ++i) {
                statisticsTypes_[i]->calculateForInstruction(
                    *implInstr, *implExecInstr);
            }
            implInstr = &program_.nextInstruction(*implInstr);
        }
        currentInstruction = &program_.nextInstruction(*currentInstruction);
    }
}

References TTAProgram::Instruction::address(), ExecutableInstruction::executionCount(), executionCounts_, InstructionMemory::implicitInstructionsAt(), TTAProgram::NullInstruction::instance(), TTAProgram::Program::instructionAt(), InstructionMemory::instructionAtConst(), TTAProgram::Address::location(), TTAProgram::Program::nextInstruction(), program_, TTAProgram::Instruction::size(), TTAProgram::Program::startAddress(), and statisticsTypes_.

Referenced by SimulatorFrontend::utilizationStatistics().

Here is the call graph for this function:

Member Data Documentation

executionCounts_

const InstructionMemory& SimulationStatistics::executionCounts_

private

The execution counts of instructions and moves in the program.

Definition at line 64 of file SimulationStatistics.hh.

Referenced by calculate().

program_

const TTAProgram::Program& SimulationStatistics::program_

private

The program used in calculating the statistics.

Definition at line 62 of file SimulationStatistics.hh.

Referenced by calculate().

statisticsTypes_

std::vector<SimulationStatisticsCalculator*> SimulationStatistics::statisticsTypes_

private

All registered statistics types are stored in this container.

Definition at line 60 of file SimulationStatistics.hh.

Referenced by addStatistics(), and calculate().

---

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

• SimulationStatistics.hh
• SimulationStatistics.cc