[mlir][sparse] cleanup small vector constant hints

[aartbik]

Summary

Following advise from

https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h

This revision removes the size hints from SmallVector (unless we are
certain of the resulting number of elements). Also, this replaces
SmallVector references with SmallVectorImpl references.

[Peiming]

Much cleaner!

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

673–674

I think there is a implicit constructor for TypeRange(Type)

So probably builder.create<scf::IfOp>(loc, codegen.insChain.getType(), rhs, /*else=*/true); works without the need of the small vector.

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

153

Can't it simply be latSets.emplace_back(); to avoid calling the move constructor here?

[aartbik]

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

673–674

Right you are!

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

153

I think you are right, good catch!

[aartbik]

addressed comments

[wrengr]

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.h

98

I remember mentioning this before and Peiming had a good response (though I don't recall what it was), but: Why not use MutableArrayRef?

180

ditto

mlir/lib/Dialect/SparseTensor/Transforms/SparseBufferRewriting.cpp

493–495

Do these two ever get resized? I didn't see any appending anywhere, though I might've missed it

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

546–547

If there's only this one value, then why not use SV inits{genLoad(...)};? Or even better, assuming createFor takes an ArrayRef then why not just Value theInit = genLoad(...); and pass {theInit} to createFor?

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

95

ditto my earlier comment about using MutableArrayRef

103

ditto

116

ditto

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

116

ditto

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

529

ditto

[Peiming]

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.h

98

I think here is inapplicable, because it calls push_back, MutableArrayRef need a fixed size

mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h

public:
   void setHasSparseOut(bool s) { hasSparseOut = s; }
 
   /// Convenience getters to immediately access the stored nodes.
   /// Typically it is inadvisible to keep the reference around, as in
   /// "TensorExpr &te = merger.exp(e))", since insertions into the merger
   /// may cause data movement and invalidate the underlying memory address.
   TensorExp &exp(unsigned e) { return tensorExps[e]; }
   LatPoint &lat(unsigned l) { return latPoints[l]; }
-  SmallVector<unsigned, 16> &set(unsigned s) { return latSets[s]; }
+  SmallVector<unsigned> &set(unsigned s) { return latSets[s]; }
 
 #ifndef NDEBUG
   /// Print methods (for debugging).
   void dumpExp(unsigned e) const;
   void dumpLat(unsigned p) const;
   void dumpSet(unsigned s) const;
   void dumpBits(const BitVector &bits) const;
 #endif
private:
   const unsigned numTensors;
   const unsigned numLoops;
   bool hasSparseOut;
   // Map that converts pair<tensor id, loop id> to the corresponding dimension
   // level type.
   std::vector<std::vector<DimLevelType>> dimTypes;
   // Map that converts pair<tensor id, loop id> to the corresponding dimension.
   std::vector<std::vector<Optional<unsigned>>> loopIdxToDim;
-  llvm::SmallVector<TensorExp, 32> tensorExps;
-  llvm::SmallVector<LatPoint, 16> latPoints;
-  llvm::SmallVector<SmallVector<unsigned, 16>, 8> latSets;
+  llvm::SmallVector<TensorExp> tensorExps;
+  llvm::SmallVector<LatPoint> latPoints;
+  llvm::SmallVector<SmallVector<unsigned>> latSets;
 };
 
 } // namespace sparse_tensor
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPARSETENSOR_UTILS_MERGER_H_

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

if (failed(parser.parseLess()))
     return {};
   // Parse the data as a dictionary.
   DictionaryAttr dict;
   if (failed(parser.parseAttribute(dict)))
     return {};
   if (failed(parser.parseGreater()))
     return {};
   // Process the data from the parsed dictionary value into struct-like data.
-  SmallVector<DimLevelType, 4> dlt;
+  SmallVector<DimLevelType> dlt;
   AffineMap dimOrd = {};
   AffineMap higherOrd = {};
   unsigned ptr = 0;
   unsigned ind = 0;
   for (const NamedAttribute &attr : dict) {
     if (attr.getName() == "dimLevelType") {
       auto arrayAttr = attr.getValue().dyn_cast<ArrayAttr>();
       if (!arrayAttr) {
function_ref<void(OpBuilder &, Location, ValueRange, Value, ValueRange)>
         bodyBuilder) {
   build(builder, result, initArgs.getTypes(), tensor, initArgs);
   // Builds foreach body.
   if (!bodyBuilder)
     return;
   auto rtp = tensor.getType().cast<RankedTensorType>();
   int64_t rank = rtp.getRank();
 
-  SmallVector<Type, 4> blockArgTypes;
+  SmallVector<Type> blockArgTypes;
   // Starts with n index.
   std::fill_n(std::back_inserter(blockArgTypes), rank, builder.getIndexType());
   // Followed by one value.
   blockArgTypes.push_back(rtp.getElementType());
   // Followed by reduction variable.
   blockArgTypes.append(initArgs.getTypes().begin(), initArgs.getTypes().end());
 
-  SmallVector<Location, 4> blockArgLocs;
+  SmallVector<Location> blockArgLocs;
   std::fill_n(std::back_inserter(blockArgLocs), blockArgTypes.size(),
               tensor.getLoc());
 
   OpBuilder::InsertionGuard guard(builder);
   auto &region = *result.regions.front();
   Block *bodyBlock =
       builder.createBlock(&region, region.end(), blockArgTypes, blockArgLocs);
   bodyBuilder(builder, result.location,

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.h

 /// For floating types, we use the "unordered" comparator (i.e., returns
 /// true if `v` is NaN).
 Value genIsNonzero(OpBuilder &builder, Location loc, Value v);
 
 /// Computes the shape of destination tensor of a reshape operator. This is only
 /// used when operands have dynamic shape. The shape of the destination is
 /// stored into dstShape.
 void genReshapeDstShape(Location loc, PatternRewriter &rewriter,
-                        SmallVector<Value, 4> &dstShape,
+                        SmallVectorImpl<Value> &dstShape,
                         ArrayRef<Value> srcShape,
                         ArrayRef<int64_t> staticDstShape,
                         ArrayRef<ReassociationIndices> reassociation);
 
 /// Translate indices during a reshaping operation.
 void translateIndicesArray(OpBuilder &builder, Location loc,
                            ArrayRef<ReassociationIndices> reassociation,
                            ValueRange srcIndices, ArrayRef<Value> srcShape,

 //     val = values[i]
 //     [i1,..,ik] = indices[i]
 //     loop-body
 void genDenseTensorOrSparseConstantIterLoop(
     OpBuilder &builder, Location loc, Value src, unsigned rank,
     function_ref<void(OpBuilder &, Location, Value, ValueRange)> bodyBuilder);
 
 /// Populates given sizes array from dense tensor or sparse tensor constant.
-void sizesFromSrc(OpBuilder &builder, SmallVector<Value, 4> &sizes,
+void sizesFromSrc(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                   Location loc, Value src);
 
 /// Scans to top of generated loop.
 Operation *getTop(Operation *op);
 
 //===----------------------------------------------------------------------===//
 // Inlined constant generators.
 //

 
 private:
   struct LoopLevelInfo {
     LoopLevelInfo(ArrayRef<size_t> tids, ArrayRef<size_t> dims, Operation *loop,
                   Value iv)
         : tids(tids), dims(dims), loop(loop), iv(iv) {}
     // TODO: maybe use a vector<pair> for tid and dim?
     // The set of tensors that the loop is operating on
-    const llvm::SmallVector<size_t, 4> tids;
+    const llvm::SmallVector<size_t> tids;
     // The corresponding dims for the tensors
-    const llvm::SmallVector<size_t, 4> dims;
+    const llvm::SmallVector<size_t> dims;
     const Operation *loop; // the loop operation
     const Value iv;        // the induction variable for the loop
   };
 
   /// Linearizes address for dense dimension (i.e., p = (i * d0) + j).
   Value genAddress(OpBuilder &builder, Location loc, size_t tid, size_t dim,
                    Value iv) {
     Value p = dim == 0 ? constantIndex(builder, loc, 0) : pidxs[tid][dim - 1];

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.cpp

Operation *SparseTensorLoopEmitter::enterLoopOverTensorAtDim(
   return loop;
 }
 
 Operation *SparseTensorLoopEmitter::enterCoIterationOverTensorsAtDims(
     OpBuilder &builder, Location loc, ArrayRef<size_t> tids,
     ArrayRef<size_t> dims, bool needsUniv, MutableArrayRef<Value> reduc,
     ArrayRef<size_t> extraTids, ArrayRef<size_t> extraDims) {
   assert(tids.size() == dims.size());
-  SmallVector<Type, 4> types;
-  SmallVector<Value, 4> operands;
+  SmallVector<Type> types;
+  SmallVector<Value> operands;
   // Construct the while-loop with a parameter for each index.
   Type indexType = builder.getIndexType();
   for (auto [tid, dim] : llvm::zip(tids, dims)) {
     if (isCompressedDLT(dimTypes[tid][dim]) ||
         isSingletonDLT(dimTypes[tid][dim])) {
       assert(pidxs[tid][dim]);
       types.push_back(indexType);
       operands.push_back(pidxs[tid][dim]);
void SparseTensorLoopEmitter::exitCoIterationLoop(
   // Generation while loop induction at the end.
   builder.setInsertionPointToEnd(&whileOp.getAfter().front());
   // Finalize the induction. Note that the induction could be performed
   // in the individual if-branches to avoid re-evaluating the conditions.
   // However, that would result in a rather elaborate forest of yield
   // instructions during code generation. Moreover, performing the induction
   // after the if-statements more closely resembles code generated by TACO.
   unsigned o = 0;
-  SmallVector<Value, 4> operands;
+  SmallVector<Value> operands;
   Value one = constantIndex(builder, loc, 1);
   for (auto [tid, dim] : llvm::zip(tids, dims)) {
     if (isCompressedDLT(dimTypes[tid][dim]) ||
         isSingletonDLT(dimTypes[tid][dim])) {
       Value op1 = coord[tid][dim];
       Value op3 = pidxs[tid][dim];
       Value cmp =
           builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::eq, op1, iv);

 
 void SparseTensorLoopEmitter::exitCurrentLoop(RewriterBase &rewriter,
                                               Location loc,
                                               MutableArrayRef<Value> reduc) {
   // Clean up the values, it would help use to discover potential bug at a
   // earlier stage (instead of silently using a wrong value).
   LoopLevelInfo &loopInfo = loopStack.back();
   assert(loopInfo.tids.size() == loopInfo.dims.size());
-  SmallVector<Value, 2> red;
+  SmallVector<Value> red;
   if (llvm::isa<scf::WhileOp>(loopInfo.loop)) {
     exitCoIterationLoop(rewriter, loc, reduc);
   } else {
     exitForLoop(rewriter, loc, reduc);
   }
 
   assert(loopStack.size() == loopSeqStack.size());
   loopStack.pop_back();
if (tp.isIntOrIndex())
     return builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ne, v,
                                          zero);
   if (tp.dyn_cast<ComplexType>())
     return builder.create<complex::NotEqualOp>(loc, v, zero);
   llvm_unreachable("Non-numeric type");
 }
 
 void mlir::sparse_tensor::genReshapeDstShape(
-    Location loc, PatternRewriter &rewriter, SmallVector<Value, 4> &dstShape,
+    Location loc, PatternRewriter &rewriter, SmallVectorImpl<Value> &dstShape,
     ArrayRef<Value> srcShape, ArrayRef<int64_t> staticDstShape,
     ArrayRef<ReassociationIndices> reassociation) {
   // Collapse shape.
   if (reassociation.size() < srcShape.size()) {
     unsigned start = 0;
     for (const auto &map : llvm::enumerate(reassociation)) {
       auto dstDim = constantIndex(rewriter, loc, 1);
       for (unsigned i = start; i < start + map.value().size(); i++) {

 }
 
 // FIXME:
 // 1. Dense tensors loop should be generated by loop emitter.
 // 2. Support reduction variables to propagate SSA chains properly.
 void mlir::sparse_tensor::genDenseTensorOrSparseConstantIterLoop(
     OpBuilder &builder, Location loc, Value src, unsigned rank,
     function_ref<void(OpBuilder &, Location, Value, ValueRange)> bodyBuilder) {
-  SmallVector<Value, 4> indicesArray;
+  SmallVector<Value> indicesArray;
   SmallVector<Value> lo;
   SmallVector<Value> hi;
   SmallVector<Value> st;
   Value zero = constantIndex(builder, loc, 0);
   Value one = constantIndex(builder, loc, 1);
   auto indicesValues = genSplitSparseConstant(builder, loc, src);
   bool isCOOConstant = indicesValues.has_value();
   Value indices;
scf::buildLoopNest(
         else
           val = genIndexAndValueForDense(builder, loc, src, indicesArray, ivs);
         bodyBuilder(builder, loc, val, indicesArray);
         return {};
       });
 }
 
 void mlir::sparse_tensor::sizesFromSrc(OpBuilder &builder,
-                                       SmallVector<Value, 4> &sizes,
+                                       SmallVectorImpl<Value> &sizes,
                                        Location loc, Value src) {
   unsigned rank = src.getType().cast<ShapedType>().getRank();
   for (unsigned i = 0; i < rank; i++)
     sizes.push_back(linalg::createOrFoldDimOp(builder, loc, src, i));
 }
 
 Operation *mlir::sparse_tensor::getTop(Operation *op) {
   for (; isa<scf::ForOp>(op->getParentOp()) ||
          isa<scf::WhileOp>(op->getParentOp()) ||
          isa<scf::ParallelOp>(op->getParentOp()) ||
          isa<scf::IfOp>(op->getParentOp());
        op = op->getParentOp())
     ;
   return op;
 }

mlir/lib/Dialect/SparseTensor/Transforms/SparseBufferRewriting.cpp

static void createBinarySearchFunc(OpBuilder &builder, ModuleOp module,
                                    bool isCoo) {
   OpBuilder::InsertionGuard insertionGuard(builder);
   Block *entryBlock = func.addEntryBlock();
   builder.setInsertionPointToStart(entryBlock);
 
   Location loc = func.getLoc();
   ValueRange args = entryBlock->getArguments();
   Value p = args[hiIdx];
-  SmallVector<Type, 2> types(2, p.getType());
+  SmallVector<Type, 2> types(2, p.getType());  // only two
   scf::WhileOp whileOp = builder.create<scf::WhileOp>(
       loc, types, SmallVector<Value, 2>{args[loIdx], args[hiIdx]});
 
   // The before-region of the WhileOp.
   Block *before =
       builder.createBlock(&whileOp.getBefore(), {}, types, {loc, loc});
   builder.setInsertionPointToEnd(before);
   Value cond1 = builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ult,
static void createBinarySearchFunc(OpBuilder &builder, ModuleOp module,
   Value hi = after->getArgument(1);
   // Compute mid = (lo + hi) >> 1.
   Value c1 = constantIndex(builder, loc, 1);
   Value mid = builder.create<arith::ShRUIOp>(
       loc, builder.create<arith::AddIOp>(loc, lo, hi), c1);
   Value midp1 = builder.create<arith::AddIOp>(loc, mid, c1);
 
   // Compare xs[p] < xs[mid].
-  SmallVector<Value, 6> compareOperands{p, mid};
+  SmallVector<Value> compareOperands{p, mid};
   uint64_t numXBuffers = isCoo ? 1 : nx;
   compareOperands.append(args.begin() + xStartIdx,
                          args.begin() + xStartIdx + numXBuffers);
   Type i1Type = IntegerType::get(module.getContext(), 1, IntegerType::Signless);
   FlatSymbolRefAttr lessThanFunc = getMangledSortHelperFunc(
       builder, func, {i1Type}, kLessThanFuncNamePrefix, nx, ny, isCoo,
       compareOperands, createLessThanFunc);
   Value cond2 = builder
createScanLoop(OpBuilder &builder, ModuleOp module, func::FuncOp func,
                bool isCoo, int step) {
   Location loc = func.getLoc();
   scf::WhileOp whileOp =
       builder.create<scf::WhileOp>(loc, TypeRange{i.getType()}, ValueRange{i});
 
   Block *before =
       builder.createBlock(&whileOp.getBefore(), {}, {i.getType()}, {loc});
   builder.setInsertionPointToEnd(before);
-  SmallVector<Value, 6> compareOperands;
+  SmallVector<Value> compareOperands;
   if (step > 0) {
     compareOperands.push_back(before->getArgument(0));
     compareOperands.push_back(p);
   } else {
     assert(step < 0);
     compareOperands.push_back(p);
     compareOperands.push_back(before->getArgument(0));
   }
static void createPartitionFunc(OpBuilder &builder, ModuleOp module,
   Value lo = args[loIdx];
   Value hi = args[hiIdx];
   Value sum = builder.create<arith::AddIOp>(loc, lo, hi);
   Value c1 = constantIndex(builder, loc, 1);
   Value p = builder.create<arith::ShRUIOp>(loc, sum, c1);
 
   Value i = lo;
   Value j = builder.create<arith::SubIOp>(loc, hi, c1);
-  SmallVector<Value, 4> operands{i, j, p};
-  SmallVector<Type, 4> types{i.getType(), j.getType(), p.getType()};
+  SmallVector<Value> operands{i, j, p};
+  SmallVector<Type> types{i.getType(), j.getType(), p.getType()};
   scf::WhileOp whileOp = builder.create<scf::WhileOp>(loc, types, operands);
 
   // The before-region of the WhileOp.
   Block *before =
       builder.createBlock(&whileOp.getBefore(), {}, types, {loc, loc, loc});
   builder.setInsertionPointToEnd(before);
   Value cond = builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ult,
                                              before->getArgument(0),
                                              before->getArgument(1));
auto [jresult, jCompareEq] =
       createScanLoop(builder, module, func, args.slice(xStartIdx, numXBuffers),
                      j, p, nx, ny, isCoo, -1);
   j = jresult;
 
   // If i < j:
   cond = builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ult, i, j);
   scf::IfOp ifOp = builder.create<scf::IfOp>(loc, types, cond, /*else=*/true);
   builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
-  SmallVector<Value, 6> swapOperands{i, j};
+  SmallVector<Value> swapOperands{i, j};
   swapOperands.append(args.begin() + xStartIdx, args.end());
   createSwap(builder, loc, swapOperands, nx, ny, isCoo);
   // If the pivot is moved, update p with the new pivot.
   Value icond =
       builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::eq, i, p);
   scf::IfOp ifOpI = builder.create<scf::IfOp>(loc, TypeRange{p.getType()},
                                               icond, /*else=*/true);
   builder.setInsertionPointToStart(&ifOpI.getThenRegion().front());
static void createSortNonstableFunc(OpBuilder &builder, ModuleOp module,
   // The if-stmt true branch.
   builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
   FlatSymbolRefAttr partitionFunc = getMangledSortHelperFunc(
       builder, func, {IndexType::get(context)}, kPartitionFuncNamePrefix, nx,
       ny, isCoo, args, createPartitionFunc);
   auto p = builder.create<func::CallOp>(
       loc, partitionFunc, TypeRange{IndexType::get(context)}, ValueRange(args));
 
-  SmallVector<Value, 6> lowOperands{lo, p.getResult(0)};
+  SmallVector<Value> lowOperands{lo, p.getResult(0)};
   lowOperands.append(args.begin() + xStartIdx, args.end());
   builder.create<func::CallOp>(loc, func, lowOperands);
 
-  SmallVector<Value, 6> highOperands{
+  SmallVector<Value> highOperands{
       builder.create<arith::AddIOp>(loc, p.getResult(0),
                                     constantIndex(builder, loc, 1)),
       hi};
   highOperands.append(args.begin() + xStartIdx, args.end());
   builder.create<func::CallOp>(loc, func, highOperands);
 
   // After the if-stmt.
   builder.setInsertionPointAfter(ifOp);
static void createSortStableFunc(OpBuilder &builder, ModuleOp module,
   Value lop1 = builder.create<arith::AddIOp>(loc, lo, c1);
 
   // Start the outer for-stmt with induction variable i.
   scf::ForOp forOpI = builder.create<scf::ForOp>(loc, lop1, hi, c1);
   builder.setInsertionPointToStart(forOpI.getBody());
   Value i = forOpI.getInductionVar();
 
   // Binary search to find the insertion point p.
-  SmallVector<Value, 6> operands{lo, i};
+  SmallVector<Value> operands{lo, i};
   operands.append(args.begin() + xStartIdx, args.end());
   FlatSymbolRefAttr searchFunc = getMangledSortHelperFunc(
       builder, func, {IndexType::get(context)}, kBinarySearchFuncNamePrefix, nx,
       ny, isCoo, operands, createBinarySearchFunc);
   Value p = builder
                 .create<func::CallOp>(loc, searchFunc, TypeRange{c1.getType()},
                                       operands)
                 .getResult(0);
 
   // Move the value at data[i] to a temporary location.
   operands[0] = operands[1] = i;
-  SmallVector<Value, 6> d;
+  SmallVector<Value> d;
   forEachIJPairInAllBuffers(
       builder, loc, operands, nx, ny, isCoo,
       [&](uint64_t unused, Value i, Value unused2, Value buffer) {
         d.push_back(builder.create<memref::LoadOp>(loc, buffer, i));
       });
 
   // Start the inner for-stmt with induction variable j, for moving data[p..i)
   // to data[p+1..i+1).

 }
 
 /// Implements the rewriting for operator sort and sort_coo.
 template <typename OpTy>
 LogicalResult matchAndRewriteSortOp(OpTy op, ValueRange xys, uint64_t nx,
                                     uint64_t ny, bool isCoo,
                                     PatternRewriter &rewriter) {
   Location loc = op.getLoc();
-  SmallVector<Value, 6> operands{constantIndex(rewriter, loc, 0), op.getN()};
+  SmallVector<Value> operands{constantIndex(rewriter, loc, 0), op.getN()};
 
   // Convert `values` to have dynamic shape and append them to `operands`.
   for (Value v : xys) {
     auto mtp = v.getType().cast<MemRefType>();
     if (!mtp.isDynamicDim(0)) {
       auto newMtp =
           MemRefType::get({ShapedType::kDynamicSize}, mtp.getElementType());
       v = rewriter.create<memref::CastOp>(loc, newMtp, v);

 
 /// Sparse rewriting rule for the sort operator.
 struct SortRewriter : public OpRewritePattern<SortOp> {
 public:
   using OpRewritePattern<SortOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(SortOp op,
                                 PatternRewriter &rewriter) const override {
-    SmallVector<Value, 6> xys(op.getXs());
+    SmallVector<Value> xys(op.getXs());
     xys.append(op.getYs().begin(), op.getYs().end());
     return matchAndRewriteSortOp(op, xys, op.getXs().size(), /*ny=*/0,
                                  /*isCoo=*/false, rewriter);
   }
 };
 
 /// Sparse rewriting rule for the sort_coo operator.
 struct SortCooRewriter : public OpRewritePattern<SortCooOp> {
 public:
   using OpRewritePattern<SortCooOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(SortCooOp op,
                                 PatternRewriter &rewriter) const override {
-    SmallVector<Value, 6> xys;
+    SmallVector<Value> xys;
     xys.push_back(op.getXy());
     xys.append(op.getYs().begin(), op.getYs().end());
     uint64_t nx = 1;
     if (auto nxAttr = op.getNxAttr())
       nx = nxAttr.getInt();
 
     uint64_t ny = 0;
     if (auto nyAttr = op.getNyAttr())

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

static void createAllocFields(OpBuilder &builder, Location loc, Type type,
   Type indexType = builder.getIndexType();
   Type idxType = idxWidth ? builder.getIntegerType(idxWidth) : indexType;
   Type ptrType = ptrWidth ? builder.getIntegerType(ptrWidth) : indexType;
   Type eltType = rtp.getElementType();
   auto shape = rtp.getShape();
   unsigned rank = shape.size();
   Value heuristic = constantIndex(builder, loc, 16);
   // Build original sizes.
-  SmallVector<Value, 8> sizes;
+  SmallVector<Value> sizes;
   for (unsigned r = 0, o = 0; r < rank; r++) {
     if (ShapedType::isDynamic(shape[r]))
       sizes.push_back(dynSizes[o++]);
     else
       sizes.push_back(constantIndex(builder, loc, shape[r]));
   }
   // The dimSizes array and memSizes array.
   unsigned lastField = getFieldIndex(type, -1u, -1u);

 ///    <prepare dimension d + 1>
 ///  }
 ///  pos[d] = next
 static Value genCompressed(OpBuilder &builder, Location loc,
                            RankedTensorType rtp, SmallVectorImpl<Value> &fields,
                            SmallVectorImpl<Value> &indices, Value value,
                            Value pos, unsigned field, unsigned d) {
   unsigned rank = rtp.getShape().size();
-  SmallVector<Type, 4> types;
+  SmallVector<Type> types;
   Type indexType = builder.getIndexType();
   Type boolType = builder.getIntegerType(1);
   Value one = constantIndex(builder, loc, 1);
   Value pp1 = builder.create<arith::AddIOp>(loc, pos, one);
   Value plo = genLoad(builder, loc, fields[field], pos);
   Value phi = genLoad(builder, loc, fields[field], pp1);
   Value psz = constantIndex(builder, loc, getMemSizesIndex(field + 1));
   Value msz = genLoad(builder, loc, fields[memSizesIdx], psz);
if (isCompressedDim(rtp, d)) {
       if (d > 0) {
         unsigned ptrWidth = getSparseTensorEncoding(rtp).getPointerBitWidth();
         Type indexType = builder.getIndexType();
         Type ptrType = ptrWidth ? builder.getIntegerType(ptrWidth) : indexType;
         Value mz = constantIndex(builder, loc, getMemSizesIndex(field));
         Value hi = genLoad(builder, loc, fields[memSizesIdx], mz);
         Value zero = constantIndex(builder, loc, 0);
         Value one = constantIndex(builder, loc, 1);
-        SmallVector<Value, 1> inits;
+        SmallVector<Value, 1> inits;  // only one
         inits.push_back(genLoad(builder, loc, fields[field], zero));
         scf::ForOp loop = createFor(builder, loc, hi, inits, one);
         Value i = loop.getInductionVar();
         Value oldv = loop.getRegionIterArg(0);
         Value newv = genLoad(builder, loc, fields[field], i);
         Value ptrZero = constantZero(builder, loc, ptrType);
         Value cond = builder.create<arith::CmpIOp>(
             loc, arith::CmpIPredicate::eq, newv, ptrZero);
         scf::IfOp ifOp = builder.create<scf::IfOp>(loc, TypeRange(ptrType),

 
 /// Sparse tensor storage conversion rule for returns.
 class SparseReturnConverter : public OpConversionPattern<func::ReturnOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(func::ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    SmallVector<Value, 8> flattened;
+    SmallVector<Value> flattened;
     flattenOperands(adaptor.getOperands(), flattened);
     // Create a return with the flattened value extracted from sparse tensors.
     rewriter.replaceOpWithNewOp<func::ReturnOp>(op, flattened);
     return success();
   }
 };
 
 /// Sparse tensor storage conversion rule for calls.
 class SparseCallConverter : public OpConversionPattern<func::CallOp> {
 public:
   // The default CallOp converter can not handle 1:N type conversion.
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(func::CallOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     // In case of:
     //  sparse_tensor, f, sparse_tensor = call @foo(...)
     // ==>
     //  memref..., f, memref = call @foo(...) replace with
     //  cast(memref...)->sparse_tensor, f, cast(memref...)->sparse_tensor
-    SmallVector<Type, 8> finalRetTy;
+    SmallVector<Type> finalRetTy;
     if (failed(typeConverter->convertTypes(op.getResultTypes(), finalRetTy)))
       return failure();
 
     // (1) Genereates new call with flattened return value.
-    SmallVector<Value, 8> flattened;
+    SmallVector<Value> flattened;
     flattenOperands(adaptor.getOperands(), flattened);
     auto newCall = rewriter.create<func::CallOp>(loc, op.getCallee(),
                                                  finalRetTy, flattened);
     // (2) Create cast operation for sparse tensor returns.
-    SmallVector<Value, 4> castedRet;
+    SmallVector<Value> castedRet;
     // Tracks the offset of current return value (of the orignal call)
     // relative to the new call (after sparse tensor flattening);
     unsigned retOffset = 0;
     // Temporal buffer to hold the flattened list of type for
     // a sparse tensor.
-    SmallVector<Type, 8> sparseFlat;
+    SmallVector<Type> sparseFlat;
     for (auto ret : op.getResults()) {
       assert(retOffset < newCall.getNumResults());
       auto retType = ret.getType();
       if (failed(typeConverter->convertType(retType, sparseFlat)))
         // This should never happen.
         llvm_unreachable("Failed to convert type in sparse tensor codegen");
 
       // Converted types can not be empty when the type conversion succeed.
matchAndRewrite(bufferization::AllocTensorOp op, OpAdaptor adaptor,
     auto enc = getSparseTensorEncoding(resType);
     if (!enc)
       return failure();
     if (op.getCopy())
       return rewriter.notifyMatchFailure(op, "tensor copy not implemented");
 
     // Construct allocation for each field.
     Location loc = op.getLoc();
-    SmallVector<Value, 8> fields;
+    SmallVector<Value> fields;
     createAllocFields(rewriter, loc, resType, adaptor.getOperands(),
                       enableBufferInitialization, fields);
     // Replace operation with resulting memrefs.
     rewriter.replaceOp(op, genTuple(rewriter, loc, resType, fields));
     return success();
   }
 
 private:
public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(LoadOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     RankedTensorType srcType =
         op.getTensor().getType().cast<RankedTensorType>();
     auto tuple = getTuple(adaptor.getTensor());
     // Prepare fields.
-    SmallVector<Value, 8> fields(tuple.getInputs());
+    SmallVector<Value> fields(tuple.getInputs());
     // Generate optional insertion finalization code.
     if (op.getHasInserts())
       genEndInsert(rewriter, op.getLoc(), srcType, fields);
     // Replace operation with resulting memrefs.
     rewriter.replaceOp(op, genTuple(rewriter, op.getLoc(), srcType, fields));
     return success();
   }
 };
RankedTensorType dstType =
         op.getTensor().getType().cast<RankedTensorType>();
     Type eltType = dstType.getElementType();
     auto tuple = getTuple(adaptor.getTensor());
     Value values = adaptor.getValues();
     Value filled = adaptor.getFilled();
     Value added = adaptor.getAdded();
     Value count = adaptor.getCount();
     // Prepare fields and indices.
-    SmallVector<Value, 8> fields(tuple.getInputs());
-    SmallVector<Value, 8> indices(adaptor.getIndices());
+    SmallVector<Value> fields(tuple.getInputs());
+    SmallVector<Value> indices(adaptor.getIndices());
     // If the innermost dimension is ordered, we need to sort the indices
     // in the "added" array prior to applying the compression.
     unsigned rank = dstType.getShape().size();
     if (isOrderedDim(dstType, rank - 1))
       rewriter.create<SortOp>(loc, count, ValueRange{added}, ValueRange{});
     // While performing the insertions, we also need to reset the elements
     // of the values/filled-switch by only iterating over the set elements,
     // to ensure that the runtime complexity remains proportional to the
public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(InsertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     RankedTensorType dstType =
         op.getTensor().getType().cast<RankedTensorType>();
     auto tuple = getTuple(adaptor.getTensor());
     // Prepare fields and indices.
-    SmallVector<Value, 8> fields(tuple.getInputs());
-    SmallVector<Value, 8> indices(adaptor.getIndices());
+    SmallVector<Value> fields(tuple.getInputs());
+    SmallVector<Value> indices(adaptor.getIndices());
     // Generate insertion.
     Value value = adaptor.getValue();
     genInsert(rewriter, op->getLoc(), dstType, fields, indices, value);
     // Replace operation with resulting memrefs.
     rewriter.replaceOp(op, genTuple(rewriter, op.getLoc(), dstType, fields));
     return success();
   }
 };

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

 }
 
 /// Generates call to lookup a level-size.
 static Value genLvlSizeCall(OpBuilder &builder, Location loc,
                             SparseTensorEncodingAttr &enc, Value src,
                             uint64_t lvl) {
   // Generate the call.
   StringRef name = "sparseLvlSize";
-  SmallVector<Value, 2> params{
+  SmallVector<Value, 2> params{  // just two
       src, constantIndex(builder, loc, toStoredDim(enc, lvl))};
   Type iTp = builder.getIndexType();
   return createFuncCall(builder, loc, name, iTp, params, EmitCInterface::Off)
       .getResult(0);
 }
 
 /// Compute the size from type (for static sizes) or from an already-converted
 /// opaque pointer source (for dynamic sizes) at the given dimension.
static Value sizeFromPtrAtDim(OpBuilder &builder, Location loc,
   auto shape = stp.getShape();
   if (shape[i] == ShapedType::kDynamicSize)
     return genLvlSizeCall(builder, loc, enc, src, i);
   return constantIndex(builder, loc, shape[i]);
 }
 
 /// Populates given sizes array from type (for static sizes) and from
 /// an already-converted opaque pointer source (for dynamic sizes).
-static void sizesFromPtr(OpBuilder &builder, SmallVector<Value, 4> &sizes,
+static void sizesFromPtr(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                          Location loc, SparseTensorEncodingAttr &enc,
                          ShapedType stp, Value src) {
   for (unsigned i = 0, rank = stp.getRank(); i < rank; i++)
     sizes.push_back(sizeFromPtrAtDim(builder, loc, enc, stp, src, i));
 }
 
 /// Populates given sizes array from type.
-static void sizesFromType(OpBuilder &builder, SmallVector<Value, 4> &sizes,
+static void sizesFromType(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                           Location loc, ShapedType stp) {
   auto shape = stp.getShape();
   for (unsigned i = 0, rank = stp.getRank(); i < rank; i++) {
     uint64_t s = shape[i] == ShapedType::kDynamicSize ? 0 : shape[i];
     sizes.push_back(constantIndex(builder, loc, s));
   }
 }
 
 /// Populates the given sizes array for concatenation from type (for static
 /// sizes) and from an already-converted opaque pointer source (for dynamic
 /// sizes).
 static void concatSizesFromInputs(OpBuilder &builder,
-                                  SmallVector<Value, 4> &sizes, Location loc,
+                                  SmallVectorImpl<Value> &sizes, Location loc,
                                   ShapedType dstTp, ValueRange srcs,
                                   unsigned dim) {
   auto dstShape = dstTp.getShape();
 
   auto srcTp = srcs[0].getType().cast<ShapedType>();
   auto srcEnc = getSparseTensorEncoding(srcTp);
   // We first fills the sizes from an input tensor, and then
   // compute the size of the concatenation dimension if necessary.

 // TODO: see the note at `_mlir_ciface_newSparseTensor` about how
 // the meaning of the various arguments (e.g., "sizes" vs "shapes")
 // is inconsistent between the different actions.
 NewCallParams &NewCallParams::genBuffers(SparseTensorEncodingAttr enc,
                                          ValueRange dimSizes, ShapedType stp) {
   const unsigned lvlRank = enc.getDimLevelType().size();
   const unsigned dimRank = stp.getRank();
   // Sparsity annotations.
-  SmallVector<Value, 4> lvlTypes;
+  SmallVector<Value> lvlTypes;
   for (auto dlt : enc.getDimLevelType())
     lvlTypes.push_back(constantDimLevelTypeEncoding(builder, loc, dlt));
   assert(lvlTypes.size() == lvlRank && "Level-rank mismatch");
   params[kParamLvlTypes] = genBuffer(builder, loc, lvlTypes);
   // Dimension-sizes array of the enveloping tensor.  Useful for either
   // verification of external data, or for construction of internal data.
   assert(dimSizes.size() == dimRank && "Dimension-rank mismatch");
   params[kParamDimSizes] = genBuffer(builder, loc, dimSizes);
   // The level-sizes array must be passed as well, since for arbitrary
   // dim2lvl mappings it cannot be trivially reconstructed at runtime.
   // For now however, since we're still assuming permutations, we will
   // initialize this parameter alongside the `dim2lvl` and `lvl2dim`
   // parameters below.  We preinitialize `lvlSizes` for code symmetry.
-  SmallVector<Value, 4> lvlSizes(lvlRank);
+  SmallVector<Value> lvlSizes(lvlRank);
   // The dimension-to-level mapping and its inverse.  We must preinitialize
   // `dim2lvl` so that the true branch below can perform random-access
   // `operator[]` assignment.  We preinitialize `lvl2dim` for code symmetry.
-  SmallVector<Value, 4> dim2lvl(dimRank);
-  SmallVector<Value, 4> lvl2dim(lvlRank);
+  SmallVector<Value> dim2lvl(dimRank);
+  SmallVector<Value> lvl2dim(lvlRank);
   auto dimOrder = enc.getDimOrdering();
   if (dimOrder) {
     assert(dimOrder.isPermutation());
     for (unsigned l = 0; l < lvlRank; l++) {
       // The `d`th source variable occurs in the `l`th result position.
       uint64_t d = dimOrder.getDimPosition(l);
       dim2lvl[d] = constantIndex(builder, loc, l);
       lvl2dim[l] = constantIndex(builder, loc, d);
static Value genGetNextCall(OpBuilder &builder, Location loc, Value iter,
   SmallVector<Value, 3> params{iter, ind, elemPtr};
   Type i1 = builder.getI1Type();
   return createFuncCall(builder, loc, name, i1, params, EmitCInterface::On)
       .getResult(0);
 }
 
 /// Converts a pointer to COO (from calls to iter->next()) into a vector of
 /// indices, apply (optional) `offset` on `offsetDim`.
-static SmallVector<Value, 4> loadIndices(OpBuilder &builder, Location loc,
-                                         unsigned rank, Value ind,
-                                         unsigned offsetDim = 0,
-                                         Value offset = Value()) {
-  SmallVector<Value, 4> ivs;
+static SmallVector<Value> loadIndices(OpBuilder &builder, Location loc,
+  SmallVector<Value> ivs;
   ivs.reserve(rank);
   for (unsigned i = 0; i < rank; i++) {
     Value idx = constantIndex(builder, loc, i);
     idx = builder.create<memref::LoadOp>(loc, ind, idx);
     if (offsetDim == i && offset)
       idx = builder.create<arith::AddIOp>(loc, idx, offset);
     ivs.push_back(idx);
   }

 static void translateIndices(Location loc, ConversionPatternRewriter &rewriter,
                              ArrayRef<ReassociationIndices> reassociation,
                              TensorType dstTp, TensorType srcTp, Value dstIdx,
                              Value srcIdx, ArrayRef<Value> dstShape,
                              ArrayRef<Value> srcShape) {
   unsigned dstRank = dstTp.getRank();
   unsigned srcRank = srcTp.getRank();
 
-  SmallVector<Value, 4> srcIndices;
+  SmallVector<Value> srcIndices;
   for (unsigned i = 0; i < srcRank; i++) {
     Value idx = rewriter.create<memref::LoadOp>(
         loc, srcIdx, constantIndex(rewriter, loc, i));
     srcIndices.push_back(idx);
   }
 
-  SmallVector<Value, 4> dstIndices;
+  SmallVector<Value> dstIndices;
   translateIndicesArray(rewriter, loc, reassociation, srcIndices, srcShape,
                         dstShape, dstIndices);
 
   for (unsigned i = 0; i < dstRank; i++)
     rewriter.create<memref::StoreOp>(loc, dstIndices[i], dstIdx,
                                      constantIndex(rewriter, loc, i));
 }
 
genSparse2SparseReshape(ReshapeOp op, typename ReshapeOp::Adaptor adaptor,
   unsigned dstRank = dstTp.getRank();
   Type elemTp = srcTp.getElementType();
   assert(elemTp == dstTp.getElementType() &&
          "reshape should not change element type");
   // Start an iterator over the source tensor (in original index order).
   auto noPerm = SparseTensorEncodingAttr::get(
       op->getContext(), encSrc.getDimLevelType(), AffineMap(), AffineMap(),
       encSrc.getPointerBitWidth(), encSrc.getIndexBitWidth());
-  SmallVector<Value, 4> srcSizes;
+  SmallVector<Value> srcSizes;
   sizesFromPtr(rewriter, srcSizes, loc, encSrc, srcTp, adaptor.getSrc());
   NewCallParams params(rewriter, loc);
   Value iter = params.genBuffers(noPerm, srcSizes, srcTp)
                    .genNewCall(Action::kToIterator, adaptor.getSrc());
   // Start a new COO for the destination tensor.
-  SmallVector<Value, 4> dstSizes;
+  SmallVector<Value> dstSizes;
   if (dstTp.hasStaticShape()) {
     sizesFromType(rewriter, dstSizes, loc, dstTp);
   } else {
     ArrayRef<int64_t> dstShape = dstTp.getShape();
     genReshapeDstShape(loc, rewriter, dstSizes, srcSizes, dstShape,
                        op.getReassociationIndices());
   }
   Value coo =
static void genSparseCOOIterationLoop(
 
   unsigned rank = tensorTp.getRank();
   Type elemTp = tensorTp.getElementType();
 
   // Start an iterator over the tensor (in original index order).
   auto noPerm = SparseTensorEncodingAttr::get(
       rewriter.getContext(), enc.getDimLevelType(), AffineMap(), AffineMap(),
       enc.getPointerBitWidth(), enc.getIndexBitWidth());
-  SmallVector<Value, 4> sizes;
+  SmallVector<Value> sizes;
   sizesFromPtr(rewriter, sizes, loc, noPerm, tensorTp, t);
   Value iter = NewCallParams(rewriter, loc)
                    .genBuffers(noPerm, sizes, tensorTp)
                    .genNewCall(Action::kToIterator, t);
 
   // Construct a while loop over the iterator.
   Value srcIdx = genAlloca(rewriter, loc, rank, rewriter.getIndexType());
   Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
matchAndRewrite(NewOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     Type resType = op.getType();
     auto enc = getSparseTensorEncoding(resType);
     if (!enc)
       return failure();
     // Generate the call to construct tensor from ptr. The sizes are
     // inferred from the result type of the new operator.
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     ShapedType stp = resType.cast<ShapedType>();
     sizesFromType(rewriter, sizes, loc, stp);
     Value ptr = adaptor.getOperands()[0];
     rewriter.replaceOp(op, NewCallParams(rewriter, loc)
                                .genBuffers(enc, sizes, stp)
                                .genNewCall(Action::kFromFile, ptr));
     return success();
   }
if (encDst && encSrc) {
       //   dst = newSparseTensor(t)
       // Using the coordinate scheme as an intermediate does not always
       // yield the fastest conversion but avoids the need for a full
       // O(N^2) conversion matrix.
       if (encDst == encSrc) {
         rewriter.replaceOp(op, adaptor.getOperands()); // hidden nop cast
         return success();
       }
-      SmallVector<Value, 4> sizes;
+      SmallVector<Value> sizes;
       NewCallParams params(rewriter, loc);
       ShapedType stp = srcType.cast<ShapedType>();
       sizesFromPtr(rewriter, sizes, loc, encSrc, stp, src);
       bool useDirectConversion;
       switch (options.sparseToSparseStrategy) {
       case SparseToSparseConversionStrategy::kViaCOO:
         useDirectConversion = false;
         break;
if (!encDst && encSrc) {
       Type elemTp = dstTensorTp.getElementType();
       // Fabricate a no-permutation encoding for NewCallParams
       // The pointer/index types must be those of `src`.
       // The dimLevelTypes aren't actually used by Action::kToIterator.
       encDst = SparseTensorEncodingAttr::get(
           op->getContext(),
           SmallVector<DimLevelType>(rank, DimLevelType::Dense), AffineMap(),
           AffineMap(), encSrc.getPointerBitWidth(), encSrc.getIndexBitWidth());
-      SmallVector<Value, 4> sizes;
+      SmallVector<Value> sizes;
       sizesFromPtr(rewriter, sizes, loc, encSrc, srcTensorTp, src);
       Value iter = NewCallParams(rewriter, loc)
                        .genBuffers(encDst, sizes, dstTensorTp)
                        .genNewCall(Action::kToIterator, src);
       Value ind = genAlloca(rewriter, loc, rank, rewriter.getIndexType());
       Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
       Block *insertionBlock = rewriter.getInsertionBlock();
       // TODO: Dense buffers should be allocated/deallocated via the callback
       // in BufferizationOptions.
       Value dst = allocDenseTensor(rewriter, loc, dstTensorTp, sizes);
       SmallVector<Value> noArgs;
       SmallVector<Type> noTypes;
       auto whileOp = rewriter.create<scf::WhileOp>(loc, noTypes, noArgs);
       Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, noTypes);
       rewriter.setInsertionPointToEnd(before);
       Value cond = genGetNextCall(rewriter, loc, iter, ind, elemPtr);
       rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
       Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, noTypes);
       rewriter.setInsertionPointToStart(after);
-      SmallVector<Value, 4> ivs = loadIndices(rewriter, loc, rank, ind);
+      SmallVector<Value> ivs = loadIndices(rewriter, loc, rank, ind);
       insertScalarIntoDenseTensor(rewriter, loc, elemPtr, dst, ivs);
       rewriter.create<scf::YieldOp>(loc);
       rewriter.setInsertionPointAfter(whileOp);
       genDelIteratorCall(rewriter, loc, elemTp, iter);
       rewriter.replaceOpWithNewOp<bufferization::ToTensorOp>(op, resType, dst);
       // Deallocate the buffer.
       if (bufferization::allocationDoesNotEscape(op->getOpResult(0))) {
         rewriter.setInsertionPoint(insertionBlock->getTerminator());
matchAndRewrite(ConvertOp op, OpAdaptor adaptor,
     // Note that the dense tensor traversal code is actually implemented
     // using MLIR IR to avoid having to expose too much low-level
     // memref traversal details to the runtime support library.
     // Also note that the code below only generates the "new" ops and
     // the loop-nest per se; whereas the entire body of the innermost
     // loop is generated by genAddElt().
     ShapedType stp = resType.cast<ShapedType>();
     unsigned rank = stp.getRank();
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     sizesFromSrc(rewriter, sizes, loc, src);
     NewCallParams params(rewriter, loc);
     Value coo =
         params.genBuffers(encDst, sizes, stp).genNewCall(Action::kEmptyCOO);
     Value ind = genAlloca(rewriter, loc, rank, rewriter.getIndexType());
     Value perm = params.getDim2LvlMap();
     Type eltType = stp.getElementType();
     Value elemPtr = genAllocaScalar(rewriter, loc, eltType);
matchAndRewrite(ConcatenateOp op, OpAdaptor adaptor,
     Value dstPerm; // destination tensor permutation (if sparse out)
     // A pointer to the value being inserted (if dense => sparse)
     Value elemPtr;
     // Memory that holds the COO for destination tensor (if sparse out)
     Value dstIdx;
     // The offset applied to the dimenstion to be concated (starting from 0)
     Value offset = constantIndex(rewriter, loc, 0);
 
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     NewCallParams params(rewriter, loc);
     concatSizesFromInputs(rewriter, sizes, loc, dstTp, op.getInputs(),
                           concatDim);
 
     if (encDst) {
       // Start a new COO for the destination tensor.
       dst =
           params.genBuffers(encDst, sizes, dstTp).genNewCall(Action::kEmptyCOO);
for (auto it : llvm::zip(op.getInputs(), adaptor.getInputs())) {
                              offset);
                 Value val = genValueForDense(builder, loc, adaptedOp, idx);
                 builder.create<memref::StoreOp>(loc, val, elemPtr);
                 genAddEltCall(builder, loc, elemTp, dst, elemPtr, dstIdx,
                               dstPerm);
               } else {
                 // Case: dense => dense
                 Value val = genValueForDense(builder, loc, adaptedOp, idx);
-                SmallVector<Value, 4> indVec(idx);
+                SmallVector<Value> indVec(idx);
                 // Apply offset.
                 indVec[concatDim] = builder.create<arith::AddIOp>(
                     loc, indVec[concatDim], offset);
                 builder.create<memref::StoreOp>(loc, val, dst, indVec);
               }
             });
       }
       // Accumulate offset.
public:
   LogicalResult
   matchAndRewrite(OutOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     ShapedType srcType = op.getTensor().getType().cast<ShapedType>();
     // Convert to default permuted COO.
     Value src = adaptor.getOperands()[0];
     auto encSrc = getSparseTensorEncoding(srcType);
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     sizesFromPtr(rewriter, sizes, loc, encSrc, srcType, src);
     auto enc = SparseTensorEncodingAttr::get(
         op->getContext(), encSrc.getDimLevelType(), AffineMap(), AffineMap(),
         encSrc.getPointerBitWidth(), encSrc.getIndexBitWidth());
     Value coo = NewCallParams(rewriter, loc)
                     .genBuffers(enc, sizes, srcType)
                     .genNewCall(Action::kToCOO, src);
     // Then output the tensor to external file with indices in the externally

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

if (arg.getOwner()->getParentOp() == op) {
       return isZeroValue(op->getOperand(arg.getArgNumber()));
     }
   }
   return isZeroValue(yieldOp.getOperand(0));
 }
 
 /// Populates given sizes array from type (for static sizes) and from
 /// the tensor (for dynamic sizes).
-static void sizesForTensor(OpBuilder &builder, SmallVector<Value, 4> &sizes,
+static void sizesForTensor(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                            Location loc, ShapedType stp, Value tensor) {
   for (const auto &d : enumerate(stp.getShape())) {
     Value dim;
     if (d.value() == ShapedType::kDynamicSize)
       dim = builder.create<tensor::DimOp>(loc, tensor, d.index());
     else
       dim = constantIndex(builder, loc, d.value());
     sizes.push_back(dim);
   }
 }
 
 // TODO: The dim level property of the COO type relies on input tensors, the
 // shape relies on the output tensor
 // Helpers to setup a COO type.
 static RankedTensorType getUnorderedCOOFromType(RankedTensorType src) {
   auto *ctx = src.getContext();
   auto rank = src.getRank();
-  SmallVector<DimLevelType, 4> dims;
+  SmallVector<DimLevelType> dims;
 
   // An unordered and non-unique compressed dim at beginning.
   dims.push_back(DimLevelType::CompressedNuNo);
 
   if (rank > 1) {
     // TODO: it is actually ordered at the level for ordered input.
     // Followed by unordered non-unique n-2 singleton levels.
     std::fill_n(std::back_inserter(dims), rank - 2,
LogicalResult matchAndRewrite(ReshapeOp op,
     SparseTensorEncodingAttr encSrc = getSparseTensorEncoding(srcTp);
     SparseTensorEncodingAttr encDst = getSparseTensorEncoding(dstTp);
     if (!encDst || !encSrc) {
       return failure();
     }
 
     // Generate code to represent the static dimension constants or compute
     // the dynamic dimension values.
-    SmallVector<Value, 4> srcSizes;
+    SmallVector<Value> srcSizes;
     sizesForTensor(rewriter, srcSizes, loc, srcTp, srcTensor);
-    SmallVector<Value, 4> dstSizes;
-    SmallVector<Value, 4> dstDynSizes;
+    SmallVector<Value> dstSizes;
+    SmallVector<Value> dstDynSizes;
     if (dstTp.hasStaticShape()) {
       for (auto d : dstTp.getShape())
         dstSizes.push_back(constantIndex(rewriter, loc, d));
     } else {
       ArrayRef<int64_t> dstShape = dstTp.getShape();
       genReshapeDstShape(loc, rewriter, dstSizes, srcSizes, dstShape,
                          op.getReassociationIndices());
       for (auto &d : llvm::enumerate(dstShape)) {
LogicalResult matchAndRewrite(ReshapeOp op,
     //   %t = sparse_tensor.cast %tmp
     RankedTensorType cooTp = getUnorderedCOOFromType(dstTp);
     auto cooBuffer =
         rewriter.create<AllocTensorOp>(loc, cooTp, dstDynSizes).getResult();
     ForeachOp foreachOp = rewriter.create<ForeachOp>(
         loc, srcTensor, cooBuffer,
         [&](OpBuilder &builder, Location loc, ValueRange args, Value v,
             ValueRange reduc) {
-          SmallVector<Value, 4> srcIndices;
-          SmallVector<Value, 4> dstIndices;
+          SmallVector<Value> srcIndices;
+          SmallVector<Value> dstIndices;
           for (int64_t i = 0, e = srcTp.getRank(); i < e; i++) {
             uint64_t dim = toStoredDim(encSrc, i);
             srcIndices.push_back(args[dim]);
           }
           translateIndicesArray(builder, loc, op.getReassociationIndices(),
                                 srcIndices, srcSizes, dstSizes, dstIndices);
           auto t = builder.create<InsertOp>(loc, v, reduc.front(), dstIndices);
           builder.create<sparse_tensor::YieldOp>(loc, t);
LogicalResult matchAndRewrite(ConcatenateOp op,
     ForeachOp foreachOp;
     for (Value input : op.getInputs()) {
       // Build a for op for each input tensor to append new values into the
       // output tensor.
       foreachOp = rewriter.create<ForeachOp>(
           loc, input, cooBuffer,
           [&](OpBuilder &builder, Location loc, ValueRange args, Value v,
               ValueRange reduc) {
-            SmallVector<Value, 4> indices;
+            SmallVector<Value> indices;
             for (int64_t i = 0; i < rank; i++) {
               Value idx = args[i];
               if (i == static_cast<int64_t>(conDim))
                 // transform coordinates on matching dim
                 idx = builder.create<arith::AddIOp>(loc, idx, offset);
               indices.push_back(idx);
             }
             Value cond = genIsNonzero(rewriter, loc, v);
private:
   //     val = values[i]
   //     [i1,..,ik] = indices[i]
   //     t->add(val, [i1,..,ik], [p1,..,pk])
   LogicalResult dense2SparseRewrite(ConvertOp op,
                                     PatternRewriter &rewriter) const {
     Location loc = op.getLoc();
     Value src = op.getSource();
     RankedTensorType dstTp = op.getType().cast<RankedTensorType>();
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     sizesFromSrc(rewriter, sizes, loc, src);
-    SmallVector<Value, 4> dynSizes;
+    SmallVector<Value> dynSizes;
     getDynamicSizes(dstTp, sizes, dynSizes);
 
     bool fromSparseConst = false;
     if (auto constOp = op.getSource().getDefiningOp<arith::ConstantOp>()) {
       if (constOp.getValue().dyn_cast<SparseElementsAttr>()) {
         fromSparseConst = true;
       }
     }
private:
   //     dst[elemment.indices] = element.value
   LogicalResult sparse2DenseRewrite(ConvertOp op,
                                     PatternRewriter &rewriter) const {
     Location loc = op->getLoc();
     RankedTensorType dstTp = op.getType().cast<RankedTensorType>();
     Value src = op.getSource();
     RankedTensorType srcTp = src.getType().cast<RankedTensorType>();
 
-    SmallVector<Value, 4> sizes;
+    SmallVector<Value> sizes;
     sizesForTensor(rewriter, sizes, loc, srcTp, src);
 
     Value dst = allocDenseTensor(rewriter, loc, dstTp, sizes);
     Block *insertionBlock = rewriter.getInsertionBlock();
     bool noEscape = bufferization::allocationDoesNotEscape(op->getOpResult(0));
 
     rewriter.create<ForeachOp>(loc, src, llvm::None,
                                [&](OpBuilder &builder, Location loc,
private:
   LogicalResult sparse2SparseRewrite(ConvertOp op,
                                      PatternRewriter &rewriter) const {
     Location loc = op->getLoc();
     Value src = op.getSource();
     RankedTensorType srcTp = src.getType().cast<RankedTensorType>();
     RankedTensorType dstTp = op.getType().cast<RankedTensorType>();
     SparseTensorEncodingAttr encDst = getSparseTensorEncoding(dstTp);
 
-    SmallVector<Value, 4> srcSizes;
+    SmallVector<Value> srcSizes;
     sizesForTensor(rewriter, srcSizes, loc, srcTp, src);
     Value tmpCoo = Value();
     if (!isUniqueCOOType(srcTp)) {
       // Construct a COO tensor from the src tensor.
       // TODO: there may be cases for which more efficiently without
       // going through an intermediate COO, such as cases that only change
       // the overhead types.
-      SmallVector<Value, 4> dynSrcSizes;
+      SmallVector<Value> dynSrcSizes;
       getDynamicSizes(srcTp, srcSizes, dynSrcSizes);
       srcTp = getUnorderedCOOFromType(srcTp);
       tmpCoo =
           rewriter.create<AllocTensorOp>(loc, srcTp, dynSrcSizes).getResult();
       auto foreachOp = rewriter.create<ForeachOp>(
           loc, src, tmpCoo,
           [&](OpBuilder &builder, Location loc, ValueRange args, Value v,
               ValueRange reduc) {
             // The resulting COO tensor has identity ordering.
             auto t = builder.create<InsertOp>(loc, v, reduc.front(),
                                               args.slice(0, srcTp.getRank()));
             builder.create<sparse_tensor::YieldOp>(loc, t);
           });
       src = rewriter.create<LoadOp>(loc, foreachOp.getResult(0), true);
     }
 
     // Sort the COO tensor so that its elements are ordered via increasing
     // indices for the storage ordering of the dst tensor.
     SparseTensorEncodingAttr encSrc = getSparseTensorEncoding(srcTp);
     auto dynShape = {ShapedType::kDynamicSize};
     auto indTp =
         MemRefType::get(dynShape, getIndexOverheadType(rewriter, encSrc));
     uint64_t rank = dstTp.getRank();
     // Gather the indices-arrays in the dst tensor storage order.
-    SmallVector<Value, 4> xs(rank, Value());
+    SmallVector<Value> xs(rank, Value());
     for (uint64_t i = 0; i < rank; i++) {
       uint64_t orgDim = toOrigDim(encSrc, i);
       xs[toStoredDim(encDst, orgDim)] = rewriter.create<ToIndicesOp>(
           loc, indTp, src, rewriter.getIndexAttr(i));
     }
 
     // Retrieve NNZ.
     Value nnz = rewriter.create<NumberOfEntriesOp>(loc, src);
     nnz =
         rewriter.create<arith::IndexCastOp>(loc, rewriter.getIndexType(), nnz);
 
     // Retrieve the values-array.
     auto valTp = MemRefType::get(dynShape, srcTp.getElementType());
     Value y = rewriter.create<ToValuesOp>(loc, valTp, src);
 
     // Sort the COO tensor.
     rewriter.create<SortOp>(loc, nnz, xs, ValueRange{y});
 
     // For each element in the COO tensor, insert the element to the dst tensor.
-    SmallVector<Value, 4> dynDstSizes;
+    SmallVector<Value> dynDstSizes;
     getDynamicSizes(dstTp, srcSizes, dynDstSizes);
     Value dst =
         rewriter.create<AllocTensorOp>(loc, dstTp, dynDstSizes).getResult();
-    SmallVector<Value, 4> indices(srcTp.getRank(), Value());
+    SmallVector<Value> indices(srcTp.getRank(), Value());
     auto foreachOp = rewriter.create<ForeachOp>(
         loc, src, dst,
         [&](OpBuilder &builder, Location loc, ValueRange args, Value v,
             ValueRange reduc) {
           for (int64_t i = 0, e = srcTp.getRank(); i < e; i++) {
             uint64_t dim = toStoredDim(encDst, i);
             indices[dim] = args[i];
           }
for (int64_t i = 0; i < rank; i++) {
       // TODO: provide utility function for loop sequences that only contains
       // one for loop?
       loopEmitter.enterNewLoopSeq(rewriter, loc, 0, static_cast<size_t>(i));
       // Note that reduc will be taken care of by loop emitter and get updated
       // in place.
       loopEmitter.enterLoopOverTensorAtDim(rewriter, loc, 0, i, reduc);
     }
 
-    SmallVector<Value, 4> coords;
+    SmallVector<Value> coords;
     coords.reserve(rank);
     loopEmitter.getCoordinateArray(coords);
 
     Value vals = loopEmitter.getValBuffer()[0];
     Value pidx = loopEmitter.getPidxs()[0].back();
     // Loads the value from sparse tensor using pointer index;
     // loads the value from dense tensor using coordinate array.
     Value val = enc ? rewriter.create<memref::LoadOp>(loc, vals, pidx)
                     : rewriter.create<memref::LoadOp>(loc, vals, coords);
 
     // 2. Inline the block in the foreach operator.
     Block *srcBlock = op.getBody();
 
-    SmallVector<Value, 4> args;
     // Remap coordinates.
+    SmallVector<Value> args;
     for (int64_t i = 0; i < rank; i++) {
       Value actual = coords[toStoredDim(enc, i)];
       args.push_back(actual);
     }
     // Remap value.
     args.push_back(val);
     // Remap reduction variables.
     args.append(reduc);
LogicalResult matchAndRewrite(NewOp op,
 
     // Allocate a temporary buffer for storing dimension sizes and indices.
     Type indexTp = rewriter.getIndexType();
     uint64_t rank = dstTp.getRank();
     Value dimSizes = genAlloca(rewriter, loc, rank, indexTp);
 
     // If the result tensor has dynamic dimensions, get the dynamic sizes from
     // the sparse tensor reader.
-    SmallVector<Value, 4> dynSizesArray;
+    SmallVector<Value> dynSizesArray;
     if (!dstTp.hasStaticShape()) {
       createFuncCall(rewriter, loc, "getSparseTensorReaderDimSizes", {},
                      {reader, dimSizes}, EmitCInterface::On)
           .getResult(0);
       ArrayRef<int64_t> dstShape = dstTp.getShape();
       for (auto &d : llvm::enumerate(dstShape)) {
         if (d.value() == ShapedType::kDynamicSize) {
           dynSizesArray.push_back(rewriter.create<memref::LoadOp>(
LogicalResult matchAndRewrite(NewOp op,
     rewriter.setInsertionPointToStart(forOp.getBody());
 
     SmallString<18> getNextFuncName{"getSparseTensorReaderNext",
                                     primaryTypeFunctionSuffix(eltTp)};
     Value indices = dimSizes; // Reuse the indices memref to store indices.
     createFuncCall(rewriter, loc, getNextFuncName, {eltTp},
                    {reader, indices, value}, EmitCInterface::On)
         .getResult(0);
-    SmallVector<Value, 4> indicesArray;
+    SmallVector<Value> indicesArray;
     for (uint64_t i = 0; i < rank; i++) {
       indicesArray.push_back(rewriter.create<memref::LoadOp>(
           loc, indices, constantIndex(rewriter, loc, i)));
     }
     Value v = rewriter.create<memref::LoadOp>(loc, value);
     auto t = rewriter.create<InsertOp>(loc, v, forOp.getRegionIterArg(0),
                                        indicesArray);
     rewriter.create<scf::YieldOp>(loc, ArrayRef<Value>(t));
LogicalResult matchAndRewrite(OutOp op,
     // Allocate a temporary buffer for storing dimension sizes and indices.
     auto srcTp = src.getType().template cast<RankedTensorType>();
     uint64_t rank = srcTp.getRank();
     Type indexTp = rewriter.getIndexType();
     Value dimSizes = genAlloca(rewriter, loc, rank, indexTp);
 
     // Generate code to calculate dimension size values and store the values to
     // the buffer.
-    SmallVector<Value, 4> dims;
+    SmallVector<Value> dims;
     sizesForTensor(rewriter, dims, loc, srcTp, src);
     for (uint64_t i = 0; i < rank; i++) {
       rewriter.create<memref::StoreOp>(loc, dims[i], dimSizes,
                                        constantIndex(rewriter, loc, i));
     }
 
     // Create a sparse tensor writer and output meta data.
     Type opaqueTp = getOpaquePointerType(rewriter);
rewriter.create<ForeachOp>(
         loc, src, llvm::None,
         [&](OpBuilder &builder, Location loc, ValueRange args, Value v,
             ValueRange reduc) {
           for (uint64_t i = 0; i < rank; i++) {
             rewriter.create<memref::StoreOp>(loc, args[i], indices,
                                              constantIndex(builder, loc, i));
           }
           rewriter.create<memref::StoreOp>(loc, v, value);
-          SmallVector<Value, 4> operands{writer, rankValue, indices, value};
+          SmallVector<Value> operands{writer, rankValue, indices, value};
           FlatSymbolRefAttr fn = getFunc(module, outNextFuncName, {}, operands,
                                          EmitCInterface::On);
           builder.create<func::CallOp>(loc, TypeRange(), fn, operands);
           builder.create<sparse_tensor::YieldOp>(loc);
         });
 
     // Release the writer.
     createFuncCall(rewriter, loc, "delSparseTensorWriter", {}, {writer},

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

 /// Helper method to construct a permuted dimension ordering
 /// that adheres to the given topological sort.
 static AffineMap permute(MLIRContext *context, AffineMap m,
                          std::vector<unsigned> &topSort) {
   unsigned sz = topSort.size();
   assert(m.getNumResults() == sz && "TopoSort/AffineMap size mismatch");
   // Construct the inverse of `m`; to avoid the asymptotic complexity
   // of calling `m.getPermutedPosition` repeatedly.
-  SmallVector<unsigned, 4> inv(sz);
+  SmallVector<unsigned> inv(sz);
   for (unsigned i = 0; i < sz; i++)
     inv[i] = m.getDimPosition(i);
   // Construct the permutation.
-  SmallVector<unsigned, 4> perm(sz);
+  SmallVector<unsigned> perm(sz);
   for (unsigned i = 0; i < sz; i++)
     perm[i] = inv[topSort[i]];
   return AffineMap::getPermutationMap(perm, context);
 }
 
 /// Helper method to inspect affine expressions. Rejects cases where the
 /// same index is used more than once. Also rejects compound affine
 /// expressions in sparse dimensions.

 //===----------------------------------------------------------------------===//
 
 /// Generates loop boundary statements (entering/exiting loops). The function
 /// passes and updates the reduction value.
 static Optional<Operation *> genLoopBoundary(
     CodeGen &codegen, Merger &merger,
     function_ref<Optional<Operation *>(MutableArrayRef<Value> reduc)>
         callback) {
-  SmallVector<Value, 4> reduc;
+  SmallVector<Value> reduc;
   if (codegen.redVal)
     reduc.push_back(codegen.redVal);
   if (codegen.expValues)
     reduc.push_back(codegen.expCount);
   if (codegen.insChain)
     reduc.push_back(codegen.insChain);
 
   auto r = callback(reduc);
static Value genIndex(CodeGen &codegen, linalg::GenericOp op, OpOperand *t) {
   assert(a.getKind() == AffineExprKind::DimId);
   unsigned idx = a.cast<AffineDimExpr>().getPosition();
   return codegen.getLoopIdxValue(idx);
 }
 
 /// Generates subscript for load/store on a dense or sparse tensor.
 static Value genSubscript(CodeGen &codegen, OpBuilder &builder,
                           linalg::GenericOp op, OpOperand *t,
-                          SmallVector<Value, 4> &args) {
+                          SmallVectorImpl<Value> &args) {
   unsigned tensor = t->getOperandNumber();
   auto map = op.getMatchingIndexingMap(t);
   auto enc = getSparseTensorEncoding(t->get().getType());
   unsigned rank = map.getNumResults();
   if (enc) {
     // Note that currently, all sparse subscripts are simple.
     // TODO: accept affine too?
     assert(map.getResult(toOrigDim(enc, rank - 1)).getKind() ==

 
 /// Generates insertion code to implement dynamic tensor store.
 static void genInsertionStore(CodeGen &codegen, OpBuilder &builder,
                               linalg::GenericOp op, OpOperand *t, Value rhs) {
   Location loc = op.getLoc();
   // Direct insertion in lexicographic index order.
   if (!codegen.expValues) {
     unsigned rank = op.getRank(t);
-    SmallVector<Value, 4> indices;
+    SmallVector<Value> indices;
     for (unsigned i = 0; i < rank; i++) {
       assert(codegen.loopEmitter.getLoopIV(i));
       indices.push_back(codegen.loopEmitter.getLoopIV(i));
     }
     codegen.insChain =
         builder.create<InsertOp>(loc, rhs, codegen.insChain, indices);
     return;
   }
static Value genTensorLoad(Merger &merger, CodeGen &codegen, OpBuilder &builder,
   // Load during insertion.
   OpOperand &t = op->getOpOperand(merger.exp(exp).tensor);
   if (&t == codegen.sparseOut) {
     if (codegen.redCustom != -1u)
       return genInsertionLoadReduce(merger, codegen, builder, op, &t);
     return genInsertionLoad(codegen, builder, op, &t);
   }
   // Actual load.
-  SmallVector<Value, 4> args;
+  SmallVector<Value> args;
   Value ptr = genSubscript(codegen, builder, op, &t, args);
   return builder.create<memref::LoadOp>(op.getLoc(), ptr, args);
 }
 
 /// Generates a store on a dense or sparse tensor.
 static void genTensorStore(Merger &merger, CodeGen &codegen, OpBuilder &builder,
                            linalg::GenericOp op, unsigned exp, Value rhs) {
   Location loc = op.getLoc();
   // Test if this is a scalarized reduction.
   if (codegen.redVal) {
     updateReduc(merger, codegen, rhs);
     return;
   }
   // Store during insertion.
   OpOperand *t = op.getDpsInitOperand(0);
   if (t == codegen.sparseOut) {
     if (!rhs) {
       // Only unary and binary are allowed to return uninitialized rhs
       // to indicate missing output.
       assert(merger.exp(exp).kind == kUnary || merger.exp(exp).kind == kBinary);
     } else if (merger.exp(exp).kind == kSelect) {
       // Select operation insertion.
       Value insChain = codegen.insChain;
       assert(insChain);
-      SmallVector<Type, 1> types;
-      types.push_back(codegen.insChain.getType());
-      scf::IfOp ifOp =
-          builder.create<scf::IfOp>(loc, types, rhs, /*else=*/true);
+      scf::IfOp ifOp = builder.create<scf::IfOp>(
+          loc, insChain.getType(), rhs, /*else=*/true);
       builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
       // Existing value was preserved to be used here.
       assert(merger.exp(exp).val);
       Value v0 = merger.exp(exp).val;
       genInsertionStore(codegen, builder, op, t, v0);
       merger.exp(exp).val = Value();
       // Yield modified insertion chain along true branch.
       builder.create<scf::YieldOp>(op.getLoc(), codegen.insChain);
       // Yield original insertion chain along false branch.
       builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
       builder.create<scf::YieldOp>(loc, insChain);
       // Done with if statement.
       codegen.insChain = ifOp->getResult(0);
       builder.setInsertionPointAfter(ifOp);
     } else {
       genInsertionStore(codegen, builder, op, t, rhs);
     }
     return;
   }
   // Actual store.
-  SmallVector<Value, 4> args;
+  SmallVector<Value> args;
   Value ptr = genSubscript(codegen, builder, op, t, args);
   builder.create<memref::StoreOp>(loc, rhs, ptr, args);
 }
 
 /// Generates an invariant value.
 inline static Value genInvariantValue(Merger &merger, CodeGen &codegen,
                                       OpBuilder &builder, unsigned exp) {
   return merger.exp(exp).val;
if (atStart) {
     assert(res.getNumResults() == 4);
     assert(!codegen.expValues);
     codegen.expValues = res.getResult(0);
     codegen.expFilled = res.getResult(1);
     codegen.expAdded = res.getResult(2);
     codegen.expCount = res.getResult(3);
   } else {
     assert(codegen.expValues);
-    SmallVector<Value, 4> indices;
+    SmallVector<Value> indices;
     for (unsigned i = 0; i < at; i++) {
       assert(codegen.loopEmitter.getLoopIV(i));
       indices.push_back(codegen.loopEmitter.getLoopIV(i));
     }
     codegen.insChain = builder.create<CompressOp>(
         loc, codegen.expValues, codegen.expFilled, codegen.expAdded,
         codegen.expCount, codegen.insChain, indices);
     codegen.expValues = codegen.expFilled = codegen.expAdded =
static void finalizeWhileOp(Merger &merger, CodeGen &codegen,
                             unsigned idx, bool needsUniv, BitVector &induction,
                             scf::WhileOp whileOp) {
   Location loc = op.getLoc();
   // Finalize each else branch of all if statements.
   if (codegen.redVal || codegen.expValues || codegen.insChain) {
     while (auto ifOp = dyn_cast_or_null<scf::IfOp>(
                builder.getInsertionBlock()->getParentOp())) {
       unsigned y = 0;
-      SmallVector<Value, 4> yields;
+      SmallVector<Value> yields;
       if (codegen.redVal) {
         yields.push_back(codegen.redVal);
         updateReduc(merger, codegen, ifOp.getResult(y++));
       }
       if (codegen.expValues) {
         yields.push_back(codegen.expCount);
         codegen.expCount = ifOp->getResult(y++);
       }
static void finalizeWhileOp(Merger &merger, CodeGen &codegen,
   builder.setInsertionPointToEnd(&whileOp.getAfter().front());
 }
 
 /// Generates a single if-statement within a while-loop.
 static scf::IfOp genIf(Merger &merger, CodeGen &codegen, OpBuilder &builder,
                        linalg::GenericOp op, unsigned idx,
                        BitVector &conditions) {
   Location loc = op.getLoc();
-  SmallVector<Type, 4> types;
+  SmallVector<Type> types;
   Value cond;
   for (unsigned b = 0, be = conditions.size(); b < be; b++) {
     if (!conditions[b])
       continue;
     unsigned tensor = merger.tensor(b);
     assert(idx == merger.index(b));
     Value clause;
     if (isCompressedDLT(merger.getDimLevelType(b)) ||
static scf::IfOp genIf(Merger &merger, CodeGen &codegen, OpBuilder &builder,
   builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
   return ifOp;
 }
 
 /// Generates end of true branch of if-statement within a while-loop.
 static void endIf(Merger &merger, CodeGen &codegen, OpBuilder &builder,
                   linalg::GenericOp op, scf::IfOp ifOp, Operation *loop,
                   Value redInput, Value cntInput, Value insInput) {
-  SmallVector<Value, 4> operands;
+  SmallVector<Value> operands;
   if (codegen.redVal) {
     operands.push_back(codegen.redVal);
     updateReduc(merger, codegen, redInput);
   }
   if (codegen.expValues) {
     operands.push_back(codegen.expCount);
     codegen.expCount = cntInput;
   }
static void translateBitsToTidDimPairs(Merger &merger, CodeGen &codegen,
   }
 }
 
 /// Starts a single loop in current sequence.
 static Operation *startLoop(Merger &merger, CodeGen &codegen,
                             OpBuilder &builder, linalg::GenericOp op,
                             unsigned at, unsigned li, bool needsUniv) {
   // The set of tensors + dims to generate loops on
-  SmallVector<size_t, 4> condTids, condDims;
+  SmallVector<size_t> condTids, condDims;
   // The set of (dense) tensors that is optimized from condition, yet still
   // need extra locals to iterate on them.
-  SmallVector<size_t, 4> extraTids, extraDims;
+  SmallVector<size_t> extraTids, extraDims;
 
   translateBitsToTidDimPairs(merger, codegen, li, codegen.topSort[at], condTids,
                              condDims, extraTids, extraDims);
   // Emit the for/while-loop control.
   Operation *loop = genLoop(merger, codegen, builder, op, at, needsUniv,
                             condTids, condDims, extraTids, extraDims);
   return loop;
 }
if (hasCycle)
       // Give it one last shot to resolve the cycle.
       return resolveCycle(merger, rewriter, op);
     if (!isAdmissible)
       // Inadmissible expression, reject.
       return failure();
 
     merger.setHasSparseOut(sparseOut != nullptr);
 
-    SmallVector<Value, 4> tensors;
+    SmallVector<Value> tensors;
     for (OpOperand &t : op->getOpOperands())
       tensors.push_back(t.get());
 
     // Recursively generates code if admissible.
     CodeGen codegen(options, tensors, numTensors, numLoops, sparseOut,
                     outerParNest, topSort);
     genBuffers(merger, codegen, rewriter, op);
     genStmt(merger, codegen, rewriter, op, exp, 0);

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

unsigned Merger::addLat(unsigned t, unsigned i, unsigned e) {
   assert(t < numTensors && i < numLoops);
   unsigned p = latPoints.size();
   latPoints.push_back(LatPoint(numLoops * numTensors, e, numTensors * i + t));
   return p;
 }
 
 unsigned Merger::addSet() {
   unsigned s = latSets.size();
-  latSets.emplace_back(SmallVector<unsigned, 16>());
+  latSets.emplace_back();
   return s;
 }
 
 unsigned Merger::conjLatPoint(Kind kind, unsigned p0, unsigned p1,
                               Operation *op) {
   unsigned p = latPoints.size();
   BitVector nb = BitVector(latPoints[p0].bits);
   nb |= latPoints[p1].bits;