DefaultICDecoderEstimator Class Reference

Inheritance diagram for DefaultICDecoderEstimator:

Collaboration diagram for DefaultICDecoderEstimator:

Classes
struct	ICParameters

Public Member Functions
	DefaultICDecoderEstimator (const std::string &name)
virtual	~DefaultICDecoderEstimator ()
virtual bool	estimateICDelayOfPath (HDB::HDBRegistry &hdbRegistry, const TransportPath &path, const IDF::MachineImplementation &machineImplementation, const IDF::SocketImplementationLocation &, const IDF::BusImplementationLocation &, const IDF::SocketImplementationLocation &, DelayInNanoSeconds &delay)
virtual bool	estimateICArea (HDB::HDBRegistry &hdbRegistry, const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, AreaInGates &area)
virtual bool	estimateICEnergy (HDB::HDBRegistry &hdbRegistry, const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, const TTAProgram::Program &, const ExecutionTrace &traceDB, EnergyInMilliJoules &energy)
Public Member Functions inherited from CostEstimator::ICDecoderEstimatorPlugin
	ICDecoderEstimatorPlugin (const std::string &name)
virtual	~ICDecoderEstimatorPlugin ()
virtual TTAMachine::ControlUnit *	generateControlUnit ()
Public Member Functions inherited from CostEstimator::CostEstimationPlugin
	CostEstimationPlugin (const std::string &name)
virtual	~CostEstimationPlugin ()
virtual std::string	name () const
virtual std::string	description () const

Private Types
typedef std::vector< ICParameters >	FanInFanOutCombinationSet

Private Member Functions
DelayInNanoSeconds	delayOfSocket (HDB::HDBManager &hdb, const TTAMachine::Socket &socket)
DelayInNanoSeconds	delayOfBus (HDB::HDBManager &hdb, const TTAMachine::Bus &bus)
DelayInNanoSeconds	delayOfSocket (HDB::HDBRegistry &hdbRegistry, const IDF::SocketImplementationLocation &implementation)
DelayInNanoSeconds	delayOfBus (HDB::HDBRegistry &hdbRegistry, const IDF::BusImplementationLocation &implementation)
DataObject	valueFromKeyValuePairString (const std::string &keyName, const std::string &keyValuePairString)
FanInFanOutCombinationSet	generateFanInFanOutCombinations (std::vector< std::size_t > &inputWidths, std::vector< std::size_t > &outputWidths)
FanInFanOutCombinationSet	socketParameters (const TTAMachine::Socket &socket)
FanInFanOutCombinationSet	busParameters (const TTAMachine::Bus &bus)

Private Attributes
std::set< std::string >	missingComponents_
	Set for component names that are missing from HDB.

Additional Inherited Members
Protected Attributes inherited from CostEstimator::CostEstimationPlugin
std::string	name_
	the name of the plugin class in the HDB; used to identify cost data

Detailed Description

The default IC&decoder cost estimation plugin.

Definition at line 124 of file DefaultICDecoderPlugin.cc.

Member Typedef Documentation

FanInFanOutCombinationSet

typedef std::vector<ICParameters> DefaultICDecoderEstimator::FanInFanOutCombinationSet

private

Definition at line 725 of file DefaultICDecoderPlugin.cc.

Constructor & Destructor Documentation

DefaultICDecoderEstimator()

DefaultICDecoderEstimator::DefaultICDecoderEstimator ( const std::string &  name )

inline

Constructor.

Parameters

name	The name of this plugin.
dataSource	The HDB used to fetch cost estimation data.

Definition at line 133 of file DefaultICDecoderPlugin.cc.

                               :
        ICDecoderEstimatorPlugin(name) {
    }

~DefaultICDecoderEstimator()

virtual DefaultICDecoderEstimator::~DefaultICDecoderEstimator ( )

inlinevirtual

Destructor.

Definition at line 141 of file DefaultICDecoderPlugin.cc.

                                         {
    }

Member Function Documentation

busParameters()

FanInFanOutCombinationSet DefaultICDecoderEstimator::busParameters ( const TTAMachine::Bus &  bus )

inlineprivate

Generates fanin/fanout/width combinations to a bus.

Parameters

bus	Bus which parameters are generated.

Returns

Set of fanin/fanout/width combinations.

Definition at line 862 of file DefaultICDecoderPlugin.cc.

                                  {
 
        std::vector<std::size_t> inputWidths;
        std::vector<std::size_t> outputWidths;
 
        TTAMachine::Machine::SocketNavigator socketNav = 
            bus.machine()->socketNavigator();
        for (int i = 0; i < socketNav.count(); ++i) {
            const TTAMachine::Socket& socket = *socketNav.item(i);
            if (bus.isConnectedTo(socket)) {
                std::size_t width = 0;
                for (int port = 0; port < socket.portCount(); port++) {
                    if (static_cast<unsigned int>(
                                socket.port(port)->width()) > width) {
                        width = socket.port(port)->width();
                    }
                }
                if (width == 0) {
                    continue;
                }
                if (socket.direction() == TTAMachine::Socket::OUTPUT) {
                    inputWidths.push_back(width);
                } else {
                    outputWidths.push_back(width);
                }
            }
        }
 
        return generateFanInFanOutCombinations(inputWidths, outputWidths);
    }

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Socket::direction(), generateFanInFanOutCombinations(), TTAMachine::Bus::isConnectedTo(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), TTAMachine::Socket::OUTPUT, TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TTAMachine::Machine::socketNavigator(), and TTAMachine::Port::width().

Referenced by delayOfBus(), estimateICArea(), and estimateICEnergy().

Here is the call graph for this function:

delayOfBus() [1/2]

DelayInNanoSeconds DefaultICDecoderEstimator::delayOfBus ( HDB::HDBManager &  hdb, const TTAMachine::Bus &  bus  )

inlineprivate

Finds out the delay of the given bus.

Definition at line 583 of file DefaultICDecoderPlugin.cc.

                                                             {
        DelayInNanoSeconds delay = 0;
        std::string busName = "";
        try {
            FanInFanOutCombinationSet parameterSet = busParameters(bus);
            // bus fanin, fanout and data width is added to name string
            FanInFanOutCombinationSet::const_iterator iter = 
                parameterSet.begin();
            for (; iter != parameterSet.end(); iter++) {
                busName = "sub_bus " +
                    Conversion::toString((*iter).fanIn) + " " +
                    Conversion::toString((*iter).fanOut) + " " +
                    Conversion::toString((*iter).dataWidth);
 
                try {
                    DataObject subbusData =
                        hdb.costEstimationDataValue(busName, name());
                    
                    delay += valueFromKeyValuePairString(
                        "throughput_delay",
                        subbusData.stringValue()).doubleValue();
                } catch (const KeyNotFound& e) {
                    std::set<std::string>::iterator iter = 
                        missingComponents_.find("tdelay" + busName);
                    if (iter == missingComponents_.end()) {
                        std::cerr << "Warning: Could not get throughput delay "
                                  << "data for '"
                                  << busName << "' from HDB: "
                                  << hdb.fileName() << ". This value is "
                                  << "not counted to total." << std::endl;
                        missingComponents_.insert("tdelay" + busName);
                    }
                }
            }
        } catch (const Exception& e) {
            throw Exception(
                __FILE__, __LINE__, __func__, 
                std::string("Cannot fetch bus delay data '") +
                busName + "'." + e.errorMessage());
        }
        return delay;
    }

References __func__, busParameters(), HDB::HDBManager::costEstimationDataValue(), DataObject::doubleValue(), Exception::errorMessage(), HDB::HDBManager::fileName(), missingComponents_, CostEstimator::CostEstimationPlugin::name(), DataObject::stringValue(), Conversion::toString(), and valueFromKeyValuePairString().

Referenced by estimateICDelayOfPath().

Here is the call graph for this function:

delayOfBus() [2/2]

DelayInNanoSeconds DefaultICDecoderEstimator::delayOfBus ( HDB::HDBRegistry &  hdbRegistry, const IDF::BusImplementationLocation &  implementation  )

inlineprivate

Finds out the delay of the given bus.

Definition at line 666 of file DefaultICDecoderPlugin.cc.

                                                            {
        // First fetch the id of the 'delay_subbus_reference' of the
        // socket. The id is used to fetch the subbus data which carries
        // the delay data.
        int implementationId = implementation.id();
        
        HDB::HDBManager& hdb = hdbRegistry.hdb(implementation.hdbFile());
 
        try {
            return hdb.busCostEstimationData(
                "throughput_delay", implementationId, name_).doubleValue();
 
        } catch (const Exception& e) {
            throw Exception(
                __FILE__, __LINE__, __func__, 
                std::string("Cannot fetch bus delay data. ") +
                e.errorMessage());
        }
    }

References __func__, HDB::HDBManager::busCostEstimationData(), DataObject::doubleValue(), Exception::errorMessage(), HDB::HDBRegistry::hdb(), implementation, and CostEstimator::CostEstimationPlugin::name_.

Here is the call graph for this function:

delayOfSocket() [1/2]

DelayInNanoSeconds DefaultICDecoderEstimator::delayOfSocket ( HDB::HDBManager &  hdb, const TTAMachine::Socket &  socket  )

inlineprivate

Finds out the delay of the given socket.

Definition at line 522 of file DefaultICDecoderPlugin.cc.

                                                                      {
        DelayInNanoSeconds delay = 0;
        std::string socketName = "";
        try {
            if (socket.direction() == TTAMachine::Socket::INPUT) {
                socketName = "input_sub_socket";
            } else if (socket.direction() == TTAMachine::Socket::OUTPUT) {
                socketName = "output_sub_socket";
            } else {
                // Socket direction is unknown, should never be
                assert(false);
            }
            
            FanInFanOutCombinationSet parameterSet =
                socketParameters(socket);
            // socket fanin, fanout and data width is added to name string
            FanInFanOutCombinationSet::const_iterator iter = 
                parameterSet.begin();
            std::string socketNameCopy = socketName;
            for (; iter != parameterSet.end(); iter++) {
                socketName = socketNameCopy + " " +
                    Conversion::toString((*iter).fanIn) + " " +
                    Conversion::toString((*iter).fanOut) + " " +
                    Conversion::toString((*iter).dataWidth);
                    if (socket.direction() == TTAMachine::Socket::INPUT &&
                            (*iter).fanIn == 1 && (*iter).fanOut == 1) {
                        // input socket 1 1 * --> no delay
                        return 0;
                    }
                try {
                    DataObject subsocketData =
                        hdb.costEstimationDataValue(socketName, name());
                    delay += valueFromKeyValuePairString(
                        "throughput_delay",
                        subsocketData.stringValue()).doubleValue();
                } catch (const KeyNotFound& e) {
                    std::set<std::string>::iterator iter = 
                        missingComponents_.find("tdelay" + socketName);
                    if (iter == missingComponents_.end()) {
                        std::cerr << "Warning: Could not get throughput delay "
                                  << "data for '"
                                  << socketName << "' from HDB: "
                                  << hdb.fileName() << ". This value is "
                                  << "not counted to total." << std::endl;
                        missingComponents_.insert("tdelay" + socketName);
                    }
                }
            }
        } catch (const Exception& e) {
            throw Exception(
                __FILE__, __LINE__, __func__, 
                std::string("Cannot fetch socket delay data '") +
                socketName + "'." + e.errorMessage());
        }
        return delay;
    }

References __func__, assert, HDB::HDBManager::costEstimationDataValue(), TTAMachine::Socket::direction(), DataObject::doubleValue(), Exception::errorMessage(), HDB::HDBManager::fileName(), TTAMachine::Socket::INPUT, missingComponents_, CostEstimator::CostEstimationPlugin::name(), TTAMachine::Socket::OUTPUT, socketParameters(), DataObject::stringValue(), Conversion::toString(), and valueFromKeyValuePairString().

Referenced by estimateICDelayOfPath().

Here is the call graph for this function:

delayOfSocket() [2/2]

DelayInNanoSeconds DefaultICDecoderEstimator::delayOfSocket ( HDB::HDBRegistry &  hdbRegistry, const IDF::SocketImplementationLocation &  implementation  )

inlineprivate

Finds out the delay of the given socket.

Not used with current implementation.

Definition at line 632 of file DefaultICDecoderPlugin.cc.

                                                               {
        // First fetch the id of the 'delay_subsocket_reference' of the
        // socket. The id is used to fetch the subsocket data which carries
        // the delay data.
        int implementationId = implementation.id();
        
        HDB::HDBManager& hdb = hdbRegistry.hdb(implementation.hdbFile());
 
        std::string entry = "delay_subsocket_reference";
 
        try {
            DataObject subsocketReference = 
                hdb.socketCostEstimationData(entry, implementationId, name_);
 
            int entryId = subsocketReference.integerValue();
 
            entry = std::string("id=") + Conversion::toString(entryId);
            DataObject subsocketData = hdb.costEstimationDataValue(entryId);
            return valueFromKeyValuePairString(
                "throughput_delay", subsocketData.stringValue()).doubleValue();
        } catch (const Exception& e) {
            throw Exception(
                __FILE__, __LINE__, __func__, 
                std::string("Cannot fetch socket delay data '") +
                entry + "'." + e.errorMessage());
        }
    }

References __func__, HDB::HDBManager::costEstimationDataValue(), DataObject::doubleValue(), Exception::errorMessage(), HDB::HDBRegistry::hdb(), implementation, DataObject::integerValue(), CostEstimator::CostEstimationPlugin::name_, HDB::HDBManager::socketCostEstimationData(), DataObject::stringValue(), Conversion::toString(), and valueFromKeyValuePairString().

Here is the call graph for this function:

estimateICArea()

virtual bool DefaultICDecoderEstimator::estimateICArea ( HDB::HDBRegistry &  hdbRegistry, const TTAMachine::Machine &  machine, const IDF::MachineImplementation &  machineImplementation, AreaInGates &  area  )

inlinevirtual

Estimates the area of an IC path.

The default implementation estimates the area by summing up areas of of all subcomponents of sockets and buses in the machine. Subcomponent data is entered by user to HDB before estimation. The estimation algorithm does not figure out the subcomponents, it only sums up the c costs of all subcomponents of a machine part. Subcomponent is a fanin/fanout combination included in a component. There can be multiple such combinations due to different widths in inputs and outputs.

The subcomponent data is fetched from HDB by first fetching all subcomponent ids of the machine part by looking for entries named 'subsocket_reference' or 'subbus_reference'. The values of these entries are identifiers of subsocket entries in the cost table. Each subsocket entry has a string of name/value pairs as their value. The cost data is stored in the name/value string. The cost data string must be in the following format: 'throughput_delay=53 area=5.2 active_energy=3 idle_energy=3 control_delay=3'

Todo:

each socket may have own HDB associated to their implementation location object

Todo:

each bus may have own HDB associated to their implementation location object

Reimplemented from CostEstimator::ICDecoderEstimatorPlugin.

Definition at line 220 of file DefaultICDecoderPlugin.cc.

                           {
        area = 0;
 
//#define DEBUG_AREA_ESTIMATION
 
        std::string socketName = "";
        try {
            /// @todo each socket may have own HDB associated to their
            /// implementation location object
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            TTAMachine::Machine::SocketNavigator socketNav = 
                machine.socketNavigator();
            for (int i = 0; i < socketNav.count(); ++i) {
                const TTAMachine::Socket& socket = *socketNav.item(i);
                socketName = "";
                if (socket.direction() == TTAMachine::Socket::INPUT) {
                    socketName = "input_sub_socket";
                } else if (socket.direction() == TTAMachine::Socket::OUTPUT) {
                    socketName = "output_sub_socket";
                } else {
                    // Socket direction is unknown
                    // No need to estimate, since it will not be used.
                    continue;
                }
 
                FanInFanOutCombinationSet parameterSet =
                    socketParameters(socket);
                // socket fanin, fanout and data width is added to name string
                FanInFanOutCombinationSet::const_iterator iter = 
                    parameterSet.begin();
                std::string socketNameCopy = socketName;
                for (; iter != parameterSet.end(); iter++) {
                    socketName = socketNameCopy + " " +
                        Conversion::toString((*iter).fanIn) + " " +
                        Conversion::toString((*iter).fanOut) + " " +
                        Conversion::toString((*iter).dataWidth);
                    try {
                        DataObject subsocketData =
                            hdb.costEstimationDataValue(socketName, name());
                        area += valueFromKeyValuePairString(
                            "area", subsocketData.stringValue()).doubleValue();
                    } catch (const KeyNotFound& e) {
                        std::set<std::string>::iterator iter = 
                            missingComponents_.find("area" + socketName);
                        if (iter == missingComponents_.end()) {
                            std::cerr << "Warning: Could not get area data "
                                      << "for '"
                                      << socketName << "' from HDB: "
                                      << hdb.fileName() << ". Area of this "
                                      << "socket not counted to total." 
                                      << std::endl;
                            missingComponents_.insert("area" + socketName);
                        }
                    }
                }
            }
        } catch (const Exception& e) {
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            debugLog(
                std::string("Could not get socket area data '") +
                socketName + "' from HDB: " + hdb.fileName() + 
                e.errorMessage());
            return false;
        }
 
        std::string busName = "";
        try {
            /// @todo each bus may have own HDB associated to their
            /// implementation location object
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            TTAMachine::Machine::BusNavigator busNav = 
                machine.busNavigator();
            for (int i = 0; i < busNav.count(); ++i) {
                const TTAMachine::Bus& bus = *busNav.item(i);
 
                FanInFanOutCombinationSet parameterSet = busParameters(bus);
                // bus fanin, fanout and data width is added to name string
                FanInFanOutCombinationSet::const_iterator iter = 
                    parameterSet.begin();
                for (; iter != parameterSet.end(); iter++) {
                    busName = "sub_bus " +
                        Conversion::toString((*iter).fanIn) + " " +
                        Conversion::toString((*iter).fanOut) + " " +
                        Conversion::toString((*iter).dataWidth);
                    try {
                        DataObject subbusData =
                            hdb.costEstimationDataValue(busName, name());
                        area += valueFromKeyValuePairString(
                            "area", subbusData.stringValue()).doubleValue();
                    } catch (const KeyNotFound& e) {
                        std::set<std::string>::iterator iter = 
                            missingComponents_.find("area" + busName);
                        if (iter == missingComponents_.end()) {
                            std::cerr << "Warning: Could not get area data "
                                      << "for '"
                                      << busName << "' from HDB: "
                                      << hdb.fileName() << ". Area of this "
                                      << "bus not counted to total." 
                                      << std::endl;
                            missingComponents_.insert("area" + busName);
                        }
                    }
                }
            }
        } catch (const Exception& e) {
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            debugLog(
                std::string("Could not get bus area data '") +
                busName + "' from HDB. " +  hdb.fileName() +
                e.errorMessage());
            return false;
        }
 
        return true;
    }

References TTAMachine::Machine::busNavigator(), busParameters(), HDB::HDBManager::costEstimationDataValue(), TTAMachine::Machine::Navigator< ComponentType >::count(), debugLog, TTAMachine::Socket::direction(), DataObject::doubleValue(), Exception::errorMessage(), HDB::HDBManager::fileName(), HDB::HDBRegistry::hdb(), IDF::MachineImplementation::icDecoderHDB(), TTAMachine::Socket::INPUT, TTAMachine::Machine::Navigator< ComponentType >::item(), machine, missingComponents_, CostEstimator::CostEstimationPlugin::name(), TTAMachine::Socket::OUTPUT, TTAMachine::Machine::socketNavigator(), socketParameters(), DataObject::stringValue(), Conversion::toString(), and valueFromKeyValuePairString().

Here is the call graph for this function:

estimateICDelayOfPath()

virtual bool DefaultICDecoderEstimator::estimateICDelayOfPath ( HDB::HDBRegistry &  hdbRegistry, const TransportPath &  path, const IDF::MachineImplementation &  machineImplementation, const IDF::SocketImplementationLocation &  , const IDF::BusImplementationLocation &  , const IDF::SocketImplementationLocation &  , DelayInNanoSeconds &  delay  )

inlinevirtual

Estimates the delay of an IC path.

The default implementation estimates the delays by summing up delays of the subcomponent of the machine part that is registered to be the 'delay component'. In practice, an entry named 'delay_subsocket_reference' or 'delay_subbus_reference' is first fetched from HDB. The entry pointed to by the fetched entry contains the delay data for the socket/bus at hand.

Parameters

path	Transport path of which delay is estimated.
machineImplementation	Implementation of the machine.
sourceSocketImplementation	Not used.
busImplementation	Not used.
destinationSocketImplementation	Not used.
delay	Result delay of the transport path.

Returns

True if the estimation succeeded.

Reimplemented from CostEstimator::ICDecoderEstimatorPlugin.

Definition at line 163 of file DefaultICDecoderPlugin.cc.

                                   {
//#define DEBUG_DELAY_ESTIMATION
        try {
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            DelayInNanoSeconds sourceDelay = 
                delayOfSocket(hdb, path.sourceSocket());
            DelayInNanoSeconds destinationDelay =
                delayOfSocket(hdb, path.destinationSocket());
            DelayInNanoSeconds busDelay = delayOfBus(hdb, path.bus());
            delay = sourceDelay + busDelay + destinationDelay;
 
#ifdef DEBUG_DELAY_ESTIMATION
            std::cout 
                << "path: {" << path.sourceSocket().name()
                << "," << path.bus().name() << "," 
                << path.destinationSocket().name() << "} "
                << "delays={" << sourceDelay << "," << busDelay << ","
                << destinationDelay << "} = " << delay << std::endl;
#endif            
            return true;
        } catch (const Exception& e) {
            debugLog(e.errorMessage());
            return false;
        }
 
        return false;
    }

References CostEstimator::TransportPath::bus(), debugLog, delayOfBus(), delayOfSocket(), CostEstimator::TransportPath::destinationSocket(), Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::MachineImplementation::icDecoderHDB(), TTAMachine::Component::name(), and CostEstimator::TransportPath::sourceSocket().

Here is the call graph for this function:

estimateICEnergy()

virtual bool DefaultICDecoderEstimator::estimateICEnergy ( HDB::HDBRegistry &  hdbRegistry, const TTAMachine::Machine &  machine, const IDF::MachineImplementation &  machineImplementation, const TTAProgram::Program &  , const ExecutionTrace &  traceDB, EnergyInMilliJoules &  energy  )

inlinevirtual

Estimates the energy consumed by IC.

The default implementation estimates the area by summing up energies of of all subcomponents of sockets and buses. For more information, see the comment of the area estimation function.

Reimplemented from CostEstimator::ICDecoderEstimatorPlugin.

Definition at line 351 of file DefaultICDecoderPlugin.cc.

                                     {
    
//#define DEBUG_ENERGY_ESTIMATION
 
        energy = 0.0;
 
        ClockCycleCount totalCycles = traceDB.simulatedCycleCount();
 
        std::string socketName = "";
        try {
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            TTAMachine::Machine::SocketNavigator socketNav = 
                machine.socketNavigator();
            for (int i = 0; i < socketNav.count(); ++i) {
                const TTAMachine::Socket& socket = *socketNav.item(i);
                socketName = "";
                if (socket.direction() == TTAMachine::Socket::INPUT) {
                    socketName = "input_sub_socket";
                } else if (socket.direction() == TTAMachine::Socket::OUTPUT) {
                    socketName = "output_sub_socket";
                } else {
                    // Socket direction is unknown
                    // No need to estimate, since it will not be used.
                    continue;
                }
 
                FanInFanOutCombinationSet parameterSet =
                    socketParameters(socket);
                // socket fanin, fanout and data width is added to name string
                FanInFanOutCombinationSet::const_iterator iter = 
                    parameterSet.begin();
                std::string socketNameCopy = socketName;
                for (; iter != parameterSet.end(); iter++) {
                    socketName = socketNameCopy + " " +
                        Conversion::toString((*iter).fanIn) + " " +
                        Conversion::toString((*iter).fanOut) + " " +
                        Conversion::toString((*iter).dataWidth);
                    DataObject subsocketData =
                        hdb.costEstimationDataValue(socketName, name());
 
                    // sum the active and idle energies of all subsockets
                    // multiplied with write and idle clock counts, 
                    // respectively
                    EnergyInMilliJoules idleEnergy = 
                        valueFromKeyValuePairString(
                            "idle_energy", subsocketData.stringValue()).
                        doubleValue();
                    EnergyInMilliJoules activeEnergy = 
                        valueFromKeyValuePairString(
                            "active_energy", subsocketData.stringValue()).
                        doubleValue();
 
                    ClockCycleCount activeCycles = 
                        traceDB.socketWriteCount(socket.name());
 
                    EnergyInMilliJoules totalActiveEnergy = 
                        activeEnergy*activeCycles;
 
                    ClockCycleCount idleCycles = totalCycles - activeCycles;
 
                    EnergyInMilliJoules totalIdleEnergy = 
                        idleEnergy*idleCycles;
 
                    EnergyInMilliJoules totalEnergy = 
                        totalIdleEnergy + totalActiveEnergy;
                    energy += totalEnergy;
#ifdef DEBUG_ENERGY_ESTIMATION
                    std::cout 
                        << "socket " << socket.name() << ", subsocket "
                        << socketName << ": "
                        << "active energy = " << activeEnergy 
                        << " mJ/cycle * " << activeCycles << " cycle = " 
                        << totalActiveEnergy << ", "
                        << "idle energy = " << idleEnergy 
                        << " mJ/cycle * " << idleCycles << " cycle = " 
                        << totalIdleEnergy << " TOTAL = " << totalEnergy
                        << std::endl;
#endif
                }
            }
        } catch (const Exception& e) {                
            debugLog(
                std::string("Could not get socket area data '") +
                socketName + "' from HDB. " + e.errorMessage());
            return false;
        }
        std::string busName = "";
        try {
            HDB::HDBManager& hdb = 
                hdbRegistry.hdb(machineImplementation.icDecoderHDB());
            TTAMachine::Machine::BusNavigator busNav = machine.busNavigator();
            for (int i = 0; i < busNav.count(); ++i) {
                const TTAMachine::Bus& bus = *busNav.item(i);
                
                FanInFanOutCombinationSet parameterSet = busParameters(bus);
                // bus fanin, fanout and data width is added to name string
                FanInFanOutCombinationSet::const_iterator iter = 
                    parameterSet.begin();
                for (; iter != parameterSet.end(); iter++) {
                    busName = "sub_bus " +
                        Conversion::toString((*iter).fanIn) + " " +
                        Conversion::toString((*iter).fanOut) + " " +
                        Conversion::toString((*iter).dataWidth);
                    DataObject subbusData =
                        hdb.costEstimationDataValue(busName, name());
 
                    // sum the active and idle energies of all subbuses
                    // multiplied with write and idle clock counts, 
                    // respectively
                    EnergyInMilliJoules idleEnergy = 
                        valueFromKeyValuePairString(
                            "idle_energy", subbusData.stringValue()).
                        doubleValue();
                    EnergyInMilliJoules activeEnergy = 
                        valueFromKeyValuePairString(
                            "active_energy", subbusData.stringValue()).
                        doubleValue();
 
                    ClockCycleCount activeCycles = 
                        traceDB.busWriteCount(bus.name());
                    
                    EnergyInMilliJoules totalActiveEnergy = 
                        activeEnergy*activeCycles;
                    
                    ClockCycleCount idleCycles = totalCycles - activeCycles;
                    
                    EnergyInMilliJoules totalIdleEnergy = 
                        idleEnergy*idleCycles;
                    
                    EnergyInMilliJoules totalEnergy = 
                        totalIdleEnergy + totalActiveEnergy;
                    energy += totalEnergy;
#ifdef DEBUG_ENERGY_ESTIMATION
                    std::cout 
                        << "bus " << bus.name() << ", subbus "
                        << busName << ": "
                        << "active energy = " << activeEnergy 
                        << " mJ/cycle * " << activeCycles << " cycle = " 
                        << totalActiveEnergy << ", "
                        << "idle energy = " << idleEnergy 
                        << " mJ/cycle * " << idleCycles << " cycle = " 
                        << totalIdleEnergy << " TOTAL = " << totalEnergy
                        << std::endl;
#endif
                }
            }
        } catch (const Exception& e) {                
            debugLog(
                std::string("Could not get bus energy data '") + busName + 
                "' from HDB. " + e.errorMessage());
            return false;
        }
        return true;
    }

References TTAMachine::Machine::busNavigator(), busParameters(), ExecutionTrace::busWriteCount(), HDB::HDBManager::costEstimationDataValue(), TTAMachine::Machine::Navigator< ComponentType >::count(), debugLog, TTAMachine::Socket::direction(), Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::MachineImplementation::icDecoderHDB(), TTAMachine::Socket::INPUT, TTAMachine::Machine::Navigator< ComponentType >::item(), machine, CostEstimator::CostEstimationPlugin::name(), TTAMachine::Component::name(), TTAMachine::Socket::OUTPUT, ExecutionTrace::simulatedCycleCount(), TTAMachine::Machine::socketNavigator(), socketParameters(), ExecutionTrace::socketWriteCount(), DataObject::stringValue(), Conversion::toString(), and valueFromKeyValuePairString().

Here is the call graph for this function:

generateFanInFanOutCombinations()

FanInFanOutCombinationSet DefaultICDecoderEstimator::generateFanInFanOutCombinations ( std::vector< std::size_t > &  inputWidths, std::vector< std::size_t > &  outputWidths  )

inlineprivate

Generates all possible fanin/fanout/data width combinations (subcomponents) for given input and output widths.

Parameters

inputWidths	Set containing component's input widths.
outputWidths	Set containing component's output widths.

Returns

Set of fanin/fanout/data width combinations.

Definition at line 736 of file DefaultICDecoderPlugin.cc.

                                            {
 
        std::sort(inputWidths.begin(), inputWidths.end());
        std::sort(outputWidths.begin(), outputWidths.end());
 
        std::set<std::size_t> allWidthsTemp;
        std::copy(
            inputWidths.begin(), inputWidths.end(), 
            std::insert_iterator<std::set<std::size_t> >(
                allWidthsTemp, allWidthsTemp.begin()));
        std::copy(
            outputWidths.begin(), outputWidths.end(), 
            std::insert_iterator<std::set<std::size_t> >(
                allWidthsTemp, allWidthsTemp.begin()));
        std::vector<std::size_t> allWidths;
        std::copy(
            allWidthsTemp.begin(), allWidthsTemp.end(), 
            std::insert_iterator<std::vector<std::size_t> >(
                allWidths, allWidths.begin()));
            
 
        FanInFanOutCombinationSet combinations;
        for (std::vector<std::size_t>::iterator i = allWidths.begin(); 
             i != allWidths.end(); ++i) {
 
            const unsigned int width = *i;
 
            // how many input widths fits in the current width?
            std::size_t fanIn = 0;
            for (unsigned int n = 0; n < inputWidths.size(); n++) {
                // we can do a trick like this because the vector is ordered
                if (width > inputWidths.at(n) && inputWidths.at(n) > 0)
                    break;
                if (inputWidths.at(n) != 0) {
                    fanIn++;
                }
            }
 
            // how many output widths fits in the current width?
            std::size_t fanOut = 0;
            for (unsigned int n = 0; n < outputWidths.size(); n++) {
                // we can do a trick like this because the vector is ordered
                if (width > outputWidths.at(n) && outputWidths.at(n) > 0)
                    break;
                if (outputWidths.at(n) != 0) {
                    fanOut++;
                }
            }
 
            if (fanIn == 0 || fanOut == 0)
                return combinations; //continue;
            ICParameters parameters;
            parameters.fanIn = fanIn;
            parameters.fanOut = fanOut;
            parameters.dataWidth = width;
            combinations.push_back(parameters);
            
            for (unsigned int n = 0; n < inputWidths.size(); n++) {
                if (inputWidths.at(n) > width) {
                    inputWidths.at(n) = inputWidths.at(n) - width;
                } else {
                    inputWidths.at(n) = 0;
                }
            }
            for (unsigned int n = 0; n < outputWidths.size(); n++) {
                if (outputWidths.at(n) > width) {
                    outputWidths.at(n) = outputWidths.at(n) - width;
                } else {
                    outputWidths.at(n) = 0;
                }
            }
 
            for (unsigned int n = 0; n < allWidths.size(); n++) {
                if (allWidths.at(n) > width) {
                    allWidths.at(n) = allWidths.at(n) - width;
                } else {
                    allWidths.at(n) = 0;
                }
            }
 
        }
 
        return combinations;
    }

References DefaultICDecoderEstimator::ICParameters::dataWidth, DefaultICDecoderEstimator::ICParameters::fanIn, and DefaultICDecoderEstimator::ICParameters::fanOut.

Referenced by busParameters(), and socketParameters().

socketParameters()

FanInFanOutCombinationSet DefaultICDecoderEstimator::socketParameters ( const TTAMachine::Socket &  socket )

inlineprivate

Generates fanin/fanout/width combinations to a socket.

Parameters

socket

Socket which parameters are generated.

Returns

Set of fanin/fanout/width combinations.

Definition at line 831 of file DefaultICDecoderPlugin.cc.

                                        {
 
        std::vector<std::size_t> inputWidths;
        std::vector<std::size_t> outputWidths;
 
        if (socket.direction() == TTAMachine::Socket::INPUT) {
            for (int i = 0; i < socket.segmentCount(); i++) {
                inputWidths.push_back(socket.segment(i)->parentBus()->width());
            }
            for (int i = 0; i < socket.portCount(); i++) {
                outputWidths.push_back(socket.port(i)->width());
            }
        } else if (socket.direction() == TTAMachine::Socket::OUTPUT) {
            for (int i = 0; i < socket.segmentCount(); i++) {
                outputWidths.push_back(socket.segment(i)->parentBus()->width());
            }
            for (int i = 0; i < socket.portCount(); i++) {
                inputWidths.push_back(socket.port(i)->width());
            }
        }
        return generateFanInFanOutCombinations(inputWidths, outputWidths);
    }

References TTAMachine::Socket::direction(), generateFanInFanOutCombinations(), TTAMachine::Socket::INPUT, TTAMachine::Socket::OUTPUT, TTAMachine::Segment::parentBus(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TTAMachine::Socket::segment(), TTAMachine::Socket::segmentCount(), TTAMachine::Bus::width(), and TTAMachine::Port::width().

Referenced by delayOfSocket(), estimateICArea(), and estimateICEnergy().

Here is the call graph for this function:

valueFromKeyValuePairString()

DataObject DefaultICDecoderEstimator::valueFromKeyValuePairString ( const std::string &  keyName, const std::string &  keyValuePairString  )

inlineprivate

Parses a string of key-value pairs and returns a value with given key.

The string must be in format "key1=value1 key2=value2" etc. the value must not have spaces in it.

Parameters

keyName	The key of the value to fetch from the string.
keyValuePairString	The key-value pair string to parse.

Returns

The value.

Exceptions

KeyNotFound

In case the key was not found in the string.

Definition at line 701 of file DefaultICDecoderPlugin.cc.

                                                                       {
        boost::smatch parsed;
        boost::regex regexp(
            (boost::format("(.*)(%s)=([^\\s]*)(.*)") % keyName).str());
        if (!regex_match(keyValuePairString, parsed, regexp)) {
            throw KeyNotFound(
                __FILE__, __LINE__, __func__, 
                "Key not found in value string.");
        } else {
            if (parsed.size() < 3)
                throw KeyNotFound(__FILE__, __LINE__, __func__);
            DataObject data;
            data.setString(parsed[3]);
            return data;
        }
    }

References __func__, and DataObject::setString().

Referenced by delayOfBus(), delayOfSocket(), delayOfSocket(), estimateICArea(), and estimateICEnergy().

Here is the call graph for this function:

Member Data Documentation

missingComponents_

std::set<std::string> DefaultICDecoderEstimator::missingComponents_

private

Set for component names that are missing from HDB.

Definition at line 516 of file DefaultICDecoderPlugin.cc.

Referenced by delayOfBus(), delayOfSocket(), and estimateICArea().

---

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

• DefaultICDecoderPlugin.cc