mdbxmou 0.1.26

package/deps/libmdbx/src/page-ops.h

@@ -0,0 +1,142 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+#include "essentials.h"
+
+MDBX_INTERNAL int __must_check_result tree_search_finalize(MDBX_cursor *mc, const MDBX_val *key, int flags);
+MDBX_INTERNAL int tree_search_lowest(MDBX_cursor *mc);
+
+enum page_search_flags {
+  Z_MODIFY = 1,
+  Z_ROOTONLY = 2,
+  Z_FIRST = 4,
+  Z_LAST = 8,
+};
+MDBX_INTERNAL int __must_check_result tree_search(MDBX_cursor *mc, const MDBX_val *key, int flags);
+
+#define MDBX_SPLIT_REPLACE MDBX_APPENDDUP /* newkey is not new */
+MDBX_INTERNAL int __must_check_result page_split(MDBX_cursor *mc, const MDBX_val *const newkey, MDBX_val *const newdata,
+                                                 pgno_t newpgno, const unsigned naf);
+
+/*----------------------------------------------------------------------------*/
+
+MDBX_INTERNAL int MDBX_PRINTF_ARGS(2, 3) bad_page(const page_t *mp, const char *fmt, ...);
+
+MDBX_INTERNAL void MDBX_PRINTF_ARGS(2, 3) poor_page(const page_t *mp, const char *fmt, ...);
+
+MDBX_NOTHROW_PURE_FUNCTION static inline bool is_frozen(const MDBX_txn *txn, const page_t *mp) {
+  return mp->txnid < txn->txnid;
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline bool is_spilled(const MDBX_txn *txn, const page_t *mp) {
+  return mp->txnid == txn->txnid;
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline bool is_shadowed(const MDBX_txn *txn, const page_t *mp) {
+  return mp->txnid > txn->txnid;
+}
+
+MDBX_MAYBE_UNUSED MDBX_NOTHROW_PURE_FUNCTION static inline bool is_correct(const MDBX_txn *txn, const page_t *mp) {
+  return mp->txnid <= txn->front_txnid;
+}
+
+MDBX_NOTHROW_PURE_FUNCTION static inline bool is_modifable(const MDBX_txn *txn, const page_t *mp) {
+  return mp->txnid == txn->front_txnid;
+}
+
+MDBX_INTERNAL int __must_check_result page_check(const MDBX_cursor *const mc, const page_t *const mp);
+
+MDBX_INTERNAL pgr_t page_get_any(const MDBX_cursor *const mc, const pgno_t pgno, const txnid_t front);
+
+MDBX_INTERNAL pgr_t page_get_three(const MDBX_cursor *const mc, const pgno_t pgno, const txnid_t front);
+
+MDBX_INTERNAL pgr_t page_get_large(const MDBX_cursor *const mc, const pgno_t pgno, const txnid_t front);
+
+static inline int __must_check_result page_get(const MDBX_cursor *mc, const pgno_t pgno, page_t **mp,
+                                               const txnid_t front) {
+  pgr_t ret = page_get_three(mc, pgno, front);
+  *mp = ret.page;
+  return ret.err;
+}
+
+/*----------------------------------------------------------------------------*/
+
+MDBX_INTERNAL int __must_check_result page_dirty(MDBX_txn *txn, page_t *mp, size_t npages);
+MDBX_INTERNAL pgr_t page_new(MDBX_cursor *mc, const unsigned flags);
+MDBX_INTERNAL pgr_t page_new_large(MDBX_cursor *mc, const size_t npages);
+MDBX_INTERNAL int page_touch_modifable(MDBX_txn *txn, const page_t *const mp);
+MDBX_INTERNAL int page_touch_unmodifable(MDBX_txn *txn, MDBX_cursor *mc, const page_t *const mp);
+
+static inline int page_touch(MDBX_cursor *mc) {
+  page_t *const mp = mc->pg[mc->top];
+  MDBX_txn *txn = mc->txn;
+
+  tASSERT(txn, mc->txn->flags & MDBX_TXN_DIRTY);
+  tASSERT(txn, F_ISSET(*cursor_dbi_state(mc), DBI_LINDO | DBI_VALID | DBI_DIRTY));
+  tASSERT(txn, !is_largepage(mp));
+  if (ASSERT_ENABLED()) {
+    if (mc->flags & z_inner) {
+      subcur_t *mx = container_of(mc->tree, subcur_t, nested_tree);
+      cursor_couple_t *couple = container_of(mx, cursor_couple_t, inner);
+      tASSERT(txn, mc->tree == &couple->outer.subcur->nested_tree);
+      tASSERT(txn, &mc->clc->k == &couple->outer.clc->v);
+      tASSERT(txn, *couple->outer.dbi_state & DBI_DIRTY);
+    }
+    tASSERT(txn, dpl_check(txn));
+  }
+
+  if (is_modifable(txn, mp)) {
+    if (!txn->tw.dirtylist) {
+      tASSERT(txn, (txn->flags & MDBX_WRITEMAP) && !MDBX_AVOID_MSYNC);
+      return MDBX_SUCCESS;
+    }
+    return is_subpage(mp) ? MDBX_SUCCESS : page_touch_modifable(txn, mp);
+  }
+  return page_touch_unmodifable(txn, mc, mp);
+}
+
+MDBX_INTERNAL void page_copy(page_t *const dst, const page_t *const src, const size_t size);
+MDBX_INTERNAL pgr_t __must_check_result page_unspill(MDBX_txn *const txn, const page_t *const mp);
+
+MDBX_INTERNAL page_t *page_shadow_alloc(MDBX_txn *txn, size_t num);
+
+MDBX_INTERNAL void page_shadow_release(MDBX_env *env, page_t *dp, size_t npages);
+
+MDBX_INTERNAL int page_retire_ex(MDBX_cursor *mc, const pgno_t pgno, page_t *mp /* maybe null */,
+                                 unsigned pageflags /* maybe unknown/zero */);
+
+static inline int page_retire(MDBX_cursor *mc, page_t *mp) { return page_retire_ex(mc, mp->pgno, mp, mp->flags); }
+
+static inline void page_wash(MDBX_txn *txn, size_t di, page_t *const mp, const size_t npages) {
+  tASSERT(txn, (txn->flags & MDBX_TXN_RDONLY) == 0);
+  mp->txnid = INVALID_TXNID;
+  mp->flags = P_BAD;
+
+  if (txn->tw.dirtylist) {
+    tASSERT(txn, (txn->flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
+    tASSERT(txn, MDBX_AVOID_MSYNC || (di && txn->tw.dirtylist->items[di].ptr == mp));
+    if (!MDBX_AVOID_MSYNC || di) {
+      dpl_remove_ex(txn, di, npages);
+      txn->tw.dirtyroom++;
+      tASSERT(txn, txn->tw.dirtyroom + txn->tw.dirtylist->length ==
+                       (txn->parent ? txn->parent->tw.dirtyroom : txn->env->options.dp_limit));
+      if (!MDBX_AVOID_MSYNC || !(txn->flags & MDBX_WRITEMAP)) {
+        page_shadow_release(txn->env, mp, npages);
+        return;
+      }
+    }
+  } else {
+    tASSERT(txn, (txn->flags & MDBX_WRITEMAP) && !MDBX_AVOID_MSYNC && !di);
+    txn->tw.writemap_dirty_npages -= (txn->tw.writemap_dirty_npages > npages) ? npages : txn->tw.writemap_dirty_npages;
+  }
+  VALGRIND_MAKE_MEM_UNDEFINED(mp, PAGEHDRSZ);
+  VALGRIND_MAKE_MEM_NOACCESS(page_data(mp), pgno2bytes(txn->env, npages) - PAGEHDRSZ);
+  MDBX_ASAN_POISON_MEMORY_REGION(page_data(mp), pgno2bytes(txn->env, npages) - PAGEHDRSZ);
+}
+
+MDBX_INTERNAL size_t page_subleaf2_reserve(const MDBX_env *env, size_t host_page_room, size_t subpage_len,
+                                           size_t item_len);
+
+#define page_next(mp) (*(page_t **)ptr_disp((mp)->entries, sizeof(void *) - sizeof(uint32_t)))

package/deps/libmdbx/src/pnl.c

@@ -0,0 +1,236 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+pnl_t pnl_alloc(size_t size) {
+  size_t bytes = pnl_size2bytes(size);
+  pnl_t pnl = osal_malloc(bytes);
+  if (likely(pnl)) {
+#ifdef osal_malloc_usable_size
+    bytes = osal_malloc_usable_size(pnl);
+#endif /* osal_malloc_usable_size */
+    pnl[0] = pnl_bytes2size(bytes);
+    assert(pnl[0] >= size);
+    pnl += 1;
+    *pnl = 0;
+  }
+  return pnl;
+}
+
+void pnl_free(pnl_t pnl) {
+  if (likely(pnl))
+    osal_free(pnl - 1);
+}
+
+void pnl_shrink(pnl_t __restrict *__restrict ppnl) {
+  assert(pnl_bytes2size(pnl_size2bytes(MDBX_PNL_INITIAL)) >= MDBX_PNL_INITIAL &&
+         pnl_bytes2size(pnl_size2bytes(MDBX_PNL_INITIAL)) < MDBX_PNL_INITIAL * 3 / 2);
+  assert(MDBX_PNL_GETSIZE(*ppnl) <= PAGELIST_LIMIT && MDBX_PNL_ALLOCLEN(*ppnl) >= MDBX_PNL_GETSIZE(*ppnl));
+  MDBX_PNL_SETSIZE(*ppnl, 0);
+  if (unlikely(MDBX_PNL_ALLOCLEN(*ppnl) >
+               MDBX_PNL_INITIAL * (MDBX_PNL_PREALLOC_FOR_RADIXSORT ? 8 : 4) - MDBX_CACHELINE_SIZE / sizeof(pgno_t))) {
+    size_t bytes = pnl_size2bytes(MDBX_PNL_INITIAL * 2);
+    pnl_t pnl = osal_realloc(*ppnl - 1, bytes);
+    if (likely(pnl)) {
+#ifdef osal_malloc_usable_size
+      bytes = osal_malloc_usable_size(pnl);
+#endif /* osal_malloc_usable_size */
+      *pnl = pnl_bytes2size(bytes);
+      *ppnl = pnl + 1;
+    }
+  }
+}
+
+int pnl_reserve(pnl_t __restrict *__restrict ppnl, const size_t wanna) {
+  const size_t allocated = MDBX_PNL_ALLOCLEN(*ppnl);
+  assert(MDBX_PNL_GETSIZE(*ppnl) <= PAGELIST_LIMIT && MDBX_PNL_ALLOCLEN(*ppnl) >= MDBX_PNL_GETSIZE(*ppnl));
+  if (likely(allocated >= wanna))
+    return MDBX_SUCCESS;
+
+  if (unlikely(wanna > /* paranoia */ PAGELIST_LIMIT)) {
+    ERROR("PNL too long (%zu > %zu)", wanna, (size_t)PAGELIST_LIMIT);
+    return MDBX_TXN_FULL;
+  }
+
+  const size_t size = (wanna + wanna - allocated < PAGELIST_LIMIT) ? wanna + wanna - allocated : PAGELIST_LIMIT;
+  size_t bytes = pnl_size2bytes(size);
+  pnl_t pnl = osal_realloc(*ppnl - 1, bytes);
+  if (likely(pnl)) {
+#ifdef osal_malloc_usable_size
+    bytes = osal_malloc_usable_size(pnl);
+#endif /* osal_malloc_usable_size */
+    *pnl = pnl_bytes2size(bytes);
+    assert(*pnl >= wanna);
+    *ppnl = pnl + 1;
+    return MDBX_SUCCESS;
+  }
+  return MDBX_ENOMEM;
+}
+
+static __always_inline int __must_check_result pnl_append_stepped(unsigned step, __restrict pnl_t *ppnl, pgno_t pgno,
+                                                                  size_t n) {
+  assert(n > 0);
+  int rc = pnl_need(ppnl, n);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  const pnl_t pnl = *ppnl;
+  if (likely(n == 1)) {
+    pnl_append_prereserved(pnl, pgno);
+    return MDBX_SUCCESS;
+  }
+
+#if MDBX_PNL_ASCENDING
+  size_t w = MDBX_PNL_GETSIZE(pnl);
+  do {
+    pnl[++w] = pgno;
+    pgno += step;
+  } while (--n);
+  MDBX_PNL_SETSIZE(pnl, w);
+#else
+  size_t w = MDBX_PNL_GETSIZE(pnl) + n;
+  MDBX_PNL_SETSIZE(pnl, w);
+  do {
+    pnl[w--] = pgno;
+    pgno += step;
+  } while (--n);
+#endif
+  return MDBX_SUCCESS;
+}
+
+__hot int __must_check_result spill_append_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n) {
+  return pnl_append_stepped(2, ppnl, pgno << 1, n);
+}
+
+__hot int __must_check_result pnl_append_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n) {
+  return pnl_append_stepped(1, ppnl, pgno, n);
+}
+
+__hot int __must_check_result pnl_insert_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n) {
+  assert(n > 0);
+  int rc = pnl_need(ppnl, n);
+  if (unlikely(rc != MDBX_SUCCESS))
+    return rc;
+
+  const pnl_t pnl = *ppnl;
+  size_t r = MDBX_PNL_GETSIZE(pnl), w = r + n;
+  MDBX_PNL_SETSIZE(pnl, w);
+  while (r && MDBX_PNL_DISORDERED(pnl[r], pgno))
+    pnl[w--] = pnl[r--];
+
+  for (pgno_t fill = MDBX_PNL_ASCENDING ? pgno + n : pgno; w > r; --w)
+    pnl[w] = MDBX_PNL_ASCENDING ? --fill : fill++;
+
+  return MDBX_SUCCESS;
+}
+
+__hot __noinline bool pnl_check(const const_pnl_t pnl, const size_t limit) {
+  assert(limit >= MIN_PAGENO - MDBX_ENABLE_REFUND);
+  if (likely(MDBX_PNL_GETSIZE(pnl))) {
+    if (unlikely(MDBX_PNL_GETSIZE(pnl) > PAGELIST_LIMIT))
+      return false;
+    if (unlikely(MDBX_PNL_LEAST(pnl) < MIN_PAGENO))
+      return false;
+    if (unlikely(MDBX_PNL_MOST(pnl) >= limit))
+      return false;
+
+    if ((!MDBX_DISABLE_VALIDATION || AUDIT_ENABLED()) && likely(MDBX_PNL_GETSIZE(pnl) > 1)) {
+      const pgno_t *scan = MDBX_PNL_BEGIN(pnl);
+      const pgno_t *const end = MDBX_PNL_END(pnl);
+      pgno_t prev = *scan++;
+      do {
+        if (unlikely(!MDBX_PNL_ORDERED(prev, *scan)))
+          return false;
+        prev = *scan;
+      } while (likely(++scan != end));
+    }
+  }
+  return true;
+}
+
+static __always_inline void pnl_merge_inner(pgno_t *__restrict dst, const pgno_t *__restrict src_a,
+                                            const pgno_t *__restrict src_b,
+                                            const pgno_t *__restrict const src_b_detent) {
+  do {
+#if MDBX_HAVE_CMOV
+    const bool flag = MDBX_PNL_ORDERED(*src_b, *src_a);
+#if defined(__LCC__) || __CLANG_PREREQ(13, 0)
+    // lcc 1.26: 13ШК (подготовка и первая итерация) + 7ШК (цикл), БЕЗ loop-mode
+    // gcc>=7: cmp+jmp с возвратом в тело цикла (WTF?)
+    // gcc<=6: cmov×3
+    // clang<=12: cmov×3
+    // clang>=13: cmov, set+add/sub
+    *dst = flag ? *src_a-- : *src_b--;
+#else
+    // gcc: cmov, cmp+set+add/sub
+    // clang<=5: cmov×2, set+add/sub
+    // clang>=6: cmov, set+add/sub
+    *dst = flag ? *src_a : *src_b;
+    src_b += (ptrdiff_t)flag - 1;
+    src_a -= flag;
+#endif
+    --dst;
+#else  /* MDBX_HAVE_CMOV */
+    while (MDBX_PNL_ORDERED(*src_b, *src_a))
+      *dst-- = *src_a--;
+    *dst-- = *src_b--;
+#endif /* !MDBX_HAVE_CMOV */
+  } while (likely(src_b > src_b_detent));
+}
+
+__hot size_t pnl_merge(pnl_t dst, const pnl_t src) {
+  assert(pnl_check_allocated(dst, MAX_PAGENO + 1));
+  assert(pnl_check(src, MAX_PAGENO + 1));
+  const size_t src_len = MDBX_PNL_GETSIZE(src);
+  const size_t dst_len = MDBX_PNL_GETSIZE(dst);
+  size_t total = dst_len;
+  assert(MDBX_PNL_ALLOCLEN(dst) >= total);
+  if (likely(src_len > 0)) {
+    total += src_len;
+    if (!MDBX_DEBUG && total < (MDBX_HAVE_CMOV ? 21 : 12))
+      goto avoid_call_libc_for_short_cases;
+    if (dst_len == 0 || MDBX_PNL_ORDERED(MDBX_PNL_LAST(dst), MDBX_PNL_FIRST(src)))
+      memcpy(MDBX_PNL_END(dst), MDBX_PNL_BEGIN(src), src_len * sizeof(pgno_t));
+    else if (MDBX_PNL_ORDERED(MDBX_PNL_LAST(src), MDBX_PNL_FIRST(dst))) {
+      memmove(MDBX_PNL_BEGIN(dst) + src_len, MDBX_PNL_BEGIN(dst), dst_len * sizeof(pgno_t));
+      memcpy(MDBX_PNL_BEGIN(dst), MDBX_PNL_BEGIN(src), src_len * sizeof(pgno_t));
+    } else {
+    avoid_call_libc_for_short_cases:
+      dst[0] = /* the detent */ (MDBX_PNL_ASCENDING ? 0 : P_INVALID);
+      pnl_merge_inner(dst + total, dst + dst_len, src + src_len, src);
+    }
+    MDBX_PNL_SETSIZE(dst, total);
+  }
+  assert(pnl_check_allocated(dst, MAX_PAGENO + 1));
+  return total;
+}
+
+#if MDBX_PNL_ASCENDING
+#define MDBX_PNL_EXTRACT_KEY(ptr) (*(ptr))
+#else
+#define MDBX_PNL_EXTRACT_KEY(ptr) (P_INVALID - *(ptr))
+#endif
+RADIXSORT_IMPL(pgno, pgno_t, MDBX_PNL_EXTRACT_KEY, MDBX_PNL_PREALLOC_FOR_RADIXSORT, 0)
+
+SORT_IMPL(pgno_sort, false, pgno_t, MDBX_PNL_ORDERED)
+
+__hot __noinline void pnl_sort_nochk(pnl_t pnl) {
+  if (likely(MDBX_PNL_GETSIZE(pnl) < MDBX_RADIXSORT_THRESHOLD) ||
+      unlikely(!pgno_radixsort(&MDBX_PNL_FIRST(pnl), MDBX_PNL_GETSIZE(pnl))))
+    pgno_sort(MDBX_PNL_BEGIN(pnl), MDBX_PNL_END(pnl));
+}
+
+SEARCH_IMPL(pgno_bsearch, pgno_t, pgno_t, MDBX_PNL_ORDERED)
+
+__hot __noinline size_t pnl_search_nochk(const pnl_t pnl, pgno_t pgno) {
+  const pgno_t *begin = MDBX_PNL_BEGIN(pnl);
+  const pgno_t *it = pgno_bsearch(begin, MDBX_PNL_GETSIZE(pnl), pgno);
+  const pgno_t *end = begin + MDBX_PNL_GETSIZE(pnl);
+  assert(it >= begin && it <= end);
+  if (it != begin)
+    assert(MDBX_PNL_ORDERED(it[-1], pgno));
+  if (it != end)
+    assert(!MDBX_PNL_ORDERED(it[0], pgno));
+  return it - begin + 1;
+}

package/deps/libmdbx/src/pnl.h

@@ -0,0 +1,146 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \note Please refer to the COPYRIGHT file for explanations license change,
+/// credits and acknowledgments.
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+#include "essentials.h"
+
+/* An PNL is an Page Number List, a sorted array of IDs.
+ *
+ * The first element of the array is a counter for how many actual page-numbers
+ * are in the list. By default PNLs are sorted in descending order, this allow
+ * cut off a page with lowest pgno (at the tail) just truncating the list. The
+ * sort order of PNLs is controlled by the MDBX_PNL_ASCENDING build option. */
+typedef pgno_t *pnl_t;
+typedef const pgno_t *const_pnl_t;
+
+#if MDBX_PNL_ASCENDING
+#define MDBX_PNL_ORDERED(first, last) ((first) < (last))
+#define MDBX_PNL_DISORDERED(first, last) ((first) >= (last))
+#else
+#define MDBX_PNL_ORDERED(first, last) ((first) > (last))
+#define MDBX_PNL_DISORDERED(first, last) ((first) <= (last))
+#endif
+
+#define MDBX_PNL_GRANULATE_LOG2 10
+#define MDBX_PNL_GRANULATE (1 << MDBX_PNL_GRANULATE_LOG2)
+#define MDBX_PNL_INITIAL (MDBX_PNL_GRANULATE - 2 - MDBX_ASSUME_MALLOC_OVERHEAD / sizeof(pgno_t))
+
+#define MDBX_PNL_ALLOCLEN(pl) ((pl)[-1])
+#define MDBX_PNL_GETSIZE(pl) ((size_t)((pl)[0]))
+#define MDBX_PNL_SETSIZE(pl, size)                                                                                     \
+  do {                                                                                                                 \
+    const size_t __size = size;                                                                                        \
+    assert(__size < INT_MAX);                                                                                          \
+    (pl)[0] = (pgno_t)__size;                                                                                          \
+  } while (0)
+#define MDBX_PNL_FIRST(pl) ((pl)[1])
+#define MDBX_PNL_LAST(pl) ((pl)[MDBX_PNL_GETSIZE(pl)])
+#define MDBX_PNL_BEGIN(pl) (&(pl)[1])
+#define MDBX_PNL_END(pl) (&(pl)[MDBX_PNL_GETSIZE(pl) + 1])
+
+#if MDBX_PNL_ASCENDING
+#define MDBX_PNL_EDGE(pl) ((pl) + 1)
+#define MDBX_PNL_LEAST(pl) MDBX_PNL_FIRST(pl)
+#define MDBX_PNL_MOST(pl) MDBX_PNL_LAST(pl)
+#else
+#define MDBX_PNL_EDGE(pl) ((pl) + MDBX_PNL_GETSIZE(pl))
+#define MDBX_PNL_LEAST(pl) MDBX_PNL_LAST(pl)
+#define MDBX_PNL_MOST(pl) MDBX_PNL_FIRST(pl)
+#endif
+
+#define MDBX_PNL_SIZEOF(pl) ((MDBX_PNL_GETSIZE(pl) + 1) * sizeof(pgno_t))
+#define MDBX_PNL_IS_EMPTY(pl) (MDBX_PNL_GETSIZE(pl) == 0)
+
+MDBX_MAYBE_UNUSED static inline size_t pnl_size2bytes(size_t size) {
+  assert(size > 0 && size <= PAGELIST_LIMIT);
+#if MDBX_PNL_PREALLOC_FOR_RADIXSORT
+
+  size += size;
+#endif /* MDBX_PNL_PREALLOC_FOR_RADIXSORT */
+  STATIC_ASSERT(MDBX_ASSUME_MALLOC_OVERHEAD +
+                    (PAGELIST_LIMIT * (MDBX_PNL_PREALLOC_FOR_RADIXSORT + 1) + MDBX_PNL_GRANULATE + 3) * sizeof(pgno_t) <
+                SIZE_MAX / 4 * 3);
+  size_t bytes =
+      ceil_powerof2(MDBX_ASSUME_MALLOC_OVERHEAD + sizeof(pgno_t) * (size + 3), MDBX_PNL_GRANULATE * sizeof(pgno_t)) -
+      MDBX_ASSUME_MALLOC_OVERHEAD;
+  return bytes;
+}
+
+MDBX_MAYBE_UNUSED static inline pgno_t pnl_bytes2size(const size_t bytes) {
+  size_t size = bytes / sizeof(pgno_t);
+  assert(size > 3 && size <= PAGELIST_LIMIT + /* alignment gap */ 65536);
+  size -= 3;
+#if MDBX_PNL_PREALLOC_FOR_RADIXSORT
+  size >>= 1;
+#endif /* MDBX_PNL_PREALLOC_FOR_RADIXSORT */
+  return (pgno_t)size;
+}
+
+MDBX_INTERNAL pnl_t pnl_alloc(size_t size);
+
+MDBX_INTERNAL void pnl_free(pnl_t pnl);
+
+MDBX_INTERNAL int pnl_reserve(pnl_t __restrict *__restrict ppnl, const size_t wanna);
+
+MDBX_MAYBE_UNUSED static inline int __must_check_result pnl_need(pnl_t __restrict *__restrict ppnl, size_t num) {
+  assert(MDBX_PNL_GETSIZE(*ppnl) <= PAGELIST_LIMIT && MDBX_PNL_ALLOCLEN(*ppnl) >= MDBX_PNL_GETSIZE(*ppnl));
+  assert(num <= PAGELIST_LIMIT);
+  const size_t wanna = MDBX_PNL_GETSIZE(*ppnl) + num;
+  return likely(MDBX_PNL_ALLOCLEN(*ppnl) >= wanna) ? MDBX_SUCCESS : pnl_reserve(ppnl, wanna);
+}
+
+MDBX_MAYBE_UNUSED static inline void pnl_append_prereserved(__restrict pnl_t pnl, pgno_t pgno) {
+  assert(MDBX_PNL_GETSIZE(pnl) < MDBX_PNL_ALLOCLEN(pnl));
+  if (AUDIT_ENABLED()) {
+    for (size_t i = MDBX_PNL_GETSIZE(pnl); i > 0; --i)
+      assert(pgno != pnl[i]);
+  }
+  *pnl += 1;
+  MDBX_PNL_LAST(pnl) = pgno;
+}
+
+MDBX_INTERNAL void pnl_shrink(pnl_t __restrict *__restrict ppnl);
+
+MDBX_INTERNAL int __must_check_result spill_append_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n);
+
+MDBX_INTERNAL int __must_check_result pnl_append_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n);
+
+MDBX_INTERNAL int __must_check_result pnl_insert_span(__restrict pnl_t *ppnl, pgno_t pgno, size_t n);
+
+MDBX_INTERNAL size_t pnl_search_nochk(const pnl_t pnl, pgno_t pgno);
+
+MDBX_INTERNAL void pnl_sort_nochk(pnl_t pnl);
+
+MDBX_INTERNAL bool pnl_check(const const_pnl_t pnl, const size_t limit);
+
+MDBX_MAYBE_UNUSED static inline bool pnl_check_allocated(const const_pnl_t pnl, const size_t limit) {
+  return pnl == nullptr || (MDBX_PNL_ALLOCLEN(pnl) >= MDBX_PNL_GETSIZE(pnl) && pnl_check(pnl, limit));
+}
+
+MDBX_MAYBE_UNUSED static inline void pnl_sort(pnl_t pnl, size_t limit4check) {
+  pnl_sort_nochk(pnl);
+  assert(pnl_check(pnl, limit4check));
+  (void)limit4check;
+}
+
+MDBX_MAYBE_UNUSED static inline size_t pnl_search(const pnl_t pnl, pgno_t pgno, size_t limit) {
+  assert(pnl_check_allocated(pnl, limit));
+  if (MDBX_HAVE_CMOV) {
+    /* cmov-ускоренный бинарный поиск может читать (но не использовать) один
+     * элемент за концом данных, этот элемент в пределах выделенного участка
+     * памяти, но не инициализирован. */
+    VALGRIND_MAKE_MEM_DEFINED(MDBX_PNL_END(pnl), sizeof(pgno_t));
+  }
+  assert(pgno < limit);
+  (void)limit;
+  size_t n = pnl_search_nochk(pnl, pgno);
+  if (MDBX_HAVE_CMOV) {
+    VALGRIND_MAKE_MEM_UNDEFINED(MDBX_PNL_END(pnl), sizeof(pgno_t));
+  }
+  return n;
+}
+
+MDBX_INTERNAL size_t pnl_merge(pnl_t dst, const pnl_t src);