[mlir][sparse] Simplifying SparseTensorEncodingAttr function arguments

[wrengr]

Summary

Since STEA isa Attribute, and that's just (a wrapper around) a pointer, the extra const and & aren't necessary for function arguments.

[wrengr]

removed a few more &

[wrengr]

git-clang-format

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensor.h

 // Dimension level types.
 //
 
 // MSVC does not allow this function to be constexpr, because
 // `SparseTensorEncodingAttr::operator bool` isn't declared constexpr.
 // And therefore all functions calling it cannot be constexpr either.
 // TODO: since Clang does allow these to be constexpr, perhaps we should
 // define a macro to abstract over `inline` vs `constexpr` annotations.
-inline DimLevelType getDimLevelType(const SparseTensorEncodingAttr &enc,
-                                    uint64_t d) {
+inline DimLevelType getDimLevelType(SparseTensorEncodingAttr enc, uint64_t d) {
   if (enc) {
     auto types = enc.getDimLevelType();
     assert(d < types.size() && "Dimension out of bounds");
     return types[d];
   }
   return DimLevelType::Dense; // unannotated tensor is dense
 }
 

 inline bool isUniqueDim(RankedTensorType type, uint64_t d) {
   return isUniqueDLT(getDimLevelType(type, d));
 }
 
 //
 // Reordering.
 //
 
-uint64_t toOrigDim(const SparseTensorEncodingAttr &enc, uint64_t d);
-uint64_t toStoredDim(const SparseTensorEncodingAttr &enc, uint64_t d);
+uint64_t toOrigDim(SparseTensorEncodingAttr enc, uint64_t d);
+uint64_t toStoredDim(SparseTensorEncodingAttr enc, uint64_t d);
 
 /// Convenience method to translate the given stored dimension
 /// to the original dimension (0 <= d < rank).
 uint64_t toOrigDim(RankedTensorType type, uint64_t d);
 
 /// Convenience method to translate the given original dimension
 /// to the stored dimension (0 <= d < rank).
 uint64_t toStoredDim(RankedTensorType type, uint64_t d);
 
 } // namespace sparse_tensor
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSOR_H_

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

for (uint64_t i = 1, e = tp.getRank(); i < e; ++i)
     if (!isSingletonDim(tp, i))
       return false;
 
   // This works for rank == 1 (unique the only compressed) and rank > 1 (unique
   // on the last singleton).
   return isUniqueDim(tp, tp.getRank() - 1);
 }
 
-uint64_t mlir::sparse_tensor::toOrigDim(const SparseTensorEncodingAttr &enc,
+uint64_t mlir::sparse_tensor::toOrigDim(SparseTensorEncodingAttr enc,
                                         uint64_t d) {
   if (enc) {
     auto order = enc.getDimOrdering();
     if (order) {
       assert(order.isPermutation());
       return order.getDimPosition(d);
     }
   }
   return d;
 }
 
-uint64_t mlir::sparse_tensor::toStoredDim(const SparseTensorEncodingAttr &enc,
+uint64_t mlir::sparse_tensor::toStoredDim(SparseTensorEncodingAttr enc,
                                           uint64_t d) {
   if (enc) {
     auto order = enc.getDimOrdering();
     if (order) {
       assert(order.isPermutation());
       auto maybePos =
           order.getResultPosition(getAffineDimExpr(d, enc.getContext()));
       assert(maybePos.has_value());

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

 
 /// Converts an overhead storage type to its internal type-encoding.
 OverheadType overheadTypeEncoding(Type tp);
 
 /// Converts the internal type-encoding for overhead storage to an mlir::Type.
 Type getOverheadType(Builder &builder, OverheadType ot);
 
 /// Returns the OverheadType for pointer overhead storage.
-OverheadType pointerOverheadTypeEncoding(const SparseTensorEncodingAttr &enc);
+OverheadType pointerOverheadTypeEncoding(SparseTensorEncodingAttr enc);
 
 /// Returns the OverheadType for index overhead storage.
-OverheadType indexOverheadTypeEncoding(const SparseTensorEncodingAttr &enc);
+OverheadType indexOverheadTypeEncoding(SparseTensorEncodingAttr enc);
 
 /// Returns the mlir::Type for pointer overhead storage.
-Type getPointerOverheadType(Builder &builder,
-                            const SparseTensorEncodingAttr &enc);
+Type getPointerOverheadType(Builder &builder, SparseTensorEncodingAttr enc);
 
 /// Returns the mlir::Type for index overhead storage.
-Type getIndexOverheadType(Builder &builder,
-                          const SparseTensorEncodingAttr &enc);
+Type getIndexOverheadType(Builder &builder, SparseTensorEncodingAttr enc);
 
 /// Convert OverheadType to its function-name suffix.
 StringRef overheadTypeFunctionSuffix(OverheadType ot);
 
 /// Converts an overhead storage type to its function-name suffix.
 StringRef overheadTypeFunctionSuffix(Type overheadTp);
 
 /// Converts a primary storage type to its internal type-encoding.
inline Value constantOverheadTypeEncoding(OpBuilder &builder, Location loc,
                                           unsigned width) {
   return constantI32(builder, loc,
                      static_cast<uint32_t>(overheadTypeEncoding(width)));
 }
 
 /// Generates a constant of the internal type-encoding for pointer
 /// overhead storage.
 inline Value constantPointerTypeEncoding(OpBuilder &builder, Location loc,
-                                         const SparseTensorEncodingAttr &enc) {
+                                         SparseTensorEncodingAttr enc) {
   return constantOverheadTypeEncoding(builder, loc, enc.getPointerBitWidth());
 }
 
 /// Generates a constant of the internal type-encoding for index overhead
 /// storage.
 inline Value constantIndexTypeEncoding(OpBuilder &builder, Location loc,
-                                       const SparseTensorEncodingAttr &enc) {
+                                       SparseTensorEncodingAttr enc) {
   return constantOverheadTypeEncoding(builder, loc, enc.getIndexBitWidth());
 }
 
 /// Generates a constant of the internal type-encoding for primary storage.
 inline Value constantPrimaryTypeEncoding(OpBuilder &builder, Location loc,
                                          Type elemTp) {
   return constantI32(builder, loc,
                      static_cast<uint32_t>(primaryTypeEncoding(elemTp)));

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

Type mlir::sparse_tensor::getOverheadType(Builder &builder, OverheadType ot) {
   case OverheadType::kU16:
     return builder.getIntegerType(16);
   case OverheadType::kU8:
     return builder.getIntegerType(8);
   }
   llvm_unreachable("Unknown OverheadType");
 }
 
-OverheadType mlir::sparse_tensor::pointerOverheadTypeEncoding(
-    const SparseTensorEncodingAttr &enc) {
+OverheadType
+mlir::sparse_tensor::pointerOverheadTypeEncoding(SparseTensorEncodingAttr enc) {
   return overheadTypeEncoding(enc.getPointerBitWidth());
 }
 
-OverheadType mlir::sparse_tensor::indexOverheadTypeEncoding(
-    const SparseTensorEncodingAttr &enc) {
+OverheadType
+mlir::sparse_tensor::indexOverheadTypeEncoding(SparseTensorEncodingAttr enc) {
   return overheadTypeEncoding(enc.getIndexBitWidth());
 }
 
-Type mlir::sparse_tensor::getPointerOverheadType(
-    Builder &builder, const SparseTensorEncodingAttr &enc) {
+Type mlir::sparse_tensor::getPointerOverheadType(Builder &builder,
+                                                 SparseTensorEncodingAttr enc) {
   return getOverheadType(builder, pointerOverheadTypeEncoding(enc));
 }
 
-Type mlir::sparse_tensor::getIndexOverheadType(
-    Builder &builder, const SparseTensorEncodingAttr &enc) {
+Type mlir::sparse_tensor::getIndexOverheadType(Builder &builder,
+                                               SparseTensorEncodingAttr enc) {
   return getOverheadType(builder, indexOverheadTypeEncoding(enc));
 }
 
 // TODO: Adjust the naming convention for the constructors of
 // `OverheadType` so we can use the `MLIR_SPARSETENSOR_FOREVERY_O` x-macro
 // here instead of `MLIR_SPARSETENSOR_FOREVERY_FIXED_O`; to further reduce
 // the possibility of typo bugs or things getting out of sync.
 StringRef mlir::sparse_tensor::overheadTypeFunctionSuffix(OverheadType ot) {

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

static Value genDimSizeCall(OpBuilder &builder, Location loc, Value tensor,
   Type iTp = builder.getIndexType();
   return createFuncCall(builder, loc, name, iTp, params, EmitCInterface::Off)
       .getResult(0);
 }
 
 /// Looks up a level-size by returning a statically-computed constant
 /// (when possible), or by calling `genLvlSizeCall` (when dynamic).
 static Value createOrFoldLvlCall(OpBuilder &builder, Location loc,
-                                 SparseTensorEncodingAttr &enc, ShapedType stp,
+                                 SparseTensorEncodingAttr enc, ShapedType stp,
                                  Value tensor, unsigned lvl) {
   // Only sparse tensors have "levels" to query.
   assert(enc);
   auto dimOrder = enc.getDimOrdering();
   // TODO: The following implementation only handles permutations;
   // we'll need to generalize this to handle arbitrary AffineExpr.
   //
   // There's no need to assert `isPermutation` here: because
static Value createOrFoldLvlCall(OpBuilder &builder, Location loc,
   return genLvlSizeCall(builder, loc, tensor, lvl);
 }
 
 /// Looks up a dimension-size by returning a constant from the shape
 /// (for static sizes), or by calling `genDimSizeCall` (for dynamic sizes
 /// of sparse tensors) or `linalg::createOrFoldDimOp` (for dynamic sizes
 /// of dense tensors).
 static Value createOrFoldDimCall(OpBuilder &builder, Location loc,
-                                 SparseTensorEncodingAttr &enc, ShapedType stp,
+                                 SparseTensorEncodingAttr enc, ShapedType stp,
                                  Value tensor, unsigned dim) {
   auto s = stp.getShape()[dim];
   if (s != ShapedType::kDynamic)
     return constantIndex(builder, loc, s);
   if (enc)
     return genDimSizeCall(builder, loc, tensor, dim);
   return linalg::createOrFoldDimOp(builder, loc, tensor, dim);
 }
 
 /// Populates the array with the dimension-sizes of the given tensor.
 static void fillDimSizes(OpBuilder &builder, Location loc,
-                         SparseTensorEncodingAttr &enc, ShapedType stp,
+                         SparseTensorEncodingAttr enc, ShapedType stp,
                          Value tensor, SmallVectorImpl<Value> &out) {
   unsigned dimRank = stp.getRank();
   out.reserve(dimRank);
   for (unsigned d = 0; d < dimRank; d++)
     out.push_back(createOrFoldDimCall(builder, loc, enc, stp, tensor, d));
 }
 
 /// Returns an array with the dimension-sizes of the given tensor.
 static SmallVector<Value> getDimSizes(OpBuilder &builder, Location loc,
-                                      SparseTensorEncodingAttr &enc,
+                                      SparseTensorEncodingAttr enc,
                                       ShapedType stp, Value tensor) {
   SmallVector<Value> out;
   fillDimSizes(builder, loc, enc, stp, tensor, out);
   return out;
 }
 
 /// Populates the array with the dimension-shape of the given `ShapedType`,
 /// where dynamic sizes are represented by zero.