#include <CostDatabase.hh>

Collaboration diagram for CostDatabase:

Public Member Functions
virtual	~CostDatabase ()

void	buildDefaultCostDatabase ()

void	buildRegisterFiles (const std::string &rfEstimatorPluginName)

void	buildFunctionUnits (const std::string &fuEstimatorPluginName)

void	buildBuses (const std::string &busEstimatorPluginName)

void	buildSockets (const std::string &socketEstimatorPluginName)

bool	isRegisterFilesBuilt ()

bool	isFunctionUnitsBuilt ()

bool	isBusesBuilt ()

bool	isSocketsBuilt ()

void	insertEntry (CostDBEntry *entry)

void	setSearchStrategy (SearchStrategy *strategy)

CostDBTypes::EntryTable	search (const CostDBEntryKey &searchKey, const CostDBTypes::MatchTypeTable &match) const

Static Public Member Functions
static CostDatabase &	instance (const HDB::HDBManager &hdb)

Private Types
typedef std::pair< const EntryKeyProperty *, CostDBTypes::MatchTypeTable >	MatchTypeMapType
	Value type for map of search types.

typedef std::map< const EntryKeyProperty *, CostDBTypes::EntryTable >	EntryMap
	Map of database entries according to entry type.

typedef std::map< const EntryKeyProperty *, CostDBTypes::MatchTypeTable >	MatchTypeMap
	Search type for each entry type.

Private Member Functions
	CostDatabase (const HDB::HDBManager &hdb)
	CostDatabase must be created with instance() method.

boost::smatch	getValues (const std::string &text, const std::string &regex)
	Finds string matches using regular expressions.

	CostDatabase (const CostDatabase &)
	Copying not allowed.

CostDatabase &	operator= (const CostDatabase &)
	Assignment not allowed.

Private Attributes
SearchStrategy *	searchStrategy_
	Search strategy used for queries.

EntryMap	entries_
	Database entries.

const HDB::HDBManager &	hdb_
	HDB used for creating cost database.

bool	registerFilesBuilt_
	Flag to note is register files built.

bool	functionUnitsBuilt_
	Flag to note is function units built.

bool	busesBuilt_
	Flag to note is buses built.

bool	socketsBuilt_
	Flag to note is sockets built.

CostDatabaseRegistry *	registry_
	Registry of CostDatabases.

Static Private Attributes
static CostDatabase *	instance_ = NULL
	Unique instance of the class.

Detailed Description

Stores database entries and search strategy for making queries.

Definition at line 64 of file CostDatabase.hh.

Member Typedef Documentation

◆ EntryMap

typedef std::map< const EntryKeyProperty*, CostDBTypes::EntryTable> CostDatabase::EntryMap

private

Map of database entries according to entry type.

Definition at line 97 of file CostDatabase.hh.

◆ MatchTypeMap

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

private

Search type for each entry type.

Definition at line 100 of file CostDatabase.hh.

◆ MatchTypeMapType

typedef std::pair< const EntryKeyProperty*, CostDBTypes::MatchTypeTable> CostDatabase::MatchTypeMapType

private

Value type for map of search types.

Definition at line 94 of file CostDatabase.hh.

Constructor & Destructor Documentation

◆ ~CostDatabase()

CostDatabase::~CostDatabase ( )

virtual

Destructor.

Deallocates memory reserved for the search strategy.

Definition at line 137 of file CostDatabase.cc.

                            {
 
    if (searchStrategy_ != NULL) {
        delete searchStrategy_;
        searchStrategy_ = NULL;
    }
 
    for (EntryMap::iterator i = entries_.begin(); i != entries_.end(); i++) {
 
        for (CostDBTypes::EntryTable::iterator j = i->second.begin();
             j != i->second.end(); j++) {
 
            if (*j != NULL) {
                delete *j;
                *j = NULL;
            }
        }
    }
}

References entries_, and searchStrategy_.

◆ CostDatabase() [1/2]

CostDatabase::CostDatabase ( const HDB::HDBManager & hdb )

private

CostDatabase must be created with instance() method.

Default constructor.

Parameters

hdb	HDBManager to be used with the cost database.

Definition at line 76 of file CostDatabase.cc.

                                                   :
    searchStrategy_(NULL), hdb_(hdb), registerFilesBuilt_(false),
    functionUnitsBuilt_(false), busesBuilt_(false), socketsBuilt_(false) {
 
    // Creates entry and field types that the database contains.
    
    EntryKeyProperty* rfileProperty =
        EntryKeyProperty::create(CostDBTypes::EK_RFILE);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_NUM_REGISTERS);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_READ_PORTS);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_WRITE_PORTS);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_BIDIR_PORTS);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_BIT_WIDTH);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_LATENCY);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_MAX_READS);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_MAX_WRITES);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_GUARD_SUPPORT);
    rfileProperty->createFieldProperty(CostDBTypes::EKF_GUARD_LATENCY);
 
    EntryKeyProperty* unitProperty =
        EntryKeyProperty::create(CostDBTypes::EK_UNIT);
    unitProperty->createFieldProperty(CostDBTypes::EKF_BIT_WIDTH);
    unitProperty->createFieldProperty(CostDBTypes::EKF_FUNCTION_UNIT);    
 
    EntryKeyProperty* mbusProperty =
        EntryKeyProperty::create(CostDBTypes::EK_MBUS);
    mbusProperty->createFieldProperty(CostDBTypes::EKF_BIT_WIDTH);
    mbusProperty->createFieldProperty(CostDBTypes::EKF_BUS_FANIN);
    mbusProperty->createFieldProperty(CostDBTypes::EKF_BUS_FANOUT);
    
    EntryKeyProperty::create(CostDBTypes::EK_SOCKET);
    
    EntryKeyProperty* inputSocketProperty =
        EntryKeyProperty::create(CostDBTypes::EK_INPUT_SOCKET);
    inputSocketProperty->createFieldProperty(
        CostDBTypes::EKF_BIT_WIDTH);
    inputSocketProperty->createFieldProperty(
        CostDBTypes::EKF_INPUT_SOCKET_FANIN);
    
    EntryKeyProperty* outputSocketProperty =
        EntryKeyProperty::create(CostDBTypes::EK_OUTPUT_SOCKET);
    outputSocketProperty->createFieldProperty(
        CostDBTypes::EKF_BIT_WIDTH);
    outputSocketProperty->createFieldProperty(
        CostDBTypes::EKF_OUTPUT_SOCKET_FANOUT);
/*
  EntryKeyProperty* controlProperty =
  EntryKeyProperty::create(CostDBTypes::EK_CONTROL);
  controlProperty->createFieldProperty(
  CostDBTypes::EKF_CONTROL_CONNECTIVITY);
*/    
    EntryKeyProperty::create(CostDBTypes::EK_INLINE_IMM_SOCKET);
 
    buildDefaultCostDatabase();
}

References buildDefaultCostDatabase(), EntryKeyProperty::create(), EntryKeyProperty::createFieldProperty(), CostDBTypes::EK_INLINE_IMM_SOCKET, CostDBTypes::EK_INPUT_SOCKET, CostDBTypes::EK_MBUS, CostDBTypes::EK_OUTPUT_SOCKET, CostDBTypes::EK_RFILE, CostDBTypes::EK_SOCKET, CostDBTypes::EK_UNIT, CostDBTypes::EKF_BIDIR_PORTS, CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_BUS_FANIN, CostDBTypes::EKF_BUS_FANOUT, CostDBTypes::EKF_FUNCTION_UNIT, CostDBTypes::EKF_GUARD_LATENCY, CostDBTypes::EKF_GUARD_SUPPORT, CostDBTypes::EKF_INPUT_SOCKET_FANIN, CostDBTypes::EKF_LATENCY, CostDBTypes::EKF_MAX_READS, CostDBTypes::EKF_MAX_WRITES, CostDBTypes::EKF_NUM_REGISTERS, CostDBTypes::EKF_OUTPUT_SOCKET_FANOUT, CostDBTypes::EKF_READ_PORTS, and CostDBTypes::EKF_WRITE_PORTS.

Here is the call graph for this function:

◆ CostDatabase() [2/2]

CostDatabase::CostDatabase ( const CostDatabase & )

private

Copying not allowed.

Member Function Documentation

◆ buildBuses()

void CostDatabase::buildBuses ( const std::string & busEstimatorPluginName )

Reads buses from the set HDB and builds bus entries in to the cost database.

Parameters

busEstimatorPluginName Name of the bus estimator plugin which cost data are read and used in the cost database.

Exceptions

Exception if an error occured during the cost database building.

Definition at line 642 of file CostDatabase.cc.

                                                                {
    // find out the plugin id that estimates buses
    std::set<RowID> pluginIDs = hdb_.costFunctionPluginIDs();    
    RowID busEstimatorPluginID = 0;
    std::set<RowID>::const_iterator pluginID = pluginIDs.begin();
    for (; pluginID != pluginIDs.end(); pluginID++) {
        CostFunctionPlugin* plugin = hdb_.costFunctionPluginByID(*pluginID);
        if (plugin->name() == busEstimatorPluginName) {
            busEstimatorPluginID = *pluginID;
            break;
        }
    } 
 
    // bus part
    std::set<RowID> buses = hdb_.busEntryIDs();
    std::set<RowID>::const_iterator id = buses.begin();
    for (; id != buses.end(); id++) {
        // fetch all data from the entry and put it to CostDB
        int bitWidth = 0;
        int fanin = 0;
        int fanout = 0;
#ifdef CAUSE_COMPILER_WARNING_AND_NOT_USED_REMOVE_IF_NOT_EVER_NEEDED
        int cntrlDelay = 0;
#endif
        double area = 0.0;
        double delay = 0.0;
        double activeEnergy = 0.0;
        double idleEnergy = 0.0;
 
        CostEstimationData query;
        query.setBusReference(*id);
        query.setPluginID(busEstimatorPluginID);
        std::set<RowID> dataIDs = hdb_.costEstimationDataIDs(query);
        std::set<RowID>::const_iterator dataID = dataIDs.begin();
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            if (data.name() == "area") {
                area = data.value().doubleValue();
                continue;
            }
            if (data.name() == "computation_delay") {
                delay = data.value().doubleValue();
                continue;
            }
            if (data.name() == "fanin") {
                fanin = data.value().integerValue();
                continue;
            }
            if (data.name() == "fanout") {
                fanout = data.value().integerValue();
                continue;
            }
            if (data.name() == "dataw") {
                bitWidth = data.value().integerValue();
                continue;
            }
            if (data.name() == "cntrl_delay") {
#ifdef CAUSE_COMPILER_WARNING_AND_NOT_USED_REMOVE_IF_NOT_EVER_NEEDED
                cntrlDelay = data.value().integerValue();
#endif
                continue;
            }
            if (data.name() == "energy") {
                activeEnergy = data.value().doubleValue();
                continue;
            }
            if (data.name() == "idle_energy") {
                idleEnergy = data.value().doubleValue();
                continue;
            }
        }
 
        CostDBEntryStats* newStatistics = 
            new CostDBEntryStats(area, delay);
        newStatistics->setEnergyActive(activeEnergy);
        newStatistics->setEnergyIdle(idleEnergy);
        
        EntryKeyProperty* busProperty = 
            EntryKeyProperty::find(CostDBTypes::EK_MBUS);
        CostDBEntryKey* newEntryKey = 
            new CostDBEntryKey(busProperty);
 
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(fanin),
                busProperty->fieldProperty(
                    CostDBTypes::EKF_BUS_FANIN)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(fanout),
                busProperty->fieldProperty(
                    CostDBTypes::EKF_BUS_FANOUT)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(bitWidth),
                busProperty->fieldProperty(
                    CostDBTypes::EKF_BIT_WIDTH)));
        
        CostDBEntry* newEntry =
            new CostDBEntry(newEntryKey);
        newEntry->addStatistics(newStatistics);
        
        insertEntry(newEntry);
    }
    busesBuilt_ = true;
}

References CostDBEntryKey::addField(), CostDBEntry::addStatistics(), HDB::HDBManager::busEntryIDs(), busesBuilt_, HDB::HDBManager::costEstimationData(), HDB::HDBManager::costEstimationDataIDs(), HDB::HDBManager::costFunctionPluginByID(), HDB::HDBManager::costFunctionPluginIDs(), DataObject::doubleValue(), CostDBTypes::EK_MBUS, CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_BUS_FANIN, CostDBTypes::EKF_BUS_FANOUT, EntryKeyProperty::fieldProperty(), EntryKeyProperty::find(), hdb_, insertEntry(), DataObject::integerValue(), CostEstimationData::name(), HDB::CostFunctionPlugin::name(), CostEstimationData::setBusReference(), CostDBEntryStats::setEnergyActive(), CostDBEntryStats::setEnergyIdle(), CostEstimationData::setPluginID(), and CostEstimationData::value().

Referenced by buildDefaultCostDatabase().

Here is the call graph for this function:

◆ buildDefaultCostDatabase()

void CostDatabase::buildDefaultCostDatabase ( )

Creates default cost database from all HDB entries.

Exceptions

Exception if an error occured during the cost database building.

Definition at line 180 of file CostDatabase.cc.

                                       {
    if (!isRegisterFilesBuilt()) {
        buildRegisterFiles("StrictMatchRFEstimator");
    }
    if (!isFunctionUnitsBuilt()) {
        buildFunctionUnits("StrictMatchFUEstimator");
    }
    if (!isBusesBuilt()) {
        buildBuses("DefaultICEstimator");
    }
    if (!isSocketsBuilt()) {
        buildSockets("DefaultICEstimator");
    }
}

References buildBuses(), buildFunctionUnits(), buildRegisterFiles(), buildSockets(), isBusesBuilt(), isFunctionUnitsBuilt(), isRegisterFilesBuilt(), and isSocketsBuilt().

Referenced by CostDatabase().

Here is the call graph for this function:

◆ buildFunctionUnits()

void CostDatabase::buildFunctionUnits ( const std::string & fuEstimatorPluginName )

Reads function units from the set HDB and builds function unit entries in to the cost database.

Parameters

fuEstimatorPluginName Name of the function unit estimator plugin which cost data are read and used in the cost database.

Exceptions

Exception if an error occured during the cost database building.

Definition at line 441 of file CostDatabase.cc.

                                                                       {
    // find out the function unit estimator plugin id
    std::set<RowID> pluginIDs = hdb_.costFunctionPluginIDs();    
    RowID fuEstimatorPluginID = 0;
    std::set<RowID>::const_iterator pluginID = pluginIDs.begin();
    for (; pluginID != pluginIDs.end(); pluginID++) {
        CostFunctionPlugin* plugin = hdb_.costFunctionPluginByID(*pluginID);
        if (plugin->name() == fuEstimatorPluginName) {
            fuEstimatorPluginID = *pluginID;
            break;
        }
    }
 
    bool useCompiledQueries = false;
 
    // Function units
    std::set<RowID> fus = hdb_.fuEntryIDs();
    std::set<RowID>::const_iterator id = fus.begin();
    for (; id != fus.end(); id++) {
        // fetch all data from the entry and put it to CostDB
        set<string> operations;
        set<vector<string> > parameters;
        vector<string> portSet;
#ifdef CAUSE_COMPILER_WARNING_AND_NOT_USED_REMOVE_IF_NOT_EVER_NEEDED
        int operationCount = 0;
        int latency = 0;
#endif
        double area = 0;
        double delay = 0;
        int width = 0;
 
        const HDB::FUEntry* entry = hdb_.fuByEntryID(*id);
 
        if (entry->hasCostFunction()) {
            if (entry->costFunction().id() != fuEstimatorPluginID) {
                // wrong type of estimation plugin
                continue;
            }
        } else {
            // no cost function plugin set.
            continue;
        }
 
        if (entry->hasArchitecture()) {            
#ifdef CAUSE_COMPILER_WARNING_AND_NOT_USED_REMOVE_IF_NOT_EVER_NEEDED
            operationCount = entry->architecture().architecture().
                operationCount();                
            latency = entry->architecture().architecture().maxLatency();
#endif
            int ports = entry->architecture().architecture().portCount();
            int i;
            for (i = 0; i < ports; i++) {
                BaseFUPort* port = 
                    entry->architecture().architecture().port(i);
                if (dynamic_cast<FUPort*>(port) != NULL) {
                    FUPort* fuPort = dynamic_cast<FUPort*>(port);
                    if (entry->architecture().hasParameterizedWidth(
                            fuPort->name())) {
                        // parameterized port
                        break;
                    } else {
                        if (width == 0) {
                            width = fuPort->width();
                        } else if (width != fuPort->width()) {
                            break;
                        }
                    }
                }
            }
            if (i != ports) {
                // Some port has parameterized width or 
                // port widths are not equal and entry cannot be used.
                continue;
            }
        } else {
            continue;
        }
        EntryKeyProperty* unitProperty = 
            EntryKeyProperty::find(CostDBTypes::EK_UNIT);
        CostDBEntryKey* newEntryKey = 
            new CostDBEntryKey(unitProperty);
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(width),
                unitProperty->fieldProperty(
                    CostDBTypes::EKF_BIT_WIDTH)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataFunctionUnit(
                    &(entry->architecture().architecture())),
                unitProperty->fieldProperty(
                    CostDBTypes::EKF_FUNCTION_UNIT)));
        CostEstimationData query;
        query.setFUReference(*id);
        query.setPluginID(fuEstimatorPluginID);
        std::set<RowID> dataIDs = hdb_.costEstimationDataIDs(query, 
                useCompiledQueries);
        std::set<RowID>::const_iterator dataID = dataIDs.begin();
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            if (data.name() == "area") {
                area = data.value().doubleValue();
                continue;
            }
            if (data.name() == "computation_delay") {
                delay = data.value().doubleValue();
                continue;
            }
        }
 
        CostDBEntryStatsFU* newStatistics = 
            new CostDBEntryStatsFU(area, delay);
 
        dataID = dataIDs.begin();
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            const std::string dataName = data.name();
            // input delays
 
            // this case is for one delay/unit case
            if (dataName == "input_delay") {
                newStatistics->setDelay("input_delay",
                                        data.value().doubleValue());
                continue;
            }
 
            boost::smatch match = 
                getValues(dataName, "input_delay[ \t]*(\\S+)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the name of the port
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
            
            // output delays
 
            // this case is for one delay/unit case
            if (dataName == "output_delay") {
                newStatistics->setDelay(
                    "output_delay", data.value().doubleValue());
                continue;
            }
 
            match = getValues(
                dataName, "output_delay[ \t]*(\\S+)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the name of the port
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
            match = getValues(
                dataName, "(output_delay)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the name of the port
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
 
            // operation energies
            match = getValues(
                dataName, "operation_execution_energy (\\S+)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the operation name
                newStatistics->setEnergyOperation(
                    match[1], data.value().doubleValue());
                continue;
            }
 
            // idle energy
            if (dataName == "fu_idle_energy") {
                newStatistics->setEnergyIdle(data.value().doubleValue());
                continue;
            }
        }
        CostDBEntry* newEntry =
            new CostDBEntry(newEntryKey);
        newEntry->addStatistics(newStatistics);
        
        insertEntry(newEntry);    
    }
    functionUnitsBuilt_ = true;
    if (useCompiledQueries) {
        hdb_.deleteCostEstimationDataIDsQueries();
    }
}

References CostDBEntryKey::addField(), CostDBEntry::addStatistics(), HDB::FUArchitecture::architecture(), HDB::FUEntry::architecture(), HDB::HDBManager::costEstimationData(), HDB::HDBManager::costEstimationDataIDs(), HDB::HDBEntry::costFunction(), HDB::HDBManager::costFunctionPluginByID(), HDB::HDBManager::costFunctionPluginIDs(), HDB::HDBManager::deleteCostEstimationDataIDsQueries(), DataObject::doubleValue(), CostDBTypes::EK_UNIT, CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_FUNCTION_UNIT, EntryKeyProperty::fieldProperty(), EntryKeyProperty::find(), HDB::HDBManager::fuByEntryID(), HDB::HDBManager::fuEntryIDs(), functionUnitsBuilt_, getValues(), HDB::FUEntry::hasArchitecture(), HDB::HDBEntry::hasCostFunction(), HDB::FUArchitecture::hasParameterizedWidth(), hdb_, HDB::CostFunctionPlugin::id(), insertEntry(), TTAMachine::FunctionUnit::maxLatency(), CostEstimationData::name(), HDB::CostFunctionPlugin::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), CostDBEntryStats::setDelay(), CostDBEntryStats::setEnergyIdle(), CostDBEntryStatsFU::setEnergyOperation(), CostEstimationData::setFUReference(), CostEstimationData::setPluginID(), CostEstimationData::value(), and TTAMachine::BaseFUPort::width().

Referenced by buildDefaultCostDatabase().

Here is the call graph for this function:

◆ buildRegisterFiles()

void CostDatabase::buildRegisterFiles ( const std::string & rfEstimatorPluginName )

Reads register files from the set HDB and builds register file entries in to the cost database.

Parameters

rfEstimatorPluginName Name of the register file estimator plugin which cost data are read and used in the cost database.

Exceptions

Exception if an error occured during the cost database building.

Definition at line 204 of file CostDatabase.cc.

                                                                       {
    // find out the register file estimator plugin id
    std::set<RowID> pluginIDs = hdb_.costFunctionPluginIDs();
    RowID rfEstimatorPluginID = 0;
    std::set<RowID>::const_iterator pluginID = pluginIDs.begin();
    for (; pluginID != pluginIDs.end(); pluginID++) {
        CostFunctionPlugin* plugin = hdb_.costFunctionPluginByID(*pluginID);
        if (plugin->name() == rfEstimatorPluginName) {
            //"StrictMatchRFEstimator") {
            rfEstimatorPluginID = *pluginID;
            break;
        }
    }
 
    bool useCompiledQueries = false;
    
    // Registers
    std::set<RowID> rfs = hdb_.rfEntryIDs();
    std::set<RowID>::const_iterator id = rfs.begin();
    for (; id != rfs.end(); id++) {
        // fetch all data from the entry and put it to CostDB
        int size = 0;
        int reads = 0;
        int writes = 0;
        int bidirPorts = 0;
        int maxReads = 0;
        int maxWrites = 0;
        int bitWidth = 0;
        int latency = 0;
        bool guardSupport = false;
        int guardLatency = 0;
        double area = 0;
        double delay = 0;
        
        const HDB::RFEntry* entry = hdb_.rfByEntryID(*id);
        
        if (entry->hasCostFunction()) {
            if (entry->costFunction().id() != rfEstimatorPluginID) {
                // wrong type of estimation plugin
                continue;
            }
        } else {
            // no cost function plugin set.
            continue;
        }
        if (entry->hasArchitecture()) {
            try {
                size = entry->architecture().size();
            } catch (NotAvailable& e) {
                // size is parametrized
                // entry cannot be added to costDB
                continue;
            }
            try {
                bitWidth = entry->architecture().width();
            } catch (NotAvailable& e) {
                // bit width is parametrized
                // entry cannot be added to costDB
                continue;
            }
            writes = entry->architecture().writePortCount();
            reads = entry->architecture().readPortCount();
            bidirPorts = entry->architecture().bidirPortCount();
            latency = entry->architecture().latency();
            maxReads = entry->architecture().maxReads();
            maxWrites = entry->architecture().maxWrites();
            guardSupport = entry->architecture().hasGuardSupport();
            guardLatency = entry->architecture().guardLatency();
        } else {
            // entry has no architecture
            continue;
        }        
        EntryKeyProperty* rfileProperty = 
            EntryKeyProperty::find(CostDBTypes::EK_RFILE);
        CostDBEntryKey* newEntryKey = 
            new CostDBEntryKey(rfileProperty);
        
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(size),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_NUM_REGISTERS)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(reads),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_READ_PORTS)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(writes),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_WRITE_PORTS)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(bidirPorts),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_BIDIR_PORTS)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(bitWidth),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_BIT_WIDTH)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(latency),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_LATENCY)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(maxReads),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_MAX_READS)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(maxWrites),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_MAX_WRITES)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataBool(guardSupport),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_GUARD_SUPPORT)));
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(guardLatency),
                rfileProperty->fieldProperty(
                    CostDBTypes::EKF_GUARD_LATENCY)));
 
        CostEstimationData query;
        query.setRFReference(*id);
        query.setPluginID(rfEstimatorPluginID);
        std::set<RowID> dataIDs = hdb_.costEstimationDataIDs(query, 
                useCompiledQueries);
        std::set<RowID>::const_iterator dataID = dataIDs.begin();
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            if (data.name() == "area") {
                area = data.value().doubleValue();
                continue;
            }
            if (data.name() == "computation_delay") {
                delay = data.value().doubleValue();
                continue;
            }
        }
        CostDBEntryStatsRF* newStatistics = 
            new CostDBEntryStatsRF(area, delay);
        dataID = dataIDs.begin();
 
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            const std::string dataName = data.name();
            // input delays
 
            // this case is for one delay/unit case
            if (dataName == "input_delay") {
                newStatistics->setDelay(
                    "input_delay", data.value().doubleValue());
                continue;
            }
            boost::smatch match = 
                getValues(dataName, "input_delay[ \t]*(\\S+)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the port name
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
 
            // output delays
 
            // this case is for one delay/unit case
            if (dataName == "output_delay") {
                newStatistics->setDelay(
                    "output_delay", data.value().doubleValue());
                continue;
            }
 
            match = getValues(dataName, "output_delay[ \t]*(\\S+)");
            if (match.size() == 2) {
                // match[0] contains the whole string
                // match[1] contains the port name
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
            
            if (dataName == "output_delay") {
                // match[0] contains the whole string
                // match[1] contains the name of the port
                newStatistics->setDelay(
                    match[1], data.value().doubleValue());
                continue;
            }
 
            // access energies
            match =
                getValues(dataName, "rf_access_energy ([0-9])* ([0-9])*");
            if (match.size() == 3) {
                // match[0] contains the whole string
                // match[1] contains the number of reads
                // match[2] contains the number of writes
                newStatistics->setEnergyReadWrite(
                    Conversion::toInt(
                        match[1]), Conversion::toInt(match[2]),
                    data.value().doubleValue());
                continue;
            }
 
            // idle energy
            if (dataName == "rf_idle_energy") {
                newStatistics->setEnergyIdle(data.value().doubleValue());
                continue;
            }
        }
 
        CostDBEntry* newEntry =
            new CostDBEntry(newEntryKey);
        newEntry->addStatistics(newStatistics);
        insertEntry(newEntry);
    }
    registerFilesBuilt_ = true;
    if (useCompiledQueries) {
        hdb_.deleteCostEstimationDataIDsQueries();
    }
}

Referenced by buildDefaultCostDatabase().

Here is the call graph for this function:

◆ buildSockets()

void CostDatabase::buildSockets ( const std::string & socketEstimatorPluginName )

Reads sockets from the set HDB and builds socket entries in to the cost database.

Parameters

socketEstimatorPluginName Name of the socket estimator plugin which cost data are read and used in the cost database.

Exceptions

Exception if an error occured during the cost database building.

Definition at line 758 of file CostDatabase.cc.

                                                                     {
    // find out the plugin id that estimates sockets
    std::set<RowID> pluginIDs = hdb_.costFunctionPluginIDs();    
    RowID socketEstimatorPluginID = 0;
    std::set<RowID>::const_iterator pluginID = pluginIDs.begin();
    for (; pluginID != pluginIDs.end(); pluginID++) {
        CostFunctionPlugin* plugin = hdb_.costFunctionPluginByID(*pluginID);
        if (plugin->name() == socketEstimatorPluginName) {
            socketEstimatorPluginID = *pluginID;
            break;
        }
    }
    
    // socket part
    std::set<RowID> sockets = hdb_.socketEntryIDs();
    std::set<RowID>::const_iterator id = sockets.begin();
    for (; id != sockets.end(); id++) {
        // fetch all data from the entry and put it to CostDB
        int bitWidth = 0;
        int fanin = 0;
        int fanout = 0;
        int cntrlDelay = 0;
        double area = 0.0;
        double delay = 0.0;
        double activeEnergy = 0.0;
        double idleEnergy = 0.0;
        
        CostEstimationData query;
        query.setSocketReference(*id);
        query.setPluginID(socketEstimatorPluginID);
        std::set<RowID> dataIDs = hdb_.costEstimationDataIDs(query);
        std::set<RowID>::const_iterator dataID = dataIDs.begin();
        for (; dataID != dataIDs.end(); dataID++) {
            CostEstimationData data = hdb_.costEstimationData(*dataID);
            if (data.name() == "area") {
                area = data.value().doubleValue();
                continue;
            }
            if (data.name() == "computation_delay") {
                delay = data.value().doubleValue();
                continue;
            }
            if (data.name() == "fanin") {
                fanin = data.value().integerValue();
                continue;
            }
            if (data.name() == "fanout") {
                fanout = data.value().integerValue();
                continue;
            }
            if (data.name() == "dataw") {
                bitWidth = data.value().integerValue();
                continue;
            }
            if (data.name() == "cntrl_delay") {
                cntrlDelay = data.value().integerValue();
                continue;
            }
            if (data.name() == "energy") {
                activeEnergy = data.value().doubleValue();
                continue;
            }
            if (data.name() == "idle_energy") {
                idleEnergy = data.value().doubleValue();
                continue;
            }
        }
 
        CostDBEntryStats* newStatistics = 
            new CostDBEntryStats(area, delay);
        // this is contol data, not real data and not really needed
        newStatistics->setDelay("cntrl_delay", cntrlDelay);
        newStatistics->setEnergyActive(activeEnergy);
        newStatistics->setEnergyIdle(idleEnergy);
 
        EntryKeyProperty* socketProperty = NULL;
        CostDBEntryKey* newEntryKey = NULL;
        if (fanin != 0) {
            socketProperty = 
                EntryKeyProperty::find(CostDBTypes::EK_INPUT_SOCKET);
            newEntryKey = 
                new CostDBEntryKey(socketProperty);
            
            // fanin needed only in input sockets
            newEntryKey->addField(
                new EntryKeyField(
                    new EntryKeyDataInt(fanin),
                    socketProperty->fieldProperty(
                        CostDBTypes::EKF_INPUT_SOCKET_FANIN)));
        }
        // else socket is output socket
        else {
            socketProperty = 
                EntryKeyProperty::find(CostDBTypes::EK_OUTPUT_SOCKET);
            newEntryKey = 
                new CostDBEntryKey(socketProperty);
            
            // fanout only needed in output sockets
            newEntryKey->addField(
                new EntryKeyField(
                    new EntryKeyDataInt(fanout),
                    socketProperty->fieldProperty(
                        CostDBTypes::EKF_OUTPUT_SOCKET_FANOUT)));
        }
 
        newEntryKey->addField(
            new EntryKeyField(
                new EntryKeyDataInt(bitWidth),
                socketProperty->fieldProperty(
                    CostDBTypes::EKF_BIT_WIDTH)));
        
        CostDBEntry* newEntry =
            new CostDBEntry(newEntryKey);
        newEntry->addStatistics(newStatistics);
        
        insertEntry(newEntry);
    }
    socketsBuilt_ = true;
}

References CostDBEntryKey::addField(), CostDBEntry::addStatistics(), HDB::HDBManager::costEstimationData(), HDB::HDBManager::costEstimationDataIDs(), HDB::HDBManager::costFunctionPluginByID(), HDB::HDBManager::costFunctionPluginIDs(), DataObject::doubleValue(), CostDBTypes::EK_INPUT_SOCKET, CostDBTypes::EK_OUTPUT_SOCKET, CostDBTypes::EKF_BIT_WIDTH, CostDBTypes::EKF_INPUT_SOCKET_FANIN, CostDBTypes::EKF_OUTPUT_SOCKET_FANOUT, EntryKeyProperty::fieldProperty(), EntryKeyProperty::find(), hdb_, insertEntry(), DataObject::integerValue(), CostEstimationData::name(), HDB::CostFunctionPlugin::name(), CostDBEntryStats::setDelay(), CostDBEntryStats::setEnergyActive(), CostDBEntryStats::setEnergyIdle(), CostEstimationData::setPluginID(), CostEstimationData::setSocketReference(), HDB::HDBManager::socketEntryIDs(), socketsBuilt_, and CostEstimationData::value().

Referenced by buildDefaultCostDatabase().

Here is the call graph for this function:

◆ getValues()

boost::smatch CostDatabase::getValues	(	const std::string &	text,
		const std::string &	regex
	)

private

Finds string matches using regular expressions.

Returns the matching strings out of the text using regexp.

Parameters

text	String the regular expression is used for.
regex	Regular expression to be matched with the text.

Returns: Returns the matched string patterns from the text or empty smatch if matching failed.

Definition at line 1001 of file CostDatabase.cc.

                                                               {
    boost::regex regx(regex + ".*");
    boost::smatch what;
    if (boost::regex_match(text, what, regx, boost::match_extra)) {
        return what;
    }
    boost::smatch empty;
    return empty;
}

Referenced by buildFunctionUnits(), and buildRegisterFiles().

◆ insertEntry()

void CostDatabase::insertEntry ( CostDBEntry * entry )

Inserts an entry into the database.

Parameters

entry Database entry.

Exceptions

ObjectAlreadyExists If inserted entry is already inserted.

Definition at line 908 of file CostDatabase.cc.

                                            {
    EntryMap::iterator i = entries_.find(entry->type());
 
    if (i == entries_.end()) {
        CostDBTypes::EntryTable newEntries;
        newEntries.push_back(entry);
        entries_.insert(pair<const EntryKeyProperty*, CostDBTypes::EntryTable>(
                            entry->type(), newEntries));
    } else {
        // if the database already contains an entry with same search
        // key, the statistics of the new entry will be added into the
        // existing entry
        for (CostDBTypes::EntryTable::iterator j = i->second.begin();
             j != i->second.end(); j++) {
 
            if ((*j)->isEqualKey(*entry)) {
        if (*j == entry) {
            throw ObjectAlreadyExists(__FILE__, __LINE__,
                          "CostDatabase::insertEntry");
        }
                for (int k = 0; k < entry->statisticsCount(); k++) {
                    CostDBEntryStats* newStats = entry->statistics(k).copy();
                    (*j)->addStatistics(newStats);
                }
                return;
            }
        }
        i->second.push_back(entry);
    }
}

References CostDBEntryStats::copy(), entries_, CostDBEntry::statistics(), CostDBEntry::statisticsCount(), and CostDBEntry::type().

Referenced by buildBuses(), buildFunctionUnits(), buildRegisterFiles(), and buildSockets().

Here is the call graph for this function:

◆ instance()

CostDatabase & CostDatabase::instance ( const HDB::HDBManager & hdb )

static

Creates and returns an instance of cost database build in base of the HDB.

Parameters

hdb	HDB to use in building the CostDatabase.

Returns: An instance of cost database.

Exceptions

Exception in case that an error occurred while creating the CostDatabase.

Definition at line 166 of file CostDatabase.cc.

                                               {
    CostDatabaseRegistry* registry = &CostDatabaseRegistry::instance();
    if (!registry->hasCostDatabase(hdb)) {
        registry->addCostDatabase(new CostDatabase(hdb), hdb);
    }
    return registry->costDatabase(hdb);
}

References CostDatabaseRegistry::addCostDatabase(), CostDatabaseRegistry::costDatabase(), CostDatabaseRegistry::hasCostDatabase(), and CostDatabaseRegistry::instance().

Referenced by CostDatabaseRegistry::costDatabase().

Here is the call graph for this function:

◆ isBusesBuilt()

bool CostDatabase::isBusesBuilt ( )

Returns true if buses are built in the cost database.

Returns: True if buses are built in the cost database.

Definition at line 965 of file CostDatabase.cc.

                           {
    return busesBuilt_;
}

References busesBuilt_.

Referenced by buildDefaultCostDatabase().

◆ isFunctionUnitsBuilt()

bool CostDatabase::isFunctionUnitsBuilt ( )

Returns true if function units are built in the cost database.

Returns: True if function units are built in the cost database.

Definition at line 955 of file CostDatabase.cc.

                                   {    
    return functionUnitsBuilt_;
}

References functionUnitsBuilt_.

Referenced by buildDefaultCostDatabase().

◆ isRegisterFilesBuilt()

bool CostDatabase::isRegisterFilesBuilt ( )

Returns true if register files are built in the cost database.

Returns: True if register files are built in the cost database.

Definition at line 945 of file CostDatabase.cc.

                                   {
    return registerFilesBuilt_;
}

References registerFilesBuilt_.

Referenced by buildDefaultCostDatabase().

◆ isSocketsBuilt()

bool CostDatabase::isSocketsBuilt ( )

Returns true if sockets are built in the cost database.

Returns: True if sockets are built in the cost database.

Definition at line 975 of file CostDatabase.cc.

                             {
    return socketsBuilt_;
}

References socketsBuilt_.

Referenced by buildDefaultCostDatabase().

◆ operator=()

CostDatabase & CostDatabase::operator= ( const CostDatabase & )

private

Assignment not allowed.

◆ search()

CostDBTypes::EntryTable CostDatabase::search	(	const CostDBEntryKey &	searchKey,
		const CostDBTypes::MatchTypeTable &	match
	)		const

Searches entries from the database matching certain search key with specific type of matches.

Parameters

searchKey	Search key.
match	Type of matches.

Returns: Entries matching the search.

Exceptions

KeyNotFound If search key type is not found.

Definition at line 888 of file CostDatabase.cc.

                                                  {
    EntryMap::const_iterator i = entries_.find(searchKey.type());
    
    // entries of searched type are in the list
    if (i == entries_.end()) {
        throw KeyNotFound(__FILE__, __LINE__, "CostDatabase::search");
    }
    
    return searchStrategy_->search(searchKey, i->second, match);
}

References entries_, SearchStrategy::search(), searchStrategy_, and CostDBEntryKey::type().

Referenced by InterpolatingRFEstimator::createSearch(), and InterpolatingFUEstimator::createSearch().

Here is the call graph for this function:

◆ setSearchStrategy()

void CostDatabase::setSearchStrategy ( SearchStrategy * strategy )

Replaces search strategy by taking a copy of another one.

Parameters

strategy Search strategy.

Definition at line 985 of file CostDatabase.cc.

                                                        {
    if (searchStrategy_ != NULL) {
    delete searchStrategy_;
    }
    searchStrategy_ = strategy->copy();
}

References SearchStrategy::copy(), and searchStrategy_.

Referenced by InterpolatingFUEstimator::initializeEstimator(), and InterpolatingRFEstimator::initializeEstimator().

Here is the call graph for this function:

Member Data Documentation

◆ busesBuilt_

bool CostDatabase::busesBuilt_

private

Flag to note is buses built.

Definition at line 113 of file CostDatabase.hh.

Referenced by buildBuses(), and isBusesBuilt().

◆ entries_

EntryMap CostDatabase::entries_

private

Database entries.

Definition at line 105 of file CostDatabase.hh.

Referenced by insertEntry(), search(), and ~CostDatabase().

◆ functionUnitsBuilt_

bool CostDatabase::functionUnitsBuilt_

private

Flag to note is function units built.

Definition at line 111 of file CostDatabase.hh.

Referenced by buildFunctionUnits(), and isFunctionUnitsBuilt().

◆ hdb_

const HDB::HDBManager& CostDatabase::hdb_

private

HDB used for creating cost database.

Definition at line 107 of file CostDatabase.hh.

Referenced by buildBuses(), buildFunctionUnits(), buildRegisterFiles(), and buildSockets().

◆ instance_

CostDatabase * CostDatabase::instance_ = NULL

staticprivate

Unique instance of the class.

Definition at line 118 of file CostDatabase.hh.

◆ registerFilesBuilt_

bool CostDatabase::registerFilesBuilt_

private

Flag to note is register files built.

Definition at line 109 of file CostDatabase.hh.

Referenced by buildRegisterFiles(), and isRegisterFilesBuilt().

◆ registry_

CostDatabaseRegistry* CostDatabase::registry_

private

Registry of CostDatabases.

Definition at line 120 of file CostDatabase.hh.

◆ searchStrategy_

SearchStrategy* CostDatabase::searchStrategy_

private

Search strategy used for queries.

Definition at line 103 of file CostDatabase.hh.

Referenced by search(), setSearchStrategy(), and ~CostDatabase().

◆ socketsBuilt_

bool CostDatabase::socketsBuilt_

private

Flag to note is sockets built.

Definition at line 115 of file CostDatabase.hh.

Referenced by buildSockets(), and isSocketsBuilt().

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

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ EntryMap

◆ MatchTypeMap

◆ MatchTypeMapType

Constructor & Destructor Documentation

◆ ~CostDatabase()

◆ CostDatabase() [1/2]

◆ CostDatabase() [2/2]

Member Function Documentation

◆ buildBuses()

◆ buildDefaultCostDatabase()

◆ buildFunctionUnits()

◆ buildRegisterFiles()

◆ buildSockets()

◆ getValues()

◆ insertEntry()

◆ instance()

◆ isBusesBuilt()

◆ isFunctionUnitsBuilt()

◆ isRegisterFilesBuilt()

◆ isSocketsBuilt()

◆ operator=()

◆ search()

◆ setSearchStrategy()

Member Data Documentation

◆ busesBuilt_

◆ entries_

◆ functionUnitsBuilt_

◆ hdb_

◆ instance_

◆ registerFilesBuilt_

◆ registry_

◆ searchStrategy_

◆ socketsBuilt_