mdbxmou 0.1.26

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

@@ -0,0 +1,237 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "test.h++"
+
+class testcase_append : public testcase {
+public:
+  testcase_append(const actor_config &config, const mdbx_pid_t pid) : testcase(config, pid) {}
+  bool run() override;
+
+  static bool review_params(actor_params &params, unsigned space_id) {
+    if (!testcase::review_params(params, space_id))
+      return false;
+    const bool ordered = !flipcoin_x3();
+    log_notice("the '%s' key-generation mode is selected", ordered ? "ordered/linear" : "unordered/non-linear");
+    if (ordered && !params.make_keygen_linear())
+      return false;
+    return true;
+  }
+};
+REGISTER_TESTCASE(append);
+
+bool testcase_append::run() {
+  const bool reverse = flipcoin();
+  const char *const caption = reverse ? "ahead" : "append";
+  log_notice("the '%s' scenario is selected", caption);
+
+  int err = db_open__begin__table_create_open_clean(dbi);
+  if (unlikely(err != MDBX_SUCCESS)) {
+    log_notice("%s: bailout-prepare due '%s'", caption, mdbx_strerror(err));
+    return true;
+  }
+
+  cursor_open(dbi);
+  keyvalue_maker.setup(config.params, 0 /* thread_number */);
+  /* LY: тест наполнения таблиц в append-режиме,
+   * при котором записи добавляются строго в конец (в порядке сортировки) */
+  const MDBX_put_flags_t flags = reverse ? ((config.params.table_flags & MDBX_DUPSORT) ? MDBX_UPSERT : MDBX_NOOVERWRITE)
+                                         : ((config.params.table_flags & MDBX_DUPSORT)
+                                                ? (flipcoin() ? MDBX_APPEND | MDBX_APPENDDUP : MDBX_APPENDDUP)
+                                                : MDBX_APPEND);
+
+  key = keygen::alloc(config.params.keylen_max);
+  data = keygen::alloc(config.params.datalen_max);
+
+  simple_checksum inserted_checksum;
+  uint64_t inserted_number = 0;
+  uint64_t serial_count = 0;
+  if (reverse)
+    keyvalue_maker.seek2end(serial_count);
+
+  unsigned txn_nops = 0;
+  uint64_t committed_inserted_number = inserted_number;
+  simple_checksum committed_inserted_checksum = inserted_checksum;
+  while (should_continue()) {
+    const keygen::serial_t serial = serial_count;
+    const bool turn_key = (config.params.table_flags & MDBX_DUPSORT) == 0 || flipcoin_n(config.params.keygen.split);
+    if (turn_key ? !keyvalue_maker.increment_key_part(serial_count, reverse ? -1 : 1)
+                 : !keyvalue_maker.increment(serial_count, reverse ? -1 : 1)) {
+      // дошли до границы пространства ключей
+      break;
+    }
+
+    log_trace("%s: insert-a %" PRIu64, caption, serial);
+    generate_pair(serial);
+    // keygen::log_pair(logging::verbose, "append.", key, data);
+
+    bool expect_key_mismatch = false;
+    if (flags & (MDBX_APPEND | MDBX_APPENDDUP)) {
+      MDBX_val ge_key = key->value;
+      MDBX_val ge_data = data->value;
+      err = mdbx_get_equal_or_great(txn_guard.get(), dbi, &ge_key, &ge_data);
+
+      if (err == MDBX_SUCCESS /* exact match */) {
+        expect_key_mismatch = true;
+        assert(inserted_number > 0);
+        assert(mdbx_cmp(txn_guard.get(), dbi, &key->value, &ge_key) == 0);
+        assert((config.params.table_flags & MDBX_DUPSORT) == 0 ||
+               mdbx_dcmp(txn_guard.get(), dbi, &data->value, &ge_data) == 0);
+        assert(inserted_number > 0);
+      } else if (err == MDBX_RESULT_TRUE /* have key-value pair great than */) {
+        assert(mdbx_cmp(txn_guard.get(), dbi, &key->value, &ge_key) < 0 ||
+               ((config.params.table_flags & MDBX_DUPSORT) &&
+                mdbx_cmp(txn_guard.get(), dbi, &key->value, &ge_key) == 0 &&
+                mdbx_dcmp(txn_guard.get(), dbi, &data->value, &ge_data) < 0));
+        switch (int(flags)) {
+        default:
+          abort();
+#if CONSTEXPR_ENUM_FLAGS_OPERATIONS
+        case MDBX_APPEND | MDBX_APPENDDUP:
+#else
+        case int(MDBX_APPEND) | int(MDBX_APPENDDUP):
+#endif
+          assert((config.params.table_flags & MDBX_DUPSORT) != 0);
+          __fallthrough;
+          // fall through
+        case MDBX_APPEND:
+          expect_key_mismatch = true;
+          break;
+        case MDBX_APPENDDUP:
+          assert((config.params.table_flags & MDBX_DUPSORT) != 0);
+          expect_key_mismatch = mdbx_cmp(txn_guard.get(), dbi, &key->value, &ge_key) == 0;
+          break;
+        }
+      } else if (err == MDBX_NOTFOUND /* all pair are less than */) {
+        switch (int(flags)) {
+        default:
+          abort();
+        case MDBX_APPENDDUP:
+#if CONSTEXPR_ENUM_FLAGS_OPERATIONS
+        case MDBX_APPEND | MDBX_APPENDDUP:
+#else
+        case int(MDBX_APPEND) | int(MDBX_APPENDDUP):
+#endif
+          assert((config.params.table_flags & MDBX_DUPSORT) != 0);
+          __fallthrough;
+          // fall through
+        case MDBX_APPEND:
+          expect_key_mismatch = false;
+          break;
+        }
+      } else
+        failure_perror("mdbx_get_equal_or_great()", err);
+    }
+
+    err = mdbx_cursor_put(cursor_guard.get(), &key->value, &data->value, flags);
+    if (err == MDBX_MAP_FULL && config.params.ignore_dbfull) {
+      log_notice("%s: bailout-insert due '%s'", caption, mdbx_strerror(err));
+      txn_end(true);
+      inserted_number = committed_inserted_number;
+      inserted_checksum = committed_inserted_checksum;
+      break;
+    }
+
+    if (!expect_key_mismatch) {
+      if (unlikely(err != MDBX_SUCCESS))
+        failure_perror("mdbx_cursor_put(append)", err);
+      ++inserted_number;
+      inserted_checksum.push((uint32_t)inserted_number, key->value);
+      inserted_checksum.push(10639, data->value);
+
+      if (config.params.speculum) {
+        Item item(iov2dataview(key), iov2dataview(data));
+        const auto insertion_result = speculum.insert(item);
+        if (!insertion_result.second) {
+          char dump_key[32], dump_value[32];
+          log_error("speculum.append: unexpected %s {%s, %s}", "MDBX_SUCCESS",
+                    mdbx_dump_val(&key->value, dump_key, sizeof(dump_key)),
+                    mdbx_dump_val(&data->value, dump_value, sizeof(dump_value)));
+          return false;
+        }
+      }
+    } else if (unlikely(err != MDBX_EKEYMISMATCH))
+      failure_perror("mdbx_cursor_put(append) != MDBX_EKEYMISMATCH", err);
+
+    if (++txn_nops >= config.params.batch_write) {
+      err = breakable_restart();
+      if (unlikely(err != MDBX_SUCCESS)) {
+        log_notice("%s: bailout-commit due '%s'", caption, mdbx_strerror(err));
+        inserted_number = committed_inserted_number;
+        inserted_checksum = committed_inserted_checksum;
+        break;
+      }
+      committed_inserted_number = inserted_number;
+      committed_inserted_checksum = inserted_checksum;
+      txn_nops = 0;
+      if (!speculum_verify()) {
+        log_notice("append: bailout breakable_restart");
+        return false;
+      }
+    }
+
+    report(1);
+  }
+
+  if (txn_guard) {
+    err = breakable_commit();
+    if (unlikely(err != MDBX_SUCCESS)) {
+      log_notice("%s: bailout-commit due '%s'", caption, mdbx_strerror(err));
+      inserted_number = committed_inserted_number;
+      inserted_checksum = committed_inserted_checksum;
+    }
+  }
+  //----------------------------------------------------------------------------
+  txn_begin(true);
+  if (!speculum_verify()) {
+    log_notice("append: bailout verify");
+    return false;
+  }
+  cursor_renew();
+
+  MDBX_val check_key, check_data;
+  err = mdbx_cursor_get(cursor_guard.get(), &check_key, &check_data, reverse ? MDBX_LAST : MDBX_FIRST);
+  if (likely(inserted_number)) {
+    if (unlikely(err != MDBX_SUCCESS))
+      failure_perror("mdbx_cursor_get(MDBX_FIRST)", err);
+  }
+
+  simple_checksum read_checksum;
+  uint64_t read_count = 0;
+  while (err == MDBX_SUCCESS) {
+    ++read_count;
+    read_checksum.push((uint32_t)read_count, check_key);
+    read_checksum.push(10639, check_data);
+
+    err = mdbx_cursor_get(cursor_guard.get(), &check_key, &check_data, reverse ? MDBX_PREV : MDBX_NEXT);
+  }
+
+  if (unlikely(err != MDBX_NOTFOUND))
+    failure_perror("mdbx_cursor_get(MDBX_NEXT) != EOF", err);
+
+  if (unlikely(read_count != inserted_number))
+    failure("read_count(%" PRIu64 ") != inserted_number(%" PRIu64 ")", read_count, inserted_number);
+
+  if (unlikely(read_checksum.value != inserted_checksum.value) && !keyvalue_maker.is_unordered())
+    failure("read_checksum(0x%016" PRIu64 ") "
+            "!= inserted_checksum(0x%016" PRIu64 ")",
+            read_checksum.value, inserted_checksum.value);
+
+  cursor_close();
+  txn_end(true);
+  //----------------------------------------------------------------------------
+
+  if (dbi) {
+    if (config.params.drop_table && !mode_readonly()) {
+      txn_begin(false);
+      db_table_drop(dbi);
+      err = breakable_commit();
+      if (unlikely(err != MDBX_SUCCESS)) {
+        log_notice("%s: bailout-clean due '%s'", caption, mdbx_strerror(err));
+        return true;
+      }
+    } else
+      db_table_close(dbi);
+  }
+  return true;
+}

package/deps/libmdbx/test/base.h++

@@ -0,0 +1,92 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../src/essentials.h"
+
+#ifdef _MSC_VER
+#pragma warning(push, 1)
+#pragma warning(disable : 4548) /* expression before comma has no effect;                                              \
+                                   expected expression with side - effect */
+#pragma warning(disable : 4530) /* C++ exception handler used, but unwind                                              \
+                                   semantics are not enabled. Specify /EHsc */
+#pragma warning(disable : 4577) /* 'noexcept' used with no exception handling                                          \
+                                   mode specified; termination on exception                                            \
+                                   is not guaranteed. Specify /EHsc */
+#endif                          /* _MSC_VER (warnings) */
+
+#if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS)
+/* If you wish to build your application for a previous Windows platform,
+ * include WinSDKVer.h and set the _WIN32_WINNT macro to the platform you
+ * wish to support before including SDKDDKVer.h.
+ *
+ * TODO: #define _WIN32_WINNT WIN32_MUSTDIE */
+#include <SDKDDKVer.h>
+#endif /* WINDOWS */
+
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS)
+#include <io.h>
+#else
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#ifdef _BSD_SOURCE
+#include <endian.h>
+#endif
+
+#include <algorithm>
+#include <cassert>
+#include <cinttypes> // for PRId64, PRIu64
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#define MDBX_INTERNAL
+#define xMDBX_TOOLS /* Avoid using internal eASSERT() */
+#include "../mdbx.h++"
+#include "../src/osal.h"
+
+#include "../src/options.h"
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#pragma warning(disable : 4201) /* nonstandard extension used: nameless                                                \
+                                   struct/union */
+#pragma warning(disable : 4127) /* conditional expression is constant */
+#if _MSC_VER < 1900
+#pragma warning(disable : 4510) /* default constructor could                                                           \
+                                   not be generated */
+#pragma warning(disable : 4512) /* assignment operator could                                                           \
+                                   not be generated  */
+#pragma warning(disable : 4610) /* user-defined constructor required */
+#ifndef snprintf
+#define snprintf(buffer, buffer_size, format, ...) _snprintf_s(buffer, buffer_size, _TRUNCATE, format, __VA_ARGS__)
+#endif
+#ifndef vsnprintf
+#define vsnprintf(buffer, buffer_size, format, args) _vsnprintf_s(buffer, buffer_size, _TRUNCATE, format, args)
+#endif
+#pragma warning(disable : 4996) /* 'vsnprintf': This function or variable                                              \
+                                   may be unsafe */
+#endif
+#endif /* _MSC_VER */

package/deps/libmdbx/test/battery-tmux.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+
+# Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru>
+# SPDX-License-Identifier: Apache-2.0
+
+TMUX=tmux
+DIR="$(dirname ${BASH_SOURCE[0]})"
+TEST="${DIR}/stochastic.sh --skip-make --db-upto-gb 32"
+PREFIX="/dev/shm/mdbxtest-"
+
+NUMACTL="$(which numactl 2>-)"
+NUMALIST=()
+NUMAIDX=0
+if [ -n "${NUMACTL}" -a $(${NUMACTL} --hardware | grep 'node [0-9]\+ cpus' | wc -l) -gt 1 ]; then
+	NUMALIST=($(${NUMACTL} --hardware | grep 'node [0-9]\+ cpus' | cut -d ' ' -f 2))
+fi
+
+function test_numacycle {
+	NUMAIDX=$((NUMAIDX + 1))
+	if [ ${NUMAIDX} -ge ${#NUMALIST[@]} ]; then
+		NUMAIDX=0
+	fi
+}
+
+function test_numanode {
+	if [[ ${#NUMALIST[@]} > 1 ]]; then
+		echo "${TEST} --numa ${NUMALIST[$NUMAIDX]}"
+	else
+		echo "${TEST}"
+	fi
+}
+
+${TMUX} kill-session -t mdbx
+rm -rf ${PREFIX}*
+# git clean -x -f -d && make test-assertions
+${TMUX} -f "${DIR}/tmux.conf" new-session -d -s mdbx htop
+
+W=0
+for ps in min 4k max; do
+	for from in 1 30000; do
+		for n in 0 1 2 3; do
+			CMD="$(test_numanode) --delay $((n * 7)) --page-size ${ps} --from ${from} --dir ${PREFIX}page-${ps}.from-${from}.${n}"
+			if [ $n -eq 0 ]; then
+				${TMUX} new-window -t mdbx:$((++W)) -n "page-${ps}.from-${from}" -k -d "$CMD"
+				${TMUX} select-layout -E tiled
+			else
+				${TMUX} split-window -t mdbx:$W -l 20% -d $CMD
+			fi
+			test_numacycle
+		done
+		for n in 0 1 2 3; do
+			CMD="$(test_numanode) --delay $((3 + n * 7)) --extra --page-size ${ps} --from ${from} --dir ${PREFIX}page-${ps}.from-${from}.${n}-extra"
+			if [ $n -eq 0 ]; then
+				${TMUX} new-window -t mdbx:$((++W)) -n "page-${ps}.from-${from}-extra" -k -d "$CMD"
+				${TMUX} select-layout -E tiled
+			else
+				${TMUX} split-window -t mdbx:$W -l 20% -d $CMD
+			fi
+			test_numacycle
+		done
+	done
+done
+
+${TMUX} attach -t mdbx

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

@@ -0,0 +1,118 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "test.h++"
+
+registry *registry::instance() {
+  static registry *singleton;
+  if (!singleton)
+    singleton = new registry();
+  return singleton;
+}
+
+bool registry::add(const record *item) {
+  auto const singleton = instance();
+  assert(singleton->name2id.count(std::string(item->name)) == 0);
+  assert(singleton->id2record.count(item->id) == 0);
+  if (singleton->name2id.count(std::string(item->name)) + singleton->id2record.count(item->id) == 0) {
+    singleton->name2id[std::string(item->name)] = item;
+    singleton->id2record[item->id] = item;
+    return true;
+  }
+  return false;
+}
+
+testcase *registry::create_actor(const actor_config &config, const mdbx_pid_t pid) {
+  return instance()->id2record.at(config.testcase)->constructor(config, pid);
+}
+
+bool registry::review_actor_params(const actor_testcase id, actor_params &params, const unsigned space_id) {
+  return instance()->id2record.at(id)->review_params(params, space_id);
+}
+
+//-----------------------------------------------------------------------------
+
+void configure_actor(unsigned &last_space_id, const actor_testcase testcase, const char *space_id_cstr,
+                     actor_params params) {
+  unsigned wait4id = 0;
+  if (params.waitfor_nops) {
+    for (auto i = global::actors.rbegin(); i != global::actors.rend(); ++i) {
+      if (i->is_waitable(params.waitfor_nops)) {
+        if (i->signal_nops && i->signal_nops != params.waitfor_nops)
+          failure("Previous waitable actor (id=%u) already linked on %u-ops\n", i->actor_id, i->signal_nops);
+        wait4id = i->actor_id;
+        i->signal_nops = params.waitfor_nops;
+        break;
+      }
+    }
+    if (!wait4id)
+      failure("No previous waitable actor for %u-ops\n", params.waitfor_nops);
+  }
+
+  unsigned long space_id = 0;
+  if (!space_id_cstr || strcmp(space_id_cstr, "auto") == 0)
+    space_id = last_space_id + 1;
+  else {
+    char *end = nullptr;
+    errno = 0;
+    space_id = strtoul(space_id_cstr, &end, 0);
+    if (errno)
+      failure_perror("Expects an integer value for space-id\n", errno);
+    if (end && *end)
+      failure("The '%s' is unexpected for space-id\n", end);
+  }
+
+  if (space_id > ACTOR_ID_MAX)
+    failure("Invalid space-id %lu\n", space_id);
+
+  if (!registry::review_actor_params(testcase, params, unsigned(space_id)))
+    failure("Actor config-review failed for space-id %lu\n", space_id);
+
+  last_space_id = unsigned(space_id);
+  log_trace("configure_actor: space %lu for %s", space_id, testcase2str(testcase));
+  global::actors.emplace_back(actor_config(testcase, params, unsigned(space_id), wait4id));
+  global::databases.insert(params.pathname_db);
+}
+
+void testcase_setup(const char *casename, const actor_params &params, unsigned &last_space_id) {
+  if (strcmp(casename, "basic") == 0) {
+    log_notice(">>> testcase_setup(%s)", casename);
+    configure_actor(last_space_id, ac_nested, nullptr, params);
+    configure_actor(last_space_id, ac_hill, nullptr, params);
+    configure_actor(last_space_id, ac_ttl, nullptr, params);
+    configure_actor(last_space_id, ac_copy, nullptr, params);
+    configure_actor(last_space_id, ac_append, nullptr, params);
+    configure_actor(last_space_id, ac_jitter, nullptr, params);
+    configure_actor(last_space_id, ac_try, nullptr, params);
+    configure_actor(last_space_id, ac_jitter, nullptr, params);
+    configure_actor(last_space_id, ac_try, nullptr, params);
+#if !defined(_WIN32) && !defined(_WIN64)
+    configure_actor(last_space_id, ac_forkread, nullptr, params);
+    configure_actor(last_space_id, ac_forkwrite, nullptr, params);
+#endif /* Windows */
+    log_notice("<<< testcase_setup(%s): done", casename);
+  } else {
+    failure("unknown testcase `%s`", casename);
+  }
+}
+
+void keycase_setup(const char *casename, actor_params &params) {
+  if (strcmp(casename, "random") == 0 || strcmp(casename, "prng") == 0) {
+    log_notice(">>> keycase_setup(%s)", casename);
+    params.keygen.keycase = kc_random;
+    // TODO
+    log_notice("<<< keycase_setup(%s): done", casename);
+  } else if (strcmp(casename, "dashes") == 0 || strcmp(casename, "aside") == 0) {
+    log_notice(">>> keycase_setup(%s)", casename);
+    params.keygen.keycase = kc_dashes;
+    // TODO
+    log_notice("<<< keycase_setup(%s): done", casename);
+  } else if (strcmp(casename, "custom") == 0) {
+    log_notice("=== keycase_setup(%s): skip", casename);
+    params.keygen.keycase = kc_custom;
+  } else {
+    failure("unknown keycase `%s`", casename);
+  }
+}
+
+/* TODO */

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

@@ -0,0 +1,134 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "test.h++"
+
+namespace chrono {
+
+#ifndef NSEC_PER_SEC
+#define NSEC_PER_SEC 1000000000u
+#endif /* NSEC_PER_SEC */
+
+uint32_t ns2fractional(uint32_t ns) {
+  assert(ns < NSEC_PER_SEC);
+  /* LY: здесь и далее используется "длинное деление", которое
+   * для ясности кода оставлено как есть (без ручной оптимизации). Так как
+   * GCC, Clang и даже MSVC сами давно умеют конвертировать деление на
+   * константу в быструю reciprocal-форму. */
+  return uint32_t((uint64_t(ns) << 32) / NSEC_PER_SEC);
+}
+
+uint32_t fractional2ns(uint32_t fractional) { return uint32_t((fractional * uint64_t(NSEC_PER_SEC)) >> 32); }
+
+#ifndef USEC_PER_SEC
+#define USEC_PER_SEC 1000000u
+#endif /* USEC_PER_SEC */
+uint32_t us2fractional(uint32_t us) {
+  assert(us < USEC_PER_SEC);
+  return uint32_t((uint64_t(us) << 32) / USEC_PER_SEC);
+}
+
+uint32_t fractional2us(uint32_t fractional) {
+#if !(defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64))
+  /* Смеяться или плакать, но все существующие на май 2024 компиляторы Microsoft
+   * для ARM/ARM64, уже порядка 10 лет, падают на этом коде из-за внтутренней
+   * ошибке (aka ICE). */
+  return uint32_t((fractional * uint64_t(USEC_PER_SEC)) >> 32);
+#else
+  static_assert(USEC_PER_SEC % 16 == 0, "WTF?");
+  /* Crutch for MSVC ARM/ARM64 compilers to avoid internal compiler error. */
+  return UInt32x32To64(fractional, USEC_PER_SEC / 16) >> 28;
+#endif
+}
+
+#ifndef MSEC_PER_SEC
+#define MSEC_PER_SEC 1000u
+#endif /* MSEC_PER_SEC */
+uint32_t ms2fractional(uint32_t ms) {
+  assert(ms < MSEC_PER_SEC);
+  return uint32_t((uint64_t(ms) << 32) / MSEC_PER_SEC);
+}
+
+uint32_t fractional2ms(uint32_t fractional) { return uint32_t((fractional * uint64_t(MSEC_PER_SEC)) >> 32); }
+
+time from_ns(uint64_t ns) {
+  time result;
+  result.fixedpoint = ((ns / NSEC_PER_SEC) << 32) | ns2fractional(uint32_t(ns % NSEC_PER_SEC));
+  return result;
+}
+
+time from_us(uint64_t us) {
+  time result;
+  result.fixedpoint = ((us / USEC_PER_SEC) << 32) | us2fractional(uint32_t(us % USEC_PER_SEC));
+  return result;
+}
+
+time from_ms(uint64_t ms) {
+  time result;
+  result.fixedpoint = ((ms / MSEC_PER_SEC) << 32) | ms2fractional(uint32_t(ms % MSEC_PER_SEC));
+  return result;
+}
+
+#if __GNUC_PREREQ(8, 0) && (defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif /* GCC/MINGW */
+
+time now_realtime() {
+#if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS)
+  static void(WINAPI * query_time)(LPFILETIME);
+  if (unlikely(!query_time)) {
+    HMODULE hModule = GetModuleHandle(TEXT("kernel32.dll"));
+    if (hModule)
+      query_time = (void(WINAPI *)(LPFILETIME))GetProcAddress(hModule, "GetSystemTimePreciseAsFileTime");
+    if (!query_time)
+      query_time = GetSystemTimeAsFileTime;
+  }
+
+  FILETIME filetime;
+  query_time(&filetime);
+  uint64_t ns100 = (uint64_t)filetime.dwHighDateTime << 32 | filetime.dwLowDateTime;
+  return from_ns((ns100 - UINT64_C(116444736000000000)) * 100u);
+#else
+  struct timespec ts;
+  if (unlikely(clock_gettime(CLOCK_REALTIME, &ts)))
+    failure_perror("clock_gettime(CLOCK_REALTIME", errno);
+
+  return from_timespec(ts);
+#endif
+}
+
+time now_monotonic() {
+#if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS)
+  static uint64_t reciprocal;
+  static LARGE_INTEGER Frequency;
+  if (reciprocal == 0) {
+    if (!QueryPerformanceFrequency(&Frequency))
+      failure_perror("QueryPerformanceFrequency()", GetLastError());
+    reciprocal = (((UINT64_C(1) << 48) + Frequency.QuadPart / 2 + 1) / Frequency.QuadPart);
+    assert(reciprocal);
+  }
+
+  LARGE_INTEGER Counter;
+  if (!QueryPerformanceCounter(&Counter))
+    failure_perror("QueryPerformanceCounter()", GetLastError());
+
+  time result;
+  result.fixedpoint = (Counter.QuadPart / Frequency.QuadPart) << 32;
+  uint64_t mod = Counter.QuadPart % Frequency.QuadPart;
+  result.fixedpoint += (mod * reciprocal) >> 16;
+  return result;
+#else
+  struct timespec ts;
+  if (unlikely(clock_gettime(CLOCK_MONOTONIC, &ts)))
+    failure_perror("clock_gettime(CLOCK_MONOTONIC)", errno);
+
+  return from_timespec(ts);
+#endif
+}
+
+#if __GNUC_PREREQ(8, 0) && (defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__))
+#pragma GCC diagnostic pop
+#endif /* GCC/MINGW */
+
+} /* namespace chrono */