#include <CachedHDBManager.hh>

Inheritance diagram for HDB::CachedHDBManager:

Collaboration diagram for HDB::CachedHDBManager:

Public Member Functions
virtual	~CachedHDBManager ()

virtual void	removeFUArchitecture (RowID archID) const

virtual void	removeFUImplementation (RowID id) const

virtual void	removeRFArchitecture (RowID archID) const

virtual void	removeRFImplementation (RowID archID) const

virtual void	modifyCostFunctionPlugin (RowID id, const CostFunctionPlugin &plugin)

virtual void	removeCostFunctionPlugin (RowID pluginID) const

virtual void	removeFUEntry (RowID id) const

virtual void	removeRFEntry (RowID id) const

virtual void	removeBusEntry (RowID id) const

virtual void	removeSocketEntry (RowID id) const

virtual void	removeCostEstimationData (RowID id) const

virtual void	modifyCostEstimationData (RowID id, const CostEstimationData &data)

virtual FUArchitecture *	fuArchitectureByID (RowID id) const

virtual RFArchitecture *	rfArchitectureByID (RowID id) const

virtual DataObject	costEstimationDataValue (const std::string &valueName, const std::string &pluginName) const

const FUArchitecture &	fuArchitectureByIDConst (RowID id) const

const RFArchitecture &	rfArchitectureByIDConst (RowID id) const

virtual void	deleteCostEstimationDataIDsQueries () const

virtual std::set< RowID >	costEstimationDataIDs (const CostEstimationData &match, bool useCompiledQueries=false, RelationalDBQueryResult *compiledQuery=NULL) const

Public Member Functions inherited from HDB::HDBManager
virtual	~HDBManager ()

std::string	fileName () const

RowID	addCostFunctionPlugin (const CostFunctionPlugin &plugin) const

RowID	addFUArchitecture (const FUArchitecture &architecture) const

bool	canRemoveFUArchitecture (RowID archID) const

RowID	addFUEntry () const

RowID	addFUImplementation (const FUEntry &entry) const

void	setArchitectureForFU (RowID fuID, RowID archID) const

void	unsetArchitectureForFU (RowID fuID) const

RowID	addRFArchitecture (const RFArchitecture &architecture) const

bool	canRemoveRFArchitecture (RowID archID) const

RowID	addRFEntry () const

RowID	addRFImplementation (const RFImplementation &implementation, RowID rfEntryID)

void	setArchitectureForRF (RowID rfID, RowID archID) const

void	unsetArchitectureForRF (RowID rfID) const

void	setCostFunctionPluginForFU (RowID fuID, RowID pluginID) const

void	unsetCostFunctionPluginForFU (RowID fuID) const

void	setCostFunctionPluginForRF (RowID rfID, RowID pluginID) const

void	unsetCostFunctionPluginForRF (RowID rfID) const

std::set< RowID >	fuEntryIDs () const

std::set< RowID >	rfEntryIDs () const

std::set< RowID >	busEntryIDs () const

std::set< RowID >	socketEntryIDs () const

std::set< RowID >	OperationImplementationIDs () const

std::set< RowID >	OperationImplementationResourceIDs () const

OperationImplementation	OperationImplementationByID (RowID id) const

OperationImplementationResource	OperationImplementationResourceByID (RowID id) const

void	addOperationImplementationResource (const OperationImplementationResource &resource)

void	addOperationImplementation (const OperationImplementation &operation)

void	removeOperationImplementation (RowID id)

void	removeOperationImplementationResource (RowID id)

std::set< RowID >	fuArchitectureIDs () const

std::set< RowID >	fuArchitectureIDsByOperationSet (const std::set< std::string > &operationNames) const

std::set< RowID >	rfArchitectureIDs () const

RowID	fuEntryIDOfImplementation (RowID implID) const

RowID	rfEntryIDOfImplementation (RowID implID) const

FUEntry *	fuByEntryID (RowID id) const

RFEntry *	rfByEntryID (RowID id) const

std::set< RowID >	fuEntriesByArchitecture (const TTAMachine::FunctionUnit &fu) const

std::set< RowID >	rfEntriesByArchitecture (int readPorts, int writePorts, int bidirPorts, int maxReads, int maxWrites, int latency, bool guardSupport, int guardLatency=0, int width=0, int size=0, bool zeroRegister=false) const

DataObject	costEstimationDataValue (RowID entryId) const

RowID	addFUCostEstimationData (RowID fuID, const std::string &valueName, const std::string &value, RowID pluginID) const

RowID	addRFCostEstimationData (RowID rfID, const std::string &valueName, const std::string &value, RowID pluginID) const

DataObject	fuCostEstimationData (const std::string &valueName, RowID implementationId, const std::string &pluginName) const

DataObject	rfCostEstimationData (const std::string &valueName, RowID implementationId, const std::string &pluginName) const

RowID	addBusEntry () const

RowID	addBusCostEstimationData (RowID busID, const std::string &valueName, const std::string &value, RowID pluginID) const

DataObject	busCostEstimationData (const std::string &valueName, RowID busID, const std::string &pluginName) const

DataObjectList *	busCostEstimationDataList (const std::string &valueName, RowID implementationId, const std::string &pluginName) const

RowID	addSocketEntry () const

RowID	addSocketCostEstimationData (RowID socketID, const std::string &valueName, const std::string &value, RowID pluginID) const

DataObject	socketCostEstimationData (const std::string &valueName, RowID socketID, const std::string &pluginName) const

DataObjectList *	socketCostEstimationDataList (const std::string &valueName, RowID implementationID, const std::string &pluginName) const

std::set< RowID >	fuCostEstimationDataIDs (RowID fuImplID) const

std::set< RowID >	rfCostEstimationDataIDs (RowID rfImplID) const

std::set< RowID >	busCostEstimationDataIDs (RowID busID) const

std::set< RowID >	socketCostEstimationDataIDs (RowID socketID) const

CostEstimationData	costEstimationData (RowID id) const

std::set< RowID >	costFunctionPluginIDs () const

std::set< RowID >	costFunctionPluginDataIDs (RowID pluginID) const

CostFunctionPlugin *	costFunctionPluginByID (RowID pluginID) const

RowID	addCostEstimationData (const CostEstimationData &data) const

std::list< std::string >	blockSourceFile ()

Static Public Member Functions
static CachedHDBManager &	instance (const std::string &hdbFile)

static CachedHDBManager &	createNew (const std::string &fileName)

Static Public Member Functions inherited from HDB::HDBManager
static void	createNew (const std::string &file)

static std::string	formatString (BlockImplementationFile::Format format)

Private Member Functions
	CachedHDBManager (const std::string &hdbFile)

virtual RFImplementation *	createImplementationOfRF (RowID id) const

virtual FUImplementation *	createImplementationOfFU (FUArchitecture &architecture, RowID id) const

void	validateCache () const

Private Attributes
std::map< RowID, FUArchitecture * >	fuArchCache_
	FU Architecture cache.

std::map< RowID, RFArchitecture * >	rfArchCache_
	RF Architecture cache.

std::map< RowID, FUImplementation * >	fuImplCache_
	FU Implementation cache.

std::map< RowID, RFImplementation * >	rfImplCache_
	RF Implementation cache.

std::map< std::string, std::map< std::string, DataObject > >	costEstimationPluginValueCache_
	Cost estimation plugin value cache (pluginName/valueName)

std::map< short int, RelationalDBQueryResult * >	costEstimationDataIDsQueries_
	map of cached (compiled) queries for costEstimatioDataIDs function

std::time_t	lastModificationTime_
	used to detect modifications to the HDB file (which invalidates cache)

uintmax_t	lastSizeInBytes_
	used to detect modifications to the HDB file (which invalidates cache)

Additional Inherited Members
Public Types inherited from HDB::HDBManager
typedef std::list< DataObject >	DataObjectList

Protected Member Functions inherited from HDB::HDBManager
void	createCostEstimatioDataIdsQuery (const CostEstimationData &match, std::string query, RelationalDBQueryResult compiledQuery=NULL, short int *queryHash=NULL, bool createBindableQuery=false) const

RelationalDBConnection *	getDBConnection () const

	HDBManager (const std::string &hdbFile)

Detailed Description

Cached interface to HDBs.

HDBManager class queries HDB file every time the manager is queried for an object in the database. Queries to the database are time consuming, especially when constructing FU and RF implementation objects based on data scattered across multiple HDB tables. CachedHDBManager caches the queried objects in memory, resulting in significant speedups if the same objects are queried repeatedly without any modifications to the related data in the HDB.

IMPORTANT NOTE:

If a new function which modifies or removes cached objects is added to the HDBManager, it must be derived here to remove corresponding objects from the cache! Please check that all functions you are using that modify cached data are reimplemented to remove cached objects.

Definition at line 63 of file CachedHDBManager.hh.

Constructor & Destructor Documentation

◆ ~CachedHDBManager()

CachedHDBManager::~CachedHDBManager ( )

virtual

The Destructor.

Deletes all cached items.

Definition at line 69 of file CachedHDBManager.cc.

                                    {
    MapTools::deleteAllValues(fuArchCache_);
    MapTools::deleteAllValues(rfArchCache_);
    MapTools::deleteAllValues(fuImplCache_);
    MapTools::deleteAllValues(rfImplCache_);
 
    costEstimationPluginValueCache_.clear();     
}

References costEstimationPluginValueCache_, MapTools::deleteAllValues(), fuArchCache_, fuImplCache_, rfArchCache_, and rfImplCache_.

Here is the call graph for this function:

◆ CachedHDBManager()

CachedHDBManager::CachedHDBManager ( const std::string & hdbFile )

private

The Constructor.

Parameters

hdbFile HDBFile to open.

Exceptions

IOException if an error occured opening the HDB file.

Definition at line 58 of file CachedHDBManager.cc.

    : HDBManager(hdbFile) {
    lastModificationTime_ = FileSystem::lastModificationTime(hdbFile);
    lastSizeInBytes_ = FileSystem::sizeInBytes(hdbFile);
}

References FileSystem::lastModificationTime(), lastModificationTime_, lastSizeInBytes_, and FileSystem::sizeInBytes().

Here is the call graph for this function:

Member Function Documentation

◆ costEstimationDataIDs()

std::set< RowID > CachedHDBManager::costEstimationDataIDs	(	const CostEstimationData &	match,
		bool	useCompiledQueries = `false`,
		RelationalDBQueryResult *	compiledQuery = `NULL`
	)		const

virtual

Wrapper for HDBManager costEstimationDataIDs.

Compiles and caches queries for HDBManager costEstimationDataIDs function.

Reimplemented from HDB::HDBManager.

Definition at line 517 of file CachedHDBManager.cc.

                                                  {
 
    if (!useCompiledQueries) {
        return HDBManager::costEstimationDataIDs(match);
    }
    
    // query hash (bit vector might be better suited for this)
    short int queryHash = 0;
    // calculate query hash only to identify the query
    HDBManager::createCostEstimatioDataIdsQuery(match, NULL, NULL, &queryHash);
 
    // check if query already exists
    std::map<short int,RelationalDBQueryResult*>::iterator it = 
        costEstimationDataIDsQueries_.find(queryHash);
 
    if (costEstimationDataIDsQueries_.end() != it) {
        // if query already existed use it
        return HDBManager::costEstimationDataIDs(match, true, it->second); 
    } else {
        // else create a new compiledQuery and use it
        assert(queryHash != 0);
        std::string query = "";
        // create bindable query
        HDBManager::createCostEstimatioDataIdsQuery(match, &query, NULL, NULL, true);
        compiledQuery = HDBManager::getDBConnection()->query(query, false);
        costEstimationDataIDsQueries_[queryHash] = compiledQuery;
        return HDBManager::costEstimationDataIDs(match, true, compiledQuery); 
    }
}

References assert, HDB::HDBManager::costEstimationDataIDs(), costEstimationDataIDsQueries_, HDB::HDBManager::createCostEstimatioDataIdsQuery(), HDB::HDBManager::getDBConnection(), and RelationalDBConnection::query().

Here is the call graph for this function:

◆ costEstimationDataValue()

DataObject CachedHDBManager::costEstimationDataValue	(	const std::string &	valueName,
		const std::string &	pluginName
	)		const

virtual

Returns cost estimation data which is not connected to any machine implementation id.

This version assumes that there's only one entry with given parameters. Caches values by plugin name.

Parameters

valueName	Name of the value to fetch.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data.

Exceptions

KeyNotFound If the HDB does not contain cost estimation data with the given arguments.

Reimplemented from HDB::HDBManager.

Definition at line 271 of file CachedHDBManager.cc.

                                                                   {
    validateCache();
 
    std::map<std::string, std::map<std::string, DataObject> >::iterator iter =
        costEstimationPluginValueCache_.find(pluginName);
 
    if (iter != costEstimationPluginValueCache_.end()) {
        std::map<std::string, DataObject>::iterator it = 
            (*iter).second.find(valueName);
        if (it != (*iter).second.end()) {
            return (*it).second;
        } else {
            DataObject dataObject = HDBManager::costEstimationDataValue(valueName, pluginName);
            (*iter).second[valueName] = dataObject;
            return dataObject;
        }
    } else {
        std::map<std::string, DataObject> temp;
        DataObject dataObject = HDBManager::costEstimationDataValue(valueName, pluginName);
        temp[valueName] = dataObject;
        costEstimationPluginValueCache_[pluginName] = temp;
        return dataObject;
    }
}

References HDB::HDBManager::costEstimationDataValue(), costEstimationPluginValueCache_, and validateCache().

Here is the call graph for this function:

◆ createImplementationOfFU()

FUImplementation * CachedHDBManager::createImplementationOfFU	(	FUArchitecture &	architecture,
		RowID	id
	)		const

privatevirtual

Returns implementation of a FU with the given index.

Returns NULL if the FU doesn't have implementation.

First the FU implementation cache is searched for the ID, if the implementation is found in the cache, a copy of the cached item is returned. If the implementation was not found in the cache, a DB query is made using the base class implementation and the item is then added to the cache.

Parameters

id	ID of the FU implementation.

Returns: FU implementation.

Reimplemented from HDB::HDBManager.

Definition at line 461 of file CachedHDBManager.cc.

                                                  {
 
    validateCache();
 
    std::map<RowID, FUImplementation*>::iterator iter = fuImplCache_.find(id);
    if (iter != fuImplCache_.end()) {
        return new FUImplementation(*(*iter).second);
    }
 
    FUImplementation* impl =
        HDBManager::createImplementationOfFU(architecture, id);
 
    if (impl != NULL) {
        fuImplCache_[id] = impl;
        return new FUImplementation(*impl);
    } else {
        return NULL;
    }
}

References HDB::HDBManager::createImplementationOfFU(), fuImplCache_, and validateCache().

Here is the call graph for this function:

◆ createImplementationOfRF()

RFImplementation * CachedHDBManager::createImplementationOfRF ( RowID id ) const

privatevirtual

Returns implementation of a RF with the given index.

Returns NULL if the RF doesn't have implementation.

First the RF implementation cache is searched for the ID, if the implementation is found in the cache, a copy of the cached item is returned. If the implementation was not found in the cache, a DB query is made using the base class implementation and the item is then added to the cache.

Parameters

id	ID of the RF implementation.

Returns: RF implementation.

Reimplemented from HDB::HDBManager.

Definition at line 427 of file CachedHDBManager.cc.

                                                         {
 
    validateCache();
 
    std::map<RowID, RFImplementation*>::iterator iter = rfImplCache_.find(id);
    if (iter != rfImplCache_.end()) {
        return new RFImplementation(*(*iter).second);
    }
 
    RFImplementation* impl = HDBManager::createImplementationOfRF(id);
 
    if (impl != NULL) {
        rfImplCache_[id] = impl;
        return new RFImplementation(*impl);
    } else {
        return NULL;
    }
}

References HDB::HDBManager::createImplementationOfRF(), rfImplCache_, and validateCache().

Here is the call graph for this function:

◆ createNew()

CachedHDBManager & CachedHDBManager::createNew ( const std::string & file )

static

Creates a new HDB and returns CachedHDBManager instance for accessing it.

Parameters

file	Full path of the new HDB file.

Returns: CachedHDBManager instance accessing the newly created HDB.

Exceptions

UnreachableStream If the HDB creation was not succesful.

Definition at line 105 of file CachedHDBManager.cc.

                                                 {
    HDBManager::createNew(file);
    return instance(file);
}

References HDB::HDBManager::createNew(), and instance().

Referenced by HDBEditorMainFrame::createHDB().

Here is the call graph for this function:

◆ deleteCostEstimationDataIDsQueries()

void CachedHDBManager::deleteCostEstimationDataIDsQueries ( ) const

virtual

Deletes cached costEstimationDataIDs queries.

Implements HDB::HDBManager.

Definition at line 555 of file CachedHDBManager.cc.

                                                           {
    std::map<short int,RelationalDBQueryResult*>::iterator it = 
        costEstimationDataIDsQueries_.begin();
 
    while (it != costEstimationDataIDsQueries_.end()) {
        delete it->second;
        it->second = NULL;
        ++it;
    }
    costEstimationDataIDsQueries_.clear();
}

References costEstimationDataIDsQueries_.

◆ fuArchitectureByID()

FUArchitecture * CachedHDBManager::fuArchitectureByID ( RowID id ) const

virtual

Returns FU architecture with the given ID.

First the fu architecture cache is searched for the ID, if the architecture is found in the cache, a copy of the cached item is returned. If the architecture was not found in the cache, a DB query is made using the base class implementation and the item is then added to the cache.

Parameters

id	ID of the fu architecture.

Returns: FUArchitecture object with the give ID.

Exceptions

KeyNotFound if an architecture with the given id was not found.

Reimplemented from HDB::HDBManager.

Definition at line 218 of file CachedHDBManager.cc.

                                                   {
    validateCache();
 
    std::map<RowID, FUArchitecture*>::iterator iter = fuArchCache_.find(id);
    if (iter != fuArchCache_.end()) {
        return new FUArchitecture(*(*iter).second);
    }
 
    FUArchitecture* arch = HDBManager::fuArchitectureByID(id);
    fuArchCache_[id] = arch;
    return new FUArchitecture(*arch);
}

References fuArchCache_, HDB::HDBManager::fuArchitectureByID(), and validateCache().

Referenced by ComponentImplementationSelector::fuArchsByOpSetWithMinLatency().

Here is the call graph for this function:

◆ fuArchitectureByIDConst()

const FUArchitecture & CachedHDBManager::fuArchitectureByIDConst ( RowID id ) const

Definition at line 484 of file CachedHDBManager.cc.

                                                        {
 
    validateCache();
 
    std::map<RowID, FUArchitecture*>::iterator iter = fuArchCache_.find(id);
    if (iter == fuArchCache_.end()) {
        FUArchitecture* arch = HDBManager::fuArchitectureByID(id);
        fuArchCache_[id] = arch;
    }
    return *fuArchCache_[id];
}

References fuArchCache_, HDB::HDBManager::fuArchitectureByID(), and validateCache().

Referenced by HDBBrowserWindow::update().

Here is the call graph for this function:

◆ instance()

CachedHDBManager & CachedHDBManager::instance ( const std::string & hdbFile )

static

Returns a CachedHDBManager instance for the given file.

Only one instance is created per file.

Parameters

hdbFile Name of the HDB file to open.

Returns: An instance of HDBManager.

Exceptions

IOException If connection to the DB cannot be established.

Definition at line 89 of file CachedHDBManager.cc.

                                                   {
    HDBRegistry* registry = &HDBRegistry::instance();
    if (!registry->hasHDB(hdbFile)) {
        registry->addHDB(new CachedHDBManager(hdbFile));
    }
    return registry->hdb(hdbFile);
}

References HDB::HDBRegistry::addHDB(), HDB::HDBRegistry::hasHDB(), HDB::HDBRegistry::hdb(), and HDB::HDBRegistry::instance().

Referenced by ProGeTools::checkForSelectableFU(), Automagic::checkForSelectableFU(), ProGeTools::checkForSelectableIU(), Automagic::checkForSelectableIU(), ProGeTools::checkForSelectableRF(), Automagic::checkForSelectableRF(), ProGeTools::createFUGeneratableOperationInfos(), Automagic::createFUGeneratableOperationInfos(), FUGen::createImplementationFiles(), createNew(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::loadFromSearchPaths(), ImplementationTester::openHdb(), and FUGen::parseOperations().

Here is the call graph for this function:

◆ modifyCostEstimationData()

void CachedHDBManager::modifyCostEstimationData	(	RowID	id,
		const CostEstimationData &	data
	)

virtual

Cached (invalidates cache) function of HDBManager::modifyCostEstimationData.

Parameters

id
data

Exceptions

InvalidData
KeyNotFound

Reimplemented from HDB::HDBManager.

Definition at line 405 of file CachedHDBManager.cc.

                                              {
    costEstimationPluginValueCache_.clear();     
    HDBManager::modifyCostEstimationData(id, data);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::modifyCostEstimationData().

Here is the call graph for this function:

◆ modifyCostFunctionPlugin()

void CachedHDBManager::modifyCostFunctionPlugin	(	RowID	id,
		const CostFunctionPlugin &	plugin
	)

virtual

Cached (invalidates cache) function of HDBManager::modifyCostFunctionPlugin.

Parameters

id
plugin

Exceptions

InvalidData
KeyNotFound

Reimplemented from HDB::HDBManager.

Definition at line 307 of file CachedHDBManager.cc.

                                                {
    // can't say by rowid what plugin is modified
    costEstimationPluginValueCache_.clear();     
 
    HDBManager::modifyCostFunctionPlugin(id, plugin);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::modifyCostFunctionPlugin().

Here is the call graph for this function:

◆ removeBusEntry()

void CachedHDBManager::removeBusEntry ( RowID id ) const

virtual

Cached (invalidates cache) function of HDBManager::removeBusEntry.

Parameters

id

Reimplemented from HDB::HDBManager.

Definition at line 363 of file CachedHDBManager.cc.

                                               {
 
    costEstimationPluginValueCache_.clear();     
    HDBManager::removeBusEntry(id);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeBusEntry().

Here is the call graph for this function:

◆ removeCostEstimationData()

void CachedHDBManager::removeCostEstimationData ( RowID id ) const

virtual

Cached (invalidates cache) function of HDBManager::removeCostEstimationData.

Parameters

id

Reimplemented from HDB::HDBManager.

Definition at line 389 of file CachedHDBManager.cc.

                                                         {   
 
    costEstimationPluginValueCache_.clear();     
    HDBManager::removeCostEstimationData(id);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeCostEstimationData().

Here is the call graph for this function:

◆ removeCostFunctionPlugin()

void CachedHDBManager::removeCostFunctionPlugin ( RowID pluginID ) const

virtual

Cached (invalidates cache) function of HDBManager::removeCostFunctionPlugin.

Parameters

pluginID

Reimplemented from HDB::HDBManager.

Definition at line 322 of file CachedHDBManager.cc.

                                                               {
 
    // can't say by rowid what plugin is removed
    costEstimationPluginValueCache_.clear();     
 
    HDBManager::removeCostFunctionPlugin(pluginID);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeCostFunctionPlugin().

Here is the call graph for this function:

◆ removeFUArchitecture()

void CachedHDBManager::removeFUArchitecture ( RowID archID ) const

virtual

Removes FU architecture from the HDB.

Removes architecture from the cache and calls base class function to actually remove the FU architecture.

Parameters

archID ID of the FU architecture to remove.

Reimplemented from HDB::HDBManager.

Definition at line 119 of file CachedHDBManager.cc.

                                                         {
    // Remove architecture from the cache.
    std::map<RowID, FUArchitecture*>::iterator iter =
        fuArchCache_.find(archID);
 
    if (iter != fuArchCache_.end()) {
        delete (*iter).second;
        fuArchCache_.erase(iter);
    }
 
    HDBManager::removeFUArchitecture(archID);
}

References fuArchCache_, and HDB::HDBManager::removeFUArchitecture().

Here is the call graph for this function:

◆ removeFUEntry()

void CachedHDBManager::removeFUEntry ( RowID id ) const

virtual

Cached (invalidates cache) function of HDBManager::removeFUEntry.

Parameters

id

Reimplemented from HDB::HDBManager.

Definition at line 337 of file CachedHDBManager.cc.

                                              {
 
    costEstimationPluginValueCache_.clear();     
    HDBManager::removeFUEntry(id);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeFUEntry().

Here is the call graph for this function:

◆ removeFUImplementation()

void CachedHDBManager::removeFUImplementation ( RowID id ) const

virtual

Removes FU implementation from the HDB.

Removes implementation from the cache and calls base class function to actually remove the FU implementation.

Parameters

id	ID of the FU implementation to remove.

Reimplemented from HDB::HDBManager.

Definition at line 141 of file CachedHDBManager.cc.

                                                       {
 
    RowID entryID = fuEntryIDOfImplementation(id);
 
    // Remove implementation from the cache.
    std::map<RowID, FUImplementation*>::iterator iter =
        fuImplCache_.find(entryID);
 
    if (iter != fuImplCache_.end()) {
        delete (*iter).second;
        fuImplCache_.erase(iter);
    }
 
    HDBManager::removeFUImplementation(id);
}

References HDB::HDBManager::fuEntryIDOfImplementation(), fuImplCache_, and HDB::HDBManager::removeFUImplementation().

Here is the call graph for this function:

◆ removeRFArchitecture()

void CachedHDBManager::removeRFArchitecture ( RowID archID ) const

virtual

Removes RF architecture from the HDB.

Removes architecture from the cache and calls base class function to actually remove the RF architecture.

Parameters

archID ID of the RF architecture to remove.

Reimplemented from HDB::HDBManager.

Definition at line 167 of file CachedHDBManager.cc.

                                                         {
    // Remove architecture from the cache.
    std::map<RowID, RFArchitecture*>::iterator iter =
        rfArchCache_.find(archID);
 
    if (iter != rfArchCache_.end()) {
        delete (*iter).second;
        rfArchCache_.erase(iter);
    }
 
    HDBManager::removeRFArchitecture(archID);
}

References HDB::HDBManager::removeRFArchitecture(), and rfArchCache_.

Here is the call graph for this function:

◆ removeRFEntry()

void CachedHDBManager::removeRFEntry ( RowID id ) const

virtual

Cached (invalidates cache) function of HDBManager::removeRFEntry.

Parameters

id

Reimplemented from HDB::HDBManager.

Definition at line 350 of file CachedHDBManager.cc.

                                              {
 
    costEstimationPluginValueCache_.clear();     
    HDBManager::removeRFEntry(id);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeRFEntry().

Here is the call graph for this function:

◆ removeRFImplementation()

void CachedHDBManager::removeRFImplementation ( RowID id ) const

virtual

Removes RF implementation from the HDB.

Removes implementation from the cache and calls base class function to actually remove the RF implementation.

Parameters

id	ID of the RF implementation to remove.

Reimplemented from HDB::HDBManager.

Definition at line 189 of file CachedHDBManager.cc.

                                                       {
 
    RowID entryID = rfEntryIDOfImplementation(id);
 
    // Remove implementation from the cache.
    std::map<RowID, RFImplementation*>::iterator iter =
        rfImplCache_.find(entryID);
 
    if (iter != rfImplCache_.end()) {
        delete (*iter).second;
        rfImplCache_.erase(iter);
    }
 
    HDBManager::removeRFImplementation(id);
}

References HDB::HDBManager::removeRFImplementation(), HDB::HDBManager::rfEntryIDOfImplementation(), and rfImplCache_.

Here is the call graph for this function:

◆ removeSocketEntry()

void CachedHDBManager::removeSocketEntry ( RowID id ) const

virtual

Cached (invalidates cache) function of HDBManager::removeSocketEntry.

Parameters

id

Reimplemented from HDB::HDBManager.

Definition at line 376 of file CachedHDBManager.cc.

                                                  {
 
    costEstimationPluginValueCache_.clear();     
    HDBManager::removeSocketEntry(id);
}

References costEstimationPluginValueCache_, and HDB::HDBManager::removeSocketEntry().

Here is the call graph for this function:

◆ rfArchitectureByID()

RFArchitecture * CachedHDBManager::rfArchitectureByID ( RowID id ) const

virtual

Returns RF architecture with the given ID.

First the RF architecture cache is searched for the ID, if the architecture is found in the cache, a copy of the cached item is returned. If the architecture was not found in the cache, a DB query is made using the base class implementation and the item is then added to the cache.

Parameters

id	ID of the fu architecture.

Returns: RFArchitecture object with the give ID.

Exceptions

KeyNotFound if an architecture with the given id was not found.

Reimplemented from HDB::HDBManager.

Definition at line 244 of file CachedHDBManager.cc.

                                                   {
    validateCache();
 
    std::map<RowID, RFArchitecture*>::iterator iter = rfArchCache_.find(id);
    if (iter != rfArchCache_.end()) {
        return new RFArchitecture(*(*iter).second);
    }
 
    RFArchitecture* arch = HDBManager::rfArchitectureByID(id);
    rfArchCache_[id] = arch;
    return new RFArchitecture(*arch);
}

References rfArchCache_, HDB::HDBManager::rfArchitectureByID(), and validateCache().

Here is the call graph for this function:

◆ rfArchitectureByIDConst()

const RFArchitecture & CachedHDBManager::rfArchitectureByIDConst ( RowID id ) const

Definition at line 498 of file CachedHDBManager.cc.

                                                        {
 
    validateCache();
 
    std::map<RowID, RFArchitecture*>::iterator iter = rfArchCache_.find(id);
    if (iter == rfArchCache_.end()) {
        RFArchitecture* arch = HDBManager::rfArchitectureByID(id);
        rfArchCache_[id] = arch;
    }
    return *rfArchCache_[id];
}

References rfArchCache_, HDB::HDBManager::rfArchitectureByID(), and validateCache().

Here is the call graph for this function:

◆ validateCache()

void CachedHDBManager::validateCache ( ) const

private

Checks if HDB file is modified. In case it is, invalid cache is cleared.

Definition at line 572 of file CachedHDBManager.cc.

                                      {
    std::string hdbFile = HDBManager::fileName();
    std::time_t modTime = FileSystem::lastModificationTime(hdbFile);
    uintmax_t byteSize = FileSystem::sizeInBytes(hdbFile);
    
    if (modTime == std::time_t(-1) || 
        byteSize == static_cast<uintmax_t>(-1)) {
        // problems accessing the file
        return;
    } else if (lastModificationTime_ == modTime && 
               lastSizeInBytes_ == byteSize) {
        // no changes
        return;
    }
 
    // delete all cached items
    MapTools::deleteAllValues(fuArchCache_);
    MapTools::deleteAllValues(rfArchCache_);
    MapTools::deleteAllValues(fuImplCache_);
    MapTools::deleteAllValues(rfImplCache_);
    costEstimationPluginValueCache_.clear();
 
    // set current size and modification time
    lastModificationTime_ = modTime;
    lastSizeInBytes_ = byteSize;
}

References costEstimationPluginValueCache_, MapTools::deleteAllValues(), HDB::HDBManager::fileName(), fuArchCache_, fuImplCache_, FileSystem::lastModificationTime(), lastModificationTime_, lastSizeInBytes_, rfArchCache_, rfImplCache_, and FileSystem::sizeInBytes().

Referenced by costEstimationDataValue(), createImplementationOfFU(), createImplementationOfRF(), fuArchitectureByID(), fuArchitectureByIDConst(), rfArchitectureByID(), and rfArchitectureByIDConst().

Here is the call graph for this function:

Member Data Documentation

◆ costEstimationDataIDsQueries_

std::map<short int, RelationalDBQueryResult*> HDB::CachedHDBManager::costEstimationDataIDsQueries_

mutableprivate

map of cached (compiled) queries for costEstimatioDataIDs function

Definition at line 143 of file CachedHDBManager.hh.

Referenced by costEstimationDataIDs(), and deleteCostEstimationDataIDsQueries().

◆ costEstimationPluginValueCache_

std::map<std::string, std::map<std::string, DataObject> > HDB::CachedHDBManager::costEstimationPluginValueCache_

mutableprivate

Cost estimation plugin value cache (pluginName/valueName)

Definition at line 139 of file CachedHDBManager.hh.

Referenced by costEstimationDataValue(), modifyCostEstimationData(), modifyCostFunctionPlugin(), removeBusEntry(), removeCostEstimationData(), removeCostFunctionPlugin(), removeFUEntry(), removeRFEntry(), removeSocketEntry(), validateCache(), and ~CachedHDBManager().

◆ fuArchCache_

std::map<RowID, FUArchitecture*> HDB::CachedHDBManager::fuArchCache_

mutableprivate

FU Architecture cache.

Definition at line 130 of file CachedHDBManager.hh.

Referenced by fuArchitectureByID(), fuArchitectureByIDConst(), removeFUArchitecture(), validateCache(), and ~CachedHDBManager().

◆ fuImplCache_

std::map<RowID, FUImplementation*> HDB::CachedHDBManager::fuImplCache_

mutableprivate

FU Implementation cache.

Definition at line 134 of file CachedHDBManager.hh.

Referenced by createImplementationOfFU(), removeFUImplementation(), validateCache(), and ~CachedHDBManager().

◆ lastModificationTime_

std::time_t HDB::CachedHDBManager::lastModificationTime_

mutableprivate

used to detect modifications to the HDB file (which invalidates cache)

Definition at line 146 of file CachedHDBManager.hh.

Referenced by CachedHDBManager(), and validateCache().

◆ lastSizeInBytes_

uintmax_t HDB::CachedHDBManager::lastSizeInBytes_

mutableprivate

used to detect modifications to the HDB file (which invalidates cache)

Definition at line 148 of file CachedHDBManager.hh.

Referenced by CachedHDBManager(), and validateCache().

◆ rfArchCache_

std::map<RowID, RFArchitecture*> HDB::CachedHDBManager::rfArchCache_

mutableprivate

RF Architecture cache.

Definition at line 132 of file CachedHDBManager.hh.

Referenced by removeRFArchitecture(), rfArchitectureByID(), rfArchitectureByIDConst(), validateCache(), and ~CachedHDBManager().

◆ rfImplCache_

std::map<RowID, RFImplementation*> HDB::CachedHDBManager::rfImplCache_

mutableprivate

RF Implementation cache.

Definition at line 136 of file CachedHDBManager.hh.

Referenced by createImplementationOfRF(), removeRFImplementation(), validateCache(), and ~CachedHDBManager().

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~CachedHDBManager()

◆ CachedHDBManager()

Member Function Documentation

◆ costEstimationDataIDs()

◆ costEstimationDataValue()

◆ createImplementationOfFU()

◆ createImplementationOfRF()

◆ createNew()

◆ deleteCostEstimationDataIDsQueries()

◆ fuArchitectureByID()

◆ fuArchitectureByIDConst()

◆ instance()

◆ modifyCostEstimationData()

◆ modifyCostFunctionPlugin()

◆ removeBusEntry()

◆ removeCostEstimationData()

◆ removeCostFunctionPlugin()

◆ removeFUArchitecture()

◆ removeFUEntry()

◆ removeFUImplementation()

◆ removeRFArchitecture()

◆ removeRFEntry()

◆ removeRFImplementation()

◆ removeSocketEntry()

◆ rfArchitectureByID()

◆ rfArchitectureByIDConst()

◆ validateCache()

Member Data Documentation

◆ costEstimationDataIDsQueries_

◆ costEstimationPluginValueCache_

◆ fuArchCache_

◆ fuImplCache_

◆ lastModificationTime_

◆ lastSizeInBytes_

◆ rfArchCache_

◆ rfImplCache_