#include <HDBManager.hh>

Inheritance diagram for HDB::HDBManager:

Collaboration diagram for HDB::HDBManager:

Classes
struct	PipelineElementUsage

Public Types
typedef std::list< DataObject >	DataObjectList

Public Member Functions
virtual	~HDBManager ()

std::string	fileName () const

RowID	addCostFunctionPlugin (const CostFunctionPlugin &plugin) const

virtual void	removeCostFunctionPlugin (RowID pluginID) const

RowID	addFUArchitecture (const FUArchitecture &architecture) const

bool	canRemoveFUArchitecture (RowID archID) const

virtual void	removeFUArchitecture (RowID archID) const

RowID	addFUEntry () const

virtual void	removeFUEntry (RowID id) const

RowID	addFUImplementation (const FUEntry &entry) const

virtual void	removeFUImplementation (RowID implementationID) const

void	setArchitectureForFU (RowID fuID, RowID archID) const

void	unsetArchitectureForFU (RowID fuID) const

RowID	addRFArchitecture (const RFArchitecture &architecture) const

bool	canRemoveRFArchitecture (RowID archID) const

virtual void	removeRFArchitecture (RowID archID) const

RowID	addRFEntry () const

virtual void	removeRFEntry (RowID id) const

RowID	addRFImplementation (const RFImplementation &implementation, RowID rfEntryID)

virtual void	removeRFImplementation (RowID implID) const

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

virtual FUArchitecture *	fuArchitectureByID (RowID id) const

virtual RFArchitecture *	rfArchitectureByID (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

virtual DataObject	costEstimationDataValue (const std::string &valueName, const std::string &pluginName) 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

virtual void	removeBusEntry (RowID id) 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

virtual void	removeSocketEntry (RowID id) 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

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

RowID	addCostEstimationData (const CostEstimationData &data) const

virtual void	removeCostEstimationData (RowID id) const

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

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

virtual void	deleteCostEstimationDataIDsQueries () const =0

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

Static Public Member Functions
static void	createNew (const std::string &file)

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

Protected Member Functions
virtual RFImplementation *	createImplementationOfRF (RowID id) const

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

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)

Private Types
typedef std::vector< PipelineElementUsage >	PipelineElementUsageTable

Private Member Functions
bool	hasFUEntry (RowID id) const

bool	hasRFEntry (RowID id) const

bool	hasBusEntry (RowID id) const

bool	hasSocketEntry (RowID id) const

bool	hasCostEstimationDataByID (RowID id) const

bool	hasCostFunctionPluginByID (RowID id) const

bool	fuEntryHasArchitecture (RowID id) const

bool	rfEntryHasArchitecture (RowID id) const

bool	containsOperation (const std::string &opName) const

bool	containsImplementationFile (const std::string &pathToFile) const

bool	containsFUArchitecture (RowID id) const

bool	containsRFArchitecture (RowID id) const

RowID	fuArchitectureID (RowID fuEntryID) const

RowID	rfArchitectureID (RowID rfEntryID) const

bool	hasColumn (const std::string &table, const std::string &columnName) const

int	addBooleanColumn (const std::string &table, const std::string &newcolumn)

CostFunctionPlugin *	createCostFunctionOfFU (RowID id) const

CostFunctionPlugin *	createCostFunctionOfRF (RowID id) const

void	addPortsAndBindingsToFUArchitecture (FUArchitecture &architecture, RowID id) const

void	addOperationPipelinesToFUArchitecture (FUArchitecture &architecture, RowID id) const

std::string	resolveArchitecturePort (const FUArchitecture &architecture, RowID entryID, const std::string &implementedPort) const

void	addOpcodesToImplementation (FUImplementation &implementation, RowID entryID) const

void	addDataPortsToImplementation (FUImplementation &implementation, FUArchitecture &architecture, RowID entryID) const

void	addFUExternalPortsToImplementation (FUImplementation &implementation, RowID entryID) const

void	addRFExternalPortsToImplementation (RFImplementation &implementation, RowID entryID) const

void	addFUParametersToImplementation (FUImplementation &implementation, RowID entryID) const

void	addRFParametersToImplementation (RFImplementation &implementation, RowID entryID) const

void	addBlockImplementationFiles (FUImplementation &implementation, RowID entryID) const

void	addDataPortsToImplementation (RFImplementation &implementation, RowID entryID) const

void	addBlockImplementationFiles (RFImplementation &implementation, RowID entryID) const

void	addBlockImplementationFileToHDB (const BlockImplementationFile &file) const

void	createCostEstimatioDataIdsQuery (const CostEstimationData &match, std::string &query) const

Static Private Member Functions
static bool	isMatchingArchitecture (const TTAMachine::FunctionUnit &fu, const FUArchitecture &arch)

static bool	areCompatiblePipelines (const PipelineElementUsageTable &table)

static void	insertFileFormats (RelationalDBConnection &connection)

static BlockImplementationFile::Format	fileFormat (const std::string &formatString)

static std::string	directionString (HDB::Direction direction)

static std::string	fuEntryByIDQuery (RowID id)

static std::string	rfEntryByIDQuery (RowID id)

static std::string	busEntryByIDQuery (RowID id)

static std::string	socketEntryByIDQuery (RowID id)

static std::string	fuArchitectureByIDQuery (RowID id)

static std::string	fuPortsAndBindingsByIDQuery (RowID id)

static std::string	ioUsageDataByIDQuery (RowID id)

static std::string	resourceUsageDataByIDQuery (RowID id)

static std::string	fuImplementationByIDQuery (RowID id)

static std::string	opcodesByIDQuery (RowID id)

static std::string	fuImplementationDataPortsByIDQuery (RowID id)

static std::string	fuExternalPortsByIDQuery (RowID id)

static std::string	rfExternalPortsByIDQuery (RowID id)

static std::string	fuPortBindingByNameQuery (RowID fuID, const std::string &portName)

static std::string	fuImplementationParametersByIDQuery (RowID id)

static std::string	rfImplementationParametersByIDQuery (RowID id)

static std::string	fuSourceFilesByIDQuery (RowID id)

static std::string	rfArchitectureByIDQuery (RowID id)

static std::string	rfImplementationByIDQuery (RowID id)

static std::string	rfImplementationByIDQuery2 (RowID id)

static std::string	rfImplementationDataPortsByIDQuery (RowID id)

static std::string	rfSourceFilesByIDQuery (RowID id)

Private Attributes
SQLite *	db_
	Handle to the database.

RelationalDBConnection *	dbConnection_
	Handle to the database connection.

std::string	hdbFile_
	The HDB file to manager.

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

Friends
class	HDBManagerTest

Detailed Description

Class used to access hardware database (HDB).

Provides methods to create new HDB and to search, add, and remove blocks from/to HDB. There can exist only one HDBManager instance per database at the same time because HDBManager creates a connection to the database in its constructor and does not close the connection unless the HDBManager instance is deleted. And there cannot be several connections to the same database at the same time.

Definition at line 82 of file HDBManager.hh.

Member Typedef Documentation

◆ DataObjectList

typedef std::list<DataObject> HDB::HDBManager::DataObjectList

Definition at line 86 of file HDBManager.hh.

◆ PipelineElementUsageTable

typedef std::vector<PipelineElementUsage> HDB::HDBManager::PipelineElementUsageTable

private

Definition at line 297 of file HDBManager.hh.

Constructor & Destructor Documentation

◆ ~HDBManager()

HDB::HDBManager::~HDBManager ( )

virtual

The destructor.

Definition at line 520 of file HDBManager.cc.

                        {
    db_->close(*dbConnection_);
    delete db_;
}

References SQLite::close(), db_, and dbConnection_.

Here is the call graph for this function:

◆ HDBManager()

HDB::HDBManager::HDBManager ( const std::string & hdbFile )

protected

The constructor.

Parameters

hdbFile Name of the HDB file to be managed by the manager.

Exceptions

IOException If connection to the DB cannot be established.

Definition at line 394 of file HDBManager.cc.

    : db_(new SQLite()), dbConnection_(NULL), hdbFile_(hdbFile) {
    if (!FileSystem::fileExists(hdbFile)) {
        string errorMsg = "File '" + hdbFile + "' doesn't exist.";
        throw FileNotFound(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    if (!FileSystem::fileIsReadable(hdbFile)) {
        string errorMsg = "File '" + hdbFile + "' has no read rights.";
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    try {
        dbConnection_ = &db_->connect(hdbFile);
    } catch (const RelationalDBException& exception) {
        throw IOException(
            __FILE__, __LINE__, __func__, exception.errorMessage());
    }
 
    // Update outdated HDB.
    // Version 0 indicates db without version number also.
    int dbVersion = dbConnection_->version();
 
    // Version 0 -> 1
    if (dbVersion < 1) {
        // Initial fu-gen tables and fugen stuff.
        dbConnection_->DDLQuery(CQ_OPERATION_IMPLEMENTATION_RESOURCE);
        dbConnection_->DDLQuery(CQ_OPERATION_IMPLEMENTATION);
        dbConnection_->DDLQuery(
            CQ_OPERATION_IMPLEMENTATION_RESOURCE_SOURCE_FILE);
        dbConnection_->DDLQuery(CQ_OPERATION_IMPLEMENTATION_SOURCE_FILE);
        dbConnection_->DDLQuery(CQ_OPERATION_IMPLEMENTATION_RESOURCES);
        dbConnection_->updateQuery(std::string(
                "INSERT INTO format(id,format) VALUES"
                "(NULL,\"" + VHDL_SIM_FORMAT + "\");"));
        dbConnection_->updateQuery(std::string(
                "INSERT INTO format(id,format) VALUES"
                "(NULL,\"" + VERILOG_SIM_FORMAT + "\");"));
        dbConnection_->updateVersion(1);
    }
 
    // Version 1 -> 2
    if (dbVersion < 2) {
        // Variables for operation snippets.
        dbConnection_->DDLQuery(CQ_OPERATION_IMPLEMENTATION_VARIABLE);
        dbConnection_->updateVersion(2);
    }
 
    // Version 2 -> 3
    if (dbVersion < 3) {
        // ipxact to resource table
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation_resource ADD COLUMN "
            "ipxact TEXT;"));
        dbConnection_->updateVersion(3);
    }
 
    // Version 3 -> 4
    if (dbVersion < 4) {
        // support for post-operation (for LOADs) and
        //  operation bus definitions for FUGen.
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation ADD COLUMN "
            "bus_definition TEXT;"));
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation ADD COLUMN "
            "post_op_vhdl TEXT;"));
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation ADD COLUMN "
            "post_op_verilog TEXT;"));
        dbConnection_->updateVersion(4);
    }
 
    // Version 4 -> 5
    if (dbVersion < 5) {
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation_resource ADD COLUMN "
            "latency INTEGER;"));
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation ADD COLUMN "
            "default_verilog TEXT;"));
        dbConnection_->updateQuery(std::string(
            "ALTER TABLE operation_implementation ADD COLUMN "
            "default_vhdl TEXT;"));
        dbConnection_->updateVersion(5);
    }
 
    // Version 5 -> 6
    if (dbVersion < 6) {
        try {
            // rename default_vhdl and default_verilog to initial_*
            // and add latency column
            dbConnection_->updateQuery(std::string(
                "ALTER TABLE operation_implementation ADD COLUMN "
                "latency INTEGER;"));
            dbConnection_->updateQuery(std::string(
                "ALTER TABLE operation_implementation RENAME COLUMN "
                "default_vhdl TO initial_vhdl;"));
            dbConnection_->updateQuery(std::string(
                "ALTER TABLE operation_implementation RENAME COLUMN "
                "default_verilog TO initial_verilog;"));
            dbConnection_->updateVersion(6);
        } catch (const RelationalDBException& exception) {
            throw IOException(
                __FILE__, __LINE__, __func__, exception.errorMessage());
        }
        dbConnection_->updateVersion(6);
    }
 
    if (dbVersion < 7) {
        try {
            if (!hasColumn("rf_architecture", "zero_register")) {
                addBooleanColumn("rf_architecture", "zero_register");
            }
        } catch (const RelationalDBException& exception) {
            throw IOException(
                __FILE__, __LINE__, __func__, exception.errorMessage());
        }
        dbConnection_->updateVersion(7);
    }
 
}

References __func__, addBooleanColumn(), SQLite::connect(), CQ_OPERATION_IMPLEMENTATION, CQ_OPERATION_IMPLEMENTATION_RESOURCE, CQ_OPERATION_IMPLEMENTATION_RESOURCE_SOURCE_FILE, CQ_OPERATION_IMPLEMENTATION_RESOURCES, CQ_OPERATION_IMPLEMENTATION_SOURCE_FILE, CQ_OPERATION_IMPLEMENTATION_VARIABLE, db_, dbConnection_, RelationalDBConnection::DDLQuery(), Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileIsReadable(), hasColumn(), RelationalDBConnection::updateQuery(), RelationalDBConnection::updateVersion(), VERILOG_SIM_FORMAT, RelationalDBConnection::version(), and VHDL_SIM_FORMAT.

Here is the call graph for this function:

Member Function Documentation

◆ addBlockImplementationFiles() [1/2]

void HDB::HDBManager::addBlockImplementationFiles	(	FUImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds the block implementation files to the given FU implementation which is the implementation of the FU entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the FU entry.

Definition at line 5323 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* sourceFileData = NULL;
    try {
        sourceFileData = dbConnection_->query(
            fuSourceFilesByIDQuery(entryID));
    } catch (const Exception&) {
        assert(false);
    }
    
    int fileColumn = sourceFileData->column("block_source_file.file");
    int formatColumn = sourceFileData->column("format.format");
    
    while (sourceFileData->hasNext()) {
        sourceFileData->next();
        const DataObject& fileData = sourceFileData->data(fileColumn);
        const DataObject& formatData = sourceFileData->data(
            formatColumn);
        BlockImplementationFile::Format format = fileFormat(
            formatData.stringValue());
        BlockImplementationFile* file = new BlockImplementationFile(
            fileData.stringValue(), format);
        implementation.addImplementationFile(file);
    }
    
    delete sourceFileData;
    sourceFileData = NULL;
}

References assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, fileFormat(), fuSourceFilesByIDQuery(), RelationalDBQueryResult::hasNext(), implementation, RelationalDBQueryResult::next(), RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by createImplementationOfFU(), and createImplementationOfRF().

Here is the call graph for this function:

◆ addBlockImplementationFiles() [2/2]

void HDB::HDBManager::addBlockImplementationFiles	(	RFImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds the block implementation files to the given RF implementation which is the implementation of the RF entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the RF entry.

Definition at line 5429 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(rfSourceFilesByIDQuery(entryID));
    } catch (const Exception&) {
        assert(false);
    }
 
    int fileColumn = result->column("block_source_file.file");
    int formatColumn = result->column("format.format");
 
    while (result->hasNext()) {
        result->next();
        const DataObject& fileData = result->data(fileColumn);
        const DataObject& formatData = result->data(formatColumn);
        BlockImplementationFile::Format format = fileFormat(
            formatData.stringValue());
        BlockImplementationFile* file = new BlockImplementationFile(
            fileData.stringValue(), format);
        implementation.addImplementationFile(file);
    }
 
    delete result;
    result = NULL;
}

References assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, fileFormat(), RelationalDBQueryResult::hasNext(), implementation, RelationalDBQueryResult::next(), RelationalDBConnection::query(), rfSourceFilesByIDQuery(), and DataObject::stringValue().

Here is the call graph for this function:

◆ addBlockImplementationFileToHDB()

void HDB::HDBManager::addBlockImplementationFileToHDB ( const BlockImplementationFile & file ) const

private

Adds the given block implementation file to the HDB.

Parameters

file	The file to add.

Definition at line 5484 of file HDBManager.cc.

                                               {
    if (!containsImplementationFile(file.pathToFile())) {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO block_source_file(id,file,format) "
                "VALUES(NULL,\"" + file.pathToFile() +
                "\",(SELECT id FROM format WHERE format=\"" +
                formatString(file.format()) + "\"));"));
    }
}

References containsImplementationFile(), dbConnection_, HDB::BlockImplementationFile::format(), formatString(), HDB::BlockImplementationFile::pathToFile(), and RelationalDBConnection::updateQuery().

Referenced by addFUImplementation(), and addRFImplementation().

Here is the call graph for this function:

◆ addBooleanColumn()

int HDB::HDBManager::addBooleanColumn	(	const std::string &	table,
		const std::string &	newcolumn
	)

private

Inserts a new boolean type column into existing table.

Parameters

table	The name of the targeted table.
newColumn	The name of the new column.

Returns: Number of rows affected by the change.

Definition at line 4366 of file HDBManager.cc.

                                {
    std::string add_column_query("ALTER TABLE ");
    add_column_query += table + " ADD COLUMN " + newcolumn;
    add_column_query += " INTEGER DEFAULT 0;";
 
    int result = 0;
 
    try {
        result = dbConnection_->updateQuery(add_column_query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    return result;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), and RelationalDBConnection::updateQuery().

Referenced by addRFImplementation(), and HDBManager().

Here is the call graph for this function:

◆ addBusCostEstimationData()

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

Adds the given cost estimation data values to given Bus entry.

Parameters

busID The ID of the Bus entry the cost data will be added. @valueName The name of the cost value. @value The cost value. @pluginID The ID of the cost function plugin that owns this data.

Definition at line 3451 of file HDBManager.cc.

                          {
 
 
    RowID dataID;
 
    // add the data
    try {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO cost_estimation_data (id,plugin_reference,"
                "bus_reference,name,value) VALUES (NULL," + 
                Conversion::toString(pluginID) + "," + 
                Conversion::toString(busID) + ",\"" + valueName + "\",\"" +
                value + "\");"));
        dataID = dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    return dataID;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addBusEntry()

RowID HDB::HDBManager::addBusEntry ( ) const

Adds an empty Bus entry to the database.

Parameters

entry The Bus entry.

Returns: ID of the added Bus entry.

Definition at line 3379 of file HDBManager.cc.

                              {
    try {
        dbConnection_->updateQuery(
            std::string("INSERT INTO bus(id) VALUES(NULL);"));
        return dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}    

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), and RelationalDBConnection::updateQuery().

Referenced by AddBusEntryCmd::Do().

Here is the call graph for this function:

◆ addCostEstimationData()

RowID HDB::HDBManager::addCostEstimationData ( const CostEstimationData & data ) const

Adds cost estimation data to the HDB.

Parameters

data	Cost estimation data to add.

Returns: Row ID of the added cost data.

Definition at line 6680 of file HDBManager.cc.

                                                                      {
    if (!data.hasName() || !data.hasValue() || !data.hasPluginID()) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    std::string query =
        std::string("INSERT INTO cost_estimation_data"
                    " (id, name, value, plugin_reference, "
                    "  fu_reference, rf_reference, "
                    "  bus_reference, socket_reference) VALUES (") +
        "NULL, '" + data.name()  + "', '" +
        data.value().stringValue() + "', " +
        Conversion::toString(data.pluginID()) + ", ";
 
    // FU Reference
    if (data.hasFUReference()) {
        if (!hasFUEntry(data.fuReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += Conversion::toString(data.fuReference());
        query += ", ";
    } else {
        query += "NULL, ";
    }
 
    // RF Reference
    if (data.hasRFReference()) {
        if (!hasRFEntry(data.rfReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += Conversion::toString(data.rfReference());
        query += ", ";
    } else {
        query += "NULL, ";
    }
 
    // Bus Reference
    if (data.hasBusReference()) {
        if (!hasBusEntry(data.busReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += Conversion::toString(data.busReference());
        query += ", ";
    } else {
        query += "NULL, ";
    }
 
    // Socket Reference
    if (data.hasSocketReference()) {
        if (!hasSocketEntry(data.socketReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += Conversion::toString(data.socketReference());
        query += ");";
    } else {
        query += "NULL);";
    }
 
    try {
        dbConnection_->updateQuery(query);
        return dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}

Referenced by CostEstimationDataDialog::onOK().

Here is the call graph for this function:

◆ addCostFunctionPlugin()

RowID HDB::HDBManager::addCostFunctionPlugin ( const CostFunctionPlugin & plugin ) const

Add the given CostFunctionPlugin to the database.

Parameters

plugin The CostFunctionPlugin to add.

Returns: ID of the plugin added.

Exceptions

Exception May throw InvalidData if the CostFunctionPlugin type is unknown.

Definition at line 612 of file HDBManager.cc.

                                                                        {
    RowID pluginID;
    try {
        dbConnection_->beginTransaction();
 
        // insert into cost_function_plugin table
        string description = plugin.description();
        string pluginFilePath = plugin.pluginFilePath();
        string type = "";
        switch (plugin.type()) {
        case CostFunctionPlugin::COST_FU:
            type = COST_PLUGIN_TYPE_FU;
            break;
        case CostFunctionPlugin::COST_RF:
            type = COST_PLUGIN_TYPE_RF;
            break;
        case CostFunctionPlugin::COST_DECOMP:
            type = COST_PLUGIN_TYPE_DECOMP;
            break;
        case CostFunctionPlugin::COST_ICDEC:
            type = COST_PLUGIN_TYPE_ICDEC;
            break;
        default:
            InvalidData ex(
                __FILE__, __LINE__, __func__,
                (boost::format("Illegal cost_function_plugin type %d.") %
                 type).str());
            throw ex;
            break;
        }
        string name = plugin.name();
 
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO cost_function_plugin(id,description,name,"
                "plugin_file_path,type) VALUES"
                "(NULL,\"" + description + "\",\"" + name + "\",\"" +
                 pluginFilePath + "\",\"" + type + "\");"));
        pluginID = dbConnection_->lastInsertRowID();
        dbConnection_->commit();
    } catch (const RelationalDBException& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
    return pluginID;
}

Referenced by AddCostFunctionPluginCmd::Do().

Here is the call graph for this function:

◆ addDataPortsToImplementation() [1/2]

void HDB::HDBManager::addDataPortsToImplementation	(	FUImplementation &	implementation,
		FUArchitecture &	architecture,
		RowID	entryID
	)		const

private

Adds data ports to the given FU implementation which is the implementation of the FU entry that has the given ID.

Parameters

implementation	The implementation.
architecture	The corresponding architecture.
entryID	ID of the FU entry.

Definition at line 4992 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* portData = NULL;
    try {
        portData = dbConnection_->query(
            fuImplementationDataPortsByIDQuery(entryID));
    } catch (const Exception& e) {
        assert(false);
    }
    int portNameColumn = portData->column("fu_port_map.name");
    int widthFormulaColumn = portData->column("fu_port_map.width_formula");
    int loadPortColumn = portData->column("fu_port_map.load_port");
    int guardPortColumn = portData->column("fu_port_map.guard_port");
    
    while (portData->hasNext()) {
        portData->next();
        const DataObject& portNameData = portData->data(portNameColumn);
        const DataObject& widthFormulaData = portData->data(
            widthFormulaColumn);
        const DataObject& loadPortData = portData->data(loadPortColumn);
        const DataObject& guardPortData = portData->data(guardPortColumn);
        
        string portName = portNameData.stringValue();
        string widthFormula = widthFormulaData.stringValue();
        string loadPort = loadPortData.stringValue();
        string guardPort = guardPortData.stringValue();
        string architecturePort = resolveArchitecturePort(
            architecture, entryID, portName);
        new FUPortImplementation(
            portName, architecturePort, widthFormula, loadPort, guardPort,
            implementation);
    }
 
    delete portData;
    portData = NULL;
}

References assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, fuImplementationDataPortsByIDQuery(), RelationalDBQueryResult::hasNext(), implementation, RelationalDBQueryResult::next(), RelationalDBConnection::query(), resolveArchitecturePort(), and DataObject::stringValue().

Referenced by createImplementationOfFU(), and createImplementationOfRF().

Here is the call graph for this function:

◆ addDataPortsToImplementation() [2/2]

void HDB::HDBManager::addDataPortsToImplementation	(	RFImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds data ports to the given RF implementation which is the implementation of the RF entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the RF entry.

Definition at line 5363 of file HDBManager.cc.

                         {
 
    // obtain port data from HDB and add ports to RF implementation
    RelationalDBQueryResult* portData = NULL;
    try {
        portData = dbConnection_->query(
            rfImplementationDataPortsByIDQuery(entryID));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    
    int portNameColumn = portData->column("name");
    int directionColumn = portData->column("direction");
    int loadPortColumn = portData->column("load_port");
    int opcodePortColumn = portData->column("opcode_port");
    int opcodePortFormulaColumn = portData->column(
        "opcode_port_width_formula");
    assert(portNameColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(directionColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(loadPortColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(opcodePortColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(
        opcodePortFormulaColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
        
    while (portData->hasNext()) {
        portData->next();
        const DataObject& portNameData = portData->data(portNameColumn);
        const DataObject& directionData = portData->data(
            directionColumn);
        const DataObject& loadPortData = portData->data(loadPortColumn);
        const DataObject& opcodePortData = portData->data(
            opcodePortColumn);
        const DataObject& opcodePortFormulaData = portData->data(
            opcodePortFormulaColumn);
        Direction direction;
        if (directionData.stringValue() == IN_DIRECTION) {
            direction = IN;
        } else if (directionData.stringValue() == OUT_DIRECTION) {
            direction = OUT;
        } else if (directionData.stringValue() == BIDIR_DIRECTION) {
            direction = BIDIR;
        } else {
            assert(false);
        }
        new RFPortImplementation(
            portNameData.stringValue(), direction, 
            loadPortData.stringValue(), opcodePortData.stringValue(),
            opcodePortFormulaData.stringValue(), implementation);
    }
    
    delete portData;
    portData = NULL;
}

References assert, HDB::BIDIR, BIDIR_DIRECTION, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), implementation, HDB::IN, IN_DIRECTION, RelationalDBQueryResult::next(), HDB::OUT, OUT_DIRECTION, RelationalDBConnection::query(), rfImplementationDataPortsByIDQuery(), DataObject::stringValue(), and RelationalDBQueryResult::UNKNOWN_INDEX.

Here is the call graph for this function:

◆ addFUArchitecture()

RowID HDB::HDBManager::addFUArchitecture ( const FUArchitecture & arch ) const

Adds the given FU architecture to the database.

Parameters

arch	The FU architecture to add.

Returns: ID of the architecture added.

Exceptions

InvalidData If the FU architecture is invalid.

Definition at line 703 of file HDBManager.cc.

                                                              {
    // check the operand bindings of the FU
    FunctionUnit& fu = arch.architecture();
    MachineValidatorResults results;
    FUValidator::checkOperations(fu, results);
    FUValidator::checkOperandBindings(fu, results);
    if (results.errorCount() > 0) {
        throw InvalidData(
            __FILE__, __LINE__, __func__, results.error(0).second);
    }
        
    RowID archID;
    std::map<FUPort*, RowID> portIDMap;
 
    try {
        dbConnection_->beginTransaction();
 
        // insert into fu_architecture table
        dbConnection_->updateQuery(
            std::string("INSERT INTO fu_architecture(id) VALUES(NULL);"));
        archID = dbConnection_->lastInsertRowID();
 
        // insert into fu_data_port table
        for (int i = 0; i < fu.operationPortCount(); i++) {
            FUPort* port = fu.operationPort(i);
            string query(
                "INSERT INTO fu_data_port(id,triggers,sets_opcode,"
                "guard_support,width,fu_arch) "
                "VALUES(NULL," + 
                Conversion::toString(port->isTriggering()) + "," + 
                Conversion::toString(port->isOpcodeSetting()) + "," +
                Conversion::toString(arch.hasGuardSupport(port->name()))
                + ",");
            if (arch.hasParameterizedWidth(port->name())) {
                query += "NULL,";
            } else {
                query += (Conversion::toString(port->width()) + ",");
            }
            query += (Conversion::toString(archID) + ");");
            dbConnection_->updateQuery(query);
            RowID portID = dbConnection_->lastInsertRowID();
            portIDMap.insert(std::pair<FUPort*, RowID>(port, portID));
        }
 
        // insert into operation table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            if (!containsOperation(operation->name())) {
                dbConnection_->updateQuery(
                    std::string(
                        "INSERT INTO operation(id,name) VALUES(NULL,\"" + 
                        operation->name() + "\");"));
            }
        }
 
        // insert into io_binding table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            for (int i = 0; i < fu.operationPortCount(); i++) {
                FUPort* port = fu.operationPort(i);
                if (operation->isBound(*port)) {
                    int io = operation->io(*port);
                    string query(
                        "INSERT INTO io_binding(id,io_number,port,operation)"
                        " VALUES(NULL," + Conversion::toString(io) + "," +
                        Conversion::toString(
                            MapTools::valueForKey<RowID>(portIDMap, port)) +
                        ",(SELECT id FROM operation WHERE "
                        "lower(name)=\"" + operation->name() + "\"));");
                    dbConnection_->updateQuery(query);
                }
            }
        }
 
        std::map<HWOperation*, RowID> pLineIDMap;
 
        // insert into operation pipeline table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO operation_pipeline(id,fu_arch,operation) "
                    "VALUES(NULL," + Conversion::toString(archID) +
                    ",(SELECT id FROM operation WHERE lower(name)=\"" + 
                    operation->name() + "\"));"));
            pLineIDMap.insert(
                std::pair<HWOperation*, RowID>(
                    operation, dbConnection_->lastInsertRowID()));
        }
 
        // insert into io_usage_table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            ExecutionPipeline* pLine = operation->pipeline();
            for (int cycle = 0; cycle < pLine->latency(); cycle++) {
                ExecutionPipeline::OperandSet readOperands = 
                    pLine->readOperands(cycle);
                ExecutionPipeline::OperandSet writtenOperands =
                    pLine->writtenOperands(cycle);
                for (ExecutionPipeline::OperandSet::const_iterator iter = 
                         readOperands.begin();
                     iter != readOperands.end(); iter++) {
                    dbConnection_->updateQuery(
                        std::string(
                            "INSERT INTO io_usage(id,cycle,io_number,action,"
                            "pipeline) VALUES(NULL," + 
                            Conversion::toString(cycle) + "," + 
                            Conversion::toString(*iter) + "," + 
                            Conversion::toString(READ_ACTION) + "," + 
                            Conversion::toString(
                                MapTools::valueForKey<RowID>(
                                    pLineIDMap, operation)) + ");"));
                }
                for (ExecutionPipeline::OperandSet::const_iterator iter =
                         writtenOperands.begin();
                     iter != writtenOperands.end(); iter++) {
                    dbConnection_->updateQuery(
                        std::string(
                            "INSERT INTO io_usage(id,cycle,io_number,action,"
                            "pipeline) VALUES(NULL," + 
                            Conversion::toString(cycle) + "," + 
                            Conversion::toString(*iter) + "," + 
                            Conversion::toString(WRITE_ACTION) + "," + 
                            Conversion::toString(
                                MapTools::valueForKey<RowID>(
                                    pLineIDMap, operation)) + ");"));
                }
            }
        }
 
        // insert into pipeline_resource table
        std::map<PipelineElement*, RowID> pipelineElementMap;
        for (int i = 0; i < fu.pipelineElementCount(); i++) {
            PipelineElement* element = fu.pipelineElement(i);
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO pipeline_resource(id,fu_arch) VALUES "
                    "(NULL," + Conversion::toString(archID) + ");"));
            pipelineElementMap.insert(
                std::pair<PipelineElement*, RowID>(
                    element, dbConnection_->lastInsertRowID()));
        }
 
        // insert into pipeline_resource_usage table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            ExecutionPipeline* pLine = operation->pipeline();
            for (int i = 0; i < fu.pipelineElementCount(); i++) {
                PipelineElement* element = fu.pipelineElement(i);
                for (int cycle = 0; cycle < pLine->latency(); cycle++) {
                    if (pLine->isResourceUsed(element->name(), cycle)) {
                        string resID = Conversion::toString(
                            MapTools::valueForKey<RowID>(
                                pipelineElementMap, element));
                        string pLineID = Conversion::toString(
                            MapTools::valueForKey<RowID>(
                                pLineIDMap, operation));
                        dbConnection_->updateQuery(
                            std::string(
                                "INSERT INTO pipeline_resource_usage(id,"
                                "cycle,resource,pipeline) VALUES(NULL," +
                                Conversion::toString(cycle) + "," +
                                resID + "," + pLineID + ");"));
                    }
                }
            }
        }                
 
        dbConnection_->commit();
        
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
    
    return archID;
}

References __func__, HDB::FUArchitecture::architecture(), assert, RelationalDBConnection::beginTransaction(), FUValidator::checkOperandBindings(), FUValidator::checkOperations(), RelationalDBConnection::commit(), containsOperation(), dbConnection_, debugLog, MachineValidatorResults::error(), MachineValidatorResults::errorCount(), Exception::errorMessage(), HDB::FUArchitecture::hasGuardSupport(), HDB::FUArchitecture::hasParameterizedWidth(), TTAMachine::HWOperation::io(), TTAMachine::HWOperation::isBound(), TTAMachine::FUPort::isOpcodeSetting(), TTAMachine::ExecutionPipeline::isResourceUsed(), TTAMachine::FUPort::isTriggering(), MapTools::keyForValue(), RelationalDBConnection::lastInsertRowID(), TTAMachine::ExecutionPipeline::latency(), TTAMachine::HWOperation::name(), TTAMachine::PipelineElement::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), TTAMachine::HWOperation::pipeline(), TTAMachine::FunctionUnit::pipelineElement(), TTAMachine::FunctionUnit::pipelineElementCount(), READ_ACTION, TTAMachine::ExecutionPipeline::readOperands(), RelationalDBConnection::rollback(), Conversion::toString(), RelationalDBConnection::updateQuery(), TTAMachine::BaseFUPort::width(), WRITE_ACTION, and TTAMachine::ExecutionPipeline::writtenOperands().

Referenced by AddFUArchFromADFCmd::Do().

Here is the call graph for this function:

◆ addFUCostEstimationData()

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

Adds the given cost estimation data values to given FU entry.

Parameters

fuID	The ID of the FU entry the cost data will be added. @valueName The name of the cost value. @value The cost value. @pluginID The ID of the cost function plugin that owns this data.

Definition at line 3196 of file HDBManager.cc.

                          {
 
 
    RowID dataID;
 
    // add the data
    try {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO cost_estimation_data (id,plugin_reference,"
                "fu_reference,name,value) VALUES (NULL," +
                Conversion::toString(pluginID) + "," +
                Conversion::toString(fuID) + ",\"" + valueName + "\",\"" +
                value + "\");"));
        dataID = dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    return dataID;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addFUEntry()

RowID HDB::HDBManager::addFUEntry ( ) const

Adds an empty FU entry to the database.

Parameters

entry The FU entry.

Returns: ID of the added FU entry.

Definition at line 1000 of file HDBManager.cc.

                             {
    try {
        dbConnection_->updateQuery(
            std::string("INSERT INTO fu(id) VALUES(NULL);"));
        return dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}    

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), and RelationalDBConnection::updateQuery().

Referenced by AddFUEntryCmd::Do(), and AddFUImplementationCmd::Do().

Here is the call graph for this function:

◆ addFUExternalPortsToImplementation()

void HDB::HDBManager::addFUExternalPortsToImplementation	(	FUImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds external ports to the given FU implementation which is the implementation of the FU entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the FU entry.

Definition at line 5041 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* extPortData = NULL;
    try {
        extPortData = dbConnection_->query(fuExternalPortsByIDQuery(entryID));
    } catch (const Exception& e) {
        assert(false);
    }
 
    int extPortNameColumn = extPortData->column("fu_external_port.name");
    int directionColumn = extPortData->column(
        "fu_external_port.direction");
    int extPortWidthFormulaColumn = extPortData->column(
        "fu_external_port.width_formula");
    int descriptionColumn = extPortData->column(
        "fu_external_port.description");
    
    while (extPortData->hasNext()) {
        extPortData->next();
        const DataObject& nameData = extPortData->data(
            extPortNameColumn);
        const DataObject& directionData = extPortData->data(
            directionColumn);
        const DataObject& widthFormulaData = extPortData->data(
            extPortWidthFormulaColumn);
        const DataObject& descriptionData = extPortData->data(
            descriptionColumn);
        
        string name = nameData.stringValue();
        string widthFormula = widthFormulaData.stringValue();
        string description = descriptionData.stringValue();
 
        Direction direction;
        if (directionData.stringValue() == IN_DIRECTION) {
            direction = IN;
        } else if (directionData.stringValue() == OUT_DIRECTION) {
            direction = OUT;
        } else {
            assert(directionData.stringValue() == BIDIR_DIRECTION);
            direction = BIDIR;
        }
 
        new FUExternalPort(
            name, direction, widthFormula, description, implementation);
    }
    
    delete extPortData;
    extPortData = NULL;
 
    // add parameter dependencies
    for (int i = 0; i < implementation.externalPortCount(); i++) {
        FUExternalPort& port = implementation.externalPort(i);
        try {
            RelationalDBQueryResult* result = dbConnection_->query(
                std::string(
                    "SELECT fu_implementation_parameter.name FROM "
                    "fu_implementation_parameter, fu_external_port, "
                    "fu_ext_port_parameter_dependency, fu_implementation "
                    "WHERE fu_implementation.fu=" +
                    Conversion::toString(entryID) +
                    " AND fu_external_port.fu_impl=fu_implementation.id AND "
                    "fu_external_port.name=\"" + port.name() +
                    "\" AND fu_ext_port_parameter_dependency.port="
                    "fu_external_port.id AND fu_implementation_parameter.id="
                    "fu_ext_port_parameter_dependency.parameter;"));
            while (result->hasNext()) {
                result->next();
                const DataObject& paramData = result->data(0);
                port.setParameterDependency(paramData.stringValue());
            }
            delete result;
        } catch (const Exception& e) {
            debugLog(e.errorMessage());
            assert(false);
        }
    }
}

References assert, HDB::BIDIR, BIDIR_DIRECTION, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), fuExternalPortsByIDQuery(), RelationalDBQueryResult::hasNext(), implementation, HDB::IN, IN_DIRECTION, HDB::ExternalPort::name(), RelationalDBQueryResult::next(), HDB::OUT, OUT_DIRECTION, RelationalDBConnection::query(), HDB::ExternalPort::setParameterDependency(), DataObject::stringValue(), and Conversion::toString().

Referenced by createImplementationOfFU().

Here is the call graph for this function:

◆ addFUImplementation()

RowID HDB::HDBManager::addFUImplementation ( const FUEntry & entry ) const

Adds the implementation of the given FU entry to the database.

In practice the implementation is added for the FU entry that has the same ID as the given FUEntry instance. The given FUEntry instance must also have an architecture similar to the architecture of the FU entry in the database. This is required in port mapping.

Parameters

entry The FU entry containing the implementation to add.

Returns: ID of the implementation that was added.

Exceptions

InvalidData If the given FUEntry instance is invalid or if the FU entry does not have architecture in the database of if the FU entry has an implementation already.

Definition at line 1098 of file HDBManager.cc.

                                                          {
    if (!entry.hasID() || !entry.hasImplementation() ||
        !entry.hasArchitecture() || !hasFUEntry(entry.id())) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    FUImplementation& impl = entry.implementation();
    FUArchitecture& arch = entry.architecture();
    FunctionUnit& fu = arch.architecture();
 
    FUEntry* existingEntry = fuByEntryID(entry.id());
    if (existingEntry->hasImplementation() ||
        !existingEntry->hasArchitecture()) {
        delete existingEntry;
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
    delete existingEntry;
    existingEntry = NULL;
 
    RowID archID = fuArchitectureID(entry.id());
    RowID implID;
 
    try {
        dbConnection_->beginTransaction();
 
        // insert into fu_implementation table
        string module = impl.moduleName();
        string opcPort = impl.opcodePort();
        string clkPort = impl.clkPort();
        string rstPort = impl.rstPort();
        string glockPort = impl.glockPort();
        string glockReqPort = impl.glockReqPort();
 
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO fu_implementation(id,name,opcode_port,"
                "clk_port,rst_port,glock_port,glock_req_port,fu) VALUES"
                "(NULL,\"" + module + "\",\"" + opcPort + "\",\"" +
                clkPort + "\",\"" + rstPort + "\",\"" + glockPort + "\",\""
                + glockReqPort + "\"," + Conversion::toString(entry.id())
                + ");"));
        implID = dbConnection_->lastInsertRowID();
        
        // insert into fu_port_map table
        for (int i = 0; i < impl.architecturePortCount(); i++) {
            FUPortImplementation& portImpl = impl.architecturePort(i);
            string name = portImpl.name();
            string widthFormula = portImpl.widthFormula();
            string loadPort = portImpl.loadPort();
            string guardPort = portImpl.guardPort();
            string archPortName = portImpl.architecturePort();
            if (!fu.hasOperationPort(archPortName)) {
                throw InvalidData(__FILE__, __LINE__, __func__);
            }
            FUPort* port = fu.operationPort(archPortName);
            bool portAdded = false;
            for (int j = 0; j < fu.operationCount(); j++) {
                HWOperation* operation = fu.operation(j);
                if (operation->isBound(*port)) {
                    int io = operation->io(*port);
                    // find the fu_data_port from DB
                    RelationalDBQueryResult* result = dbConnection_->query(
                        std::string(
                            "SELECT fu_data_port.id FROM fu_data_port,"
                            "io_binding,operation WHERE "
                            "fu_data_port.fu_arch=" +
                            Conversion::toString(archID) +
                            " AND io_binding.port=fu_data_port.id AND "
                            "io_binding.io_number=" +
                            Conversion::toString(io) +
                            " AND lower(operation.name)=\"" + 
                            operation->name() + 
                            "\" AND io_binding.operation=operation.id;"));
                    if (!result->hasNext()) {
                        delete result;
                        throw InvalidData(__FILE__, __LINE__, __func__);
                    }
                    result->next();
                    string portID = result->data(0).stringValue();
                    delete result;
                    
                    // update fu_port_map table
                    dbConnection_->updateQuery(
                        std::string(
                            "INSERT INTO fu_port_map(id,name,width_formula,"
                            "load_port,guard_port,fu_impl,arch_port) VALUES"
                            "(NULL,\"" + name + "\",\"" + widthFormula +
                            "\",\"" + loadPort + "\",\"" + guardPort +
                            "\"," + Conversion::toString(implID) + "," +
                            portID + ");"));
                    portAdded = true;
                    break;
                }
            }
            
            if (!portAdded) {
                throw InvalidData(__FILE__, __LINE__, __func__);
            }
        }
#ifdef ALLOW_OPCODE_EDITING
        // insert into opcode_map table
        for (int i = 0; i < fu.operationCount(); i++) {
            HWOperation* operation = fu.operation(i);
            if (!containsOperation(operation->name())) {
                format errorMsg(
                    "FU implementation uses unknown operation %1%."); 
                errorMsg % operation->name();
                throw InvalidData(
                    __FILE__, __LINE__, __func__, errorMsg.str());
            }
            if (fu.operationCount() > 1 && 
                !impl.hasOpcode(operation->name())) {
                format errorMsg("Opcode not defined for operation %1%.");
                errorMsg % operation->name();
                throw InvalidData(
                    __FILE__, __LINE__, __func__, errorMsg.str());
            }
            if (fu.operationCount() > 1) {
                int opcode = impl.opcode(operation->name());
                dbConnection_->updateQuery(
                    std::string(
                        "INSERT INTO opcode_map(id,opcode,operation,fu_impl)"
                        " VALUES(NULL," + Conversion::toString(opcode) +
                        ",(SELECT id FROM operation WHERE lower(name)=\"" +
                        operation->name() + "\")," +
                        Conversion::toString(implID) + ");"));
            }
        }
#endif
        // insert into fu_external_port table
        for (int i = 0; i < impl.externalPortCount(); i++) {
            FUExternalPort& port = impl.externalPort(i);
            string direction = directionString(port.direction());
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO fu_external_port(id,name,direction,"
                    "width_formula,description,fu_impl) VALUES(NULL,\"" +
                    port.name() + "\",\"" + direction + "\",\"" +
                    port.widthFormula() + "\",\"" + port.description() +
                    "\"," + Conversion::toString(implID) + ");"));
        }
 
        // insert into fu_implementation_parameter table
        for (int i = 0; i < impl.parameterCount(); i++) {
            FUImplementation::Parameter param = impl.parameter(i);
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO fu_implementation_parameter(id,name,type,"
                    "value,fu_impl) VALUES(NULL,\"" + param.name +
                    "\",\"" + param.type + "\",\"" + param.value +
                    "\"," + Conversion::toString(implID) + ");"));
        }
 
        // insert into fu_ext_port_parameter_dependency table
        for (int i = 0; i < impl.externalPortCount(); i++) {
            FUExternalPort& port = impl.externalPort(i);
            for (int i = 0; i < port.parameterDependencyCount(); i++) {
                string param = port.parameterDependency(i);
                dbConnection_->updateQuery(
                    std::string(
                        "INSERT INTO fu_ext_port_parameter_dependency(id,"
                        "port,parameter) VALUES(NULL,(SELECT id FROM "
                        "fu_external_port WHERE fu_impl=" +
                        Conversion::toString(implID) + " AND name=\"" +
                        port.name() + "\"),(SELECT id FROM "
                        "fu_implementation_parameter WHERE fu_impl=" +
                        Conversion::toString(implID) + " AND name=\"" +
                        param + "\"));"));
            }
        }
 
        // insert into block_source_file table
        for (int i = 0; i < impl.implementationFileCount(); i++) {
            BlockImplementationFile& file = impl.file(i);
            addBlockImplementationFileToHDB(file);
        }
 
        // insert into fu_source_file table
        for (int i = 0; i < impl.implementationFileCount(); i++) {
            BlockImplementationFile& file = impl.file(i);
            string path = file.pathToFile();
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO fu_source_file(id,fu_impl,file) "
                    "VALUES(NULL," + Conversion::toString(implID) +
                    ",(SELECT id FROM block_source_file WHERE file=\"" +
                    path + "\"));"));
        }
 
        dbConnection_->commit();
 
    } catch (const RelationalDBException& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    } catch (const InvalidData& e) {
        dbConnection_->rollback();
        throw;
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
 
    return implID;
}

Referenced by AddFUImplementationCmd::Do(), and HDBEditorModifyCmd::Do().

◆ addFUParametersToImplementation()

void HDB::HDBManager::addFUParametersToImplementation	(	FUImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds parameters to the given FU implementation which is the implementation of the FU entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the FU entry.

Definition at line 5226 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            fuImplementationParametersByIDQuery(entryID));
    } catch (const Exception&) {
        assert(false);
    }
 
    while (result->hasNext()) {
        result->next();
        const DataObject& nameData = result->data("name");
        const DataObject& typeData = result->data("type");
        const DataObject& valueData = result->data("value");
        string name = nameData.stringValue();
        string type = typeData.stringValue();
        string value = valueData.stringValue();
        implementation.addParameter(name, type, value);
    }
    delete result;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, fuImplementationParametersByIDQuery(), RelationalDBQueryResult::hasNext(), implementation, RelationalDBQueryResult::next(), RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by createImplementationOfFU().

Here is the call graph for this function:

◆ addOpcodesToImplementation()

void HDB::HDBManager::addOpcodesToImplementation	(	FUImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds the operation codes to the given FU implementation which is the implementation of the FU entry that has the given ID.

Parameters

implementation	The FU implementation.
entryID	ID of the FU entry.

Definition at line 4957 of file HDBManager.cc.

                         {
 
    RelationalDBQueryResult* opcodeData = NULL;
    try {
        opcodeData = dbConnection_->query(opcodesByIDQuery(entryID));
    } catch (const Exception&) {
        assert(false);
    }
    int operationColumn = opcodeData->column("operation.name");
    int opcodeColumn = opcodeData->column("opcode_map.opcode");
    while (opcodeData->hasNext()) {
        opcodeData->next();
        const DataObject& operationData = opcodeData->data(
            operationColumn);
        const DataObject& opcodeDataObject = opcodeData->data(
            opcodeColumn);
        implementation.setOpcode(
            operationData.stringValue(), opcodeDataObject.integerValue());
    }
    delete opcodeData;
    opcodeData = NULL;
}

References assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), implementation, DataObject::integerValue(), RelationalDBQueryResult::next(), opcodesByIDQuery(), RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by createImplementationOfFU().

Here is the call graph for this function:

◆ addOperationImplementation()

void HDB::HDBManager::addOperationImplementation ( const OperationImplementation & operation )

Add addOperationImplementation to the DB.

Definition at line 2527 of file HDBManager.cc.

                                                  {
 
 
    std::string i1 = "INSERT INTO operation_implementation(id,name,latency,"
        "post_op_vhdl,post_op_verilog,bus_definition,"
        "initial_vhdl,initial_verilog) "
        "VALUES (NULL,\"" + operation.name + "\","
             + std::to_string(operation.latency) + ","
        "\"" + operation.postOpImplFileVhdl + "\","
        "\"" + operation.postOpImplFileVerilog + "\","
        "\"" + operation.absBusDefFile + "\","
        "\"" + operation.initialImplFileVhdl + "\","
        "\"" + operation.initialImplFileVerilog +
        "\");";
    dbConnection_->updateQuery(i1);
    RowID newid = dbConnection_->lastInsertRowID();
 
    for (const auto r : operation.resources) {
        std::string i2 = "INSERT INTO operation_implementation_resources("
            "id, operation, resource, count) "
            "VALUES (NULL, " + std::to_string(newid)
            + ", " + std::to_string(r.id)
            + ", " + std::to_string(r.count)
            + ");";
        dbConnection_->updateQuery(i2);
    }
 
    for (const auto r : operation.vhdlVariables) {
        std::string i2 = "INSERT INTO operation_implementation_variable("
            "id, operation, name, width, type, language) "
            "VALUES (NULL, " + std::to_string(newid)
            + ", \"" + r.name + "\""
            + ", \"" + r.width + "\""
            + ", \"" + r.type + "\""
            + ", \"VHDL\");";
        dbConnection_->updateQuery(i2);
    }
 
    for (const auto r : operation.verilogVariables) {
        std::string i2 = "INSERT INTO operation_implementation_variable("
            "id, operation, name, width, type, language) "
            "VALUES (NULL, " + std::to_string(newid)
            + ", \"" + r.name + "\""
            + ", \"" + r.width + "\""
            + ", \"" + r.type + "\""
            + ", \"Verilog\");";
        dbConnection_->updateQuery(i2);
    }
 
    std::string i3 = "INSERT INTO block_source_file(id,file,format) "
        "VALUES (NULL,\"" + operation.implFileVhdl +
        "\", " + std::to_string(BlockImplementationFile::VHDL) + ");";
    dbConnection_->updateQuery(i3);
    RowID vhdl = dbConnection_->lastInsertRowID();
 
    std::string i4 = "INSERT INTO "
        "operation_implementation_source_file(id, operation, file) "
        "VALUES (NULL, " + std::to_string(newid) +
        ", " + std::to_string(vhdl) +
        ");";
    dbConnection_->updateQuery(i4);
 
    std::string i5 = "INSERT INTO block_source_file(id,file,format) "
        "VALUES (NULL,\"" + operation.implFileVerilog +
        "\", " + std::to_string(BlockImplementationFile::Verilog) + ");";
    dbConnection_->updateQuery(i5);
    RowID verilog = dbConnection_->lastInsertRowID();
 
    std::string i6 = "INSERT INTO "
        "operation_implementation_source_file(id, operation, file) "
        "VALUES (NULL, " + std::to_string(newid) +
        ", " + std::to_string(verilog) +
        ");";
    dbConnection_->updateQuery(i6);
}

Referenced by OperationImplementationDialog::onOK().

Here is the call graph for this function:

◆ addOperationImplementationResource()

void HDB::HDBManager::addOperationImplementationResource ( const OperationImplementationResource & resource )

Add addOperationImplementationResource to the DB.

Definition at line 2468 of file HDBManager.cc.

                                                     {
 
    dbConnection_->updateQuery(
        std::string(
            "INSERT INTO operation_implementation_resource(id,name,ipxact) "
            "VALUES (NULL, \"" +
            resource.name +"\", \"" + resource.ipxact+ "\");"));
    RowID resourceID = dbConnection_->lastInsertRowID();
 
    auto t = resource.simFormats.begin();
    auto f = resource.simFiles.begin();
    for (; f != resource.simFiles.end(); ++f, ++t) {
        int type = fileFormat(*t) + 1;
 
        dbConnection_->updateQuery(
        std::string(
            "INSERT INTO block_source_file(id,file,format) "
            "VALUES (NULL, \"" + *f + "\","
            + std::to_string(type) +
            ");"));
        RowID fileID = dbConnection_->lastInsertRowID();
 
        dbConnection_->updateQuery(
        std::string(
            "INSERT INTO operation_implementation_resource_source_file"
            "(id,resource,file) "
            "VALUES (NULL, " + std::to_string(resourceID) + ", "
            + std::to_string(fileID) +
            ");"));
    }
 
    auto st = resource.synFormats.begin();
    auto sf = resource.synFiles.begin();
    for (; sf != resource.synFiles.end(); ++sf, ++st) {
        int type = fileFormat(*st) + 1;
 
        dbConnection_->updateQuery(
        std::string(
            "INSERT INTO block_source_file(id,file,format) "
            "VALUES (NULL, \"" + *sf + "\","
            + std::to_string(type) +
            ");"));
        RowID fileID = dbConnection_->lastInsertRowID();
 
        dbConnection_->updateQuery(
        std::string(
            "INSERT INTO operation_implementation_resource_source_file"
            "(id,resource,file) "
            "VALUES (NULL, " + std::to_string(resourceID) + ", "
            + std::to_string(fileID) +
            ");"));
    }
}

References dbConnection_, fileFormat(), HDB::OperationImplementationResource::ipxact, RelationalDBConnection::lastInsertRowID(), HDB::OperationImplementationResource::name, HDB::OperationImplementationResource::simFiles, HDB::OperationImplementationResource::simFormats, HDB::OperationImplementationResource::synFiles, HDB::OperationImplementationResource::synFormats, and RelationalDBConnection::updateQuery().

Referenced by OperationImplementationResourceDialog::onOK().

Here is the call graph for this function:

◆ addOperationPipelinesToFUArchitecture()

void HDB::HDBManager::addOperationPipelinesToFUArchitecture	(	FUArchitecture &	architecture,
		RowID	id
	)		const

private

Obtains data from HDB and creates the operation pipelines to the given FU architecture.

Parameters

architecture	The FU architecture to which the operations are added.
id	ID the FU architecture in HDB.

Definition at line 4503 of file HDBManager.cc.

                    {
 
    FunctionUnit& fu = architecture.architecture();
 
    // make the SQL query to obtain IO usage data
    RelationalDBQueryResult* ioUsageData = NULL;
    try {
        ioUsageData = dbConnection_->query(ioUsageDataByIDQuery(id));
    } catch (const Exception& e) {
        assert(false);
    }
    int operationColumn = ioUsageData->column("operation.name");
    int cycleColumn = ioUsageData->column("io_usage.cycle");
    int ioColumn = ioUsageData->column("io_usage.io_number");
    int actionColumn = ioUsageData->column("io_usage.action");
    
    while (ioUsageData->hasNext()) {
        ioUsageData->next();
        const DataObject& operationData = ioUsageData->data(operationColumn);
        const DataObject& cycleData = ioUsageData->data(cycleColumn);
        const DataObject& ioData = ioUsageData->data(ioColumn);
        const DataObject& actionData = ioUsageData->data(actionColumn);
 
        string operationName = operationData.stringValue();
        int cycle = cycleData.integerValue();
        int ioNumber = ioData.integerValue();
        int action = actionData.boolValue();
        
        assert(fu.hasOperation(operationName));
        HWOperation* operation = fu.operation(operationName);
        ExecutionPipeline* pipeline = operation->pipeline();
        if (action == READ_ACTION) {
            pipeline->addPortRead(ioNumber, cycle, 1);
        } else if (action == WRITE_ACTION) {
            pipeline->addPortWrite(ioNumber, cycle, 1);
        }
    }
 
    delete ioUsageData;
    ioUsageData = NULL;
 
    // add resource usages
    RelationalDBQueryResult* resUsageData = NULL;
    try {
        resUsageData = dbConnection_->query(resourceUsageDataByIDQuery(id));
    } catch (const Exception&) {
        assert(false);
    }
    operationColumn = resUsageData->column("operation.name");
    cycleColumn = resUsageData->column("pipeline_resource_usage.cycle");
    int resourceColumn = resUsageData->column("pipeline_resource.id");
 
    int resourceName(0);
    std::map<int, string> resourceMap;
 
    while (resUsageData->hasNext()) {
        resUsageData->next();
        const DataObject& operationData = resUsageData->data(
            operationColumn);
        const DataObject& cycleData = resUsageData->data(cycleColumn);
        const DataObject& resourceData = resUsageData->data(resourceColumn);
 
        string operationName = operationData.stringValue();
        int cycle = cycleData.integerValue();
        int resourceID = resourceData.integerValue();
        
        assert(fu.hasOperation(operationName));
        HWOperation* operation = fu.operation(operationName);
        ExecutionPipeline* pipeline = operation->pipeline();
        if (!MapTools::containsKey(resourceMap, resourceID)) {
            resourceMap.insert(
                std::pair<int, string>(
                    resourceID, "res" + Conversion::toString(resourceName)));
            resourceName++;
        }
        pipeline->addResourceUse(
            MapTools::valueForKey<string>(
                resourceMap, resourceID), cycle, 1);
    }
 
    delete resUsageData;
    resUsageData = NULL;
}

References TTAMachine::ExecutionPipeline::addPortRead(), TTAMachine::ExecutionPipeline::addPortWrite(), TTAMachine::ExecutionPipeline::addResourceUse(), HDB::FUArchitecture::architecture(), assert, DataObject::boolValue(), RelationalDBQueryResult::column(), MapTools::containsKey(), RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), TTAMachine::FunctionUnit::hasOperation(), DataObject::integerValue(), ioUsageDataByIDQuery(), MapTools::keyForValue(), RelationalDBQueryResult::next(), TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::pipeline(), RelationalDBConnection::query(), READ_ACTION, resourceUsageDataByIDQuery(), DataObject::stringValue(), Conversion::toString(), and WRITE_ACTION.

Referenced by fuArchitectureByID().

Here is the call graph for this function:

◆ addPortsAndBindingsToFUArchitecture()

void HDB::HDBManager::addPortsAndBindingsToFUArchitecture	(	FUArchitecture &	architecture,
		RowID	id
	)		const

private

Obtains data from HDB and creates ports and operand bindings to the given FU architecture that has the given ID in HDB.

Parameters

architecture	The FU architecture to which the ports are added.
id	ID of the FU architecture in HDB.

Definition at line 4392 of file HDBManager.cc.

                    {
 
    FunctionUnit& fu = architecture.architecture();
 
    // make the SQL query to obtain the ports
    RelationalDBQueryResult* fuPorts = NULL;
    try {
        fuPorts = dbConnection_->query(fuPortsAndBindingsByIDQuery(id));
    } catch (const Exception& e) {
        abortWithError(e.errorMessage());
    }
    int portIDColumnIndex = fuPorts->column("fu_data_port.id");
    int triggersColumnIndex = fuPorts->column("fu_data_port.triggers");
    int setsOpcodeColumnIndex = fuPorts->column("fu_data_port.sets_opcode");
    int guardSupportColumnIndex = fuPorts->column(
        "fu_data_port.guard_support");
    int widthColumnIndex = fuPorts->column("fu_data_port.width");
    int operationColumnIndex = fuPorts->column("operation.name");
    int bindingColumnIndex = fuPorts->column("io_binding.io_number");
 
    // @fixme Do not assert() inside a library function in case of broken
    // user input data!!
    assert(portIDColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(triggersColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(setsOpcodeColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(
        guardSupportColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(widthColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(operationColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(bindingColumnIndex != RelationalDBQueryResult::UNKNOWN_INDEX);
 
    if (!fuPorts->hasNext()) {
        delete fuPorts;
        abortWithError("No row.");
    }
 
    std::map<int, std::string> portIDMap;
 
    // create ports, operations and bindings to the FU
    int name(1);
    while (fuPorts->hasNext()) {
        fuPorts->next();
 
        const DataObject& idData = fuPorts->data(portIDColumnIndex);
        const DataObject& triggersData = fuPorts->data(triggersColumnIndex);
        const DataObject& setsOpcodeData = fuPorts->data(
            setsOpcodeColumnIndex);
        const DataObject& guardData = fuPorts->data(guardSupportColumnIndex);
        const DataObject& widthData = fuPorts->data(widthColumnIndex);
        const DataObject& operationData = fuPorts->data(
            operationColumnIndex);
        const DataObject& bindingData = fuPorts->data(bindingColumnIndex);
 
        int portID = idData.integerValue();
 
        // create operation if it is not created yet
        string operationName = operationData.stringValue();
        if (!fu.hasOperation(operationName)) {
            new HWOperation(operationName, fu);
        }
 
        // create port if it is not created yet
        if (!MapTools::containsKey(portIDMap, portID)) {
            bool triggers = triggersData.boolValue();
            bool setsOpcode = setsOpcodeData.boolValue();            
            string portName = "p" + Conversion::toString(name);
 
            int width = DEFAULT_PORT_WIDTH;
            if (widthData.isNull()) {
                architecture.setParameterizedWidth(portName);
            } else {
                width = widthData.integerValue();
            }
            new FUPort(portName, width, fu, triggers, setsOpcode);
            portIDMap.insert(
                std::pair<int, string>(idData.integerValue(), portName));
            if (setsOpcode && !triggers) 
                debugLog(
                    std::string("Created a suspicious port ") + portName + 
                    " which sets opcode but does not trigger");
 
            // set guard support
            if (guardData.boolValue()) {
                architecture.setGuardSupport(portName);
            }
 
            name++;
        }
        
        // create binding
        FUPort* portToBind = fu.operationPort(
            MapTools::valueForKey<string>(portIDMap, portID));
        HWOperation* operation = fu.operation(operationName);
        operation->bindPort(bindingData.integerValue(), *portToBind);
    }
 
    delete fuPorts;
    fuPorts = NULL;
}

References abortWithError, HDB::FUArchitecture::architecture(), assert, TTAMachine::HWOperation::bindPort(), DataObject::boolValue(), RelationalDBQueryResult::column(), MapTools::containsKey(), RelationalDBQueryResult::data(), dbConnection_, debugLog, DEFAULT_PORT_WIDTH, Exception::errorMessage(), fuPortsAndBindingsByIDQuery(), RelationalDBQueryResult::hasNext(), TTAMachine::FunctionUnit::hasOperation(), DataObject::integerValue(), DataObject::isNull(), MapTools::keyForValue(), RelationalDBQueryResult::next(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationPort(), RelationalDBConnection::query(), HDB::FUArchitecture::setGuardSupport(), HDB::FUArchitecture::setParameterizedWidth(), DataObject::stringValue(), Conversion::toString(), and RelationalDBQueryResult::UNKNOWN_INDEX.

Referenced by fuArchitectureByID().

Here is the call graph for this function:

◆ addRFArchitecture()

RowID HDB::HDBManager::addRFArchitecture ( const RFArchitecture & architecture ) const

Adds the given RF architecture to the HDB.

Parameters

architecture The architecture to add.

Returns: ID of the architecture added.

Definition at line 1447 of file HDBManager.cc.

                                                                      {
 
    try {
        string query = 
            "INSERT INTO rf_architecture(id,size,width,read_ports,"
            "write_ports,bidir_ports,latency,max_reads,max_writes,"
            "guard_support,guard_latency,zero_register) VALUES(NULL,";
        if (architecture.hasParameterizedSize()) {
            query += "NULL,";
        } else {
            query += (Conversion::toString(architecture.size()) + ",");
        }
        if (architecture.hasParameterizedWidth()) {
            query += "NULL,";
        } else {
            query += (Conversion::toString(architecture.width()) + ",");
        }
        query += (Conversion::toString(architecture.readPortCount()) + ",");
        query += (Conversion::toString(architecture.writePortCount()) + ",");
        query += (Conversion::toString(architecture.bidirPortCount()) + ",");
        query += (Conversion::toString(architecture.latency()) + ",");
        query += (Conversion::toString(architecture.maxReads()) + ",");
        query += (Conversion::toString(architecture.maxWrites()) + ",");
        query += 
            (Conversion::toString(architecture.hasGuardSupport()) + ",");
        query += (Conversion::toString(architecture.guardLatency()) + ",");
        query += (Conversion::toString(architecture.zeroRegister()));
        query += ");";
        
        dbConnection_->updateQuery(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    return dbConnection_->lastInsertRowID();
}

Referenced by AddRFArchitectureCmd::Do().

Here is the call graph for this function:

◆ addRFCostEstimationData()

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

Adds the given cost estimation data values to given RF entry.

Parameters

rfID	The ID of the RF entry the cost data will be added. @valueName The name of the cost value. @value The cost value. @pluginID The ID of the cost function plugin that owns this data.

Definition at line 3232 of file HDBManager.cc.

                          {
 
    RowID dataID;
    
    // add the data
    try {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO cost_estimation_data (id,plugin_reference,"
                "rf_reference,name,value) VALUES (NULL," + 
                Conversion::toString(pluginID) + "," + 
                Conversion::toString(rfID) + ",\"" + valueName + "\",\"" +
                value + "\");"));
        dataID = dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    return dataID;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addRFEntry()

RowID HDB::HDBManager::addRFEntry ( ) const

Adds an empty RF entry to the database.

Returns: ID of the entry added.

Definition at line 1543 of file HDBManager.cc.

                             {
    try {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO rf(id,architecture,cost_function) "
                "VALUES(NULL,NULL,NULL);"));
        return dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), and RelationalDBConnection::updateQuery().

Referenced by AddRFEntryCmd::Do(), and AddRFImplementationCmd::Do().

Here is the call graph for this function:

◆ addRFExternalPortsToImplementation()

void HDB::HDBManager::addRFExternalPortsToImplementation	(	RFImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds external ports to the given RF implementation which is the implementation of the RF entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the RF implementation entry.

Definition at line 5129 of file HDBManager.cc.

                         {
 
    if (!dbConnection_->tableExistsInDB("rf_external_port")) {
        return;
    }
 
    RelationalDBQueryResult* extPortData = NULL;
    try {
        extPortData = dbConnection_->query(rfExternalPortsByIDQuery(entryID));
    } catch (const Exception& e) {
        assert(false);
    }
 
    int extPortNameColumn = extPortData->column("rf_external_port.name");
    int directionColumn = extPortData->column(
        "rf_external_port.direction");
    int extPortWidthFormulaColumn = extPortData->column(
        "rf_external_port.width_formula");
    int descriptionColumn = extPortData->column(
        "rf_external_port.description");
 
    while (extPortData->hasNext()) {
        extPortData->next();
        const DataObject& nameData = extPortData->data(
            extPortNameColumn);
        const DataObject& directionData = extPortData->data(
            directionColumn);
        const DataObject& widthFormulaData = extPortData->data(
            extPortWidthFormulaColumn);
        const DataObject& descriptionData = extPortData->data(
            descriptionColumn);
 
        string name = nameData.stringValue();
        string widthFormula = widthFormulaData.stringValue();
        string description = descriptionData.stringValue();
 
        Direction direction;
        if (directionData.stringValue() == IN_DIRECTION) {
            direction = IN;
        } else if (directionData.stringValue() == OUT_DIRECTION) {
            direction = OUT;
        } else {
            assert(directionData.stringValue() == BIDIR_DIRECTION);
            direction = BIDIR;
        }
 
        new RFExternalPort(
            name, direction, widthFormula, description, implementation);
    }
 
    delete extPortData;
    extPortData = NULL;
 
    // add parameter dependencies
    if (!dbConnection_->tableExistsInDB("rf_ext_port_parameter_dependency")) {
        return;
    }
 
    for (int i = 0; i < implementation.externalPortCount(); i++) {
        RFExternalPort& port = implementation.externalPort(i);
        try {
            RelationalDBQueryResult* result = dbConnection_->query(
                std::string(
                    "SELECT rf_implementation_parameter.name FROM "
                    "rf_implementation_parameter, rf_external_port, "
                    "rf_ext_port_parameter_dependency, rf_implementation "
                    "WHERE rf_implementation.rf=" +
                    Conversion::toString(entryID) +
                    " AND rf_external_port.rf_impl=rf_implementation.id AND "
                    "rf_external_port.name=\"" + port.name() +
                    "\" AND rf_ext_port_parameter_dependency.port="
                    "rf_external_port.id AND rf_implementation_parameter.id="
                    "rf_ext_port_parameter_dependency.parameter;"));
            while (result->hasNext()) {
                result->next();
                const DataObject& paramData = result->data(0);
                port.setParameterDependency(paramData.stringValue());
            }
            delete result;
        } catch (const Exception& e) {
            debugLog(e.errorMessage());
            assert(false);
        }
    }
}

References assert, HDB::BIDIR, BIDIR_DIRECTION, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), implementation, HDB::IN, IN_DIRECTION, HDB::ExternalPort::name(), RelationalDBQueryResult::next(), HDB::OUT, OUT_DIRECTION, RelationalDBConnection::query(), rfExternalPortsByIDQuery(), HDB::ExternalPort::setParameterDependency(), DataObject::stringValue(), RelationalDBConnection::tableExistsInDB(), and Conversion::toString().

Referenced by createImplementationOfRF().

Here is the call graph for this function:

◆ addRFImplementation()

RowID HDB::HDBManager::addRFImplementation	(	const RFImplementation &	implementation,
		RowID	rfEntryID
	)

Adds an implementation for the the given RF entry.

Parameters

implementation	The implementation to add.
rfEntryID	ID of the RF entry.

Exceptions

InvalidData If the RF entry has an implementation already or if the database does not contain an RF entry with the given ID.

Definition at line 1626 of file HDBManager.cc.

                                                             {
    if (!hasRFEntry(rfEntryID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
    
    RFEntry* entry = rfByEntryID(rfEntryID);
    if (entry->hasImplementation()) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
    delete entry;
    entry = NULL;
    
    if(!hasColumn("rf_implementation", "sac_param")) {
        addBooleanColumn("rf_implementation", "sac_param");
    }
 
    // Create tables for external ports, parameters and parameter dependecies
    // if needed.
    if (!dbConnection_->tableExistsInDB("rf_implementation_parameter")) {
        dbConnection_->DDLQuery(CQ_RF_IMPLEMENTATION_PARAMETER);
    }
    if (!dbConnection_->tableExistsInDB("rf_external_port")) {
        dbConnection_->DDLQuery(CQ_RF_EXTERNAL_PORT);
    }
    if (!dbConnection_->tableExistsInDB("rf_ext_port_parameter_dependency")) {
        dbConnection_->DDLQuery(CQ_RF_EXT_PORT_PARAMETER_DEPENDENCY);
 
    }
 
    try {
        dbConnection_->beginTransaction();
 
        int sacFlagAsInt = implementation.separateAddressCycleParameter();
 
        // insert into rf_implementation table
        std::string insert_query(
            "INSERT INTO rf_implementation(id,name,size_param,"
            "width_param,clk_port,rst_port,glock_port,guard_port,sac_param,rf) "
            "VALUES(NULL,\"" + implementation.moduleName() + "\",\"" +
            implementation.sizeParameter() + "\",\"" +
            implementation.widthParameter() + "\",\"" +
            implementation.clkPort() + "\",\"" +
            implementation.rstPort() + "\",\"" +
            implementation.glockPort() + "\",\"" +
            implementation.guardPort() + "\"," +
            Conversion::toString(sacFlagAsInt) +  "," +
            Conversion::toString(rfEntryID) + ");");
 
        dbConnection_->updateQuery(insert_query);
        RowID implID = dbConnection_->lastInsertRowID();
 
        // insert into rf_data_port table
        for (int i = 0; i < implementation.portCount(); i++) {
            RFPortImplementation& port = implementation.port(i);
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_data_port(id,name,direction,load_port,"
                    "opcode_port,opcode_port_width_formula,rf_impl) "
                    "VALUES(NULL,\"" + port.name() + "\",\"" +
                    directionString(port.direction()) + "\",\"" +
                    port.loadPort() + "\",\"" + port.opcodePort() + "\",\""
                    + port.opcodePortWidthFormula() + "\"," +
                    Conversion::toString(implID) + ");"));
        }
 
        // insert into block_source_file table
        for (int i = 0; i < implementation.implementationFileCount(); i++) {
            BlockImplementationFile& file = implementation.file(i);
            addBlockImplementationFileToHDB(file);
        }
 
        // insert into rf_source_file table
        for (int i = 0; i < implementation.implementationFileCount(); i++) {
            BlockImplementationFile& file = implementation.file(i);
            string path = file.pathToFile();
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_source_file values(NULL, " + 
                    Conversion::toString(implID) +
                    ", (SELECT id FROM block_source_file WHERE file=\"" +
                    path + "\"));"));
        }
        
        // insert into rf_external_port table
        for (int i = 0; i < implementation.externalPortCount(); i++) {
            RFExternalPort& port = implementation.externalPort(i);
            string direction = directionString(port.direction());
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_external_port(id,name,direction,"
                    "width_formula,description,rf_impl) VALUES(NULL,\"" +
                    port.name() + "\",\"" + direction + "\",\"" +
                    port.widthFormula() + "\",\"" + port.description() +
                    "\"," + Conversion::toString(implID) + ");"));
        }
 
        // insert into rf_implementation_parameter table
        for (int i = 0; i < implementation.parameterCount(); i++) {
            RFImplementation::Parameter param = implementation.parameter(i);
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_implementation_parameter(id,name,type,"
                    "value,rf_impl) VALUES(NULL,\"" + param.name +
                    "\",\"" + param.type + "\",\"" + param.value +
                    "\"," + Conversion::toString(implID) + ");"));
        }
 
        // Insert implicit parameters to rf_implementation_parameter table
        // (size and width parameter references if not empty and parameters
        // for them do not exists).
        string widthParam = implementation.widthParameter();
        if (!widthParam.empty() && !implementation.hasParameter(widthParam)) {
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_implementation_parameter(id,name,type,"
                    "value,rf_impl) VALUES(NULL,\"" + widthParam +
                    "\", \"integer\", \"\"," +
                    Conversion::toString(implID) + ");"));
        }
        string sizeParam = implementation.sizeParameter();
        if (!sizeParam.empty() && !implementation.hasParameter(sizeParam)) {
            dbConnection_->updateQuery(
                std::string(
                    "INSERT INTO rf_implementation_parameter(id,name,type,"
                    "value,rf_impl) VALUES(NULL,\"" + sizeParam +
                    "\", \"integer\", \"\"," +
                    Conversion::toString(implID) + ");"));
        }
 
        // insert into rf_ext_port_parameter_dependency table
        for (int i = 0; i < implementation.externalPortCount(); i++) {
            RFExternalPort& port = implementation.externalPort(i);
            for (int i = 0; i < port.parameterDependencyCount(); i++) {
                string param = port.parameterDependency(i);
                dbConnection_->updateQuery(
                    std::string(
                        "INSERT INTO rf_ext_port_parameter_dependency(id,"
                        "port,parameter) VALUES(NULL,(SELECT id FROM "
                        "rf_external_port WHERE rf_impl=" +
                        Conversion::toString(implID) + " AND name=\"" +
                        port.name() + "\"),(SELECT id FROM "
                        "rf_implementation_parameter WHERE rf_impl=" +
                        Conversion::toString(implID) + " AND name=\"" +
                        param + "\"));"));
            }
        }
 
        dbConnection_->commit();
        return implID;
 
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}

References __func__, addBlockImplementationFileToHDB(), addBooleanColumn(), assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), CQ_RF_EXT_PORT_PARAMETER_DEPENDENCY, CQ_RF_EXTERNAL_PORT, CQ_RF_IMPLEMENTATION_PARAMETER, dbConnection_, RelationalDBConnection::DDLQuery(), debugLog, HDB::ExternalPort::description(), HDB::ExternalPort::direction(), HDB::RFPortImplementation::direction(), directionString(), Exception::errorMessage(), hasColumn(), HDB::RFEntry::hasImplementation(), hasRFEntry(), implementation, RelationalDBConnection::lastInsertRowID(), HDB::PortImplementation::loadPort(), HDB::ExternalPort::name(), HDB::Parameter::name, HDB::PortImplementation::name(), HDB::RFPortImplementation::opcodePort(), HDB::RFPortImplementation::opcodePortWidthFormula(), HDB::ExternalPort::parameterDependency(), HDB::ExternalPort::parameterDependencyCount(), HDB::BlockImplementationFile::pathToFile(), rfByEntryID(), RelationalDBConnection::rollback(), RelationalDBConnection::tableExistsInDB(), Conversion::toString(), HDB::Parameter::type, RelationalDBConnection::updateQuery(), HDB::Parameter::value, and HDB::ExternalPort::widthFormula().

Referenced by AddRFImplementationCmd::Do(), and HDBEditorModifyCmd::Do().

Here is the call graph for this function:

◆ addRFParametersToImplementation()

void HDB::HDBManager::addRFParametersToImplementation	(	RFImplementation &	implementation,
		RowID	entryID
	)		const

private

Adds parameters to the given RF implementation which is the implementation of the RF entry that has the given ID.

Parameters

implementation	The implementation.
entryID	ID of the RF entry.

Definition at line 5260 of file HDBManager.cc.

                         {
 
    if (!dbConnection_->tableExistsInDB("rf_implementation_parameter")) {
        // Add implicit parameters: size and width parameters if older
        // hdb is opened.
        if (implementation.widthParameter() != "") {
            implementation.addParameter(implementation.widthParameter(),
                "integer", "");
        }
        if (implementation.sizeParameter() != "") {
            implementation.addParameter(implementation.sizeParameter(),
                "integer", "");
        }
        return;
    }
 
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            rfImplementationParametersByIDQuery(entryID));
    } catch (const Exception&) {
        assert(false);
    }
 
    while (result->hasNext()) {
        result->next();
        const DataObject& nameData = result->data("name");
        const DataObject& typeData = result->data("type");
        const DataObject& valueData = result->data("value");
        string name = nameData.stringValue();
        string type = typeData.stringValue();
        string value = valueData.stringValue();
        implementation.addParameter(name, type, value);
    }
 
    // If RF implementation's size and width parameter dependencies do not have
    // parameter defined, add default parameters for them.
    if (implementation.widthParameter() != "" &&
        !implementation.hasParameter(implementation.widthParameter())) {
        implementation.addParameter(implementation.widthParameter(),
            "integer", "");
        implementation.addParameter(implementation.sizeParameter(),
            "integer", "");
    }
    if (implementation.sizeParameter() != "" &&
        !implementation.hasParameter(implementation.sizeParameter())) {
        implementation.addParameter(implementation.sizeParameter(),
            "integer", "");
    }
    delete result;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), implementation, RelationalDBQueryResult::next(), RelationalDBConnection::query(), rfImplementationParametersByIDQuery(), DataObject::stringValue(), and RelationalDBConnection::tableExistsInDB().

Referenced by createImplementationOfRF().

Here is the call graph for this function:

◆ addSocketCostEstimationData()

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

Adds the given cost estimation data values to given Socket entry.

Parameters

socketID The ID of the Socket entry the cost data will be added. @valueName The name of the cost value. @value The cost value. @pluginID The ID of the cost function plugin that owns this data.

Definition at line 3664 of file HDBManager.cc.

                          {
 
 
    RowID dataID;
 
    // add the data
    try {
        dbConnection_->updateQuery(
            std::string(
                "INSERT INTO cost_estimation_data (id,plugin_reference,"
                "socket_reference,name,value) VALUES (NULL," + 
                Conversion::toString(pluginID) + "," + 
                Conversion::toString(socketID) + ",\"" + valueName + "\",\"" +
                value + "\");"));
        dataID = dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    return dataID;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addSocketEntry()

RowID HDB::HDBManager::addSocketEntry ( ) const

Adds an empty Socket entry to the database.

Parameters

entry The Socket entry.

Returns: ID of the added Socket entry.

Definition at line 3592 of file HDBManager.cc.

                                 {
    try {
        dbConnection_->updateQuery(
            std::string("INSERT INTO socket(id) VALUES(NULL);"));
        return dbConnection_->lastInsertRowID();
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return 0;
}    

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), and RelationalDBConnection::updateQuery().

Referenced by AddSocketEntryCmd::Do().

Here is the call graph for this function:

◆ areCompatiblePipelines()

bool HDB::HDBManager::areCompatiblePipelines ( const PipelineElementUsageTable & table )

staticprivate

Checks whether the pipeline element usages of the given table are compatible.

They are compatible if the first pipeline is more restrictive or equal to the second pipeline.

Parameters

table The table that describes the pipeline usages.

Returns: True if the pipelines are compatible, otherwise false.

Definition at line 5620 of file HDBManager.cc.

                                                                         {
    
    for (size_t i = 0; i < table.size(); i++) {
        std::set<const PipelineElement*> usedResources1 = table[i].usage1;
        // create a set of vector indices which mean what stages cannot be 
        // executed at the same time
        std::set<size_t> illegalStages1;
        for (size_t usageIndex = 0; usageIndex < table.size();
             usageIndex++) {
            if (usageIndex == i) {
                continue;
            }
            std::set<const PipelineElement*> resources = 
                table[usageIndex].usage1;
            std::set<const PipelineElement*> intersect;
            SetTools::intersection(usedResources1, resources, intersect);
            if (!intersect.empty()) {
                illegalStages1.insert(usageIndex);
            }
        }
 
        // create a similar vector of the other pipeline
        std::set<const PipelineElement*> usedResources2 = table[i].usage2;
        std::set<size_t> illegalStages2;
        for (size_t usageIndex = 0; usageIndex < table.size();
             usageIndex++) {
            if (usageIndex == i) {
                continue;
            }
            std::set<const PipelineElement*> resources = 
                table[usageIndex].usage2;
            std::set<const PipelineElement*> intersect;
            SetTools::intersection(usedResources2, resources, intersect);
            if (!intersect.empty()) {
                illegalStages2.insert(usageIndex);
            }
        }
 
        std::set<size_t> difference;
        AssocTools::difference(illegalStages2, illegalStages1, difference);
        if (!difference.empty()) {
            return false;
        }
    }
 
    return true;
}

References AssocTools::difference(), and SetTools::intersection().

Referenced by isMatchingArchitecture().

Here is the call graph for this function:

◆ blockSourceFile()

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

Returns block source file names

Returns: List of block source file names.

Definition at line 7124 of file HDBManager.cc.

                            {
    
    RelationalDBQueryResult* queryResult;
    try {
        queryResult = dbConnection_->query(
            std::string("SELECT * FROM block_source_file"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    std::list<std::string> files;
    while (queryResult->hasNext()) {
        queryResult->next(); 
        files.push_back(queryResult->data(1).stringValue());
    }
 
    delete queryResult;
    return files;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and DataObject::stringValue().

Here is the call graph for this function:

◆ busCostEstimationData()

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

Returns bus cost estimation data.

This version assumes that there's only one entry with given parameters.

Parameters

valueName	Name of the value to fetch.
busID	The ID of the bus entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data.

Exceptions

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

Definition at line 3492 of file HDBManager.cc.

                                       {
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(            
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND socket_reference IS NULL AND " +
            "     bus_reference = " + Conversion::toString(busID) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');");
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by DefaultICDecoderEstimator::delayOfBus().

Here is the call graph for this function:

◆ busCostEstimationDataIDs()

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

Returns a set of cost estimation data IDs which reference the given bus entry.

Parameters

busID ID of the bus entry.

Returns: Set of cost estimation data IDs.

Definition at line 6500 of file HDBManager.cc.

                                                      {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT id "
                "FROM cost_estimation_data "
                "WHERE bus_reference = ") +
            Conversion::toString(busID);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBToHtml::busEntryToHtml().

Here is the call graph for this function:

◆ busCostEstimationDataList()

HDBManager::DataObjectList * HDB::HDBManager::busCostEstimationDataList	(	const std::string &	valueName,
		RowID	busID,
		const std::string &	pluginName
	)		const

Returns a list of bus cost estimation data.

Parameters

valueName	Name of the value to fetch.
busID	The ID of the bus entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data. Becomes property of the caller.

Exceptions

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

Definition at line 3542 of file HDBManager.cc.

                                       {
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(            
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND socket_reference IS NULL AND " +
            "     bus_reference = " + Conversion::toString(busID) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');");
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }   
 
    if (queryResult->hasNext()) {
     
        DataObjectList* data = new DataObjectList;
   
        while (queryResult->hasNext()) {
            queryResult->next();
            DataObject value = queryResult->data("value");
            data->push_back(value);
        }
 
        delete queryResult;
        queryResult = NULL;
        return data;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ busEntryByIDQuery()

std::string HDB::HDBManager::busEntryByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the Bus entry that has the given ID.

The result set has fields {id}.

Parameters

id	ID of the entry.

Returns: The SQL query.

Definition at line 5805 of file HDBManager.cc.

                                      {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM bus "
        "WHERE bus.id=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by hasBusEntry().

Here is the call graph for this function:

◆ busEntryIDs()

std::set< RowID > HDB::HDBManager::busEntryIDs ( ) const

Returns a set of Bus entry IDs in the database.

Returns: A set containing all the Bus entry IDs in the database.

Definition at line 2085 of file HDBManager.cc.

                              {
 
    string query = "SELECT id AS 'bus.id' FROM bus;";
 
    // make the SQL query to obtain all the IDs
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(query);
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    std::set<RowID> idSet;
    while (queryResult->hasNext()) {
        queryResult->next();
        const DataObject& idData = queryResult->data("bus.id");
        idSet.insert(idData.integerValue());
    }
 
    delete queryResult;
    return idSet;
}   

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by CostDatabase::buildBuses(), CostEstimationDataDialog::onEntryTypeSelection(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ canRemoveFUArchitecture()

bool HDB::HDBManager::canRemoveFUArchitecture ( RowID archID ) const

Tells whether the FU architecture that has the given ID can be removed from the database. It can be removed only if no FU entry uses it.

Parameters

archID ID of the FU architecture.

Returns: True if the architecture can be removed, otherwise false.

Definition at line 890 of file HDBManager.cc.

                                                      {
 
    // check whether the architecture is used by FU entries
    try {
        RelationalDBQueryResult* queryResult = dbConnection_->query(
            std::string(
                "SELECT id FROM fu WHERE architecture=" +
                Conversion::toString(archID) + ";"));
        if (queryResult->hasNext()) {
            // there is an FU entry using the architecture
            delete queryResult;
            return false;
        } else {
            delete queryResult;
            return true;
        }
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBEditorDeleteCmd::Do(), and removeFUArchitecture().

Here is the call graph for this function:

◆ canRemoveRFArchitecture()

bool HDB::HDBManager::canRemoveRFArchitecture ( RowID archID ) const

Tells whether the given RF architecture can be removed.

The architecture can be removed if it is not used by any RF entry.

Parameters

archID ID of the RF architecture.

Definition at line 1494 of file HDBManager.cc.

                                                      {
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM rf WHERE architecture=" + 
                Conversion::toString(archID) + ";"));
        bool returnValue = !result->hasNext();
        delete result;
        return returnValue;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBEditorDeleteCmd::Do(), and removeRFArchitecture().

Here is the call graph for this function:

◆ containsFUArchitecture()

bool HDB::HDBManager::containsFUArchitecture ( RowID id ) const

private

Tells whether the HDB contains a FU architecture that has the given ID.

Parameters

id The ID.

Returns: True if the HDB contains the architecture, otherwise false.

Definition at line 4198 of file HDBManager.cc.

                                                 {
 
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM fu_architecture WHERE id=" +
                Conversion::toString(id) + ";"));
        bool returnValue = result->hasNext();
        delete result;
        return returnValue;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by fuArchitectureByID(), and setArchitectureForFU().

Here is the call graph for this function:

◆ containsImplementationFile()

bool HDB::HDBManager::containsImplementationFile ( const std::string & pathToFile ) const

private

Tells whether the HDB contains the given block implementation file.

Parameters

pathToFile Full path to the file.

Definition at line 4171 of file HDBManager.cc.

                                                                        {
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT * FROM block_source_file WHERE file=\"" +
                pathToFile + "\";"));
        bool returnValue = result->hasNext();
        delete result;
        return returnValue;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), and RelationalDBConnection::query().

Referenced by addBlockImplementationFileToHDB().

Here is the call graph for this function:

◆ containsOperation()

bool HDB::HDBManager::containsOperation ( const std::string & opName ) const

private

Tells whether the HDB contains the given operation in operation table.

Parameters

opName Name of the operation.

Returns: True if HDB contains the operation, otherwise false.

Definition at line 4145 of file HDBManager.cc.

                                                           {
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT * FROM operation WHERE lower(name)=lower(\"" + opName
                + "\");"));
        bool returnValue = result->hasNext();
        delete result;
        return returnValue;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), and RelationalDBConnection::query().

Referenced by addFUArchitecture(), and addFUImplementation().

Here is the call graph for this function:

◆ containsRFArchitecture()

bool HDB::HDBManager::containsRFArchitecture ( RowID id ) const

private

Tells whether the HDB contains a RF architecture with the given ID.

Parameters

id The ID.

Returns: True if the HDB contains the architecture, otherwise false.

Definition at line 4226 of file HDBManager.cc.

                                                 {
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM rf_architecture WHERE id=" +
                Conversion::toString(id) + ";"));
        bool returnValue = result->hasNext();
        delete result;
        return returnValue;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return false;
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by rfArchitectureByID(), and setArchitectureForRF().

Here is the call graph for this function:

◆ costEstimationData()

CostEstimationData HDB::HDBManager::costEstimationData ( RowID entryId ) const

Returns cost estimation data with the given id.

Parameters

entryId Id of the cost estimation data entry.

Returns: The data.

Exceptions

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

Definition at line 6309 of file HDBManager.cc.

                                                  {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT value, cost_estimation_data.name AS data_name, "
                "       cost_function_plugin.id AS plugin_id, "
                "       fu_reference, rf_reference, bus_reference, "
                "       socket_reference "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE cost_estimation_data.plugin_reference="
                "      cost_function_plugin.id AND "
                "      cost_estimation_data.id = ") +
            Conversion::toString(entryId);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);
    } 
 
    if (queryResult->hasNext()) {
        queryResult->next();
 
        std::string name = queryResult->data("data_name").stringValue();
 
        CostEstimationData data;
        data.setName(name);
        data.setValue(queryResult->data("value"));
        data.setPluginID(queryResult->data("plugin_id").integerValue());
 
        if (!queryResult->data("fu_reference").isNull()) {
            data.setFUReference(queryResult->data("fu_reference").integerValue());
        }
        if (!queryResult->data("rf_reference").isNull()) {
            data.setRFReference(queryResult->data("rf_reference").integerValue());
        }
        if (!queryResult->data("bus_reference").isNull()) {
            data.setBusReference(queryResult->data("bus_reference").integerValue());
        }
        if (!queryResult->data("socket_reference").isNull()) {
            data.setSocketReference(
                queryResult->data("socket_reference").integerValue());
        }
 
        delete queryResult;
        queryResult = NULL;
 
        return data;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), CostEstimationData::setBusReference(), CostEstimationData::setFUReference(), CostEstimationData::setName(), CostEstimationData::setPluginID(), CostEstimationData::setRFReference(), CostEstimationData::setSocketReference(), CostEstimationData::setValue(), DataObject::stringValue(), and Conversion::toString().

Referenced by CostDatabase::buildBuses(), CostDatabase::buildFunctionUnits(), CostDatabase::buildRegisterFiles(), CostDatabase::buildSockets(), HDBToHtml::busEntryToHtml(), HDBToHtml::costFunctionPluginToHtml(), HDBToHtml::fuEntryToHtml(), HDBToHtml::fuImplToHtml(), HDBToHtml::rfEntryToHtml(), HDBToHtml::rfImplToHtml(), HDBToHtml::socketEntryToHtml(), CostEstimationDataDialog::TransferDataToWindow(), and CostFunctionPluginDialog::TransferDataToWindow().

Here is the call graph for this function:

◆ costEstimationDataIDs()

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

virtual

Function for querying cost estimation data from the HDB.

Returns set of cost estiamtion data Row IDs that match the given datas attributes that are set.

Parameters

match	CostEstimationData which is matched to the HDB data.
useCompiledQueries	if true use a compiled query instead of making a new one.
compiledQuery	Pointer to a prepared query to be used.

Returns: Set of cost estimation data row IDs that match the query.

Reimplemented in HDB::CachedHDBManager.

Definition at line 6764 of file HDBManager.cc.

                                                  {
 
    std::string query = "";
    if (!compiledQuery) {
        createCostEstimatioDataIdsQuery(match, &query);
    } else {
        // only bind query variables
        createCostEstimatioDataIdsQuery(match, NULL, compiledQuery, NULL);
    }
 
    RelationalDBQueryResult* result = NULL;
    
    if (compiledQuery) {
        result = compiledQuery;
    } else {
        try {
            result = dbConnection_->query(query);
        } catch (const Exception& e) {
            debugLog(query);
            debugLog(e.errorMessage());
            assert(false);
        }
    }
 
    std::set<RowID> dataIDs;
    while (result->hasNext()) {
        result->next();
        dataIDs.insert(result->data(0).integerValue());
    }
 
    if (!compiledQuery) {
        delete result;
    } else {
        compiledQuery->reset();
    }
 
    return dataIDs;
}

References assert, createCostEstimatioDataIdsQuery(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and RelationalDBQueryResult::reset().

Referenced by CostDatabase::buildBuses(), CostDatabase::buildFunctionUnits(), CostDatabase::buildRegisterFiles(), CostDatabase::buildSockets(), and HDB::CachedHDBManager::costEstimationDataIDs().

Here is the call graph for this function:

◆ costEstimationDataValue() [1/2]

DataObject HDB::HDBManager::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.

Todo:: Another version for fetching lists of data.

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 in HDB::CachedHDBManager.

Definition at line 3817 of file HDBManager.cc.

                                                                   {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND fu_reference IS NULL " +
            " AND socket_reference IS NULL " +
            " AND bus_reference IS NULL " +       
            " AND cost_estimation_data.name LIKE('" + valueName + "');";
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by HDB::CachedHDBManager::costEstimationDataValue(), DefaultICDecoderEstimator::delayOfBus(), DefaultICDecoderEstimator::delayOfSocket(), DefaultICDecoderEstimator::delayOfSocket(), DefaultICDecoderEstimator::estimateICArea(), and DefaultICDecoderEstimator::estimateICEnergy().

Here is the call graph for this function:

◆ costEstimationDataValue() [2/2]

DataObject HDB::HDBManager::costEstimationDataValue ( RowID entryId ) const

Returns cost estimation data value with the given id.

Parameters

entryId Id of the cost estimation data entry.

Returns: The data.

Exceptions

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

Definition at line 3868 of file HDBManager.cc.

                                                       {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT value "
                "FROM cost_estimation_data "
                "WHERE cost_estimation_data.id = ") +
            Conversion::toString(entryId);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ costFunctionPluginByID()

CostFunctionPlugin * HDB::HDBManager::costFunctionPluginByID ( RowID pluginID ) const

Returns cost function plugin with the given ID.

Parameters

pluginID ID of the cost function plugin.

Returns: Cost function plugin with the given ID.

Exceptions

Exception Throws if pluginID not found (KeyNotFound) or illegal cost_function_plugin row found.

Definition at line 6617 of file HDBManager.cc.

                                                       {
    RelationalDBQueryResult* pluginData;
 
    std::string pluginDataQuery =
        "SELECT id, description, name, plugin_file_path, type "
        "       FROM cost_function_plugin WHERE id = ";
 
    pluginDataQuery += Conversion::toString(pluginID);
 
    try {
        pluginData = dbConnection_->query(pluginDataQuery);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (pluginData->hasNext()) {
        pluginData->next();
        
        int id = pluginData->data("id").integerValue();
        std::string name = pluginData->data("name").stringValue();
        std::string desc = pluginData->data("description").stringValue();
        std::string path = pluginData->data("plugin_file_path").stringValue();
        std::string typeStr = pluginData->data("type").stringValue();
        
        CostFunctionPlugin::CostFunctionPluginType type = 
            CostFunctionPlugin::COST_FU;
        if (typeStr == COST_PLUGIN_TYPE_FU) {
            type = CostFunctionPlugin::COST_FU;
        } else if (typeStr == COST_PLUGIN_TYPE_RF) {
            type = CostFunctionPlugin::COST_RF;
        } else if (typeStr == COST_PLUGIN_TYPE_DECOMP) {
            type = CostFunctionPlugin::COST_DECOMP;
        } else if (typeStr == COST_PLUGIN_TYPE_ICDEC) {
            type = CostFunctionPlugin::COST_ICDEC;
        } else {
            delete pluginData;
            InvalidData ex(
                __FILE__, __LINE__, __func__, 
                (boost::format("Illegal cost_function_plugin type %d.") %
                 type).str());
            throw ex;
        }
 
        delete pluginData;
        return new CostFunctionPlugin(id, desc, name, path, type);
 
    } else {
        delete pluginData;
        throw KeyNotFound(
            __FILE__, __LINE__, __func__, 
            (boost::format("Cost function plugin with id %d not found.") %
             pluginID).str());
    }
}

References __func__, assert, HDB::CostFunctionPlugin::COST_DECOMP, HDB::CostFunctionPlugin::COST_FU, HDB::CostFunctionPlugin::COST_ICDEC, COST_PLUGIN_TYPE_DECOMP, COST_PLUGIN_TYPE_FU, COST_PLUGIN_TYPE_ICDEC, COST_PLUGIN_TYPE_RF, HDB::CostFunctionPlugin::COST_RF, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by CostDatabase::buildBuses(), CostDatabase::buildFunctionUnits(), CostDatabase::buildRegisterFiles(), CostDatabase::buildSockets(), HDBToHtml::costFunctionPluginToHtml(), SetCostFunctionPluginCmd::Do(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ costFunctionPluginDataIDs()

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

Returns cost estimation data IDs related to the given cost function plugin.

Parameters

pluginID ID of the cost function plugin.

Returns: IDs of the cost function plugin estimation data.

Definition at line 6575 of file HDBManager.cc.

                                                          {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT id "
                "FROM cost_estimation_data "
                "WHERE plugin_reference = ") +
            Conversion::toString(pluginID);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBToHtml::costFunctionPluginToHtml(), and CostFunctionPluginDialog::TransferDataToWindow().

Here is the call graph for this function:

◆ costFunctionPluginIDs()

std::set< RowID > HDB::HDBManager::costFunctionPluginIDs ( ) const

Returns RowIDs of cost fucntion plugins in the HDB.

Returns: All cost function plugin IDs.

Definition at line 6539 of file HDBManager.cc.

                                        {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            "SELECT id FROM cost_function_plugin";
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by CostDatabase::buildBuses(), CostDatabase::buildFunctionUnits(), CostDatabase::buildRegisterFiles(), CostDatabase::buildSockets(), SetCostFunctionPluginCmd::Do(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ createCostEstimatioDataIdsQuery() [1/2]

void HDB::HDBManager::createCostEstimatioDataIdsQuery	(	const CostEstimationData &	match,
		std::string &	query
	)		const

private

◆ createCostEstimatioDataIdsQuery() [2/2]

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

protected

Creates or prepares the query for cost estimation data ids.

Parameters

match	CostEstimationData which is matched to the HDB data.
query	String variable where query is stored, null if no query is to be created.
compiledQuery	Pointer to a prepared query to be used, null if not to be used.
queryHash	Pointer to unique id variable to be created for the query, null if not to be created.
createBindableQuery	If true query of a kind where variables can be binded is created, if false normal query with values is created.

Definition at line 6821 of file HDBManager.cc.

                                    {
 
    if (queryHash) {
        *queryHash = 0;
    }
    bool firstMatch = true;
    unsigned int count = 0;
 
    if (query) {
        *query = "SELECT id FROM cost_estimation_data WHERE ";
    }
 
    if (match.hasName()) {
        if (queryHash) {
            *queryHash |= 1;
        }
 
        if (compiledQuery) {
            compiledQuery->bindString(++count, match.name());
        }
 
        if (query) {
            firstMatch = false;
            *query += "name='";
            *query += createBindableQuery ? "?" : match.name();
            *query += "'";
        }
    }
 
    if (match.hasValue()) {
        if (queryHash) {
            *queryHash |= 2;
        }
 
        if (compiledQuery) {
            compiledQuery->bindString(++count, match.name());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "value='";
            *query += createBindableQuery ? "?" : match.name();
            *query += "'";
        }
    }
 
    if (match.hasPluginID()) {
        if (queryHash) {
            *queryHash |= 4;
        }
 
        if (compiledQuery) {
            compiledQuery->bindInt(++count, match.pluginID());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "plugin_reference = ";
            *query += createBindableQuery ? "?" : 
                Conversion::toString(match.pluginID());
        }
    }
 
    if (match.hasFUReference()) {
        if (queryHash) {
            *queryHash |= 8;
        }
 
        if (compiledQuery) {
            compiledQuery->bindInt(++count, match.fuReference());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "fu_reference = ";
            *query += createBindableQuery ? "?" : 
                Conversion::toString(match.fuReference());
        }
    }
 
    if (match.hasRFReference()) {
        if (queryHash) {
            *queryHash |= 16;
        }
 
        if (compiledQuery) {
            compiledQuery->bindInt(++count, match.rfReference());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "rf_reference = ";
            *query += createBindableQuery ? "?" : 
                Conversion::toString(match.rfReference());
        }
    }
 
    if (match.hasBusReference()) {
        if (queryHash) {
            *queryHash |= 32;
        }
 
        if (compiledQuery) {
            compiledQuery->bindInt(++count, match.rfReference());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "bus_reference = ";
            *query += createBindableQuery ? "?" : 
                Conversion::toString(match.busReference());
        }
    }
 
    if (match.hasSocketReference()) {
        if (queryHash) {
            *queryHash |= 64;
        }
 
        if (compiledQuery) {
            compiledQuery->bindInt(++count, match.rfReference());
        }
 
        if (query) {
            if (!firstMatch) *query += " AND ";
            firstMatch = false;
            *query += "socket_reference = ";
            *query += createBindableQuery ? "?" : 
                Conversion::toString(match.socketReference());
        }
    }
 
    if (query) {
        *query += ";";
    }
}

Referenced by HDB::CachedHDBManager::costEstimationDataIDs(), and costEstimationDataIDs().

Here is the call graph for this function:

◆ createCostFunctionOfFU()

CostFunctionPlugin * HDB::HDBManager::createCostFunctionOfFU ( RowID id ) const

private

Obtains the cost function data of the FU that has the given ID and creates a CostFunctionPlugin instance of it.

Parameters

id	ID of the FU entry.

Returns: The newly created FUImplementation instance or NULL if the FU has no cost function.

Definition at line 4677 of file HDBManager.cc.

                                                 {
 
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(
            "SELECT cost_function_plugin.id AS id, "
            "       cost_function_plugin.description AS description,"
            "       cost_function_plugin.name AS name, "
            "       cost_function_plugin.plugin_file_path AS plugin_file_path "
            "FROM cost_function_plugin, fu "
            "WHERE fu.id = " + Conversion::toString(id) + 
            " AND cost_function_plugin.id = fu.cost_function;");
    } catch (const Exception& e) {
        delete queryResult;
        debugLog(e.errorMessage());
        return NULL;
    }
 
    CostFunctionPlugin* costFunction = NULL;
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        const DataObject& pluginIdData = 
            queryResult->data("id");
        const DataObject& descriptionData = 
            queryResult->data("description");
        const DataObject& nameData = 
            queryResult->data("name");
        const DataObject& pluginFilePathData = 
            queryResult->data("plugin_file_path");
 
        int pluginId = -1;
        string description = "";
        string name = "";
        string pluginFilePath = "";
        try {
            if (!pluginIdData.isNull()) {
                pluginId = pluginIdData.integerValue();
            } 
            description = descriptionData.stringValue();
            name = nameData.stringValue();
            pluginFilePath = pluginFilePathData.stringValue();
        } catch (const Exception& e) {
            debugLog(
                std::string("Something wrong with conversion: ") + 
                e.errorMessage());
            delete queryResult;
            queryResult = NULL;
            return NULL;
        }
 
        costFunction = new CostFunctionPlugin(
            pluginId, description, name, pluginFilePath, 
            CostFunctionPlugin::COST_FU);
    }
    
    delete queryResult;
    queryResult = NULL;
    return costFunction;
}

References HDB::CostFunctionPlugin::COST_FU, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by fuByEntryID().

Here is the call graph for this function:

◆ createCostFunctionOfRF()

CostFunctionPlugin * HDB::HDBManager::createCostFunctionOfRF ( RowID id ) const

private

Obtains the cost function data of the RF that has the given ID and creates a CostFunctionPlugin instance of it.

Parameters

id	ID of the RF entry.

Returns: The newly created FUImplementation instance or NULL if the RF has no cost function.

Definition at line 4749 of file HDBManager.cc.

                                                 {
 
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(
            "SELECT cost_function_plugin.id AS id, "
            "       cost_function_plugin.description AS description,"
            "       cost_function_plugin.name AS name, "
            "       cost_function_plugin.plugin_file_path AS plugin_file_path "
            "FROM cost_function_plugin, rf "
            "WHERE rf.id = " + Conversion::toString(id) + 
            " AND cost_function_plugin.id = rf.cost_function;");
    } catch (const Exception& e) {
        delete queryResult;
        debugLog(e.errorMessage());
        return NULL;
    }
 
    CostFunctionPlugin* costFunction = NULL;
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        const DataObject& pluginIdData = 
            queryResult->data("id");
        const DataObject& descriptionData = 
            queryResult->data("description");
        const DataObject& nameData = 
            queryResult->data("name");
        const DataObject& pluginFilePathData = 
            queryResult->data("plugin_file_path");
 
        int pluginId = -1;
        string description = "";
        string name = "";
        string pluginFilePath = "";
        try {
            if (!pluginIdData.isNull()) {
                pluginId = pluginIdData.integerValue();
            } 
            description = descriptionData.stringValue();
            name = nameData.stringValue();
            pluginFilePath = pluginFilePathData.stringValue();
        } catch (const Exception& e) {
            debugLog(
                std::string("Something wrong with conversion: ") + 
                e.errorMessage());
            delete queryResult;
            queryResult = NULL;
            return NULL;
        }
 
        costFunction = new CostFunctionPlugin(
            pluginId, description, name, pluginFilePath, 
            CostFunctionPlugin::COST_RF);
    }
    
    delete queryResult;
    queryResult = NULL;
    return costFunction;
}

References HDB::CostFunctionPlugin::COST_RF, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by rfByEntryID().

Here is the call graph for this function:

◆ createImplementationOfFU()

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

protectedvirtual

Obtains implementation data of the FU that has the given ID and creates an FUImplementation instance of it.

Parameters

architecture	Architecture of the FU (needed when matching the ports in the implementation).
id	ID of the FU entry.

Returns: The newly created FUImplementation instance or NULL if the FU has no implementation.

Reimplemented in HDB::CachedHDBManager.

Definition at line 4601 of file HDBManager.cc.

                    {
 
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* implData = NULL;
    const std::string queryString = fuImplementationByIDQuery(id);
    try {
        implData = dbConnection_->query(queryString);
    } catch (const Exception& e) {
        delete implData;
        debugLog(
            std::string("query ") + queryString + " threw something: " + 
            e.errorMessage());
        return NULL;
    }
 
    FUImplementation* implementation = NULL;
 
    if (implData->hasNext()) {
        implData->next();
        assert(!implData->hasNext());
 
        int idColumn = implData->column("fu_implementation.id");
        int nameColumn = implData->column("fu_implementation.name");
        int opcodePortColumn = implData->column(
            "fu_implementation.opcode_port");
        int clkPortColumn = implData->column("fu_implementation.clk_port");
        int rstPortColumn = implData->column("fu_implementation.rst_port");
        int glockPortColumn = implData->column(
            "fu_implementation.glock_port");
        int glockReqPortColumn = implData->column(
            "fu_implementation.glock_req_port");
        
        const DataObject& idData = implData->data(idColumn);
        const DataObject& nameData = implData->data(nameColumn);
        const DataObject& opcodePortData = implData->data(opcodePortColumn);
        const DataObject& clkPortData = implData->data(clkPortColumn);
        const DataObject& rstPortData = implData->data(rstPortColumn);
        const DataObject& glockPortData = implData->data(glockPortColumn);
        const DataObject& glockReqPortData = implData->data(
            glockReqPortColumn);
 
        RowID implID = idData.integerValue();
        string name = nameData.stringValue();
        string opcodePort = opcodePortData.stringValue();
        string clkPort = clkPortData.stringValue();
        string rstPort = rstPortData.stringValue();
        string glockPort = glockPortData.stringValue();
        string glockReqPort = glockReqPortData.stringValue();
 
        implementation = new FUImplementation(
            name, opcodePort, clkPort, rstPort, glockPort, glockReqPort);
        implementation->setID(implID);
        
        addFUParametersToImplementation(*implementation, id);
        addOpcodesToImplementation(*implementation, id);
        addDataPortsToImplementation(*implementation, architecture, id);
        addFUExternalPortsToImplementation(*implementation, id);
        addBlockImplementationFiles(*implementation, id);
    }
    
    delete implData;
    implData = NULL;
    return implementation;
}

References addBlockImplementationFiles(), addDataPortsToImplementation(), addFUExternalPortsToImplementation(), addFUParametersToImplementation(), addOpcodesToImplementation(), assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), fuImplementationByIDQuery(), RelationalDBQueryResult::hasNext(), implementation, DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by HDB::CachedHDBManager::createImplementationOfFU(), and fuByEntryID().

Here is the call graph for this function:

◆ createImplementationOfRF()

RFImplementation * HDB::HDBManager::createImplementationOfRF ( RowID id ) const

protectedvirtual

Obtains implementation data of the RF that has the given ID and creates an RFImplementation instance of it.

Parameters

id	ID of the RF entry.

Returns: The newly created RFImplementation instance or NULL if the RF has no implementation.

Reimplemented in HDB::CachedHDBManager.

Definition at line 4823 of file HDBManager.cc.

                                                   {
 
    RelationalDBQueryResult* implementationData = NULL;
    try {
        if(hasColumn("rf_implementation", "sac_param")) {
            // Use new query.
            implementationData = dbConnection_->query(
                rfImplementationByIDQuery2(id));
        } else {
            // Use fallback query.
            implementationData = dbConnection_->query(
                rfImplementationByIDQuery(id));
        }
    } catch (const Exception& e) {
        assert(false);
    }
 
    RFImplementation* implementation = NULL;
 
    if (implementationData->hasNext()) {
        implementationData->next();
        assert(!implementationData->hasNext());
        int idColumn = implementationData->column("id");
        int nameColumn = implementationData->column("name");
        int sizeParamColumn = implementationData->column("size_param");
        int widthParamColumn = implementationData->column("width_param");
        int sacParamColumn = implementationData->column("sac_param");
        int clkPortColumn = implementationData->column("clk_port");
        int rstPortColumn = implementationData->column("rst_port");
        int glockPortColumn = implementationData->column("glock_port");
        int guardPortColumn = implementationData->column("guard_port");
        
        const DataObject& idData = implementationData->data(idColumn);
        const DataObject& nameData = implementationData->data(nameColumn);
        const DataObject& sizeParamData = implementationData->data(
            sizeParamColumn);
        const DataObject& widthParamData = implementationData->data(
            widthParamColumn);
        const DataObject& clkPortData = implementationData->data(
            clkPortColumn);
        const DataObject& rstPortData = implementationData->data(
            rstPortColumn);
        const DataObject& glockPortData = implementationData->data(
            glockPortColumn);
        const DataObject& guardPortData = implementationData->data(
            guardPortColumn);
        const DataObject& sacParamData = implementationData->data(
            sacParamColumn);
 
        string sizeParam = sizeParamData.stringValue();
        string widthParam = widthParamData.stringValue();
        string guardPort = guardPortData.stringValue();
        bool sacParam =
            (sacParamColumn != RelationalDBQueryResult::UNKNOWN_INDEX) ?
            sacParamData.boolValue() :
            false;
 
        implementation = new RFImplementation(
            nameData.stringValue(), clkPortData.stringValue(), 
            rstPortData.stringValue(), glockPortData.stringValue(), 
            sizeParam, widthParam, guardPort, sacParam);
        implementation->setID(idData.integerValue());
 
        addRFParametersToImplementation(*implementation, id);
        addDataPortsToImplementation(*implementation, id);
        addRFExternalPortsToImplementation(*implementation, id);
        addBlockImplementationFiles(*implementation, id);
    }
    
    delete implementationData;
    implementationData = NULL;
    return implementation;
}

References addBlockImplementationFiles(), addDataPortsToImplementation(), addRFExternalPortsToImplementation(), addRFParametersToImplementation(), assert, DataObject::boolValue(), RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, hasColumn(), RelationalDBQueryResult::hasNext(), implementation, DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), rfImplementationByIDQuery(), rfImplementationByIDQuery2(), DataObject::stringValue(), and RelationalDBQueryResult::UNKNOWN_INDEX.

Referenced by HDB::CachedHDBManager::createImplementationOfRF(), and rfByEntryID().

Here is the call graph for this function:

◆ createNew()

void HDB::HDBManager::createNew ( const std::string & file )

static

Creates a new HDB to the given file.

Parameters

file	The database file to be created.

Exceptions

UnreachableStream If the given file exists already or cannot be created for another reason.

Definition at line 534 of file HDBManager.cc.

                                           {
    if (!FileSystem::fileIsCreatable(file)) {
        const string procName = "HDBManager::createNew";
        throw UnreachableStream(__FILE__, __LINE__, procName);
    }
 
    try {
        SQLite db;
        RelationalDBConnection& connection = db.connect(file);
 
        // create tables to the database
        connection.DDLQuery(CQ_FU);
        connection.DDLQuery(CQ_FU_ARCHITECTURE);
        connection.DDLQuery(CQ_PIPELINE_RESOURCE);
        connection.DDLQuery(CQ_OPERATION_PIPELINE);
        connection.DDLQuery(CQ_PIPELINE_RESOURCE_USAGE);
        connection.DDLQuery(CQ_IO_USAGE);
        connection.DDLQuery(CQ_OPERATION);
        connection.DDLQuery(CQ_FU_DATA_PORT);
        connection.DDLQuery(CQ_IO_BINDING);
        connection.DDLQuery(CQ_FU_IMPLEMENTATION);
        connection.DDLQuery(CQ_OPCODE_MAP);
        connection.DDLQuery(CQ_FU_PORT_MAP);
        connection.DDLQuery(CQ_FU_EXTERNAL_PORT);
        connection.DDLQuery(CQ_FU_IMPLEMENTATION_PARAMETER);
        connection.DDLQuery(CQ_FU_EXT_PORT_PARAMETER_DEPENDENCY);
        connection.DDLQuery(CQ_RF);
        connection.DDLQuery(CQ_RF_ARCHITECTURE);
        connection.DDLQuery(CQ_RF_IMPLEMENTATION);
        connection.DDLQuery(CQ_RF_IMPLEMENTATION_PARAMETER);
        connection.DDLQuery(CQ_RF_EXTERNAL_PORT);
        connection.DDLQuery(CQ_RF_EXT_PORT_PARAMETER_DEPENDENCY);
        connection.DDLQuery(CQ_RF_DATA_PORT);
        connection.DDLQuery(CQ_FORMAT);
        connection.DDLQuery(CQ_BUS);
        connection.DDLQuery(CQ_SOCKET);
        connection.DDLQuery(CQ_COST_FUNCTION_PLUGIN);
        connection.DDLQuery(CQ_COST_ESTIMATION_DATA);
        connection.DDLQuery(CQ_BLOCK_SOURCE_FILE);
        connection.DDLQuery(CQ_RF_SOURCE_FILE);
        connection.DDLQuery(CQ_FU_SOURCE_FILE);
        connection.DDLQuery(CQ_FU_PORT_MAP_ARCH_INDEX);
        connection.DDLQuery(CQ_FU_IMPL_ENTRY_INDEX);
        connection.DDLQuery(CQ_RF_IMPL_ENTRY_INDEX);
 
        // insert the contents to format table
        insertFileFormats(connection);
        db.close(connection);
    } catch (const Exception& e) {
        debugLog(
            std::string("Initialization of HDB failed. ") +
            e.errorMessage());
        // this should not normally happen, but only if our table creation
        // queries are broken, thus it's a program error and not input error
        assert(false);
    }
}

References assert, SQLite::close(), SQLite::connect(), CQ_BLOCK_SOURCE_FILE, CQ_BUS, CQ_COST_ESTIMATION_DATA, CQ_COST_FUNCTION_PLUGIN, CQ_FORMAT, CQ_FU, CQ_FU_ARCHITECTURE, CQ_FU_DATA_PORT, CQ_FU_EXT_PORT_PARAMETER_DEPENDENCY, CQ_FU_EXTERNAL_PORT, CQ_FU_IMPL_ENTRY_INDEX, CQ_FU_IMPLEMENTATION, CQ_FU_IMPLEMENTATION_PARAMETER, CQ_FU_PORT_MAP, CQ_FU_PORT_MAP_ARCH_INDEX, CQ_FU_SOURCE_FILE, CQ_IO_BINDING, CQ_IO_USAGE, CQ_OPCODE_MAP, CQ_OPERATION, CQ_OPERATION_PIPELINE, CQ_PIPELINE_RESOURCE, CQ_PIPELINE_RESOURCE_USAGE, CQ_RF, CQ_RF_ARCHITECTURE, CQ_RF_DATA_PORT, CQ_RF_EXT_PORT_PARAMETER_DEPENDENCY, CQ_RF_EXTERNAL_PORT, CQ_RF_IMPL_ENTRY_INDEX, CQ_RF_IMPLEMENTATION, CQ_RF_IMPLEMENTATION_PARAMETER, CQ_RF_SOURCE_FILE, CQ_SOCKET, RelationalDBConnection::DDLQuery(), debugLog, Exception::errorMessage(), FileSystem::fileIsCreatable(), and insertFileFormats().

Referenced by HDB::CachedHDBManager::createNew(), and main().

Here is the call graph for this function:

◆ deleteCostEstimationDataIDsQueries()

virtual void HDB::HDBManager::deleteCostEstimationDataIDsQueries ( ) const

pure virtual

Implemented in HDB::CachedHDBManager.

Referenced by CostDatabase::buildFunctionUnits(), and CostDatabase::buildRegisterFiles().

◆ directionString()

std::string HDB::HDBManager::directionString ( HDB::Direction direction )

staticprivate

Returns the string used to represent the given direction in HDB.

Parameters

direction The direction.

Returns: The string.

Definition at line 5747 of file HDBManager.cc.

                                                  {
    if (direction == HDB::IN) {
        return IN_DIRECTION;
    } else if (direction == HDB::OUT) {
        return OUT_DIRECTION;
    } else {
        return BIDIR_DIRECTION;
    }
}

References BIDIR_DIRECTION, HDB::IN, IN_DIRECTION, HDB::OUT, and OUT_DIRECTION.

Referenced by addFUImplementation(), and addRFImplementation().

◆ fileFormat()

BlockImplementationFile::Format HDB::HDBManager::fileFormat ( const std::string & formatString )

staticprivate

Returns the format corresponding to the given string which is stored in the database.

Parameters

formatString The format string stored in the database.

Returns: The format.

Definition at line 5700 of file HDBManager.cc.

                                                    {
    if (formatString == VHDL_FORMAT) {
        return BlockImplementationFile::VHDL;
    } else if (formatString == VERILOG_FORMAT) {
         return BlockImplementationFile::Verilog;
    } else if (formatString == VHDL_SIM_FORMAT) {
         return BlockImplementationFile::VHDLsim;
    } else if (formatString == VERILOG_SIM_FORMAT) {
         return BlockImplementationFile::Verilogsim;
    }
    assert(false);
    // dummy return to avoid whining with some compilers
    return BlockImplementationFile::VHDL;
}

References assert, formatString(), HDB::BlockImplementationFile::Verilog, VERILOG_FORMAT, VERILOG_SIM_FORMAT, HDB::BlockImplementationFile::Verilogsim, HDB::BlockImplementationFile::VHDL, VHDL_FORMAT, VHDL_SIM_FORMAT, and HDB::BlockImplementationFile::VHDLsim.

Referenced by addBlockImplementationFiles(), addBlockImplementationFiles(), and addOperationImplementationResource().

Here is the call graph for this function:

◆ fileName()

std::string HDB::HDBManager::fileName ( ) const

Returns the file name of the HDB managed by this HDBManager.

Returns: Absolute path to the HDB file.

Definition at line 598 of file HDBManager.cc.

                           {
    return FileSystem::absolutePathOf(hdbFile_);
}

References FileSystem::absolutePathOf(), and hdbFile_.

Referenced by HDB::HDBRegistry::addHDB(), ComponentImplementationSelector::addHDB(), DefaultICDecoderEstimator::delayOfBus(), DefaultICDecoderEstimator::delayOfSocket(), DefaultICDecoderEstimator::estimateICArea(), AutoSelectImplementationsDialog::findFUImplementations(), AutoSelectImplementationsDialog::findIUImplementations(), AutoSelectImplementationsDialog::findRFImplementations(), ComponentImplementationSelector::fuImplementations(), ComponentImplementationSelector::iuImplementations(), AddFUFromHDBDialog::loadHDB(), AddRFFromHDBDialog::loadHDB(), BlockImplementationFileDialog::onBrowse(), BlockImplementationFileDialog::onOK(), ComponentImplementationSelector::rfImplementations(), OperationImplementationDialog::sanitize(), OperationImplementationResourceDialog::sanitize(), and HDB::CachedHDBManager::validateCache().

Here is the call graph for this function:

◆ formatString()

std::string HDB::HDBManager::formatString ( BlockImplementationFile::Format format )

static

Returns the string used to represent the given file format in HDB.

Parameters

format The format.

Returns: The string.

Definition at line 5723 of file HDBManager.cc.

                                                             {
    if (format == BlockImplementationFile::VHDL) {
        return VHDL_FORMAT;
    } else if (format == BlockImplementationFile::Verilog) {
       return VERILOG_FORMAT;
    } else if (format == BlockImplementationFile::VHDLsim) {
       return VHDL_SIM_FORMAT;
    } else if (format == BlockImplementationFile::Verilogsim) {
       return VERILOG_SIM_FORMAT;
    }
 
    // dummy return to avoid compiler whining
    assert(false);
    return "";
}

References assert, HDB::BlockImplementationFile::Verilog, VERILOG_FORMAT, VERILOG_SIM_FORMAT, HDB::BlockImplementationFile::Verilogsim, HDB::BlockImplementationFile::VHDL, VHDL_FORMAT, VHDL_SIM_FORMAT, and HDB::BlockImplementationFile::VHDLsim.

Referenced by addBlockImplementationFileToHDB(), fileFormat(), OperationImplementationResourceDialog::onAddVerilogSimFile(), OperationImplementationResourceDialog::onAddVerilogSynFile(), OperationImplementationResourceDialog::onAddVhdlSimFile(), OperationImplementationResourceDialog::onAddVhdlSynFile(), and OperationImplementationResourceDialog::onOK().

◆ fuArchitectureByID()

FUArchitecture * HDB::HDBManager::fuArchitectureByID ( RowID id ) const

virtual

Creates an FUArchitecture instance of the FU architecture that has the given ID.

Parameters

ID	The ID of the FU architecture.

Returns: The newly created FUArchitecture instance.

Exceptions

KeyNotFound If the HDB does not have a FU architecture with the given ID.

Reimplemented in HDB::CachedHDBManager.

Definition at line 2926 of file HDBManager.cc.

                                             {
    if (!containsFUArchitecture(id)) {
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
 
    FunctionUnit* fu = new FunctionUnit("name");
    FUArchitecture* architecture = new FUArchitecture(fu);
    architecture->setID(id);
    addPortsAndBindingsToFUArchitecture(*architecture, id);
    addOperationPipelinesToFUArchitecture(*architecture, id);
    return architecture;
}

References __func__, addOperationPipelinesToFUArchitecture(), addPortsAndBindingsToFUArchitecture(), containsFUArchitecture(), and HWBlockArchitecture::setID().

Referenced by HDB::CachedHDBManager::fuArchitectureByID(), HDB::CachedHDBManager::fuArchitectureByIDConst(), HDBToHtml::fuArchToHtml(), fuByEntryID(), fuEntriesByArchitecture(), and AddFUFromHDBDialog::loadHDB().

Here is the call graph for this function:

◆ fuArchitectureByIDQuery()

std::string HDB::HDBManager::fuArchitectureByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the architecture of the FU entry that has the given ID.

The result set has all the fields of fu_architecture.

Parameters

id	ID of the FU entry.

Definition at line 5843 of file HDBManager.cc.

                                            {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM fu, fu_architecture "
        "WHERE fu.id=" + idString + " AND"
        "      fu_architecture.id = fu.architecture;";
    return query;
}

References Conversion::toString().

Here is the call graph for this function:

◆ fuArchitectureID()

RowID HDB::HDBManager::fuArchitectureID ( RowID fuEntryID ) const

private

Returns the ID of the architecture of the given FU entry.

Parameters

fuEntryID ID of the FU entry.

Returns: ID of the FU architecture.

Exceptions

NotAvailable If the FU entry does not have an architecture.

Definition at line 4254 of file HDBManager.cc.

                                                  {
    RelationalDBQueryResult* result;
    try {
        result = dbConnection_->query(
            std::string(
                "SELECT architecture FROM fu WHERE id=" +
                Conversion::toString(fuEntryID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (!result->hasNext()) {
        delete result;
        throw NotAvailable(__FILE__, __LINE__, __func__);
    }
 
    result->next();
    const DataObject& idData = result->data(0);
    if (idData.isNull()) {
        delete result;
        throw NotAvailable(__FILE__, __LINE__, __func__);
    } else {
        RowID retValue = idData.integerValue();
        delete result;
        return retValue;
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by addFUImplementation().

Here is the call graph for this function:

◆ fuArchitectureIDs()

std::set< RowID > HDB::HDBManager::fuArchitectureIDs ( ) const

Returns a set of FU architecture IDs in the database.

Returns: A set containing all the FU architecture IDs in the database.

Definition at line 2149 of file HDBManager.cc.

                                    {
 
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            std::string("SELECT id FROM fu_architecture;"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    std::set<RowID> idSet;
    while (result->hasNext()) {
        result->next();
        const DataObject& idData = result->data(0);
        idSet.insert(idData.integerValue());
    }
 
    delete result;
    return idSet;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by SetFUArchitectureCmd::Do(), AddFUFromHDBDialog::loadHDB(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ fuArchitectureIDsByOperationSet()

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

Definition at line 2670 of file HDBManager.cc.

                                                   {
 
    RelationalDBQueryResult* result = NULL;
    try {
        std::string operationQuery = "(";
        std::set<string>::const_iterator iter = operationNames.begin();
        while (iter != operationNames.end()) {
            // LIKE makes case-insensitive match to operation names
            operationQuery +=
                "operation.name LIKE '" + *iter + "'";
            iter++;
            if (iter != operationNames.end()) {
                operationQuery += " OR ";
            }
        }
        operationQuery += ")";
        if (operationQuery == "()") {
            return std::set<RowID>();
        }
        result = dbConnection_->query(
            std::string("SELECT fu_architecture.id FROM operation_pipeline,"
                        "operation, fu_architecture WHERE "
                        "operation.id=operation_pipeline.operation AND "
                        "operation_pipeline.fu_arch=fu_architecture.id AND "
                        + operationQuery +
                        "GROUP BY fu_architecture.id ORDER BY "
                        "fu_architecture.id;"));
    } catch (const Exception& e) {
        std::string eMsg = ", HDB file where error occurred was: " + hdbFile_;
        debugLog(e.errorMessage() + eMsg);
        assert(false);
    }
 
    std::set<RowID> idSet;
    while (result->hasNext()) {
        result->next();
        const DataObject& idData = result->data(0);
        idSet.insert(idData.integerValue());
    }
 
    delete result;
    return idSet;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), hdbFile_, DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by ComponentImplementationSelector::fuArchsByOpSetWithMinLatency().

Here is the call graph for this function:

◆ fuByEntryID()

FUEntry * HDB::HDBManager::fuByEntryID ( RowID id ) const

Returns the FU entry that has the given ID.

Parameters

id	The ID of the FU entry.

Returns: The FU entry. @excpetion KeyNotFound If the HDB does not contain an FU entry with the given ID.

Definition at line 2814 of file HDBManager.cc.

                                      {
    std::string query = "SELECT architecture FROM fu WHERE id=";
    query += Conversion::toString(id) + ";";
 
    RelationalDBQueryResult* result = NULL;
    try {
        result =  dbConnection_->query(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    bool hasArch = false;
    RowID archID = -1;
    if (result->hasNext()) {        
        result->next();
        DataObject data = result->data(0);
        if (!data.isNull()) {
            hasArch = true;
            archID = data.integerValue();
        }
        delete result;
        result = NULL;
    } else {
        delete result;
        std::ostringstream stream;
        stream << "FU entry with id " << id << " not found from hdb "
               << hdbFile_;
        throw KeyNotFound(__FILE__, __LINE__, __func__, stream.str());
    }
 
    FUEntry* entry = new FUEntry();
    entry->setID(id);
    if (hasArch) {
        FUArchitecture* architecture = fuArchitectureByID(archID);
        entry->setArchitecture(architecture);
        FUImplementation* implementation = createImplementationOfFU(
            *architecture, id);
        entry->setImplementation(implementation);
    }
 
    CostFunctionPlugin* costFunction = createCostFunctionOfFU(id);
    entry->setCostFunction(costFunction);
    entry->setHDBFile(hdbFile_);
    delete result;
    return entry;
}

References __func__, assert, createCostFunctionOfFU(), createImplementationOfFU(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), fuArchitectureByID(), RelationalDBQueryResult::hasNext(), hdbFile_, implementation, DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), HDB::FUEntry::setArchitecture(), HDB::HDBEntry::setCostFunction(), HDB::HDBEntry::setHDBFile(), HDB::HDBEntry::setID(), HDB::FUEntry::setImplementation(), and Conversion::toString().

Referenced by addFUImplementation(), ProGe::NetlistGenerator::addFUToNetlist(), CostDatabase::buildFunctionUnits(), ProGeTools::checkForSelectableFU(), Automagic::checkForSelectableFU(), ProGe::BlockSourceCopier::copyShared(), AddFUImplementationCmd::Do(), HDBEditorModifyCmd::Do(), CostEstimator::Estimator::fuCostFunctionPluginOfImplementation(), ImplementationTester::fuEntryFromHdb(), HDBToHtml::fuEntryToHtml(), HDBToHtml::fuImplToHtml(), ProGeTestBenchGenerator::generate(), ProGeScriptGenerator::getBlockOrder(), AddFUImplementationCmd::isEnabled(), PlatformIntegrator::loadFUExternalPorts(), BlockImplementationDialog::onHDBSelection(), setArchitectureForFU(), unsetArchitectureForFU(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ fuCostEstimationData()

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

Returns FU cost estimation data.

This version assumes that there's only one entry with given parameters.

Todo:

Another version for fetching lists of data.

Refactor most of the code in *costEstimationData() functions to a helper function

Parameters

valueName	Name of the value to fetch.
implementationId	The ID of the FU entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data.

Exceptions

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

Definition at line 3275 of file HDBManager.cc.

                                       {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND bus_reference IS NULL " +
            " AND socket_reference IS NULL AND " +
            "     fu_reference = " + Conversion::toString(implementationId) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');");
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

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

Here is the call graph for this function:

◆ fuCostEstimationDataIDs()

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

Returns a set of cost estimation data IDs which reference the give FU implementation.

Parameters

fuImplID ID of the FU implementation.

Returns: Set of cost estimation data IDs.

Definition at line 6377 of file HDBManager.cc.

                                                        {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT id "
                "FROM cost_estimation_data "
                "WHERE fu_reference = ") +
            Conversion::toString(fuImplID);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBToHtml::fuEntryToHtml(), and HDBToHtml::fuImplToHtml().

Here is the call graph for this function:

◆ fuEntriesByArchitecture()

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

Returns a set of FU entry IDs that have a corresponding architecture with the given one.

The set may contain FU entry IDs that have ports with parametrized width while the given one has fixed width.

Parameters

fu	The FU architecture.

Returns: Set of FU entry IDs.

Definition at line 3026 of file HDBManager.cc.

                                            {
 
    std::set<RowID> architectureIDs;
    std::set<RowID> entryIDs;
 
    try {
        // get FU architectures with required operation set
        string query = "";
        for (int i = 0; i < fu.operationCount(); i++) {
            query += 
                "SELECT fu_arch FROM operation_pipeline,operation "
                "WHERE operation.name=\"" + fu.operation(i)->name() +
                "\" AND operation_pipeline.operation=operation.id";
            if (i+1 < fu.operationCount()) {
                query += " INTERSECT ";
            } else {
                query += ";";
            }
        }
            
        RelationalDBQueryResult* queryResult = dbConnection_->query(query);
 
        // check the architectures are compeletely similar
        while (queryResult->hasNext()) {
            queryResult->next();
            const DataObject& archID = queryResult->data(0);
            FUArchitecture* arch = fuArchitectureByID(archID.integerValue());
            if (isMatchingArchitecture(fu, *arch)) {
                architectureIDs.insert(arch->id());
            }
            delete arch;
        }
 
        delete queryResult;
 
        if (!architectureIDs.empty()) {
            // find the FU entry IDs
            string fuEntryQuery = "SELECT id FROM fu WHERE ";
            for (std::set<RowID>::const_iterator iter = 
                     architectureIDs.begin();
                 iter != architectureIDs.end(); iter++) {
                fuEntryQuery += "architecture=" + 
                    Conversion::toString(*iter);
                std::set<RowID>::const_iterator nextIter = iter;
                nextIter++;
                if (nextIter == architectureIDs.end()) {
                    fuEntryQuery += ";";
                } else {
                    fuEntryQuery += " OR ";
                }
            }
 
            RelationalDBQueryResult* fuEntryResult = dbConnection_->query(
                fuEntryQuery);
            while (fuEntryResult->hasNext()) {
                fuEntryResult->next();
                const DataObject& idData = fuEntryResult->data(0);
                entryIDs.insert(idData.integerValue());
            }
 
            delete fuEntryResult;
        }
 
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        ;
    }
 
    return entryIDs;
}

References RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), fuArchitectureByID(), RelationalDBQueryResult::hasNext(), HWBlockArchitecture::id(), DataObject::integerValue(), isMatchingArchitecture(), TTAMachine::HWOperation::name(), RelationalDBQueryResult::next(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by ComponentImplementationSelector::fuImplementations(), and BlockImplementationDialog::onHDBSelection().

Here is the call graph for this function:

◆ fuEntryByIDQuery()

std::string HDB::HDBManager::fuEntryByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the FU entry that has the given ID.

The result set has fields {id, architecture, cost_function}.

Parameters

id	ID of the entry.

Returns: The SQL query.

Definition at line 5767 of file HDBManager.cc.

                                     {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM fu "
        "WHERE fu.id=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by hasFUEntry().

Here is the call graph for this function:

◆ fuEntryHasArchitecture()

bool HDB::HDBManager::fuEntryHasArchitecture ( RowID id ) const

private

Tells whether the FU entry that has the given ID has an architecture.

Parameters

id	ID of the FU entry.

Returns: True if it has an architecture, otherwise false.

Exceptions

KeyNotFound If the HDB does not contain a FU entry with the given ID.

Definition at line 4083 of file HDBManager.cc.

                                                 {
    RelationalDBQueryResult* result;
    try {
        result = dbConnection_->query(
            std::string(
                "SELECT architecture FROM fu WHERE id=" + 
                Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        const DataObject& data = result->data(0);
        delete result;
        return !data.isNull();
    } else {
        delete result;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ fuEntryIDOfImplementation()

RowID HDB::HDBManager::fuEntryIDOfImplementation ( RowID implID ) const

Returns the ID of the FU entry that has the given implementation ID.

Parameters

implID The implementation ID.

Returns: The FU entry ID.

Exceptions

KeyNotFound If there is no implementation by the given ID.

Definition at line 2751 of file HDBManager.cc.

                                                        {
    RelationalDBQueryResult* result = NULL;
    try {
        result =  dbConnection_->query(
            std::string(
                "SELECT fu from fu_implementation WHERE id=" + 
                Conversion::toString(implID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        RowID id = result->data(0).integerValue();
        delete result;
        return id;
    } else {
        delete result;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBEditorDeleteCmd::Do(), HDBEditorModifyCmd::Do(), HDBToHtml::fuImplToHtml(), and HDB::CachedHDBManager::removeFUImplementation().

Here is the call graph for this function:

◆ fuEntryIDs()

std::set< RowID > HDB::HDBManager::fuEntryIDs ( ) const

Returns a set of FU entry IDs in the database.

Returns: A set containing all the FU entry IDs in the database.

Definition at line 2021 of file HDBManager.cc.

                             {
 
    string query = "SELECT id AS 'fu.id' FROM fu;";
 
    // make the SQL query to obtain all the IDs
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(query);
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    std::set<RowID> idSet;
    while (queryResult->hasNext()) {
        queryResult->next();
        const DataObject& idData = queryResult->data("fu.id");
        idSet.insert(idData.integerValue());
    }
 
    delete queryResult;
    return idSet;
}     

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by CostDatabase::buildFunctionUnits(), ProGeTools::checkForSelectableFU(), Automagic::checkForSelectableFU(), ImplementationTester::fuEntryIDs(), CostEstimationDataDialog::onEntryTypeSelection(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ fuExternalPortsByIDQuery()

std::string HDB::HDBManager::fuExternalPortsByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting external port data of implementation of the FU that has the given ID.

The result table has fields {fu_external_port.name, fu_external_port.direction, fu_external_port.width_formula, fu_external_port.description}.

Parameters

id	ID of the FU entry in HDB.

Returns: The SQL query.

Definition at line 6029 of file HDBManager.cc.

                                             {
    string idString = Conversion::toString(id);
    string query =
        "SELECT fu_external_port.name AS 'fu_external_port.name',"
        "       fu_external_port.direction AS 'fu_external_port.direction',"
        "       fu_external_port.width_formula AS "
        "           'fu_external_port.width_formula',"
        "       fu_external_port.description AS "
        "           'fu_external_port.description' "
        "FROM fu, fu_implementation, fu_external_port "
        "WHERE fu.id=" + idString + " AND"
        "      fu_implementation.fu=fu.id AND"
        "      fu_external_port.fu_impl=fu_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addFUExternalPortsToImplementation().

Here is the call graph for this function:

◆ fuImplementationByIDQuery()

std::string HDB::HDBManager::fuImplementationByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting FU implementation data of the FU that has the given ID.

The result table has fields {fu_implementation.id, fu_implementation.name, fu_implementation.opcode_port, fu_implementation.clk_port, fu_implementation.rst_port, fu_implementation.glock_port, fu_implementation.glock_req_port}.

Parameters

id	ID of the FU entry in HDB.

Definition at line 5948 of file HDBManager.cc.

                                              {
    string idString = Conversion::toString(id);
    string query =
        "SELECT fu_implementation.id AS 'fu_implementation.id',"
        "       fu_implementation.name AS 'fu_implementation.name',"
        "       fu_implementation.opcode_port AS "
        "'fu_implementation.opcode_port',"
        "       fu_implementation.clk_port AS 'fu_implementation.clk_port',"
        "       fu_implementation.rst_port AS 'fu_implementation.rst_port',"
        "       fu_implementation.glock_port AS "
        "           'fu_implementation.glock_port',"
        "       fu_implementation.glock_req_port AS "
        "           'fu_implementation.glock_req_port' "
        "FROM fu, fu_implementation "
        "WHERE fu.id=" + idString + " AND"
        "      fu_implementation.fu=fu.id;";
    return query;
}

References Conversion::toString().

Referenced by createImplementationOfFU().

Here is the call graph for this function:

◆ fuImplementationDataPortsByIDQuery()

std::string HDB::HDBManager::fuImplementationDataPortsByIDQuery ( RowID id )

staticprivate

Creates an SQL qury for getting data port data of implementation of the FU that has the given ID.

The result table has fields {fu_port_map.name, fu_port_map.width_formula, fu_port_map.load_port, fu_port_map.guard_port}

Parameters

id	ID of the FU entry in HDB.

Definition at line 6002 of file HDBManager.cc.

                                                       {
    string idString = Conversion::toString(id);
    string query =
        "SELECT fu_port_map.name AS 'fu_port_map.name',"
        "       fu_port_map.width_formula AS 'fu_port_map.width_formula',"
        "       fu_port_map.load_port AS 'fu_port_map.load_port',"
        "       fu_port_map.guard_port AS 'fu_port_map.guard_port' "
        "FROM fu, fu_port_map, fu_implementation "
        "WHERE fu.id=" + idString + " AND"
        "      fu_implementation.fu=fu.id AND"
        "      fu_port_map.fu_impl=fu_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addDataPortsToImplementation().

Here is the call graph for this function:

◆ fuImplementationParametersByIDQuery()

std::string HDB::HDBManager::fuImplementationParametersByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the parameters of the implementation of the FU that has the given ID.

The result table has fields {name, type, value}.

Parameters

id	ID of the FU implementation entry.

Returns: The SQL query.

Definition at line 6085 of file HDBManager.cc.

                                                        {
    string idString = Conversion::toString(id);
    string query =
        "SELECT fu_implementation_parameter.name AS 'name',"
        "       fu_implementation_parameter.type AS 'type',"
        "       fu_implementation_parameter.value AS 'value' "
        "FROM fu_implementation, fu_implementation_parameter "
        "WHERE fu_implementation.fu=" + idString + " AND"
        "      fu_implementation_parameter.fu_impl=fu_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addFUParametersToImplementation().

Here is the call graph for this function:

◆ fuPortBindingByNameQuery()

std::string HDB::HDBManager::fuPortBindingByNameQuery	(	RowID	fuID,
		const std::string &	portName
	)

staticprivate

Creates an SQL query for getting io binding data of port that has the given name.

The result table has fields {operation.name, io_binding.io_number}.

Parameters

fuID	ID of the FU entry.
portName	Name of the implemented port.

Returns: The SQL query.

Definition at line 6132 of file HDBManager.cc.

                               {
 
    string idString = Conversion::toString(fuID);
    string query =
        "SELECT operation.name AS 'operation.name',"
        "       io_binding.io_number AS 'io_binding.io_number' "
        "FROM operation, io_binding, fu_port_map, fu_implementation "
        "WHERE fu_implementation.fu=" + idString + " AND"
        "      fu_port_map.fu_impl=fu_implementation.id AND"
        "      fu_port_map.name='" + portName + "' AND"
        "      io_binding.port=fu_port_map.arch_port AND"
        "      operation.id=io_binding.operation;";
    return query;
}

References Conversion::toString().

Referenced by resolveArchitecturePort().

Here is the call graph for this function:

◆ fuPortsAndBindingsByIDQuery()

std::string HDB::HDBManager::fuPortsAndBindingsByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the architectural ports and their operand bindings of the FU architecture that has the given ID.

The result table has fields {fu_data_port.id, fu_data_port.triggers, fu_data_port.sets-opcode, fu_data_port.guard_support, fu_data_port.width, operation.name, io_binding.io_number}

Parameters

id	The ID of the FU architecture.

Definition at line 5866 of file HDBManager.cc.

                                                {
    string idString = Conversion::toString(id);
    string query = 
        "SELECT fu_data_port.id AS 'fu_data_port.id',"
        "       fu_data_port.triggers AS 'fu_data_port.triggers',"
        "       fu_data_port.sets_opcode AS 'fu_data_port.sets_opcode',"
        "       fu_data_port.guard_support AS 'fu_data_port.guard_support',"
        "       fu_data_port.width AS 'fu_data_port.width',"
        "       operation.name AS 'operation.name',"
        "       io_binding.io_number AS 'io_binding.io_number' "
        "FROM fu_data_port, io_binding, operation "
        "WHERE fu_data_port.fu_arch=" + idString + " AND"
        "      io_binding.port=fu_data_port.id AND"
        "      io_binding.operation=operation.id;";
    return query;
}

References Conversion::toString().

Referenced by addPortsAndBindingsToFUArchitecture().

Here is the call graph for this function:

◆ fuSourceFilesByIDQuery()

std::string HDB::HDBManager::fuSourceFilesByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the block source files of the FU entry that has the given ID.

The result table has fields {block_source_file.file, format.format}.

Parameters

id	ID of the FU entry.

Returns: The SQL query.

Definition at line 6160 of file HDBManager.cc.

                                           {
    string idString = Conversion::toString(id);
    string query =
        "SELECT block_source_file.file AS 'block_source_file.file',"
        "       format.format AS 'format.format' "
        "FROM block_source_file, fu_source_file, fu_implementation, format "
        "WHERE fu_implementation.fu=" + idString + " AND"
        "      fu_source_file.fu_impl=fu_implementation.id AND"
        "      block_source_file.id=fu_source_file.file AND"
        "      format.id=block_source_file.format;";
    return query;
}

References Conversion::toString().

Referenced by addBlockImplementationFiles().

Here is the call graph for this function:

◆ getDBConnection()

RelationalDBConnection * HDB::HDBManager::getDBConnection ( ) const

protected

Returns used database connection.

Definition at line 6973 of file HDBManager.cc.

                                  {
    return dbConnection_;
}

References dbConnection_.

Referenced by HDB::CachedHDBManager::costEstimationDataIDs().

◆ hasBusEntry()

bool HDB::HDBManager::hasBusEntry ( RowID id ) const

private

Tells whether the HDB has an Bus entry that has the given ID.

Returns: True if the HDB has the entry, otherwise false.

Definition at line 3966 of file HDBManager.cc.

                                      {
 
    RelationalDBQueryResult* result;
 
    try {
        result = dbConnection_->query(busEntryByIDQuery(id));
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, busEntryByIDQuery(), dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by addCostEstimationData(), modifyCostEstimationData(), and removeBusEntry().

Here is the call graph for this function:

◆ hasColumn()

bool HDB::HDBManager::hasColumn	(	const std::string &	table,
		const std::string &	columnName
	)		const

private

Returns true if a table by name has a column by given name.

Parameters

table	The table by name to search the column from.
columnName	The name of the column to be searched.

Returns: True if the table has the named column.

Definition at line 4328 of file HDBManager.cc.

                                                               {
 
    std::string table_info_query("PRAGMA table_info(");
    table_info_query += table;
    table_info_query += ");";
 
    RelationalDBQueryResult* result;
    try {
        result = dbConnection_->query(table_info_query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    while(result->hasNext()) {
        result->next();
        // Second column in result row is column name of the table.
        const DataObject& columnData = result->data(1);
        std::string columnNameFromTable = columnData.stringValue();
 
        assert(!columnNameFromTable.empty());
        if(columnNameFromTable == columnName) {
            return true;
        }
    }
 
    return false;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by addRFImplementation(), createImplementationOfRF(), and HDBManager().

Here is the call graph for this function:

◆ hasCostEstimationDataByID()

bool HDB::HDBManager::hasCostEstimationDataByID ( RowID id ) const

private

Tells whether the HDB has cost estimation data that has the given ID.

Returns: True if the HDB has the data, otherwise false.

Definition at line 4021 of file HDBManager.cc.

                                                    {
 
    RelationalDBQueryResult* result;
    std::string query = "SELECT id FROM cost_estimation_data WHERE id=";
    query += Conversion::toString(id) + ";";
 
    try {
        result = dbConnection_->query(query);
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by modifyCostEstimationData().

Here is the call graph for this function:

◆ hasCostFunctionPluginByID()

bool HDB::HDBManager::hasCostFunctionPluginByID ( RowID id ) const

private

Tells whether the HDB has cost function plugin that has the given ID.

Returns: True if the HDB has the plugin, otherwise false.

Definition at line 4050 of file HDBManager.cc.

                                                    {
 
    RelationalDBQueryResult* result;
    std::string query = "SELECT id FROM cost_function_plugin WHERE id=";
    query += Conversion::toString(id) + ";";
 
    try {
        result = dbConnection_->query(query);
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by modifyCostFunctionPlugin().

Here is the call graph for this function:

◆ hasFUEntry()

bool HDB::HDBManager::hasFUEntry ( RowID id ) const

private

Tells whether the HDB has an FU entry that has the given ID.

Returns: True if the HDB has the entry, otherwise false.

Definition at line 3910 of file HDBManager.cc.

                                     {
 
    RelationalDBQueryResult* result;
 
    try {
        result = dbConnection_->query(fuEntryByIDQuery(id));
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, dbConnection_, fuEntryByIDQuery(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by addCostEstimationData(), addFUImplementation(), modifyCostEstimationData(), removeFUEntry(), setArchitectureForFU(), and unsetArchitectureForFU().

Here is the call graph for this function:

◆ hasRFEntry()

bool HDB::HDBManager::hasRFEntry ( RowID id ) const

private

Tells whether the HDB has an RF entry that has the given ID.

Returns: True if the HDB has the entry, otherwise false.

Definition at line 3938 of file HDBManager.cc.

                                     {
 
    RelationalDBQueryResult* result;
 
    try {
        result = dbConnection_->query(rfEntryByIDQuery(id));
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and rfEntryByIDQuery().

Referenced by addCostEstimationData(), addRFImplementation(), modifyCostEstimationData(), removeRFEntry(), and setArchitectureForRF().

Here is the call graph for this function:

◆ hasSocketEntry()

bool HDB::HDBManager::hasSocketEntry ( RowID id ) const

private

Tells whether the HDB has an Socket entry that has the given ID.

Returns: True if the HDB has the entry, otherwise false.

Definition at line 3994 of file HDBManager.cc.

                                         {
 
    RelationalDBQueryResult* result;
 
    try {
        result = dbConnection_->query(socketEntryByIDQuery(id));
    } catch (const Exception&) {
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        assert(!result->hasNext());
        delete result;
        return true;
    } else {
        delete result;
        return false;
    }
}

References assert, dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and socketEntryByIDQuery().

Referenced by addCostEstimationData(), modifyCostEstimationData(), and removeSocketEntry().

Here is the call graph for this function:

◆ insertFileFormats()

void HDB::HDBManager::insertFileFormats ( RelationalDBConnection & connection )

staticprivate

Inserts the supported formats to the format table.

Parameters

connection The connection used when inserting the formats.

Definition at line 5675 of file HDBManager.cc.

                                                                {
    try {
        connection.updateQuery(
            std::string(
                "INSERT INTO format(id,format) VALUES(1,\"" +
                VHDL_FORMAT + "\");"));
        connection.updateQuery(
            std::string(
                "INSERT INTO format(id,format) VALUES(2,\"" +
                VERILOG_FORMAT + "\");"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, debugLog, Exception::errorMessage(), RelationalDBConnection::updateQuery(), VERILOG_FORMAT, and VHDL_FORMAT.

Referenced by createNew().

Here is the call graph for this function:

◆ ioUsageDataByIDQuery()

std::string HDB::HDBManager::ioUsageDataByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the IO usage data of pipelines of operations contained in the FU architecture that has the given ID.

The result table has fields {operation.name, io_usage.cycle, io_usage.io_number, io_usage.action}.

Parameters

id	ID of the FU architecture in HDB.

Definition at line 5894 of file HDBManager.cc.

                                         {
    string idString = Conversion::toString(id);
    string query =
        "SELECT operation.name AS 'operation.name',"
        "       io_usage.cycle AS 'io_usage.cycle',"
        "       io_usage.io_number AS 'io_usage.io_number',"
        "       io_usage.action AS 'io_usage.action' "
        "FROM operation_pipeline, io_usage, operation "
        "WHERE operation_pipeline.fu_arch=" + idString + " AND"
        "      io_usage.pipeline=operation_pipeline.id AND"
        "      operation.id=operation_pipeline.operation;";
    return query;
}

References Conversion::toString().

Referenced by addOperationPipelinesToFUArchitecture().

Here is the call graph for this function:

◆ isMatchingArchitecture()

bool HDB::HDBManager::isMatchingArchitecture	(	const TTAMachine::FunctionUnit &	fu,
		const FUArchitecture &	arch
	)

staticprivate

Checks whether the given FU has a mathing architecture with the given FU architecture instance.

Parameters

fu	The function unit.
arch	The FU architecture.

Returns: True if the architectures match, otherwise false.

Definition at line 5505 of file HDBManager.cc.

                                {
 
    if (fu.operationCount() != arch.architecture().operationCount()) {
        return false;
    }
 
    std::map<const FUPort*, const FUPort*> portMap;
    for (int i = 0; i < fu.operationPortCount(); i++) {
        portMap.insert(
            std::pair<const FUPort*, const FUPort*>(
                fu.operationPort(i), NULL));
    }
    
    PipelineElementUsageTable plineElementUsages;
 
    for (int i = 0; i < fu.operationCount(); i++) {
        HWOperation* operation = fu.operation(i);
        if (!arch.architecture().hasOperation(operation->name())) {
            return false;
        }
        HWOperation* archOp = arch.architecture().operation(
            operation->name());
        if (operation->latency() != archOp->latency()) {
            return false;
        }
 
        // check operand bindings
        for (int i = 0; i < fu.operationPortCount(); i++) {
            FUPort* port = fu.operationPort(i);
            if (operation->isBound(*port)) {
                int io = operation->io(*port);
                FUPort* samePort = archOp->port(io);
                if (samePort == NULL) {
                    return false;
                }
                const FUPort* existingSamePort =
                    MapTools::valueForKey<const FUPort*>(portMap, port);
                if (existingSamePort != NULL &&
                    existingSamePort != samePort) {
                    return false;
                }
                
                // check the width of the ports
                if (!arch.hasParameterizedWidth(samePort->name()) && 
                    samePort->width() != port->width()) {
                    return false;
                }
 
                if (port->isOpcodeSetting() != samePort->isOpcodeSetting() ||
                    port->isTriggering() != samePort->isTriggering()) {
                    return false;
                }
                portMap.erase(port);
                portMap.insert(
                    std::pair<const FUPort*, const FUPort*>(port, samePort));
            }
        }
 
        // check operation pipeline
        ExecutionPipeline* opPipeline =  operation->pipeline();
        ExecutionPipeline* archOpPipeline = archOp->pipeline();
        for (int cycle = 0; cycle < operation->latency(); cycle++) {
            ExecutionPipeline::OperandSet written1 = 
                opPipeline->writtenOperands(cycle);
            ExecutionPipeline::OperandSet written2 = 
                archOpPipeline->writtenOperands(cycle);
            if (written1 != written2) {
                return false;
            }
            ExecutionPipeline::OperandSet read1 = 
                opPipeline->readOperands(cycle);
            ExecutionPipeline::OperandSet read2 = 
                archOpPipeline->readOperands(cycle);
            if (read1 != read2) {
                return false;
            }
 
            PipelineElementUsage usage;
            for (int i = 0; i < fu.pipelineElementCount(); i++) {
                const PipelineElement* elem = fu.pipelineElement(i);
                if (opPipeline->isResourceUsed(elem->name(),cycle)) {
                    usage.usage1.insert(elem);
                }
            }
 
            for (int i = 0; i < arch.architecture().pipelineElementCount();
                 i++) {
                const PipelineElement* elem =
                    arch.architecture().pipelineElement(i);
                if (archOpPipeline->isResourceUsed(elem->name(), cycle)) {
                    usage.usage2.insert(elem);
                }
            }
 
            plineElementUsages.push_back(usage);
        }
    }
 
    return areCompatiblePipelines(plineElementUsages);
}

References HDB::FUArchitecture::architecture(), areCompatiblePipelines(), TTAMachine::FunctionUnit::hasOperation(), HDB::FUArchitecture::hasParameterizedWidth(), TTAMachine::HWOperation::io(), TTAMachine::HWOperation::isBound(), TTAMachine::FUPort::isOpcodeSetting(), TTAMachine::ExecutionPipeline::isResourceUsed(), TTAMachine::FUPort::isTriggering(), MapTools::keyForValue(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), TTAMachine::PipelineElement::name(), TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), TTAMachine::HWOperation::pipeline(), TTAMachine::FunctionUnit::pipelineElement(), TTAMachine::FunctionUnit::pipelineElementCount(), TTAMachine::HWOperation::port(), TTAMachine::ExecutionPipeline::readOperands(), HDB::HDBManager::PipelineElementUsage::usage1, HDB::HDBManager::PipelineElementUsage::usage2, TTAMachine::BaseFUPort::width(), and TTAMachine::ExecutionPipeline::writtenOperands().

Referenced by fuEntriesByArchitecture().

Here is the call graph for this function:

◆ modifyCostEstimationData()

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

virtual

Updates cost estimation data in the HDB.

Parameters

id	Row ID of the data to update.
data	Updated data.

Reimplemented in HDB::CachedHDBManager.

Definition at line 6985 of file HDBManager.cc.

                                                                             {
    if (!data.hasName() || !data.hasValue() || !data.hasPluginID()) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    if (!hasCostEstimationDataByID(id)) {
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
 
    std::string query =
        std::string("UPDATE cost_estimation_data SET ") +
        " name='" + data.name() +
        "', value='" + data.value().stringValue() +
        "', plugin_reference=" + Conversion::toString(data.pluginID());
 
    // FU entry reference.
    if (data.hasFUReference()) {
        if (!hasFUEntry(data.fuReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += ", fu_reference=";
        query += Conversion::toString(data.fuReference());
    } else {
        query += ", fu_reference=NULL";
    }
 
    // RF entry reference.
    if (data.hasRFReference()) {
        if (!hasRFEntry(data.rfReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += ", rf_reference=";
        query += Conversion::toString(data.rfReference());
    } else {
        query += ", rf_reference=NULL";
    }
 
    // Bus entry reference
    if (data.hasBusReference()) {
        if (!hasBusEntry(data.busReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += ", bus_reference=";
        query += Conversion::toString(data.busReference());
    } else {
        query += ", bus_reference=NULL";
    }
 
    // Socket entry reference.
    if (data.hasSocketReference()) {
        if (!hasSocketEntry(data.socketReference())) {
            throw KeyNotFound(__FILE__, __LINE__, __func__);
        }
        query += ", socket_reference=";
        query += Conversion::toString(data.socketReference());
    } else {
        query += ", socket_reference=NULL";
    }
 
    query += " WHERE id=";
    query += Conversion::toString(id);
    query += ";";
 
    try {
        dbConnection_->updateQuery(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

Referenced by HDB::CachedHDBManager::modifyCostEstimationData(), and CostEstimationDataDialog::onOK().

Here is the call graph for this function:

◆ modifyCostFunctionPlugin()

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

virtual

Modifies cost estimation function plugin attributes.

Parameters

id	RowID of the plugin to modify.
plugin	Modified plugin (ID is ignored).

Exceptions

InvalidData	Throws if the given plugin was invalid.
KeyNotFound	Throws if no cost function plugin was found with given RowID.

Reimplemented in HDB::CachedHDBManager.

Definition at line 7066 of file HDBManager.cc.

                                                {
    if (plugin.name() == "") {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
    
    if (!hasCostFunctionPluginByID(id)) {
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
 
    string type = "";
    switch (plugin.type()) {
    case CostFunctionPlugin::COST_FU:
        type = COST_PLUGIN_TYPE_FU;
        break;
    case CostFunctionPlugin::COST_RF:
        type = COST_PLUGIN_TYPE_RF;
        break;
    case CostFunctionPlugin::COST_DECOMP:            
        type = COST_PLUGIN_TYPE_DECOMP;
        break;
    case CostFunctionPlugin::COST_ICDEC:
        type = COST_PLUGIN_TYPE_ICDEC;
        break;
    default:
        InvalidData ex(
            __FILE__, __LINE__, __func__, 
            (boost::format("Illegal cost_function_plugin type %d.") %
             type).str());
        throw ex;
        break;
    }
    
    std::string query =
        std::string("UPDATE cost_function_plugin SET ") +
        " name='" + plugin.name() +
        "', description='" + plugin.description() +
        "', plugin_file_path='" + plugin.pluginFilePath() +
        "', type='" + type + "'";
    
    query += " WHERE id=";
    query += Conversion::toString(id);
    query += ";";
    
    try {
        dbConnection_->updateQuery(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

Referenced by HDB::CachedHDBManager::modifyCostFunctionPlugin(), and CostFunctionPluginDialog::onOK().

Here is the call graph for this function:

◆ opcodesByIDQuery()

std::string HDB::HDBManager::opcodesByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting operation code data of the FU that has the given ID.

The result table has fields {operation.name, opcode_map.opcode}.

Parameters

id	ID of the FU entry in HDB.

Definition at line 5977 of file HDBManager.cc.

                                     {
    string idString = Conversion::toString(id);
    string query =
        "SELECT operation.name AS 'operation.name',"
        "       opcode_map.opcode AS 'opcode_map.opcode' "
        "FROM fu, fu_implementation, operation, opcode_map "
        "WHERE fu.id=" + idString + " AND"
        "      fu_implementation.fu=fu.id AND"
        "      opcode_map.fu_impl=fu_implementation.id AND"
        "      operation.id=opcode_map.operation;";
    return query;
}

References Conversion::toString().

Referenced by addOpcodesToImplementation().

Here is the call graph for this function:

◆ OperationImplementationByID()

HDB::OperationImplementation HDB::HDBManager::OperationImplementationByID ( RowID id ) const

Returns OperationImplementation.

Returns: OperationImplementation.

Definition at line 2234 of file HDBManager.cc.

                                                      {
    RelationalDBQueryResult* result = nullptr;
    try {
        result = dbConnection_->query(
            std::string("SELECT * FROM operation_implementation WHERE id = ") +
            std::to_string(id) +
            std::string(";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    OperationImplementation retval;
    if (result->hasNext()) {
        result->next();
 
        retval.id = id;
        retval.latency = result->data("latency").integerValue();
        retval.name = result->data("name").stringValue();
        retval.postOpImplFileVhdl =
            result->data("post_op_vhdl").stringValue();
        retval.postOpImplFileVerilog =
            result->data("post_op_verilog").stringValue();
        retval.absBusDefFile =
            result->data("bus_definition").stringValue();
        retval.initialImplFileVerilog =
            result->data("initial_verilog").stringValue();
        retval.initialImplFileVhdl =
            result->data("initial_vhdl").stringValue();
    }
    delete result;
    result = nullptr;
 
    try {
        result = dbConnection_->query(
            std::string("SELECT block_source_file.file "
                        "FROM operation_implementation_source_file, "
                        "block_source_file "
                        "WHERE operation_implementation_source_"
                            "file.operation = ") +
            std::to_string(id) +
            std::string(" AND operation_implementation_source_file.file = "
                        " block_source_file.id"
                        " AND block_source_file.format = "
                        + std::to_string(
                            BlockImplementationFile::VHDL) +
                        ";"));
 
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    if (result->hasNext()) {
        result->next();
        retval.implFileVhdl = result->data("file").stringValue();
    }
    delete result;
    result = nullptr;
 
    try {
        result = dbConnection_->query(
            std::string("SELECT block_source_file.file "
                        "FROM operation_implementation_source_file, "
                        "block_source_file "
                        "WHERE operation_implementation_"
                            "source_file.operation = ") +
            std::to_string(id) +
            std::string(" AND operation_implementation_source_file.file = "
                        " block_source_file.id"
                        " AND block_source_file.format = "
                        + std::to_string(
                            BlockImplementationFile::Verilog) +
                        ";"));
 
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    if (result->hasNext()) {
        result->next();
        retval.implFileVerilog = result->data("file").stringValue();
    }
    delete result;
    result = nullptr;
 
    std::string q1 = "SELECT resource, count "
        "FROM operation_implementation_resources "
        "WHERE operation_implementation_resources.operation = "
        + std::to_string(id) + ";";
    result = dbConnection_->query(q1);
    while (result->hasNext()) {
        result->next();
        int resource = result->data("resource").integerValue();
        OperationImplementationResource r =
            OperationImplementationResourceByID(resource);
        r.count = result->data("count").integerValue();
        retval.resources.emplace_back(r);
    }
 
    std::string q2 = "SELECT name, width, type, language "
        "FROM operation_implementation_variable "
        "WHERE CAST(operation as TEXT) = \"" + std::to_string(id) + "\";";
    result = dbConnection_->query(q2);
    while (result->hasNext()) {
        result->next();
        std::string name = result->data("name").stringValue();
        std::string width = result->data("width").stringValue();
        std::string type = result->data("type").stringValue();
        std::string lang = result->data("language").stringValue();
        // TODO not all HDBs have a rename column yet, so variable renaming is
        // hardcoded
        bool rename = true;
        // std::string renamestr = result->data("rename").stringValue();
        // bool rename = renamestr != "0";
        if (lang == "VHDL") {
            Variable var = {name, width, type, rename};
            retval.vhdlVariables.emplace_back(var);
        } else if (lang == "Verilog") {
            retval.verilogVariables.emplace_back(
                Variable{name, width, type, rename});
        } else {
            throw std::runtime_error("Unknown language");
        }
    }
 
    if (dbConnection_->tableExistsInDB(
            "operation_implementation_globalsignal")) {
        std::string q3 =
            "SELECT name, width, type, language, rename "
            "FROM operation_implementation_globalsignal "
            "WHERE CAST(operation as TEXT) = \"" +
            std::to_string(id) + "\";";
        result = dbConnection_->query(q3);
        while (result->hasNext()) {
            result->next();
            std::string name = result->data("name").stringValue();
            std::string width = result->data("width").stringValue();
            std::string type = result->data("type").stringValue();
            std::string lang = result->data("language").stringValue();
            std::string renamestr = result->data("rename").stringValue();
            bool rename = renamestr != "0";
            if (lang == "VHDL") {
                Variable var = {name, width, type, rename};
                retval.vhdlGlobalSignals.emplace_back(var);
            } else if (lang == "Verilog") {
                retval.verilogGlobalSignals.emplace_back(
                    Variable{name, width, type, rename});
            } else {
                throw std::runtime_error("Unknown language");
            }
        }
    }
 
    return retval;
}

Referenced by ProGeTools::createFUGeneratableOperationInfos(), Automagic::createFUGeneratableOperationInfos(), FUGen::createImplementationFiles(), HDBToHtml::OperationImplementationToHtml(), FUGen::parseOperations(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ OperationImplementationIDs()

std::set< RowID > HDB::HDBManager::OperationImplementationIDs ( ) const

Returns a set of Operation Implementation Resource IDs in the database.

Returns: A set containing all the Operation Implementation Resource IDs in the database.

Definition at line 2179 of file HDBManager.cc.

                                             {
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            std::string("SELECT id FROM operation_implementation;"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    std::set<RowID> idSet;
    while (result->hasNext()) {
        result->next();
        const DataObject& idData = result->data(0);
        idSet.insert(idData.integerValue());
    }
 
    delete result;
    return idSet;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by ProGeTools::createFUGeneratableOperationInfos(), Automagic::createFUGeneratableOperationInfos(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ OperationImplementationResourceByID()

HDB::OperationImplementationResource HDB::HDBManager::OperationImplementationResourceByID ( RowID id ) const

Returns OperationImplementationResource.

Returns: OperationImplementationResource.

Definition at line 2396 of file HDBManager.cc.

                                                              {
    RelationalDBQueryResult* result = nullptr;
    try {
        result = dbConnection_->query(
            std::string("SELECT * FROM "
                "operation_implementation_resource WHERE id = ") +
            std::to_string(id) +
            std::string(";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    OperationImplementationResource retval;
    if (result->hasNext()) {
        result->next();
 
        retval.id = id;
        retval.name = result->data("name").stringValue();
        retval.ipxact = result->data("ipxact").stringValue();
    }
    delete result;
    result = nullptr;
 
    try {
        result = dbConnection_->query(
            std::string("SELECT block_source_file.file, "
                        "format.format "
                        "FROM operation_implementation_resource_"
                        "source_file, block_source_file, "
                        "format "
                        "WHERE operation_implementation_resource_"
                            "source_file.resource = ") +
            std::to_string(id) +
            std::string(" AND operation_implementation_resource_"
                        "source_file.file = "
                        " block_source_file.id "
                        "AND block_source_file.format = "
                        "format.id;"
                        ));
 
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    while (result->hasNext()) {
        result->next();
        std::string format = result->data("format").stringValue();
        if (format == VHDL_FORMAT) {
            retval.synFiles.push_back(result->data("file").stringValue());
            retval.synFormats.push_back(format);
        } else if (format == VHDL_SIM_FORMAT) {
            retval.simFiles.push_back(result->data("file").stringValue());
            retval.simFormats.push_back(format);
        } else if (format == VERILOG_FORMAT) {
            retval.synFiles.push_back(result->data("file").stringValue());
            retval.synFormats.push_back(format);
        } else if (format == VERILOG_SIM_FORMAT) {
            retval.simFiles.push_back(result->data("file").stringValue());
            retval.simFormats.push_back(format);
        }
    }
    delete result;
    result = nullptr;
 
    return retval;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), HDB::OperationImplementationResource::id, HDB::OperationImplementationResource::ipxact, HDB::OperationImplementationResource::name, RelationalDBQueryResult::next(), RelationalDBConnection::query(), HDB::OperationImplementationResource::simFiles, HDB::OperationImplementationResource::simFormats, DataObject::stringValue(), HDB::OperationImplementationResource::synFiles, HDB::OperationImplementationResource::synFormats, VERILOG_FORMAT, VERILOG_SIM_FORMAT, VHDL_FORMAT, and VHDL_SIM_FORMAT.

Referenced by OperationImplementationDialog::addAvailableResourcesToList(), OperationImplementationByID(), HDBToHtml::OperationImplementationResourceToHtml(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ OperationImplementationResourceIDs()

std::set< RowID > HDB::HDBManager::OperationImplementationResourceIDs ( ) const

Returns a set of Operation Implementation IDs in the database.

Returns: A set containing all the Operation Implemnetation IDs in the database.

Definition at line 2207 of file HDBManager.cc.

                                                     {
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            std::string("SELECT id FROM operation_implementation_resource;"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    std::set<RowID> idSet;
    while (result->hasNext()) {
        result->next();
        const DataObject& idData = result->data(0);
        idSet.insert(idData.integerValue());
    }
 
    delete result;
    return idSet;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by OperationImplementationDialog::addAvailableResourcesToList(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ removeBusEntry()

void HDB::HDBManager::removeBusEntry ( RowID id ) const

virtual

Removes the Bus entry that has the given ID from the database.

The entry is removed entirely, meaning that also cost estimation data of that entry are removed.

Parameters

id	The ID of the Bus entry.

Reimplemented in HDB::CachedHDBManager.

Definition at line 3404 of file HDBManager.cc.

                                         {
 
    if (!hasBusEntry(id)) {
        return;
    }
 
    // remove cost estimation data
    try {
        // get the IDs of cost estimation datas
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM cost_estimation_data "
                "WHERE bus_reference=" + Conversion::toString(id) + ";"));
        while (result->hasNext()) {
            result->next();
            const DataObject& costIDData = result->data(0);
            int dataID = costIDData.integerValue();
            removeCostEstimationData(dataID);
        }
        delete result;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove from bus table
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM bus "
                "WHERE id=" + Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), hasBusEntry(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), removeCostEstimationData(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeBusEntry().

Here is the call graph for this function:

◆ removeCostEstimationData()

void HDB::HDBManager::removeCostEstimationData ( RowID id ) const

virtual

Removes the cost estimation data that has the given ID.

Parameters

id	ID of the cost estimation data.

Reimplemented in HDB::CachedHDBManager.

Definition at line 5465 of file HDBManager.cc.

                                                   {   
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM cost_estimation_data "
                "WHERE id=" + Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by CostFunctionPluginDialog::onDelete(), removeBusEntry(), HDB::CachedHDBManager::removeCostEstimationData(), removeFUEntry(), and removeSocketEntry().

Here is the call graph for this function:

◆ removeCostFunctionPlugin()

void HDB::HDBManager::removeCostFunctionPlugin ( RowID pluginID ) const

virtual

Removes the CostFunctionPlugin that has the given ID.

Parameters

pluginID ID of the cost plugin.

Reimplemented in HDB::CachedHDBManager.

Definition at line 670 of file HDBManager.cc.

                                                         {
 
    try {
        dbConnection_->beginTransaction();
 
        // remove from cost_function_plugin table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM cost_function_plugin "
                "WHERE id=" + Conversion::toString(pluginID) + ";"));
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM cost_estimation_data "
                "WHERE plugin_reference=" +
                Conversion::toString(pluginID) + ";"));
 
        dbConnection_->commit();
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::rollback(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by AddCostFunctionPluginCmd::Do(), HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeCostFunctionPlugin().

Here is the call graph for this function:

◆ removeFUArchitecture()

void HDB::HDBManager::removeFUArchitecture ( RowID archID ) const

virtual

Removes the FU architecture that has the given ID. The architecture is removed only it is not used by any FU entry. Otherwise an exception is thrown.

Parameters

archID ID of the FU architecture.

Exceptions

InvalidData If the architecture cannot be removed since it is used by some FU entry.

Reimplemented in HDB::CachedHDBManager.

Definition at line 927 of file HDBManager.cc.

                                                   {
    if (!canRemoveFUArchitecture(archID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    try {
        dbConnection_->beginTransaction();
 
        // remove from io_binding table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM io_binding "
                "WHERE port IN "
                "(SELECT id "
                "FROM fu_data_port "
                "WHERE fu_arch=" + Conversion::toString(archID) + ");"));
        
        // remove from fu_data_port table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_data_port "
                "WHERE fu_arch=" + Conversion::toString(archID) + ";"));
 
        // remove from io_usage_table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM io_usage "
                "WHERE pipeline IN "
                "(SELECT id FROM operation_pipeline "
                "WHERE fu_arch=" + Conversion::toString(archID) + ");"));
        
        // remove from pipeline_resource_usage table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM pipeline_resource_usage "
                "WHERE pipeline IN "
                "(SELECT id FROM operation_pipeline "
                "WHERE fu_arch=" + Conversion::toString(archID) + ");"));
        
        // remove from pipeline_resource_table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM pipeline_resource "
                "WHERE fu_arch=" + Conversion::toString(archID) + ";"));
        
        // remove from operation_pipeline_table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM operation_pipeline "
                "WHERE fu_arch=" + Conversion::toString(archID) + ";"));
        
        // remove from fu_architecture table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_architecture "
                "WHERE id=" + Conversion::toString(archID) + ";"));
        
        dbConnection_->commit();
 
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
}

References __func__, assert, RelationalDBConnection::beginTransaction(), canRemoveFUArchitecture(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::rollback(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeFUArchitecture().

Here is the call graph for this function:

◆ removeFUEntry()

void HDB::HDBManager::removeFUEntry ( RowID id ) const

virtual

Removes the FU entry that has the given ID from the database.

The entry is removed entirely, meaning that all also FU implementation and cost estimation data of that entry are removed.

Parameters

id	The ID of the FU entry.

Reimplemented in HDB::CachedHDBManager.

Definition at line 1025 of file HDBManager.cc.

                                        {
 
    if (!hasFUEntry(id)) {
        return;
    }
 
    // remove implementation
    try {
        // get the ID of the implementation
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM fu_implementation "
                "WHERE fu=" + Conversion::toString(id) + ";"));
        if (result->hasNext()) {
            result->next();
            const DataObject& implIDData = result->data(0);
            int implID = implIDData.integerValue();
            removeFUImplementation(implID);
        }
        delete result;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove cost estimation data
    try {
        // get the IDs of cost estimation datas
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM cost_estimation_data "
                "WHERE fu_reference=" + Conversion::toString(id) + ";"));
        while (result->hasNext()) {
            result->next();
            const DataObject& costIDData = result->data(0);
            int dataID = costIDData.integerValue();
            removeCostEstimationData(dataID);
        }
        delete result;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove from fu table
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu "
                "WHERE id=" + Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), hasFUEntry(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), removeCostEstimationData(), removeFUImplementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeFUEntry().

Here is the call graph for this function:

◆ removeFUImplementation()

void HDB::HDBManager::removeFUImplementation ( RowID implID ) const

virtual

Removes the given FU implementation from the database.

Parameters

implID ID of the FU implementation.

Reimplemented in HDB::CachedHDBManager.

Definition at line 1311 of file HDBManager.cc.

                                                     {
    
    try {
        dbConnection_->beginTransaction();
 
        // remove from fu_ext_port_parameter_dependency table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_ext_port_parameter_dependency "
                "WHERE parameter in (SELECT ALL id FROM "
                "fu_implementation_parameter WHERE fu_impl="
                + Conversion::toString(implID) + ");"));
 
        // remove from fu_external_port table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_external_port "
                "WHERE fu_impl=" + Conversion::toString(implID) + ";"));
        
        // remove from fu_port_map table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_port_map "
                "WHERE fu_impl=" + Conversion::toString(implID) + ";"));
        
        // remove from opcode_map table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM opcode_map "
                "WHERE fu_impl=" + Conversion::toString(implID) + ";"));
                
        // remove from fu_implementation_parameter
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_implementation_parameter "
                "WHERE fu_impl=" + Conversion::toString(implID) + ";"));
        
        // remove from fu_source_file
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_source_file "
                "WHERE fu_impl=" + Conversion::toString(implID) + ";"));
        
        // remove from block_source_file
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM block_source_file "
                "WHERE id NOT IN "
                "(SELECT file FROM fu_source_file UNION "
                "SELECT file FROM rf_source_file);"));
        
        // remove from fu_implementation
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM fu_implementation "
                "WHERE id=" + Conversion::toString(implID) + ";"));
        
        dbConnection_->commit();
        
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::rollback(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorModifyCmd::Do(), removeFUEntry(), and HDB::CachedHDBManager::removeFUImplementation().

Here is the call graph for this function:

◆ removeOperationImplementation()

void HDB::HDBManager::removeOperationImplementation ( RowID id )

Remove Operation Implemententation from DB.

Definition at line 2608 of file HDBManager.cc.

                                                  {
    std::string d1 = "DELETE FROM operation_implementation "
        "WHERE id = " + std::to_string(id) + ";";
    std::string d2 =
        "DELETE FROM operation_implementation_source_file "
        "WHERE operation = " + std::to_string(id) + ";";
    std::string d3 =
        "DELETE FROM operation_implementation_resources "
        "WHERE operation = " + std::to_string(id) + ";";
    std::string d4 =
        "DELETE FROM operation_implementation_variable "
        "WHERE operation = " + std::to_string(id) + ";";
    std::string s1 = "SELECT file FROM "
        "operation_implementation_source_file "
        "WHERE operation = " + std::to_string(id) + ";";
 
    RelationalDBQueryResult* result = dbConnection_->query(s1);
    while (result->hasNext()) {
        result->next();
        int file_id = result->data(0).integerValue();
        std::string d3lete = "DELETE FROM block_source_file "
            "WHERE id = " + std::to_string(file_id) + ";";
        dbConnection_->updateQuery(d3lete);
    }
 
    dbConnection_->updateQuery(d4);
    dbConnection_->updateQuery(d3);
    dbConnection_->updateQuery(d2);
    dbConnection_->updateQuery(d1);
    delete result;
}

References RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do().

Here is the call graph for this function:

◆ removeOperationImplementationResource()

void HDB::HDBManager::removeOperationImplementationResource ( RowID id )

Remove Operation Implemententation Resource from DB.

Definition at line 2644 of file HDBManager.cc.

                                                          {
    std::string d1 = "DELETE FROM operation_implementation_resource "
        "WHERE id = " + std::to_string(id) + ";";
    std::string d2 =
        "DELETE FROM operation_implementation_resource_source_file "
        "WHERE resource = " + std::to_string(id) + ";";
    std::string s1 = "SELECT file FROM "
        "operation_implementation_resource_source_file "
        "WHERE resource = " + std::to_string(id) + ";";
 
    RelationalDBQueryResult* result = dbConnection_->query(s1);
    while (result->hasNext()) {
        result->next();
        int file_id = result->data(0).integerValue();
        std::string d3 = "DELETE FROM block_source_file "
            "WHERE id = " + std::to_string(file_id) + ";";
            dbConnection_->updateQuery(d3);
    }
 
    dbConnection_->updateQuery(d2);
    dbConnection_->updateQuery(d1);
    delete result;
}

References RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do().

Here is the call graph for this function:

◆ removeRFArchitecture()

void HDB::HDBManager::removeRFArchitecture ( RowID archID ) const

virtual

Removes the RF architecture that has the given ID.

Parameters

archID ID of the RF architecture.

Exceptions

InvalidData If the RF architecture cannot be removed.

Reimplemented in HDB::CachedHDBManager.

Definition at line 1521 of file HDBManager.cc.

                                                   {
    if (!canRemoveRFArchitecture(archID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM rf_architecture WHERE id=" +
                Conversion::toString(archID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References __func__, assert, canRemoveRFArchitecture(), dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeRFArchitecture().

Here is the call graph for this function:

◆ removeRFEntry()

void HDB::HDBManager::removeRFEntry ( RowID id ) const

virtual

Removes the RF entry that has the given ID.

Cost estimation data and implementation of the entry are removed too.

Parameters

id	ID of the RF entry.

Reimplemented in HDB::CachedHDBManager.

Definition at line 1569 of file HDBManager.cc.

                                        {
 
    if (!hasRFEntry(id)) {
        return;
    }
    
    // remove from cost_estimation_data
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM cost_estimation_data WHERE rf_reference=" +
                Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove implementation
    try {
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM rf_implementation WHERE rf=" +
                Conversion::toString(id) + ";"));
        if (result->hasNext()) {
            result->next();
            RowID implID = result->data(0).integerValue();
            removeRFImplementation(implID);
        }
        delete result;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove the entry
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM rf WHERE id=" + Conversion::toString(id)
                + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }       
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), hasRFEntry(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), removeRFImplementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeRFEntry().

Here is the call graph for this function:

◆ removeRFImplementation()

void HDB::HDBManager::removeRFImplementation ( RowID implID ) const

virtual

Removes the RF implementation that has the given ID.

Parameters

implID ID of the RF implementation.

Reimplemented in HDB::CachedHDBManager.

Definition at line 1794 of file HDBManager.cc.

                                                     {
 
    bool dependencyTableExists =
        dbConnection_->tableExistsInDB("rf_ext_port_parameter_dependency");
    bool parameterTableExists =
        dbConnection_->tableExistsInDB("rf_implementation_parameter");
    bool externalPortTableExists =
        dbConnection_->tableExistsInDB("rf_external_port");
 
    try {
        dbConnection_->beginTransaction();
        
        // remove from rf_ext_port_parameter_dependency table if it exists
        // (backward compatibility for old HDBs).
        if (dependencyTableExists) {
            assert(parameterTableExists && externalPortTableExists);
            dbConnection_->updateQuery(
                std::string(
                    "DELETE FROM rf_ext_port_parameter_dependency "
                    "WHERE parameter in (SELECT ALL id "
                    "FROM rf_implementation_parameter WHERE rf_impl = " +
                    Conversion::toString(implID) + ");"));
        }
 
        // remove from rf_external_port table if it exists
        // (backward compatibility for old HDBs).
        if (externalPortTableExists) {
            dbConnection_->updateQuery(
                std::string(
                    "DELETE FROM rf_external_port "
                    "WHERE rf_impl=" +
                    Conversion::toString(implID) + ";"));
        }
 
        // remove from rf_implementation_parameter table if it exists
        // (backward compatibility for old HDBs).
        if (parameterTableExists) {
            dbConnection_->updateQuery(
                std::string(
                    "DELETE FROM rf_implementation_parameter "
                    "WHERE rf_impl=" + Conversion::toString(implID) + ";"));
        }
 
        // remove from rf_source_file table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM rf_source_file WHERE rf_impl=" +
                Conversion::toString(implID) + ";"));
        
        // remove from block_source_file table
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM block_source_file WHERE id NOT IN "
                "(SELECT file FROM fu_source_file UNION "
                "SELECT file FROM rf_source_file);"));
        
        // remove from rf_data_port
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM rf_data_port WHERE rf_impl=" +
                Conversion::toString(implID) + ";"));
 
        // remove from rf_implementation
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM rf_implementation WHERE id=" +
                Conversion::toString(implID) + ";"));
 
        dbConnection_->commit();
 
    } catch (const Exception& e) {
        dbConnection_->rollback();
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::rollback(), RelationalDBConnection::tableExistsInDB(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorModifyCmd::Do(), removeRFEntry(), and HDB::CachedHDBManager::removeRFImplementation().

Here is the call graph for this function:

◆ removeSocketEntry()

void HDB::HDBManager::removeSocketEntry ( RowID id ) const

virtual

Removes the Socket entry that has the given ID from the database.

The entry is removed entirely, meaning that also cost estimation data of that entry are removed.

Parameters

id	The ID of the Socket entry.

Reimplemented in HDB::CachedHDBManager.

Definition at line 3617 of file HDBManager.cc.

                                            {
 
    if (!hasSocketEntry(id)) {
        return;
    }
 
    // remove cost estimation data
    try {
        // get the IDs of cost estimation datas
        RelationalDBQueryResult* result = dbConnection_->query(
            std::string(
                "SELECT id FROM cost_estimation_data "
                "WHERE socket_reference=" + Conversion::toString(id) + ";"));
        while (result->hasNext()) {
            result->next();
            const DataObject& costIDData = result->data(0);
            int dataID = costIDData.integerValue();
            removeCostEstimationData(dataID);
        }
        delete result;
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    // remove from socket table
    try {
        dbConnection_->updateQuery(
            std::string(
                "DELETE FROM socket "
                "WHERE id=" + Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), hasSocketEntry(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), removeCostEstimationData(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by HDBEditorDeleteCmd::Do(), and HDB::CachedHDBManager::removeSocketEntry().

Here is the call graph for this function:

◆ resolveArchitecturePort()

std::string HDB::HDBManager::resolveArchitecturePort	(	const FUArchitecture &	architecture,
		RowID	entryID,
		const std::string &	implementedPort
	)		const

private

Resolves what is the architectural port corresponding to the given implemented port.

Parameters

architecture	The architecture of the FU.
id	ID of the FU entry in the database.
implementedPort	Name of the implemented port to resolve.

Returns: Name of the corresponding port in the FU architecture.

Definition at line 4908 of file HDBManager.cc.

                                            {
 
    RelationalDBQueryResult* bindingData = NULL;
    try {
        bindingData = dbConnection_->query(
            fuPortBindingByNameQuery(entryID, implementedPort));
    } catch (const Exception&) {
        assert(false);
    }
 
    int operationColumn = bindingData->column("operation.name");
    int ioColumn = bindingData->column("io_binding.io_number");
    assert(operationColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
    assert(ioColumn != RelationalDBQueryResult::UNKNOWN_INDEX);
 
    FunctionUnit& fu = architecture.architecture();
    string portName = "";
 
    while (bindingData->hasNext()) {
        bindingData->next();
        const DataObject& operationData = bindingData->data(operationColumn);
        const DataObject& ioData = bindingData->data(ioColumn);
        string operationName = operationData.stringValue();
        int io = ioData.integerValue();
        assert(fu.hasOperation(operationName));
        HWOperation* operation = fu.operation(operationName);
        FUPort* port = operation->port(io);
        assert(portName == "" || portName == port->name());
        portName = port->name();
    }
 
    delete bindingData;
    bindingData = NULL;
 
    return portName;
}

References HDB::FUArchitecture::architecture(), assert, RelationalDBQueryResult::column(), RelationalDBQueryResult::data(), dbConnection_, fuPortBindingByNameQuery(), RelationalDBQueryResult::hasNext(), TTAMachine::FunctionUnit::hasOperation(), DataObject::integerValue(), TTAMachine::Port::name(), RelationalDBQueryResult::next(), TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::port(), RelationalDBConnection::query(), DataObject::stringValue(), and RelationalDBQueryResult::UNKNOWN_INDEX.

Referenced by addDataPortsToImplementation().

Here is the call graph for this function:

◆ resourceUsageDataByIDQuery()

std::string HDB::HDBManager::resourceUsageDataByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting resource usage data of pipelines of the FU architecture that has the given ID.

The result table has fields {operation.name, pipeline_resource_usage.cycle, pipeline_resource.id}

Parameters

id	ID of the FU architecture in HDB.

Definition at line 5919 of file HDBManager.cc.

                                               {
    string idString  = Conversion::toString(id);
    string query =
        "SELECT operation.name AS 'operation.name',"
        "       pipeline_resource_usage.cycle AS "
        "          'pipeline_resource_usage.cycle',"
        "       pipeline_resource.id AS 'pipeline_resource.id' "
        "FROM pipeline_resource_usage, pipeline_resource, operation,"
        "     operation_pipeline "
        "WHERE operation_pipeline.fu_arch=" + idString + " AND"
        "      pipeline_resource_usage.pipeline=operation_pipeline.id AND"
        "      pipeline_resource.id = pipeline_resource_usage.resource AND"
        "      operation.id=operation_pipeline.operation;";
    return query;
}

References Conversion::toString().

Referenced by addOperationPipelinesToFUArchitecture().

Here is the call graph for this function:

◆ rfArchitectureByID()

RFArchitecture * HDB::HDBManager::rfArchitectureByID ( RowID id ) const

virtual

Creates an RFArchitecture instance of the RF architecture that has the given ID.

Parameters

id	The ID of the RF architecture.

Returns: The newly created RFArchitecture instance.

Exceptions

KeyNotFound If the HDB does not contain RF architecture with the given ID.

Reimplemented in HDB::CachedHDBManager.

Definition at line 2949 of file HDBManager.cc.

                                             {
    if (!containsRFArchitecture(id)) {
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
 
    RelationalDBQueryResult* architectureData;
    try {
        architectureData = dbConnection_->query(rfArchitectureByIDQuery(id));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    int sizeColumn = architectureData->column("size");
    int widthColumn = architectureData->column("width");
    int readPortsColumn = architectureData->column("read_ports");
    int writePortsColumn = architectureData->column("write_ports");
    int bidirPortsColumn = architectureData->column("bidir_ports");
    int latencyColumn = architectureData->column("latency");
    int maxReadsColumn = architectureData->column("max_reads");
    int maxWritesColumn = architectureData->column("max_writes");
    int guardSupportColumn = architectureData->column("guard_support");
    int guardLatencyColumn = architectureData->column("guard_latency");
    int zeroRegisterColumn = architectureData->column("zero_register");
 
    assert(architectureData->hasNext());
    architectureData->next();
    assert(!architectureData->hasNext());
    const DataObject& sizeData = architectureData->data(sizeColumn);
    const DataObject& widthData = architectureData->data(widthColumn);
    const DataObject& readPortsData = architectureData->data(
        readPortsColumn);
    const DataObject& writePortsData = architectureData->data(
        writePortsColumn);
    const DataObject& bidirPortsData = architectureData->data(
        bidirPortsColumn);
    const DataObject& latencyData = architectureData->data(
        latencyColumn);
    const DataObject& maxReadsData = architectureData->data(
        maxReadsColumn);
    const DataObject& maxWritesData = architectureData->data(
        maxWritesColumn);
    const DataObject& guardSupportData = architectureData->data(
        guardSupportColumn);
    const DataObject& guardLatencyData = architectureData->data(
        guardLatencyColumn);
    const DataObject& zeroRegisterData = architectureData->data(
        zeroRegisterColumn);
    RFArchitecture* architecture = new RFArchitecture(
        readPortsData.integerValue(), writePortsData.integerValue(),
        bidirPortsData.integerValue(), maxReadsData.integerValue(),
        maxWritesData.integerValue(), latencyData.integerValue(), 
        guardSupportData.boolValue(), guardLatencyData.integerValue(),
        zeroRegisterData.boolValue());
    std::cout.flush();
    architecture->setID(id);
    if (!sizeData.isNull()) {
        architecture->setSize(sizeData.integerValue());
    }
    if (!widthData.isNull()) {
        architecture->setWidth(widthData.integerValue());
    }
    delete architectureData;
    return architecture;
}

References __func__, assert, DataObject::boolValue(), RelationalDBQueryResult::column(), containsRFArchitecture(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), rfArchitectureByIDQuery(), HWBlockArchitecture::setID(), HDB::RFArchitecture::setSize(), and HDB::RFArchitecture::setWidth().

Referenced by AddRFFromHDBDialog::loadHDB(), AddIUFromHDBDialog::loadHDB(), HDB::CachedHDBManager::rfArchitectureByID(), HDB::CachedHDBManager::rfArchitectureByIDConst(), HDBToHtml::rfArchToHtml(), and rfByEntryID().

Here is the call graph for this function:

◆ rfArchitectureByIDQuery()

std::string HDB::HDBManager::rfArchitectureByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the architecture data of the RF architecture that has the given ID.

The result table has all the fields of rf_architecture table.

Parameters

id	ID of the RF architecture.

Returns: The SQL query.

Definition at line 6184 of file HDBManager.cc.

                                            {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM rf_architecture "
        "WHERE id=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by rfArchitectureByID().

Here is the call graph for this function:

◆ rfArchitectureID()

RowID HDB::HDBManager::rfArchitectureID ( RowID rfEntryID ) const

private

Returns the ID of the architecture of the given RF entry.

Parameters

rfEntryID ID of the RF entry.

Returns: ID of the RF architecture.

Exceptions

NotAvailable If the RF entry does not have an architecture.

Definition at line 4291 of file HDBManager.cc.

                                                  {
    RelationalDBQueryResult* result;
    try {
        result = dbConnection_->query(
            std::string(
                "SELECT architecture FROM rf WHERE id=" +
                Conversion::toString(rfEntryID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (!result->hasNext()) {
        delete result;
        throw NotAvailable(__FILE__, __LINE__, __func__);
    }
 
    result->next();
    const DataObject& idData = result->data(0);
    if (idData.isNull()) {
        delete result;
        throw NotAvailable(__FILE__, __LINE__, __func__);
    } else {
        RowID retValue = idData.integerValue();
        delete result;
        return retValue;
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ rfArchitectureIDs()

std::set< RowID > HDB::HDBManager::rfArchitectureIDs ( ) const

Returns a set of RF architecture IDs in the database.

Returns: A set containing all the RF architecture IDs in the database.

Definition at line 2720 of file HDBManager.cc.

                                    {
 
    RelationalDBQueryResult* result = NULL;
    try {
        result = dbConnection_->query(
            std::string("SELECT id FROM rf_architecture;"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    std::set<RowID> idSet;
    while (result->hasNext()) {
        result->next();
        const DataObject& idData = result->data(0);
        idSet.insert(idData.integerValue());
    }
 
    delete result;
    return idSet;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by SetRFArchitectureCmd::Do(), AddRFFromHDBDialog::loadHDB(), AddIUFromHDBDialog::loadHDB(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ rfByEntryID()

RFEntry * HDB::HDBManager::rfByEntryID ( RowID id ) const

Returns the RF entry that has the given ID.

Parameters

id	The ID of the RF entry.

Returns: The RF entry.

Exceptions

KeyNotFound If the HDB does not contain an RF entry with the given ID.

Definition at line 2871 of file HDBManager.cc.

                                      {
    std::string query = "SELECT architecture FROM rf WHERE id=";
    query += Conversion::toString(id) + ";";
 
    RelationalDBQueryResult* result = NULL;
    try {
        result =  dbConnection_->query(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());        
        assert(false);
    }
 
    bool hasArch = false;
    RowID archID = -1;
    if (result->hasNext()) {        
        result->next();
        DataObject data = result->data(0);
        if (!data.isNull()) {
            hasArch = true;
            archID = data.integerValue();
        }
        delete result;
        result = NULL;
    } else {
        delete result;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
 
    RFEntry* entry = new RFEntry();
    entry->setID(id);
    if (hasArch) {
        RFArchitecture* architecture = rfArchitectureByID(archID);
        entry->setArchitecture(architecture);
    }
 
    RFImplementation* implementation = createImplementationOfRF(id);
    CostFunctionPlugin* costFunction = createCostFunctionOfRF(id);
    entry->setImplementation(implementation);
    entry->setCostFunction(costFunction);
    entry->setHDBFile(hdbFile_);
    delete result;
 
    return entry;
}

References __func__, assert, createCostFunctionOfRF(), createImplementationOfRF(), RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), hdbFile_, implementation, DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), rfArchitectureByID(), HDB::RFEntry::setArchitecture(), HDB::HDBEntry::setCostFunction(), HDB::HDBEntry::setHDBFile(), HDB::HDBEntry::setID(), HDB::RFEntry::setImplementation(), and Conversion::toString().

Referenced by ProGe::NetlistGenerator::addBaseRFToNetlist(), addRFImplementation(), CostDatabase::buildRegisterFiles(), ProGeTools::checkForSelectableIU(), Automagic::checkForSelectableIU(), ProGeTools::checkForSelectableRF(), Automagic::checkForSelectableRF(), ProGe::ProcessorGenerator::checkIULatencies(), ProGe::BlockSourceCopier::copyBaseRFFiles(), AddRFImplementationCmd::Do(), HDBEditorModifyCmd::Do(), ProGeScriptGenerator::getBlockOrder(), AddRFImplementationCmd::isEnabled(), BlockImplementationDialog::onHDBSelection(), CostEstimator::Estimator::rfCostFunctionPluginOfImplementation(), ImplementationTester::rfEntryFromHdb(), HDBToHtml::rfEntryToHtml(), HDBToHtml::rfImplToHtml(), setArchitectureForRF(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ rfCostEstimationData()

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

Returns RF cost estimation data.

This version assumes that there's only one entry with given parameters.

Todo:: Another version for fetching lists of data.

Parameters

valueName	Name of the value to fetch.
implementationId	The ID of the RF entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data.

Exceptions

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

Definition at line 3331 of file HDBManager.cc.

                                       {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND fu_reference IS NULL " +
            " AND bus_reference IS NULL " +
            " AND socket_reference IS NULL AND " +
            "     rf_reference = " + Conversion::toString(implementationId) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');");
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

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

Here is the call graph for this function:

◆ rfCostEstimationDataIDs()

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

Returns a set of cost estimation data IDs which reference the give RF implementation.

Parameters

rfImplID ID of the RF implementation.

Returns: Set of cost estimation data IDs.

Definition at line 6418 of file HDBManager.cc.

                                                        {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT id "
                "FROM cost_estimation_data "
                "WHERE rf_reference = ") +
            Conversion::toString(rfImplID);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBToHtml::rfEntryToHtml(), and HDBToHtml::rfImplToHtml().

Here is the call graph for this function:

◆ rfEntriesByArchitecture()

std::set< RowID > HDB::HDBManager::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

Returns a set of RF entry IDs that have the described architecture.

In case that size or width is given as a parameter are also the RF entries with a parameterized width or size returned as are the entries with matched width and/or size.

Parameters

readPorts	The number of read ports.
writePorts	The number of write ports.
bidirPorts	The number of bidirectional ports.
maxRead	The (minimum) max reads value.
latency	The exact latency.
guardSupport	Guard support.
guardLatency	The guard latency.
width	The bit withd of the register file.
size	The number of registers in the register file.
zeroRegister	zero register of the register file

Returns: Set of RF entry IDs.

Definition at line 3119 of file HDBManager.cc.

                             {
 
    RelationalDBQueryResult* result = NULL;
    try {
        string query = "SELECT rf.id FROM rf,rf_architecture "
            "WHERE rf_architecture.read_ports=" +
            Conversion::toString(readPorts) +
            " AND rf_architecture.write_ports=" +
            Conversion::toString(writePorts) +
            " AND rf_architecture.bidir_ports=" +
            Conversion::toString(bidirPorts) +
            " AND rf_architecture.max_reads>=" +
            Conversion::toString(maxReads) +
            " AND rf_architecture.max_writes>=" +
            Conversion::toString(maxWrites) +
            " AND rf_architecture.latency=" +
            Conversion::toString(latency);
        if (guardSupport) {
            query += " AND rf_architecture.guard_support=" + 
                Conversion::toString(guardSupport) + 
                " AND rf_architecture.guard_latency=" + 
                Conversion::toString(guardLatency);
        }
        if (size != 0) {
            query += " AND (rf_architecture.size=" +
                Conversion::toString(size) + 
                " OR rf_architecture.size is NULL)";
        }
        if (width != 0) {
            query += " AND (rf_architecture.width=" + 
                Conversion::toString(width) +
                " OR rf_architecture.width is NULL)";
        }
        query += " AND (rf_architecture.zero_register=" +
            Conversion::toString(zeroRegister);
        if (!zeroRegister) {
            query += " OR rf_architecture.zero_register is NULL";
        }
        query += ")";
        query += " AND rf.architecture=rf_architecture.id;";
        result = dbConnection_->query(query);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        ;
    }
 
    std::set<RowID> entryIDs;
    while (result->hasNext()) {
        result->next();
        entryIDs.insert(result->data(0).integerValue());
    }
    delete result;
 
    return entryIDs;
}

References RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by ComponentImplementationSelector::iuImplementations(), BlockImplementationDialog::onHDBSelection(), and ComponentImplementationSelector::rfImplementations().

Here is the call graph for this function:

◆ rfEntryByIDQuery()

std::string HDB::HDBManager::rfEntryByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the RF entry that has the given ID.

The result set has fields {id, architecture, cost_function}.

Parameters

id	ID of the entry.

Returns: The SQL query.

Definition at line 5786 of file HDBManager.cc.

                                     {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM rf "
        "WHERE rf.id=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by hasRFEntry().

Here is the call graph for this function:

◆ rfEntryHasArchitecture()

bool HDB::HDBManager::rfEntryHasArchitecture ( RowID id ) const

private

Tells whether the RF entry that has the given ID has an architecture.

Parameters

id	ID of the RF entry.

Returns: True if it has an architecture, otherwise false.

Exceptions

KeyNotFound If the HDB does not contain a RF entry with the given ID.

Definition at line 4115 of file HDBManager.cc.

                                                 {
    RelationalDBQueryResult* result;
    try {
        result = dbConnection_->query(
            std::string(
                "SELECT architecture FROM rf WHERE id=" +
                Conversion::toString(id) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
    
    if (result->hasNext()) {
        result->next();
        const DataObject& data = result->data(0);
        delete result;
        return !data.isNull();
    } else {
        delete result;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ rfEntryIDOfImplementation()

RowID HDB::HDBManager::rfEntryIDOfImplementation ( RowID implID ) const

Returns the ID of the RF entry that has the given implementation ID.

Parameters

implID The implementation ID.

Returns: The RF entry ID.

Exceptions

KeyNotFound If there is no implementation by the given ID.

Definition at line 2782 of file HDBManager.cc.

                                                        {
    RelationalDBQueryResult* result = NULL;
    try {
        result =  dbConnection_->query(
            std::string(
                "SELECT rf from rf_implementation WHERE id=" + 
                Conversion::toString(implID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
 
    if (result->hasNext()) {
        result->next();
        RowID id = result->data(0).integerValue();
        delete result;
        return id;
    } else {
        delete result;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBEditorDeleteCmd::Do(), HDBEditorModifyCmd::Do(), HDB::CachedHDBManager::removeRFImplementation(), and HDBToHtml::rfImplToHtml().

Here is the call graph for this function:

◆ rfEntryIDs()

std::set< RowID > HDB::HDBManager::rfEntryIDs ( ) const

Returns a set of RF entry IDs in the database.

Returns: A set containing all the RF entry IDs in the database.

Definition at line 2053 of file HDBManager.cc.

                             {
 
    string query = "SELECT id AS 'rf.id' FROM rf;";
 
    // make the SQL query to obtain all the IDs
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(query);
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    std::set<RowID> idSet;
    while (queryResult->hasNext()) {
        queryResult->next();
        const DataObject& idData = queryResult->data("rf.id");
        idSet.insert(idData.integerValue());
    }
 
    delete queryResult;
    return idSet;
}     

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by CostDatabase::buildRegisterFiles(), ProGeTools::checkForSelectableIU(), Automagic::checkForSelectableIU(), ProGeTools::checkForSelectableRF(), Automagic::checkForSelectableRF(), CostEstimationDataDialog::onEntryTypeSelection(), ImplementationTester::rfEntryIDs(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ rfExternalPortsByIDQuery()

std::string HDB::HDBManager::rfExternalPortsByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting external port data of implementation of the RF that has the given ID.

The result table has fields {rf_external_port.name, rf_external_port.direction, rf_external_port.width_formula, rf_external_port.description}.

Parameters

id	ID of the RF entry in HDB.

Returns: The SQL query.

Definition at line 6058 of file HDBManager.cc.

                                             {
    string idString = Conversion::toString(id);
    string query =
        "SELECT rf_external_port.name AS 'rf_external_port.name',"
        "       rf_external_port.direction AS 'rf_external_port.direction',"
        "       rf_external_port.width_formula AS "
        "           'rf_external_port.width_formula',"
        "       rf_external_port.description AS "
        "           'rf_external_port.description' "
        "FROM rf, rf_implementation, rf_external_port "
        "WHERE rf.id=" + idString + " AND"
        "      rf_implementation.rf=rf.id AND"
        "      rf_external_port.rf_impl=rf_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addRFExternalPortsToImplementation().

Here is the call graph for this function:

◆ rfImplementationByIDQuery()

std::string HDB::HDBManager::rfImplementationByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the implementation of the RF entry that has the given ID.

The result table has fields {id, name, size_param, width_param, clk_port, rst_port, glock_port, guard_port}.

Parameters

id	The ID of the RF entry.

Returns: The SQL query.

Definition at line 6205 of file HDBManager.cc.

                                              {
    string idString = Conversion::toString(id);
    string query =
            "SELECT id,"
            "       name,"
            "       size_param,"
            "       width_param,"
            "       clk_port,"
            "       rst_port,"
            "       glock_port,"
            "       guard_port "
            "FROM rf_implementation "
            "WHERE rf_implementation.rf=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by createImplementationOfRF().

Here is the call graph for this function:

◆ rfImplementationByIDQuery2()

std::string HDB::HDBManager::rfImplementationByIDQuery2 ( RowID id )

staticprivate

Same as rfImplementationByIDQuery() bus has additional field for separate address cycle.

The result table has fields {id, name, size_param, width_param, clk_port, rst_port, glock_port, guard_port, sac_param}.

Parameters

id	The ID of the RF entry.

Returns: The SQL query.

Definition at line 6232 of file HDBManager.cc.

                                               {
    string idString = Conversion::toString(id);
    string query =
            "SELECT id,"
            "       name,"
            "       size_param,"
            "       width_param,"
            "       clk_port,"
            "       rst_port,"
            "       glock_port,"
            "       guard_port, "
            "       sac_param "
            "FROM rf_implementation "
            "WHERE rf_implementation.rf=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by createImplementationOfRF().

Here is the call graph for this function:

◆ rfImplementationDataPortsByIDQuery()

std::string HDB::HDBManager::rfImplementationDataPortsByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the data ports of the implementation of the RF entry that has the given ID.

The result table has fields {name, direction, load_port, opcode_port, opcode_port_width_formula}.

Parameters

id	ID of the RF entry.

Returns: The SQL query.

Definition at line 6260 of file HDBManager.cc.

                                                       {
    string idString = Conversion::toString(id);
    string query =
        "SELECT rf_data_port.name AS 'name',"
        "       rf_data_port.direction AS 'direction',"
        "       rf_data_port.load_port AS 'load_port',"
        "       rf_data_port.opcode_port AS 'opcode_port',"
        "       rf_data_port.opcode_port_width_formula AS "
        "           'opcode_port_width_formula' "
        "FROM rf_data_port, rf_implementation "
        "WHERE rf_implementation.rf=" + idString + " AND"
        "      rf_data_port.rf_impl=rf_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addDataPortsToImplementation().

Here is the call graph for this function:

◆ rfImplementationParametersByIDQuery()

std::string HDB::HDBManager::rfImplementationParametersByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the parameters of the implementation of the RF that has the given ID.

The result table has fields {name, type, value}.

Parameters

id	ID of the RF entry.

Returns: The SQL query.

Definition at line 6108 of file HDBManager.cc.

                                                        {
    string idString = Conversion::toString(id);
    string query =
        "SELECT rf_implementation_parameter.name AS 'name',"
        "       rf_implementation_parameter.type AS 'type',"
        "       rf_implementation_parameter.value AS 'value' "
        "FROM rf_implementation, rf_implementation_parameter "
        "WHERE rf_implementation.rf=" + idString + " AND"
        "      rf_implementation_parameter.rf_impl=rf_implementation.id;";
    return query;
}

References Conversion::toString().

Referenced by addRFParametersToImplementation().

Here is the call graph for this function:

◆ rfSourceFilesByIDQuery()

std::string HDB::HDBManager::rfSourceFilesByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the block implementation files of the RF entry that has the given ID.

The result table has fields {block_source_file.file, format.format}.

Parameters

id	ID of the RF entry.

Returns: The SQL query.

Definition at line 6286 of file HDBManager.cc.

                                           {
    string idString = Conversion::toString(id);
    string query =
        "SELECT block_source_file.file AS 'block_source_file.file',"
        "       format.format AS 'format.format' "
        "FROM block_source_file, format, rf_implementation, rf_source_file "
        "WHERE rf_implementation.rf=" + idString + " AND"
        "      rf_source_file.rf_impl=rf_implementation.id AND"
        "      block_source_file.id=rf_source_file.file AND"
        "      format.id=block_source_file.format;";
    return query;
}

References Conversion::toString().

Referenced by addBlockImplementationFiles().

Here is the call graph for this function:

◆ setArchitectureForFU()

void HDB::HDBManager::setArchitectureForFU	(	RowID	fuID,
		RowID	archID
	)		const

Sets the given architecture for the given FU entry.

Parameters

fuID	ID of the FU entry.
archID	ID of the FU architecture.

Exceptions

InvalidData If the FU entry has an implementation already or if the HDB does not have FU or architecture by the given ID.

Definition at line 1387 of file HDBManager.cc.

                                                               {
    if (!hasFUEntry(fuID) || !containsFUArchitecture(archID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    FUEntry* entry = fuByEntryID(fuID);
    if (entry->hasImplementation()) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    // set the architecture
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE fu SET architecture=" +
                Conversion::toString(archID) + " WHERE id=" +
                Conversion::toString(fuID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References __func__, assert, containsFUArchitecture(), dbConnection_, debugLog, Exception::errorMessage(), fuByEntryID(), hasFUEntry(), HDB::FUEntry::hasImplementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by AddFUImplementationCmd::Do(), and SetFUArchitectureCmd::Do().

Here is the call graph for this function:

◆ setArchitectureForRF()

void HDB::HDBManager::setArchitectureForRF	(	RowID	rfID,
		RowID	archID
	)		const

Sets architecture for an RF entry.

Parameters

rfID	ID of the RF entry.
archID	ID of the RF architecture to set.

Exceptions

InvalidData If the database does not contain the given IDs or if the RF entry has an architecture already.

Definition at line 1881 of file HDBManager.cc.

                                                               {
    if (!hasRFEntry(rfID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    RFEntry* entry = rfByEntryID(rfID);
    if (entry->hasArchitecture()) {
        delete entry;
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
    delete entry;
    entry = NULL;
 
    if (!containsRFArchitecture(archID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE rf SET architecture=" +
                Conversion::toString(archID) + " WHERE id=" +
                Conversion::toString(rfID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References __func__, assert, containsRFArchitecture(), dbConnection_, debugLog, Exception::errorMessage(), HDB::RFEntry::hasArchitecture(), hasRFEntry(), rfByEntryID(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by AddRFImplementationCmd::Do(), and SetRFArchitectureCmd::Do().

Here is the call graph for this function:

◆ setCostFunctionPluginForFU()

void HDB::HDBManager::setCostFunctionPluginForFU	(	RowID	fuID,
		RowID	pluginID
	)		const

Sets the given cost function plugin for the given FU entry.

Parameters

fuID	ID of the FU entry.
pluginID	ID of the cost function plugin.

Definition at line 1936 of file HDBManager.cc.

                                                                       {
 
    // set the cost function plugin for fu
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE fu SET cost_function=" +
                Conversion::toString(pluginID) + " WHERE id=" +
                Conversion::toString(fuID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetCostFunctionPluginCmd::Do().

Here is the call graph for this function:

◆ setCostFunctionPluginForRF()

void HDB::HDBManager::setCostFunctionPluginForRF	(	RowID	rfID,
		RowID	pluginID
	)		const

Sets the given cost function plugin for the given RF entry.

Parameters

rfID	ID of the RF entry.
pluginID	ID of the cost function plugin.

Definition at line 1979 of file HDBManager.cc.

                                                                       {
 
    // set the cost function plugin for rf
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE rf SET cost_function=" +
                Conversion::toString(pluginID) + " WHERE id=" +
                Conversion::toString(rfID) + ";"));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetCostFunctionPluginCmd::Do().

Here is the call graph for this function:

◆ socketCostEstimationData()

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

Returns socket cost estimation data.

This version assumes that there's only one entry with given parameters.

Parameters

valueName	Name of the value to fetch.
socketID	The ID of the socket entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data.

Exceptions

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

Definition at line 3704 of file HDBManager.cc.

                                       {
    // make the SQL query to obtain implementation data
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND bus_reference IS NULL AND " +
            "     socket_reference = " + 
            Conversion::toString(socketID) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');";
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    if (queryResult->hasNext()) {
        queryResult->next();
        
        DataObject value = queryResult->data("value");
 
        delete queryResult;
        queryResult = NULL;
 
        return value;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by DefaultICDecoderEstimator::delayOfSocket().

Here is the call graph for this function:

◆ socketCostEstimationDataIDs()

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

Returns a set of cost estimation data IDs which reference the given socket entry.

Parameters

socketID ID of the socket entry.

Returns: Set of cost estimation data IDs.

Definition at line 6459 of file HDBManager.cc.

                                                            {
 
    // make the SQL query to obtain IDs.
    RelationalDBQueryResult* queryResult = NULL;
    try {
        std::string theQuery =
            std::string(
                "SELECT id "
                "FROM cost_estimation_data "
                "WHERE socket_reference = ") +
            Conversion::toString(socketID);
 
        queryResult = dbConnection_->query(theQuery);
 
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    } 
 
    std::set<RowID> ids;
 
    while (queryResult->hasNext()) {
        queryResult->next();
 
        ids.insert(queryResult->data("id").integerValue());
    }
 
    delete queryResult;
    queryResult = NULL;
    return ids;
}

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by HDBToHtml::socketEntryToHtml().

Here is the call graph for this function:

◆ socketCostEstimationDataList()

HDBManager::DataObjectList * HDB::HDBManager::socketCostEstimationDataList	(	const std::string &	valueName,
		RowID	socketID,
		const std::string &	pluginName
	)		const

Returns socket cost estimation data.

Parameters

valueName	Name of the value to fetch.
socketID	The ID of the socket entry.
pluginName	Name of the cost estimation plugin that owns the data.

Returns: The data. Becomes property of the caller.

Exceptions

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

Definition at line 3758 of file HDBManager.cc.

                                       {
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(            
            std::string(
                "SELECT value "
                "FROM cost_estimation_data, cost_function_plugin "
                "WHERE plugin_reference = cost_function_plugin.id AND " 
                "cost_function_plugin.name LIKE('") + 
            pluginName + "') " +
            " AND rf_reference IS NULL " +
            " AND bus_reference IS NULL AND " +
            "     socket_reference = " + 
            Conversion::toString(socketID) + 
            " AND cost_estimation_data.name LIKE('" + valueName + "');");
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    if (queryResult->hasNext()) {
     
        DataObjectList* data = new DataObjectList;
   
        while (queryResult->hasNext()) {
            queryResult->next();
            DataObject value = queryResult->data("value");
            data->push_back(value);
        }
 
        delete queryResult;
        queryResult = NULL;
        return data;
    } else {
        delete queryResult;
        throw KeyNotFound(__FILE__, __LINE__, __func__);
    }    
    // silence compiler warning
    throw 1;
}

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ socketEntryByIDQuery()

std::string HDB::HDBManager::socketEntryByIDQuery ( RowID id )

staticprivate

Creates an SQL query for getting the Socket entry that has the given ID.

The result set has fields {id}.

Parameters

id	ID of the entry.

Returns: The SQL query.

Definition at line 5824 of file HDBManager.cc.

                                         {
    string idString = Conversion::toString(id);
    string query =
        "SELECT * "
        "FROM socket "
        "WHERE socket.id=" + idString + ";";
    return query;
}

References Conversion::toString().

Referenced by hasSocketEntry().

Here is the call graph for this function:

◆ socketEntryIDs()

std::set< RowID > HDB::HDBManager::socketEntryIDs ( ) const

Returns a set of Socket entry IDs in the database.

Returns: A set containing all the Socket entry IDs in the database.

Definition at line 2117 of file HDBManager.cc.

                                 {
 
    string query = "SELECT id AS 'socket.id' FROM socket;";
 
    // make the SQL query to obtain all the IDs
    RelationalDBQueryResult* queryResult = NULL;
    try {
        queryResult = dbConnection_->query(query);
    } catch (const Exception& e) {
        // should not throw in any case
        debugLog(e.errorMessage());
        assert(false);        
    }
 
    std::set<RowID> idSet;
    while (queryResult->hasNext()) {
        queryResult->next();
        const DataObject& idData = queryResult->data("socket.id");
        idSet.insert(idData.integerValue());
    }
 
    delete queryResult;
    return idSet;
}   

References assert, RelationalDBQueryResult::data(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by CostDatabase::buildSockets(), CostEstimationDataDialog::onEntryTypeSelection(), and HDBBrowserWindow::update().

Here is the call graph for this function:

◆ unsetArchitectureForFU()

void HDB::HDBManager::unsetArchitectureForFU ( RowID fuID ) const

Unsets the architecture of the given FU entry.

Parameters

fuID	ID of the FU entry.

Exceptions

InvalidData If the HDB does not contain the given FU entry or if the FU entry has an implementation.

Definition at line 1418 of file HDBManager.cc.

                                                   {
    if (!hasFUEntry(fuID)) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    FUEntry* entry = fuByEntryID(fuID);
    if (entry->hasImplementation()) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    // unset the architecture
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE fu SET architecture=NULL WHERE id=" +
                Conversion::toString(fuID)));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), fuByEntryID(), hasFUEntry(), HDB::FUEntry::hasImplementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetFUArchitectureCmd::Do().

Here is the call graph for this function:

◆ unsetArchitectureForRF()

void HDB::HDBManager::unsetArchitectureForRF ( RowID rfID ) const

Unsets architecture of the given RF entry.

Parameters

rfID	ID of the RF entry.

Definition at line 1916 of file HDBManager.cc.

                                                   {
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE rf SET architecture=NULL WHERE id=" +
                Conversion::toString(rfID)));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetRFArchitectureCmd::Do().

Here is the call graph for this function:

◆ unsetCostFunctionPluginForFU()

void HDB::HDBManager::unsetCostFunctionPluginForFU ( RowID fuID ) const

Unsets cost function plugin of the given FU entry.

Parameters

fuID	ID of the FU entry.

Definition at line 1957 of file HDBManager.cc.

                                                         {
 
    // unset the cost function plugin
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE fu SET cost_function=NULL WHERE id=" +
                Conversion::toString(fuID)));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetCostFunctionPluginCmd::Do().

Here is the call graph for this function:

◆ unsetCostFunctionPluginForRF()

void HDB::HDBManager::unsetCostFunctionPluginForRF ( RowID rfID ) const

Unsets cost function plugin of the given RF entry.

Parameters

rfID	ID of the RF entry.

Definition at line 2000 of file HDBManager.cc.

                                                         {
 
    // unset the cost function plugin
    try {
        dbConnection_->updateQuery(
            std::string(
                "UPDATE rf SET cost_function=NULL WHERE id=" +
                Conversion::toString(rfID)));
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        assert(false);
    }
}

References assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SetCostFunctionPluginCmd::Do().

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ HDBManagerTest

friend class HDBManagerTest

friend

Definition at line 84 of file HDBManager.hh.

Member Data Documentation

◆ db_

SQLite* HDB::HDBManager::db_

private

Handle to the database.

Definition at line 400 of file HDBManager.hh.

Referenced by HDBManager(), and ~HDBManager().

◆ dbConnection_

RelationalDBConnection* HDB::HDBManager::dbConnection_

private

Handle to the database connection.

Definition at line 402 of file HDBManager.hh.

◆ hdbFile_

std::string HDB::HDBManager::hdbFile_

private

The HDB file to manager.

Definition at line 404 of file HDBManager.hh.

Referenced by fileName(), fuArchitectureIDsByOperationSet(), fuByEntryID(), and rfByEntryID().

◆ instance_

HDBManager * HDB::HDBManager::instance_ = NULL

staticprivate

Unique instance of the HDBManager.

Definition at line 406 of file HDBManager.hh.

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DataObjectList

◆ PipelineElementUsageTable

Constructor & Destructor Documentation

◆ ~HDBManager()

◆ HDBManager()

Member Function Documentation

◆ addBlockImplementationFiles() [1/2]

◆ addBlockImplementationFiles() [2/2]

◆ addBlockImplementationFileToHDB()

◆ addBooleanColumn()

◆ addBusCostEstimationData()

◆ addBusEntry()

◆ addCostEstimationData()

◆ addCostFunctionPlugin()

◆ addDataPortsToImplementation() [1/2]

◆ addDataPortsToImplementation() [2/2]

◆ addFUArchitecture()

◆ addFUCostEstimationData()

◆ addFUEntry()

◆ addFUExternalPortsToImplementation()

◆ addFUImplementation()

◆ addFUParametersToImplementation()

◆ addOpcodesToImplementation()

◆ addOperationImplementation()

◆ addOperationImplementationResource()

◆ addOperationPipelinesToFUArchitecture()

◆ addPortsAndBindingsToFUArchitecture()

◆ addRFArchitecture()

◆ addRFCostEstimationData()

◆ addRFEntry()

◆ addRFExternalPortsToImplementation()

◆ addRFImplementation()

◆ addRFParametersToImplementation()

◆ addSocketCostEstimationData()

◆ addSocketEntry()

◆ areCompatiblePipelines()

◆ blockSourceFile()

◆ busCostEstimationData()

◆ busCostEstimationDataIDs()

◆ busCostEstimationDataList()

◆ busEntryByIDQuery()

◆ busEntryIDs()

◆ canRemoveFUArchitecture()

◆ canRemoveRFArchitecture()

◆ containsFUArchitecture()

◆ containsImplementationFile()

◆ containsOperation()

◆ containsRFArchitecture()

◆ costEstimationData()

◆ costEstimationDataIDs()

◆ costEstimationDataValue() [1/2]

◆ costEstimationDataValue() [2/2]

◆ costFunctionPluginByID()

◆ costFunctionPluginDataIDs()

◆ costFunctionPluginIDs()

◆ createCostEstimatioDataIdsQuery() [1/2]

◆ createCostEstimatioDataIdsQuery() [2/2]

◆ createCostFunctionOfFU()

◆ createCostFunctionOfRF()

◆ createImplementationOfFU()

◆ createImplementationOfRF()

◆ createNew()

◆ deleteCostEstimationDataIDsQueries()

◆ directionString()

◆ fileFormat()

◆ fileName()

◆ formatString()