[mlir][sparse] export sparse tensor runtime support through header file

[aartbik]

Summary

Exposing the C versions of the methods of the sparse runtime support lib
through header files will enable using the same methods in an MLIR program
as well as a C++ program, which will simplify future benchmarking comparisons
(e.g. comparing MLIR generated code with eigen for Matrix Market sparse matrices).

[aartbik]

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

220

Note, this layout looks funny, but no matter what I tried, the auto formatter changes this back to this.....

mlir/lib/ExecutionEngine/SparseUtils.cpp

19

note that this ifdef mimics the logic of the c runner utils lib

[penpornk]

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

213

Nit: Are we missing a for? s/support/support for/ ?

mlir/lib/ExecutionEngine/SparseUtils.cpp

151

Just curious, when we create a memref in MLIR, are the base pointer and offset always initialized at the creation time?

[mehdi_amini]

Do you have tests for all this?

[aartbik]

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

213

Yes, we are. Thanks!

mlir/lib/ExecutionEngine/SparseUtils.cpp

151

Yes, and for scalars only the data pointer will work. Note that if we want to support more complex memrefs (like assigning directly into compound buffers), we may want to refine this a bit, but that is for now not the intended behavior.

[aartbik]

addressed missing "for"

[aartbik]

In D91316#2390343, @mehdi_amini wrote:

Do you have tests for all this?

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

(note that the lib was already added, I am just adding a header so that cpp programs can use the same code by linking to the lib)

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

 extern "C" MLIR_CRUNNERUTILS_EXPORT void printU64(uint64_t u);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printF32(float f);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printF64(double d);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printOpen();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printClose();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printComma();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void printNewline();
 
-#endif // EXECUTIONENGINE_CRUNNERUTILS_H_
+//===----------------------------------------------------------------------===//
+// Small runtime support for sparse tensors.
+//===----------------------------------------------------------------------===//
+extern "C" MLIR_CRUNNERUTILS_EXPORT void openMatrixC(char *filename,
+                                                     uint64_t *mdata,
+                                                     uint64_t *ndata,
+                                                     uint64_t *nnzdata);
+extern "C" MLIR_CRUNNERUTILS_EXPORT void
+readMatrixItemC(uint64_t *idata, uint64_t *jdata, double *ddata);
+extern "C" MLIR_CRUNNERUTILS_EXPORT void closeMatrix();
+extern "C" MLIR_CRUNNERUTILS_EXPORT char *getMatrix(uint64_t id);
 
+#endif // EXECUTIONENGINE_CRUNNERUTILS_H_

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

 extern "C" void printU64(uint64_t u) { fprintf(stdout, "%" PRIu64, u); }
 extern "C" void printF32(float f) { fprintf(stdout, "%g", f); }
 extern "C" void printF64(double d) { fprintf(stdout, "%lg", d); }
 extern "C" void printOpen() { fputs("( ", stdout); }
 extern "C" void printClose() { fputs(" )", stdout); }
 extern "C" void printComma() { fputs(", ", stdout); }
 extern "C" void printNewline() { fputc('\n', stdout); }
 
-#endif
+#endif // MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS

mlir/lib/ExecutionEngine/SparseUtils.cpp

 //===- SparseUtils.cpp - Sparse Utils for MLIR execution ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a light-weight runtime library that is useful for
 // sparse tensor manipulations. The functionality provided in this library
 // is meant to simplify benchmarking, testing, and debugging MLIR code that
 // operates on sparse tensors. The provided functionality is **not** part
 // of core MLIR, however.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/ExecutionEngine/CRunnerUtils.h"
+
+#ifdef MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS
+
 #include <cctype>
 #include <cinttypes>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
 //===----------------------------------------------------------------------===//
 //

 //                                         memref<index>, memref<f64>) -> ()
 //     .... process next nonzero element A[i][j] = d ....
 //   }
 //   call @closeMatrix() : () -> ()
 //
 // The implementation is *not* thread-safe. Also, only *one* matrix file can
 // be open at the time. A matrix file must be closed before reading in a next.
 //
-// Note that input parameters mimic the layout of a MemRef<T>:
+// Note that input parameters in the "MLIRized" version of a function mimic
+// the data layout of a MemRef<T>:
+//
 //   struct MemRef {
 //     T *base;
 //     T *data;
 //     int64_t off;
 //   }
+//
 //===----------------------------------------------------------------------===//
 
 // Currently open matrix. This is *not* thread-safe or re-entrant.
 static FILE *sparseFile = nullptr;
 static char *sparseFilename = nullptr;
 
-extern "C" void openMatrix(char *filename, uint64_t *mbase, uint64_t *mdata,
-                           int64_t moff, uint64_t *nbase, uint64_t *ndata,
-                           int64_t noff, uint64_t *nnzbase, uint64_t *nnzdata,
-                           int64_t nnzoff) {
+extern "C" void openMatrixC(char *filename, uint64_t *mdata, uint64_t *ndata,
+                            uint64_t *nnzdata) {
   if (sparseFile != nullptr) {
     fprintf(stderr, "Other file still open %s vs. %s\n", sparseFilename,
             filename);
     exit(1);
   }
   sparseFile = fopen(filename, "r");
   if (!sparseFile) {
     fprintf(stderr, "Cannot find %s\n", filename);
     exit(1);
   }
   sparseFilename = filename;
   readHeader(sparseFile, filename, mdata, ndata, nnzdata);
 }
 
-extern "C" void readMatrixItem(uint64_t *ibase, uint64_t *idata, int64_t ioff,
-                               uint64_t *jbase, uint64_t *jdata, int64_t joff,
-                               double *dbase, double *ddata, int64_t doff) {
+// "MLIRized" version.
+extern "C" void openMatrix(char *filename, uint64_t *mbase, uint64_t *mdata,
+                           int64_t moff, uint64_t *nbase, uint64_t *ndata,
+                           int64_t noff, uint64_t *nnzbase, uint64_t *nnzdata,
+                           int64_t nnzoff) {
+  openMatrixC(filename, mdata, ndata, nnzdata);
+}
+
+extern "C" void readMatrixItemC(uint64_t *idata, uint64_t *jdata,
+                                double *ddata) {
   if (sparseFile == nullptr) {
     fprintf(stderr, "Cannot read item from unopened matrix\n");
     exit(1);
   }
   readItem(sparseFile, sparseFilename, idata, jdata, ddata);
 }
 
+// "MLIRized" version.
+extern "C" void readMatrixItem(uint64_t *ibase, uint64_t *idata, int64_t ioff,
+                               uint64_t *jbase, uint64_t *jdata, int64_t joff,
+                               double *dbase, double *ddata, int64_t doff) {
+  readMatrixItemC(idata, jdata, ddata);
+}
+
 extern "C" void closeMatrix() {
   if (sparseFile == nullptr) {
     fprintf(stderr, "Cannot close unopened matrix\n");
     exit(1);
   }
   fclose(sparseFile);
   sparseFile = nullptr;
   sparseFilename = nullptr;
 }
 
 // Helper method to read matrix filenames from the environment, defined
 // with the naming convention ${MATRIX0}, ${MATRIX1}, etc.
 extern "C" char *getMatrix(uint64_t id) {
   char var[80];
   sprintf(var, "MATRIX%" PRIu64, id);
   char *env = getenv(var);
   return env;
 }
+
+#endif // MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS