Inheritance diagram for InterpolatingFUEstimator:

Collaboration diagram for InterpolatingFUEstimator:

Public Member Functions
	InterpolatingFUEstimator (const std::string &name)

virtual	~InterpolatingFUEstimator ()

	DESCRIPTION ("FU cost estimator plugin that estimates costs of FUs by generating" "cost database from cost values of HDB and uses interpolation to " "estimate the costs. In case there's no cost data available for the " "given FU the plugin interpolates the estimate if possible.")

bool	estimateArea (const TTAMachine::FunctionUnit &fu, const IDF::FUImplementationLocation &, AreaInGates &area, HDB::HDBManager &hdb)

bool	estimatePortWriteDelay (const TTAMachine::FUPort &port, const IDF::FUImplementationLocation &, DelayInNanoSeconds &delay, HDB::HDBManager &hdb)

bool	estimatePortReadDelay (const TTAMachine::FUPort &port, const IDF::FUImplementationLocation &, DelayInNanoSeconds &delay, HDB::HDBManager &hdb)

bool	estimateMaximumComputationDelay (const TTAMachine::FunctionUnit &fu, const IDF::FUImplementationLocation &, DelayInNanoSeconds &delay, HDB::HDBManager &hdb)

virtual bool	estimateEnergy (const TTAMachine::FunctionUnit &fu, const IDF::FUImplementationLocation &implementation, const TTAProgram::Program &, const ExecutionTrace &trace, EnergyInMilliJoules &energy, HDB::HDBManager &hdb)

Public Member Functions inherited from CostEstimator::FUCostEstimationPlugin
	FUCostEstimationPlugin (const std::string &name)

virtual	~FUCostEstimationPlugin ()

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::map< const EntryKeyProperty *, CostDBTypes::MatchTypeTable >	MatchTypeMap
	Search type for each entry type.

Private Member Functions
void	initializeEstimator (const HDBManager &hdb)

void	createSearchTypes ()

CostDBTypes::EntryTable	createSearch (const FunctionUnit &fu) const

Private Attributes
CostDatabaseRegistry *	costDatabaseRegistry_
	Registry of cost databases.

CostDatabase *	costdb_
	Cost database being used.

SearchStrategy *	strategy_
	Search strategy to be used with the cost database.

EntryKeyProperty *	unitProperty_
	Entry key property of function unit.

MatchTypeMap	searchTypes_
	Types of matches used for searching entries from the cost database.

CostDBTypes::MatchTypeTable	unitMatchType_
	Table of types of match.

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

Definition at line 62 of file InterpolatingFUEstimator.cc.

Member Typedef Documentation

◆ MatchTypeMap

typedef std::map< const EntryKeyProperty*, CostDBTypes::MatchTypeTable> InterpolatingFUEstimator::MatchTypeMap

private

Search type for each entry type.

Definition at line 408 of file InterpolatingFUEstimator.cc.

Constructor & Destructor Documentation

◆ InterpolatingFUEstimator()

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

inline

Definition at line 64 of file InterpolatingFUEstimator.cc.

                                                    :
        FUCostEstimationPlugin(name) {
        costDatabaseRegistry_ = &CostDatabaseRegistry::instance();
    }

References costDatabaseRegistry_, and CostDatabaseRegistry::instance().

Here is the call graph for this function:

◆ ~InterpolatingFUEstimator()

virtual InterpolatingFUEstimator::~InterpolatingFUEstimator ( )

inlinevirtual

Definition at line 69 of file InterpolatingFUEstimator.cc.

69 {

70 }

Member Function Documentation

◆ createSearch()

CostDBTypes::EntryTable InterpolatingFUEstimator::createSearch ( const FunctionUnit & fu ) const

inlineprivate

Creates a search to cost database to find entries matching the given function unit.

Parameters

fu	Function unit which matches are searched.

Returns: Returns entries that matched the function unit.

Definition at line 453 of file InterpolatingFUEstimator.cc.

                                                                 {
 
    CostDBTypes::EntryTable results;
    int ports = fu.operationPortCount();
    int width = 0;
    for (int n = 0; n < ports; n++) {
        BaseFUPort* port = fu.port(n);
        if (dynamic_cast<FUPort*>(port) != NULL) {
            FUPort* fuPort = dynamic_cast<FUPort*>(port);
            if (width == 0) {
                width = fuPort->width();
            } else if (width != fuPort->width()) {
                return results;
            }
        }
    }
    CostDBEntryKey* searchKey = new CostDBEntryKey(unitProperty_);  
    searchKey->addField(
        new EntryKeyField(
            new EntryKeyDataInt(width),
            unitProperty_->fieldProperty(CostDBTypes::EKF_BIT_WIDTH)));
    searchKey->addField(
        new EntryKeyField(
            new EntryKeyDataFunctionUnit(&fu),
            unitProperty_->fieldProperty(CostDBTypes::EKF_FUNCTION_UNIT)));
    // Perform a database query.
    try {
        results = costdb_->search(*searchKey, unitMatchType_);
    } catch (Exception& e) {
        // no results
        delete searchKey;
        searchKey = 0;
        throw e;
    }
    delete searchKey;
    searchKey = 0;
 
    return results;
}

References CostDBEntryKey::addField(), costdb_, CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_FUNCTION_UNIT, EntryKeyProperty::fieldProperty(), TTAMachine::FunctionUnit::operationPortCount(), TTAMachine::FunctionUnit::port(), CostDatabase::search(), unitMatchType_, unitProperty_, and TTAMachine::BaseFUPort::width().

Referenced by estimateArea(), estimateEnergy(), estimateMaximumComputationDelay(), estimatePortReadDelay(), and estimatePortWriteDelay().

Here is the call graph for this function:

◆ createSearchTypes()

void InterpolatingFUEstimator::createSearchTypes ( )

inlineprivate

Creates types of matches used for searching cost database entries.

Definition at line 434 of file InterpolatingFUEstimator.cc.

                         {
    
    unitMatchType_.push_back(
        new MatchType(
            unitProperty_->fieldProperty(CostDBTypes::EKF_BIT_WIDTH),
            CostDBTypes::MATCH_INTERPOLATION));
    unitMatchType_.push_back(
        new MatchType(
            unitProperty_->fieldProperty(CostDBTypes::EKF_FUNCTION_UNIT),
            CostDBTypes::MATCH_EXACT));
}

References CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_FUNCTION_UNIT, EntryKeyProperty::fieldProperty(), CostDBTypes::MATCH_EXACT, CostDBTypes::MATCH_INTERPOLATION, unitMatchType_, and unitProperty_.

Referenced by initializeEstimator().

Here is the call graph for this function:

◆ DESCRIPTION()

InterpolatingFUEstimator::DESCRIPTION ( "FU cost estimator plugin that estimates costs of FUs by generating" "cost database from cost values of HDB and uses interpolation to " "estimate the costs. In case there's no cost data available for the " "given FU the plugin interpolates the estimate if possible." )

◆ estimateArea()

bool InterpolatingFUEstimator::estimateArea	(	const TTAMachine::FunctionUnit &	fu,
		const IDF::FUImplementationLocation &	,
		AreaInGates &	area,
		HDB::HDBManager &	hdb
	)

inlinevirtual

Estimates the function unit's area by fetching cost data named 'area' from HDB.

Reimplemented from CostEstimator::FUCostEstimationPlugin.

Definition at line 84 of file InterpolatingFUEstimator.cc.

                            {
 
//#define DEBUG_AREA_ESTIMATION
        try {
            initializeEstimator(hdb);
            CostDBTypes::EntryTable results = createSearch(fu);
            CostDBTypes::EntryTable::const_iterator i = results.begin();
            area = 0.0;
            // worst case area is returned
            for (;i < results.end(); i++) {
                for (int n = 0; n < (*i)->statisticsCount(); n++) {
                    if (area < (*i)->statistics(n).area()) {
                        area = (*i)->statistics(n).area();
                    }
                }
            }
        } catch (Exception& e) {
            return false;
        }
#ifdef DEBUG_AREA_ESTIMATION
        Application::logStream() 
            << fu.name() << " area " << area << std::endl;
#endif
        return true;
    }    

References createSearch(), initializeEstimator(), Application::logStream(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ estimateEnergy()

virtual bool InterpolatingFUEstimator::estimateEnergy	(	const TTAMachine::FunctionUnit &	fu,
		const IDF::FUImplementationLocation &	implementation,
		const TTAProgram::Program &	,
		const ExecutionTrace &	trace,
		EnergyInMilliJoules &	energy,
		HDB::HDBManager &	hdb
	)

inlinevirtual

Estimates the energy consumed by given FU.

Estimate is done by computing the sum of all operation execution energies and FU idle energy. Operation execution energies are stored with entries named 'operation_execution_energy operation_name'. The idle energy is in entry named 'fu_idle_energy'.

Reimplemented from CostEstimator::FUCostEstimationPlugin.

Definition at line 263 of file InterpolatingFUEstimator.cc.

                            {
 
//#define DEBUG_ENERGY_ESTIMATION
        try {
            initializeEstimator(hdb);
            CostDBTypes::EntryTable results = createSearch(fu);
 
            energy = 0.0;
            ClockCycleCount cyclesWithFUAccess = 0;
#ifdef DEBUG_ENERGY_ESTIMATION        
            Application::logStream() 
                << "## function unit " << fu.name() << ": " << std::endl;
#endif
            ExecutionTrace::FUOperationTriggerCountList* operationTriggers =
                trace.functionUnitOperationTriggerCounts(fu.name());
            for (ExecutionTrace::FUOperationTriggerCountList::
                     const_iterator i = operationTriggers->begin(); 
                 i != operationTriggers->end(); ++i) {
 
                const ExecutionTrace::FUOperationTriggerCount& triggerCount = 
                    *i;
 
                const ExecutionTrace::OperationID operation = 
                    StringTools::stringToLower(triggerCount.get<0>());
 
                const ExecutionTrace::OperationTriggerCount count = 
                    triggerCount.get<1>();
 
                const std::string dataName = 
                    std::string("operation_execution_energy ") + operation;
 
                try {
                    CostDBTypes::EntryTable::const_iterator i = results.begin();
                    for (;i < results.end(); i++) {
 
                        // in case there are multiple operation execution
                        // energies, select the worst case in the result
                        // @todo ensure that multiple results is not a bug
                        EnergyInMilliJoules tempEnergy = 0.0;
                        for (int n = 0; n < (*i)->statisticsCount(); n++) {
                            if (((*i)->statistics(n).energyOperation(
                                     operation) * count) > tempEnergy) {
 
                                tempEnergy += 
                                    (*i)->statistics(n).energyOperation(
                                        operation) * count;
                            }
#ifdef DEBUG_ENERGY_ESTIMATION
                            if (n > 0) {
                                Application::logStream() 
                                    << " NOTE: Multiple fu execution energy"
                                    <<  " results found!"
                                    << " operation: " << operation
                                    << " " 
                                    << (*i)->statistics(n).energyOperation(
                                        operation)
                                    << std::endl;
                            }
#endif
                        }
                        energy += tempEnergy;
                    }
                    cyclesWithFUAccess += count;
                } catch (const KeyNotFound&) {
                    // if no data found, don't even try to estimate the area
                    delete operationTriggers;
                    operationTriggers = NULL;
                    Application::logStream()
                        << "Cost estimation data '" << dataName 
                        << "' not found in HDB." << std::endl;
                    return false;
                } catch (const Exception& e) {
                    delete operationTriggers;
                    operationTriggers = NULL;
                    debugLog(e.errorMessage());
                    return false;
                }
                
            }
            delete operationTriggers;
            operationTriggers = NULL;
            
            // add the cost of FU idling
            const ClockCycleCount idleCycles = 
                trace.simulatedCycleCount() - cyclesWithFUAccess;
            const std::string dataName = std::string("fu_idle_energy");
            
            try {
                CostDBTypes::EntryTable::const_iterator i = results.begin();
                for (;i < results.end(); i++) {
 
                    // in case there are multiple fu idle energies,
                    // select the worst case in the result
                    // @todo ensure that multiple results is not a bug
                    EnergyInMilliJoules tempEnergy = 0.0;
                    for (int n = 0; n < (*i)->statisticsCount(); n++) {
                        if (((*i)->statistics(n).energyIdle() * idleCycles) >
                            tempEnergy) {
                            
                            tempEnergy = 
                                (*i)->statistics(n).energyIdle() * idleCycles;
                        }
#ifdef DEBUG_ENERGY_ESTIMATION
                        if (n > 0) {
                            Application::logStream() 
                                << " NOTE: Multiple fu idle energy results found!"
                                << (*i)->statistics(n).energyIdle()
                                << std::endl;
                        }
#endif
                    }
                    energy += tempEnergy;
                } 
            } catch (const KeyNotFound&) {
                // if no data found, don't even try to estimate the area
                Application::logStream()
                    << "Cost estimation data '" << dataName 
                    << "' for FU with id " << implementation.id() 
                    << " not found in HDB." << std::endl;
                return false;
            }
        } catch (const Exception& e) {
            debugLog(e.errorMessage());
            return false;
        }
            
        return true;
    }

References createSearch(), debugLog, Exception::errorMessage(), ExecutionTrace::functionUnitOperationTriggerCounts(), implementation, initializeEstimator(), Application::logStream(), TTAMachine::Component::name(), ExecutionTrace::simulatedCycleCount(), StringTools::stringToLower(), and trace.

Here is the call graph for this function:

◆ estimateMaximumComputationDelay()

bool InterpolatingFUEstimator::estimateMaximumComputationDelay	(	const TTAMachine::FunctionUnit &	fu,
		const IDF::FUImplementationLocation &	,
		DelayInNanoSeconds &	delay,
		HDB::HDBManager &	hdb
	)

inlinevirtual

Estimates the function unit maximum computation delay by fetching cost data named 'computation_delay' from HDB.

Reimplemented from CostEstimator::FUCostEstimationPlugin.

Definition at line 226 of file InterpolatingFUEstimator.cc.

                            {
 
//#define DEBUG_DELAY_ESTIMATION
        try {
            initializeEstimator(hdb);
            CostDBTypes::EntryTable results = createSearch(fu);            
            CostDBTypes::EntryTable::const_iterator i = results.begin();
            delay = 0.0;
            // the worst case is returned if found multiple results
            for (;i < results.end(); i++) {
                for (int n = 0; n < (*i)->statisticsCount(); n++) {
                    if (delay < (*i)->statistics(n).delay()) {
                        delay = (*i)->statistics(n).delay();
                    }
                }
            }
        } catch (Exception& e) {
            return false;
        }
#ifdef DEBUG_DELAY_ESTIMATION
        Application::logStream() 
            << fu.name() << " computation delay " << delay << std::endl;
#endif // DEBUG_DELAY_ESTIMATION
        return true;
    }  

References createSearch(), initializeEstimator(), Application::logStream(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ estimatePortReadDelay()

bool InterpolatingFUEstimator::estimatePortReadDelay	(	const TTAMachine::FUPort &	port,
		const IDF::FUImplementationLocation &	,
		DelayInNanoSeconds &	delay,
		HDB::HDBManager &	hdb
	)

inlinevirtual

Estimates the function unit port read delay by fetching cost data named 'output_delay' from HDB.

Assumes that all ports have the same output delay, that is, there is only one 'output_delay' entry for a FU in HDB.

Reimplemented from CostEstimator::FUCostEstimationPlugin.

Definition at line 177 of file InterpolatingFUEstimator.cc.

                            {
 
//#define DEBUG_DELAY_ESTIMATION
        try {
            initializeEstimator(hdb);
            CostDBTypes::EntryTable results = createSearch(*port.parentUnit());
            CostDBTypes::EntryTable::const_iterator i = results.begin();
            delay = 0.0;
            // worst case delay is returned
            for (;i < results.end(); i++) {
                for (int n = 0; n < (*i)->statisticsCount(); n++) {
#ifndef UNIQUE_PORT_DELAY
                    if (delay < (*i)->statistics(n).delayPort("output_delay")) {
                        delay = (*i)->statistics(n).delayPort("output_delay");
                    }
#endif // UNIQUE_PORT_DELAY
#ifdef UNIQUE_PORT_DELAY
                    // this one is used if defferent ports of an unit 
                    // can have different delays
                    if (delay < (*i)->statistics(n).delayPort(port.name())) {
                        delay = (*i)->statistics(n).delayPort(port.name());
                    }
#endif // UNIQUE_PORT_DELAY
                }
            }
        } catch (Exception& e) {
#ifdef DEBUG_DELAY_ESTIMATION
            Application::logStream() << "No input_delay data for function "
                                     << "unit " 
                                     << port.parentUnit()->name()
                                     << " found in HDB." << std::endl;
#endif // DEBUG_DELAY_ESTIMATION
            return false;
        }
#ifdef DEBUG_DELAY_ESTIMATION
        Application::logStream() 
            << port.name() << " (port) delay " << delay << std::endl;
#endif // DEBUG_DELAY_ESTIMATION
        return true;
    } 

References createSearch(), initializeEstimator(), Application::logStream(), TTAMachine::Component::name(), TTAMachine::Port::name(), and TTAMachine::BaseFUPort::parentUnit().

Here is the call graph for this function:

◆ estimatePortWriteDelay()

bool InterpolatingFUEstimator::estimatePortWriteDelay	(	const TTAMachine::FUPort &	port,
		const IDF::FUImplementationLocation &	,
		DelayInNanoSeconds &	delay,
		HDB::HDBManager &	hdb
	)

inlinevirtual

Estimates the function unit port write delay by fetching cost data named 'input_delay' from HDB.

Assumes that all ports have the same input delay, that is, there is only one 'input_delay' entry for a FU in HDB.

Reimplemented from CostEstimator::FUCostEstimationPlugin.

Definition at line 122 of file InterpolatingFUEstimator.cc.

                            {
 
//#define DEBUG_DELAY_ESTIMATION
 
        try {
            initializeEstimator(hdb);
            CostDBTypes::EntryTable results = createSearch(*port.parentUnit());
            
            CostDBTypes::EntryTable::const_iterator i = results.begin();
            delay = 0.0;
            // worst case delay is returned
            for (;i < results.end(); i++) {
                for (int n = 0; n < (*i)->statisticsCount(); n++) {
#ifndef UNIQUE_PORT_DELAY
                    if (delay < (*i)->statistics(n).delayPort("input_delay")) {
                        delay = (*i)->statistics(n).delayPort("input_delay");
                    }
#endif // UNIQUE_PORT_DELAY
#ifdef UNIQUE_PORT_DELAY
                    // this one is used if defferent ports of an unit 
                    // can have different delays
                    if (delay < (*i)->statistics(n).delayPort(port.name())) {
                        delay = (*i)->statistics(n).delayPort(port.name());
                    }
#endif // UNIQUE_PORT_DELAY
                }
            }
        } catch (Exception& e) {
#ifdef DEBUG_DELAY_ESTIMATION
            Application::logStream() << "No input_delay data for function "
                                     << "unit " 
                                     << port.parentUnit()->name()
                                     << " found in HDB." << std::endl;
#endif // DEBUG_DELAY_ESTIMATION
            return false;
        }
#ifdef DEBUG_DELAY_ESTIMATION
        Application::logStream() 
            << port.name() << " (port) delay " << delay << std::endl;
#endif
        return true;
    }

References createSearch(), initializeEstimator(), Application::logStream(), TTAMachine::Component::name(), TTAMachine::Port::name(), and TTAMachine::BaseFUPort::parentUnit().

Here is the call graph for this function:

◆ initializeEstimator()

void InterpolatingFUEstimator::initializeEstimator ( const HDBManager & hdb )

inlineprivate

Initializes the plugin.

Parameters

hdb	The HDB to be used in searching entries. Cost database is created in basis of this HDB.

Definition at line 421 of file InterpolatingFUEstimator.cc.

                                           {
    
    costdb_ = &costDatabaseRegistry_->costDatabase(hdb);
    strategy_ = new FilterSearch();
    costdb_->setSearchStrategy(strategy_);
    unitProperty_ = EntryKeyProperty::find(CostDBTypes::EK_UNIT);
    createSearchTypes();
}