mdbxmou 0.1.26

package/deps/libmdbx/test/jitter.c++

@@ -0,0 +1,197 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "test.h++"
+
+class testcase_jitter : public testcase {
+protected:
+  void check_dbi_error(int expect, const char *stage);
+
+public:
+  testcase_jitter(const actor_config &config, const mdbx_pid_t pid) : testcase(config, pid) {}
+  bool run() override;
+};
+REGISTER_TESTCASE(jitter);
+
+void testcase_jitter::check_dbi_error(int expect, const char *stage) {
+  MDBX_stat stat;
+  int err = mdbx_dbi_stat(txn_guard.get(), dbi, &stat, sizeof(stat));
+  if (err != expect)
+    failure("unexpected result for %s dbi-handle: expect %d, got %d", stage, expect, err);
+}
+
+bool testcase_jitter::run() {
+  int err;
+  size_t upper_limit = config.params.size_upper;
+  if (upper_limit < 1)
+    upper_limit = config.params.size_now * 2;
+
+  tablename_buf buffer;
+  const char *const tablename = db_tablename(buffer);
+  tablename_buf buffer_renamed;
+  const char *const tablename_renamed = db_tablename(buffer_renamed, ".renamed");
+
+  while (should_continue()) {
+    jitter_delay();
+    db_open();
+
+    if (!dbi && !mode_readonly()) {
+      // create table
+      txn_begin(false);
+      dbi = db_table_open(true);
+      check_dbi_error(MDBX_SUCCESS, "created-uncommitted");
+
+      bool renamed = false;
+      if (flipcoin()) {
+        err = mdbx_dbi_rename(txn_guard.get(), dbi, tablename_renamed);
+        if (err != MDBX_SUCCESS)
+          failure_perror("jitter.rename-1", err);
+        renamed = true;
+      }
+
+      // note: here and below the 4-byte length keys and value are used
+      //       to be compatible with any Db-flags given from command line.
+      MDBX_val k = {(void *)"k000", 4}, v = {(void *)"v001", 4};
+      err = mdbx_put(txn_guard.get(), dbi, &k, &v, MDBX_UPSERT);
+      if (err != MDBX_SUCCESS)
+        failure_perror("jitter.put-1", err);
+      txn_end(false);
+
+      // drop & re-create table, but abort txn
+      txn_begin(false);
+      check_dbi_error(MDBX_SUCCESS, "created-committed");
+      err = mdbx_drop(txn_guard.get(), dbi, true);
+      if (unlikely(err != MDBX_SUCCESS))
+        failure_perror("mdbx_drop(delete=true)", err);
+      check_dbi_error(MDBX_BAD_DBI, "dropped-uncommitted");
+      dbi = db_table_open(true);
+      check_dbi_error(MDBX_SUCCESS, "recreated-uncommitted");
+      txn_end(true);
+
+      // check after aborted txn
+      txn_begin(false);
+      v = {(void *)"v002", 4};
+      err = mdbx_put(txn_guard.get(), dbi, &k, &v, MDBX_UPSERT);
+      if (err != MDBX_BAD_DBI)
+        failure_perror("jitter.put-2", err);
+      check_dbi_error(MDBX_BAD_DBI, "dropped-recreated-aborted");
+      // restore DBI
+      dbi = db_table_open(false, renamed);
+      if (renamed) {
+        err = mdbx_dbi_open(txn_guard.get(), tablename_renamed, flipcoin() ? MDBX_DB_ACCEDE : config.params.table_flags,
+                            &dbi);
+        if (unlikely(err != MDBX_SUCCESS))
+          failure_perror("open-renamed", err);
+        err = mdbx_dbi_rename(txn_guard.get(), dbi, tablename);
+        if (err != MDBX_SUCCESS)
+          failure_perror("jitter.rename-2", err);
+      }
+      check_dbi_error(MDBX_SUCCESS, "dropped-recreated-aborted+reopened");
+      v = {(void *)"v003", 4};
+      err = mdbx_put(txn_guard.get(), dbi, &k, &v, MDBX_UPSERT);
+      if (err != MDBX_SUCCESS)
+        failure_perror("jitter.put-3", err);
+      txn_end(false);
+    }
+
+    if (upper_limit < 1) {
+      MDBX_envinfo info;
+      err = mdbx_env_info_ex(db_guard.get(), txn_guard.get(), &info, sizeof(info));
+      if (err)
+        failure_perror("mdbx_env_info_ex()", err);
+      upper_limit = (info.mi_geo.upper < INTPTR_MAX) ? (intptr_t)info.mi_geo.upper : INTPTR_MAX;
+    }
+
+    if (flipcoin()) {
+      jitter_delay();
+      txn_begin(true);
+      fetch_canary();
+      if (flipcoin()) {
+        MDBX_txn_info info;
+        err = mdbx_txn_reset(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_reset()", err);
+        err = mdbx_txn_info(txn_guard.get(), &info, false);
+        if (err != MDBX_BAD_TXN)
+          failure_perror("mdbx_txn_info(MDBX_BAD_TXN)", err);
+        err = mdbx_txn_reset(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_reset(again)", err);
+        err = mdbx_txn_break(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_break()", err);
+
+        err = mdbx_txn_abort(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_abort()", err);
+        txn_guard.release();
+        txn_begin(true);
+        err = mdbx_txn_reset(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_reset()", err);
+
+        err = mdbx_txn_renew(txn_guard.get());
+        if (err)
+          failure_perror("mdbx_txn_renew()", err);
+        err = mdbx_txn_info(txn_guard.get(), &info, false);
+        if (err)
+          failure_perror("mdbx_txn_info()", err);
+      }
+      jitter_delay();
+      txn_end(flipcoin());
+    }
+
+    const bool coin4size = flipcoin();
+    jitter_delay();
+    txn_begin(mode_readonly());
+    jitter_delay();
+    if (!mode_readonly()) {
+      fetch_canary();
+      update_canary(1);
+      if (global::config::geometry_jitter) {
+        err = mdbx_env_set_geometry(db_guard.get(), -1, -1, coin4size ? upper_limit * 2 / 3 : upper_limit * 3 / 2, -1,
+                                    -1, -1);
+        if (err != MDBX_SUCCESS && err != MDBX_UNABLE_EXTEND_MAPSIZE && err != MDBX_MAP_FULL && err != MDBX_TOO_LARGE &&
+            err != MDBX_EPERM)
+          failure_perror("mdbx_env_set_geometry-1", err);
+      }
+    }
+    if (flipcoin()) {
+      uint64_t unused;
+      err = mdbx_dbi_sequence(txn_guard.get(), MAIN_DBI, &unused, mode_readonly() ? 0 : 1);
+      if (err)
+        failure_perror("mdbx_dbi_sequence()", err);
+    }
+    txn_end(flipcoin());
+
+    if (global::config::geometry_jitter) {
+      err = mdbx_env_set_geometry(db_guard.get(), -1, -1, !coin4size ? upper_limit * 2 / 3 : upper_limit * 3 / 2, -1,
+                                  -1, -1);
+      if (err != MDBX_SUCCESS && err != MDBX_UNABLE_EXTEND_MAPSIZE && err != MDBX_MAP_FULL && err != MDBX_TOO_LARGE &&
+          err != MDBX_EPERM)
+        failure_perror("mdbx_env_set_geometry-2", err);
+    }
+
+    if (flipcoin()) {
+      jitter_delay();
+      txn_begin(true);
+      jitter_delay();
+      txn_end(flipcoin());
+    }
+
+    if (global::config::geometry_jitter) {
+      jitter_delay();
+      err = mdbx_env_set_geometry(db_guard.get(), -1, -1, upper_limit, -1, -1, -1);
+      if (err != MDBX_SUCCESS && err != MDBX_UNABLE_EXTEND_MAPSIZE && err != MDBX_MAP_FULL && err != MDBX_TOO_LARGE &&
+          err != MDBX_EPERM)
+        failure_perror("mdbx_env_set_geometry-3", err);
+    }
+
+    db_close();
+
+    /* just 'align' nops with other tests with batching */
+    const auto batching = std::max(config.params.batch_read, config.params.batch_write);
+    report(std::max(1u, batching / 2));
+  }
+  return true;
+}

package/deps/libmdbx/test/keygen.c++

@@ -0,0 +1,393 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "test.h++"
+
+static const uint64_t primes[64] = {
+    /* */
+    0, 1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381,
+    /* */
+    UINT64_C(32749), UINT64_C(65521), UINT64_C(131071), UINT64_C(262139), UINT64_C(524287), UINT64_C(1048573),
+    UINT64_C(2097143), UINT64_C(4194301), UINT64_C(8388593), UINT64_C(16777213), UINT64_C(33554393), UINT64_C(67108859),
+    UINT64_C(134217689), UINT64_C(268435399), UINT64_C(536870909), UINT64_C(1073741789), UINT64_C(2147483647),
+    UINT64_C(4294967291), UINT64_C(8589934583), UINT64_C(17179869143), UINT64_C(34359738337), UINT64_C(68719476731),
+    UINT64_C(137438953447), UINT64_C(274877906899), UINT64_C(549755813881), UINT64_C(1099511627689),
+    UINT64_C(2199023255531), UINT64_C(4398046511093), UINT64_C(8796093022151), UINT64_C(17592186044399),
+    UINT64_C(35184372088777), UINT64_C(70368744177643), UINT64_C(140737488355213), UINT64_C(281474976710597),
+    UINT64_C(562949953421231), UINT64_C(1125899906842597), UINT64_C(2251799813685119), UINT64_C(4503599627370449),
+    UINT64_C(9007199254740881), UINT64_C(18014398509481951), UINT64_C(36028797018963913), UINT64_C(72057594037927931),
+    UINT64_C(144115188075855859), UINT64_C(288230376151711717), UINT64_C(576460752303423433),
+    UINT64_C(1152921504606846883), UINT64_C(2305843009213693951), UINT64_C(4611686018427387847),
+    UINT64_C(9223372036854775783)};
+
+/* static unsigned supid_log2(uint64_t v) {
+  unsigned r = 0;
+  while (v > 1) {
+    v >>= 1;
+    r += 1;
+  }
+  return r;
+} */
+
+namespace keygen {
+
+/* LY: https://en.wikipedia.org/wiki/Injective_function */
+serial_t injective(const serial_t serial, const unsigned bits /* at least serial_minwith (8) */, const serial_t salt) {
+  assert(bits >= serial_minwith && bits <= serial_maxwith);
+
+  /* LY: All these "magic" prime numbers were found
+   *     and verified with a bit of brute force. */
+
+  static const uint64_t m[64 - serial_minwith + 1] = {
+      /* 8 - 24 */
+      113, 157, 397, 653, 1753, 5641, 9697, 23873, 25693, 80833, 105953, 316937, 309277, 834497, 1499933, 4373441,
+      10184137,
+      /* 25 - 64 */
+      10184137, 17279209, 33990377, 67295161, 284404553, 1075238767, 6346721573, 6924051577, 19204053433, 45840188887,
+      53625693977, 73447827913, 141638870249, 745683604649, 1283334050489, 1100828289853, 2201656586197, 5871903036137,
+      11238507001417, 45264020802263, 105008404482889, 81921776907059, 199987980256399, 307207457507641,
+      946769023178273, 2420886491930041, 3601632139991929, 11984491914483833, 21805846439714153, 23171543400565993,
+      53353226456762893, 155627817337932409, 227827205384840249, 816509268558278821, 576933057762605689,
+      2623957345935638441, 5048241705479929949, 4634245581946485653, 4613509448041658233, 4952535426879925961};
+  static const uint8_t s[64 - serial_minwith + 1] = {/* 8 - 24 */
+                                                     2, 3, 4, 4, 2, 4, 3, 3, 7, 3, 3, 4, 8, 3, 10, 3, 11,
+                                                     /* 25 - 64 */
+                                                     11, 9, 9, 9, 11, 10, 5, 14, 11, 16, 14, 12, 13, 16, 19, 10, 10, 21,
+                                                     7, 20, 10, 14, 22, 19, 3, 21, 18, 19, 26, 24, 2, 21, 25, 29, 24,
+                                                     10, 11, 14, 20, 19};
+
+  const auto mask = actor_params::serial_mask(bits);
+  const auto mult = m[bits - 8];
+  const auto shift = s[bits - 8];
+  serial_t result = serial * mult;
+  if (salt) {
+    const unsigned left = bits / 2;
+    const unsigned right = bits - left;
+    result = (result << left) | ((result & mask) >> right);
+    result = (result ^ salt) * mult;
+  }
+
+  result ^= (result & mask) >> shift;
+  result &= mask;
+  log_trace("keygen-injective: serial %" PRIu64 "/%u @%" PRIx64 ",%u,%" PRIu64 " => %" PRIu64 "/%u", serial, bits, mult,
+            shift, salt, result, bits);
+  return result;
+}
+
+void __hot maker::pair(serial_t serial, const buffer &key, buffer &value, serial_t value_age,
+                       const bool keylen_changeable) {
+  assert(mapping.width >= serial_minwith && mapping.width <= serial_maxwith);
+  assert(mapping.split <= mapping.width);
+  assert(mapping.mesh <= mapping.width);
+  assert(mapping.rotate <= mapping.width);
+  assert(mapping.offset <= actor_params::serial_mask(mapping.width));
+  assert(!(key_essentials.flags &
+           ~(essentials::prng_fill_flag | unsigned(MDBX_INTEGERKEY | MDBX_REVERSEKEY | MDBX_DUPSORT))));
+  assert(!(value_essentials.flags &
+           ~(essentials::prng_fill_flag | unsigned(MDBX_INTEGERDUP | MDBX_REVERSEDUP | MDBX_DUPFIXED))));
+
+  log_trace("keygen-pair: serial %" PRIu64 ", data-age %" PRIu64, serial, value_age);
+
+  if (mapping.mesh >= serial_minwith) {
+    serial = (serial & ~actor_params::serial_mask(mapping.mesh)) | injective(serial, mapping.mesh, salt);
+    log_trace("keygen-pair: mesh@%u => %" PRIu64, mapping.mesh, serial);
+  }
+
+  if (mapping.rotate) {
+    const unsigned right = mapping.rotate;
+    const unsigned left = mapping.width - right;
+    serial = (serial << left) | ((serial & actor_params::serial_mask(mapping.width)) >> right);
+    log_trace("keygen-pair: rotate@%u => %" PRIu64 ", 0x%" PRIx64, mapping.rotate, serial, serial);
+  }
+
+  if (mapping.offset) {
+    serial = (serial + mapping.offset) & actor_params::serial_mask(mapping.width);
+    log_trace("keygen-pair: offset@%" PRIu64 " => %" PRIu64, mapping.offset, serial);
+  }
+  if (base) {
+    serial += base;
+    log_trace("keygen-pair: base@%" PRIu64 " => %" PRIu64, base, serial);
+  }
+
+  serial_t key_serial = serial;
+  serial_t value_serial = (value_age & value_age_mask) << mapping.split;
+  if (mapping.split) {
+    if (MDBX_db_flags_t(key_essentials.flags) & MDBX_DUPSORT) {
+      key_serial >>= mapping.split;
+      value_serial += serial & actor_params::serial_mask(mapping.split);
+    } else {
+      /* Без MDBX_DUPSORT требуется уникальность ключей, а для этого нельзя
+       * отбрасывать какие-либо биты serial после инъективного преобразования.
+       * Поэтому key_serial не трогаем, а в value_serial нелинейно вмешиваем
+       * запрошенное количество бит из serial */
+      value_serial +=
+          (serial ^ (serial >> mapping.split) * UINT64_C(57035339200100753)) & actor_params::serial_mask(mapping.split);
+    }
+
+    log_trace("keygen-pair: split@%u => k%" PRIu64 ", v%" PRIu64, mapping.split, key_serial, value_serial);
+  }
+
+  log_trace("keygen-pair: key %" PRIu64 ", value %" PRIu64, key_serial, value_serial);
+  key_serial = mk_begin(key_serial, key_essentials, *key);
+  value_serial = mk_begin(value_serial, value_essentials, *value);
+
+#if 0 /* unused for now */
+  if (key->value.iov_len + value->value.iov_len > pair_maxlen) {
+    unsigned extra = key->value.iov_len + value->value.iov_len - pair_maxlen;
+    if (keylen_changeable &&
+        key->value.iov_len > std::max(8u, (unsigned)key_essentials.minlen)) {
+#if defined(__GNUC__) || defined(__clang__)
+      const bool coin = __builtin_parityll(serial) != 0;
+#else
+      const bool coin = INT64_C(0xF2CEECA9989BD96A) * int64_t(serial) < 0;
+#endif
+      if (coin) {
+        const unsigned gap =
+            key->value.iov_len - std::max(8u, (unsigned)key_essentials.minlen);
+        const unsigned chop = std::min(gap, extra);
+        log_trace("keygen-pair: chop %u key-len %u -> %u", chop,
+                  (unsigned)key->value.iov_len,
+                  (unsigned)key->value.iov_len - chop);
+        key->value.iov_len -= chop;
+        extra -= chop;
+      }
+    }
+    if (extra && value->value.iov_len >
+                     std::max(8u, (unsigned)value_essentials.minlen)) {
+      const unsigned gap = value->value.iov_len -
+                           std::max(8u, (unsigned)value_essentials.minlen);
+      const unsigned chop = std::min(gap, extra);
+      log_trace("keygen-pair: chop %u value-len %u -> %u", chop,
+                (unsigned)value->value.iov_len,
+                (unsigned)value->value.iov_len - chop);
+      value->value.iov_len -= chop;
+      extra -= chop;
+    }
+    if (keylen_changeable && extra &&
+        key->value.iov_len > std::max(8u, (unsigned)key_essentials.minlen)) {
+      const unsigned gap =
+          key->value.iov_len - std::max(8u, (unsigned)key_essentials.minlen);
+      const unsigned chop = std::min(gap, extra);
+      log_trace("keygen-pair: chop %u key-len %u -> %u", chop,
+                (unsigned)key->value.iov_len,
+                (unsigned)key->value.iov_len - chop);
+      key->value.iov_len -= chop;
+      extra -= chop;
+    }
+  }
+#else
+  (void)keylen_changeable;
+#endif /* unused for now */
+
+  mk_continue(key_serial, key_essentials, *key);
+  mk_continue(value_serial, value_essentials, *value);
+  log_pair(logging::trace, "kv", key, value);
+}
+
+void maker::setup(const config::actor_params_pod &actor, unsigned thread_number) {
+#if CONSTEXPR_ENUM_FLAGS_OPERATIONS
+  static_assert(unsigned(MDBX_INTEGERKEY | MDBX_REVERSEKEY | MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP |
+                         MDBX_REVERSEDUP) < UINT16_MAX,
+                "WTF?");
+#else
+  assert(unsigned(MDBX_INTEGERKEY | MDBX_REVERSEKEY | MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP |
+                  MDBX_REVERSEDUP) < UINT16_MAX);
+#endif
+
+  key_essentials.flags =
+      uint16_t(actor.table_flags & MDBX_db_flags_t(MDBX_INTEGERKEY | MDBX_REVERSEKEY | MDBX_DUPSORT));
+  assert(actor.keylen_min <= UINT16_MAX);
+  key_essentials.minlen = uint16_t(actor.keylen_min);
+  assert(actor.keylen_max <= UINT32_MAX);
+  key_essentials.maxlen =
+      std::min(uint32_t(actor.keylen_max), uint32_t(mdbx_limits_keysize_max(actor.pagesize, actor.table_flags)));
+  key_essentials.bits =
+      (key_essentials.maxlen < sizeof(serial_t)) ? key_essentials.maxlen * CHAR_BIT : sizeof(serial_t) * CHAR_BIT;
+  key_essentials.mask = actor_params::serial_mask(key_essentials.bits);
+  assert(key_essentials.bits > 63 || key_essentials.mask > primes[key_essentials.bits]);
+
+  value_essentials.flags =
+      uint16_t(actor.table_flags & MDBX_db_flags_t(MDBX_INTEGERDUP | MDBX_REVERSEDUP | MDBX_DUPFIXED));
+  assert(actor.datalen_min <= UINT16_MAX);
+  value_essentials.minlen = uint16_t(actor.datalen_min);
+  assert(actor.datalen_max <= UINT32_MAX);
+  value_essentials.maxlen =
+      std::min(uint32_t(actor.datalen_max), uint32_t(mdbx_limits_valsize_max(actor.pagesize, actor.table_flags)));
+  value_essentials.bits =
+      (value_essentials.maxlen < sizeof(serial_t)) ? value_essentials.maxlen * CHAR_BIT : sizeof(serial_t) * CHAR_BIT;
+  value_essentials.mask = actor_params::serial_mask(value_essentials.bits);
+  assert(value_essentials.bits > 63 || value_essentials.mask > primes[value_essentials.bits]);
+
+  if (!actor.keygen.zero_fill) {
+    key_essentials.flags |= essentials::prng_fill_flag;
+    value_essentials.flags |= essentials::prng_fill_flag;
+  }
+
+  mapping = actor.keygen;
+  const auto split = mapping.split;
+  while (mapping.split > value_essentials.bits - essentials::value_age_minwidth || mapping.split >= mapping.width)
+    mapping.split -= 1;
+  if (split != mapping.split)
+    log_notice("keygen: reduce mapping-split from %u to %u", split, mapping.split);
+
+  const auto width = mapping.width;
+  while (unsigned((actor.table_flags & MDBX_DUPSORT) ? mapping.width - mapping.split : mapping.width) >
+         key_essentials.bits)
+    mapping.width -= 1;
+  if (width != mapping.width)
+    log_notice("keygen: reduce mapping-width from %u to %u", width, mapping.width);
+
+  value_age_bits = value_essentials.bits - mapping.split;
+  value_age_mask = actor_params::serial_mask(value_age_bits);
+  assert(value_age_bits >= essentials::value_age_minwidth);
+
+  salt = (prng_state ^ (thread_number * 1575554837) * UINT64_C(59386707711075671)) * UINT64_C(14653293970879851569);
+  base = actor.serial_base();
+}
+
+bool maker::is_unordered() const {
+  return mapping.rotate || mapping.mesh > ((MDBX_db_flags_t(key_essentials.flags) & MDBX_DUPSORT) ? 0 : mapping.split);
+}
+
+void maker::seek2end(serial_t &serial) const { serial = actor_params::serial_mask(mapping.width) - 1; }
+
+bool maker::increment(serial_t &serial, int64_t delta) const {
+  if (serial > actor_params::serial_mask(mapping.width)) {
+    log_extra("keygen-increment: %" PRIu64 " > %" PRIu64 ", overflow", serial,
+              actor_params::serial_mask(mapping.width));
+    return false;
+  }
+
+  serial_t target = serial + delta;
+  if (target > actor_params::serial_mask(mapping.width) || ((delta > 0) ? target < serial : target > serial)) {
+    log_extra("keygen-increment: %" PRIu64 "%-" PRId64 " => %" PRIu64 ", overflow", serial, delta, target);
+    return false;
+  }
+
+  log_extra("keygen-increment: %" PRIu64 "%-" PRId64 " => %" PRIu64 ", continue", serial, delta, target);
+  serial = target;
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+
+MDBX_NOTHROW_PURE_FUNCTION static inline unsigned length(serial_t serial) {
+#if defined(__clang__) && __clang__ > 8
+  unsigned n = 0;
+  if (serial > UINT32_MAX) {
+    n = 4;
+    serial >>= 32;
+  }
+  if (serial > UINT16_MAX) {
+    n += 2;
+    serial >>= 16;
+  }
+  if (serial > UINT8_MAX) {
+    n += 1;
+    serial >>= 8;
+  }
+#else
+  unsigned n = (serial > UINT32_MAX) ? 4 : 0;
+  serial = (serial > UINT32_MAX) ? serial >> 32 : serial;
+
+  n += (serial > UINT16_MAX) ? 2 : 0;
+  serial = (serial > UINT16_MAX) ? serial >> 16 : serial;
+
+  n += (serial > UINT8_MAX);
+  serial = (serial > UINT8_MAX) ? serial >> 8 : serial;
+#endif
+  return n + (serial > 0);
+}
+
+buffer alloc(size_t limit) {
+  result *ptr = (result *)malloc(sizeof(result) + limit + 8);
+  if (unlikely(ptr == nullptr))
+    failure_perror("malloc(keyvalue_buffer)", errno);
+  ptr->value.iov_base = ptr->bytes;
+  ptr->value.iov_len = 0;
+  ptr->limit = limit + 8;
+  return buffer(ptr);
+}
+
+serial_t __hot maker::mk_begin(serial_t serial, const essentials &params, result &out) {
+  assert(out.limit >= params.maxlen);
+  assert(params.maxlen >= params.minlen);
+  assert(serial <= params.mask);
+  if (unlikely(serial > params.mask)) {
+#if 1
+    serial %= primes[params.bits];
+    assert(params.mask > primes[params.bits]);
+#else
+    const serial_t maxbits = params.maxlen * CHAR_BIT;
+    serial ^=
+        (serial >> maxbits / 2) * serial_t((sizeof(serial_t) > 4) ? UINT64_C(40719303417517073) : UINT32_C(3708688457));
+    serial &= params.mask;
+#endif
+    assert(params.maxlen >= length(serial));
+  }
+
+  out.value.iov_len = std::max(unsigned(params.minlen), length(serial));
+  const auto variation = params.maxlen - params.minlen;
+  if (variation) {
+    if (serial % (variation + serial_t(1))) {
+      auto refix = serial * UINT64_C(48835288005252737);
+      refix ^= refix >> 32;
+      out.value.iov_len = std::max(out.value.iov_len, params.minlen + size_t(1) + size_t(refix) % variation);
+    }
+  }
+
+  assert(length(serial) <= out.value.iov_len);
+  assert(out.value.iov_len >= params.minlen);
+  assert(out.value.iov_len <= params.maxlen);
+  return serial;
+}
+
+void __hot maker::mk_continue(const serial_t serial, const essentials &params, result &out) {
+#if CONSTEXPR_ENUM_FLAGS_OPERATIONS
+  static_assert((essentials::prng_fill_flag & unsigned(MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERKEY |
+                                                       MDBX_INTEGERDUP | MDBX_REVERSEKEY | MDBX_REVERSEDUP)) == 0,
+                "WTF?");
+#else
+  assert((essentials::prng_fill_flag & unsigned(MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERKEY | MDBX_INTEGERDUP |
+                                                MDBX_REVERSEKEY | MDBX_REVERSEDUP)) == 0);
+#endif
+  assert(length(serial) <= out.value.iov_len);
+  out.value.iov_base = out.bytes;
+  if (MDBX_db_flags_t(params.flags) & (MDBX_INTEGERKEY | MDBX_INTEGERDUP)) {
+    assert(params.maxlen == params.minlen);
+    if (MDBX_db_flags_t(params.flags) & (MDBX_INTEGERKEY | MDBX_INTEGERDUP))
+      assert(params.minlen == 4 || params.minlen == 8);
+    out.u64 = serial;
+    if (!is_byteorder_le() && out.value.iov_len != 8)
+      out.u32 = uint32_t(serial);
+  } else {
+    const auto prefix = std::max(std::min(unsigned(params.minlen), 8u), length(serial));
+    out.u64 = htobe64(serial);
+    out.value.iov_base = out.bytes + 8 - prefix;
+    if (out.value.iov_len > prefix) {
+      if (params.flags & essentials::prng_fill_flag) {
+        uint64_t state = serial ^ UINT64_C(0x923ab47b7ee6f6e4);
+        prng_fill(state, out.bytes + 8, out.value.iov_len - prefix);
+      } else
+        memset(out.bytes + 8, '\0', out.value.iov_len - prefix);
+    }
+    if (unlikely(MDBX_db_flags_t(params.flags) & (MDBX_REVERSEKEY | MDBX_REVERSEDUP)))
+      std::reverse((char *)out.value.iov_base, (char *)out.value.iov_base + out.value.iov_len);
+  }
+
+  assert(out.value.iov_len >= params.minlen);
+  assert(out.value.iov_len <= params.maxlen);
+  assert(out.value.iov_len >= length(serial));
+  assert(out.value.iov_base >= out.bytes);
+  assert((char *)out.value.iov_base + out.value.iov_len <= (char *)&out.bytes + out.limit);
+}
+
+void log_pair(logging::loglevel level, const char *prefix, const buffer &key, buffer &value) {
+  if (log_enabled(level)) {
+    char dump_key[4096], dump_value[4096];
+    logging::output(level, "%s-pair: key %s, value %s", prefix, mdbx_dump_val(&key->value, dump_key, sizeof(dump_key)),
+                    mdbx_dump_val(&value->value, dump_value, sizeof(dump_value)));
+  }
+}
+
+} /* namespace keygen */