[mlir][sparse] Marking several things const/static

[wrengr]

Summary

This is (tangential) work towards fixing: https://github.com/llvm/llvm-project/issues/51652

[aartbik]

One comment, but assuming you remove the two lines, good to go!

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

574–575

please remove the comment wrt not using const on rev (focusing on what we did, not what we didn't ;-)

[wrengr]

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

574–575

Doh, forgot to remove that note-to-self ;)

[wrengr]

removing note-to-self comment

[wrengr]

Removing the dependency differentials

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

private:
   unsigned iteratorPos;
 };
 
 /// Abstract base class of sparse tensor storage. Note that we use
 /// function overloading to implement "partial" method specialization.
 class SparseTensorStorageBase {
 public:
   /// Dimension size query.
-  virtual uint64_t getDimSize(uint64_t) = 0;
+  virtual uint64_t getDimSize(uint64_t) const = 0;
 
   /// Overhead storage.
   virtual void getPointers(std::vector<uint64_t> **, uint64_t) { fatal("p64"); }
   virtual void getPointers(std::vector<uint32_t> **, uint64_t) { fatal("p32"); }
   virtual void getPointers(std::vector<uint16_t> **, uint64_t) { fatal("p16"); }
   virtual void getPointers(std::vector<uint8_t> **, uint64_t) { fatal("p8"); }
   virtual void getIndices(std::vector<uint64_t> **, uint64_t) { fatal("i64"); }
   virtual void getIndices(std::vector<uint32_t> **, uint64_t) { fatal("i32"); }
public:
   }
 
   /// Finishes insertion.
   virtual void endInsert() = 0;
 
   virtual ~SparseTensorStorageBase() = default;
 
 private:
-  void fatal(const char *tp) {
+  static void fatal(const char *tp) {
     fprintf(stderr, "unsupported %s\n", tp);
     exit(1);
   }
 };
 
 /// A memory-resident sparse tensor using a storage scheme based on
 /// per-dimension sparse/dense annotations. This data structure provides a
 /// bufferized form of a sparse tensor type. In contrast to generating setup
public:
   }
 
   ~SparseTensorStorage() override = default;
 
   /// Get the rank of the tensor.
   uint64_t getRank() const { return sizes.size(); }
 
   /// Get the size of the given dimension of the tensor.
-  uint64_t getDimSize(uint64_t d) override {
+  uint64_t getDimSize(uint64_t d) const override {
     assert(d < getRank());
     return sizes[d];
   }
 
   /// Partially specialize these getter methods based on template types.
   void getPointers(std::vector<P> **out, uint64_t d) override {
     assert(d < getRank());
     *out = &pointers[d];
for (uint64_t d = diff; d < rank; d++) {
       }
       top = 0;
       idx[d] = i;
     }
     values.push_back(val);
   }
 
   /// Finds the lexicographic differing dimension.
-  uint64_t lexDiff(const uint64_t *cursor) {
+  uint64_t lexDiff(const uint64_t *cursor) const {
     for (uint64_t r = 0, rank = getRank(); r < rank; r++)
       if (cursor[r] > idx[r])
         return r;
       else
         assert(cursor[r] == idx[r] && "non-lexicographic insertion");
     assert(0 && "duplication insertion");
     return -1u;
   }
 
   /// Returns true if dimension is compressed.
   inline bool isCompressedDim(uint64_t d) const {
     assert(d < getRank());
     return (!pointers[d].empty());
   }
 
 private:
-  std::vector<uint64_t> sizes; // per-dimension sizes
+  const std::vector<uint64_t> sizes; // per-dimension sizes
   std::vector<uint64_t> rev;   // "reverse" permutation
   std::vector<uint64_t> idx;   // index cursor
   std::vector<std::vector<P>> pointers;
   std::vector<std::vector<I>> indices;
   std::vector<V> values;
 };
 
 /// Helper to convert string to lower case.
 static char *toLower(char *token) {
   for (char *c = token; *c; c++)
static SparseTensorCOO<V> *openSparseTensorCOO(char *filename, uint64_t rank,
   }
   // Close the file and return tensor.
   fclose(file);
   return tensor;
 }
 
 /// Writes the sparse tensor to extended FROSTT format.
 template <typename V>
-void outSparseTensor(void *tensor, void *dest, bool sort) {
+static void outSparseTensor(void *tensor, void *dest, bool sort) {
   assert(tensor && dest);
   auto coo = static_cast<SparseTensorCOO<V> *>(tensor);
   if (sort)
     coo->sort();
   char *filename = static_cast<char *>(dest);
   auto &sizes = coo->getSizes();
   auto &elements = coo->getElements();
   uint64_t rank = coo->getRank();
static void outSparseTensor(void *tensor, void *dest, bool sort) {
   file.flush();
   file.close();
   assert(file.good());
   delete coo;
 }
 
 /// Initializes sparse tensor from an external COO-flavored format.
 template <typename V>
-SparseTensorStorage<uint64_t, uint64_t, V> *
+static SparseTensorStorage<uint64_t, uint64_t, V> *
 toMLIRSparseTensor(uint64_t rank, uint64_t nse, uint64_t *shape, V *values,
                    uint64_t *indices, uint64_t *perm, uint8_t *sparse) {
   const DimLevelType *sparsity = (DimLevelType *)(sparse);
 #ifndef NDEBUG
   // Verify that perm is a permutation of 0..(rank-1).
   std::vector<uint64_t> order(perm, perm + rank);
   std::sort(order.begin(), order.end());
   for (uint64_t i = 0; i < rank; ++i) {
#endif
   }
   // Return sparse tensor storage format as opaque pointer.
   return SparseTensorStorage<uint64_t, uint64_t, V>::newSparseTensor(
       rank, shape, perm, sparsity, tensor);
 }
 
 /// Converts a sparse tensor to an external COO-flavored format.
 template <typename V>
-void fromMLIRSparseTensor(void *tensor, uint64_t *pRank, uint64_t *pNse,
-                          uint64_t **pShape, V **pValues, uint64_t **pIndices) {
+static void fromMLIRSparseTensor(void *tensor, uint64_t *pRank, uint64_t *pNse,
+                                 uint64_t **pShape, V **pValues,
+                                 uint64_t **pIndices) {
   auto sparseTensor =
       static_cast<SparseTensorStorage<uint64_t, uint64_t, V> *>(tensor);
   uint64_t rank = sparseTensor->getRank();
   std::vector<uint64_t> perm(rank);
   std::iota(perm.begin(), perm.end(), 0);
   SparseTensorCOO<V> *coo = sparseTensor->toCOO(perm.data());
 
   const std::vector<Element<V>> &elements = coo->getElements();