[mlir][sparse] Rename SparseTensorFile to SparseTensorReader.

[bixia]

Summary

This is to prepare for adding SparseTensorWriter.

mlir/include/mlir/ExecutionEngine/SparseTensor/File.h

 // off to the cpp file.
 
 // TODO: consider distinguishing separate classes for before vs
 // after reading the header; so as to statically avoid the need
 // to `assert(isValid())`.
 
 /// This class abstracts over the information stored in file headers,
 /// as well as providing the buffers and methods for parsing those headers.
-class SparseTensorFile final {
+class SparseTensorReader final {
 public:
   enum class ValueKind : uint8_t {
     // The value before calling `readHeader`.
     kInvalid = 0,
     // Values that can be set by `readMMEHeader`.
     kPattern = 1,
     kReal = 2,
     kInteger = 3,
     kComplex = 4,
     // The value set by `readExtFROSTTHeader`.
     kUndefined = 5
   };
 
-  explicit SparseTensorFile(const char *filename) : filename(filename) {
+  explicit SparseTensorReader(const char *filename) : filename(filename) {
     assert(filename && "Received nullptr for filename");
   }
 
   // Disallows copying, to avoid duplicating the `file` pointer.
-  SparseTensorFile(const SparseTensorFile &) = delete;
-  SparseTensorFile &operator=(const SparseTensorFile &) = delete;
+  SparseTensorReader(const SparseTensorReader &) = delete;
+  SparseTensorReader &operator=(const SparseTensorReader &) = delete;
 
   // This dtor tries to avoid leaking the `file`.  (Though it's better
   // to call `closeFile` explicitly when possible, since there are
   // circumstances where dtors are not called reliably.)
-  ~SparseTensorFile() { closeFile(); }
+  ~SparseTensorReader() { closeFile(); }
 
   /// Opens the file for reading.
   void openFile();
 
   /// Closes the file.
   void closeFile();
 
   /// Attempts to read a line from the file.

 } // namespace detail
 
 /// Reads a sparse tensor with the given filename into a memory-resident
 /// sparse tensor in coordinate scheme.
 template <typename V>
 inline SparseTensorCOO<V> *
 openSparseTensorCOO(const char *filename, uint64_t rank, const uint64_t *shape,
                     const uint64_t *perm, PrimaryType valTp) {
-  SparseTensorFile stfile(filename);
+  SparseTensorReader stfile(filename);
   stfile.openFile();
   stfile.readHeader();
   // Check tensor element type against the value type in the input file.
   if (!stfile.canReadAs(valTp))
     MLIR_SPARSETENSOR_FATAL(
         "Tensor element type %d not compatible with values in file %s\n",
         static_cast<int>(valTp), filename);
   stfile.assertMatchesShape(rank, shape);

mlir/lib/ExecutionEngine/SparseTensor/File.cpp

 #include "mlir/ExecutionEngine/SparseTensor/File.h"
 
 #include <cctype>
 #include <cstring>
 
 using namespace mlir::sparse_tensor;
 
 /// Opens the file for reading.
-void SparseTensorFile::openFile() {
+void SparseTensorReader::openFile() {
   if (file)
     MLIR_SPARSETENSOR_FATAL("Already opened file %s\n", filename);
   file = fopen(filename, "r");
   if (!file)
     MLIR_SPARSETENSOR_FATAL("Cannot find file %s\n", filename);
 }
 
 /// Closes the file.
-void SparseTensorFile::closeFile() {
+void SparseTensorReader::closeFile() {
   if (file) {
     fclose(file);
     file = nullptr;
   }
 }
 
 // TODO(wrengr/bixia): figure out how to reorganize the element-parsing
 // loop of `openSparseTensorCOO` into methods of this class, so we can
 // avoid leaking access to the `line` pointer (both for general hygiene
 // and because we can't mark it const due to the second argument of
 // `strtoul`/`strtoud` being `char * *restrict` rather than
 // `char const* *restrict`).
 //
 /// Attempts to read a line from the file.
-char *SparseTensorFile::readLine() {
+char *SparseTensorReader::readLine() {
   if (fgets(line, kColWidth, file))
     return line;
   MLIR_SPARSETENSOR_FATAL("Cannot read next line of %s\n", filename);
 }
 
 /// Reads and parses the file's header.
-void SparseTensorFile::readHeader() {
+void SparseTensorReader::readHeader() {
   assert(file && "Attempt to readHeader() before openFile()");
   if (strstr(filename, ".mtx"))
     readMMEHeader();
   else if (strstr(filename, ".tns"))
     readExtFROSTTHeader();
   else
     MLIR_SPARSETENSOR_FATAL("Unknown format %s\n", filename);
   assert(isValid() && "Failed to read the header");
 }
 
 /// Asserts the shape subsumes the actual dimension sizes.  Is only
 /// valid after parsing the header.
-void SparseTensorFile::assertMatchesShape(uint64_t rank,
+void SparseTensorReader::assertMatchesShape(uint64_t rank,
                                             const uint64_t *shape) const {
   assert(rank == getRank() && "Rank mismatch");
   for (uint64_t r = 0; r < rank; ++r)
     assert((shape[r] == 0 || shape[r] == idata[2 + r]) &&
            "Dimension size mismatch");
 }
 
-bool SparseTensorFile::canReadAs(PrimaryType valTy) const {
+bool SparseTensorReader::canReadAs(PrimaryType valTy) const {
   switch (valueKind_) {
   case ValueKind::kInvalid:
     assert(false && "Must readHeader() before calling canReadAs()");
     return false; // In case assertions are disabled.
   case ValueKind::kPattern:
     return true;
   case ValueKind::kInteger:
     // When the file is specified to store integer values, we still

 }
 
 /// Idiomatic name for checking string inequality.
 static inline bool strne(const char *lhs, const char *rhs) {
   return strcmp(lhs, rhs); // aka `!= 0`
 }
 
 /// Read the MME header of a general sparse matrix of type real.
-void SparseTensorFile::readMMEHeader() {
+void SparseTensorReader::readMMEHeader() {
   char header[64];
   char object[64];
   char format[64];
   char field[64];
   char symmetry[64];
   // Read header line.
   if (fscanf(file, "%63s %63s %63s %63s %63s\n", header, object, format, field,
              symmetry) != 5)
if (sscanf(line, "%" PRIu64 "%" PRIu64 "%" PRIu64 "\n", idata + 2, idata + 3,
              idata + 1) != 3)
     MLIR_SPARSETENSOR_FATAL("Cannot find size in %s\n", filename);
 }
 
 /// Read the "extended" FROSTT header. Although not part of the documented
 /// format, we assume that the file starts with optional comments followed
 /// by two lines that define the rank, the number of nonzeros, and the
 /// dimensions sizes (one per rank) of the sparse tensor.
-void SparseTensorFile::readExtFROSTTHeader() {
+void SparseTensorReader::readExtFROSTTHeader() {
   // Skip comments.
   while (true) {
     readLine();
     if (line[0] != '#')
       break;
   }
   // Next line contains RANK and NNZ.
   if (sscanf(line, "%" PRIu64 "%" PRIu64 "\n", idata, idata + 1) != 2)

mlir/lib/ExecutionEngine/SparseTensor/Storage.cpp

void SparseTensorStorageBase::expInsert(uint64_t *, V *, bool *, uint64_t *, \
                                           uint64_t) {                          \
     FATAL_PIV("expInsert" #VNAME);                                             \
   }
 MLIR_SPARSETENSOR_FOREVERY_V(IMPL_EXPINSERT)
 #undef IMPL_EXPINSERT
 
 #undef FATAL_PIV
 
-// TODO: try to unify this with `SparseTensorFile::assertMatchesShape`
+// TODO: try to unify this with `SparseTensorReader::assertMatchesShape`
 // (which is used by `openSparseTensorCOO`).  It's easy enough to resolve
 // the `std::vector` vs pointer mismatch for `dimSizes`; but it's trickier
 // to resolve the presence/absence of `perm` (without introducing extra
 // overhead), so perhaps the code duplication is unavoidable?
 void mlir::sparse_tensor::detail::assertPermutedSizesMatchShape(
     const std::vector<uint64_t> &dimSizes, uint64_t rank, const uint64_t *perm,
     const uint64_t *shape) {
   assert(perm && "Got nullptr for permutation");
   assert(shape && "Got nullptr for shape");
   assert(rank == dimSizes.size() && "Rank mismatch");
   for (uint64_t d = 0; d < rank; ++d)
     assert((shape[d] == 0 || shape[d] == dimSizes[perm[d]]) &&
            "Dimension size mismatch");
 }

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

char *getTensorFilename(index_type id) {
   char *env = getenv(var);
   if (!env)
     MLIR_SPARSETENSOR_FATAL("Environment variable %s is not set\n", var);
   return env;
 }
 
 void readSparseTensorShape(char *filename, std::vector<uint64_t> *out) {
   assert(out && "Received nullptr for out-parameter");
-  SparseTensorFile stfile(filename);
+  SparseTensorReader stfile(filename);
   stfile.openFile();
   stfile.readHeader();
   stfile.closeFile();
   const uint64_t rank = stfile.getRank();
   const uint64_t *dimSizes = stfile.getDimSizes();
   out->reserve(rank);
   out->assign(dimSizes, dimSizes + rank);
 }