DesignSpaceExplorer Class Reference

#include <DesignSpaceExplorer.hh>

Inheritance diagram for DesignSpaceExplorer:

Collaboration diagram for DesignSpaceExplorer:

Public Member Functions
	DesignSpaceExplorer ()
virtual	~DesignSpaceExplorer ()
virtual void	setDSDB (DSDBManager &dsdb)
virtual bool	evaluate (const DSDBManager::MachineConfiguration &configuration, CostEstimates &results=dummyEstimate_, bool estimate=false)
virtual DSDBManager &	db ()
std::vector< DesignSpaceExplorerPlugin * >	getPlugins ()
RowID	createImplementationAndStore (const DSDBManager::MachineConfiguration &conf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")
bool	createImplementation (const DSDBManager::MachineConfiguration &conf, DSDBManager::MachineConfiguration &newConf, const double &frequency=0.0, const double &maxArea=0.0, const bool &createEstimates=true, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb")
IDF::MachineImplementation *	selectComponents (const TTAMachine::Machine &mach, const double &frequency=0.0, const double &maxArea=0.0, const std::string &icDec="DefaultICDecoder", const std::string &icDecHDB="asic_130nm_1.5V.hdb") const
void	createEstimateData (const TTAMachine::Machine &mach, const IDF::MachineImplementation &idf, CostEstimator::AreaInGates &area, CostEstimator::DelayInNanoSeconds &longestPathDelay)
RowID	addConfToDSDB (const DSDBManager::MachineConfiguration &conf)

Static Public Member Functions
static DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &pluginName, DSDBManager *dsdb=NULL)

Protected Member Functions
TTAProgram::Program *	schedule (const std::string applicationFile, TTAMachine::Machine &machine, TCEString paramOptions="-O3")
const ExecutionTrace *	simulate (const TTAProgram::Program &program, const TTAMachine::Machine &machine, const TestApplication &testApplication, const ClockCycleCount &maxCycles, ClockCycleCount &runnedCycles, const bool tracing, const bool useCompiledSimulation=false, std::vector< ClockCycleCount > *executionCounts=NULL)

Private Attributes
DSDBManager *	dsdb_
	Design space database where results are stored.
CostEstimator::Estimator	estimator_
	The estimator frontend.
std::ostringstream *	oStream_
	Output stream.

Static Private Attributes
static PluginTools	pluginTool_
	The plugin tool.
static CostEstimates	dummyEstimate_
	Used for the default evaluate() argument.

Detailed Description

Design space explorer interface provides methods to automatically evaluate machine configurations and select best implementations to the processor components according the test applications set in Design Space Database (DSDB).

Definition at line 70 of file DesignSpaceExplorer.hh.

Constructor & Destructor Documentation

DesignSpaceExplorer()

DesignSpaceExplorer::DesignSpaceExplorer

(

)

The constructor.

Definition at line 84 of file DesignSpaceExplorer.cc.

                                         {
    
    //schedulingPlan_ = 
    //    SchedulingPlan::loadFromFile(Environment::oldGccSchedulerConf());
    oStream_ = new std::ostringstream;
    OperationGlobals::setOutputStream(*oStream_);
}

References oStream_, and OperationGlobals::setOutputStream().

Here is the call graph for this function:

~DesignSpaceExplorer()

DesignSpaceExplorer::~DesignSpaceExplorer ( )

virtual

The destructor.

Definition at line 95 of file DesignSpaceExplorer.cc.

                                          {
 
    //delete schedulingPlan_;
    //schedulingPlan_ = NULL;
    delete oStream_;
    oStream_ = NULL;
}

References oStream_.

Member Function Documentation

addConfToDSDB()

RowID DesignSpaceExplorer::addConfToDSDB

(

const DSDBManager::MachineConfiguration &

conf

)

Add given configuration to the database.

Parameters

conf	Configuration to be added to the database.
dsdb	Database where to add the configuration.

Returns

RowID Row ID of the config in the database. 0 if adding failed.

Definition at line 794 of file DesignSpaceExplorer.cc.

                                                 {
 
    try {
        return dsdb_->addConfiguration(conf);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        return 0;
    }
}

References DSDBManager::addConfiguration(), debugLog, dsdb_, and Exception::errorMessage().

Referenced by createImplementationAndStore(), Evaluate::explore(), and MinimalOpSet::explore().

Here is the call graph for this function:

createEstimateData()

void DesignSpaceExplorer::createEstimateData	(	const TTAMachine::Machine &	mach,
		const IDF::MachineImplementation &	idf,
		CostEstimator::AreaInGates &	area,
		CostEstimator::DelayInNanoSeconds &	longestPathDelay
	)

creates estimate data for machine and idf.

Parameters

mach	Machine mathcing given idf.
idf	Implementation definition for given machine.
area	Estimated area cost.
longestPathDelay	Estimated longest path delay.

Definition at line 774 of file DesignSpaceExplorer.cc.

                                                       {
 
    area = estimator_.totalArea(mach, idf);
    longestPathDelay = estimator_.longestPath(mach, idf);                
}

References estimator_, CostEstimator::Estimator::longestPath(), and CostEstimator::Estimator::totalArea().

Referenced by createImplementation(), createImplementationAndStore(), and evaluate().

Here is the call graph for this function:

createImplementation()

bool DesignSpaceExplorer::createImplementation	(	const DSDBManager::MachineConfiguration &	conf,
		DSDBManager::MachineConfiguration &	newConf,
		const double &	frequency = 0.0,
		const double &	maxArea = 0.0,
		const bool &	createEstimates = true,
		const std::string &	icDec = "DefaultICDecoder",
		const std::string &	icDecHDB = "asic_130nm_1.5V.hdb"
	)

Selects components for a machine and ands them to a given config.

Parameters

conf	MachineConfiguration of which architecture is used.
newConf	MachineConfiguration where idf is to be added.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
createEstimates	Boolean for creating estimates.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns

RowID of the new machine configuration having adf and idf.

Definition at line 689 of file DesignSpaceExplorer.cc.

                               {
 
    const TTAMachine::Machine* mach = dsdb_->architecture(conf.architectureID);
    IDF::MachineImplementation* idf = NULL;
 
    idf = selectComponents(*mach, frequency, maxArea, icDec, icDecHDB);
    if (!idf) {
        return false;
    }
 
    CostEstimator::AreaInGates area = 0;
    CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
    if (createEstimates) {
        createEstimateData(*mach, *idf, area, longestPathDelay);
    }
 
    delete mach;
    mach = NULL;
 
    newConf.architectureID = conf.architectureID;
    newConf.implementationID = dsdb_->addImplementation(*idf, longestPathDelay, area);
    newConf.hasImplementation = true;
    
    // idf written to the dsdb so it can be deleted
    delete idf;
    idf = NULL;
    return true;
}

References DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, createEstimateData(), dsdb_, DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::MachineConfiguration::implementationID, and selectComponents().

Referenced by MinimalOpSet::explore(), and SimpleICOptimizer::explore().

Here is the call graph for this function:

createImplementationAndStore()

RowID DesignSpaceExplorer::createImplementationAndStore	(	const DSDBManager::MachineConfiguration &	conf,
		const double &	frequency = 0.0,
		const double &	maxArea = 0.0,
		const bool &	createEstimates = true,
		const std::string &	icDec = "DefaultICDecoder",
		const std::string &	icDecHDB = "asic_130nm_1.5V.hdb"
	)

Selects components for a machine and creates a new configuration.

Also stores the new configuration to the dsdb and returns it's rowID.

Parameters

conf	MachineConfiguration of which architecture is used.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
createEstimates	Boolean for creating estimates.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns

RowID of the new machine configuration having adf and idf.

Definition at line 636 of file DesignSpaceExplorer.cc.

                               {
 
    const TTAMachine::Machine* mach = dsdb_->architecture(conf.architectureID);
    IDF::MachineImplementation* idf = NULL;
 
    idf = selectComponents(*mach, frequency, maxArea, icDec, icDecHDB);
    if (!idf) {
        return 0;
    }
    
    CostEstimator::AreaInGates area = 0;
    CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
    if (createEstimates) {
        createEstimateData(*mach, *idf, area, longestPathDelay);
    }
 
    delete mach;
    mach = NULL;
 
    DSDBManager::MachineConfiguration newConf;
    newConf.architectureID = conf.architectureID;
 
    newConf.implementationID = 
        dsdb_->addImplementation(*idf, longestPathDelay, area);
    newConf.hasImplementation = true;
    
    // idf written to the dsdb so it can be deleted
    delete idf;
    idf = NULL;
 
    return addConfToDSDB(newConf);
}

References addConfToDSDB(), DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, createEstimateData(), dsdb_, DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::MachineConfiguration::implementationID, and selectComponents().

Referenced by FrequencySweepExplorer::explore().

Here is the call graph for this function:

db()

DSDBManager & DesignSpaceExplorer::db ( )

virtual

Returns the DSDBManager of the current exploration process.

Returns

The DSDBManager of the current exploration process.

Definition at line 339 of file DesignSpaceExplorer.cc.

                        {
 
    return *dsdb_;
}

References dsdb_.

Referenced by ConnectionSweeper::averageWorsening(), MinimizeMachine::checkCycleCounts(), ADFCombiner::explore(), BlocksConnectIC::explore(), ComponentAdder::explore(), Evaluate::explore(), GrowMachine::explore(), ImplementationSelector::explore(), MinimalOpSet::explore(), RemoveUnconnectedComponents::explore(), VectorLSGenerator::explore(), VLIWConnectIC::explore(), ConnectionSweeper::explore(), FrequencySweepExplorer::explore(), ImmediateGenerator::explore(), SimpleICOptimizer::explore(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeMachine(), MinimizeMachine::minimizeRegisterFiles(), Evaluate::printEstimates(), ConnectionSweeper::removeAllConnections(), ConnectionSweeper::removeLeastNecessaryConnections(), simulate(), ConnectionSweeper::sweepBypasses(), and ConnectionSweeper::sweepRFs().

evaluate()

bool DesignSpaceExplorer::evaluate ( const DSDBManager::MachineConfiguration &  configuration, CostEstimates &  result = dummyEstimate_, bool  estimate = false  )

virtual

Evaluates one processor configuration (architecture+implementation pair).

Evaluates the total area and the longest path delay of the current processor configuration (architecture+implementation pair) and also the energy consumed in each program in the DSDB with this processor configuration. Also configurations without implementation can be evaluated but no cost estimations are performed so the CostEstimate object won't include area, energy and longest path delay estimations. Estimation is not included either if the estimate flag is set to false.

Parameters

configuration	Machine configuration (architecture, implementation).
result	CostEstimates object where the configuration cost estimates are stored if the evaluation succeeds.
estimate	Flag indicating that the evaluate will also estimate the given configuration.

Exceptions

InvalidData

thrown in case there are flaws in the application configuration which leads to evaluation failure.

Returns

Returns true if the evaluation succeeds false otherwise.

Definition at line 135 of file DesignSpaceExplorer.cc.

                                          {
 
    TTAMachine::Machine* adf = NULL;
    IDF::MachineImplementation* idf = NULL;
    if (configuration.hasImplementation) {
        adf = dsdb_->architecture(configuration.architectureID);
        idf = dsdb_->implementation(configuration.implementationID);
    } else {
        adf = dsdb_->architecture(configuration.architectureID);
    }
 
    try {
        // program independent estimations
        if (configuration.hasImplementation && estimate) {
 
            // estimate total area and longest path delay
            CostEstimator::AreaInGates totalArea = 0;
            CostEstimator::DelayInNanoSeconds longestPathDelay = 0;
            createEstimateData(*adf, *idf, totalArea, longestPathDelay);
 
            dsdb_->setAreaEstimate(configuration.implementationID, totalArea);
            result.setArea(totalArea);
 
            dsdb_->setLongestPathDelayEstimate(
                configuration.implementationID, longestPathDelay);
            result.setLongestPathDelay(longestPathDelay);
        }
       
        // get all programs from the dsdb
        set<RowID> applicationIDs = dsdb_->applicationIDs();
        for (set<RowID>::const_iterator i = applicationIDs.begin();
             i != applicationIDs.end(); i++) {
 
            if (dsdb_->isUnschedulable((*i), configuration.architectureID)) {
                return false;
            }
 
            if (!estimate && 
                dsdb_->hasCycleCount(*i, configuration.architectureID)) {
                // this configuration has been compiled+simulated previously,
                // the old cycle count can be reused for this app
                continue; 
            }
 
            string applicationPath = dsdb_->applicationPath(*i);
            TestApplication testApplication(applicationPath);
            
            std::string applicationFile = testApplication.applicationPath();
 
            // test that program is found
            if (applicationFile.length() < 1) {
                delete adf;
                adf = NULL;
                delete idf;
                idf = NULL;
                throw InvalidData(
                    __FILE__, __LINE__, __func__,
                    (boost::format(
                        "No program found from application dir '%s'") 
                     % applicationPath).str());
                return false;
            }
            
#if (!defined(HAVE_CXX11) && !defined(HAVE_CXX0X))
            std::auto_ptr<TTAProgram::Program> scheduledProgram(
                schedule(applicationFile, *adf));
#else
            std::unique_ptr<TTAProgram::Program> scheduledProgram(
                schedule(applicationFile, *adf));
#endif
 
            if (scheduledProgram.get() == NULL) {
                dsdb_->setUnschedulable((*i), configuration.architectureID);
                delete adf;
                adf = NULL;
                delete idf;
                idf = NULL;
                return false;
            }
 
            bool hasFunctionsOfInterest =
                testApplication.hasFunctionsOfInterest();
            std::vector<ClockCycleCount> instructionExecutionCounts;
 
            // simulate the scheduled program
            ClockCycleCount totalCycleCount;
            const ExecutionTrace* traceDB = NULL;
            if (configuration.hasImplementation && estimate) {
                traceDB = simulate(
                    *scheduledProgram, *adf, testApplication, 0,
                    totalCycleCount, true, false,
                    hasFunctionsOfInterest ? &instructionExecutionCounts
                                           : nullptr);
            } else {
                simulate(
                    *scheduledProgram, *adf, testApplication, 0,
                    totalCycleCount, false, false,
                    hasFunctionsOfInterest ? &instructionExecutionCounts
                                           : nullptr);
            }
 
            //std::cerr << "DEBUG: simulated" << std::endl;
            // verify the simulation
            if (testApplication.hasCorrectOutput()) {
                string correctResult =
                    StringTools::trim(testApplication.correctOutput());
                string resultString = StringTools::trim(oStream_->str());
                if (resultString != correctResult) {
                    std::cerr << "Simulation FAILED, possible bug in scheduler!"
                              << std::endl;
                    std::cerr << "Architecture id in DSDB:" << std::endl;
                    std::cerr << configuration.architectureID << std::endl;
                    std::cerr << "use sqlite3 to find out which configuration "
                              << "has that id to get the machine written to "
                              << "ADF." << std::endl;
                    // @todo Do a method into DSDBManager to find out the
                    //       configuration ID.
                    std::cerr << "********** result found:" << std::endl;
                    std::cerr << resultString << std::endl;
                    std::cerr << "********** expected result:" << std::endl;
                    std::cerr << correctResult << std::endl;
                    std::cerr << "**********" << std::endl;
                    delete idf;
                    idf = NULL;
                    delete adf;
                    adf = NULL;
                    return false;
                }
                // std::cerr << "DEBUG: simulation OK" << std::endl;
                // reset the stream pointer in to the beginning and empty the
                // stream
                oStream_->str("");
                oStream_->seekp(0);
            }
 
            // Accumulate the cycle counts from functions of interest,
            // if defined in the application.
            ClockCycleCount cycleCountOfInterest = totalCycleCount;
            if (hasFunctionsOfInterest) {
                cycleCountOfInterest = (ClockCycleCount)(0);
                size_t instructionCount =
                    scheduledProgram->instructionVector().size();
                assert(instructionExecutionCounts.size() == instructionCount);
                auto& interestingProcedures =
                    testApplication.functionsOfInterest();
                for (const auto& procName : interestingProcedures) {
                    if (!scheduledProgram->hasProcedure(procName)) continue;
                    TTAProgram::Procedure& proc =
                        scheduledProgram->procedure(procName);
                    ClockCycleCount procCycles = 0;
                    for (auto i = proc.startAddress().location();
                         i <= proc.endAddress().location(); ++i) {
                        procCycles += instructionExecutionCounts[i];
                    }
                    if (Application::increasedVerbose()) {
                        Application::logStream()
                            << "[Procedure: " << procName
                            << ", size: " << proc.instructionCount()
                            << " cc: " << procCycles << "] " << std::endl;
                    }
                    cycleCountOfInterest += procCycles;
                }
            }
 
            // add simulated cycle count to dsdb
            dsdb_->addCycleCount(
                (*i), configuration.architectureID, cycleCountOfInterest);
 
            if (configuration.hasImplementation && estimate) {
                // energy estimate the simulated program
                EnergyInMilliJoules programEnergy =
                    estimator_.totalEnergy(
                        *adf, *idf, *scheduledProgram, *traceDB);
                dsdb_->addEnergyEstimate(
                    (*i), configuration.implementationID, programEnergy);
                result.setEnergy(*scheduledProgram, programEnergy);
            }
            delete traceDB;
            traceDB = NULL;
        }
    } catch (const Exception& e) {
        delete adf;
        adf = NULL;
        delete idf;
        idf = NULL;
        debugLog(e.errorMessageStack());
        return false;
    }
    delete idf;
    idf = NULL;
    delete adf;
    adf = NULL;
    return true;
}

References __func__, DSDBManager::addCycleCount(), DSDBManager::addEnergyEstimate(), DSDBManager::applicationIDs(), TestApplication::applicationPath(), DSDBManager::applicationPath(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, assert, TestApplication::correctOutput(), createEstimateData(), debugLog, dsdb_, TTAProgram::CodeSnippet::endAddress(), Exception::errorMessageStack(), estimator_, TestApplication::functionsOfInterest(), TestApplication::hasCorrectOutput(), DSDBManager::hasCycleCount(), TestApplication::hasFunctionsOfInterest(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::implementation(), DSDBManager::MachineConfiguration::implementationID, Application::increasedVerbose(), TTAProgram::CodeSnippet::instructionCount(), DSDBManager::isUnschedulable(), TTAProgram::Address::location(), Application::logStream(), oStream_, schedule(), CostEstimates::setArea(), DSDBManager::setAreaEstimate(), CostEstimates::setEnergy(), CostEstimates::setLongestPathDelay(), DSDBManager::setLongestPathDelayEstimate(), DSDBManager::setUnschedulable(), simulate(), TTAProgram::CodeSnippet::startAddress(), CostEstimator::Estimator::totalEnergy(), and StringTools::trim().

Referenced by MinimizeMachine::evalNewConfigWithoutImplementation(), Evaluate::explore(), GrowMachine::explore(), MinimalOpSet::explore(), ConnectionSweeper::explore(), SimpleICOptimizer::explore(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeMachine(), MinimizeMachine::minimizeRegisterFiles(), ConnectionSweeper::removeAllConnections(), and ConnectionSweeper::removeLeastNecessaryConnections().

Here is the call graph for this function:

getPlugins()

std::vector< DesignSpaceExplorerPlugin * > DesignSpaceExplorer::getPlugins

(

)

Parses the plugin search directories and loads all available plugins

Definition at line 596 of file DesignSpaceExplorer.cc.

                                                                      {
    
    std::vector<DesignSpaceExplorerPlugin*> plugins;
    vector<string> found_plugins;
    vector<string> searchPaths = Environment::explorerPluginPaths();
    for (vector<string>::const_iterator iter = searchPaths.begin();
            iter != searchPaths.end(); iter++) {
 
        if (FileSystem::fileExists(*iter)) {
            FileSystem::findFromDirectory(".*\\.so$", *iter, found_plugins);
        }
    }
    for (unsigned int i = 0; i < found_plugins.size(); ++i) {
        std::string pluginName = FileSystem::fileNameBody(found_plugins[i]);
        DesignSpaceExplorerPlugin* plugin = loadExplorerPlugin(pluginName, NULL);
        if (!plugin) {
            continue;
        }
        
        plugins.push_back(plugin);
    }
    
    return plugins;
}

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

Here is the call graph for this function:

loadExplorerPlugin()

DesignSpaceExplorerPlugin * DesignSpaceExplorer::loadExplorerPlugin ( const std::string &  pluginName, DSDBManager *  dsdb = NULL  )

static

Loads the given explorer plugin from the default search pathes of the explorer plugins.

Searches for file named the plugin with an extension ".so". e.g. if the plugin is namen SimplePlugin is the file SimplePlugin.so loaded. Plugins are searched from the default search pathes of explorer plugins.

Parameters

pluginName	Name of the plugin to be loaded.
dsdb	DSDBManager to be used by the plugin.

Returns

Returns the loaded DesignSpacsExplorerPlugin instance.

Exceptions

FileNotFound	If the given plugin is not found from the search paths of explorer plugins.
DynamicLibraryException	If the dynamic library cannot be opened.

Definition at line 566 of file DesignSpaceExplorer.cc.

                                                    {
    string pluginFileName = pluginName + ".so";
    vector<string> searchPaths = Environment::explorerPluginPaths();
    for (vector<string>::const_iterator iter = searchPaths.begin();
         iter != searchPaths.end(); iter++) {
        
        if (FileSystem::fileExists(*iter)) {
            pluginTool_.addSearchPath(*iter);
        }
    }
    pluginTool_.registerModule(pluginFileName);
        DesignSpaceExplorerPlugin* (*pluginCreator)();
        pluginTool_.importSymbol(
                "create_explorer_plugin_" + pluginName, pluginCreator, 
                pluginFileName);
 
    DesignSpaceExplorerPlugin* plugin = pluginCreator();
    if (dsdb) {
        plugin->setDSDB(*dsdb);
    }
    return plugin;
}

References PluginTools::addSearchPath(), Environment::explorerPluginPaths(), FileSystem::fileExists(), PluginTools::importSymbol(), pluginTool_, PluginTools::registerModule(), and setDSDB().

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), ADFCombiner::explore(), FrequencySweepExplorer::explore(), SimpleICOptimizer::explore(), getPlugins(), and loadExplorerPlugin().

Here is the call graph for this function:

schedule()

TTAProgram::Program * DesignSpaceExplorer::schedule ( const std::string  bytecodeFile, TTAMachine::Machine &  target, TCEString  paramOptions = "-O3"  )

protected

Compiles the given application bytecode file on the given target machine.

Parameters

bytecodeFile	Bytecode filename with path.
target	The machine to compile the sequential program against.
paramOptions	Compiler options (if cmdline options are not given)

Returns

Scheduled parallel program or NULL if scheduler produced exeption.

Definition at line 354 of file DesignSpaceExplorer.cc.

                            {
 
    TCEString compilerOptions;
    
    ExplorerCmdLineOptions* options = 
        dynamic_cast<ExplorerCmdLineOptions*>(Application::cmdLineOptions());
    if (options != NULL) {
        if (options->compilerOptions()) {
            compilerOptions = options->compilerOptionsString();
        // use compiler options given by method parameters (-O3 by default)
        } else {
            compilerOptions = paramOptions;
        }
    }
    // If compiler options did not provide optimization, we use default.
    if (compilerOptions.find("-O") == std::string::npos) {
        compilerOptions += " -O3";        
    }
    static const std::string DS = FileSystem::DIRECTORY_SEPARATOR;
    
    // create temp directory for the target machine
    std::string tmpDir = FileSystem::createTempDirectory();
 
    // write machine to a file for tcecc
    std::string adf = tmpDir + DS + "mach.adf";
    std::string tpef = tmpDir + DS + "program.tpef";
    ADFSerializer serializer;
    serializer.setDestinationFile(adf);
    try {
        serializer.writeMachine(target);
    } catch (const SerializerException& exception) {
        FileSystem::removeFileOrDirectory(tmpDir);
        throw IOException(
            __FILE__, __LINE__, __func__, exception.errorMessage());
    }     
    // call tcecc to compile, link and schedule the program
    std::vector<std::string> tceccOutputLines;
    std::string tceccPath = Environment::tceCompiler();
    std::string tceccCommand = tceccPath + " "  
        + compilerOptions + " --no-link -a " + adf + " -o " 
        + tpef + " " + bytecodeFile + " --no-plugin-cache 2>&1";
 
    const bool debug = Application::verboseLevel() > 0;
 
    Application::runShellCommandAndGetOutput(tceccCommand, tceccOutputLines);
 
    if (debug && tceccOutputLines.size() > 0) {
        for (unsigned int i = 0; i < tceccOutputLines.size(); ++i) {
            std::cout << tceccOutputLines.at(i) << std::endl;
        }
    }
    
    // check if tcecc produced any tpef output
    if (!(FileSystem::fileExists(tpef) && FileSystem::fileIsReadable(tpef))) {
        if (debug) {
            std::cout << "failed command: " << tceccCommand << std::endl
                      << "temporary directory left for inspection at: " 
                      << tmpDir << std::endl;
        } else {
            FileSystem::removeFileOrDirectory(tmpDir);            
        }
        return NULL;    
    } 
    
    TTAProgram::Program* prog = NULL;
    try {
        prog = TTAProgram::Program::loadFromTPEF(tpef, target);
    } catch (const Exception& e) {
        FileSystem::removeFileOrDirectory(tmpDir);
        IOException error(__FILE__, __LINE__,__func__, e.errorMessage());
        error.setCause(e);
        throw error;
    }
    FileSystem::removeFileOrDirectory(tmpDir);    
    return prog;        
}

References __func__, Application::cmdLineOptions(), FileSystem::createTempDirectory(), FileSystem::DIRECTORY_SEPARATOR, DS, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileIsReadable(), TTAProgram::Program::loadFromTPEF(), options, FileSystem::removeFileOrDirectory(), Application::runShellCommandAndGetOutput(), Exception::setCause(), XMLSerializer::setDestinationFile(), Environment::tceCompiler(), Application::verboseLevel(), and ADFSerializer::writeMachine().

Referenced by evaluate(), and SimpleICOptimizer::explore().

Here is the call graph for this function:

selectComponents()

IDF::MachineImplementation * DesignSpaceExplorer::selectComponents	(	const TTAMachine::Machine &	mach,
		const double &	frequency = 0.0,
		const double &	maxArea = 0.0,
		const std::string &	icDec = "DefaultICDecoder",
		const std::string &	icDecHDB = "asic_130nm_1.5V.hdb"
	)		const

Selects components for a machine, creates a idf.

Parameters

mach	Target machine for which components are selected.
frequency	The minimum frequency of the implementations.
maxArea	Maximum area for implementations.
icDec	IC decoder to be used.
icDecHDB	IC decoder HDB file.

Returns

Machine Implementation pointer if ok, else NULL.

Definition at line 737 of file DesignSpaceExplorer.cc.

                                     {
 
    ComponentImplementationSelector impSelector;
    IDF::MachineImplementation* idf = NULL;
 
    try {
        // TODO: check that idf is deleted when it has been written to the
        // dsdb, and not in use anymore (selectComponents reserves it with
        // new)
        idf = impSelector.selectComponents(&mach, icDec,
                icDecHDB, frequency, maxArea);
    } catch (const Exception& e) {
        debugLog(e.errorMessage());
        if (idf != NULL) {
            delete idf;
            idf = NULL;
        }
    }
 
    return idf;
}

References debugLog, Exception::errorMessage(), and ComponentImplementationSelector::selectComponents().

Referenced by createImplementation(), and createImplementationAndStore().

Here is the call graph for this function:

setDSDB()

void DesignSpaceExplorer::setDSDB ( DSDBManager &  dsdb )

virtual

Sets new design space database.

Parameters

dsdb	Design space database to be used with the explorer.

Definition at line 109 of file DesignSpaceExplorer.cc.

                                              {
 
    dsdb_ = &dsdb;
}

References dsdb_.

Referenced by BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), GrowMachine::explore(), loadExplorerPlugin(), MinimizeMachine::minimizeBuses(), MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeRegisterFiles(), and CallExplorerPluginWindow::onRun().

simulate()

const ExecutionTrace * DesignSpaceExplorer::simulate ( const TTAProgram::Program &  program, const TTAMachine::Machine &  machine, const TestApplication &  testApplication, const ClockCycleCount &  maxCycles, ClockCycleCount &  runnedCycles, const bool  tracing, const bool  useCompiledSimulation = false, std::vector< ClockCycleCount > *  instructionExecutionCounts = NULL  )

protected

Simulates the parallel program.

Simulates the target machine as long as the program runs or the maximum cycle count is reached. If maximum cycle count is reached an exception is thrown.

Parameters

program	Sequential program.
machine	Target machine.
testApplication	Test application directory.
maxCycles	Maximum amount of clock cycles that program is allowed to run. Not used by this implementation.
runnedCycles	Simulated cycle amount is stored here.
tracing	Flag indicating is the tracing used.

Returns

Execution trace of the program.

Exceptions

Exception

All exceptions produced by simulator engine except SimulationCycleLimitReached in case of max cycles are reached without program finishing and SimulationTimeOut in case of simulation is killed after simulating maximum time that is currently 10h.

Definition at line 455 of file DesignSpaceExplorer.cc.

                                                            {
    // initialize the simulator
    SimulatorFrontend simulator(
        useCompiledSimulation ? 
        SimulatorFrontend::SIM_COMPILED : 
        SimulatorFrontend::SIM_NORMAL);
    
    // setting simulator timeout in seconds
    simulator.setTimeout(480);
 
    // use memory file in sqlite
    // TODO: should use a tmp dir as now TraceDB produces multiple
    // text files, thus only the SQL part goes to memory
    const string traceFile = ":memory:";
    simulator.forceTraceDBFileName(traceFile);
    if (!useCompiledSimulation)
        simulator.setRFAccessTracing(tracing);
    simulator.setUtilizationDataSaving(tracing);
    simulator.setExecutionTracing(tracing);
 
    simulator.loadMachine(machine);
    simulator.loadProgram(program);
    // run the 'setup.sh' in the test application directory
    testApplication.setupSimulation();
    // if there is 'simulate.ttasim' file in the application dir we use that
    if (testApplication.hasSimulateTTASim()) {
        std::string command = "";
        std::istream* input = testApplication.simulateTTASim();
        BaseLineReader reader(*input, *oStream_);
        reader.initialize();
        reader.setPromptPrinting(false);
        SimulatorInterpreterContext interpreterContext(simulator);
        SimulatorInterpreter interpreter(0, NULL, interpreterContext, reader);
        while (!interpreter.isQuitCommandGiven()) {
            try {
                command = reader.readLine();
            } catch (const EndOfFile&) {
                interpreter.interpret(SIM_INTERP_QUIT_COMMAND);
                if (interpreter.result().size() > 0) {
                    *oStream_ << interpreter.result() << std::endl;
                }
                break;
            }
            command = StringTools::trim(command);
            if (command == "") {
                continue;
            }
            interpreter.interpret(command);
            if (interpreter.result().size() > 0) {
                *oStream_ << interpreter.result() << std::endl;
            }
        }
        delete input;
        input = NULL;
    } else {
        // no 'simulate.ttasim' file
        BaseLineReader reader(std::cin, *oStream_);
        reader.initialize();
        SimulatorInterpreterContext interpreterContext(simulator);
        SimulatorInterpreter interpreter(0, NULL, interpreterContext, reader);
        simulator.run();
        if (interpreter.result().size() > 0) {
            *oStream_ << interpreter.result() << std::endl;
        }
    }
 
    runnedCycles = simulator.cycleCount();
 
    int instructionCount = program.instructionVector().size();
    if (instructionExecutionCounts != nullptr) {
        instructionExecutionCounts->resize(instructionCount, 0);
        for (int i = 0; i < instructionCount; ++i) {
            (*instructionExecutionCounts)[i] =
                simulator.executableInstructionAt(i).executionCount();
        }
    }
 
    // Flush data collected during simulation to the trace file.
    const ExecutionTrace* db = NULL;
    if (tracing) {
        db = simulator.lastTraceDB();
    }
    
    simulator.killSimulation();
    
    return db;
}

References SimulatorFrontend::cycleCount(), db(), SimulatorFrontend::executableInstructionAt(), ExecutableInstruction::executionCount(), SimulatorFrontend::forceTraceDBFileName(), TestApplication::hasSimulateTTASim(), BaseLineReader::initialize(), TclInterpreter::interpret(), SimulatorInterpreter::isQuitCommandGiven(), SimulatorFrontend::killSimulation(), SimulatorFrontend::lastTraceDB(), SimulatorFrontend::loadMachine(), SimulatorFrontend::loadProgram(), machine, oStream_, program, BaseLineReader::readLine(), ScriptInterpreter::result(), SimulatorFrontend::run(), SimulatorFrontend::setExecutionTracing(), BaseLineReader::setPromptPrinting(), SimulatorFrontend::setRFAccessTracing(), SimulatorFrontend::setTimeout(), TestApplication::setupSimulation(), SimulatorFrontend::setUtilizationDataSaving(), SimulatorFrontend::SIM_COMPILED, SIM_INTERP_QUIT_COMMAND, SimulatorFrontend::SIM_NORMAL, TestApplication::simulateTTASim(), and StringTools::trim().

Referenced by evaluate().

Here is the call graph for this function:

Member Data Documentation

dsdb_

DSDBManager* DesignSpaceExplorer::dsdb_

private

Design space database where results are stored.

Definition at line 131 of file DesignSpaceExplorer.hh.

Referenced by addConfToDSDB(), createImplementation(), createImplementationAndStore(), db(), evaluate(), and setDSDB().

dummyEstimate_

CostEstimates DesignSpaceExplorer::dummyEstimate_

staticprivate

Used for the default evaluate() argument.

Definition at line 139 of file DesignSpaceExplorer.hh.

estimator_

CostEstimator::Estimator DesignSpaceExplorer::estimator_

private

The estimator frontend.

Definition at line 135 of file DesignSpaceExplorer.hh.

Referenced by createEstimateData(), and evaluate().

oStream_

std::ostringstream* DesignSpaceExplorer::oStream_

private

Output stream.

Definition at line 137 of file DesignSpaceExplorer.hh.

Referenced by DesignSpaceExplorer(), evaluate(), simulate(), and ~DesignSpaceExplorer().

pluginTool_

PluginTools DesignSpaceExplorer::pluginTool_

staticprivate

The plugin tool.

Definition at line 133 of file DesignSpaceExplorer.hh.

Referenced by loadExplorerPlugin().

---

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

• DesignSpaceExplorer.hh
• DesignSpaceExplorer.cc