[mlir][sparse] performs a tab cleanup (NFC)

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 
 def SparseTensor_CompressOp : SparseTensor_Op<"compress",
     [AllTypesMatch<["tensor", "result"]>]>,
     Arguments<(ins AnyStridedMemRefOfRank<1>:$values,
                    StridedMemRefRankOf<[I1],[1]>:$filled,
                    StridedMemRefRankOf<[Index],[1]>:$added,
                    Index:$count,
                    AnySparseTensor:$tensor,
-       Variadic<Index>:$indices)>,
+                   Variadic<Index>:$indices)>,
     Results<(outs AnySparseTensor:$result)> {
   string summary = "Compressed an access pattern for insertion";
   string description = [{
     Finishes a single access pattern expansion by moving inserted elements
     into the sparse storage scheme of the given tensor with the given
     indices. The arity of indices is one less than the rank of the tensor,
     with the remainder innermost indices defined through the added array.
     The values and filled array are reset in a *sparse* fashion by only
string description = [{
 
     ```mlir
     %result = sparse_tensor.compress %values, %filled, %added, %count into %tensor[%i]
       : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<4x4xf64, #CSR>
     ```
   }];
   let assemblyFormat = "$values `,` $filled `,` $added `,` $count"
                        " `into` $tensor `[` $indices `]` attr-dict"
-           " `:` type($values) `,` type($filled) `,` type($added)"
-           " `,` type($tensor)";
+                       " `:` type($values) `,` type($filled) `,` type($added)"
+                       " `,` type($tensor)";
   let hasVerifier = 1;
 }
 
 def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
     Arguments<(ins AnySparseTensor:$tensor, UnitAttr:$hasInserts)>,
     Results<(outs AnyTensor:$result)> {
   let summary =
     "Rematerializes tensor from underlying sparse storage format";

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_abs.mlir

%v1 = arith.constant sparse<
            0xFFF0000000000000, // -Inf
            -0.0,               // -Zero
            0.0                 // +Zero
         ]
     > : tensor<32xf64>
     %v2 = arith.constant sparse<
        [ [0], [3], [5], [11], [13], [17], [18], [21], [31] ],
          [ -2147483648, -2147483647, -1000, -1, 0,
-     1, 1000, 2147483646, 2147483647
-   ]
+           1, 1000, 2147483646, 2147483647
+         ]
     > : tensor<32xi32>
     %sv1 = sparse_tensor.convert %v1
          : tensor<32xf64> to tensor<?xf64, #SparseVector>
     %sv2 = sparse_tensor.convert %v2
          : tensor<32xi32> to tensor<?xi32, #SparseVector>
 
     // Call abs kernels.
     %0 = call @sparse_absf(%sv1) : (tensor<?xf64, #SparseVector>)

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_flatten.mlir

 // from file, and runs the resulting code with the JIT compiler.
 //
 module {
   //
   // A kernel that flattens a rank 8 tensor into a dense matrix.
   //
   func.func @kernel_flatten(%arga: tensor<7x3x3x3x3x3x5x3xf64, #SparseTensor>,
                             %argx: tensor<7x3xf64>)
-           -> tensor<7x3xf64> {
+                                -> tensor<7x3xf64> {
     %0 = linalg.generic #trait_flatten
       ins(%arga: tensor<7x3x3x3x3x3x5x3xf64, #SparseTensor>)
       outs(%argx: tensor<7x3xf64>) {
       ^bb(%a: f64, %x: f64):
         %0 = arith.addf %x, %a : f64
         linalg.yield %0 : f64
     } -> tensor<7x3xf64>
     return %0 : tensor<7x3xf64>

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matvec.mlir

 module {
   //
   // A kernel that multiplies a sparse matrix A with a dense vector b
   // into a dense vector x.
   //
   func.func @kernel_matvec(%arga: tensor<?x?xi32, #SparseMatrix>,
                            %argb: tensor<?xi32>,
                            %argx: tensor<?xi32>)
-          -> tensor<?xi32> {
+                               -> tensor<?xi32> {
     %0 = linalg.generic #matvec
       ins(%arga, %argb: tensor<?x?xi32, #SparseMatrix>, tensor<?xi32>)
       outs(%argx: tensor<?xi32>) {
       ^bb(%a: i32, %b: i32, %x: i32):
         %0 = arith.muli %a, %b : i32
         %1 = arith.addi %x, %0 : i32
         linalg.yield %1 : i32
     } -> tensor<?xi32>

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_mttkrp.mlir

module {
   //
   // Computes Matricized Tensor Times Khatri-Rao Product (MTTKRP) kernel. See
   // http://tensor-compiler.org/docs/data_analytics/index.html.
   //
   func.func @kernel_mttkrp(%argb: tensor<?x?x?xf64, #SparseTensor>,
                            %argc: tensor<?x?xf64>,
                            %argd: tensor<?x?xf64>,
                            %arga: tensor<?x?xf64>)
-          -> tensor<?x?xf64> {
+                               -> tensor<?x?xf64> {
     %0 = linalg.generic #mttkrp
       ins(%argb, %argc, %argd:
             tensor<?x?x?xf64, #SparseTensor>, tensor<?x?xf64>, tensor<?x?xf64>)
       outs(%arga: tensor<?x?xf64>) {
       ^bb(%b: f64, %c: f64, %d: f64, %a: f64):
         %0 = arith.mulf %b, %c : f64
         %1 = arith.mulf %d, %0 : f64
         %2 = arith.addf %a, %1 : f64

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_out_reduction.mlir

#redsum = {
   ],
   iterator_types = ["parallel", "parallel", "reduction"],
   doc = "X(i,j) = SUM_k A(i,j,k) * B(i,j,k)"
 }
 
 module {
   func.func @redsum(%arga: tensor<?x?x?xi32, #SparseTensor>,
                %argb: tensor<?x?x?xi32, #SparseTensor>)
-             -> tensor<?x?xi32, #SparseMatrix> {
+                   -> tensor<?x?xi32, #SparseMatrix> {
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %d0 = tensor.dim %arga, %c0 : tensor<?x?x?xi32, #SparseTensor>
     %d1 = tensor.dim %arga, %c1 : tensor<?x?x?xi32, #SparseTensor>
     %xinit = bufferization.alloc_tensor(%d0, %d1): tensor<?x?xi32, #SparseMatrix>
     %0 = linalg.generic #redsum
       ins(%arga, %argb: tensor<?x?x?xi32, #SparseTensor>,
                         tensor<?x?x?xi32, #SparseTensor>)

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_quantized_matmul.mlir

func.func @entry() {
 
     %sparse_input2 = sparse_tensor.convert %input2 : tensor<3x6xi8> to tensor<3x6xi8, #DCSR>
 
     // Call the kernel.
     %output = arith.constant dense<0> : tensor<5x6xi32>
     %0 = call @quantized_matmul(%input1, %sparse_input2, %output)
        : (tensor<5x3xi8>,
           tensor<3x6xi8, #DCSR>,
-    tensor<5x6xi32>) -> tensor<5x6xi32>
+          tensor<5x6xi32>) -> tensor<5x6xi32>
 
     //
     // Verify the output.
     //
     // CHECK:    ( ( -16510, 0, 16640, 12500, 1250, -390 ),
     // CHECK-SAME: ( -254, 0, 256, -200, -20, -6 ),
     // CHECK-SAME: ( 1143, 0, -1152, -200, -20, 27 ),
     // CHECK-SAME: ( -254, 0, 256, -300, -30, -6 ),