mdbxmou 0.1.26

package/deps/libmdbx/src/spill.c

@@ -0,0 +1,431 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+void spill_remove(MDBX_txn *txn, size_t idx, size_t npages) {
+  tASSERT(txn, idx > 0 && idx <= MDBX_PNL_GETSIZE(txn->tw.spilled.list) && txn->tw.spilled.least_removed > 0);
+  txn->tw.spilled.least_removed = (idx < txn->tw.spilled.least_removed) ? idx : txn->tw.spilled.least_removed;
+  txn->tw.spilled.list[idx] |= 1;
+  MDBX_PNL_SETSIZE(txn->tw.spilled.list,
+                   MDBX_PNL_GETSIZE(txn->tw.spilled.list) - (idx == MDBX_PNL_GETSIZE(txn->tw.spilled.list)));
+
+  while (unlikely(npages > 1)) {
+    const pgno_t pgno = (txn->tw.spilled.list[idx] >> 1) + 1;
+    if (MDBX_PNL_ASCENDING) {
+      if (++idx > MDBX_PNL_GETSIZE(txn->tw.spilled.list) || (txn->tw.spilled.list[idx] >> 1) != pgno)
+        return;
+    } else {
+      if (--idx < 1 || (txn->tw.spilled.list[idx] >> 1) != pgno)
+        return;
+      txn->tw.spilled.least_removed = (idx < txn->tw.spilled.least_removed) ? idx : txn->tw.spilled.least_removed;
+    }
+    txn->tw.spilled.list[idx] |= 1;
+    MDBX_PNL_SETSIZE(txn->tw.spilled.list,
+                     MDBX_PNL_GETSIZE(txn->tw.spilled.list) - (idx == MDBX_PNL_GETSIZE(txn->tw.spilled.list)));
+    --npages;
+  }
+}
+
+pnl_t spill_purge(MDBX_txn *txn) {
+  tASSERT(txn, txn->tw.spilled.least_removed > 0);
+  const pnl_t sl = txn->tw.spilled.list;
+  if (txn->tw.spilled.least_removed != INT_MAX) {
+    size_t len = MDBX_PNL_GETSIZE(sl), r, w;
+    for (w = r = txn->tw.spilled.least_removed; r <= len; ++r) {
+      sl[w] = sl[r];
+      w += 1 - (sl[r] & 1);
+    }
+    for (size_t i = 1; i < w; ++i)
+      tASSERT(txn, (sl[i] & 1) == 0);
+    MDBX_PNL_SETSIZE(sl, w - 1);
+    txn->tw.spilled.least_removed = INT_MAX;
+  } else {
+    for (size_t i = 1; i <= MDBX_PNL_GETSIZE(sl); ++i)
+      tASSERT(txn, (sl[i] & 1) == 0);
+  }
+  return sl;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int spill_page(MDBX_txn *txn, iov_ctx_t *ctx, page_t *dp, const size_t npages) {
+  tASSERT(txn, !(txn->flags & MDBX_WRITEMAP));
+#if MDBX_ENABLE_PGOP_STAT
+  txn->env->lck->pgops.spill.weak += npages;
+#endif /* MDBX_ENABLE_PGOP_STAT */
+  const pgno_t pgno = dp->pgno;
+  int err = iov_page(txn, ctx, dp, npages);
+  if (likely(err == MDBX_SUCCESS))
+    err = spill_append_span(&txn->tw.spilled.list, pgno, npages);
+  return err;
+}
+
+/* Set unspillable LRU-label for dirty pages watched by txn.
+ * Returns the number of pages marked as unspillable. */
+static size_t spill_cursor_keep(const MDBX_txn *const txn, const MDBX_cursor *mc) {
+  tASSERT(txn, (txn->flags & (MDBX_TXN_RDONLY | MDBX_WRITEMAP)) == 0);
+  size_t keep = 0;
+  while (!is_poor(mc)) {
+    tASSERT(txn, mc->top >= 0);
+    const page_t *mp;
+    intptr_t i = 0;
+    do {
+      mp = mc->pg[i];
+      tASSERT(txn, !is_subpage(mp));
+      if (is_modifable(txn, mp)) {
+        size_t const n = dpl_search(txn, mp->pgno);
+        if (txn->tw.dirtylist->items[n].pgno == mp->pgno &&
+            /* не считаем дважды */ dpl_age(txn, n)) {
+          size_t *const ptr = ptr_disp(txn->tw.dirtylist->items[n].ptr, -(ptrdiff_t)sizeof(size_t));
+          *ptr = txn->tw.dirtylru;
+          tASSERT(txn, dpl_age(txn, n) == 0);
+          ++keep;
+        }
+      }
+    } while (++i <= mc->top);
+
+    tASSERT(txn, is_leaf(mp));
+    if (!mc->subcur || mc->ki[mc->top] >= page_numkeys(mp))
+      break;
+    if (!(node_flags(page_node(mp, mc->ki[mc->top])) & N_TREE))
+      break;
+    mc = &mc->subcur->cursor;
+  }
+  return keep;
+}
+
+static size_t spill_txn_keep(MDBX_txn *txn, MDBX_cursor *m0) {
+  tASSERT(txn, (txn->flags & (MDBX_TXN_RDONLY | MDBX_WRITEMAP)) == 0);
+  dpl_lru_turn(txn);
+  size_t keep = m0 ? spill_cursor_keep(txn, m0) : 0;
+
+  TXN_FOREACH_DBI_ALL(txn, dbi) {
+    if (F_ISSET(txn->dbi_state[dbi], DBI_DIRTY | DBI_VALID) && txn->dbs[dbi].root != P_INVALID)
+      for (MDBX_cursor *mc = txn->cursors[dbi]; mc; mc = mc->next)
+        if (mc != m0)
+          keep += spill_cursor_keep(txn, mc);
+  }
+
+  return keep;
+}
+
+/* Returns the spilling priority (0..255) for a dirty page:
+ *      0 = should be spilled;
+ *    ...
+ *  > 255 = must not be spilled. */
+MDBX_NOTHROW_PURE_FUNCTION static unsigned spill_prio(const MDBX_txn *txn, const size_t i, const uint32_t reciprocal) {
+  dpl_t *const dl = txn->tw.dirtylist;
+  const uint32_t age = dpl_age(txn, i);
+  const size_t npages = dpl_npages(dl, i);
+  const pgno_t pgno = dl->items[i].pgno;
+  if (age == 0) {
+    DEBUG("skip %s %zu page %" PRIaPGNO, "keep", npages, pgno);
+    return 256;
+  }
+
+  page_t *const dp = dl->items[i].ptr;
+  if (dp->flags & (P_LOOSE | P_SPILLED)) {
+    DEBUG("skip %s %zu page %" PRIaPGNO, (dp->flags & P_LOOSE) ? "loose" : "parent-spilled", npages, pgno);
+    return 256;
+  }
+
+  /* Can't spill twice,
+   * make sure it's not already in a parent's spill list(s). */
+  MDBX_txn *parent = txn->parent;
+  if (parent && (parent->flags & MDBX_TXN_SPILLS)) {
+    do
+      if (spill_intersect(parent, pgno, npages)) {
+        DEBUG("skip-2 parent-spilled %zu page %" PRIaPGNO, npages, pgno);
+        dp->flags |= P_SPILLED;
+        return 256;
+      }
+    while ((parent = parent->parent) != nullptr);
+  }
+
+  tASSERT(txn, age * (uint64_t)reciprocal < UINT32_MAX);
+  unsigned prio = age * reciprocal >> 24;
+  tASSERT(txn, prio < 256);
+  if (likely(npages == 1))
+    return prio = 256 - prio;
+
+  /* make a large/overflow pages be likely to spill */
+  size_t factor = npages | npages >> 1;
+  factor |= factor >> 2;
+  factor |= factor >> 4;
+  factor |= factor >> 8;
+  factor |= factor >> 16;
+  factor = (size_t)prio * log2n_powerof2(factor + 1) + /* golden ratio */ 157;
+  factor = (factor < 256) ? 255 - factor : 0;
+  tASSERT(txn, factor < 256 && factor < (256 - prio));
+  return prio = (unsigned)factor;
+}
+
+static size_t spill_gate(const MDBX_env *env, intptr_t part, const size_t total) {
+  const intptr_t spill_min = env->options.spill_min_denominator
+                                 ? (total + env->options.spill_min_denominator - 1) / env->options.spill_min_denominator
+                                 : 1;
+  const intptr_t spill_max =
+      total - (env->options.spill_max_denominator ? total / env->options.spill_max_denominator : 0);
+  part = (part < spill_max) ? part : spill_max;
+  part = (part > spill_min) ? part : spill_min;
+  eASSERT(env, part >= 0 && (size_t)part <= total);
+  return (size_t)part;
+}
+
+__cold int spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0, const intptr_t wanna_spill_entries,
+                          const intptr_t wanna_spill_npages, const size_t need) {
+  tASSERT(txn, (txn->flags & MDBX_TXN_RDONLY) == 0);
+
+  int rc = MDBX_SUCCESS;
+  if (unlikely(txn->tw.loose_count >=
+               (txn->tw.dirtylist ? txn->tw.dirtylist->pages_including_loose : txn->tw.writemap_dirty_npages)))
+    goto done;
+
+  const size_t dirty_entries = txn->tw.dirtylist ? (txn->tw.dirtylist->length - txn->tw.loose_count) : 1;
+  const size_t dirty_npages =
+      (txn->tw.dirtylist ? txn->tw.dirtylist->pages_including_loose : txn->tw.writemap_dirty_npages) -
+      txn->tw.loose_count;
+  const size_t need_spill_entries = spill_gate(txn->env, wanna_spill_entries, dirty_entries);
+  const size_t need_spill_npages = spill_gate(txn->env, wanna_spill_npages, dirty_npages);
+
+  const size_t need_spill = (need_spill_entries > need_spill_npages) ? need_spill_entries : need_spill_npages;
+  if (!need_spill)
+    goto done;
+
+  if (txn->flags & MDBX_WRITEMAP) {
+    NOTICE("%s-spilling %zu dirty-entries, %zu dirty-npages", "msync", dirty_entries, dirty_npages);
+    const MDBX_env *env = txn->env;
+    tASSERT(txn, txn->tw.spilled.list == nullptr);
+    rc = osal_msync(&txn->env->dxb_mmap, 0, pgno_align2os_bytes(env, txn->geo.first_unallocated), MDBX_SYNC_KICK);
+    if (unlikely(rc != MDBX_SUCCESS))
+      goto bailout;
+#if MDBX_AVOID_MSYNC
+    MDBX_ANALYSIS_ASSUME(txn->tw.dirtylist != nullptr);
+    tASSERT(txn, dpl_check(txn));
+    env->lck->unsynced_pages.weak += txn->tw.dirtylist->pages_including_loose - txn->tw.loose_count;
+    dpl_clear(txn->tw.dirtylist);
+    txn->tw.dirtyroom = env->options.dp_limit - txn->tw.loose_count;
+    for (page_t *lp = txn->tw.loose_pages; lp != nullptr; lp = page_next(lp)) {
+      tASSERT(txn, lp->flags == P_LOOSE);
+      rc = dpl_append(txn, lp->pgno, lp, 1);
+      if (unlikely(rc != MDBX_SUCCESS))
+        goto bailout;
+      MDBX_ASAN_UNPOISON_MEMORY_REGION(&page_next(lp), sizeof(page_t *));
+      VALGRIND_MAKE_MEM_DEFINED(&page_next(lp), sizeof(page_t *));
+    }
+    tASSERT(txn, dpl_check(txn));
+#else
+    tASSERT(txn, txn->tw.dirtylist == nullptr);
+    env->lck->unsynced_pages.weak += txn->tw.writemap_dirty_npages;
+    txn->tw.writemap_spilled_npages += txn->tw.writemap_dirty_npages;
+    txn->tw.writemap_dirty_npages = 0;
+#endif /* MDBX_AVOID_MSYNC */
+    goto done;
+  }
+
+  NOTICE("%s-spilling %zu dirty-entries, %zu dirty-npages", "write", need_spill_entries, need_spill_npages);
+  MDBX_ANALYSIS_ASSUME(txn->tw.dirtylist != nullptr);
+  tASSERT(txn, txn->tw.dirtylist->length - txn->tw.loose_count >= 1);
+  tASSERT(txn, txn->tw.dirtylist->pages_including_loose - txn->tw.loose_count >= need_spill_npages);
+  if (!txn->tw.spilled.list) {
+    txn->tw.spilled.least_removed = INT_MAX;
+    txn->tw.spilled.list = pnl_alloc(need_spill);
+    if (unlikely(!txn->tw.spilled.list)) {
+      rc = MDBX_ENOMEM;
+    bailout:
+      txn->flags |= MDBX_TXN_ERROR;
+      return rc;
+    }
+  } else {
+    /* purge deleted slots */
+    spill_purge(txn);
+    rc = pnl_reserve(&txn->tw.spilled.list, need_spill);
+    (void)rc /* ignore since the resulting list may be shorter
+     and pnl_append() will increase pnl on demand */
+        ;
+  }
+
+  /* Сортируем чтобы запись на диск была полее последовательна */
+  dpl_t *const dl = dpl_sort(txn);
+
+  /* Preserve pages which may soon be dirtied again */
+  const size_t unspillable = spill_txn_keep(txn, m0);
+  if (unspillable + txn->tw.loose_count >= dl->length) {
+#if xMDBX_DEBUG_SPILLING == 1 /* avoid false failure in debug mode  */
+    if (likely(txn->tw.dirtyroom + txn->tw.loose_count >= need))
+      return MDBX_SUCCESS;
+#endif /* xMDBX_DEBUG_SPILLING */
+    ERROR("all %zu dirty pages are unspillable since referenced "
+          "by a cursor(s), use fewer cursors or increase "
+          "MDBX_opt_txn_dp_limit",
+          unspillable);
+    goto done;
+  }
+
+  /* Подзадача: Вытолкнуть часть страниц на диск в соответствии с LRU,
+   * но при этом учесть важные поправки:
+   *  - лучше выталкивать старые large/overflow страницы, так будет освобождено
+   *    больше памяти, а также так как они (в текущем понимании) гораздо реже
+   *    повторно изменяются;
+   *  - при прочих равных лучше выталкивать смежные страницы, так будет
+   *    меньше I/O операций;
+   *  - желательно потратить на это меньше времени чем std::partial_sort_copy;
+   *
+   * Решение:
+   *  - Квантуем весь диапазон lru-меток до 256 значений и задействуем один
+   *    проход 8-битного radix-sort. В результате получаем 256 уровней
+   *    "свежести", в том числе значение lru-метки, старее которой страницы
+   *    должны быть выгружены;
+   *  - Двигаемся последовательно в сторону увеличения номеров страниц
+   *    и выталкиваем страницы с lru-меткой старее отсекающего значения,
+   *    пока не вытолкнем достаточно;
+   *  - Встречая страницы смежные с выталкиваемыми для уменьшения кол-ва
+   *    I/O операций выталкиваем и их, если они попадают в первую половину
+   *    между выталкиваемыми и самыми свежими lru-метками;
+   *  - дополнительно при сортировке умышленно старим large/overflow страницы,
+   *    тем самым повышая их шансы на выталкивание. */
+
+  /* get min/max of LRU-labels */
+  uint32_t age_max = 0;
+  for (size_t i = 1; i <= dl->length; ++i) {
+    const uint32_t age = dpl_age(txn, i);
+    age_max = (age_max >= age) ? age_max : age;
+  }
+
+  VERBOSE("lru-head %u, age-max %u", txn->tw.dirtylru, age_max);
+
+  /* half of 8-bit radix-sort */
+  pgno_t radix_entries[256], radix_npages[256];
+  memset(&radix_entries, 0, sizeof(radix_entries));
+  memset(&radix_npages, 0, sizeof(radix_npages));
+  size_t spillable_entries = 0, spillable_npages = 0;
+  const uint32_t reciprocal = (UINT32_C(255) << 24) / (age_max + 1);
+  for (size_t i = 1; i <= dl->length; ++i) {
+    const unsigned prio = spill_prio(txn, i, reciprocal);
+    size_t *const ptr = ptr_disp(dl->items[i].ptr, -(ptrdiff_t)sizeof(size_t));
+    TRACE("page %" PRIaPGNO ", lru %zu, is_multi %c, npages %u, age %u of %u, prio %u", dl->items[i].pgno, *ptr,
+          (dl->items[i].npages > 1) ? 'Y' : 'N', dpl_npages(dl, i), dpl_age(txn, i), age_max, prio);
+    if (prio < 256) {
+      radix_entries[prio] += 1;
+      spillable_entries += 1;
+      const pgno_t npages = dpl_npages(dl, i);
+      radix_npages[prio] += npages;
+      spillable_npages += npages;
+    }
+  }
+
+  tASSERT(txn, spillable_npages >= spillable_entries);
+  pgno_t spilled_entries = 0, spilled_npages = 0;
+  if (likely(spillable_entries > 0)) {
+    size_t prio2spill = 0, prio2adjacent = 128, amount_entries = radix_entries[0], amount_npages = radix_npages[0];
+    for (size_t i = 1; i < 256; i++) {
+      if (amount_entries < need_spill_entries || amount_npages < need_spill_npages) {
+        prio2spill = i;
+        prio2adjacent = i + (257 - i) / 2;
+        amount_entries += radix_entries[i];
+        amount_npages += radix_npages[i];
+      } else if (amount_entries + amount_entries < spillable_entries + need_spill_entries
+                 /* РАВНОЗНАЧНО: amount - need_spill < spillable - amount */
+                 || amount_npages + amount_npages < spillable_npages + need_spill_npages) {
+        prio2adjacent = i;
+        amount_entries += radix_entries[i];
+        amount_npages += radix_npages[i];
+      } else
+        break;
+    }
+
+    VERBOSE("prio2spill %zu, prio2adjacent %zu, spillable %zu/%zu,"
+            " wanna-spill %zu/%zu, amount %zu/%zu",
+            prio2spill, prio2adjacent, spillable_entries, spillable_npages, need_spill_entries, need_spill_npages,
+            amount_entries, amount_npages);
+    tASSERT(txn, prio2spill < prio2adjacent && prio2adjacent <= 256);
+
+    iov_ctx_t ctx;
+    rc = iov_init(txn, &ctx, amount_entries, amount_npages,
+#if defined(_WIN32) || defined(_WIN64)
+                  txn->env->ioring.overlapped_fd ? txn->env->ioring.overlapped_fd :
+#endif
+                                                 txn->env->lazy_fd,
+                  true);
+    if (unlikely(rc != MDBX_SUCCESS))
+      goto bailout;
+
+    size_t r = 0, w = 0;
+    pgno_t last = 0;
+    while (r < dl->length && (spilled_entries < need_spill_entries || spilled_npages < need_spill_npages)) {
+      dl->items[++w] = dl->items[++r];
+      unsigned prio = spill_prio(txn, w, reciprocal);
+      if (prio > prio2spill && (prio >= prio2adjacent || last != dl->items[w].pgno))
+        continue;
+
+      const size_t e = w;
+      last = dpl_endpgno(dl, w);
+      while (--w && dpl_endpgno(dl, w) == dl->items[w + 1].pgno && spill_prio(txn, w, reciprocal) < prio2adjacent)
+        ;
+
+      for (size_t i = w; ++i <= e;) {
+        const unsigned npages = dpl_npages(dl, i);
+        prio = spill_prio(txn, i, reciprocal);
+        DEBUG("%sspill[%zu] %u page %" PRIaPGNO " (age %d, prio %u)", (prio > prio2spill) ? "co-" : "", i, npages,
+              dl->items[i].pgno, dpl_age(txn, i), prio);
+        tASSERT(txn, prio < 256);
+        ++spilled_entries;
+        spilled_npages += npages;
+        rc = spill_page(txn, &ctx, dl->items[i].ptr, npages);
+        if (unlikely(rc != MDBX_SUCCESS))
+          goto failed;
+      }
+    }
+
+    VERBOSE("spilled entries %u, spilled npages %u", spilled_entries, spilled_npages);
+    tASSERT(txn, spillable_entries == 0 || spilled_entries > 0);
+    tASSERT(txn, spilled_npages >= spilled_entries);
+
+  failed:
+    while (r < dl->length)
+      dl->items[++w] = dl->items[++r];
+    tASSERT(txn, r - w == spilled_entries || rc != MDBX_SUCCESS);
+
+    dl->sorted = dpl_setlen(dl, w);
+    txn->tw.dirtyroom += spilled_entries;
+    txn->tw.dirtylist->pages_including_loose -= spilled_npages;
+    tASSERT(txn, dpl_check(txn));
+
+    if (!iov_empty(&ctx)) {
+      tASSERT(txn, rc == MDBX_SUCCESS);
+      rc = iov_write(&ctx);
+    }
+    if (unlikely(rc != MDBX_SUCCESS))
+      goto bailout;
+
+    txn->env->lck->unsynced_pages.weak += spilled_npages;
+    pnl_sort(txn->tw.spilled.list, (size_t)txn->geo.first_unallocated << 1);
+    txn->flags |= MDBX_TXN_SPILLS;
+    NOTICE("spilled %u dirty-entries, %u dirty-npages, now have %zu dirty-room", spilled_entries, spilled_npages,
+           txn->tw.dirtyroom);
+  } else {
+    tASSERT(txn, rc == MDBX_SUCCESS);
+    for (size_t i = 1; i <= dl->length; ++i) {
+      page_t *dp = dl->items[i].ptr;
+      VERBOSE("unspillable[%zu]: pgno %u, npages %u, flags 0x%04X, age %u, prio %u", i, dp->pgno, dpl_npages(dl, i),
+              dp->flags, dpl_age(txn, i), spill_prio(txn, i, reciprocal));
+    }
+  }
+
+#if xMDBX_DEBUG_SPILLING == 2
+  if (txn->tw.loose_count + txn->tw.dirtyroom <= need / 2 + 1)
+    ERROR("dirty-list length: before %zu, after %zu, parent %zi, loose %zu; "
+          "needed %zu, spillable %zu; "
+          "spilled %u dirty-entries, now have %zu dirty-room",
+          dl->length + spilled_entries, dl->length,
+          (txn->parent && txn->parent->tw.dirtylist) ? (intptr_t)txn->parent->tw.dirtylist->length : -1,
+          txn->tw.loose_count, need, spillable_entries, spilled_entries, txn->tw.dirtyroom);
+  ENSURE(txn->env, txn->tw.loose_count + txn->tw.dirtyroom > need / 2);
+#endif /* xMDBX_DEBUG_SPILLING */
+
+done:
+  return likely(txn->tw.dirtyroom + txn->tw.loose_count > ((need > CURSOR_STACK_SIZE) ? CURSOR_STACK_SIZE : need))
+             ? MDBX_SUCCESS
+             : MDBX_TXN_FULL;
+}

package/deps/libmdbx/src/spill.h

@@ -0,0 +1,74 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+#include "essentials.h"
+
+MDBX_INTERNAL void spill_remove(MDBX_txn *txn, size_t idx, size_t npages);
+MDBX_INTERNAL pnl_t spill_purge(MDBX_txn *txn);
+MDBX_INTERNAL int spill_slowpath(MDBX_txn *const txn, MDBX_cursor *const m0, const intptr_t wanna_spill_entries,
+                                 const intptr_t wanna_spill_npages, const size_t need);
+/*----------------------------------------------------------------------------*/
+
+static inline size_t spill_search(const MDBX_txn *txn, pgno_t pgno) {
+  tASSERT(txn, (txn->flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
+  const pnl_t pnl = txn->tw.spilled.list;
+  if (likely(!pnl))
+    return 0;
+  pgno <<= 1;
+  size_t n = pnl_search(pnl, pgno, (size_t)MAX_PAGENO + MAX_PAGENO + 1);
+  return (n <= MDBX_PNL_GETSIZE(pnl) && pnl[n] == pgno) ? n : 0;
+}
+
+static inline bool spill_intersect(const MDBX_txn *txn, pgno_t pgno, size_t npages) {
+  const pnl_t pnl = txn->tw.spilled.list;
+  if (likely(!pnl))
+    return false;
+  const size_t len = MDBX_PNL_GETSIZE(pnl);
+  if (LOG_ENABLED(MDBX_LOG_EXTRA)) {
+    DEBUG_EXTRA("PNL len %zu [", len);
+    for (size_t i = 1; i <= len; ++i)
+      DEBUG_EXTRA_PRINT(" %li", (pnl[i] & 1) ? -(long)(pnl[i] >> 1) : (long)(pnl[i] >> 1));
+    DEBUG_EXTRA_PRINT("%s\n", "]");
+  }
+  const pgno_t spilled_range_begin = pgno << 1;
+  const pgno_t spilled_range_last = ((pgno + (pgno_t)npages) << 1) - 1;
+#if MDBX_PNL_ASCENDING
+  const size_t n = pnl_search(pnl, spilled_range_begin, (size_t)(MAX_PAGENO + 1) << 1);
+  tASSERT(txn, n && (n == MDBX_PNL_GETSIZE(pnl) + 1 || spilled_range_begin <= pnl[n]));
+  const bool rc = n <= MDBX_PNL_GETSIZE(pnl) && pnl[n] <= spilled_range_last;
+#else
+  const size_t n = pnl_search(pnl, spilled_range_last, (size_t)MAX_PAGENO + MAX_PAGENO + 1);
+  tASSERT(txn, n && (n == MDBX_PNL_GETSIZE(pnl) + 1 || spilled_range_last >= pnl[n]));
+  const bool rc = n <= MDBX_PNL_GETSIZE(pnl) && pnl[n] >= spilled_range_begin;
+#endif
+  if (ASSERT_ENABLED()) {
+    bool check = false;
+    for (size_t i = 0; i < npages; ++i)
+      check |= spill_search(txn, (pgno_t)(pgno + i)) != 0;
+    tASSERT(txn, check == rc);
+  }
+  return rc;
+}
+
+static inline int txn_spill(MDBX_txn *const txn, MDBX_cursor *const m0, const size_t need) {
+  tASSERT(txn, (txn->flags & MDBX_TXN_RDONLY) == 0);
+  tASSERT(txn, !m0 || cursor_is_tracked(m0));
+
+  const intptr_t wanna_spill_entries = txn->tw.dirtylist ? (need - txn->tw.dirtyroom - txn->tw.loose_count) : 0;
+  const intptr_t wanna_spill_npages =
+      need + (txn->tw.dirtylist ? txn->tw.dirtylist->pages_including_loose : txn->tw.writemap_dirty_npages) -
+      txn->tw.loose_count - txn->env->options.dp_limit;
+
+  /* production mode */
+  if (likely(wanna_spill_npages < 1 && wanna_spill_entries < 1)
+#if xMDBX_DEBUG_SPILLING == 1
+      /* debug mode: always try to spill if xMDBX_DEBUG_SPILLING == 1 */
+      && txn->txnid % 23 > 11
+#endif
+  )
+    return MDBX_SUCCESS;
+
+  return spill_slowpath(txn, m0, wanna_spill_entries, wanna_spill_npages, need);
+}

package/deps/libmdbx/src/table.c

@@ -0,0 +1,107 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+int tbl_setup(const MDBX_env *env, volatile kvx_t *const kvx, const tree_t *const db) {
+  osal_memory_fence(mo_AcquireRelease, false);
+
+  if (unlikely(!check_table_flags(db->flags))) {
+    ERROR("incompatible or invalid db.flags (0x%x) ", db->flags);
+    return MDBX_INCOMPATIBLE;
+  }
+
+  size_t v_lmin = valsize_min(db->flags);
+  size_t v_lmax = env_valsize_max(env, db->flags);
+  if ((db->flags & (MDBX_DUPFIXED | MDBX_INTEGERDUP)) != 0 && db->dupfix_size) {
+    if (!MDBX_DISABLE_VALIDATION && unlikely(db->dupfix_size < v_lmin || db->dupfix_size > v_lmax)) {
+      ERROR("db.dupfix_size (%u) <> min/max value-length (%zu/%zu)", db->dupfix_size, v_lmin, v_lmax);
+      return MDBX_CORRUPTED;
+    }
+    v_lmin = v_lmax = db->dupfix_size;
+  }
+
+  kvx->clc.k.lmin = keysize_min(db->flags);
+  kvx->clc.k.lmax = env_keysize_max(env, db->flags);
+  if (unlikely(!kvx->clc.k.cmp)) {
+    kvx->clc.v.cmp = builtin_datacmp(db->flags);
+    kvx->clc.k.cmp = builtin_keycmp(db->flags);
+  }
+  kvx->clc.v.lmin = v_lmin;
+  osal_memory_fence(mo_Relaxed, true);
+  kvx->clc.v.lmax = v_lmax;
+  osal_memory_fence(mo_AcquireRelease, true);
+
+  eASSERT(env, kvx->clc.k.lmax >= kvx->clc.k.lmin);
+  eASSERT(env, kvx->clc.v.lmax >= kvx->clc.v.lmin);
+  return MDBX_SUCCESS;
+}
+
+int tbl_fetch(MDBX_txn *txn, size_t dbi) {
+  cursor_couple_t couple;
+  int rc = cursor_init(&couple.outer, txn, MAIN_DBI);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  kvx_t *const kvx = &txn->env->kvs[dbi];
+  rc = tree_search(&couple.outer, &kvx->name, 0);
+  if (unlikely(rc != MDBX_SUCCESS)) {
+  bailout:
+    NOTICE("dbi %zu refs to inaccessible table `%.*s` for txn %" PRIaTXN " (err %d)", dbi, (int)kvx->name.iov_len,
+           (const char *)kvx->name.iov_base, txn->txnid, rc);
+    return (rc == MDBX_NOTFOUND) ? MDBX_BAD_DBI : rc;
+  }
+
+  MDBX_val data;
+  struct node_search_result nsr = node_search(&couple.outer, &kvx->name);
+  if (unlikely(!nsr.exact)) {
+    rc = MDBX_NOTFOUND;
+    goto bailout;
+  }
+  if (unlikely((node_flags(nsr.node) & (N_DUP | N_TREE)) != N_TREE)) {
+    NOTICE("dbi %zu refs to not a named table `%.*s` for txn %" PRIaTXN " (%s)", dbi, (int)kvx->name.iov_len,
+           (const char *)kvx->name.iov_base, txn->txnid, "wrong flags");
+    return MDBX_INCOMPATIBLE; /* not a named DB */
+  }
+
+  rc = node_read(&couple.outer, nsr.node, &data, couple.outer.pg[couple.outer.top]);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  if (unlikely(data.iov_len != sizeof(tree_t))) {
+    NOTICE("dbi %zu refs to not a named table `%.*s` for txn %" PRIaTXN " (%s)", dbi, (int)kvx->name.iov_len,
+           (const char *)kvx->name.iov_base, txn->txnid, "wrong rec-size");
+    return MDBX_INCOMPATIBLE; /* not a named DB */
+  }
+
+  uint16_t flags = UNALIGNED_PEEK_16(data.iov_base, tree_t, flags);
+  /* The txn may not know this DBI, or another process may
+   * have dropped and recreated the DB with other flags. */
+  tree_t *const db = &txn->dbs[dbi];
+  if (unlikely((db->flags & DB_PERSISTENT_FLAGS) != flags)) {
+    NOTICE("dbi %zu refs to the re-created table `%.*s` for txn %" PRIaTXN
+           " with different flags (present 0x%X != wanna 0x%X)",
+           dbi, (int)kvx->name.iov_len, (const char *)kvx->name.iov_base, txn->txnid, db->flags & DB_PERSISTENT_FLAGS,
+           flags);
+    return MDBX_INCOMPATIBLE;
+  }
+
+  memcpy(db, data.iov_base, sizeof(tree_t));
+#if !MDBX_DISABLE_VALIDATION
+  const txnid_t pp_txnid = couple.outer.pg[couple.outer.top]->txnid;
+  tASSERT(txn, txn->front_txnid >= pp_txnid);
+  if (unlikely(db->mod_txnid > pp_txnid)) {
+    ERROR("db.mod_txnid (%" PRIaTXN ") > page-txnid (%" PRIaTXN ")", db->mod_txnid, pp_txnid);
+    return MDBX_CORRUPTED;
+  }
+#endif /* !MDBX_DISABLE_VALIDATION */
+  rc = tbl_setup_ifneed(txn->env, kvx, db);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  if (unlikely(dbi_changed(txn, dbi)))
+    return MDBX_BAD_DBI;
+
+  txn->dbi_state[dbi] &= ~DBI_STALE;
+  return MDBX_SUCCESS;
+}