/* * Copyright 2017-2022 Leonid Yuriev * and other libmdbx authors: please see AUTHORS file. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in the file LICENSE in the * top-level directory of the distribution or, alternatively, at * . */ #include "test.h" const char *testcase2str(const actor_testcase testcase) { switch (testcase) { default: assert(false); return "?!"; case ac_none: return "none"; case ac_hill: return "hill"; case ac_deadread: return "deadread"; case ac_deadwrite: return "deadwrite"; case ac_jitter: return "jitter"; case ac_try: return "try"; case ac_copy: return "copy"; case ac_append: return "append"; case ac_ttl: return "ttl"; case ac_nested: return "nested"; } } const char *status2str(actor_status status) { switch (status) { default: assert(false); return "?!"; case as_debugging: return "debugging"; case as_running: return "running"; case as_successful: return "successful"; case as_killed: return "killed"; case as_failed: return "failed"; case as_coredump: return "coredump"; } } const char *keygencase2str(const keygen_case keycase) { switch (keycase) { default: assert(false); return "?!"; case kc_random: return "random"; case kc_dashes: return "dashes"; case kc_custom: return "custom"; } } //----------------------------------------------------------------------------- int testcase::hsr_callback(const MDBX_env *env, const MDBX_txn *txn, mdbx_pid_t pid, mdbx_tid_t tid, uint64_t laggard, unsigned gap, size_t space, int retry) MDBX_CXX17_NOEXCEPT { (void)txn; testcase *self = (testcase *)mdbx_env_get_userctx(env); if (retry == 0) log_notice("hsr_callback: waitfor pid %lu, thread %" PRIuPTR ", txn #%" PRIu64 ", gap %d, space %zu", (long)pid, (size_t)tid, laggard, gap, space); MDBX_envinfo info; int rc = mdbx_env_info_ex(env, txn, &info, sizeof(info)); if (rc != MDBX_SUCCESS) return rc; if (self->should_continue(true) && (space > size_t(info.mi_geo.grow) * 2 || info.mi_geo.current >= info.mi_geo.upper)) { osal_yield(); if (retry > 0) osal_udelay(retry * 100); return MDBX_RESULT_FALSE /* retry / wait until reader done */; } /* allow growth or MDBX_MAP_FULL */ return MDBX_RESULT_TRUE; } void testcase::db_prepare() { log_trace(">> db_prepare"); assert(!db_guard); MDBX_env *env = nullptr; int rc = mdbx_env_create(&env); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_create()", rc); assert(env != nullptr); db_guard.reset(env); rc = mdbx_env_set_userctx(env, this); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_userctx()", rc); rc = mdbx_env_set_maxreaders(env, config.params.max_readers); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_maxreaders()", rc); rc = mdbx_env_set_maxdbs(env, config.params.max_tables); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_maxdbs()", rc); rc = mdbx_env_set_hsr(env, testcase::hsr_callback); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_hsr()", rc); rc = mdbx_env_set_geometry( env, config.params.size_lower, config.params.size_now, config.params.size_upper, config.params.growth_step, config.params.shrink_threshold, config.params.pagesize); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_set_mapsize()", rc); log_trace("<< db_prepare"); } void testcase::db_open() { log_trace(">> db_open"); if (!db_guard) db_prepare(); jitter_delay(true); MDBX_env_flags_t mode = config.params.mode_flags; if (config.params.random_writemap && flipcoin()) mode ^= MDBX_WRITEMAP; actual_env_mode = mode; int rc = mdbx_env_open(db_guard.get(), config.params.pathname_db.c_str(), mode, 0640); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_env_open()", rc); rc = mdbx_env_set_syncperiod(db_guard.get(), unsigned(0.042 * 65536)); if (unlikely(rc != MDBX_SUCCESS) && rc != MDBX_BUSY) failure_perror("mdbx_env_set_syncperiod()", rc); rc = mdbx_env_set_syncbytes(db_guard.get(), INT_MAX / 421); if (unlikely(rc != MDBX_SUCCESS) && rc != MDBX_BUSY) failure_perror("mdbx_env_set_syncbytes()", rc); log_trace("<< db_open"); } void testcase::db_close() { log_trace(">> db_close"); cursor_guard.reset(); txn_guard.reset(); db_guard.reset(); log_trace("<< db_close"); } void testcase::txn_begin(bool readonly, MDBX_txn_flags_t flags) { assert((flags & MDBX_TXN_RDONLY) == 0); log_trace(">> txn_begin(%s, 0x%04X)", readonly ? "read-only" : "read-write", flags); assert(!txn_guard); MDBX_txn *txn = nullptr; int rc = mdbx_txn_begin(db_guard.get(), nullptr, readonly ? flags | MDBX_TXN_RDONLY : flags, &txn); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_txn_begin()", rc); txn_guard.reset(txn); need_speculum_assign = config.params.speculum && !readonly; log_trace("<< txn_begin(%s, 0x%04X)", readonly ? "read-only" : "read-write", flags); } int testcase::breakable_commit() { log_trace(">> txn_commit"); assert(txn_guard); /* CLANG/LLVM C++ library could stupidly copy std::set<> item-by-item, * i.e. with insertion(s) & comparison(s), which will cause null dereference * during call mdbx_cmp() with zero txn. So it is the workaround for this: * - explicitly make copies of the `speculums`; * - explicitly move relevant copy after transaction commit. */ SET speculum_committed_copy(ItemCompare(this)), speculum_copy(ItemCompare(this)); if (need_speculum_assign) { speculum_committed_copy = speculum_committed; speculum_copy = speculum; } MDBX_txn *txn = txn_guard.release(); txn_inject_writefault(txn); int rc = mdbx_txn_commit(txn); if (unlikely(rc != MDBX_SUCCESS) && (rc != MDBX_MAP_FULL || !config.params.ignore_dbfull)) failure_perror("mdbx_txn_commit()", rc); if (need_speculum_assign) { need_speculum_assign = false; if (unlikely(rc != MDBX_SUCCESS)) speculum = std::move(speculum_committed_copy); else speculum_committed = std::move(speculum_copy); } log_trace("<< txn_commit: %s", rc ? "failed" : "Ok"); return rc; } unsigned testcase::txn_underutilization_x256(MDBX_txn *txn) const { if (txn) { MDBX_txn_info info; int err = mdbx_txn_info(txn, &info, false); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_txn_info()", err); const size_t left = size_t(info.txn_space_leftover); const size_t total = size_t(info.txn_space_leftover) + size_t(info.txn_space_dirty); return (unsigned)(left / (total >> 8)); } return 0; } void testcase::txn_end(bool abort) { log_trace(">> txn_end(%s)", abort ? "abort" : "commit"); assert(txn_guard); MDBX_txn *txn = txn_guard.release(); if (abort) { int err = mdbx_txn_abort(txn); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_txn_abort()", err); if (need_speculum_assign) speculum = speculum_committed; } else { txn_inject_writefault(txn); int err = mdbx_txn_commit(txn); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_txn_commit()", err); if (need_speculum_assign) speculum_committed = speculum; } log_trace("<< txn_end(%s)", abort ? "abort" : "commit"); } void testcase::cursor_open(MDBX_dbi handle) { log_trace(">> cursor_open(%u)", handle); assert(!cursor_guard); assert(txn_guard); MDBX_cursor *cursor = nullptr; int rc = mdbx_cursor_open(txn_guard.get(), handle, &cursor); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_cursor_open()", rc); cursor_guard.reset(cursor); log_trace("<< cursor_open(%u)", handle); } void testcase::cursor_close() { log_trace(">> cursor_close()"); assert(cursor_guard); MDBX_cursor *cursor = cursor_guard.release(); mdbx_cursor_close(cursor); log_trace("<< cursor_close()"); } void testcase::cursor_renew() { log_trace(">> cursor_renew()"); assert(cursor_guard); int err = mdbx_cursor_renew(txn_guard.get(), cursor_guard.get()); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_cursor_renew()", err); log_trace("<< cursor_renew()"); } int testcase::breakable_restart() { int rc = MDBX_SUCCESS; if (txn_guard) rc = breakable_commit(); txn_begin(false, MDBX_TXN_READWRITE); if (cursor_guard) cursor_renew(); return rc; } void testcase::txn_restart(bool abort, bool readonly, MDBX_txn_flags_t flags) { if (txn_guard) txn_end(abort); txn_begin(readonly, flags); if (cursor_guard) cursor_renew(); } void testcase::txn_inject_writefault(void) { if (txn_guard) txn_inject_writefault(txn_guard.get()); } void testcase::txn_inject_writefault(MDBX_txn *txn) { if (config.params.inject_writefaultn && txn) { if (config.params.inject_writefaultn <= nops_completed && (MDBX_txn_flags_t(mdbx_txn_flags(txn)) & MDBX_TXN_RDONLY) == 0) { log_verbose( "== txn_inject_writefault(): got %u nops or more, inject FAULT", config.params.inject_writefaultn); log_flush(); #if defined(_WIN32) || defined(_WIN64) || defined(_WINDOWS) TerminateProcess(GetCurrentProcess(), 42); #else raise(SIGKILL); #endif } } } bool testcase::wait4start() { if (config.wait4id) { log_trace(">> wait4start(%u)", config.wait4id); assert(!global::singlemode); int rc = osal_waitfor(config.wait4id); if (rc) { log_trace("<< wait4start(%u), failed %s", config.wait4id, test_strerror(rc)); return false; } } else { log_trace("== skip wait4start: not needed"); } if (config.params.delaystart) { int rc = osal_delay(config.params.delaystart); if (rc) { log_trace("<< delay(%u), failed %s", config.params.delaystart, test_strerror(rc)); return false; } } else { log_trace("== skip delay: not needed"); } return true; } void testcase::kick_progress(bool active) const { if (!global::config::progress_indicator) return; logging::progress_canary(active); } void testcase::report(size_t nops_done) { assert(nops_done > 0); if (!nops_done) return; nops_completed += nops_done; log_debug("== complete +%" PRIuPTR " iteration, total %" PRIu64 " done", nops_done, nops_completed); kick_progress(true); if (config.signal_nops && !signalled && config.signal_nops <= nops_completed) { log_trace(">> signal(n-ops %" PRIu64 ")", nops_completed); if (!global::singlemode) osal_broadcast(config.actor_id); signalled = true; log_trace("<< signal(n-ops %" PRIu64 ")", nops_completed); } } void testcase::signal() { if (!signalled) { log_trace(">> signal(forced)"); if (!global::singlemode) osal_broadcast(config.actor_id); signalled = true; log_trace("<< signal(forced)"); } } bool testcase::setup() { db_prepare(); if (!wait4start()) return false; start_timestamp = chrono::now_monotonic(); nops_completed = 0; return true; } bool testcase::teardown() { log_trace(">> testcase::teardown"); signal(); db_close(); log_trace("<< testcase::teardown"); return true; } bool testcase::should_continue(bool check_timeout_only) const { bool result = true; if (config.params.test_duration) { chrono::time since; since.fixedpoint = chrono::now_monotonic().fixedpoint - start_timestamp.fixedpoint; if (since.seconds() >= config.params.test_duration) result = false; } if (!check_timeout_only && config.params.test_nops && nops_completed >= config.params.test_nops) result = false; if (result) kick_progress(false); return result; } void testcase::fetch_canary() { MDBX_canary canary_now; log_trace(">> fetch_canary"); int rc = mdbx_canary_get(txn_guard.get(), &canary_now); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_canary_get()", rc); if (canary_now.v < last.canary.v) failure("fetch_canary: %" PRIu64 "(canary-now.v) < %" PRIu64 "(canary-last.v)", canary_now.v, last.canary.v); if (canary_now.y < last.canary.y) failure("fetch_canary: %" PRIu64 "(canary-now.y) < %" PRIu64 "(canary-last.y)", canary_now.y, last.canary.y); last.canary = canary_now; log_trace("<< fetch_canary: db-sequence %" PRIu64 ", db-sequence.txnid %" PRIu64, last.canary.y, last.canary.v); } void testcase::update_canary(uint64_t increment) { MDBX_canary canary_now = last.canary; log_trace(">> update_canary: sequence %" PRIu64 " += %" PRIu64, canary_now.y, increment); canary_now.y += increment; int rc = mdbx_canary_put(txn_guard.get(), &canary_now); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_canary_put()", rc); log_trace("<< update_canary: sequence = %" PRIu64, canary_now.y); } bool testcase::is_handle_created_in_current_txn(const MDBX_dbi handle, MDBX_txn *txn) { unsigned flags, state; int err = mdbx_dbi_flags_ex(txn, handle, &flags, &state); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_dbi_flags_ex()", err); return (state & MDBX_DBI_CREAT) != 0; } int testcase::db_open__begin__table_create_open_clean(MDBX_dbi &handle) { db_open(); int err, retry_left = 42; for (;;) { txn_begin(false); handle = db_table_open(true); if (is_handle_created_in_current_txn(handle, txn_guard.get())) return MDBX_SUCCESS; db_table_clear(handle); err = breakable_commit(); if (likely(err == MDBX_SUCCESS)) { txn_begin(false); return MDBX_SUCCESS; } if (--retry_left == 0) break; jitter_delay(true); } log_notice("db_begin_table_create_open_clean: bailout due '%s'", mdbx_strerror(err)); return err; } MDBX_dbi testcase::db_table_open(bool create) { log_trace(">> testcase::db_table_create"); char tablename_buf[16]; const char *tablename = nullptr; if (config.space_id) { int rc = snprintf(tablename_buf, sizeof(tablename_buf), "TBL%04u", config.space_id); if (rc < 4 || rc >= (int)sizeof(tablename_buf) - 1) failure("snprintf(tablename): %d", rc); tablename = tablename_buf; } log_debug("use %s table", tablename ? tablename : "MAINDB"); MDBX_dbi handle = 0; int rc = mdbx_dbi_open(txn_guard.get(), tablename, (create ? MDBX_CREATE : MDBX_DB_DEFAULTS) | config.params.table_flags, &handle); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_dbi_open()", rc); log_trace("<< testcase::db_table_create, handle %u", handle); return handle; } void testcase::db_table_drop(MDBX_dbi handle) { log_trace(">> testcase::db_table_drop, handle %u", handle); if (config.params.drop_table) { int rc = mdbx_drop(txn_guard.get(), handle, true); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_drop(delete=true)", rc); speculum.clear(); log_trace("<< testcase::db_table_drop"); } else { log_trace("<< testcase::db_table_drop: not needed"); } } void testcase::db_table_clear(MDBX_dbi handle, MDBX_txn *txn) { log_trace(">> testcase::db_table_clear, handle %u", handle); int rc = mdbx_drop(txn ? txn : txn_guard.get(), handle, false); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_drop(delete=false)", rc); speculum.clear(); log_trace("<< testcase::db_table_clear"); } void testcase::db_table_close(MDBX_dbi handle) { log_trace(">> testcase::db_table_close, handle %u", handle); assert(!txn_guard); int rc = mdbx_dbi_close(db_guard.get(), handle); if (unlikely(rc != MDBX_SUCCESS)) failure_perror("mdbx_dbi_close()", rc); log_trace("<< testcase::db_table_close"); } void testcase::checkdata(const char *step, MDBX_dbi handle, MDBX_val key2check, MDBX_val expected_valued) { MDBX_val actual_value = expected_valued; int rc = mdbx_get_equal_or_great(txn_guard.get(), handle, &key2check, &actual_value); if (unlikely(rc != MDBX_SUCCESS)) failure_perror(step, rc); if (!is_samedata(&actual_value, &expected_valued)) failure("%s data mismatch", step); } //----------------------------------------------------------------------------- bool test_execute(const actor_config &config_const) { const mdbx_pid_t pid = osal_getpid(); actor_config config = config_const; if (global::singlemode) { logging::setup(format("single_%s", testcase2str(config.testcase))); } else { logging::setup((logging::loglevel)config.params.loglevel, format("child_%u.%u", config.actor_id, config.space_id)); log_trace(">> wait4barrier"); osal_wait4barrier(); log_trace("<< wait4barrier"); } try { std::unique_ptr test(registry::create_actor(config, pid)); size_t iter = 0; do { iter++; if (!test->setup()) { log_notice("test setup failed"); return false; } if (!test->run()) { log_notice("test failed"); return false; } if (!test->teardown()) { log_notice("test teardown failed"); return false; } if (config.params.nrepeat == 1) log_verbose("test successfully"); else { if (config.params.nrepeat) log_verbose("test successfully (iteration %zi of %zi)", iter, size_t(config.params.nrepeat)); else log_verbose("test successfully (iteration %zi)", iter); config.params.keygen.seed += INT32_C(0xA4F4D37B); log_verbose("turn keygen to %u", config.params.keygen.seed); } } while (config.params.nrepeat == 0 || iter < config.params.nrepeat); return true; } catch (const std::exception &pipets) { failure("***** Exception: %s *****", pipets.what()); return false; } } //----------------------------------------------------------------------------- enum speculum_cursors : int { lowerbound = 0, prev = 1, prev_prev = 2, next = 3, next_next = 4, seek_check = 5 }; bool testcase::is_same(const Item &a, const Item &b) const { if (!is_samedata(dataview2iov(a.first), dataview2iov(b.first))) return false; if ((config.params.table_flags & MDBX_DUPSORT) && !is_samedata(dataview2iov(a.second), dataview2iov(b.second))) return false; return true; } bool testcase::is_same(const testcase::SET::const_iterator &it, const MDBX_val &k, const MDBX_val &v) const { return is_samedata(dataview2iov(it->first), k) && is_samedata(dataview2iov(it->second), v); } void testcase::verbose(const char *where, const char *stage, const testcase::SET::const_iterator &it) const { if (it == speculum.end()) log_verbose("speculum-%s: %s expect END", where, stage); else { char dump_key[32], dump_value[32]; MDBX_val it_key = dataview2iov(it->first); MDBX_val it_data = dataview2iov(it->second); log_verbose("speculum-%s: %s expect {%s, %s}", where, stage, mdbx_dump_val(&it_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&it_data, dump_value, sizeof(dump_value))); } } void testcase::verbose(const char *where, const char *stage, const MDBX_val &k, const MDBX_val &v, int err) const { char dump_key[32], dump_value[32]; if (err != MDBX_SUCCESS && err != MDBX_RESULT_TRUE) log_verbose("speculum-%s: %s cursor {%d, %s}", where, stage, err, mdbx_strerror(err)); else log_verbose("speculum-%s: %s cursor {%s, %s}", where, stage, mdbx_dump_val(&k, dump_key, sizeof(dump_key)), mdbx_dump_val(&v, dump_value, sizeof(dump_value))); } void testcase::speculum_check_iterator(const char *where, const char *stage, const testcase::SET::const_iterator &it, const MDBX_val &k, const MDBX_val &v) const { char dump_key[32], dump_value[32]; MDBX_val it_key = dataview2iov(it->first); MDBX_val it_data = dataview2iov(it->second); // log_verbose("speculum-%s: %s expect {%s, %s}", where, stage, // mdbx_dump_val(&it_key, dump_key, sizeof(dump_key)), // mdbx_dump_val(&it_data, dump_value, sizeof(dump_value))); if (!is_samedata(it_key, k)) failure("speculum-%s: %s key mismatch %s (must) != %s", where, stage, mdbx_dump_val(&it_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&k, dump_value, sizeof(dump_value))); if (!is_samedata(it_data, v)) failure("speculum-%s: %s data mismatch %s (must) != %s", where, stage, mdbx_dump_val(&it_data, dump_key, sizeof(dump_key)), mdbx_dump_val(&v, dump_value, sizeof(dump_value))); } #if SPECULUM_CURSORS void testcase::speculum_check_cursor(const char *where, const char *stage, const testcase::SET::const_iterator &it, int cursor_err, const MDBX_val &cursor_key, const MDBX_val &cursor_data) const { // verbose(where, stage, cursor_key, cursor_data, cursor_err); // verbose(where, stage, it); if (cursor_err != MDBX_SUCCESS && cursor_err != MDBX_NOTFOUND && cursor_err != MDBX_RESULT_TRUE && cursor_err != MDBX_ENODATA) failure("speculum-%s: %s %s %d %s", where, stage, "cursor-get", cursor_err, mdbx_strerror(cursor_err)); char dump_key[32], dump_value[32]; if (it == speculum.end() && cursor_err != MDBX_NOTFOUND) failure("speculum-%s: %s extra pair {%s, %s}", where, stage, mdbx_dump_val(&cursor_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&cursor_data, dump_value, sizeof(dump_value))); else if (it != speculum.end() && cursor_err == MDBX_NOTFOUND) { MDBX_val it_key = dataview2iov(it->first); MDBX_val it_data = dataview2iov(it->second); failure("speculum-%s: %s lack pair {%s, %s}", where, stage, mdbx_dump_val(&it_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&it_data, dump_value, sizeof(dump_value))); } else if (cursor_err == MDBX_SUCCESS || cursor_err == MDBX_RESULT_TRUE) speculum_check_iterator(where, stage, it, cursor_key, cursor_data); } void testcase::speculum_check_cursor(const char *where, const char *stage, const testcase::SET::const_iterator &it, MDBX_cursor *cursor, const MDBX_cursor_op op) const { MDBX_val cursor_key = {0, 0}; MDBX_val cursor_data = {0, 0}; int err; if (it != speculum.end() && std::next(it) == speculum.end() && op == MDBX_PREV && (config.params.table_flags & MDBX_DUPSORT)) { /* Workaround for MDBX/LMDB flaw */ err = mdbx_cursor_get(cursor, &cursor_key, &cursor_data, MDBX_LAST); if (err == MDBX_SUCCESS) err = mdbx_cursor_get(cursor, &cursor_key, &cursor_data, MDBX_LAST_DUP); } else err = mdbx_cursor_get(cursor, &cursor_key, &cursor_data, op); return speculum_check_cursor(where, stage, it, err, cursor_key, cursor_data); } void testcase::speculum_prepare_cursors(const Item &item) { int err; assert(config.params.speculum); if (speculum_cursors[lowerbound]) for (auto &guard : speculum_cursors) { if (txn_guard.get() != mdbx_cursor_txn(guard.get()) || dbi != mdbx_cursor_dbi(guard.get())) { err = mdbx_cursor_bind(txn_guard.get(), guard.get(), dbi); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_cursor_bind()", err); } } else for (auto &guard : speculum_cursors) { MDBX_cursor *cursor = nullptr; err = mdbx_cursor_open(txn_guard.get(), dbi, &cursor); if (unlikely(err != MDBX_SUCCESS)) failure_perror("mdbx_cursor_open()", err); guard.reset(cursor); } const auto cursor_lowerbound = speculum_cursors[lowerbound].get(); const MDBX_val item_key = dataview2iov(item.first), item_data = dataview2iov(item.second); MDBX_val lowerbound_key = item_key; MDBX_val lowerbound_data = item_data; // verbose("prepare-cursors", "item", item_key, item_data); err = mdbx_cursor_get(cursor_lowerbound, &lowerbound_key, &lowerbound_data, MDBX_SET_LOWERBOUND); // verbose("prepare-cursors", "lowerbound", lowerbound_key, lowerbound_data, // err); if (unlikely(err != MDBX_SUCCESS && err != MDBX_RESULT_TRUE && err != MDBX_NOTFOUND)) failure("speculum-%s: %s %s %d %s", "prepare-cursors", "lowerbound", "cursor-get", err, mdbx_strerror(err)); auto it_lowerbound = speculum.lower_bound(item); // verbose("prepare-cursors", "lowerbound", it_lowerbound); speculum_check_cursor("prepare-cursors", "lowerbound", it_lowerbound, err, lowerbound_key, lowerbound_data); const auto cursor_prev = speculum_cursors[prev].get(); err = mdbx_cursor_copy(cursor_lowerbound, cursor_prev); if (unlikely(err != MDBX_SUCCESS)) failure("speculum-%s: %s %s %d %s", "prepare-cursors", "prev", "cursor-copy", err, mdbx_strerror(err)); auto it_prev = it_lowerbound; if (it_prev != speculum.begin()) { speculum_check_cursor("prepare-cursors", "prev", --it_prev, cursor_prev, MDBX_PREV); } else if ((err = mdbx_cursor_on_first(cursor_prev)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-first %d %s", "prepare-cursors", "prev", err, mdbx_strerror(err)); const auto cursor_prev_prev = speculum_cursors[prev_prev].get(); err = mdbx_cursor_copy(cursor_prev, cursor_prev_prev); if (unlikely(err != MDBX_SUCCESS)) failure("speculum-%s: %s %s %d %s", "prepare-cursors", "prev-prev", "cursor-copy", err, mdbx_strerror(err)); auto it_prev_prev = it_prev; if (it_prev_prev != speculum.begin()) { speculum_check_cursor("prepare-cursors", "prev-prev", --it_prev_prev, cursor_prev_prev, MDBX_PREV); } else if ((err = mdbx_cursor_on_first(cursor_prev_prev)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-first %d %s", "prepare-cursors", "prev-prev", err, mdbx_strerror(err)); const auto cursor_next = speculum_cursors[next].get(); err = mdbx_cursor_copy(cursor_lowerbound, cursor_next); if (unlikely(err != MDBX_SUCCESS)) failure("speculum-%s: %s %s %d %s", "prepare-cursors", "next", "cursor-copy", err, mdbx_strerror(err)); auto it_next = it_lowerbound; if (it_next != speculum.end()) { speculum_check_cursor("prepare-cursors", "next", ++it_next, cursor_next, MDBX_NEXT); } else if ((err = mdbx_cursor_on_last(cursor_next)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-last %d %s", "prepare-cursors", "next", err, mdbx_strerror(err)); const auto cursor_next_next = speculum_cursors[next_next].get(); err = mdbx_cursor_copy(cursor_next, cursor_next_next); if (unlikely(err != MDBX_SUCCESS)) failure("speculum-%s: %s %s %d %s", "prepare-cursors", "next-next", "cursor-copy", err, mdbx_strerror(err)); auto it_next_next = it_next; if (it_next_next != speculum.end()) { speculum_check_cursor("prepare-cursors", "next-next", ++it_next_next, cursor_next_next, MDBX_NEXT); } else if ((err = mdbx_cursor_on_last(cursor_next_next)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-last %d %s", "prepare-cursors", "next-next", err, mdbx_strerror(err)); } #endif /* SPECULUM_CURSORS */ int testcase::insert(const keygen::buffer &akey, const keygen::buffer &adata, MDBX_put_flags_t flags) { int err; bool rc = true; Item item; #if SPECULUM_CURSORS MDBX_cursor *check_seek_cursor = nullptr; MDBX_val seek_check_key, seek_check_data; int seek_check_err = 42; #endif /* SPECULUM_CURSORS */ if (config.params.speculum) { item.first = iov2dataview(akey); item.second = iov2dataview(adata); #if SPECULUM_CURSORS speculum_prepare_cursors(item); check_seek_cursor = speculum_cursors[seek_check].get(); seek_check_key = akey->value; seek_check_data = adata->value; seek_check_err = mdbx_cursor_get( check_seek_cursor, &seek_check_key, &seek_check_data, (config.params.table_flags & MDBX_DUPSORT) ? MDBX_GET_BOTH : MDBX_SET_KEY); if (seek_check_err != MDBX_SUCCESS && seek_check_err != MDBX_NOTFOUND) failure("speculum-%s: %s pre-insert %d %s", "insert", "seek", seek_check_err, mdbx_strerror(seek_check_err)); #endif /* SPECULUM_CURSORS */ } err = mdbx_put(txn_guard.get(), dbi, &akey->value, &adata->value, flags); if (err != MDBX_SUCCESS && err != MDBX_KEYEXIST) return err; if (config.params.speculum) { char dump_key[32], dump_value[32]; const auto insertion_result = speculum.insert(item); if (err == MDBX_KEYEXIST && insertion_result.second) { log_error("speculum.insert: unexpected %s {%s, %s}", "MDBX_KEYEXIST", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&adata->value, dump_value, sizeof(dump_value))); rc = false; } if (err == MDBX_SUCCESS && !insertion_result.second) { log_error("speculum.insert: unexpected %s {%s, %s}", "MDBX_SUCCESS", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&adata->value, dump_value, sizeof(dump_value))); rc = false; } #if SPECULUM_CURSORS if (insertion_result.second) { if (seek_check_err != MDBX_NOTFOUND) { log_error( "speculum.pre-insert-seek: unexpected %d {%s, %s}", seek_check_err, mdbx_dump_val(&seek_check_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&seek_check_data, dump_value, sizeof(dump_value))); rc = false; } } else { if (seek_check_err != MDBX_SUCCESS) { log_error( "speculum.pre-insert-seek: unexpected %d {%s, %s}", seek_check_err, mdbx_dump_val(&seek_check_key, dump_key, sizeof(dump_key)), mdbx_dump_val(&seek_check_data, dump_value, sizeof(dump_value))); speculum_check_iterator("insert", "pre-seek", insertion_result.first, seek_check_key, seek_check_data); rc = false; } } if (insertion_result.first != speculum.begin()) { const auto cursor_prev = speculum_cursors[prev].get(); auto it_prev = insertion_result.first; speculum_check_cursor("after-insert", "prev", --it_prev, cursor_prev, MDBX_GET_CURRENT); if (it_prev != speculum.begin()) { const auto cursor_prev_prev = speculum_cursors[prev_prev].get(); auto it_prev_prev = it_prev; speculum_check_cursor("after-insert", "prev-prev", --it_prev_prev, cursor_prev_prev, MDBX_GET_CURRENT); } } auto it_lowerbound = insertion_result.first; if (++it_lowerbound != speculum.end()) { const auto cursor_lowerbound = speculum_cursors[lowerbound].get(); speculum_check_cursor("after-insert", "lowerbound", it_lowerbound, cursor_lowerbound, MDBX_GET_CURRENT); auto it_next = it_lowerbound; if (++it_next != speculum.end()) { const auto cursor_next = speculum_cursors[next].get(); speculum_check_cursor("after-insert", "next", it_next, cursor_next, MDBX_GET_CURRENT); auto it_next_next = it_next; if (++it_next_next != speculum.end()) { const auto cursor_next_next = speculum_cursors[next_next].get(); speculum_check_cursor("after-insert", "next-next", it_next_next, cursor_next_next, MDBX_GET_CURRENT); } } } #endif /* SPECULUM_CURSORS */ } return rc ? MDBX_SUCCESS : MDBX_RESULT_TRUE; } int testcase::replace(const keygen::buffer &akey, const keygen::buffer &new_data, const keygen::buffer &old_data, MDBX_put_flags_t flags) { if (config.params.speculum) { const auto S_key = iov2dataview(akey); const auto S_old = iov2dataview(old_data); const auto S_new = iov2dataview(new_data); const auto removed = speculum.erase(SET::key_type(S_key, S_old)); if (unlikely(removed != 1)) { char dump_key[128], dump_value[128]; log_error( "speculum-%s: %s old value {%s, %s}", "replace", (removed > 1) ? "multi" : "no", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&old_data->value, dump_value, sizeof(dump_value))); } if (unlikely(!speculum.emplace(S_key, S_new).second)) { char dump_key[128], dump_value[128]; log_error( "speculum-replace: new pair not inserted {%s, %s}", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&new_data->value, dump_value, sizeof(dump_value))); } } return mdbx_replace(txn_guard.get(), dbi, &akey->value, &new_data->value, &old_data->value, flags); } int testcase::remove(const keygen::buffer &akey, const keygen::buffer &adata) { int err; bool rc = true; Item item; if (config.params.speculum) { item.first = iov2dataview(akey); item.second = iov2dataview(adata); #if SPECULUM_CURSORS speculum_prepare_cursors(item); #endif /* SPECULUM_CURSORS */ } err = mdbx_del(txn_guard.get(), dbi, &akey->value, &adata->value); if (err != MDBX_NOTFOUND && err != MDBX_SUCCESS) return err; if (config.params.speculum) { char dump_key[32], dump_value[32]; const auto it_found = speculum.find(item); if (it_found == speculum.end()) { if (err != MDBX_NOTFOUND) { log_error("speculum.remove: unexpected %s {%s, %s}", "MDBX_SUCCESS", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&adata->value, dump_value, sizeof(dump_value))); rc = false; } } else { if (err != MDBX_SUCCESS) { log_error("speculum.remove: unexpected %s {%s, %s}", "MDBX_NOTFOUND", mdbx_dump_val(&akey->value, dump_key, sizeof(dump_key)), mdbx_dump_val(&adata->value, dump_value, sizeof(dump_value))); rc = false; } #if SPECULUM_CURSORS if (it_found != speculum.begin()) { const auto cursor_prev = speculum_cursors[prev].get(); auto it_prev = it_found; speculum_check_cursor("after-remove", "prev", --it_prev, cursor_prev, MDBX_GET_CURRENT); if (it_prev != speculum.begin()) { const auto cursor_prev_prev = speculum_cursors[prev_prev].get(); auto it_prev_prev = it_prev; speculum_check_cursor("after-remove", "prev-prev", --it_prev_prev, cursor_prev_prev, MDBX_GET_CURRENT); } } auto it_next = it_found; const auto cursor_next = speculum_cursors[next].get(); const auto cursor_lowerbound = speculum_cursors[lowerbound].get(); if (++it_next != speculum.end()) { speculum_check_cursor("after-remove", "next", it_next, cursor_next, MDBX_GET_CURRENT); speculum_check_cursor("after-remove", "lowerbound", it_next, cursor_lowerbound, MDBX_NEXT); auto it_next_next = it_next; const auto cursor_next_next = speculum_cursors[next_next].get(); if (++it_next_next != speculum.end()) { speculum_check_cursor("after-remove", "next-next", it_next_next, cursor_next_next, MDBX_GET_CURRENT); } else if ((err = mdbx_cursor_on_last(cursor_next_next)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-last %d %s", "after-remove", "next-next", err, mdbx_strerror(err)); } else { if ((err = mdbx_cursor_on_last(cursor_next)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-last %d %s", "after-remove", "next", err, mdbx_strerror(err)); if ((err = mdbx_cursor_on_last(cursor_lowerbound)) != MDBX_RESULT_TRUE) failure("speculum-%s: %s on-last %d %s", "after-remove", "lowerbound", err, mdbx_strerror(err)); } #endif /* SPECULUM_CURSORS */ speculum.erase(it_found); } } return rc ? MDBX_SUCCESS : MDBX_RESULT_TRUE; } bool testcase::speculum_verify() { if (!config.params.speculum) return true; if (!txn_guard) txn_begin(true); char dump_key[128], dump_value[128]; char dump_mkey[128], dump_mvalue[128]; MDBX_cursor *cursor; int eof, err = mdbx_cursor_open(txn_guard.get(), dbi, &cursor); if (err != MDBX_SUCCESS) failure_perror("mdbx_cursor_open()", err); bool rc = true; MDBX_val akey, avalue; MDBX_val mkey, mvalue; err = mdbx_cursor_get(cursor, &akey, &avalue, MDBX_FIRST); if (err == MDBX_NOTFOUND) { err = mdbx_cursor_get(cursor, &akey, &avalue, MDBX_GET_CURRENT); if (err == MDBX_ENODATA) err = MDBX_NOTFOUND; else { log_error("unexpected %d for MDBX_GET_CURRENT on empty DB", err); rc = false; } } unsigned extra = 0, lost = 0, n = 0; assert(std::is_sorted(speculum.cbegin(), speculum.cend(), ItemCompare(this))); auto it = speculum.cbegin(); while (true) { if (err != MDBX_SUCCESS) { akey.iov_len = avalue.iov_len = 0; akey.iov_base = avalue.iov_base = nullptr; } else { eof = mdbx_cursor_eof(cursor); if (eof != MDBX_RESULT_FALSE) { log_error("false-positive cursor-eof %u/%u: db{%s, %s}, rc %i", n, extra, mdbx_dump_val(&akey, dump_key, sizeof(dump_key)), mdbx_dump_val(&avalue, dump_value, sizeof(dump_value)), eof); rc = false; } } const auto S_key = iov2dataview(akey); const auto S_data = iov2dataview(avalue); if (it != speculum.cend()) { mkey = it->first; mvalue = it->second; } if (err == MDBX_SUCCESS && it != speculum.cend() && S_key == it->first && S_data == it->second) { ++it; err = mdbx_cursor_get(cursor, &akey, &avalue, MDBX_NEXT); } else if (err == MDBX_SUCCESS && (it == speculum.cend() || S_key < it->first || (S_key == it->first && S_data < it->second))) { extra += 1; if (it != speculum.cend()) { log_error("extra pair %u/%u: db{%s, %s} < mi{%s, %s}", n, extra, mdbx_dump_val(&akey, dump_key, sizeof(dump_key)), mdbx_dump_val(&avalue, dump_value, sizeof(dump_value)), mdbx_dump_val(&mkey, dump_mkey, sizeof(dump_mkey)), mdbx_dump_val(&mvalue, dump_mvalue, sizeof(dump_mvalue))); } else { log_error("extra pair %u/%u: db{%s, %s} < mi.END", n, extra, mdbx_dump_val(&akey, dump_key, sizeof(dump_key)), mdbx_dump_val(&avalue, dump_value, sizeof(dump_value))); } err = mdbx_cursor_get(cursor, &akey, &avalue, MDBX_NEXT); rc = false; } else if (it != speculum.cend() && (err == MDBX_NOTFOUND || S_key > it->first || (S_key == it->first && S_data > it->second))) { lost += 1; if (err == MDBX_NOTFOUND) { log_error("lost pair %u/%u: db.END > mi{%s, %s}", n, lost, mdbx_dump_val(&mkey, dump_mkey, sizeof(dump_mkey)), mdbx_dump_val(&mvalue, dump_mvalue, sizeof(dump_mvalue))); } else { log_error("lost pair %u/%u: db{%s, %s} > mi{%s, %s}", n, lost, mdbx_dump_val(&akey, dump_key, sizeof(dump_key)), mdbx_dump_val(&avalue, dump_value, sizeof(dump_value)), mdbx_dump_val(&mkey, dump_mkey, sizeof(dump_mkey)), mdbx_dump_val(&mvalue, dump_mvalue, sizeof(dump_mvalue))); } ++it; rc = false; } else if (err == MDBX_NOTFOUND && it == speculum.cend()) { break; } else if (err != MDBX_SUCCESS) { failure_perror("mdbx_cursor_get()", err); } else { assert(!"WTF?"); } n += 1; } if (err == MDBX_NOTFOUND) { eof = mdbx_cursor_eof(cursor); if (eof != MDBX_RESULT_TRUE) { eof = mdbx_cursor_eof(cursor); log_error("false-negative cursor-eof: %u, rc %i", n, eof); rc = false; } } mdbx_cursor_close(cursor); return rc; } bool testcase::check_batch_get() { char dump_key[128], dump_value[128]; char dump_key_batch[128], dump_value_batch[128]; MDBX_cursor *cursor; int err = mdbx_cursor_open(txn_guard.get(), dbi, &cursor); if (err != MDBX_SUCCESS) failure_perror("mdbx_cursor_open()", err); MDBX_cursor *batch_cursor; err = mdbx_cursor_open(txn_guard.get(), dbi, &batch_cursor); if (err != MDBX_SUCCESS) failure_perror("mdbx_cursor_open()", err); MDBX_val pairs[42]; size_t count = 0xDeadBeef; err = mdbx_cursor_get_batch(batch_cursor, &count, pairs, ARRAY_LENGTH(pairs), MDBX_FIRST); bool rc = true; size_t i, n = 0; while (err == MDBX_SUCCESS) { for (i = 0; i < count; i += 2) { mdbx::slice k, v; int err2 = mdbx_cursor_get(cursor, &k, &v, MDBX_NEXT); if (err2 != MDBX_SUCCESS) failure_perror("mdbx_cursor_open()", err2); if (k != pairs[i] || v != pairs[i + 1]) { log_error( "batch-get pair mismatch %zu/%zu: sequential{%s, %s} != " "batch{%s, %s}", n + i / 2, i, mdbx_dump_val(&k, dump_key, sizeof(dump_key)), mdbx_dump_val(&v, dump_value, sizeof(dump_value)), mdbx_dump_val(&pairs[i], dump_key_batch, sizeof(dump_key_batch)), mdbx_dump_val(&pairs[i + 1], dump_value_batch, sizeof(dump_value_batch))); rc = false; } } n += i / 2; err = mdbx_cursor_get_batch(batch_cursor, &count, pairs, ARRAY_LENGTH(pairs), MDBX_NEXT); } if (err != MDBX_NOTFOUND) failure_perror("mdbx_cursor_get_batch()", err); err = mdbx_cursor_eof(batch_cursor); if (err != MDBX_RESULT_TRUE) { log_error("batch-get %s cursor not-eof %d", "batch", err); rc = false; } err = mdbx_cursor_on_last(batch_cursor); if (err != MDBX_RESULT_TRUE) { log_error("batch-get %s cursor not-on-last %d", "batch", err); rc = false; } err = mdbx_cursor_on_last(cursor); if (err != MDBX_RESULT_TRUE) { log_error("batch-get %s cursor not-on-last %d", "checked", err); rc = false; } mdbx_cursor_close(cursor); mdbx_cursor_close(batch_cursor); return rc; }