Format code changes to be nicer

weiya711 · weiya711 · commit 1d028bb2208a · 2021-06-20T21:20:14.000-07:00
diff --git a/include/taco/index_notation/index_notation.h b/include/taco/index_notation/index_notation.h
@@ -691,7 +691,6 @@ class IndexStmt : public util::IntrusivePtr<const IndexStmtNode> {
   IndexStmt precompute(IndexExpr expr, std::vector<IndexVar> i_vars,
                        std::vector<IndexVar> iw_vars, TensorVar workspace) const;
   
-
   /// bound specifies a compile-time constraint on an index variable's
   /// iteration space that allows knowledge of the
   /// size or structured sparsity pattern of the inputs to be
@@ -1134,7 +1133,6 @@ bool isReductionNotation(IndexStmt, std::string* reason=nullptr);
 /// given a schedule described by the Provenance Graph
 bool isReductionNotationScheduled(IndexStmt, ProvenanceGraph, std::string* reason=nullptr);
 
-
 /// Check whether the statement is in the concrete index notation dialect.
 /// This means every index variable has a forall node, there are no reduction
 /// nodes, and that every reduction variable use is nested inside a compound
diff --git a/include/taco/parser/schedule_parser.h b/include/taco/parser/schedule_parser.h
@@ -17,8 +17,6 @@ std::vector<std::string> varListParser(const std::string);
 // serialize the result of a parse (for debugging)
 std::string serializeParsedSchedule(std::vector<std::vector<std::string>>);
 
-
-
 }}
 
 #endif //TACO_EINSUM_PARSER_H
diff --git a/src/index_notation/index_notation.cpp b/src/index_notation/index_notation.cpp
@@ -1461,8 +1461,6 @@ map<IndexVar,Dimension> IndexStmt::getIndexVarDomains() const {
   return indexVarDomains;
 }
 
-
-
 IndexStmt IndexStmt::concretizeScheduled(ProvenanceGraph provGraph, vector<IndexVar> forallIndexVarList) const {
   IndexStmt stmt = *this;
   string r;
@@ -2785,7 +2783,8 @@ IndexStmt makeReductionNotationScheduled(IndexStmt stmt, ProvenanceGraph provGra
   return makeReductionNotationScheduled(to<Assignment>(stmt), provGraph);
 }
 
-IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGraph, vector<IndexVar> forallIndexVars) {
+IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGraph, 
+                                        vector<IndexVar> forallIndexVars) {
   std::string reason;
   taco_iassert(isReductionNotationScheduled(stmt, provGraph, &reason))
     << "Not reduction notation: " << stmt << std::endl << reason;
@@ -2820,7 +2819,8 @@ IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGrap
             stmt = forall(i, stmt);
           }
         } else {
-          reductionAndFreeVars.insert(reductionAndFreeVars.end(), topLevelReductions.begin(), topLevelReductions.end());
+          reductionAndFreeVars.insert(reductionAndFreeVars.end(), topLevelReductions.begin(), 
+                                      topLevelReductions.end());
         }
       }
       else {
@@ -2873,7 +2873,8 @@ IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGrap
         auto ancestorVars = provGraph.getUnderivedAncestors(i);
         IndexVar ancestorI = *reductionAndFreeVars.begin();
         for (auto &ancestorVar : ancestorVars) {
-          if (std::find(reductionAndFreeVars.begin(), reductionAndFreeVars.end(), ancestorVar) != reductionAndFreeVars.end()) {
+          if (std::find(reductionAndFreeVars.begin(), reductionAndFreeVars.end(), ancestorVar) 
+              != reductionAndFreeVars.end()) {
             stmt = forall(i, stmt);
           }
         }
diff --git a/src/ir/workspace_rewriter.cpp b/src/ir/workspace_rewriter.cpp
@@ -15,7 +15,8 @@ using namespace taco::ir;
 namespace taco {
 
 struct WorkspaceRewriter : ir::IRRewriter {
-  WorkspaceRewriter(std::vector<TensorVar> whereTemps, std::map<TensorVar, std::vector<ir::Expr>> temporarySizeMap) : whereTemps(whereTemps),
+  WorkspaceRewriter(std::vector<TensorVar> whereTemps, std::map<TensorVar, 
+    std::vector<ir::Expr>> temporarySizeMap) : whereTemps(whereTemps),
   temporarySizeMap(temporarySizeMap) {}
   std::vector<TensorVar> whereTemps;
   std::map<TensorVar, std::vector<ir::Expr>> temporarySizeMap;
@@ -29,14 +30,18 @@ struct WorkspaceRewriter : ir::IRRewriter {
         string gpName = temp.getName() + to_string(op->mode + 1) + "_dimension";
 
         if (temp.defined() && gpName == op->name) {
-          taco_iassert(temporarySizeMap.find(temp) != temporarySizeMap.end()) << "Cannot rewrite workspace Dimension "
-                                                                                 "GetProperty due to tensorVar not in expression map";
+          taco_iassert(temporarySizeMap.find(temp) != temporarySizeMap.end()) << "Cannot rewrite workspace "
+                                                                                 "Dimension GetProperty due "
+                                                                                 "to tensorVar not in "
+                                                                                 "expression map";
           auto tempExprList = temporarySizeMap.at(temp);
 
-          taco_iassert((int)tempExprList.size() > op->mode) << "Cannot rewrite workspace (" << op->tensor <<
-                                                               ") Dimension GetProperty "
-                                                               "due to mode (" << op->mode << ") not in expression map (size = "
-                                                               << tempExprList.size() << ")";
+          taco_iassert((int)tempExprList.size() > op->mode) << "Cannot rewrite workspace (" 
+                                                            << op->tensor 
+                                                            << ") Dimension GetProperty due to mode (" 
+                                                            << op->mode 
+                                                            << ") not in expression map (size = "
+                                                            << tempExprList.size() << ")";
           expr = tempExprList.at(op->mode);
           return;
         }
diff --git a/src/parser/schedule_parser.cpp b/src/parser/schedule_parser.cpp
@@ -45,7 +45,9 @@ vector<vector<string>> ScheduleParser(const string argValue) {
             parenthesesCnt++;
             break;
         case parser::Token::rparen:
-            taco_uassert(parenthesesCnt > 0) << "mismatched parentheses (too many right-parens, negative nesting level) in schedule expression '" << argValue << "'";
+            taco_uassert(parenthesesCnt > 0) << "mismatched parentheses" 
+                                                "(too many right-parens, negative nesting level) "
+                                                "in schedule expression '" << argValue << "'";
             if(parenthesesCnt > 1)
                 current_element += lexer.tokenString(tok);
             parenthesesCnt--;
@@ -76,8 +78,9 @@ vector<vector<string>> ScheduleParser(const string argValue) {
             curlyParenthesesCnt++;
             break;
         case parser::Token::rcurly:
-            taco_uassert(curlyParenthesesCnt > 0) << "mismatched curly parentheses (too many right-curly-parens, "
-                                                     "negative nesting level) in schedule expression '" << argValue << "'";
+            taco_uassert(curlyParenthesesCnt > 0) << "mismatched curly parentheses "
+                                                     "(too many right-curly-parens, negative nesting level)"
+                                                     " in schedule expression '" << argValue << "'";
             current_element += lexer.tokenString(tok);
             curlyParenthesesCnt--;
             break;
@@ -95,7 +98,8 @@ vector<vector<string>> ScheduleParser(const string argValue) {
             break;
         }
     }
-    taco_uassert(parenthesesCnt == 0) << "imbalanced parentheses (too few right-parens) in schedule expression '" << argValue << "'";
+    taco_uassert(parenthesesCnt == 0) << "imbalanced parentheses (too few right-parens) "
+                                         "in schedule expression '" << argValue << "'";
     if(current_element.length() > 0)
         current_schedule.push_back(current_element);
     if(current_schedule.size() > 0)
@@ -131,8 +135,9 @@ vector<string> varListParser(const string argValue) {
         curlyParenthesesCnt++;
         break;
       case parser::Token::rcurly:
-        taco_uassert(curlyParenthesesCnt > 0) << "mismatched curly parentheses (too many right-curly-parens, "
-                                                 "negative nesting level) in schedule expression '" << argValue << "'";
+        taco_uassert(curlyParenthesesCnt > 0) << "mismatched curly parentheses "
+                                                 "(too many right-curly-parens, negative nesting level)"
+                                                 " in schedule expression '" << argValue << "'";
         if (curlyParenthesesCnt == 1) {
             parsed.push_back(current_element);
             current_element = "";
@@ -159,8 +164,8 @@ vector<string> varListParser(const string argValue) {
         break;
     }
   }
-  taco_uassert(curlyParenthesesCnt == 0) << "imbalanced curly brackets (too few right-curly brackets) in"
-                                            " schedule expression '" << argValue << "'";
+  taco_uassert(curlyParenthesesCnt == 0) << "imbalanced curly brackets (too few right-curly brackets) "
+                                            "in schedule expression '" << argValue << "'";
   if(current_element.length() > 0)
     parsed.push_back(current_element);
   return parsed;
diff --git a/test/tests-scheduling-eval.cpp b/test/tests-scheduling-eval.cpp
@@ -76,25 +76,19 @@ IndexStmt scheduleSpGEMMCPU(IndexStmt stmt, bool doPrecompute) {
                 {result.getType().getShape().getDimension(1)}), taco::dense);
     stmt = stmt.precompute(assign.getRhs(), j, j, w);
   }
-  cout << "SPGEMM: " << stmt << endl;
   stmt = stmt.assemble(result, AssembleStrategy::Insert, true);
-  cout << "Post Assembly SPGEMM: " << stmt << endl;
   auto qi_stmt = stmt.as<Assemble>().getQueries();
   IndexVar qi;
   if (isa<Where>(qi_stmt)) {
     qi = qi_stmt.as<Where>().getConsumer().as<Forall>().getIndexVar();
   } else {
     qi = qi_stmt.as<Forall>().getIndexVar();
   }
-;
   stmt = stmt.parallelize(i, ParallelUnit::CPUThread,
-                          OutputRaceStrategy::NoRaces);
-  cout << "\nPost Parallelize SPGEMM: " << stmt << endl;
-  stmt = stmt
+                          OutputRaceStrategy::NoRaces)
              .parallelize(qi, ParallelUnit::CPUThread,
                           OutputRaceStrategy::NoRaces);
 
-  cout << "Post Scheduled SPGEMM: " << stmt << endl;
   return stmt;
 }
 
diff --git a/test/tests-workspaces.cpp b/test/tests-workspaces.cpp
@@ -247,8 +247,10 @@ TEST(workspaces, precompute4D_add) {
 
 
   IndexStmt stmt = A.getAssignment().concretize();
-  TensorVar ws1("ws1", Type(Float64, {(size_t)N, (size_t)N, (size_t)N, (size_t)N}), Format{Dense, Dense, Dense, Dense});
-  TensorVar ws2("ws2", Type(Float64, {(size_t)N, (size_t)N, (size_t)N, (size_t)N}), Format{Dense, Dense, Dense, Dense});
+  TensorVar ws1("ws1", Type(Float64, {(size_t)N, (size_t)N, (size_t)N, (size_t)N}), 
+                Format{Dense, Dense, Dense, Dense});
+  TensorVar ws2("ws2", Type(Float64, {(size_t)N, (size_t)N, (size_t)N, (size_t)N}), 
+                Format{Dense, Dense, Dense, Dense});
   stmt = stmt.precompute(precomputedExpr, {i, j, k, l}, {i, j, k, l}, ws1)
     .precompute(ws1(i, j, k, l) + D(i, j, k, l), {i, j, k, l}, {i, j, k ,l}, ws2);
 
diff --git a/tools/taco.cpp b/tools/taco.cpp
@@ -389,8 +389,8 @@ static bool setSchedulingCommands(vector<vector<string>> scheduleCommands, parse
       cout << endl;
       taco_uassert(scheduleCommand.size() == 3 || scheduleCommand.size() == 4)
         << "'precompute' scheduling directive takes 3 or 4 parameters: "
-        << "precompute(expr, i, iw [, workspace_name]) or precompute(expr, {i_vars}, {iw_vars} [, workspace_name])"
-        << scheduleCommand.size();
+        << "precompute(expr, i, iw [, workspace_name]) or precompute(expr, {i_vars}, "
+           "{iw_vars} [, workspace_name])" << scheduleCommand.size();
 
       exprStr = scheduleCommand[0];
 //      i       = scheduleCommand[1];

Original file line number	Diff line number	Diff line change
`@@ -1461,8 +1461,6 @@ map<IndexVar,Dimension> IndexStmt::getIndexVarDomains() const {`
`1461`	`1461`	`return indexVarDomains;`
`1462`	`1462`	`}`
`1463`	`1463`
`1464`		`-`
`1465`		`-`
`1466`	`1464`	`IndexStmt IndexStmt::concretizeScheduled(ProvenanceGraph provGraph, vector<IndexVar> forallIndexVarList) const {`
`1467`	`1465`	`IndexStmt stmt = *this;`
`1468`	`1466`	`string r;`
`@@ -2785,7 +2783,8 @@ IndexStmt makeReductionNotationScheduled(IndexStmt stmt, ProvenanceGraph provGra`
`2785`	`2783`	`return makeReductionNotationScheduled(to<Assignment>(stmt), provGraph);`
`2786`	`2784`	`}`
`2787`	`2785`
`2788`		`-IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGraph, vector<IndexVar> forallIndexVars) {`
	`2786`	`+IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGraph,`
	`2787`	`+ vector<IndexVar> forallIndexVars) {`
`2789`	`2788`	`std::string reason;`
`2790`	`2789`	`taco_iassert(isReductionNotationScheduled(stmt, provGraph, &reason))`
`2791`	`2790`	`<< "Not reduction notation: " << stmt << std::endl << reason;`
`@@ -2820,7 +2819,8 @@ IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGrap`
`2820`	`2819`	`stmt = forall(i, stmt);`
`2821`	`2820`	`}`
`2822`	`2821`	`} else {`
`2823`		`- reductionAndFreeVars.insert(reductionAndFreeVars.end(), topLevelReductions.begin(), topLevelReductions.end());`
	`2822`	`+ reductionAndFreeVars.insert(reductionAndFreeVars.end(), topLevelReductions.begin(),`
	`2823`	`+ topLevelReductions.end());`
`2824`	`2824`	`}`
`2825`	`2825`	`}`
`2826`	`2826`	`else {`
`@@ -2873,7 +2873,8 @@ IndexStmt makeConcreteNotationScheduled(IndexStmt stmt, ProvenanceGraph provGrap`
`2873`	`2873`	`auto ancestorVars = provGraph.getUnderivedAncestors(i);`
`2874`	`2874`	`IndexVar ancestorI = *reductionAndFreeVars.begin();`
`2875`	`2875`	`for (auto &ancestorVar : ancestorVars) {`
`2876`		`- if (std::find(reductionAndFreeVars.begin(), reductionAndFreeVars.end(), ancestorVar) != reductionAndFreeVars.end()) {`
	`2876`	`+ if (std::find(reductionAndFreeVars.begin(), reductionAndFreeVars.end(), ancestorVar)`
	`2877`	`+ != reductionAndFreeVars.end()) {`
`2877`	`2878`	`stmt = forall(i, stmt);`
`2878`	`2879`	`}`
`2879`	`2880`	`}`