#include <MinimalOpSetCheck.hh>

Inheritance diagram for MinimalOpSetCheck:

Collaboration diagram for MinimalOpSetCheck:

Public Member Functions
	MinimalOpSetCheck ()

virtual	~MinimalOpSetCheck ()

virtual bool	check (const TTAMachine::Machine &machine, MachineCheckResults &results) const

virtual bool	check (const TTAMachine::Machine &machine) const

bool	checkWithIgnore (const TTAMachine::Machine &machine, const std::set< std::string > &ignoreFUName) const

void	missingOperations (const TTAMachine::Machine &machine, std::vector< std::string > &missingOps) const

void	buildMinimalOpSet (const TTAMachine::Machine *machine=NULL)

TCETools::CIStringSet	minimalOpSet () const

virtual bool	canFix (const TTAMachine::Machine &mach) const

virtual std::string	fix (TTAMachine::Machine &machine) const

Public Member Functions inherited from MachineCheck
virtual std::string	shortDescription () const

virtual std::string	description () const

virtual	~MachineCheck ()

Private Attributes
TCETools::CIStringSet	minimalOpSet_

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

Detailed Description

MachineCheck to check is the machine fully connected.

Definition at line 53 of file MinimalOpSetCheck.hh.

Constructor & Destructor Documentation

◆ MinimalOpSetCheck()

MinimalOpSetCheck::MinimalOpSetCheck ( )

Definition at line 46 of file MinimalOpSetCheck.cc.

                                     : 
    MachineCheck("Common helper functionality for minimal opset checks.") {
    buildMinimalOpSet();
}

References buildMinimalOpSet().

Here is the call graph for this function:

◆ ~MinimalOpSetCheck()

MinimalOpSetCheck::~MinimalOpSetCheck ( )

virtual

Definition at line 51 of file MinimalOpSetCheck.cc.

51 {

52}

Member Function Documentation

◆ buildMinimalOpSet()

void MinimalOpSetCheck::buildMinimalOpSet ( const TTAMachine::Machine * machine = NULL )

Constructs a minimal opset from a given machine.

Parameters

machine Machine that is used as reference for minimal opset.

Definition at line 255 of file MinimalOpSetCheck.cc.

                                                                     {
    bool deleteMach = false;
    if (machine == NULL) {
        machine = TTAMachine::Machine::loadFromADF(Environment::minimalADF());
        deleteMach = true;
    }
 
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine->functionUnitNavigator();
    // construct the opset list
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit* fu = fuNav.item(i);
        fu->operationNames(minimalOpSet_);
    }
 
    if (deleteMach) {
        delete machine;
        machine = NULL;
    }
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadFromADF(), machine, Environment::minimalADF(), minimalOpSet_, and TTAMachine::FunctionUnit::operationNames().

Referenced by MinimalOpSetCheck().

Here is the call graph for this function:

◆ canFix()

bool MinimalOpSetCheck::canFix ( const TTAMachine::Machine & mach ) const

virtual

Returns true if the checker can automatically fix the machine to pass the check.

Returns: True, minimal opset can be always added to the machine.

Reimplemented from MachineCheck.

Definition at line 346 of file MinimalOpSetCheck.cc.

                                                        {
    return true;
}

◆ check() [1/2]

bool MinimalOpSetCheck::check ( const TTAMachine::Machine & machine ) const

virtual

Checks if machine has all operations in minimal opset.

Parameters

machine Machine to be checked against minimal opset.

Returns: True if minimal operation set was met, false otherwise.

Definition at line 61 of file MinimalOpSetCheck.cc.

                                                               {
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine.functionUnitNavigator();
    TCETools::CIStringSet opSet;
    // construct the opset list
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit* fu = fuNav.item(i);
        fu->operationNames(opSet);
    }
 
    // if machines opset is smaller than required opset
    if (opSet.size() < minimalOpSet_.size()) {
        return false;
    }
 
    TCETools::CIStringSet::const_iterator first1 = minimalOpSet_.begin();
    TCETools::CIStringSet::const_iterator last1 = minimalOpSet_.end();
 
    TCETools::CIStringSet::iterator first2 = opSet.begin();
    TCETools::CIStringSet::iterator last2 = opSet.end();
 
    // return false if missing operation was found
    while (first1 != last1 && first2 != last2) {
        if (*first1 < *first2) {
            return false;
        } else if (*first2 < *first1) {
            ++first2;
        } else { 
            ++first1; 
            ++first2; 
        }
    }
    if (first1 != last1) {
        return false;
    }
    return true;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, minimalOpSet_, and TTAMachine::FunctionUnit::operationNames().

Here is the call graph for this function:

◆ check() [2/2]

bool MinimalOpSetCheck::check	(	const TTAMachine::Machine &	machine,
		MachineCheckResults &	results
	)		const

virtual

Checks the machine if it misses operations from the minimal op set.

Parameters

results Results of the validation are added to the given instance.

Implements MachineCheck.

Definition at line 106 of file MinimalOpSetCheck.cc.

                                            {
    
    // construct the opset list
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine.functionUnitNavigator();
    TCETools::CIStringSet opSet;
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit* fu = fuNav.item(i);
        fu->operationNames(opSet);
    }
 
    TCETools::CIStringSet::iterator first1 = minimalOpSet_.begin();
    TCETools::CIStringSet::iterator last1 = minimalOpSet_.end();
 
    TCETools::CIStringSet::iterator first2 = opSet.begin();
    TCETools::CIStringSet::iterator last2 = opSet.end();
 
    std::string eMsg = "Operation missing from the minimal operation set: ";
 
    bool errorsAdded = false;
    // missing opset is the difference towards minimalOpSet_
    while (first1 != last1 && first2 != last2) {
        if (*first1 < *first2) {
            results.addError(*this, eMsg.append(*first1++));
            errorsAdded = true;
        } else if (*first2 < *first1) {
            ++first2;
        } else { 
            ++first1; 
            ++first2; 
        }
    }
    while (first1 != last1) {
        results.addError(*this, eMsg.append(*first1++));
        errorsAdded = true;
    }
    return !errorsAdded;
}

References MachineCheckResults::addError(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, minimalOpSet_, and TTAMachine::FunctionUnit::operationNames().

Here is the call graph for this function:

◆ checkWithIgnore()

bool MinimalOpSetCheck::checkWithIgnore	(	const TTAMachine::Machine &	machine,
		const std::set< std::string > &	ignoreFUName
	)		const

Checks if machine has all operations in minimal opset.

Ignores fus with specified names from the check. This is useful with testing if minimal opset requirement breaks if a certain FUs are removed.

Parameters

machine	Machine to be checked against minimal opset.
ignoreFUs	Names of the fus to be ignored regarding the check.

Returns: True if minimal operation set was met, false otherwise.

Definition at line 159 of file MinimalOpSetCheck.cc.

                                                 {
 
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine.functionUnitNavigator();
    TCETools::CIStringSet opSet;
    // construct the opset list
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit* fu = fuNav.item(i);
        if (ignoreFUName.find(fu->name()) == ignoreFUName.end()) {
            fu->operationNames(opSet);
        }
    }
 
    // if machines opset is smaller than required opset
    if (opSet.size() < minimalOpSet_.size()) {
        return false;
    }
 
    TCETools::CIStringSet::const_iterator first1 = minimalOpSet_.begin();
    TCETools::CIStringSet::const_iterator last1 = minimalOpSet_.end();
 
    TCETools::CIStringSet::iterator first2 = opSet.begin();
    TCETools::CIStringSet::iterator last2 = opSet.end();
 
    // return false if missing operation was found
    while (first1 != last1 && first2 != last2) {
        if (*first1 < *first2) {
            return false;
        } else if (*first2 < *first1) {
            ++first2;
        } else { 
            ++first1; 
            ++first2; 
        }
    }
    if (first1 != last1) {
        return false;
    }
    return true;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, minimalOpSet_, TTAMachine::Component::name(), and TTAMachine::FunctionUnit::operationNames().

Referenced by SimpleICOptimizer::removeAllConnections().

Here is the call graph for this function:

◆ fix()

std::string MinimalOpSetCheck::fix ( TTAMachine::Machine & mach ) const

virtual

Adds FUs to the machine so that it doesn't miss operations anymore.

Check is done against minimal opset.

Parameters

machine Machine to be checked against minimal opset and where FUs are inserted so that minimal opset is fulfilled.

Returns: A short description what was done.

Reimplemented from MachineCheck.

Definition at line 298 of file MinimalOpSetCheck.cc.

                                                    {
    std::vector<std::string> missingOps;
    missingOperations(mach, missingOps);
 
    if (missingOps.size() < 1) {
        const std::string errorMessage = "No missing operations found.";
        throw InvalidData(
            __FILE__, __LINE__, __func__, errorMessage);
    }
 
    // go through minimal adf and add FUs that include missing ops
    TTAMachine::Machine* minMach = TTAMachine::Machine::loadFromADF(
            Environment::minimalADF());
    
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        minMach->functionUnitNavigator();
    std::set<std::string> fuAdded;
    FullyConnectedCheck conCheck = FullyConnectedCheck();
 
    for (unsigned int moi = 0; moi < missingOps.size(); ++moi) {
        for (int fui = 0; fui < fuNav.count(); ++fui) {
            TTAMachine::FunctionUnit* fu = fuNav.item(fui);
            if (fu->hasOperation(missingOps.at(moi))) {
                if (fuAdded.end() != fuAdded.find(fu->name())) {
                    break;
                }
                fuAdded.insert(fu->name());
                fu->unsetMachine();
                mach.addFunctionUnit(*fu);
                // connect the fu
                for (int op = 0; op < fu->operationPortCount(); ++op) {
                    conCheck.connectFUPort(*fu->operationPort(op));
                }
                break;
            }
        }
    }
    delete minMach;
    return "Operations were added to fulfill minimal opset requirements.";
}

References __func__, TTAMachine::Machine::addFunctionUnit(), FullyConnectedCheck::connectFUPort(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Machine::loadFromADF(), Environment::minimalADF(), missingOperations(), TTAMachine::Component::name(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), and TTAMachine::FunctionUnit::unsetMachine().

Referenced by MinimalOpSet::explore().

Here is the call graph for this function:

◆ minimalOpSet()

TCETools::CIStringSet MinimalOpSetCheck::minimalOpSet ( ) const

Returns constructed minimal opset.

Returns: Minimal opset as strings in a set.

Definition at line 283 of file MinimalOpSetCheck.cc.

                                      {
    return minimalOpSet_;
}

References minimalOpSet_.

◆ missingOperations()

void MinimalOpSetCheck::missingOperations	(	const TTAMachine::Machine &	machine,
		std::vector< std::string > &	missingOps
	)		const

Return operations that are missing from a machine.

Returns operations that are missing from a machine compared to the minimal operation set.

Parameters

machine	Machine to be checked against minimal opset.
missingOps	Vector where missing operation names are to be stored.

Definition at line 213 of file MinimalOpSetCheck.cc.

                                            {
 
    // construct the opset list
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine.functionUnitNavigator();
    TCETools::CIStringSet opSet;
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit* fu = fuNav.item(i);
        fu->operationNames(opSet);
    }
 
    TCETools::CIStringSet::const_iterator first1 = minimalOpSet_.begin();
    TCETools::CIStringSet::const_iterator last1 = minimalOpSet_.end();
 
    TCETools::CIStringSet::iterator first2 = opSet.begin();
    TCETools::CIStringSet::iterator last2 = opSet.end();
 
    // missing opset is the difference towards minimalOpSet_
    while (first1 != last1 && first2 != last2) {
        if (*first1 < *first2) {
            missingOps.push_back(*first1++);
        } else if (*first2 < *first1) {
            ++first2;
        } else { 
            ++first1; 
            ++first2; 
        }
    }
    while (first1 != last1) {
        missingOps.push_back(*first1++);
    }
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, minimalOpSet_, and TTAMachine::FunctionUnit::operationNames().

Referenced by ProgrammabilityValidator::checkPrimitiveSet(), MinimalOpSet::explore(), and fix().

Here is the call graph for this function:

Member Data Documentation

◆ minimalOpSet_

TCETools::CIStringSet MinimalOpSetCheck::minimalOpSet_

private

Definition at line 80 of file MinimalOpSetCheck.hh.

Referenced by buildMinimalOpSet(), check(), check(), checkWithIgnore(), minimalOpSet(), and missingOperations().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MinimalOpSetCheck()

◆ ~MinimalOpSetCheck()

Member Function Documentation

◆ buildMinimalOpSet()

◆ canFix()

◆ check() [1/2]

◆ check() [2/2]

◆ checkWithIgnore()

◆ fix()

◆ minimalOpSet()

◆ missingOperations()

Member Data Documentation

◆ minimalOpSet_