MachineResourceModifier Class Reference

#include <MachineResourceModifier.hh>

Collaboration diagram for MachineResourceModifier:

Public Types
typedef std::multimap< double, TTAMachine::Bus * >	BusMap
	Map of bus amounts in percents.
typedef std::multimap< double, TTAMachine::RegisterFile * >	RegisterMap
	Map of register amounts in percents.
typedef std::multimap< double, TTAMachine::FunctionUnit * >	FunctionUnitMap
	Map of function unit amounts in percents.

Public Member Functions
	MachineResourceModifier ()
virtual	~MachineResourceModifier ()
void	addBusesByAmount (int busesToAdd, TTAMachine::Machine &mach)
void	increaseAllRFsThatDiffersByAmount (int registersToAdd, TTAMachine::Machine &mach)
void	percentualRegisterIncrease (double percentsOfRegistersToAdd, TTAMachine::Machine &mach)
void	increaseAllFUsThatDiffersByAmount (int moreFUs, TTAMachine::Machine &mach)
void	percentualFUIncrease (double percentualFUIncrease, TTAMachine::Machine &mach)
void	reduceBuses (const int &busesToRemove, TTAMachine::Machine &mach, std::list< std::string > &removedBusNames)
bool	removeBuses (const int &countToRemove, TTAMachine::Machine &mach, std::list< std::string > &removedBusNames)
void	removeNotConnectedSockets (TTAMachine::Machine &mach, std::list< std::string > &removedSocketNames)
void	analyzeBuses (const TTAMachine::Machine &mach, BusMap &busMap) const
void	analyzeRegisters (const TTAMachine::Machine &mach, RegisterMap &registerMap) const
void	analyzeFunctionUnits (const TTAMachine::Machine &mach, FunctionUnitMap &unitMap) const

Private Member Functions
bool	hasSlot (const TTAMachine::Machine &mach, const std::string &slotName)

Detailed Description

Class that adds or removes resources of the given architecture.

Definition at line 49 of file MachineResourceModifier.hh.

Member Typedef Documentation

BusMap

typedef std::multimap<double, TTAMachine::Bus*> MachineResourceModifier::BusMap

Map of bus amounts in percents.

Definition at line 52 of file MachineResourceModifier.hh.

FunctionUnitMap

typedef std::multimap<double, TTAMachine::FunctionUnit*> MachineResourceModifier::FunctionUnitMap

Map of function unit amounts in percents.

Definition at line 56 of file MachineResourceModifier.hh.

RegisterMap

typedef std::multimap<double, TTAMachine::RegisterFile*> MachineResourceModifier::RegisterMap

Map of register amounts in percents.

Definition at line 54 of file MachineResourceModifier.hh.

Constructor & Destructor Documentation

MachineResourceModifier()

MachineResourceModifier::MachineResourceModifier

(

)

The constructor.

Definition at line 48 of file MachineResourceModifier.cc.

                                                 {
}

~MachineResourceModifier()

MachineResourceModifier::~MachineResourceModifier ( )

virtual

The destructor.

Definition at line 54 of file MachineResourceModifier.cc.

                                                  {
}

Member Function Documentation

addBusesByAmount()

void MachineResourceModifier::addBusesByAmount	(	int	busesToAdd,
		TTAMachine::Machine &	mach
	)

Adds given number of buses to the given architecture.

Determines the bus parameters in basis of the original architecture and the most common bus types are added first.

Parameters

busesToAdd

Number of buses to add. @mach Architecture where the buses are added.

Definition at line 67 of file MachineResourceModifier.cc.

                                             {
 
    BusMap busMap;
    analyzeBuses(mach, busMap);
 
    int addedBuses = 0;
    std::multimap<double, TTAMachine::Bus*>::const_iterator iter = busMap.end();
    while (iter != busMap.begin()) {
        iter--;
        if (addedBuses == busesToAdd) {
            break;
        }
        double numberToAdd = ceil((*iter).first * busesToAdd);
 
        while (numberToAdd > 0) {
            if (addedBuses < busesToAdd) {
                TTAMachine::Bus& original = *(*iter).second;
                TTAMachine::Bus* newBus = original.copy();
 
                int busNum = 0;
                std::string busBaseName = original.name();
                TTAMachine::Machine::BusNavigator busNavigator = 
                    mach.busNavigator();
                while (busNavigator.hasItem(
                           busBaseName + Conversion::toString(busNum))) {
                    busNum++;
                }
 
                newBus->setName(busBaseName + Conversion::toString(busNum));
                mach.addBus(*newBus);
 
                original.copyGuardsTo(*newBus);
                // Fully connect the machine.
                FullyConnectedCheck check;
                check.fix(mach);
                addedBuses++;
            }
            numberToAdd--;
        }
    }
}

References TTAMachine::Machine::addBus(), analyzeBuses(), TTAMachine::Machine::busNavigator(), TTAMachine::Bus::copy(), TTAMachine::Bus::copyGuardsTo(), FullyConnectedCheck::fix(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Component::name(), TTAMachine::Bus::setName(), and Conversion::toString().

Referenced by GrowMachine::explore().

Here is the call graph for this function:

analyzeBuses()

void MachineResourceModifier::analyzeBuses	(	const TTAMachine::Machine &	mach,
		BusMap &	busMap
	)		const

Analyzes the bus types of the architecture.

Parameters

mach	Machine to be analyzed.
busMap	Map where bus counts are stored.

Definition at line 272 of file MachineResourceModifier.cc.

                                                         {
 
    TTAMachine::Machine::BusNavigator busNavigator = mach.busNavigator();
 
    std::set<int> checkedBuses;
    for (int i = 0; i < busNavigator.count(); i++) {
 
        // go trough only the buses that are not already counted
        if (checkedBuses.find(i) != checkedBuses.end()) {
            continue;
        }
 
        TTAMachine::Bus* bus = busNavigator.item(i);        
        int counter = 1;
        for (int j = i + 1; j < busNavigator.count(); j++) {
            if (bus->isArchitectureEqual(*busNavigator.item(j))) {
                checkedBuses.insert(j);
                counter++;
            }
        }
        busMap.insert(
            std::pair<double, TTAMachine::Bus*>(
                Conversion::toDouble(counter) / 
                Conversion::toDouble(busNavigator.count()), bus));
        checkedBuses.insert(i);
    }
 
    assert(Conversion::toInt(checkedBuses.size()) == busNavigator.count());    
}

References assert, TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Bus::isArchitectureEqual(), TTAMachine::Machine::Navigator< ComponentType >::item(), Conversion::toDouble(), and Conversion::toInt().

Referenced by addBusesByAmount(), and reduceBuses().

Here is the call graph for this function:

analyzeFunctionUnits()

void MachineResourceModifier::analyzeFunctionUnits	(	const TTAMachine::Machine &	mach,
		FunctionUnitMap &	unitMap
	)		const

Analyzes the unit types of the architecture.

Parameters

mach	Machine which function units are analyzed.
unitMap	Map where unit counts are stored. FU pointers in the map are pointers to the machine units.

Definition at line 554 of file MachineResourceModifier.cc.

                                                                   {
 
    TTAMachine::Machine::FunctionUnitNavigator unitNavigator =
        mach.functionUnitNavigator();
 
    std::set<int> checkedUnits;
    for (int i = 0; i < unitNavigator.count(); i++) {
        // go trough only the units that are not already counted
        if (checkedUnits.find(i) != checkedUnits.end()) {
            continue;
        }
 
        TTAMachine::FunctionUnit* fu = unitNavigator.item(i);        
        int counter = 1;
        for (int j = i + 1; j < unitNavigator.count(); j++) {
            if (fu->isArchitectureEqual(unitNavigator.item(j))) {
                checkedUnits.insert(j);
                counter++;
            }
        }
 
        unitMap.insert(
            std::pair<double, TTAMachine::FunctionUnit*>(
                Conversion::toDouble(counter) / 
                Conversion::toDouble(unitNavigator.count()), fu));
        checkedUnits.insert(i);
    }
 
    assert(Conversion::toInt(checkedUnits.size())
           == unitNavigator.count());    
}

References assert, TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::isArchitectureEqual(), TTAMachine::Machine::Navigator< ComponentType >::item(), Conversion::toDouble(), and Conversion::toInt().

Referenced by increaseAllFUsThatDiffersByAmount(), MinimizeMachine::minimizeFunctionUnits(), and percentualFUIncrease().

Here is the call graph for this function:

analyzeRegisters()

void MachineResourceModifier::analyzeRegisters	(	const TTAMachine::Machine &	mach,
		RegisterMap &	registerMap
	)		const

Analyzes the register types of the architecture.

Parameters

mach	Machine which registers are analyzed.
registerMap	Map where register counts are stored.

Definition at line 410 of file MachineResourceModifier.cc.

                                                                   {
 
    TTAMachine::Machine::RegisterFileNavigator registerNavigator =
        mach.registerFileNavigator();
 
    std::set<int> checkedRegisters;
    for (int i = 0; i < registerNavigator.count(); i++) {
        // go trough only the registers that are not already counted
        if (checkedRegisters.find(i) != checkedRegisters.end()) {
            continue;
        }
        // @todo boolean registers are propably not needed to multiply
        TTAMachine::RegisterFile* rf = registerNavigator.item(i);        
        int counter = 1;
        for (int j = i + 1; j < registerNavigator.count(); j++) {
            if (rf->isArchitectureEqual(*registerNavigator.item(j))) {
                checkedRegisters.insert(j);
                counter++;
            }
        }
        
        registerMap.insert(
            std::pair<double, TTAMachine::RegisterFile*>(
                Conversion::toDouble(counter) / 
                Conversion::toDouble(registerNavigator.count()), rf));
 
        checkedRegisters.insert(i);
    }
 
    assert(Conversion::toInt(checkedRegisters.size())
           == registerNavigator.count());    
}

References assert, TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::RegisterFile::isArchitectureEqual(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::registerFileNavigator(), Conversion::toDouble(), and Conversion::toInt().

Referenced by increaseAllRFsThatDiffersByAmount(), MinimizeMachine::minimizeRegisterFiles(), and percentualRegisterIncrease().

Here is the call graph for this function:

hasSlot()

bool MachineResourceModifier::hasSlot ( const TTAMachine::Machine &  mach, const std::string &  slotName  )

private

Returns true if the machine contains an Instruction template slot for given bus name.

Parameters

mach	Machine where the slot is searched.
busName	Name of the slot that is searched.

Returns

True if the machine contains template slot for the given bus name.

Definition at line 218 of file MachineResourceModifier.cc.

                                                    {
    
    Machine::InstructionTemplateNavigator itNav =
        mach.instructionTemplateNavigator();
    for (int i = 0; i < itNav.count(); i++) {
        for (int slot = 0;
             slot < itNav.item(i)->slotCount();
             slot++) {
            
            if (itNav.item(i)->slot(slot)->slot() == slotName) {
                return true;
            }
        }
    }
    return false;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::instructionTemplateNavigator(), and TTAMachine::Machine::Navigator< ComponentType >::item().

Referenced by reduceBuses(), and removeBuses().

Here is the call graph for this function:

increaseAllFUsThatDiffersByAmount()

void MachineResourceModifier::increaseAllFUsThatDiffersByAmount	(	int	unitsToAdd,
		TTAMachine::Machine &	mach
	)

Increase all different funtion units by given amount.

Parameters

unitsToAdd	How many function units are added for each fu type.
mach	Machine where the function units are added.

Definition at line 451 of file MachineResourceModifier.cc.

                                             {
 
    FunctionUnitMap fuMap;
    analyzeFunctionUnits(mach, fuMap);
    
    std::multimap<double, TTAMachine::FunctionUnit*>::const_iterator iter =
        fuMap.end();
    while (iter != fuMap.begin()) {
        iter--;
        int addedUnits = 0;
        while (addedUnits < unitsToAdd) {
            ObjectState* newFuState = (*iter).second->saveState();
            TTAMachine::FunctionUnit* newFU = 
                new TTAMachine::FunctionUnit(newFuState);
            delete newFuState;
 
            newFuState = NULL;
            int fuNum = 1;
            std::string fuBaseName = "fu";
            TTAMachine::Machine::FunctionUnitNavigator fuNavigator = 
                mach.functionUnitNavigator();
            while (fuNavigator.hasItem(
                       fuBaseName + Conversion::toString(fuNum))) {
                fuNum++;
            }
            newFU->setName(fuBaseName + Conversion::toString(fuNum));
            mach.addFunctionUnit(*newFU);
            
            // set the same address space to the new unit.
            newFU->setAddressSpace((*iter).second->addressSpace());
 
            // Fully connect the machine (adds new sockets).
            FullyConnectedCheck check;
            check.fix(mach);
            addedUnits++;
        }
    }
}

References TTAMachine::Machine::addFunctionUnit(), analyzeFunctionUnits(), FullyConnectedCheck::fix(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::FunctionUnit::setAddressSpace(), TTAMachine::FunctionUnit::setName(), and Conversion::toString().

Referenced by GrowMachine::explore().

Here is the call graph for this function:

increaseAllRFsThatDiffersByAmount()

void MachineResourceModifier::increaseAllRFsThatDiffersByAmount	(	int	registersToAdd,
		TTAMachine::Machine &	mach
	)

Increase all different register files by given amount.

Parameters

registersToAdd	Number of every register type will be added.
mach	Machine which registers are added.

Definition at line 311 of file MachineResourceModifier.cc.

                                                 {
 
    RegisterMap rfMap;
    analyzeRegisters(mach, rfMap);
    
    std::multimap<double, TTAMachine::RegisterFile*>::const_iterator iter =
        rfMap.end();
    while (iter != rfMap.begin()) {
        iter--;
        if (!(*iter).second->isUsedAsGuard()) {
            int addedRegisters = 0;
            while (addedRegisters < registersToAdd) {
                ObjectState* newRFState = (*iter).second->saveState();
                TTAMachine::RegisterFile* newRF = 
                    new TTAMachine::RegisterFile(newRFState);
                delete newRFState;
                newRFState = NULL;
 
                int rfNum = 1;
                std::string rfBaseName = "rf";
                TTAMachine::Machine::RegisterFileNavigator rfNavigator = 
                    mach.registerFileNavigator();
                while (rfNavigator.hasItem(
                           rfBaseName + Conversion::toString(rfNum))) {
                    rfNum++;
                }
                newRF->setName(rfBaseName + Conversion::toString(rfNum));
                mach.addRegisterFile(*newRF);
                // Fully connect the machine.
                FullyConnectedCheck check;
                check.fix(mach);
                addedRegisters++;
            }
        }
    }
}

References TTAMachine::Machine::addRegisterFile(), analyzeRegisters(), FullyConnectedCheck::fix(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::RegisterFile::setName(), and Conversion::toString().

Referenced by GrowMachine::explore().

Here is the call graph for this function:

percentualFUIncrease()

void MachineResourceModifier::percentualFUIncrease	(	double	percentualFUIncrease,
		TTAMachine::Machine &	mach
	)

Increase all different function units by percentage value.

Fully connects the machine after adding the units.

Parameters

percentualFUIncrease	How much will the function units be increased in percents.
mach	Machine which function units are increased.

Definition at line 501 of file MachineResourceModifier.cc.

                                                          {
 
    if (percentualFUIncrease < 0.0) {
        // nothing to add
        return;
    }
 
    FunctionUnitMap fuMap;
    analyzeFunctionUnits(mach, fuMap);
    TTAMachine::Machine::FunctionUnitNavigator fuNavigator =
        mach.functionUnitNavigator();
    
    std::multimap<double, TTAMachine::FunctionUnit*>::const_iterator iter =
        fuMap.end();
    while (iter != fuMap.begin()) {
        iter--;
        int addedUnits = 0;
        int unitsToAdd = 
            Conversion::toInt(ceil((*iter).first * percentualFUIncrease));
        while (addedUnits < unitsToAdd) {
            TTAMachine::FunctionUnit* newFU = 
                new TTAMachine::FunctionUnit((*iter).second->saveState());
            int fuNum = 1;
            std::string fuBaseName = "fu";
            TTAMachine::Machine::FunctionUnitNavigator fuNavigator = 
                mach.functionUnitNavigator();
            while (fuNavigator.hasItem(
                       fuBaseName + Conversion::toString(fuNum))) {
                fuNum++;
            }
            newFU->setName(fuBaseName + Conversion::toString(fuNum));
            mach.addFunctionUnit(*newFU);
 
            // set the same address space to the new unit.
            newFU->setAddressSpace((*iter).second->addressSpace());
 
            // Fully connect the machine.
            FullyConnectedCheck check;
            check.fix(mach);
            addedUnits++;
        }
    }
}

References TTAMachine::Machine::addFunctionUnit(), analyzeFunctionUnits(), TTAMachine::Machine::Navigator< ComponentType >::end(), FullyConnectedCheck::fix(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), percentualFUIncrease(), TTAMachine::FunctionUnit::setAddressSpace(), TTAMachine::FunctionUnit::setName(), Conversion::toInt(), and Conversion::toString().

Referenced by percentualFUIncrease().

Here is the call graph for this function:

percentualRegisterIncrease()

void MachineResourceModifier::percentualRegisterIncrease	(	double	percentsOfRegistersToAdd,
		TTAMachine::Machine &	mach
	)

Increase all different register files by percentage value.

Fully connects the machine after adding the units.

Parameters

percentualRegisterIncrease	How much will the register files be increased in percents.
mach	Machine which registers are increased.

Definition at line 359 of file MachineResourceModifier.cc.

                                                              {
 
    if (percentsOfRegistersToAdd < 0.0) {
        // nothing to add
        return;
    }
 
    RegisterMap rfMap;
    analyzeRegisters(mach, rfMap);
    TTAMachine::Machine::RegisterFileNavigator rfNavigator =
        mach.registerFileNavigator();
    
    std::multimap<double, TTAMachine::RegisterFile*>::const_iterator iter =
        rfMap.end();
    while (iter != rfMap.begin()) {
        iter--;
        if (!(*iter).second->isUsedAsGuard()) {
            int addedRegisters = 0;
            int registersToAdd = 
                Conversion::toInt(
                    ceil((*iter).first * percentsOfRegistersToAdd));
            while (addedRegisters < registersToAdd) {
                TTAMachine::RegisterFile* newRF = 
                    new TTAMachine::RegisterFile((*iter).second->saveState());
                int rfNum = 1;
                std::string rfBaseName = "rf";
                TTAMachine::Machine::RegisterFileNavigator rfNavigator = 
                    mach.registerFileNavigator();
                while (rfNavigator.hasItem(
                           rfBaseName + Conversion::toString(rfNum))) {
                    rfNum++;
                }
                newRF->setName(rfBaseName + Conversion::toString(rfNum));
                mach.addRegisterFile(*newRF);
                // Fully connect the machine.
                FullyConnectedCheck check;
                check.fix(mach);
                addedRegisters++;
            }
        }
    }
}

References TTAMachine::Machine::addRegisterFile(), analyzeRegisters(), TTAMachine::Machine::Navigator< ComponentType >::end(), FullyConnectedCheck::fix(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::RegisterFile::setName(), Conversion::toInt(), and Conversion::toString().

Here is the call graph for this function:

reduceBuses()

void MachineResourceModifier::reduceBuses	(	const int &	busesToRemove,
		TTAMachine::Machine &	mach,
		std::list< std::string > &	removedBusNames
	)

Reduces the amount of buses with a given number using some strange algorithm.

Won't remove buses that are immediate template slots. Remove slots first. Slots may cause that given number of buses cannot be removed. (I, maattae, have really no idea why this function does what it does. And what it does isn't actually very clear.)

Parameters

busesToRemove	Number of buses to remove.
mach	Machine where the buses are removed.
removedBusName	Names of the removed buses are added at the end of this list.

Definition at line 125 of file MachineResourceModifier.cc.

                                         {
 
    BusMap busMap;
    analyzeBuses(mach, busMap);
 
    int removedBuses = 0;
    std::multimap<double, TTAMachine::Bus*>::const_iterator iter =
        busMap.begin();
 
    while (iter != busMap.end() && removedBuses != busesToRemove) {
 
        double numberToRemove = ceil(iter->first * busesToRemove);
 
        TTAMachine::Machine::BusNavigator navigator = mach.busNavigator();
 
        for (int i = 0; numberToRemove > 0 && i < navigator.count(); i++) {
            if (removedBuses < busesToRemove) {
                if ((*iter).second->isArchitectureEqual(
                        *navigator.item(i))) {
                    Machine::InstructionTemplateNavigator itNav =
                        mach.instructionTemplateNavigator();
                    if (hasSlot(mach, navigator.item(i)->name())) {
                        // buses that contains template slot are not removed
                        continue;
                    }
                    // remove the bus
                    removedBusNames.push_back(
                        (*iter).second->name());
                    mach.removeBus(*(navigator.item(i)));
                    removedBuses++;
                    numberToRemove--;
                }
            } else {
                // continue with next bus type
                break;
            }
        }
        iter++;
    }
}

References analyzeBuses(), TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), hasSlot(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Machine::removeBus().

Here is the call graph for this function:

removeBuses()

bool MachineResourceModifier::removeBuses	(	const int &	countToRemove,
		TTAMachine::Machine &	mach,
		std::list< std::string > &	removedBusNames
	)

Removes busses from machine.

Doens't remove buses that have template slots.

Parameters

countToRemove	Number of buses to remove in optimal case.
mach	Machine where buses are going to be removed.
removedBusName	Names of the removed buses are added at the end of this list.

Returns

True if the number of buses to be removed were actually removed, false otherwise.

Definition at line 182 of file MachineResourceModifier.cc.

                                         {
 
    TTAMachine::Machine::BusNavigator navigator = mach.busNavigator();
    Machine::InstructionTemplateNavigator itNav = 
        mach.instructionTemplateNavigator();
 
    // TODO: make test that the last guard bus isn't removed either.
    for (int busesRemoved = 0, i = 0; 0 < navigator.count(); ++i) {
        if ( countToRemove == busesRemoved ) {
            return true;
        }
        // buses that contains template slot are not removed
        if (hasSlot(mach, navigator.item(i)->name())) {
            continue;
        }
        removedBusNames.push_back(navigator.item(i)->name());
        // remove the bus
        mach.removeBus(*(navigator.item(i)));
        ++busesRemoved;
        --i;
    }
    return false;
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), hasSlot(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Machine::removeBus().

Referenced by MinimizeMachine::minimizeBuses().

Here is the call graph for this function:

removeNotConnectedSockets()

void MachineResourceModifier::removeNotConnectedSockets	(	TTAMachine::Machine &	mach,
		std::list< std::string > &	removedSocketNames
	)

Removes not sockets that have no connection to any port from the machine.

Parameters

mach	Machine where the sockets are removed.
removedSocketNames	Names of the removed sockets are inserted at the end of this list.

Definition at line 244 of file MachineResourceModifier.cc.

                                                                     {
 
    std::list<std::string> socketsToRemove;
 
    TTAMachine::Machine::SocketNavigator navigator = mach.socketNavigator();
    for (int i = 0; i < navigator.count(); i++) {
        if (navigator.item(i)->portCount() == 0 ||
            navigator.item(i)->segmentCount() == 0) {
            socketsToRemove.push_back(navigator.item(i)->name());
        }
    }
 
    std::list<std::string>::const_iterator iter = socketsToRemove.begin();
    while (iter != socketsToRemove.end()) {
        mach.removeSocket(*navigator.item(*iter));
        removedSocketNames.push_back(*iter);
        iter++;
    }
}

References TTAMachine::Machine::Navigator< ComponentType >::begin(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::removeSocket(), and TTAMachine::Machine::socketNavigator().

Referenced by MinimizeMachine::minimizeFunctionUnits(), MinimizeMachine::minimizeRegisterFiles(), RemoveUnconnectedComponents::removeSockets(), and ProGe::ProcessorGenerator::removeUnconnectedSockets().

Here is the call graph for this function:

---

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

• MachineResourceModifier.hh
• MachineResourceModifier.cc