[Polly] Refactoring IsInnermostParallel() in ISL to take the C++ wrapper object. NFC

[QwertycowMoo]

Summary

Currently, the IslAst library is a C library that would be incompatible with the rest of the LLVM because LLVM is written in C++.
I took one function, IsInnermostParallel(), and refactored it so that it would take the C++ wrapper object instead of using reference counters with the C ISL library. As well, all the references that use IsInnermostParallel() will use manage_copy() since they are still expecting the C object.

[Meinersbur]

The pre-merge check failed. You can find the error in its log (Usually the pre-merge check directly adds the error into this review, don't know why this did not happen here):

[3036/3231] Building CXX object tools/polly/lib/CMakeFiles/obj.Polly.dir/CodeGen/IslNodeBuilder.cpp.o
FAILED: tools/polly/lib/CMakeFiles/obj.Polly.dir/CodeGen/IslNodeBuilder.cpp.o
CCACHE_CPP2=yes CCACHE_HASHDIR=yes /usr/bin/ccache /usr/bin/clang++ -DBUILD_EXAMPLES -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/polly/lib -I/mnt/disks/ssd0/agent/llvm-project/polly/lib -Itools/polly/include -I/mnt/disks/ssd0/agent/llvm-project/polly/lib/External -I/mnt/disks/ssd0/agent/llvm-project/polly/lib/External/pet/include -I/mnt/disks/ssd0/agent/llvm-project/polly/lib/External/isl/include -Itools/polly/lib/External/isl/include -I/mnt/disks/ssd0/agent/llvm-project/polly/include -Iinclude -I/mnt/disks/ssd0/agent/llvm-project/llvm/include -gmlt -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -fno-exceptions -fno-rtti -O3   -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT tools/polly/lib/CMakeFiles/obj.Polly.dir/CodeGen/IslNodeBuilder.cpp.o -MF tools/polly/lib/CMakeFiles/obj.Polly.dir/CodeGen/IslNodeBuilder.cpp.o.d -o tools/polly/lib/CMakeFiles/obj.Polly.dir/CodeGen/IslNodeBuilder.cpp.o -c /mnt/disks/ssd0/agent/llvm-project/polly/lib/CodeGen/IslNodeBuilder.cpp
/mnt/disks/ssd0/agent/llvm-project/polly/lib/CodeGen/IslNodeBuilder.cpp:765:49: error: reference to type 'const isl::ast_node' could not bind to an lvalue of type 'isl_ast_node *'
  if (Vector && IslAstInfo::isInnermostParallel(For) &&
                                                ^~~
/mnt/disks/ssd0/agent/llvm-project/polly/include/polly/CodeGen/IslAst.h:151:56: note: passing argument to parameter 'Node' here
  static bool isInnermostParallel(const isl::ast_node &Node);
                                                       ^
1 error generated.

I also applied this patch locally and the same error occurs with gcc as well as msvc. Did you maybe forget to git add IslNodeBuilder.cpp a change into the commit? Could you fix this and then update the diff of this Phabricator review?

[QwertycowMoo]

Added IslNodeBuilder.cpp to the diff, required for build.
Just forgot it when creating the diff

[Meinersbur]

LGTM, thanks!

Would you like me to push the commit to main?

[QwertycowMoo]

Great! Go ahead and commit then!

polly/include/polly/CodeGen/IslAst.h

public:
 
   /// 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);
 
   /// Is this loop an innermost parallel loop?
-  static bool isInnermostParallel(__isl_keep isl_ast_node *Node);
+  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?
   static bool isExecutedInParallel(__isl_keep isl_ast_node *Node);
 
   /// Get the nodes schedule or a nullptr if not available.

polly/lib/CodeGen/IslAst.cpp

static isl_printer *cbPrintFor(__isl_take isl_printer *Printer,
   const std::string KnownParallelStr = "#pragma known-parallel";
   const std::string DepDisPragmaStr = "#pragma minimal dependence distance: ";
   const std::string SimdPragmaStr = "#pragma simd";
   const std::string OmpPragmaStr = "#pragma omp parallel for";
 
   if (DD)
     Printer = printLine(Printer, DepDisPragmaStr, DD);
 
-  if (IslAstInfo::isInnermostParallel(Node))
+  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))
     Printer = printLine(Printer, KnownParallelStr + BrokenReductionsStr);
 
   isl_pw_aff_free(DD);
static void walkAstForStatistics(__isl_keep isl_ast_node *Ast) {
   isl_ast_node_foreach_descendant_top_down(
       Ast,
       [](__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(Node))
+          if (IslAstInfo::isInnermostParallel(isl::manage_copy(Node)))
             NumInnermostParallel++;
           if (IslAstInfo::isOutermostParallel(Node))
             NumOutermostParallel++;
           if (IslAstInfo::isReductionParallel(Node))
             NumReductionParallel++;
           if (IslAstInfo::isExecutedInParallel(Node))
             NumExecutedInParallel++;
           break;

 }
 
 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(Node) ||
+  return IslAstInfo::isInnermostParallel(isl::manage_copy(Node)) ||
          IslAstInfo::isOutermostParallel(Node);
 }
 
-bool IslAstInfo::isInnermostParallel(__isl_keep isl_ast_node *Node) {
-  IslAstUserPayload *Payload = getNodePayload(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));
   return Payload && Payload->IsOutermostParallel;
 }
 

polly/lib/CodeGen/IslNodeBuilder.cpp

return isl_ast_node_foreach_descendant_top_down(
                return isl_bool_true;
              },
              nullptr) == isl_stat_error;
 }
 
 void IslNodeBuilder::createFor(__isl_take isl_ast_node *For) {
   bool Vector = PollyVectorizerChoice == VECTORIZER_POLLY;
 
-  if (Vector && IslAstInfo::isInnermostParallel(For) &&
+  if (Vector && IslAstInfo::isInnermostParallel(isl::manage_copy(For)) &&
       !IslAstInfo::isReductionParallel(For)) {
     int VectorWidth = getNumberOfIterations(isl::manage_copy(For));
     if (1 < VectorWidth && VectorWidth <= 16 && !hasPartialAccesses(For)) {
       createForVector(For, VectorWidth);
       return;
     }
   }