InfoProcCommand Class Reference

Inheritance diagram for InfoProcCommand:

Collaboration diagram for InfoProcCommand:

Public Member Functions
	InfoProcCommand (SimControlLanguageCommand &parentCommand)
virtual	~InfoProcCommand ()
virtual bool	execute (const std::vector< DataObject > &arguments)
Public Member Functions inherited from SimControlLanguageSubCommand
	SimControlLanguageSubCommand (SimControlLanguageCommand &parentCommand)
virtual	~SimControlLanguageSubCommand ()
virtual SimControlLanguageCommand &	parent ()

Detailed Description

Implementation of "info proc".

Definition at line 721 of file InfoCommand.cc.

Constructor & Destructor Documentation

InfoProcCommand()

InfoProcCommand::InfoProcCommand ( SimControlLanguageCommand &  parentCommand )

inline

Constructor.

Definition at line 726 of file InfoCommand.cc.

                                                              : 
        SimControlLanguageSubCommand(parentCommand) {
    }

~InfoProcCommand()

virtual InfoProcCommand::~InfoProcCommand ( )

inlinevirtual

Destructor.

Definition at line 733 of file InfoCommand.cc.

                               {
    }

Member Function Documentation

execute()

virtual bool InfoProcCommand::execute ( const std::vector< DataObject > &  arguments )

inlinevirtual

Executes the "info proc" command.

Parameters

arguments

Arguments to the command, including the command.

Returns

true in case execution was successful.

Implements SimControlLanguageSubCommand.

Definition at line 742 of file InfoCommand.cc.

                                                                 {
 
        if (!parent().checkSimulationEnded() &&
            !parent().checkSimulationInitialized() &&
            !parent().checkSimulationStopped() &&
            !parent().simulatorFrontend().isSimulationRunning()) {
 
            return false;
        }
 
        const int argumentCount = arguments.size() - 2;
 
        if (!parent().checkArgumentCount(argumentCount, 1, 1)) {
            return false;
        }
 
        const std::string command =
            StringTools::stringToLower(arguments[2].stringValue());
 
        if (command == "cycles") {
            parent().interpreter()->setResult(
                (boost::format("%.0f") %
                 parent().simulatorFrontend().cycleCount()).str());
            return true;
        } else if (command == "stats") {
            std::stringstream result;
 
            const ClockCycleCount totalCycles =
                parent().simulatorFrontend().cycleCount();
 
            const UtilizationStats& stats =
                parent().simulatorFrontend().utilizationStatistics();
 
            result
                << std::endl
                << "utilizations" << std::endl
                << "------------" << std::endl;
 
            const int COLUMN_WIDTH = 15;
            const TTAMachine::Machine& mach =
                parent().simulatorFrontend().machine();
            std::set<std::string> operationsOfMachine;
 
            result
                << std::endl << "buses:" << std::endl << std::endl;
 
            const TTAMachine::Machine::BusNavigator& busNav =
                mach.busNavigator();
 
            for (int i = 0; i < busNav.count(); ++i) {
                TTAMachine::Bus* bus = busNav.item(i);
                assert(bus != NULL);
                const ClockCycleCount writes =
                    stats.busWrites(bus->name());
 
                result
                    << std::left << std::setw(COLUMN_WIDTH)
                    << bus->name() << " "
                    << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(writes * 100.0 / totalCycles) +
                    "% (" + Conversion::toString(writes) + " writes)"
                    << std::endl;
            }
 
            result
                << std::endl
                << "sockets:" << std::endl << std::endl;
 
            const TTAMachine::Machine::SocketNavigator& socketNav =
                mach.socketNavigator();
            for (int i = 0; i < socketNav.count(); ++i) {
                TTAMachine::Socket* socket = socketNav.item(i);
                assert(socket != NULL);
                const ClockCycleCount writes =
                    stats.socketWrites(socket->name());
 
                result
                    << std::left << std::setw(COLUMN_WIDTH)
                    << socket->name() << " " 
                    << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(writes * 100.0 / totalCycles) +
                    "% (" + Conversion::toString(writes) + " writes)"
                    << std::endl;
            }
 
            result
                << std::endl
                << "operations executed in function units:"
                << std::endl << std::endl;
 
            const TTAMachine::Machine::FunctionUnitNavigator& fuNav =
                mach.functionUnitNavigator();
            for (int i = 0; i <= fuNav.count(); ++i) {
                TTAMachine::FunctionUnit* fu = NULL;
                if (i < fuNav.count())
                    fu = fuNav.item(i);
                else
                    fu = mach.controlUnit();
                assert(fu != NULL);
                const ClockCycleCount totalTriggersOfFU = 
                    stats.triggerCount(fu->name());
 
                result
                    << fu->name() << ":" << std::endl;
 
                for (int j = 0; j < fu->operationCount(); ++j) {
                    const TTAMachine::HWOperation* op = fu->operation(j);
                    assert(op != NULL);
                    const std::string operationUpper =
                        StringTools::stringToUpper(op->name());
                    operationsOfMachine.insert(operationUpper);
                    const ClockCycleCount executions =
                        stats.operationExecutions(
                            fu->name(), operationUpper);
 
                    result
                        << std::left << std::setw(COLUMN_WIDTH)
                        << operationUpper << " "
                        << std::left << std::setw(COLUMN_WIDTH)
                        << Conversion::toString(
                            executions * 100.0 / totalTriggersOfFU) +
                        "% of FU total (" +
                        Conversion::toString(executions) + " executions)"
                        << std::endl;
                }
 
                result
                    << std::left << std::setw(COLUMN_WIDTH)
                    << "TOTAL" << " "
                    << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(
                        totalTriggersOfFU * 100.0 / totalCycles) + "% (" +
                    Conversion::toString(totalTriggersOfFU) +
                    " triggers)" << std::endl << std::endl;
            }
 
            const TTAMachine::FunctionUnit& gcu = *mach.controlUnit();
            for (int j = 0; j < gcu.operationCount(); ++j) {
                const TTAMachine::HWOperation* op = gcu.operation(j);
                assert(op != NULL);
                const std::string operationUpper =
                    StringTools::stringToUpper(op->name());
                operationsOfMachine.insert(operationUpper);
            }
 
            result
                << std::endl << "operations:" << std::endl << std::endl;
 
            for (std::set<std::string>::iterator i =
                     operationsOfMachine.begin(); i !=
                     operationsOfMachine.end(); ++i) {
                const ClockCycleCount executions =
                    stats.operationExecutions(*i);
 
                result
                    << std::left << std::setw(COLUMN_WIDTH)
                    << *i << " " << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(executions * 100.0 / totalCycles) +
                    "% (" + Conversion::toString(executions) + " executions)"
                    << std::endl;
            }
 
            result
                << std::endl
                << "FU port guard accesses:" << std::endl;
 
            UtilizationStats::FUOperationUtilizationIndex fuGuardAccesses =
                stats.FUGuardAccesses();
 
            // loop each FU
            for (UtilizationStats::FUOperationUtilizationIndex::iterator i =
                fuGuardAccesses.begin(); i != fuGuardAccesses.end(); ++i) {
 
                std::string fuName = i->first;
 
                result
                    << std::endl
                    << fuName << ":"
                    << std::endl;
 
                // loop each FU port in the utilization list
                for (UtilizationStats::ComponentUtilizationIndex::iterator j =
                    i->second.begin(); j != i->second.end(); ++j) {
                    std::string fuPort = j->first;
 
                    ClockCycleCount count =
                    stats.FUGuardAccesses(fuName, fuPort);
                        result
                            << std::left << std::setw(COLUMN_WIDTH)
                            << fuPort << ": "
                            << Conversion::toString(count) << " reads"
                            << std::endl;
                }
            }
 
            result
                << std::endl
                << "register accesses:" << std::endl
                << std::endl;
 
            const TTAMachine::Machine::RegisterFileNavigator& rfNav =
                mach.registerFileNavigator();
            for (int i = 0; i < rfNav.count(); ++i) {
                TTAMachine::RegisterFile* rf = rfNav.item(i);
                assert(rf != NULL);
 
                result
                    << rf->name() << ":" << std::endl;
 
                int regsUsedInFile = 0;
                int lastReg = 0;
                int totalReads = 0;
                int totalWrites = 0;
                int totalGuards = 0;
                lastReg = rf->numberOfRegisters() - 1;
 
                for (int reg = 0; reg <= lastReg; ++reg) {
                    ClockCycleCount reads =
                        stats.registerReads(rf->name(), reg);
                    totalReads += reads;
                    ClockCycleCount guardReads =
                        stats.guardRegisterReads(rf->name(), reg);
                    totalGuards += guardReads;
                    ClockCycleCount writes =
                        stats.registerWrites(rf->name(), reg);
                    totalWrites += writes;
                    ++regsUsedInFile;
                    result
                        << std::left << std::setw(COLUMN_WIDTH)
                        << reg << " "
                        << std::left << std::setw(COLUMN_WIDTH)
                        << Conversion::toString(reads) + " reads, "
                        << std::left << std::setw(COLUMN_WIDTH + 5)
                        << Conversion::toString(guardReads) + " guard reads, "
                        << std::left << std::setw(COLUMN_WIDTH)
                        << Conversion::toString(writes) + " writes"
                        << std::endl;
                }
 
                result
                    << std::left << std::setw(COLUMN_WIDTH)
                    << "TOTAL"
                    << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(totalReads) + " reads, "
                    << std::left << std::setw(COLUMN_WIDTH + 5)
                    << Conversion::toString(totalGuards) + " guard reads, "
                    << std::left << std::setw(COLUMN_WIDTH)
                    << Conversion::toString(totalWrites) + " writes"
                    << std::endl;
 
                result
                    << "TOTAL " << regsUsedInFile << " registers used"
                    << std::endl << std::endl;
            }
 
            result
                << std::endl
                << "immediate unit accesses:" << std::endl
                << std::endl;
 
            const TTAMachine::Machine::ImmediateUnitNavigator& iuNav =
                mach.immediateUnitNavigator();
            for (int i = 0; i < iuNav.count(); ++i) {
                TTAMachine::ImmediateUnit* iu = iuNav.item(i);
                assert(iu != NULL);
 
                result
                    << iu->name() << ":" << std::endl;
 
                int usedRegCount = 0;
                int lastReg = 0;
                lastReg = iu->numberOfRegisters() - 1;
 
                for (int reg = 0; reg <= lastReg; ++reg) {
                    ClockCycleCount reads =
                        stats.registerReads(iu->name(), reg);
                    ClockCycleCount writes =
                        stats.registerWrites(iu->name(), reg);
                    ++usedRegCount;
                    result
                        << std::left << std::setw(COLUMN_WIDTH)
                        << reg << " "
                        << std::left << std::setw(COLUMN_WIDTH)
                        << Conversion::toString(reads) + " reads, "
                        << std::left << std::setw(COLUMN_WIDTH)
                        << Conversion::toString(writes) + " writes"
                        << std::endl;
                }
                result
                    << "TOTAL " << usedRegCount << " registers used"
                    << std::endl << std::endl;
            }
 
 
            if (parent().simulatorFrontend().rfAccessTracing()) {
 
                try {
                    const RFAccessTracker& rfAccessTracker =
                        parent().simulatorFrontend().rfAccessTracker();
 
                    result
                        << std::endl
                        << "register file accesses" << std::endl
                        << "----------------------" << std::endl;
 
                    const int COL_WIDTH = 20;
 
                    result
                        << std::left << std::setw(COL_WIDTH)
                        << "register file"
                        << std::left << std::setw(COL_WIDTH)
                        << "writes"
                        << std::left << std::setw(COL_WIDTH)
                        << "reads"
                        << std::left << std::setw(COL_WIDTH)
                        << "count" << std::endl;
 
                    RFAccessTracker::ConcurrentRFAccessIndex::
                        const_iterator i =
                        rfAccessTracker.accessDataBase().begin();
 
                    for (; i != rfAccessTracker.accessDataBase().end(); ++i) {
                        result
                            << std::left << std::setw(COL_WIDTH)
                            << (*i).first.get<0>()
                            << std::left << std::setw(COL_WIDTH)
                            << (*i).first.get<1>()
                            << std::left << std::setw(COL_WIDTH)
                            << (*i).first.get<2>()
                            << std::left << std::setw(COL_WIDTH)
                            << (*i).second << std::endl;
                    }
                } catch (const InstanceNotFound&) {
                }
            }
 
            parent().interpreter()->setResult(result.str());
            return true;
 
        } else if (command == "mapping") {
            const TTAMachine::Machine& mach =
                parent().simulatorFrontend().machine();
            const TTAMachine::Machine::AddressSpaceNavigator& nav =
                mach.addressSpaceNavigator();
            for (int i = 0; i < nav.count(); ++i) {
                TTAMachine::AddressSpace& space = *nav.item(i);
                unsigned int sizeOfSpace = space.end() - space.start();
                parent().outputStream()
                    << std::left << std::setw(15)
                    << space.name()
                    << std::left
                    << Conversion::toHexString(space.start(), 8)
                    << " - "
                    << Conversion::toHexString(space.end(), 8)
                    << " (" << sizeOfSpace << " ";
                if (space.width() == 8) {
                    parent().outputStream() << "bytes";
                } else {
                    parent().outputStream()
                        << "words of size " << space.width() << " bits";
                }
                parent().outputStream() << ")" << std::endl;
            }
            return true;
        } else {
            parent().interpreter()->setError(
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_UNKNOWN_SUBCOMMAND).str());
            return false;
        }
    }

References RFAccessTracker::accessDataBase(), TTAMachine::Machine::addressSpaceNavigator(), assert, TTAMachine::Machine::busNavigator(), UtilizationStats::busWrites(), TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), SimulatorFrontend::cycleCount(), TTAMachine::AddressSpace::end(), UtilizationStats::FUGuardAccesses(), TTAMachine::Machine::functionUnitNavigator(), UtilizationStats::guardRegisterReads(), TTAMachine::Machine::immediateUnitNavigator(), CustomCommand::interpreter(), TTAMachine::Machine::Navigator< ComponentType >::item(), SimulatorFrontend::machine(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), UtilizationStats::operationExecutions(), SimControlLanguageCommand::outputStream(), SimControlLanguageSubCommand::parent(), TTAMachine::Machine::registerFileNavigator(), UtilizationStats::registerReads(), UtilizationStats::registerWrites(), SimulatorFrontend::rfAccessTracker(), ScriptInterpreter::setError(), ScriptInterpreter::setResult(), SimControlLanguageCommand::simulatorFrontend(), TTAMachine::Machine::socketNavigator(), UtilizationStats::socketWrites(), TTAMachine::AddressSpace::start(), StringTools::stringToLower(), StringTools::stringToUpper(), SimulatorToolbox::textGenerator(), Conversion::toHexString(), Conversion::toString(), UtilizationStats::triggerCount(), Texts::TXT_UNKNOWN_SUBCOMMAND, SimulatorFrontend::utilizationStatistics(), and TTAMachine::AddressSpace::width().

Here is the call graph for this function:

---

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

• InfoCommand.cc