diff options
| author | Luke Chen <luke.chen@mongodb.com> | 2021-07-27 15:13:43 +1000 |
|---|---|---|
| committer | Evergreen Agent <no-reply@evergreen.mongodb.com> | 2021-07-27 05:33:43 +0000 |
| commit | 4587620b1d98d9659f1c70949bdf1df8a40893ec (patch) | |
| tree | af584b90f4aaa37bfbe210812b6a05586620b4ce /src/third_party | |
| parent | ab9f1e76d2b88388fcb17576cab7b3d88fafc923 (diff) | |
| download | mongo-4587620b1d98d9659f1c70949bdf1df8a40893ec.tar.gz | |
Import wiredtiger: 8b35a8d923eca1558aee73c45a5031ab65e82032 from branch mongodb-5.0
ref: 87de782470..8b35a8d923
for: 5.0.2
WT-6902 Metadata subpage for Architecture Guide
WT-6914 Write "database files" subpage for Architecture Guide
WT-7607 Add the possibility to use an existing database for many-coll-test
WT-7703 Fix timeout in test_checkpoint_snapshot04
WT-7732 Add a timeout configuration for flush_tier
WT-7758 Force evict a page when the update chain is too long
WT-7787 Don't read pages for checkpoint cleanup when the cache is in aggressive mode
WT-7789 Change tiered python tests to fail without extension library
WT-7817 Make tiered storage address cookies backward compatible
WT-7864 Add support to run.py for running lists/ranges of scenarios in a test
WT-7865 Disable timeout assert while waiting for eviction to quiesce prior to RTS and test
WT-7870 Fix measurement of cyclomatic code complexity
WT-7871 Remove comment that is no longer true
WT-7874 Remove two other stale comments
WT-7883 Remove incorrect wt_free statement
WT-7889 Find/replace existing uses of WT with WiredTiger in reference guide
WT-7890 Fix CMake syntax error in config_lib
Diffstat (limited to 'src/third_party')
48 files changed, 1022 insertions, 650 deletions
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/ycsb-f.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/ycsb-f.wtperf index c997b7c1231..4fe3587ac0a 100644 --- a/src/third_party/wiredtiger/bench/wtperf/runners/ycsb-f.wtperf +++ b/src/third_party/wiredtiger/bench/wtperf/runners/ycsb-f.wtperf @@ -5,7 +5,8 @@ key_sz=100 value_sz=1024 icount=120000000 run_time=3600 -threads=((count=10,reads=1),(count=10,modifies=1)) +sess_config="isolation=snapshot" +threads=((count=10,reads=1),(count=10,modify=1,ops_per_txn=1)) warmup=120 sample_interval=5 populate_threads=8 diff --git a/src/third_party/wiredtiger/build_cmake/helpers.cmake b/src/third_party/wiredtiger/build_cmake/helpers.cmake index 5593018284a..4dc449c0748 100644 --- a/src/third_party/wiredtiger/build_cmake/helpers.cmake +++ b/src/third_party/wiredtiger/build_cmake/helpers.cmake @@ -434,7 +434,7 @@ function(config_lib config_name description) message("-- Looking for library ${CONFIG_LIB_LIB}: found ${has_lib_${config_name}}, include path ${include_path_${config_name}}") include_directories(${include_path_${config_name}}) else() - message("-- Looking for library ${CONFIG_LIB_LIB}: found ${has_lib$_{config_name}}") + message("-- Looking for library ${CONFIG_LIB_LIB}: found ${has_lib_${config_name}}") endif() unset(include_path_${config_name} CACHE) else() diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py index c560a28eb11..43dadd9ff40 100644 --- a/src/third_party/wiredtiger/dist/api_data.py +++ b/src/third_party/wiredtiger/dist/api_data.py @@ -1573,6 +1573,11 @@ methods = { \c on setting causes the caller to wait until all work queued for this call to be completely processed before returning''', choices=['off', 'on']), + Config('timeout', '0', r''' + maximum amount of time to allow for waiting for previous flushing + of objects, in seconds. The actual amount of time spent waiting may + exceed the configured value. A value of zero disables the timeout''', + type='int'), ]), 'WT_SESSION.strerror' : Method([]), diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok index eb797977de4..99e582bdfc5 100644 --- a/src/third_party/wiredtiger/dist/s_string.ok +++ b/src/third_party/wiredtiger/dist/s_string.ok @@ -1062,6 +1062,7 @@ metadata metadata's metafile mfence +minSnapshotHistoryWindowInSeconds minorp mips mkdir diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py index aca6c6b2298..82c73e9f780 100644 --- a/src/third_party/wiredtiger/dist/stat_data.py +++ b/src/third_party/wiredtiger/dist/stat_data.py @@ -213,6 +213,7 @@ conn_stats = [ CacheStat('cache_eviction_fail_in_reconciliation', 'pages selected for eviction unable to be evicted because of failure in reconciliation'), CacheStat('cache_eviction_fail_parent_has_overflow_items', 'pages selected for eviction unable to be evicted as the parent page has overflow items'), CacheStat('cache_eviction_force', 'forced eviction - pages selected count'), + CacheStat('cache_eviction_force_long_update_list', 'forced eviction - pages selected because of a large number of updates to a single item'), CacheStat('cache_eviction_force_clean', 'forced eviction - pages evicted that were clean count'), CacheStat('cache_eviction_force_clean_time', 'forced eviction - pages evicted that were clean time (usecs)'), CacheStat('cache_eviction_force_delete', 'forced eviction - pages selected because of too many deleted items count'), diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data index 0c8a3bfad10..258ff799271 100644 --- a/src/third_party/wiredtiger/import.data +++ b/src/third_party/wiredtiger/import.data @@ -2,5 +2,5 @@ "vendor": "wiredtiger", "github": "wiredtiger/wiredtiger.git", "branch": "mongodb-5.0", - "commit": "87de78247074b291bbcf79c15d2a215af7cc2f7e" + "commit": "8b35a8d923eca1558aee73c45a5031ab65e82032" } diff --git a/src/third_party/wiredtiger/src/block/block_addr.c b/src/third_party/wiredtiger/src/block/block_addr.c index abaa0280330..1b06768f7de 100644 --- a/src/third_party/wiredtiger/src/block/block_addr.c +++ b/src/third_party/wiredtiger/src/block/block_addr.c @@ -8,24 +8,54 @@ #include "wt_internal.h" +#define WT_BLOCK_COOKIE_FILEID 0x01 /* The following bytes are an object ID. */ + /* - * __block_buffer_to_addr -- - * Convert a filesystem address cookie into its components, UPDATING the caller's buffer - * reference so it can be called repeatedly to load a buffer. + * __block_addr_unpack -- + * Unpack an address cookie into components, UPDATING the caller's buffer reference so this + * function can be called repeatedly to unpack a buffer containing multiple address cookies. */ static int -__block_buffer_to_addr(WT_BLOCK *block, const uint8_t **pp, uint32_t *objectidp, wt_off_t *offsetp, - uint32_t *sizep, uint32_t *checksump) +__block_addr_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t **pp, size_t addr_size, + uint32_t *objectidp, wt_off_t *offsetp, uint32_t *sizep, uint32_t *checksump) { - uint64_t l, o, s, c; + uint64_t i, o, s, c; + uint8_t flags; + const uint8_t *begin; - if (block->has_objects) - WT_RET(__wt_vunpack_uint(pp, 0, &l)); - else - l = 0; + /* + * Address cookies are a file offset, size and checksum triplet, with optional object ID: unpack + * the trailing object ID if there are bytes following the triple. The checkpoint cookie is more + * complicated: it has four address blocks all having the same object ID. Rather than retrofit + * the object ID into each of those address blocks (which would mean somehow figuring out the + * length of each individual address block), the object ID is appended to the end of the + * checkpoint cookie and this function skips the object ID unpack when the passed in cookie size + * is 0. (This feature is ONLY used by the checkpoint code, all other callers assert the cookie + * size is not 0. We could alternatively have a "checkpoint cookie" boolean, or use a NULL + * object ID address when never returning a object ID, but a cookie size of 0 seems equivalent.) + */ + begin = *pp; WT_RET(__wt_vunpack_uint(pp, 0, &o)); WT_RET(__wt_vunpack_uint(pp, 0, &s)); WT_RET(__wt_vunpack_uint(pp, 0, &c)); + i = 0; + flags = 0; + if (addr_size != 0 && WT_PTRDIFF(*pp, begin) < addr_size) { + flags = **pp; + ++(*pp); + if (LF_ISSET(WT_BLOCK_COOKIE_FILEID)) + WT_RET(__wt_vunpack_uint(pp, 0, &i)); + } + + /* + * If there's an address cookie size and either there is no flag value or the flag value is the + * object ID flag by itself, assert the cookie was entirely consumed. Future extensions will use + * different cookie flag values (although the file-ID flag might still be set, our test is for + * equality). + */ + WT_ASSERT(session, + addr_size == 0 || (flags != 0 && flags != WT_BLOCK_COOKIE_FILEID) || + WT_PTRDIFF(*pp, begin) == addr_size); /* * To avoid storing large offsets, we minimize the value by subtracting a block for description @@ -37,60 +67,73 @@ __block_buffer_to_addr(WT_BLOCK *block, const uint8_t **pp, uint32_t *objectidp, * that's simpler than testing sizes of 0 all over the place. */ if (s == 0) { + *objectidp = 0; *offsetp = 0; - *objectidp = *sizep = *checksump = 0; + *sizep = *checksump = 0; } else { - if (block->has_objects && l == 0 && o != WT_BLOCK_INVALID_OFFSET) - WT_RET_MSG(NULL, EINVAL, "address cookie decoding for Btree with objects has object 0"); - *objectidp = (uint32_t)l; + *objectidp = (uint32_t)i; *offsetp = (wt_off_t)(o + 1) * block->allocsize; *sizep = (uint32_t)s * block->allocsize; *checksump = (uint32_t)c; } + return (0); } /* - * __wt_block_addr_to_buffer -- - * Convert the filesystem components into its address cookie. + * __wt_block_addr_pack -- + * Pack components into an address cookie, UPDATING the caller's buffer reference. */ int -__wt_block_addr_to_buffer(WT_BLOCK *block, uint8_t **pp, uint32_t objectid, wt_off_t offset, +__wt_block_addr_pack(WT_BLOCK *block, uint8_t **pp, uint32_t objectid, wt_off_t offset, uint32_t size, uint32_t checksum) { - uint64_t l, o, s, c; + uint64_t i, o, s, c; - /* See the comment above: this is the reverse operation. */ + /* See the comment above about storing large offsets: this is the reverse operation. */ if (size == 0) { + i = 0; o = WT_BLOCK_INVALID_OFFSET; - l = s = c = 0; + s = c = 0; } else { - l = objectid; + i = objectid; o = (uint64_t)offset / block->allocsize - 1; s = size / block->allocsize; c = checksum; } - if (block->has_objects) { - if (l == 0 && o != WT_BLOCK_INVALID_OFFSET) - WT_RET_MSG(NULL, EINVAL, "address cookie encoding for Btree with objects has object 0"); - WT_RET(__wt_vpack_uint(pp, 0, l)); - } WT_RET(__wt_vpack_uint(pp, 0, o)); WT_RET(__wt_vpack_uint(pp, 0, s)); WT_RET(__wt_vpack_uint(pp, 0, c)); + + /* + * Don't store object IDs of zero, the function that cracks the cookie defaults IDs to 0. + * + * TODO: testing has-objects is not quite right. Ideally, we don't store a object ID if there's + * only a single object. We want to be able to convert existing object to a stack, which means + * starting with a single object with no object IDs, where all future objects in the stack know + * a missing object ID is a reference to the base object. + */ + if (i != 0 && block->has_objects) { + **pp = WT_BLOCK_COOKIE_FILEID; + ++(*pp); + WT_RET(__wt_vpack_uint(pp, 0, i)); + } return (0); } /* - * __wt_block_buffer_to_addr -- - * Convert a filesystem address cookie into its components NOT UPDATING the caller's buffer - * reference. + * __wt_block_addr_unpack -- + * Unpack an address cookie into components, NOT UPDATING the caller's buffer reference. */ int -__wt_block_buffer_to_addr(WT_BLOCK *block, const uint8_t *p, uint32_t *objectidp, wt_off_t *offsetp, - uint32_t *sizep, uint32_t *checksump) +__wt_block_addr_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *p, + size_t addr_size, uint32_t *objectidp, wt_off_t *offsetp, uint32_t *sizep, uint32_t *checksump) { - return (__block_buffer_to_addr(block, &p, objectidp, offsetp, sizep, checksump)); + /* Checkpoint passes zero as the cookie size, nobody else should. */ + WT_ASSERT(session, addr_size != 0); + + return ( + __block_addr_unpack(session, block, &p, addr_size, objectidp, offsetp, sizep, checksump)); } /* @@ -104,12 +147,11 @@ __wt_block_addr_invalid( wt_off_t offset; uint32_t checksum, objectid, size; - WT_UNUSED(session); - WT_UNUSED(addr_size); WT_UNUSED(live); /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); #ifdef HAVE_DIAGNOSTIC /* @@ -135,10 +177,9 @@ __wt_block_addr_string( wt_off_t offset; uint32_t checksum, objectid, size; - WT_UNUSED(addr_size); - /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); /* Printable representation. */ WT_RET(__wt_buf_fmt(session, buf, @@ -149,46 +190,75 @@ __wt_block_addr_string( } /* - * __block_buffer_to_ckpt -- + * __block_ckpt_unpack -- * Convert a checkpoint cookie into its components. */ static int -__block_buffer_to_ckpt( - WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *p, WT_BLOCK_CKPT *ci) +__block_ckpt_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *ckpt, + size_t ckpt_size, WT_BLOCK_CKPT *ci) { uint64_t a; - const uint8_t **pp; + uint32_t objectid; + uint8_t flags; + const uint8_t *begin; - ci->version = *p++; + begin = ckpt; + + ci->version = ckpt[0]; if (ci->version != WT_BM_CHECKPOINT_VERSION) WT_RET_MSG(session, WT_ERROR, "unsupported checkpoint version"); - pp = &p; - WT_RET(__block_buffer_to_addr( - block, pp, &ci->root_objectid, &ci->root_offset, &ci->root_size, &ci->root_checksum)); - WT_RET(__block_buffer_to_addr( - block, pp, &ci->alloc.objectid, &ci->alloc.offset, &ci->alloc.size, &ci->alloc.checksum)); - WT_RET(__block_buffer_to_addr( - block, pp, &ci->avail.objectid, &ci->avail.offset, &ci->avail.size, &ci->avail.checksum)); - WT_RET(__block_buffer_to_addr(block, pp, &ci->discard.objectid, &ci->discard.offset, + /* + * See the comment above about address cookies and sizes for an explanation. + * + * Passing an address cookie size of 0 so the unpack function doesn't read an object ID. + */ + ++ckpt; + WT_RET(__block_addr_unpack(session, block, &ckpt, 0, &ci->root_objectid, &ci->root_offset, + &ci->root_size, &ci->root_checksum)); + WT_RET(__block_addr_unpack(session, block, &ckpt, 0, &ci->alloc.objectid, &ci->alloc.offset, + &ci->alloc.size, &ci->alloc.checksum)); + WT_RET(__block_addr_unpack(session, block, &ckpt, 0, &ci->avail.objectid, &ci->avail.offset, + &ci->avail.size, &ci->avail.checksum)); + WT_RET(__block_addr_unpack(session, block, &ckpt, 0, &ci->discard.objectid, &ci->discard.offset, &ci->discard.size, &ci->discard.checksum)); - WT_RET(__wt_vunpack_uint(pp, 0, &a)); + WT_RET(__wt_vunpack_uint(&ckpt, 0, &a)); ci->file_size = (wt_off_t)a; - WT_RET(__wt_vunpack_uint(pp, 0, &a)); + WT_RET(__wt_vunpack_uint(&ckpt, 0, &a)); ci->ckpt_size = a; + /* The first part of the checkpoint cookie is optionally followed by an object ID. */ + objectid = 0; + flags = 0; + if (WT_PTRDIFF(ckpt, begin) != ckpt_size) { + flags = *ckpt++; + if (LF_ISSET(WT_BLOCK_COOKIE_FILEID)) { + WT_RET(__wt_vunpack_uint(&ckpt, 0, &a)); + objectid = (uint32_t)a; + } + } + ci->root_objectid = ci->alloc.objectid = ci->avail.objectid = ci->discard.objectid = objectid; + + /* + * If there is no flag value or the flag value is the object ID flag by itself, assert the + * cookie was entirely consumed. Future extensions will use different cookie flag values + * (although the file-ID flag might still be set, our test is for equality). + */ + WT_ASSERT(session, + (flags != 0 && flags != WT_BLOCK_COOKIE_FILEID) || WT_PTRDIFF(ckpt, begin) == ckpt_size); + return (0); } /* - * __wt_block_buffer_to_ckpt -- + * __wt_block_ckpt_unpack -- * Convert a checkpoint cookie into its components, block manager version. */ int -__wt_block_buffer_to_ckpt( - WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *p, WT_BLOCK_CKPT *ci) +__wt_block_ckpt_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *ckpt, + size_t ckpt_size, WT_BLOCK_CKPT *ci) { - return (__block_buffer_to_ckpt(session, block, p, ci)); + return (__block_ckpt_unpack(session, block, ckpt, ckpt_size, ci)); } /* @@ -196,27 +266,24 @@ __wt_block_buffer_to_ckpt( * Convert a checkpoint cookie into its components, external utility version. */ int -__wt_block_ckpt_decode(WT_SESSION *wt_session, WT_BLOCK *block, const uint8_t *p, WT_BLOCK_CKPT *ci) - WT_GCC_FUNC_ATTRIBUTE((visibility("default"))) +__wt_block_ckpt_decode(WT_SESSION *wt_session, WT_BLOCK *block, const uint8_t *ckpt, + size_t ckpt_size, WT_BLOCK_CKPT *ci) WT_GCC_FUNC_ATTRIBUTE((visibility("default"))) { WT_SESSION_IMPL *session; session = (WT_SESSION_IMPL *)wt_session; - return (__block_buffer_to_ckpt(session, block, p, ci)); + return (__block_ckpt_unpack(session, block, ckpt, ckpt_size, ci)); } /* - * __wt_block_ckpt_to_buffer -- + * __wt_block_ckpt_pack -- * Convert the components into its checkpoint cookie. */ int -__wt_block_ckpt_to_buffer( +__wt_block_ckpt_pack( WT_SESSION_IMPL *session, WT_BLOCK *block, uint8_t **pp, WT_BLOCK_CKPT *ci, bool skip_avail) { uint64_t a; - uint32_t objectid; - - objectid = block->objectid; if (ci->version != WT_BM_CHECKPOINT_VERSION) WT_RET_MSG(session, WT_ERROR, "unsupported checkpoint version"); @@ -224,21 +291,32 @@ __wt_block_ckpt_to_buffer( (*pp)[0] = ci->version; (*pp)++; - WT_RET(__wt_block_addr_to_buffer( - block, pp, objectid, ci->root_offset, ci->root_size, ci->root_checksum)); - WT_RET(__wt_block_addr_to_buffer( - block, pp, objectid, ci->alloc.offset, ci->alloc.size, ci->alloc.checksum)); + /* + * See the comment above about address cookies and sizes for an explanation. + * + * Passing an object ID of 0 so the pack function doesn't store an object ID. + */ + WT_RET(__wt_block_addr_pack(block, pp, 0, ci->root_offset, ci->root_size, ci->root_checksum)); + WT_RET( + __wt_block_addr_pack(block, pp, 0, ci->alloc.offset, ci->alloc.size, ci->alloc.checksum)); if (skip_avail) - WT_RET(__wt_block_addr_to_buffer(block, pp, 0, 0, 0, 0)); + WT_RET(__wt_block_addr_pack(block, pp, 0, 0, 0, 0)); else - WT_RET(__wt_block_addr_to_buffer( - block, pp, objectid, ci->avail.offset, ci->avail.size, ci->avail.checksum)); - WT_RET(__wt_block_addr_to_buffer( - block, pp, objectid, ci->discard.offset, ci->discard.size, ci->discard.checksum)); + WT_RET( + __wt_block_addr_pack(block, pp, 0, ci->avail.offset, ci->avail.size, ci->avail.checksum)); + WT_RET(__wt_block_addr_pack( + block, pp, 0, ci->discard.offset, ci->discard.size, ci->discard.checksum)); a = (uint64_t)ci->file_size; WT_RET(__wt_vpack_uint(pp, 0, a)); a = ci->ckpt_size; WT_RET(__wt_vpack_uint(pp, 0, a)); + /* Don't store object IDs of zero, the function that cracks the cookie defaults IDs to 0. */ + if (block->objectid != 0) { + **pp = WT_BLOCK_COOKIE_FILEID; + ++(*pp); + a = block->objectid; + WT_RET(__wt_vpack_uint(pp, 0, a)); + } return (0); } @@ -249,7 +327,7 @@ __wt_block_ckpt_to_buffer( */ void __wt_ckpt_verbose(WT_SESSION_IMPL *session, WT_BLOCK *block, const char *tag, const char *ckpt_name, - const uint8_t *ckpt_string) + const uint8_t *ckpt_string, size_t ckpt_size) { WT_BLOCK_CKPT *ci, _ci; WT_DECL_ITEM(tmp); @@ -264,10 +342,11 @@ __wt_ckpt_verbose(WT_SESSION_IMPL *session, WT_BLOCK *block, const char *tag, co /* Initialize the checkpoint, crack the cookie. */ ci = &_ci; WT_ERR(__wt_block_ckpt_init(session, ci, "string")); - WT_ERR(__wt_block_buffer_to_ckpt(session, block, ckpt_string, ci)); + WT_ERR(__wt_block_ckpt_unpack(session, block, ckpt_string, ckpt_size, ci)); WT_ERR(__wt_scr_alloc(session, 0, &tmp)); WT_ERR(__wt_buf_fmt(session, tmp, "version=%" PRIu8, ci->version)); + WT_ERR(__wt_buf_catfmt(session, tmp, ", object ID=%" PRIu32, ci->root_objectid)); if (ci->root_offset == WT_BLOCK_INVALID_OFFSET) WT_ERR(__wt_buf_catfmt(session, tmp, ", root=[Empty]")); else diff --git a/src/third_party/wiredtiger/src/block/block_ckpt.c b/src/third_party/wiredtiger/src/block/block_ckpt.c index 54a1f98942e..addcd9b447f 100644 --- a/src/third_party/wiredtiger/src/block/block_ckpt.c +++ b/src/third_party/wiredtiger/src/block/block_ckpt.c @@ -52,7 +52,7 @@ __wt_block_checkpoint_load(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint ci = NULL; if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) - __wt_ckpt_verbose(session, block, "load", NULL, addr); + __wt_ckpt_verbose(session, block, "load", NULL, addr, addr_size); /* * There's a single checkpoint in the file that can be written, all of the others are read-only. @@ -85,7 +85,7 @@ __wt_block_checkpoint_load(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint ci->file_size = block->allocsize; else { /* Crack the checkpoint cookie. */ - WT_ERR(__wt_block_buffer_to_ckpt(session, block, addr, ci)); + WT_ERR(__wt_block_ckpt_unpack(session, block, addr, addr_size, ci)); /* Verify sets up next. */ if (block->verify) @@ -94,7 +94,7 @@ __wt_block_checkpoint_load(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint /* Read any root page. */ if (ci->root_offset != WT_BLOCK_INVALID_OFFSET) { endp = root_addr; - WT_ERR(__wt_block_addr_to_buffer( + WT_ERR(__wt_block_addr_pack( block, &endp, ci->root_objectid, ci->root_offset, ci->root_size, ci->root_checksum)); *root_addr_sizep = WT_PTRDIFF(endp, root_addr); } @@ -283,7 +283,7 @@ __ckpt_extlist_read(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckpt) ci = ckpt->bpriv; WT_RET(__wt_block_ckpt_init(session, ci, ckpt->name)); - WT_RET(__wt_block_buffer_to_ckpt(session, block, ckpt->raw.data, ci)); + WT_RET(__wt_block_ckpt_unpack(session, block, ckpt->raw.data, ckpt->raw.size, ci)); WT_RET(__wt_block_extlist_read(session, block, &ci->alloc, ci->file_size)); WT_RET(__wt_block_extlist_read(session, block, &ci->discard, ci->file_size)); @@ -614,7 +614,7 @@ __ckpt_process(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckptbase) continue; if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) - __wt_ckpt_verbose(session, block, "delete", ckpt->name, ckpt->raw.data); + __wt_ckpt_verbose(session, block, "delete", ckpt->name, ckpt->raw.data, ckpt->raw.size); /* * Find the checkpoint into which we'll roll this checkpoint's blocks: it's the next real @@ -814,7 +814,7 @@ __ckpt_update( */ WT_RET(__wt_buf_init(session, &ckpt->raw, WT_BLOCK_CHECKPOINT_BUFFER)); endp = ckpt->raw.mem; - WT_RET(__wt_block_ckpt_to_buffer(session, block, &endp, ci, true)); + WT_RET(__wt_block_ckpt_pack(session, block, &endp, ci, true)); ckpt->raw.size = WT_PTRDIFF(endp, ckpt->raw.mem); /* @@ -883,11 +883,11 @@ __ckpt_update( /* Copy the COMPLETE checkpoint information into the checkpoint. */ WT_RET(__wt_buf_init(session, &ckpt->raw, WT_BLOCK_CHECKPOINT_BUFFER)); endp = ckpt->raw.mem; - WT_RET(__wt_block_ckpt_to_buffer(session, block, &endp, ci, false)); + WT_RET(__wt_block_ckpt_pack(session, block, &endp, ci, false)); ckpt->raw.size = WT_PTRDIFF(endp, ckpt->raw.mem); if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) - __wt_ckpt_verbose(session, block, "create", ckpt->name, ckpt->raw.data); + __wt_ckpt_verbose(session, block, "create", ckpt->name, ckpt->raw.data, ckpt->raw.size); return (0); } diff --git a/src/third_party/wiredtiger/src/block/block_ckpt_scan.c b/src/third_party/wiredtiger/src/block/block_ckpt_scan.c index b419a42ed73..74b2257b7a0 100644 --- a/src/third_party/wiredtiger/src/block/block_ckpt_scan.c +++ b/src/third_party/wiredtiger/src/block/block_ckpt_scan.c @@ -176,24 +176,26 @@ __block_checkpoint_update(WT_SESSION_IMPL *session, WT_BLOCK *block, struct save checkpoint = info->checkpoint; if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) - __wt_ckpt_verbose(session, block, "import original", NULL, checkpoint->mem); + __wt_ckpt_verbose( + session, block, "import original", NULL, checkpoint->mem, checkpoint->size); /* * Convert the final checkpoint data blob to a WT_BLOCK_CKPT structure, update it with the avail * list information, and convert it back to a data blob. */ - WT_RET(__wt_block_buffer_to_ckpt(session, block, checkpoint->data, &ci)); + WT_RET(__wt_block_ckpt_unpack(session, block, checkpoint->data, checkpoint->size, &ci)); ci.avail.offset = info->offset; ci.avail.size = info->size; ci.avail.checksum = info->checksum; ci.file_size = (wt_off_t)info->file_size; WT_RET(__wt_buf_extend(session, checkpoint, WT_BLOCK_CHECKPOINT_BUFFER)); endp = checkpoint->mem; - WT_RET(__wt_block_ckpt_to_buffer(session, block, &endp, &ci, false)); + WT_RET(__wt_block_ckpt_pack(session, block, &endp, &ci, false)); checkpoint->size = WT_PTRDIFF(endp, checkpoint->mem); if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) - __wt_ckpt_verbose(session, block, "import replace", NULL, checkpoint->mem); + __wt_ckpt_verbose( + session, block, "import replace", NULL, checkpoint->mem, checkpoint->size); return (0); } diff --git a/src/third_party/wiredtiger/src/block/block_compact.c b/src/third_party/wiredtiger/src/block/block_compact.c index 735b4d5c4f4..6d7e87edbee 100644 --- a/src/third_party/wiredtiger/src/block/block_compact.c +++ b/src/third_party/wiredtiger/src/block/block_compact.c @@ -138,11 +138,11 @@ __wt_block_compact_page_skip( wt_off_t limit, offset; uint32_t checksum, objectid, size; - WT_UNUSED(addr_size); *skipp = true; /* Return a default skip. */ /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); /* * If this block is in the chosen percentage of the file and there's a block on the available diff --git a/src/third_party/wiredtiger/src/block/block_ext.c b/src/third_party/wiredtiger/src/block/block_ext.c index 70903985d57..37916e482de 100644 --- a/src/third_party/wiredtiger/src/block/block_ext.c +++ b/src/third_party/wiredtiger/src/block/block_ext.c @@ -565,11 +565,15 @@ __wt_block_free(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr, wt_off_t offset; uint32_t checksum, objectid, size; - WT_UNUSED(addr_size); WT_STAT_DATA_INCR(session, block_free); /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); + + /* We can't reuse free space in an object. */ + if (objectid != block->objectid) + return (0); __wt_verbose(session, WT_VERB_BLOCK, "free %" PRIu32 ": %" PRIdMAX "/%" PRIdMAX, objectid, (intmax_t)offset, (intmax_t)size); @@ -578,12 +582,11 @@ __wt_block_free(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr, WT_RET(__wt_block_misplaced( session, block, "free", offset, size, true, __PRETTY_FUNCTION__, __LINE__)); #endif - if (objectid == block->objectid) { - WT_RET(__wt_block_ext_prealloc(session, 5)); - __wt_spin_lock(session, &block->live_lock); - ret = __wt_block_off_free(session, block, objectid, offset, (wt_off_t)size); - __wt_spin_unlock(session, &block->live_lock); - } + + WT_RET(__wt_block_ext_prealloc(session, 5)); + __wt_spin_lock(session, &block->live_lock); + ret = __wt_block_off_free(session, block, objectid, offset, (wt_off_t)size); + __wt_spin_unlock(session, &block->live_lock); return (ret); } diff --git a/src/third_party/wiredtiger/src/block/block_read.c b/src/third_party/wiredtiger/src/block/block_read.c index 796d071b305..3fec75acfe8 100644 --- a/src/third_party/wiredtiger/src/block/block_read.c +++ b/src/third_party/wiredtiger/src/block/block_read.c @@ -29,7 +29,8 @@ __wt_bm_preload(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t WT_STAT_CONN_INCR(session, block_preload); /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); WT_RET(__wt_block_fh(session, block, objectid, &fh)); handle = fh->handle; @@ -67,11 +68,11 @@ __wt_bm_read( uint32_t checksum, objectid, size; bool mapped; - WT_UNUSED(addr_size); block = bm->block; /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); /* * Map the block if it's possible. @@ -165,7 +166,8 @@ __wt_bm_corrupt(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t WT_ERR(__wt_bm_read(bm, session, tmp, addr, addr_size)); /* Crack the cookie, dump the block. */ - WT_ERR(__wt_block_buffer_to_addr(bm->block, addr, &objectid, &offset, &size, &checksum)); + WT_ERR(__wt_block_addr_unpack( + session, bm->block, addr, addr_size, &objectid, &offset, &size, &checksum)); WT_ERR(__wt_bm_corrupt_dump(session, tmp, objectid, offset, size, checksum)); err: @@ -207,21 +209,6 @@ err: #endif /* - * __wt_block_fh -- - * Get a block file handle. - */ -int -__wt_block_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t objectid, WT_FH **fhp) -{ - if (!block->has_objects) - *fhp = block->fh; - else - WT_RET(__wt_block_tiered_fh(session, block, objectid, fhp)); - - return (0); -} - -/* * __wt_block_read_off -- * Read an addr/size pair referenced block into a buffer. */ diff --git a/src/third_party/wiredtiger/src/block/block_slvg.c b/src/third_party/wiredtiger/src/block/block_slvg.c index 46a87e76f10..32c8f8fc8ed 100644 --- a/src/third_party/wiredtiger/src/block/block_slvg.c +++ b/src/third_party/wiredtiger/src/block/block_slvg.c @@ -152,7 +152,7 @@ __wt_block_salvage_next( /* Re-create the address cookie that should reference this block. */ endp = addr; - WT_ERR(__wt_block_addr_to_buffer(block, &endp, objectid, offset, size, checksum)); + WT_ERR(__wt_block_addr_pack(block, &endp, objectid, offset, size, checksum)); *addr_sizep = WT_PTRDIFF(endp, addr); done: @@ -172,13 +172,12 @@ __wt_block_salvage_valid( wt_off_t offset; uint32_t size, objectid, checksum; - WT_UNUSED(addr_size); - /* * Crack the cookie. If the upper layer took the block, move past it; if the upper layer * rejected the block, move past an allocation size chunk and free it. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); if (valid) block->slvg_off = offset + size; else { diff --git a/src/third_party/wiredtiger/src/block/block_tiered.c b/src/third_party/wiredtiger/src/block/block_tiered.c index 2733e9a1386..d912b058d30 100644 --- a/src/third_party/wiredtiger/src/block/block_tiered.c +++ b/src/third_party/wiredtiger/src/block/block_tiered.c @@ -15,7 +15,6 @@ static int __block_switch_writeable(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id) { - WT_DECL_RET; WT_FH *new_fh, *old_fh; /* @@ -25,27 +24,29 @@ __block_switch_writeable(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t obj * requests in flight. */ old_fh = block->fh; - WT_ERR(block->opener->open( + WT_RET(block->opener->open( block->opener, session, object_id, WT_FS_OPEN_FILE_TYPE_DATA, block->file_flags, &new_fh)); block->fh = new_fh; block->objectid = object_id; - WT_ERR(__wt_close(session, &old_fh)); - -err: - return (ret); + return (__wt_close(session, &old_fh)); } /* - * __wt_block_tiered_fh -- - * Open an object from the shared tier. + * __wt_block_fh -- + * Get a block file handle. */ int -__wt_block_tiered_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id, WT_FH **fhp) +__wt_block_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id, WT_FH **fhp) { - WT_DECL_ITEM(tmp); WT_DECL_RET; + /* It's the local object if there's no object ID or the object ID matches our own. */ + if (object_id == 0 || object_id == block->objectid) { + *fhp = block->fh; + return (0); + } + /* * FIXME-WT-7470: take a read lock to get a handle, and a write lock to open a handle or extend * the array. @@ -63,15 +64,24 @@ __wt_block_tiered_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_ if ((*fhp = block->ofh[object_id]) != NULL) return (0); - WT_RET(__wt_scr_alloc(session, 0, &tmp)); - WT_ERR(block->opener->open(block->opener, session, object_id, WT_FS_OPEN_FILE_TYPE_DATA, - WT_FS_OPEN_READONLY | block->file_flags, &block->ofh[object_id])); - *fhp = block->ofh[object_id]; - WT_ASSERT(session, *fhp != NULL); + /* + * Fail gracefully if we don't have an opener, or if the opener fails: a release that can't read + * tiered storage blocks might have been pointed at a file that it can read, but that references + * files it doesn't know about, or there may have been some other mismatch. Regardless, we want + * to log a specific error message, we're missing a file. + */ + ret = block->opener->open == NULL ? + WT_NOTFOUND : + block->opener->open(block->opener, session, object_id, WT_FS_OPEN_FILE_TYPE_DATA, + WT_FS_OPEN_READONLY | block->file_flags, &block->ofh[object_id]); + if (ret == 0) { + *fhp = block->ofh[object_id]; + return (0); + } -err: - __wt_scr_free(session, &tmp); - return (ret); + WT_RET_MSG(session, ret, + "object %s with ID %" PRIu32 " referenced unknown object with ID %" PRIu32, block->name, + block->objectid, object_id); } /* diff --git a/src/third_party/wiredtiger/src/block/block_vrfy.c b/src/third_party/wiredtiger/src/block/block_vrfy.c index 28c95415254..01ec16f59ab 100644 --- a/src/third_party/wiredtiger/src/block/block_vrfy.c +++ b/src/third_party/wiredtiger/src/block/block_vrfy.c @@ -119,7 +119,7 @@ __verify_last_avail(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckpt) ci = &_ci; WT_RET(__wt_block_ckpt_init(session, ci, ckpt->name)); - WT_ERR(__wt_block_buffer_to_ckpt(session, block, ckpt->raw.data, ci)); + WT_ERR(__wt_block_ckpt_unpack(session, block, ckpt->raw.data, ckpt->raw.size, ci)); el = &ci->avail; if (el->offset != WT_BLOCK_INVALID_OFFSET) { @@ -148,7 +148,7 @@ __verify_set_file_size(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckpt) ci = &_ci; WT_RET(__wt_block_ckpt_init(session, ci, ckpt->name)); - WT_ERR(__wt_block_buffer_to_ckpt(session, block, ckpt->raw.data, ci)); + WT_ERR(__wt_block_ckpt_unpack(session, block, ckpt->raw.data, ckpt->raw.size, ci)); if (block->verify_layout) { WT_ERR(__wt_scr_alloc(session, 0, &tmp)); @@ -318,10 +318,9 @@ __wt_block_verify_addr( wt_off_t offset; uint32_t checksum, objectid, size; - WT_UNUSED(addr_size); - /* Crack the cookie. */ - WT_RET(__wt_block_buffer_to_addr(block, addr, &objectid, &offset, &size, &checksum)); + WT_RET(__wt_block_addr_unpack( + session, block, addr, addr_size, &objectid, &offset, &size, &checksum)); /* Add to the per-file list. */ WT_RET(__verify_filefrag_add(session, block, NULL, offset, size, false)); diff --git a/src/third_party/wiredtiger/src/block/block_write.c b/src/third_party/wiredtiger/src/block/block_write.c index 72381c5492d..442d69927f8 100644 --- a/src/third_party/wiredtiger/src/block/block_write.c +++ b/src/third_party/wiredtiger/src/block/block_write.c @@ -196,7 +196,7 @@ __wt_block_write(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, uint8_ data_checksum, checkpoint_io, false)); endp = addr; - WT_RET(__wt_block_addr_to_buffer(block, &endp, objectid, offset, size, checksum)); + WT_RET(__wt_block_addr_pack(block, &endp, objectid, offset, size, checksum)); *addr_sizep = WT_PTRDIFF(endp, addr); return (0); diff --git a/src/third_party/wiredtiger/src/btree/bt_debug.c b/src/third_party/wiredtiger/src/btree/bt_debug.c index 0e8daa06e34..81f419184f5 100644 --- a/src/third_party/wiredtiger/src/btree/bt_debug.c +++ b/src/third_party/wiredtiger/src/btree/bt_debug.c @@ -383,17 +383,19 @@ __wt_debug_offset( /* * This routine depends on the default block manager's view of files, where an address consists - * of a file offset, length, and checksum. This is for debugging only: other block managers - * might not see a file or address the same way, that's why there's no block manager method. + * of a file ID, file offset, length, and checksum. This is only for debugging, other block + * managers might not describe underlying objects the same way, that's why there's no block + * manager method. * * Convert the triplet into an address structure. */ block = S2BT(session)->bm->block; endp = addr; - WT_RET(__wt_block_addr_to_buffer(block, &endp, block->objectid, offset, size, checksum)); + WT_RET(__wt_block_addr_pack(block, &endp, block->objectid, offset, size, checksum)); /* - * Read the address through the btree I/O functions (so the block is decompressed as necessary). + * Read the address through the btree I/O functions (so the block is decompressed and/or + * unencrypted as necessary). */ WT_RET(__wt_scr_alloc(session, 0, &buf)); WT_ERR(__wt_bt_read(session, buf, addr, WT_PTRDIFF(endp, addr))); diff --git a/src/third_party/wiredtiger/src/btree/bt_split.c b/src/third_party/wiredtiger/src/btree/bt_split.c index c3af3cbb2e4..e6ca5c7118b 100644 --- a/src/third_party/wiredtiger/src/btree/bt_split.c +++ b/src/third_party/wiredtiger/src/btree/bt_split.c @@ -520,8 +520,6 @@ __split_root(WT_SESSION_IMPL *session, WT_PAGE *root) * * Note: as the root page cannot currently be evicted, the root split generation isn't ever * used. That said, it future proofs eviction and isn't expensive enough to special-case. - * - * Getting a new split generation implies a full barrier, no additional barrier is needed. */ WT_FULL_BARRIER(); split_gen = __wt_gen(session, WT_GEN_SPLIT); @@ -772,8 +770,6 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new, uint32_t * Get a generation for this split, mark the page. This must be after the new index is swapped * into place in order to know that no readers with the new generation will look at the old * index. - * - * Getting a new split generation implies a full barrier, no additional barrier is needed. */ WT_FULL_BARRIER(); split_gen = __wt_gen(session, WT_GEN_SPLIT); @@ -1044,8 +1040,6 @@ __split_internal(WT_SESSION_IMPL *session, WT_PAGE *parent, WT_PAGE *page) * Get a generation for this split, mark the parent page. This must be after the new index is * swapped into place in order to know that no readers with the new generation will look at the * old index. - * - * Getting a new split generation implies a full barrier, no additional barrier is needed. */ WT_FULL_BARRIER(); split_gen = __wt_gen(session, WT_GEN_SPLIT); diff --git a/src/third_party/wiredtiger/src/btree/bt_sync.c b/src/third_party/wiredtiger/src/btree/bt_sync.c index d6a02ca1a30..9a157903053 100644 --- a/src/third_party/wiredtiger/src/btree/bt_sync.c +++ b/src/third_party/wiredtiger/src/btree/bt_sync.c @@ -385,6 +385,12 @@ __sync_page_skip(WT_SESSION_IMPL *session, WT_REF *ref, void *context, bool *ski if (ref->state != WT_REF_DISK) return (0); + /* Don't read any pages when the cache is operating in aggressive mode. */ + if (__wt_cache_aggressive(session)) { + *skipp = true; + return (0); + } + /* Don't read pages into cache during startup or shutdown phase. */ if (F_ISSET(S2C(session), WT_CONN_RECOVERING | WT_CONN_CLOSING_TIMESTAMP)) { *skipp = true; diff --git a/src/third_party/wiredtiger/src/btree/row_modify.c b/src/third_party/wiredtiger/src/btree/row_modify.c index 7c13e88e2be..5ecbd33fe3b 100644 --- a/src/third_party/wiredtiger/src/btree/row_modify.c +++ b/src/third_party/wiredtiger/src/btree/row_modify.c @@ -307,18 +307,21 @@ __wt_row_insert_alloc(WT_SESSION_IMPL *session, const WT_ITEM *key, u_int skipde /* * __wt_update_obsolete_check -- - * Check for obsolete updates. + * Check for obsolete updates and force evict the page if the update list is too long. */ WT_UPDATE * __wt_update_obsolete_check( - WT_SESSION_IMPL *session, WT_PAGE *page, WT_UPDATE *upd, bool update_accounting) + WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_UPDATE *upd, bool update_accounting) { + WT_PAGE *page; WT_TXN_GLOBAL *txn_global; WT_UPDATE *first, *next; size_t size; uint64_t oldest, stable; u_int count, upd_seen, upd_unstable; + next = NULL; + page = cbt->ref->page; txn_global = &S2C(session)->txn_global; upd_seen = upd_unstable = 0; @@ -372,10 +375,23 @@ __wt_update_obsolete_check( if (size != 0) __wt_cache_page_inmem_decr(session, page, size); } - return (next); } /* + * Force evict a page when there are more than WT_THOUSAND updates to a single item. Increasing + * the minSnapshotHistoryWindowInSeconds to 300 introduced a performance regression in which the + * average number of updates on a single item was approximately 1000 in write-heavy workloads. + * This is why we use WT_THOUSAND here. + */ + if (count > WT_THOUSAND) { + WT_STAT_CONN_INCR(session, cache_eviction_force_long_update_list); + __wt_page_evict_soon(session, cbt->ref); + } + + if (next != NULL) + return (next); + + /* * If the list is long, don't retry checks on this page until the transaction state has moved * forwards. This function is used to trim update lists independently of the page state, ensure * there is a modify structure. diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c index 75f2db226f2..168c3824d8e 100644 --- a/src/third_party/wiredtiger/src/config/config_def.c +++ b/src/third_party/wiredtiger/src/config/config_def.c @@ -329,7 +329,8 @@ static const WT_CONFIG_CHECK confchk_WT_SESSION_drop[] = { static const WT_CONFIG_CHECK confchk_WT_SESSION_flush_tier[] = { {"flush_timestamp", "string", NULL, NULL, NULL, 0}, {"force", "boolean", NULL, NULL, NULL, 0}, {"lock_wait", "boolean", NULL, NULL, NULL, 0}, - {"sync", "string", NULL, "choices=[\"off\",\"on\"]", NULL, 0}, {NULL, NULL, NULL, NULL, NULL, 0}}; + {"sync", "string", NULL, "choices=[\"off\",\"on\"]", NULL, 0}, + {"timeout", "int", NULL, NULL, NULL, 0}, {NULL, NULL, NULL, NULL, NULL, 0}}; static const WT_CONFIG_CHECK confchk_WT_SESSION_join[] = { {"bloom_bit_count", "int", NULL, "min=2,max=1000", NULL, 0}, @@ -1211,8 +1212,8 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator", "checkpoint_wait=true,force=false,lock_wait=true," "remove_files=true", confchk_WT_SESSION_drop, 4}, - {"WT_SESSION.flush_tier", "flush_timestamp=,force=false,lock_wait=true,sync=on", - confchk_WT_SESSION_flush_tier, 4}, + {"WT_SESSION.flush_tier", "flush_timestamp=,force=false,lock_wait=true,sync=on,timeout=0", + confchk_WT_SESSION_flush_tier, 5}, {"WT_SESSION.join", "bloom_bit_count=16,bloom_false_positives=false," "bloom_hash_count=8,compare=\"eq\",count=,operation=\"and\"," diff --git a/src/third_party/wiredtiger/src/conn/conn_tiered.c b/src/third_party/wiredtiger/src/conn/conn_tiered.c index 39524e0758b..58b2026c5b8 100644 --- a/src/third_party/wiredtiger/src/conn/conn_tiered.c +++ b/src/third_party/wiredtiger/src/conn/conn_tiered.c @@ -23,20 +23,27 @@ * __flush_tier_wait -- * Wait for all previous work units queued to be processed. */ -static void -__flush_tier_wait(WT_SESSION_IMPL *session) +static int +__flush_tier_wait(WT_SESSION_IMPL *session, const char **cfg) { + WT_CONFIG_ITEM cval; WT_CONNECTION_IMPL *conn; + uint64_t now, start, timeout; int yield_count; conn = S2C(session); yield_count = 0; + now = start = 0; /* * The internal thread needs the schema lock to perform its operations and flush tier also * acquires the schema lock. We cannot be waiting in this function while holding that lock or no * work will get done. */ WT_ASSERT(session, !FLD_ISSET(session->lock_flags, WT_SESSION_LOCKED_SCHEMA)); + WT_RET(__wt_config_gets(session, cfg, "timeout", &cval)); + timeout = (uint64_t)cval.val; + if (timeout != 0) + __wt_seconds(session, &start); /* * It may be worthwhile looking at the add and decrement values and make choices of whether to @@ -44,11 +51,17 @@ __flush_tier_wait(WT_SESSION_IMPL *session) * take a long time so yielding may not be effective. */ while (!WT_FLUSH_STATE_DONE(conn->flush_state)) { + if (start != 0) { + __wt_seconds(session, &now); + if (now - start > timeout) + return (EBUSY); + } if (++yield_count < WT_THOUSAND) __wt_yield(); else __wt_cond_wait(session, conn->flush_cond, 200, NULL); } + return (0); } /* @@ -337,7 +350,7 @@ __wt_flush_tier(WT_SESSION_IMPL *session, const char *config) WT_DECL_RET; uint32_t flags; const char *cfg[3]; - bool wait; + bool locked, wait; conn = S2C(session); WT_STAT_CONN_INCR(session, flush_tier); @@ -372,6 +385,7 @@ __wt_flush_tier(WT_SESSION_IMPL *session, const char *config) __wt_spin_lock(session, &conn->flush_tier_lock); else WT_RET(__wt_spin_trylock(session, &conn->flush_tier_lock)); + locked = true; /* * We cannot perform another flush tier until any earlier ones are done. Often threads will wait @@ -379,7 +393,7 @@ __wt_flush_tier(WT_SESSION_IMPL *session, const char *config) * turned off then any following call must wait and will do so here. We have to wait while not * holding the schema lock. */ - __flush_tier_wait(session); + WT_ERR(__flush_tier_wait(session, cfg)); if (wait) WT_WITH_CHECKPOINT_LOCK( session, WT_WITH_SCHEMA_LOCK(session, ret = __flush_tier_once(session, flags))); @@ -387,9 +401,14 @@ __wt_flush_tier(WT_SESSION_IMPL *session, const char *config) WT_WITH_CHECKPOINT_LOCK_NOWAIT(session, ret, WT_WITH_SCHEMA_LOCK_NOWAIT(session, ret, ret = __flush_tier_once(session, flags))); __wt_spin_unlock(session, &conn->flush_tier_lock); + locked = false; if (ret == 0 && LF_ISSET(WT_FLUSH_TIER_ON)) - __flush_tier_wait(session); + WT_ERR(__flush_tier_wait(session, cfg)); + +err: + if (locked) + __wt_spin_unlock(session, &conn->flush_tier_lock); return (ret); } @@ -520,6 +539,7 @@ __tiered_mgr_server(void *arg) WT_ITEM path, tmp; WT_SESSION_IMPL *session; WT_TIERED_MANAGER *mgr; + const char *cfg[2]; session = arg; conn = S2C(session); @@ -527,6 +547,8 @@ __tiered_mgr_server(void *arg) WT_CLEAR(path); WT_CLEAR(tmp); + cfg[0] = "timeout=0"; + cfg[1] = NULL; for (;;) { /* Wait until the next event. */ @@ -542,7 +564,7 @@ __tiered_mgr_server(void *arg) WT_WITH_SCHEMA_LOCK(session, ret = __flush_tier_once(session, 0)); WT_ERR(ret); if (ret == 0) - __flush_tier_wait(session); + WT_ERR(__flush_tier_wait(session, cfg)); WT_ERR(__tier_storage_remove(session, false)); } diff --git a/src/third_party/wiredtiger/src/docs/arch-data-file.dox b/src/third_party/wiredtiger/src/docs/arch-data-file.dox index 834329c981f..80a32dd4525 100644 --- a/src/third_party/wiredtiger/src/docs/arch-data-file.dox +++ b/src/third_party/wiredtiger/src/docs/arch-data-file.dox @@ -1,17 +1,108 @@ /*! @arch_page arch-data-file Data File Format -The format of the WiredTiger data file is given by structures -in \c block.h , defining the overall structure of the file and -its blocks. The \c WT_BLOCK_DESC starts the file. Following that, -individual pages appear, each with a \c WT_PAGE_HEADER defined in \c btmem.h -and a \c WT_BLOCK_HEADER defined in \c block.h . Individual cells then -sequentially appear as defined in \c cell.h . Each cell encodes -a key or value. Ordering is important, values are all associated with -the key that precedes them. Multiple values may be present, which -can represent multiple versions. Extremely large values may be represented -as a reference to another page. - -The exact encoding is rather complex, and beyond what can be described here. -The encoding strikes a balance between data that can be compacted efficiently -in time and space, extensibility, and compatibility with previous versions. +@section Database Files + +WiredTiger stores databases in a durable format through writing data to files +it has created in the database directory. These include data files representing +tables in a MongoDB database, a history store file used to track previous +versions of the database tables, as well as other metadata files for the +entire system. + +Data files are denoted by the .wt suffix. The history store file +(WiredTigerHS.wt) and the metadata file (WiredTiger.wt) are special WiredTiger +files, but have the same underlying structure as normal data files. + +@section Format & Layout of Data Files + +In memory, a database table is represented by a B-Tree data structure, which is +made up of nodes that are page structures. The root and internal pages will only +store keys and references to other pages, while leaf pages store keys, values and +sometimes references to overflow pages. When these pages are written onto the +disk, they are written out as units of data called blocks. On the disk, a +WiredTiger data file is just a collection of blocks which logically represent +the pages of the B-Tree. + +The layout of a .wt file consists of a file description \c WT_BLOCK_DESC which +always occupies the first block, followed by a set of on-disk pages. +The file description contains metadata about the file such as the WiredTiger +major and minor version, a magic number, and a checksum of the block +contents. This information is used to verify that the file is a legitimate +WiredTiger data file with a compatible WiredTiger version, and that its +contents are not corrupted. + +@section Format & Layout of On-Disk Pages + +Pages consist of a header (\c WT_PAGE_HEADER and \c WT_BLOCK_HEADER) followed +by a variable number of cells, which encode keys, values or addresses (see +\c cell.h). The page header \c WT_PAGE_HEADER consists of information such +as the column-store record number, write generation (required for ordering +pages in time), in-memory size, cell count (the number of cells on the page), +data length (the overflow record length), and the page type. This is +immediately followed by the block header \c WT_BLOCK_HEADER which contains +block-manager specific information such as flags and version. + +After the page header, pages with variable-length keys or values will have +a set of cells. There are four main types of cells - keys, data, deleted +cells, and off-page references. Cells are also usually followed by some +additional data depending on its type. For example, values may have a time +validity window, and off-page references may have a validity window and an +address cookie. Ordering is important, values are all associated with the +key that precedes them. Multiple values may be present, which can represent +multiple versions. Extremely large values may be represented as a reference +to another page (see overflow pages). + +The exact encoding of cells is rather complex, and beyond what can be +described here. The encoding strikes a balance between data that can be +compacted efficiently in time and space, extensibility, and compatibility +with previous versions. + +@section Page Types + +Different types of pages are made up of different types of cells. + +(1) Internal Pages - as the B-Tree grows in size and layer/s are added, +there will be pages between the root page and leaf page. These internal +pages contain keys that point to other pages. +- The row-store internal page \c WT_PAGE_ROW_INT is made up of a key cell +(\c WT_CELL_KEY or \c WT_CELL_KEY_OVFL) followed by an off-page reference +(\c WT_CELL_ADDR_XXX). +- The column-store internal page \c WT_PAGE_COL_INT simply contains an +off-page reference. + +(2) Leaf Pages - leaf pages consist of a page header, followed by keys, +values or addresses (these reference overflow pages). +- The row-store leaf page \c WT_PAGE_ROW_LEAF is made up of a key cell +(\c WT_CELL_KEY or \c WT_CELL_KEY_OVFL) followed by a value +(\c WT_CELL_VALUE/VALUE_COPY/VALUE_OVFL). +- The column-store leaf page (for variable-length data) \c WT_PAGE_COL_VAR +is made up of data cells (\c WT_CELL_VALUE/VALUE_COPY/VALUE_OVFL) or +deleted cells (\c WT_CELL_DEL). The page header has a starting record +number, so the associated keys for all column store values is deduced by +their position in the page. + +(3) Overflow Pages - overflow pages are needed when keys/values that are +too large must be stored separately in the file, apart from where the item +is logically placed. Page sizes and configuration values such as +internal_key_max, leaf_key_max and leaf_value_max are used to determine +overflow items. + +While the above gives a general overview of how different page types are +structured, it is a simplified representation. Due to the large amount of +data being stored, WiredTiger may compress data to preserve memory and disk +space. Keys may not be stored in their entirety when prefix compression +is used (the identical key prefix is stored only once per page to reduce +size). In addition, each block written may be compressed and/or encrypted. +The header portion of each block remains uncompressed and unencrypted. + +@section Data File Functions + +When data needs to be read from a data file, it is unpacked into in-memory +structures, and vice versa, we pack the contents when we want to write a +page image to a data file. Low level functions that pack or unpack the +contents of individual cells are in \c cell_inline.h. Functions +like \c __wt_cell_unpack_kv and \c __wt_cell_unpack_addr to unpack keys, +values and addresses are found here, and uses of such functions appear in +the B-Tree code. Similarly, there are \c __wt_cell_pack_* functions to +pack particular kinds of keys, values and addresses; these are used in +the reconciliation code. */ diff --git a/src/third_party/wiredtiger/src/docs/arch-metadata.dox b/src/third_party/wiredtiger/src/docs/arch-metadata.dox index d709dc78810..d5f89a43f3e 100644 --- a/src/third_party/wiredtiger/src/docs/arch-metadata.dox +++ b/src/third_party/wiredtiger/src/docs/arch-metadata.dox @@ -1,19 +1,76 @@ /*! @arch_page arch-metadata Metadata -Metadata in WiredTiger is stored as a table in the \c "WiredTiger.wt" file. -The table's key is a \c uri string, and the value is its complete -configuration string. The configuration itself is a list of key/value -pairs in string form. The configuration's keys are dependent on the -type of \c uri. Thus, a metadata entry with a \c uri key beginning with -\c "table:" will be a configuration string -having configuration entries like \c key_format and \c value_format to -describe the data encoding for the uri. A metadata key beginning with +Metadata in WiredTiger captures important information about the user's database. +Metadata includes tracking essential information such as the files and tables +present in the database, their associated configurations, as well as the latest checkpoints. +The checkpoint information tells WiredTiger where to the find +root page and all other parts of its tree when accessing the file. + +The main metadata in WiredTiger is stored in the \c WiredTiger.wt file. + +@section metadata_table Metadata Table + +The keys in the \c WiredTiger.wt table are \c uri strings. For example, keys can include \c "table:" & \c "file:" +prefixed URIs, representing typical row-store WiredTiger tables. A non-exhaustive list of other +example keys could also include \c "index:", \c "colgroups:" and \c "system:" prefixed URIs, representing +indexes, colgroups and special system values respectively. + +The value corresponding to a given \c uri key in the metadata table is its +associated configuration string. The configuration value itself is a list of key/value +pairs in string form. The key/value pairs in the configuration strings are dependent on the +type of \c uri. Thus, a metadata entry with a \c uri key beginning with \c "table:" will be +a configuration string having entries such as \c key_format and \c value_format to +describe the data encoding for the uri. A metadata key beginning with \c "file:" will have a different set of configuration entries associated -with it. +with it. See @ref config_strings for more details about WiredTiger configuration strings. + +@section metadata_checkpoint Storing Checkpoint Metadata + +The latest checkpoint information for each btree in the system is stored in its metadata entry. The checkpoint metadata +provides a known point in time from which WiredTiger can recover a btree's data after a restart. +The checkpoint metadata for a given btree is stored within the configuration string under its +associated \c uri key within the \c WiredTiger.wt table. Metadata configuration entries relevant to capturing +a given btree's checkpoint state include: +- \c checkpoint: The file's checkpoint entries, including their timestamp, transaction ID and write generation. Most importantly +this information also tracks an encoded address cookie that describes the blocks that make up the checkpoint's data. +- \c checkpoint_lsn: The LSN of the last checkpoint. +- \c checkpoint_backup_info: Incremental backup information. + +@section metadata_turtle Turtle file + +The metadata file \c WiredTiger.wt is a regular WiredTiger table itself. As such, the metadata table has a btree that also needs to be +checkpointed. Since a new metadata entry needs to be created for each btree at the time of checkpointing, the metadata table is the last +file to be checkpointed in the process. Checkpointing the metadata table last is important +for capturing a consistent state of the btrees in the database at the time of the last checkpoint. + +Due to this ordering, to successfully restore the checkpoint of the \c WiredTiger.wt file, WiredTiger captures the most +recent checkpointing information of the metadata table in a separate special turtle file called +\c "WiredTiger.turtle". The turtle file itself is metadata for the WiredTiger metadata. Using the +turtle file, WiredTiger can read the latest checkpoint information from the file when recovering the \c WiredTiger.wt table. +Recovering the checkpoint of the \c WiredTiger.wt table in turn restores a consistent view of the checkpointing information +for the other btrees in the system. + +@section metadata_reading Reading Metadata + +The contents of the metadata table is ASCII printable. The URIs and configuration values +are all printable strings. + +@subsection metadata_cursor "metadata:" cursor + +To read the metadata, a caller can open a cursor, via \c WT_SESSION::open_cursor, with a \c uri equal +to \c "metadata:". Changes to the metadata cannot be written through the metadata +cursor interface i.e. the metadata cursor is a read-only interface. Metadata is only changed/affected +by API calls. + +@subsection metadata_create_cursor "metadata:create" cursor + +Additionally, to only read strings relating to creation configurations of the various +\c uri keys present, a cursor can be opened with a \c uri equal to \c "metadata:create". This type of +cursor causes WiredTiger to strip out internal metadata when querying. -A caller of WiredTiger can use WT_SESSION::open_cursor with a \c uri equal to -\c "meta:" to read the metadata. Using this interface, metadata can only -be queried, not changed. Changes to the metadata are affected by API calls -such as WT_SESSION::create, WT_SESSION::drop, WT_SESSION::rename. +@subsection metadata_wt_util Printing metadata with the wt utility +Lastly the metadata in the \c WiredTiger.wt table can be dumped using the \c wt utility. A command option for +specifically printing the metadata is \c "wt list -v". This will display the various \c uri key strings with their associated +configuration strings. */ diff --git a/src/third_party/wiredtiger/src/docs/arch-rts.dox b/src/third_party/wiredtiger/src/docs/arch-rts.dox index 451732f5776..3e2cf6b70d0 100644 --- a/src/third_party/wiredtiger/src/docs/arch-rts.dox +++ b/src/third_party/wiredtiger/src/docs/arch-rts.dox @@ -16,8 +16,8 @@ updates are aborted and the on-disk version updates are replaced with an update from history store otherwise the data store version is removed. Rollback to stable is performed in three phases -1. WT startup -2. WT shutdown +1. WiredTiger startup +2. WiredTiger shutdown 3. Application initiated To improve the performance of rollback to stable operation, rollback to stable diff --git a/src/third_party/wiredtiger/src/docs/spell.ok b/src/third_party/wiredtiger/src/docs/spell.ok index d4b22545abe..da63c933d3f 100644 --- a/src/third_party/wiredtiger/src/docs/spell.ok +++ b/src/third_party/wiredtiger/src/docs/spell.ok @@ -1,5 +1,6 @@ personal_ws-1.1 en 200 ACM +ADDR APIs ASAN ActiveState @@ -149,6 +150,7 @@ aR abc abstime ack'ed +addr ajn alloc allocator @@ -179,6 +181,7 @@ br btmem btree btrees +btree's bufs builtin builtins @@ -193,6 +196,7 @@ cdb cds changelog checkpointed +checkpointing checksum checksums ckp @@ -374,6 +378,7 @@ keyfmt keyid keyname keyvalue +kv kvs lang lastname diff --git a/src/third_party/wiredtiger/src/docs/testing.dox b/src/third_party/wiredtiger/src/docs/testing.dox index b33ad279562..5b9835f6cd9 100644 --- a/src/third_party/wiredtiger/src/docs/testing.dox +++ b/src/third_party/wiredtiger/src/docs/testing.dox @@ -37,7 +37,7 @@ into the WiredTiger GitHub source tree. @subsection test_csuite CSuite @subsection test_cppsuite CPPSuite @subsection test_format Format -@subsection test_perf WT Perf +@subsection test_perf WiredTiger Perf @subsection test_workgen Workgen @section testing_compatibility Compatibility Testing diff --git a/src/third_party/wiredtiger/src/docs/tool-optrack.dox b/src/third_party/wiredtiger/src/docs/tool-optrack.dox index c13dd31ae84..e39a17e3a08 100644 --- a/src/third_party/wiredtiger/src/docs/tool-optrack.dox +++ b/src/third_party/wiredtiger/src/docs/tool-optrack.dox @@ -104,7 +104,7 @@ efficient than writing strings, and the map file is needed to decode them. Now the binary log files need to be converted into the text format. To do that use the script `wt_optrack_decode.py` in the WiredTiger tree. We will refer to -the path to your WiredTiger tree as WT. Suppose that the process ID that +the path to your WiredTiger tree as WiredTiger. Suppose that the process ID that generated the operation tracking files is 25660. Then you'd run the decode script like so: @@ -124,7 +124,7 @@ nanoseconds. In the end, you should see lots of output files whose names look like the optrack log files, but with the suffixes `-internal.txt` and `-external.txt`. -The "internal" files are the log files for WT internal sessions (such as +The "internal" files are the log files for WiredTiger internal sessions (such as eviction threads). The "external" files are for the sessions created by the client application. @@ -195,7 +195,7 @@ workload described earlier in this tutorial. Please open the URL, because we will now walk over what it shows. The main page shows a number of outlier histograms. Each histogram corresponds -to a function that was tracked by the operation tracking system in WT. The +to a function that was tracked by the operation tracking system in WiredTiger. The x-axis shows the execution timeline (in nanoseconds). The y-axis shows how many abnormally long executions of the function occurred during very period of the execution. diff --git a/src/third_party/wiredtiger/src/include/block.h b/src/third_party/wiredtiger/src/include/block.h index cd6cf3e662e..7b4fa732027 100644 --- a/src/third_party/wiredtiger/src/include/block.h +++ b/src/third_party/wiredtiger/src/include/block.h @@ -325,7 +325,7 @@ struct __wt_block_desc { */ struct __wt_block_file_opener { /* An id to be used with the open call to reference the current object. */ -#define WT_TIERED_CURRENT_ID 0xFFFFFFFFUL +#define WT_TIERED_CURRENT_ID UINT32_MAX int (*open)( WT_BLOCK_FILE_OPENER *, WT_SESSION_IMPL *, uint32_t, WT_FS_OPEN_FILE_TYPE, u_int, WT_FH **); uint32_t (*current_object_id)(WT_BLOCK_FILE_OPENER *); diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h index 38d8f72a052..ef7ac6d6929 100644 --- a/src/third_party/wiredtiger/src/include/extern.h +++ b/src/third_party/wiredtiger/src/include/extern.h @@ -4,7 +4,7 @@ extern WT_HAZARD *__wt_hazard_check(WT_SESSION_IMPL *session, WT_REF *ref, WT_SESSION_IMPL **sessionp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern WT_THREAD_RET __wt_cache_pool_server(void *arg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern WT_UPDATE *__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_PAGE *page, +extern WT_UPDATE *__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_UPDATE *upd, bool update_accounting) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern bool __wt_block_offset_invalid(WT_BLOCK *block, wt_off_t offset, uint32_t size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -87,18 +87,15 @@ extern int __wt_bad_object_type(WT_SESSION_IMPL *session, const char *uri) WT_GCC_FUNC_DECL_ATTRIBUTE((cold)) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_addr_invalid(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr, size_t addr_size, bool live) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_block_addr_pack(WT_BLOCK *block, uint8_t **pp, uint32_t objectid, wt_off_t offset, + uint32_t size, uint32_t checksum) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_addr_string(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, const uint8_t *addr, size_t addr_size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_addr_to_buffer(WT_BLOCK *block, uint8_t **pp, uint32_t objectid, - wt_off_t offset, uint32_t size, uint32_t checksum) +extern int __wt_block_addr_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *p, + size_t addr_size, uint32_t *objectidp, wt_off_t *offsetp, uint32_t *sizep, uint32_t *checksump) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_alloc(WT_SESSION_IMPL *session, WT_BLOCK *block, wt_off_t *offp, wt_off_t size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_buffer_to_addr(WT_BLOCK *block, const uint8_t *p, uint32_t *objectidp, - wt_off_t *offsetp, uint32_t *sizep, uint32_t *checksump) - WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_buffer_to_ckpt(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *p, - WT_BLOCK_CKPT *ci) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_checkpoint(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, WT_CKPT *ckptbase, bool data_checksum) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_checkpoint_final(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, @@ -114,13 +111,15 @@ extern int __wt_block_checkpoint_start(WT_SESSION_IMPL *session, WT_BLOCK *block WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_checkpoint_unload(WT_SESSION_IMPL *session, WT_BLOCK *block, bool checkpoint) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_ckpt_decode(WT_SESSION *wt_session, WT_BLOCK *block, const uint8_t *p, - WT_BLOCK_CKPT *ci) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("default"))) +extern int __wt_block_ckpt_decode(WT_SESSION *wt_session, WT_BLOCK *block, const uint8_t *ckpt, + size_t ckpt_size, WT_BLOCK_CKPT *ci) WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("default"))) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_ckpt_init(WT_SESSION_IMPL *session, WT_BLOCK_CKPT *ci, const char *name) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_ckpt_to_buffer(WT_SESSION_IMPL *session, WT_BLOCK *block, uint8_t **pp, +extern int __wt_block_ckpt_pack(WT_SESSION_IMPL *session, WT_BLOCK *block, uint8_t **pp, WT_BLOCK_CKPT *ci, bool skip_avail) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_block_ckpt_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *ckpt, + size_t ckpt_size, WT_BLOCK_CKPT *ci) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_close(WT_SESSION_IMPL *session, WT_BLOCK *block) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_compact_end(WT_SESSION_IMPL *session, WT_BLOCK *block) @@ -156,7 +155,7 @@ extern int __wt_block_extlist_truncate(WT_SESSION_IMPL *session, WT_BLOCK *block WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_extlist_write(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_EXTLIST *el, WT_EXTLIST *additional) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t objectid, WT_FH **fhp) +extern int __wt_block_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id, WT_FH **fhp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_free(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr, size_t addr_size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -202,8 +201,6 @@ extern int __wt_block_size_alloc(WT_SESSION_IMPL *session, WT_SIZE **szp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_switch_object(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id, uint32_t flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_block_tiered_fh(WT_SESSION_IMPL *session, WT_BLOCK *block, uint32_t object_id, - WT_FH **fhp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_truncate(WT_SESSION_IMPL *session, WT_BLOCK *block, wt_off_t len) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_block_unmap(WT_SESSION_IMPL *session, WT_BLOCK *block, void *mapped_region, @@ -1694,7 +1691,7 @@ extern void __wt_checkpoint_progress(WT_SESSION_IMPL *session, bool closing); extern void __wt_checkpoint_signal(WT_SESSION_IMPL *session, wt_off_t logsize); extern void __wt_checkpoint_tree_reconcile_update(WT_SESSION_IMPL *session, WT_TIME_AGGREGATE *ta); extern void __wt_ckpt_verbose(WT_SESSION_IMPL *session, WT_BLOCK *block, const char *tag, - const char *ckpt_name, const uint8_t *ckpt_string); + const char *ckpt_name, const uint8_t *ckpt_string, size_t ckpt_size); extern void __wt_cond_auto_wait( WT_SESSION_IMPL *session, WT_CONDVAR *cond, bool progress, bool (*run_func)(WT_SESSION_IMPL *)); extern void __wt_cond_auto_wait_signal(WT_SESSION_IMPL *session, WT_CONDVAR *cond, bool progress, diff --git a/src/third_party/wiredtiger/src/include/serial_inline.h b/src/third_party/wiredtiger/src/include/serial_inline.h index 1fb7e31496e..8e6813f2866 100644 --- a/src/third_party/wiredtiger/src/include/serial_inline.h +++ b/src/third_party/wiredtiger/src/include/serial_inline.h @@ -229,6 +229,7 @@ __wt_update_serial(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_PAGE *page upd = *updp; *updp = NULL; prev_upd_ts = WT_TS_NONE; + #ifdef HAVE_DIAGNOSTIC prev_upd_ts = upd->prev_durable_ts; #endif @@ -296,7 +297,7 @@ __wt_update_serial(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_PAGE *page if (WT_PAGE_TRYLOCK(session, page) != 0) return (0); - obsolete = __wt_update_obsolete_check(session, page, upd->next, true); + obsolete = __wt_update_obsolete_check(session, cbt, upd->next, true); WT_PAGE_UNLOCK(session, page); diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h index b0b161b876d..8aa75787f99 100644 --- a/src/third_party/wiredtiger/src/include/stat.h +++ b/src/third_party/wiredtiger/src/include/stat.h @@ -397,6 +397,7 @@ struct __wt_connection_stats { int64_t cache_eviction_force_clean_time; int64_t cache_eviction_force_dirty; int64_t cache_eviction_force_dirty_time; + int64_t cache_eviction_force_long_update_list; int64_t cache_eviction_force_delete; int64_t cache_eviction_force; int64_t cache_eviction_force_fail; diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in index 1f3048d79c3..4ca3eeb1f72 100644 --- a/src/third_party/wiredtiger/src/include/wiredtiger.in +++ b/src/third_party/wiredtiger/src/include/wiredtiger.in @@ -815,6 +815,9 @@ struct __wt_session { * internal thread. The \c on setting causes the caller to wait until all work queued for * this call to be completely processed before returning., a string\, chosen from the * following options: \c "off"\, \c "on"; default \c on.} + * @config{timeout, maximum amount of time to allow for waiting for previous flushing of + * objects\, in seconds. The actual amount of time spent waiting may exceed the configured + * value. A value of zero disables the timeout., an integer; default \c 0.} * @configend * @errors */ @@ -5200,968 +5203,973 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); /*! cache: forced eviction - pages evicted that were dirty time (usecs) */ #define WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY_TIME 1083 /*! + * cache: forced eviction - pages selected because of a large number of + * updates to a single item + */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_LONG_UPDATE_LIST 1084 +/*! * cache: forced eviction - pages selected because of too many deleted * items count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1084 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1085 /*! cache: forced eviction - pages selected count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1085 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1086 /*! cache: forced eviction - pages selected unable to be evicted count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1086 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1087 /*! cache: forced eviction - pages selected unable to be evicted time */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1087 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1088 /*! cache: hazard pointer blocked page eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1088 +#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1089 /*! cache: hazard pointer check calls */ -#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1089 +#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1090 /*! cache: hazard pointer check entries walked */ -#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1090 +#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1091 /*! cache: hazard pointer maximum array length */ -#define WT_STAT_CONN_CACHE_HAZARD_MAX 1091 +#define WT_STAT_CONN_CACHE_HAZARD_MAX 1092 /*! cache: history store score */ -#define WT_STAT_CONN_CACHE_HS_SCORE 1092 +#define WT_STAT_CONN_CACHE_HS_SCORE 1093 /*! cache: history store table insert calls */ -#define WT_STAT_CONN_CACHE_HS_INSERT 1093 +#define WT_STAT_CONN_CACHE_HS_INSERT 1094 /*! cache: history store table insert calls that returned restart */ -#define WT_STAT_CONN_CACHE_HS_INSERT_RESTART 1094 +#define WT_STAT_CONN_CACHE_HS_INSERT_RESTART 1095 /*! cache: history store table max on-disk size */ -#define WT_STAT_CONN_CACHE_HS_ONDISK_MAX 1095 +#define WT_STAT_CONN_CACHE_HS_ONDISK_MAX 1096 /*! cache: history store table on-disk size */ -#define WT_STAT_CONN_CACHE_HS_ONDISK 1096 +#define WT_STAT_CONN_CACHE_HS_ONDISK 1097 /*! * cache: history store table out-of-order resolved updates that lose * their durable timestamp */ -#define WT_STAT_CONN_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP 1097 +#define WT_STAT_CONN_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP 1098 /*! * cache: history store table out-of-order updates that were fixed up by * reinserting with the fixed timestamp */ -#define WT_STAT_CONN_CACHE_HS_ORDER_REINSERT 1098 +#define WT_STAT_CONN_CACHE_HS_ORDER_REINSERT 1099 /*! cache: history store table reads */ -#define WT_STAT_CONN_CACHE_HS_READ 1099 +#define WT_STAT_CONN_CACHE_HS_READ 1100 /*! cache: history store table reads missed */ -#define WT_STAT_CONN_CACHE_HS_READ_MISS 1100 +#define WT_STAT_CONN_CACHE_HS_READ_MISS 1101 /*! cache: history store table reads requiring squashed modifies */ -#define WT_STAT_CONN_CACHE_HS_READ_SQUASH 1101 +#define WT_STAT_CONN_CACHE_HS_READ_SQUASH 1102 /*! * cache: history store table truncation by rollback to stable to remove * an unstable update */ -#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE 1102 +#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE 1103 /*! * cache: history store table truncation by rollback to stable to remove * an update */ -#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS 1103 +#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS 1104 /*! cache: history store table truncation to remove an update */ -#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE 1104 +#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE 1105 /*! * cache: history store table truncation to remove range of updates due * to key being removed from the data page during reconciliation */ -#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL 1105 +#define WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL 1106 /*! * cache: history store table truncation to remove range of updates due * to out-of-order timestamp update on data page */ -#define WT_STAT_CONN_CACHE_HS_ORDER_REMOVE 1106 +#define WT_STAT_CONN_CACHE_HS_ORDER_REMOVE 1107 /*! cache: history store table writes requiring squashed modifies */ -#define WT_STAT_CONN_CACHE_HS_WRITE_SQUASH 1107 +#define WT_STAT_CONN_CACHE_HS_WRITE_SQUASH 1108 /*! cache: in-memory page passed criteria to be split */ -#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1108 +#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1109 /*! cache: in-memory page splits */ -#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1109 +#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1110 /*! cache: internal pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1110 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1111 /*! cache: internal pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED 1111 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED 1112 /*! cache: internal pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN 1112 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN 1113 /*! cache: internal pages seen by eviction walk that are already queued */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED 1113 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED 1114 /*! cache: internal pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1114 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1115 /*! cache: leaf pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1115 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1116 /*! cache: maximum bytes configured */ -#define WT_STAT_CONN_CACHE_BYTES_MAX 1116 +#define WT_STAT_CONN_CACHE_BYTES_MAX 1117 /*! cache: maximum page size at eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1117 +#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1118 /*! cache: modified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1118 +#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1119 /*! cache: modified pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1119 +#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1120 /*! cache: operations timed out waiting for space in cache */ -#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1120 +#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1121 /*! cache: overflow pages read into cache */ -#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1121 +#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1122 /*! cache: page split during eviction deepened the tree */ -#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1122 +#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1123 /*! cache: page written requiring history store records */ -#define WT_STAT_CONN_CACHE_WRITE_HS 1123 +#define WT_STAT_CONN_CACHE_WRITE_HS 1124 /*! cache: pages currently held in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_INUSE 1124 +#define WT_STAT_CONN_CACHE_PAGES_INUSE 1125 /*! cache: pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP 1125 +#define WT_STAT_CONN_CACHE_EVICTION_APP 1126 /*! cache: pages evicted in parallel with checkpoint */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_IN_PARALLEL_WITH_CHECKPOINT 1126 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_IN_PARALLEL_WITH_CHECKPOINT 1127 /*! cache: pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1127 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1128 /*! cache: pages queued for eviction post lru sorting */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU 1128 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU 1129 /*! cache: pages queued for urgent eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1129 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1130 /*! cache: pages queued for urgent eviction during walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1130 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1131 /*! * cache: pages queued for urgent eviction from history store due to high * dirty content */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT_HS_DIRTY 1131 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT_HS_DIRTY 1132 /*! cache: pages read into cache */ -#define WT_STAT_CONN_CACHE_READ 1132 +#define WT_STAT_CONN_CACHE_READ 1133 /*! cache: pages read into cache after truncate */ -#define WT_STAT_CONN_CACHE_READ_DELETED 1133 +#define WT_STAT_CONN_CACHE_READ_DELETED 1134 /*! cache: pages read into cache after truncate in prepare state */ -#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1134 +#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1135 /*! cache: pages requested from the cache */ -#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1135 +#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1136 /*! cache: pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1136 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1137 /*! cache: pages seen by eviction walk that are already queued */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED 1137 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED 1138 /*! cache: pages selected for eviction unable to be evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1138 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1139 /*! * cache: pages selected for eviction unable to be evicted as the parent * page has overflow items */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS 1139 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS 1140 /*! * cache: pages selected for eviction unable to be evicted because of * active children on an internal page */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE 1140 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE 1141 /*! * cache: pages selected for eviction unable to be evicted because of * failure in reconciliation */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION 1141 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION 1142 /*! * cache: pages selected for eviction unable to be evicted because of * race between checkpoint and out of order timestamps handling */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_CHECKPOINT_OUT_OF_ORDER_TS 1142 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_CHECKPOINT_OUT_OF_ORDER_TS 1143 /*! cache: pages walked for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK 1143 +#define WT_STAT_CONN_CACHE_EVICTION_WALK 1144 /*! cache: pages written from cache */ -#define WT_STAT_CONN_CACHE_WRITE 1144 +#define WT_STAT_CONN_CACHE_WRITE 1145 /*! cache: pages written requiring in-memory restoration */ -#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1145 +#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1146 /*! cache: percentage overhead */ -#define WT_STAT_CONN_CACHE_OVERHEAD 1146 +#define WT_STAT_CONN_CACHE_OVERHEAD 1147 /*! cache: tracked bytes belonging to internal pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1147 +#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1148 /*! cache: tracked bytes belonging to leaf pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_LEAF 1148 +#define WT_STAT_CONN_CACHE_BYTES_LEAF 1149 /*! cache: tracked dirty bytes in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1149 +#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1150 /*! cache: tracked dirty pages in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1150 +#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1151 /*! cache: unmodified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1151 +#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1152 /*! capacity: background fsync file handles considered */ -#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1152 +#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1153 /*! capacity: background fsync file handles synced */ -#define WT_STAT_CONN_FSYNC_ALL_FH 1153 +#define WT_STAT_CONN_FSYNC_ALL_FH 1154 /*! capacity: background fsync time (msecs) */ -#define WT_STAT_CONN_FSYNC_ALL_TIME 1154 +#define WT_STAT_CONN_FSYNC_ALL_TIME 1155 /*! capacity: bytes read */ -#define WT_STAT_CONN_CAPACITY_BYTES_READ 1155 +#define WT_STAT_CONN_CAPACITY_BYTES_READ 1156 /*! capacity: bytes written for checkpoint */ -#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1156 +#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1157 /*! capacity: bytes written for eviction */ -#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1157 +#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1158 /*! capacity: bytes written for log */ -#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1158 +#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1159 /*! capacity: bytes written total */ -#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1159 +#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1160 /*! capacity: threshold to call fsync */ -#define WT_STAT_CONN_CAPACITY_THRESHOLD 1160 +#define WT_STAT_CONN_CAPACITY_THRESHOLD 1161 /*! capacity: time waiting due to total capacity (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1161 +#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1162 /*! capacity: time waiting during checkpoint (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1162 +#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1163 /*! capacity: time waiting during eviction (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1163 +#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1164 /*! capacity: time waiting during logging (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_LOG 1164 +#define WT_STAT_CONN_CAPACITY_TIME_LOG 1165 /*! capacity: time waiting during read (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_READ 1165 +#define WT_STAT_CONN_CAPACITY_TIME_READ 1166 /*! checkpoint-cleanup: pages added for eviction */ -#define WT_STAT_CONN_CC_PAGES_EVICT 1166 +#define WT_STAT_CONN_CC_PAGES_EVICT 1167 /*! checkpoint-cleanup: pages removed */ -#define WT_STAT_CONN_CC_PAGES_REMOVED 1167 +#define WT_STAT_CONN_CC_PAGES_REMOVED 1168 /*! checkpoint-cleanup: pages skipped during tree walk */ -#define WT_STAT_CONN_CC_PAGES_WALK_SKIPPED 1168 +#define WT_STAT_CONN_CC_PAGES_WALK_SKIPPED 1169 /*! checkpoint-cleanup: pages visited */ -#define WT_STAT_CONN_CC_PAGES_VISITED 1169 +#define WT_STAT_CONN_CC_PAGES_VISITED 1170 /*! connection: auto adjusting condition resets */ -#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1170 +#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1171 /*! connection: auto adjusting condition wait calls */ -#define WT_STAT_CONN_COND_AUTO_WAIT 1171 +#define WT_STAT_CONN_COND_AUTO_WAIT 1172 /*! * connection: auto adjusting condition wait raced to update timeout and * skipped updating */ -#define WT_STAT_CONN_COND_AUTO_WAIT_SKIPPED 1172 +#define WT_STAT_CONN_COND_AUTO_WAIT_SKIPPED 1173 /*! connection: detected system time went backwards */ -#define WT_STAT_CONN_TIME_TRAVEL 1173 +#define WT_STAT_CONN_TIME_TRAVEL 1174 /*! connection: files currently open */ -#define WT_STAT_CONN_FILE_OPEN 1174 +#define WT_STAT_CONN_FILE_OPEN 1175 /*! connection: hash bucket array size for data handles */ -#define WT_STAT_CONN_BUCKETS_DH 1175 +#define WT_STAT_CONN_BUCKETS_DH 1176 /*! connection: hash bucket array size general */ -#define WT_STAT_CONN_BUCKETS 1176 +#define WT_STAT_CONN_BUCKETS 1177 /*! connection: memory allocations */ -#define WT_STAT_CONN_MEMORY_ALLOCATION 1177 +#define WT_STAT_CONN_MEMORY_ALLOCATION 1178 /*! connection: memory frees */ -#define WT_STAT_CONN_MEMORY_FREE 1178 +#define WT_STAT_CONN_MEMORY_FREE 1179 /*! connection: memory re-allocations */ -#define WT_STAT_CONN_MEMORY_GROW 1179 +#define WT_STAT_CONN_MEMORY_GROW 1180 /*! connection: pthread mutex condition wait calls */ -#define WT_STAT_CONN_COND_WAIT 1180 +#define WT_STAT_CONN_COND_WAIT 1181 /*! connection: pthread mutex shared lock read-lock calls */ -#define WT_STAT_CONN_RWLOCK_READ 1181 +#define WT_STAT_CONN_RWLOCK_READ 1182 /*! connection: pthread mutex shared lock write-lock calls */ -#define WT_STAT_CONN_RWLOCK_WRITE 1182 +#define WT_STAT_CONN_RWLOCK_WRITE 1183 /*! connection: total fsync I/Os */ -#define WT_STAT_CONN_FSYNC_IO 1183 +#define WT_STAT_CONN_FSYNC_IO 1184 /*! connection: total read I/Os */ -#define WT_STAT_CONN_READ_IO 1184 +#define WT_STAT_CONN_READ_IO 1185 /*! connection: total write I/Os */ -#define WT_STAT_CONN_WRITE_IO 1185 +#define WT_STAT_CONN_WRITE_IO 1186 /*! cursor: Total number of entries skipped by cursor next calls */ -#define WT_STAT_CONN_CURSOR_NEXT_SKIP_TOTAL 1186 +#define WT_STAT_CONN_CURSOR_NEXT_SKIP_TOTAL 1187 /*! cursor: Total number of entries skipped by cursor prev calls */ -#define WT_STAT_CONN_CURSOR_PREV_SKIP_TOTAL 1187 +#define WT_STAT_CONN_CURSOR_PREV_SKIP_TOTAL 1188 /*! * cursor: Total number of entries skipped to position the history store * cursor */ -#define WT_STAT_CONN_CURSOR_SKIP_HS_CUR_POSITION 1188 +#define WT_STAT_CONN_CURSOR_SKIP_HS_CUR_POSITION 1189 /*! * cursor: Total number of pages skipped without reading by cursor next * calls */ -#define WT_STAT_CONN_CURSOR_NEXT_SKIP_PAGE_COUNT 1189 +#define WT_STAT_CONN_CURSOR_NEXT_SKIP_PAGE_COUNT 1190 /*! * cursor: Total number of pages skipped without reading by cursor prev * calls */ -#define WT_STAT_CONN_CURSOR_PREV_SKIP_PAGE_COUNT 1190 +#define WT_STAT_CONN_CURSOR_PREV_SKIP_PAGE_COUNT 1191 /*! * cursor: Total number of times a search near has exited due to prefix * config */ -#define WT_STAT_CONN_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS 1191 +#define WT_STAT_CONN_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS 1192 /*! cursor: cached cursor count */ -#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1192 +#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1193 /*! cursor: cursor bulk loaded cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT_BULK 1193 +#define WT_STAT_CONN_CURSOR_INSERT_BULK 1194 /*! cursor: cursor close calls that result in cache */ -#define WT_STAT_CONN_CURSOR_CACHE 1194 +#define WT_STAT_CONN_CURSOR_CACHE 1195 /*! cursor: cursor create calls */ -#define WT_STAT_CONN_CURSOR_CREATE 1195 +#define WT_STAT_CONN_CURSOR_CREATE 1196 /*! cursor: cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT 1196 +#define WT_STAT_CONN_CURSOR_INSERT 1197 /*! cursor: cursor insert key and value bytes */ -#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1197 +#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1198 /*! cursor: cursor modify calls */ -#define WT_STAT_CONN_CURSOR_MODIFY 1198 +#define WT_STAT_CONN_CURSOR_MODIFY 1199 /*! cursor: cursor modify key and value bytes affected */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1199 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1200 /*! cursor: cursor modify value bytes modified */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1200 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1201 /*! cursor: cursor next calls */ -#define WT_STAT_CONN_CURSOR_NEXT 1201 +#define WT_STAT_CONN_CURSOR_NEXT 1202 /*! * cursor: cursor next calls that skip due to a globally visible history * store tombstone */ -#define WT_STAT_CONN_CURSOR_NEXT_HS_TOMBSTONE 1202 +#define WT_STAT_CONN_CURSOR_NEXT_HS_TOMBSTONE 1203 /*! * cursor: cursor next calls that skip greater than or equal to 100 * entries */ -#define WT_STAT_CONN_CURSOR_NEXT_SKIP_GE_100 1203 +#define WT_STAT_CONN_CURSOR_NEXT_SKIP_GE_100 1204 /*! cursor: cursor next calls that skip less than 100 entries */ -#define WT_STAT_CONN_CURSOR_NEXT_SKIP_LT_100 1204 +#define WT_STAT_CONN_CURSOR_NEXT_SKIP_LT_100 1205 /*! cursor: cursor operation restarted */ -#define WT_STAT_CONN_CURSOR_RESTART 1205 +#define WT_STAT_CONN_CURSOR_RESTART 1206 /*! cursor: cursor prev calls */ -#define WT_STAT_CONN_CURSOR_PREV 1206 +#define WT_STAT_CONN_CURSOR_PREV 1207 /*! * cursor: cursor prev calls that skip due to a globally visible history * store tombstone */ -#define WT_STAT_CONN_CURSOR_PREV_HS_TOMBSTONE 1207 +#define WT_STAT_CONN_CURSOR_PREV_HS_TOMBSTONE 1208 /*! * cursor: cursor prev calls that skip greater than or equal to 100 * entries */ -#define WT_STAT_CONN_CURSOR_PREV_SKIP_GE_100 1208 +#define WT_STAT_CONN_CURSOR_PREV_SKIP_GE_100 1209 /*! cursor: cursor prev calls that skip less than 100 entries */ -#define WT_STAT_CONN_CURSOR_PREV_SKIP_LT_100 1209 +#define WT_STAT_CONN_CURSOR_PREV_SKIP_LT_100 1210 /*! cursor: cursor remove calls */ -#define WT_STAT_CONN_CURSOR_REMOVE 1210 +#define WT_STAT_CONN_CURSOR_REMOVE 1211 /*! cursor: cursor remove key bytes removed */ -#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1211 +#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1212 /*! cursor: cursor reserve calls */ -#define WT_STAT_CONN_CURSOR_RESERVE 1212 +#define WT_STAT_CONN_CURSOR_RESERVE 1213 /*! cursor: cursor reset calls */ -#define WT_STAT_CONN_CURSOR_RESET 1213 +#define WT_STAT_CONN_CURSOR_RESET 1214 /*! cursor: cursor search calls */ -#define WT_STAT_CONN_CURSOR_SEARCH 1214 +#define WT_STAT_CONN_CURSOR_SEARCH 1215 /*! cursor: cursor search history store calls */ -#define WT_STAT_CONN_CURSOR_SEARCH_HS 1215 +#define WT_STAT_CONN_CURSOR_SEARCH_HS 1216 /*! cursor: cursor search near calls */ -#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1216 +#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1217 /*! cursor: cursor sweep buckets */ -#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1217 +#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1218 /*! cursor: cursor sweep cursors closed */ -#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1218 +#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1219 /*! cursor: cursor sweep cursors examined */ -#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1219 +#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1220 /*! cursor: cursor sweeps */ -#define WT_STAT_CONN_CURSOR_SWEEP 1220 +#define WT_STAT_CONN_CURSOR_SWEEP 1221 /*! cursor: cursor truncate calls */ -#define WT_STAT_CONN_CURSOR_TRUNCATE 1221 +#define WT_STAT_CONN_CURSOR_TRUNCATE 1222 /*! cursor: cursor update calls */ -#define WT_STAT_CONN_CURSOR_UPDATE 1222 +#define WT_STAT_CONN_CURSOR_UPDATE 1223 /*! cursor: cursor update key and value bytes */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1223 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1224 /*! cursor: cursor update value size change */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1224 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1225 /*! cursor: cursors reused from cache */ -#define WT_STAT_CONN_CURSOR_REOPEN 1225 +#define WT_STAT_CONN_CURSOR_REOPEN 1226 /*! cursor: open cursor count */ -#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1226 +#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1227 /*! data-handle: connection data handle size */ -#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1227 +#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1228 /*! data-handle: connection data handles currently active */ -#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1228 +#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1229 /*! data-handle: connection sweep candidate became referenced */ -#define WT_STAT_CONN_DH_SWEEP_REF 1229 +#define WT_STAT_CONN_DH_SWEEP_REF 1230 /*! data-handle: connection sweep dhandles closed */ -#define WT_STAT_CONN_DH_SWEEP_CLOSE 1230 +#define WT_STAT_CONN_DH_SWEEP_CLOSE 1231 /*! data-handle: connection sweep dhandles removed from hash list */ -#define WT_STAT_CONN_DH_SWEEP_REMOVE 1231 +#define WT_STAT_CONN_DH_SWEEP_REMOVE 1232 /*! data-handle: connection sweep time-of-death sets */ -#define WT_STAT_CONN_DH_SWEEP_TOD 1232 +#define WT_STAT_CONN_DH_SWEEP_TOD 1233 /*! data-handle: connection sweeps */ -#define WT_STAT_CONN_DH_SWEEPS 1233 +#define WT_STAT_CONN_DH_SWEEPS 1234 /*! * data-handle: connection sweeps skipped due to checkpoint gathering * handles */ -#define WT_STAT_CONN_DH_SWEEP_SKIP_CKPT 1234 +#define WT_STAT_CONN_DH_SWEEP_SKIP_CKPT 1235 /*! data-handle: session dhandles swept */ -#define WT_STAT_CONN_DH_SESSION_HANDLES 1235 +#define WT_STAT_CONN_DH_SESSION_HANDLES 1236 /*! data-handle: session sweep attempts */ -#define WT_STAT_CONN_DH_SESSION_SWEEPS 1236 +#define WT_STAT_CONN_DH_SESSION_SWEEPS 1237 /*! lock: checkpoint lock acquisitions */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1237 +#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1238 /*! lock: checkpoint lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1238 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1239 /*! lock: checkpoint lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1239 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1240 /*! lock: dhandle lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1240 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1241 /*! lock: dhandle lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1241 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1242 /*! lock: dhandle read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1242 +#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1243 /*! lock: dhandle write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1243 +#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1244 /*! * lock: durable timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION 1244 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION 1245 /*! * lock: durable timestamp queue lock internal thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL 1245 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL 1246 /*! lock: durable timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT 1246 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT 1247 /*! lock: durable timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT 1247 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT 1248 /*! lock: metadata lock acquisitions */ -#define WT_STAT_CONN_LOCK_METADATA_COUNT 1248 +#define WT_STAT_CONN_LOCK_METADATA_COUNT 1249 /*! lock: metadata lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1249 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1250 /*! lock: metadata lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1250 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1251 /*! * lock: read timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1251 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1252 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1252 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1253 /*! lock: read timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1253 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1254 /*! lock: read timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1254 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1255 /*! lock: schema lock acquisitions */ -#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1255 +#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1256 /*! lock: schema lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1256 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1257 /*! lock: schema lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1257 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1258 /*! * lock: table lock application thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1258 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1259 /*! * lock: table lock internal thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1259 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1260 /*! lock: table read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1260 +#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1261 /*! lock: table write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1261 +#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1262 /*! lock: txn global lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1262 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1263 /*! lock: txn global lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1263 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1264 /*! lock: txn global read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1264 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1265 /*! lock: txn global write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1265 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1266 /*! log: busy returns attempting to switch slots */ -#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1266 +#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1267 /*! log: force archive time sleeping (usecs) */ -#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1267 +#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1268 /*! log: log bytes of payload data */ -#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1268 +#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1269 /*! log: log bytes written */ -#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1269 +#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1270 /*! log: log files manually zero-filled */ -#define WT_STAT_CONN_LOG_ZERO_FILLS 1270 +#define WT_STAT_CONN_LOG_ZERO_FILLS 1271 /*! log: log flush operations */ -#define WT_STAT_CONN_LOG_FLUSH 1271 +#define WT_STAT_CONN_LOG_FLUSH 1272 /*! log: log force write operations */ -#define WT_STAT_CONN_LOG_FORCE_WRITE 1272 +#define WT_STAT_CONN_LOG_FORCE_WRITE 1273 /*! log: log force write operations skipped */ -#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1273 +#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1274 /*! log: log records compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1274 +#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1275 /*! log: log records not compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1275 +#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1276 /*! log: log records too small to compress */ -#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1276 +#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1277 /*! log: log release advances write LSN */ -#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1277 +#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1278 /*! log: log scan operations */ -#define WT_STAT_CONN_LOG_SCANS 1278 +#define WT_STAT_CONN_LOG_SCANS 1279 /*! log: log scan records requiring two reads */ -#define WT_STAT_CONN_LOG_SCAN_REREADS 1279 +#define WT_STAT_CONN_LOG_SCAN_REREADS 1280 /*! log: log server thread advances write LSN */ -#define WT_STAT_CONN_LOG_WRITE_LSN 1280 +#define WT_STAT_CONN_LOG_WRITE_LSN 1281 /*! log: log server thread write LSN walk skipped */ -#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1281 +#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1282 /*! log: log sync operations */ -#define WT_STAT_CONN_LOG_SYNC 1282 +#define WT_STAT_CONN_LOG_SYNC 1283 /*! log: log sync time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DURATION 1283 +#define WT_STAT_CONN_LOG_SYNC_DURATION 1284 /*! log: log sync_dir operations */ -#define WT_STAT_CONN_LOG_SYNC_DIR 1284 +#define WT_STAT_CONN_LOG_SYNC_DIR 1285 /*! log: log sync_dir time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1285 +#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1286 /*! log: log write operations */ -#define WT_STAT_CONN_LOG_WRITES 1286 +#define WT_STAT_CONN_LOG_WRITES 1287 /*! log: logging bytes consolidated */ -#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1287 +#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1288 /*! log: maximum log file size */ -#define WT_STAT_CONN_LOG_MAX_FILESIZE 1288 +#define WT_STAT_CONN_LOG_MAX_FILESIZE 1289 /*! log: number of pre-allocated log files to create */ -#define WT_STAT_CONN_LOG_PREALLOC_MAX 1289 +#define WT_STAT_CONN_LOG_PREALLOC_MAX 1290 /*! log: pre-allocated log files not ready and missed */ -#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1290 +#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1291 /*! log: pre-allocated log files prepared */ -#define WT_STAT_CONN_LOG_PREALLOC_FILES 1291 +#define WT_STAT_CONN_LOG_PREALLOC_FILES 1292 /*! log: pre-allocated log files used */ -#define WT_STAT_CONN_LOG_PREALLOC_USED 1292 +#define WT_STAT_CONN_LOG_PREALLOC_USED 1293 /*! log: records processed by log scan */ -#define WT_STAT_CONN_LOG_SCAN_RECORDS 1293 +#define WT_STAT_CONN_LOG_SCAN_RECORDS 1294 /*! log: slot close lost race */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1294 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1295 /*! log: slot close unbuffered waits */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1295 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1296 /*! log: slot closures */ -#define WT_STAT_CONN_LOG_SLOT_CLOSES 1296 +#define WT_STAT_CONN_LOG_SLOT_CLOSES 1297 /*! log: slot join atomic update races */ -#define WT_STAT_CONN_LOG_SLOT_RACES 1297 +#define WT_STAT_CONN_LOG_SLOT_RACES 1298 /*! log: slot join calls atomic updates raced */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1298 +#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1299 /*! log: slot join calls did not yield */ -#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1299 +#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1300 /*! log: slot join calls found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1300 +#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1301 /*! log: slot join calls slept */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1301 +#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1302 /*! log: slot join calls yielded */ -#define WT_STAT_CONN_LOG_SLOT_YIELD 1302 +#define WT_STAT_CONN_LOG_SLOT_YIELD 1303 /*! log: slot join found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1303 +#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1304 /*! log: slot joins yield time (usecs) */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1304 +#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1305 /*! log: slot transitions unable to find free slot */ -#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1305 +#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1306 /*! log: slot unbuffered writes */ -#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1306 +#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1307 /*! log: total in-memory size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_MEM 1307 +#define WT_STAT_CONN_LOG_COMPRESS_MEM 1308 /*! log: total log buffer size */ -#define WT_STAT_CONN_LOG_BUFFER_SIZE 1308 +#define WT_STAT_CONN_LOG_BUFFER_SIZE 1309 /*! log: total size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_LEN 1309 +#define WT_STAT_CONN_LOG_COMPRESS_LEN 1310 /*! log: written slots coalesced */ -#define WT_STAT_CONN_LOG_SLOT_COALESCED 1310 +#define WT_STAT_CONN_LOG_SLOT_COALESCED 1311 /*! log: yields waiting for previous log file close */ -#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1311 +#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1312 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1312 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1313 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1313 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1314 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1314 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1315 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1315 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1316 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1316 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1317 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1317 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1318 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1318 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1319 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1319 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1320 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1320 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1321 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1321 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1322 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1322 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1323 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1323 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1324 /*! perf: operation read latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1324 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1325 /*! perf: operation read latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1325 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1326 /*! perf: operation read latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1326 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1327 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1327 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1328 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1328 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1329 /*! perf: operation write latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1329 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1330 /*! perf: operation write latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1330 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1331 /*! perf: operation write latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1331 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1332 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1332 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1333 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1333 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1334 /*! reconciliation: approximate byte size of timestamps in pages written */ -#define WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TS 1334 +#define WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TS 1335 /*! * reconciliation: approximate byte size of transaction IDs in pages * written */ -#define WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TXN 1335 +#define WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TXN 1336 /*! reconciliation: fast-path pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1336 +#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1337 /*! reconciliation: internal-page overflow keys */ -#define WT_STAT_CONN_REC_OVERFLOW_KEY_INTERNAL 1337 +#define WT_STAT_CONN_REC_OVERFLOW_KEY_INTERNAL 1338 /*! reconciliation: leaf-page overflow keys */ -#define WT_STAT_CONN_REC_OVERFLOW_KEY_LEAF 1338 +#define WT_STAT_CONN_REC_OVERFLOW_KEY_LEAF 1339 /*! reconciliation: maximum seconds spent in a reconciliation call */ -#define WT_STAT_CONN_REC_MAXIMUM_SECONDS 1339 +#define WT_STAT_CONN_REC_MAXIMUM_SECONDS 1340 /*! reconciliation: page reconciliation calls */ -#define WT_STAT_CONN_REC_PAGES 1340 +#define WT_STAT_CONN_REC_PAGES 1341 /*! reconciliation: page reconciliation calls for eviction */ -#define WT_STAT_CONN_REC_PAGES_EVICTION 1341 +#define WT_STAT_CONN_REC_PAGES_EVICTION 1342 /*! * reconciliation: page reconciliation calls that resulted in values with * prepared transaction metadata */ -#define WT_STAT_CONN_REC_PAGES_WITH_PREPARE 1342 +#define WT_STAT_CONN_REC_PAGES_WITH_PREPARE 1343 /*! * reconciliation: page reconciliation calls that resulted in values with * timestamps */ -#define WT_STAT_CONN_REC_PAGES_WITH_TS 1343 +#define WT_STAT_CONN_REC_PAGES_WITH_TS 1344 /*! * reconciliation: page reconciliation calls that resulted in values with * transaction ids */ -#define WT_STAT_CONN_REC_PAGES_WITH_TXN 1344 +#define WT_STAT_CONN_REC_PAGES_WITH_TXN 1345 /*! reconciliation: pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE 1345 +#define WT_STAT_CONN_REC_PAGE_DELETE 1346 /*! * reconciliation: pages written including an aggregated newest start * durable timestamp */ -#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_START_DURABLE_TS 1346 +#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_START_DURABLE_TS 1347 /*! * reconciliation: pages written including an aggregated newest stop * durable timestamp */ -#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS 1347 +#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS 1348 /*! * reconciliation: pages written including an aggregated newest stop * timestamp */ -#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TS 1348 +#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TS 1349 /*! * reconciliation: pages written including an aggregated newest stop * transaction ID */ -#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TXN 1349 +#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TXN 1350 /*! * reconciliation: pages written including an aggregated newest * transaction ID */ -#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_TXN 1350 +#define WT_STAT_CONN_REC_TIME_AGGR_NEWEST_TXN 1351 /*! * reconciliation: pages written including an aggregated oldest start * timestamp */ -#define WT_STAT_CONN_REC_TIME_AGGR_OLDEST_START_TS 1351 +#define WT_STAT_CONN_REC_TIME_AGGR_OLDEST_START_TS 1352 /*! reconciliation: pages written including an aggregated prepare */ -#define WT_STAT_CONN_REC_TIME_AGGR_PREPARED 1352 +#define WT_STAT_CONN_REC_TIME_AGGR_PREPARED 1353 /*! reconciliation: pages written including at least one prepare state */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_PREPARED 1353 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_PREPARED 1354 /*! * reconciliation: pages written including at least one start durable * timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_START_TS 1354 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_START_TS 1355 /*! reconciliation: pages written including at least one start timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TS 1355 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TS 1356 /*! * reconciliation: pages written including at least one start transaction * ID */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TXN 1356 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TXN 1357 /*! * reconciliation: pages written including at least one stop durable * timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS 1357 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS 1358 /*! reconciliation: pages written including at least one stop timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TS 1358 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TS 1359 /*! * reconciliation: pages written including at least one stop transaction * ID */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TXN 1359 +#define WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TXN 1360 /*! reconciliation: records written including a prepare state */ -#define WT_STAT_CONN_REC_TIME_WINDOW_PREPARED 1360 +#define WT_STAT_CONN_REC_TIME_WINDOW_PREPARED 1361 /*! reconciliation: records written including a start durable timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_START_TS 1361 +#define WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_START_TS 1362 /*! reconciliation: records written including a start timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_START_TS 1362 +#define WT_STAT_CONN_REC_TIME_WINDOW_START_TS 1363 /*! reconciliation: records written including a start transaction ID */ -#define WT_STAT_CONN_REC_TIME_WINDOW_START_TXN 1363 +#define WT_STAT_CONN_REC_TIME_WINDOW_START_TXN 1364 /*! reconciliation: records written including a stop durable timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_STOP_TS 1364 +#define WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_STOP_TS 1365 /*! reconciliation: records written including a stop timestamp */ -#define WT_STAT_CONN_REC_TIME_WINDOW_STOP_TS 1365 +#define WT_STAT_CONN_REC_TIME_WINDOW_STOP_TS 1366 /*! reconciliation: records written including a stop transaction ID */ -#define WT_STAT_CONN_REC_TIME_WINDOW_STOP_TXN 1366 +#define WT_STAT_CONN_REC_TIME_WINDOW_STOP_TXN 1367 /*! reconciliation: split bytes currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1367 +#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1368 /*! reconciliation: split objects currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1368 +#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1369 /*! session: flush state races */ -#define WT_STAT_CONN_FLUSH_STATE_RACES 1369 +#define WT_STAT_CONN_FLUSH_STATE_RACES 1370 /*! session: flush_tier operation calls */ -#define WT_STAT_CONN_FLUSH_TIER 1370 +#define WT_STAT_CONN_FLUSH_TIER 1371 /*! session: open session count */ -#define WT_STAT_CONN_SESSION_OPEN 1371 +#define WT_STAT_CONN_SESSION_OPEN 1372 /*! session: session query timestamp calls */ -#define WT_STAT_CONN_SESSION_QUERY_TS 1372 +#define WT_STAT_CONN_SESSION_QUERY_TS 1373 /*! session: table alter failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1373 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1374 /*! session: table alter successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1374 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1375 /*! session: table alter unchanged and skipped */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1375 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1376 /*! session: table compact failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1376 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1377 /*! session: table compact successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1377 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1378 /*! session: table create failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1378 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1379 /*! session: table create successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1379 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1380 /*! session: table drop failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1380 +#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1381 /*! session: table drop successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1381 +#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1382 /*! session: table rename failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1382 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1383 /*! session: table rename successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1383 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1384 /*! session: table salvage failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1384 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1385 /*! session: table salvage successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1385 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1386 /*! session: table truncate failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1386 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1387 /*! session: table truncate successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1387 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1388 /*! session: table verify failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1388 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1389 /*! session: table verify successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1389 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1390 /*! session: tiered operations dequeued and processed */ -#define WT_STAT_CONN_TIERED_WORK_UNITS_DEQUEUED 1390 +#define WT_STAT_CONN_TIERED_WORK_UNITS_DEQUEUED 1391 /*! session: tiered operations scheduled */ -#define WT_STAT_CONN_TIERED_WORK_UNITS_CREATED 1391 +#define WT_STAT_CONN_TIERED_WORK_UNITS_CREATED 1392 /*! session: tiered storage local retention time (secs) */ -#define WT_STAT_CONN_TIERED_RETENTION 1392 +#define WT_STAT_CONN_TIERED_RETENTION 1393 /*! session: tiered storage object size */ -#define WT_STAT_CONN_TIERED_OBJECT_SIZE 1393 +#define WT_STAT_CONN_TIERED_OBJECT_SIZE 1394 /*! thread-state: active filesystem fsync calls */ -#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1394 +#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1395 /*! thread-state: active filesystem read calls */ -#define WT_STAT_CONN_THREAD_READ_ACTIVE 1395 +#define WT_STAT_CONN_THREAD_READ_ACTIVE 1396 /*! thread-state: active filesystem write calls */ -#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1396 +#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1397 /*! thread-yield: application thread time evicting (usecs) */ -#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1397 +#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1398 /*! thread-yield: application thread time waiting for cache (usecs) */ -#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1398 +#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1399 /*! * thread-yield: connection close blocked waiting for transaction state * stabilization */ -#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1399 +#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1400 /*! thread-yield: connection close yielded for lsm manager shutdown */ -#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1400 +#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1401 /*! thread-yield: data handle lock yielded */ -#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1401 +#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1402 /*! * thread-yield: get reference for page index and slot time sleeping * (usecs) */ -#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1402 +#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1403 /*! thread-yield: log server sync yielded for log write */ -#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1403 +#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1404 /*! thread-yield: page access yielded due to prepare state change */ -#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1404 +#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1405 /*! thread-yield: page acquire busy blocked */ -#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1405 +#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1406 /*! thread-yield: page acquire eviction blocked */ -#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1406 +#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1407 /*! thread-yield: page acquire locked blocked */ -#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1407 +#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1408 /*! thread-yield: page acquire read blocked */ -#define WT_STAT_CONN_PAGE_READ_BLOCKED 1408 +#define WT_STAT_CONN_PAGE_READ_BLOCKED 1409 /*! thread-yield: page acquire time sleeping (usecs) */ -#define WT_STAT_CONN_PAGE_SLEEP 1409 +#define WT_STAT_CONN_PAGE_SLEEP 1410 /*! * thread-yield: page delete rollback time sleeping for state change * (usecs) */ -#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1410 +#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1411 /*! thread-yield: page reconciliation yielded due to child modification */ -#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1411 +#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1412 /*! transaction: Number of prepared updates */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES 1412 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES 1413 /*! transaction: Number of prepared updates committed */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COMMITTED 1413 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COMMITTED 1414 /*! transaction: Number of prepared updates repeated on the same key */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_KEY_REPEATED 1414 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_KEY_REPEATED 1415 /*! transaction: Number of prepared updates rolled back */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_ROLLEDBACK 1415 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_ROLLEDBACK 1416 /*! transaction: prepared transactions */ -#define WT_STAT_CONN_TXN_PREPARE 1416 +#define WT_STAT_CONN_TXN_PREPARE 1417 /*! transaction: prepared transactions committed */ -#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1417 +#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1418 /*! transaction: prepared transactions currently active */ -#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1418 +#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1419 /*! transaction: prepared transactions rolled back */ -#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1419 +#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1420 /*! transaction: query timestamp calls */ -#define WT_STAT_CONN_TXN_QUERY_TS 1420 +#define WT_STAT_CONN_TXN_QUERY_TS 1421 /*! transaction: race to read prepared update retry */ -#define WT_STAT_CONN_TXN_READ_RACE_PREPARE_UPDATE 1421 +#define WT_STAT_CONN_TXN_READ_RACE_PREPARE_UPDATE 1422 /*! transaction: rollback to stable calls */ -#define WT_STAT_CONN_TXN_RTS 1422 +#define WT_STAT_CONN_TXN_RTS 1423 /*! * transaction: rollback to stable history store records with stop * timestamps older than newer records */ -#define WT_STAT_CONN_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START 1423 +#define WT_STAT_CONN_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START 1424 /*! transaction: rollback to stable inconsistent checkpoint */ -#define WT_STAT_CONN_TXN_RTS_INCONSISTENT_CKPT 1424 +#define WT_STAT_CONN_TXN_RTS_INCONSISTENT_CKPT 1425 /*! transaction: rollback to stable keys removed */ -#define WT_STAT_CONN_TXN_RTS_KEYS_REMOVED 1425 +#define WT_STAT_CONN_TXN_RTS_KEYS_REMOVED 1426 /*! transaction: rollback to stable keys restored */ -#define WT_STAT_CONN_TXN_RTS_KEYS_RESTORED 1426 +#define WT_STAT_CONN_TXN_RTS_KEYS_RESTORED 1427 /*! transaction: rollback to stable pages visited */ -#define WT_STAT_CONN_TXN_RTS_PAGES_VISITED 1427 +#define WT_STAT_CONN_TXN_RTS_PAGES_VISITED 1428 /*! transaction: rollback to stable restored tombstones from history store */ -#define WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES 1428 +#define WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES 1429 /*! transaction: rollback to stable restored updates from history store */ -#define WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES 1429 +#define WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES 1430 /*! transaction: rollback to stable sweeping history store keys */ -#define WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS 1430 +#define WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS 1431 /*! transaction: rollback to stable tree walk skipping pages */ -#define WT_STAT_CONN_TXN_RTS_TREE_WALK_SKIP_PAGES 1431 +#define WT_STAT_CONN_TXN_RTS_TREE_WALK_SKIP_PAGES 1432 /*! transaction: rollback to stable updates aborted */ -#define WT_STAT_CONN_TXN_RTS_UPD_ABORTED 1432 +#define WT_STAT_CONN_TXN_RTS_UPD_ABORTED 1433 /*! transaction: rollback to stable updates removed from history store */ -#define WT_STAT_CONN_TXN_RTS_HS_REMOVED 1433 +#define WT_STAT_CONN_TXN_RTS_HS_REMOVED 1434 /*! transaction: sessions scanned in each walk of concurrent sessions */ -#define WT_STAT_CONN_TXN_SESSIONS_WALKED 1434 +#define WT_STAT_CONN_TXN_SESSIONS_WALKED 1435 /*! transaction: set timestamp calls */ -#define WT_STAT_CONN_TXN_SET_TS 1435 +#define WT_STAT_CONN_TXN_SET_TS 1436 /*! transaction: set timestamp durable calls */ -#define WT_STAT_CONN_TXN_SET_TS_DURABLE 1436 +#define WT_STAT_CONN_TXN_SET_TS_DURABLE 1437 /*! transaction: set timestamp durable updates */ -#define WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD 1437 +#define WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD 1438 /*! transaction: set timestamp oldest calls */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1438 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1439 /*! transaction: set timestamp oldest updates */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1439 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1440 /*! transaction: set timestamp stable calls */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE 1440 +#define WT_STAT_CONN_TXN_SET_TS_STABLE 1441 /*! transaction: set timestamp stable updates */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1441 +#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1442 /*! transaction: transaction begins */ -#define WT_STAT_CONN_TXN_BEGIN 1442 +#define WT_STAT_CONN_TXN_BEGIN 1443 /*! transaction: transaction checkpoint currently running */ -#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1443 +#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1444 /*! * transaction: transaction checkpoint currently running for history * store file */ -#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING_HS 1444 +#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING_HS 1445 /*! transaction: transaction checkpoint generation */ -#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1445 +#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1446 /*! * transaction: transaction checkpoint history store file duration * (usecs) */ -#define WT_STAT_CONN_TXN_HS_CKPT_DURATION 1446 +#define WT_STAT_CONN_TXN_HS_CKPT_DURATION 1447 /*! transaction: transaction checkpoint max time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1447 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1448 /*! transaction: transaction checkpoint min time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1448 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1449 /*! * transaction: transaction checkpoint most recent duration for gathering * all handles (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION 1449 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION 1450 /*! * transaction: transaction checkpoint most recent duration for gathering * applied handles (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_APPLY 1450 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_APPLY 1451 /*! * transaction: transaction checkpoint most recent duration for gathering * skipped handles (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_SKIP 1451 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_SKIP 1452 /*! transaction: transaction checkpoint most recent handles applied */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_APPLIED 1452 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_APPLIED 1453 /*! transaction: transaction checkpoint most recent handles skipped */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_SKIPPED 1453 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_SKIPPED 1454 /*! transaction: transaction checkpoint most recent handles walked */ -#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_WALKED 1454 +#define WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_WALKED 1455 /*! transaction: transaction checkpoint most recent time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1455 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1456 /*! transaction: transaction checkpoint prepare currently running */ -#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_RUNNING 1456 +#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_RUNNING 1457 /*! transaction: transaction checkpoint prepare max time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_MAX 1457 +#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_MAX 1458 /*! transaction: transaction checkpoint prepare min time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_MIN 1458 +#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_MIN 1459 /*! transaction: transaction checkpoint prepare most recent time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_RECENT 1459 +#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_RECENT 1460 /*! transaction: transaction checkpoint prepare total time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_TOTAL 1460 +#define WT_STAT_CONN_TXN_CHECKPOINT_PREP_TOTAL 1461 /*! transaction: transaction checkpoint scrub dirty target */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1461 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1462 /*! transaction: transaction checkpoint scrub time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1462 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1463 /*! transaction: transaction checkpoint total time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1463 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1464 /*! transaction: transaction checkpoints */ -#define WT_STAT_CONN_TXN_CHECKPOINT 1464 +#define WT_STAT_CONN_TXN_CHECKPOINT 1465 /*! transaction: transaction checkpoints due to obsolete pages */ -#define WT_STAT_CONN_TXN_CHECKPOINT_OBSOLETE_APPLIED 1465 +#define WT_STAT_CONN_TXN_CHECKPOINT_OBSOLETE_APPLIED 1466 /*! * transaction: transaction checkpoints skipped because database was * clean */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1466 +#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1467 /*! transaction: transaction failures due to history store */ -#define WT_STAT_CONN_TXN_FAIL_CACHE 1467 +#define WT_STAT_CONN_TXN_FAIL_CACHE 1468 /*! * transaction: transaction fsync calls for checkpoint after allocating * the transaction ID */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1468 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1469 /*! * transaction: transaction fsync duration for checkpoint after * allocating the transaction ID (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1469 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1470 /*! transaction: transaction range of IDs currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_RANGE 1470 +#define WT_STAT_CONN_TXN_PINNED_RANGE 1471 /*! transaction: transaction range of IDs currently pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1471 +#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1472 /*! transaction: transaction range of timestamps currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1472 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1473 /*! transaction: transaction range of timestamps pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1473 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1474 /*! * transaction: transaction range of timestamps pinned by the oldest * active read timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1474 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1475 /*! * transaction: transaction range of timestamps pinned by the oldest * timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1475 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1476 /*! transaction: transaction read timestamp of the oldest active reader */ -#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1476 +#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1477 /*! transaction: transaction rollback to stable currently running */ -#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE_RUNNING 1477 +#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE_RUNNING 1478 /*! transaction: transaction sync calls */ -#define WT_STAT_CONN_TXN_SYNC 1478 +#define WT_STAT_CONN_TXN_SYNC 1479 /*! transaction: transaction walk of concurrent sessions */ -#define WT_STAT_CONN_TXN_WALK_SESSIONS 1479 +#define WT_STAT_CONN_TXN_WALK_SESSIONS 1480 /*! transaction: transactions committed */ -#define WT_STAT_CONN_TXN_COMMIT 1480 +#define WT_STAT_CONN_TXN_COMMIT 1481 /*! transaction: transactions rolled back */ -#define WT_STAT_CONN_TXN_ROLLBACK 1481 +#define WT_STAT_CONN_TXN_ROLLBACK 1482 /*! transaction: update conflicts */ -#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1482 +#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1483 /*! * @} diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c index a7f7c70f9c6..9ec45ccd6ba 100644 --- a/src/third_party/wiredtiger/src/support/stat.c +++ b/src/third_party/wiredtiger/src/support/stat.c @@ -1066,6 +1066,7 @@ static const char *const __stats_connection_desc[] = { "cache: forced eviction - pages evicted that were clean time (usecs)", "cache: forced eviction - pages evicted that were dirty count", "cache: forced eviction - pages evicted that were dirty time (usecs)", + "cache: forced eviction - pages selected because of a large number of updates to a single item", "cache: forced eviction - pages selected because of too many deleted items count", "cache: forced eviction - pages selected count", "cache: forced eviction - pages selected unable to be evicted count", @@ -1597,6 +1598,7 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) stats->cache_eviction_force_clean_time = 0; stats->cache_eviction_force_dirty = 0; stats->cache_eviction_force_dirty_time = 0; + stats->cache_eviction_force_long_update_list = 0; stats->cache_eviction_force_delete = 0; stats->cache_eviction_force = 0; stats->cache_eviction_force_fail = 0; @@ -2104,6 +2106,8 @@ __wt_stat_connection_aggregate(WT_CONNECTION_STATS **from, WT_CONNECTION_STATS * to->cache_eviction_force_clean_time += WT_STAT_READ(from, cache_eviction_force_clean_time); to->cache_eviction_force_dirty += WT_STAT_READ(from, cache_eviction_force_dirty); to->cache_eviction_force_dirty_time += WT_STAT_READ(from, cache_eviction_force_dirty_time); + to->cache_eviction_force_long_update_list += + WT_STAT_READ(from, cache_eviction_force_long_update_list); to->cache_eviction_force_delete += WT_STAT_READ(from, cache_eviction_force_delete); to->cache_eviction_force += WT_STAT_READ(from, cache_eviction_force); to->cache_eviction_force_fail += WT_STAT_READ(from, cache_eviction_force_fail); diff --git a/src/third_party/wiredtiger/src/tiered/tiered_handle.c b/src/third_party/wiredtiger/src/tiered/tiered_handle.c index af7a81bf341..5cfd583b1c9 100644 --- a/src/third_party/wiredtiger/src/tiered/tiered_handle.c +++ b/src/third_party/wiredtiger/src/tiered/tiered_handle.c @@ -577,7 +577,6 @@ __tiered_open(WT_SESSION_IMPL *session, const char *cfg[]) if (0) { err: __wt_free(session, tiered->obj_config); - __wt_free(session, tiered->tiers); __wt_free(session, metaconf); } __wt_verbose(session, WT_VERB_TIERED, "TIERED_OPEN: Done ret %d", ret); diff --git a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c index 0a6b7e52cf9..97da70f3b6b 100644 --- a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c +++ b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c @@ -1672,7 +1672,13 @@ __rollback_to_stable(WT_SESSION_IMPL *session, bool no_ckpt) if (retries == WT_RTS_EVICT_MAX_RETRIES) { WT_ERR(__wt_msg( session, "timed out waiting for eviction to quiesce, running rollback to stable")); - WT_ASSERT(session, false && "Timed out waiting for eviction to quiesce prior to rts"); + /* + * FIXME: WT-7877 RTS fails when there are active transactions running in parallel to it. + * Waiting in a loop for eviction to quiesce is not efficient in some scenarios where the + * cache is not cleared in 2 minutes. Enable the following assert and + * test_rollback_to_stable22.py when the cache issue is addressed. + */ + /* WT_ASSERT(session, false && "Timed out waiting for eviction to quiesce prior to rts"); */ } /* diff --git a/src/third_party/wiredtiger/src/utilities/util_list.c b/src/third_party/wiredtiger/src/utilities/util_list.c index e0953c0abfe..49e8ae0b199 100644 --- a/src/third_party/wiredtiger/src/utilities/util_list.c +++ b/src/third_party/wiredtiger/src/utilities/util_list.c @@ -258,7 +258,8 @@ list_print_checkpoint(WT_SESSION *session, const char *key) /* Decode the checkpoint block. */ if (ckpt->raw.data == NULL) continue; - if ((ret = __wt_block_ckpt_decode(session, block, ckpt->raw.data, &ci)) == 0) { + if ((ret = __wt_block_ckpt_decode(session, block, ckpt->raw.data, ckpt->raw.size, &ci)) == + 0) { printf( "\t\t" "file-size: "); diff --git a/src/third_party/wiredtiger/test/evergreen.yml b/src/third_party/wiredtiger/test/evergreen.yml index c1eefaa2349..9191a9447e8 100755 --- a/src/third_party/wiredtiger/test/evergreen.yml +++ b/src/third_party/wiredtiger/test/evergreen.yml @@ -40,6 +40,25 @@ functions: params: path: "WT_TEST-big-endian.tgz" destination: "wiredtiger/build_posix/test/format" + "fetch artifacts from many-coll" : + - command: s3.get + params: + aws_key: ${aws_key} + aws_secret: ${aws_secret} + remote_file: dbpath_100k_500.tgz + bucket: build_external + local_file: dbpath_100k_500.tgz + - command: shell.exec + params: + shell: bash + script: | + set -o errexit + set -o verbose + mkdir -p mongo-tests/largescale/many-collection/dbpath + - command: archive.targz_extract + params: + path: "dbpath_100k_500.tgz" + destination: "mongo-tests/largescale/many-collection/dbpath/." "fetch mongo-tests repo" : command: shell.exec params: @@ -2576,6 +2595,10 @@ tasks: - func: "import wiredtiger into mongo" - func: "compile mongodb" - func: "fetch mongo-tests repo" + # After WT-7868 we can use the following function to retrieve an existing database and remove + # the "clean-and-populate" option from the script arguments to skip the initial populating + # step. + # - func: "fetch artifacts from many-coll" - command: shell.exec params: working_dir: mongo-tests/largescale @@ -2596,21 +2619,26 @@ tasks: - func: "get project" - command: shell.exec params: - working_dir: "wiredtiger/src" + working_dir: "wiredtiger" shell: bash script: | set -o verbose + # Install Metrix++, ensuring it is outside the 'src' directory git clone https://github.com/metrixplusplus/metrixplusplus metrixplusplus - python "metrixplusplus/metrix++.py" collect --std.code.lines.code --std.code.complexity.cyclomatic - python "metrixplusplus/metrix++.py" view + + # We only want complexity measures for the 'src' directory + cd src + + python "../metrixplusplus/metrix++.py" collect --std.code.lines.code --std.code.complexity.cyclomatic + python "../metrixplusplus/metrix++.py" view # Set the cyclomatic complexity limit to 20 - python "metrixplusplus/metrix++.py" limit --max-limit=std.code.complexity:cyclomatic:20 + python "../metrixplusplus/metrix++.py" limit --max-limit=std.code.complexity:cyclomatic:20 # Fail if there are functions with cyclomatic complexity larger than 95 set -o errexit - python "metrixplusplus/metrix++.py" limit --max-limit=std.code.complexity:cyclomatic:95 + python "../metrixplusplus/metrix++.py" limit --max-limit=std.code.complexity:cyclomatic:95 buildvariants: diff --git a/src/third_party/wiredtiger/test/suite/run.py b/src/third_party/wiredtiger/test/suite/run.py index 86aafdb261c..4e1971cbcbe 100755 --- a/src/third_party/wiredtiger/test/suite/run.py +++ b/src/third_party/wiredtiger/test/suite/run.py @@ -131,7 +131,8 @@ Options:\n\ -p | --preserve preserve output files in WT_TEST/<testname>\n\ -r N | --random-sample N randomly sort scenarios to be run, then\n\ execute every Nth (2<=N<=1000) scenario.\n\ - -s N | --scenario N use scenario N (N can be number or symbolic)\n\ + -s N | --scenario N use scenario N (N can be symbolic, number, or\n\ + list of numbers and ranges in the form 1,3-5,7)\n\ -t | --timestamp name WT_TEST according to timestamp\n\ -v N | --verbose N set verboseness to N (0<=N<=3, default=1)\n\ -i | --ignore-stdout dont fail on unexpected stdout or stderr\n\ @@ -178,16 +179,40 @@ def show_env(verbose, envvar): # e.g. test_util03 -> util reCatname = re.compile(r"test_([^0-9]+)[0-9]*") +# Look for a list of the form 0-9,11,15-17. +def parse_int_list(str): + # Use a dictionary as the result set to avoid repeated list scans. + # (Only the keys are used; the values are ignored.) + ret = {} + # Divide the input into ranges separated by commas. + for r in str.split(","): + # Split the range we got (if it is one). + bounds = r.split("-") + if len(bounds) == 1 and bounds[0].isdigit(): + # It's a single number with no dash. + scenario = int(bounds[0]) + ret[scenario] = True + continue + if len(bounds) == 2 and bounds[0].isdigit() and bounds[1].isdigit(): + # It's two numbers separated by a dash. + for scenario in range(int(bounds[0]), int(bounds[1]) + 1): + ret[scenario] = True + continue + # It's not valid syntax; give up. + return None + return ret + def restrictScenario(testcases, restrict): if restrict == '': return testcases - elif restrict.isdigit(): - s = int(restrict) - return [t for t in testcases - if hasattr(t, 'scenario_number') and t.scenario_number == s] else: - return [t for t in testcases - if hasattr(t, 'scenario_name') and t.scenario_name == restrict] + scenarios = parse_int_list(restrict) + if scenarios is not None: + return [t for t in testcases + if hasattr(t, 'scenario_number') and t.scenario_number in scenarios] + else: + return [t for t in testcases + if hasattr(t, 'scenario_name') and t.scenario_name == restrict] def addScenarioTests(tests, loader, testname, scenario): loaded = loader.loadTestsFromName(testname) diff --git a/src/third_party/wiredtiger/test/suite/test_checkpoint_snapshot04.py b/src/third_party/wiredtiger/test/suite/test_checkpoint_snapshot04.py index 70ce703c333..0bc908c26fc 100644 --- a/src/third_party/wiredtiger/test/suite/test_checkpoint_snapshot04.py +++ b/src/third_party/wiredtiger/test/suite/test_checkpoint_snapshot04.py @@ -50,7 +50,7 @@ class test_checkpoint_snapshot04(backup_base): scenarios = make_scenarios(target_backup) def conn_config(self): - config = 'cache_size=25MB' + config = 'cache_size=200MB' return config def large_updates(self, uri, value, ds, nrows): diff --git a/src/third_party/wiredtiger/test/suite/test_rollback_to_stable22.py b/src/third_party/wiredtiger/test/suite/test_rollback_to_stable22.py index ac56c6c6b5f..ac123fe9ccd 100644 --- a/src/third_party/wiredtiger/test/suite/test_rollback_to_stable22.py +++ b/src/third_party/wiredtiger/test/suite/test_rollback_to_stable22.py @@ -46,6 +46,8 @@ class test_rollback_to_stable22(test_rollback_to_stable_base): nrows = 1000 nds = 10 + self.skipTest('Skip it until the fix is provided to handle concurrent internal transactions running in parallel.') + # Create a few tables and populate them with some initial data. # # Our way of preventing history store operations from interfering with rollback to stable's diff --git a/src/third_party/wiredtiger/test/suite/test_tiered02.py b/src/third_party/wiredtiger/test/suite/test_tiered02.py index 6e50ec595d6..bed8e57ef54 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered02.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered02.py @@ -48,9 +48,11 @@ class test_tiered02(wttest.WiredTigerTestCase): 'bucket_prefix=%s,' % self.bucket_prefix + \ 'name=%s),tiered_manager=(wait=0)' % self.extension_name - # Load the local store extension, but skip the test if it is missing. + # Load the local store extension. def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) def progress(self, s): diff --git a/src/third_party/wiredtiger/test/suite/test_tiered03.py b/src/third_party/wiredtiger/test/suite/test_tiered03.py index 536bc00dd70..61e12c08e28 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered03.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered03.py @@ -62,9 +62,11 @@ class test_tiered03(wttest.WiredTigerTestCase): 'bucket_prefix=%s,' % self.bucket_prefix + \ 'name=%s)' % self.extension_name - # Load the local store extension, but skip the test if it is missing. + # Load the local store extension. def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) # Test sharing data between a primary and a secondary diff --git a/src/third_party/wiredtiger/test/suite/test_tiered04.py b/src/third_party/wiredtiger/test/suite/test_tiered04.py index bca7f43fc4d..efb5630eda6 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered04.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered04.py @@ -67,9 +67,11 @@ class test_tiered04(wttest.WiredTigerTestCase): 'name=%s,' % self.extension_name + \ 'object_target_size=%s)' % self.object_sys - # Load the local store extension, but skip the test if it is missing. + # Load the local store extension. def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) # Check for a specific string as part of the uri's metadata. @@ -183,10 +185,15 @@ class test_tiered04(wttest.WiredTigerTestCase): retain = self.get_stat(stat.conn.tiered_retention, None) self.assertEqual(retain, new) self.pr("reconfigure flush_tier") - self.session.flush_tier(None) + # Call flush_tier with its various configuration arguments. It is difficult + # to force a timeout or lock contention with a unit test. So just test the + # call for now. + self.session.flush_tier('timeout=10') + self.session.flush_tier('lock_wait=false') + self.session.flush_tier('sync=off') self.pr("reconfigure get stat") calls = self.get_stat(stat.conn.flush_tier, None) - self.assertEqual(calls, 5) + self.assertEqual(calls, 7) if __name__ == '__main__': wttest.run() diff --git a/src/third_party/wiredtiger/test/suite/test_tiered05.py b/src/third_party/wiredtiger/test/suite/test_tiered05.py index 5ac7293cb46..2af464ba64b 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered05.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered05.py @@ -42,7 +42,9 @@ class test_tiered05(wttest.WiredTigerTestCase): wait = 2 def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) def conn_config(self): diff --git a/src/third_party/wiredtiger/test/suite/test_tiered06.py b/src/third_party/wiredtiger/test/suite/test_tiered06.py index d1eb9feae6f..5593c75f3ff 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered06.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered06.py @@ -32,9 +32,11 @@ FileSystem = wiredtiger.FileSystem # easy access to constants # test_tiered06.py # Test the local storage source. class test_tiered06(wttest.WiredTigerTestCase): - # Load the local store extension, but skip the test if it is missing. + # Load the local store extension. def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True #extlist.extension('storage_sources', # 'local_store=(config=\"(verbose=1,delay_ms=200,force_delay=3)\")') extlist.extension('storage_sources', 'local_store') diff --git a/src/third_party/wiredtiger/test/suite/test_tiered07.py b/src/third_party/wiredtiger/test/suite/test_tiered07.py index 61293325e56..1e123f8cd1c 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered07.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered07.py @@ -41,7 +41,9 @@ class test_tiered07(wttest.WiredTigerTestCase): extension_name = "local_store" def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) def conn_config(self): diff --git a/src/third_party/wiredtiger/test/suite/test_tiered08.py b/src/third_party/wiredtiger/test/suite/test_tiered08.py index af5e7af32bc..b06e84b5f12 100755 --- a/src/third_party/wiredtiger/test/suite/test_tiered08.py +++ b/src/third_party/wiredtiger/test/suite/test_tiered08.py @@ -63,9 +63,11 @@ class test_tiered08(wttest.WiredTigerTestCase): 'bucket_prefix=%s,' % self.bucket_prefix + \ 'name=%s),tiered_manager=(wait=0)' % self.extension_name - # Load the local store extension, but skip the test if it is missing. + # Load the local store extension. def conn_extensions(self, extlist): - extlist.skip_if_missing = True + # Windows doesn't support dynamically loaded extension libraries. + if os.name == 'nt': + extlist.skip_if_missing = True extlist.extension('storage_sources', self.extension_name) def get_stat(self, stat): @@ -110,7 +112,7 @@ class test_tiered08(wttest.WiredTigerTestCase): # FIXME-WT-7833 # This test can trigger races in file handle access during flush_tier. # We will re-enable it when that is fixed. - return + self.skipTest('Concurrent flush_tier and insert operations not supported yet.') cfg = self.conn_config() self.pr('Config is: ' + cfg) |