Explorer.cc File Reference

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include "StringTools.hh"
#include "Application.hh"
#include "Exception.hh"
#include "FileSystem.hh"
#include "DesignSpaceExplorer.hh"
#include "DesignSpaceExplorerPlugin.hh"
#include "ExplorerCmdLineOptions.hh"
#include "DSDBManager.hh"
#include "HDBRegistry.hh"
#include "MachineImplementation.hh"
#include "Machine.hh"
#include "ExplorerPluginParameter.hh"
#include "Environment.hh"
#include "Conversion.hh"

Include dependency graph for Explorer.cc:

Go to the source code of this file.

Functions
DSDBManager *	loadDSDB (const std::string &dsdbFile)
void	parseParameter (const std::string &param, std::string &paramName, std::string &paramValue)
void	determineLongest (const vector< DSDBManager::ConfigurationCosts > &confs, int &configurationID, int &applicationPath, int &cycleCount, int &energyEstimate, int &longestPathDelay, int &area)
void	printSpaces (unsigned int numberOfSpaces)
DSDBManager::Order	orderingOfData (const string &order)
bool	loadPluginParameters (DesignSpaceExplorerPlugin *plugin, const ExplorerCmdLineOptions &options)
DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &plugin, DSDBManager *dsdb)
void	printPlugins ()
void	printPluginParamInfo (DesignSpaceExplorerPlugin &plugin)
void	printParetoSet (const DSDBManager &dsdb, TCEString criteriaSet)
int	main (int argc, char *argv[])

Variables
const string	EXPLORER_DEFAULT_HDB = "asic_130nm_1.5V.hdb"

Function Documentation

determineLongest()

void determineLongest	(	const vector< DSDBManager::ConfigurationCosts > &	confs,
		int &	configurationID,
		int &	applicationPath,
		int &	cycleCount,
		int &	energyEstimate,
		int &	longestPathDelay,
		int &	area
	)

Determines the widest column so that column widths can be tuned.

Lengths of the data values are returned through the parameters.

Parameters

confs

Configuration costs which lengths are checked. @configurationID Length of the configuration ID string. @applicationPath Length of the path string of an application. @cycleCount Length of the program cycle count string. @energyEstimate Length of the programs energy estimate string.

Definition at line 120 of file Explorer.cc.

               {
 
    for (unsigned int i = 0; i < confs.size(); i++) {
        int size = Conversion::toString(confs[i].configurationID).size();
        if (size > configurationID) {
            configurationID = size;
        }
        size = confs[i].application.size();
        if (size > applicationPath) {
            applicationPath = size;
        }
        size = Conversion::toString(confs[i].cycleCount).size();
        if (size > cycleCount) {
            cycleCount = size;
        }
        size = Conversion::toString(confs[i].energyEstimate).size();
        if (size > energyEstimate) {
            energyEstimate = size;
        }
        size = Conversion::toString(confs[i].longestPathDelay).size();
        if (size > longestPathDelay) {          
            longestPathDelay = size;
        }
 
        size = Conversion::toString(confs[i].area).size(); 
        if (size > area) {
            area = size;                                                                                                                                                                          
        }
    }
}

References Conversion::toString().

Referenced by main().

Here is the call graph for this function:

loadDSDB()

DSDBManager* loadDSDB

(

const std::string &

dsdbFile

)

Loads the output Design Space Database file and creates a DSDB from it.

If the given filename doesn't exists creates a new DSDB file with the given name.

Parameters

dsdbFile

The DSDB file name.

Returns

DSDBManager of the DSDB file.

Definition at line 76 of file Explorer.cc.

                                    {
    if (FileSystem::fileExists(dsdbFile)) {
        return new DSDBManager(dsdbFile);
    } else {
        return DSDBManager::createNew(dsdbFile);
    }
}

References DSDBManager::createNew(), and FileSystem::fileExists().

Referenced by main().

Here is the call graph for this function:

loadExplorerPlugin()

DesignSpaceExplorerPlugin* loadExplorerPlugin	(	const std::string &	plugin,
		DSDBManager *	dsdb
	)

Loads explorer plugin.

Parameters

plugin	Explorer plugin name to be loaded.
dsdb	DSDB that plugin is associated with.

Returns

explorer plugin as a pointer.

Definition at line 227 of file Explorer.cc.

                                                               {
    
    // Try to load the explorer plugin.
    DesignSpaceExplorerPlugin* explorer = NULL;
    try {
        explorer = DesignSpaceExplorer::loadExplorerPlugin(plugin, dsdb);
    } catch (const FileNotFound& e) {
        std::cerr << "No explorer plugin file named '" << plugin
                  << ".so' found."  << std::endl;
        delete dsdb;
        return NULL;
    } catch (const Exception& e) {
        std::string msg = "Error while trying to load the explorer plugin "
            "named '" + plugin + ".so'.";
        verboseLog(msg)
        msg = "With reason: " + e.errorMessage();
        verboseLogC(msg, 1)
        delete dsdb;
        delete explorer;
        return NULL;
    }
    return explorer;
}

References Exception::errorMessage(), DesignSpaceExplorer::loadExplorerPlugin(), verboseLog, and verboseLogC.

Referenced by DesignSpaceExplorer::getPlugins(), main(), and printPlugins().

Here is the call graph for this function:

loadPluginParameters()

bool loadPluginParameters	(	DesignSpaceExplorerPlugin *	plugin,
		const ExplorerCmdLineOptions &	options
	)

Parses parameters given from command line and passes them to the plugin.

Parameters

plugin	Explorer plugin that receives the parameters.
options	Explorer command line options where parameters are read.

Definition at line 198 of file Explorer.cc.

                                           {
 
    // Check the parameters to be passed to the explorer plugin.
    for (int i = 0; i < options.explorerPluginParameterCount(); i++) {
        string param = options.explorerPluginParameter(i);
        string paramName;
        string paramValue;
        try {
            parseParameter(param, paramName, paramValue);
            plugin->giveParameter(paramName, paramValue);
        } catch (const Exception& e) {
            std::cerr << e.errorMessage() << std::endl;
            return false;
        }
    }
    return true;
}

References Exception::errorMessage(), DesignSpaceExplorerPlugin::giveParameter(), options, and parseParameter().

Referenced by main().

Here is the call graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

Main function.

Parses the command line and figures out what to do.

Parameters

argc	The command line argument count.
argv	The command line arguments (passed to the interpreter).

Returns

The return status.

Definition at line 402 of file Explorer.cc.

                                 {
 
    Application::initialize();    
 
    // boolean to check if done something useful
    bool doneUseful = false;
 
    // Parses the command line options.
    ExplorerCmdLineOptions* options = new ExplorerCmdLineOptions();
    try {
        options->parse(argv, argc);
        Application::setCmdLineOptions(options);
    } catch (ParserStopRequest) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& i) {
        std::cerr << i.errorMessage() <<  std::endl;
        return EXIT_FAILURE;
    }
 
    int verboseLevel = Application::verboseLevel();
    if (verboseLevel < 0) {
        Application::setVerboseLevel();
    } else {
        Application::setVerboseLevel(verboseLevel);
    }
 
    if (options->printPlugins()) {
        printPlugins();
        return EXIT_SUCCESS;
    }
 
    if (options->pluginInfo().length() != 0) {
        std::string plugin = options->pluginInfo();
        DesignSpaceExplorerPlugin* explorer = loadExplorerPlugin(plugin, NULL);
        if (!explorer) {
            return EXIT_FAILURE;
        }
        printPluginParamInfo(*explorer);
        delete explorer;
        explorer = NULL;
        return EXIT_SUCCESS;
    }
 
    // Only argument should be dsdb.
    if (options->numberOfArguments() != 1) {
        std::cerr << "Illegal number of arguments." << std::endl << std::endl;
        options->printHelp();
        return EXIT_FAILURE;
    }
    // Get the database file.
    std::string dsdbFile = "";
    dsdbFile = options->argument(1);
 
    // Loads the database.
    DSDBManager* dsdb = NULL;
    try {
        dsdb = loadDSDB(dsdbFile);
    } catch (const IOException& e) {
        std::cerr << e.errorMessage() << std::endl;
        delete dsdb;
        return EXIT_FAILURE;
    }
 
    // adds new configuration to the DSDB
    if (options->adfFile()) {
        TTAMachine::Machine* adf = NULL;
        IDF::MachineImplementation* idf = NULL;
        try {
            DSDBManager::MachineConfiguration conf;
            conf.hasImplementation = false;
            adf = TTAMachine::Machine::loadFromADF(options->adfFileName());
            conf.architectureID = dsdb->addArchitecture(*adf);
            if (options->idfFile()) {
                idf = 
                    IDF::MachineImplementation::loadFromIDF(
                        options->idfFileName());
                conf.implementationID = dsdb->addImplementation(*idf, 0, 0);
                conf.hasImplementation = true;
            }
            RowID confID = dsdb->addConfiguration(conf);
            std::cout 
                << "Added configuration " << confID << " into the DSDB." 
                << std::endl;
            delete adf;
            delete idf;
            doneUseful = true;
        } catch (const Exception& e) {
            std::cout << "Error occured reading ADF or IDF. " 
                      << e.errorMessage() << std::endl;
            delete dsdb;
            return EXIT_FAILURE;           
        }
    }
 
    // Check and add the test application directories.
    int testDirectories = options->testApplicationDirectoryCount();
    for (int i = 0; i < testDirectories; i++) {
        std::string testDir = options->testApplicationDirectory(i);
        if (FileSystem::fileExists(testDir) &&
            FileSystem::fileIsDirectory(testDir)) {
            TestApplication app(testDir);
            if (!app.isValid()) {
                std::cerr 
                    << "Application directory '" << testDir 
                    << "' is invalid. Ensure that at least program.bc with "
                    << "the input program exists. Also either " 
                    << "'correct_simulation_output' or 'verify.sh' is needed "
                    << "for verifying the program output."
                    << std::endl;
            } else if (!dsdb->hasApplication(testDir)) {
                dsdb->addApplication(testDir);
            } else {
                std::cerr 
                    << "application directory '" << testDir 
                    << "' has already been added" << std::endl;
            }
        } else {
            std::cerr << "Application directory '" << testDir
                      << "' does not exist." << std::endl;
        }
        doneUseful = true;
    }
 
    TCEString paretoSet = options->paretoSetValues();
    if (paretoSet != "") {
        // Prints the pareto sets
        if (paretoSet != "C") {
            std::cerr << "Unsupported pareto set value type." << std::endl;
            return EXIT_FAILURE;
        }
        printParetoSet(*dsdb, paretoSet);
        return EXIT_SUCCESS;
    }
 
    // Prints the summary of the configurations in the database.
    if (options->printSummary()) {
        DSDBManager::Order ordering = orderingOfData(options->summaryOrdering());
        cout << "Configurations in DSDB: " << endl;
        int idLength = 7;
        int pathLength = 16;
        int cycleLength = 11;
        int energyLength = 15;
        int lpdLength = 18;
        int areaLength = 4;
        cout << "| Conf ID | Application path | cycle count | energy estimate | longest path delay | area "
             << endl;
        cout << "------------------------------------------------------------------------------------------"
             << endl;
        vector<DSDBManager::ConfigurationCosts> confCosts =
            dsdb->applicationCostEstimatesByConf(ordering);
        // Checks the longes strings of all data values that will be printed.
        // Values are used to create a clean output of the results.
        determineLongest(
            confCosts, idLength, pathLength, cycleLength, 
            energyLength, lpdLength, areaLength);
        for (unsigned int i = 0; i < confCosts.size(); i++) {
            cout << "| ";
            cout << confCosts[i].configurationID;
            printSpaces(
                idLength - Conversion::toString(
                    confCosts[i].configurationID).size());
            cout << " | ";
            cout << confCosts[i].application;
            printSpaces(
                pathLength - confCosts[i].application.size());
            cout << " | ";
            cout << confCosts[i].cycleCount;
            printSpaces(
                cycleLength - Conversion::toString(
                    confCosts[i].cycleCount).size());
            cout << " | ";
            cout << confCosts[i].energyEstimate;
            printSpaces(
                energyLength - Conversion::toString(
                    confCosts[i].energyEstimate).size());
            cout << " | ";
            cout << confCosts[i].longestPathDelay;
            printSpaces(
                    lpdLength - Conversion::toString(
                        confCosts[i].longestPathDelay).size());
            cout << " | ";
            cout << confCosts[i].area;
            printSpaces(
                    areaLength - Conversion::toString(
                        confCosts[i].area).size());   
            cout << " |" << endl;
        }
        cout <<  "-----------------------------------------------------------------------------------------"
            << endl;
    }
    
    // Prints the total amount of configurations in the database.
    if (options->printSummary() || options->numberOfConfigurations()) {
        cout << "Total: " << dsdb->configurationIDs().size() 
             << " configurations "
             << "in the database." << endl;
        delete dsdb;
        return EXIT_SUCCESS;
    }
 
    // Write the configuration ADF and IDF to files.
    if (options->writeOutConfiguration()) {
        for (int i = 0; i < options->numberOfConfigurationsToWrite(); i++) {
            if (dsdb->hasConfiguration(options->configurationToWrite(i))) {
                DSDBManager::MachineConfiguration configuration = 
                    dsdb->configuration(options->configurationToWrite(i));
                std::string adfFileName = 
                    Conversion::toString(options->configurationToWrite(i))
                    + ".adf";
                try {
                    dsdb->writeArchitectureToFile(
                        configuration.architectureID, adfFileName);
                    std::cout << "Written ADF file of configuration "
                              << options->configurationToWrite(i)
                              << std::endl;
                } catch (const Exception& e) {
                    std::cerr << "Error occured while writing the ADF." 
                              << std::endl;
                    delete dsdb;
                    return EXIT_FAILURE;
                }
 
                if (configuration.hasImplementation) {
                    std::string idfFileName = 
                        Conversion::toString(options->configurationToWrite(i))
                        + ".idf";
                    try {
                        dsdb->writeImplementationToFile(
                            configuration.implementationID, idfFileName);
                        std::cout << "Written IDF file of configuration "
                                  << options->configurationToWrite(i)
                                  << std::endl;
                    } catch (const Exception& e) {
                        std::cerr << "Error occured while writing the IDF."
                                  << std::endl;
                        delete dsdb;
                        return EXIT_FAILURE;
                    }
                }
            } else {
                // dsdb didn't have requested configuration
                std::cerr << "No configuration found with id: " 
                          << options->configurationToWrite(i) << "." 
                          << std::endl;
                delete dsdb;
                return EXIT_FAILURE;
            }
        }
        delete dsdb;
        return EXIT_SUCCESS;
    }
    
    // Remove applications from DSDB if requested
    if (options->applicationIDToRemoveCount() > 0) {
        for (int i = 0; i < options->applicationIDToRemoveCount(); i++) {
            RowID id = options->applicationIDToRemove(i);
            try {
                dsdb->removeApplication(id);
            } catch (const KeyNotFound&) {
                std::cerr << "No application with ID: " << id << " in DSDB."
                          << std::endl;
            }
        }
        delete dsdb;
        return EXIT_SUCCESS;
    }
 
    // If the list applications option is given.
    if (options->printApplications()) {
        std::cout << "Applications in the DSDB:" << std::endl;
        std::cout << " ID | Application" << std::endl;
        std::cout << "---------------------------------" << std::endl;
        std::set<RowID> appIDs = dsdb->applicationIDs();
        std::set<RowID>::const_iterator appIter = appIDs.begin();
        for (; appIter != appIDs.end(); appIter++) {
            std::cout << " " << (*appIter) << " | " 
                      << dsdb->applicationPath(*appIter)
                      << std::endl;
        }
        std::cout << "---------------------------------" << std::endl;
        std::cout << "Total: " << dsdb->applicationCount() 
                  << " applications in DSDB." << std::endl;
        delete dsdb;
        return EXIT_SUCCESS;
    }
 
    // Check the explorer plugin.
    std::string pluginToUse = "";
    pluginToUse = options->explorerPlugin();
    if (pluginToUse == "") {
        if (!doneUseful) {
            std::cerr << "No explorer plugin given." << std::endl;
            delete dsdb;
            return EXIT_FAILURE;
        } else {
            delete dsdb;
            return EXIT_SUCCESS;
        }
    }
    
    // Try to load the explorer plugin.
    DesignSpaceExplorerPlugin* explorer = loadExplorerPlugin(pluginToUse, dsdb);
    if (!explorer || !loadPluginParameters(explorer, *options)) {
        delete dsdb;
        return EXIT_FAILURE;
    }
 
    if (testDirectories < 1 && !dsdb->applicationCount() &&
        explorer->requiresApplication()) {
        // used plugin may not need a test application, or the app is
        // provided to the plugin with its own parameter
        std::cerr << "No test application paths given or found in dsdb."
                  << std::endl;
        return EXIT_FAILURE;
    }
 
    // Load the HDB files if given as option
    if (options->hdbFileNames()) {
        vector<string> hdbPaths;
        // put current working directory first in path find priority
        hdbPaths.push_back(FileSystem::currentWorkingDir());
        // concatenate search paths after current working dir path
        vector<string> srchPaths = Environment::hdbPaths();
        hdbPaths.insert(hdbPaths.end(), srchPaths.begin(), srchPaths.end());
 
        for (int i = 0; i < options->hdbFileNameCount(); i++) {
            string pathToHdb = options->hdbFileName(i);
            string hdbFile = options->hdbFileName(i);
            for (unsigned int p = 0; p < hdbPaths.size(); p++) {
                string tempPath = 
                    hdbPaths.at(p) + FileSystem::DIRECTORY_SEPARATOR + hdbFile;
                if (FileSystem::fileExists(tempPath)) {
                    pathToHdb = tempPath;
                    break;
                }
            }
            try {
                HDB::HDBRegistry::instance().hdb(pathToHdb);
            } catch (const FileNotFound& e) {
                std::cerr << "Could not find HDB file " 
                          << options->hdbFileName(i) << std::endl;
            }
        }
    } else {
        // if no hdb was given, use default hdb
        string pathToHdb = EXPLORER_DEFAULT_HDB;
        vector<string> hdbPaths = Environment::hdbPaths();
        for (unsigned int i = 0; i < hdbPaths.size(); i++) {
            string tempPath =
                hdbPaths.at(i) + FileSystem::DIRECTORY_SEPARATOR
                + EXPLORER_DEFAULT_HDB;
            if (FileSystem::fileExists(tempPath)) {
                pathToHdb = tempPath;
                break;
            }
        }
        try {
            HDB::HDBRegistry::instance().hdb(pathToHdb);
        } catch (const FileNotFound& e) {
            std::cerr << "Could not find HDB file " 
                      << pathToHdb << std::endl;
        }
    }
    
    try {
        RowID startPointConfigurationID = options->startConfiguration();        
        if (startPointConfigurationID == 0 &&
            explorer->requiresStartingPointArchitecture()) {
            std::cerr 
                << "No starting point configuration defined. " << std::endl
                << "Use -s <confID> to define the configuration to "
                << "start the exploration from." << std::endl;
            return EXIT_FAILURE;
 
        }
        vector<RowID> result =
            explorer->explore(startPointConfigurationID);
        if (result.empty()) {
            cout 
                << "No fitting processor configurations were created." << endl;
        } else {
            std::cout << "Best result configurations:" << std::endl;
            for (unsigned int i = 0; i < result.size(); i++) {
                cout << " " << result[i] << endl;
            }
        }
    } catch (const Exception& e) {
        std::cerr << e.errorMessage()
                  << " " << e.fileName()
                  << " " << e.lineNum() << std::endl;
        delete dsdb;
        delete explorer;
        return EXIT_FAILURE;
    }
 
    delete dsdb;
    delete explorer;
    return EXIT_SUCCESS;
}

References DSDBManager::addApplication(), DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::addImplementation(), DSDBManager::applicationCostEstimatesByConf(), DSDBManager::applicationCount(), DSDBManager::applicationIDs(), DSDBManager::applicationPath(), DSDBManager::MachineConfiguration::architectureID, CmdLineParser::argument(), DSDBManager::configuration(), DSDBManager::configurationIDs(), FileSystem::currentWorkingDir(), determineLongest(), FileSystem::DIRECTORY_SEPARATOR, Exception::errorMessage(), DesignSpaceExplorerPlugin::explore(), EXPLORER_DEFAULT_HDB, FileSystem::fileExists(), FileSystem::fileIsDirectory(), Exception::fileName(), DSDBManager::hasApplication(), DSDBManager::hasConfiguration(), DSDBManager::MachineConfiguration::hasImplementation, HDB::HDBRegistry::hdb(), Environment::hdbPaths(), DSDBManager::MachineConfiguration::implementationID, Application::initialize(), HDB::HDBRegistry::instance(), TestApplication::isValid(), Exception::lineNum(), loadDSDB(), loadExplorerPlugin(), TTAMachine::Machine::loadFromADF(), IDF::MachineImplementation::loadFromIDF(), loadPluginParameters(), CmdLineParser::numberOfArguments(), options, orderingOfData(), CmdLineOptions::parse(), MachInfoCmdLineOptions::printHelp(), printParetoSet(), printPluginParamInfo(), printPlugins(), printSpaces(), DSDBManager::removeApplication(), DesignSpaceExplorerPlugin::requiresApplication(), DesignSpaceExplorerPlugin::requiresStartingPointArchitecture(), Application::setCmdLineOptions(), Application::setVerboseLevel(), Conversion::toString(), Application::verboseLevel(), DSDBManager::writeArchitectureToFile(), and DSDBManager::writeImplementationToFile().

Here is the call graph for this function:

orderingOfData()

DSDBManager::Order orderingOfData

(

const string &

order

)

Returns the ordering of data indicated by the string.

@order Option string given by user that tells the ordering.

Returns

The ordering of the data.

Definition at line 177 of file Explorer.cc.

                                                     {
    if (order == "I") {
        return DSDBManager::ORDER_BY_CONFIGURATION;
    } else if (order == "P") {
        return DSDBManager::ORDER_BY_APPLICATION;
    } else if (order == "C") {
        return DSDBManager::ORDER_BY_CYCLE_COUNT;
    } else if (order == "E") {
        return DSDBManager::ORDER_BY_ENERGY_ESTIMATE;
    } else {
        return DSDBManager::ORDER_BY_CONFIGURATION;
    }
}

References DSDBManager::ORDER_BY_APPLICATION, DSDBManager::ORDER_BY_CONFIGURATION, DSDBManager::ORDER_BY_CYCLE_COUNT, and DSDBManager::ORDER_BY_ENERGY_ESTIMATE.

Referenced by main().

parseParameter()

void parseParameter	(	const std::string &	param,
		std::string &	paramName,
		std::string &	paramValue
	)

Parses the given parameter which has form 'paramname=paramvalue" to different strings.

Parameters

param	The parameter.
paramName	Parameter name is stored here.
paramValue	Parameter value is stored here.

Exceptions

InvalidData

If the given parameter is not in the correct form.

Definition at line 94 of file Explorer.cc.

                                                                         {
    string::size_type separatorPos = param.find("=", 0);
    if (separatorPos == string::npos) {
        string errorMsg = 
            "Explorer plugin parameters must be in form "
            "'parametername=parametervalue'.";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    paramName = param.substr(0, separatorPos);
    paramValue = param.substr(separatorPos+1, param.length());
}

References __func__.

Referenced by loadPluginParameters().

printParetoSet()

void printParetoSet	(	const DSDBManager &	dsdb,
		TCEString	criteriaSet
	)

Prints the pareto set of configurations in the DSDB using the given criteria set.

Definition at line 353 of file Explorer.cc.

                                                               {
    if (criteriaSet != "C")
        return; // only connectivity,cycles criteria supported
     
    DSDBManager::ParetoSetConnectivityAndCycles paretoSet = 
        dsdb.paretoSetConnectivityAndCycles();
 
    const int CONF_COL_W = 6;
    const int CONNECTIVITY_COL_W = 6;
    const int CYCLES_COL_W = 8;
 
    std::cout << std::setw(CONF_COL_W) << std::right << "conf #" 
              << " | ";
 
    std::cout << std::setw(CONNECTIVITY_COL_W) << std::right << "conn" 
              << " | ";
 
    std::cout << std::setw(CYCLES_COL_W) << std::right << "cycles" 
              << std::endl;
 
    for (int i = 0; i < CONF_COL_W + CONNECTIVITY_COL_W + CYCLES_COL_W + 10; 
         ++i) {
        std::cout << "-";
    }
    std::cout << std::endl;
 
    for (DSDBManager::ParetoSetConnectivityAndCycles::const_iterator i = 
             paretoSet.begin(); i != paretoSet.end(); ++i) {
        DSDBManager::ParetoPointConnectivityAndCycles point = *i;
        std::cout << std::setw(CONF_COL_W) << std::right << point.get<0>()
                  << " | ";
 
        std::cout << std::setw(CONNECTIVITY_COL_W) << std::right << point.get<1>()
                  << " | ";
 
        std::cout << std::setw(CYCLES_COL_W) << std::right << point.get<2>()
                  << std::endl;        
    }
}

References DSDBManager::paretoSetConnectivityAndCycles().

Referenced by main().

Here is the call graph for this function:

printPluginParamInfo()

void printPluginParamInfo

(

DesignSpaceExplorerPlugin &

plugin

)

Prints explorer plugin parameter info.

Parameters

plugin

Explorer plugin which parameter info is to be printed.

Definition at line 303 of file Explorer.cc.

                                                        {
    using std::setw;
    DesignSpaceExplorerPlugin::ParameterMap pm = plugin.parameters();
    DesignSpaceExplorerPlugin::PMCIt it = pm.begin();
    cout.flags(std::ios::left);
    cout << setw(30) << "parameter name " << setw(15) << "type" << "default value" << endl;
    cout << "-----------------------------------------------------------------------------" << endl;
    while (it != pm.end()) {
        cout << setw(30) << it->first << setw(15);
        switch (it->second.type()) {
            case UINT:
                cout << "unsigned int"; 
                break;
            case INT:
                cout << "int"; 
                break;
            case STRING:
                cout << "string"; 
                break;
            case BOOL:
                cout << "boolean"; 
                break;
            default:
                cout << "unknown type"; 
        }
        if (!it->second.isCompulsory()) {
            if (it->second.type() == BOOL) {
                cout << 
                    (it->second.value() == "1" || it->second.value() == "true"
                     ? "true" : "false"); 
            } else {
                cout << it->second.value();
            }
        }
        cout << std::endl;
        if (it->second.description().size() > 0) {
            cout << std::endl;
            cout << it->second.description();
            cout << std::endl;
            cout << std::endl;
        }
        ++it; 
    }
}

References BOOL, INT, DesignSpaceExplorerPlugin::parameters(), STRING, and UINT.

Referenced by main().

Here is the call graph for this function:

printPlugins()

void printPlugins

(

)

Prints explorer plugins and their descriptions.

Definition at line 256 of file Explorer.cc.

               {
    vector<string> found_plugins;
    vector<string> stripped_plugins;
    vector<string> searchPaths = Environment::explorerPluginPaths();
    for (vector<string>::const_iterator iter = searchPaths.begin();
            iter != searchPaths.end(); iter++) {
        if (FileSystem::fileExists(*iter)) {
            // now list all files with postfix ".so"
            verboseLogC("Fetching plugins from directory: " + *iter, 1)
            FileSystem::findFromDirectory(".*\\.so$", *iter, found_plugins);
        }
    }
    cout << "| Plugin name                 | Description " << endl
         << "--------------------------------------------" << endl;
    cout.flags(std::ios::left);
    // Eliminate duplicates such as ComponentAdded.0.so ComponentAdded.so
    for (unsigned int i = 0; i < found_plugins.size(); ++i) {
        std::string finalPluginName = found_plugins[i];        
        std::string pluginName = FileSystem::fileNameBody(found_plugins[i]); 
        // Repeat "basename" until all .0.0. are removed so symbol can be found
        // correctly
        while (pluginName != finalPluginName) {
            finalPluginName = pluginName;
            pluginName = FileSystem::fileNameBody(pluginName); 
        }
        if(find(stripped_plugins.begin(), stripped_plugins.end(), pluginName)
            == stripped_plugins.end()) {
            stripped_plugins.push_back(pluginName);
        }
    }
    for (unsigned int i = 0; i < stripped_plugins.size(); ++i) {
        std::string pluginName = stripped_plugins[i];        
        DesignSpaceExplorerPlugin* plugin = loadExplorerPlugin(pluginName, NULL);
        if (!plugin) {
            return;
        }
        cout << std::setw(30) << pluginName << plugin->description() << endl;
    }
}

References DesignSpaceExplorerPlugin::description(), Environment::explorerPluginPaths(), FileSystem::fileExists(), FileSystem::fileNameBody(), FileSystem::findFromDirectory(), loadExplorerPlugin(), and verboseLogC.

Referenced by main().

Here is the call graph for this function:

printSpaces()

void printSpaces

(

unsigned int

numberOfSpaces

)

Outputs given number of empty characters to cout.

Parameters

numberOfSpaces

The number of empty characters to output.

Definition at line 164 of file Explorer.cc.

                                         {
    while (numberOfSpaces != 0) {
        cout << " ";
        numberOfSpaces--;
    }
}

Referenced by main().

Variable Documentation

EXPLORER_DEFAULT_HDB

const string EXPLORER_DEFAULT_HDB = "asic_130nm_1.5V.hdb"

Definition at line 64 of file Explorer.cc.

Referenced by main().