#include <OperationDAGSelector.hh>

Collaboration diagram for OperationDAGSelector:

Classes
struct	CaseInsensitiveCmp

class	OperationDAGList

Public Types
typedef TCETools::CIStringSet	OperationSet

Static Public Member Functions
static OperationDAGList	findDags (const std::string &opName, OperationSet opSet, const ImmInfo *immInfo=nullptr)

static OperationDAG *	createExpandedDAG (const Operation &op, OperationSet &opSet)

Private Member Functions
	OperationDAGSelector ()

virtual	~OperationDAGSelector ()

Static Private Member Functions
static int	countUnknownOperations (OperationDAG &dag, OperationSet &opSet)

Detailed Description

Class that search DAGs from operation set.

Definition at line 50 of file OperationDAGSelector.hh.

Member Typedef Documentation

◆ OperationSet

typedef TCETools::CIStringSet OperationDAGSelector::OperationSet

Definition at line 88 of file OperationDAGSelector.hh.

Constructor & Destructor Documentation

◆ OperationDAGSelector()

OperationDAGSelector::OperationDAGSelector ( )

private

◆ ~OperationDAGSelector()

virtual OperationDAGSelector::~OperationDAGSelector ( )

privatevirtual

Member Function Documentation

◆ countUnknownOperations()

int OperationDAGSelector::countUnknownOperations	(	OperationDAG &	dag,
		OperationSet &	opSet
	)

staticprivate

Returns number of operations that DAG contains which are not in given opset.

Currently does not check recursively, but only one level used operations.

Parameters

dag	DAG which is checked.
opSet	Operations that are found.

Returns: Number of operations that DAG contains that did not exist in opset.

Definition at line 130 of file OperationDAGSelector.cc.

                                             {
  
     int strangeOpCount = 0;
     
     for (int i = 0; i < dag.nodeCount(); i++) {
         OperationNode* node = dynamic_cast<OperationNode*>(&dag.node(i));
         
         // check if operation was found from opset
         if (node != NULL) {
             Operation& refOp = node->referencedOperation();
             
             if (opSet.find(refOp.name()) == opSet.end()) {
                 strangeOpCount++;
             }
         }
     }
     
     return strangeOpCount;
 }

References Operation::name(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), and OperationNode::referencedOperation().

Referenced by createExpandedDAG(), and findDags().

Here is the call graph for this function:

◆ createExpandedDAG()

OperationDAG * OperationDAGSelector::createExpandedDAG	(	const Operation &	op,
		OperationSet &	opSet
	)

static

Tries to find simplest graph that is expanded with given opset.

Todo:: Implement function when neccessary. Right now returns DAG for operation that has smallest number of operations that are not found in given opset.

Parameters

op	Operation whose expanded dag is requested.
opSet	Operation names which are allowed to use for expanding.

Returns: Dynamically allocated DAG for operation expanded with given opset. OperationDAG::null if there is no dag for operation.

Definition at line 164 of file OperationDAGSelector.cc.

                                               {
     
     OperationDAGList foundDags;
     int lastUnknownOperations = INT_MAX;
     
     // find DAG that has lowest cont of operations that are not in opset
     for (int i = 0; i < op.dagCount(); i++) {
         OperationDAG& currDag = op.dag(i);
         int strangeCount = countUnknownOperations(currDag, opSet);
         
         if (strangeCount <= lastUnknownOperations) {
             
             if (strangeCount < lastUnknownOperations) {            
                 lastUnknownOperations = strangeCount;
                 foundDags.clear();
             }
             
             foundDags.push_back(&currDag);            
         }     
     }
     
     OperationDAG& selectedDag = foundDags.smallestNodeCount();
     
     if (selectedDag.isNull()) {
         return &selectedDag;
     } else {
         return new OperationDAG(selectedDag);
     }    
 }

References countUnknownOperations(), Operation::dag(), Operation::dagCount(), OperationDAG::isNull(), and OperationDAGSelector::OperationDAGList::smallestNodeCount().

Here is the call graph for this function:

◆ findDags()

OperationDAGSelector::OperationDAGList OperationDAGSelector::findDags	(	const std::string &	opName,
		OperationSet	opSet,
		const ImmInfo *	immInfo = `nullptr`
	)

static

Returns a list of dags of an operation, which use only given set of operations.

Additionally, immediate info can be provided to this function. The info describes immediate transport capabilities to the operands of the (known) operations. ImmInfo discards dags that have constant values bound to operand that can not have the immediate transported to.

Parameters

opName	Name of operation whose DAGs are requested.
opSet	Set of operations that are allowed to be referred by the returned DAGs.
immInfo	The immediate info.

Returns: List of DAGs which comply the search parameters.

Definition at line 57 of file OperationDAGSelector.cc.

                             {
  
     OperationDAGList retDags;
     OperationPool opPool;
     Operation& op = opPool.operation(opName.c_str());
  
     for (int i = 0; i < op.dagCount(); i++) {
         OperationDAG& currDag = op.dag(i);        
         
         if (op.dagError(i) != "") {
             throw IllegalParameters(__FILE__,__LINE__,__func__,
                 TCEString("Operation:") + op.name()
                 + " has invalid dag, index: " + Conversion::toString(i)
                 + "\n\tError: " + op.dagError(i));
         }
  
         if (countUnknownOperations(currDag, opSet) != 0) {
             continue; // Discard the dag with unsupported operations
         }
  
         if (immInfo) {
             bool discardDag = false;
             for (int i = 0; i < currDag.nodeCount(); i++) {
                 const ConstantNode* cNode =
                     dynamic_cast<ConstantNode*>(&currDag.node(i));
                 if (cNode == nullptr) continue;
  
                 for (auto& edge : currDag.outEdges(*cNode)) {
                     const OperationNode* opNode = dynamic_cast<OperationNode*>(
                         &currDag.headNode(*edge));
                     assert(opNode &&
                         "Operation DAG node is other than OperationNode.");
  
                     if (immInfo->count(
                             opNode->referencedOperation(),
                             edge->dstOperand())) {
                         // TODO check if constant can be encoded as short
                         // immediate.
  
                         // TODO: should check if the operand can be swapped.
                         // If so, alter the dag to get the better immediate
                         // transport support.
                     } else {
                         discardDag = true;
                         break;
                     }
                 }
                 if (discardDag) break;
             }
             if (discardDag) {
                 continue;
             }
         }
         retDags.push_back(&currDag);
     }
  
     return retDags;
 }