ComponentImplementationSelector Class Reference

#include <ComponentImplementationSelector.hh>

Collaboration diagram for ComponentImplementationSelector:

Classes
struct	implComp

Public Member Functions
	ComponentImplementationSelector ()
virtual	~ComponentImplementationSelector ()
void	addHDB (const HDB::HDBManager &hdb)
void	addCase (const TTAProgram::Program &program, const ExecutionTrace &traceDB)
std::map< const IDF::FUImplementationLocation *, CostEstimates * >	fuImplementations (const TTAMachine::FunctionUnit &fu, double frequencyMHz=0, double maxArea=0)
std::list< TTAMachine::FunctionUnit * >	fuArchsByOpSetWithMinLatency (const std::set< std::string > &operationSet, int width=0) const
std::map< const IDF::RFImplementationLocation *, CostEstimates * >	rfImplementations (const TTAMachine::RegisterFile &rf, bool guarded=false, double frequencyMHz=0, double maxArea=0)
std::map< const IDF::IUImplementationLocation *, CostEstimates * >	iuImplementations (const TTAMachine::ImmediateUnit &iu, double frequencyMHz=0, double maxArea=0)
void	selectComponentsToConf (DSDBManager::MachineConfiguration &conf, DSDBManager &dsdb, TTAMachine::Machine *mach=NULL, const std::string &icDecoder="ic_hdb", const std::string &icDecoderHDB="asic_130nm_1.5V.hdb", const double &frequency=0, const double &maxArea=0)
IDF::MachineImplementation *	selectComponents (const TTAMachine::Machine *mach, const std::string &icDecoder="ic_hdb", const std::string &icDecoderHDB="asic_130nm_1.5V.hdb", const double &frequency=0, const double &maxArea=0)
void	selectFUs (const TTAMachine::Machine *mach, IDF::MachineImplementation *idf, const double &frequency=0, const double &maxArea=0, const bool &filterLongestPathDelay=true)
void	selectRFs (const TTAMachine::Machine *mach, IDF::MachineImplementation *idf, const double &frequency=0, const double &maxArea=0)
void	selectIUs (const TTAMachine::Machine *mach, IDF::MachineImplementation *idf, const double &frequency=0, const double &maxArea=0)

Private Attributes
std::set< std::string >	usedHDBs_
	HDBs from which implementations are serched are stored in this set.
CostEstimator::Estimator	estimator_
	Cost estimator to estimate the unit costs.

Detailed Description

Purpose of the component implementation selector class is to select suitable implementations to architecture components. The component implementation selector uses HDB to look for implementations and returns set of suitable implementations that fulfill the given cost requirements. Class uses cost estimator to estimate the costs of suitable implementations. Cost estimation data includes energy estimations of all program cases that are set.

Definition at line 74 of file ComponentImplementationSelector.hh.

Constructor & Destructor Documentation

ComponentImplementationSelector()

ComponentImplementationSelector::ComponentImplementationSelector

(

)

The constructor.

Definition at line 67 of file ComponentImplementationSelector.cc.

                                                                 {
}

~ComponentImplementationSelector()

ComponentImplementationSelector::~ComponentImplementationSelector ( )

virtual

The destructor

Definition at line 73 of file ComponentImplementationSelector.cc.

                                                                  {
}

Member Function Documentation

addCase()

void ComponentImplementationSelector::addCase	(	const TTAProgram::Program &	program,
		const ExecutionTrace &	traceDB
	)

Adds new traceDB and corresponding program.

Parameters

program	Test case program to be used.
traceDB	Simulation trace of the program.

Definition at line 94 of file ComponentImplementationSelector.cc.

                                                     {
 
}

addHDB()

void ComponentImplementationSelector::addHDB

(

const HDB::HDBManager &

hdb

)

Adds new HDB to look for components.

Parameters

hdb	The HDB file name to be added.

Exceptions

Exception

in case there was a problem while opening the HDB.

Definition at line 83 of file ComponentImplementationSelector.cc.

                                                             {
    usedHDBs_.insert(hdb.fileName());
}

References HDB::HDBManager::fileName(), and usedHDBs_.

Referenced by AutoSelectImplementationsDialog::findFUImplementations(), AutoSelectImplementationsDialog::findIUImplementations(), AutoSelectImplementationsDialog::findRFImplementations(), selectComponents(), and ImplementationSelector::setupSelector().

Here is the call graph for this function:

fuArchsByOpSetWithMinLatency()

list< TTAMachine::FunctionUnit * > ComponentImplementationSelector::fuArchsByOpSetWithMinLatency	(	const std::set< std::string > &	operationSet,
		int	width = 0
	)		const

Finds the minimum set of Function units that is needed to satisfy all the wanted operations.

Function units are selected so that the number of needed units would be as low as possible and smaller latency is preferred. If there are units with same latency then units with smaller amount of operations is preferred. If there still are units with equal operations then the unit with the widest triggering port is preferred.

Parameters

operationSet	Set of operation names the resultig set of function units must include.
width	Bitwidth of the funtion unit ports. Not used if left as default.

Returns

Minimal set of function units that have all the asked operations. Returns an empty set if all operations cannot be supported by any set of function units.

Definition at line 212 of file ComponentImplementationSelector.cc.

          {
 
    // Convert operation names to lower case.
    set<string> operations;
    set<string>::const_iterator oper = operationSet.begin();
    for (; oper != operationSet.end(); oper++) {
        operations.insert(StringTools::stringToLower((*oper)));
    }
 
    // Get all function unit architectures.
    list<pair<TTAMachine::FunctionUnit*, int> >functionUnits;
    for (set<string>::const_iterator i = usedHDBs_.begin();
         i != usedHDBs_.end(); i++) {
 
        set<RowID> fuArchIDs = 
            HDBRegistry::instance().hdb(*i).fuArchitectureIDsByOperationSet(
                operations);
        set<RowID>::const_iterator iter = fuArchIDs.begin();
        for (;iter != fuArchIDs.end(); iter++) {
            FUArchitecture* fuArch = 
                HDBRegistry::instance().hdb(*i).fuArchitectureByID(*iter);
 
            // check the fu port widths if the width is given as parameter
            if (width) {
                bool portsDiffer = false;
                for (int p = 0; p < fuArch->architecture().portCount(); p++) {
                    if (fuArch->architecture().port(p)->width() != width) {
                        portsDiffer = true;
                    }
                }
                if (portsDiffer) {
                    continue;
                }
            }
            pair<FunctionUnit*, int> fuIntPair(&fuArch->architecture(), 0);
            functionUnits.push_back(fuIntPair);
        }
    }
    
    list<TTAMachine::FunctionUnit*> results;
    
    // Find the best set of function units
    while (operations.size() != 0) {
        list<pair<TTAMachine::FunctionUnit*, int> >::iterator fu = 
            functionUnits.begin();
        for (; fu != functionUnits.end(); fu++) {
            int neededOperations = 0;
            set<string>::iterator operation = operations.begin();
            while (operation != operations.end()) {
                if ((*fu).first->hasOperation(*operation)) {
                    neededOperations++;
                }
                operation++;
            }
            (*fu).second = neededOperations;
        }
        
        list<TTAMachine::FunctionUnit*> bestMatches;
        int bestFU = 0;
        
        // Find out which FU:s implement most needed operations
        for (fu = functionUnits.begin(); fu != functionUnits.end(); fu++) {
            if ((*fu).second > bestFU) {
                bestMatches.clear();
                bestMatches.push_back((*fu).first);
                bestFU = (*fu).second;
            } else if ((*fu).second == bestFU) {
                bestMatches.push_back((*fu).first);
            }
        }
 
        // if found set
        if (bestMatches.size() != 0) {
            TTAMachine::FunctionUnit* bestFU = NULL;
            int minLatency = -1;
            int minOperations = -1;
            int maxPortWidth = -1;
            // Select one of the best FU:s
            list<TTAMachine::FunctionUnit*>::const_iterator bestMatchFU = 
                bestMatches.begin();
            for (; bestMatchFU != bestMatches.end(); bestMatchFU++) {
                int fuMaxLatency = (*bestMatchFU)->maxLatency();
                if (fuMaxLatency < minLatency) {
                    minLatency = fuMaxLatency;
                    minOperations = (*bestMatchFU)->operationCount();
                    bestFU = (*bestMatchFU);
                } else if (minLatency == -1) {
                    minLatency = fuMaxLatency;
                    minOperations = (*bestMatchFU)->operationCount();
                    bestFU = (*bestMatchFU);
                } else if (fuMaxLatency == minLatency) {
                    int fuOperations = (*bestMatchFU)->operationCount();
                    if (fuOperations < minOperations) {
                        minOperations = fuOperations;
                        bestFU = (*bestMatchFU);
                    } else if (minOperations == -1) {
                        minOperations = fuOperations;
                        bestFU = (*bestMatchFU);
                    } else if (fuOperations == minOperations) {
                        int bestFUPortWidth = 0;
                        for (int i = 0;
                             i < (*bestMatchFU)->operationPortCount();
                             i++) {
 
                            FUPort* port = (*bestMatchFU)->operationPort(i);
                            if (port->isTriggering()) {
                                if (bestFUPortWidth < port->width()) {
                                    bestFUPortWidth = port->width();
                                }
                            }
                        }
                        if (maxPortWidth < bestFUPortWidth) {
                            maxPortWidth = bestFUPortWidth;
                            bestFU = (*bestMatchFU);
                        }
                    }
                }
            }
            for (int oper = 0; oper < bestFU->operationCount(); oper++) {
                operations.erase(
                    StringTools::stringToLower(
                        bestFU->operation(oper)->name()));
            }
            results.push_back(bestFU);
            
            // remove the best suitable fu from the set of function untis.
            list<pair<FunctionUnit*, int> >::iterator fuIntIter =
                functionUnits.begin();
            for (; fuIntIter != functionUnits.end(); fuIntIter++) {
                if ((*fuIntIter).first == bestFU) {
                    functionUnits.erase(fuIntIter);
                    break;
                }
            }
        } else {
            break;
        }
    }
    if (operations.size() != 0) {
        results.clear();
    }
    return results;
}

References HDB::FUArchitecture::architecture(), HDB::CachedHDBManager::fuArchitectureByID(), HDB::HDBManager::fuArchitectureIDsByOperationSet(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::instance(), TTAMachine::FUPort::isTriggering(), TTAMachine::FunctionUnit::maxLatency(), TTAMachine::HWOperation::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::port(), StringTools::stringToLower(), usedHDBs_, and TTAMachine::BaseFUPort::width().

Here is the call graph for this function:

fuImplementations()

map< const IDF::FUImplementationLocation *, CostEstimates * > ComponentImplementationSelector::fuImplementations	(	const TTAMachine::FunctionUnit &	fu,
		double	frequencyMHz = 0,
		double	maxArea = 0
	)

Finds set of possible function unit implementations.

Finds out which function unit implementations fulfill the frequency and area requirements. The implementations are selected by estimating costs of different function unit implementations that match the given funtion unit architecture. All implementations that fulfill the given frequency and area requirements are returned including the estimated cost data of those implementations.

Parameters

fu	Function unit architecture.
frequencyMHz	Target frequency (MHz) of the function unit.
maxArea	Maximum area (in gates) of the function unit.

Returns

Set of FU implementations with cost estimation data. Returns an empty set if none found.

Definition at line 116 of file ComponentImplementationSelector.cc.

                                                                           {
 
    // Get all fu entries matching the given architecture from all available
    // HDBs and create implementation locations of them.
    set<const IDF::FUImplementationLocation*> fuImplementations;
    for (set<string>::const_iterator i = usedHDBs_.begin();
         i != usedHDBs_.end(); i++) {
        
        HDBManager& hdb = HDBRegistry::instance().hdb(*i);
        set<RowID> fuEntryIDs = hdb.fuEntriesByArchitecture(fu);
        set<RowID>::const_iterator id = fuEntryIDs.begin();
        for (; id != fuEntryIDs.end(); id++) {
            IDF::FUImplementationLocation* fuIDF = 
                new IDF::FUImplementationLocation(
                    hdb.fileName(), *id,
                    fu.name());
            IDF::MachineImplementation* machIDF =
                new IDF::MachineImplementation();
            machIDF->addFUImplementation(fuIDF);
            fuImplementations.insert(fuIDF);
        }
    }
    map<const IDF::FUImplementationLocation*, CostEstimates*> results;
    set<const IDF::FUImplementationLocation*>::const_iterator iter = 
        fuImplementations.begin();
    
    // in case we are not limiting the costs, return all matching
    // implementations
    if (static_cast<int>(frequencyMHz) <= 0 && 
            static_cast<int>(maxArea) <= 0) {
 
        for (; iter != fuImplementations.end(); iter++) {
            results.insert(
                pair<const IDF::FUImplementationLocation*, CostEstimates*>(
                    (*iter), NULL));
        }
        return results;
    }
 
    // Estimate costs the the implementations
    while (iter != fuImplementations.end()) {
        auto rmIt = iter;
        try {
            double area = estimator_.functionUnitArea(fu, *(*iter));
            if (area > maxArea && static_cast<int>(maxArea) > 0) {
                // FU area too large
                iter++;
                fuImplementations.erase(rmIt);
                continue;
            }
            double delayInNanoSeconds = 
                estimator_.functionUnitMaximumComputationDelay(fu, *(*iter));
            
            // 1000/ns = MHz
            if (delayInNanoSeconds > 0 && (static_cast<double>(1000) / static_cast<double>(delayInNanoSeconds)) < static_cast<double>(frequencyMHz)) {
                // FU too slow
                iter++;
                fuImplementations.erase(rmIt);
                continue;
            }
            CostEstimates* estimates = new CostEstimates();
            estimates->setArea(area);
            estimates->setLongestPathDelay(delayInNanoSeconds);
            results.insert(
                pair<const IDF::FUImplementationLocation*, CostEstimates*>(
                    (*iter), estimates));
        } catch (CannotEstimateCost& e) {
            // Couldn't estimate the fu.
            iter++;
            fuImplementations.erase(rmIt);
            continue;
        }
        iter++;
    }
    return results;
}

References IDF::MachineImplementation::addFUImplementation(), estimator_, HDB::HDBManager::fileName(), HDB::HDBManager::fuEntriesByArchitecture(), fuImplementations(), CostEstimator::Estimator::functionUnitArea(), CostEstimator::Estimator::functionUnitMaximumComputationDelay(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::instance(), TTAMachine::Component::name(), CostEstimates::setArea(), CostEstimates::setLongestPathDelay(), and usedHDBs_.

Referenced by AutoSelectImplementationsDialog::findFUImplementations(), fuImplementations(), and selectFUs().

Here is the call graph for this function:

iuImplementations()

map< const IDF::IUImplementationLocation *, CostEstimates * > ComponentImplementationSelector::iuImplementations	(	const TTAMachine::ImmediateUnit &	iu,
		double	frequencyMHz = 0,
		double	maxArea = 0
	)

Finds set of possible immediate unit implementations.

Finds out which immediate unit implementations fulfill the frequency and area requirements. The implementations are selected by estimating costs of different immediate unit implementations that match the given immediate unit architecture. All implementations that fulfill the given frequency and area requirements are returned including the estimated cost data of those implementations.

Parameters

iu	Immediate unit architecture.
frequencyMHz	Target frequency (MHz) of the immediate unit.
maxArea	Maximum area (in gates) of the immediate unit.

Returns

Set of IU implementations with cost evaluation data. Returns an empty set if none found.

Definition at line 494 of file ComponentImplementationSelector.cc.

                                                                            {
 
    // Get all iu entries matching the given architecture from all available
    // HDBs and create implementation locations of them.
    set<const IDF::IUImplementationLocation*> iuImplementations;
    for (set<string>::const_iterator i = usedHDBs_.begin();
         i != usedHDBs_.end(); i++) {
        
        HDBManager& hdb = HDBRegistry::instance().hdb(*i);
        int readPorts = iu.portCount();
 
        set<RowID> iuEntryIDs =
            hdb.rfEntriesByArchitecture(
                readPorts,
                1, // writePorts in iu is always 1, not visible in adf
                0, // bidirPorts
                0, // maxReads
                0, // maxWrites
                1, // latency always 1
                false, // guard support always false
                0, // guard latency
                iu.width(),
                iu.numberOfRegisters());
 
        set<RowID>::const_iterator id = iuEntryIDs.begin();
        for (; id != iuEntryIDs.end(); id++) {
            IDF::IUImplementationLocation* iuIDF = 
                new IDF::IUImplementationLocation(
                    hdb.fileName(), *id, iu.name());
            IDF::MachineImplementation* machIDF =
                new IDF::MachineImplementation();
            machIDF->addIUImplementation(iuIDF);
            iuImplementations.insert(iuIDF);
        }
    }
    map<const IDF::IUImplementationLocation*, CostEstimates*> results;
    set<const IDF::IUImplementationLocation*>::const_iterator iter = 
        iuImplementations.begin();
 
    // in case we are not limiting the costs, return all matching
    // implementations
    if (static_cast<int>(frequencyMHz) <= 0 && 
            static_cast<int>(maxArea) <= 0) {
 
        for (; iter != iuImplementations.end(); iter++) {
            results.insert(
                pair<const IDF::IUImplementationLocation*, CostEstimates*>(
                    (*iter), NULL));
        }
        return results;
    }
 
    while (iter != iuImplementations.end()) {
        auto rmIt = iter;
        try {
            double area = estimator_.registerFileArea(iu, *(*iter));
            if (area > maxArea && static_cast<int>(maxArea) > 0) {
                // IU area too large
                iter++;
                iuImplementations.erase(rmIt);
                continue;
            }
            double delayInNanoSeconds = 
                estimator_.registerFileMaximumComputationDelay(iu, *(*iter));
 
            // 1000/ns = MHz
            if ((1000/delayInNanoSeconds) < frequencyMHz) {
                // RF too slow
                iter++;
                iuImplementations.erase(rmIt);
                continue;
            }
            CostEstimates* estimates = new CostEstimates();
            estimates->setArea(area);
            estimates->setLongestPathDelay(delayInNanoSeconds);
            results.insert(
                pair<const IDF::IUImplementationLocation*, CostEstimates*>(
                    (*iter), estimates));
        } catch (CannotEstimateCost& e) {
            // Couldn't estimate the iu.
            iter++;
            iuImplementations.erase(rmIt);
            continue;
        }
        iter++;
    }
    return results;
}

References IDF::MachineImplementation::addIUImplementation(), estimator_, HDB::HDBManager::fileName(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::instance(), iuImplementations(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Unit::portCount(), CostEstimator::Estimator::registerFileArea(), CostEstimator::Estimator::registerFileMaximumComputationDelay(), HDB::HDBManager::rfEntriesByArchitecture(), CostEstimates::setArea(), CostEstimates::setLongestPathDelay(), usedHDBs_, and TTAMachine::BaseRegisterFile::width().

Referenced by AutoSelectImplementationsDialog::findIUImplementations(), iuImplementations(), and selectIUs().

Here is the call graph for this function:

rfImplementations()

map< const IDF::RFImplementationLocation *, CostEstimates * > ComponentImplementationSelector::rfImplementations	(	const TTAMachine::RegisterFile &	rf,
		bool	guarded = false,
		double	frequencyMHz = 0,
		double	maxArea = 0
	)

Finds set of possible register file implementations.

Finds out which register file implementations fulfill the frequency and area requirements. The implementations are selected by estimating costs of different register file implementations that match the given register file architecture. All implementations that fulfill the given frequency and area requirements are returned including the estimated cost data of those implementations.

Parameters

rf	Register file architecture.
guarded	Flag indicating if the register file is guarded, defaults to false.
frequencyMHz	Target frequency (MHz) of the register file.
maxArea	Maximum area (in gates) of the register file.

Returns

Set of RF implementations with cost evaluation data. Returns an empty set if none found.

Definition at line 377 of file ComponentImplementationSelector.cc.

                    {
 
    // Get all rf entries matching the given architecture from all available
    // HDBs and create implementation locations of them.
    set<const IDF::RFImplementationLocation*> rfImplementations;
    for (set<string>::const_iterator i = usedHDBs_.begin();
         i != usedHDBs_.end(); i++) {
        
        HDBManager& hdb = HDBRegistry::instance().hdb(*i);
        int readPorts = 0;
        int writePorts = 0;
        int bidirPorts = 0;
        for (int p = 0; p < rf.portCount(); p++) {
            const TTAMachine::RFPort* port = rf.port(p);
            if (port->inputSocket() != NULL && port->outputSocket() != NULL) {
                bidirPorts++;
            } else if (port->inputSocket() != NULL) {
                writePorts++;
            } else if (port->outputSocket() != NULL) {
                readPorts++;
            }
        }
        set<RowID> rfEntryIDs = hdb.rfEntriesByArchitecture(
            readPorts, writePorts, bidirPorts, rf.maxReads(), rf.maxWrites(),
            // latency always 1
            1,
            // guard support
            guarded,
            // guard latency
            rf.guardLatency(), rf.width(), rf.numberOfRegisters(),
            rf.zeroRegister());
 
        set<RowID>::const_iterator id = rfEntryIDs.begin();
        for (; id != rfEntryIDs.end(); id++) {
            IDF::RFImplementationLocation* rfIDF = 
                new IDF::RFImplementationLocation(
                    hdb.fileName(), *id, rf.name());
            IDF::MachineImplementation* machIDF =
                new IDF::MachineImplementation();
            machIDF->addRFImplementation(rfIDF);
            rfImplementations.insert(rfIDF);
        }
    }
    map<const IDF::RFImplementationLocation*, CostEstimates*> results;
    set<const IDF::RFImplementationLocation*>::const_iterator iter = 
        rfImplementations.begin();
 
    // in case we are not limiting the costs, return all matching
    // implementations
    if (static_cast<int>(frequencyMHz) <= 0 && 
            static_cast<int>(maxArea) <= 0) {
 
        for (; iter != rfImplementations.end(); iter++) {
            results.insert(
                pair<const IDF::RFImplementationLocation*, CostEstimates*>(
                    (*iter), NULL));
        }
        return results;
    }
 
    while (iter != rfImplementations.end()) {
        auto rmIt = iter;
        try {
            double area = estimator_.registerFileArea(rf, *(*iter));
            if (area > maxArea && static_cast<int>(maxArea) > 0) {
                // RF area too large
                iter++;
                rfImplementations.erase(rmIt);
                continue;
            }
            double delayInNanoSeconds = 
                estimator_.registerFileMaximumComputationDelay(rf, *(*iter));
 
            // 1000/ns = MHz
            if ((1000/delayInNanoSeconds) < frequencyMHz) {
                // RF too slow
                iter++;
                rfImplementations.erase(rmIt);
                continue;
            }
            CostEstimates* estimates = new CostEstimates();
            estimates->setArea(area);
            estimates->setLongestPathDelay(delayInNanoSeconds);
            results.insert(
                pair<const IDF::RFImplementationLocation*, CostEstimates*>(
                    (*iter), estimates));
        } catch (CannotEstimateCost& e) {
            // Couldn't estimate the rf.
            iter++;
            rfImplementations.erase(rmIt);
            continue;
        }
        iter++;
    }
    return results;
}

References IDF::MachineImplementation::addRFImplementation(), estimator_, HDB::HDBManager::fileName(), TTAMachine::RegisterFile::guardLatency(), HDB::HDBRegistry::hdb(), TTAMachine::Port::inputSocket(), HDB::HDBRegistry::instance(), TTAMachine::RegisterFile::maxReads(), TTAMachine::RegisterFile::maxWrites(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), CostEstimator::Estimator::registerFileArea(), CostEstimator::Estimator::registerFileMaximumComputationDelay(), HDB::HDBManager::rfEntriesByArchitecture(), rfImplementations(), CostEstimates::setArea(), CostEstimates::setLongestPathDelay(), usedHDBs_, TTAMachine::BaseRegisterFile::width(), and TTAMachine::RegisterFile::zeroRegister().

Referenced by AutoSelectImplementationsDialog::findRFImplementations(), rfImplementations(), and selectRFs().

Here is the call graph for this function:

selectComponents()

IDF::MachineImplementation * ComponentImplementationSelector::selectComponents	(	const TTAMachine::Machine *	mach,
		const std::string &	icDecoder = "ic_hdb",
		const std::string &	icDecoderHDB = "asic_130nm_1.5V.hdb",
		const double &	frequency = 0,
		const double &	maxArea = 0
	)

Selects the implementations for the machine configuration.

Parameters

configuration	MachineConfiguration of which architecture is used.
frequency	The minimum frequency of the implementations.
icDecoder	The name of the ic decoder plugin for idf.
icDecoderHDB	The name of the hdb used by ic decoder plugin.

Returns

RowID of the new machine configuration having adf and idf.

Exceptions

Exception

No suitable implementations found.

Definition at line 645 of file ComponentImplementationSelector.cc.

                           {
    HDBRegistry& hdbRegistry = HDBRegistry::instance();
    for (int i = 0; i < hdbRegistry.hdbCount(); i++) {
        addHDB(hdbRegistry.hdb(i));
    }
 
    IDF::MachineImplementation* idf = new IDF::MachineImplementation;
 
    // select implementations for funtion units
    selectFUs(mach, idf, frequency, maxArea);
 
    // select implementations for register files
    selectRFs(mach, idf);
 
    // select implementations for immediate units
    selectIUs(mach, idf, frequency, maxArea);
 
    // add the ic decoder plugin
    std::vector<std::string> icDecPaths =
        Environment::icDecoderPluginPaths();
    idf->setICDecoderPluginName(icDecoder);
    idf->setICDecoderHDB(icDecoderHDB);
    std::vector<std::string>::const_iterator iter = icDecPaths.begin();
    for (; iter != icDecPaths.end(); iter++) {
        std::string path = *iter;
        std::string file = 
            path + FileSystem::DIRECTORY_SEPARATOR + icDecoder + "Plugin.so";
        if (FileSystem::fileExists(file)) {
            idf->setICDecoderPluginFile(file);
            break;
        }
    }
 
    return idf;
}

References addHDB(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::hdbCount(), Environment::icDecoderPluginPaths(), HDB::HDBRegistry::instance(), selectFUs(), selectIUs(), selectRFs(), IDF::MachineImplementation::setICDecoderHDB(), IDF::MachineImplementation::setICDecoderPluginFile(), and IDF::MachineImplementation::setICDecoderPluginName().

Referenced by ImplementationSelector::explore(), DesignSpaceExplorer::selectComponents(), and selectComponentsToConf().

Here is the call graph for this function:

selectComponentsToConf()

void ComponentImplementationSelector::selectComponentsToConf	(	DSDBManager::MachineConfiguration &	conf,
		DSDBManager &	dsdb,
		TTAMachine::Machine *	mach = NULL,
		const std::string &	icDecoder = "ic_hdb",
		const std::string &	icDecoderHDB = "asic_130nm_1.5V.hdb",
		const double &	frequency = 0,
		const double &	maxArea = 0
	)

Selects the implementations for machine configuration.

Stores created idf to the given configuration and the configuration hold information in the given dsdb. If no machine is given then read the machine from dsdb through given configuration.

Parameters

conf	Machine configuration.
dsdb	DSDB where implementation is added.
mach	Machine for what the implementation is generated.
icDecoder	The name of the ic decoder plugin for idf.
icDecoderHDB	The name of the hdb used by ic decoder plugin.
frequency	The minimum frequency of the implementations.
maxArea	The maximum area of the implementations.

Definition at line 601 of file ComponentImplementationSelector.cc.

                           {
    if (mach == NULL) {
        try {
            mach = dsdb.architecture(conf.architectureID);
        } catch (const Exception& e) {
            Exception error(__FILE__, __LINE__, __func__, 
                    e.errorMessage());
            error.setCause(e);
            throw error;
        }
    }
        
    IDF::MachineImplementation* idf = NULL;
    try {
        // building the idf
        idf = selectComponents(
                mach, icDecoder, icDecoderHDB, frequency, maxArea);
    } catch (const Exception& e) {
        Exception error(__FILE__, __LINE__, __func__, 
                e.errorMessage());
        error.setCause(e);
        conf.hasImplementation = false;
        throw error;
    }
 
    conf.implementationID = dsdb.addImplementation(*idf, 0, 0);
    conf.hasImplementation = true;
}

References __func__, DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, Exception::errorMessage(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::MachineConfiguration::implementationID, selectComponents(), and Exception::setCause().

Referenced by ADFCombiner::explore(), and ComponentAdder::explore().

Here is the call graph for this function:

selectFUs()

void ComponentImplementationSelector::selectFUs	(	const TTAMachine::Machine *	mach,
		IDF::MachineImplementation *	idf,
		const double &	frequency = 0,
		const double &	maxArea = 0,
		const bool &	filterLongestPathDelay = true
	)

Selects the implementations for FUs in the machine configuration.

frequency and maxArea to zero by default. TODO: throw more appropriate exceptions

Definition at line 691 of file ComponentImplementationSelector.cc.

                                        {
    Machine::FunctionUnitNavigator fuNav = mach->functionUnitNavigator();
 
    // select implementations for funtion units
    for (int i = 0; i < fuNav.count(); i++) {
        FunctionUnit* fu = fuNav.item(i);
 
        map<const IDF::FUImplementationLocation*, CostEstimates*> fuMap =
            fuImplementations(*fu, frequency, maxArea);
        // Create an id ordered set of idf entries to ensure
        // deterministic behaviour       
        set<std::pair<const IDF::FUImplementationLocation*, CostEstimates*>, 
            implComp> fuSet;
        for (map<const IDF::FUImplementationLocation*, 
                 CostEstimates*>::iterator i = fuMap.begin();
             i != fuMap.end(); i++) {       
            fuSet.insert(
                std::make_pair(i->first, i->second));
        }
       
        set<std::pair<const IDF::FUImplementationLocation*, CostEstimates*> >::
            const_iterator iter = fuSet.begin();
        if (fuMap.size() != 0) {
            set<std::pair<const IDF::FUImplementationLocation*, 
                CostEstimates*> >::const_iterator wanted = iter;
            if (filterLongestPathDelay && maxArea > 0 && frequency > 0) {
                double longestPathDelay = 0;
                double area = 0;
                bool first = true;
                while (iter != fuSet.end()) {
                    CostEstimates* estimate = iter->second;
                    if (estimate == NULL) {
                        std::string errorMsg = "When selecting FUs regarding"
                            " longest path delay, no cost estimates were"
                            " found for FU: " + fu->name();
                        Application::writeToErrorLog(
                            __FILE__, __LINE__, __func__, errorMsg, 1);
                        break;
                    }
                    if (first) {
                        area = estimate->area();
                        longestPathDelay = estimate->longestPathDelay();
                        wanted = iter;
                        first = false;
                    } else if (longestPathDelay < 
                               estimate->longestPathDelay()) {
                        longestPathDelay = estimate->longestPathDelay();
                        area = estimate->area();
                        wanted = iter;
                    } else if (longestPathDelay == 
                               estimate->longestPathDelay() && 
                               area < estimate->area()) {
                        area = estimate->area();
                        wanted = iter;
                    }
                    iter++;
                }
            }
 
            const IDF::FUImplementationLocation* fuImpl = (*wanted).first;
       
            ObjectState* state = fuImpl->saveState();
            IDF::FUImplementationLocation* newFUImpl =
                new IDF::FUImplementationLocation(state);
 
            try {
                idf->addFUImplementation(newFUImpl);
            } catch (const Exception& e) {
                Exception error(
                    __FILE__, __LINE__, __func__, 
                    e.errorMessage());
                error.setCause(e);
                throw error;
            }
        } else {
            throw Exception(
                    __FILE__, __LINE__, __func__,
                    "no implementations found for FU: " + fu->name());
        }
    }
}

References __func__, IDF::MachineImplementation::addFUImplementation(), CostEstimates::area(), TTAMachine::Machine::Navigator< ComponentType >::count(), Exception::errorMessage(), fuImplementations(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), CostEstimates::longestPathDelay(), TTAMachine::Component::name(), IDF::UnitImplementationLocation::saveState(), Exception::setCause(), and Application::writeToErrorLog().

Referenced by selectComponents().

Here is the call graph for this function:

selectIUs()

void ComponentImplementationSelector::selectIUs	(	const TTAMachine::Machine *	mach,
		IDF::MachineImplementation *	idf,
		const double &	frequency = 0,
		const double &	maxArea = 0
	)

Selects the implementations for IUs in the machine configuration.

Definition at line 867 of file ComponentImplementationSelector.cc.

                                                    {
    Machine::ImmediateUnitNavigator iuNav = mach->immediateUnitNavigator();
    
    // select implementations for immediate units
    for (int index = 0; index < iuNav.count(); index++) {
        TTAMachine::ImmediateUnit* iu = iuNav.item(index);
 
        map<const IDF::IUImplementationLocation*, CostEstimates*> iuMap =
            iuImplementations(*iu, frequency, maxArea);
 
    // Create an id ordered set of idf entries to ensure the deterministic behaviour
    set<std::pair<const IDF::IUImplementationLocation*, CostEstimates*>, implComp> iuSet;
    for (map<const IDF::IUImplementationLocation*, CostEstimates*>::const_iterator i = 
             iuMap.begin(); i != iuMap.end(); i++) {
        iuSet.insert(std::make_pair(i->first, i->second));
    }
    set<std::pair<const IDF::IUImplementationLocation*, 
                  CostEstimates*> >::const_iterator iter = iuSet.begin();
        if (iuMap.size() != 0) {
            double longestPathDelay = 0;
            double area = 0;
            bool first = true;
            set<std::pair<const IDF::RFImplementationLocation*, CostEstimates*> >::const_iterator wanted = iter;
 
            while (iter != iuSet.end()) {
                CostEstimates* estimate = iter->second;
                if (estimate == NULL) {
                    std::string errorMsg = "When selecting IUs regarding"
                        " longest path delay, no cost estimates were"
                        " found for IU: " + iu->name();
                    Application::writeToErrorLog(
                            __FILE__, __LINE__, __func__, errorMsg, 1);
                    break;
                }
            if (first) {
                    area = estimate->area();
                    longestPathDelay = estimate->longestPathDelay();
                    wanted = iter;
                    first = false;
                } else if (longestPathDelay < estimate->longestPathDelay()) {
                    longestPathDelay = estimate->longestPathDelay();
                    area = estimate->area();
                    wanted = iter;
                } else if (longestPathDelay == estimate->longestPathDelay() && area < estimate->area()) {
                    area = estimate->area();
                    wanted = iter;
                }
                iter++;
            }
 
            const IDF::IUImplementationLocation* iuImpl = (*wanted).first;
            ObjectState* state = iuImpl->saveState();
            IDF::IUImplementationLocation* newIUImpl = 
                new IDF::IUImplementationLocation(state);
            try {
                idf->addIUImplementation(newIUImpl);
            } catch (const Exception& e) {
                Exception error(__FILE__, __LINE__, __func__, 
                        e.errorMessage());
                error.setCause(e);
                throw error;
            }
        } else {
            throw Exception(
                    __FILE__, __LINE__, __func__,
                    "no implementations found for IU: " + iu->name());
        }
    }
}

References __func__, IDF::MachineImplementation::addIUImplementation(), CostEstimates::area(), TTAMachine::Machine::Navigator< ComponentType >::count(), Exception::errorMessage(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), iuImplementations(), CostEstimates::longestPathDelay(), TTAMachine::Component::name(), IDF::UnitImplementationLocation::saveState(), Exception::setCause(), and Application::writeToErrorLog().

Referenced by selectComponents().

Here is the call graph for this function:

selectRFs()

void ComponentImplementationSelector::selectRFs	(	const TTAMachine::Machine *	mach,
		IDF::MachineImplementation *	idf,
		const double &	frequency = 0,
		const double &	maxArea = 0
	)

Selects the implementations for RFs in the machine configuration.

Selects the the RF that has biggest longest path delay.

Definition at line 783 of file ComponentImplementationSelector.cc.

                                                    {
    Machine::RegisterFileNavigator rfNav = mach->registerFileNavigator();
    
    // selects the register that has biggest longest path delay
    for (int i = 0; i < rfNav.count(); i++) {
        RegisterFile* rf = rfNav.item(i);
        map<const IDF::RFImplementationLocation*, CostEstimates*> rfMap;
 
        // check if the register is boolean register.
        if (rf->isUsedAsGuard()) {
            // select from guarded registers
            rfMap = rfImplementations(*rf, true, frequency, maxArea);
        } else {
            // select from non guarded registers
            rfMap = rfImplementations(*rf, false, frequency, maxArea);
        }
    // Create an id ordered set of idf entries to ensure the deterministic behaviour
        set<std::pair<const IDF::RFImplementationLocation*, CostEstimates*>, implComp> rfSet;
    for ( map<const IDF::RFImplementationLocation*, CostEstimates*>::const_iterator i = rfMap.begin();
              i != rfMap.end(); i++) {
        rfSet.insert(std::make_pair(i->first, i->second));
        }
    set<std::pair<const IDF::RFImplementationLocation*, CostEstimates*> >::const_iterator iter = rfSet.begin();
        if (rfMap.size() != 0) {
            double longestPathDelay = 0;
        double area = 0;
            bool first = true;
            set<std::pair<const IDF::RFImplementationLocation*,
                CostEstimates*> >::const_iterator wanted = iter;
            if (maxArea > 0 && frequency > 0) {
                while (iter != rfSet.end()) {
                    CostEstimates* estimate = iter->second;
                    if (estimate == NULL) {
                        std::string errorMsg = "When selecting RFs regarding"
                            " longest path delay, no cost estimates were"
                            " found for RF: " + rf->name();
                        Application::writeToErrorLog(
                                __FILE__, __LINE__, __func__, errorMsg, 1);
                        break;
                    }
            if (first) {
                        area = estimate->area();
                longestPathDelay = estimate->longestPathDelay();
                wanted = iter;
                first = false;
                } else if (longestPathDelay < estimate->longestPathDelay()) {
            longestPathDelay = estimate->longestPathDelay();
                area = estimate->area();
                wanted = iter;
            } else if (longestPathDelay == estimate->longestPathDelay() && area < estimate->area()) {
            area = estimate->area();
                wanted = iter;
            }
           
                    iter++;
                }
            }
            const IDF::RFImplementationLocation* rfImpl = (*wanted).first;
            ObjectState* state = rfImpl->saveState();
            IDF::RFImplementationLocation* newRFImpl = 
                new IDF::RFImplementationLocation(state);
            try {
                idf->addRFImplementation(newRFImpl);
            } catch (const Exception& e) {
                Exception error(__FILE__, __LINE__, __func__, 
                        e.errorMessage());
                error.setCause(e);
                throw error;
            }
        } else {
            throw Exception(
                    __FILE__, __LINE__, __func__,
                    "no implementations found for RF: " + rf->name());
        }
    }
}

References __func__, IDF::MachineImplementation::addRFImplementation(), CostEstimates::area(), TTAMachine::Machine::Navigator< ComponentType >::count(), Exception::errorMessage(), TTAMachine::RegisterFile::isUsedAsGuard(), TTAMachine::Machine::Navigator< ComponentType >::item(), CostEstimates::longestPathDelay(), TTAMachine::Component::name(), TTAMachine::Machine::registerFileNavigator(), rfImplementations(), IDF::UnitImplementationLocation::saveState(), Exception::setCause(), and Application::writeToErrorLog().

Referenced by selectComponents().

Here is the call graph for this function:

Member Data Documentation

estimator_

CostEstimator::Estimator ComponentImplementationSelector::estimator_

private

Cost estimator to estimate the unit costs.

Definition at line 131 of file ComponentImplementationSelector.hh.

Referenced by fuImplementations(), iuImplementations(), and rfImplementations().

usedHDBs_

std::set<std::string> ComponentImplementationSelector::usedHDBs_

private

HDBs from which implementations are serched are stored in this set.

Definition at line 129 of file ComponentImplementationSelector.hh.

Referenced by addHDB(), fuArchsByOpSetWithMinLatency(), fuImplementations(), iuImplementations(), and rfImplementations().

---

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

• ComponentImplementationSelector.hh
• ComponentImplementationSelector.cc