[mlir][sparse] Replace pass-by-value with pass-by-memref for C interface routines to fix Windows build.

[wrengr]

mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp

634–635

Be sure to add vref to the non-null assertion at the beginning of the function

679–680

be sure to add vref to the non-null assertion at the beginning of the function.

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

67–68

Since the %v is just going to be stored here anyways, I wonder if there isn't some way to pass %vs[%i] directly to @getSparseTensorReaderNextF32 to avoid needing to allocate %value and then load %v.

[bixia]

Add assert for the value memref. Add a TODO to investigate the posibility of using memref.subview for the test.

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

67–68

Add a TODO to explore this.

mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h

MLIR_CRUNNERUTILS_EXPORT void _mlir_ciface_getSparseTensorReaderDimSizes(
     void *p, StridedMemRefType<index_type, 1> *dref);
 
 /// Releases the SparseTensorReader. This also closes the file associated with
 /// the reader.
 MLIR_CRUNNERUTILS_EXPORT void delSparseTensorReader(void *p);
 
 /// Returns the next element for the sparse tensor being read.
 #define IMPL_GETNEXT(VNAME, V)                                                 \
-  MLIR_CRUNNERUTILS_EXPORT V _mlir_ciface_getSparseTensorReaderNext##VNAME(    \
-      void *p, StridedMemRefType<index_type, 1> *iref);
+  MLIR_CRUNNERUTILS_EXPORT void _mlir_ciface_getSparseTensorReaderNext##VNAME( \
+      void *p, StridedMemRefType<index_type, 1> *iref,                         \
+      StridedMemRefType<V, 0> *vref);
 MLIR_SPARSETENSOR_FOREVERY_V(IMPL_GETNEXT)
 #undef IMPL_GETNEXT
 
 using SparseTensorWriter = std::ostream;
 
 /// Creates a SparseTensorWriter for outputing a sparse tensor to a file with
 /// the given file name. When the file name is empty, std::cout is used.
 //
 // Only the extended FROSTT format is supported currently.
 MLIR_CRUNNERUTILS_EXPORT void *createSparseTensorWriter(char *filename);
 
 /// Finalizes the outputing of a sparse tensor to a file and releases the
 /// SparseTensorWriter.
 MLIR_CRUNNERUTILS_EXPORT void delSparseTensorWriter(void *p);
 
 /// Outputs the sparse tensor rank, nnz and shape.
 MLIR_CRUNNERUTILS_EXPORT void _mlir_ciface_outSparseTensorWriterMetaData(
     void *p, index_type rank, index_type nnz,
     StridedMemRefType<index_type, 1> *dref);
 
 /// Outputs an element for the sparse tensor.
 #define IMPL_OUTNEXT(VNAME, V)                                                 \
   MLIR_CRUNNERUTILS_EXPORT void _mlir_ciface_outSparseTensorWriterNext##VNAME( \
       void *p, index_type rank, StridedMemRefType<index_type, 1> *iref,        \
-      V value);
+      StridedMemRefType<V, 0> *vref);
 MLIR_SPARSETENSOR_FOREVERY_V(IMPL_OUTNEXT)
 #undef IMPL_OUTNEXT
 
 } // extern "C"
 
 #endif // MLIR_EXECUTIONENGINE_SPARSETENSORRUNTIME_H

mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp

for (uint64_t r = 0; r < rank; ++r)
     dimSizes[r] = sizes[r];
 }
 
 void delSparseTensorReader(void *p) {
   delete static_cast<SparseTensorReader *>(p);
 }
 
 #define IMPL_GETNEXT(VNAME, V)                                                 \
-  V _mlir_ciface_getSparseTensorReaderNext##VNAME(                             \
-      void *p, StridedMemRefType<index_type, 1> *iref) {                       \
-    assert(p &&iref);                                                          \
+  void _mlir_ciface_getSparseTensorReaderNext##VNAME(                          \
+      void *p, StridedMemRefType<index_type, 1> *iref,                         \
+      StridedMemRefType<V, 0> *vref) {                                         \
+    assert(p &&iref &&vref);                                                   \
     assert(iref->strides[0] == 1);                                             \
     index_type *indices = iref->data + iref->offset;                           \
     SparseTensorReader *stfile = static_cast<SparseTensorReader *>(p);         \
     index_type rank = stfile->getRank();                                       \
     char *linePtr = stfile->readLine();                                        \
     for (index_type r = 0; r < rank; ++r) {                                    \
       uint64_t idx = strtoul(linePtr, &linePtr, 10);                           \
       indices[r] = idx - 1;                                                    \
     }                                                                          \
-    return detail::readCOOValue<V>(&linePtr, stfile->isPattern());             \
+    V *value = vref->data + vref->offset;                                      \
+    *value = detail::readCOOValue<V>(&linePtr, stfile->isPattern());           \
   }
 MLIR_SPARSETENSOR_FOREVERY_V(IMPL_GETNEXT)
 #undef IMPL_GETNEXT
 
 void *createSparseTensorWriter(char *filename) {
   SparseTensorWriter *file =
       (filename[0] == 0) ? &std::cout : new std::ofstream(filename);
   *file << "# extended FROSTT format\n";
void _mlir_ciface_outSparseTensorWriterMetaData(
   for (index_type r = 0; r < rank - 1; ++r)
     file << dimSizes[r] << " ";
   file << dimSizes[rank - 1] << std::endl;
 }
 
 #define IMPL_OUTNEXT(VNAME, V)                                                 \
   void _mlir_ciface_outSparseTensorWriterNext##VNAME(                          \
       void *p, index_type rank, StridedMemRefType<index_type, 1> *iref,        \
-      V value) {                                                               \
-    assert(p &&iref);                                                          \
+      StridedMemRefType<V, 0> *vref) {                                         \
+    assert(p &&iref &&vref);                                                   \
     assert(iref->strides[0] == 1);                                             \
     index_type *indices = iref->data + iref->offset;                           \
     SparseTensorWriter &file = *static_cast<SparseTensorWriter *>(p);          \
     for (uint64_t r = 0; r < rank; ++r)                                        \
       file << (indices[r] + 1) << " ";                                         \
-    file << value << std::endl;                                                \
+    V *value = vref->data + vref->offset;                                      \
+    file << *value << std::endl;                                               \
   }
 MLIR_SPARSETENSOR_FOREVERY_V(IMPL_OUTNEXT)
 #undef IMPL_OUTNEXT
 
 } // extern "C"
 
 #endif // MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS

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

module {
 
   func.func private @getTensorFilename(index) -> (!Filename)
 
   func.func private @createSparseTensorReader(!Filename) -> (!TensorReader)
   func.func private @delSparseTensorReader(!TensorReader) -> ()
   func.func private @getSparseTensorReaderRank(!TensorReader) -> (index)
   func.func private @getSparseTensorReaderNNZ(!TensorReader) -> (index)
   func.func private @getSparseTensorReaderIsSymmetric(!TensorReader) -> (i1)
-  func.func private @getSparseTensorReaderDimSizes(!TensorReader, memref<?xindex>)
-    -> () attributes { llvm.emit_c_interface }
-  func.func private @getSparseTensorReaderNextF32(!TensorReader, memref<?xindex>)
-    -> (f32) attributes { llvm.emit_c_interface }
+  func.func private @getSparseTensorReaderDimSizes(!TensorReader,
+    memref<?xindex>) -> () attributes { llvm.emit_c_interface }
+  func.func private @getSparseTensorReaderNextF32(!TensorReader,
+    memref<?xindex>, memref<f32>) -> () attributes { llvm.emit_c_interface }
 
   func.func private @createSparseTensorWriter(!Filename) -> (!TensorWriter)
   func.func private @delSparseTensorWriter(!TensorWriter)
   func.func private @outSparseTensorWriterMetaData(!TensorWriter, index, index,
     memref<?xindex>) -> () attributes { llvm.emit_c_interface }
   func.func private @outSparseTensorWriterNextF32(!TensorWriter, index,
-    memref<?xindex>, f32) -> () attributes { llvm.emit_c_interface }
+    memref<?xindex>, memref<f32>) -> () attributes { llvm.emit_c_interface }
 
   func.func @dumpi(%arg0: memref<?xindex>) {
     %c0 = arith.constant 0 : index
     %v = vector.transfer_read %arg0[%c0], %c0: memref<?xindex>, vector<17xindex>
     vector.print %v : vector<17xindex>
     return
   }
 
func.func @readTensorFile(%tensor: !TensorReader)
     %rank = call @getSparseTensorReaderRank(%tensor) : (!TensorReader) -> index
     %nnz = call @getSparseTensorReaderNNZ(%tensor) : (!TensorReader) -> index
 
     // Assume rank == 2.
     %x0s = memref.alloc(%nnz) : memref<?xindex>
     %x1s = memref.alloc(%nnz) : memref<?xindex>
     %vs = memref.alloc(%nnz) : memref<?xf32>
     %indices = memref.alloc(%rank) : memref<?xindex>
+    %value = memref.alloca() : memref<f32>
     scf.for %i = %c0 to %nnz step %c1 {
-      %v = func.call @getSparseTensorReaderNextF32(%tensor, %indices)
-        : (!TensorReader, memref<?xindex>) -> f32
+      func.call @getSparseTensorReaderNextF32(%tensor, %indices, %value)
+        : (!TensorReader, memref<?xindex>, memref<f32>) -> ()
+      // TODO: can we use memref.subview to avoid the need for the %value
+      //       buffer?
+      %v = memref.load %value[] : memref<f32>
       memref.store %v, %vs[%i] : memref<?xf32>
       %i0 = memref.load %indices[%c0] : memref<?xindex>
       memref.store %i0, %x0s[%i] : memref<?xindex>
       %i1 = memref.load %indices[%c1] : memref<?xindex>
       memref.store %i1, %x1s[%i] : memref<?xindex>
     }
 
     // Release the resource for the indices.
func.func @createTensorFileFrom(%fileName0: !Filename, %fileName1: !Filename) {
     func.call @getSparseTensorReaderDimSizes(%tensor0,%dimSizes)
       : (!TensorReader, memref<?xindex>) -> ()
     call @outSparseTensorWriterMetaData(%tensor1, %rank, %nnz, %dimSizes)
       : (!TensorWriter, index, index, memref<?xindex>) -> ()
 
     //TODO: handle isSymmetric.
     // Assume rank == 2.
     %indices = memref.alloc(%rank) : memref<?xindex>
+    %value = memref.alloca() : memref<f32>
     scf.for %i = %c0 to %nnz step %c1 {
-      %v = func.call @getSparseTensorReaderNextF32(%tensor0, %indices)
-        : (!TensorReader, memref<?xindex>) -> f32
-      func.call @outSparseTensorWriterNextF32(%tensor1, %rank, %indices, %v)
-        : (!TensorWriter, index, memref<?xindex>, f32) -> ()
+      func.call @getSparseTensorReaderNextF32(%tensor0, %indices, %value)
+        : (!TensorReader, memref<?xindex>, memref<f32>) -> ()
+      func.call @outSparseTensorWriterNextF32(%tensor1, %rank, %indices, %value)
+        : (!TensorWriter, index, memref<?xindex>, memref<f32>) -> ()
     }
 
     // Release the resources.
     call @delSparseTensorReader(%tensor0) : (!TensorReader) -> ()
     call @delSparseTensorWriter(%tensor1) : (!TensorWriter) -> ()
     memref.dealloc %dimSizes : memref<?xindex>
     memref.dealloc %indices : memref<?xindex>