[mlir][affine] Vectorizer test notifies the case with the unparallel loop with reduction

[Lewuathe]

Summary

Vectorizer test does not support unparallel loop since no parallel reduction is available. We can emit the informational message instead of crashing the cli in such a case.
Fixes https://github.com/llvm/llvm-project/issues/61842

[mehdi_amini]

mlir/test/Dialect/Affine/SuperVectorize/vectorize_unsupported.mlir

1

Please remove allow-unregistered-dialect

mlir/test/Dialect/Affine/SuperVectorize/vectorize_unsupported.mlir

+// RUN: mlir-opt -allow-unregistered-dialect %s -affine-super-vectorizer-test  -vectorize-affine-loop-nest -split-input-file 2>&1 |  FileCheck %s
+
+func.func @unparallel_loop_reduction_unsupported(%in: memref<256x512xf32>, %out: memref<256xf32>) {
+ // CHECK: Outermost loop cannot be parallel
+ %cst = arith.constant 1.000000e+00 : f32
+ %final_red = affine.for %j = 0 to 512 iter_args(%red_iter = %cst) -> (f32) {
+   %add = arith.addf %red_iter, %red_iter : f32
+   affine.yield %add : f32
+ }
+ return
+}

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

struct VectorizerTestPass
   void runOnOperation() override;
   void testVectorShapeRatio(llvm::raw_ostream &outs);
   void testForwardSlicing(llvm::raw_ostream &outs);
   void testBackwardSlicing(llvm::raw_ostream &outs);
   void testSlicing(llvm::raw_ostream &outs);
   void testComposeMaps(llvm::raw_ostream &outs);
 
   /// Test for 'vectorizeAffineLoopNest' utility.
-  void testVecAffineLoopNest();
+  void testVecAffineLoopNest(llvm::raw_ostream &outs);
 };
 
 } // namespace
 
 void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) {
   auto f = getOperation();
   using matcher::Op;
   SmallVector<int64_t, 8> shape(clTestVectorShapeRatio.begin(),
void VectorizerTestPass::testComposeMaps(llvm::raw_ostream &outs) {
   AffineMap res;
   for (auto m : maps) {
     res = res ? res.compose(m) : m;
   }
   simplifyAffineMap(res).print(outs << "\nComposed map: ");
 }
 
 /// Test for 'vectorizeAffineLoopNest' utility.
-void VectorizerTestPass::testVecAffineLoopNest() {
+void VectorizerTestPass::testVecAffineLoopNest(llvm::raw_ostream &outs) {
   std::vector<SmallVector<AffineForOp, 2>> loops;
   gatherLoops(getOperation(), loops);
 
   // Expected only one loop nest.
   if (loops.empty() || loops[0].size() != 1)
     return;
 
   // We vectorize the outermost loop found with VF=4.
   AffineForOp outermostLoop = loops[0][0];
   VectorizationStrategy strategy;
   strategy.vectorSizes.push_back(4 /*vectorization factor*/);
   strategy.loopToVectorDim[outermostLoop] = 0;
+
+  ReductionLoopMap reductionLoops;
+  SmallVector<LoopReduction, 2> reductions;
+  if (!isLoopParallel(outermostLoop, &reductions)) {
+    outs << "Outermost loop cannot be parallel\n";
+    return;
+  }
   std::vector<SmallVector<AffineForOp, 2>> loopsToVectorize;
   loopsToVectorize.push_back({outermostLoop});
   (void)vectorizeAffineLoopNest(loopsToVectorize, strategy);
 }
 
 void VectorizerTestPass::runOnOperation() {
   // Only support single block functions at this point.
   func::FuncOp f = getOperation();
llvm::raw_string_ostream outs(str);
     if (clTestSlicingAnalysis)
       testSlicing(outs);
 
     if (clTestComposeMaps)
       testComposeMaps(outs);
   }
 
   if (clTestVecAffineLoopNest)
-    testVecAffineLoopNest();
+    testVecAffineLoopNest(outs);
 
   if (!outs.str().empty()) {
     emitRemark(UnknownLoc::get(&getContext()), outs.str());
   }
 }
 
 namespace mlir {
 void registerVectorizerTestPass() { PassRegistration<VectorizerTestPass>(); }
 } // namespace mlir