[mlir] Use llvm accumulate wrappers. NFCI.

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

@@ -264,8 +264,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

@@ -264,8 +264,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

@@ -268,8 +268,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

@@ -268,8 +268,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

@@ -268,8 +268,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

@@ -405,8 +405,7 @@ class MLIRGenImpl {
     // The attribute is a vector with a floating point value per element
     // (number) in the array, see `collectData()` below for more details.
     std::vector<double> data;
-    data.reserve(std::accumulate(lit.getDims().begin(), lit.getDims().end(), 1,
-                                 std::multiplies<int>()));
+    data.reserve(llvm::product_of(lit.getDims()));
     collectData(lit, data);
 
     // The type of this attribute is tensor of 64-bit floating-point with the

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

@@ -22,6 +22,7 @@
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/STLExtras.h"
 #include <cstdint>
 #include <numeric>
 
@@ -110,9 +111,7 @@ static Value calculateMemrefTotalSizeBytes(Location loc, MemRefType memrefType,
                      {TypeAttr::get(memrefType.getElementType())}));
 
   IndexType indexType = builder.getIndexType();
-  int64_t numElements = std::accumulate(memrefType.getShape().begin(),
-                                        memrefType.getShape().end(), int64_t{1},
-                                        std::multiplies<int64_t>());
+  int64_t numElements = llvm::product_of(memrefType.getShape());
   emitc::ConstantOp numElementsValue = emitc::ConstantOp::create(
       builder, loc, indexType, builder.getIndexAttr(numElements));
 

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

@@ -18,6 +18,7 @@
 #include "mlir/Dialect/Tosa/Utils/ConversionUtils.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include <numeric>
 
@@ -70,8 +71,7 @@ TensorType inferReshapeExpandedType(TensorType inputType,
 
         // Calculate the product of all elements in 'newShape' except for the -1
         // placeholder, which we discard by negating the result.
-        int64_t totalSizeNoPlaceholder = -std::accumulate(
-            newShape.begin(), newShape.end(), 1, std::multiplies<int64_t>());
+        int64_t totalSizeNoPlaceholder = -llvm::product_of(newShape);
 
         // If there is a 0 component in 'newShape', resolve the placeholder as
         // 0.

mlir/lib/Conversion/VectorToAMX/VectorToAMX.cpp

@@ -20,6 +20,7 @@
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/DebugLog.h"
 
 #include <numeric>
@@ -265,8 +266,7 @@ loadStoreFromTransfer(PatternRewriter &rewriter,
   if (isPacked)
     src = collapseLastDim(rewriter, src);
   int64_t rows = vecShape[0];
-  int64_t cols = std::accumulate(vecShape.begin() + 1, vecShape.end(), 1,
-                                 std::multiplies<int64_t>());
+  int64_t cols = llvm::product_of(vecShape.drop_front());
   auto tileType = amx::TileType::get({rows, cols}, vecTy.getElementType());
 
   Value zeroIndex = rewriter.createOrFold<arith::ConstantIndexOp>(loc, 0);
@@ -336,8 +336,7 @@ static TypedValue<amx::TileType> loadTile(PatternRewriter &rewriter,
 
   ArrayRef<int64_t> shape = vecTy.getShape();
   int64_t rows = shape[0];
-  int64_t cols = std::accumulate(shape.begin() + 1, shape.end(), 1,
-                                 std::multiplies<int64_t>());
+  int64_t cols = llvm::product_of(shape.drop_front());
   auto tileType = amx::TileType::get({rows, cols}, vecTy.getElementType());
 
   return amx::TileLoadOp::create(rewriter, loc, tileType, buf,

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

@@ -26,6 +26,7 @@
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "llvm/ADT/STLExtras.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTVECTORTOSCF
@@ -760,8 +761,7 @@ struct DecomposePrintOpConversion : public VectorToSCFPattern<vector::PrintOp> {
     if (vectorType.getRank() != 1) {
       // Flatten n-D vectors to 1D. This is done to allow indexing with a
       // non-constant value.
-      auto flatLength = std::accumulate(shape.begin(), shape.end(), 1,
-                                        std::multiplies<int64_t>());
+      int64_t flatLength = llvm::product_of(shape);
       auto flatVectorType =
           VectorType::get({flatLength}, vectorType.getElementType());
       value = vector::ShapeCastOp::create(rewriter, loc, flatVectorType, value);

mlir/lib/Conversion/XeGPUToXeVM/XeGPUToXeVM.cpp

@@ -23,6 +23,7 @@
 #include "mlir/Dialect/XeGPU/IR/XeGPU.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include "mlir/IR/BuiltinTypes.h"
@@ -774,9 +775,7 @@ struct ConvertXeGPUToXeVMPass
       if (rank < 1 || type.getNumElements() == 1)
         return elemType;
       // Otherwise, convert the vector to a flat vector type.
-      int64_t sum =
-          std::accumulate(type.getShape().begin(), type.getShape().end(),
-                          int64_t{1}, std::multiplies<int64_t>());
+      int64_t sum = llvm::product_of(type.getShape());
       return VectorType::get(sum, elemType);
     });
     typeConverter.addConversion([&](xegpu::TensorDescType type) -> Type {

mlir/lib/Dialect/Arith/Utils/Utils.cpp

@@ -351,9 +351,9 @@ Value createProduct(OpBuilder &builder, Location loc, ArrayRef<Value> values,
   Value one = ConstantOp::create(builder, loc, resultType,
                                  builder.getOneAttr(resultType));
   ArithBuilder arithBuilder(builder, loc);
-  return std::accumulate(
-      values.begin(), values.end(), one,
-      [&arithBuilder](Value acc, Value v) { return arithBuilder.mul(acc, v); });
+  return llvm::accumulate(values, one, [&arithBuilder](Value acc, Value v) {
+    return arithBuilder.mul(acc, v);
+  });
 }
 
 /// Map strings to float types.

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

@@ -2460,8 +2460,7 @@ static LogicalResult verifyDistributedType(Type expanded, Type distributed,
              << dDim << ")";
     scales[i] = eDim / dDim;
   }
-  if (std::accumulate(scales.begin(), scales.end(), 1,
-                      std::multiplies<int64_t>()) != warpSize)
+  if (llvm::product_of(scales) != warpSize)
     return op->emitOpError()
            << "incompatible distribution dimensions from " << expandedVecType
            << " to " << distributedVecType << " with warp size = " << warpSize;

mlir/lib/Dialect/GPU/Utils/DistributionUtils.cpp

@@ -15,6 +15,7 @@
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include <numeric>
 
@@ -118,8 +119,7 @@ bool WarpDistributionPattern::delinearizeLaneId(
       return false;
     sizes.push_back(large / small);
   }
-  if (std::accumulate(sizes.begin(), sizes.end(), 1,
-                      std::multiplies<int64_t>()) != warpSize)
+  if (llvm::product_of(sizes) != warpSize)
     return false;
 
   AffineExpr s0, s1;

mlir/lib/Dialect/Linalg/Transforms/ShardingInterfaceImpl.cpp

@@ -266,9 +266,8 @@ struct StructuredOpShardingInterface
     LinalgOp linalgOp = llvm::cast<LinalgOp>(op);
     SmallVector<utils::IteratorType> iteratorTypes =
         linalgOp.getIteratorTypesArray();
-    unsigned reductionItersCount = std::accumulate(
-        iteratorTypes.begin(), iteratorTypes.end(), 0,
-        [](unsigned count, utils::IteratorType iter) {
+    unsigned reductionItersCount = llvm::accumulate(
+        iteratorTypes, 0u, [](unsigned count, utils::IteratorType iter) {
           return count + (iter == utils::IteratorType::reduction);
         });
     shard::ReductionKind reductionKind = getReductionKindOfLinalgOp(linalgOp);

mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp

@@ -8,6 +8,7 @@
 
 #include "mlir/Dialect/Quant/Utils/UniformSupport.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "llvm/ADT/STLExtras.h"
 #include <numeric>
 
 using namespace mlir;
@@ -76,9 +77,7 @@ UniformQuantizedPerAxisValueConverter::convert(DenseFPElementsAttr attr) {
   // using the right quantization parameters.
   int64_t flattenIndex = 0;
   auto shape = type.getShape();
-  int64_t chunkSize =
-      std::accumulate(std::next(shape.begin(), quantizationDim + 1),
-                      shape.end(), 1, std::multiplies<int64_t>());
+  int64_t chunkSize = llvm::product_of(shape.drop_front(quantizationDim + 1));
   Type newElementType = IntegerType::get(attr.getContext(), storageBitWidth);
   return attr.mapValues(newElementType, [&](const APFloat &old) {
     int chunkIndex = (flattenIndex++) / chunkSize;

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

@@ -400,7 +400,7 @@ LogicalResult spirv::CompositeConstructOp::verify() {
       return emitOpError("operand element type mismatch: expected to be ")
              << resultType.getElementType() << ", but provided " << elementType;
   }
-  unsigned totalCount = std::accumulate(sizes.begin(), sizes.end(), 0);
+  unsigned totalCount = llvm::sum_of(sizes);
   if (totalCount != cType.getNumElements())
     return emitOpError("has incorrect number of operands: expected ")
            << cType.getNumElements() << ", but provided " << totalCount;

mlir/lib/Dialect/Shard/IR/ShardOps.cpp

@@ -1010,18 +1010,6 @@ static LogicalResult verifyInGroupDevice(Location loc, StringRef deviceName,
   return success();
 }
 
-template <typename It>
-static auto product(It begin, It end) {
-  using ElementType = std::decay_t<decltype(*begin)>;
-  return std::accumulate(begin, end, static_cast<ElementType>(1),
-                         std::multiplies<ElementType>());
-}
-
-template <typename R>
-static auto product(R &&range) {
-  return product(adl_begin(range), adl_end(range));
-}
-
 static LogicalResult verifyDimensionCompatibility(Location loc,
                                                   int64_t expectedDimSize,
                                                   int64_t resultDimSize,

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

@@ -2368,9 +2368,10 @@ llvm::LogicalResult tosa::ReshapeOp::verify() {
       }
     }
 
-    int64_t newShapeElementsNum = std::accumulate(
-        shapeValues.begin(), shapeValues.end(), 1LL,
-        [](int64_t acc, int64_t dim) { return (dim > 0) ? acc * dim : acc; });
+    int64_t newShapeElementsNum =
+        llvm::accumulate(shapeValues, int64_t(1), [](int64_t acc, int64_t dim) {
+          return (dim > 0) ? acc * dim : acc;
+        });
     bool isStaticNewShape =
         llvm::all_of(shapeValues, [](int64_t s) { return s > 0; });
     if ((isStaticNewShape && inputElementsNum != newShapeElementsNum) ||

mlir/lib/Dialect/Tosa/Transforms/TosaFolders.cpp

@@ -20,6 +20,7 @@
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/Matchers.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace mlir;
@@ -375,8 +376,7 @@ llvm::APInt calculateReducedValue(const mlir::ElementsAttr &oldTensorAttr,
   for (int64_t reductionAxisVal = 1; reductionAxisVal < oldShape[reductionAxis];
        ++reductionAxisVal) {
 
-    int64_t stride = std::accumulate(oldShape.begin() + reductionAxis + 1,
-                                     oldShape.end(), 1, std::multiplies<int>());
+    int64_t stride = llvm::product_of(oldShape.drop_front(reductionAxis + 1));
     int64_t index = indexAtOldTensor + stride * reductionAxisVal;
     reducedValue =
         OperationType::calcOneElement(reducedValue, oldTensor[index]);
@@ -424,8 +424,7 @@ struct ReduceConstantOptimization : public OpRewritePattern<OperationType> {
     auto oldShape = shapedOldElementsValues.getShape();
     auto newShape = resultType.getShape();
 
-    auto newNumOfElements = std::accumulate(newShape.begin(), newShape.end(), 1,
-                                            std::multiplies<int>());
+    int64_t newNumOfElements = llvm::product_of(newShape);
     llvm::SmallVector<APInt> newReducedTensor(newNumOfElements);
 
     for (int64_t reductionIndex = 0; reductionIndex < newNumOfElements;

mlir/lib/Dialect/Utils/IndexingUtils.cpp

@@ -81,21 +81,10 @@ SmallVector<int64_t> mlir::computeElementwiseMul(ArrayRef<int64_t> v1,
   return computeElementwiseMulImpl(v1, v2);
 }
 
-int64_t mlir::computeSum(ArrayRef<int64_t> basis) {
-  assert(llvm::all_of(basis, [](int64_t s) { return s > 0; }) &&
-         "basis must be nonnegative");
-  if (basis.empty())
-    return 0;
-  return std::accumulate(basis.begin(), basis.end(), 1, std::plus<int64_t>());
-}
-
 int64_t mlir::computeProduct(ArrayRef<int64_t> basis) {
   assert(llvm::all_of(basis, [](int64_t s) { return s > 0; }) &&
          "basis must be nonnegative");
-  if (basis.empty())
-    return 1;
-  return std::accumulate(basis.begin(), basis.end(), 1,
-                         std::multiplies<int64_t>());
+  return llvm::product_of(basis);
 }
 
 int64_t mlir::linearize(ArrayRef<int64_t> offsets, ArrayRef<int64_t> basis) {
@@ -158,19 +147,11 @@ SmallVector<AffineExpr> mlir::computeElementwiseMul(ArrayRef<AffineExpr> v1,
 }
 
 AffineExpr mlir::computeSum(MLIRContext *ctx, ArrayRef<AffineExpr> basis) {
-  if (basis.empty())
-    return getAffineConstantExpr(0, ctx);
-  return std::accumulate(basis.begin(), basis.end(),
-                         getAffineConstantExpr(0, ctx),
-                         std::plus<AffineExpr>());
+  return llvm::sum_of(basis, getAffineConstantExpr(0, ctx));
 }
 
 AffineExpr mlir::computeProduct(MLIRContext *ctx, ArrayRef<AffineExpr> basis) {
-  if (basis.empty())
-    return getAffineConstantExpr(1, ctx);
-  return std::accumulate(basis.begin(), basis.end(),
-                         getAffineConstantExpr(1, ctx),
-                         std::multiplies<AffineExpr>());
+  return llvm::product_of(basis, getAffineConstantExpr(1, ctx));
 }
 
 AffineExpr mlir::linearize(MLIRContext *ctx, ArrayRef<AffineExpr> offsets,

mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp

@@ -374,11 +374,11 @@ mlir::composeReassociationIndices(
   if (consumerReassociations.empty())
     return composedIndices;
 
-  size_t consumerDims = std::accumulate(
-      consumerReassociations.begin(), consumerReassociations.end(), 0,
-      [](size_t all, ReassociationIndicesRef indices) {
-        return all + indices.size();
-      });
+  size_t consumerDims =
+      llvm::accumulate(consumerReassociations, size_t(0),
+                       [](size_t all, ReassociationIndicesRef indices) {
+                         return all + indices.size();
+                       });
   if (producerReassociations.size() != consumerDims)
     return std::nullopt;
 

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

@@ -2496,8 +2496,7 @@ struct ToElementsOfBroadcast final : OpRewritePattern<ToElementsOp> {
     auto srcElems = vector::ToElementsOp::create(
         rewriter, toElementsOp.getLoc(), bcastOp.getSource());
 
-    int64_t dstCount = std::accumulate(dstShape.begin(), dstShape.end(), 1,
-                                       std::multiplies<int64_t>());
+    int64_t dstCount = llvm::product_of(dstShape);
 
     SmallVector<Value> replacements;
     replacements.reserve(dstCount);

mlir/lib/Dialect/Vector/Transforms/LowerVectorShapeCast.cpp

@@ -21,6 +21,7 @@
 #include "mlir/IR/Location.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
+#include "llvm/ADT/STLExtras.h"
 #include <numeric>
 
 #define DEBUG_TYPE "vector-shape-cast-lowering"
@@ -166,10 +167,7 @@ class ShapeCastOpRewritePattern : public OpRewritePattern<vector::ShapeCastOp> {
     const VectorType resultType = shapeCast.getResultVectorType();
     const ArrayRef<int64_t> resultShape = resultType.getShape();
 
-    const int64_t nSlices =
-        std::accumulate(sourceShape.begin(), sourceShape.begin() + sourceDim, 1,
-                        std::multiplies<int64_t>());
-
+    const int64_t nSlices = llvm::product_of(sourceShape.take_front(sourceDim));
     SmallVector<int64_t> extractIndex(sourceDim, 0);
     SmallVector<int64_t> insertIndex(resultDim, 0);
     Value result = ub::PoisonOp::create(rewriter, loc, resultType);