#include <DSDBManager.hh>

Collaboration diagram for DSDBManager:

Classes
struct	appComparator

struct	ApplicationData

struct	ConfigurationCosts
	Struct for configuration costs with a specified application. More...

struct	cycleComparator

struct	energyComparator

struct	idComparator

struct	MachineConfiguration

Public Types
enum	Order { ORDER_BY_CONFIGURATION, ORDER_BY_CYCLE_COUNT, ORDER_BY_ENERGY_ESTIMATE, ORDER_BY_APPLICATION }
	Identifiers for ordering results. More...

typedef boost::tuple< RowID, int, ClockCycleCount >	ParetoPointConnectivityAndCycles

typedef std::set< ParetoPointConnectivityAndCycles >	ParetoSetConnectivityAndCycles

Public Member Functions
	DSDBManager (const std::string &file)

virtual	~DSDBManager ()

std::string	dsdbFile () const

RowID	addArchitecture (const TTAMachine::Machine &mom)

RowID	addImplementation (const IDF::MachineImplementation &impl, double longestPathDelay, CostEstimator::AreaInGates area)

RowID	addConfiguration (const MachineConfiguration &conf)

RowID	addApplication (const std::string &path)

void	addEnergyEstimate (RowID application, RowID implementation, double energyEstimate)

void	addCycleCount (RowID application, RowID architecture, ClockCycleCount count)

void	setLongestPathDelayEstimate (RowID implementation, double delay)

void	setAreaEstimate (RowID implementation, CostEstimator::AreaInGates area)

bool	hasApplication (RowID id) const

bool	hasApplication (const std::string &applicationPath) const

void	removeApplication (RowID id)

std::string	applicationPath (RowID id) const

bool	hasArchitecture (RowID id) const

TTAMachine::Machine *	architecture (RowID id) const

RowID	architectureId (const TTAMachine::Machine &mach) const

bool	hasImplementation (RowID id) const

IDF::MachineImplementation *	implementation (RowID id) const

bool	hasConfiguration (RowID id) const

MachineConfiguration	configuration (RowID id) const

RowID	configurationId (const MachineConfiguration &conf) const

void	removeConfiguration (RowID id)

bool	hasEnergyEstimate (RowID application, RowID implementation) const

double	energyEstimate (RowID application, RowID implementation) const

bool	hasCycleCount (RowID application, RowID architecture) const

ClockCycleCount	cycleCount (RowID application, RowID architecture) const

std::vector< ClockCycleCount >	cycleCounts (const MachineConfiguration &conf) const

bool	isUnschedulable (RowID application, RowID architecture) const

void	setUnschedulable (RowID application, RowID architecture)

double	longestPathDelayEstimate (RowID implementation) const

CostEstimator::AreaInGates	areaEstimate (RowID implementation) const

std::set< RowID >	applicationIDs () const

std::set< RowID >	architectureIDs () const

std::set< RowID >	configurationIDs () const

std::set< RowID >	archConfigurationIDs (RowID architectureID) const

void	writeArchitectureToFile (RowID id, const std::string &path) const

void	writeImplementationToFile (RowID id, const std::string &path) const

void	writeConfigurationToFile (const MachineConfiguration &conf, const std::string &path)

std::vector< ConfigurationCosts >	applicationCostEstimatesByConf (Order ordering=ORDER_BY_CONFIGURATION) const

ParetoSetConnectivityAndCycles	paretoSetConnectivityAndCycles (RowID application=ILLEGAL_ROW_ID) const

int	applicationCount () const

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

Private Member Functions
std::string	architectureString (RowID id) const

std::string	implementationString (RowID id) const

Private Attributes
SQLite *	db_
	Handle to the database. More...

RelationalDBConnection *	dbConnection_
	Handle to the database connection. More...

std::string	file_
	The DSDB file containing the current database. More...

Detailed Description

Design space database manager.

Design space database stores information about explored machine configurations for test applications.

The following information can be stored:

Machine architectures.
Implementations for architectures which define a working machine configuration.
Longest path delay estimates for implementations.
Area estimates for implementations.
Test applications for exploration.
Runtimes as clock cycle counts for application-architecture pairs.
Energy estimates for application-implementation pairs.

Definition at line 76 of file DSDBManager.hh.

Member Typedef Documentation

◆ ParetoPointConnectivityAndCycles

typedef boost::tuple<RowID, int, ClockCycleCount> DSDBManager::ParetoPointConnectivityAndCycles

Definition at line 153 of file DSDBManager.hh.

◆ ParetoSetConnectivityAndCycles

typedef std::set<ParetoPointConnectivityAndCycles> DSDBManager::ParetoSetConnectivityAndCycles

Definition at line 156 of file DSDBManager.hh.

Member Enumeration Documentation

◆ Order

enum DSDBManager::Order

Identifiers for ordering results.

Enumerator
ORDER_BY_CONFIGURATION
ORDER_BY_CYCLE_COUNT
ORDER_BY_ENERGY_ESTIMATE
ORDER_BY_APPLICATION

Definition at line 159 of file DSDBManager.hh.

                {
         ORDER_BY_CONFIGURATION,
         ORDER_BY_CYCLE_COUNT,
         ORDER_BY_ENERGY_ESTIMATE,
         ORDER_BY_APPLICATION
     };

Constructor & Destructor Documentation

◆ DSDBManager()

DSDBManager::DSDBManager ( const std::string & file )

The Constructor.

Loads a DSDB from the given file.

Parameters

file	DSDB file to load.

Exceptions

IOException if the DSDB file couldn't be succesfully loaded.

Definition at line 108 of file DSDBManager.cc.

     : db_(new SQLite()), dbConnection_(NULL), file_(file) {
     if (!FileSystem::fileExists(file)) {
         string msg = "File '" + file + "' doesn't exist.";
         throw FileNotFound(__FILE__, __LINE__, __func__, msg);
     }
  
     try {
         dbConnection_ = &db_->connect(file);
     } catch (const RelationalDBException& exception) {
         throw IOException(
             __FILE__, __LINE__, __func__, exception.errorMessage());
     }
 }

References __func__, SQLite::connect(), db_, dbConnection_, Exception::errorMessage(), and FileSystem::fileExists().

Referenced by createNew().

Here is the call graph for this function:

◆ ~DSDBManager()

DSDBManager::~DSDBManager ( )

virtual

The Destructor.

Closes the database connection.

Definition at line 128 of file DSDBManager.cc.

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

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

Here is the call graph for this function:

Member Function Documentation

◆ addApplication()

RowID DSDBManager::addApplication ( const std::string & path )

Adds a new application to the database.

Parameters

path	Path of the application test case.

Returns: RowID of the added application.

Exceptions

InvalidData in case the application dir is not valid.

Definition at line 440 of file DSDBManager.cc.

                                                  {
  
     RowID id = -1;
     try {
         dbConnection_->beginTransaction();
         dbConnection_->updateQuery(
             std::string(
                 "INSERT INTO application(id, path) VALUES"
                 "(NULL,\"" + 
                 // remove trailing file system separator from path
                 ((path.substr(path.length() - 1) 
                   == FileSystem::DIRECTORY_SEPARATOR) ? 
                  path.substr(0,path.length()-1) : 
                  path) + "\");"));
  
         id = 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 id;
 }

References assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, FileSystem::DIRECTORY_SEPARATOR, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), RelationalDBConnection::rollback(), and RelationalDBConnection::updateQuery().

Referenced by main().

Here is the call graph for this function:

◆ addArchitecture()

RowID DSDBManager::addArchitecture ( const TTAMachine::Machine & mom )

Adds machine architecture to the database.

In case an existing equal architecture is found in the DB, does not add a new one, but returns the ID of the old one.

Parameters

mom	Machine architecture to add.

Returns: RowID of the added architecture.

Definition at line 191 of file DSDBManager.cc.

                                                          {
     RowID existing = architectureId(mom);
     if (existing != ILLEGAL_ROW_ID) {
         return existing;
     }    
  
     string adf = "";
     try {
         dbConnection_->beginTransaction();
         ADFSerializer serializer;
         serializer.setDestinationString(adf);
         ObjectState* os = mom.saveState();
         serializer.writeState(os);
         delete os;
         os = NULL;
         
         // limit the size of the adf
         if (adf.size() >= 5000000) {
             RelationalDBException error(
                     __FILE__, __LINE__, __func__,
                     "ADF size too big.");
             throw error;
         }
     } catch (const SerializerException& e) {
         debugLog(e.errorMessage());
         assert(false);
     }
  
     RowID id = -1;
     try {
         dbConnection_->updateQuery(
             (boost::format(
                 "INSERT INTO architecture(id, adf_hash, adf_xml, "
                 "connection_count) VALUES"
                 "(NULL, \'%s\', \'%s\', %d);") %
              mom.hash() % adf % 
              MachineConnectivityCheck::totalConnectionCount(mom)).str());
         id = 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 id;
 }

References __func__, architectureId(), assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), TTAMachine::Machine::hash(), ILLEGAL_ROW_ID, RelationalDBConnection::lastInsertRowID(), RelationalDBConnection::rollback(), TTAMachine::Machine::saveState(), XMLSerializer::setDestinationString(), MachineConnectivityCheck::totalConnectionCount(), RelationalDBConnection::updateQuery(), and ADFSerializer::writeState().

Referenced by Evaluate::createConfig(), MinimalOpSet::createConfig(), BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), MinimizeMachine::evalNewConfigWithoutImplementation(), VLIWConnectIC::explore(), MinimalOpSet::explore(), BlocksConnectIC::explore(), RemoveUnconnectedComponents::explore(), VectorLSGenerator::explore(), GrowMachine::explore(), ComponentAdder::explore(), ImplementationSelector::explore(), ImmediateGenerator::explore(), SimpleICOptimizer::explore(), ADFCombiner::explore(), main(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeRegisterFiles(), and CallExplorerPluginWindow::onRun().

Here is the call graph for this function:

◆ addConfiguration()

RowID DSDBManager::addConfiguration ( const MachineConfiguration & conf )

Adds a new machine configuration to the database.

In case a same configuration found in the DB, reuses that one.

Parameters

conf	Configuration to add.

Returns: RowID of the new configuration.

Exceptions

KeyNotFound if the configuration contained unknown IDs.

Definition at line 299 of file DSDBManager.cc.

                                                               {
     RowID existing = configurationId(conf);
     if (existing != ILLEGAL_ROW_ID) {
         return existing;
     }    
     RowID id = -1;
     if (!hasArchitecture(conf.architectureID)) {
         std::string msg =
             "Architecture with ID " +
             Conversion::toString(conf.architectureID) +
             "not found.";
         throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
     }
  
     if (conf.hasImplementation && !hasImplementation(conf.implementationID)) {
         std::string msg =
             "Implementation with ID " +
             Conversion::toString(conf.implementationID) +
             " not found.";
         throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
     }
  
     try {
         dbConnection_->beginTransaction();
         std::string implID;
         if (conf.hasImplementation) {
             implID = Conversion::toString(conf.implementationID);
         } else {
             implID = "NULL";
         }
  
         dbConnection_->updateQuery(
             std::string(
                 "INSERT INTO machine_configuration("
                 "id, architecture, implementation) VALUES"
                 "(NULL,") +
             Conversion::toString(conf.architectureID) + ", " +
             implID + ");");
  
         id = 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 id;
 }

References __func__, DSDBManager::MachineConfiguration::architectureID, assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), configurationId(), dbConnection_, debugLog, Exception::errorMessage(), hasArchitecture(), DSDBManager::MachineConfiguration::hasImplementation, hasImplementation(), ILLEGAL_ROW_ID, DSDBManager::MachineConfiguration::implementationID, RelationalDBConnection::lastInsertRowID(), RelationalDBConnection::rollback(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), MinimizeMachine::evalNewConfigWithoutImplementation(), VLIWConnectIC::explore(), BlocksConnectIC::explore(), RemoveUnconnectedComponents::explore(), GrowMachine::explore(), VectorLSGenerator::explore(), ComponentAdder::explore(), ImplementationSelector::explore(), ImmediateGenerator::explore(), SimpleICOptimizer::explore(), ADFCombiner::explore(), main(), MinimizeMachine::minimizeBuses(), and CallExplorerPluginWindow::onRun().

Here is the call graph for this function:

◆ addCycleCount()

void DSDBManager::addCycleCount	(	RowID	application,
		RowID	architecture,
		ClockCycleCount	count
	)

Adds cycle count of an application on specific architecture.

Parameters

application	RowID of the application.
architecture	RowID of the machine architecture.
count	Cycle count

Definition at line 583 of file DSDBManager.cc.

                                                                   {
     if (!hasApplication(application)) {
         const std::string error = (boost::format(
             "DSDB file '%s' has no application with id '%d'."
             "Can't add a cycle count.") 
             % file_ % application).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
     if (!hasArchitecture(architecture)) {
         const std::string error = (boost::format(
             "DSDB file '%s' has no architecture with id '%d'."
             "Can't add a cycle count.") 
             % file_ % architecture).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     std::string q =
         "INSERT INTO cycle_count(application, architecture, cycles, "
         "unschedulable) VALUES(" +
         Conversion::toString(application) + ", " +
         Conversion::toString(architecture) + ", " +
         Conversion::toString(count) + ", 0);";
  
     dbConnection_->updateQuery(q);
 }

References __func__, architecture(), dbConnection_, file_, hasApplication(), hasArchitecture(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addEnergyEstimate()

void DSDBManager::addEnergyEstimate	(	RowID	application,
		RowID	implementation,
		double	energyEstimate
	)

Adds an energy estimate for application on specific implementation.

Parameters

application	RowID of the application.
implementation	RowID of the machine implementation.
energy	Application energy estimate as joules.

Definition at line 477 of file DSDBManager.cc.

                                                                     {
     if (!hasApplication(application)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no application with id '%d'."
             "Can't add an energy estimate.") 
             % file_ % application).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
     if (!hasImplementation(implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'."
             "Can't add an energy estimate.") 
             % file_ % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     std::string q =
         "INSERT INTO energy_estimate ("
         "application, implementation, energy_estimate) VALUES(" +
         Conversion::toString(application) + ", " +
         Conversion::toString(implementation) + ", " +
         Conversion::toString(energyEstimate) + ");";
  
     dbConnection_->updateQuery(q);
 }

References __func__, dbConnection_, energyEstimate(), file_, hasApplication(), hasImplementation(), implementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addImplementation()

RowID DSDBManager::addImplementation	(	const IDF::MachineImplementation &	impl,
		double	longestPathDelay,
		CostEstimator::AreaInGates	area
	)

Adds machine implementation to the database.

Parameters

impl	Machine implementation to add.
longestPathDelay	Longest path delay in seconds.
area	Area as number of gates.

Returns: RowID of the added architecture.

Definition at line 252 of file DSDBManager.cc.

                       {
     RowID id = -1;
     try {
         dbConnection_->beginTransaction();
         IDF::IDFSerializer serializer;
         string idf = "";
         serializer.setDestinationString(idf);
         ObjectState* is = impl.saveState();
         serializer.writeState(is);
         delete is;
         is = NULL;
     
         dbConnection_->updateQuery(
             std::string(
                 "INSERT INTO implementation("
                 "id, idf_xml, lpd, area) VALUES"
                 "(NULL,\'" + idf + "\'," +
                 Conversion::toString(longestPathDelay) + ", "+
                 Conversion::toString(area) + ");"));
  
         id = 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 id;
 }

References assert, RelationalDBConnection::beginTransaction(), RelationalDBConnection::commit(), dbConnection_, debugLog, Exception::errorMessage(), RelationalDBConnection::lastInsertRowID(), RelationalDBConnection::rollback(), IDF::MachineImplementation::saveState(), XMLSerializer::setDestinationString(), Conversion::toString(), RelationalDBConnection::updateQuery(), and IDF::IDFSerializer::writeState().

Referenced by Evaluate::createConfig(), MinimalOpSet::createConfig(), RemoveUnconnectedComponents::explore(), ImplementationSelector::explore(), ImmediateGenerator::explore(), main(), MinimizeMachine::minimizeBuses(), and ComponentImplementationSelector::selectComponentsToConf().

Here is the call graph for this function:

◆ applicationCostEstimatesByConf()

std::vector< DSDBManager::ConfigurationCosts > DSDBManager::applicationCostEstimatesByConf ( Order ordering = ORDER_BY_CONFIGURATION ) const

Returs set of ConfigurationCosts ordered by the given ordering.

Parameters

ordering Ordering of the results.

Returns: ConfigurationCosts of all configurations in the DSDB ordered by the given option.

Definition at line 1524 of file DSDBManager.cc.

                                                                 {
  
     RelationalDBQueryResult* appResult = NULL;
     try {
         appResult = dbConnection_->query("select * from application;");
     }
     catch (const Exception& e) {
         delete appResult;
         abortWithError(e.errorMessage());
     }
     vector<ApplicationData> appData;
    
     while (appResult->hasNext()) {
         appResult->next();
         ApplicationData data;
         data.id = appResult->data(0).stringValue();
         data.name = appResult->data(1).stringValue();
         appData.push_back(data);
     }
     delete appResult;
     RelationalDBQueryResult* queryResult = NULL;
     try {
         queryResult = dbConnection_->query(
             "SELECT id from machine_configuration;");
     } catch (const Exception& e) {
         delete queryResult;
         abortWithError(e.errorMessage());
     }
    
     vector<ConfigurationCosts> res;
  
     set<ConfigurationCosts, idComparator> results;
  
     while (queryResult->hasNext()) {
         queryResult->next();
         for (unsigned int i = 0; i < appData.size(); i++) {
             ConfigurationCosts cc;
             cc.configurationID = queryResult->data(0).integerValue();
             cc.application = appData.at(i).name;
             RelationalDBQueryResult* impResult = NULL;
             
             try {
                 impResult = dbConnection_->query(
                     "select lpd, area from implementation, machine_configuration "
                     "where machine_configuration.id=" + queryResult->data(0).stringValue() +
                     " and machine_configuration.implementation = implementation.id limit 1;");
             } catch (const Exception& e) {
                 delete impResult;
                 abortWithError(e.errorMessage());
             }
             if (impResult->hasNext()) {
                 impResult->next();
                 cc.longestPathDelay = impResult->data(0).doubleValue();
                 cc.area = impResult->data(1).doubleValue();
             } else {
                 cc.longestPathDelay = 0.0;
                 cc.area = 0.0;
             }
             RelationalDBQueryResult* energyResult = NULL;
             try {
                 energyResult = dbConnection_->query(
                     "select energy_estimate from energy_estimate, machine_configuration, application "
                     "where application.id=" + appData[i].id + " and machine_configuration.id="
                     + queryResult->data(0).stringValue() + " and machine_configuration.implementation="
                     "energy_estimate.implementation and application.id=energy_estimate.application;");
              } catch (const Exception& e) {
                  delete energyResult;
                  abortWithError(e.errorMessage());
              }
              if (energyResult->hasNext()) {
                  energyResult->next();
                  cc.energyEstimate = energyResult->data(0).doubleValue();
              } else {
                  cc.energyEstimate = 0.0;
              }
              delete energyResult;
  
              RelationalDBQueryResult* cycleResult = NULL;
              try {
                  cycleResult = dbConnection_->query(
                      "select cycles from cycle_count, application, machine_configuration where application.id="
                      + appData.at(i).id + " and machine_configuration.id=" + 
                      queryResult->data(0).stringValue() +
                      " and machine_configuration.architecture=cycle_count.architecture and application.id="
                      "cycle_count.application;");
              } catch (const Exception& e) {
                  delete cycleResult;
                  abortWithError(e.errorMessage());
              }
              if (cycleResult->hasNext()) {
                  cycleResult->next();
                  cc.cycleCount = cycleResult->data(0).integerValue();
              } else {
                  cc.cycleCount = 0;
              }
              delete cycleResult;
             
              results.insert(cc);
          }
      }   
      delete queryResult;   
      if (ordering == ORDER_BY_CYCLE_COUNT) {
          set<ConfigurationCosts, cycleComparator> cycleResults;
          for (set<ConfigurationCosts, idComparator>::iterator i = results.begin(); i != results.end(); i++) {
              cycleResults.insert(*i);
          }
         
          for (set<ConfigurationCosts, cycleComparator>::iterator i = cycleResults.begin(); i != cycleResults.end(); i++) {
              res.push_back(*i);
          }
          return res;
     } else if (ordering == ORDER_BY_APPLICATION) {
         set<ConfigurationCosts, appComparator> appResults;
         for (set<ConfigurationCosts, idComparator>::iterator i = results.begin(); i != results.end(); i++) {
            appResults.insert(*i);
         }
         for (set<ConfigurationCosts, appComparator>::iterator i = appResults.begin(); i != appResults.end(); i++) {
             res.push_back(*i);
         }
     } else if (ordering == ORDER_BY_ENERGY_ESTIMATE) {
         set<ConfigurationCosts, energyComparator> energyResults;
         for (set<ConfigurationCosts, idComparator>::iterator i = results.begin(); i != results.end(); i++) {
            energyResults.insert(*i);
         }
         for (set<ConfigurationCosts, energyComparator>::iterator i = energyResults.begin(); i != energyResults.end(); i++) {
             res.push_back(*i);
         }
     } else {
         for (set<ConfigurationCosts, idComparator>::iterator i = results.begin(); i != results.end(); i++) {
             res.push_back(*i);
         }
     }
    
     return res;
 }

References abortWithError, DSDBManager::ConfigurationCosts::application, DSDBManager::ConfigurationCosts::area, DSDBManager::ConfigurationCosts::configurationID, DSDBManager::ConfigurationCosts::cycleCount, RelationalDBQueryResult::data(), dbConnection_, DataObject::doubleValue(), DSDBManager::ConfigurationCosts::energyEstimate, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DSDBManager::ApplicationData::id, DataObject::integerValue(), DSDBManager::ConfigurationCosts::longestPathDelay, DSDBManager::ApplicationData::name, RelationalDBQueryResult::next(), ORDER_BY_APPLICATION, ORDER_BY_CYCLE_COUNT, ORDER_BY_ENERGY_ESTIMATE, RelationalDBConnection::query(), and DataObject::stringValue().

Referenced by main().

Here is the call graph for this function:

◆ applicationCount()

int DSDBManager::applicationCount ( ) const

Returns the number of applications in the dsdb.

Returns: The number of applications in the dsdb.

Definition at line 1666 of file DSDBManager.cc.

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

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

Referenced by main().

Here is the call graph for this function:

◆ applicationIDs()

std::set< RowID > DSDBManager::applicationIDs ( ) const

Returns IDs of all applications in the database.

Returns: RowIDs of all applications in the database.

Definition at line 1381 of file DSDBManager.cc.

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

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

Referenced by cycleCounts(), ConnectionSweeper::explore(), SimpleICOptimizer::explore(), FrequencySweepExplorer::fastEnough(), main(), MinimizeMachine::minimizeMachine(), and paretoSetConnectivityAndCycles().

Here is the call graph for this function:

◆ applicationPath()

std::string DSDBManager::applicationPath ( RowID id ) const

Returns path of an application with the given ID.

Parameters

id	RowID of the application test case.

Returns: Path of the application test case.

Definition at line 947 of file DSDBManager.cc.

                                            {
     if (!hasApplication(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no application with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
     try {
         result = dbConnection_->query(
             "SELECT path FROM application WHERE id=" +
             Conversion::toString(id) + ";");
     } catch (const Exception& e) {
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         abortWithError("No rows in result!");
     }
  
     result->next();
     const std::string path = result->data(0).stringValue();
     delete result;
     return path;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), file_, hasApplication(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by SimpleICOptimizer::explore(), FrequencySweepExplorer::fastEnough(), hasApplication(), main(), and MinimizeMachine::minimizeMachine().

Here is the call graph for this function:

◆ archConfigurationIDs()

std::set< RowID > DSDBManager::archConfigurationIDs ( RowID architectureID ) const

Returns IDs of all configurations referencing the given architecture.

Parameters

architectureID ID of the architecture to search configurations for.

Returns: Configuration IDs of a machine architecture.

Definition at line 1487 of file DSDBManager.cc.

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

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

Here is the call graph for this function:

◆ architecture()

TTAMachine::Machine * DSDBManager::architecture ( RowID id ) const

Returns machine architecture with the given id.

Parameters

id	RowID of the machine architecture.

Returns: Machine object model of the architecture.

Definition at line 807 of file DSDBManager.cc.

                                         {
     const std::string adf = architectureString(id);
     ADFSerializer serializer;
     serializer.setSourceString(adf);
     ObjectState* state = serializer.readState();
     TTAMachine::Machine* mach = new TTAMachine::Machine();
     mach->loadState(state);
     delete state;
  
     return mach;
 }

References architectureString(), TTAMachine::Machine::loadState(), ADFSerializer::readState(), and XMLSerializer::setSourceString().

Referenced by addCycleCount(), cycleCount(), BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), VLIWConnectIC::explore(), MinimalOpSet::explore(), BlocksConnectIC::explore(), RemoveUnconnectedComponents::explore(), VectorLSGenerator::explore(), GrowMachine::explore(), ComponentAdder::explore(), ImplementationSelector::explore(), ConnectionSweeper::explore(), ImmediateGenerator::explore(), SimpleICOptimizer::explore(), ADFCombiner::explore(), hasCycleCount(), isUnschedulable(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeRegisterFiles(), CallExplorerPluginWindow::onRun(), ComponentImplementationSelector::selectComponentsToConf(), and setUnschedulable().

Here is the call graph for this function:

◆ architectureId()

RowID DSDBManager::architectureId ( const TTAMachine::Machine & mach ) const

Returns the row ID of the given architecture.

Searches for the architecture using its Machine::hash() string. e

Parameters

id	RowID of the machine architecture. ILLEGAL_ROW_ID, if not found.

Returns: The architecture ID.

Definition at line 705 of file DSDBManager.cc.

                                                                {
  
     RelationalDBQueryResult* result = NULL;
     try {
         result = dbConnection_->query(
             TCEString("SELECT id FROM architecture WHERE adf_hash = \'") +
             mach.hash() + "\';");
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         return ILLEGAL_ROW_ID;
     }
  
     result->next();
     const DataObject& data = result->data(0);
  
     int id = data.integerValue();
     delete result;
     return id;
 }

References abortWithError, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), TTAMachine::Machine::hash(), RelationalDBQueryResult::hasNext(), ILLEGAL_ROW_ID, DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by addArchitecture().

Here is the call graph for this function:

◆ architectureIDs()

std::set< RowID > DSDBManager::architectureIDs ( ) const

Returns IDs of all machine architectures in the database.

Returns: RowIDs of all architectures in the database.

Definition at line 1416 of file DSDBManager.cc.

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

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

Here is the call graph for this function:

◆ architectureString()

std::string DSDBManager::architectureString ( RowID id ) const

private

Returns the machine architecture of the given id as string.

Parameters

id	RowID of the machine architecture.

Returns: The architecture as string.

Definition at line 665 of file DSDBManager.cc.

                                               {
     if (!hasArchitecture(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no architecture with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
     try {
         result = dbConnection_->query(
             "SELECT adf_xml FROM architecture WHERE id=" +
             Conversion::toString(id) + ";");
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& adfData = result->data(0);
  
     std::string arch = adfData.stringValue();
     delete result;
     return arch;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), file_, hasArchitecture(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by architecture(), and writeArchitectureToFile().

Here is the call graph for this function:

◆ areaEstimate()

AreaInGates DSDBManager::areaEstimate ( RowID implementation ) const

Returns area estimate for an specific implementation.

Parameters

implementation RowID of the machine implementation.

Returns: Area estimate in gates.

Exceptions

KeyNotFound If the implementation was not found in DB.

Definition at line 1343 of file DSDBManager.cc.

                                                     {
     if (!hasImplementation(implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'.") 
             % file_ % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT area FROM implementation WHERE id=" +
             Conversion::toString(implementation) + ";");
  
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& data = result->data(0);
     AreaInGates area = data.integerValue();
     delete result;
     return area;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), file_, hasImplementation(), RelationalDBQueryResult::hasNext(), implementation(), DataObject::integerValue(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by setAreaEstimate().

Here is the call graph for this function:

◆ configuration()

DSDBManager::MachineConfiguration DSDBManager::configuration ( RowID id ) const

Returns machine configuration with the give ID.

Parameters

id	ID of the machine configuration to return.

Returns: Machine configuration with the give ID.

Exceptions

KeyNotFound If a configuration with the given ID was not found.

Definition at line 361 of file DSDBManager.cc.

                                          {
     if (!hasConfiguration(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no configuration with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT architecture, implementation FROM "
             "machine_configuration WHERE id=" +
             Conversion::toString(id) + ";");
  
     } catch (const Exception& e) {
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         abortWithError("No rows in result!");
     }
  
     result->next();
     MachineConfiguration conf;
     conf.architectureID = result->data(0).integerValue();
     if (result->data(1).isNull()) {
         conf.hasImplementation = false;
         conf.implementationID = -1;
     } else {
         conf.hasImplementation = true;
         conf.implementationID = result->data(1).integerValue();
     }
     delete result;
     return conf;
 }

References __func__, abortWithError, DSDBManager::MachineConfiguration::architectureID, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), file_, hasConfiguration(), DSDBManager::MachineConfiguration::hasImplementation, RelationalDBQueryResult::hasNext(), DSDBManager::MachineConfiguration::implementationID, DataObject::integerValue(), DataObject::isNull(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by FrequencySweepExplorer::callPlugin(), Evaluate::explore(), VLIWConnectIC::explore(), MinimalOpSet::explore(), BlocksConnectIC::explore(), RemoveUnconnectedComponents::explore(), GrowMachine::explore(), VectorLSGenerator::explore(), ComponentAdder::explore(), ImplementationSelector::explore(), ConnectionSweeper::explore(), ImmediateGenerator::explore(), SimpleICOptimizer::explore(), FrequencySweepExplorer::fastEnough(), main(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeMachine(), and MinimizeMachine::minimizeRegisterFiles().

Here is the call graph for this function:

◆ configurationId()

RowID DSDBManager::configurationId ( const MachineConfiguration & conf ) const

Returns the row ID of the given configuration.

Parameters

id	RowID of the configuration. ILLEGAL_ROW_ID, if not found.

Returns: The configuration ID.

Definition at line 762 of file DSDBManager.cc.

                                                                    {
  
     RelationalDBQueryResult* result = NULL;
     try {
         TCEString queryStr;
         if (conf.hasImplementation) {
             queryStr =
                 (boost::format(
                     "SELECT id FROM machine_configuration "
                     "WHERE architecture = %d AND implementation = %d;")
                  % conf.architectureID % conf.implementationID).str();
         } else {
             queryStr =
                 (boost::format(
                     "SELECT id FROM machine_configuration "
                     "WHERE architecture = %d AND implementation IS NULL;")
                  % conf.architectureID).str();
         }
         result = dbConnection_->query(queryStr);
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         return ILLEGAL_ROW_ID;
     }
  
     result->next();
     const DataObject& data = result->data(0);
  
     int id = data.integerValue();
     delete result;
     return id;
 }

References abortWithError, DSDBManager::MachineConfiguration::architectureID, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), DSDBManager::MachineConfiguration::hasImplementation, RelationalDBQueryResult::hasNext(), ILLEGAL_ROW_ID, DSDBManager::MachineConfiguration::implementationID, DataObject::integerValue(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by addConfiguration().

Here is the call graph for this function:

◆ configurationIDs()

std::set< RowID > DSDBManager::configurationIDs ( ) const

Returns IDs of all machine configurations in the database.

Returns: RowIDs of all configurations in the database.

Definition at line 1451 of file DSDBManager.cc.

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

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

Referenced by main().

Here is the call graph for this function:

◆ createNew()

DSDBManager * DSDBManager::createNew ( const std::string & file )

static

Creates a new DSDB file, and a DSDB manager for it.

Parameters

file	Full path to the DSDB file to create.

Returns: An instance of DSDBManager with the newly created empty DSDB.

Exceptions

IOException if the DSDB file creation was not succesful.

Definition at line 141 of file DSDBManager.cc.

                                             {
     if (!FileSystem::fileIsCreatable(file)) {
         const string procName = "DSDBManager::createNew";
         throw IOException(__FILE__, __LINE__, procName);
     }
  
     try {
         SQLite db;
         RelationalDBConnection& connection = db.connect(file);
     
         // create tables to the database
         connection.DDLQuery(CREATE_ARCH_TABLE);
         connection.DDLQuery(CREATE_IMPL_TABLE);
         connection.DDLQuery(CREATE_MACHINE_CFG_TABLE);
         connection.DDLQuery(CREATE_APPLICATION_TABLE);
         connection.DDLQuery(CREATE_CYCLE_COUNT_TABLE);
         connection.DDLQuery(CREATE_ENERGY_ESTIMATE_TABLE);
  
         db.close(connection);
     } catch (const Exception& e) {
         debugLog(
             std::string("Initialization of DSDB failed. ") + 
             e.errorMessage());
         std::cerr << e.errorMessage() << std::endl;
         assert(false);
     }
         
     return new DSDBManager(file);
 }

References assert, SQLite::close(), SQLite::connect(), CREATE_APPLICATION_TABLE, CREATE_ARCH_TABLE, CREATE_CYCLE_COUNT_TABLE, CREATE_ENERGY_ESTIMATE_TABLE, CREATE_IMPL_TABLE, CREATE_MACHINE_CFG_TABLE, RelationalDBConnection::DDLQuery(), debugLog, DSDBManager(), Exception::errorMessage(), and FileSystem::fileIsCreatable().

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), loadDSDB(), and CallExplorerPluginWindow::onRun().

Here is the call graph for this function:

◆ cycleCount()

ClockCycleCount DSDBManager::cycleCount	(	RowID	application,
		RowID	architecture
	)		const

Returns cycle count for an application on specific architecture.

Parameters

application	RowID of the application.
architecture	RowID of the architecture.

Returns: Cycle count in cycles.

Exceptions

KeyNotFound If cycle count was not found in DB.

Definition at line 1261 of file DSDBManager.cc.

                                                                    {
     if (!hasCycleCount(application, architecture)) {
         const std::string error = (boost::format(
             "No cycle count found for application in DSDB file '%s'") 
             % file_).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT cycles FROM cycle_count WHERE application=" +
             Conversion::toString(application) + " AND architecture=" +
             Conversion::toString(architecture) + ";");
  
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& data = result->data(0);
     ClockCycleCount count = static_cast<ClockCycleCount>(data.doubleValue());
     delete result;
     result = NULL;
     return count;
 }

References __func__, abortWithError, architecture(), RelationalDBQueryResult::data(), dbConnection_, DataObject::doubleValue(), Exception::errorMessage(), file_, hasCycleCount(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by cycleCounts(), ConnectionSweeper::explore(), and FrequencySweepExplorer::fastEnough().

Here is the call graph for this function:

◆ cycleCounts()

std::vector< ClockCycleCount > DSDBManager::cycleCounts ( const MachineConfiguration & conf ) const

Returns the cycle counts for the given configuration for all applications, if known.

Returns: The cycle counts ordered by the application order. Empty if at least one application missed a cycle count.

Definition at line 738 of file DSDBManager.cc.

                                                                {
  
     std::vector<ClockCycleCount> ccs;    
     std::set<RowID> appIds = applicationIDs();
     for (std::set<RowID>::const_iterator appI = appIds.begin(); 
          appI != appIds.end(); ++appI) {
         RowID appID = *appI;
         if (!hasCycleCount(appID, conf.architectureID)) {
             ccs.clear();
             return ccs;
         }
         ccs.push_back(cycleCount(appID, conf.architectureID));
     }   
     return ccs;
 }

References applicationIDs(), DSDBManager::MachineConfiguration::architectureID, cycleCount(), and hasCycleCount().

Here is the call graph for this function:

◆ dsdbFile()

std::string DSDBManager::dsdbFile ( ) const

Returns absolute path of the database file.

Returns: Database file path.

Definition at line 177 of file DSDBManager.cc.

                             {
     return FileSystem::absolutePathOf(file_);
 }

References FileSystem::absolutePathOf(), and file_.

Here is the call graph for this function:

◆ energyEstimate()

double DSDBManager::energyEstimate	(	RowID	application,
		RowID	implementation
	)		const

Returns energy estimate for an application on specific implementation.

Parameters

application	RowID of the application.
implementation	RowID of the implementation.

Returns: Energy estimate in joules.

Exceptions

KeyNotFound If an energy estimate was not found.

Definition at line 1187 of file DSDBManager.cc.

                                                                          {
     if (!hasEnergyEstimate(application, implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no energy estimate with an application id "
             "'%d', and with an implementation id '%d'.") 
             % file_ % application % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT energy_estimate FROM energy_estimate WHERE application=" +
             Conversion::toString(application) + " AND implementation=" +
             Conversion::toString(implementation) + ";");
  
     } catch (const Exception& e) {
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& data = result->data(0);
     double energyEstimate = data.doubleValue();
     delete result;
     return energyEstimate;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, DataObject::doubleValue(), Exception::errorMessage(), file_, hasEnergyEstimate(), RelationalDBQueryResult::hasNext(), implementation(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Referenced by addEnergyEstimate().

Here is the call graph for this function:

◆ hasApplication() [1/2]

bool DSDBManager::hasApplication ( const std::string & applicationPath ) const

Checks if the database contains application with the given application path.

Parameters

applicationPath Path of the application.

Returns: True, if an application with the given path exists in the DB.

Definition at line 1041 of file DSDBManager.cc.

                                                                   {
  
     RelationalDBQueryResult* result = NULL;
     try {
         result = dbConnection_->query(
             "SELECT * FROM application WHERE path='" +
             // remove trailing file system separator from path
             ((applicationPath.substr(applicationPath.length() - 1) 
               == FileSystem::DIRECTORY_SEPARATOR) ? 
              applicationPath.substr(0,applicationPath.length()-1) : 
              applicationPath) + "';");
     } catch (Exception&) {
         assert(false);
     }
  
     if (result->hasNext()) {
         delete result;
         return true;
     } else {
         delete result;
         return false;
     }
 }

References applicationPath(), assert, dbConnection_, FileSystem::DIRECTORY_SEPARATOR, RelationalDBQueryResult::hasNext(), and RelationalDBConnection::query().

Here is the call graph for this function:

◆ hasApplication() [2/2]

bool DSDBManager::hasApplication ( RowID id ) const

Checks if the database contains application with the given RowID.

Parameters

id	ID of the application.

Returns: True, if an application with the given ID exists in the DB.

Definition at line 1013 of file DSDBManager.cc.

                                           {
  
     RelationalDBQueryResult* result = NULL;
     
     try {
         result = dbConnection_->query(
             "SELECT path FROM application WHERE id=" +
             Conversion::toString(id) + ";");
     } catch (Exception&) {
         assert(false);
     }
  
     if (result->hasNext()) {
         delete result;
         return true;
     } else {
         delete result;
         return false;
     }
 }

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

Referenced by addCycleCount(), addEnergyEstimate(), applicationPath(), main(), removeApplication(), and setUnschedulable().

Here is the call graph for this function:

◆ hasArchitecture()

bool DSDBManager::hasArchitecture ( RowID id ) const

Checks if the database contains architecture with the given RowID.

Parameters

id	ID of the architecture.

Returns: True, if an architecture with the given ID exists in the DB.

Definition at line 1101 of file DSDBManager.cc.

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

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

Referenced by addConfiguration(), addCycleCount(), architectureString(), and setUnschedulable().

Here is the call graph for this function:

◆ hasConfiguration()

bool DSDBManager::hasConfiguration ( RowID id ) const

Checks if the database contains configuration with the given RowID.

Parameters

id	ID of the configuration.

Returns: True, if a configuration with the given ID exists in the DB.

Definition at line 1129 of file DSDBManager.cc.

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

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

Referenced by configuration(), main(), and removeConfiguration().

Here is the call graph for this function:

◆ hasCycleCount()

bool DSDBManager::hasCycleCount	(	RowID	application,
		RowID	architecture
	)		const

Checks if cycle count exists for an application and architecture with given IDs.

Parameters

application	ID of the application.
architecture	ID of the machine architecture

Returns: True, if a cycle count exists in the DB.

Definition at line 1228 of file DSDBManager.cc.

                                                                       {
  
     RelationalDBQueryResult* result = NULL;
     
     try {
         result = dbConnection_->query(
             "SELECT cycles FROM cycle_count WHERE cycles IS NOT NULL AND "
             " application=" +
             Conversion::toString(application) + " AND " +
             "architecture=" + Conversion::toString(architecture) + ";");
     } catch (Exception&) {
         assert(false);
     }
  
     if (result->hasNext()) {
         delete result;
         return true;
     } else {
         delete result;
         return false;
     }
 }

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

Referenced by cycleCount(), cycleCounts(), and ConnectionSweeper::explore().

Here is the call graph for this function:

◆ hasEnergyEstimate()

bool DSDBManager::hasEnergyEstimate	(	RowID	application,
		RowID	implementation
	)		const

Checks if energy estimate exists for an application and implementation with given IDs.

Parameters

application	ID of the application.
implementation	ID of the machine implementation.

Returns: True, if an energy estimate exists in the DB.

Definition at line 983 of file DSDBManager.cc.

           {
  
     RelationalDBQueryResult* result = NULL;
     
     try {
         result = dbConnection_->query(
             "SELECT energy_estimate FROM energy_estimate WHERE application=" +
             Conversion::toString(application) + " AND " +
             "implementation=" + Conversion::toString(implementation) + ";");
     } catch (Exception&) {
         assert(false);
     }
  
     if (result->hasNext()) {
         delete result;
         return true;
     } else {
         delete result;
         return false;
     }
 }

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

Referenced by energyEstimate().

Here is the call graph for this function:

◆ hasImplementation()

bool DSDBManager::hasImplementation ( RowID id ) const

Checks if the database contains implementation with the given RowID.

Parameters

id	ID of the implementation

Returns: True, if implementation with the given ID exists in the DB.

Definition at line 1157 of file DSDBManager.cc.

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

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

Referenced by addConfiguration(), addEnergyEstimate(), areaEstimate(), implementationString(), longestPathDelayEstimate(), setAreaEstimate(), and setLongestPathDelayEstimate().

Here is the call graph for this function:

◆ implementation()

IDF::MachineImplementation * DSDBManager::implementation ( RowID id ) const

Returns machine implementation with the given id.

Parameters

id	RowID of the machine implementation.

Returns: MachineImplementation object containing the implementation.

Definition at line 887 of file DSDBManager.cc.

                                           {
     const std::string idf = implementationString(id);
     IDF::IDFSerializer serializer;
     serializer.setSourceString(idf);
     ObjectState* state = serializer.readState();
     IDF::MachineImplementation* impl = new IDF::MachineImplementation();
     impl->loadState(state);
     delete state;
  
     return impl;
 }

References implementationString(), IDF::MachineImplementation::loadState(), IDF::IDFSerializer::readState(), and XMLSerializer::setSourceString().

Referenced by addEnergyEstimate(), areaEstimate(), energyEstimate(), RemoveUnconnectedComponents::explore(), ImmediateGenerator::explore(), hasEnergyEstimate(), longestPathDelayEstimate(), MinimizeMachine::minimizeBuses(), setAreaEstimate(), and setLongestPathDelayEstimate().

Here is the call graph for this function:

◆ implementationString()

std::string DSDBManager::implementationString ( RowID id ) const

private

Returns machine implementation with the given id as string.

Parameters

id	RowID of the machine implementation.

Returns: The implementation as string.

Definition at line 847 of file DSDBManager.cc.

                                                 {
     if (!hasImplementation(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT idf_xml FROM implementation WHERE id=" +
             Conversion::toString(id) + ";");
  
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& idfData = result->data(0);
  
     std::string implString = idfData.stringValue(); 
     delete result;
     return implString;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), file_, hasImplementation(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), DataObject::stringValue(), and Conversion::toString().

Referenced by implementation(), and writeImplementationToFile().

Here is the call graph for this function:

◆ isUnschedulable()

bool DSDBManager::isUnschedulable	(	RowID	application,
		RowID	architecture
	)		const

Checks if the application has been scheduled for the given architecture previously unsuccessfully.

Parameters

application	RowID of the application.
architecture	RowID of the machine architecture.

Returns: True, if it's known that the application is unschedulable for the given architecture.

Definition at line 550 of file DSDBManager.cc.

                                                  {
  
     RelationalDBQueryResult* result = NULL;
     
     try {
         result = dbConnection_->query(
             "SELECT unschedulable FROM cycle_count WHERE application=" +
             Conversion::toString(application) + " AND " +
             "architecture=" + Conversion::toString(architecture) + " "
             "AND unschedulable = 1;");
     } catch (Exception& e) {
         abortWithError(e.errorMessage());
     }
  
     if (result->hasNext()) {
         delete result;
         return true;
     } else {
         delete result;
         return false;
     }
 }

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

Here is the call graph for this function:

◆ longestPathDelayEstimate()

double DSDBManager::longestPathDelayEstimate ( RowID implementation ) const

Returns longest path delay estimate for an specific implementation.

Parameters

implementation RowID of the machine implementation.

Returns: Longest path delay in nanoseconds.

Exceptions

KeyNotFound If the implmentation was not found in DB.

Definition at line 1303 of file DSDBManager.cc.

                                                                 {
     if (!hasImplementation(implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'.") 
             % file_ % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     RelationalDBQueryResult* result = NULL;
  
     try {
         result = dbConnection_->query(
             "SELECT lpd FROM implementation WHERE id=" +
             Conversion::toString(implementation) + ";");
  
     } catch (const Exception& e) {
         delete result;
         abortWithError(e.errorMessage());
     }
  
     if (!result->hasNext()) {
         delete result;
         abortWithError("No rows in result!");
     }
  
     result->next();
     const DataObject& data = result->data(0);
     double delay = data.doubleValue();
     delete result;
     return delay;
 }

References __func__, abortWithError, RelationalDBQueryResult::data(), dbConnection_, DataObject::doubleValue(), Exception::errorMessage(), file_, hasImplementation(), RelationalDBQueryResult::hasNext(), implementation(), RelationalDBQueryResult::next(), RelationalDBConnection::query(), and Conversion::toString().

Here is the call graph for this function:

◆ paretoSetConnectivityAndCycles()

DSDBManager::ParetoSetConnectivityAndCycles DSDBManager::paretoSetConnectivityAndCycles ( RowID application = ILLEGAL_ROW_ID ) const

Finds a pareto set of configurations using the connection count and the cycle count of the given application as criteria.

Definition at line 1697 of file DSDBManager.cc.

                                                                    {
  
     if (application == ILLEGAL_ROW_ID) {
         std::set<RowID> ids = applicationIDs();
         assert(ids.size() == 1);
         application = *ids.begin();
     } 
  
     ParetoSetConnectivityAndCycles paretoSet;
  
     // make the SQL query to obtain IDs.
     RelationalDBQueryResult* queryResult = NULL;
     TCEString theQuery;
     try {
         theQuery =
             (boost::format(
                 "SELECT machine_configuration.id AS id, connection_count, "
                 "       cycles "
                 "FROM application, architecture, machine_configuration, "
                 "     cycle_count "
                 "WHERE machine_configuration.architecture = "
                 "      cycle_count.architecture AND "
                 "      cycle_count.unschedulable = 0 AND "
                 "      cycle_count.cycles IS NOT NULL AND "
                 "      cycle_count.application = %d AND "
                 "      architecture.id = cycle_count.architecture;") %
              application).str();
  
         queryResult = dbConnection_->query(theQuery);
  
     } catch (const Exception& e) {
         // should not throw in any case
         delete queryResult;
         abortWithError(TCEString("FAIL: ") + theQuery + ": " + e.errorMessage());
     }
  
     while (queryResult->hasNext()) {
         queryResult->next();
         ParetoPointConnectivityAndCycles newPoint = 
             boost::make_tuple(
                 queryResult->data(0).integerValue(),
                 queryResult->data(1).integerValue(),
                 queryResult->data(2).integerValue());
         // go through the old pareto sets and remove those that are
         // dominated by the new point, in case at least one point that
         // dominates this point is found, do not add the point
         bool dominated = false;
         for (ParetoSetConnectivityAndCycles::iterator i = paretoSet.begin();
              i != paretoSet.end(); ) {
             ParetoPointConnectivityAndCycles oldPoint = *i;
             if (newPoint.get<1>() <= oldPoint.get<1>() &&
                 newPoint.get<2>() <= oldPoint.get<2>() &&
                 (newPoint.get<1>() < oldPoint.get<1>() ||
                  newPoint.get<2>() < oldPoint.get<2>())) {
                 // newPoint dominates the oldPoint, remove the oldPoint
                 paretoSet.erase(i++);
                 continue;
             } else if (oldPoint.get<1>() <= newPoint.get<1>() &&
                        oldPoint.get<2>() <= newPoint.get<2>() &&
                        (oldPoint.get<1>() < newPoint.get<1>() ||
                         oldPoint.get<2>() < newPoint.get<2>())) {
                 // there was an old point in the set that dominates this one,
                 // we cannot add it to the set but we should look for other
                 // points this point could dominate
                 dominated = true;
             } 
             i++;
         }
         if (!dominated) paretoSet.insert(newPoint);
  
     }
     delete queryResult;
     return paretoSet;
 }

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

Referenced by printParetoSet().

Here is the call graph for this function:

◆ removeApplication()

void DSDBManager::removeApplication ( RowID id )

Removes the application that has the given ID.

Parameters

id	Application ID to remove.

Exceptions

KeyNotFound If the application ID was not found in the database.

Definition at line 1071 of file DSDBManager.cc.

                                        {
     if (!hasApplication(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no application with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     try {
         dbConnection_->beginTransaction();
         dbConnection_->updateQuery(
             std::string(
                 "DELETE FROM application "
                 "WHERE id=" + Conversion::toString(id) + ";"));
  
         dbConnection_->commit();
     } catch (const Exception& e) {
         dbConnection_->rollback();
         debugLog(e.errorMessage());
         assert(false);
     }
 }

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

Referenced by main().

Here is the call graph for this function:

◆ removeConfiguration()

void DSDBManager::removeConfiguration ( RowID id )

Removes configuration with the give ID from the database.

Arhcitecture and implementation that are referenced by the configuration are not removed.

Parameters

id	ID of the configuration to remove.

Exceptions

KeyNotFound If a configuration ID was not found in the database.

Definition at line 409 of file DSDBManager.cc.

                                          {
     if (!hasConfiguration(id)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no configuration with id '%d'.") 
             % file_ % id).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     try {
         dbConnection_->beginTransaction();
         dbConnection_->updateQuery(
             std::string(
                 "DELETE FROM machine_configuration "
                 "WHERE id=" + Conversion::toString(id) + ";"));
  
         dbConnection_->commit();
     } catch (const Exception& e) {
         dbConnection_->rollback();
         debugLog(e.errorMessage());
         assert(false);
     }
 }

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

Here is the call graph for this function:

◆ setAreaEstimate()

void DSDBManager::setAreaEstimate	(	RowID	implementation,
		CostEstimator::AreaInGates	area
	)

Sets the area estimate for an implementation.

Parameters

implementation	RowID of the machine implementation.
area	Implementation area estimate in gates.

Definition at line 641 of file DSDBManager.cc.

                                                                            {
     if (!hasImplementation(implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'.") 
             % file_ % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     std::string q =
         "UPDATE implementation SET "
         "area=" +
         Conversion::toString(areaEstimate) + " WHERE implementation.id=" +
         Conversion::toString(implementation) + ";";        
  
     dbConnection_->updateQuery(q);
 }

References __func__, areaEstimate(), dbConnection_, file_, hasImplementation(), implementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ setLongestPathDelayEstimate()

void DSDBManager::setLongestPathDelayEstimate	(	RowID	implementation,
		double	delay
	)

Sets the longest path delay estimate for an implementation.

Parameters

implementation	RowID of the machine implementation.
delay	Longest path delay estimate of implementation in nanoseconds.

Definition at line 617 of file DSDBManager.cc.

                                                                            {
     if (!hasImplementation(implementation)) {
         const std::string error = (boost::format(
             "DSDP file '%s' has no implementation with id '%d'.") 
             % file_ % implementation).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     std::string q =
         "UPDATE implementation SET "
         "lpd=" +
         Conversion::toString(delay) + " WHERE implementation.id=" +
         Conversion::toString(implementation) + ";";
  
     dbConnection_->updateQuery(q);
 }

References __func__, dbConnection_, file_, hasImplementation(), implementation(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ setUnschedulable()

void DSDBManager::setUnschedulable	(	RowID	application,
		RowID	architecture
	)

Sets the application to be unschedulable for an architecture, thus cycle count nor further estimation could not be done.

This is saved to the DB so future evaluations of the same architecture can be skipped.

Parameters

application	RowID of the application.
architecture	RowID of the machine architecture.

Definition at line 515 of file DSDBManager.cc.

                                                                    {
     if (!hasApplication(application)) {
         const std::string error = (boost::format(
             "DSDB file '%s' has no application with id '%d'."
             "Can't add a cycle count.") 
             % file_ % application).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
     if (!hasArchitecture(architecture)) {
         const std::string error = (boost::format(
             "DSDB file '%s' has no architecture with id '%d'."
             "Can't add a cycle count.") 
             % file_ % architecture).str();
         throw KeyNotFound(__FILE__, __LINE__, __func__, error);
     }
  
     std::string q =
         "INSERT INTO cycle_count(application, architecture, "
         "unschedulable) VALUES(" +
         Conversion::toString(application) + ", " +
         Conversion::toString(architecture) + ", 1);";
  
     dbConnection_->updateQuery(q);
 }

References __func__, architecture(), dbConnection_, file_, hasApplication(), hasArchitecture(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ writeArchitectureToFile()

void DSDBManager::writeArchitectureToFile	(	RowID	id,
		const std::string &	path
	)		const

Writes the machine architecture of given ID to file.

Parameters

id	RowID of the machine architecture.
path	File path where the ADF file is written.

Definition at line 826 of file DSDBManager.cc.

                                                                           {
     const std::string adf = architectureString(id);
     ADFSerializer serializer;
     serializer.setSourceString(adf);
     serializer.setDestinationFile(path);
     try {
         ObjectState* state = serializer.readState();
         serializer.writeState(state);
     } catch (const SerializerException& exception) {
         throw IOException(
             __FILE__, __LINE__, __func__, exception.errorMessage());
     }
 }

References __func__, architectureString(), Exception::errorMessage(), ADFSerializer::readState(), XMLSerializer::setDestinationFile(), XMLSerializer::setSourceString(), and ADFSerializer::writeState().

Referenced by main(), and writeConfigurationToFile().

Here is the call graph for this function:

◆ writeConfigurationToFile()

void DSDBManager::writeConfigurationToFile	(	const MachineConfiguration &	conf,
		const std::string &	path
	)

Writes the machine configuration to files path.{idf,adf}.

Parameters

conf	MachineConfiguration to be written to a path.
path	Path where the ADF and possibly the IDF of the configuration will be written.

Definition at line 929 of file DSDBManager.cc.

                                                              {
     const std::string adfFile = path + ".adf";
     const std::string idfFile = path + ".idf";
  
     writeArchitectureToFile(conf.architectureID, adfFile);
     if (conf.hasImplementation) {
         writeImplementationToFile(conf.implementationID, idfFile);
     }
 }

References DSDBManager::MachineConfiguration::architectureID, DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::MachineConfiguration::implementationID, writeArchitectureToFile(), and writeImplementationToFile().

Here is the call graph for this function:

◆ writeImplementationToFile()

void DSDBManager::writeImplementationToFile	(	RowID	id,
		const std::string &	path
	)		const

Writes the machine implementation of given ID to file.

Parameters

id	RowID of the machine implementation.
path	File path where the IDF file is written.

Definition at line 906 of file DSDBManager.cc.

                                            {
     const std::string idf = implementationString(id);
     IDF::IDFSerializer serializer;
     serializer.setSourceString(idf);
     serializer.setDestinationFile(path);
     try {
         ObjectState* state = serializer.readState();
         serializer.writeState(state);
     } catch (const SerializerException& exception) {
         throw IOException(
             __FILE__, __LINE__, __func__, exception.errorMessage());
     }
 }

References __func__, Exception::errorMessage(), implementationString(), IDF::IDFSerializer::readState(), XMLSerializer::setDestinationFile(), XMLSerializer::setSourceString(), and IDF::IDFSerializer::writeState().

Referenced by main(), and writeConfigurationToFile().

Here is the call graph for this function:

Member Data Documentation

◆ db_

SQLite* DSDBManager::db_

private

Handle to the database.

Definition at line 250 of file DSDBManager.hh.

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

◆ dbConnection_

RelationalDBConnection* DSDBManager::dbConnection_

private

Handle to the database connection.

Definition at line 252 of file DSDBManager.hh.

Referenced by addApplication(), addArchitecture(), addConfiguration(), addCycleCount(), addEnergyEstimate(), addImplementation(), applicationCostEstimatesByConf(), applicationCount(), applicationIDs(), applicationPath(), archConfigurationIDs(), architectureId(), architectureIDs(), architectureString(), areaEstimate(), configuration(), configurationId(), configurationIDs(), cycleCount(), DSDBManager(), energyEstimate(), hasApplication(), hasArchitecture(), hasConfiguration(), hasCycleCount(), hasEnergyEstimate(), hasImplementation(), implementationString(), isUnschedulable(), longestPathDelayEstimate(), paretoSetConnectivityAndCycles(), removeApplication(), removeConfiguration(), setAreaEstimate(), setLongestPathDelayEstimate(), setUnschedulable(), and ~DSDBManager().

◆ file_

std::string DSDBManager::file_

private

The DSDB file containing the current database.

Definition at line 254 of file DSDBManager.hh.

Referenced by addCycleCount(), addEnergyEstimate(), applicationPath(), architectureString(), areaEstimate(), configuration(), cycleCount(), dsdbFile(), energyEstimate(), implementationString(), longestPathDelayEstimate(), removeApplication(), removeConfiguration(), setAreaEstimate(), setLongestPathDelayEstimate(), and setUnschedulable().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ParetoPointConnectivityAndCycles

◆ ParetoSetConnectivityAndCycles

Member Enumeration Documentation

◆ Order

Constructor & Destructor Documentation

◆ DSDBManager()

◆ ~DSDBManager()

Member Function Documentation

◆ addApplication()

◆ addArchitecture()

◆ addConfiguration()

◆ addCycleCount()

◆ addEnergyEstimate()

◆ addImplementation()

◆ applicationCostEstimatesByConf()

◆ applicationCount()

◆ applicationIDs()

◆ applicationPath()

◆ archConfigurationIDs()

◆ architecture()

◆ architectureId()

◆ architectureIDs()

◆ architectureString()

◆ areaEstimate()

◆ configuration()

◆ configurationId()

◆ configurationIDs()

◆ createNew()

◆ cycleCount()

◆ cycleCounts()

◆ dsdbFile()

◆ energyEstimate()

◆ hasApplication() [1/2]

◆ hasApplication() [2/2]

◆ hasArchitecture()

◆ hasConfiguration()

◆ hasCycleCount()

◆ hasEnergyEstimate()

◆ hasImplementation()

◆ implementation()

◆ implementationString()

◆ isUnschedulable()

◆ longestPathDelayEstimate()

◆ paretoSetConnectivityAndCycles()

◆ removeApplication()

◆ removeConfiguration()

◆ setAreaEstimate()

◆ setLongestPathDelayEstimate()

◆ setUnschedulable()

◆ writeArchitectureToFile()

◆ writeConfigurationToFile()

◆ writeImplementationToFile()

Member Data Documentation

◆ db_

◆ dbConnection_

◆ file_