[mlir][sparse] Renaming CPP macros for clarity

[aartbik]

mlir/lib/ExecutionEngine/SparseUtils.cpp

665

while you are here, how do you feel about using getNext here (the base name of the method, not the macro)?

[wrengr]

addressing comment

mlir/lib/ExecutionEngine/SparseUtils.cpp

if (action <= kFromCOO) {                                                  \
         tensor->startIterator();                                               \
       } else {                                                                 \
         assert(action == kToCOO);                                              \
       }                                                                        \
       return tensor;                                                           \
     }                                                                          \
   }
 
-#define IMPL1(NAME, TYPE, LIB)                                                 \
+#define IMPL_SPARSEVALUES(NAME, TYPE, LIB)                                     \
   void _mlir_ciface_##NAME(StridedMemRefType<TYPE, 1> *ref, void *tensor) {    \
     assert(ref);                                                               \
     assert(tensor);                                                            \
     std::vector<TYPE> *v;                                                      \
     static_cast<SparseTensorStorageBase *>(tensor)->LIB(&v);                   \
     ref->basePtr = ref->data = v->data();                                      \
     ref->offset = 0;                                                           \
     ref->sizes[0] = v->size();                                                 \
     ref->strides[0] = 1;                                                       \
   }
 
-#define IMPL2(NAME, TYPE, LIB)                                                 \
+#define IMPL_GETOVERHEAD(NAME, TYPE, LIB)                                      \
   void _mlir_ciface_##NAME(StridedMemRefType<TYPE, 1> *ref, void *tensor,      \
                            index_t d) {                                        \
     assert(ref);                                                               \
     assert(tensor);                                                            \
     std::vector<TYPE> *v;                                                      \
     static_cast<SparseTensorStorageBase *>(tensor)->LIB(&v, d);                \
     ref->basePtr = ref->data = v->data();                                      \
     ref->offset = 0;                                                           \
     ref->sizes[0] = v->size();                                                 \
     ref->strides[0] = 1;                                                       \
   }
 
-#define IMPL3(NAME, TYPE)                                                      \
+#define IMPL_ADDELT(NAME, TYPE)                                                \
   void *_mlir_ciface_##NAME(void *tensor, TYPE value,                          \
                             StridedMemRefType<index_t, 1> *iref,               \
                             StridedMemRefType<index_t, 1> *pref) {             \
     assert(tensor);                                                            \
     assert(iref);                                                              \
     assert(pref);                                                              \
     assert(iref->strides[0] == 1 && pref->strides[0] == 1);                    \
     assert(iref->sizes[0] == pref->sizes[0]);                                  \

 /// method for materializing sparse tensors into the computation.
 ///
 /// action:
 /// kEmpty = returns empty storage to fill later
 /// kFromFile = returns storage, where ptr contains filename to read
 /// kFromCOO = returns storage, where ptr contains coordinate scheme to assign
 /// kEmptyCOO = returns empty coordinate scheme to fill and use with kFromCOO
 /// kToCOO = returns coordinate scheme from storage in ptr to use with kFromCOO
-/// kToIter = returns iterator from storage in ptr (call IMPL_GETNEXT to use)
+/// kToIter = returns iterator from storage in ptr (call getNext() to use)
 void *
 _mlir_ciface_newSparseTensor(StridedMemRefType<uint8_t, 1> *aref, // NOLINT
                              StridedMemRefType<index_t, 1> *sref,
                              StridedMemRefType<index_t, 1> *pref,
                              uint32_t ptrTp, uint32_t indTp, uint32_t valTp,
                              uint32_t action, void *ptr) {
   assert(aref && sref && pref);
   assert(aref->strides[0] == 1 && sref->strides[0] == 1 &&
_mlir_ciface_newSparseTensor(StridedMemRefType<uint8_t, 1> *aref, // NOLINT
   CASE(kU8, kU8, kI16, uint8_t, uint8_t, int16_t);
   CASE(kU8, kU8, kI8, uint8_t, uint8_t, int8_t);
 
   // Unsupported case (add above if needed).
   fputs("unsupported combination of types\n", stderr);
   exit(1);
 }
 
-/// Methods that provide direct access to pointers, indices, and values.
-IMPL2(sparsePointers, index_t, getPointers)
-IMPL2(sparsePointers64, uint64_t, getPointers)
-IMPL2(sparsePointers32, uint32_t, getPointers)
-IMPL2(sparsePointers16, uint16_t, getPointers)
-IMPL2(sparsePointers8, uint8_t, getPointers)
-IMPL2(sparseIndices, index_t, getIndices)
-IMPL2(sparseIndices64, uint64_t, getIndices)
-IMPL2(sparseIndices32, uint32_t, getIndices)
-IMPL2(sparseIndices16, uint16_t, getIndices)
-IMPL2(sparseIndices8, uint8_t, getIndices)
-IMPL1(sparseValuesF64, double, getValues)
-IMPL1(sparseValuesF32, float, getValues)
-IMPL1(sparseValuesI64, int64_t, getValues)
-IMPL1(sparseValuesI32, int32_t, getValues)
-IMPL1(sparseValuesI16, int16_t, getValues)
-IMPL1(sparseValuesI8, int8_t, getValues)
+/// Methods that provide direct access to pointers.
+IMPL_GETOVERHEAD(sparsePointers, index_t, getPointers)
+IMPL_GETOVERHEAD(sparsePointers64, uint64_t, getPointers)
+IMPL_GETOVERHEAD(sparsePointers32, uint32_t, getPointers)
+IMPL_GETOVERHEAD(sparsePointers16, uint16_t, getPointers)
+IMPL_GETOVERHEAD(sparsePointers8, uint8_t, getPointers)
+
+/// Methods that provide direct access to indices.
+IMPL_GETOVERHEAD(sparseIndices, index_t, getIndices)
+IMPL_GETOVERHEAD(sparseIndices64, uint64_t, getIndices)
+IMPL_GETOVERHEAD(sparseIndices32, uint32_t, getIndices)
+IMPL_GETOVERHEAD(sparseIndices16, uint16_t, getIndices)
+IMPL_GETOVERHEAD(sparseIndices8, uint8_t, getIndices)
+
+/// Methods that provide direct access to values.
+IMPL_SPARSEVALUES(sparseValuesF64, double, getValues)
+IMPL_SPARSEVALUES(sparseValuesF32, float, getValues)
+IMPL_SPARSEVALUES(sparseValuesI64, int64_t, getValues)
+IMPL_SPARSEVALUES(sparseValuesI32, int32_t, getValues)
+IMPL_SPARSEVALUES(sparseValuesI16, int16_t, getValues)
+IMPL_SPARSEVALUES(sparseValuesI8, int8_t, getValues)
 
 /// Helper to add value to coordinate scheme, one per value type.
-IMPL3(addEltF64, double)
-IMPL3(addEltF32, float)
-IMPL3(addEltI64, int64_t)
-IMPL3(addEltI32, int32_t)
-IMPL3(addEltI16, int16_t)
-IMPL3(addEltI8, int8_t)
+IMPL_ADDELT(addEltF64, double)
+IMPL_ADDELT(addEltF32, float)
+IMPL_ADDELT(addEltI64, int64_t)
+IMPL_ADDELT(addEltI32, int32_t)
+IMPL_ADDELT(addEltI16, int16_t)
+IMPL_ADDELT(addEltI8, int8_t)
 
 /// Helper to enumerate elements of coordinate scheme, one per value type.
 IMPL_GETNEXT(getNextF64, double)
 IMPL_GETNEXT(getNextF32, float)
 IMPL_GETNEXT(getNextI64, int64_t)
 IMPL_GETNEXT(getNextI32, int32_t)
 IMPL_GETNEXT(getNextI16, int16_t)
 IMPL_GETNEXT(getNextI8, int8_t)
 
 #undef CASE
-#undef IMPL1
-#undef IMPL2
-#undef IMPL3
+#undef IMPL_SPARSEVALUES
+#undef IMPL_GETOVERHEAD
+#undef IMPL_ADDELT
 #undef IMPL_GETNEXT
 
 //===----------------------------------------------------------------------===//
 //
 // Public API with methods that accept C-style data structures to interact
 // with sparse tensors, which are only visible as opaque pointers externally.
 // These methods can be used both by MLIR compiler-generated code as well as by
 // an external runtime that wants to interact with MLIR compiler-generated code.