[mlir][sparse] use typenames for opaque pointers

[aartbik]

Summary

Makes intent more readable

[bixia]

mlir/integration_test/Sparse/CPU/frostt-example.mlir

21–25

I can tell that the new order of these declarations is the same as the order the routines are used. Is this a guideline for ordering declarations?
How about Alphabetical order?

[aartbik]

mlir/integration_test/Sparse/CPU/frostt-example.mlir

21–25

I don't think we have a fixed order (although usually alphabetical works).
Here I indeed thought it was a good idea to order this in the order used.

mlir/integration_test/Sparse/CPU/frostt-example.mlir

 // RUN: mlir-opt %s \
 // RUN:  -convert-scf-to-std -convert-vector-to-scf \
 // RUN:  -convert-linalg-to-llvm -convert-vector-to-llvm | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.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
 
+//
+// Use descriptive names for opaque pointers.
+//
+!Filename = type !llvm.ptr<i8>
+!Tensor   = type !llvm.ptr<i8>
+
 module {
   //
   // Example of using the sparse runtime support library to read a sparse tensor
   // in the FROSTT file format (http://frostt.io/tensors/file-formats.html).
   //
-  func private @openTensor(!llvm.ptr<i8>, memref<?xindex>) -> (!llvm.ptr<i8>)
-  func private @readTensorItem(!llvm.ptr<i8>, memref<?xindex>, memref<?xf64>) -> ()
-  func private @closeTensor(!llvm.ptr<i8>) -> ()
-  func private @getTensorFilename(index) -> (!llvm.ptr<i8>)
+  func private @getTensorFilename(index) -> (!Filename)
+  func private @openTensor(!Filename, memref<?xindex>) -> (!Tensor)
+  func private @readTensorItem(!Tensor, memref<?xindex>, memref<?xf64>) -> ()
+  func private @closeTensor(!Tensor) -> ()
 
   func @entry() {
     %d0  = constant 0.0 : f64
     %i0  = constant 0   : i64
     %c0  = constant 0   : index
     %c1  = constant 1   : index
     %c2  = constant 2   : index
     %c10 = constant 10  : index
 
     //
     // Setup memrefs to get meta data, indices and values.
     // The index array should provide sufficient space.
     //
     %idata = alloc(%c10) : memref<?xindex>
     %ddata = alloc(%c1)  : memref<?xf64>
 
     //
     // Obtain the sparse tensor filename through this test helper.
     //
-    %fileName = call @getTensorFilename(%c0) : (index) -> (!llvm.ptr<i8>)
+    %fileName = call @getTensorFilename(%c0) : (index) -> (!Filename)
 
     //
     // Read a sparse tensor. The call yields a pointer to an opaque
     // memory-resident sparse tensor object that is only understood by
     // other methods in the sparse runtime support library. This call also
     // provides the rank and the number of nonzero elements (nnz) through
     // a memref array.
     //
-    %tensor = call @openTensor(%fileName, %idata)
-      : (!llvm.ptr<i8>, memref<?xindex>) -> (!llvm.ptr<i8>)
+    %tensor = call @openTensor(%fileName, %idata) : (!Filename, memref<?xindex>) -> (!Tensor)
 
     //
     // Print some meta data.
     //
     %rank = load %idata[%c0] : memref<?xindex>
     %nnz  = load %idata[%c1] : memref<?xindex>
     vector.print %rank : index
     vector.print %nnz  : index
     scf.for %r = %c2 to %c10 step %c1 {
       %d = load %idata[%r] : memref<?xindex>
       vector.print %d : index
     }
 
     //
     // Now we are ready to read in the nonzero elements of the sparse tensor
     // and insert these into a sparse storage scheme. In this example, we
     // simply print the elements on the fly.
     //
     scf.for %k = %c0 to %nnz step %c1 {
-      call @readTensorItem(%tensor, %idata, %ddata)
-        : (!llvm.ptr<i8>, memref<?xindex>, memref<?xf64>) -> ()
+      call @readTensorItem(%tensor, %idata, %ddata) : (!Tensor, memref<?xindex>, memref<?xf64>) -> ()
       //
       // Build index vector and print element (here, using the
       // knowledge that the read sparse tensor has rank 8).
       //
       %0 = vector.broadcast %i0 : i64 to vector<8xi64>
       %1 = scf.for %r = %c0 to %rank step %c1 iter_args(%in = %0) -> vector<8xi64> {
         %i  = load %idata[%r] : memref<?xindex>
         %ii = index_cast %i : index to i64
         %ri = index_cast %r : index to i32
         %out = vector.insertelement %ii, %in[%ri : i32] : vector<8xi64>
         scf.yield %out : vector<8xi64>
       }
       %2 = load %ddata[%c0] : memref<?xf64>
       vector.print %1 : vector<8xi64>
       vector.print %2 : f64
     }
 
     //
     // Since at this point we have processed the contents, make sure to
     // close the sparse tensor to release its memory resources.
     //
-    call @closeTensor(%tensor) : (!llvm.ptr<i8>) -> ()
+    call @closeTensor(%tensor) : (!Tensor) -> ()
 
     //
     // Verify that the results are as expected.
     //
     // CHECK: 8
     // CHECK: 16
     // CHECK: 7
     // CHECK: 3

mlir/integration_test/Sparse/CPU/matrix-market-example.mlir

 // RUN: mlir-opt %s \
 // RUN:  -convert-scf-to-std -convert-vector-to-scf \
 // RUN:  -convert-linalg-to-llvm -convert-vector-to-llvm | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
 // 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
 
+//
+// Use descriptive names for opaque pointers.
+//
+!Filename = type !llvm.ptr<i8>
+!Tensor   = type !llvm.ptr<i8>
+
 module {
   //
   // Example of using the sparse runtime support library to read a sparse matrix
   // in the Matrix Market Exchange Format (https://math.nist.gov/MatrixMarket).
   //
-  func private @openTensor(!llvm.ptr<i8>, memref<?xindex>) -> (!llvm.ptr<i8>)
-  func private @readTensorItem(!llvm.ptr<i8>, memref<?xindex>, memref<?xf64>) -> ()
-  func private @closeTensor(!llvm.ptr<i8>) -> ()
-  func private @getTensorFilename(index) -> (!llvm.ptr<i8>)
+  func private @getTensorFilename(index) -> (!Filename)
+  func private @openTensor(!Filename, memref<?xindex>) -> (!Tensor)
+  func private @readTensorItem(!Tensor, memref<?xindex>, memref<?xf64>) -> ()
+  func private @closeTensor(!Tensor) -> ()
 
   func @entry() {
     %d0  = constant 0.0 : f64
     %c0  = constant 0 : index
     %c1  = constant 1 : index
     %c2  = constant 2 : index
     %c3  = constant 3 : index
     %c4  = constant 4 : index
     %c5  = constant 5 : index
 
     //
     // Setup memrefs to get meta data, indices, and values.
     //
     %idata = alloc(%c4) : memref<?xindex>
     %ddata = alloc(%c1) : memref<?xf64>
 
     //
     // Obtain the sparse matrix filename through this test helper.
     //
-    %fileName = call @getTensorFilename(%c0) : (index) -> (!llvm.ptr<i8>)
+    %fileName = call @getTensorFilename(%c0) : (index) -> (!Filename)
 
     //
     // Read a sparse matrix. The call yields a pointer to an opaque
     // memory-resident sparse tensor object that is only understood by
     // other methods in the sparse runtime support library. This call also
     // provides the rank (always 2 for the Matrix Market), number of
     // nonzero elements (nnz), and the size (m x n) through a memref array.
     //
-    %tensor = call @openTensor(%fileName, %idata)
-      : (!llvm.ptr<i8>, memref<?xindex>) -> (!llvm.ptr<i8>)
+    %tensor = call @openTensor(%fileName, %idata) : (!Filename, memref<?xindex>) -> (!Tensor)
     %rank = load %idata[%c0] : memref<?xindex>
     %nnz  = load %idata[%c1] : memref<?xindex>
     %m    = load %idata[%c2] : memref<?xindex>
     %n    = load %idata[%c3] : memref<?xindex>
 
     //
     // At this point, code should prepare a proper sparse storage scheme for
     // an m x n matrix with nnz nonzero elements. For simplicity, here we
     // simply intialize a dense m x n matrix to all zeroes.
     //
     %a = alloc(%m, %n) : memref<?x?xf64>
     scf.for %ii = %c0 to %m step %c1 {
       scf.for %jj = %c0 to %n step %c1 {
         store %d0, %a[%ii, %jj] : memref<?x?xf64>
       }
     }
 
     //
     // Now we are ready to read in nnz nonzero elements of the sparse matrix
     // and insert these into a sparse storage scheme. In this example, we
     // simply insert them in the dense matrix.
     //
     scf.for %k = %c0 to %nnz step %c1 {
-      call @readTensorItem(%tensor, %idata, %ddata)
-        : (!llvm.ptr<i8>, memref<?xindex>, memref<?xf64>) -> ()
+      call @readTensorItem(%tensor, %idata, %ddata) : (!Tensor, memref<?xindex>, memref<?xf64>) -> ()
       %i = load %idata[%c0] : memref<?xindex>
       %j = load %idata[%c1] : memref<?xindex>
       %d = load %ddata[%c0] : memref<?xf64>
       store %d, %a[%i, %j] : memref<?x?xf64>
     }
 
     //
     // Since at this point we have copied the sparse matrix to our own
     // storage scheme, make sure to close the matrix to release its
     // memory resources.
     //
-    call @closeTensor(%tensor) : (!llvm.ptr<i8>) -> ()
+    call @closeTensor(%tensor) : (!Tensor) -> ()
 
     //
     // Verify that the results are as expected.
     //
     %A = vector.transfer_read %a[%c0, %c0], %d0 : memref<?x?xf64>, vector<5x5xf64>
     vector.print %rank : index
     vector.print %nnz  : index
     vector.print %m    : index