simplifying inlining

lemire · lemire · commit 9924846ae1bf · 2025-12-04T23:03:00.000-05:00
diff --git a/amalgamation.sh b/amalgamation.sh
@@ -162,7 +162,7 @@ echo "Creating ${AMAL_C}..."
 
     echo "#include \"roaring.h\"  /* include public API definitions */"
 
-    for h in ${ALL_PRIVATE_H} src/roaring_internal_inline.h ${ALL_PRIVATE_C}; do
+    for h in ${ALL_PRIVATE_H} ${ALL_PRIVATE_C}; do
         dofile $h
     done
 } > "${DESTINATION}/${AMAL_C}"
diff --git a/include/roaring/containers/containers.h b/include/roaring/containers/containers.h
@@ -2434,15 +2434,131 @@ roaring_container_iterator_t container_init_iterator_last(const container_t *c,
  * Moves the iterator to the next entry. Returns true and sets `value` if a
  * value is present.
  */
-bool container_iterator_next(const container_t *c, uint8_t typecode,
-                             roaring_container_iterator_t *it, uint16_t *value);
+inline bool container_iterator_next(const container_t *c, uint8_t typecode,
+                                    roaring_container_iterator_t *it,
+                                    uint16_t *value) {
+    switch (typecode) {
+        case BITSET_CONTAINER_TYPE: {
+            const bitset_container_t *bc = const_CAST_bitset(c);
+            it->index++;
+
+            uint32_t wordindex = it->index / 64;
+            if (wordindex >= BITSET_CONTAINER_SIZE_IN_WORDS) {
+                return false;
+            }
+
+            uint64_t word =
+                bc->words[wordindex] & (UINT64_MAX << (it->index % 64));
+            // next part could be optimized/simplified
+            while (word == 0 &&
+                   (wordindex + 1 < BITSET_CONTAINER_SIZE_IN_WORDS)) {
+                wordindex++;
+                word = bc->words[wordindex];
+            }
+            if (word != 0) {
+                it->index = wordindex * 64 + roaring_trailing_zeroes(word);
+                *value = it->index;
+                return true;
+            }
+            return false;
+        }
+        case ARRAY_CONTAINER_TYPE: {
+            const array_container_t *ac = const_CAST_array(c);
+            it->index++;
+            if (it->index < ac->cardinality) {
+                *value = ac->array[it->index];
+                return true;
+            }
+            return false;
+        }
+        case RUN_CONTAINER_TYPE: {
+            if (*value == UINT16_MAX) {  // Avoid overflow to zero
+                return false;
+            }
+
+            const run_container_t *rc = const_CAST_run(c);
+            uint32_t limit =
+                rc->runs[it->index].value + rc->runs[it->index].length;
+            if (*value < limit) {
+                (*value)++;
+                return true;
+            }
+
+            it->index++;
+            if (it->index < rc->n_runs) {
+                *value = rc->runs[it->index].value;
+                return true;
+            }
+            return false;
+        }
+        default:
+            assert(false);
+            roaring_unreachable;
+            return false;
+    }
+}
 
 /**
  * Moves the iterator to the previous entry. Returns true and sets `value` if a
  * value is present.
  */
-bool container_iterator_prev(const container_t *c, uint8_t typecode,
-                             roaring_container_iterator_t *it, uint16_t *value);
+inline bool container_iterator_prev(const container_t *c, uint8_t typecode,
+                                    roaring_container_iterator_t *it,
+                                    uint16_t *value) {
+    switch (typecode) {
+        case BITSET_CONTAINER_TYPE: {
+            if (--it->index < 0) {
+                return false;
+            }
+
+            const bitset_container_t *bc = const_CAST_bitset(c);
+            int32_t wordindex = it->index / 64;
+            uint64_t word =
+                bc->words[wordindex] & (UINT64_MAX >> (63 - (it->index % 64)));
+
+            while (word == 0 && --wordindex >= 0) {
+                word = bc->words[wordindex];
+            }
+            if (word == 0) {
+                return false;
+            }
+
+            it->index = (wordindex * 64) + (63 - roaring_leading_zeroes(word));
+            *value = it->index;
+            return true;
+        }
+        case ARRAY_CONTAINER_TYPE: {
+            if (--it->index < 0) {
+                return false;
+            }
+            const array_container_t *ac = const_CAST_array(c);
+            *value = ac->array[it->index];
+            return true;
+        }
+        case RUN_CONTAINER_TYPE: {
+            if (*value == 0) {
+                return false;
+            }
+
+            const run_container_t *rc = const_CAST_run(c);
+            (*value)--;
+            if (*value >= rc->runs[it->index].value) {
+                return true;
+            }
+
+            if (--it->index < 0) {
+                return false;
+            }
+
+            *value = rc->runs[it->index].value + rc->runs[it->index].length;
+            return true;
+        }
+        default:
+            assert(false);
+            roaring_unreachable;
+            return false;
+    }
+}
 
 /**
  * Moves the iterator to the smallest entry that is greater than or equal to
diff --git a/include/roaring/roaring.h b/include/roaring/roaring.h
@@ -464,8 +464,7 @@ bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
 /**
  * Check if value is present
  */
-inline bool roaring_bitmap_contains(const roaring_bitmap_t *r,
-                                           uint32_t val) {
+inline bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val) {
     // For performance reasons, this function is inline and uses internal
     // functions directly.
 #ifdef __cplusplus
diff --git a/src/containers/containers.c b/src/containers/containers.c
@@ -1,8 +1,6 @@
 #include <roaring/containers/containers.h>
 #include <roaring/memory.h>
 
-#include "roaring_internal_inline.h"
-
 #ifdef __cplusplus
 extern "C" {
 // In Windows MSVC C++ compiler, (type){init} does not compile,
@@ -45,6 +43,14 @@ extern inline container_t *container_iandnot(container_t *c1, uint8_t type1,
                                              uint8_t type2,
                                              uint8_t *result_type);
 
+extern bool container_iterator_next(const container_t *c, uint8_t typecode,
+                                    roaring_container_iterator_t *it,
+                                    uint16_t *value);
+
+extern bool container_iterator_prev(const container_t *c, uint8_t typecode,
+                                    roaring_container_iterator_t *it,
+                                    uint16_t *value);
+
 void container_free(container_t *c, uint8_t type) {
     switch (type) {
         case BITSET_CONTAINER_TYPE:
@@ -371,18 +377,6 @@ roaring_container_iterator_t container_init_iterator_last(const container_t *c,
     }
 }
 
-bool container_iterator_next(const container_t *c, uint8_t typecode,
-                             roaring_container_iterator_t *it,
-                             uint16_t *value) {
-    return container_iterator_next_inline(c, typecode, it, value);
-}
-
-bool container_iterator_prev(const container_t *c, uint8_t typecode,
-                             roaring_container_iterator_t *it,
-                             uint16_t *value) {
-    return container_iterator_prev_inline(c, typecode, it, value);
-}
-
 bool container_iterator_lower_bound(const container_t *c, uint8_t typecode,
                                     roaring_container_iterator_t *it,
                                     uint16_t *value_out, uint16_t val) {
diff --git a/src/roaring.c b/src/roaring.c
@@ -14,8 +14,6 @@
 #include <roaring/containers/containers.h>
 #include <roaring/roaring_array.h>
 
-#include "roaring_internal_inline.h"
-
 #ifdef __cplusplus
 using namespace ::roaring::internal;
 
@@ -1832,8 +1830,8 @@ bool roaring_uint32_iterator_advance(roaring_uint32_iterator_t *it) {
         return (it->has_value = loadfirstvalue(it));
     }
     uint16_t low16 = (uint16_t)it->current_value;
-    if (container_iterator_next_inline(it->container, it->typecode,
-                                       &it->container_it, &low16)) {
+    if (container_iterator_next(it->container, it->typecode, &it->container_it,
+                                &low16)) {
         it->current_value = it->highbits | low16;
         return (it->has_value = true);
     }
@@ -1850,8 +1848,8 @@ bool roaring_uint32_iterator_previous(roaring_uint32_iterator_t *it) {
         return (it->has_value = loadlastvalue(it));
     }
     uint16_t low16 = (uint16_t)it->current_value;
-    if (container_iterator_prev_inline(it->container, it->typecode,
-                                       &it->container_it, &low16)) {
+    if (container_iterator_prev(it->container, it->typecode, &it->container_it,
+                                &low16)) {
         it->current_value = it->highbits | low16;
         return (it->has_value = true);
     }
diff --git a/src/roaring64.c b/src/roaring64.c
@@ -17,8 +17,6 @@
 // containers.h last to avoid conflict with ROARING_CONTAINER_T.
 #include <roaring/containers/containers.h>
 
-#include "roaring_internal_inline.h"
-
 #define CROARING_ALIGN_BUF(buf, alignment)          \
     (char *)(((uintptr_t)(buf) + ((alignment)-1)) & \
              (ptrdiff_t)(~((alignment)-1)))
@@ -2610,9 +2608,8 @@ bool roaring64_iterator_advance(roaring64_iterator_t *it) {
     }
     leaf_t leaf = (leaf_t)*it->art_it.value;
     uint16_t low16 = (uint16_t)it->value;
-    if (container_iterator_next_inline(get_container(it->r, leaf),
-                                       get_typecode(leaf), &it->container_it,
-                                       &low16)) {
+    if (container_iterator_next(get_container(it->r, leaf), get_typecode(leaf),
+                                &it->container_it, &low16)) {
         it->value = it->high48 | low16;
         return (it->has_value = true);
     }
@@ -2634,9 +2631,8 @@ bool roaring64_iterator_previous(roaring64_iterator_t *it) {
     }
     leaf_t leaf = (leaf_t)*it->art_it.value;
     uint16_t low16 = (uint16_t)it->value;
-    if (container_iterator_prev_inline(get_container(it->r, leaf),
-                                       get_typecode(leaf), &it->container_it,
-                                       &low16)) {
+    if (container_iterator_prev(get_container(it->r, leaf), get_typecode(leaf),
+                                &it->container_it, &low16)) {
         it->value = it->high48 | low16;
         return (it->has_value = true);
     }
diff --git a/src/roaring_internal_inline.h b/src/roaring_internal_inline.h
