mdbxmou 0.1.26

package/deps/libmdbx/src/proto.h

@@ -0,0 +1,105 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+#include "essentials.h"
+
+/* Internal prototypes */
+
+/* audit.c */
+MDBX_INTERNAL int audit_ex(MDBX_txn *txn, size_t retired_stored, bool dont_filter_gc);
+
+/* mvcc-readers.c */
+MDBX_INTERNAL bsr_t mvcc_bind_slot(MDBX_env *env);
+MDBX_MAYBE_UNUSED MDBX_INTERNAL pgno_t mvcc_largest_this(MDBX_env *env, pgno_t largest);
+MDBX_INTERNAL txnid_t mvcc_shapshot_oldest(MDBX_env *const env, const txnid_t steady);
+MDBX_INTERNAL pgno_t mvcc_snapshot_largest(const MDBX_env *env, pgno_t last_used_page);
+MDBX_INTERNAL txnid_t mvcc_kick_laggards(MDBX_env *env, const txnid_t straggler);
+MDBX_INTERNAL int mvcc_cleanup_dead(MDBX_env *env, int rlocked, int *dead);
+MDBX_INTERNAL txnid_t mvcc_kick_laggards(MDBX_env *env, const txnid_t laggard);
+
+/* dxb.c */
+MDBX_INTERNAL int dxb_setup(MDBX_env *env, const int lck_rc, const mdbx_mode_t mode_bits);
+MDBX_INTERNAL int __must_check_result dxb_read_header(MDBX_env *env, meta_t *meta, const int lck_exclusive,
+                                                      const mdbx_mode_t mode_bits);
+enum resize_mode { implicit_grow, impilict_shrink, explicit_resize };
+MDBX_INTERNAL int __must_check_result dxb_resize(MDBX_env *const env, const pgno_t used_pgno, const pgno_t size_pgno,
+                                                 pgno_t limit_pgno, const enum resize_mode mode);
+MDBX_INTERNAL int dxb_set_readahead(const MDBX_env *env, const pgno_t edge, const bool enable, const bool force_whole);
+MDBX_INTERNAL int __must_check_result dxb_sync_locked(MDBX_env *env, unsigned flags, meta_t *const pending,
+                                                      troika_t *const troika);
+#if defined(ENABLE_MEMCHECK) || defined(__SANITIZE_ADDRESS__)
+MDBX_INTERNAL void dxb_sanitize_tail(MDBX_env *env, MDBX_txn *txn);
+#else
+static inline void dxb_sanitize_tail(MDBX_env *env, MDBX_txn *txn) {
+  (void)env;
+  (void)txn;
+}
+#endif /* ENABLE_MEMCHECK || __SANITIZE_ADDRESS__ */
+
+/* txn.c */
+MDBX_INTERNAL bool txn_refund(MDBX_txn *txn);
+MDBX_INTERNAL txnid_t txn_snapshot_oldest(const MDBX_txn *const txn);
+MDBX_INTERNAL int txn_abort(MDBX_txn *txn);
+MDBX_INTERNAL int txn_renew(MDBX_txn *txn, unsigned flags);
+MDBX_INTERNAL int txn_park(MDBX_txn *txn, bool autounpark);
+MDBX_INTERNAL int txn_unpark(MDBX_txn *txn);
+MDBX_INTERNAL int txn_check_badbits_parked(const MDBX_txn *txn, int bad_bits);
+MDBX_INTERNAL void txn_done_cursors(MDBX_txn *txn, const bool merge);
+
+#define TXN_END_NAMES                                                                                                  \
+  {"committed", "empty-commit", "abort", "reset", "fail-begin", "fail-beginchild", "ousted", nullptr}
+enum {
+  /* txn_end operation number, for logging */
+  TXN_END_COMMITTED,
+  TXN_END_PURE_COMMIT,
+  TXN_END_ABORT,
+  TXN_END_RESET,
+  TXN_END_FAIL_BEGIN,
+  TXN_END_FAIL_BEGINCHILD,
+  TXN_END_OUSTED,
+
+  TXN_END_OPMASK = 0x07 /* mask for txn_end() operation number */,
+  TXN_END_UPDATE = 0x10 /* update env state (DBIs) */,
+  TXN_END_FREE = 0x20 /* free txn unless it is env.basal_txn */,
+  TXN_END_EOTDONE = 0x40 /* txn's cursors already closed */,
+  TXN_END_SLOT = 0x80 /* release any reader slot if NOSTICKYTHREADS */
+};
+MDBX_INTERNAL int txn_end(MDBX_txn *txn, unsigned mode);
+MDBX_INTERNAL int txn_write(MDBX_txn *txn, iov_ctx_t *ctx);
+MDBX_INTERNAL void txn_take_gcprof(const MDBX_txn *txn, MDBX_commit_latency *latency);
+MDBX_INTERNAL void txn_merge(MDBX_txn *const parent, MDBX_txn *const txn, const size_t parent_retired_len);
+
+/* env.c */
+MDBX_INTERNAL int env_open(MDBX_env *env, mdbx_mode_t mode);
+MDBX_INTERNAL int env_info(const MDBX_env *env, const MDBX_txn *txn, MDBX_envinfo *out, size_t bytes, troika_t *troika);
+MDBX_INTERNAL int env_sync(MDBX_env *env, bool force, bool nonblock);
+MDBX_INTERNAL int env_close(MDBX_env *env, bool resurrect_after_fork);
+MDBX_INTERNAL MDBX_txn *env_owned_wrtxn(const MDBX_env *env);
+MDBX_INTERNAL int __must_check_result env_page_auxbuffer(MDBX_env *env);
+MDBX_INTERNAL unsigned env_setup_pagesize(MDBX_env *env, const size_t pagesize);
+
+/* api-opt.c */
+MDBX_INTERNAL void env_options_init(MDBX_env *env);
+MDBX_INTERNAL void env_options_adjust_defaults(MDBX_env *env);
+MDBX_INTERNAL void env_options_adjust_dp_limit(MDBX_env *env);
+MDBX_INTERNAL pgno_t default_dp_limit(const MDBX_env *env);
+
+/* tree.c */
+MDBX_INTERNAL int tree_drop(MDBX_cursor *mc, const bool may_have_tables);
+MDBX_INTERNAL int __must_check_result tree_rebalance(MDBX_cursor *mc);
+MDBX_INTERNAL int __must_check_result tree_propagate_key(MDBX_cursor *mc, const MDBX_val *key);
+MDBX_INTERNAL void recalculate_merge_thresholds(MDBX_env *env);
+MDBX_INTERNAL void recalculate_subpage_thresholds(MDBX_env *env);
+
+/* table.c */
+MDBX_INTERNAL int __must_check_result tbl_fetch(MDBX_txn *txn, size_t dbi);
+MDBX_INTERNAL int __must_check_result tbl_setup(const MDBX_env *env, volatile kvx_t *const kvx, const tree_t *const db);
+
+/* coherency.c */
+MDBX_INTERNAL bool coherency_check_meta(const MDBX_env *env, const volatile meta_t *meta, bool report);
+MDBX_INTERNAL int coherency_fetch_head(MDBX_txn *txn, const meta_ptr_t head, uint64_t *timestamp);
+MDBX_INTERNAL int coherency_check_written(const MDBX_env *env, const txnid_t txnid, const volatile meta_t *meta,
+                                          const intptr_t pgno, uint64_t *timestamp);
+MDBX_INTERNAL int coherency_timeout(uint64_t *timestamp, intptr_t pgno, const MDBX_env *env);

package/deps/libmdbx/src/refund.c

@@ -0,0 +1,212 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#include "internals.h"
+
+#if MDBX_ENABLE_REFUND
+static void refund_reclaimed(MDBX_txn *txn) {
+  /* Scanning in descend order */
+  pgno_t first_unallocated = txn->geo.first_unallocated;
+  const pnl_t pnl = txn->tw.repnl;
+  tASSERT(txn, MDBX_PNL_GETSIZE(pnl) && MDBX_PNL_MOST(pnl) == first_unallocated - 1);
+#if MDBX_PNL_ASCENDING
+  size_t i = MDBX_PNL_GETSIZE(pnl);
+  tASSERT(txn, pnl[i] == first_unallocated - 1);
+  while (--first_unallocated, --i > 0 && pnl[i] == first_unallocated - 1)
+    ;
+  MDBX_PNL_SETSIZE(pnl, i);
+#else
+  size_t i = 1;
+  tASSERT(txn, pnl[i] == first_unallocated - 1);
+  size_t len = MDBX_PNL_GETSIZE(pnl);
+  while (--first_unallocated, ++i <= len && pnl[i] == first_unallocated - 1)
+    ;
+  MDBX_PNL_SETSIZE(pnl, len -= i - 1);
+  for (size_t move = 0; move < len; ++move)
+    pnl[1 + move] = pnl[i + move];
+#endif
+  VERBOSE("refunded %" PRIaPGNO " pages: %" PRIaPGNO " -> %" PRIaPGNO, txn->geo.first_unallocated - first_unallocated,
+          txn->geo.first_unallocated, first_unallocated);
+  txn->geo.first_unallocated = first_unallocated;
+  tASSERT(txn, pnl_check_allocated(txn->tw.repnl, txn->geo.first_unallocated - 1));
+}
+
+static void refund_loose(MDBX_txn *txn) {
+  tASSERT(txn, txn->tw.loose_pages != nullptr);
+  tASSERT(txn, txn->tw.loose_count > 0);
+
+  dpl_t *const dl = txn->tw.dirtylist;
+  if (dl) {
+    tASSERT(txn, dl->length >= txn->tw.loose_count);
+    tASSERT(txn, (txn->flags & MDBX_WRITEMAP) == 0 || MDBX_AVOID_MSYNC);
+  } else {
+    tASSERT(txn, (txn->flags & MDBX_WRITEMAP) != 0 && !MDBX_AVOID_MSYNC);
+  }
+
+  pgno_t onstack[MDBX_CACHELINE_SIZE * 8 / sizeof(pgno_t)];
+  pnl_t suitable = onstack;
+
+  if (!dl || dl->length - dl->sorted > txn->tw.loose_count) {
+    /* Dirty list is useless since unsorted. */
+    if (pnl_bytes2size(sizeof(onstack)) < txn->tw.loose_count) {
+      suitable = pnl_alloc(txn->tw.loose_count);
+      if (unlikely(!suitable))
+        return /* this is not a reason for transaction fail */;
+    }
+
+    /* Collect loose-pages which may be refunded. */
+    tASSERT(txn, txn->geo.first_unallocated >= MIN_PAGENO + txn->tw.loose_count);
+    pgno_t most = MIN_PAGENO;
+    size_t w = 0;
+    for (const page_t *lp = txn->tw.loose_pages; lp; lp = page_next(lp)) {
+      tASSERT(txn, lp->flags == P_LOOSE);
+      tASSERT(txn, txn->geo.first_unallocated > lp->pgno);
+      if (likely(txn->geo.first_unallocated - txn->tw.loose_count <= lp->pgno)) {
+        tASSERT(txn, w < ((suitable == onstack) ? pnl_bytes2size(sizeof(onstack)) : MDBX_PNL_ALLOCLEN(suitable)));
+        suitable[++w] = lp->pgno;
+        most = (lp->pgno > most) ? lp->pgno : most;
+      }
+      MDBX_ASAN_UNPOISON_MEMORY_REGION(&page_next(lp), sizeof(page_t *));
+      VALGRIND_MAKE_MEM_DEFINED(&page_next(lp), sizeof(page_t *));
+    }
+
+    if (most + 1 == txn->geo.first_unallocated) {
+      /* Sort suitable list and refund pages at the tail. */
+      MDBX_PNL_SETSIZE(suitable, w);
+      pnl_sort(suitable, MAX_PAGENO + 1);
+
+      /* Scanning in descend order */
+      const intptr_t step = MDBX_PNL_ASCENDING ? -1 : 1;
+      const intptr_t begin = MDBX_PNL_ASCENDING ? MDBX_PNL_GETSIZE(suitable) : 1;
+      const intptr_t end = MDBX_PNL_ASCENDING ? 0 : MDBX_PNL_GETSIZE(suitable) + 1;
+      tASSERT(txn, suitable[begin] >= suitable[end - step]);
+      tASSERT(txn, most == suitable[begin]);
+
+      for (intptr_t i = begin + step; i != end; i += step) {
+        if (suitable[i] != most - 1)
+          break;
+        most -= 1;
+      }
+      const size_t refunded = txn->geo.first_unallocated - most;
+      DEBUG("refund-suitable %zu pages %" PRIaPGNO " -> %" PRIaPGNO, refunded, most, txn->geo.first_unallocated);
+      txn->geo.first_unallocated = most;
+      txn->tw.loose_count -= refunded;
+      if (dl) {
+        txn->tw.dirtyroom += refunded;
+        dl->pages_including_loose -= refunded;
+        assert(txn->tw.dirtyroom <= txn->env->options.dp_limit);
+
+        /* Filter-out dirty list */
+        size_t r = 0;
+        w = 0;
+        if (dl->sorted) {
+          do {
+            if (dl->items[++r].pgno < most) {
+              if (++w != r)
+                dl->items[w] = dl->items[r];
+            }
+          } while (r < dl->sorted);
+          dl->sorted = w;
+        }
+        while (r < dl->length) {
+          if (dl->items[++r].pgno < most) {
+            if (++w != r)
+              dl->items[w] = dl->items[r];
+          }
+        }
+        dpl_setlen(dl, w);
+        tASSERT(txn, txn->tw.dirtyroom + txn->tw.dirtylist->length ==
+                         (txn->parent ? txn->parent->tw.dirtyroom : txn->env->options.dp_limit));
+      }
+      goto unlink_loose;
+    }
+  } else {
+    /* Dirtylist is mostly sorted, just refund loose pages at the end. */
+    dpl_sort(txn);
+    tASSERT(txn, dl->length < 2 || dl->items[1].pgno < dl->items[dl->length].pgno);
+    tASSERT(txn, dl->sorted == dl->length);
+
+    /* Scan dirtylist tail-forward and cutoff suitable pages. */
+    size_t n;
+    for (n = dl->length; dl->items[n].pgno == txn->geo.first_unallocated - 1 && dl->items[n].ptr->flags == P_LOOSE;
+         --n) {
+      tASSERT(txn, n > 0);
+      page_t *dp = dl->items[n].ptr;
+      DEBUG("refund-sorted page %" PRIaPGNO, dp->pgno);
+      tASSERT(txn, dp->pgno == dl->items[n].pgno);
+      txn->geo.first_unallocated -= 1;
+    }
+    dpl_setlen(dl, n);
+
+    if (dl->sorted != dl->length) {
+      const size_t refunded = dl->sorted - dl->length;
+      dl->sorted = dl->length;
+      txn->tw.loose_count -= refunded;
+      txn->tw.dirtyroom += refunded;
+      dl->pages_including_loose -= refunded;
+      tASSERT(txn, txn->tw.dirtyroom + txn->tw.dirtylist->length ==
+                       (txn->parent ? txn->parent->tw.dirtyroom : txn->env->options.dp_limit));
+
+      /* Filter-out loose chain & dispose refunded pages. */
+    unlink_loose:
+      for (page_t *__restrict *__restrict link = &txn->tw.loose_pages; *link;) {
+        page_t *dp = *link;
+        tASSERT(txn, dp->flags == P_LOOSE);
+        MDBX_ASAN_UNPOISON_MEMORY_REGION(&page_next(dp), sizeof(page_t *));
+        VALGRIND_MAKE_MEM_DEFINED(&page_next(dp), sizeof(page_t *));
+        if (txn->geo.first_unallocated > dp->pgno) {
+          link = &page_next(dp);
+        } else {
+          *link = page_next(dp);
+          if ((txn->flags & MDBX_WRITEMAP) == 0)
+            page_shadow_release(txn->env, dp, 1);
+        }
+      }
+    }
+  }
+
+  tASSERT(txn, dpl_check(txn));
+  if (suitable != onstack)
+    pnl_free(suitable);
+  txn->tw.loose_refund_wl = txn->geo.first_unallocated;
+}
+
+bool txn_refund(MDBX_txn *txn) {
+  const pgno_t before = txn->geo.first_unallocated;
+
+  if (txn->tw.loose_pages && txn->tw.loose_refund_wl > txn->geo.first_unallocated)
+    refund_loose(txn);
+
+  while (true) {
+    if (MDBX_PNL_GETSIZE(txn->tw.repnl) == 0 || MDBX_PNL_MOST(txn->tw.repnl) != txn->geo.first_unallocated - 1)
+      break;
+
+    refund_reclaimed(txn);
+    if (!txn->tw.loose_pages || txn->tw.loose_refund_wl <= txn->geo.first_unallocated)
+      break;
+
+    const pgno_t memo = txn->geo.first_unallocated;
+    refund_loose(txn);
+    if (memo == txn->geo.first_unallocated)
+      break;
+  }
+
+  if (before == txn->geo.first_unallocated)
+    return false;
+
+  if (txn->tw.spilled.list)
+    /* Squash deleted pagenums if we refunded any */
+    spill_purge(txn);
+
+  return true;
+}
+
+#else /* MDBX_ENABLE_REFUND */
+
+bool txn_refund(MDBX_txn *txn) {
+  (void)txn;
+  /* No online auto-compactification. */
+  return false;
+}
+
+#endif /* MDBX_ENABLE_REFUND */