diff options
55 files changed, 1945 insertions, 580 deletions
diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py index 39f49fc50e9..37b84df00e1 100644 --- a/src/third_party/wiredtiger/dist/api_data.py +++ b/src/third_party/wiredtiger/dist/api_data.py @@ -450,6 +450,18 @@ connection_runtime_config = [ for space to be available in cache before giving up. Default will wait forever''', min=0), + Config('cache_overflow', '', r''' + cache overflow configuration options''', + type='category', subconfig=[ + Config('file_max', '0', r''' + The maximum number of bytes that WiredTiger is allowed to use for + its cache overflow mechanism. If the cache overflow file exceeds + this size, a panic will be triggered. The default value means that + the cache overflow file is unbounded and may use as much space as + the filesystem will accommodate. The minimum non-zero setting is + 100MB.''', # !!! Must match WT_LAS_FILE_MIN + min='0') + ]), Config('cache_overhead', '8', r''' assume the heap allocator overhead is the specified percentage, and adjust the cache usage by that amount (for example, if there is 10GB @@ -476,6 +488,25 @@ connection_runtime_config = [ above 0 configures periodic checkpoints''', min='0', max='100000'), ]), + Config('debug_mode', '', r''' + control the settings of various extended debugging features''', + type='category', subconfig=[ + Config('checkpoint_retention', '0', r''' + adjust log archiving to retain the log records of this number + of checkpoints. Zero or one means perform normal archiving.''', + min='0', max='1024'), + Config('rollback_error', '0', r''' + return a WT_ROLLBACK error from a transaction operation about + every Nth operation to simulate a collision''', + min='0', max='10M'), + Config('table_logging', 'false', r''' + if true, write transaction related information to the log for all + operations, even operations for tables with logging turned off. + This setting introduces a log format change that may break older + versions of WiredTiger. These operations are informational and + skipped in recovery.''', + type='boolean'), + ]), Config('error_prefix', '', r''' prefix string for error messages'''), Config('eviction', '', r''' @@ -863,7 +894,7 @@ wiredtiger_open_common =\ warnings. Including \c "data" will cause WiredTiger data files to use direct I/O, including \c "log" will cause WiredTiger log files to use direct I/O, and including \c "checkpoint" will cause WiredTiger data - files opened at a checkpoint (i.e: read only) to use direct I/O. + files opened at a checkpoint (i.e: read-only) to use direct I/O. \c direct_io should be combined with \c write_through to get the equivalent of \c O_DIRECT on Windows''', type='list', choices=['checkpoint', 'data', 'log']), @@ -1282,8 +1313,12 @@ methods = { 'WT_SESSION.begin_transaction' : Method([ Config('ignore_prepare', 'false', r''' whether to ignore the updates by other prepared transactions as part of - read operations of this transaction''', - type='boolean'), + read operations of this transaction. When \c true, forces the + transaction to be read-only. Use \c force to ignore prepared updates + and permit writes (which can cause lost updates unless the application + knows something about the relationship between prepared transactions + and the updates that are ignoring them)''', + choices=['false', 'force', 'true']), Config('isolation', '', r''' the isolation level for this transaction; defaults to the session's isolation level''', diff --git a/src/third_party/wiredtiger/dist/api_err.py b/src/third_party/wiredtiger/dist/api_err.py index cc6b9a6610a..38082f117cf 100644 --- a/src/third_party/wiredtiger/dist/api_err.py +++ b/src/third_party/wiredtiger/dist/api_err.py @@ -67,8 +67,10 @@ errors = [ Error('WT_TRY_SALVAGE', -31809, 'database corruption detected', ''' This error is generated when corruption is detected in an on-disk file. - The application may choose to salvage the file or retry wiredtiger_open - with the 'salvage=true' configuration setting.'''), + During normal operations, this may occur in rare circumstances as a + result of a system crash. The application may choose to salvage the + file or retry wiredtiger_open with the 'salvage=true' configuration + setting.'''), ] # Update the #defines in the wiredtiger.in file. diff --git a/src/third_party/wiredtiger/dist/log.py b/src/third_party/wiredtiger/dist/log.py index 4669b6bcc73..b3e6a71b63a 100644 --- a/src/third_party/wiredtiger/dist/log.py +++ b/src/third_party/wiredtiger/dist/log.py @@ -18,6 +18,9 @@ field_types = { 'WT_ERR(__logrec_make_hex_str(session, &escaped, &arg));']), 'recno' : ('uint64_t', 'r', '%" PRIu64 "', 'arg', [ '' ]), 'uint32' : ('uint32_t', 'I', '%" PRIu32 "', 'arg', [ '' ]), + # The fileid may have the high bit set. Print in both decimal and hex. + 'uint32_id' : ('uint32_t', 'I', + '%" PRIu32 " 0x%" PRIx32 "', 'arg, arg', [ '' ]), 'uint64' : ('uint64_t', 'Q', '%" PRIu64 "', 'arg', [ '' ]), } diff --git a/src/third_party/wiredtiger/dist/log_data.py b/src/third_party/wiredtiger/dist/log_data.py index 9e1538ccf04..18f368eaad0 100644 --- a/src/third_party/wiredtiger/dist/log_data.py +++ b/src/third_party/wiredtiger/dist/log_data.py @@ -36,7 +36,7 @@ rectypes = [ # the allocated LSN to reduce the amount of work recovery has to do, and # they are useful for debugging recovery. LogRecordType('file_sync', 'file sync', [ - ('uint32', 'fileid'), ('int', 'start')]), + ('uint32_id', 'fileid'), ('int', 'start')]), # Debugging message in the log LogRecordType('message', 'message', [('string', 'message')]), @@ -62,25 +62,39 @@ class LogOperationType: optypes = [ # commit operations LogOperationType('col_modify', 'column modify', - [('uint32', 'fileid'), ('recno', 'recno'), ('item', 'value')]), + [('uint32_id', 'fileid'), ('recno', 'recno'), ('item', 'value')]), LogOperationType('col_put', 'column put', - [('uint32', 'fileid'), ('recno', 'recno'), ('item', 'value')]), + [('uint32_id', 'fileid'), ('recno', 'recno'), ('item', 'value')]), LogOperationType('col_remove', 'column remove', - [('uint32', 'fileid'), ('recno', 'recno')]), + [('uint32_id', 'fileid'), ('recno', 'recno')]), LogOperationType('col_truncate', 'column truncate', - [('uint32', 'fileid'), ('recno', 'start'), ('recno', 'stop')]), + [('uint32_id', 'fileid'), ('recno', 'start'), ('recno', 'stop')]), LogOperationType('row_modify', 'row modify', - [('uint32', 'fileid'), ('item', 'key'), ('item', 'value')]), + [('uint32_id', 'fileid'), ('item', 'key'), ('item', 'value')]), LogOperationType('row_put', 'row put', - [('uint32', 'fileid'), ('item', 'key'), ('item', 'value')]), + [('uint32_id', 'fileid'), ('item', 'key'), ('item', 'value')]), LogOperationType('row_remove', 'row remove', - [('uint32', 'fileid'), ('item', 'key')]), + [('uint32_id', 'fileid'), ('item', 'key')]), LogOperationType('row_truncate', 'row truncate', - [('uint32', 'fileid'), ('item', 'start'), ('item', 'stop'), + [('uint32_id', 'fileid'), ('item', 'start'), ('item', 'stop'), ('uint32', 'mode')]), # system operations LogOperationType('checkpoint_start', 'checkpoint start', []), LogOperationType('prev_lsn', 'previous LSN', [('WT_LSN', 'prev_lsn')]), + +# diagnostic operations +# Operations used only for diagnostic purposes should be have their type +# values in the diagnostic range in src/include/wiredtiger.in so that they +# are always ignored by recovery. + # + # We need to know the base size/type of a 'struct timespec'. Cast its + # parts to uint64_t and split it into seconds and nanoseconds. + # + LogOperationType('txn_timestamp', 'txn_timestamp', + [('uint64', 'time_sec'), ('uint64', 'time_nsec'), + ('uint64', 'commit_ts'), ('uint64', 'durable_ts'), + ('uint64', 'first_ts'), ('uint64', 'prepare_ts'), + ('uint64', 'read_ts')]), ] diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok index c1781aa8425..06e58b46236 100644 --- a/src/third_party/wiredtiger/dist/s_string.ok +++ b/src/third_party/wiredtiger/dist/s_string.ok @@ -1097,6 +1097,7 @@ pragmas pre pread prealloc +precomp preload preloaded prepend diff --git a/src/third_party/wiredtiger/dist/s_void b/src/third_party/wiredtiger/dist/s_void index fcbe2b8a9a0..7313201c678 100755 --- a/src/third_party/wiredtiger/dist/s_void +++ b/src/third_party/wiredtiger/dist/s_void @@ -116,6 +116,7 @@ func_ok() -e '/int snappy_pre_size$/d' \ -e '/int snappy_terminate$/d' \ -e '/int subtest_error_handler$/d' \ + -e '/int test_las_workload$/d' \ -e '/int uri2name$/d' \ -e '/int usage$/d' \ -e '/int util_err$/d' \ diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py index 640ebff8a08..478830108f3 100644 --- a/src/third_party/wiredtiger/dist/stat_data.py +++ b/src/third_party/wiredtiger/dist/stat_data.py @@ -275,6 +275,7 @@ connection_stats = [ CacheStat('cache_lookaside_entries', 'cache overflow table entries', 'no_clear,no_scale'), CacheStat('cache_lookaside_insert', 'cache overflow table insert calls'), CacheStat('cache_lookaside_ondisk', 'cache overflow table on-disk size', 'no_clear,no_scale,size'), + CacheStat('cache_lookaside_ondisk_max', 'cache overflow table max on-disk size', 'no_clear,no_scale,size'), CacheStat('cache_lookaside_remove', 'cache overflow table remove calls'), CacheStat('cache_lookaside_score', 'cache overflow score', 'no_clear,no_scale'), CacheStat('cache_overhead', 'percentage overhead', 'no_clear,no_scale'), @@ -726,6 +727,8 @@ dsrc_stats = [ # Compression statistics ########################################## CompressStat('compress_read', 'compressed pages read'), + CompressStat('compress_precomp_intl_max_page_size', 'compressed page maximum internal page size prior to compression', 'no_clear,no_scale,size'), + CompressStat('compress_precomp_leaf_max_page_size', 'compressed page maximum leaf page size prior to compression ', 'no_clear,no_scale,size'), CompressStat('compress_write', 'compressed pages written'), CompressStat('compress_write_fail', 'page written failed to compress'), CompressStat('compress_write_too_small', 'page written was too small to compress'), diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data index b16bb0a5058..43ede9082a0 100644 --- a/src/third_party/wiredtiger/import.data +++ b/src/third_party/wiredtiger/import.data @@ -1,5 +1,5 @@ { - "commit": "5d321d0c6091636a2344ef9915ca06b0c078bda3", + "commit": "57bd75fee93b685c133281100719f886d0184589", "github": "wiredtiger/wiredtiger.git", "vendor": "wiredtiger", "branch": "mongodb-4.2" diff --git a/src/third_party/wiredtiger/src/btree/bt_delete.c b/src/third_party/wiredtiger/src/btree/bt_delete.c index cfe4c242664..00d6bbc68e8 100644 --- a/src/third_party/wiredtiger/src/btree/bt_delete.c +++ b/src/third_party/wiredtiger/src/btree/bt_delete.c @@ -325,7 +325,7 @@ __tombstone_update_alloc(WT_SESSION_IMPL *session, if (page_del != NULL) { upd->txnid = page_del->txnid; upd->start_ts = page_del->timestamp; - upd->durable_ts = page_del->timestamp; + upd->durable_ts = page_del->durable_timestamp; upd->prepare_state = page_del->prepare_state; } *updp = upd; diff --git a/src/third_party/wiredtiger/src/btree/bt_stat.c b/src/third_party/wiredtiger/src/btree/bt_stat.c index 201022def4f..70e898a2d3c 100644 --- a/src/third_party/wiredtiger/src/btree/bt_stat.c +++ b/src/third_party/wiredtiger/src/btree/bt_stat.c @@ -50,6 +50,11 @@ __wt_btree_stat_init(WT_SESSION_IMPL *session, WT_CURSOR_STAT *cst) WT_STAT_SET(session, stats, cache_bytes_inuse, __wt_btree_bytes_inuse(session)); + WT_STAT_SET(session, stats, + compress_precomp_leaf_max_page_size, btree->maxleafpage_precomp); + WT_STAT_SET(session, stats, + compress_precomp_intl_max_page_size, btree->maxintlpage_precomp); + if (F_ISSET(cst, WT_STAT_TYPE_CACHE_WALK)) __wt_curstat_cache_walk(session); diff --git a/src/third_party/wiredtiger/src/cache/cache_las.c b/src/third_party/wiredtiger/src/cache/cache_las.c index a7e8afe7e02..87d55c1ac5e 100644 --- a/src/third_party/wiredtiger/src/cache/cache_las.c +++ b/src/third_party/wiredtiger/src/cache/cache_las.c @@ -57,6 +57,46 @@ __las_entry_count(WT_CACHE *cache) } /* + * __wt_las_config -- + * Configure the lookaside table. + */ +int +__wt_las_config(WT_SESSION_IMPL *session, const char **cfg) +{ + WT_CONFIG_ITEM cval; + WT_CURSOR_BTREE *las_cursor; + WT_SESSION_IMPL *las_session; + + WT_RET(__wt_config_gets( + session, cfg, "cache_overflow.file_max", &cval)); + + if (cval.val != 0 && cval.val < WT_LAS_FILE_MIN) + WT_RET_MSG(session, EINVAL, + "max cache overflow size %" PRId64 " below minimum %d", + cval.val, WT_LAS_FILE_MIN); + + /* This is expected for in-memory configurations. */ + las_session = S2C(session)->cache->las_session[0]; + WT_ASSERT(session, + las_session != NULL || F_ISSET(S2C(session), WT_CONN_IN_MEMORY)); + + if (las_session == NULL) + return (0); + + /* + * We need to set file_max on the btree associated with one of the + * lookaside sessions. + */ + las_cursor = (WT_CURSOR_BTREE *)las_session->las_cursor; + las_cursor->btree->file_max = (uint64_t)cval.val; + + WT_STAT_CONN_SET( + session, cache_lookaside_ondisk_max, las_cursor->btree->file_max); + + return (0); +} + +/* * __wt_las_empty -- * Return when there are entries in the lookaside table. */ @@ -126,7 +166,7 @@ __wt_las_stats_update(WT_SESSION_IMPL *session) * Initialize the database's lookaside store. */ int -__wt_las_create(WT_SESSION_IMPL *session) +__wt_las_create(WT_SESSION_IMPL *session, const char **cfg) { WT_CACHE *cache; WT_CONNECTION_IMPL *conn; @@ -166,6 +206,8 @@ __wt_las_create(WT_SESSION_IMPL *session) WT_RET(__wt_las_cursor_open(cache->las_session[i])); } + WT_RET(__wt_las_config(session, cfg)); + /* The statistics server is already running, make sure we don't race. */ WT_WRITE_BARRIER(); F_SET(conn, WT_CONN_LOOKASIDE_OPEN); @@ -620,7 +662,8 @@ __wt_las_insert_block(WT_CURSOR *cursor, WT_TXN_ISOLATION saved_isolation; WT_UPDATE *upd; wt_off_t las_size; - uint64_t insert_cnt, las_counter, las_pageid, prepared_insert_cnt; + uint64_t insert_cnt, las_counter, las_pageid, max_las_size; + uint64_t prepared_insert_cnt; uint32_t btree_id, i, slot; uint8_t *p; bool local_txn; @@ -761,6 +804,11 @@ __wt_las_insert_block(WT_CURSOR *cursor, WT_ERR(__wt_block_manager_named_size(session, WT_LAS_FILE, &las_size)); WT_STAT_CONN_SET(session, cache_lookaside_ondisk, las_size); + max_las_size = ((WT_CURSOR_BTREE *)cursor)->btree->file_max; + if (max_las_size != 0 && (uint64_t)las_size > max_las_size) + WT_PANIC_MSG(session, WT_PANIC, + "WiredTigerLAS: file size of %" PRIu64 " exceeds maximum " + "size %" PRIu64, (uint64_t)las_size, max_las_size); err: /* Resolve the transaction. */ if (local_txn) { diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c index e56e7f29004..11b41b07787 100644 --- a/src/third_party/wiredtiger/src/config/config_def.c +++ b/src/third_party/wiredtiger/src/config/config_def.c @@ -61,6 +61,12 @@ static const WT_CONFIG_CHECK }; static const WT_CONFIG_CHECK + confchk_wiredtiger_open_cache_overflow_subconfigs[] = { + { "file_max", "int", NULL, "min=0", NULL, 0 }, + { NULL, NULL, NULL, NULL, NULL, 0 } +}; + +static const WT_CONFIG_CHECK confchk_wiredtiger_open_checkpoint_subconfigs[] = { { "log_size", "int", NULL, "min=0,max=2GB", NULL, 0 }, { "wait", "int", NULL, "min=0,max=100000", NULL, 0 }, @@ -74,6 +80,16 @@ static const WT_CONFIG_CHECK }; static const WT_CONFIG_CHECK + confchk_wiredtiger_open_debug_mode_subconfigs[] = { + { "checkpoint_retention", "int", + NULL, "min=0,max=1024", + NULL, 0 }, + { "rollback_error", "int", NULL, "min=0,max=10M", NULL, 0 }, + { "table_logging", "boolean", NULL, NULL, NULL, 0 }, + { NULL, NULL, NULL, NULL, NULL, 0 } +}; + +static const WT_CONFIG_CHECK confchk_wiredtiger_open_eviction_subconfigs[] = { { "threads_max", "int", NULL, "min=1,max=20", NULL, 0 }, { "threads_min", "int", NULL, "min=1,max=20", NULL, 0 }, @@ -148,6 +164,9 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure[] = { NULL, NULL, confchk_wiredtiger_open_async_subconfigs, 3 }, { "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 }, + { "cache_overflow", "category", + NULL, NULL, + confchk_wiredtiger_open_cache_overflow_subconfigs, 1 }, { "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 }, { "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 }, { "checkpoint", "category", @@ -156,6 +175,9 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure[] = { { "compatibility", "category", NULL, NULL, confchk_WT_CONNECTION_reconfigure_compatibility_subconfigs, 1 }, + { "debug_mode", "category", + NULL, NULL, + confchk_wiredtiger_open_debug_mode_subconfigs, 3 }, { "error_prefix", "string", NULL, NULL, NULL, 0 }, { "eviction", "category", NULL, NULL, @@ -279,7 +301,9 @@ static const WT_CONFIG_CHECK }; static const WT_CONFIG_CHECK confchk_WT_SESSION_begin_transaction[] = { - { "ignore_prepare", "boolean", NULL, NULL, NULL, 0 }, + { "ignore_prepare", "string", + NULL, "choices=[\"false\",\"force\",\"true\"]", + NULL, 0 }, { "isolation", "string", NULL, "choices=[\"read-uncommitted\",\"read-committed\"," "\"snapshot\"]", @@ -854,6 +878,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = { { "builtin_extension_config", "string", NULL, NULL, NULL, 0 }, { "cache_cursors", "boolean", NULL, NULL, NULL, 0 }, { "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 }, + { "cache_overflow", "category", + NULL, NULL, + confchk_wiredtiger_open_cache_overflow_subconfigs, 1 }, { "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 }, { "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 }, { "checkpoint", "category", @@ -865,6 +892,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = { confchk_wiredtiger_open_compatibility_subconfigs, 3 }, { "config_base", "boolean", NULL, NULL, NULL, 0 }, { "create", "boolean", NULL, NULL, NULL, 0 }, + { "debug_mode", "category", + NULL, NULL, + confchk_wiredtiger_open_debug_mode_subconfigs, 3 }, { "direct_io", "list", NULL, "choices=[\"checkpoint\",\"data\",\"log\"]", NULL, 0 }, @@ -963,6 +993,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = { { "builtin_extension_config", "string", NULL, NULL, NULL, 0 }, { "cache_cursors", "boolean", NULL, NULL, NULL, 0 }, { "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 }, + { "cache_overflow", "category", + NULL, NULL, + confchk_wiredtiger_open_cache_overflow_subconfigs, 1 }, { "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 }, { "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 }, { "checkpoint", "category", @@ -974,6 +1007,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = { confchk_wiredtiger_open_compatibility_subconfigs, 3 }, { "config_base", "boolean", NULL, NULL, NULL, 0 }, { "create", "boolean", NULL, NULL, NULL, 0 }, + { "debug_mode", "category", + NULL, NULL, + confchk_wiredtiger_open_debug_mode_subconfigs, 3 }, { "direct_io", "list", NULL, "choices=[\"checkpoint\",\"data\",\"log\"]", NULL, 0 }, @@ -1073,6 +1109,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = { { "builtin_extension_config", "string", NULL, NULL, NULL, 0 }, { "cache_cursors", "boolean", NULL, NULL, NULL, 0 }, { "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 }, + { "cache_overflow", "category", + NULL, NULL, + confchk_wiredtiger_open_cache_overflow_subconfigs, 1 }, { "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 }, { "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 }, { "checkpoint", "category", @@ -1082,6 +1121,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = { { "compatibility", "category", NULL, NULL, confchk_wiredtiger_open_compatibility_subconfigs, 3 }, + { "debug_mode", "category", + NULL, NULL, + confchk_wiredtiger_open_debug_mode_subconfigs, 3 }, { "direct_io", "list", NULL, "choices=[\"checkpoint\",\"data\",\"log\"]", NULL, 0 }, @@ -1177,6 +1219,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_usercfg[] = { { "builtin_extension_config", "string", NULL, NULL, NULL, 0 }, { "cache_cursors", "boolean", NULL, NULL, NULL, 0 }, { "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 }, + { "cache_overflow", "category", + NULL, NULL, + confchk_wiredtiger_open_cache_overflow_subconfigs, 1 }, { "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 }, { "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 }, { "checkpoint", "category", @@ -1186,6 +1231,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_usercfg[] = { { "compatibility", "category", NULL, NULL, confchk_wiredtiger_open_compatibility_subconfigs, 3 }, + { "debug_mode", "category", + NULL, NULL, + confchk_wiredtiger_open_debug_mode_subconfigs, 3 }, { "direct_io", "list", NULL, "choices=[\"checkpoint\",\"data\",\"log\"]", NULL, 0 }, @@ -1322,12 +1370,14 @@ static const WT_CONFIG_ENTRY config_entries[] = { }, { "WT_CONNECTION.reconfigure", "async=(enabled=false,ops_max=1024,threads=2),cache_max_wait_ms=0" - ",cache_overhead=8,cache_size=100MB,checkpoint=(log_size=0," - "wait=0),compatibility=(release=),error_prefix=," - "eviction=(threads_max=8,threads_min=1)," - "eviction_checkpoint_target=1,eviction_dirty_target=5," - "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95" - ",file_manager=(close_handle_minimum=250,close_idle_time=30," + ",cache_overflow=(file_max=0),cache_overhead=8,cache_size=100MB," + "checkpoint=(log_size=0,wait=0),compatibility=(release=)," + "debug_mode=(checkpoint_retention=0,rollback_error=0," + "table_logging=false),error_prefix=,eviction=(threads_max=8," + "threads_min=1),eviction_checkpoint_target=1," + "eviction_dirty_target=5,eviction_dirty_trigger=20," + "eviction_target=80,eviction_trigger=95," + "file_manager=(close_handle_minimum=250,close_idle_time=30," "close_scan_interval=10),io_capacity=(total=0),log=(archive=true," "os_cache_dirty_pct=0,prealloc=true,zero_fill=false)," "lsm_manager=(merge=true,worker_thread_max=4),lsm_merge=true," @@ -1336,7 +1386,7 @@ static const WT_CONFIG_ENTRY config_entries[] = { "statistics=none,statistics_log=(json=false,on_close=false," "sources=,timestamp=\"%b %d %H:%M:%S\",wait=0)," "timing_stress_for_test=,verbose=", - confchk_WT_CONNECTION_reconfigure, 24 + confchk_WT_CONNECTION_reconfigure, 26 }, { "WT_CONNECTION.rollback_to_stable", "", @@ -1573,19 +1623,21 @@ static const WT_CONFIG_ENTRY config_entries[] = { { "wiredtiger_open", "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1" ",builtin_extension_config=,cache_cursors=true," - "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB," - "checkpoint=(log_size=0,wait=0),checkpoint_sync=true," - "compatibility=(release=,require_max=,require_min=)," - "config_base=true,create=false,direct_io=,encryption=(keyid=," - "name=,secretkey=),error_prefix=,eviction=(threads_max=8," - "threads_min=1),eviction_checkpoint_target=1," - "eviction_dirty_target=5,eviction_dirty_trigger=20," - "eviction_target=80,eviction_trigger=95,exclusive=false," - "extensions=,file_extend=,file_manager=(close_handle_minimum=250," - "close_idle_time=30,close_scan_interval=10),hazard_max=1000," - "in_memory=false,io_capacity=(total=0),log=(archive=true," - "compressor=,enabled=false,file_max=100MB,os_cache_dirty_pct=0," - "path=\".\",prealloc=true,recover=on,zero_fill=false)," + "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8" + ",cache_size=100MB,checkpoint=(log_size=0,wait=0)," + "checkpoint_sync=true,compatibility=(release=,require_max=," + "require_min=),config_base=true,create=false," + "debug_mode=(checkpoint_retention=0,rollback_error=0," + "table_logging=false),direct_io=,encryption=(keyid=,name=," + "secretkey=),error_prefix=,eviction=(threads_max=8,threads_min=1)" + ",eviction_checkpoint_target=1,eviction_dirty_target=5," + "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95" + ",exclusive=false,extensions=,file_extend=," + "file_manager=(close_handle_minimum=250,close_idle_time=30," + "close_scan_interval=10),hazard_max=1000,in_memory=false," + "io_capacity=(total=0),log=(archive=true,compressor=," + "enabled=false,file_max=100MB,os_cache_dirty_pct=0,path=\".\"," + "prealloc=true,recover=on,zero_fill=false)," "lsm_manager=(merge=true,worker_thread_max=4),lsm_merge=true," "mmap=true,multiprocess=false,operation_tracking=(enabled=false," "path=\".\"),readonly=false,salvage=false,session_max=100," @@ -1596,24 +1648,26 @@ static const WT_CONFIG_ENTRY config_entries[] = { "timing_stress_for_test=,transaction_sync=(enabled=false," "method=fsync),use_environment=true,use_environment_priv=false," "verbose=,write_through=", - confchk_wiredtiger_open, 48 + confchk_wiredtiger_open, 50 }, { "wiredtiger_open_all", "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1" ",builtin_extension_config=,cache_cursors=true," - "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB," - "checkpoint=(log_size=0,wait=0),checkpoint_sync=true," - "compatibility=(release=,require_max=,require_min=)," - "config_base=true,create=false,direct_io=,encryption=(keyid=," - "name=,secretkey=),error_prefix=,eviction=(threads_max=8," - "threads_min=1),eviction_checkpoint_target=1," - "eviction_dirty_target=5,eviction_dirty_trigger=20," - "eviction_target=80,eviction_trigger=95,exclusive=false," - "extensions=,file_extend=,file_manager=(close_handle_minimum=250," - "close_idle_time=30,close_scan_interval=10),hazard_max=1000," - "in_memory=false,io_capacity=(total=0),log=(archive=true," - "compressor=,enabled=false,file_max=100MB,os_cache_dirty_pct=0," - "path=\".\",prealloc=true,recover=on,zero_fill=false)," + "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8" + ",cache_size=100MB,checkpoint=(log_size=0,wait=0)," + "checkpoint_sync=true,compatibility=(release=,require_max=," + "require_min=),config_base=true,create=false," + "debug_mode=(checkpoint_retention=0,rollback_error=0," + "table_logging=false),direct_io=,encryption=(keyid=,name=," + "secretkey=),error_prefix=,eviction=(threads_max=8,threads_min=1)" + ",eviction_checkpoint_target=1,eviction_dirty_target=5," + "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95" + ",exclusive=false,extensions=,file_extend=," + "file_manager=(close_handle_minimum=250,close_idle_time=30," + "close_scan_interval=10),hazard_max=1000,in_memory=false," + "io_capacity=(total=0),log=(archive=true,compressor=," + "enabled=false,file_max=100MB,os_cache_dirty_pct=0,path=\".\"," + "prealloc=true,recover=on,zero_fill=false)," "lsm_manager=(merge=true,worker_thread_max=4),lsm_merge=true," "mmap=true,multiprocess=false,operation_tracking=(enabled=false," "path=\".\"),readonly=false,salvage=false,session_max=100," @@ -1624,14 +1678,16 @@ static const WT_CONFIG_ENTRY config_entries[] = { "timing_stress_for_test=,transaction_sync=(enabled=false," "method=fsync),use_environment=true,use_environment_priv=false," "verbose=,version=(major=0,minor=0),write_through=", - confchk_wiredtiger_open_all, 49 + confchk_wiredtiger_open_all, 51 }, { "wiredtiger_open_basecfg", "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1" ",builtin_extension_config=,cache_cursors=true," - "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB," - "checkpoint=(log_size=0,wait=0),checkpoint_sync=true," - "compatibility=(release=,require_max=,require_min=),direct_io=," + "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8" + ",cache_size=100MB,checkpoint=(log_size=0,wait=0)," + "checkpoint_sync=true,compatibility=(release=,require_max=," + "require_min=),debug_mode=(checkpoint_retention=0," + "rollback_error=0,table_logging=false),direct_io=," "encryption=(keyid=,name=,secretkey=),error_prefix=," "eviction=(threads_max=8,threads_min=1)," "eviction_checkpoint_target=1,eviction_dirty_target=5," @@ -1650,14 +1706,16 @@ static const WT_CONFIG_ENTRY config_entries[] = { "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0)," "timing_stress_for_test=,transaction_sync=(enabled=false," "method=fsync),verbose=,version=(major=0,minor=0),write_through=", - confchk_wiredtiger_open_basecfg, 43 + confchk_wiredtiger_open_basecfg, 45 }, { "wiredtiger_open_usercfg", "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1" ",builtin_extension_config=,cache_cursors=true," - "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB," - "checkpoint=(log_size=0,wait=0),checkpoint_sync=true," - "compatibility=(release=,require_max=,require_min=),direct_io=," + "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8" + ",cache_size=100MB,checkpoint=(log_size=0,wait=0)," + "checkpoint_sync=true,compatibility=(release=,require_max=," + "require_min=),debug_mode=(checkpoint_retention=0," + "rollback_error=0,table_logging=false),direct_io=," "encryption=(keyid=,name=,secretkey=),error_prefix=," "eviction=(threads_max=8,threads_min=1)," "eviction_checkpoint_target=1,eviction_dirty_target=5," @@ -1676,7 +1734,7 @@ static const WT_CONFIG_ENTRY config_entries[] = { "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0)," "timing_stress_for_test=,transaction_sync=(enabled=false," "method=fsync),verbose=,write_through=", - confchk_wiredtiger_open_usercfg, 42 + confchk_wiredtiger_open_usercfg, 44 }, { NULL, NULL, NULL, 0 } }; diff --git a/src/third_party/wiredtiger/src/conn/conn_api.c b/src/third_party/wiredtiger/src/conn/conn_api.c index cb7428aab09..6d414edaa42 100644 --- a/src/third_party/wiredtiger/src/conn/conn_api.c +++ b/src/third_party/wiredtiger/src/conn/conn_api.c @@ -1816,6 +1816,48 @@ err: /* return (ret); } +/* + * __wt_debug_mode_config -- + * Set debugging configuration. + */ +int +__wt_debug_mode_config(WT_SESSION_IMPL *session, const char *cfg[]) +{ + WT_CONFIG_ITEM cval; + WT_CONNECTION_IMPL *conn; + WT_TXN_GLOBAL *txn_global; + + conn = S2C(session); + txn_global = &conn->txn_global; + + WT_RET(__wt_config_gets(session, + cfg, "debug_mode.rollback_error", &cval)); + txn_global->debug_rollback = (uint64_t)cval.val; + + WT_RET(__wt_config_gets(session, + cfg, "debug_mode.table_logging", &cval)); + if (cval.val) + FLD_SET(conn->log_flags, WT_CONN_LOG_DEBUG_MODE); + else + FLD_CLR(conn->log_flags, WT_CONN_LOG_DEBUG_MODE); + + WT_RET(__wt_config_gets(session, + cfg, "debug_mode.checkpoint_retention", &cval)); + conn->debug_ckpt_cnt = (uint32_t)cval.val; + if (cval.val == 0) { + if (conn->debug_ckpt != NULL) + __wt_free(session, conn->debug_ckpt); + conn->debug_ckpt = NULL; + } else if (conn->debug_ckpt != NULL) + WT_RET(__wt_realloc(session, NULL, + conn->debug_ckpt_cnt, &conn->debug_ckpt)); + else + WT_RET(__wt_calloc_def(session, + conn->debug_ckpt_cnt, &conn->debug_ckpt)); + + return (0); +} + /* Simple structure for name and flag configuration searches. */ typedef struct { const char *name; @@ -2588,6 +2630,7 @@ wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler, session, cval.str, cval.len, &conn->error_prefix)); } WT_ERR(__wt_verbose_config(session, cfg)); + WT_ERR(__wt_debug_mode_config(session, cfg)); WT_ERR(__wt_timing_stress_config(session, cfg)); __wt_btree_page_version_config(session); diff --git a/src/third_party/wiredtiger/src/conn/conn_handle.c b/src/third_party/wiredtiger/src/conn/conn_handle.c index a3818b3c914..faee6216ed7 100644 --- a/src/third_party/wiredtiger/src/conn/conn_handle.c +++ b/src/third_party/wiredtiger/src/conn/conn_handle.c @@ -132,8 +132,9 @@ __wt_connection_destroy(WT_CONNECTION_IMPL *conn) /* Free allocated memory. */ __wt_free(session, conn->cfg); - __wt_free(session, conn->home); + __wt_free(session, conn->debug_ckpt); __wt_free(session, conn->error_prefix); + __wt_free(session, conn->home); __wt_free(session, conn->sessions); __wt_stat_connection_discard(session, conn); diff --git a/src/third_party/wiredtiger/src/conn/conn_log.c b/src/third_party/wiredtiger/src/conn/conn_log.c index 81f5724663f..0ab7d507ee1 100644 --- a/src/third_party/wiredtiger/src/conn/conn_log.c +++ b/src/third_party/wiredtiger/src/conn/conn_log.c @@ -392,9 +392,19 @@ __log_archive_once(WT_SESSION_IMPL *session, uint32_t backup_file) */ if (backup_file != 0) min_lognum = WT_MIN(log->ckpt_lsn.l.file, backup_file); - else - min_lognum = WT_MIN( - log->ckpt_lsn.l.file, log->sync_lsn.l.file); + else { + /* + * Figure out the minimum log file to archive. Use the + * LSN in the debugging array if necessary. + */ + if (conn->debug_ckpt_cnt == 0) + min_lognum = WT_MIN( + log->ckpt_lsn.l.file, log->sync_lsn.l.file); + else + min_lognum = WT_MIN( + conn->debug_ckpt[conn->debug_ckpt_cnt - 1].l.file, + log->sync_lsn.l.file); + } __wt_verbose(session, WT_VERB_LOG, "log_archive: archive to log number %" PRIu32, min_lognum); diff --git a/src/third_party/wiredtiger/src/conn/conn_open.c b/src/third_party/wiredtiger/src/conn/conn_open.c index 27d1e6a620d..3a1025fea1b 100644 --- a/src/third_party/wiredtiger/src/conn/conn_open.c +++ b/src/third_party/wiredtiger/src/conn/conn_open.c @@ -239,7 +239,7 @@ __wt_connection_workers(WT_SESSION_IMPL *session, const char *cfg[]) WT_RET(__wt_meta_track_init(session)); /* Create the lookaside table. */ - WT_RET(__wt_las_create(session)); + WT_RET(__wt_las_create(session, cfg)); /* * Start eviction threads. diff --git a/src/third_party/wiredtiger/src/conn/conn_reconfig.c b/src/third_party/wiredtiger/src/conn/conn_reconfig.c index a6783c9fb9b..8981ab531bb 100644 --- a/src/third_party/wiredtiger/src/conn/conn_reconfig.c +++ b/src/third_party/wiredtiger/src/conn/conn_reconfig.c @@ -454,6 +454,7 @@ __wt_conn_reconfig(WT_SESSION_IMPL *session, const char **cfg) /* Serialize reconfiguration. */ __wt_spin_lock(session, &conn->reconfig_lock); + F_SET(conn, WT_CONN_RECONFIGURING); /* * The configuration argument has been checked for validity, update the @@ -490,19 +491,22 @@ __wt_conn_reconfig(WT_SESSION_IMPL *session, const char **cfg) WT_ERR(__wt_cache_config(session, true, cfg)); WT_ERR(__wt_capacity_server_create(session, cfg)); WT_ERR(__wt_checkpoint_server_create(session, cfg)); + WT_ERR(__wt_debug_mode_config(session, cfg)); + WT_ERR(__wt_las_config(session, cfg)); WT_ERR(__wt_logmgr_reconfig(session, cfg)); WT_ERR(__wt_lsm_manager_reconfig(session, cfg)); WT_ERR(__wt_statlog_create(session, cfg)); WT_ERR(__wt_sweep_config(session, cfg)); - WT_ERR(__wt_verbose_config(session, cfg)); WT_ERR(__wt_timing_stress_config(session, cfg)); + WT_ERR(__wt_verbose_config(session, cfg)); /* Third, merge everything together, creating a new connection state. */ WT_ERR(__wt_config_merge(session, cfg, NULL, &p)); __wt_free(session, conn->cfg); conn->cfg = p; -err: __wt_spin_unlock(session, &conn->reconfig_lock); +err: F_CLR(conn, WT_CONN_RECONFIGURING); + __wt_spin_unlock(session, &conn->reconfig_lock); return (ret); } diff --git a/src/third_party/wiredtiger/src/docs/error-handling.dox b/src/third_party/wiredtiger/src/docs/error-handling.dox index e25d3500790..c8ae427cbae 100644 --- a/src/third_party/wiredtiger/src/docs/error-handling.dox +++ b/src/third_party/wiredtiger/src/docs/error-handling.dox @@ -75,7 +75,7 @@ This error is only generated when wiredtiger_open is configured to run in-memory This error is generated when the application attempts to update an already updated record which is in prepared state. An updated record will be in prepared state, when the transaction that performed the update is in prepared state. @par <code>WT_TRY_SALVAGE</code> -This error is generated when corruption is detected in an on-disk file. The application may choose to salvage the file or retry wiredtiger_open with the 'salvage=true' configuration setting. +This error is generated when corruption is detected in an on-disk file. During normal operations, this may occur in rare circumstances as a result of a system crash. The application may choose to salvage the file or retry wiredtiger_open with the 'salvage=true' configuration setting. @if IGNORE_BUILT_BY_API_ERR_END @endif diff --git a/src/third_party/wiredtiger/src/evict/evict_lru.c b/src/third_party/wiredtiger/src/evict/evict_lru.c index 659f584fbe4..836fcd8cb59 100644 --- a/src/third_party/wiredtiger/src/evict/evict_lru.c +++ b/src/third_party/wiredtiger/src/evict/evict_lru.c @@ -18,7 +18,7 @@ static int __evict_server(WT_SESSION_IMPL *, bool *); static void __evict_tune_workers(WT_SESSION_IMPL *session); static int __evict_walk(WT_SESSION_IMPL *, WT_EVICT_QUEUE *); static int __evict_walk_tree( - WT_SESSION_IMPL *, WT_EVICT_QUEUE *, u_int, u_int *); + WT_SESSION_IMPL *, WT_EVICT_QUEUE *, u_int, u_int *, uint64_t *); #define WT_EVICT_HAS_WORKERS(s) \ (S2C(s)->evict_threads.current_threads > 1) @@ -1347,6 +1347,62 @@ err: WT_TRACK_OP_END(session); } /* + * __evict_walk_choose_dhandle -- + * Randomly select a dhandle for the next eviction walk + */ +static void +__evict_walk_choose_dhandle( + WT_SESSION_IMPL *session, WT_DATA_HANDLE **dhandle_p) +{ + WT_CONNECTION_IMPL *conn; + WT_DATA_HANDLE *dhandle; + u_int dh_bucket_count, rnd_bucket, rnd_dh; + + conn = S2C(session); + *dhandle_p = NULL; + + WT_ASSERT(session, __wt_rwlock_islocked(session, &conn->dhandle_lock)); + + /* Nothing to do if the dhandle list is empty. */ + if (TAILQ_EMPTY(&conn->dhqh)) + return; + + /* + * If we do not have a lot of dhandles, most hash buckets will be empty. + * Just pick a random dhandle from the list in that case. + */ + if (conn->dhandle_count < 10 * WT_HASH_ARRAY_SIZE) { + rnd_dh = __wt_random(&session->rnd) % conn->dhandle_count; + dhandle = TAILQ_FIRST(&conn->dhqh); + for (; rnd_dh > 0; rnd_dh--) + dhandle = TAILQ_NEXT(dhandle, q); + *dhandle_p = dhandle; + return; + } + + /* + * Keep picking up a random bucket until we find one that is not empty. + */ + dh_bucket_count = 0; + rnd_bucket = 0; + while (dh_bucket_count == 0) { + rnd_bucket = __wt_random(&session->rnd) % WT_HASH_ARRAY_SIZE; + dh_bucket_count = conn->dh_bucket_count[rnd_bucket]; + } + + /* We can't pick up an empty bucket with a non zero bucket count. */ + WT_ASSERT(session, !TAILQ_EMPTY(&conn->dhhash[rnd_bucket])); + + /* Pick a random dhandle in the chosen bucket. */ + rnd_dh = __wt_random(&session->rnd) % dh_bucket_count; + dhandle = TAILQ_FIRST(&conn->dhhash[rnd_bucket]); + for (; rnd_dh > 0; rnd_dh--) + dhandle = TAILQ_NEXT(dhandle, q); + + *dhandle_p = dhandle; +} + +/* * __evict_walk -- * Fill in the array by walking the next set of pages. */ @@ -1359,6 +1415,8 @@ __evict_walk(WT_SESSION_IMPL *session, WT_EVICT_QUEUE *queue) WT_DATA_HANDLE *dhandle; WT_DECL_RET; WT_TRACK_OP_DECL; + uint64_t loop_count; + uint64_t pages_seen_file, pages_seen_interim, pages_seen_total; u_int max_entries, retries, slot, start_slot, total_candidates; bool dhandle_locked, incr; @@ -1385,8 +1443,31 @@ __evict_walk(WT_SESSION_IMPL *session, WT_EVICT_QUEUE *queue) total_candidates = (u_int)(F_ISSET(cache, WT_CACHE_EVICT_CLEAN) ? __wt_cache_pages_inuse(cache) : cache->pages_dirty_leaf); max_entries = WT_MIN(max_entries, 1 + total_candidates / 2); + pages_seen_interim = pages_seen_total = 0; + +retry: loop_count = 0; + while (slot < max_entries) { + loop_count++; + + /* We're done if shutting down or reconfiguring. */ + if (F_ISSET(conn, WT_CONN_CLOSING) || + F_ISSET(conn, WT_CONN_RECONFIGURING)) + break; + + /* If we have seen enough pages in this walk, we're done. */ + if (pages_seen_total > WT_EVICT_WALK_INCR * 100) + break; + + /* + * If we are not finding pages at all, we're done. + * Every 100th iteration, check if we made progress. + */ + if (loop_count % 100 == 0) { + if (pages_seen_interim == pages_seen_total) + break; + pages_seen_interim = pages_seen_total; + } -retry: while (slot < max_entries) { /* * If another thread is waiting on the eviction server to clear * the walk point in a tree, give up. @@ -1407,12 +1488,12 @@ retry: while (slot < max_entries) { /* * On entry, continue from wherever we got to in the * scan last time through. If we don't have a saved - * handle, start from the beginning of the list. + * handle, pick one randomly from the list. */ if ((dhandle = cache->walk_tree) != NULL) cache->walk_tree = NULL; else - dhandle = TAILQ_FIRST(&conn->dhqh); + __evict_walk_choose_dhandle(session, &dhandle); } else { if (incr) { WT_ASSERT(session, dhandle->session_inuse > 0); @@ -1421,10 +1502,10 @@ retry: while (slot < max_entries) { incr = false; cache->walk_tree = NULL; } - dhandle = TAILQ_NEXT(dhandle, q); + __evict_walk_choose_dhandle(session, &dhandle); } - /* If we reach the end of the list, we're done. */ + /* If we couldn't find any dhandle, we're done. */ if (dhandle == NULL) break; @@ -1502,8 +1583,9 @@ retry: while (slot < max_entries) { */ cache->walk_tree = dhandle; WT_WITH_DHANDLE(session, dhandle, - ret = __evict_walk_tree( - session, queue, max_entries, &slot)); + ret = __evict_walk_tree(session, queue, + max_entries, &slot, &pages_seen_file)); + pages_seen_total += pages_seen_file; WT_ASSERT(session, __wt_session_gen( session, WT_GEN_SPLIT) == 0); @@ -1520,9 +1602,8 @@ retry: while (slot < max_entries) { } /* - * Walk the list of files a few times if we don't find enough pages. - * Try two passes through all the files, give up when we have some - * candidates and we aren't finding more. + * Repeat the walks a few times if we don't find enough pages. + * Give up when we have some candidates and we aren't finding more. */ if (slot < max_entries && (retries < 2 || (retries < WT_RETRY_MAX && @@ -1682,8 +1763,8 @@ __evict_walk_target(WT_SESSION_IMPL *session, u_int max_entries) * Get a few page eviction candidates from a single underlying file. */ static int -__evict_walk_tree(WT_SESSION_IMPL *session, - WT_EVICT_QUEUE *queue, u_int max_entries, u_int *slotp) +__evict_walk_tree(WT_SESSION_IMPL *session, WT_EVICT_QUEUE *queue, + u_int max_entries, u_int *slotp, uint64_t *pages_seen_p) { WT_BTREE *btree; WT_CACHE *cache; @@ -1703,6 +1784,7 @@ __evict_walk_tree(WT_SESSION_IMPL *session, last_parent = NULL; restarts = 0; give_up = urgent_queued = false; + *pages_seen_p = 0; /* * Figure out how many slots to fill from this tree. @@ -2073,6 +2155,8 @@ fast: /* If the page can't be evicted, give up. */ btree->evict_ref = ref; } + *pages_seen_p = pages_seen; + WT_STAT_CONN_INCRV(session, cache_eviction_walk, refs_walked); WT_STAT_CONN_INCRV(session, cache_eviction_pages_seen, pages_seen); WT_STAT_DATA_INCRV(session, cache_eviction_pages_seen, pages_seen); diff --git a/src/third_party/wiredtiger/src/include/btree.h b/src/third_party/wiredtiger/src/include/btree.h index 27e26af0e18..0becfded2a9 100644 --- a/src/third_party/wiredtiger/src/include/btree.h +++ b/src/third_party/wiredtiger/src/include/btree.h @@ -197,6 +197,12 @@ struct __wt_btree { uint64_t bytes_dirty_total; /* Bytes ever dirtied in cache. */ /* + * The maximum bytes allowed to be used for the table on disk. This is + * currently only used for the lookaside table. + */ + uint64_t file_max; + + /* * We flush pages from the tree (in order to make checkpoint faster), * without a high-level lock. To avoid multiple threads flushing at * the same time, lock the tree. diff --git a/src/third_party/wiredtiger/src/include/cache.h b/src/third_party/wiredtiger/src/include/cache.h index 9c485b5e693..07d25d13ec2 100644 --- a/src/third_party/wiredtiger/src/include/cache.h +++ b/src/third_party/wiredtiger/src/include/cache.h @@ -54,6 +54,7 @@ typedef enum __wt_cache_op { WT_SYNC_WRITE_LEAVES } WT_CACHE_OP; +#define WT_LAS_FILE_MIN (100 * WT_MEGABYTE) #define WT_LAS_NUM_SESSIONS 5 #define WT_LAS_SWEEP_ENTRIES (20 * WT_THOUSAND) #define WT_LAS_SWEEP_SEC 2 diff --git a/src/third_party/wiredtiger/src/include/connection.h b/src/third_party/wiredtiger/src/include/connection.h index 2e0155fd821..09d5a780f79 100644 --- a/src/third_party/wiredtiger/src/include/connection.h +++ b/src/third_party/wiredtiger/src/include/connection.h @@ -122,6 +122,7 @@ struct __wt_named_extractor { F_ISSET(session, WT_SESSION_LOCKED_HANDLE_LIST_WRITE)); \ TAILQ_INSERT_HEAD(&(conn)->dhqh, dhandle, q); \ TAILQ_INSERT_HEAD(&(conn)->dhhash[bucket], dhandle, hashq); \ + ++(conn)->dh_bucket_count[bucket]; \ ++(conn)->dhandle_count; \ } while (0) @@ -130,6 +131,7 @@ struct __wt_named_extractor { F_ISSET(session, WT_SESSION_LOCKED_HANDLE_LIST_WRITE)); \ TAILQ_REMOVE(&(conn)->dhqh, dhandle, q); \ TAILQ_REMOVE(&(conn)->dhhash[bucket], dhandle, hashq); \ + --(conn)->dh_bucket_count[bucket]; \ --(conn)->dhandle_count; \ } while (0) @@ -207,6 +209,9 @@ struct __wt_connection_impl { WT_SPINLOCK optrack_map_spinlock; /* Translation file spinlock. */ uintmax_t optrack_pid; /* Cache the process ID. */ + WT_LSN *debug_ckpt; /* Debug mode checkpoint LSNs. */ + uint32_t debug_ckpt_cnt;/* Checkpoint retention number */ + void **foc; /* Free-on-close array */ size_t foc_cnt; /* Array entries */ size_t foc_size; /* Array size */ @@ -235,6 +240,8 @@ struct __wt_connection_impl { TAILQ_HEAD(__wt_blockhash, __wt_block) blockhash[WT_HASH_ARRAY_SIZE]; TAILQ_HEAD(__wt_block_qh, __wt_block) blockqh; + /* Locked: handles in each bucket */ + u_int dh_bucket_count[WT_HASH_ARRAY_SIZE]; u_int dhandle_count; /* Locked: handles in the queue */ u_int open_btree_count; /* Locked: open writable btree count */ uint32_t next_file_id; /* Locked: file ID counter */ @@ -339,15 +346,16 @@ struct __wt_connection_impl { /* AUTOMATIC FLAG VALUE GENERATION START */ #define WT_CONN_LOG_ARCHIVE 0x001u /* Archive is enabled */ -#define WT_CONN_LOG_DOWNGRADED 0x002u /* Running older version */ -#define WT_CONN_LOG_ENABLED 0x004u /* Logging is enabled */ -#define WT_CONN_LOG_EXISTED 0x008u /* Log files found */ -#define WT_CONN_LOG_FORCE_DOWNGRADE 0x010u /* Force downgrade */ -#define WT_CONN_LOG_RECOVER_DIRTY 0x020u /* Recovering unclean */ -#define WT_CONN_LOG_RECOVER_DONE 0x040u /* Recovery completed */ -#define WT_CONN_LOG_RECOVER_ERR 0x080u /* Error if recovery required */ -#define WT_CONN_LOG_RECOVER_FAILED 0x100u /* Recovery failed */ -#define WT_CONN_LOG_ZERO_FILL 0x200u /* Manually zero files */ +#define WT_CONN_LOG_DEBUG_MODE 0x002u /* Debug-mode logging enabled */ +#define WT_CONN_LOG_DOWNGRADED 0x004u /* Running older version */ +#define WT_CONN_LOG_ENABLED 0x008u /* Logging is enabled */ +#define WT_CONN_LOG_EXISTED 0x010u /* Log files found */ +#define WT_CONN_LOG_FORCE_DOWNGRADE 0x020u /* Force downgrade */ +#define WT_CONN_LOG_RECOVER_DIRTY 0x040u /* Recovering unclean */ +#define WT_CONN_LOG_RECOVER_DONE 0x080u /* Recovery completed */ +#define WT_CONN_LOG_RECOVER_ERR 0x100u /* Error if recovery required */ +#define WT_CONN_LOG_RECOVER_FAILED 0x200u /* Recovery failed */ +#define WT_CONN_LOG_ZERO_FILL 0x400u /* Manually zero files */ /* AUTOMATIC FLAG VALUE GENERATION STOP */ uint32_t log_flags; /* Global logging configuration */ WT_CONDVAR *log_cond; /* Log server wait mutex */ @@ -519,16 +527,17 @@ struct __wt_connection_impl { #define WT_CONN_OPTRACK 0x0004000u #define WT_CONN_PANIC 0x0008000u #define WT_CONN_READONLY 0x0010000u -#define WT_CONN_RECOVERING 0x0020000u -#define WT_CONN_SALVAGE 0x0040000u -#define WT_CONN_SERVER_ASYNC 0x0080000u -#define WT_CONN_SERVER_CAPACITY 0x0100000u -#define WT_CONN_SERVER_CHECKPOINT 0x0200000u -#define WT_CONN_SERVER_LOG 0x0400000u -#define WT_CONN_SERVER_LSM 0x0800000u -#define WT_CONN_SERVER_STATISTICS 0x1000000u -#define WT_CONN_SERVER_SWEEP 0x2000000u -#define WT_CONN_WAS_BACKUP 0x4000000u +#define WT_CONN_RECONFIGURING 0x0020000u +#define WT_CONN_RECOVERING 0x0040000u +#define WT_CONN_SALVAGE 0x0080000u +#define WT_CONN_SERVER_ASYNC 0x0100000u +#define WT_CONN_SERVER_CAPACITY 0x0200000u +#define WT_CONN_SERVER_CHECKPOINT 0x0400000u +#define WT_CONN_SERVER_LOG 0x0800000u +#define WT_CONN_SERVER_LSM 0x1000000u +#define WT_CONN_SERVER_STATISTICS 0x2000000u +#define WT_CONN_SERVER_SWEEP 0x4000000u +#define WT_CONN_WAS_BACKUP 0x8000000u /* AUTOMATIC FLAG VALUE GENERATION STOP */ uint32_t flags; }; diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h index 4a245d03f47..f122c5e8f84 100644 --- a/src/third_party/wiredtiger/src/include/extern.h +++ b/src/third_party/wiredtiger/src/include/extern.h @@ -203,9 +203,10 @@ extern int __wt_update_alloc(WT_SESSION_IMPL *session, const WT_ITEM *value, WT_ extern WT_UPDATE *__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_PAGE *page, WT_UPDATE *upd); extern int __wt_search_insert(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_INSERT_HEAD *ins_head, WT_ITEM *srch_key) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_row_search(WT_SESSION_IMPL *session, WT_ITEM *srch_key, WT_REF *leaf, WT_CURSOR_BTREE *cbt, bool insert, bool restore) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_las_config(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern bool __wt_las_empty(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_las_stats_update(WT_SESSION_IMPL *session); -extern int __wt_las_create(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_las_create(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_las_destroy(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_las_cursor_open(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags); @@ -255,6 +256,7 @@ extern int __wt_encryptor_config(WT_SESSION_IMPL *session, WT_CONFIG_ITEM *cval, extern int __wt_conn_remove_encryptor(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_extractor_config(WT_SESSION_IMPL *session, const char *uri, const char *config, WT_EXTRACTOR **extractorp, int *ownp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_conn_remove_extractor(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_debug_mode_config(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_verbose_config(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_verbose_dump_sessions(WT_SESSION_IMPL *session, bool show_cursors) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_timing_stress_config(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -391,7 +393,7 @@ extern int __wt_page_release_evict(WT_SESSION_IMPL *session, WT_REF *ref, uint32 extern int __wt_evict(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t previous_state, uint32_t flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_curstat_cache_walk(WT_SESSION_IMPL *session); extern int __wt_log_printf(WT_SESSION_IMPL *session, const char *format, ...) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern void __wt_log_ckpt(WT_SESSION_IMPL *session, WT_LSN *ckp_lsn); +extern void __wt_log_ckpt(WT_SESSION_IMPL *session, WT_LSN *ckpt_lsn); extern int __wt_log_flush_lsn(WT_SESSION_IMPL *session, WT_LSN *lsn, bool start) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_log_background(WT_SESSION_IMPL *session, WT_LSN *lsn); extern int __wt_log_force_sync(WT_SESSION_IMPL *session, WT_LSN *min_lsn) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -447,6 +449,9 @@ extern int __wt_logop_checkpoint_start_print(WT_SESSION_IMPL *session, const uin extern int __wt_logop_prev_lsn_pack(WT_SESSION_IMPL *session, WT_ITEM *logrec, WT_LSN *prev_lsn) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_logop_prev_lsn_unpack(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_LSN *prev_lsnp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_logop_prev_lsn_print(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_TXN_PRINTLOG_ARGS *args) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_logop_txn_timestamp_pack(WT_SESSION_IMPL *session, WT_ITEM *logrec, uint64_t time_sec, uint64_t time_nsec, uint64_t commit_ts, uint64_t durable_ts, uint64_t first_ts, uint64_t prepare_ts, uint64_t read_ts) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_logop_txn_timestamp_unpack(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, uint64_t *time_secp, uint64_t *time_nsecp, uint64_t *commit_tsp, uint64_t *durable_tsp, uint64_t *first_tsp, uint64_t *prepare_tsp, uint64_t *read_tsp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_logop_txn_timestamp_print(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_TXN_PRINTLOG_ARGS *args) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_txn_op_printlog(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_TXN_PRINTLOG_ARGS *args) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_log_slot_activate(WT_SESSION_IMPL *session, WT_LOGSLOT *slot); extern int __wt_log_slot_switch(WT_SESSION_IMPL *session, WT_MYSLOT *myslot, bool retry, bool forced, bool *did_work) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -861,6 +866,7 @@ extern void __wt_txn_op_free(WT_SESSION_IMPL *session, WT_TXN_OP *op); extern int __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_txn_log_commit(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_txn_checkpoint_logread(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_LSN *ckpt_lsn) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_txn_ts_log(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_txn_checkpoint_log(WT_SESSION_IMPL *session, bool full, uint32_t flags, WT_LSN *lsnp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_txn_truncate_log(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *start, WT_CURSOR_BTREE *stop) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern void __wt_txn_truncate_end(WT_SESSION_IMPL *session); diff --git a/src/third_party/wiredtiger/src/include/log.h b/src/third_party/wiredtiger/src/include/log.h index 463f92a34a3..e7e49b8b0ce 100644 --- a/src/third_party/wiredtiger/src/include/log.h +++ b/src/third_party/wiredtiger/src/include/log.h @@ -21,6 +21,9 @@ #define WT_LOG_SYNC_ENABLED 0x10u /* AUTOMATIC FLAG VALUE GENERATION STOP */ +#define WT_LOGOP_IGNORE 0x80000000 +#define WT_LOGOP_IS_IGNORED(val) (val & WT_LOGOP_IGNORE) + /* * WT_LSN -- * A log sequence number, representing a position in the transaction log. diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h index 234f8beb8fe..e752ac05c0d 100644 --- a/src/third_party/wiredtiger/src/include/stat.h +++ b/src/third_party/wiredtiger/src/include/stat.h @@ -371,6 +371,7 @@ struct __wt_connection_stats { int64_t cache_lookaside_score; int64_t cache_lookaside_entries; int64_t cache_lookaside_insert; + int64_t cache_lookaside_ondisk_max; int64_t cache_lookaside_ondisk; int64_t cache_lookaside_remove; int64_t cache_eviction_checkpoint; @@ -824,6 +825,8 @@ struct __wt_dsrc_stats { int64_t cache_state_refs_skipped; int64_t cache_state_root_size; int64_t cache_state_pages; + int64_t compress_precomp_intl_max_page_size; + int64_t compress_precomp_leaf_max_page_size; int64_t compress_read; int64_t compress_write; int64_t compress_write_fail; diff --git a/src/third_party/wiredtiger/src/include/txn.h b/src/third_party/wiredtiger/src/include/txn.h index 52f319e1da4..29ad33f3b76 100644 --- a/src/third_party/wiredtiger/src/include/txn.h +++ b/src/third_party/wiredtiger/src/include/txn.h @@ -170,6 +170,8 @@ struct __wt_txn_global { WT_TXN_STATE checkpoint_state; /* Checkpoint's txn state */ wt_timestamp_t checkpoint_timestamp; /* Checkpoint's timestamp */ + volatile uint64_t debug_ops; /* Debug mode op counter */ + uint64_t debug_rollback; /* Debug mode rollback */ volatile uint64_t metadata_pinned; /* Oldest ID for metadata */ /* Named snapshot state. */ diff --git a/src/third_party/wiredtiger/src/include/txn.i b/src/third_party/wiredtiger/src/include/txn.i index f79507e31ad..0c8e22c90d1 100644 --- a/src/third_party/wiredtiger/src/include/txn.i +++ b/src/third_party/wiredtiger/src/include/txn.i @@ -1109,13 +1109,19 @@ static inline int __wt_txn_update_check(WT_SESSION_IMPL *session, WT_UPDATE *upd) { WT_TXN *txn; + WT_TXN_GLOBAL *txn_global; bool ignore_prepare_set; txn = &session->txn; + txn_global = &S2C(session)->txn_global; if (txn->isolation != WT_ISO_SNAPSHOT) return (0); + if (txn_global->debug_rollback != 0 && + ++txn_global->debug_ops % txn_global->debug_rollback == 0) + return (__wt_txn_rollback_required(session, + "debug mode simulated conflict")); /* * Always include prepared transactions in this check: they are not * supposed to affect visibility for update operations. diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in index 3028a825a9d..9830d79a190 100644 --- a/src/third_party/wiredtiger/src/include/wiredtiger.in +++ b/src/third_party/wiredtiger/src/include/wiredtiger.in @@ -1783,8 +1783,13 @@ struct __wt_session { * @param session the session handle * @configstart{WT_SESSION.begin_transaction, see dist/api_data.py} * @config{ignore_prepare, whether to ignore the updates by other - * prepared transactions as part of read operations of this - * transaction., a boolean flag; default \c false.} + * prepared transactions as part of read operations of this transaction. + * When \c true\, forces the transaction to be read-only. Use \c force + * to ignore prepared updates and permit writes (which can cause lost + * updates unless the application knows something about the relationship + * between prepared transactions and the updates that are ignoring + * them)., a string\, chosen from the following options: \c "false"\, \c + * "force"\, \c "true"; default \c false.} * @config{isolation, the isolation level for this transaction; defaults * to the session's isolation level., a string\, chosen from the * following options: \c "read-uncommitted"\, \c "read-committed"\, \c @@ -2229,6 +2234,16 @@ struct __wt_connection { * application thread will wait for space to be available in cache * before giving up. Default will wait forever., an integer greater * than or equal to 0; default \c 0.} + * @config{cache_overflow = (, cache overflow configuration options., a + * set of related configuration options defined below.} + * @config{ file_max, The maximum number of bytes + * that WiredTiger is allowed to use for its cache overflow mechanism. + * If the cache overflow file exceeds this size\, a panic will be + * triggered. The default value means that the cache overflow file is + * unbounded and may use as much space as the filesystem will + * accommodate. The minimum non-zero setting is 100MB., an integer + * greater than or equal to 0; default \c 0.} + * @config{ ),,} * @config{cache_overhead, assume the heap allocator overhead is the * specified percentage\, and adjust the cache usage by that amount (for * example\, if there is 10GB of data in cache\, a percentage of 10 @@ -2261,6 +2276,24 @@ struct __wt_connection { * @config{ release, compatibility release * version string., a string; default empty.} * @config{ ),,} + * @config{debug_mode = (, control the settings of various extended + * debugging features., a set of related configuration options defined + * below.} + * @config{ checkpoint_retention, adjust + * log archiving to retain the log records of this number of + * checkpoints. Zero or one means perform normal archiving., an integer + * between 0 and 1024; default \c 0.} + * @config{ + * rollback_error, return a WT_ROLLBACK error from a transaction + * operation about every Nth operation to simulate a collision., an + * integer between 0 and 10M; default \c 0.} + * @config{ table_logging, if true\, write + * transaction related information to the log for all operations\, even + * operations for tables with logging turned off. This setting + * introduces a log format change that may break older versions of + * WiredTiger. These operations are informational and skipped in + * recovery., a boolean flag; default \c false.} + * @config{ ),,} * @config{error_prefix, prefix string for error messages., a string; * default empty.} * @config{eviction = (, eviction configuration options., a set of @@ -2833,6 +2866,15 @@ struct __wt_connection { * thread will wait for space to be available in cache before giving up. * Default will wait forever., an integer greater than or equal to 0; default \c * 0.} + * @config{cache_overflow = (, cache overflow configuration options., a set of + * related configuration options defined below.} + * @config{ file_max, The maximum number of bytes that + * WiredTiger is allowed to use for its cache overflow mechanism. If the cache + * overflow file exceeds this size\, a panic will be triggered. The default + * value means that the cache overflow file is unbounded and may use as much + * space as the filesystem will accommodate. The minimum non-zero setting is + * 100MB., an integer greater than or equal to 0; default \c 0.} + * @config{ ),,} * @config{cache_overhead, assume the heap allocator overhead is the specified * percentage\, and adjust the cache usage by that amount (for example\, if * there is 10GB of data in cache\, a percentage of 10 means WiredTiger treats @@ -2881,6 +2923,20 @@ struct __wt_connection { * true.} * @config{create, create the database if it does not exist., a boolean flag; * default \c false.} + * @config{debug_mode = (, control the settings of various extended debugging + * features., a set of related configuration options defined below.} + * @config{ checkpoint_retention, adjust log archiving to + * retain the log records of this number of checkpoints. Zero or one means + * perform normal archiving., an integer between 0 and 1024; default \c 0.} + * @config{ rollback_error, return a WT_ROLLBACK error + * from a transaction operation about every Nth operation to simulate a + * collision., an integer between 0 and 10M; default \c 0.} + * @config{ table_logging, if true\, write transaction + * related information to the log for all operations\, even operations for + * tables with logging turned off. This setting introduces a log format change + * that may break older versions of WiredTiger. These operations are + * informational and skipped in recovery., a boolean flag; default \c false.} + * @config{ ),,} * @config{direct_io, Use \c O_DIRECT on POSIX systems\, and \c * FILE_FLAG_NO_BUFFERING on Windows to access files. Options are given as a * list\, such as <code>"direct_io=[data]"</code>. Configuring \c direct_io @@ -2888,7 +2944,7 @@ struct __wt_connection { * warnings. Including \c "data" will cause WiredTiger data files to use direct * I/O\, including \c "log" will cause WiredTiger log files to use direct I/O\, * and including \c "checkpoint" will cause WiredTiger data files opened at a - * checkpoint (i.e: read only) to use direct I/O. \c direct_io should be + * checkpoint (i.e: read-only) to use direct I/O. \c direct_io should be * combined with \c write_through to get the equivalent of \c O_DIRECT on * Windows., a list\, with values chosen from the following options: \c * "checkpoint"\, \c "data"\, \c "log"; default empty.} @@ -3825,9 +3881,10 @@ const char *wiredtiger_version(int *majorp, int *minorp, int *patchp) #define WT_PREPARE_CONFLICT (-31808) /*! * Database corruption detected. - * This error is generated when corruption is detected in an on-disk file. The - * application may choose to salvage the file or retry wiredtiger_open with the - * 'salvage=true' configuration setting. + * This error is generated when corruption is detected in an on-disk file. + * During normal operations, this may occur in rare circumstances as a result of + * a system crash. The application may choose to salvage the file or retry + * wiredtiger_open with the 'salvage=true' configuration setting. */ #define WT_TRY_SALVAGE (-31809) /* @@ -4958,13 +5015,19 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); #define WT_LOGOP_COL_MODIFY 9 /*! row-store modify */ #define WT_LOGOP_ROW_MODIFY 10 +/* + * NOTE: Diagnostic-only log operations should have values in + * the ignore range. + */ +/*! Diagnostic: transaction timestamps */ +#define WT_LOGOP_TXN_TIMESTAMP (WT_LOGOP_IGNORE | 11) /*! @} */ /******************************************* * Statistic reference. *******************************************/ /* - * DO NOT EDIT: automatically built by dist/api_stat.py. + * DO NOT EDIT: automatically built by dist/stat.py. * Statistics section: BEGIN */ @@ -5071,762 +5134,764 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); #define WT_STAT_CONN_CACHE_LOOKASIDE_ENTRIES 1045 /*! cache: cache overflow table insert calls */ #define WT_STAT_CONN_CACHE_LOOKASIDE_INSERT 1046 +/*! cache: cache overflow table max on-disk size */ +#define WT_STAT_CONN_CACHE_LOOKASIDE_ONDISK_MAX 1047 /*! cache: cache overflow table on-disk size */ -#define WT_STAT_CONN_CACHE_LOOKASIDE_ONDISK 1047 +#define WT_STAT_CONN_CACHE_LOOKASIDE_ONDISK 1048 /*! cache: cache overflow table remove calls */ -#define WT_STAT_CONN_CACHE_LOOKASIDE_REMOVE 1048 +#define WT_STAT_CONN_CACHE_LOOKASIDE_REMOVE 1049 /*! cache: checkpoint blocked page eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT 1049 +#define WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT 1050 /*! cache: eviction calls to get a page */ -#define WT_STAT_CONN_CACHE_EVICTION_GET_REF 1050 +#define WT_STAT_CONN_CACHE_EVICTION_GET_REF 1051 /*! cache: eviction calls to get a page found queue empty */ -#define WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY 1051 +#define WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY 1052 /*! cache: eviction calls to get a page found queue empty after locking */ -#define WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2 1052 +#define WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2 1053 /*! cache: eviction currently operating in aggressive mode */ -#define WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET 1053 +#define WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET 1054 /*! cache: eviction empty score */ -#define WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE 1054 +#define WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE 1055 /*! cache: eviction passes of a file */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES 1055 +#define WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES 1056 /*! cache: eviction server candidate queue empty when topping up */ -#define WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY 1056 +#define WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY 1057 /*! cache: eviction server candidate queue not empty when topping up */ -#define WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY 1057 +#define WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY 1058 /*! cache: eviction server evicting pages */ -#define WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING 1058 +#define WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING 1059 /*! * cache: eviction server slept, because we did not make progress with * eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT 1059 +#define WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT 1060 /*! cache: eviction server unable to reach eviction goal */ -#define WT_STAT_CONN_CACHE_EVICTION_SLOW 1060 +#define WT_STAT_CONN_CACHE_EVICTION_SLOW 1061 /*! cache: eviction state */ -#define WT_STAT_CONN_CACHE_EVICTION_STATE 1061 +#define WT_STAT_CONN_CACHE_EVICTION_STATE 1062 /*! cache: eviction walk target pages histogram - 0-9 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10 1062 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10 1063 /*! cache: eviction walk target pages histogram - 10-31 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32 1063 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32 1064 /*! cache: eviction walk target pages histogram - 128 and higher */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128 1064 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128 1065 /*! cache: eviction walk target pages histogram - 32-63 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64 1065 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64 1066 /*! cache: eviction walk target pages histogram - 64-128 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128 1066 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128 1067 /*! cache: eviction walks abandoned */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED 1067 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED 1068 /*! cache: eviction walks gave up because they restarted their walk twice */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED 1068 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED 1069 /*! * cache: eviction walks gave up because they saw too many pages and * found no candidates */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS 1069 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS 1070 /*! * cache: eviction walks gave up because they saw too many pages and * found too few candidates */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO 1070 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO 1071 /*! cache: eviction walks reached end of tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED 1071 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED 1072 /*! cache: eviction walks started from root of tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT 1072 +#define WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT 1073 /*! cache: eviction walks started from saved location in tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS 1073 +#define WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS 1074 /*! cache: eviction worker thread active */ -#define WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS 1074 +#define WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS 1075 /*! cache: eviction worker thread created */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED 1075 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED 1076 /*! cache: eviction worker thread evicting pages */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING 1076 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING 1077 /*! cache: eviction worker thread removed */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED 1077 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED 1078 /*! cache: eviction worker thread stable number */ -#define WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS 1078 +#define WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS 1079 /*! * cache: failed eviction of pages that exceeded the in-memory maximum * count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1079 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1080 /*! * cache: failed eviction of pages that exceeded the in-memory maximum * time (usecs) */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1080 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1081 /*! cache: files with active eviction walks */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE 1081 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE 1082 /*! cache: files with new eviction walks started */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED 1082 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED 1083 /*! cache: force re-tuning of eviction workers once in a while */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE 1083 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE 1084 /*! cache: hazard pointer blocked page eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1084 +#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1085 /*! cache: hazard pointer check calls */ -#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1085 +#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1086 /*! cache: hazard pointer check entries walked */ -#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1086 +#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1087 /*! cache: hazard pointer maximum array length */ -#define WT_STAT_CONN_CACHE_HAZARD_MAX 1087 +#define WT_STAT_CONN_CACHE_HAZARD_MAX 1088 /*! cache: in-memory page passed criteria to be split */ -#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1088 +#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1089 /*! cache: in-memory page splits */ -#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1089 +#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1090 /*! cache: internal pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1090 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1091 /*! cache: internal pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1091 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1092 /*! cache: leaf pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1092 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1093 /*! cache: maximum bytes configured */ -#define WT_STAT_CONN_CACHE_BYTES_MAX 1093 +#define WT_STAT_CONN_CACHE_BYTES_MAX 1094 /*! cache: maximum page size at eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1094 +#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1095 /*! cache: modified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1095 +#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1096 /*! cache: modified pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1096 +#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1097 /*! cache: operations timed out waiting for space in cache */ -#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1097 +#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1098 /*! cache: overflow pages read into cache */ -#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1098 +#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1099 /*! cache: page split during eviction deepened the tree */ -#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1099 +#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1100 /*! cache: page written requiring cache overflow records */ -#define WT_STAT_CONN_CACHE_WRITE_LOOKASIDE 1100 +#define WT_STAT_CONN_CACHE_WRITE_LOOKASIDE 1101 /*! cache: pages currently held in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_INUSE 1101 +#define WT_STAT_CONN_CACHE_PAGES_INUSE 1102 /*! cache: pages evicted because they exceeded the in-memory maximum count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1102 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1103 /*! * cache: pages evicted because they exceeded the in-memory maximum time * (usecs) */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_TIME 1103 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_TIME 1104 /*! cache: pages evicted because they had chains of deleted items count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1104 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1105 /*! * cache: pages evicted because they had chains of deleted items time * (usecs) */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE_TIME 1105 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE_TIME 1106 /*! cache: pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP 1106 +#define WT_STAT_CONN_CACHE_EVICTION_APP 1107 /*! cache: pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1107 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1108 /*! cache: pages queued for urgent eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1108 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1109 /*! cache: pages queued for urgent eviction during walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1109 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1110 /*! cache: pages read into cache */ -#define WT_STAT_CONN_CACHE_READ 1110 +#define WT_STAT_CONN_CACHE_READ 1111 /*! cache: pages read into cache after truncate */ -#define WT_STAT_CONN_CACHE_READ_DELETED 1111 +#define WT_STAT_CONN_CACHE_READ_DELETED 1112 /*! cache: pages read into cache after truncate in prepare state */ -#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1112 +#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1113 /*! cache: pages read into cache requiring cache overflow entries */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE 1113 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE 1114 /*! cache: pages read into cache requiring cache overflow for checkpoint */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT 1114 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT 1115 /*! cache: pages read into cache skipping older cache overflow entries */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED 1115 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED 1116 /*! * cache: pages read into cache with skipped cache overflow entries * needed later */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY 1116 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY 1117 /*! * cache: pages read into cache with skipped cache overflow entries * needed later by checkpoint */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT 1117 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT 1118 /*! cache: pages requested from the cache */ -#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1118 +#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1119 /*! cache: pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1119 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1120 /*! cache: pages selected for eviction unable to be evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1120 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1121 /*! cache: pages walked for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK 1121 +#define WT_STAT_CONN_CACHE_EVICTION_WALK 1122 /*! cache: pages written from cache */ -#define WT_STAT_CONN_CACHE_WRITE 1122 +#define WT_STAT_CONN_CACHE_WRITE 1123 /*! cache: pages written requiring in-memory restoration */ -#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1123 +#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1124 /*! cache: percentage overhead */ -#define WT_STAT_CONN_CACHE_OVERHEAD 1124 +#define WT_STAT_CONN_CACHE_OVERHEAD 1125 /*! cache: tracked bytes belonging to internal pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1125 +#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1126 /*! cache: tracked bytes belonging to leaf pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_LEAF 1126 +#define WT_STAT_CONN_CACHE_BYTES_LEAF 1127 /*! cache: tracked dirty bytes in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1127 +#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1128 /*! cache: tracked dirty pages in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1128 +#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1129 /*! cache: unmodified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1129 +#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1130 /*! capacity: background fsync file handles considered */ -#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1130 +#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1131 /*! capacity: background fsync file handles synced */ -#define WT_STAT_CONN_FSYNC_ALL_FH 1131 +#define WT_STAT_CONN_FSYNC_ALL_FH 1132 /*! capacity: background fsync time (msecs) */ -#define WT_STAT_CONN_FSYNC_ALL_TIME 1132 +#define WT_STAT_CONN_FSYNC_ALL_TIME 1133 /*! capacity: bytes read */ -#define WT_STAT_CONN_CAPACITY_BYTES_READ 1133 +#define WT_STAT_CONN_CAPACITY_BYTES_READ 1134 /*! capacity: bytes written for checkpoint */ -#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1134 +#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1135 /*! capacity: bytes written for eviction */ -#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1135 +#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1136 /*! capacity: bytes written for log */ -#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1136 +#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1137 /*! capacity: bytes written total */ -#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1137 +#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1138 /*! capacity: threshold to call fsync */ -#define WT_STAT_CONN_CAPACITY_THRESHOLD 1138 +#define WT_STAT_CONN_CAPACITY_THRESHOLD 1139 /*! capacity: time waiting due to total capacity (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1139 +#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1140 /*! capacity: time waiting during checkpoint (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1140 +#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1141 /*! capacity: time waiting during eviction (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1141 +#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1142 /*! capacity: time waiting during logging (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_LOG 1142 +#define WT_STAT_CONN_CAPACITY_TIME_LOG 1143 /*! capacity: time waiting during read (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_READ 1143 +#define WT_STAT_CONN_CAPACITY_TIME_READ 1144 /*! connection: auto adjusting condition resets */ -#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1144 +#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1145 /*! connection: auto adjusting condition wait calls */ -#define WT_STAT_CONN_COND_AUTO_WAIT 1145 +#define WT_STAT_CONN_COND_AUTO_WAIT 1146 /*! connection: detected system time went backwards */ -#define WT_STAT_CONN_TIME_TRAVEL 1146 +#define WT_STAT_CONN_TIME_TRAVEL 1147 /*! connection: files currently open */ -#define WT_STAT_CONN_FILE_OPEN 1147 +#define WT_STAT_CONN_FILE_OPEN 1148 /*! connection: memory allocations */ -#define WT_STAT_CONN_MEMORY_ALLOCATION 1148 +#define WT_STAT_CONN_MEMORY_ALLOCATION 1149 /*! connection: memory frees */ -#define WT_STAT_CONN_MEMORY_FREE 1149 +#define WT_STAT_CONN_MEMORY_FREE 1150 /*! connection: memory re-allocations */ -#define WT_STAT_CONN_MEMORY_GROW 1150 +#define WT_STAT_CONN_MEMORY_GROW 1151 /*! connection: pthread mutex condition wait calls */ -#define WT_STAT_CONN_COND_WAIT 1151 +#define WT_STAT_CONN_COND_WAIT 1152 /*! connection: pthread mutex shared lock read-lock calls */ -#define WT_STAT_CONN_RWLOCK_READ 1152 +#define WT_STAT_CONN_RWLOCK_READ 1153 /*! connection: pthread mutex shared lock write-lock calls */ -#define WT_STAT_CONN_RWLOCK_WRITE 1153 +#define WT_STAT_CONN_RWLOCK_WRITE 1154 /*! connection: total fsync I/Os */ -#define WT_STAT_CONN_FSYNC_IO 1154 +#define WT_STAT_CONN_FSYNC_IO 1155 /*! connection: total read I/Os */ -#define WT_STAT_CONN_READ_IO 1155 +#define WT_STAT_CONN_READ_IO 1156 /*! connection: total write I/Os */ -#define WT_STAT_CONN_WRITE_IO 1156 +#define WT_STAT_CONN_WRITE_IO 1157 /*! cursor: cached cursor count */ -#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1157 +#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1158 /*! cursor: cursor bulk loaded cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT_BULK 1158 +#define WT_STAT_CONN_CURSOR_INSERT_BULK 1159 /*! cursor: cursor close calls that result in cache */ -#define WT_STAT_CONN_CURSOR_CACHE 1159 +#define WT_STAT_CONN_CURSOR_CACHE 1160 /*! cursor: cursor create calls */ -#define WT_STAT_CONN_CURSOR_CREATE 1160 +#define WT_STAT_CONN_CURSOR_CREATE 1161 /*! cursor: cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT 1161 +#define WT_STAT_CONN_CURSOR_INSERT 1162 /*! cursor: cursor insert key and value bytes */ -#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1162 +#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1163 /*! cursor: cursor modify calls */ -#define WT_STAT_CONN_CURSOR_MODIFY 1163 +#define WT_STAT_CONN_CURSOR_MODIFY 1164 /*! cursor: cursor modify key and value bytes affected */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1164 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1165 /*! cursor: cursor modify value bytes modified */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1165 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1166 /*! cursor: cursor next calls */ -#define WT_STAT_CONN_CURSOR_NEXT 1166 +#define WT_STAT_CONN_CURSOR_NEXT 1167 /*! cursor: cursor operation restarted */ -#define WT_STAT_CONN_CURSOR_RESTART 1167 +#define WT_STAT_CONN_CURSOR_RESTART 1168 /*! cursor: cursor prev calls */ -#define WT_STAT_CONN_CURSOR_PREV 1168 +#define WT_STAT_CONN_CURSOR_PREV 1169 /*! cursor: cursor remove calls */ -#define WT_STAT_CONN_CURSOR_REMOVE 1169 +#define WT_STAT_CONN_CURSOR_REMOVE 1170 /*! cursor: cursor remove key bytes removed */ -#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1170 +#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1171 /*! cursor: cursor reserve calls */ -#define WT_STAT_CONN_CURSOR_RESERVE 1171 +#define WT_STAT_CONN_CURSOR_RESERVE 1172 /*! cursor: cursor reset calls */ -#define WT_STAT_CONN_CURSOR_RESET 1172 +#define WT_STAT_CONN_CURSOR_RESET 1173 /*! cursor: cursor search calls */ -#define WT_STAT_CONN_CURSOR_SEARCH 1173 +#define WT_STAT_CONN_CURSOR_SEARCH 1174 /*! cursor: cursor search near calls */ -#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1174 +#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1175 /*! cursor: cursor sweep buckets */ -#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1175 +#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1176 /*! cursor: cursor sweep cursors closed */ -#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1176 +#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1177 /*! cursor: cursor sweep cursors examined */ -#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1177 +#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1178 /*! cursor: cursor sweeps */ -#define WT_STAT_CONN_CURSOR_SWEEP 1178 +#define WT_STAT_CONN_CURSOR_SWEEP 1179 /*! cursor: cursor truncate calls */ -#define WT_STAT_CONN_CURSOR_TRUNCATE 1179 +#define WT_STAT_CONN_CURSOR_TRUNCATE 1180 /*! cursor: cursor update calls */ -#define WT_STAT_CONN_CURSOR_UPDATE 1180 +#define WT_STAT_CONN_CURSOR_UPDATE 1181 /*! cursor: cursor update key and value bytes */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1181 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1182 /*! cursor: cursor update value size change */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1182 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1183 /*! cursor: cursors reused from cache */ -#define WT_STAT_CONN_CURSOR_REOPEN 1183 +#define WT_STAT_CONN_CURSOR_REOPEN 1184 /*! cursor: open cursor count */ -#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1184 +#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1185 /*! data-handle: connection data handle size */ -#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1185 +#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1186 /*! data-handle: connection data handles currently active */ -#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1186 +#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1187 /*! data-handle: connection sweep candidate became referenced */ -#define WT_STAT_CONN_DH_SWEEP_REF 1187 +#define WT_STAT_CONN_DH_SWEEP_REF 1188 /*! data-handle: connection sweep dhandles closed */ -#define WT_STAT_CONN_DH_SWEEP_CLOSE 1188 +#define WT_STAT_CONN_DH_SWEEP_CLOSE 1189 /*! data-handle: connection sweep dhandles removed from hash list */ -#define WT_STAT_CONN_DH_SWEEP_REMOVE 1189 +#define WT_STAT_CONN_DH_SWEEP_REMOVE 1190 /*! data-handle: connection sweep time-of-death sets */ -#define WT_STAT_CONN_DH_SWEEP_TOD 1190 +#define WT_STAT_CONN_DH_SWEEP_TOD 1191 /*! data-handle: connection sweeps */ -#define WT_STAT_CONN_DH_SWEEPS 1191 +#define WT_STAT_CONN_DH_SWEEPS 1192 /*! data-handle: session dhandles swept */ -#define WT_STAT_CONN_DH_SESSION_HANDLES 1192 +#define WT_STAT_CONN_DH_SESSION_HANDLES 1193 /*! data-handle: session sweep attempts */ -#define WT_STAT_CONN_DH_SESSION_SWEEPS 1193 +#define WT_STAT_CONN_DH_SESSION_SWEEPS 1194 /*! lock: checkpoint lock acquisitions */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1194 +#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1195 /*! lock: checkpoint lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1195 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1196 /*! lock: checkpoint lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1196 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1197 /*! * lock: commit timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION 1197 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION 1198 /*! lock: commit timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL 1198 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL 1199 /*! lock: commit timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT 1199 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT 1200 /*! lock: commit timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT 1200 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT 1201 /*! lock: dhandle lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1201 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1202 /*! lock: dhandle lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1202 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1203 /*! lock: dhandle read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1203 +#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1204 /*! lock: dhandle write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1204 +#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1205 /*! lock: metadata lock acquisitions */ -#define WT_STAT_CONN_LOCK_METADATA_COUNT 1205 +#define WT_STAT_CONN_LOCK_METADATA_COUNT 1206 /*! lock: metadata lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1206 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1207 /*! lock: metadata lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1207 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1208 /*! * lock: read timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1208 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1209 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1209 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1210 /*! lock: read timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1210 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1211 /*! lock: read timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1211 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1212 /*! lock: schema lock acquisitions */ -#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1212 +#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1213 /*! lock: schema lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1213 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1214 /*! lock: schema lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1214 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1215 /*! * lock: table lock application thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1215 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1216 /*! * lock: table lock internal thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1216 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1217 /*! lock: table read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1217 +#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1218 /*! lock: table write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1218 +#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1219 /*! lock: txn global lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1219 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1220 /*! lock: txn global lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1220 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1221 /*! lock: txn global read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1221 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1222 /*! lock: txn global write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1222 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1223 /*! log: busy returns attempting to switch slots */ -#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1223 +#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1224 /*! log: force archive time sleeping (usecs) */ -#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1224 +#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1225 /*! log: log bytes of payload data */ -#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1225 +#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1226 /*! log: log bytes written */ -#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1226 +#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1227 /*! log: log files manually zero-filled */ -#define WT_STAT_CONN_LOG_ZERO_FILLS 1227 +#define WT_STAT_CONN_LOG_ZERO_FILLS 1228 /*! log: log flush operations */ -#define WT_STAT_CONN_LOG_FLUSH 1228 +#define WT_STAT_CONN_LOG_FLUSH 1229 /*! log: log force write operations */ -#define WT_STAT_CONN_LOG_FORCE_WRITE 1229 +#define WT_STAT_CONN_LOG_FORCE_WRITE 1230 /*! log: log force write operations skipped */ -#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1230 +#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1231 /*! log: log records compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1231 +#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1232 /*! log: log records not compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1232 +#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1233 /*! log: log records too small to compress */ -#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1233 +#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1234 /*! log: log release advances write LSN */ -#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1234 +#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1235 /*! log: log scan operations */ -#define WT_STAT_CONN_LOG_SCANS 1235 +#define WT_STAT_CONN_LOG_SCANS 1236 /*! log: log scan records requiring two reads */ -#define WT_STAT_CONN_LOG_SCAN_REREADS 1236 +#define WT_STAT_CONN_LOG_SCAN_REREADS 1237 /*! log: log server thread advances write LSN */ -#define WT_STAT_CONN_LOG_WRITE_LSN 1237 +#define WT_STAT_CONN_LOG_WRITE_LSN 1238 /*! log: log server thread write LSN walk skipped */ -#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1238 +#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1239 /*! log: log sync operations */ -#define WT_STAT_CONN_LOG_SYNC 1239 +#define WT_STAT_CONN_LOG_SYNC 1240 /*! log: log sync time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DURATION 1240 +#define WT_STAT_CONN_LOG_SYNC_DURATION 1241 /*! log: log sync_dir operations */ -#define WT_STAT_CONN_LOG_SYNC_DIR 1241 +#define WT_STAT_CONN_LOG_SYNC_DIR 1242 /*! log: log sync_dir time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1242 +#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1243 /*! log: log write operations */ -#define WT_STAT_CONN_LOG_WRITES 1243 +#define WT_STAT_CONN_LOG_WRITES 1244 /*! log: logging bytes consolidated */ -#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1244 +#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1245 /*! log: maximum log file size */ -#define WT_STAT_CONN_LOG_MAX_FILESIZE 1245 +#define WT_STAT_CONN_LOG_MAX_FILESIZE 1246 /*! log: number of pre-allocated log files to create */ -#define WT_STAT_CONN_LOG_PREALLOC_MAX 1246 +#define WT_STAT_CONN_LOG_PREALLOC_MAX 1247 /*! log: pre-allocated log files not ready and missed */ -#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1247 +#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1248 /*! log: pre-allocated log files prepared */ -#define WT_STAT_CONN_LOG_PREALLOC_FILES 1248 +#define WT_STAT_CONN_LOG_PREALLOC_FILES 1249 /*! log: pre-allocated log files used */ -#define WT_STAT_CONN_LOG_PREALLOC_USED 1249 +#define WT_STAT_CONN_LOG_PREALLOC_USED 1250 /*! log: records processed by log scan */ -#define WT_STAT_CONN_LOG_SCAN_RECORDS 1250 +#define WT_STAT_CONN_LOG_SCAN_RECORDS 1251 /*! log: slot close lost race */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1251 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1252 /*! log: slot close unbuffered waits */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1252 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1253 /*! log: slot closures */ -#define WT_STAT_CONN_LOG_SLOT_CLOSES 1253 +#define WT_STAT_CONN_LOG_SLOT_CLOSES 1254 /*! log: slot join atomic update races */ -#define WT_STAT_CONN_LOG_SLOT_RACES 1254 +#define WT_STAT_CONN_LOG_SLOT_RACES 1255 /*! log: slot join calls atomic updates raced */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1255 +#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1256 /*! log: slot join calls did not yield */ -#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1256 +#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1257 /*! log: slot join calls found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1257 +#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1258 /*! log: slot join calls slept */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1258 +#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1259 /*! log: slot join calls yielded */ -#define WT_STAT_CONN_LOG_SLOT_YIELD 1259 +#define WT_STAT_CONN_LOG_SLOT_YIELD 1260 /*! log: slot join found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1260 +#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1261 /*! log: slot joins yield time (usecs) */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1261 +#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1262 /*! log: slot transitions unable to find free slot */ -#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1262 +#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1263 /*! log: slot unbuffered writes */ -#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1263 +#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1264 /*! log: total in-memory size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_MEM 1264 +#define WT_STAT_CONN_LOG_COMPRESS_MEM 1265 /*! log: total log buffer size */ -#define WT_STAT_CONN_LOG_BUFFER_SIZE 1265 +#define WT_STAT_CONN_LOG_BUFFER_SIZE 1266 /*! log: total size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_LEN 1266 +#define WT_STAT_CONN_LOG_COMPRESS_LEN 1267 /*! log: written slots coalesced */ -#define WT_STAT_CONN_LOG_SLOT_COALESCED 1267 +#define WT_STAT_CONN_LOG_SLOT_COALESCED 1268 /*! log: yields waiting for previous log file close */ -#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1268 +#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1269 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1269 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1270 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1270 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1271 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1271 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1272 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1272 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1273 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1273 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1274 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1274 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1275 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1275 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1276 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1276 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1277 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1277 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1278 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1278 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1279 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1279 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1280 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1280 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1281 /*! perf: operation read latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1281 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1282 /*! perf: operation read latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1282 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1283 /*! perf: operation read latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1283 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1284 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1284 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1285 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1285 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1286 /*! perf: operation write latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1286 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1287 /*! perf: operation write latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1287 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1288 /*! perf: operation write latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1288 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1289 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1289 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1290 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1290 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1291 /*! reconciliation: fast-path pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1291 +#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1292 /*! reconciliation: page reconciliation calls */ -#define WT_STAT_CONN_REC_PAGES 1292 +#define WT_STAT_CONN_REC_PAGES 1293 /*! reconciliation: page reconciliation calls for eviction */ -#define WT_STAT_CONN_REC_PAGES_EVICTION 1293 +#define WT_STAT_CONN_REC_PAGES_EVICTION 1294 /*! reconciliation: pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE 1294 +#define WT_STAT_CONN_REC_PAGE_DELETE 1295 /*! reconciliation: split bytes currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1295 +#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1296 /*! reconciliation: split objects currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1296 +#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1297 /*! session: open session count */ -#define WT_STAT_CONN_SESSION_OPEN 1297 +#define WT_STAT_CONN_SESSION_OPEN 1298 /*! session: session query timestamp calls */ -#define WT_STAT_CONN_SESSION_QUERY_TS 1298 +#define WT_STAT_CONN_SESSION_QUERY_TS 1299 /*! session: table alter failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1299 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1300 /*! session: table alter successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1300 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1301 /*! session: table alter unchanged and skipped */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1301 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1302 /*! session: table compact failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1302 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1303 /*! session: table compact successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1303 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1304 /*! session: table create failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1304 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1305 /*! session: table create successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1305 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1306 /*! session: table drop failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1306 +#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1307 /*! session: table drop successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1307 +#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1308 /*! session: table rebalance failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1308 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1309 /*! session: table rebalance successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1309 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1310 /*! session: table rename failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1310 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1311 /*! session: table rename successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1311 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1312 /*! session: table salvage failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1312 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1313 /*! session: table salvage successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1313 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1314 /*! session: table truncate failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1314 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1315 /*! session: table truncate successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1315 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1316 /*! session: table verify failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1316 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1317 /*! session: table verify successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1317 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1318 /*! thread-state: active filesystem fsync calls */ -#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1318 +#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1319 /*! thread-state: active filesystem read calls */ -#define WT_STAT_CONN_THREAD_READ_ACTIVE 1319 +#define WT_STAT_CONN_THREAD_READ_ACTIVE 1320 /*! thread-state: active filesystem write calls */ -#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1320 +#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1321 /*! thread-yield: application thread time evicting (usecs) */ -#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1321 +#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1322 /*! thread-yield: application thread time waiting for cache (usecs) */ -#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1322 +#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1323 /*! * thread-yield: connection close blocked waiting for transaction state * stabilization */ -#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1323 +#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1324 /*! thread-yield: connection close yielded for lsm manager shutdown */ -#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1324 +#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1325 /*! thread-yield: data handle lock yielded */ -#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1325 +#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1326 /*! * thread-yield: get reference for page index and slot time sleeping * (usecs) */ -#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1326 +#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1327 /*! thread-yield: log server sync yielded for log write */ -#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1327 +#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1328 /*! thread-yield: page access yielded due to prepare state change */ -#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1328 +#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1329 /*! thread-yield: page acquire busy blocked */ -#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1329 +#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1330 /*! thread-yield: page acquire eviction blocked */ -#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1330 +#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1331 /*! thread-yield: page acquire locked blocked */ -#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1331 +#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1332 /*! thread-yield: page acquire read blocked */ -#define WT_STAT_CONN_PAGE_READ_BLOCKED 1332 +#define WT_STAT_CONN_PAGE_READ_BLOCKED 1333 /*! thread-yield: page acquire time sleeping (usecs) */ -#define WT_STAT_CONN_PAGE_SLEEP 1333 +#define WT_STAT_CONN_PAGE_SLEEP 1334 /*! * thread-yield: page delete rollback time sleeping for state change * (usecs) */ -#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1334 +#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1335 /*! thread-yield: page reconciliation yielded due to child modification */ -#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1335 +#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1336 /*! transaction: Number of prepared updates */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1336 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1337 /*! transaction: Number of prepared updates added to cache overflow */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_LOOKASIDE_INSERTS 1337 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_LOOKASIDE_INSERTS 1338 /*! transaction: Number of prepared updates resolved */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_RESOLVED 1338 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_RESOLVED 1339 /*! transaction: commit timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED 1339 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED 1340 /*! transaction: commit timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY 1340 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY 1341 /*! transaction: commit timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD 1341 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD 1342 /*! transaction: commit timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS 1342 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS 1343 /*! transaction: commit timestamp queue length */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN 1343 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN 1344 /*! transaction: number of named snapshots created */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1344 +#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1345 /*! transaction: number of named snapshots dropped */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1345 +#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1346 /*! transaction: prepared transactions */ -#define WT_STAT_CONN_TXN_PREPARE 1346 +#define WT_STAT_CONN_TXN_PREPARE 1347 /*! transaction: prepared transactions committed */ -#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1347 +#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1348 /*! transaction: prepared transactions currently active */ -#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1348 +#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1349 /*! transaction: prepared transactions rolled back */ -#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1349 +#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1350 /*! transaction: query timestamp calls */ -#define WT_STAT_CONN_TXN_QUERY_TS 1350 +#define WT_STAT_CONN_TXN_QUERY_TS 1351 /*! transaction: read timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1351 +#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1352 /*! transaction: read timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1352 +#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1353 /*! transaction: read timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1353 +#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1354 /*! transaction: read timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1354 +#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1355 /*! transaction: read timestamp queue length */ -#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1355 +#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1356 /*! transaction: rollback to stable calls */ -#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1356 +#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1357 /*! transaction: rollback to stable updates aborted */ -#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1357 +#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1358 /*! transaction: rollback to stable updates removed from cache overflow */ -#define WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED 1358 +#define WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED 1359 /*! transaction: set timestamp calls */ -#define WT_STAT_CONN_TXN_SET_TS 1359 +#define WT_STAT_CONN_TXN_SET_TS 1360 /*! transaction: set timestamp commit calls */ -#define WT_STAT_CONN_TXN_SET_TS_COMMIT 1360 +#define WT_STAT_CONN_TXN_SET_TS_COMMIT 1361 /*! transaction: set timestamp commit updates */ -#define WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD 1361 +#define WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD 1362 /*! transaction: set timestamp oldest calls */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1362 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1363 /*! transaction: set timestamp oldest updates */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1363 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1364 /*! transaction: set timestamp stable calls */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE 1364 +#define WT_STAT_CONN_TXN_SET_TS_STABLE 1365 /*! transaction: set timestamp stable updates */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1365 +#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1366 /*! transaction: transaction begins */ -#define WT_STAT_CONN_TXN_BEGIN 1366 +#define WT_STAT_CONN_TXN_BEGIN 1367 /*! transaction: transaction checkpoint currently running */ -#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1367 +#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1368 /*! transaction: transaction checkpoint generation */ -#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1368 +#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1369 /*! transaction: transaction checkpoint max time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1369 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1370 /*! transaction: transaction checkpoint min time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1370 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1371 /*! transaction: transaction checkpoint most recent time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1371 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1372 /*! transaction: transaction checkpoint scrub dirty target */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1372 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1373 /*! transaction: transaction checkpoint scrub time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1373 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1374 /*! transaction: transaction checkpoint total time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1374 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1375 /*! transaction: transaction checkpoints */ -#define WT_STAT_CONN_TXN_CHECKPOINT 1375 +#define WT_STAT_CONN_TXN_CHECKPOINT 1376 /*! * transaction: transaction checkpoints skipped because database was * clean */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1376 +#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1377 /*! transaction: transaction failures due to cache overflow */ -#define WT_STAT_CONN_TXN_FAIL_CACHE 1377 +#define WT_STAT_CONN_TXN_FAIL_CACHE 1378 /*! * transaction: transaction fsync calls for checkpoint after allocating * the transaction ID */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1378 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1379 /*! * transaction: transaction fsync duration for checkpoint after * allocating the transaction ID (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1379 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1380 /*! transaction: transaction range of IDs currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_RANGE 1380 +#define WT_STAT_CONN_TXN_PINNED_RANGE 1381 /*! transaction: transaction range of IDs currently pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1381 +#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1382 /*! * transaction: transaction range of IDs currently pinned by named * snapshots */ -#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1382 +#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1383 /*! transaction: transaction range of timestamps currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1383 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1384 /*! transaction: transaction range of timestamps pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1384 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1385 /*! * transaction: transaction range of timestamps pinned by the oldest * active read timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1385 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1386 /*! * transaction: transaction range of timestamps pinned by the oldest * timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1386 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1387 /*! transaction: transaction read timestamp of the oldest active reader */ -#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1387 +#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1388 /*! transaction: transaction sync calls */ -#define WT_STAT_CONN_TXN_SYNC 1388 +#define WT_STAT_CONN_TXN_SYNC 1389 /*! transaction: transactions committed */ -#define WT_STAT_CONN_TXN_COMMIT 1389 +#define WT_STAT_CONN_TXN_COMMIT 1390 /*! transaction: transactions rolled back */ -#define WT_STAT_CONN_TXN_ROLLBACK 1390 +#define WT_STAT_CONN_TXN_ROLLBACK 1391 /*! transaction: update conflicts */ -#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1391 +#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1392 /*! * @} @@ -6142,95 +6207,105 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); * cache_walk or all statistics are enabled */ #define WT_STAT_DSRC_CACHE_STATE_PAGES 2100 +/*! + * compression: compressed page maximum internal page size prior to + * compression + */ +#define WT_STAT_DSRC_COMPRESS_PRECOMP_INTL_MAX_PAGE_SIZE 2101 +/*! + * compression: compressed page maximum leaf page size prior to + * compression + */ +#define WT_STAT_DSRC_COMPRESS_PRECOMP_LEAF_MAX_PAGE_SIZE 2102 /*! compression: compressed pages read */ -#define WT_STAT_DSRC_COMPRESS_READ 2101 +#define WT_STAT_DSRC_COMPRESS_READ 2103 /*! compression: compressed pages written */ -#define WT_STAT_DSRC_COMPRESS_WRITE 2102 +#define WT_STAT_DSRC_COMPRESS_WRITE 2104 /*! compression: page written failed to compress */ -#define WT_STAT_DSRC_COMPRESS_WRITE_FAIL 2103 +#define WT_STAT_DSRC_COMPRESS_WRITE_FAIL 2105 /*! compression: page written was too small to compress */ -#define WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL 2104 +#define WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL 2106 /*! cursor: bulk loaded cursor insert calls */ -#define WT_STAT_DSRC_CURSOR_INSERT_BULK 2105 +#define WT_STAT_DSRC_CURSOR_INSERT_BULK 2107 /*! cursor: cache cursors reuse count */ -#define WT_STAT_DSRC_CURSOR_REOPEN 2106 +#define WT_STAT_DSRC_CURSOR_REOPEN 2108 /*! cursor: close calls that result in cache */ -#define WT_STAT_DSRC_CURSOR_CACHE 2107 +#define WT_STAT_DSRC_CURSOR_CACHE 2109 /*! cursor: create calls */ -#define WT_STAT_DSRC_CURSOR_CREATE 2108 +#define WT_STAT_DSRC_CURSOR_CREATE 2110 /*! cursor: insert calls */ -#define WT_STAT_DSRC_CURSOR_INSERT 2109 +#define WT_STAT_DSRC_CURSOR_INSERT 2111 /*! cursor: insert key and value bytes */ -#define WT_STAT_DSRC_CURSOR_INSERT_BYTES 2110 +#define WT_STAT_DSRC_CURSOR_INSERT_BYTES 2112 /*! cursor: modify */ -#define WT_STAT_DSRC_CURSOR_MODIFY 2111 +#define WT_STAT_DSRC_CURSOR_MODIFY 2113 /*! cursor: modify key and value bytes affected */ -#define WT_STAT_DSRC_CURSOR_MODIFY_BYTES 2112 +#define WT_STAT_DSRC_CURSOR_MODIFY_BYTES 2114 /*! cursor: modify value bytes modified */ -#define WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH 2113 +#define WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH 2115 /*! cursor: next calls */ -#define WT_STAT_DSRC_CURSOR_NEXT 2114 +#define WT_STAT_DSRC_CURSOR_NEXT 2116 /*! cursor: open cursor count */ -#define WT_STAT_DSRC_CURSOR_OPEN_COUNT 2115 +#define WT_STAT_DSRC_CURSOR_OPEN_COUNT 2117 /*! cursor: operation restarted */ -#define WT_STAT_DSRC_CURSOR_RESTART 2116 +#define WT_STAT_DSRC_CURSOR_RESTART 2118 /*! cursor: prev calls */ -#define WT_STAT_DSRC_CURSOR_PREV 2117 +#define WT_STAT_DSRC_CURSOR_PREV 2119 /*! cursor: remove calls */ -#define WT_STAT_DSRC_CURSOR_REMOVE 2118 +#define WT_STAT_DSRC_CURSOR_REMOVE 2120 /*! cursor: remove key bytes removed */ -#define WT_STAT_DSRC_CURSOR_REMOVE_BYTES 2119 +#define WT_STAT_DSRC_CURSOR_REMOVE_BYTES 2121 /*! cursor: reserve calls */ -#define WT_STAT_DSRC_CURSOR_RESERVE 2120 +#define WT_STAT_DSRC_CURSOR_RESERVE 2122 /*! cursor: reset calls */ -#define WT_STAT_DSRC_CURSOR_RESET 2121 +#define WT_STAT_DSRC_CURSOR_RESET 2123 /*! cursor: search calls */ -#define WT_STAT_DSRC_CURSOR_SEARCH 2122 +#define WT_STAT_DSRC_CURSOR_SEARCH 2124 /*! cursor: search near calls */ -#define WT_STAT_DSRC_CURSOR_SEARCH_NEAR 2123 +#define WT_STAT_DSRC_CURSOR_SEARCH_NEAR 2125 /*! cursor: truncate calls */ -#define WT_STAT_DSRC_CURSOR_TRUNCATE 2124 +#define WT_STAT_DSRC_CURSOR_TRUNCATE 2126 /*! cursor: update calls */ -#define WT_STAT_DSRC_CURSOR_UPDATE 2125 +#define WT_STAT_DSRC_CURSOR_UPDATE 2127 /*! cursor: update key and value bytes */ -#define WT_STAT_DSRC_CURSOR_UPDATE_BYTES 2126 +#define WT_STAT_DSRC_CURSOR_UPDATE_BYTES 2128 /*! cursor: update value size change */ -#define WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED 2127 +#define WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED 2129 /*! reconciliation: dictionary matches */ -#define WT_STAT_DSRC_REC_DICTIONARY 2128 +#define WT_STAT_DSRC_REC_DICTIONARY 2130 /*! reconciliation: fast-path pages deleted */ -#define WT_STAT_DSRC_REC_PAGE_DELETE_FAST 2129 +#define WT_STAT_DSRC_REC_PAGE_DELETE_FAST 2131 /*! * reconciliation: internal page key bytes discarded using suffix * compression */ -#define WT_STAT_DSRC_REC_SUFFIX_COMPRESSION 2130 +#define WT_STAT_DSRC_REC_SUFFIX_COMPRESSION 2132 /*! reconciliation: internal page multi-block writes */ -#define WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL 2131 +#define WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL 2133 /*! reconciliation: internal-page overflow keys */ -#define WT_STAT_DSRC_REC_OVERFLOW_KEY_INTERNAL 2132 +#define WT_STAT_DSRC_REC_OVERFLOW_KEY_INTERNAL 2134 /*! reconciliation: leaf page key bytes discarded using prefix compression */ -#define WT_STAT_DSRC_REC_PREFIX_COMPRESSION 2133 +#define WT_STAT_DSRC_REC_PREFIX_COMPRESSION 2135 /*! reconciliation: leaf page multi-block writes */ -#define WT_STAT_DSRC_REC_MULTIBLOCK_LEAF 2134 +#define WT_STAT_DSRC_REC_MULTIBLOCK_LEAF 2136 /*! reconciliation: leaf-page overflow keys */ -#define WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF 2135 +#define WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF 2137 /*! reconciliation: maximum blocks required for a page */ -#define WT_STAT_DSRC_REC_MULTIBLOCK_MAX 2136 +#define WT_STAT_DSRC_REC_MULTIBLOCK_MAX 2138 /*! reconciliation: overflow values written */ -#define WT_STAT_DSRC_REC_OVERFLOW_VALUE 2137 +#define WT_STAT_DSRC_REC_OVERFLOW_VALUE 2139 /*! reconciliation: page checksum matches */ -#define WT_STAT_DSRC_REC_PAGE_MATCH 2138 +#define WT_STAT_DSRC_REC_PAGE_MATCH 2140 /*! reconciliation: page reconciliation calls */ -#define WT_STAT_DSRC_REC_PAGES 2139 +#define WT_STAT_DSRC_REC_PAGES 2141 /*! reconciliation: page reconciliation calls for eviction */ -#define WT_STAT_DSRC_REC_PAGES_EVICTION 2140 +#define WT_STAT_DSRC_REC_PAGES_EVICTION 2142 /*! reconciliation: pages deleted */ -#define WT_STAT_DSRC_REC_PAGE_DELETE 2141 +#define WT_STAT_DSRC_REC_PAGE_DELETE 2143 /*! session: object compaction */ -#define WT_STAT_DSRC_SESSION_COMPACT 2142 +#define WT_STAT_DSRC_SESSION_COMPACT 2144 /*! transaction: update conflicts */ -#define WT_STAT_DSRC_TXN_UPDATE_CONFLICT 2143 +#define WT_STAT_DSRC_TXN_UPDATE_CONFLICT 2145 /*! * @} @@ -6272,7 +6347,7 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); /*! @} */ /* * Statistics section: END - * DO NOT EDIT: automatically built by dist/api_stat.py. + * DO NOT EDIT: automatically built by dist/stat.py. */ /*! @} */ diff --git a/src/third_party/wiredtiger/src/log/log.c b/src/third_party/wiredtiger/src/log/log.c index 90d269c3b3e..a035a97748b 100644 --- a/src/third_party/wiredtiger/src/log/log.c +++ b/src/third_party/wiredtiger/src/log/log.c @@ -236,16 +236,26 @@ __log_fs_write(WT_SESSION_IMPL *session, * thread as needed. */ void -__wt_log_ckpt(WT_SESSION_IMPL *session, WT_LSN *ckp_lsn) +__wt_log_ckpt(WT_SESSION_IMPL *session, WT_LSN *ckpt_lsn) { WT_CONNECTION_IMPL *conn; WT_LOG *log; + int i; conn = S2C(session); log = conn->log; - log->ckpt_lsn = *ckp_lsn; + log->ckpt_lsn = *ckpt_lsn; if (conn->log_cond != NULL) __wt_cond_signal(session, conn->log_cond); + /* + * If we are storing debugging LSNs to retain additional log files + * from archiving, then rotate the newest LSN into the array. + */ + if (conn->debug_ckpt_cnt != 0) { + for (i = (int)conn->debug_ckpt_cnt - 1; i > 0; --i) + conn->debug_ckpt[i] = conn->debug_ckpt[i - 1]; + conn->debug_ckpt[0] = *ckpt_lsn; + } } /* diff --git a/src/third_party/wiredtiger/src/log/log_auto.c b/src/third_party/wiredtiger/src/log/log_auto.c index f6d7afed0c2..d7f59fd920e 100644 --- a/src/third_party/wiredtiger/src/log/log_auto.c +++ b/src/third_party/wiredtiger/src/log/log_auto.c @@ -149,7 +149,7 @@ __wt_logop_col_modify_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"col_modify\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__wt_fprintf(session, args->fs, " \"recno\": %" PRIu64 ",\n", recno)); WT_ERR(__logrec_make_json_str(session, &escaped, &value)); @@ -224,7 +224,7 @@ __wt_logop_col_put_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"col_put\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__wt_fprintf(session, args->fs, " \"recno\": %" PRIu64 ",\n", recno)); WT_ERR(__logrec_make_json_str(session, &escaped, &value)); @@ -295,7 +295,7 @@ __wt_logop_col_remove_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"col_remove\",\n")); WT_RET(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_RET(__wt_fprintf(session, args->fs, " \"recno\": %" PRIu64 "", recno)); return (0); @@ -357,7 +357,7 @@ __wt_logop_col_truncate_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"col_truncate\",\n")); WT_RET(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_RET(__wt_fprintf(session, args->fs, " \"start\": %" PRIu64 ",\n", start)); WT_RET(__wt_fprintf(session, args->fs, @@ -424,7 +424,7 @@ __wt_logop_row_modify_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"row_modify\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__logrec_make_json_str(session, &escaped, &key)); WT_ERR(__wt_fprintf(session, args->fs, " \"key\": \"%s\",\n", escaped)); @@ -505,7 +505,7 @@ __wt_logop_row_put_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"row_put\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__logrec_make_json_str(session, &escaped, &key)); WT_ERR(__wt_fprintf(session, args->fs, " \"key\": \"%s\",\n", escaped)); @@ -585,7 +585,7 @@ __wt_logop_row_remove_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"row_remove\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__logrec_make_json_str(session, &escaped, &key)); WT_ERR(__wt_fprintf(session, args->fs, " \"key\": \"%s\"", escaped)); @@ -659,7 +659,7 @@ __wt_logop_row_truncate_print(WT_SESSION_IMPL *session, WT_RET(__wt_fprintf(session, args->fs, " \"optype\": \"row_truncate\",\n")); WT_ERR(__wt_fprintf(session, args->fs, - " \"fileid\": %" PRIu32 ",\n", fileid)); + " \"fileid\": %" PRIu32 " 0x%" PRIx32 ",\n", fileid, fileid)); WT_ERR(__logrec_make_json_str(session, &escaped, &start)); WT_ERR(__wt_fprintf(session, args->fs, " \"start\": \"%s\",\n", escaped)); @@ -798,6 +798,82 @@ __wt_logop_prev_lsn_print(WT_SESSION_IMPL *session, } int +__wt_logop_txn_timestamp_pack( + WT_SESSION_IMPL *session, WT_ITEM *logrec, + uint64_t time_sec, uint64_t time_nsec, uint64_t commit_ts, uint64_t durable_ts, uint64_t first_ts, uint64_t prepare_ts, uint64_t read_ts) +{ + const char *fmt = WT_UNCHECKED_STRING(IIQQQQQQQ); + size_t size; + uint32_t optype, recsize; + + optype = WT_LOGOP_TXN_TIMESTAMP; + WT_RET(__wt_struct_size(session, &size, fmt, + optype, 0, time_sec, time_nsec, commit_ts, durable_ts, first_ts, prepare_ts, read_ts)); + + __wt_struct_size_adjust(session, &size); + WT_RET(__wt_buf_extend(session, logrec, logrec->size + size)); + recsize = (uint32_t)size; + WT_RET(__wt_struct_pack(session, + (uint8_t *)logrec->data + logrec->size, size, fmt, + optype, recsize, time_sec, time_nsec, commit_ts, durable_ts, first_ts, prepare_ts, read_ts)); + + logrec->size += (uint32_t)size; + return (0); +} + +int +__wt_logop_txn_timestamp_unpack( + WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, + uint64_t *time_secp, uint64_t *time_nsecp, uint64_t *commit_tsp, uint64_t *durable_tsp, uint64_t *first_tsp, uint64_t *prepare_tsp, uint64_t *read_tsp) +{ + WT_DECL_RET; + const char *fmt = WT_UNCHECKED_STRING(IIQQQQQQQ); + uint32_t optype, size; + + if ((ret = __wt_struct_unpack(session, *pp, WT_PTRDIFF(end, *pp), fmt, + &optype, &size, time_secp, time_nsecp, commit_tsp, durable_tsp, first_tsp, prepare_tsp, read_tsp)) != 0) + WT_RET_MSG(session, ret, "logop_txn_timestamp: unpack failure"); + WT_ASSERT(session, optype == WT_LOGOP_TXN_TIMESTAMP); + + *pp += size; + return (0); +} + +int +__wt_logop_txn_timestamp_print(WT_SESSION_IMPL *session, + const uint8_t **pp, const uint8_t *end, WT_TXN_PRINTLOG_ARGS *args) +{ + uint64_t time_sec; + uint64_t time_nsec; + uint64_t commit_ts; + uint64_t durable_ts; + uint64_t first_ts; + uint64_t prepare_ts; + uint64_t read_ts; + + WT_RET(__wt_logop_txn_timestamp_unpack( + session, pp, end, &time_sec, &time_nsec, &commit_ts, &durable_ts, &first_ts, &prepare_ts, &read_ts)); + + WT_RET(__wt_fprintf(session, args->fs, + " \"optype\": \"txn_timestamp\",\n")); + WT_RET(__wt_fprintf(session, args->fs, + " \"time_sec\": %" PRIu64 ",\n", time_sec)); + WT_RET(__wt_fprintf(session, args->fs, + " \"time_nsec\": %" PRIu64 ",\n", time_nsec)); + WT_RET(__wt_fprintf(session, args->fs, + " \"commit_ts\": %" PRIu64 ",\n", commit_ts)); + WT_RET(__wt_fprintf(session, args->fs, + " \"durable_ts\": %" PRIu64 ",\n", durable_ts)); + WT_RET(__wt_fprintf(session, args->fs, + " \"first_ts\": %" PRIu64 ",\n", first_ts)); + WT_RET(__wt_fprintf(session, args->fs, + " \"prepare_ts\": %" PRIu64 ",\n", prepare_ts)); + WT_RET(__wt_fprintf(session, args->fs, + " \"read_ts\": %" PRIu64 "", read_ts)); + return (0); +} + +int __wt_txn_op_printlog(WT_SESSION_IMPL *session, const uint8_t **pp, const uint8_t *end, WT_TXN_PRINTLOG_ARGS *args) { @@ -848,6 +924,10 @@ __wt_txn_op_printlog(WT_SESSION_IMPL *session, WT_RET(__wt_logop_prev_lsn_print(session, pp, end, args)); break; + case WT_LOGOP_TXN_TIMESTAMP: + WT_RET(__wt_logop_txn_timestamp_print(session, pp, end, args)); + break; + WT_ILLEGAL_VALUE(session, optype); } diff --git a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c index fe7b3b8c3bb..2766e74f92c 100644 --- a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c +++ b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c @@ -253,6 +253,9 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, */ if (upd_select->upd == NULL) upd_select->upd = upd; + + if (!F_ISSET(r, WT_REC_EVICT)) + break; } /* Keep track of the selected update. */ diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c index db70264046d..32241675a9e 100644 --- a/src/third_party/wiredtiger/src/support/stat.c +++ b/src/third_party/wiredtiger/src/support/stat.c @@ -104,6 +104,8 @@ static const char * const __stats_dsrc_desc[] = { "cache_walk: Refs skipped during cache traversal", "cache_walk: Size of the root page", "cache_walk: Total number of pages currently in cache", + "compression: compressed page maximum internal page size prior to compression", + "compression: compressed page maximum leaf page size prior to compression ", "compression: compressed pages read", "compression: compressed pages written", "compression: page written failed to compress", @@ -290,6 +292,8 @@ __wt_stat_dsrc_clear_single(WT_DSRC_STATS *stats) /* not clearing cache_state_refs_skipped */ /* not clearing cache_state_root_size */ /* not clearing cache_state_pages */ + /* not clearing compress_precomp_intl_max_page_size */ + /* not clearing compress_precomp_leaf_max_page_size */ stats->compress_read = 0; stats->compress_write = 0; stats->compress_write_fail = 0; @@ -477,6 +481,10 @@ __wt_stat_dsrc_aggregate_single( to->cache_state_refs_skipped += from->cache_state_refs_skipped; to->cache_state_root_size += from->cache_state_root_size; to->cache_state_pages += from->cache_state_pages; + to->compress_precomp_intl_max_page_size += + from->compress_precomp_intl_max_page_size; + to->compress_precomp_leaf_max_page_size += + from->compress_precomp_leaf_max_page_size; to->compress_read += from->compress_read; to->compress_write += from->compress_write; to->compress_write_fail += from->compress_write_fail; @@ -697,6 +705,10 @@ __wt_stat_dsrc_aggregate( to->cache_state_root_size += WT_STAT_READ(from, cache_state_root_size); to->cache_state_pages += WT_STAT_READ(from, cache_state_pages); + to->compress_precomp_intl_max_page_size += + WT_STAT_READ(from, compress_precomp_intl_max_page_size); + to->compress_precomp_leaf_max_page_size += + WT_STAT_READ(from, compress_precomp_leaf_max_page_size); to->compress_read += WT_STAT_READ(from, compress_read); to->compress_write += WT_STAT_READ(from, compress_write); to->compress_write_fail += WT_STAT_READ(from, compress_write_fail); @@ -800,6 +812,7 @@ static const char * const __stats_connection_desc[] = { "cache: cache overflow score", "cache: cache overflow table entries", "cache: cache overflow table insert calls", + "cache: cache overflow table max on-disk size", "cache: cache overflow table on-disk size", "cache: cache overflow table remove calls", "cache: checkpoint blocked page eviction", @@ -1234,6 +1247,7 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) /* not clearing cache_lookaside_score */ /* not clearing cache_lookaside_entries */ stats->cache_lookaside_insert = 0; + /* not clearing cache_lookaside_ondisk_max */ /* not clearing cache_lookaside_ondisk */ stats->cache_lookaside_remove = 0; stats->cache_eviction_checkpoint = 0; @@ -1657,6 +1671,8 @@ __wt_stat_connection_aggregate( WT_STAT_READ(from, cache_lookaside_entries); to->cache_lookaside_insert += WT_STAT_READ(from, cache_lookaside_insert); + to->cache_lookaside_ondisk_max += + WT_STAT_READ(from, cache_lookaside_ondisk_max); to->cache_lookaside_ondisk += WT_STAT_READ(from, cache_lookaside_ondisk); to->cache_lookaside_remove += diff --git a/src/third_party/wiredtiger/src/txn/txn.c b/src/third_party/wiredtiger/src/txn/txn.c index c76966da6ee..4056d33a2b7 100644 --- a/src/third_party/wiredtiger/src/txn/txn.c +++ b/src/third_party/wiredtiger/src/txn/txn.c @@ -529,7 +529,8 @@ __wt_txn_config(WT_SESSION_IMPL *session, const char *cfg[]) /* Check if prepared updates should be ignored during reads. */ WT_RET(__wt_config_gets_def(session, cfg, "ignore_prepare", 0, &cval)); - if (cval.val) + if (cval.val || + (cval.len > 0 && WT_STRING_MATCH("force", cval.str, cval.len))) F_SET(txn, WT_TXN_IGNORE_PREPARE); /* @@ -1079,8 +1080,12 @@ __wt_txn_prepare(WT_SESSION_IMPL *session, const char *cfg[]) WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING)); WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) || txn->mod_count == 0); - /* Transaction should not have updated any of the logged tables. */ - WT_ASSERT(session, txn->logrec == NULL); + /* + * A transaction should not have updated any of the logged tables, + * if debug mode logging is not turned on. + */ + if (!FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_DEBUG_MODE)) + WT_ASSERT(session, txn->logrec == NULL); /* Set the prepare timestamp. */ WT_RET(__wt_txn_set_timestamp(session, cfg)); diff --git a/src/third_party/wiredtiger/src/txn/txn_log.c b/src/third_party/wiredtiger/src/txn/txn_log.c index f55715eb91b..6398cea7e4e 100644 --- a/src/third_party/wiredtiger/src/txn/txn_log.c +++ b/src/third_party/wiredtiger/src/txn/txn_log.c @@ -59,19 +59,15 @@ __txn_op_log_row_key_check(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) * Log an operation for the current transaction. */ static int -__txn_op_log(WT_SESSION_IMPL *session, - WT_ITEM *logrec, WT_TXN_OP *op, WT_CURSOR_BTREE *cbt) +__txn_op_log(WT_SESSION_IMPL *session, WT_ITEM *logrec, + WT_TXN_OP *op, WT_CURSOR_BTREE *cbt, uint32_t fileid) { WT_CURSOR *cursor; WT_ITEM value; WT_UPDATE *upd; uint64_t recno; - uint32_t fileid; cursor = &cbt->iface; - - fileid = op->btree->id; - upd = op->u.op_upd; value.data = upd->data; value.size = upd->size; @@ -210,7 +206,16 @@ __txn_logrec_init(WT_SESSION_IMPL *session) if (txn->logrec != NULL) return (0); - WT_ASSERT(session, txn->id != WT_TXN_NONE); + /* + * The only way we should ever get in here without a txn id is if we + * are recording diagnostic information. In that case, allocate an id. + */ + if (FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_DEBUG_MODE) && + txn->id == WT_TXN_NONE) + WT_RET(__wt_txn_id_check(session)); + else + WT_ASSERT(session, txn->id != WT_TXN_NONE); + WT_RET(__wt_struct_size(session, &header_size, fmt, rectype, txn->id)); WT_RET(__wt_logrec_alloc(session, header_size, &logrec)); @@ -233,6 +238,7 @@ err: __wt_logrec_free(session, &logrec); int __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) { + WT_CONNECTION_IMPL *conn; WT_DECL_RET; WT_ITEM *logrec; WT_TXN *txn; @@ -240,11 +246,13 @@ __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) uint32_t fileid; + conn = S2C(session); txn = &session->txn; - if (!FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_ENABLED) || + if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) || F_ISSET(session, WT_SESSION_NO_LOGGING) || - F_ISSET(S2BT(session), WT_BTREE_NO_LOGGING)) + (F_ISSET(S2BT(session), WT_BTREE_NO_LOGGING) && + !FLD_ISSET(conn->log_flags, WT_CONN_LOG_DEBUG_MODE))) return (0); /* We'd better have a transaction. */ @@ -255,6 +263,14 @@ __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) op = txn->mod + txn->mod_count - 1; fileid = op->btree->id; + /* + * If this operation is diagnostic only, set the ignore bit on the + * fileid so that recovery can skip it. + */ + if (F_ISSET(S2BT(session), WT_BTREE_NO_LOGGING) && + FLD_ISSET(conn->log_flags, WT_CONN_LOG_DEBUG_MODE)) + FLD_SET(fileid, WT_LOGOP_IGNORE); + WT_RET(__txn_logrec_init(session)); logrec = txn->logrec; @@ -267,7 +283,7 @@ __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt) break; case WT_TXN_OP_BASIC_COL: case WT_TXN_OP_BASIC_ROW: - ret = __txn_op_log(session, logrec, op, cbt); + ret = __txn_op_log(session, logrec, op, cbt, fileid); break; case WT_TXN_OP_TRUNCATE_COL: ret = __wt_logop_col_truncate_pack(session, logrec, fileid, @@ -366,6 +382,50 @@ __wt_txn_checkpoint_logread(WT_SESSION_IMPL *session, } /* + * __wt_txn_ts_log -- + * Write a log record recording timestamps in the transaction. + */ +int +__wt_txn_ts_log(WT_SESSION_IMPL *session) +{ + struct timespec t; + WT_CONNECTION_IMPL *conn; + WT_ITEM *logrec; + WT_TXN *txn; + wt_timestamp_t commit, durable, first, prepare, read; + + conn = S2C(session); + txn = &session->txn; + + if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) || + F_ISSET(session, WT_SESSION_NO_LOGGING) || + !FLD_ISSET(conn->log_flags, WT_CONN_LOG_DEBUG_MODE)) + return (0); + + /* We'd better have a transaction running. */ + WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING)); + + WT_RET(__txn_logrec_init(session)); + logrec = txn->logrec; + commit = durable = first = prepare = read = WT_TS_NONE; + if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT)) { + commit = txn->commit_timestamp; + first = txn->first_commit_timestamp; + } + if (F_ISSET(txn, WT_TXN_HAS_TS_DURABLE)) + durable = txn->durable_timestamp; + if (F_ISSET(txn, WT_TXN_HAS_TS_PREPARE)) + prepare = txn->prepare_timestamp; + if (F_ISSET(txn, WT_TXN_HAS_TS_READ)) + read = txn->read_timestamp; + + __wt_epoch(session, &t); + return (__wt_logop_txn_timestamp_pack(session, logrec, + (uint64_t)t.tv_sec, (uint64_t)t.tv_nsec, + commit, durable, first, prepare, read)); +} + +/* * __wt_txn_checkpoint_log -- * Write a log record for a checkpoint operation. */ diff --git a/src/third_party/wiredtiger/src/txn/txn_recover.c b/src/third_party/wiredtiger/src/txn/txn_recover.c index a51f5205942..b68a4415e76 100644 --- a/src/third_party/wiredtiger/src/txn/txn_recover.c +++ b/src/third_party/wiredtiger/src/txn/txn_recover.c @@ -51,6 +51,11 @@ __recovery_cursor(WT_SESSION_IMPL *session, WT_RECOVERY *r, c = NULL; /* + * File ids with the bit set to ignore this operation are skipped. + */ + if (WT_LOGOP_IS_IGNORED(id)) + return (0); + /* * Metadata operations have an id of 0. Match operations based * on the id and the current pass of recovery for metadata. * @@ -115,7 +120,8 @@ __txn_op_apply( WT_DECL_RET; WT_ITEM key, start_key, stop_key, value; WT_SESSION_IMPL *session; - uint64_t recno, start_recno, stop_recno; + wt_timestamp_t commit, durable, first, prepare, read; + uint64_t recno, start_recno, stop_recno, t_nsec, t_sec; uint32_t fileid, mode, optype, opsize; session = r->session; @@ -125,6 +131,16 @@ __txn_op_apply( WT_ERR(__wt_logop_read(session, pp, end, &optype, &opsize)); end = *pp + opsize; + /* + * If it is an operation type that should be ignored, we're done. + * Note that file ids within known operations also use the same + * macros to indicate that operation should be ignored. + */ + if (WT_LOGOP_IS_IGNORED(optype)) { + *pp += opsize; + goto done; + } + switch (optype) { case WT_LOGOP_COL_MODIFY: WT_ERR(__wt_logop_col_modify_unpack(session, pp, end, @@ -266,10 +282,20 @@ __txn_op_apply( WT_TRET(stop->close(stop)); WT_ERR(ret); break; + case WT_LOGOP_TXN_TIMESTAMP: + /* + * Timestamp records are informational only. We have to + * unpack it to properly move forward in the log record + * to the next operation, but otherwise ignore. + */ + WT_ERR(__wt_logop_txn_timestamp_unpack(session, pp, end, &t_sec, + &t_nsec, &commit, &durable, &first, &prepare, &read)); + break; WT_ILLEGAL_VALUE_ERR(session, optype); } +done: /* Reset the cursor so it doesn't block eviction. */ if (cursor != NULL) WT_ERR(cursor->reset(cursor)); diff --git a/src/third_party/wiredtiger/src/txn/txn_timestamp.c b/src/third_party/wiredtiger/src/txn/txn_timestamp.c index 0e5fe4b53af..7e26bfe8fe5 100644 --- a/src/third_party/wiredtiger/src/txn/txn_timestamp.c +++ b/src/third_party/wiredtiger/src/txn/txn_timestamp.c @@ -970,7 +970,9 @@ __wt_txn_set_timestamp(WT_SESSION_IMPL *session, const char *cfg[]) WT_CONFIG_ITEM cval; WT_DECL_RET; wt_timestamp_t ts; + bool set_ts; + set_ts = false; WT_TRET(__wt_txn_context_check(session, true)); /* Look for a commit timestamp. */ @@ -979,6 +981,7 @@ __wt_txn_set_timestamp(WT_SESSION_IMPL *session, const char *cfg[]) if (ret == 0 && cval.len != 0) { WT_RET(__wt_txn_parse_timestamp(session, "commit", &ts, &cval)); WT_RET(__wt_txn_set_commit_timestamp(session, ts)); + set_ts = true; __wt_txn_publish_commit_timestamp(session); } @@ -999,6 +1002,7 @@ __wt_txn_set_timestamp(WT_SESSION_IMPL *session, const char *cfg[]) WT_RET(__wt_config_gets_def(session, cfg, "read_timestamp", 0, &cval)); if (ret == 0 && cval.len != 0) { WT_RET(__wt_txn_parse_timestamp(session, "read", &ts, &cval)); + set_ts = true; WT_RET(__wt_txn_set_read_timestamp(session, ts)); } @@ -1010,6 +1014,8 @@ __wt_txn_set_timestamp(WT_SESSION_IMPL *session, const char *cfg[]) session, "prepare", &ts, &cval)); WT_RET(__wt_txn_set_prepare_timestamp(session, ts)); } + if (set_ts) + WT_RET(__wt_txn_ts_log(session)); return (0); } diff --git a/src/third_party/wiredtiger/src/utilities/util_list.c b/src/third_party/wiredtiger/src/utilities/util_list.c index c2e1a043de9..e34fee663dc 100644 --- a/src/third_party/wiredtiger/src/utilities/util_list.c +++ b/src/third_party/wiredtiger/src/utilities/util_list.c @@ -206,12 +206,6 @@ list_print_checkpoint(WT_SESSION *session, const char *key) memset(&ci, 0, sizeof(ci)); WT_CKPT_FOREACH(ckptbase, ckpt) { - if (allocsize != 0 && (ret = __wt_block_ckpt_decode( - session, allocsize, ckpt->raw.data, &ci)) != 0) { - (void)util_err(session, ret, "__wt_block_ckpt_decode"); - /* continue if damaged */ - ci.root_size = 0; - } /* * Call ctime, not ctime_r; ctime_r has portability problems, * the Solaris version is different from the POSIX standard. @@ -232,7 +226,12 @@ list_print_checkpoint(WT_SESSION *session, const char *key) printf(" (%" PRIu64 " KB)\n", v / WT_KILOBYTE); else printf(" (%" PRIu64 " B)\n", v); - if (ci.root_size != 0) { + + /* Decode the checkpoint block. */ + if (ckpt->raw.data == NULL) + continue; + if ((ret = __wt_block_ckpt_decode( + session, allocsize, ckpt->raw.data, &ci)) == 0) { printf("\t\t" "root offset: %" PRIuMAX " (0x%" PRIxMAX ")\n", (uintmax_t)ci.root_offset, @@ -243,6 +242,9 @@ list_print_checkpoint(WT_SESSION *session, const char *key) printf("\t\t" "root checksum: %" PRIu32 " (0x%" PRIx32 ")\n", ci.root_checksum, ci.root_checksum); + } else { + /* Ignore the error and continue if damaged. */ + (void)util_err(session, ret, "__wt_block_ckpt_decode"); } } diff --git a/src/third_party/wiredtiger/src/utilities/util_main.c b/src/third_party/wiredtiger/src/utilities/util_main.c index 9b94acdc9ed..81ce18c3598 100644 --- a/src/third_party/wiredtiger/src/utilities/util_main.c +++ b/src/third_party/wiredtiger/src/utilities/util_main.c @@ -30,9 +30,11 @@ usage(void) fprintf(stderr, "global options:\n" "\t" "-C\t" "wiredtiger_open configuration\n" + "\t" "-E\t" "secret encryption key\n" "\t" "-h\t" "database directory\n" "\t" "-L\t" "turn logging off for debug-mode\n" - "\t" "-R\t" "run recovery if configured\n" + "\t" "-R\t" "run recovery (if recovery configured)\n" + "\t" "-S\t" "run salvage recovery (if recovery configured)\n" "\t" "-V\t" "display library version and exit\n" "\t" "-v\t" "verbose\n"); fprintf(stderr, diff --git a/src/third_party/wiredtiger/test/csuite/Makefile.am b/src/third_party/wiredtiger/test/csuite/Makefile.am index 53175472c1e..8b29565b596 100644 --- a/src/third_party/wiredtiger/test/csuite/Makefile.am +++ b/src/third_party/wiredtiger/test/csuite/Makefile.am @@ -131,6 +131,10 @@ test_wt4699_json_SOURCES = wt4699_json/main.c noinst_PROGRAMS += test_wt4699_json all_TESTS += test_wt4699_json +test_wt4803_cache_overflow_abort_SOURCES = wt4803_cache_overflow_abort/main.c +noinst_PROGRAMS += test_wt4803_cache_overflow_abort +all_TESTS += test_wt4803_cache_overflow_abort + # Run this during a "make check" smoke test. TESTS = $(all_TESTS) LOG_COMPILER = $(TEST_WRAPPER) diff --git a/src/third_party/wiredtiger/test/csuite/timestamp_abort/main.c b/src/third_party/wiredtiger/test/csuite/timestamp_abort/main.c index db92e5dbf53..8c2b3c6f7e3 100644 --- a/src/third_party/wiredtiger/test/csuite/timestamp_abort/main.c +++ b/src/third_party/wiredtiger/test/csuite/timestamp_abort/main.c @@ -71,9 +71,10 @@ static char home[1024]; /* Program working dir */ #define SESSION_MAX (MAX_TH + 3 + MAX_TH * PREPARE_PCT) static const char * table_pfx = "table"; +static const char * const uri_collection = "collection"; static const char * const uri_local = "local"; static const char * const uri_oplog = "oplog"; -static const char * const uri_collection = "collection"; +static const char * const uri_shadow = "shadow"; static const char * const ckpt_file = "checkpoint_done"; @@ -82,9 +83,13 @@ static volatile uint64_t global_ts = 1; #define ENV_CONFIG_COMPAT ",compatibility=(release=\"2.9\")" #define ENV_CONFIG_DEF \ - "create,log=(archive=false,file_max=10M,enabled),session_max=%" PRIu32 + "cache_size=20M,create,log=(archive=true,file_max=10M,enabled)," \ + "debug_mode=(table_logging=true,checkpoint_retention=5)," \ + "statistics=(fast),statistics_log=(wait=1,json=true),session_max=%" PRIu32 #define ENV_CONFIG_TXNSYNC \ - "create,log=(archive=false,file_max=10M,enabled)," \ + "cache_size=20M,create,log=(archive=true,file_max=10M,enabled)," \ + "debug_mode=(table_logging=true,checkpoint_retention=5)," \ + "statistics=(fast),statistics_log=(wait=1,json=true)," \ "transaction_sync=(enabled,method=none),session_max=%" PRIu32 #define ENV_CONFIG_REC "log=(archive=false,recover=on)" @@ -225,7 +230,7 @@ static WT_THREAD_RET thread_run(void *arg) { FILE *fp; - WT_CURSOR *cur_coll, *cur_local, *cur_oplog; + WT_CURSOR *cur_coll, *cur_local, *cur_oplog, *cur_shadow; WT_ITEM data; WT_RAND_STATE rnd; WT_SESSION *prepared_session, *session; @@ -287,6 +292,15 @@ thread_run(void *arg) testutil_check(session->open_cursor(session, uri, NULL, NULL, &cur_coll)); testutil_check(__wt_snprintf( + uri, sizeof(uri), "%s:%s", table_pfx, uri_shadow)); + if (use_prep) + testutil_check(prepared_session->open_cursor(prepared_session, + uri, NULL, NULL, &cur_shadow)); + else + testutil_check(session->open_cursor(session, + uri, NULL, NULL, &cur_shadow)); + + testutil_check(__wt_snprintf( uri, sizeof(uri), "%s:%s", table_pfx, uri_local)); if (use_prep) testutil_check(prepared_session->open_cursor(prepared_session, @@ -316,7 +330,7 @@ thread_run(void *arg) if (use_ts) { testutil_check(pthread_rwlock_rdlock(&ts_lock)); - active_ts = __wt_atomic_addv64(&global_ts, 1); + active_ts = __wt_atomic_addv64(&global_ts, 2); testutil_check(__wt_snprintf(tscfg, sizeof(tscfg), "commit_timestamp=%" PRIx64, active_ts)); @@ -335,6 +349,7 @@ thread_run(void *arg) cur_coll->set_key(cur_coll, kname); cur_local->set_key(cur_local, kname); cur_oplog->set_key(cur_oplog, kname); + cur_shadow->set_key(cur_shadow, kname); /* * Put an informative string into the value so that it * can be viewed well in a binary dump. @@ -352,6 +367,20 @@ thread_run(void *arg) data.data = cbuf; cur_coll->set_value(cur_coll, &data); testutil_check(cur_coll->insert(cur_coll)); + cur_shadow->set_value(cur_shadow, &data); + if (use_ts) { + /* + * Change the timestamp in the middle of the + * transaction so that we simulate a secondary. + */ + ++active_ts; + testutil_check(__wt_snprintf(tscfg, + sizeof(tscfg), "commit_timestamp=%" PRIx64, + active_ts)); + testutil_check(session->timestamp_transaction( + session, tscfg)); + } + testutil_check(cur_shadow->insert(cur_shadow)); data.size = __wt_random(&rnd) % MAX_VAL; data.data = obuf; cur_oplog->set_value(cur_oplog, &data); @@ -444,6 +473,10 @@ run_workload(uint32_t nth) testutil_check(session->create(session, uri, "key_format=S,value_format=u,log=(enabled=false)")); testutil_check(__wt_snprintf( + uri, sizeof(uri), "%s:%s", table_pfx, uri_shadow)); + testutil_check(session->create(session, uri, + "key_format=S,value_format=u,log=(enabled=false)")); + testutil_check(__wt_snprintf( uri, sizeof(uri), "%s:%s", table_pfx, uri_local)); testutil_check(session->create(session, uri, "key_format=S,value_format=u")); @@ -555,7 +588,7 @@ main(int argc, char *argv[]) FILE *fp; REPORT c_rep[MAX_TH], l_rep[MAX_TH], o_rep[MAX_TH]; WT_CONNECTION *conn; - WT_CURSOR *cur_coll, *cur_local, *cur_oplog; + WT_CURSOR *cur_coll, *cur_local, *cur_oplog, *cur_shadow; WT_RAND_STATE rnd; WT_SESSION *session; pid_t pid; @@ -733,6 +766,10 @@ main(int argc, char *argv[]) testutil_check(session->open_cursor(session, buf, NULL, NULL, &cur_coll)); testutil_check(__wt_snprintf( + buf, sizeof(buf), "%s:%s", table_pfx, uri_shadow)); + testutil_check(session->open_cursor(session, + buf, NULL, NULL, &cur_shadow)); + testutil_check(__wt_snprintf( buf, sizeof(buf), "%s:%s", table_pfx, uri_local)); testutil_check(session->open_cursor(session, buf, NULL, NULL, &cur_local)); @@ -807,13 +844,20 @@ main(int argc, char *argv[]) cur_coll->set_key(cur_coll, kname); cur_local->set_key(cur_local, kname); cur_oplog->set_key(cur_oplog, kname); + cur_shadow->set_key(cur_shadow, kname); /* * The collection table should always only have the - * data as of the checkpoint. + * data as of the checkpoint. The shadow table should + * always have the exact same data (or not) as the + * collection table. */ if ((ret = cur_coll->search(cur_coll)) != 0) { if (ret != WT_NOTFOUND) testutil_die(ret, "search"); + if ((ret = cur_shadow->search(cur_shadow)) == 0) + testutil_die(ret, + "shadow search success"); + /* * If we don't find a record, the stable * timestamp written to our file better be @@ -850,7 +894,10 @@ main(int argc, char *argv[]) " > stable ts %" PRIu64 "\n", fname, key, stable_fp, stable_val); fatal = true; - } + } else if ((ret = cur_shadow->search(cur_shadow)) != 0) + /* Collection and shadow both have the data. */ + testutil_die(ret, "shadow search failure"); + /* * The local table should always have all data. */ diff --git a/src/third_party/wiredtiger/test/csuite/wt4333_handle_locks/main.c b/src/third_party/wiredtiger/test/csuite/wt4333_handle_locks/main.c index a551cbf29de..fea9ad0bfe3 100644 --- a/src/third_party/wiredtiger/test/csuite/wt4333_handle_locks/main.c +++ b/src/third_party/wiredtiger/test/csuite/wt4333_handle_locks/main.c @@ -383,7 +383,7 @@ main(int argc, char *argv[]) /* * Bypass this test for OS X. We periodically see it hang without error, * leaving a zombie process that never exits (WT-4613, BUILD-7616). - */ + */ #if defined(__APPLE__) skip = true; #endif diff --git a/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c b/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c new file mode 100644 index 00000000000..7d9b0baf132 --- /dev/null +++ b/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c @@ -0,0 +1,239 @@ +/*- + * Public Domain 2014-2019 MongoDB, Inc. + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +#include "test_util.h" + +#include <signal.h> +#include <sys/wait.h> + +/* + * JIRA ticket reference: WT-4803 + * Test case description: This test is checking the functionality of the + * lookaside file_max configuration. When the size of the lookaside file exceeds + * this value, we expect to panic. + * Failure mode: If we receive a panic in the test cases we weren't expecting to + * and vice versa. + */ + +#define NUM_KEYS 2000 + +/* + * This is a global flag that should be set before running test_las_workload. + * It lets the child process know whether it should be expecting a panic or not + * so that it can adjust its exit code as needed. + */ +static bool expect_panic; + +static int +handle_message(WT_EVENT_HANDLER *handler, + WT_SESSION *session, int error, const char *message) +{ + WT_UNUSED(handler); + WT_UNUSED(session); + + (void)fprintf( + stderr, "%s: %s\n", message, session->strerror(session, error)); + + if (error == WT_PANIC && + strstr(message, "exceeds maximum size") != NULL) { + fprintf(stderr, "Got cache overflow error (expect_panic=%s)\n", + expect_panic ? "true" : "false"); + + /* + * If we're expecting a panic, exit with zero to indicate to the + * parent that this test was successful. + * + * If not, don't intercept. We'll naturally exit with non-zero + * if we're terminating due to panic. + */ + if (expect_panic) + exit(EXIT_SUCCESS); + } + + return (0); +} + +static WT_EVENT_HANDLER event_handler = { + handle_message, + NULL, + NULL, + NULL +}; + +static void +las_workload(TEST_OPTS *opts, const char *las_file_max) +{ + WT_CURSOR *cursor; + WT_SESSION *other_session, *session; + int i; + char buf[WT_MEGABYTE], open_config[128]; + + testutil_check(__wt_snprintf(open_config, sizeof(open_config), + "create,cache_size=50MB,cache_overflow=(file_max=%s)", + las_file_max)); + + testutil_check(wiredtiger_open( + opts->home, &event_handler, open_config, &opts->conn)); + testutil_check( + opts->conn->open_session(opts->conn, NULL, NULL, &session)); + testutil_check( + session->create(session, opts->uri, "key_format=i,value_format=S")); + testutil_check( + session->open_cursor(session, opts->uri, NULL, NULL, &cursor)); + + memset(buf, 0xA, WT_MEGABYTE); + buf[WT_MEGABYTE - 1] = '\0'; + + /* Populate the table. */ + for (i = 0; i < NUM_KEYS; ++i) { + cursor->set_key(cursor, i); + cursor->set_value(cursor, buf); + testutil_check(cursor->insert(cursor)); + } + + /* + * Open a snapshot isolation transaction in another session. This forces + * the cache to retain all previous values. Then update all keys with a + * new value in the original session while keeping that snapshot + * transaction open. With the large value buffer, small cache and lots + * of keys, this will force a lot of lookaside usage. + * + * When the file_max setting is small, the maximum size should easily be + * reached and we should panic. When the maximum size is large or not + * set, then we should succeed. + */ + testutil_check( + opts->conn->open_session(opts->conn, NULL, NULL, &other_session)); + testutil_check(other_session->begin_transaction( + other_session, "isolation=snapshot")); + + memset(buf, 0xB, WT_MEGABYTE); + buf[WT_MEGABYTE - 1] = '\0'; + + for (i = 0; i < NUM_KEYS; ++i) { + cursor->set_key(cursor, i); + cursor->set_value(cursor, buf); + testutil_check(cursor->update(cursor)); + } + + /* + * Cleanup. + * We do not get here when the file_max size is small because we will + * have already hit the maximum and exited. This code only executes on + * the successful path. + */ + testutil_check( + other_session->rollback_transaction(other_session, NULL)); + testutil_check(other_session->close(other_session, NULL)); + + testutil_check(cursor->close(cursor)); + testutil_check(session->close(session, NULL)); +} + +static int +test_las_workload(TEST_OPTS *opts, const char *las_file_max) +{ + pid_t pid; + int status; + + /* + * We're going to run this workload for different configurations of + * file_max. So clean out the work directory each time. + */ + testutil_make_work_dir(opts->home); + + /* + * Since it's possible that the workload will panic and abort, we will + * fork the process and execute the workload in the child process. + * + * This way, we can safely check the exit code of the child process and + * confirm that it is what we expected. + */ + pid = fork(); + if (pid < 0) + /* Failed fork. */ + testutil_die(errno, "fork"); + else if (pid == 0) { + /* Child process from here. */ + las_workload(opts, las_file_max); + + /* + * If we're expecting a panic during the workload, we shouldn't + * get to this point. Exit with non-zero to indicate to parent + * that we should fail this test. + */ + fprintf(stderr, + "Successfully completed workload (expect_panic=%s)\n", + expect_panic ? "true" : "false"); + + if (expect_panic) + exit(EXIT_FAILURE); + else + exit(EXIT_SUCCESS); + } + + /* Parent process from here. */ + if (waitpid(pid, &status, 0) == -1) + testutil_die(errno, "waitpid"); + + return (status); +} + +int +main(int argc, char **argv) +{ + TEST_OPTS opts; + + memset(&opts, 0x0, sizeof(opts)); + testutil_check(testutil_parse_opts(argc, argv, &opts)); + + /* + * The lookaside is unbounded. + * We don't expect any failure since we can use as much as needed. + */ + expect_panic = false; + testutil_check(test_las_workload(&opts, "0")); + + /* + * The lookaside is limited to 5GB. + * This is more than enough for this workload so we don't expect any + * failure. + */ + expect_panic = false; + testutil_check(test_las_workload(&opts, "5GB")); + + /* + * The lookaside is limited to 100MB. + * This is insufficient for this workload so we're expecting a failure. + */ + expect_panic = true; + testutil_check(test_las_workload(&opts, "100MB")); + + testutil_cleanup(&opts); + + return (0); +} diff --git a/src/third_party/wiredtiger/test/evergreen.yml b/src/third_party/wiredtiger/test/evergreen.yml index cbb0199df75..99933cff595 100644 --- a/src/third_party/wiredtiger/test/evergreen.yml +++ b/src/third_party/wiredtiger/test/evergreen.yml @@ -8,7 +8,7 @@ functions: command: git.get_project params: directory: wiredtiger - "fetch artifacts" : + "fetch artifacts" : - command: s3.get params: aws_key: ${aws_key} @@ -43,7 +43,7 @@ functions: "fetch mongo-tests repo" : command: shell.exec params: - script: | + script: | git clone https://github.com/wiredtiger/mongo-tests "compile wiredtiger": command: shell.exec @@ -60,7 +60,7 @@ functions: sh ./reconf ${configure_env_vars|} ../configure ${configure_python_setting|} --enable-diagnostic --enable-python --enable-zlib --enable-strict --enable-static --prefix=$(pwd)/LOCAL_INSTALL ${make_command|make} ${smp_command|} 2>&1 - + # On macOS, change the binary location with install_name_tool since DYLD_LIBRARY_PATH # appears not to work for dynamic modules loaded by python. For wt, the libtool generated # script has the wrong path for running on test machines. @@ -672,6 +672,20 @@ tasks: ${test_env_vars|} $(pwd)/test_wt4699_json 2>&1 + - name: csuite-wt4803-cache-overflow-abort-test + depends_on: + - name: compile + commands: + - func: "fetch artifacts" + - command: shell.exec + params: + working_dir: "wiredtiger/build_posix/test/csuite" + script: | + set -o errexit + set -o verbose + + ${test_env_vars|} $(pwd)/test_wt4803_cache_overflow_abort 2>&1 + - name: csuite-rwlock-test depends_on: - name: compile @@ -823,9 +837,9 @@ tasks: # Break out Python unit tests into multiple buckets/tasks based on test name and runtime # The test/suite/run.py script can work out test names by casting each command argument - # with "test_" prefix and "*.py" postfix. + # with "test_" prefix and "*.py" postfix. # - # One example: + # One example: # "test/suite/run.py [ab]" will be translated to testing "test_a*.py" and "test_b*.py" - name: unit-test-bucket00 @@ -989,18 +1003,18 @@ tasks: - name: million-collection-test depends_on: [] - run_on: + run_on: - rhel62-large - commands: + commands: - func: "fetch mongo-tests repo" - command: shell.exec params: working_dir: mongo-tests - script: | + script: | set -o errexit set -o verbose ulimit -n 1000000 - ulimit -c unlimited + ulimit -c unlimited largescale/run-million-collection-test.sh . - name: compatibility-test-for-mongodb-releases diff --git a/src/third_party/wiredtiger/test/evergreen/verify_wt_datafiles.sh b/src/third_party/wiredtiger/test/evergreen/verify_wt_datafiles.sh index 4c7b56d34ea..82ddb3ed9ac 100755 --- a/src/third_party/wiredtiger/test/evergreen/verify_wt_datafiles.sh +++ b/src/third_party/wiredtiger/test/evergreen/verify_wt_datafiles.sh @@ -49,7 +49,7 @@ if [ ! -x "t" ]; then exit 6 fi -lib_dir=$(dirname "${wt_binary}") +export LD_LIBRARY_PATH=$(dirname "${wt_binary}") num_tables_verified=0 # Work out the list of directories that include wt data files @@ -62,7 +62,7 @@ for d in ${dirs_include_datafile} do echo "${d}" - tables=$(LD_LIBRARY_PATH="${lib_dir}" ${wt_binary} -h "${d}" list) + tables=$(${wt_binary} -h "${d}" list) rc=$? if [ "$rc" -ne "0" ]; then @@ -74,21 +74,23 @@ do for t in ${tables} do echo ${t} - LD_LIBRARY_PATH="${lib_dir}" ${wt_binary} -h ${d} verify ${t} + ${wt_binary} -h ${d} verify ${t} if [ "$?" -ne "0" ]; then echo "Failed to verify '${t}' table under '${d}' directory, exiting ..." exit 2 fi - dump=$(LD_LIBRARY_PATH="${lib_dir}" ${wt_binary} -h ${d} dump ${t}) + if [ "${verbose}" == true ]; then + ${wt_binary} -h ${d} dump ${t} + else + ${wt_binary} -h ${d} dump ${t} > /dev/null + fi + if [ "$?" -ne "0" ]; then echo "Failed to dump '${t}' table under '${d}' directory, exiting ..." exit 3 fi - # Print out the table dump if verbose flag is on - [[ "${verbose}" == true ]] && echo ${dump} - # Table verification is successful, increment the counter let "num_tables_verified+=1" echo "num_tables_verified = ${num_tables_verified}" diff --git a/src/third_party/wiredtiger/test/format/config.c b/src/third_party/wiredtiger/test/format/config.c index f20ef7a762d..8f2c25429c9 100644 --- a/src/third_party/wiredtiger/test/format/config.c +++ b/src/third_party/wiredtiger/test/format/config.c @@ -92,8 +92,8 @@ config_setup(void) } config_map_file_type(g.c_file_type, &g.type); - config_single("data_source=table", 0); - if (!config_is_perm("data_source")) + if (!config_is_perm("data_source")) { + config_single("data_source=table", 0); switch (mmrand(NULL, 1, 5)) { case 1: /* 20% */ config_single("data_source=file", 0); @@ -120,6 +120,7 @@ config_setup(void) case 3: case 4: case 5: /* 60% */ break; } + } /* * If data_source and file_type were both "permanent", we may still diff --git a/src/third_party/wiredtiger/test/suite/test_compat01.py b/src/third_party/wiredtiger/test/suite/test_compat01.py index faf5ed1673f..7181d474fa6 100644 --- a/src/third_party/wiredtiger/test/suite/test_compat01.py +++ b/src/third_party/wiredtiger/test/suite/test_compat01.py @@ -53,6 +53,7 @@ class test_compat01(wttest.WiredTigerTestCase, suite_subprocess): # and without the patch number. Test both. start_compat = [ ('def', dict(compat1='none', logv1=3)), + ('32', dict(compat1='3.2', logv1=3)), ('31', dict(compat1="3.1", logv1=3)), ('30', dict(compat1="3.0", logv1=2)), ('30_patch', dict(compat1="3.0.0", logv1=2)), @@ -62,6 +63,7 @@ class test_compat01(wttest.WiredTigerTestCase, suite_subprocess): ] restart_compat = [ ('def2', dict(compat2='none', logv2=3)), + ('32_2', dict(compat2='3.2', logv2=3)), ('31_2', dict(compat2="3.1", logv2=3)), ('30_2', dict(compat2="3.0", logv2=2)), ('30_patch2', dict(compat2="3.0.0", logv2=2)), diff --git a/src/third_party/wiredtiger/test/suite/test_compat02.py b/src/third_party/wiredtiger/test/suite/test_compat02.py index bcdff19b6c1..de5862513a8 100644 --- a/src/third_party/wiredtiger/test/suite/test_compat02.py +++ b/src/third_party/wiredtiger/test/suite/test_compat02.py @@ -56,20 +56,30 @@ class test_compat02(wttest.WiredTigerTestCase, suite_subprocess): # The API uses only the major and minor numbers but accepts with # and without the patch number. Test one on release and the # required minimum just for testing of parsing. - # + compat_create = [ ('def', dict(create_rel='none', log_create=3)), ('32', dict(create_rel="3.2", log_create=3)), + ('31', dict(create_rel="3.1", log_create=3)), ('30', dict(create_rel="3.0", log_create=2)), ('26', dict(create_rel="2.6", log_create=1)), ] + compat_release = [ ('def_rel', dict(rel='none', log_rel=3)), ('32_rel', dict(rel="3.2", log_rel=3)), + ('31_rel', dict(rel="3.1", log_rel=3)), ('30_rel', dict(rel="3.0", log_rel=2)), ('26_rel', dict(rel="2.6", log_rel=1)), ('26_patch_rel', dict(rel="2.6.1", log_rel=1)), ] + + # Only the maximum version should exist below for each log version + # i.e. even though 3.1 is also log_max=3 3.2 is above it and also + # log_max=3 as such we don't need 3.1 in this list. + # However the exemption to this rule is versions which include a patch + # number as the patch number will get removed in the conn_reconfig.c + # This rule exemption applies to the minimum verison check as well. compat_max = [ ('future_max', dict(max_req=future_rel, log_max=future_logv)), ('def_max', dict(max_req='none', log_max=3)), @@ -78,10 +88,12 @@ class test_compat02(wttest.WiredTigerTestCase, suite_subprocess): ('26_max', dict(max_req="2.6", log_max=1)), ('26_patch_max', dict(max_req="2.6.1", log_max=1)), ] + + # Only the minimum version should exist below for each log version. compat_min = [ ('future_min', dict(min_req=future_rel, log_min=future_logv)), ('def_min', dict(min_req='none', log_min=3)), - ('32_min', dict(min_req="3.2", log_min=3)), + ('31_min', dict(min_req="3.1", log_min=3)), ('30_min', dict(min_req="3.0", log_min=2)), ('26_min', dict(min_req="2.6", log_min=1)), ('26_patch_min', dict(min_req="2.6.1", log_min=1)), @@ -132,12 +144,11 @@ class test_compat02(wttest.WiredTigerTestCase, suite_subprocess): log_str = 'log=(enabled,file_max=%s,archive=false),' % self.logmax restart_config = log_str + compat_str self.pr("Restart conn " + restart_config) - # + # We have a lot of error cases. There are too many and they are # dependent on the order of the library code so don't check specific # error messages. So just determine if an error should occur and # make sure it does. - # if ((self.log_min >= self.future_logv) or (self.log_max >= self.future_logv) or (self.max_req != 'none' and self.log_max < self.log_rel) or diff --git a/src/third_party/wiredtiger/test/suite/test_compat03.py b/src/third_party/wiredtiger/test/suite/test_compat03.py index 064fe5ab7ed..421a8fbe381 100644 --- a/src/third_party/wiredtiger/test/suite/test_compat03.py +++ b/src/third_party/wiredtiger/test/suite/test_compat03.py @@ -56,15 +56,22 @@ class test_compat03(wttest.WiredTigerTestCase, suite_subprocess): # The API uses only the major and minor numbers but accepts with # and without the patch number. Test one on release and the # required minimum just for testing of parsing. - # compat_release = [ ('def_rel', dict(rel='none', log_rel=3)), ('future_rel', dict(rel=future_rel, log_rel=future_logv)), ('32_rel', dict(rel="3.2", log_rel=3)), + ('31_rel', dict(rel="3.1", log_rel=3)), ('30_rel', dict(rel="3.0", log_rel=2)), ('26_rel', dict(rel="2.6", log_rel=1)), ('26_patch_rel', dict(rel="2.6.1", log_rel=1)), ] + + # Only the maximum version should exist below for each log version + # i.e. even though 3.1 is also log_max=3 3.2 is above it and also + # log_max=3 as such we don't need 3.1 in this list. + # However the exemption to this rule is versions which include a patch + # number as the patch number will get removed in the conn_reconfig.c + # This rule exemption applies to the minimum verison check as well. compat_max = [ ('def_max', dict(max_req='none', log_max=3)), ('future_max', dict(max_req=future_rel, log_max=future_logv)), @@ -73,19 +80,18 @@ class test_compat03(wttest.WiredTigerTestCase, suite_subprocess): ('26_max', dict(max_req="2.6", log_max=1)), ('26_patch_max', dict(max_req="2.6.1", log_max=1)), ] + + # Only the minimum version should exist below for each log version. compat_min = [ ('def_min', dict(min_req='none', log_min=3)), ('future_min', dict(min_req=future_rel, log_min=future_logv)), - ('32_min', dict(min_req="3.2", log_min=3)), + ('31_min', dict(min_req="3.1", log_min=3)), ('30_min', dict(min_req="3.0", log_min=2)), ('26_min', dict(min_req="2.6", log_min=1)), ('26_patch_min', dict(min_req="2.6.1", log_min=1)), ] - base_config = [ - ('basecfg_true', dict(basecfg='true')), - ('basecfg_false', dict(basecfg='false')), - ] - scenarios = make_scenarios(compat_release, compat_max, compat_min, base_config) + + scenarios = make_scenarios(compat_release, compat_max, compat_min) # This test creates scenarios that lead to errors. This is different # than compat02 because it is testing errors (or success) using the @@ -93,9 +99,10 @@ class test_compat03(wttest.WiredTigerTestCase, suite_subprocess): def test_compat03(self): testdir = 'TEST' os.mkdir(testdir) - config_str = 'create,config_base=%s,' % self.basecfg + config_str = 'create,' log_str = 'log=(archive=false,enabled,file_max=%s),' % self.logmax compat_str = '' + if (self.rel != 'none'): compat_str += 'compatibility=(release="%s"),' % self.rel if (self.max_req != 'none'): @@ -105,12 +112,11 @@ class test_compat03(wttest.WiredTigerTestCase, suite_subprocess): config_str += log_str + compat_str self.pr("Conn config:" + config_str) - # # We have a lot of error cases. There are too many and they are # dependent on the order of the library code so don't check specific # error messages. So just determine if an error should occur and # make sure it does. - # + if ((self.log_min >= self.future_logv) or (self.log_max >= self.future_logv) or (self.log_rel >= self.future_logv) or diff --git a/src/third_party/wiredtiger/test/suite/test_compat04.py b/src/third_party/wiredtiger/test/suite/test_compat04.py index a5b59021639..30f88252b2e 100644 --- a/src/third_party/wiredtiger/test/suite/test_compat04.py +++ b/src/third_party/wiredtiger/test/suite/test_compat04.py @@ -56,11 +56,13 @@ class test_compat04(wttest.WiredTigerTestCase, suite_subprocess): # create_release = [ ('def_rel', dict(create_rel='none', log_crrel=3)), + ('32_rel', dict(create_rel='3.2', log_crrel=3)), ('31_rel', dict(create_rel="3.1", log_crrel=3)), ('30_rel', dict(create_rel="3.0", log_crrel=2)), ('26_rel', dict(create_rel="2.6", log_crrel=1)), ] reconfig_release = [ + ('32_rel', dict(rel="3.2", log_rel=3)), ('31_rel', dict(rel="3.1", log_rel=3)), ('30_rel', dict(rel="3.0", log_rel=2)), ('300_rel', dict(rel="3.0.0", log_rel=2)), diff --git a/src/third_party/wiredtiger/test/suite/test_debug_mode01.py b/src/third_party/wiredtiger/test/suite/test_debug_mode01.py new file mode 100644 index 00000000000..88ba81f9c1c --- /dev/null +++ b/src/third_party/wiredtiger/test/suite/test_debug_mode01.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python +# +# Public Domain 2014-2019 MongoDB, Inc. +# Public Domain 2008-2014 WiredTiger, Inc. +# +# This is free and unencumbered software released into the public domain. +# +# Anyone is free to copy, modify, publish, use, compile, sell, or +# distribute this software, either in source code form or as a compiled +# binary, for any purpose, commercial or non-commercial, and by any +# means. +# +# In jurisdictions that recognize copyright laws, the author or authors +# of this software dedicate any and all copyright interest in the +# software to the public domain. We make this dedication for the benefit +# of the public at large and to the detriment of our heirs and +# successors. We intend this dedication to be an overt act of +# relinquishment in perpetuity of all present and future rights to this +# software under copyright law. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. + +import wiredtiger, wttest + +# test_debug_mode01.py +# Test the debug mode settings. Test rollback_error in this one. +class test_debug_mode01(wttest.WiredTigerTestCase): + conn_config = 'log=(enabled=true),debug_mode=(rollback_error=5)' + session_config = 'isolation=snapshot' + uri = 'file:test_debug' + + entries = 22 + min_error = entries // 5 + + def rollback_error(self, val, insert=True): + keys = range(1, self.entries) + c = self.session.open_cursor(self.uri, None) + # We expect some operations to return an exception so we cannot + # use the simple 'c[k] = 1'. But we must explicitly set the key + # and value and then use the insert or update primitives. + # + # Look for a generic 'WT_ROLLBACK' string not the specific + # simulated reason string. + msg = '/WT_ROLLBACK/' + rollback = 0 + for k in keys: + self.session.begin_transaction() + c.set_key(k) + c.set_value(val) + # Execute the insert or update. It will return true if the simulated + # conflict exception is raised, false if no exception occurred. + if insert: + conflict = self.assertRaisesException(wiredtiger.WiredTigerError, \ + lambda:c.insert(), msg, True) + else: + conflict = self.assertRaisesException(wiredtiger.WiredTigerError, \ + lambda:c.update(), msg, True) + + if conflict: + rollback += 1 + self.pr("Key: " + str(k) + " Rolled back") + self.session.rollback_transaction() + else: + self.session.commit_transaction() + c.close() + return rollback + + def test_rollback_error(self): + self.session.create(self.uri, 'key_format=i,value_format=i') + rollback = self.rollback_error(1) + rollback += self.rollback_error(2, False) + self.pr("Rollback: " + str(rollback)) + self.pr("Minimum: " + str(self.min_error)) + self.assertTrue(rollback >= self.min_error) + + def test_rollback_error_off(self): + # The setting is added in to wiredtiger_open via the config above. + # Test that we can properly turn the setting off via reconfigure. + # There should then be no rollback errors. + self.conn.reconfigure("debug_mode=(rollback_error=0)") + + self.session.create(self.uri, 'key_format=i,value_format=i') + rollback = self.rollback_error(1) + rollback += self.rollback_error(2) + self.assertTrue(rollback == 0) + +if __name__ == '__main__': + wttest.run() diff --git a/src/third_party/wiredtiger/test/suite/test_debug_mode02.py b/src/third_party/wiredtiger/test/suite/test_debug_mode02.py new file mode 100644 index 00000000000..0452e60fbd1 --- /dev/null +++ b/src/third_party/wiredtiger/test/suite/test_debug_mode02.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python +# +# Public Domain 2024-2029 MongoDB, Inc. +# Public Domain 2008-2024 WiredTiger, Inc. +# +# This is free and unencumbered software released into the public domain. +# +# Anyone is free to copy, modify, publish, use, compile, sell, or +# distribute this software, either in source code form or as a compiled +# binary, for any purpose, commercial or non-commercial, and by any +# means. +# +# In jurisdictions that recognize copyright laws, the author or authors +# of this software dedicate any and all copyright interest in the +# software to the public domain. We make this dedication for the benefit +# of the public at large and to the detriment of our heirs and +# successors. We intend this dedication to be an overt act of +# relinquishment in perpetuity of all present and future rights to this +# software under copyright law. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. + +import fnmatch, os, time, wiredtiger, wttest + +# test_debug_mode02.py +# Test the debug mode settings. Test checkpoint_retention use. +class test_debug_mode02(wttest.WiredTigerTestCase): + uri = 'file:test_debug' + + entries = 100 + loop = 0 + retain = 5 + log1 = 'WiredTigerLog.0000000001' + log2 = 'WiredTigerLog.0000000002' + + def conn_config(self): + return 'log=(enabled=true,file_max=100K),debug_mode=(checkpoint_retention=%d)' % self.retain + + def log_set(self): + logs = fnmatch.filter(os.listdir(self.home), "*gerLog*") + return set(logs) + + def check_archive(self, logfile): + archived = False + for i in range(1,90): + # Sleep and then see if archive ran. We do this in a loop + # for slow machines. Max out at 90 seconds. + time.sleep(1.0) + if not os.path.exists(logfile): + archived = True + break + self.assertTrue(archived) + + def advance_log_checkpoint(self): + # Advance the log file to the next file and write a checkpoint. + keys = range(1, self.entries) + cur_set = self.log_set() + c = self.session.open_cursor(self.uri, None) + new_set = cur_set + # Write data in small chunks until we switch log files. + while cur_set == new_set: + for k in keys: + c[k + (self.loop * self.entries)] = 1 + self.loop += 1 + new_set = self.log_set() + c.close() + # Write a checkpoint into the new log file. + self.session.checkpoint() + + def test_checkpoint_retain(self): + self.session.create(self.uri, 'key_format=i,value_format=i') + # No log files should be archived while we have fewer than the + # retention number of logs. Make sure each iteration the new + # logs are a proper superset of the previous time. + for i in range(1, self.retain): + cur_set = self.log_set() + self.advance_log_checkpoint() + # We don't accomodate slow machines here because we don't expect + # the files the change and there is no way to know if archive ran + # otherwise. + time.sleep(1.0) + new_set = self.log_set() + self.assertTrue(new_set.issuperset(cur_set)) + + self.assertTrue(os.path.exists(self.log1)) + self.advance_log_checkpoint() + self.check_archive(self.log1) + + # Test that both zero and one archive as usual. And test reconfigure. + def test_checkpoint_retain_off(self): + self.conn.reconfigure("debug_mode=(checkpoint_retention=0)") + self.session.create(self.uri, 'key_format=i,value_format=i') + + self.advance_log_checkpoint() + self.check_archive(self.log1) + + self.conn.reconfigure("debug_mode=(checkpoint_retention=1)") + self.advance_log_checkpoint() + self.check_archive(self.log2) + +if __name__ == '__main__': + wttest.run() diff --git a/src/third_party/wiredtiger/test/suite/test_debug_mode03.py b/src/third_party/wiredtiger/test/suite/test_debug_mode03.py new file mode 100644 index 00000000000..feb5c0d904a --- /dev/null +++ b/src/third_party/wiredtiger/test/suite/test_debug_mode03.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python +# +# Public Domain 2034-2039 MongoDB, Inc. +# Public Domain 2008-2034 WiredTiger, Inc. +# +# This is free and unencumbered software released into the public domain. +# +# Anyone is free to copy, modify, publish, use, compile, sell, or +# distribute this software, either in source code form or as a compiled +# binary, for any purpose, commercial or non-commercial, and by any +# means. +# +# In jurisdictions that recognize copyright laws, the author or authors +# of this software dedicate any and all copyright interest in the +# software to the public domain. We make this dedication for the benefit +# of the public at large and to the detriment of our heirs and +# successors. We intend this dedication to be an overt act of +# relinquishment in perpetuity of all present and future rights to this +# software under copyright law. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. + +import wiredtiger, wttest + +# test_debug_mode03.py +# Test the debug mode settings. Test table_logging use. +class test_debug_mode03(wttest.WiredTigerTestCase): + conn_config = 'log=(enabled=true,file_max=100K),debug_mode=(table_logging=true)' + uri = 'file:test_debug' + entries = 100 + value = b'\x01\x02abcd\x03\x04' + + def add_data(self): + # Add a binary value we can search for in the log. + keys = range(0, self.entries) + c = self.session.open_cursor(self.uri, None) + for k in keys: + c[k] = self.value + c.close() + + def find_log_recs(self): + # Open a log cursor. We should find log records that have + # the value we inserted. + c = self.session.open_cursor("log:", None) + count = 0 + while c.next() == 0: + # lsn.file, lsn.offset, opcount + keys = c.get_key() + # txnid, rectype, optype, fileid, logrec_key, logrec_value + values = c.get_value() + # Look for log records that have a key/value pair. + if values[4] != b'': + if self.value in values[5]: # logrec_value + count += 1 + c.close() + return count + + def test_table_logging(self): + self.session.create(self.uri, 'key_format=i,value_format=u,log=(enabled=false)') + self.add_data() + count = self.find_log_recs() + self.assertEqual(count, self.entries) + + # Test that both zero and one archive as usual. And test reconfigure. + def test_table_logging_off(self): + self.conn.reconfigure("debug_mode=(table_logging=false)") + self.session.create(self.uri, 'key_format=i,value_format=u,log=(enabled=false)') + self.add_data() + count = self.find_log_recs() + self.assertEqual(count, 0) + +if __name__ == '__main__': + wttest.run() diff --git a/src/third_party/wiredtiger/test/suite/test_las04.py b/src/third_party/wiredtiger/test/suite/test_las04.py new file mode 100644 index 00000000000..9d35d3c17f3 --- /dev/null +++ b/src/third_party/wiredtiger/test/suite/test_las04.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python +# +# Public Domain 2014-2019 MongoDB, Inc. +# Public Domain 2008-2014 WiredTiger, Inc. +# +# This is free and unencumbered software released into the public domain. +# +# Anyone is free to copy, modify, publish, use, compile, sell, or +# distribute this software, either in source code form or as a compiled +# binary, for any purpose, commercial or non-commercial, and by any +# means. +# +# In jurisdictions that recognize copyright laws, the author or authors +# of this software dedicate any and all copyright interest in the +# software to the public domain. We make this dedication for the benefit +# of the public at large and to the detriment of our heirs and +# successors. We intend this dedication to be an overt act of +# relinquishment in perpetuity of all present and future rights to this +# software under copyright law. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +# +# test_las04.py +# Test file_max configuration and reconfiguration for the lookaside table. +# + +import wiredtiger, wttest +from wtscenario import make_scenarios + +# Taken from src/include/misc.h. +WT_MB = 1048576 + +class test_las04(wttest.WiredTigerTestCase): + uri = 'table:las_04' + in_memory_values = [ + ('false', dict(in_memory=False)), + ('none', dict(in_memory=None)), + ('true', dict(in_memory=True)) + ] + init_file_max_values = [ + ('default', dict(init_file_max=None, init_stat_val=0)), + ('non-zero', dict(init_file_max='100MB', init_stat_val=(WT_MB * 100))), + ('zero', dict(init_file_max='0', init_stat_val=0)) + ] + reconfig_file_max_values = [ + ('non-zero', dict(reconfig_file_max='100MB', + reconfig_stat_val=(WT_MB * 100))), + ('too-low', dict(reconfig_file_max='99MB', reconfig_stat_val=None)), + ('zero', dict(reconfig_file_max='0', reconfig_stat_val=0)) + ] + scenarios = make_scenarios(init_file_max_values, reconfig_file_max_values, + in_memory_values) + + def conn_config(self): + config = 'statistics=(fast)' + if self.init_file_max is not None: + config += ',cache_overflow=(file_max={})'.format(self.init_file_max) + if self.in_memory is not None: + config += ',in_memory=' + ('true' if self.in_memory else 'false') + return config + + def get_stat(self, stat): + stat_cursor = self.session.open_cursor('statistics:') + val = stat_cursor[stat][2] + stat_cursor.close() + return val + + def test_las(self): + self.session.create(self.uri, 'key_format=S,value_format=S') + + if self.in_memory: + # For in-memory configurations, we simply ignore any lookaside + # related configuration. + self.assertEqual( + self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max), + 0) + else: + self.assertEqual( + self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max), + self.init_stat_val) + + reconfigure = lambda: self.conn.reconfigure( + 'cache_overflow=(file_max={})'.format(self.reconfig_file_max)) + + # We expect an error when the statistic value is None because the value + # is out of range. + if self.reconfig_stat_val is None: + self.assertRaisesWithMessage( + wiredtiger.WiredTigerError, reconfigure, '/below minimum/') + return + + reconfigure() + + if self.in_memory: + self.assertEqual( + self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max), + 0) + else: + self.assertEqual( + self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max), + self.reconfig_stat_val) + +if __name__ == '__main__': + wttest.run() diff --git a/src/third_party/wiredtiger/test/suite/test_timestamp17.py b/src/third_party/wiredtiger/test/suite/test_timestamp17.py index ad1a9770173..f03b002c0ed 100644 --- a/src/third_party/wiredtiger/test/suite/test_timestamp17.py +++ b/src/third_party/wiredtiger/test/suite/test_timestamp17.py @@ -27,8 +27,8 @@ # OTHER DEALINGS IN THE SOFTWARE. # # test_timestamp17.py -# Test unintended timestamp usage on an update and ensure behaviour -# matches expectations. Additionally move the timestamp to ensure +# Test unintended timestamp usage on an update and ensure behavior +# matches expectations. Additionally, move the timestamp to ensure # that values read are still consistent after those timestamps are # moved. # diff --git a/src/third_party/wiredtiger/test/suite/wttest.py b/src/third_party/wiredtiger/test/suite/wttest.py index d3d75d24c42..260daef7d02 100755 --- a/src/third_party/wiredtiger/test/suite/wttest.py +++ b/src/third_party/wiredtiger/test/suite/wttest.py @@ -523,20 +523,33 @@ class WiredTigerTestCase(unittest.TestCase): """ Like TestCase.assertRaises(), with some additional options. If the exceptionString argument is used, the exception's string - must match it. If optional is set, then no assertion occurs - if the exception doesn't occur. + must match it, or its pattern if the string starts and ends with + a slash. If optional is set, then no assertion occurs if the + exception doesn't occur. Returns true if the assertion is raised. """ raised = False try: expr() except BaseException as err: + self.pr('Exception raised shown as string: "' + \ + str(err) + '"') if not isinstance(err, exceptionType): self.fail('Exception of incorrect type raised, got type: ' + \ str(type(err))) - if exceptionString != None and exceptionString != str(err): - self.fail('Exception with incorrect string raised, got: "' + \ - str(err) + '"') + if exceptionString != None: + # Match either a pattern or an exact string. + fail = False + self.pr('Expecting string msg: ' + exceptionString) + if len(exceptionString) > 2 and \ + exceptionString[0] == '/' and exceptionString[-1] == '/' : + if re.search(exceptionString[1:-1], str(err)) == None: + fail = True + elif exceptionString != str(err): + fail = True + if fail: + self.fail('Exception with incorrect string raised, got: "' + \ + str(err) + '" Expected: ' + exceptionString) raised = True if not raised and not optional: self.fail('no assertion raised') |