RegisterQuantityCheck Class Reference

#include <RegisterQuantityCheck.hh>

Inheritance diagram for RegisterQuantityCheck:

Collaboration diagram for RegisterQuantityCheck:

Public Member Functions
	RegisterQuantityCheck ()
virtual	~RegisterQuantityCheck ()
virtual bool	check (const TTAMachine::Machine &mach) const
virtual bool	check (const TTAMachine::Machine &mach, MachineCheckResults &results) const
bool	checkWithIgnore (const TTAMachine::Machine &mach, const std::set< std::string > &ignoreRFs) const
bool	checkWithIgnore (const TTAMachine::Machine &mach, MachineCheckResults &results, const std::set< std::string > &ignoreRFs) const
bool	checkIntRegs (const TTAMachine::Machine &mach) const
bool	canFixIntRegs (const TTAMachine::Machine &mach) const
bool	fixIntRegs (TTAMachine::Machine &mach) const
Public Member Functions inherited from MachineCheck
virtual std::string	shortDescription () const
virtual std::string	description () const
virtual bool	canFix (const TTAMachine::Machine &mach) const
virtual std::string	fix (TTAMachine::Machine &mach) const
virtual	~MachineCheck ()

Private Types
typedef std::pair< const TTAMachine::RegisterFile *, int >	Register

Private Member Functions
void	findGuardRegisters (const TTAMachine::Machine &mach, std::set< Register > &registers, const std::set< std::string > &ignoreRFs) const
unsigned int	countIntRegisters (const TTAMachine::Machine &mach, const std::set< Register > &guardRegs, const std::set< std::string > &ignoreRFs) const
bool	checkPredRegs (const unsigned int &regCount, MachineCheckResults *results) const
unsigned int	missingIntRegs (const unsigned int &regCount, MachineCheckResults *results, bool isFullyConnected) const

Private Attributes
FullyConnectedCheck	fullyConCheck_

Additional Inherited Members
Protected Member Functions inherited from MachineCheck
	MachineCheck (const std::string &shortDesc_)

Detailed Description

Definition at line 48 of file RegisterQuantityCheck.hh.

Member Typedef Documentation

Register

typedef std::pair<const TTAMachine::RegisterFile*, int> RegisterQuantityCheck::Register

private

Definition at line 71 of file RegisterQuantityCheck.hh.

Constructor & Destructor Documentation

RegisterQuantityCheck()

RegisterQuantityCheck::RegisterQuantityCheck

(

)

Definition at line 47 of file RegisterQuantityCheck.cc.

                                             : 
    MachineCheck("Checks that machine has enough registers") {}

~RegisterQuantityCheck()

RegisterQuantityCheck::~RegisterQuantityCheck ( )

virtual

Definition at line 50 of file RegisterQuantityCheck.cc.

{}

Member Function Documentation

canFixIntRegs()

bool RegisterQuantityCheck::canFixIntRegs

(

const TTAMachine::Machine &

mach

)

const

Returns true if an int register file found, meaning int registers can be added.

Returns

True, if int rf found.

Definition at line 380 of file RegisterQuantityCheck.cc.

                                                                        {
    TTAMachine::Machine::RegisterFileNavigator regNav =
        mach.registerFileNavigator();
 
    // return true if an int register file was found
    for (int i = 0; i < regNav.count(); i++) {
        TTAMachine::RegisterFile* rf = regNav.item(i);
        if (rf->width() == 32) {
            return true;
        }
    }
    return false;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::registerFileNavigator(), and TTAMachine::BaseRegisterFile::width().

Referenced by SimpleICOptimizer::fixIntRegisters().

Here is the call graph for this function:

check() [1/2]

bool RegisterQuantityCheck::check ( const TTAMachine::Machine &  mach ) const

virtual

Checks register quantities, just returns false if problems where found.

Parameters

mach	Machine to be checked for registers resources.
results	MachineCheckResults where possible errors are added.

Returns

True if no problems were found during testing, false otherwise.

Definition at line 61 of file RegisterQuantityCheck.cc.

                                                                {
    std::set<Register> guardRegs;
    const std::set<std::string> ignoreRFs; //empty, no ignore
 
    // find all registers that can be used for guards
    findGuardRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough predicate registers
    if (!checkPredRegs(guardRegs.size(), NULL)) {
        return false;
    }
 
    // count all integer registers
    unsigned int intRegs = countIntRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough integer registers
    if (missingIntRegs(intRegs, NULL, fullyConCheck_.check(mach))) {
        return false;
    }
 
    return true;
}

References FullyConnectedCheck::check(), checkPredRegs(), countIntRegisters(), findGuardRegisters(), fullyConCheck_, and missingIntRegs().

Here is the call graph for this function:

check() [2/2]

bool RegisterQuantityCheck::check ( const TTAMachine::Machine &  mach, MachineCheckResults &  results  ) const

virtual

Checks register quantities.

Stores errors during checking to a MachineCheckResults object given as a parameter.

Parameters

mach	Machine to be checked for registers resources.
results	MachineCheckResults where possible errors are added.

Returns

True if no problems were found during testing, false otherwise.

Implements MachineCheck.

Definition at line 96 of file RegisterQuantityCheck.cc.

                                        {
 
    const std::set<std::string> empty;
    return RegisterQuantityCheck::checkWithIgnore(mach, results, empty);
}

References checkWithIgnore().

Here is the call graph for this function:

checkIntRegs()

bool RegisterQuantityCheck::checkIntRegs

(

const TTAMachine::Machine &

mach

)

const

Check only if enough integer registers.

Parameters

mach	Machine to be checked for int registers.

Returns

True if enough integer registers found.

Definition at line 186 of file RegisterQuantityCheck.cc.

                                                                       {
    // find all registers that can be used for guards
    std::set<Register> guardRegs;
    const std::set<std::string> ignoreRFs; //empty, no ignore
    findGuardRegisters(mach, guardRegs, ignoreRFs);
 
    // count all integer registers
    unsigned int intRegs = countIntRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough integer registers
    if (missingIntRegs(intRegs, NULL, fullyConCheck_.check(mach))) {
        return false;
    }
    return true;
}

References FullyConnectedCheck::check(), countIntRegisters(), findGuardRegisters(), fullyConCheck_, and missingIntRegs().

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

Here is the call graph for this function:

checkPredRegs()

bool RegisterQuantityCheck::checkPredRegs ( const unsigned int &  regCount, MachineCheckResults *  results  ) const

private

Checks that there are enough predicate registers.

Outputs errors in MachineCheckResults object if given as a pointer.

Parameters

regCount	The number of predicate registers.
results	MachineCheckResults where possible errors are added.

Returns

True if the number of predicate registers given was high enough.

Definition at line 288 of file RegisterQuantityCheck.cc.

                                        {
    
    if (regCount < 2) {
        if (results != NULL) {
            std::string msg = "too few predicate registers, 2 needed, ";
            msg += Conversion::toString(regCount);
            msg += " found";
            results->addError(*this, msg);
        }
        return false;
    }
   return true;
}

References MachineCheckResults::addError(), and Conversion::toString().

Referenced by check(), and checkWithIgnore().

Here is the call graph for this function:

checkWithIgnore() [1/2]

bool RegisterQuantityCheck::checkWithIgnore	(	const TTAMachine::Machine &	mach,
		const std::set< std::string > &	ignoreRFs
	)		const

Checks register quantities with an option to ignore some RFs.

Can be passed a list of RFs names that are ignored regarding the test.

Parameters

mach	Machine to be checked for registers resources.
ignoreRFs	A sorted list of RFs to be ignored while checking the needed registers.

Returns

True if no problems were found during testing, false otherwise.

Definition at line 116 of file RegisterQuantityCheck.cc.

                                              {
 
    std::set<Register> guardRegs;
 
    // find all registers that can be used for guards
    findGuardRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough predicate registers
    if (!checkPredRegs(guardRegs.size(), NULL)) {
        return false;
    }
 
    // count all integer registers
    unsigned int intRegs = countIntRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough integer registers
    if (missingIntRegs(intRegs, NULL, fullyConCheck_.check(mach))) {
        return false;
    }
 
    return true;
}

References FullyConnectedCheck::check(), checkPredRegs(), countIntRegisters(), findGuardRegisters(), fullyConCheck_, and missingIntRegs().

Referenced by check(), and SimpleICOptimizer::removeAllConnections().

Here is the call graph for this function:

checkWithIgnore() [2/2]

bool RegisterQuantityCheck::checkWithIgnore	(	const TTAMachine::Machine &	mach,
		MachineCheckResults &	results,
		const std::set< std::string > &	ignoreRFs
	)		const

Checks register quantities with an option to ignore some RFs.

Can be passed a list of RFs names that are ignored regarding the test. Stores errors during checking to a MachineCheckResults object given as a parameter.

Parameters

mach	Machine to be checked for registers resources.
results	MachineCheckResults where possible errors are added.
ignoreRFs	A sorted list of RFs to be ignored while checking the needed registers.

Returns

True if no problems were found during testing, false otherwise.

Definition at line 156 of file RegisterQuantityCheck.cc.

                                              {
 
    std::set<Register> guardRegs;
 
    // find all registers that can be used for guards
    findGuardRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough predicate registers
    checkPredRegs(guardRegs.size(), &results);
 
    // count all integer registers
    unsigned int intRegs = countIntRegisters(mach, guardRegs, ignoreRFs);
 
    // check if enough integer registers
    missingIntRegs(intRegs, &results, fullyConCheck_.check(mach));
 
    return results.errorCount() == 0;
}

References FullyConnectedCheck::check(), checkPredRegs(), countIntRegisters(), MachineCheckResults::errorCount(), findGuardRegisters(), fullyConCheck_, and missingIntRegs().

Here is the call graph for this function:

countIntRegisters()

unsigned int RegisterQuantityCheck::countIntRegisters ( const TTAMachine::Machine &  mach, const std::set< Register > &  guardRegs, const std::set< std::string > &  ignoreRFs  ) const

private

Counts integer registers int the given machine.

Doesn't count guard registers given as sorted list of pairs. Can be passed a list of RFs names that are ignored regarding the test.

Parameters

mach	Machine where integer registers are counted.
guardRegs	A sorted list of register file, index pairs.
ignoreRFs	A sorted list of RFs to be ignored while counting the registers.

Returns

The number of counted integer registers in them machine.

Definition at line 254 of file RegisterQuantityCheck.cc.

                                              {
 
    TTAMachine::Machine::RegisterFileNavigator regNav =
        mach.registerFileNavigator();
 
    unsigned int intRegs = 0;
    for (int i = 0; i < regNav.count(); i++) {
        const TTAMachine::RegisterFile* rf = regNav.item(i);
        if (rf->width() == 32 && 
                ignoreRFs.find(rf->name()) == ignoreRFs.end()) {
            for (int j = 0; j < rf->size(); j++) {
                if (!AssocTools::containsKey(guardRegs, Register(rf,j))) {
                    intRegs++;
                }
            }
        }
    }
    return intRegs;
}

References AssocTools::containsKey(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::BaseRegisterFile::size(), and TTAMachine::BaseRegisterFile::width().

Referenced by check(), checkIntRegs(), checkWithIgnore(), and fixIntRegs().

Here is the call graph for this function:

findGuardRegisters()

void RegisterQuantityCheck::findGuardRegisters ( const TTAMachine::Machine &  mach, std::set< Register > &  guardRegs, const std::set< std::string > &  ignoreRFs  ) const

private

Checks register quantities with an option to ignore some RFs.

Can be passed a list of RFs names that are ignored regarding the test.

Parameters

mach	Machine to be checked for registers resources.
guardRegs	Counts registers that can be used as guards in the given machine.
ignoreRFs	A sorted list of RFs to be ignored while checking the needed registers.

Returns

True if no problems were found during testing, false otherwise.

Definition at line 216 of file RegisterQuantityCheck.cc.

                                              {
    
    // find all registers that can be used for guards
    TTAMachine::Machine::BusNavigator busNav = mach.busNavigator();
    for (int i = 0; i < busNav.count(); i++) {
        TTAMachine::Bus* bus = busNav.item(i);
        for (int j = 0; j < bus->guardCount(); j++) {
            const TTAMachine::RegisterGuard* regGuard =
                dynamic_cast<TTAMachine::RegisterGuard*>(bus->guard(j));
            if (regGuard != NULL) {
                if(ignoreRFs.find(regGuard->registerFile()->name()) ==
                        ignoreRFs.end()) {
                    guardRegs.insert(
                        Register(
                            regGuard->registerFile(), regGuard->registerIndex()));
                }
            }
        }
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::RegisterGuard::registerIndex().

Referenced by check(), checkIntRegs(), checkWithIgnore(), and fixIntRegs().

Here is the call graph for this function:

fixIntRegs()

bool RegisterQuantityCheck::fixIntRegs

(

TTAMachine::Machine &

mach

)

const

Adds integer registers to an int rf so that requirements are met.

Parameters

machine

Machine where integer registers are to be added if needed.

Returns

True if something was done to the machine, false otherwise.

Definition at line 340 of file RegisterQuantityCheck.cc.

                                                               {
    // find all guard registers, which are ignored
    std::set<Register> guardRegs;
    const std::set<std::string> ignoreRFs; //empty, no ignore
    findGuardRegisters(mach, guardRegs, ignoreRFs);
 
    // count all integer registers
    unsigned int intRegs = countIntRegisters(mach, guardRegs, ignoreRFs);
   
    unsigned int missingRegs = 
        missingIntRegs(intRegs, NULL, fullyConCheck_.check(mach));
 
    if (!missingRegs) {
        return true;
    }
 
    TTAMachine::Machine::RegisterFileNavigator regNav =
        mach.registerFileNavigator();
 
    // find an int rf to add registers
    for (int i = 0; i < regNav.count(); i++) {
        TTAMachine::RegisterFile* rf = regNav.item(i);
        if (rf->width() == 32) {
            rf->setNumberOfRegisters(rf->size() + missingRegs);
            return true;
        }
    }
 
    // no int rf found
    return false;
}

References FullyConnectedCheck::check(), TTAMachine::Machine::Navigator< ComponentType >::count(), countIntRegisters(), findGuardRegisters(), fullyConCheck_, TTAMachine::Machine::Navigator< ComponentType >::item(), missingIntRegs(), TTAMachine::Machine::registerFileNavigator(), TTAMachine::RegisterFile::setNumberOfRegisters(), TTAMachine::BaseRegisterFile::size(), and TTAMachine::BaseRegisterFile::width().

Referenced by SimpleICOptimizer::fixIntRegisters().

Here is the call graph for this function:

missingIntRegs()

unsigned int RegisterQuantityCheck::missingIntRegs ( const unsigned int &  regCount, MachineCheckResults *  results, bool  isFullyConnected  ) const

private

Checks that there are enough integer registers.

Outputs errors in MachineCheckResults object if given as a pointer.

Parameters

regCount	The number of integer registers.
results	MachineCheckResults where possible errors are added.

Returns

number of missing registers, 0 if none missing.

Definition at line 315 of file RegisterQuantityCheck.cc.

                                 {
 
    unsigned int neededIntRegs = isFullyConnected ? 5 : 6;
    unsigned int missingRegisters = 0;
     
    if (regCount < neededIntRegs) {
        missingRegisters = neededIntRegs - regCount;
        if (results != NULL) {
            results->addError(*this, "too few integer registers");
        }
    }
   return missingRegisters;
}

References MachineCheckResults::addError().

Referenced by check(), checkIntRegs(), checkWithIgnore(), and fixIntRegs().

Here is the call graph for this function:

Member Data Documentation

fullyConCheck_

FullyConnectedCheck RegisterQuantityCheck::fullyConCheck_

private

Definition at line 88 of file RegisterQuantityCheck.hh.

Referenced by check(), checkIntRegs(), checkWithIgnore(), and fixIntRegs().

---

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

• RegisterQuantityCheck.hh
• RegisterQuantityCheck.cc