[SYCLomatic] Support migration of cusparse<T>csrgemm and cusparseXcsrgemmNnz

clang/lib/DPCT/APINamesCUSPARSE.inc

@@ -531,3 +531,28 @@ ASSIGNABLE_FACTORY(CALL_FACTORY_ENTRY(
     "cusparseSpSM_solve", CALL(MapNames::getDpctNamespace() + "sparse::spsm",
                                MEMBER_CALL(ARG(0), true, "get_queue"), ARG(1),
                                ARG(2), ARG(3), ARG(4), ARG(5), ARG(6), ARG(7))))
+
+ASSIGNABLE_FACTORY(CALL_FACTORY_ENTRY(
+    "cusparseScsrgemm",
+    CALL(MapNames::getDpctNamespace() + "sparse::csrgemm", ARG(0), ARG(1),
+         ARG(2), ARG(3), ARG(4), ARG(5), ARG(6), ARG(8), ARG(9), ARG(10),
+         ARG(11), ARG(13), ARG(14), ARG(15), ARG(16), ARG(17), ARG(18),
+         ARG(19))))
+ASSIGNABLE_FACTORY(CALL_FACTORY_ENTRY(
+    "cusparseDcsrgemm",
+    CALL(MapNames::getDpctNamespace() + "sparse::csrgemm", ARG(0), ARG(1),
+         ARG(2), ARG(3), ARG(4), ARG(5), ARG(6), ARG(8), ARG(9), ARG(10),
+         ARG(11), ARG(13), ARG(14), ARG(15), ARG(16), ARG(17), ARG(18),
+         ARG(19))))
+ASSIGNABLE_FACTORY(CALL_FACTORY_ENTRY(
+    "cusparseCcsrgemm",
+    CALL(MapNames::getDpctNamespace() + "sparse::csrgemm", ARG(0), ARG(1),
+         ARG(2), ARG(3), ARG(4), ARG(5), ARG(6), ARG(8), ARG(9), ARG(10),
+         ARG(11), ARG(13), ARG(14), ARG(15), ARG(16), ARG(17), ARG(18),
+         ARG(19))))
+ASSIGNABLE_FACTORY(CALL_FACTORY_ENTRY(
+    "cusparseZcsrgemm",
+    CALL(MapNames::getDpctNamespace() + "sparse::csrgemm", ARG(0), ARG(1),
+         ARG(2), ARG(3), ARG(4), ARG(5), ARG(6), ARG(8), ARG(9), ARG(10),
+         ARG(11), ARG(13), ARG(14), ARG(15), ARG(16), ARG(17), ARG(18),
+         ARG(19))))

clang/lib/DPCT/APINames_cuSPARSE.inc

@@ -244,11 +244,11 @@ ENTRY(cusparseScsrgeam2, cusparseScsrgeam2, false, NO_FLAG, P4, "comment")
 ENTRY(cusparseDcsrgeam2, cusparseDcsrgeam2, false, NO_FLAG, P4, "comment")
 ENTRY(cusparseCcsrgeam2, cusparseCcsrgeam2, false, NO_FLAG, P4, "comment")
 ENTRY(cusparseZcsrgeam2, cusparseZcsrgeam2, false, NO_FLAG, P4, "comment")
-ENTRY(cusparseXcsrgemmNnz, cusparseXcsrgemmNnz, false, NO_FLAG, P4, "comment")
-ENTRY(cusparseScsrgemm, cusparseScsrgemm, false, NO_FLAG, P4, "comment")
-ENTRY(cusparseDcsrgemm, cusparseDcsrgemm, false, NO_FLAG, P4, "comment")
-ENTRY(cusparseCcsrgemm, cusparseCcsrgemm, false, NO_FLAG, P4, "comment")
-ENTRY(cusparseZcsrgemm, cusparseZcsrgemm, false, NO_FLAG, P4, "comment")
+ENTRY(cusparseXcsrgemmNnz, cusparseXcsrgemmNnz, true, NO_FLAG, P4, "DPCT1130")
+ENTRY(cusparseScsrgemm, cusparseScsrgemm, true, NO_FLAG, P4, "comment")
+ENTRY(cusparseDcsrgemm, cusparseDcsrgemm, true, NO_FLAG, P4, "comment")
+ENTRY(cusparseCcsrgemm, cusparseCcsrgemm, true, NO_FLAG, P4, "comment")
+ENTRY(cusparseZcsrgemm, cusparseZcsrgemm, true, NO_FLAG, P4, "comment")
 ENTRY(cusparseScsrgemm2_bufferSizeExt, cusparseScsrgemm2_bufferSizeExt, false, NO_FLAG, P4, "comment")
 ENTRY(cusparseDcsrgemm2_bufferSizeExt, cusparseDcsrgemm2_bufferSizeExt, false, NO_FLAG, P4, "comment")
 ENTRY(cusparseCcsrgemm2_bufferSizeExt, cusparseCcsrgemm2_bufferSizeExt, false, NO_FLAG, P4, "comment")

clang/lib/DPCT/ASTTraversal.cpp

@@ -3792,8 +3792,9 @@ void SPBLASFunctionCallRule::registerMatcher(MatchFinder &MF) {
         "cusparseCsrsv_solveEx",
         /*level 3*/
         "cusparseScsrmm", "cusparseDcsrmm", "cusparseCcsrmm", "cusparseZcsrmm",
-        "cusparseScsrmm2", "cusparseDcsrmm2", "cusparseCcsrmm2",
-        "cusparseZcsrmm2",
+        "cusparseScsrgemm", "cusparseDcsrgemm", "cusparseCcsrgemm",
+        "cusparseZcsrgemm", "cusparseXcsrgemmNnz", "cusparseScsrmm2",
+        "cusparseDcsrmm2", "cusparseCcsrmm2", "cusparseZcsrmm2",
         /*Generic*/
         "cusparseCreateCsr", "cusparseDestroySpMat", "cusparseCsrGet",
         "cusparseSpMatGetFormat", "cusparseSpMatGetIndexBase",
@@ -3861,6 +3862,102 @@ void SPBLASFunctionCallRule::runRule(const MatchFinder::MatchResult &Result) {
     EA.applyAllSubExprRepl();
     return;
   }
+  if (FuncName == "cusparseXcsrgemmNnz") {
+    std::vector<std::string> MigratedArgs;
+    for (const auto &Arg : CE->arguments()) {
+      MigratedArgs.push_back(ExprAnalysis::ref(Arg));
+    }
+    // We need find the next cusparse<T>csrgemm API call which is using the
+    // result of this API call, otherwise a warning will be emitted.
+    auto findOuterCS = [](const Stmt *Input) {
+      const CompoundStmt *CS = nullptr;
+      DpctGlobalInfo::findAncestor<Stmt>(
+          Input, [&](const DynTypedNode &Cur) -> bool {
+            if (Cur.get<DoStmt>() || Cur.get<ForStmt>() ||
+                Cur.get<WhileStmt>() || Cur.get<SwitchStmt>() ||
+                Cur.get<IfStmt>())
+              return true;
+            if (const CompoundStmt *S = Cur.get<CompoundStmt>())
+              CS = S;
+            return false;
+          });
+      return CS;
+    };
+    const CompoundStmt *CS1 = findOuterCS(CE);
+    // Find all the cusparse<T>csrgemm calls in this range.
+    using namespace clang::ast_matchers;
+    auto Matcher =
+        findAll(callExpr(callee(functionDecl(hasAnyName(
+                             "cusparseScsrgemm", "cusparseDcsrgemm",
+                             "cusparseCcsrgemm", "cusparseZcsrgemm"))))
+                    .bind("CallExpr"));
+    auto CEResults = match(Matcher, *CS1, DpctGlobalInfo::getContext());
+    // Find the correct call
+    const CallExpr* CorrectCall = nullptr;
+    for (auto &Result : CEResults) {
+      const CallExpr *MatchedCE = Result.getNodeAs<CallExpr>("CallExpr");
+      if (MatchedCE) {
+        // 1. The context should be the same
+        const CompoundStmt *CS2 = findOuterCS(MatchedCE);
+        if (CS1 != CS2)
+          continue;
+        // 2. The args should be the same
+        std::vector<std::string> MatchedCEMigratedArgs;
+        for (const auto &Arg : MatchedCE->arguments()) {
+          MatchedCEMigratedArgs.push_back(ExprAnalysis::ref(Arg));
+        }
+        const static std::map<unsigned /*CE*/, unsigned /*MatchedCE*/> IdxMap =
+            {
+                {0, 0},   {1, 1},   {2, 2},   {3, 3},   {4, 4},   {5, 5},
+                {6, 6},   {7, 7},   {8, 9},   {9, 10},  {10, 11}, {11, 12},
+                {12, 14}, {13, 15}, {14, 16}, {15, 18},
+            };
+        bool IsSame = true;
+        for (const auto &P : IdxMap) {
+          if (MigratedArgs[P.first] != MatchedCEMigratedArgs[P.second]) {
+            IsSame = false;
+            break;
+          }
+        }
+        if (IsSame) {
+          CorrectCall = MatchedCE;
+          break;
+        }
+      }
+    }
+    if (!CorrectCall) {
+      // emit warning
+      return;
+    }
+    const static std::map<unsigned /*CE*/, unsigned /*MatchedCE*/>
+        InsertBeforeIdxMap = {
+            {8, 8},
+            {12, 13},
+        };
+    std::string MigratedCall;
+    MigratedCall =
+        MapNames::getDpctNamespace() + "sparse::csrgemm_nnz(";
+    for (unsigned i = 0; i < MigratedArgs.size(); i++) {
+      if (InsertBeforeIdxMap.count(i)) {
+        MigratedCall +=
+            (ExprAnalysis::ref(CorrectCall->getArg(InsertBeforeIdxMap.at(i))) +
+             ", ");
+      }
+      MigratedCall += MigratedArgs[i];
+      if (i != MigratedArgs.size() - 1)
+        MigratedCall += ", ";
+    }
+    MigratedCall += ")";
+    auto DefRange = getDefinitionRange(CE->getBeginLoc(), CE->getEndLoc());
+    SourceLocation Begin = DefRange.getBegin();
+    SourceLocation End = DefRange.getEnd();
+    End = End.getLocWithOffset(
+        Lexer::MeasureTokenLength(End, DpctGlobalInfo::getSourceManager(),
+                                  DpctGlobalInfo::getContext().getLangOpts()));
+    emplaceTransformation(replaceText(Begin, End, std::move(MigratedCall),
+                                      DpctGlobalInfo::getSourceManager()));
+    return;
+  }
 }
 
 REGISTER_RULE(SPBLASFunctionCallRule, PassKind::PK_Migration,