[Polly] Refabricating IsOutermostParallel() from Integer Set Libarary(ISL) to take the C++ wrapper

[prateekpardeshi]

Summary

Polly use algorithms from the Integer Set Library (isl), which is a library written in C and which is incompatible with the rest of the LLVM as it is written in C++.

Changes made:

• Refabricating IsOutermostParallel() to take C++ bindings instead of reference-counting in C isl lib.
• Addition of manage_copy() to be used as reference for C objects instead of IsOutermostParallel()

[Meinersbur]

The build failed because the formatting is not right (see "Lint: Pre-merge checks" message). You can run ninja polly-update-format to automatically fix it, then update the diff of this review.

compiler-rt/lib/hwasan/hwasan_flags.inc

83 ↗

(On Diff #327334)

Unrelated change; please remove from the diff

[prateekpardeshi]

Ran ninja polly-update-format and updated diff while removing unrelated changes.

[Meinersbur]

LGTM. Thanks for the update.

Do you need assistance to land this change?

[prateekpardeshi]

Please merge this code if it seems okay. Thanks!

polly/include/polly/CodeGen/IslAst.h

public:
 
   /// Is this loop an innermost loop?
   static bool isInnermost(__isl_keep isl_ast_node *Node);
 
   /// Is this loop a parallel loop?
   static bool isParallel(__isl_keep isl_ast_node *Node);
 
   /// Is this loop an outermost parallel loop?
-  static bool isOutermostParallel(__isl_keep isl_ast_node *Node);
+  static bool isOutermostParallel(const isl::ast_node &Node);
 
   /// Is this loop an innermost parallel loop?
   static bool isInnermostParallel(const isl::ast_node &Node);
 
   /// Is this loop a reduction parallel loop?
   static bool isReductionParallel(__isl_keep isl_ast_node *Node);
 
   /// Will the loop be run as thread parallel?

polly/lib/CodeGen/IslAst.cpp

static isl_printer *cbPrintFor(__isl_take isl_printer *Printer,
   if (DD)
     Printer = printLine(Printer, DepDisPragmaStr, DD);
 
   if (IslAstInfo::isInnermostParallel(isl::manage_copy(Node)))
     Printer = printLine(Printer, SimdPragmaStr + BrokenReductionsStr);
 
   if (IslAstInfo::isExecutedInParallel(Node))
     Printer = printLine(Printer, OmpPragmaStr);
-  else if (IslAstInfo::isOutermostParallel(Node))
+  else if (IslAstInfo::isOutermostParallel(isl::manage_copy(Node)))
     Printer = printLine(Printer, KnownParallelStr + BrokenReductionsStr);
 
   isl_pw_aff_free(DD);
   return isl_ast_node_for_print(Node, Printer, Options);
 }
 
 /// Check if the current scheduling dimension is parallel.
 ///
isl_ast_node_foreach_descendant_top_down(
       [](__isl_keep isl_ast_node *Node, void *User) -> isl_bool {
         switch (isl_ast_node_get_type(Node)) {
         case isl_ast_node_for:
           NumForLoops++;
           if (IslAstInfo::isParallel(Node))
             NumParallel++;
           if (IslAstInfo::isInnermostParallel(isl::manage_copy(Node)))
             NumInnermostParallel++;
-          if (IslAstInfo::isOutermostParallel(Node))
+          if (IslAstInfo::isOutermostParallel(isl::manage_copy(Node)))
             NumOutermostParallel++;
           if (IslAstInfo::isReductionParallel(Node))
             NumReductionParallel++;
           if (IslAstInfo::isExecutedInParallel(Node))
             NumExecutedInParallel++;
           break;
 
         case isl_ast_node_if:

 
 bool IslAstInfo::isInnermost(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
   return Payload && Payload->IsInnermost;
 }
 
 bool IslAstInfo::isParallel(__isl_keep isl_ast_node *Node) {
   return IslAstInfo::isInnermostParallel(isl::manage_copy(Node)) ||
-         IslAstInfo::isOutermostParallel(Node);
+         IslAstInfo::isOutermostParallel(isl::manage_copy(Node));
 }
 
 bool IslAstInfo::isInnermostParallel(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsInnermostParallel;
 }
 
-bool IslAstInfo::isOutermostParallel(__isl_keep isl_ast_node *Node) {
-  IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
+bool IslAstInfo::isOutermostParallel(const isl::ast_node &Node) {
+  IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsOutermostParallel;
 }
 
 bool IslAstInfo::isReductionParallel(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
   return Payload && Payload->IsReductionParallel;
 }
 
 bool IslAstInfo::isExecutedInParallel(__isl_keep isl_ast_node *Node) {
   if (!PollyParallel)
     return false;
 
   // Do not parallelize innermost loops.
   //
   // Parallelizing innermost loops is often not profitable, especially if
   // they have a low number of iterations.
   //
   // TODO: Decide this based on the number of loop iterations that will be
   //       executed. This can possibly require run-time checks, which again
   //       raises the question of both run-time check overhead and code size
   //       costs.
   if (!PollyParallelForce && isInnermost(Node))
     return false;
 
-  return isOutermostParallel(Node) && !isReductionParallel(Node);
+  return isOutermostParallel(isl::manage_copy(Node)) &&
+         !isReductionParallel(Node);
 }
 
 __isl_give isl_union_map *
 IslAstInfo::getSchedule(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
   return Payload ? isl_ast_build_get_schedule(Payload->Build) : nullptr;
 }