[mlir][sparse] Simplifying closure

[wrengr]

Summary

By closing over the rank itself rather than this, we save a method call on each iteration. A minor optimization, but one that adds up.

Depends On D126016

[aartbik]

Oh, nice, I wonder if that makes reading the very large tensors slightly faster again!

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

176

const even?

[wrengr]

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

176

Adding const wouldn't change anything here, since we're closing over rank by value (and the values stored in a closure are always const).

Things would be different if rank were a pointer (like this) or if we closed over it by reference ([&rank](...){...}), since in both cases the closure would end up storing something like T* const ptr. So if we wanted to prohibit mutation we'd need the extra const on the thing being closed over, so that the closure instead stores T const* const ptr.

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

void add(const std::vector<uint64_t> &ind, V val) {
     elements.emplace_back(base + size, val);
   }
 
   /// Sorts elements lexicographically by index.
   void sort() {
     assert(!iteratorLocked && "Attempt to sort() after startIterator()");
     // TODO: we may want to cache an `isSorted` bit, to avoid
     // unnecessary/redundant sorting.
-    std::sort(elements.begin(), elements.end(),
-              [this](const Element<V> &e1, const Element<V> &e2) {
-                uint64_t rank = getRank();
+    std::sort(elements.begin(), elements.end(),
+              [rank](const Element<V> &e1, const Element<V> &e2) {
                 for (uint64_t r = 0; r < rank; r++) {
                   if (e1.indices[r] == e2.indices[r])
                     continue;
                   return e1.indices[r] < e2.indices[r];
                 }
                 return false;
               });
   }