[mlir][sparse] Rename add{Pointer,Index} to append{Pointer,Index}

[wrengr]

Summary

This clarifies that these methods only work in append mode, not for general insertions. This is a prospective change towards https://github.com/llvm/llvm-project/issues/51652 which also performs random-access insertions, so we want to avoid confusion.

[aartbik]

Yes, renaming makes a lot of sense!

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

SparseTensorStorage(const std::vector<uint64_t> &szs, const uint64_t *perm,
     for (uint64_t r = 0; r < rank; r++) {
       assert(sizes[r] > 0 && "Dimension size zero has trivial storage");
       sz *= sizes[r];
       if (sparsity[r] == DimLevelType::kCompressed) {
         pointers[r].reserve(sz + 1);
         indices[r].reserve(sz);
         sz = 1;
         allDense = false;
-        // Prepare the pointer structure.  We cannot use `addPointer`
+        // Prepare the pointer structure.  We cannot use `appendPointer`
         // here, because `isCompressedDim` won't work until after this
         // preparation has been done.
         pointers[r].push_back(0);
       } else {
         assert(sparsity[r] == DimLevelType::kDense &&
                "singleton not yet supported");
       }
     }
newSparseTensor(uint64_t rank, const uint64_t *sizes, const uint64_t *perm,
     }
     return n;
   }
 
 private:
   /// Appends the next free position of `indices[d]` to `pointers[d]`.
   /// Thus, when called after inserting the last element of a segment,
   /// it will append the position where the next segment begins.
-  inline void addPointer(uint64_t d) {
+  inline void appendPointer(uint64_t d) {
     assert(isCompressedDim(d)); // Entails `d < getRank()`.
     uint64_t p = indices[d].size();
     assert(p <= std::numeric_limits<P>::max() &&
            "Pointer value is too large for the P-type");
     pointers[d].push_back(p); // Here is where we convert to `P`.
   }
 
   /// Appends the given index to `indices[d]`.
-  inline void addIndex(uint64_t d, uint64_t i) {
+  inline void appendIndex(uint64_t d, uint64_t i) {
     assert(isCompressedDim(d)); // Entails `d < getRank()`.
     assert(i <= std::numeric_limits<I>::max() &&
            "Index value is too large for the I-type");
     indices[d].push_back(i); // Here is where we convert to `I`.
   }
 
   /// Initializes sparse tensor storage scheme from a memory-resident sparse
   /// tensor in coordinate scheme. This method prepares the pointers and
void fromCOO(const std::vector<Element<V>> &elements, uint64_t lo,
     while (lo < hi) { // If `hi` is unchanged, then `lo < elements.size()`.
       // Find segment in interval with same index elements in this dimension.
       uint64_t i = elements[lo].indices[d];
       uint64_t seg = lo + 1;
       while (seg < hi && elements[seg].indices[d] == i)
         seg++;
       // Handle segment in interval for sparse or dense dimension.
       if (isCompressedDim(d)) {
-        addIndex(d, i);
+        appendIndex(d, i);
       } else {
         // For dense storage we must fill in all the zero values between
         // the previous element (when last we ran this for-loop) and the
         // current element.
         for (; full < i; full++)
           endDim(d + 1);
         full++;
       }
       fromCOO(elements, lo, seg, d + 1);
       // And move on to next segment in interval.
       lo = seg;
     }
     // Finalize the sparse pointer structure at this dimension.
     if (isCompressedDim(d)) {
-      addPointer(d);
+      appendPointer(d);
     } else {
       // For dense storage we must fill in all the zero values after
       // the last element.
       for (uint64_t sz = sizes[d]; full < sz; full++)
         endDim(d + 1);
     }
   }
 
private:
   }
 
   /// Ends a deeper, never seen before dimension.
   void endDim(uint64_t d) {
     assert(d <= getRank());
     if (d == getRank()) {
       values.push_back(0);
     } else if (isCompressedDim(d)) {
-      addPointer(d);
+      appendPointer(d);
     } else {
       for (uint64_t full = 0, sz = sizes[d]; full < sz; full++)
         endDim(d + 1);
     }
   }
 
   /// Wraps up a single insertion path, inner to outer.
   void endPath(uint64_t diff) {
     uint64_t rank = getRank();
     assert(diff <= rank);
     for (uint64_t i = 0; i < rank - diff; i++) {
       uint64_t d = rank - i - 1;
       if (isCompressedDim(d)) {
-        addPointer(d);
+        appendPointer(d);
       } else {
         for (uint64_t full = idx[d] + 1, sz = sizes[d]; full < sz; full++)
           endDim(d + 1);
       }
     }
   }
 
   /// Continues a single insertion path, outer to inner.
   void insPath(const uint64_t *cursor, uint64_t diff, uint64_t top, V val) {
     uint64_t rank = getRank();
     assert(diff < rank);
     for (uint64_t d = diff; d < rank; d++) {
       uint64_t i = cursor[d];
       if (isCompressedDim(d)) {
-        addIndex(d, i);
+        appendIndex(d, i);
       } else {
         for (uint64_t full = top; full < i; full++)
           endDim(d + 1);
       }
       top = 0;
       idx[d] = i;
     }
     values.push_back(val);