refactoring

Change-Id: If2a3789ed76c98a5f1d1be729f5051a2c54af2a7

Author: hassnaaHamdi

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -35,7 +35,6 @@
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/ScalarEvolutionExpander.h"
 #include <cassert>
-#include <queue>
 
 using namespace llvm;
 
@@ -2780,50 +2779,22 @@ static Value *interleaveVectors(IRBuilderBase &Builder, ArrayRef<Value *> Vals,
   // Scalable vectors cannot use arbitrary shufflevectors (only splats), so
   // must use intrinsics to interleave.
   if (VecTy->isScalableTy()) {
-    if (Vals.size() == 2) {
-      VectorType *WideVecTy = VectorType::getDoubleElementsVectorType(VecTy);
-      return Builder.CreateIntrinsic(WideVecTy, Intrinsic::vector_interleave2,
-                                     Vals,
-                                     /*FMFSource=*/nullptr, Name);
-    }
     unsigned InterleaveFactor = Vals.size();
     SmallVector<Value *> InterleavingValues(Vals);
-    // The total number of nodes in a balanced binary tree is calculated as 2n -
-    // 1, where `n` is the number of leaf nodes (`InterleaveFactor`). In this
-    // context, we exclude the root node because it will serve as the final
-    // interleaved value. Thus, the number of nodes to be processed/interleaved
-    // is: (2n - 1) - 1 = 2n - 2.
-
-    unsigned NumInterleavingValues = 2 * InterleaveFactor - 2;
-    for (unsigned I = 1; I < NumInterleavingValues; I += 2) {
-      // values that haven't been processed yet:
-      unsigned Remaining = InterleavingValues.size() - I + 1;
-      if (Remaining > 2 && isPowerOf2_32(Remaining)) {
-
-        // The remaining values form a new level in the interleaving tree.
-        // Arrange these values in the correct interleaving order for this
-        // level. The interleaving order places alternating elements from the
-        // first and second halves,
-        std::vector<Value *> RemainingValues(InterleavingValues.begin() + I - 1,
-                                             InterleavingValues.end());
-        unsigned Middle = Remaining / 2;
-        for (unsigned J = I - 1, K = 0; J < InterleavingValues.size();
-             J += 2, K++) {
-          InterleavingValues[J] = RemainingValues[K];
-          InterleavingValues[J + 1] = RemainingValues[Middle + K];
-        }
-      }
+    // As we are interleaving, the values sz will be shrinked until we have the
+    // single final interleaved value.
+    for (unsigned Midpoint = Factor / 2; Midpoint > 0; Midpoint /= 2) {
       VectorType *InterleaveTy =
-          cast<VectorType>(InterleavingValues[I]->getType());
+          cast<VectorType>(InterleavingValues[0]->getType());
       VectorType *WideVecTy =
           VectorType::getDoubleElementsVectorType(InterleaveTy);
-      auto *InterleaveRes = Builder.CreateIntrinsic(
-          WideVecTy, Intrinsic::vector_interleave2,
-          {InterleavingValues[I - 1], InterleavingValues[I]},
-          /*FMFSource=*/nullptr, Name);
-      InterleavingValues.push_back(InterleaveRes);
+      for (unsigned I = 0; I < Midpoint; ++I)
+        InterleavingValues[I] = Builder.CreateIntrinsic(
+            WideVecTy, Intrinsic::vector_interleave2,
+            {InterleavingValues[I], InterleavingValues[Midpoint + I]},
+            /*FMFSource=*/nullptr, Name);
     }
-    return InterleavingValues[NumInterleavingValues];
+    return InterleavingValues[0];
   }
 
   // Fixed length. Start by concatenating all vectors into a wide vector.
@@ -2960,49 +2931,31 @@ void VPInterleaveRecipe::execute(VPTransformState &State) {
         // Scalable vectors cannot use arbitrary shufflevectors (only splats),
         // so must use intrinsics to deinterleave.
 
-        SmallVector<Value *> DeinterleavedValues;
-        // If the InterleaveFactor is > 2, so we will have to do recursive
+        SmallVector<Value *> DeinterleavedValues(InterleaveFactor);
+        DeinterleavedValues[0] = NewLoad;
+        // For the case of InterleaveFactor > 2, we will have to do recursive
         // deinterleaving, because the current available deinterleave intrinsic
-        // supports only Factor of 2. DeinterleaveCount represent how many times
-        // we will do deinterleaving, we will do deinterleave on all nonleaf
-        // nodes in the deinterleave tree.
-        unsigned DeinterleaveCount = InterleaveFactor - 1;
-        std::vector<Value *> TempDeinterleavedValues;
-        TempDeinterleavedValues.push_back(NewLoad);
-        for (unsigned I = 0; I < DeinterleaveCount; ++I) {
-          auto *DiTy = TempDeinterleavedValues[I]->getType();
-          Value *DI = State.Builder.CreateIntrinsic(
-              Intrinsic::vector_deinterleave2, DiTy, TempDeinterleavedValues[I],
-              /*FMFSource=*/nullptr, "strided.vec");
-          Value *StridedVec = State.Builder.CreateExtractValue(DI, 0);
-          TempDeinterleavedValues.push_back(StridedVec);
-          StridedVec = State.Builder.CreateExtractValue(DI, 1);
-          TempDeinterleavedValues.push_back(StridedVec);
-          // Perform sorting at the start of each new level in the tree.
-          // A new level begins when the number of remaining values is a power
-          // of 2 and greater than 2. If a level has only 2 nodes, no sorting is
-          // needed as they are already in order. Number of remaining values to
-          // be processed:
-          unsigned NumRemainingValues = TempDeinterleavedValues.size() - I - 1;
-          if (NumRemainingValues > 2 && isPowerOf2_32(NumRemainingValues)) {
-            // these remaining values represent a new level in the tree,
-            // Reorder the values to match the correct deinterleaving order.
-            std::vector<Value *> RemainingValues(
-                TempDeinterleavedValues.begin() + I + 1,
-                TempDeinterleavedValues.end());
-            unsigned Middle = NumRemainingValues / 2;
-            for (unsigned J = 0, K = I + 1; J < NumRemainingValues;
-                 J += 2, K++) {
-              TempDeinterleavedValues[K] = RemainingValues[J];
-              TempDeinterleavedValues[Middle + K] = RemainingValues[J + 1];
-            }
+        // supports only Factor of 2, otherwise it will bailout after first
+        // iteration.
+        // As we are deinterleaving, the values will be doubled until reachingt
+        // to the InterleaveFactor.
+        for (int NumVectors = 1; NumVectors < InterleaveFactor;
+             NumVectors *= 2) {
+          // deinterleave the elements within the vector
+          std::vector<Value *> TempDeinterleavedValues(NumVectors);
+          for (int I = 0; I < NumVectors; ++I) {
+            auto *DiTy = DeinterleavedValues[I]->getType();
+            TempDeinterleavedValues[I] = State.Builder.CreateIntrinsic(
+                Intrinsic::vector_deinterleave2, DiTy, DeinterleavedValues[I],
+                /*FMFSource=*/nullptr, "strided.vec");
           }
+          // Extract the deinterleaved values:
+          for (int I = 0; I < 2; ++I)
+            for (int J = 0; J < NumVectors; ++J)
+              DeinterleavedValues[NumVectors * I + J] =
+                  State.Builder.CreateExtractValue(TempDeinterleavedValues[J],
+                                                   I);
         }
-        // Final deinterleaved values:
-        DeinterleavedValues.insert(DeinterleavedValues.begin(),
-                                   TempDeinterleavedValues.begin() +
-                                       InterleaveFactor - 1,
-                                   TempDeinterleavedValues.end());
 
 #ifndef NDEBUG
         for (Value *Val : DeinterleavedValues)