#include <Estimator.hh>

Collaboration diagram for CostEstimator::Estimator:

Public Member Functions
	Estimator ()

virtual	~Estimator ()

AreaInGates	totalArea (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)
	area estimation functions More...

AreaInGates	totalAreaOfFunctionUnits (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)

AreaInGates	totalAreaOfRegisterFiles (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)

AreaInGates	icArea (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)

AreaInGates	functionUnitArea (const TTAMachine::FunctionUnit &architecture, const IDF::FUImplementationLocation &implementationEntry)

AreaInGates	registerFileArea (const TTAMachine::BaseRegisterFile &architecture, const IDF::RFImplementationLocation &implementationEntry)

EnergyInMilliJoules	totalEnergy (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, const TTAProgram::Program &program, const ExecutionTrace &traceDB)
	energy estimation functions More...

EnergyInMilliJoules	icEnergy (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, const TTAProgram::Program &program, const ExecutionTrace &traceDB)

EnergyInMilliJoules	functionUnitEnergy (const TTAMachine::FunctionUnit &architecture, const IDF::FUImplementationLocation &implementationEntry, const TTAProgram::Program &program, const ExecutionTrace &traceDB)

EnergyInMilliJoules	registerFileEnergy (const TTAMachine::BaseRegisterFile &architecture, const IDF::RFImplementationLocation &implementationEntry, const TTAProgram::Program &program, const ExecutionTrace &traceDB)

EnergyInMilliJoules	totalEnergyOfFunctionUnits (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, const TTAProgram::Program &program, const ExecutionTrace &traceDB)

EnergyInMilliJoules	totalEnergyOfRegisterFiles (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation, const TTAProgram::Program &program, const ExecutionTrace &traceDB)

DelayInNanoSeconds	longestPath (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)
	delay estimation functions More...

DelayInNanoSeconds	decompressorDelay (const TTAMachine::Machine &machine, const IDF::MachineImplementation &machineImplementation)

DelayInNanoSeconds	functionUnitPortWriteDelay (const TTAMachine::FUPort &port, const IDF::FUImplementationLocation &implementationEntry)

DelayInNanoSeconds	functionUnitPortReadDelay (const TTAMachine::FUPort &port, const IDF::FUImplementationLocation &implementationEntry)

DelayInNanoSeconds	functionUnitMaximumComputationDelay (const TTAMachine::FunctionUnit &architecture, const IDF::FUImplementationLocation &implementation)

DelayInNanoSeconds	registerFileMaximumComputationDelay (const TTAMachine::BaseRegisterFile &architecture, const IDF::RFImplementationLocation &implementationEntry)

DelayInNanoSeconds	registerFilePortWriteDelay (const TTAMachine::RFPort &port, const IDF::RFImplementationLocation &implementationEntry)

DelayInNanoSeconds	registerFilePortReadDelay (const TTAMachine::RFPort &port, const IDF::RFImplementationLocation &implementationEntry)

Private Member Functions
DelayInNanoSeconds	estimateSocketToSocketDelayOfPath (const std::string pluginPath, const std::string pluginName, const TransportPath &path, const IDF::MachineImplementation &machineImplementation, const IDF::SocketImplementationLocation &sourceSocketImplementation, const IDF::BusImplementationLocation &busImplementation, const IDF::SocketImplementationLocation &destinationSocketImplementation)

FUCostEstimationPlugin &	fuCostFunctionPluginOfImplementation (const IDF::FUImplementationLocation &implementation)

RFCostEstimationPlugin &	rfCostFunctionPluginOfImplementation (const IDF::RFImplementationLocation &implementation)

Static Private Member Functions
static TransportPathList *	findAllICPaths (const TTAMachine::Machine &machine)

Private Attributes
FUCostEstimationPluginRegistry	fuEstimatorPluginRegistry_
	all accessed FU estimation plugins are stored in this registry More...

RFCostEstimationPluginRegistry	rfEstimatorPluginRegistry_
	all accessed RF estimation plugins are stored in this registry More...

ICDecoderCostEstimationPluginRegistry	icDecoderEstimatorPluginRegistry_
	all accessed IC&decoder plugins are stored in this registry More...

Detailed Description

The frontend to hardware cost estimation functionality.

This class is used by clients that need to estimate area, energy, or delay of a whole TTA processor or parts of it.

The estimation functions of this interface throw CannotEstimateCost, because it really is an exceptional situation when this class cannot estimate, because it's client's responsibility to make sure all plugins etc. can be found for estimating the machine. In case of single plugins, the situation is not exceptional, but they provide estimation as a "capability", thus they signal explicitly whether they can estimate a cost or not by returning true or false, respectively.

Definition at line 85 of file Estimator.hh.

Constructor & Destructor Documentation

◆ Estimator()

CostEstimator::Estimator::Estimator ( )

Constructor.

Definition at line 64 of file Estimator.cc.

64 {

65 }

◆ ~Estimator()

CostEstimator::Estimator::~Estimator ( )

virtual

Destructor.

Definition at line 70 of file Estimator.cc.

70 {

71 }

Member Function Documentation

◆ decompressorDelay()

DelayInNanoSeconds CostEstimator::Estimator::decompressorDelay	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

◆ estimateSocketToSocketDelayOfPath()

DelayInNanoSeconds CostEstimator::Estimator::estimateSocketToSocketDelayOfPath	(	const std::string	pluginPath,
		const std::string	pluginName,
		const TransportPath &	path,
		const IDF::MachineImplementation &	machineImplementation,
		const IDF::SocketImplementationLocation &	sourceSocketImplementation,
		const IDF::BusImplementationLocation &	busImplementation,
		const IDF::SocketImplementationLocation &	destinationSocketImplementation
	)

private

Estimates the delay of a single socket-to-socket path.

Delegates the task to the given IC&decoder plugin.

Parameters

pluginPath	The path of the IC&decoder estimator plugin to use.
pluginName	The name of the IC&decoder estimator plugin to use.
pluginDataHDB	The HDB from which the plugin should fetch its data.
path	The path to estimate.
machineImplementation	Implementation of the machine.
sourceSocketImplementation	The implementation descriptor of source socket.
busImplementation	The implementation descriptor of bus.
destinationSocketImplementation	The implementation descriptor of destination socket.

Definition at line 1316 of file Estimator.cc.

                                                                             {
     DelayInNanoSeconds delay = 0.0;
     try {
  
         ICDecoderEstimatorPlugin& plugin = 
             icDecoderEstimatorPluginRegistry_.plugin(
                 pluginPath, pluginName);
  
         if (!plugin.estimateICDelayOfPath(
                 HDBRegistry::instance(), path, machineImplementation,
                 sourceSocketImplementation, 
                 busImplementation, destinationSocketImplementation, delay)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "The IC&decoder estimator plugin '%s' could not estimate "
                     "delay of a path.") % pluginName).str());
         }
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             std::string("Error while using ICDecoder estimation plugin. ") +
             e.errorMessage());
     }
     return delay;
 }

References __func__, Exception::errorMessage(), CostEstimator::ICDecoderEstimatorPlugin::estimateICDelayOfPath(), and HDB::HDBRegistry::instance().

Here is the call graph for this function:

◆ findAllICPaths()

TransportPathList * CostEstimator::Estimator::findAllICPaths ( const TTAMachine::Machine & machine )

staticprivate

Finds all paths in the interconnection network of the given machine.

Parameters

machine Machine to search the paths in.

Returns: List of transport paths. Becomes property of the client.

Exceptions

IllegalMachine In case the machine is badly formed, for example, has features that are not supported yet.

Definition at line 1228 of file Estimator.cc.

                                                           {
     TransportPathList* paths = new TransportPathList();
  
     TTAMachine::Machine::BusNavigator busNav = machine.busNavigator();
     for (int bi = 0; bi < busNav.count(); ++bi) {
         typedef std::set<const TTAMachine::Socket*> SocketSet;
         SocketSet outputSockets, inputSockets;
  
         const TTAMachine::Bus& bus = *busNav.item(bi);
         if (bus.segmentCount() > 1) {
             throw IllegalMachine(
                 __FILE__, __LINE__, __func__,
                 "Segmented buses not supported yet.");
         }
  
         const TTAMachine::Segment& segment = *bus.segment(0);
  
         // fetch all input and output sockets connected to the bus (segment)
         for (int ci = 0; ci < segment.connectionCount(); ++ci) {
             const TTAMachine::Socket& socket = *segment.connection(ci);
             if (socket.direction() == TTAMachine::Socket::INPUT) {
                 inputSockets.insert(&socket);
             } else if (socket.direction() == TTAMachine::Socket::OUTPUT) {
                 outputSockets.insert(&socket);
             } else {
                 throw IllegalMachine(
                     __FILE__, __LINE__, __func__,
                     "Unsupported socket direction.");
             }
         }
  
         for (SocketSet::iterator osi = outputSockets.begin(); 
              osi != outputSockets.end(); ++osi) {
             const TTAMachine::Socket& outputSocket = **osi;
  
             // iterate through all (output) ports connected to the socket
             for (int opi = 0; opi < outputSocket.portCount(); ++opi) {
                 const TTAMachine::Port& outputPort = *outputSocket.port(opi);
  
                 // iterate through all input sockets connected to the bus
                 for (SocketSet::iterator isi = inputSockets.begin();
                      isi != inputSockets.end(); ++isi) {
                     const TTAMachine::Socket& inputSocket = **isi;
  
                     // iterate through all endpoints of the path (input ports)
                     for (int ipi = 0; ipi < inputSocket.portCount(); ++ipi) {
                         const TTAMachine::Port& inputPort = *inputSocket.port(
                             ipi);
                         TransportPath path(
                             outputPort, outputSocket, bus, inputSocket,
                             inputPort);
                         paths->push_back(path);
 #if 0
                         Application::logStream()
                             << "path: {" << outputPort.parentUnit()->name()
                             << "::" << outputPort.name() << ", "
                             << outputSocket.name() << ", "
                             << bus.name() << ", "
                             << inputSocket.name() << ", "
                             << inputPort.parentUnit()->name()
                             << "::" << inputPort.name() << "}" << std::endl;
 #endif
                     }
                 }
             }
         }
     }
     return paths;
 }

References __func__, TTAMachine::Machine::busNavigator(), TTAMachine::Segment::connection(), TTAMachine::Segment::connectionCount(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Socket::direction(), TTAMachine::Socket::INPUT, TTAMachine::Machine::Navigator< ComponentType >::item(), Application::logStream(), machine, TTAMachine::Port::name(), TTAMachine::Component::name(), TTAMachine::Socket::OUTPUT, TTAMachine::Port::parentUnit(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TTAMachine::Bus::segment(), and TTAMachine::Bus::segmentCount().

Here is the call graph for this function:

◆ fuCostFunctionPluginOfImplementation()

FUCostEstimationPlugin & CostEstimator::Estimator::fuCostFunctionPluginOfImplementation ( const IDF::FUImplementationLocation & implementationEntry )

private

Loads an FU cost estimation plugin for the given FU implementation.

Parameters

implementationEntry The implementation of the FU.

Returns: The plugin.

Exceptions

Exception In case the plugin was not found or could not be loaded.

Definition at line 260 of file Estimator.cc.

                                                             {
     std::string pluginFileName = "";
     std::string pluginName = "";
     HDB::HDBManager* theHDB = NULL;
     try {
         // use the HDB to find the estimation plugin from the plugin
         // registry
         theHDB = &HDBRegistry::instance().hdb(implementationEntry.hdbFile());
         HDB::FUEntry* fuEntry = theHDB->fuByEntryID(implementationEntry.id());
  
         if (fuEntry == NULL || !fuEntry->hasCostFunction()) {
             delete fuEntry;
             fuEntry = NULL;
             throw Exception(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "Function unit entry %d does not have cost "
                     "estimation plugin set.") % 
                  implementationEntry.id()).str());
         }
  
         HDB::CostFunctionPlugin& pluginData = fuEntry->costFunction();
         pluginFileName = pluginData.pluginFilePath();
         pluginName = pluginData.name();
  
         try {
             return fuEstimatorPluginRegistry_.plugin(
                 pluginFileName, pluginName);
         } catch (const Exception& e) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 std::string("Unable to open FU estimation plugin '") + 
                 pluginFileName + "'. " + e.errorMessage());
         }
     } catch (const Exception& e) {
         throw Exception(
             __FILE__, __LINE__, __func__, e.errorMessage());
     }
     // avoid warnings with some compilers
     throw 1;
 }

References __func__, HDB::HDBEntry::costFunction(), Exception::errorMessage(), HDB::HDBManager::fuByEntryID(), HDB::HDBEntry::hasCostFunction(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), IDF::UnitImplementationLocation::id(), HDB::HDBRegistry::instance(), HDB::CostFunctionPlugin::name(), and HDB::CostFunctionPlugin::pluginFilePath().

Here is the call graph for this function:

◆ functionUnitArea()

AreaInGates CostEstimator::Estimator::functionUnitArea	(	const TTAMachine::FunctionUnit &	architecture,
		const IDF::FUImplementationLocation &	implementationEntry
	)

Estimates the area of the given function unit.

Parameters

architecture	The FU architecture of which area to estimate.
implementationEntry	The implementation information of FU. Can be an instance of NullFUImplementationLocation.

Exceptions

CannotEstimateCost In case the area could not be estimated.

Returns: Estimate of area.

Definition at line 364 of file Estimator.cc.

                                                             {
     try {
         AreaInGates area = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!fuCostFunctionPluginOfImplementation(implementationEntry).
             estimateArea(architecture, implementationEntry, area, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string(
                     "Plugin was unable to estimate area of function unit '") +
                 architecture.name() + ".");
         }
         return area;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string("Unable to estimate area of function unit '") +
             architecture.name() + "'. " + e.errorMessage());
     }
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ functionUnitEnergy()

EnergyInMilliJoules CostEstimator::Estimator::functionUnitEnergy	(	const TTAMachine::FunctionUnit &	architecture,
		const IDF::FUImplementationLocation &	implementationEntry,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Estimates the energy consumed by the given FU when running the given program.

Parameters

architecture	The FU architecture of which area to estimate.
implementationEntry	The implementation information of FU. Can be an instance of NullFUImplementationLocation.
program	The program of which energy to calculate.
traceDB	The simulation trace database of the program running in the target architecture.

Returns: Estimate of consumed energy.

Exceptions

CannotEstimateCost In case the energy could not be estimated.

Definition at line 510 of file Estimator.cc.

                                                                      {
     try {
         AreaInGates area = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!fuCostFunctionPluginOfImplementation(implementationEntry).
             estimateEnergy(
                 architecture, implementationEntry, program, traceDB, area, 
                 hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string("Plugin was unable to estimate energy."));
         }
         return area;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string("Unable to estimate energy of function unit '") +
             architecture.name() + "'. " + e.errorMessage());
     }
  
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Component::name(), and program.

Here is the call graph for this function:

◆ functionUnitMaximumComputationDelay()

DelayInNanoSeconds CostEstimator::Estimator::functionUnitMaximumComputationDelay	(	const TTAMachine::FunctionUnit &	architecture,
		const IDF::FUImplementationLocation &	implementationEntry
	)

Estimates the maximum computation delay of the given function unit.

The maximum computation delay is the longest stage in the FU unit's pipeline. It's used mainly for calculating the maximum clock frequency of target architecture by finding the longest path of the machine.

Parameters

architecture	The FU architecture of which area to estimate.
implementationEntry	The implementation information of FU.

Exceptions

CannotEstimateCost In case the computation delay could not be estimated.

Returns: Estimate of computation delay of the given FU.

Definition at line 834 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!fuCostFunctionPluginOfImplementation(implementationEntry).
             estimateMaximumComputationDelay(
                 architecture, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string(
                     "Plugin was unable to estimate computation delay of FU ") +
                 architecture.name());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Computation delay estimation could not be done for the given "
                 "function unit entry. ") +
             e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ functionUnitPortReadDelay()

DelayInNanoSeconds CostEstimator::Estimator::functionUnitPortReadDelay	(	const TTAMachine::FUPort &	port,
		const IDF::FUImplementationLocation &	implementationEntry
	)

Estimates the output delay of the given function unit port.

Parameters

port	The architecture of the FU port of which area to estimate.
implementationEntry	The implementation information of the FU port belongs to.

Exceptions

CannotEstimateCost In case the output delay could not be estimated.

Returns: Estimate of output delay of the given FU port.

Definition at line 718 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!fuCostFunctionPluginOfImplementation(implementationEntry).
             estimatePortReadDelay(port, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 (boost::format(
                     "Plugin was unable to estimate output delay of port "
                     "%s::%s.") % port.parentUnit()->name() % port.name()).
                 str());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Output delay estimation could not be done for the given "
                 "function unit entry. ") + e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Port::name(), TTAMachine::Component::name(), and TTAMachine::BaseFUPort::parentUnit().

Here is the call graph for this function:

◆ functionUnitPortWriteDelay()

DelayInNanoSeconds CostEstimator::Estimator::functionUnitPortWriteDelay	(	const TTAMachine::FUPort &	port,
		const IDF::FUImplementationLocation &	implementationEntry
	)

Estimates the input delay of the given function unit port.

Parameters

port	The architecture of FU port of which area to estimate.
implementationEntry	The implementation information of the FU the port belongs to.

Exceptions

CannotEstimateCost In case the input delay could not be estimated.

Returns: Estimate of input delay of the given FU port.

Definition at line 679 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!fuCostFunctionPluginOfImplementation(implementationEntry).
             estimatePortWriteDelay(port, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 (boost::format(
                     "Plugin was unable to estimate input delay of port "
                     "%s::%s.") % port.parentUnit()->name() % port.name()).
                 str());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Input delay estimation could not be done for the given "
                 "function unit entry. ") +
             e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Port::name(), TTAMachine::Component::name(), and TTAMachine::BaseFUPort::parentUnit().

Here is the call graph for this function:

◆ icArea()

AreaInGates CostEstimator::Estimator::icArea	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

Estimates the area consumed by the interconnection network.

Parameters

machine	The machine of which IC area to estimate.
machineImplementation	The machine implementation information.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 206 of file Estimator.cc.

                                                            {
     if (!machineImplementation.hasICDecoderPluginName() ||
         !machineImplementation.hasICDecoderPluginFile() ||
         !machineImplementation.hasICDecoderHDB()) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             "Missing IC&decoder plugin information.");
     }        
  
     AreaInGates area = 0.0;
     try {
  
         ICDecoderEstimatorPlugin& plugin = 
             icDecoderEstimatorPluginRegistry_.plugin(
                 machineImplementation.icDecoderPluginFile(),
                 machineImplementation.icDecoderPluginName());
  
         if (!plugin.estimateICArea(
                 HDBRegistry::instance(), machine, machineImplementation,
                 area)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "The IC&decoder estimator plugin '%s' unable to estimate "
                     "area of IC.") % 
                  machineImplementation.icDecoderPluginName()).str());
         }
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             std::string("Error while using ICDecoder estimation plugin. ") +
             e.errorMessage());
     }
  
     if (Application::verboseLevel() > 0) {
         Application::logStream() 
             << "IC contributes " << area << " gates" 
             << std::endl;
     }
  
     return area;
 }

References __func__, Exception::errorMessage(), CostEstimator::ICDecoderEstimatorPlugin::estimateICArea(), IDF::MachineImplementation::hasICDecoderHDB(), IDF::MachineImplementation::hasICDecoderPluginFile(), IDF::MachineImplementation::hasICDecoderPluginName(), IDF::MachineImplementation::icDecoderPluginFile(), IDF::MachineImplementation::icDecoderPluginName(), HDB::HDBRegistry::instance(), Application::logStream(), machine, and Application::verboseLevel().

Here is the call graph for this function:

◆ icEnergy()

EnergyInMilliJoules CostEstimator::Estimator::icEnergy	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Estimates the total energy consumed by the interconnection network of the given machine running the given program.

Parameters

machine	Architecture of the processor.
machineImplementation	Implementation information of the processor.
traceDB	The simulation trace database obtained from simulating the program.

Returns: Energy in milli joules.

Exceptions

CannotEstimateCost If the energy could not be estimated.

Definition at line 456 of file Estimator.cc.

                                                                      {
     if (!machineImplementation.hasICDecoderPluginName() ||
         !machineImplementation.hasICDecoderPluginFile() ||
         !machineImplementation.hasICDecoderHDB()) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             "Missing IC&decoder plugin information.");
     }        
  
     EnergyInMilliJoules energy = 0.0;
     try {
  
         ICDecoderEstimatorPlugin& plugin = 
             icDecoderEstimatorPluginRegistry_.plugin(
                 machineImplementation.icDecoderPluginFile(),
                 machineImplementation.icDecoderPluginName());
  
         if (!plugin.estimateICEnergy(
                 HDBRegistry::instance(), machine, machineImplementation,
                 program, traceDB, energy)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "The IC&decoder estimator plugin '%s' could not estimate "
                     "energy for IC.") % 
                     machineImplementation.icDecoderPluginName()).str());
  
         }
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             std::string("Error while using ICDecoder estimation plugin. ") +
             e.errorMessage());
     }
     return energy;
 }

References __func__, Exception::errorMessage(), CostEstimator::ICDecoderEstimatorPlugin::estimateICEnergy(), IDF::MachineImplementation::hasICDecoderHDB(), IDF::MachineImplementation::hasICDecoderPluginFile(), IDF::MachineImplementation::hasICDecoderPluginName(), IDF::MachineImplementation::icDecoderPluginFile(), IDF::MachineImplementation::icDecoderPluginName(), HDB::HDBRegistry::instance(), machine, and program.

Here is the call graph for this function:

◆ longestPath()

DelayInNanoSeconds CostEstimator::Estimator::longestPath	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

delay estimation functions

Calculates the longest path of the machine.

The longest path is the longest delay in the machine. It can be a path in interconnection network or a computation delay of an FU.

Parameters

machine	Machine to calculate the longest path for.
machineImplementation	Implementation identifier for the machine.

Returns: The delay of the longest path.

Definition at line 915 of file Estimator.cc.

                                                            {
     //#define LONGEST_PATH_DEBUGGING
  
     DelayInNanoSeconds maximumICDelay = 0.0;
  
     // find all the paths in IC
     TransportPathList* icPaths = findAllICPaths(machine);
  
     // find if there is bus that is fully connected
     std::string fBusName = "";
     TTAMachine::Machine::BusNavigator busNav = machine.busNavigator();
     TTAMachine::Machine::SocketNavigator sNav = machine.socketNavigator();
     for (int i = 0; i < busNav.count(); ++i) {
         const TTAMachine::Bus& bus = *busNav.item(i);
         const TTAMachine::Segment& segment = *bus.segment(0);
  
         // check if bus is fully connected
         if (segment.connectionCount() == sNav.count()) {
             fBusName = bus.name();
             break;
         }
     }
  
     // calculate delays for all the paths in the machine
     for (TransportPathList::iterator i = icPaths->begin(); 
         i != icPaths->end(); ++i) {
  
         // if fully connected bus was found, check only paths that contain it
         if (fBusName != "" && fBusName != (i->bus()).name()) {
             continue;
         }
  
         DelayInNanoSeconds readDelay = 0, writeDelay = 0, busDelay = 0,
             pathDelay = 0;
  
         TransportPath& path = *i;
         
         // calculate the port->socket, socket->port part by using FU/RF plugins
         const TTAMachine::Port& sourcePort = path.sourcePort();
  
         if (dynamic_cast<const TTAMachine::FUPort*>(&sourcePort) != NULL) {
  
             const TTAMachine::FUPort& sourceFUPort = 
                 dynamic_cast<const TTAMachine::FUPort&>(sourcePort);
             const TTAMachine::FunctionUnit& fu = *sourceFUPort.parentUnit();
             if (!machineImplementation.hasFUImplementation(fu.name())) {
                 throw CannotEstimateCost(
                     __FILE__, __LINE__, __func__, 
                     (boost::format(
                         "Implementation information missing for function unit "
                         "'%s'.") % fu.name()).str());
             }
             // read delay
             readDelay = functionUnitPortReadDelay(
                 sourceFUPort, machineImplementation.fuImplementation(
                     fu.name()));
         } else if (dynamic_cast<const TTAMachine::RFPort*>(&sourcePort) 
                    != NULL) {
             const TTAMachine::RFPort& sourceRFPort = 
                 dynamic_cast<const TTAMachine::RFPort&>(sourcePort);
             const TTAMachine::BaseRegisterFile& rf = 
                 *sourceRFPort.parentUnit();
             if (machineImplementation.hasRFImplementation(rf.name())) {
                 // read delay
                 readDelay = registerFilePortReadDelay( 
                     sourceRFPort, machineImplementation.rfImplementation(
                         rf.name()));
             } else if (machineImplementation.hasIUImplementation(rf.name())) {
                 // read delay
                 readDelay = registerFilePortReadDelay( 
                     sourceRFPort, machineImplementation.iuImplementation(
                         rf.name()));
             } else {
                 throw CannotEstimateCost(
                     __FILE__, __LINE__, __func__, 
                     (boost::format(
                         "Implementation information missing for register file "
                         "'%s'.") % rf.name()).str());
             }
         } else if (dynamic_cast<const TTAMachine::BaseFUPort*>(
                        &sourcePort) != NULL) {
             // @todo What to do with the GCU port?
             readDelay = 0.0;
         } else {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, "Unsupported port type.");
         }
  
         const TTAMachine::Port& destinationPort = path.destinationPort();
  
         if (dynamic_cast<const TTAMachine::FUPort*>(&destinationPort) 
             != NULL) {
  
             const TTAMachine::FUPort& destinationFUPort = 
                 dynamic_cast<const TTAMachine::FUPort&>(destinationPort);
             
             const TTAMachine::FunctionUnit& fu = 
                 *destinationFUPort.parentUnit();
  
             if (dynamic_cast<const TTAMachine::ControlUnit*>(&fu) != NULL) {
                 // @todo gcu port
                 writeDelay = 0.0;
             } else if (!machineImplementation.hasFUImplementation(fu.name())) {
                 throw CannotEstimateCost(
                     __FILE__, __LINE__, __func__, 
                     (boost::format(
                         "Implementation information missing for function "
                         "unit '%s'.") % fu.name()).str());
             } else {
                 // write delay
                 writeDelay = functionUnitPortWriteDelay( 
                     destinationFUPort, machineImplementation.fuImplementation(
                         fu.name()));
             }
         } else if (dynamic_cast<const TTAMachine::RFPort*>(&destinationPort) 
                    != NULL) {
             const TTAMachine::RFPort& destinationRFPort = 
                 dynamic_cast<const TTAMachine::RFPort&>(destinationPort);
  
             const TTAMachine::BaseRegisterFile& rf = 
                 *destinationRFPort.parentUnit();
             if (!machineImplementation.hasRFImplementation(rf.name())) {
                 throw CannotEstimateCost(
                     __FILE__, __LINE__, __func__, 
                     (boost::format(
                         "Implementation information missing for register file "
                         "'%s'.") % rf.name()).str());
             }
  
             // write delay
             writeDelay += registerFilePortWriteDelay( 
                 destinationRFPort, machineImplementation.rfImplementation(
                     rf.name()));
         } else if (dynamic_cast<const TTAMachine::BaseFUPort*>(
                        &destinationPort) != NULL) {
             // @todo What to do with the GCU port?
             writeDelay = 0.0;
         } else {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, "Unsupported port type.");
         }
         
  
         if (!machineImplementation.hasICDecoderPluginName() ||
             !machineImplementation.hasICDecoderPluginFile() ||
             !machineImplementation.hasICDecoderHDB()) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 "Missing IC&decoder plugin information.");
         }        
  
         // Find out if there are idf entries to sockets and bus
  
         IDF::SocketImplementationLocation* sourceSocketImplementation = NULL;
         if (!machineImplementation.hasSocketImplementation(
                 path.sourceSocket().name())) {
             sourceSocketImplementation = 
                 &IDF::NullUnitImplementationLocation::instance();
         } else {
             sourceSocketImplementation =
                 &machineImplementation.socketImplementation(
                     path.sourceSocket().name());
         }
         IDF::SocketImplementationLocation* destinationSocketImplementation =
             NULL;
         if (!machineImplementation.hasSocketImplementation(
                 path.destinationSocket().name())) {
             destinationSocketImplementation = 
                 &IDF::NullUnitImplementationLocation::instance();
         } else {
             destinationSocketImplementation =
                 &machineImplementation.socketImplementation(
                     path.destinationSocket().name());
         }
         IDF::BusImplementationLocation* busImplementation = NULL;
         if (!machineImplementation.hasBusImplementation(path.bus().name())) {
             busImplementation = 
                 &IDF::NullUnitImplementationLocation::instance();
         } else {
             busImplementation = 
                 &machineImplementation.busImplementation(path.bus().name());
         }
  
         // calculate the socket->bus->socket part by using a ICDecoder plugin
         busDelay = 
             estimateSocketToSocketDelayOfPath(
                 machineImplementation.icDecoderPluginFile(), 
                 machineImplementation.icDecoderPluginName(),
                 path,
                 machineImplementation,
                 *sourceSocketImplementation,
                 *busImplementation,
                 *destinationSocketImplementation);
  
         // the total delay of the path
         pathDelay = readDelay + busDelay + writeDelay;
  
         maximumICDelay = std::max(maximumICDelay, pathDelay);
  
 #ifdef LONGEST_PATH_DEBUGGING
         const TTAMachine::Bus& bus = path.bus();
         Application::logStream() 
             << sourcePort.parentUnit()->name() << "::" 
             << sourcePort.name() << " (" << readDelay << "), " 
             << bus.name() << " (" << busDelay << "), "
             << destinationPort.parentUnit()->name() << "::" 
             << destinationPort.name() << " (" << writeDelay << ") = "
             << pathDelay << std::endl;
 #endif
     } // end of a for statement to calculate delays for all paths
  
     // find out if the longest path is in a function unit
     DelayInNanoSeconds maximumFUDelay = 0.0;
  
     // go through all function units and compute the computation delays
     // for all of them and store the largest found delay
     TTAMachine::Machine::FunctionUnitNavigator fuNav = 
         machine.functionUnitNavigator();
     for (int i = 0; i < fuNav.count(); ++i) {
         const TTAMachine::FunctionUnit& fu = *fuNav.item(i);
  
         if (!machineImplementation.hasFUImplementation(fu.name())) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "Implementation information missing for function unit "
                     "'%s'.") % fu.name()).str());
         }
         DelayInNanoSeconds delay = 
             functionUnitMaximumComputationDelay(
                 fu, machineImplementation.fuImplementation(fu.name()));
         maximumFUDelay = std::max(maximumFUDelay, delay);
  
 #ifdef LONGEST_PATH_DEBUGGING
         Application::logStream()
             << "maximum computation delay of " << fu.name() << " = " 
             << delay << " ns" << std::endl;
 #endif
     }
  
     // GCU not treated as a regular FU
     // GCU should be estimated with icdecoder
     /*
     const TTAMachine::FunctionUnit& gcu = *machine.controlUnit();
  
     if (!machineImplementation.hasFUImplementation(gcu.name())) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__, 
             (boost::format(
                 "Implementation information missing for function unit "
                 "'%s'.") % gcu.name()).str());
     }
  
     DelayInNanoSeconds delay = 
         functionUnitMaximumComputationDelay(
             gcu, machineImplementation.fuImplementation(gcu.name()));
         
     maximumFUDelay = std::max(maximumFUDelay, delay);
     
 #ifdef LONGEST_PATH_DEBUGGING
     Application::logStream()
         << "maximum computation delay of " << gcu.name() << " (GCU) = " 
         << delay << " ns" << std::endl;
 #endif
     */
     // find out if the longest path is in a register file
     DelayInNanoSeconds maximumRFDelay = 0.0;
  
     // go through all register files and compute the computation delays
     // for all of them and store the maximum of the calculated delay
     TTAMachine::Machine::RegisterFileNavigator rfNav = 
         machine.registerFileNavigator();
     for (int i = 0; i < rfNav.count(); ++i) {
         const TTAMachine::BaseRegisterFile& rf = *rfNav.item(i);
  
         if (!machineImplementation.hasRFImplementation(rf.name())) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "Implementation information missing for register file "
                     "'%s'.") % rf.name()).str());
         }
  
         DelayInNanoSeconds delay = 
             registerFileMaximumComputationDelay(
                 rf, machineImplementation.rfImplementation(rf.name()));
         
         maximumRFDelay = std::max(maximumRFDelay, delay);
  
 #ifdef LONGEST_PATH_DEBUGGING
     Application::logStream()
         << "maximum computation delay of " << rf.name() << " = " 
         << delay << " ns" << std::endl;
 #endif
     }
        
     delete icPaths;
     icPaths = NULL;
  
     return std::max(maximumICDelay, std::max(maximumFUDelay, maximumRFDelay));
 }

Referenced by ImmediateGenerator::explore(), and main().

Here is the call graph for this function:

◆ registerFileArea()

AreaInGates CostEstimator::Estimator::registerFileArea	(	const TTAMachine::BaseRegisterFile &	architecture,
		const IDF::RFImplementationLocation &	implementationEntry
	)

Estimates the area of the given register file.

Parameters

architecture	The RF architecture of which area to estimate.
implementationEntry	The implementation information of RF. Can be an instance of NullRFImplementationLocation.

Exceptions

CannotEstimateCost In case the area could not be estimated.

Returns: Estimate of area.

Definition at line 398 of file Estimator.cc.

                                                             {
     try {
         AreaInGates area = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!rfCostFunctionPluginOfImplementation(implementationEntry).
             estimateArea(architecture, implementationEntry, area, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string("Plugin was unable to estimate area."));
         }
         return area;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string("Unable to estimate area of register file '") +
             architecture.name() + "'. " + e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ registerFileEnergy()

EnergyInMilliJoules CostEstimator::Estimator::registerFileEnergy	(	const TTAMachine::BaseRegisterFile &	architecture,
		const IDF::RFImplementationLocation &	implementationEntry,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Estimates the energy consumed by the given register file when running the given program.

Parameters

architecture	The RF architecture of which area to estimate.
implementationEntry	The implementation information of RF. Can be an instance of NullRFImplementationLocation.
program	The program of which energy to calculate.
traceDB	The simulation trace database of the program running in the target architecture.

Returns: Estimate of consumed energy.

Exceptions

CannotEstimateCost In case the energy could not be estimated.

Definition at line 551 of file Estimator.cc.

                                                                      {
     try {
         AreaInGates area = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!rfCostFunctionPluginOfImplementation(implementationEntry).
             estimateEnergy(
                 architecture, implementationEntry, program, traceDB, area,
                 hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string("Plugin was unable to estimate energy."));
         }
         return area;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string("Unable to estimate energy of register file '") +
             architecture.name() + "'. " + e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Component::name(), and program.

Here is the call graph for this function:

◆ registerFileMaximumComputationDelay()

DelayInNanoSeconds CostEstimator::Estimator::registerFileMaximumComputationDelay	(	const TTAMachine::BaseRegisterFile &	architecture,
		const IDF::RFImplementationLocation &	implementationEntry
	)

Estimates the maximum computation delay of the given register file.

The maximum computation delay is the longest stage in a RF's execution. It's used mainly for calculating the maximum clock frequency of target architecture.

Parameters

architecture	The RF architecture of which area to estimate.
implementationEntry	The implementation information of RF.

Exceptions

CannotEstimateCost In case the computation delay could not be estimated.

Returns: Estimate of computation delay of the given RF.

Definition at line 876 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!rfCostFunctionPluginOfImplementation(implementationEntry).
             estimateMaximumComputationDelay(
                 architecture, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 std::string(
                     "Plugin was unable to estimate computation delay of RF ") +
                 architecture.name());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Computation delay estimation could not be done for the given "
                 "register file entry. ") +
             e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ registerFilePortReadDelay()

DelayInNanoSeconds CostEstimator::Estimator::registerFilePortReadDelay	(	const TTAMachine::RFPort &	port,
		const IDF::RFImplementationLocation &	implementationEntry
	)

Estimates the output delay of the given register file port.

Parameters

port	The RF port of which output delay to estimate.
implementationEntry	The implementation information of RF.

Exceptions

CannotEstimateCost In case the output delay could not be estimated.

Returns: Estimate of output delay of the given RF.

Definition at line 793 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!rfCostFunctionPluginOfImplementation(implementationEntry).
             estimatePortReadDelay(port, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 (boost::format(
                     "Plugin was unable to estimate output delay of port "
                     "%s::%s.") % port.parentUnit()->name() % port.name()).
                 str());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Output delay estimation could not be done for the given "
                 "register file entry. ") + e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Port::name(), TTAMachine::Component::name(), and TTAMachine::RFPort::parentUnit().

Here is the call graph for this function:

◆ registerFilePortWriteDelay()

DelayInNanoSeconds CostEstimator::Estimator::registerFilePortWriteDelay	(	const TTAMachine::RFPort &	port,
		const IDF::RFImplementationLocation &	implementationEntry
	)

Estimates the input delay of the given register file port.

Parameters

port	The RF port of which input delay to estimate.
implementationEntry	The implementation information of the RF the port belongs to.

Exceptions

CannotEstimateCost In case the input delay could not be estimated.

Returns: Estimate of input delay of the given RF port.

Definition at line 756 of file Estimator.cc.

                                                             {
     try {
         DelayInNanoSeconds delay = 0.0;
         HDB::HDBManager& hdb = HDBRegistry::instance().hdb(
             implementationEntry.hdbFile());
         if (!rfCostFunctionPluginOfImplementation(implementationEntry).
             estimatePortWriteDelay(port, implementationEntry, delay, hdb)) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__,
                 (boost::format(
                     "Plugin was unable to estimate input delay of port "
                     "%s::%s.") % port.parentUnit()->name() % port.name()).
                 str());
         }
         return delay;
     } catch (const Exception& e) {
         throw CannotEstimateCost(
             __FILE__, __LINE__, __func__,
             std::string(
                 "Input delay estimation could not be done for a "
                 "register file entry. ") + e.errorMessage());
     }
     return 0.0;
 }

References __func__, Exception::errorMessage(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), HDB::HDBRegistry::instance(), TTAMachine::Port::name(), TTAMachine::Component::name(), and TTAMachine::RFPort::parentUnit().

Here is the call graph for this function:

◆ rfCostFunctionPluginOfImplementation()

RFCostEstimationPlugin & CostEstimator::Estimator::rfCostFunctionPluginOfImplementation ( const IDF::RFImplementationLocation & implementationEntry )

private

Loads a RF cost estimation plugin for the given RF implementation.

Parameters

implementationEntry The implementation of the RF.

Returns: The plugin.

Exceptions

Exception In case the plugin was not found or could not be loaded.

Definition at line 312 of file Estimator.cc.

                                                             {
     std::string pluginFileName = "";
     std::string pluginName = "";
     HDB::HDBManager* theHDB = NULL;
     try {
         // use the HDB to find the estimation plugin from the plugin
         // registry
         theHDB = &HDBRegistry::instance().hdb(implementationEntry.hdbFile());
         HDB::RFEntry* rfEntry = theHDB->rfByEntryID(implementationEntry.id());
  
         if (rfEntry == NULL || !rfEntry->hasCostFunction()) {
             delete rfEntry;
             rfEntry = NULL;
             throw Exception(
                 __FILE__, __LINE__, __func__, 
                 (boost::format(
                     "Register file entry %d does not have cost "
                     "estimation plugin set.") % implementationEntry.id()).str());
         }
  
         HDB::CostFunctionPlugin& pluginData = rfEntry->costFunction();
         pluginFileName = pluginData.pluginFilePath();
         pluginName = pluginData.name();
  
         try {
             return rfEstimatorPluginRegistry_.plugin(
                 pluginFileName, pluginName);
         } catch (const Exception& e) {
             throw CannotEstimateCost(
                 __FILE__, __LINE__, __func__, 
                 std::string("Unable to open RF estimation plugin '") + 
                 pluginFileName + "'. " + e.errorMessage());
         }
     } catch (const Exception& e) {
         throw Exception(
             __FILE__, __LINE__, __func__, e.errorMessage());
     }
     // avoid warnings with some compilers
     throw 1;
 }

References __func__, HDB::HDBEntry::costFunction(), Exception::errorMessage(), HDB::HDBEntry::hasCostFunction(), HDB::HDBRegistry::hdb(), IDF::UnitImplementationLocation::hdbFile(), IDF::UnitImplementationLocation::id(), HDB::HDBRegistry::instance(), HDB::CostFunctionPlugin::name(), HDB::CostFunctionPlugin::pluginFilePath(), and HDB::HDBManager::rfByEntryID().

Here is the call graph for this function:

◆ totalArea()

AreaInGates CostEstimator::Estimator::totalArea	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

area estimation functions

Estimates the total area of given machine.

Area estimate is calculated as a sum of areas of different machine parts.

Parameters

machine	The machine architecture to estimate.
machineImplementation	The machine implementation information.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 84 of file Estimator.cc.

                                                            {
     return totalAreaOfFunctionUnits(machine, machineImplementation) +
         totalAreaOfRegisterFiles(machine, machineImplementation) +
         icArea(machine, machineImplementation);
 }

References machine.

Referenced by ImmediateGenerator::explore(), and main().

◆ totalAreaOfFunctionUnits()

AreaInGates CostEstimator::Estimator::totalAreaOfFunctionUnits	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

Estimates the total area of all function units in the given machine.

GCU is not treated as an FU. It should be estimated as a part of IC.

Parameters

machine	The machine architecture to estimate.
machineImplementation	The machine implementation information.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 103 of file Estimator.cc.

                                                            {
     AreaInGates total = 0.0;
     TTAMachine::Machine::FunctionUnitNavigator nav = 
         machine.functionUnitNavigator();
     for (int i = 0; i < nav.count(); ++i) {
         TTAMachine::FunctionUnit* fuArchitecture = nav.item(i);
         IDF::FUImplementationLocation* fuImplementation = 
             &IDF::NullFUImplementationLocation::instance();
         
         if (machineImplementation.hasFUImplementation(
                 fuArchitecture->name())) {
             fuImplementation = &machineImplementation.fuImplementation(
                 fuArchitecture->name());
         }
  
         CostEstimator::AreaInGates areaFU = 
             functionUnitArea(*fuArchitecture, *fuImplementation);
         total += areaFU;
  
         if (areaFU <= 0) {
             Application::warningStream() 
                 << "Warning: gate count of FU '"
                 << fuArchitecture->name() << "' was estimated as " 
                 << areaFU << std::endl;
         } else if (Application::verboseLevel() > 0) {
             Application::logStream() 
                 << "FU '" << fuArchitecture->name() 
                 << "' contributes " << areaFU << " gates" << std::endl;
         }
     }
     // GCU is not included in the MOM FU navigator, so we have to treat it
     // separately
     // GCU should be estimated as a part of IC.
     /*
     TTAMachine::FunctionUnit* fuArchitecture = machine.controlUnit();
     IDF::FUImplementationLocation* fuImplementation = 
         &IDF::NullFUImplementationLocation::instance();
  
     if (machineImplementation.hasFUImplementation(
             fuArchitecture->name())) {
         fuImplementation = &machineImplementation.fuImplementation(
             fuArchitecture->name());
     }
     total += functionUnitArea(*fuArchitecture, *fuImplementation);
     */
     return total;
 }

References TTAMachine::Machine::Navigator< ComponentType >::count(), IDF::MachineImplementation::fuImplementation(), TTAMachine::Machine::functionUnitNavigator(), IDF::MachineImplementation::hasFUImplementation(), IDF::NullUnitImplementationLocation::instance(), TTAMachine::Machine::Navigator< ComponentType >::item(), Application::logStream(), machine, TTAMachine::Component::name(), Application::verboseLevel(), and Application::warningStream().

Here is the call graph for this function:

◆ totalAreaOfRegisterFiles()

AreaInGates CostEstimator::Estimator::totalAreaOfRegisterFiles	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation
	)

Estimates the total area of all register files in the given machine.

Parameters

machine	The machine architecture to estimate.
machineImplementation	The machine implementation information.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 162 of file Estimator.cc.

                                                            {
     AreaInGates total = 0.0;
     TTAMachine::Machine::RegisterFileNavigator nav = 
         machine.registerFileNavigator();
     for (int i = 0; i < nav.count(); ++i) {
         TTAMachine::BaseRegisterFile* rfArchitecture = nav.item(i);
         IDF::RFImplementationLocation* rfImplementation = 
             &IDF::NullRFImplementationLocation::instance();
  
         if (machineImplementation.hasRFImplementation(
                 rfArchitecture->name())) {
             rfImplementation = &machineImplementation.rfImplementation(
                 rfArchitecture->name());
         }
  
         CostEstimator::AreaInGates areaRF = 
             registerFileArea(*rfArchitecture, *rfImplementation);
         total += areaRF;
  
         if (areaRF <= 0) {
             Application::warningStream() 
                 << "Warning: gate count of RF '"
                 << rfArchitecture->name() << "' was estimated as " 
                 << areaRF << std::endl;
         } else if (Application::verboseLevel() > 0) {
             Application::logStream() 
                 << "RF '" << rfArchitecture->name()
                 << "' contributes " << areaRF << " gates" << std::endl;
         }
     }
     return total;
 }

References TTAMachine::Machine::Navigator< ComponentType >::count(), IDF::MachineImplementation::hasRFImplementation(), IDF::NullUnitImplementationLocation::instance(), TTAMachine::Machine::Navigator< ComponentType >::item(), Application::logStream(), machine, TTAMachine::Component::name(), TTAMachine::Machine::registerFileNavigator(), IDF::MachineImplementation::rfImplementation(), Application::verboseLevel(), and Application::warningStream().

Here is the call graph for this function:

◆ totalEnergy()

EnergyInMilliJoules CostEstimator::Estimator::totalEnergy	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

energy estimation functions

Estimates the total energy consumed by the given processor running the given program.

Parameters

machine	Architecture of the processor.
machineImplementation	Implementation information of the processor.
traceDB	The execution trace database obtained from simulating the program.

Returns: Energy in milli joules.

Exceptions

CannotEstimateCost If the energy could not be estimated.

Definition at line 433 of file Estimator.cc.

                                                                      {
     return totalEnergyOfFunctionUnits(
         machine, machineImplementation, program, traceDB) +
         totalEnergyOfRegisterFiles(
             machine, machineImplementation, program, traceDB) +
         icEnergy(machine, machineImplementation, program, traceDB);
 }

References machine, and program.

Referenced by main().

◆ totalEnergyOfFunctionUnits()

EnergyInMilliJoules CostEstimator::Estimator::totalEnergyOfFunctionUnits	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Estimates the total energy consumed by all function units in the machine (GCU not included).

Energy estimate is calculated as a sum of consumed energies of all FUs.

Parameters

machine	The machine architecture to estimate.
machineImplementation	The machine implementation information.
program	The program of which energy to calculate.
traceDB	The simulation trace database of the program running in the target architecture.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 592 of file Estimator.cc.

                                                                      {
     EnergyInMilliJoules total = 0.0;
     TTAMachine::Machine::FunctionUnitNavigator nav = 
         machine.functionUnitNavigator();
     for (int i = 0; i < nav.count(); ++i) {
         TTAMachine::FunctionUnit* fuArchitecture = nav.item(i);
         IDF::FUImplementationLocation* fuImplementation = 
             &IDF::NullFUImplementationLocation::instance();
  
         if (machineImplementation.hasFUImplementation(
                 fuArchitecture->name())) {
             fuImplementation = &machineImplementation.fuImplementation(
                 fuArchitecture->name());
         }
         total += functionUnitEnergy(
             *fuArchitecture, *fuImplementation, program, traceDB);
     }
     // GCU is not included in the MOM FU navigation, so we have to treat it
     // separately
     // GCU should be estimated by icdecoder
     /*
     TTAMachine::FunctionUnit* fuArchitecture = machine.controlUnit();
     IDF::FUImplementationLocation* fuImplementation = 
         &IDF::NullFUImplementationLocation::instance();
  
     if (machineImplementation.hasFUImplementation(
             fuArchitecture->name())) {
         fuImplementation = &machineImplementation.fuImplementation(
             fuArchitecture->name());
     }
     total += functionUnitEnergy(
         *fuArchitecture, *fuImplementation, program, traceDB);
     */
     return total;
 }

References TTAMachine::Machine::Navigator< ComponentType >::count(), IDF::MachineImplementation::fuImplementation(), TTAMachine::Machine::functionUnitNavigator(), IDF::MachineImplementation::hasFUImplementation(), IDF::NullUnitImplementationLocation::instance(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, TTAMachine::Component::name(), and program.

Here is the call graph for this function:

◆ totalEnergyOfRegisterFiles()

EnergyInMilliJoules CostEstimator::Estimator::totalEnergyOfRegisterFiles	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	machineImplementation,
		const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Estimates the total energy consumed by all register files in the machine.

Energy estimate is calculated as a sum of energies of RFs.

Parameters

machine	The machine architecture to estimate.
machineImplementation	The machine implementation information.
program	The program of which energy to calculate.
traceDB	The simulation trace database of the program running in the target architecture.

Exceptions

CannotEstimateCost In case cost cannot be estimated for some reason. Reason is given in error message.

Definition at line 645 of file Estimator.cc.

                                                                      {
     EnergyInMilliJoules total = 0.0;
     TTAMachine::Machine::RegisterFileNavigator nav = 
         machine.registerFileNavigator();
     for (int i = 0; i < nav.count(); ++i) {
         TTAMachine::BaseRegisterFile* rfArchitecture = nav.item(i);
         IDF::RFImplementationLocation* rfImplementation = 
             &IDF::NullRFImplementationLocation::instance();
  
         if (machineImplementation.hasRFImplementation(
                 rfArchitecture->name())) {
             rfImplementation = &machineImplementation.rfImplementation(
                 rfArchitecture->name());
         }
         total += registerFileEnergy(
             *rfArchitecture, *rfImplementation, program, traceDB);
     }
     return total;
 }

References TTAMachine::Machine::Navigator< ComponentType >::count(), IDF::MachineImplementation::hasRFImplementation(), IDF::NullUnitImplementationLocation::instance(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, TTAMachine::Component::name(), program, TTAMachine::Machine::registerFileNavigator(), and IDF::MachineImplementation::rfImplementation().

Here is the call graph for this function:

Member Data Documentation

◆ fuEstimatorPluginRegistry_

FUCostEstimationPluginRegistry CostEstimator::Estimator::fuEstimatorPluginRegistry_

private

all accessed FU estimation plugins are stored in this registry

Definition at line 202 of file Estimator.hh.

◆ icDecoderEstimatorPluginRegistry_

ICDecoderCostEstimationPluginRegistry CostEstimator::Estimator::icDecoderEstimatorPluginRegistry_

private

all accessed IC&decoder plugins are stored in this registry

Definition at line 206 of file Estimator.hh.

◆ rfEstimatorPluginRegistry_

RFCostEstimationPluginRegistry CostEstimator::Estimator::rfEstimatorPluginRegistry_

private

all accessed RF estimation plugins are stored in this registry

Definition at line 204 of file Estimator.hh.

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Estimator()

◆ ~Estimator()

Member Function Documentation

◆ decompressorDelay()

◆ estimateSocketToSocketDelayOfPath()

◆ findAllICPaths()

◆ fuCostFunctionPluginOfImplementation()

◆ functionUnitArea()

◆ functionUnitEnergy()

◆ functionUnitMaximumComputationDelay()

◆ functionUnitPortReadDelay()

◆ functionUnitPortWriteDelay()

◆ icArea()

◆ icEnergy()

◆ longestPath()

◆ registerFileArea()

◆ registerFileEnergy()

◆ registerFileMaximumComputationDelay()

◆ registerFilePortReadDelay()

◆ registerFilePortWriteDelay()

◆ rfCostFunctionPluginOfImplementation()

◆ totalArea()

◆ totalAreaOfFunctionUnits()

◆ totalAreaOfRegisterFiles()

◆ totalEnergy()

◆ totalEnergyOfFunctionUnits()

◆ totalEnergyOfRegisterFiles()

Member Data Documentation

◆ fuEstimatorPluginRegistry_

◆ icDecoderEstimatorPluginRegistry_

◆ rfEstimatorPluginRegistry_