[mlir][sparse] remove redundant whitespace

[Peiming]

Sorry about this!

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

%0 = linalg.generic #trait_mat_op
             right={
               ^bb0(%y: f64):
                 sparse_tensor.yield %y : f64
             }
           linalg.yield %result : f64
       } -> tensor<4x4xf64, #DCSR>
     return %0 : tensor<4x4xf64, #DCSR>
   }
-  
   // Performs triangular add/sub operation (using semi-ring binary op).
   func.func @triangular(%A: tensor<4x4xf64, #DCSR>,
                         %B: tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> {
     %C = bufferization.alloc_tensor() : tensor<4x4xf64, #DCSR>
     %0 = linalg.generic #trait_mat_op
       ins(%A, %B: tensor<4x4xf64, #DCSR>,
                   tensor<4x4xf64, #DCSR>)
       outs(%C: tensor<4x4xf64, #DCSR>) {
module {
 
   // Perform sub operation (using semi-ring binary op) with a constant threshold.
   func.func @sub_with_thres(%A: tensor<4x4xf64, #DCSR>,
                             %B: tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> {
     %C = bufferization.alloc_tensor() : tensor<4x4xf64, #DCSR>
     // Defines out-block constant bounds.
     %thres_out_up = arith.constant 2.0 : f64
     %thres_out_lo = arith.constant -2.0 : f64
-    
     %0 = linalg.generic #trait_mat_op
       ins(%A, %B: tensor<4x4xf64, #DCSR>,
                   tensor<4x4xf64, #DCSR>)
       outs(%C: tensor<4x4xf64, #DCSR>) {
         ^bb0(%a: f64, %b: f64, %c: f64) :
           %result = sparse_tensor.binary %a, %b : f64, f64 to f64
             overlap={
               ^bb0(%x: f64, %y: f64):
%0 = linalg.generic #trait_mat_op
             }
             right={
               ^bb0(%y: f64):
                 %ny = arith.negf %y : f64
                 %cmp = arith.cmpf "oge", %ny, %thres_out_up : f64
                 %tmp = arith.select %cmp, %thres_out_up, %ny : f64
                 %cmp1 = arith.cmpf "ole", %tmp, %thres_out_lo : f64
                 %ret = arith.select %cmp1, %thres_out_lo, %tmp : f64
-                sparse_tensor.yield %ret : f64          
+                sparse_tensor.yield %ret : f64
             }
           linalg.yield %result : f64
       } -> tensor<4x4xf64, #DCSR>
     return %0 : tensor<4x4xf64, #DCSR>
   }
 
   // Performs isEqual only on intersecting elements.
   func.func @intersect_equal(%A: tensor<4x4xf64, #DCSR>,
%0 = linalg.generic #trait_mat_op
               ^bb0(%y: f64):
                 %ret = arith.negf %y : f64
                 sparse_tensor.yield %ret : f64
             }
           linalg.yield %result : f64
       } -> tensor<4x4xf64, #DCSR>
     return %0 : tensor<4x4xf64, #DCSR>
   }
-  
   //
   // Utility functions to dump the value of a tensor.
   //
 
   func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
module {
   func.func @dump_mat_4x4(%A: tensor<4x4xf64, #DCSR>) {
     %c0 = arith.constant 0 : index
     %du = arith.constant -1.0 : f64
 
     %c = sparse_tensor.convert %A : tensor<4x4xf64, #DCSR> to tensor<4x4xf64>
     %m = bufferization.to_memref %c : memref<4x4xf64>
     %v = vector.transfer_read %m[%c0, %c0], %du: memref<4x4xf64>, vector<4x4xf64>
     vector.print %v : vector<4x4xf64>
-    
     %1 = sparse_tensor.values %A : tensor<4x4xf64, #DCSR> to memref<?xf64>
     %2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<16xf64>
     vector.print %2 : vector<16xf64>
-    
     // Release the resources.
     memref.dealloc %m : memref<4x4xf64>
     return
   }
 
   func.func @dump_mat_4x4_i8(%A: tensor<4x4xi8, #DCSR>) {
     %c0 = arith.constant 0 : index
     %du = arith.constant -1 : i8
 
     %c = sparse_tensor.convert %A : tensor<4x4xi8, #DCSR> to tensor<4x4xi8>
     %m = bufferization.to_memref %c : memref<4x4xi8>
     %v = vector.transfer_read %m[%c0, %c0], %du: memref<4x4xi8>, vector<4x4xi8>
     vector.print %v : vector<4x4xi8>
-    
     %1 = sparse_tensor.values %A : tensor<4x4xi8, #DCSR> to memref<?xi8>
     %2 = vector.transfer_read %1[%c0], %du: memref<?xi8>, vector<16xi8>
     vector.print %2 : vector<16xi8>
-    
     // Release the resources.
     memref.dealloc %m : memref<4x4xi8>
     return
   }
-  
   // Driver method to call and verify kernels.
   func.func @entry() {
     %c0 = arith.constant 0 : index
 
     // Setup sparse vectors.
     %v1 = arith.constant sparse<
        [ [0], [3], [11], [17], [20], [21], [28], [29], [31] ],
          [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]
%3 = call @vector_index(%sv1)
        : (tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector>
 
     // Call sparse matrix kernels.
     %5 = call @matrix_intersect(%sm1, %sm2)
       : (tensor<?x?xf64, #DCSR>, tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR>
     %6 = call @add_tensor_1(%sm3, %sm4)
       : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
     %7 = call @add_tensor_2(%sm3, %sm4)
-      : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>    
+      : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
     %8 = call @triangular(%sm3, %sm4)
       : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
     %9 = call @sub_with_thres(%sm3, %sm4)
       : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
     %10 = call @intersect_equal(%sm3, %sm4)
       : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xi8, #DCSR>
     %11 = call @only_left_right(%sm3, %sm4)
       : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
func.func @entry() {
     call @dump_vec_i32(%3) : (tensor<?xi32, #SparseVector>) -> ()
     call @dump_mat(%5) : (tensor<?x?xf64, #DCSR>) -> ()
     call @dump_mat_4x4(%6) : (tensor<4x4xf64, #DCSR>) -> ()
     call @dump_mat_4x4(%7) : (tensor<4x4xf64, #DCSR>) -> ()
     call @dump_mat_4x4(%8) : (tensor<4x4xf64, #DCSR>) -> ()
     call @dump_mat_4x4(%9) : (tensor<4x4xf64, #DCSR>) -> ()
     call @dump_mat_4x4_i8(%10) : (tensor<4x4xi8, #DCSR>) -> ()
     call @dump_mat_4x4(%11) : (tensor<4x4xf64, #DCSR>) -> ()
-    
     // Release the resources.
     sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %sv2 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR>
     sparse_tensor.release %sm2 : tensor<?x?xf64, #DCSR>
     sparse_tensor.release %sm3 : tensor<4x4xf64, #DCSR>
     sparse_tensor.release %sm4 : tensor<4x4xf64, #DCSR>
     sparse_tensor.release %0 : tensor<?xf64, #SparseVector>

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

%0 = linalg.generic #trait_vec_scale
           %1 = sparse_tensor.unary %a : f64 to f64
             present={
               ^bb0(%x0: f64):
                 %tmp = arith.index_cast %idx : index to i64
                 %idxf = arith.uitofp %tmp : i64 to f64
                 %ret = arith.mulf %x0, %idxf : f64
                 sparse_tensor.yield %ret : f64
             }
-            absent={} 
+            absent={}
           linalg.yield %1 : f64
     } -> tensor<?xf64, #SparseVector>
     return %0 : tensor<?xf64, #SparseVector>
   }
 
   // Clips values to the range [3, 7].
   func.func @matrix_clip(%argx: tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> {
     %c0 = arith.constant 0 : index
%0 = linalg.generic #trait_mat_scale
                 %result = arith.select %cmp2, %v, %tmp : f64
                 sparse_tensor.yield %result : f64
             }
             absent={}
           linalg.yield %1 : f64
     } -> tensor<?x?xf64, #DCSR>
     return %0 : tensor<?x?xf64, #DCSR>
   }
-  
-
   // Dumps a sparse vector of type f64.
   func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
     // Dump the values array to verify only sparse contents are stored.
     %c0 = arith.constant 0 : index
     %d0 = arith.constant -1.0 : f64
     %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
     %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64>
     vector.print %1 : vector<32xf64>
func.func @entry() {
 
     // Call sparse vector kernels.
     %0 = call @vector_complement(%sv1)
        : (tensor<?xf64, #SparseVector>) -> tensor<?xi32, #SparseVector>
     %1 = call @vector_negation(%sv1)
        : (tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector>
     %2 = call @vector_magnify(%sv1)
        : (tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector>
-    
-
     // Call sparse matrix kernels.
     %3 = call @matrix_clip(%sm1)
       : (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR>
     %4 = call @matrix_slice(%sm1)
       : (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR>
 
     //
     // Verify the results.
func.func @entry() {
     // CHECK-NEXT: ( ( 99, 99, 0, 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0, 0, 0, 99 ), ( 0, 0, 99, 0, 5, 0, 0, 6 ), ( 99, 0, 99, 99, 0, 0, 0, 0 ) )
     //
     call @dump_vec_f64(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
     call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> ()
     call @dump_vec_f64(%1) : (tensor<?xf64, #SparseVector>) -> ()
     call @dump_vec_f64(%2) : (tensor<?xf64, #SparseVector>) -> ()
     call @dump_mat(%3) : (tensor<?x?xf64, #DCSR>) -> ()
     call @dump_mat(%4) : (tensor<?x?xf64, #DCSR>) -> ()
-    
     // Release the resources.
     sparse_tensor.release %sv1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %sm1 : tensor<?x?xf64, #DCSR>
     sparse_tensor.release %0 : tensor<?xi32, #SparseVector>
     sparse_tensor.release %1 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %2 : tensor<?xf64, #SparseVector>
     sparse_tensor.release %3 : tensor<?x?xf64, #DCSR>
     sparse_tensor.release %4 : tensor<?x?xf64, #DCSR>
     return
   }
 }