[llvm] [LoopInterchange] Add metadata to control loop-interchange (PR #127474)

[Ryotaro Kasuga via llvm-commits]

================
@@ -572,6 +578,70 @@ struct LoopInterchange {
 
 } // end anonymous namespace
 
+bool LoopInterchangeList::hasSupportedLoopDepth(
+    OptimizationRemarkEmitter &ORE) {
+  unsigned LoopNestDepth = ListEnd - ListBegin;
+  if (LoopNestDepth < MinLoopNestDepth || LoopNestDepth > MaxLoopNestDepth) {
+    LLVM_DEBUG(dbgs() << "Unsupported depth of loop nest " << LoopNestDepth
+                      << ", the supported range is [" << MinLoopNestDepth
+                      << ", " << MaxLoopNestDepth << "].\n");
+    Loop *OuterLoop = LoopList[ListBegin];
+    ORE.emit([&]() {
+      return OptimizationRemarkMissed(DEBUG_TYPE, "UnsupportedLoopNestDepth",
+                                      OuterLoop->getStartLoc(),
+                                      OuterLoop->getHeader())
+             << "Unsupported depth of loop nest, the supported range is ["
+             << std::to_string(MinLoopNestDepth) << ", "
+             << std::to_string(MaxLoopNestDepth) << "].\n";
+    });
+    return false;
+  }
+  return true;
+}
+
+// Check the metadata for interchange. The outermost one is taken into account
+// and nested ones are ignored. The metadata affects the entire loop nest such
+// that the outermost loop is the loop for which the metadata is specified. For
+// example, in the following example, the loop-interchange will be performed
+// only to the outermost two loops, and the second pragma is ignored.
+//
+// for (...)
+//   for (...)
+//     #pragma clang loop interchange(disable)
+//     for (...)
+//       #pragma clang loop interchange(enable)
+//       for (...)
+//         for (...)
+//           Stmt
+//
----------------
kasuga-fj wrote:

Thanks for your comment.

> E.g. it could specify to apply unroll_and_jam on the i-loop, which becomes the outer loop after the interchange has been applied.

IIUIC, we can rewrite the metadata and move the metadata for `unroll_and_jam` from the j-loop to i-loop. What I'm curious is that, is this desirable behavior for the user? IMO this behavior is a bit confusing for the user. The best solution here would be to apply unroll_and_jam before interchange, but as you said, it's impossible due to the order depends on the default pipeline.

> For insterchange, this could be used to specify multiple pairwise exchanges, one following the other.

You meant that, in the code below, the i-loop and j-loop are exchanged first, then the k-loop and l-loop are exchanged. Is my understanding correct?

```c
#pragma clang loop interchange(enable)
for (int i = 0; i < N; i++) {
  for (int j = 0; j < N; j++) {
    #pragma clang loop interchange(enable)
    for (int k = 0; k < N; k++) {
      for (int l = 0; l < N; l++) {
        ...
      }
    }
  }
}
```

At first I tried implementing it in this way. But now I feel it would be more useful to affect the entire loop nest rather than against a loop pairwise, since LoopInterchange handles a loop nest. That is, in the code above, loop interchange is applied to all four loops, and the new order of the loop nest is determined by the LoopInterchange pass. Or, if we want to disable the interchange for some reason and specify it as below, it would be better to stop applying the interchange not only to the i-loop and j-loop, but to the entire loop nest (i.e., including the k-loop and l-loop). WDYT?

```c
#pragma clang loop interchange(disable)
for (int i = 0; i < N; i++) {
  for (int j = 0; j < N; j++) {
    for (int k = 0; k < N; k++) {
      for (int l = 0; l < N; l++) {
        ...
      }
    }
  }
}
```

https://github.com/llvm/llvm-project/pull/127474