/// \author Леонид Юрьев aka Leonid Yuriev \date 2015-2024 /// \copyright SPDX-License-Identifier: Apache-2.0 #include "test.h++" #if !(defined(_WIN32) || defined(_WIN64)) #include #include #endif /* !Windows */ MDBX_NORETURN void usage(void) { puts( "usage:\n" " --help or -h Show this text\n" "Common parameters:\n" " --loglevel=[0-7]|[fatal..extra]s" " --pathname=... Path and/or name of database files\n" " --repeat=N Set repeat counter\n" " --threads=N Number of thread (unsupported for now)\n" " --timeout=N[s|m|h|d] Set timeout in seconds/minutes/hours/days\n" " --failfast[=YES/no] Lill all actors on first failure/error\n" " --max-readers=N See mdbx_env_set_maxreaders() description\n" " --max-tables=N Se mdbx_env_set_maxdbs() description\n" " --dump-config[=YES/no] Dump entire test config before run\n" " --progress[=YES/no] Enable/disable progress `canary`\n" " --console[=yes/no] Enable/disable console-like output\n" " --cleanup-before[=YES/no] Cleanup/remove and re-create database\n" " --cleanup-after[=YES/no] Cleanup/remove database after completion\n" " --prng-seed=N Seed PRNG\n" "Database size control:\n" " --pagesize=... Database page size: min, max, 256..65536\n" " --size-lower=N[K|M|G|T] Lower-bound of size in Kb/Mb/Gb/Tb\n" " --size-upper Upper-bound of size in Kb/Mb/Gb/Tb\n" " --size Initial size in Kb/Mb/Gb/Tb\n" " --shrink-threshold Shrink threshold in Kb/Mb/Gb/Tb\n" " --growth-step Grow step in Kb/Mb/Gb/Tb\n" "Predefined complex scenarios/cases:\n" " --case=... Only `basic` scenario implemented for now\n" " basic == Simultaneous multi-process execution\n" " of test-actors: nested,hill,ttl,copy,append,jitter,try\n" "Test actors:\n" " --hill Fill-up and empty-down\n" " by CRUD-operation quads\n" " --ttl Stochastic time-to-live simulation\n" " --nested Nested transactionы\n" " with stochastic-size bellows\n" " --jitter Jitter/delays simulation\n" " --try Try write-transaction, no more\n" " --copy Online copy/backup\n" " --append Append-mode insertions\n" " --dead.reader Dead-reader simulator\n" " --dead.writer Dead-writer simulator\n" #if !defined(_WIN32) && !defined(_WIN64) " --fork.reader After-fork reader\n" " --fork.writer After-fork writer\n" #endif /* Windows */ "Actor options:\n" " --batch.read=N Read-operations batch size\n" " --batch.write=N Write-operations batch size\n" " --delay=N | --no-delay (no)Delay test-actor before start\n" " --wait4ops=N | --no-wait4ops (no)Wait for previous test-actor\n" " completes # ops before start\n" " --duration=N[s|m|h|d] Define running duration\n" " --nops=N[K|M|G|T] Define number of operations/steps\n" " --inject-writefault[=yes|NO] TBD (see the source code)\n" " --drop[=yes|NO] Drop key-value space/table on " "completion\n" " --ignore-dbfull[=yes|NO] Ignore MDBX_MAP_FULL error\n" " --speculum[=yes|NO] Use internal `speculum` to check " "dataset\n" " --geometry-jitter[=YES|no] Use jitter for geometry upper-limit\n" "Keys and Value:\n" " --keylen.min=N Minimal keys length\n" " --keylen.max=N Miximal keys length\n" " --keylen=N Set both min/max for keys length\n" " --datalen.min=N Minimal data length\n" " --datalen.max=N Miximal data length\n" " --datalen=N Set both min/max for data length\n" " --keygen.width=N TBD (see the source code)\n" " --keygen.mesh=N TBD (see the source code)\n" " --keygen.zerofill=yes|NO TBD (see the source code)\n" " --keygen.split=N TBD (see the source code)\n" " --keygen.rotate=N TBD (see the source code)\n" " --keygen.offset=N TBD (see the source code)\n" " --keygen.case=random Generator case (only `random` for now)\n" "Database operation mode:\n" " --mode={[+-]FLAG}[,[+-]FLAG]...\n" " nosubdir == MDBX_NOSUBDIR\n" " rdonly == MDBX_RDONLY\n" " exclusive == MDBX_EXCLUSIVE\n" " accede == MDBX_ACCEDE\n" " nometasync == MDBX_NOMETASYNC\n" " lifo == MDBX_LIFORECLAIM\n" " nosync-safe == MDBX_SAFE_NOSYNC\n" " writemap == MDBX_WRITEMAP\n" " nosync-utterly == MDBX_UTTERLY_NOSYNC\n" " perturb == MDBX_PAGEPERTURB\n" " nostickythreads== MDBX_NOSTICKYTHREADS\n" " nordahead == MDBX_NORDAHEAD\n" " nomeminit == MDBX_NOMEMINIT\n" " --random-writemap[=YES|no] Toggle MDBX_WRITEMAP randomly\n" "Key-value space/table options:\n" " --table={[+-]FLAG}[,[+-]FLAG]...\n" " key.reverse == MDBX_REVERSEKEY\n" " key.integer == MDBX_INTEGERKEY\n" " data.dups == MDBX_DUPSORT\n" " data.integer == MDBX_INTEGERDUP | MDBX_DUPFIXED | MDBX_DUPSORT\n" " data.fixed == MDBX_DUPFIXED | MDBX_DUPSORT\n" " data.reverse == MDBX_REVERSEDUP | MDBX_DUPSORT\n"); exit(EXIT_FAILURE); } //----------------------------------------------------------------------------- void actor_params::set_defaults(const std::string &tmpdir) { pathname_log = ""; loglevel = #if MDBX_DEBUG < 1 logging::verbose; #elif MDBX_DEBUG > 1 logging::trace; #elif defined(_WIN32) || defined(_WIN64) || defined(__APPLE__) logging::verbose; #else logging::debug; #endif pathname_db = tmpdir + "mdbx-test.db"; mode_flags = MDBX_NOSUBDIR | MDBX_WRITEMAP | MDBX_SYNC_DURABLE | MDBX_ACCEDE; table_flags = MDBX_DUPSORT; size_lower = -1; size_now = intptr_t((table_flags & MDBX_DUPSORT) ? 256 : 1024) << 20; size_now = std::min(size_now, mdbx_limits_dbsize_max(-1)); size_upper = -1; shrink_threshold = -1; growth_step = -1; pagesize = -1; prng_seed = 0; keygen.zero_fill = false; keygen.keycase = kc_random; keygen.width = (table_flags & MDBX_DUPSORT) ? 32 : 64; keygen.mesh = keygen.width; keygen.split = keygen.width / 2; keygen.rotate = 3; keygen.offset = 41; test_duration = 0; test_nops = 1000; nrepeat = 1; nthreads = 1; keylen_min = mdbx_keylen_min(); keylen_max = mdbx_keylen_max(); datalen_min = mdbx_datalen_min(); datalen_max = std::min(mdbx_datalen_max(), 256u * 1024 + 42); batch_read = 42; batch_write = 42; delaystart = 0; waitfor_nops = 0; inject_writefaultn = 0; drop_table = false; ignore_dbfull = false; speculum = false; random_writemap = true; max_readers = 42; max_tables = 42; global::config::timeout_duration_seconds = 0 /* infinite */; global::config::dump_config = true; global::config::cleanup_before = true; global::config::cleanup_after = true; global::config::failfast = true; global::config::progress_indicator = true; global::config::console_mode = osal_istty(STDERR_FILENO); global::config::geometry_jitter = true; } namespace global { std::vector actors; std::unordered_map events; std::unordered_map pid2actor; std::set databases; unsigned nactors; chrono::time start_monotonic; chrono::time deadline_monotonic; bool singlemode; namespace config { unsigned timeout_duration_seconds; bool dump_config; bool cleanup_before; bool cleanup_after; bool failfast; bool progress_indicator; bool console_mode; bool geometry_jitter; } /* namespace config */ } /* namespace global */ //----------------------------------------------------------------------------- const char global::thunk_param_prefix[] = "--execute="; std::string thunk_param(const actor_config &config) { return config.serialize(global::thunk_param_prefix); } void cleanup() { log_trace(">> cleanup"); for (const auto &db_path : global::databases) { int err = mdbx_env_delete(db_path.c_str(), MDBX_ENV_JUST_DELETE); if (err != MDBX_SUCCESS && err != MDBX_RESULT_TRUE) failure_perror(db_path.c_str(), err); } log_trace("<< cleanup"); } static void fixup4qemu(actor_params ¶ms) { #ifdef MDBX_SAFE4QEMU #if MDBX_WORDBITS == 32 intptr_t safe4qemu_limit = size_t(512) << 20 /* 512 megabytes */; #if defined(__SANITIZE_ADDRESS__) safe4qemu_limit >>= 1; #else if (RUNNING_ON_VALGRIND) safe4qemu_limit >>= 1; #endif /* __SANITIZE_ADDRESS__ */ if (params.size_lower > safe4qemu_limit || params.size_now > safe4qemu_limit || params.size_upper > safe4qemu_limit) { params.size_upper = std::min(params.size_upper, safe4qemu_limit); params.size_now = std::min(params.size_now, params.size_upper); params.size_lower = std::min(params.size_lower, params.size_now); log_notice("workaround: for conformance 32-bit build with " "QEMU/ASAN/Valgrind database size reduced to %zu megabytes", safe4qemu_limit >> 20); } #endif /* MDBX_WORDBITS == 32 */ #if defined(__alpha__) || defined(__alpha) || defined(__sparc__) || \ defined(__sparc) || defined(__sparc64__) || defined(__sparc64) if (params.size_lower != params.size_upper) { log_notice( "workaround: for conformance Alpha/Sparc build with QEMU/ASAN/Valgrind " "enforce fixed database size %zu megabytes", params.size_upper >> 20); params.size_lower = params.size_now = params.size_upper; } #endif /* Alpha || Sparc */ #endif /* MDBX_SAFE4QEMU */ (void)params; } static void set_linebuf_append(FILE *out) { setvbuf(out, NULL, _IOLBF, 65536); #if !defined(_WIN32) && !defined(_WIN64) int fd = fileno(out); int flags = fcntl(fd, F_GETFD); if (flags != -1) (void)fcntl(fd, F_SETFD, O_APPEND | flags); #endif /* !Windows */ } int main(int argc, char *const argv[]) { set_linebuf_append(stdout); set_linebuf_append(stderr); #ifdef _DEBUG log_trace("#argc = %d", argc); for (int i = 0; i < argc; ++i) log_trace("#argv[%d] = %s", i, argv[i]); #endif /* _DEBUG */ if (argc < 2) failure("No parameters given. Try --help\n"); if (argc == 2 && strncmp(argv[1], global::thunk_param_prefix, strlen(global::thunk_param_prefix)) == 0) return test_execute( actor_config(argv[1] + strlen(global::thunk_param_prefix))) ? EXIT_SUCCESS : EXIT_FAILURE; if (argc == 2 && (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0)) usage(); actor_params params; params.set_defaults(osal_tempdir()); global::config::dump_config = true; logging::setup((logging::loglevel)params.loglevel, "main"); unsigned last_space_id = 0; for (int narg = 1; narg < argc; ++narg) { if (config::parse_option(argc, argv, narg, "dump-config", global::config::dump_config)) continue; if (config::parse_option(argc, argv, narg, "cleanup-before", global::config::cleanup_before)) continue; if (config::parse_option(argc, argv, narg, "cleanup-after", global::config::cleanup_after)) continue; if (config::parse_option(argc, argv, narg, "failfast", global::config::failfast)) continue; if (config::parse_option(argc, argv, narg, "progress", global::config::progress_indicator)) continue; if (config::parse_option(argc, argv, narg, "console", global::config::console_mode)) continue; if (config::parse_option(argc, argv, narg, "geometry-jitter", global::config::geometry_jitter)) continue; if (config::parse_option(argc, argv, narg, "timeout", global::config::timeout_duration_seconds, config::duration, 1)) continue; logging::loglevel loglevel; if (config::parse_option(argc, argv, narg, "loglevel", loglevel)) { logging::setup(loglevel, "main"); params.loglevel = static_cast(loglevel); continue; } const char *value = nullptr; if (config::parse_option(argc, argv, narg, "case", &value)) { fixup4qemu(params); testcase_setup(value, params, last_space_id); continue; } if (config::parse_option(argc, argv, narg, "pathname", params.pathname_db)) continue; if (config::parse_option(argc, argv, narg, "mode", params.mode_flags, config::mode_bits)) continue; if (config::parse_option(argc, argv, narg, "random-writemap", params.random_writemap)) continue; if (config::parse_option(argc, argv, narg, "table", params.table_flags, config::table_bits)) { if ((params.table_flags & MDBX_DUPFIXED) == 0) params.table_flags &= ~MDBX_INTEGERDUP; if ((params.table_flags & MDBX_DUPSORT) == 0) params.table_flags &= ~(MDBX_DUPFIXED | MDBX_REVERSEDUP | MDBX_INTEGERDUP); const unsigned keylen_max = params.mdbx_keylen_max(); if (params.keylen_min > keylen_max) params.keylen_min = keylen_max; if (params.keylen_max > keylen_max) params.keylen_max = keylen_max; const unsigned keylen_min = params.mdbx_keylen_min(); if (params.keylen_min < keylen_min) params.keylen_min = keylen_min; if (params.keylen_max < keylen_min) params.keylen_max = keylen_min; const unsigned datalen_max = params.mdbx_datalen_max(); if (params.datalen_min > datalen_max) params.datalen_min = datalen_max; if (params.datalen_max > datalen_max) params.datalen_max = datalen_max; const unsigned datalen_min = params.mdbx_datalen_min(); if (params.datalen_min < datalen_min) params.datalen_min = datalen_min; if (params.datalen_max < datalen_min) params.datalen_max = datalen_min; continue; } if (config::parse_option(argc, argv, narg, "pagesize", params.pagesize, int(mdbx_limits_pgsize_min()), int(mdbx_limits_pgsize_max()))) { const unsigned keylen_max = params.mdbx_keylen_max(); if (params.keylen_min > keylen_max) params.keylen_min = keylen_max; if (params.keylen_max > keylen_max) params.keylen_max = keylen_max; const unsigned datalen_max = params.mdbx_datalen_max(); if (params.datalen_min > datalen_max) params.datalen_min = datalen_max; if (params.datalen_max > datalen_max) params.datalen_max = datalen_max; continue; } if (config::parse_option(argc, argv, narg, "repeat", params.nrepeat, config::entropy)) continue; if (config::parse_option(argc, argv, narg, "threads", params.nthreads, config::no_scale, 1, 64)) continue; if (config::parse_option_intptr(argc, argv, narg, "size-lower", params.size_lower, mdbx_limits_dbsize_min(params.pagesize), mdbx_limits_dbsize_max(params.pagesize))) continue; int64_t i64 = params.size_upper; if (config::parse_option(argc, argv, narg, "size-upper-upto", i64, int64_t(mdbx_limits_dbsize_min(params.pagesize)), INT64_MAX, -1)) { if (i64 > mdbx_limits_dbsize_max(params.pagesize)) i64 = mdbx_limits_dbsize_max(params.pagesize); params.size_upper = intptr_t(i64); continue; } if (config::parse_option_intptr(argc, argv, narg, "size-upper", params.size_upper, mdbx_limits_dbsize_min(params.pagesize), mdbx_limits_dbsize_max(params.pagesize))) continue; if (config::parse_option_intptr(argc, argv, narg, "size", params.size_now, mdbx_limits_dbsize_min(params.pagesize), mdbx_limits_dbsize_max(params.pagesize))) continue; if (config::parse_option( argc, argv, narg, "shrink-threshold", params.shrink_threshold, 0, (int)std::min((intptr_t)INT_MAX, mdbx_limits_dbsize_max(params.pagesize) - mdbx_limits_dbsize_min(params.pagesize)))) continue; if (config::parse_option( argc, argv, narg, "growth-step", params.growth_step, 0, (int)std::min((intptr_t)INT_MAX, mdbx_limits_dbsize_max(params.pagesize) - mdbx_limits_dbsize_min(params.pagesize)))) continue; if (config::parse_option(argc, argv, narg, "keygen.width", params.keygen.width, 8, 64)) continue; if (config::parse_option(argc, argv, narg, "keygen.mesh", params.keygen.mesh, 0, 64)) continue; if (config::parse_option(argc, argv, narg, "prng-seed", params.prng_seed, config::entropy)) { prng_seed(params.prng_seed); continue; } if (config::parse_option(argc, argv, narg, "keygen.zerofill", params.keygen.zero_fill)) continue; if (config::parse_option(argc, argv, narg, "keygen.split", params.keygen.split, 0, 63)) continue; if (config::parse_option(argc, argv, narg, "keygen.rotate", params.keygen.rotate, 0, 63)) continue; if (config::parse_option(argc, argv, narg, "keygen.offset", params.keygen.offset, config::binary)) continue; if (config::parse_option(argc, argv, narg, "keygen.case", &value)) { keycase_setup(value, params); continue; } if (config::parse_option( argc, argv, narg, "keylen.min", params.keylen_min, (params.table_flags & MDBX_INTEGERKEY) ? config::intkey : config::no_scale, params.mdbx_keylen_min(), params.mdbx_keylen_max())) { if ((params.table_flags & MDBX_INTEGERKEY) || params.keylen_max < params.keylen_min) params.keylen_max = params.keylen_min; continue; } if (config::parse_option( argc, argv, narg, "keylen.max", params.keylen_max, (params.table_flags & MDBX_INTEGERKEY) ? config::intkey : config::no_scale, params.mdbx_keylen_min(), params.mdbx_keylen_max())) { if ((params.table_flags & MDBX_INTEGERKEY) || params.keylen_min > params.keylen_max) params.keylen_min = params.keylen_max; continue; } if (config::parse_option( argc, argv, narg, "keylen", params.keylen_min, (params.table_flags & MDBX_INTEGERKEY) ? config::intkey : config::no_scale, params.mdbx_keylen_min(), params.mdbx_keylen_max())) { params.keylen_max = params.keylen_min; continue; } if (config::parse_option( argc, argv, narg, "datalen.min", params.datalen_min, (params.table_flags & MDBX_INTEGERDUP) ? config::intkey : config::no_scale, params.mdbx_datalen_min(), params.mdbx_datalen_max())) { if ((params.table_flags & (MDBX_INTEGERDUP | MDBX_DUPFIXED)) || params.datalen_max < params.datalen_min) params.datalen_max = params.datalen_min; continue; } if (config::parse_option( argc, argv, narg, "datalen.max", params.datalen_max, (params.table_flags & MDBX_INTEGERDUP) ? config::intkey : config::no_scale, params.mdbx_datalen_min(), params.mdbx_datalen_max())) { if ((params.table_flags & (MDBX_INTEGERDUP | MDBX_DUPFIXED)) || params.datalen_min > params.datalen_max) params.datalen_min = params.datalen_max; continue; } if (config::parse_option( argc, argv, narg, "datalen", params.datalen_min, (params.table_flags & MDBX_INTEGERDUP) ? config::intkey : config::no_scale, params.mdbx_datalen_min(), params.mdbx_datalen_max())) { params.datalen_max = params.datalen_min; continue; } if (config::parse_option(argc, argv, narg, "batch.read", params.batch_read, config::no_scale, 1)) continue; if (config::parse_option(argc, argv, narg, "batch.write", params.batch_write, config::no_scale, 1)) continue; if (config::parse_option(argc, argv, narg, "delay", params.delaystart, config::duration)) continue; if (config::parse_option(argc, argv, narg, "wait4ops", params.waitfor_nops, config::decimal)) continue; if (config::parse_option(argc, argv, narg, "inject-writefault", params.inject_writefaultn, config::decimal)) continue; if (config::parse_option(argc, argv, narg, "drop", params.drop_table)) continue; if (config::parse_option(argc, argv, narg, "ignore-dbfull", params.ignore_dbfull)) continue; if (config::parse_option(argc, argv, narg, "speculum", params.speculum)) continue; if (config::parse_option(argc, argv, narg, "max-readers", params.max_readers, config::no_scale, 1, 255)) continue; if (config::parse_option(argc, argv, narg, "max-tables", params.max_tables, config::no_scale, 1, INT16_MAX)) continue; if (config::parse_option(argc, argv, narg, "no-delay", nullptr)) { params.delaystart = 0; continue; } if (config::parse_option(argc, argv, narg, "no-wait4ops", nullptr)) { params.waitfor_nops = 0; continue; } if (config::parse_option(argc, argv, narg, "duration", params.test_duration, config::duration, 1)) { params.test_nops = 0; continue; } if (config::parse_option(argc, argv, narg, "nops", params.test_nops, config::decimal, 1)) { params.test_duration = 0; continue; } if (config::parse_option(argc, argv, narg, "hill", &value, "auto")) { fixup4qemu(params); configure_actor(last_space_id, ac_hill, value, params); continue; } if (config::parse_option(argc, argv, narg, "jitter", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_jitter, value, params); continue; } if (config::parse_option(argc, argv, narg, "dead.reader", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_deadread, value, params); continue; } if (config::parse_option(argc, argv, narg, "dead.writer", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_deadwrite, value, params); continue; } if (config::parse_option(argc, argv, narg, "try", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_try, value, params); continue; } if (config::parse_option(argc, argv, narg, "copy", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_copy, value, params); continue; } if (config::parse_option(argc, argv, narg, "append", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_append, value, params); continue; } if (config::parse_option(argc, argv, narg, "ttl", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_ttl, value, params); continue; } if (config::parse_option(argc, argv, narg, "nested", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_nested, value, params); continue; } #if !defined(_WIN32) && !defined(_WIN64) if (config::parse_option(argc, argv, narg, "fork.reader", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_forkread, value, params); continue; } if (config::parse_option(argc, argv, narg, "fork.writer", nullptr)) { fixup4qemu(params); configure_actor(last_space_id, ac_forkwrite, value, params); continue; } #endif /* Windows */ if (*argv[narg] != '-') { fixup4qemu(params); testcase_setup(argv[narg], params, last_space_id); } else failure("Unknown option '%s'. Try --help\n", argv[narg]); } if (global::config::dump_config) config::dump(); //-------------------------------------------------------------------------- if (global::actors.empty()) { log_notice("no testcase(s) configured, exiting"); return EXIT_SUCCESS; } bool failed = false; global::start_monotonic = chrono::now_monotonic(); global::deadline_monotonic.fixedpoint = (global::config::timeout_duration_seconds == 0) ? chrono::infinite().fixedpoint : global::start_monotonic.fixedpoint + chrono::from_seconds(global::config::timeout_duration_seconds) .fixedpoint; if (global::config::cleanup_before) cleanup(); if (global::actors.size() == 1) { logging::setup("main"); global::singlemode = true; if (!test_execute(global::actors.front())) failed = true; } else { logging::setup("overlord"); log_trace("=== preparing..."); log_trace(">> osal_setup"); osal_setup(global::actors); log_trace("<< osal_setup"); for (auto &a : global::actors) { mdbx_pid_t pid; log_trace(">> actor_start"); int rc = osal_actor_start(a, pid); log_trace("<< actor_start"); if (rc) { log_trace(">> killall_actors: (%s)", "start failed"); osal_killall_actors(); log_trace("<< killall_actors"); failure("Failed to start actor #%u (%s)\n", a.actor_id, test_strerror(rc)); } global::pid2actor[pid] = &a; } log_trace("=== ready to start..."); atexit(osal_killall_actors); log_trace(">> wait4barrier"); osal_wait4barrier(); log_trace("<< wait4barrier"); size_t left = global::actors.size(); log_trace("=== polling..."); while (left > 0) { unsigned timeout_seconds_left = INT_MAX; chrono::time now_monotonic = chrono::now_monotonic(); if (now_monotonic.fixedpoint >= global::deadline_monotonic.fixedpoint) timeout_seconds_left = 0; else { chrono::time left_monotonic; left_monotonic.fixedpoint = global::deadline_monotonic.fixedpoint - now_monotonic.fixedpoint; timeout_seconds_left = left_monotonic.seconds(); } mdbx_pid_t pid; int rc = osal_actor_poll(pid, timeout_seconds_left); if (rc) failure("Poll error: %s (%d)\n", test_strerror(rc), rc); if (pid) { actor_status status = osal_actor_info(pid); actor_config *actor = global::pid2actor.at(pid); if (!actor) continue; if (status > as_running) { log_notice("actor #%u, id %d, pid %ld: %s\n", actor->actor_id, actor->space_id, (long)pid, status2str(status)); left -= 1; if (status != as_successful) { if (global::config::failfast && !failed) { log_trace(">> killall_actors: (%s)", "failfast"); osal_killall_actors(); log_trace("<< killall_actors"); } failed = true; } } else { log_verbose("actor #%u, id %d, pid %ld: %s\n", actor->actor_id, actor->space_id, (long)pid, status2str(status)); } } else { if (timeout_seconds_left == 0) failure("Timeout\n"); } } log_trace("=== done..."); } if (!failed) { MDBX_envinfo info; int err = mdbx_preopen_snapinfo(params.pathname_db.c_str(), &info, sizeof(info)); if (err != MDBX_SUCCESS) failure_perror("mdbx_preopen_snapinfo()", err); } log_notice("RESULT: %s\n", failed ? "Failed" : "Successful"); if (global::config::cleanup_after) { if (failed) log_verbose("skip cleanup"); else cleanup(); } #if !(defined(_WIN32) || defined(_WIN64)) struct rusage spent; if (!getrusage(global::singlemode ? RUSAGE_SELF : RUSAGE_CHILDREN, &spent)) { log_notice("%6s: user %f, system %f", "CPU", spent.ru_utime.tv_sec + spent.ru_utime.tv_usec * 1e-6, spent.ru_stime.tv_sec + spent.ru_stime.tv_usec * 1e-6); #if defined(__linux__) || defined(__gnu_linux__) || defined(__FreeBSD__) || \ defined(__NetBSD__) || defined(__OpenBSD__) || defined(__BSD__) || \ defined(__bsdi__) || defined(__DragonFly__) || defined(__APPLE__) || \ defined(__MACH__) || defined(__sun) log_notice("%6s: read %ld, write %ld", "IOPs", spent.ru_inblock, spent.ru_oublock); if (spent.ru_maxrss > 0) log_notice("%6s: %ld Kb", "RAM", spent.ru_maxrss #if defined(__sun) * getpagesize() / 1024u #elif defined(__APPLE__) / 1024u #endif ); log_notice("%6s: reclaims %ld, faults %ld, swaps %ld", "Paging", spent.ru_minflt, spent.ru_majflt, spent.ru_nswap); #endif /* Linux */ } #endif /* !Windows */ return failed ? EXIT_FAILURE : EXIT_SUCCESS; }