[mlir][sparse] fix two typos

[aartbik]

Summary

(1) copy-and-past error in encoding alias name:

this is an annotation for a tensor (3-d) not a matrix (2-d).

(2) typo in "initialization"

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

string description = [{
     for example, phase counter [Gustavson72], expanded or switch array
     [Pissanetzky84], in phase scan [Duff90], access pattern expansion [Bik96],
     and workspaces [Kjolstad19].
 
     The values and filled array have sizes that suffice for a *dense* innermost
     dimension (e.g. a full row for matrices). The added array and count are used
     to store new indices when a false value is encountered in the filled array.
     All arrays should be allocated before the loop (possibly even shared between
-    loops in a future optimization) so that their *dense* intitialization can be
+    loops in a future optimization) so that their *dense* initialization can be
     amortized over many iterations. Setting and resetting the dense arrays in
     the loop nest itself is kept *sparse* by only iterating over set elements
     through an indirection using the added array, so that the operations are
     kept proportional to the number of nonzeros.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.

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

 // RUN: TENSOR0="%mlir_integration_test_dir/data/mttkrp_b.tns" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 !Filename = type !llvm.ptr<i8>
 
-#SparseMatrix = #sparse_tensor.encoding<{
+#SparseTensor = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed", "compressed" ]
 }>
 
 #mttkrp = {
   indexing_maps = [
     affine_map<(i,j,k,l) -> (i,k,l)>, // B
     affine_map<(i,j,k,l) -> (k,j)>,   // C
     affine_map<(i,j,k,l) -> (l,j)>,   // D
     affine_map<(i,j,k,l) -> (i,j)>    // A (out)
   ],
   iterator_types = ["parallel", "parallel", "reduction", "reduction"],
   doc = "A(i,j) += B(i,k,l) * D(l,j) * C(k,j)"
 }
 
 //
 // Integration test that lowers a kernel annotated as sparse to
 // actual sparse code, initializes a matching sparse storage scheme
 // from file, and runs the resulting code with the JIT compiler.
 //
 module {
   //
   // Computes Matricized Tensor Times Khatri-Rao Product (MTTKRP) kernel. See
   // http://tensor-compiler.org/docs/data_analytics/index.html.
   //
-  func @kernel_mttkrp(%argb: tensor<?x?x?xf64, #SparseMatrix>,
+  func @kernel_mttkrp(%argb: tensor<?x?x?xf64, #SparseTensor>,
                       %argc: tensor<?x?xf64>,
                       %argd: tensor<?x?xf64>,
                       %arga: tensor<?x?xf64> {linalg.inplaceable = true})
           -> tensor<?x?xf64> {
     %0 = linalg.generic #mttkrp
       ins(%argb, %argc, %argd:
-            tensor<?x?x?xf64, #SparseMatrix>, tensor<?x?xf64>, tensor<?x?xf64>)
+            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
         linalg.yield %2 : f64
     } -> tensor<?x?xf64>
     return %0 : tensor<?x?xf64>
func @entry() {
     %c3 = arith.constant 3 : index
     %c4 = arith.constant 4 : index
     %c5 = arith.constant 5 : index
     %c256 = arith.constant 256 : index
 
     // Read the sparse B input from a file.
     %fileName = call @getTensorFilename(%c0) : (index) -> (!Filename)
     %b = sparse_tensor.new %fileName
-          : !Filename to tensor<?x?x?xf64, #SparseMatrix>
+          : !Filename to tensor<?x?x?xf64, #SparseTensor>
 
     // Initialize dense C and D inputs and dense output A.
     %cdata = memref.alloc(%c3, %c5) : memref<?x?xf64>
     scf.for %i = %c0 to %c3 step %c1 {
       scf.for %j = %c0 to %c5 step %c1 {
         %k0 = arith.muli %i, %c5 : index
         %k1 = arith.addi %k0, %j : index
         %k2 = arith.index_cast %k1 : index to i32
scf.for %i = %c0 to %c2 step %c1 {
       scf.for %j = %c0 to %c5 step %c1 {
         memref.store %i0, %adata[%i, %j] : memref<?x?xf64>
       }
     }
     %a = bufferization.to_tensor %adata : memref<?x?xf64>
 
     // Call kernel.
     %0 = call @kernel_mttkrp(%b, %c, %d, %a)
-      : (tensor<?x?x?xf64, #SparseMatrix>,
+      : (tensor<?x?x?xf64, #SparseTensor>,
         tensor<?x?xf64>, tensor<?x?xf64>, tensor<?x?xf64>) -> tensor<?x?xf64>
 
     // Print the result for verification.
     //
     // CHECK: ( ( 16075, 21930, 28505, 35800, 43815 ),
     // CHECK:   ( 10000, 14225, 19180, 24865, 31280 ) )
     //
     %m = bufferization.to_memref %0 : memref<?x?xf64>
     %v = vector.transfer_read %m[%c0, %c0], %i0
           : memref<?x?xf64>, vector<2x5xf64>
     vector.print %v : vector<2x5xf64>
 
     // Release the resources.
     memref.dealloc %adata : memref<?x?xf64>
     memref.dealloc %cdata : memref<?x?xf64>
     memref.dealloc %ddata : memref<?x?xf64>
-    sparse_tensor.release %b : tensor<?x?x?xf64, #SparseMatrix>
+    sparse_tensor.release %b : tensor<?x?x?xf64, #SparseTensor>
 
     return
   }
 }