[FIX] delete things not belong to this PR

Author: MeowMJ

src/CGRANode.cpp

@@ -596,10 +596,6 @@ void CGRANode::enableComplex(string type) {
   else m_supportComplexType.push_back(type);
 }
 
-void CGRANode::enablePathDim() {
-  m_supportPathDim = true;
-}
-
 void CGRANode::enableVectorization() {
   m_supportVectorization = true;
 }
@@ -652,10 +648,6 @@ bool CGRANode::supportComplex(string type) {
   return false;
 }
 
-bool CGRANode::supportPathDim() {
-  return m_supportPathDim;
-}
-
 bool CGRANode::supportVectorization() {
   return m_supportVectorization;
 }

src/DFG.cpp

@@ -295,95 +295,6 @@ void DFG::tuneForPattern() {
   }
 }
 
-void DFG::tuneForDualIssueAfter() {
-  // tuneForDualIssueAfter reconstruct the edge for dual issue after tuneForPattern().
-  // the edges between the dualIssue-combined DFGNodes and its parents/children must be combined into one edge only.
-  std::cout<<"[MMJ] tuneForDualIssueAfter is running " <<std::endl;
-  for (DFGNode* dfgNode: nodes) {
-    if (dfgNode->hasMerged() and !dfgNode->hasCombined()){
-      std::cout<<"[MMJ] dfgNode is " << dfgNode->getID() <<std::endl;
-      for (DFGNode* predNode: *(dfgNode->getPredNodes())) {
-        // delete all edges between predNode and merged dfgNode
-        DFGEdge* firstEdge = NULL;
-        while (hasDFGEdge(predNode, dfgNode)){
-          if (firstEdge == NULL) {
-            firstEdge = getDFGEdge(predNode, dfgNode);
-          }
-          deleteDFGEdge(predNode, dfgNode);
-        }     
-        // add the first edge back
-        if (firstEdge){
-          m_DFGEdges.push_back(firstEdge);
-        }               
-      }
-    }
-  }
-}
-
-void DFG::tuneForDualIssue() {
-  // tuneForDualIssue reconstruct the edge for dual issue without tuneForPattern()
-  // the edges between the merged DFGNodes and its parents/children must be combined into one edge only.
-  // reconstruct connected DFG by modifying m_DFGEdge
-  std::cout<<"[MMJ] tuneForDualIssue is running " <<std::endl;
-  list<DFGNode*>* removeNodes = new list<DFGNode*>();
-  for (DFGNode* dfgNode: nodes) {
-    if (dfgNode->hasMerged() and !dfgNode->hasCombined()) {
-      if (dfgNode->isPatternRoot()) {
-        std::cout<<"[MMJ] dfgNode is " << dfgNode->getID() <<std::endl;
-        for (DFGNode* patternNode: *(dfgNode->getPatternNodes())) {
-          std::cout<<"[MMJ] patternNode is " << patternNode->getID() <<std::endl;
-          if (hasDFGEdge(dfgNode, patternNode))
-            m_DFGEdges.remove(getDFGEdge(dfgNode, patternNode));
-
-          for (DFGNode* predNode: *(patternNode->getPredNodes())) {
-            // we only keep one edge between dfgNode and predNode
-            if (predNode == dfgNode or
-                predNode->isOneOfThem(dfgNode->getPatternNodes())) {
-              deleteDFGEdge(predNode, patternNode);
-              continue;
-            }
-            DFGNode* newPredNode = NULL;
-            if (predNode->hasMerged() or predNode->hasCombined())
-              newPredNode = predNode->getPatternRoot();
-            else
-              newPredNode = predNode;
-            replaceDFGEdge(predNode, patternNode, newPredNode, dfgNode);              
-          }
-
-          for (DFGNode* succNode: *(patternNode->getSuccNodes())) {
-            std::cout<<"[MMJ] succNode is " << succNode->getID() <<std::endl;
-            if (succNode == dfgNode or
-                succNode->isOneOfThem(dfgNode->getPatternNodes())) {
-              deleteDFGEdge(patternNode, succNode);
-              continue;
-            }
-            DFGNode* newSuccNode = NULL;
-            if (succNode->hasMerged() or succNode->hasCombined())
-              newSuccNode = succNode->getPatternRoot();
-            else
-              newSuccNode = succNode;
-            replaceDFGEdge(patternNode, succNode, dfgNode, newSuccNode);
-          }
-        }
-      } else {
-        removeNodes->push_back(dfgNode);
-      }
-    }
-  }
-  for (DFGNode* dfgNode: *removeNodes) {
-    nodes.remove(dfgNode);
-  }
-}
-
-void DFG::ESCORT() {
-  dualIssueNew(2,100);
-  // If dualIssueNew fails
-  dualIssue(3,100);
-  tuneForDualIssue();
-  tuneForDualIssueAfter();
-  return;
-}
-
 void DFG::combineCmpBranch() {
   // detect patterns (e.g., cmp+branch)
   DFGNode* addNode = NULL;
@@ -645,223 +556,6 @@ void DFG::combineForUnroll(string type) {
   }
 }
 
-// combineSuccSame combines DFGNodes of same opcodeName with a same parent.
-// Note that the edges between the same parent and the input DFGNodes will be combined into one edge.
-// Note the pathName of DFGNodes must be different.
-void DFG::combineSuccSame(const list<DFGNode*>* t_sameSuccNode, const int t_mergeSize){
-  std::cout <<"[MMJ] combineSuccSame is running "<< std::endl;
-  // choose DFGNode in t_sameSuccNode with different pathName
-  list<DFGNode*>* uniqueNodes;
-  map<string, list<DFGNode*>> pathNameMap;
-  for (DFGNode* dfgNode: *t_sameSuccNode){
-    std::cout <<"[MMJ] t_sameSuccNode dfgNode "<< dfgNode->getID() << std::endl;
-    if (!pathNameMap.count(dfgNode->getPathName())){
-      pathNameMap[dfgNode->getPathName()].push_back(dfgNode);
-      uniqueNodes->push_back(dfgNode);
-      std::cout <<"[MMJ] uniqueNodes dfgNode "<< dfgNode->getID() << std::endl;
-    }
-  }
-
-  // merge uniqueNodes (size must > 1)
-  if (uniqueNodes->size() == 1){
-    std::cout <<"[MMJ] combineSuccSame uniqueNodes.size() == 1 " << std::endl;
-    return;
-  }
-
-  int mergeCount = 0;
-  DFGNode* headNode = uniqueNodes->front();
-  std::cout <<"[MMJ] headNode"<< headNode->getID() << std::endl;
-  for (DFGNode* dfgNode: *uniqueNodes){
-    std::cout <<"[MMJ] uniqueNodes next"<< dfgNode->getID() << std::endl;
-    if(dfgNode != headNode and !dfgNode->hasMerged() and !dfgNode->hasCombined()){
-        headNode ->addPatternPartner(dfgNode);                  
-    }
-    dfgNode->setMerge(); 
-    std::cout <<"[MMJ] dual Issue combine "<< dfgNode->getID() << std::endl; 
-    mergeCount++;
-    if (mergeCount == t_mergeSize) {
-      // combined DFGNode number <= t_mergeSize
-      break;
-    }                   
-  }
-  uniqueNodes->clear();
-  // the handling of edges is in tuneForDualIssue()
-  return;
-}
-
-// findOpSameSucc finds nodes that are the same after br, t_mergeSize decides the max number of nodes that can be combined
-bool DFG::findOpSameSucc(const list<DFGNode*>* t_succList, const int t_mergeSize) {
-  std::cout <<"[MMJ] findOpSameSucc is running "<< std::endl;
-  bool found = false;
-  map<string, list<DFGNode*>> opcodeNameMap;
-
-  // map succeed DFGNode with their operation name
-  for (DFGNode* succNode: *t_succList) {
-    opcodeNameMap[succNode->getOpcodeName()].push_back(succNode);
-  }
-  // combine succeed DFGNodes with number <= t_mergeSize
-  for (auto& pair: opcodeNameMap) {
-      if (pair.second.size() > 1) {
-        combineSuccSame(&pair.second, t_mergeSize);
-        found = true;
-      }
-  }
-  return found;
-}
-
-// findOpSucc finds nodes br which means the nodes are from different paths, t_mergeSize decides the max number of nodes that can be combined
-void DFG::findOpSucc(const list<DFGNode*>* t_succList, const int t_mergeSize) {
-  // std::cout <<"[MMJ] findOpSucc is running "<< std::endl;
-  // list<DFGNode*>* uniqueNodes;
-  // list<DFGNode*> succUniqueNodes;
-  // uniqueNodes = combineSuccSame(t_succList, t_mergeSize);
-  // // after merge nodes after br, we merge succeed nodes of the merged nodes
-  // while (true){
-  //   for (DFGNode* dfgNode: *uniqueNodes){
-  //     for (DFGNode* succNode: *(dfgNode->getSuccNodes())){
-  //       if (succNode->getPathName() == dfgNode->getPathName()){
-  //         // find succNodes of uniqueNodes and succNodes must in the same path with uniqueNodes
-  //         succUniqueNodes.push_back(succNode);
-  //       }
-  //     }
-  //   }
-  //   uniqueNodes =  combineSuccSame(&succUniqueNodes, t_mergeSize);
-  //   succUniqueNodes.clear();
-  //   if (uniqueNodes == NULL){
-  //     // finish if no uniqueNodes to be combined
-  //     std::cout <<"[MMJ] break the  findOpSucc"<< std::endl;
-  //     break;
-  //   }
-  // }
-  return;
-}
-
-// dualIssue is used to identify 'br' with multiple output, it combines the ouput together with the same control edge.
-// Note that the control edge is only one bit width since there is noly one 'br' input.
-// Note that dualIssue must be done after other combine operation.
-void DFG::dualIssue(const int t_mergeSize, const int t_mergeCount){
-  // testBench: adpcmkernel's 'br-3phi'
-  // toBeMatchedDFGNodes is to store the DFG nodes after br
-  std::cout <<"[MMJ] dual Issue is running. "<<std::endl;
-  list<DFGNode*>* toBeMatchedDFGNodes = new list<DFGNode*>();
-  int countPartialMerge = 1;
-  for (DFGNode* dfgNode: nodes) {
-    if(countPartialMerge > t_mergeCount){
-      return;
-    }
-    // we support both br and switch
-    if ((dfgNode->isBranch() or dfgNode->isOpt("switch")) and !dfgNode->hasMerged()) {
-      bool found = false;
-      std::cout <<"[MMJ] dual Issue finds the br/switch "<< dfgNode->getID() << std::endl;
-      for (DFGNode* succNode: *(dfgNode->getSuccNodes())) {
-        if (!succNode->hasMerged() and !succNode->hasCombined()){
-          toBeMatchedDFGNodes->push_back(succNode); 
-        }
-      }  
-      // find nodes that are the same after br
-      found = findOpSameSucc(toBeMatchedDFGNodes, t_mergeSize);
-      countPartialMerge++;
-    }
-    // clear toBeMatchedDFGNodes and find the next br/switch
-    toBeMatchedDFGNodes->clear();
-  }
-}
-
-
-// findIFELPath finds succeed nodes after br with different path
-void DFG::findIFELPath(list<DFGNode*>* t_succList, const int t_mergeSize) {
-  std::cout <<"[MMJ] findIFELPath is running "<< std::endl;
-  map<string, list<DFGNode*>> pathNameMap;
-  for (DFGNode* dfgNode: *t_succList){
-    std::cout <<"[MMJ] t_succList dfgNode "<< dfgNode->getID() << std::endl;
-    if (!dfgNode->hasMerged() and !dfgNode->hasCombined()){
-      pathNameMap[dfgNode->getPathName()].push_back(dfgNode);
-    }
-  }
-
-  for (auto& pair: pathNameMap) {
-    // sort every path by name to make similar names adjacent
-    pair.second.sort([](DFGNode* a, DFGNode* b) {
-        return a->getOpcodeName() < b->getOpcodeName(); 
-    });
-  }
-
-  list<DFGNode*> diffPathNode;
-  while(true){
-    for (auto& pair: pathNameMap) {
-      if (pair.second.empty()){
-        // if there is no node in this path, pass
-        continue;
-      }
-      diffPathNode.push_back(pair.second.front());
-      pair.second.pop_front();
-    }
-    if (diffPathNode.empty()){
-      std::cout <<"[MMJ] findIFELPath is finished "<<  std::endl;
-      return;
-    }
-    pathMerge(&diffPathNode, t_mergeSize);
-    diffPathNode.clear();
-  } 
-}
-
-// pathMerge is used to merge exclusive pathes
-void DFG::pathMerge(list<DFGNode*>* t_diffPathNode, const int t_mergeSize){
-  std::cout <<"[MMJ] pathMerge is running "<< std::endl;
-  // choose DFGNode in t_sameSuccNode with different pathName
-  if (t_diffPathNode->size() < 2){
-    // pathMerge is finished.
-    std::cout <<"[MMJ] pathMerge is finished "<< std::endl;
-    return;
-  }
-  list<DFGNode*> pathSucc;
-  for (DFGNode* dfgNode: *t_diffPathNode){
-    for (DFGNode* succNode: *(dfgNode->getSuccNodes())){
-      if ((succNode->getPathName() == dfgNode->getPathName()) and !succNode->hasMerged() and !succNode->hasCombined()){
-        // only add one succNode that is along the path of current dfgNode
-        pathSucc.push_back(succNode);
-        break;
-      }
-    }
-  }
-  int mergeCount = 0;
-  DFGNode* headNode = t_diffPathNode->front();
-  for (DFGNode* dfgNode: *t_diffPathNode){
-    if(dfgNode != headNode and !dfgNode->hasMerged() and !dfgNode->hasCombined()){
-        headNode ->addPatternPartner(dfgNode);                  
-    }
-    dfgNode->setMerge(); 
-    std::cout <<"[MMJ] dual Issue combine "<< dfgNode->getID() << std::endl; 
-    mergeCount++;
-    if (mergeCount == t_mergeSize) {
-      // combined DFGNode number <= t_mergeSize
-      break;
-    }                   
-  }
-  pathMerge(&pathSucc, t_mergeSize);
-  pathSucc.clear();
-}
-
-// dualIssueNew is used to identify 'br' with multiple output, it combines the ouput together with the same control edge.
-// Note that the control edge is only one bit width since there is noly one 'br' input.
-// Note that dualIssue must be done after other combine operation.
-void DFG::dualIssueNew(const int t_mergeSize, const int t_mergeCount){
-  // testBench: nwkernel's 'add-sext-ge'
-  // toBeMatchedDFGNodes is to store the DFG nodes after br
-  std::cout <<"[MMJ] dualIssueNew is running. "<<std::endl;
-  int countPartialMerge = 1;
-  for (DFGNode* dfgNode: nodes) {
-    if (countPartialMerge > t_mergeCount){
-      return;
-    }
-    if ((dfgNode->isBranch() or dfgNode->isOpt("switch")) and !dfgNode->hasMerged()) {
-      findIFELPath(dfgNode->getSuccNodes(), t_mergeSize);
-      countPartialMerge++;
-    }
-  }
-}
-
-
 bool DFG::shouldIgnore(Instruction* t_inst) {
   if (m_targetFunction) {
     return false;

src/DFGNode.cpp

@@ -335,14 +335,6 @@ void DFGNode::setCombine(string type) {
   m_combinedtype = type;
 }
 
-bool DFGNode::hasMerged() {
-  return m_merged;
-}
-
-void DFGNode::setMerge() {
-  m_merged = true;
-}
-
 void DFGNode::addPatternPartner(DFGNode* t_patternNode) {
   // setCombine() and setMerge() use the same addPatternPartner
   m_isPatternRoot = true;