MinimizeMachine Class Reference

Inheritance diagram for MinimizeMachine:

Collaboration diagram for MinimizeMachine:

Private Member Functions
	PLUGIN_DESCRIPTION ("Removes resources until the real time " "requirements of applications are not reached anymore.")
	MinimizeMachine ()
virtual bool	requiresStartingPointArchitecture () const
virtual bool	producesArchitecture () const
virtual bool	requiresHDB () const
virtual bool	requiresSimulationData () const
virtual std::vector< RowID >	explore (const RowID &configurationID, const unsigned int &)
void	readParameters ()
RowID	minimizeMachine (RowID confToMinimize)
RowID	minimizeBuses (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
RowID	minimizeRegisterFiles (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
RowID	minimizeFunctionUnits (RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
bool	evalNewConfigWithoutImplementation (DesignSpaceExplorer &explorer, const TTAMachine::Machine &mach, DSDBManager &dsdb, DSDBManager::MachineConfiguration &newConfiguration, RowID &confID, CostEstimates &newEstimates)
bool	checkCycleCounts (const DSDBManager::MachineConfiguration &conf, const std::vector< ClockCycleCount > &maxCycleCounts)

Private Attributes
bool	minBus_
	minimize busses
bool	minFU_
	minimize function units
bool	minRF_
	minimize register files
unsigned int	frequency_
	running frequency in MHz for apps

Static Private Attributes
static const std::string	minBusPN_
static const std::string	minFUPN_
static const std::string	minRFPN_
static const std::string	frequencyPN_

Additional Inherited Members
Public Types inherited from DesignSpaceExplorerPlugin
typedef std::pair< std::string, ExplorerPluginParameter >	Parameter
typedef std::map< std::string, ExplorerPluginParameter >	ParameterMap
typedef std::map< std::string, ExplorerPluginParameter >::iterator	PMIt
typedef std::map< std::string, ExplorerPluginParameter >::const_iterator	PMCIt
Public Member Functions inherited from DesignSpaceExplorerPlugin
virtual bool	requiresApplication () const
virtual std::string	description () const
void	addParameter (TCEString name, ExplorerPluginParameterType type, bool compulsory=true, TCEString defaultValue="", TCEString description="")
template<typename T >
void	readCompulsoryParameter (const std::string paramName, T &param) const
template<typename T >
void	readOptionalParameter (const std::string paramName, T &param) const
template<typename RT >
RT	parameterValue (const std::string &paramName) const
virtual	~DesignSpaceExplorerPlugin ()
virtual void	giveParameter (const std::string &name, const std::string &value)
virtual std::string	name () const
virtual void	setPluginName (const std::string &pluginName)
virtual bool	hasParameter (const std::string &paramName) const
ParameterMap	parameters () const
virtual bool	booleanValue (const std::string &parameter) const
Public Member Functions inherited from DesignSpaceExplorer
	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 inherited from DesignSpaceExplorer
static DesignSpaceExplorerPlugin *	loadExplorerPlugin (const std::string &pluginName, DSDBManager *dsdb=NULL)
Protected Member Functions inherited from DesignSpaceExplorerPlugin
	DesignSpaceExplorerPlugin ()
void	checkParameters () const
Protected Member Functions inherited from DesignSpaceExplorer
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)
Protected Attributes inherited from DesignSpaceExplorerPlugin
std::string	pluginName_
	the name of the explorer plugin
ParameterMap	parameters_
	Parameters for the plugin.

Detailed Description

Explorer plugin that removes resources until the real time requirements of applications are not reached anymore.

@TODO: maxRunTime parameter, which overrides app dir max runtime setting @TODO: if no maxRunTime then no frequency is needed == no cycle count limits

Supported parameters:

• min_bus, boolean for do minimize busses minimization, default true.
• min_fu, boolean for do minimize FUs minimization, default true.
• min_rf, boolean for do minimize RFs minimization, default true.
• frequency, running frequency for applications.

Definition at line 70 of file MinimizeMachine.cc.

Constructor & Destructor Documentation

MinimizeMachine()

MinimizeMachine::MinimizeMachine ( )

inlineprivate

Definition at line 74 of file MinimizeMachine.cc.

                     : DesignSpaceExplorerPlugin(), 
        minBus_(true),
        minFU_(true),
        minRF_(true),
        frequency_(0) {
 
        // compulsory parameters
        addParameter(frequencyPN_, UINT);
 
        // parameters that have a default value
        addParameter(minBusPN_, BOOL, false, Conversion::toString(minBus_));
        addParameter(minFUPN_, BOOL, false, Conversion::toString(minFU_));
        addParameter(minRFPN_, BOOL, false, Conversion::toString(minRF_));
    }

References DesignSpaceExplorerPlugin::addParameter(), BOOL, frequencyPN_, minBus_, minBusPN_, minFU_, minFUPN_, minRF_, minRFPN_, Conversion::toString(), and UINT.

Here is the call graph for this function:

Member Function Documentation

checkCycleCounts()

bool MinimizeMachine::checkCycleCounts ( const DSDBManager::MachineConfiguration &  conf, const std::vector< ClockCycleCount > &  maxCycleCounts  )

inlineprivate

Checks that max cycle counts are not exceeded.

Expects that maxCycleCount vector contains cycle counts for the matching programs in the same order as the estimates.

Parameters

estimates	Estimations that contain cycle counts.
maxCycleCounts	Maximum cycle counts of the applications.

Returns

true if maximum cycle counts are not exceeded, false otherwise.

Definition at line 701 of file MinimizeMachine.cc.

                                                          {
 
 
        std::vector<ClockCycleCount> cycleCounts;
        std::set<RowID> appIds = db().applicationIDs();
        for (std::set<RowID>::const_iterator appI = appIds.begin(); 
             appI != appIds.end(); ++appI) {
            RowID appID = *appI;
            if (!db().hasCycleCount(appID, conf.architectureID)) {
                abortWithError("there was no cycle count?");
            }
            cycleCounts.push_back(
                db().cycleCount(appID, conf.architectureID));
        }
 
        for (int i = 0; i < (int)cycleCounts.size(); i++) {
            // if no time constraints
            if (maxCycleCounts.at(i) < 1) {
                continue;
            }
            // if some apps maxCycles was exceeded
            if (maxCycleCounts.at(i) < cycleCounts.at(i)) {
                return false;
            }
        }
        return true;
    }

References abortWithError, DSDBManager::applicationIDs(), DSDBManager::MachineConfiguration::architectureID, DesignSpaceExplorer::db(), and DSDBManager::hasCycleCount().

Referenced by minimizeBuses(), minimizeFunctionUnits(), and minimizeRegisterFiles().

Here is the call graph for this function:

evalNewConfigWithoutImplementation()

bool MinimizeMachine::evalNewConfigWithoutImplementation ( DesignSpaceExplorer &  explorer, const TTAMachine::Machine &  mach, DSDBManager &  dsdb, DSDBManager::MachineConfiguration &  newConfiguration, RowID &  confID, CostEstimates &  newEstimates  )

inlineprivate

Create, store and evaluate a new configuration without implementation.

Parameters

explorer	Design space explorer to use to evaluate.
mach	machine for the new configuration.
dsdb	Design space database to store the new configuration.
newConfiguration	New machine configuration.
confID	Row ID of the new configuration in the DSDB.
newEstimates	Estimates that are calculated during evaluation.

Returns

true if evaluation succeed, if not, return false.

Definition at line 669 of file MinimizeMachine.cc.

                                                    {
        try {
            newConfiguration.architectureID = dsdb.addArchitecture(mach);
        } catch (const RelationalDBException& e) {
            // Error occurred while adding adf to the dsdb, adf
            // probably too big
            throw e;
        }
        newConfiguration.hasImplementation = false;
 
        try {
            confID = dsdb.addConfiguration(newConfiguration);
        } catch (const KeyNotFound& e) {
            throw e;
        }
 
    return explorer.evaluate(newConfiguration, newEstimates, false);
    }

References DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::MachineConfiguration::architectureID, DesignSpaceExplorer::evaluate(), and DSDBManager::MachineConfiguration::hasImplementation.

Referenced by minimizeFunctionUnits(), and minimizeRegisterFiles().

Here is the call graph for this function:

explore()

virtual std::vector< RowID > MinimizeMachine::explore ( const RowID &  configurationID, const unsigned int &    )

inlineprivatevirtual

Minimizes given configuration by not exceeding applications max runtime which depends on given frequncy

Reimplemented from DesignSpaceExplorerPlugin.

Definition at line 99 of file MinimizeMachine.cc.

                                                               {
        std::vector<RowID> result;
 
        readParameters();
 
        // TODO: make better parameter error function
        if (frequency_ < 1) {
            result.push_back(configurationID);
            return result;
        }
 
        RowID min = minimizeMachine(configurationID);
 
        result.push_back(min);
        return result;
    }

References frequency_, minimizeMachine(), and readParameters().

Here is the call graph for this function:

minimizeBuses()

RowID MinimizeMachine::minimizeBuses ( RowID  confToMinimize, std::vector< ClockCycleCount > &  maxCycleCounts  )

inlineprivate

Reduces the number of buses in the machine as much as possible to still achieve the application run time requirements.

This function can handle implementations. Uses binary search to minimize the buses.

Parameters

confToMinimize	ID of the machine configuration which buses are reduced.
maxCycleCounts	Max cycle counts per program.

Returns

ID of the new congiguration where buses are reduced.

Definition at line 228 of file MinimizeMachine.cc.

                                                    {
        
        DSDBManager& dsdb = db();
 
        DSDBManager::MachineConfiguration configuration =
            dsdb.configuration(confToMinimize);
        
        TTAMachine::Machine* mach = NULL;
        try {
            mach = dsdb.architecture(configuration.architectureID);
        } catch (const Exception& e) {
            debugLog(std::string("No machine architecture found in config id "
                        "by MimimizeMachine plugin. "));
            delete mach;
            return confToMinimize;
        }
 
        TTAMachine::Machine::BusNavigator busNav = mach->busNavigator();
 
        // can't reduce buses from one
        int origBusCount = busNav.count();
        if (origBusCount < 2) {
            return confToMinimize;
        }
 
        DesignSpaceExplorer explorer;
        explorer.setDSDB(dsdb);
 
        CostEstimates estimates;
       
        // new configuration must be created
        DSDBManager::MachineConfiguration startConf;
        startConf.architectureID = dsdb.addArchitecture(*mach);
        startConf.hasImplementation = false;
 
        if (!explorer.evaluate(startConf, estimates, false)) {
            delete mach;
            mach = NULL;
            // return the original conf
            return confToMinimize;
        }
 
        // check if some apps maxCycles was exceeded
        if (!checkCycleCounts(startConf, maxCycleCounts)) {
            delete mach;
            mach = NULL;
            // return the original conf
            return confToMinimize;
        }
         
        MachineResourceModifier modifier;
 
        // variables for binary search    
        int busHigh = origBusCount;
        int busLow = 1;
        int busMid = (busLow + busHigh) /2;
 
        TTAMachine::Machine* newMach = NULL;
        RowID lastArchID = 0;
        RowID lastConfID = 0;
        RowID lastOKArchID = 0;
        RowID lastOKConfID = 0;
 
        std::list<std::string> removedBusNames;
 
        // use binary search to find out the bus count that can be removed
        // removes busses as long as each apps max cycle counts are not exceeded
        // if buses are not of equal value this doesn't really work.
        do {
            assert(newMach == NULL);
            newMach = new TTAMachine::Machine(*mach);
 
            int busesToRemove = (origBusCount - busMid);
 
            if (!modifier.removeBuses(busesToRemove, *newMach, removedBusNames)) {
                // TODO: some good way to cope with non complete bus removal
            }
 
            DSDBManager::MachineConfiguration newConfiguration;
            try {
                lastArchID = dsdb.addArchitecture(*newMach);
                // machine stored to dsdb can be deleted
                delete newMach;
                newMach = NULL;
            } catch (const RelationalDBException& e) {
                // Error occurred while adding adf to the dsdb, adf
                // probably too big
                delete newMach;
                newMach = NULL;
                break;
            }
 
            newConfiguration.architectureID = lastArchID;
            newConfiguration.hasImplementation = false;
            try {
                lastConfID = dsdb.addConfiguration(newConfiguration);
            } catch (const KeyNotFound& e) {
                break;
            }
            CostEstimates newEstimates;
 
            bool newConfigOK = false;
            if (explorer.evaluate(newConfiguration, newEstimates, false)) {
                // goes through every apps new cycles
                newConfigOK = 
                    checkCycleCounts(newConfiguration, maxCycleCounts);
            } 
 
            if (newConfigOK) {
                busHigh = busMid - 1;
                busMid = (busLow + busMid) / 2;
                lastOKArchID = lastArchID;
                lastOKConfID = lastConfID;
            } else {
                busLow = busMid + 1;
                busMid = (busMid + busHigh) / 2;
            }
        } while (busLow <= busHigh && busLow <= busMid);
 
        // these aren't needed anymore
        lastArchID = 0;
        lastConfID = 0;
 
        // delete old machine
        delete mach;
        mach = NULL;
        
        // check if no new architecture/config could be created
        if (lastOKArchID == 0) {
            return confToMinimize;
        }
        
        // create new idf for the new machine if needed
        if (configuration.hasImplementation) {
            IDF::MachineImplementation* idf =
                dsdb.implementation(configuration.implementationID);
 
            // remove removed busses from orginal implementation file
            std::list<std::string>::const_iterator busNameIter = 
                removedBusNames.begin();
            while (busNameIter != removedBusNames.end()) {
                idf->removeBusImplementation(*busNameIter);
                busNameIter++;
            }
 
            DSDBManager::MachineConfiguration newConfiguration;
            newConfiguration.architectureID = lastOKArchID;
 
            CostEstimates newEstimates;
            if (explorer.evaluate(newConfiguration, newEstimates, false)) {
                newConfiguration.implementationID = 
                    dsdb.addImplementation(
                            *idf, newEstimates.longestPathDelay(),newEstimates.area());
 
                delete idf;
                idf = NULL;
 
                newConfiguration.hasImplementation = true;
                // add new configuration
                RowID confID = dsdb.addConfiguration(newConfiguration);
                return confID;
            } else {
                return confToMinimize;
            }
        } else {
            return lastOKConfID;
        }
 
        assert(false);
        return 9999; 
    }

References DSDBManager::addArchitecture(), DSDBManager::addConfiguration(), DSDBManager::addImplementation(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, CostEstimates::area(), assert, TTAMachine::Machine::busNavigator(), checkCycleCounts(), DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), DesignSpaceExplorer::db(), debugLog, DesignSpaceExplorer::evaluate(), DSDBManager::MachineConfiguration::hasImplementation, DSDBManager::implementation(), DSDBManager::MachineConfiguration::implementationID, CostEstimates::longestPathDelay(), MachineResourceModifier::removeBuses(), IDF::MachineImplementation::removeBusImplementation(), and DesignSpaceExplorer::setDSDB().

Referenced by minimizeMachine().

Here is the call graph for this function:

minimizeFunctionUnits()

RowID MinimizeMachine::minimizeFunctionUnits ( RowID  confToMinimize, std::vector< ClockCycleCount > &  maxCycleCounts  )

inlineprivate

Reduces the number of function units in the machine as much as possible to still achieve the application run time requirements.

This function won't handle implementations.

Parameters

confToMinimize	ID of the machine configuration which function units are reduced.
maxCycleCounts	Max cycle counts per program.

Returns

ID of the new congiguration where function units are reduced or same that was given if nothing was done.

Definition at line 544 of file MinimizeMachine.cc.

                                                        {
 
        DSDBManager& dsdb = db();
        RowID latestConfID = 0;
 
        MachineResourceModifier modifier;
        DesignSpaceExplorer explorer;
        explorer.setDSDB(dsdb);
 
        DSDBManager::MachineConfiguration configuration =
            dsdb.configuration(confToMinimize);
 
        const TTAMachine::Machine* origMach = NULL;
        try {
            origMach = dsdb.architecture(configuration.architectureID);
        } catch (const Exception& e) {
            debugLog(std::string("No machine architecture found in config id "
                        "by MimimizeMachine plugin. "));
            delete origMach;
            return confToMinimize;
        }
 
        MachineResourceModifier::FunctionUnitMap origFUMap;
        modifier.analyzeFunctionUnits(*origMach, origFUMap);
 
        CostEstimates estimates;
        DSDBManager::MachineConfiguration startConf;
        startConf.architectureID = dsdb.addArchitecture(*origMach);
        startConf.hasImplementation = false;
 
        if (!explorer.evaluate(startConf, estimates, false)) {
            // can't evaluate the given configuration
            delete origMach;
            origMach = NULL;
            return confToMinimize;
        }
 
        // check if some apps maxCycles was exceeded
        if (!checkCycleCounts(startConf, maxCycleCounts)) {
            delete origMach;
            origMach = NULL;
            return confToMinimize;
        }
 
        MachineResourceModifier::FunctionUnitMap::const_iterator fuMapIter =
            origFUMap.begin();
 
        ObjectState* currentState = origMach->saveState();
 
        // go through all different function unit types
        for (; fuMapIter != origFUMap.end(); fuMapIter++) {
            TTAMachine::Machine mach;
            mach.loadState(currentState);
            TTAMachine::Machine::FunctionUnitNavigator fuNav =
                mach.functionUnitNavigator();
            int i = 0;
            // go through every function unit in the machine to find matching FU
            while (i < fuNav.count()) {
                if (((*fuMapIter).second)->isArchitectureEqual(
                            fuNav.item(i), true)) {
 
                    mach.removeFunctionUnit(*fuNav.item(i));
                    std::list<std::string> socketList;
                    modifier.removeNotConnectedSockets(mach, socketList);
 
                    DSDBManager::MachineConfiguration newConfiguration;
                    RowID confID = 0;
                    CostEstimates newEstimates;
                    
                    // if the evaluation fails the removed FU is needed
                    // and the old machine state is loaded
                    if (!evalNewConfigWithoutImplementation(explorer, mach,
                            dsdb, newConfiguration, confID, newEstimates)) {
 
                        // continue with old machine state and
                        // try with next FU type
                        break;
                    }
 
                    // goes through every apps new cycles
                    if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
                        // continue with old machine state and
                        // try with next register file type
                        break;
                    }
                    latestConfID = confID;
 
                    // save the new machine state
                    delete currentState;
                    currentState = mach.saveState();
 
                    // continue removing same FU type
                    // no need to advance the FU navigator, 
                    // because of the removal
                    continue;
                }
                // if the units did not match, try next one in the machine
                i++;
            }
        }
        delete origMach;
        origMach = NULL;
        if (latestConfID != 0) {
            return latestConfID;
        } else {
            // no new config could be created
            return confToMinimize; 
        }
    }

References DSDBManager::addArchitecture(), MachineResourceModifier::analyzeFunctionUnits(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, checkCycleCounts(), DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), DesignSpaceExplorer::db(), debugLog, evalNewConfigWithoutImplementation(), DesignSpaceExplorer::evaluate(), TTAMachine::Machine::functionUnitNavigator(), DSDBManager::MachineConfiguration::hasImplementation, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadState(), TTAMachine::Machine::removeFunctionUnit(), MachineResourceModifier::removeNotConnectedSockets(), TTAMachine::Machine::saveState(), and DesignSpaceExplorer::setDSDB().

Referenced by minimizeMachine().

Here is the call graph for this function:

minimizeMachine()

RowID MinimizeMachine::minimizeMachine ( RowID  confToMinimize )

inlineprivate

Minimizes the number of buses, function units and register files in the given configuration in that order.

This function minimizes the buses first, then function units and then register files. Removes also the extra sockets after minimization. Won't handle implementaions (IDF handling missing from fu and rf part).

Parameters

confToMinimize	Configuration to be minimized.
maxCycles	Maximum clock cycle count that won't be exceeded.

Returns

Minimized configuration id.

Definition at line 157 of file MinimizeMachine.cc.

                                                {
 
        // calculate maxCycleCounts for all apps
        DSDBManager& dsdb = db();
        std::vector<ClockCycleCount> maxCycleCounts;
        std::set<RowID> applicationIDs = dsdb.applicationIDs();
        std::set<RowID>::const_iterator applicationIter;
        for (applicationIter = applicationIDs.begin();
                applicationIter != applicationIDs.end();
                applicationIter++) {
 
            TestApplication testApplication(
                    dsdb.applicationPath(*applicationIter));
 
            if (testApplication.maxRuntime() <= 0) {
                maxCycleCounts.push_back(0);
            } else {
                maxCycleCounts.push_back(
                    static_cast<ClockCycleCount>(
                        testApplication.maxRuntime() * 
                        static_cast<double>(frequency_) * 
                        static_cast<double>(1000000)));
            }
        }
    
        RowID orgConfToMinimize = confToMinimize;
        if (minBus_) {
            confToMinimize = minimizeBuses(confToMinimize, maxCycleCounts);
            CostEstimates res;
            evaluate(dsdb.configuration(confToMinimize), res, true);
        }
 
        if (minFU_) {
            confToMinimize = minimizeFunctionUnits(
                confToMinimize, 
                maxCycleCounts);
            CostEstimates res;            
            evaluate(dsdb.configuration(confToMinimize), res, true); 
        }
 
        if (minRF_) {
            confToMinimize = minimizeRegisterFiles(
                confToMinimize, 
                maxCycleCounts);
            CostEstimates res;            
            evaluate(dsdb.configuration(confToMinimize), res, true); 
        }
 
        if (orgConfToMinimize == confToMinimize) {
            debugLog(
                std::string("No new config could be generated by "
                            "MinimizeMachine plugin."));
        }
        CostEstimates res;            
        evaluate(dsdb.configuration(confToMinimize), res, true); 
        return confToMinimize;
    }

References DSDBManager::applicationIDs(), DSDBManager::applicationPath(), DSDBManager::configuration(), DesignSpaceExplorer::db(), debugLog, DesignSpaceExplorer::evaluate(), frequency_, TestApplication::maxRuntime(), minBus_, minFU_, minimizeBuses(), minimizeFunctionUnits(), minimizeRegisterFiles(), and minRF_.

Referenced by explore().

Here is the call graph for this function:

minimizeRegisterFiles()

RowID MinimizeMachine::minimizeRegisterFiles ( RowID  confToMinimize, std::vector< ClockCycleCount > &  maxCycleCounts  )

inlineprivate

Reduces the number of register files in the machine as much as possible to still achieve the application run time requirements.

This function won't handle implementations.

Parameters

confToMinimize	ID of the machine configuration which register files are reduced.
maxCycleCounts	Max cycle counts per program.

Returns

ID of the new congiguration where register files are reduced or same that was given if nothing was done.

Definition at line 414 of file MinimizeMachine.cc.

                                                        {
 
        DSDBManager& dsdb = db();
        RowID latestConfID = 0;
 
        MachineResourceModifier modifier;
        DesignSpaceExplorer explorer;
        explorer.setDSDB(dsdb);
 
        DSDBManager::MachineConfiguration configuration =
            dsdb.configuration(confToMinimize);
 
        const TTAMachine::Machine* origMach = NULL;
        try {
            origMach = dsdb.architecture(configuration.architectureID);
        } catch (const Exception& e) {
            debugLog(std::string("No machine architecture found in config id "
                        "by MimimizeMachine plugin. "));
            delete origMach;
            return confToMinimize;
        }
 
        MachineResourceModifier::RegisterMap origRegisterMap;
        modifier.analyzeRegisters(*origMach, origRegisterMap);
 
        CostEstimates estimates;
 
        DSDBManager::MachineConfiguration startConf;
        startConf.architectureID = dsdb.addArchitecture(*origMach);
        startConf.hasImplementation = false;
 
        // evaluates the desing with all dsdb apps
        if (!explorer.evaluate(startConf, estimates, false)) {
            // can't evaluate the given configuration
            delete origMach;
            origMach = NULL;
            return confToMinimize;
        }
        
        // check if some apps maxCycles was exceeded
        if (!checkCycleCounts(startConf, maxCycleCounts)) {
            delete origMach;
            origMach = NULL;
            return confToMinimize;
        }
 
        MachineResourceModifier::RegisterMap::const_iterator registerMapIter =
            origRegisterMap.begin();
 
        ObjectState* currentState = origMach->saveState();
        // go through all different register file types
        for (; registerMapIter != origRegisterMap.end(); registerMapIter++) {
            TTAMachine::Machine mach;
            mach.loadState(currentState);
            TTAMachine::Machine::RegisterFileNavigator rfNav =
                mach.registerFileNavigator();
 
            int i = 0;
            rfNav = mach.registerFileNavigator();
            // go through every register file in the machine to find matching RF
            while (i < rfNav.count()) {
                if (((*registerMapIter).second)->isArchitectureEqual(
                            *rfNav.item(i))) {
 
                    // remove the register file
                    mach.removeRegisterFile(*rfNav.item(i));
                    std::list<std::string> socketList;
                    modifier.removeNotConnectedSockets(mach, socketList);
 
                    DSDBManager::MachineConfiguration newConfiguration;
                    RowID confID = 0;
                    CostEstimates newEstimates;
                    
                    // if the evaluation fails the removed RF is needed
                    // and the old machine state is loaded
                    if (!evalNewConfigWithoutImplementation(explorer, mach,
                            dsdb, newConfiguration, confID, newEstimates)) {
 
                        // continue with old machine state and
                        // try with next register file type
                        break;
                    }
 
                    // check every apps new cycle counts against
                    // maxCycleCounts
                    if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
                        // continue with old machine state and
                        // try with next register file type
                        break;
                    }
                    latestConfID = confID;
 
                    // save the new machine state
                    delete currentState;
                    currentState = mach.saveState();
 
                    // else continue removing same register types
                    // no need to advance the rf navigator, 
                    // because of the removal
                    continue;
                }
                // if the registers did not match, try next one in the machine
                i++;
            }
        }
 
        delete origMach;
        origMach = NULL;
        if (latestConfID != 0) {
            return latestConfID;
        } else {
            // no new config could be created
            return confToMinimize; 
        }
    }

References DSDBManager::addArchitecture(), MachineResourceModifier::analyzeRegisters(), DSDBManager::architecture(), DSDBManager::MachineConfiguration::architectureID, checkCycleCounts(), DSDBManager::configuration(), TTAMachine::Machine::Navigator< ComponentType >::count(), DesignSpaceExplorer::db(), debugLog, evalNewConfigWithoutImplementation(), DesignSpaceExplorer::evaluate(), DSDBManager::MachineConfiguration::hasImplementation, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadState(), TTAMachine::Machine::registerFileNavigator(), MachineResourceModifier::removeNotConnectedSockets(), TTAMachine::Machine::removeRegisterFile(), TTAMachine::Machine::saveState(), and DesignSpaceExplorer::setDSDB().

Referenced by minimizeMachine().

Here is the call graph for this function:

PLUGIN_DESCRIPTION()

MinimizeMachine::PLUGIN_DESCRIPTION ( "Removes resources until the real time " "requirements of applications are not reached anymore."  )

private

producesArchitecture()

virtual bool MinimizeMachine::producesArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 90 of file MinimizeMachine.cc.

{ return true; }

readParameters()

void MinimizeMachine::readParameters ( )

inlineprivate

Reads the parameters given to the plugin.

Definition at line 135 of file MinimizeMachine.cc.

                          {
        readCompulsoryParameter(frequencyPN_, frequency_);
 
        readOptionalParameter(minBusPN_, minBus_);
        readOptionalParameter(minFUPN_, minFU_);
        readOptionalParameter(minRFPN_, minRF_);
    }

References frequency_, frequencyPN_, minBus_, minBusPN_, minFU_, minFUPN_, minRF_, minRFPN_, DesignSpaceExplorerPlugin::readCompulsoryParameter(), and DesignSpaceExplorerPlugin::readOptionalParameter().

Referenced by explore().

Here is the call graph for this function:

requiresHDB()

virtual bool MinimizeMachine::requiresHDB ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 91 of file MinimizeMachine.cc.

{ return true; }

requiresSimulationData()

virtual bool MinimizeMachine::requiresSimulationData ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 92 of file MinimizeMachine.cc.

{ return false; }

requiresStartingPointArchitecture()

virtual bool MinimizeMachine::requiresStartingPointArchitecture ( ) const

inlineprivatevirtual

Implements DesignSpaceExplorerPlugin.

Definition at line 89 of file MinimizeMachine.cc.

{ return true; }

Member Data Documentation

frequency_

unsigned int MinimizeMachine::frequency_

private

running frequency in MHz for apps

Definition at line 130 of file MinimizeMachine.cc.

Referenced by explore(), minimizeMachine(), and readParameters().

frequencyPN_

const std::string MinimizeMachine::frequencyPN_

staticprivate

Definition at line 121 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), and readParameters().

minBus_

bool MinimizeMachine::minBus_

private

minimize busses

Definition at line 124 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), minimizeMachine(), and readParameters().

minBusPN_

const std::string MinimizeMachine::minBusPN_

staticprivate

Definition at line 118 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), and readParameters().

minFU_

bool MinimizeMachine::minFU_

private

minimize function units

Definition at line 126 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), minimizeMachine(), and readParameters().

minFUPN_

const std::string MinimizeMachine::minFUPN_

staticprivate

Definition at line 119 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), and readParameters().

minRF_

bool MinimizeMachine::minRF_

private

minimize register files

Definition at line 128 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), minimizeMachine(), and readParameters().

minRFPN_

const std::string MinimizeMachine::minRFPN_

staticprivate

Definition at line 120 of file MinimizeMachine.cc.

Referenced by MinimizeMachine(), and readParameters().

---

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

• MinimizeMachine.cc