diff options
| author | Luke Chen <luke.chen@mongodb.com> | 2019-07-10 13:26:20 +1000 |
|---|---|---|
| committer | Luke Chen <luke.chen@mongodb.com> | 2019-07-10 13:26:20 +1000 |
| commit | 1a50f90ec4418b0e2f9bdadb79ea49684911b0fb (patch) | |
| tree | 37d119374d45e1f1a508cadf40b3a86ea7e31523 /src/third_party/wiredtiger/src | |
| parent | 40b6fd725ccb0464644b1b9f75b113ebf7ed6a74 (diff) | |
| download | mongo-1a50f90ec4418b0e2f9bdadb79ea49684911b0fb.tar.gz | |
Import wiredtiger: 99e0760cc5f11440b21184874d8dd2ae5bde23d6 from branch mongodb-4.2
ref: d86b3a8a33..99e0760cc5
for: 4.2.0-rc3
WT-4502 Assertion checking hazard pointers on page discard is too strong
WT-4733 Change test/format to do longer-term repeatable read testing
WT-4743 Fix memory leaks and core dumps in page-split error handling
WT-4786 Coverity: Invalid format specifiers in printf-like invocations
WT-4792 Add stat to track pages queued for eviction after LRU sorting
WT-4805 Modify error message verification for test_prepare04.py
WT-4812 Fix the Python distribution script for Python3 changes
WT-4818 Add debugging of bad read file descriptor when files are missing during recovery
WT-4832 Change ordering on shutdown to close LSM and async threads earlier
WT-4836 Lower scheduling frequency for endianness compatibility tests
WT-4840 WT_CURSOR.modify must require explicit, snapshot-isolation transaction
WT-4864 Coverity: Redundant NULL check
WT-4866 Coverity: WT_SESSION.import can leak memory
WT-4867 Skip assertion when reserved updates are seen
WT-4882 Improve checkpoint performance when there are large metadata pages
WT-4887 Skip read timestamp required assert during recovery
WT-4888 Remove support for Berkeley DB
WT-4891 WT_SESSION.verify memory allocation overrun
WT-4892 Improve statistics about forced eviction
WT-4893 Fix a race between internal page child-page eviction checks and cursors in the tree
WT-4895 Fix debug eviction mode so it chooses skew more randomly
WT-4898 Don't allow the eviction server to reconcile if it's busy
WT-4910 Port Windows SConstruct to Python 3
WT-4918 LSM allocated mutexes leaked in readonly tests
WT-4920 Add statistics tracking when eviction server is waiting for page transitions
Diffstat (limited to 'src/third_party/wiredtiger/src')
35 files changed, 837 insertions, 602 deletions
diff --git a/src/third_party/wiredtiger/src/async/async_api.c b/src/third_party/wiredtiger/src/async/async_api.c index e879067bbbb..9f9aa979139 100644 --- a/src/third_party/wiredtiger/src/async/async_api.c +++ b/src/third_party/wiredtiger/src/async/async_api.c @@ -345,7 +345,7 @@ __wt_async_reconfig(WT_SESSION_IMPL *session, const char *cfg[]) return (ret); } if (!conn->async_cfg && run) /* Case 2 */ - return (__async_start(session)); + return (__wt_async_create(session, cfg)); if (!conn->async_cfg) /* Case 3 */ return (0); @@ -578,22 +578,25 @@ __async_runtime_config(WT_ASYNC_OP_IMPL *op, const char *cfg[]) */ int __wt_async_new_op(WT_SESSION_IMPL *session, const char *uri, - const char *config, const char *cfg[], WT_ASYNC_CALLBACK *cb, - WT_ASYNC_OP_IMPL **opp) + const char *config, WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP_IMPL **opp) { WT_ASYNC_OP_IMPL *op; WT_CONNECTION_IMPL *conn; WT_DECL_RET; + const char *cfg[] = { S2C(session)->cfg, NULL, NULL }; *opp = NULL; conn = S2C(session); if (!conn->async_cfg) + WT_RET(__wt_async_create(session, cfg)); + if (!conn->async_cfg) WT_RET_MSG( session, ENOTSUP, "Asynchronous operations not configured"); op = NULL; WT_ERR(__async_new_op_alloc(session, uri, config, &op)); + cfg[1] = config; WT_ERR(__async_runtime_config(op, cfg)); op->cb = cb; *opp = op; diff --git a/src/third_party/wiredtiger/src/block/block_ckpt.c b/src/third_party/wiredtiger/src/block/block_ckpt.c index db6b458d671..a968370c2a5 100644 --- a/src/third_party/wiredtiger/src/block/block_ckpt.c +++ b/src/third_party/wiredtiger/src/block/block_ckpt.c @@ -140,7 +140,7 @@ err: /* } /* Checkpoints don't need the original information, discard it. */ - if (checkpoint && ci != NULL) + if (checkpoint) __wt_block_ckpt_destroy(session, ci); return (ret); diff --git a/src/third_party/wiredtiger/src/btree/bt_curnext.c b/src/third_party/wiredtiger/src/btree/bt_curnext.c index 6a85ccf6c17..94fe29d468d 100644 --- a/src/third_party/wiredtiger/src/btree/bt_curnext.c +++ b/src/third_party/wiredtiger/src/btree/bt_curnext.c @@ -711,8 +711,10 @@ __wt_btcur_next(WT_CURSOR_BTREE *cbt, bool truncating) */ if (page != NULL && (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD || - (newpage && cbt->page_deleted_count > 0))) + (newpage && cbt->page_deleted_count > 0))) { __wt_page_evict_soon(session, cbt->ref); + WT_STAT_CONN_INCR(session, cache_eviction_force_delete); + } cbt->page_deleted_count = 0; if (F_ISSET(cbt, WT_CBT_READ_ONCE)) diff --git a/src/third_party/wiredtiger/src/btree/bt_curprev.c b/src/third_party/wiredtiger/src/btree/bt_curprev.c index 1b8df0008b9..5ac53cb2036 100644 --- a/src/third_party/wiredtiger/src/btree/bt_curprev.c +++ b/src/third_party/wiredtiger/src/btree/bt_curprev.c @@ -665,8 +665,10 @@ __wt_btcur_prev(WT_CURSOR_BTREE *cbt, bool truncating) */ if (page != NULL && (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD || - (newpage && cbt->page_deleted_count > 0))) + (newpage && cbt->page_deleted_count > 0))) { __wt_page_evict_soon(session, cbt->ref); + WT_STAT_CONN_INCR(session, cache_eviction_force_delete); + } cbt->page_deleted_count = 0; if (F_ISSET(cbt, WT_CBT_READ_ONCE)) diff --git a/src/third_party/wiredtiger/src/btree/bt_cursor.c b/src/third_party/wiredtiger/src/btree/bt_cursor.c index b7176c74adf..51ccf1d6415 100644 --- a/src/third_party/wiredtiger/src/btree/bt_cursor.c +++ b/src/third_party/wiredtiger/src/btree/bt_cursor.c @@ -1477,9 +1477,11 @@ __wt_btcur_modify(WT_CURSOR_BTREE *cbt, WT_MODIFY *entries, int nentries) * the update if the update chain is too long; third, there's a check * if the updated value is too large to store; fourth, to simplify the * count of bytes being added/removed; fifth, we can get into serious - * trouble if we attempt to modify a value that doesn't exist. For the - * fifth reason, verify we're not in a read-uncommitted transaction, - * that implies a value that might disappear out from under us. + * trouble if we attempt to modify a value that doesn't exist or read + * a value that might not exist in the future. For the fifth reason, + * fail if in anything other than a snapshot transaction, read-committed + * and read-uncommitted imply values that might disappear out from under + * us or an inability to repeat point-in-time reads. * * Also, an application might read a value outside of a transaction and * then call modify. For that to work, the read must be part of the @@ -1490,9 +1492,10 @@ __wt_btcur_modify(WT_CURSOR_BTREE *cbt, WT_MODIFY *entries, int nentries) * because it will work most of the time and the failure is unlikely to * be detected. Require explicit transactions for modify operations. */ - if (session->txn.isolation == WT_ISO_READ_UNCOMMITTED) + if (session->txn.isolation != WT_ISO_SNAPSHOT) WT_ERR_MSG(session, ENOTSUP, - "not supported in read-uncommitted transactions"); + "not supported in read-committed or read-uncommitted " + "transactions"); if (F_ISSET(&session->txn, WT_TXN_AUTOCOMMIT)) WT_ERR_MSG(session, ENOTSUP, "not supported in implicit transactions"); diff --git a/src/third_party/wiredtiger/src/btree/bt_discard.c b/src/third_party/wiredtiger/src/btree/bt_discard.c index 44d4e1a63a7..a3cbd6a2101 100644 --- a/src/third_party/wiredtiger/src/btree/bt_discard.c +++ b/src/third_party/wiredtiger/src/btree/bt_discard.c @@ -225,16 +225,6 @@ __free_page_modify(WT_SESSION_IMPL *session, WT_PAGE *page) } /* - * __free_page_int -- - * Discard a WT_PAGE_COL_INT or WT_PAGE_ROW_INT page. - */ -static void -__free_page_int(WT_SESSION_IMPL *session, WT_PAGE *page) -{ - __wt_free_ref_index(session, page, WT_INTL_INDEX_GET_SAFE(page), false); -} - -/* * __wt_free_ref -- * Discard the contents of a WT_REF structure (optionally including the * pages it references). @@ -248,9 +238,6 @@ __wt_free_ref( if (ref == NULL) return; - /* Assert there are no hazard pointers. */ - WT_ASSERT(session, __wt_hazard_check_assert(session, ref, false)); - /* * Optionally free the referenced pages. (The path to free referenced * page is used for error cleanup, no instantiated and then discarded @@ -289,7 +276,24 @@ __wt_free_ref( __wt_free(session, ref->page_del); } - __wt_overwrite_and_free(session, ref); + __wt_overwrite_and_free_len(session, ref, WT_REF_CLEAR_SIZE); +} + +/* + * __free_page_int -- + * Discard a WT_PAGE_COL_INT or WT_PAGE_ROW_INT page. + */ +static void +__free_page_int(WT_SESSION_IMPL *session, WT_PAGE *page) +{ + WT_PAGE_INDEX *pindex; + uint32_t i; + + for (pindex = + WT_INTL_INDEX_GET_SAFE(page), i = 0; i < pindex->entries; ++i) + __wt_free_ref(session, pindex->index[i], page->type, false); + + __wt_free(session, pindex); } /* @@ -300,14 +304,24 @@ void __wt_free_ref_index(WT_SESSION_IMPL *session, WT_PAGE *page, WT_PAGE_INDEX *pindex, bool free_pages) { + WT_REF *ref; uint32_t i; if (pindex == NULL) return; - for (i = 0; i < pindex->entries; ++i) - __wt_free_ref( - session, pindex->index[i], page->type, free_pages); + for (i = 0; i < pindex->entries; ++i) { + ref = pindex->index[i]; + + /* + * Used when unrolling splits and other error paths where there + * should never have been a hazard pointer taken. + */ + WT_ASSERT(session, + __wt_hazard_check_assert(session, ref, false)); + + __wt_free_ref(session, ref, page->type, free_pages); + } __wt_free(session, pindex); } diff --git a/src/third_party/wiredtiger/src/btree/bt_split.c b/src/third_party/wiredtiger/src/btree/bt_split.c index 8bd58c17975..c0a48edf639 100644 --- a/src/third_party/wiredtiger/src/btree/bt_split.c +++ b/src/third_party/wiredtiger/src/btree/bt_split.c @@ -1182,8 +1182,49 @@ err: __split_ref_final(session, &locked); switch (complete) { case WT_ERR_RETURN: + /* + * The replace-index variable is the internal page being split's + * new page index, referencing the first chunk of WT_REFs that + * aren't being moved to other pages. Those WT_REFs survive the + * failure, they're referenced from the page's current index. + * Simply free that memory, but nothing it references. + */ + __wt_free(session, replace_index); + + /* + * The alloc-index variable is the array of new WT_REF entries + * intended to be inserted into the page being split's parent. + * + * Except for the first slot (the original page's WT_REF), it's + * an array of newly allocated combined WT_PAGE_INDEX and WT_REF + * structures, each of which references a newly allocated (and + * modified) child page, each of which references an index of + * WT_REFs from the page being split. Free everything except for + * slot 1 and the WT_REFs in the child page indexes. + * + * First, skip slot 1. Second, we want to free all of the child + * pages referenced from the alloc-index array, but we can't + * just call the usual discard function because the WT_REFs + * referenced by the child pages remain referenced by the + * original page, after error. For each entry, free the child + * page's page index (so the underlying page-free function will + * ignore it), then call the general-purpose discard function. + */ + if (alloc_index == NULL) + break; + alloc_refp = alloc_index->index; + *alloc_refp++ = NULL; + for (i = 1; i < children; ++alloc_refp, ++i) { + ref = *alloc_refp; + if (ref == NULL || ref->page == NULL) + continue; + + child = ref->page; + child_pindex = WT_INTL_INDEX_GET_SAFE(child); + __wt_free(session, child_pindex); + WT_INTL_INDEX_SET(child, NULL); + } __wt_free_ref_index(session, page, alloc_index, true); - __wt_free_ref_index(session, page, replace_index, false); break; case WT_ERR_PANIC: __wt_err(session, ret, @@ -1408,8 +1449,20 @@ err: if (parent != NULL) __split_internal_unlock(session, page); /* A page may have been busy, in which case return without error. */ - WT_RET_BUSY_OK(ret); - return (0); + switch (ret) { + case 0: + case WT_PANIC: + break; + case EBUSY: + ret = 0; + break; + default: + __wt_err(session, ret, + "ignoring not-fatal error during parent page split"); + ret = 0; + break; + } + return (ret); } #ifdef HAVE_DIAGNOSTIC @@ -1625,7 +1678,7 @@ __split_multi_inmem_fail(WT_SESSION_IMPL *session, WT_PAGE *orig, WT_REF *ref) /* * We failed creating new in-memory pages. For error-handling reasons, * we've left the update chains referenced by both the original and - * new pages. Discard the new allocated WT_REF structures and their + * new pages. Discard the newly allocated WT_REF structures and their * pages (setting a flag so the discard code doesn't discard the updates * on the page). * diff --git a/src/third_party/wiredtiger/src/btree/bt_walk.c b/src/third_party/wiredtiger/src/btree/bt_walk.c index a7cb433b56a..30cdaf2225a 100644 --- a/src/third_party/wiredtiger/src/btree/bt_walk.c +++ b/src/third_party/wiredtiger/src/btree/bt_walk.c @@ -447,6 +447,13 @@ restart: /* WT_ERR_NOTFOUND_OK(ret); __wt_spin_backoff(&swap_yield, &swap_sleep); + if (swap_yield < 1000) + WT_STAT_CONN_INCR(session, + cache_eviction_walk_internal_yield); + if (swap_sleep != 0) + WT_STAT_CONN_INCRV(session, + cache_eviction_walk_internal_wait, + swap_sleep); } /* NOTREACHED */ } @@ -560,6 +567,8 @@ descend: /* * An expected error, so "couple" is unchanged. */ if (ret == WT_NOTFOUND) { + WT_STAT_CONN_INCR(session, + cache_eviction_walk_leaf_notfound); WT_NOT_READ(ret, 0); break; } diff --git a/src/third_party/wiredtiger/src/conn/conn_api.c b/src/third_party/wiredtiger/src/conn/conn_api.c index e68fb6c15f8..24df42b45f1 100644 --- a/src/third_party/wiredtiger/src/conn/conn_api.c +++ b/src/third_party/wiredtiger/src/conn/conn_api.c @@ -725,7 +725,9 @@ __conn_async_new_op(WT_CONNECTION *wt_conn, const char *uri, const char *config, conn = (WT_CONNECTION_IMPL *)wt_conn; CONNECTION_API_CALL(conn, session, async_new_op, config, cfg); - WT_ERR(__wt_async_new_op(session, uri, config, cfg, callback, &op)); + WT_UNUSED(cfg); + + WT_ERR(__wt_async_new_op(session, uri, config, callback, &op)); *asyncopp = &op->iface; @@ -1047,22 +1049,13 @@ __conn_close(WT_CONNECTION *wt_conn, const char *config) const char *ckpt_cfg; conn = (WT_CONNECTION_IMPL *)wt_conn; - ckpt_cfg = "use_timestamp=false"; CONNECTION_API_CALL(conn, session, close, config, cfg); - - /* The default session is used to access data handles during close. */ - F_CLR(session, WT_SESSION_NO_DATA_HANDLES); +err: WT_TRET(__wt_config_gets(session, cfg, "leak_memory", &cval)); if (cval.val != 0) F_SET(conn, WT_CONN_LEAK_MEMORY); - WT_TRET(__wt_config_gets(session, cfg, "use_timestamp", &cval)); - if (cval.val != 0) { - ckpt_cfg = "use_timestamp=true"; - if (conn->txn_global.has_stable_timestamp) - F_SET(conn, WT_CONN_CLOSING_TIMESTAMP); - } /* * Ramp the eviction dirty target down to encourage eviction threads to @@ -1071,7 +1064,7 @@ __conn_close(WT_CONNECTION *wt_conn, const char *config) conn->cache->eviction_dirty_trigger = 1.0; conn->cache->eviction_dirty_target = 0.1; -err: /* + /* * Rollback all running transactions. * We do this as a separate pass because an active transaction in one * session could cause trouble when closing a file, even if that @@ -1102,7 +1095,8 @@ err: /* WT_TRET(wt_session->close(wt_session, config)); } - WT_TRET(__wt_async_flush(session)); + /* Wait for in-flight operations to complete. */ + WT_TRET(__wt_txn_activity_drain(session)); /* * Disable lookaside eviction: it doesn't help us shut down and can @@ -1111,8 +1105,24 @@ err: /* */ F_SET(conn, WT_CONN_EVICTION_NO_LOOKASIDE); - /* Wait for in-flight operations to complete. */ - WT_TRET(__wt_txn_activity_drain(session)); + /* + * Clear any pending async operations and shut down the async worker + * threads and system before closing LSM. + */ + WT_TRET(__wt_async_flush(session)); + WT_TRET(__wt_async_destroy(session)); + + WT_TRET(__wt_lsm_manager_destroy(session)); + + /* + * After the async and LSM threads have exited, we shouldn't opening + * any more files. + */ + F_SET(conn, WT_CONN_CLOSING_NO_MORE_OPENS); + WT_FULL_BARRIER(); + + /* The default session is used to access data handles during close. */ + F_CLR(session, WT_SESSION_NO_DATA_HANDLES); /* * Perform a system-wide checkpoint so that all tables are consistent @@ -1121,6 +1131,13 @@ err: /* * shutting down all the subsystems. We have shut down all user * sessions, but send in true for waiting for internal races. */ + WT_TRET(__wt_config_gets(session, cfg, "use_timestamp", &cval)); + ckpt_cfg = "use_timestamp=false"; + if (cval.val != 0) { + ckpt_cfg = "use_timestamp=true"; + if (conn->txn_global.has_stable_timestamp) + F_SET(conn, WT_CONN_CLOSING_TIMESTAMP); + } if (!F_ISSET(conn, WT_CONN_IN_MEMORY | WT_CONN_READONLY)) { s = NULL; WT_TRET(__wt_open_internal_session( diff --git a/src/third_party/wiredtiger/src/conn/conn_handle.c b/src/third_party/wiredtiger/src/conn/conn_handle.c index faee6216ed7..6f61d10afbe 100644 --- a/src/third_party/wiredtiger/src/conn/conn_handle.c +++ b/src/third_party/wiredtiger/src/conn/conn_handle.c @@ -65,7 +65,7 @@ __wt_connection_init(WT_CONNECTION_IMPL *conn) WT_RET(__wt_rwlock_init(session, &conn->hot_backup_lock)); WT_RWLOCK_INIT_TRACKED(session, &conn->table_lock, table); - /* Setup the spin locks for the LSM manager queues. */ + /* Setup serialization for the LSM manager queues. */ WT_RET(__wt_spin_init(session, &conn->lsm_manager.app_lock, "LSM application queue lock")); WT_RET(__wt_spin_init(session, @@ -130,6 +130,12 @@ __wt_connection_destroy(WT_CONNECTION_IMPL *conn) __wt_rwlock_destroy(session, &conn->table_lock); __wt_spin_destroy(session, &conn->turtle_lock); + /* Free LSM serialization resources. */ + __wt_spin_destroy(session, &conn->lsm_manager.switch_lock); + __wt_spin_destroy(session, &conn->lsm_manager.app_lock); + __wt_spin_destroy(session, &conn->lsm_manager.manager_lock); + __wt_cond_destroy(session, &conn->lsm_manager.work_cond); + /* Free allocated memory. */ __wt_free(session, conn->cfg); __wt_free(session, conn->debug_ckpt); diff --git a/src/third_party/wiredtiger/src/conn/conn_open.c b/src/third_party/wiredtiger/src/conn/conn_open.c index 3a1025fea1b..c9d34987df4 100644 --- a/src/third_party/wiredtiger/src/conn/conn_open.c +++ b/src/third_party/wiredtiger/src/conn/conn_open.c @@ -76,32 +76,24 @@ __wt_connection_close(WT_CONNECTION_IMPL *conn) wt_conn = &conn->iface; session = conn->default_session; + /* + * The LSM and async services are not shut down in this path (which is + * called when wiredtiger_open hits an error (as well as during normal + * shutdown). Assert they're not running. + */ + WT_ASSERT(session, + !F_ISSET(conn, WT_CONN_SERVER_ASYNC | WT_CONN_SERVER_LSM)); + /* Shut down the subsystems, ensuring workers see the state change. */ F_SET(conn, WT_CONN_CLOSING); WT_FULL_BARRIER(); /* - * Clear any pending async operations and shut down the async worker - * threads and system before closing LSM. - */ - WT_TRET(__wt_async_flush(session)); - WT_TRET(__wt_async_destroy(session)); - - /* * Shut down server threads other than the eviction server, which is * needed later to close btree handles. Some of these threads access * btree handles, so take care in ordering shutdown to make sure they * exit before files are closed. */ - WT_TRET(__wt_lsm_manager_destroy(session)); - - /* - * Once the async and LSM threads exit, we shouldn't be opening any - * more files. - */ - F_SET(conn, WT_CONN_CLOSING_NO_MORE_OPENS); - WT_FULL_BARRIER(); - WT_TRET(__wt_capacity_server_destroy(session)); WT_TRET(__wt_checkpoint_server_destroy(session)); WT_TRET(__wt_statlog_destroy(session, true)); @@ -250,9 +242,6 @@ __wt_connection_workers(WT_SESSION_IMPL *session, const char *cfg[]) /* Start the handle sweep thread. */ WT_RET(__wt_sweep_create(session)); - /* Start the optional async threads. */ - WT_RET(__wt_async_create(session, cfg)); - /* Start the optional capacity thread. */ WT_RET(__wt_capacity_server_create(session, cfg)); diff --git a/src/third_party/wiredtiger/src/cursor/cur_std.c b/src/third_party/wiredtiger/src/cursor/cur_std.c index 808780b4675..073df6eaaf6 100644 --- a/src/third_party/wiredtiger/src/cursor/cur_std.c +++ b/src/third_party/wiredtiger/src/cursor/cur_std.c @@ -916,11 +916,16 @@ __cursor_modify(WT_CURSOR *cursor, WT_MODIFY *entries, int nentries) /* * The underlying btree code cannot support WT_CURSOR.modify within - * a read-uncommitted transaction. Disallow it here for consistency. + * a read-committed or read-uncommitted transaction, or outside of + * an explicit transaction. Disallow here as well, for consistency. */ - if (session->txn.isolation == WT_ISO_READ_UNCOMMITTED) + if (session->txn.isolation != WT_ISO_SNAPSHOT) WT_ERR_MSG(session, ENOTSUP, - "not supported in read-uncommitted transactions"); + "not supported in read-committed or read-uncommitted " + "transactions"); + if (F_ISSET(&session->txn, WT_TXN_AUTOCOMMIT)) + WT_ERR_MSG(session, ENOTSUP, + "not supported in implicit transactions"); WT_ERR(__cursor_checkkey(cursor)); diff --git a/src/third_party/wiredtiger/src/docs/checkpoint.dox b/src/third_party/wiredtiger/src/docs/checkpoint.dox index 3d636cd17b6..2da3b1df272 100644 --- a/src/third_party/wiredtiger/src/docs/checkpoint.dox +++ b/src/third_party/wiredtiger/src/docs/checkpoint.dox @@ -55,11 +55,13 @@ archiving purposes. @section checkpoint_cursors Checkpoint cursors Cursors are normally opened in the most recent version of a data source. -However, a checkpoint configuration string may be provided to -WT_SESSION::open_cursor, opening a read-only, static view of the data -source. This provides a limited form of time-travel, as the static view -is not changed by subsequent checkpoints, and will persist until the -checkpoint cursor is closed. +However, a checkpoint configuration string may be provided +to WT_SESSION::open_cursor, opening a read-only, static view of the +data source. This provides a limited form of time-travel, as the static +view is not changed by subsequent checkpoints and will persist until +the checkpoint cursor is closed. While it is not an error to set a read +timestamp in a transaction including a checkpoint cursor, it also has no +effect on the checkpoint cursor's behavior. @section checkpoint_naming Checkpoint naming diff --git a/src/third_party/wiredtiger/src/docs/custom-data-sources.dox b/src/third_party/wiredtiger/src/docs/custom-data-sources.dox index 9082ee95dea..340f25997a5 100644 --- a/src/third_party/wiredtiger/src/docs/custom-data-sources.dox +++ b/src/third_party/wiredtiger/src/docs/custom-data-sources.dox @@ -6,12 +6,6 @@ support a set of methods for a different URI type (for example, in the same way WiredTiger supports the built-in type "file:", an application data source might support the type "dsrc:"). -The WiredTiger distribution includes an example of a complete custom -data source implementation (based on Oracle's Berkeley DB database -engine), in the file test/format/kvs_bdb.c. This example implementation is -public domain software, please feel free to use this code as a prototype -implementation of other custom data sources. - Applications register their WT_DATA_SOURCE interface implementations with WiredTiger using the WT_CONNECTION::add_data_source method: diff --git a/src/third_party/wiredtiger/src/docs/spell.ok b/src/third_party/wiredtiger/src/docs/spell.ok index cb65c7b1b01..98ec49779a4 100644 --- a/src/third_party/wiredtiger/src/docs/spell.ok +++ b/src/third_party/wiredtiger/src/docs/spell.ok @@ -120,8 +120,6 @@ autogen automake basecfg basho -bdb -bdbmap benchmarking bigram bindir diff --git a/src/third_party/wiredtiger/src/docs/upgrading.dox b/src/third_party/wiredtiger/src/docs/upgrading.dox index b4c7f5b7d2b..c5bb8ded037 100644 --- a/src/third_party/wiredtiger/src/docs/upgrading.dox +++ b/src/third_party/wiredtiger/src/docs/upgrading.dox @@ -1,6 +1,19 @@ /*! @page upgrading Upgrading WiredTiger applications </dl><hr> +@section version_321 Upgrading to Version 3.2.1 +<dl> + +<dt>WT_CURSOR::modify transaction requirements</dt> +<dd> +In previous releases of WiredTiger, WT_CURSOR::modify operations could be +performed within <code>read-committed</code> transactions. This implies +point-in-time reads that cannot be repeated. In the 3.2.1 release, +WT_CURSOR::modify operations must be performed in an explicit transaction +at snapshot isolation, and will fail if that's not the case. +</dd> + +</dl><hr> @section version_320 Upgrading to Version 3.2.0 <dl> diff --git a/src/third_party/wiredtiger/src/evict/evict_lru.c b/src/third_party/wiredtiger/src/evict/evict_lru.c index 931216376b9..b0b29942cb2 100644 --- a/src/third_party/wiredtiger/src/evict/evict_lru.c +++ b/src/third_party/wiredtiger/src/evict/evict_lru.c @@ -1373,6 +1373,8 @@ __evict_lru_walk(WT_SESSION_IMPL *session) } } + WT_STAT_CONN_INCRV(session, + cache_eviction_pages_queued_post_lru, queue->evict_candidates); queue->evict_current = queue->evict_queue; __wt_spin_unlock(session, &queue->evict_lock); diff --git a/src/third_party/wiredtiger/src/evict/evict_page.c b/src/third_party/wiredtiger/src/evict/evict_page.c index 2510815401f..5df9b7ce9bb 100644 --- a/src/third_party/wiredtiger/src/evict/evict_page.c +++ b/src/third_party/wiredtiger/src/evict/evict_page.c @@ -55,16 +55,10 @@ __wt_page_release_evict(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags) { WT_BTREE *btree; WT_DECL_RET; - WT_PAGE *page; - uint64_t time_start, time_stop; uint32_t evict_flags, previous_state; - bool locked, too_big; + bool locked; btree = S2BT(session); - locked = false; - page = ref->page; - time_start = __wt_clock(session); - evict_flags = LF_ISSET(WT_READ_NO_SPLIT) ? WT_EVICT_CALL_NO_SPLIT : 0; /* * This function always releases the hazard pointer - ensure that's @@ -73,47 +67,20 @@ __wt_page_release_evict(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags) * without first locking the page, it could be evicted in between. */ previous_state = ref->state; - if ((previous_state == WT_REF_MEM || previous_state == WT_REF_LIMBO) && - WT_REF_CAS_STATE(session, ref, previous_state, WT_REF_LOCKED)) - locked = true; + locked = + (previous_state == WT_REF_MEM || previous_state == WT_REF_LIMBO) && + WT_REF_CAS_STATE(session, ref, previous_state, WT_REF_LOCKED); if ((ret = __wt_hazard_clear(session, ref)) != 0 || !locked) { if (locked) WT_REF_SET_STATE(ref, previous_state); return (ret == 0 ? EBUSY : ret); } - (void)__wt_atomic_addv32(&btree->evict_busy, 1); - - too_big = page->memory_footprint >= btree->splitmempage; + evict_flags = LF_ISSET(WT_READ_NO_SPLIT) ? WT_EVICT_CALL_NO_SPLIT : 0; + FLD_SET(evict_flags, WT_EVICT_CALL_URGENT); - /* - * Track how long the call to evict took. If eviction is successful then - * we have one of two pairs of stats to increment. - */ + (void)__wt_atomic_addv32(&btree->evict_busy, 1); ret = __wt_evict(session, ref, previous_state, evict_flags); - time_stop = __wt_clock(session); - if (ret == 0) { - if (too_big) { - WT_STAT_CONN_INCR(session, cache_eviction_force); - WT_STAT_CONN_INCRV(session, cache_eviction_force_time, - WT_CLOCKDIFF_US(time_stop, time_start)); - } else { - /* - * If the page isn't too big, we are evicting it because - * it had a chain of deleted entries that make traversal - * expensive. - */ - WT_STAT_CONN_INCR(session, cache_eviction_force_delete); - WT_STAT_CONN_INCRV(session, - cache_eviction_force_delete_time, - WT_CLOCKDIFF_US(time_stop, time_start)); - } - } else { - WT_STAT_CONN_INCR(session, cache_eviction_force_fail); - WT_STAT_CONN_INCRV(session, cache_eviction_force_fail_time, - WT_CLOCKDIFF_US(time_stop, time_start)); - } - (void)__wt_atomic_subv32(&btree->evict_busy, 1); return (ret); @@ -130,12 +97,14 @@ __wt_evict(WT_SESSION_IMPL *session, WT_CONNECTION_IMPL *conn; WT_DECL_RET; WT_PAGE *page; + uint64_t time_start, time_stop; bool clean_page, closing, inmem_split, local_gen, tree_dead; conn = S2C(session); page = ref->page; closing = LF_ISSET(WT_EVICT_CALL_CLOSING); local_gen = false; + time_start = time_stop = 0; /* [-Werror=maybe-uninitialized] */ __wt_verbose(session, WT_VERB_EVICT, "page %p (%s)", (void *)page, __wt_page_type_string(page->type)); @@ -155,6 +124,16 @@ __wt_evict(WT_SESSION_IMPL *session, } /* + * Track how long forcible eviction took. Immediately increment the + * forcible eviction counter, we might do an in-memory split and not + * an eviction, which skips the other statistics. + */ + if (LF_ISSET(WT_EVICT_CALL_URGENT)) { + time_start = __wt_clock(session); + WT_STAT_CONN_INCR(session, cache_eviction_force); + } + + /* * Get exclusive access to the page if our caller doesn't have the tree * locked down. */ @@ -225,6 +204,21 @@ __wt_evict(WT_SESSION_IMPL *session, else WT_ERR(__evict_page_dirty_update(session, ref, flags)); + if (LF_ISSET(WT_EVICT_CALL_URGENT)) { + time_stop = __wt_clock(session); + if (clean_page) { + WT_STAT_CONN_INCR(session, cache_eviction_force_clean); + WT_STAT_CONN_INCRV(session, + cache_eviction_force_clean_time, + WT_CLOCKDIFF_US(time_stop, time_start)); + } + else { + WT_STAT_CONN_INCR(session, cache_eviction_force_dirty); + WT_STAT_CONN_INCRV(session, + cache_eviction_force_dirty_time, + WT_CLOCKDIFF_US(time_stop, time_start)); + } + } if (clean_page) { WT_STAT_CONN_INCR(session, cache_eviction_clean); WT_STAT_DATA_INCR(session, cache_eviction_clean); @@ -237,6 +231,14 @@ __wt_evict(WT_SESSION_IMPL *session, err: if (!closing) __evict_exclusive_clear(session, ref, previous_state); + if (LF_ISSET(WT_EVICT_CALL_URGENT)) { + time_stop = __wt_clock(session); + WT_STAT_CONN_INCR(session, cache_eviction_force_fail); + WT_STAT_CONN_INCRV(session, + cache_eviction_force_fail_time, + WT_CLOCKDIFF_US(time_stop, time_start)); + } + WT_STAT_CONN_INCR(session, cache_eviction_fail); WT_STAT_DATA_INCR(session, cache_eviction_fail); } @@ -470,11 +472,46 @@ __evict_child_check(WT_SESSION_IMPL *session, WT_REF *parent) WT_REF *child; bool active; + /* + * There may be cursors in the tree walking the list of child pages. + * The parent is locked, so all we care about is cursors already in the + * child pages, no thread can enter them. Any cursor moving through the + * child pages must be hazard pointer coupling between pages, where the + * page on which it currently has a hazard pointer must be in a state + * other than on-disk. Walk the child list forward, then backward, to + * ensure we don't race with a cursor walking in the opposite direction + * from our check. + */ + WT_INTL_FOREACH_BEGIN(session, parent->page, child) { + switch (child->state) { + case WT_REF_DISK: /* On-disk */ + case WT_REF_DELETED: /* On-disk, deleted */ + case WT_REF_LOOKASIDE: /* On-disk, lookaside */ + break; + default: + return (__wt_set_return(session, EBUSY)); + } + } WT_INTL_FOREACH_END; + WT_INTL_FOREACH_REVERSE_BEGIN(session, parent->page, child) { + switch (child->state) { + case WT_REF_DISK: /* On-disk */ + case WT_REF_DELETED: /* On-disk, deleted */ + case WT_REF_LOOKASIDE: /* On-disk, lookaside */ + break; + default: + return (__wt_set_return(session, EBUSY)); + } + } WT_INTL_FOREACH_END; + + /* + * The fast check is done and there are no cursors in the child pages. + * Make sure the child WT_REF structures pages can be discarded. + */ WT_INTL_FOREACH_BEGIN(session, parent->page, child) { switch (child->state) { case WT_REF_DISK: /* On-disk */ break; - case WT_REF_DELETED: /* Deleted */ + case WT_REF_DELETED: /* On-disk, deleted */ /* * If the child page was part of a truncate, * transaction rollback might switch this page into its @@ -498,7 +535,7 @@ __evict_child_check(WT_SESSION_IMPL *session, WT_REF *parent) if (active) return (__wt_set_return(session, EBUSY)); break; - case WT_REF_LOOKASIDE: + case WT_REF_LOOKASIDE: /* On-disk, lookaside */ /* * If the lookaside history is obsolete, the reference * can be ignored. @@ -520,9 +557,8 @@ __evict_child_check(WT_SESSION_IMPL *session, WT_REF *parent) * for conditions that would block its eviction. */ static int -__evict_review( - WT_SESSION_IMPL *session, WT_REF *ref, uint32_t evict_flags, - bool *inmem_splitp) +__evict_review(WT_SESSION_IMPL *session, + WT_REF *ref, uint32_t evict_flags, bool *inmem_splitp) { WT_CACHE *cache; WT_CONNECTION_IMPL *conn; @@ -646,41 +682,39 @@ __evict_review( if (closing) LF_SET(WT_REC_VISIBILITY_ERR); - else if (!WT_PAGE_IS_INTERNAL(page) && - !F_ISSET(S2BT(session), WT_BTREE_LOOKASIDE)) { - if (F_ISSET(conn, WT_CONN_IN_MEMORY)) - LF_SET(WT_REC_IN_MEMORY | - WT_REC_SCRUB | WT_REC_UPDATE_RESTORE); - else if (WT_SESSION_BTREE_SYNC(session)) - LF_SET(WT_REC_LOOKASIDE); - else if (!WT_IS_METADATA(session->dhandle)) { - LF_SET(WT_REC_UPDATE_RESTORE); + else if (WT_PAGE_IS_INTERNAL(page) || + F_ISSET(S2BT(session), WT_BTREE_LOOKASIDE)) + ; + else if (WT_SESSION_BTREE_SYNC(session)) + LF_SET(WT_REC_LOOKASIDE); + else if (F_ISSET(conn, WT_CONN_IN_MEMORY)) + LF_SET(WT_REC_IN_MEMORY | WT_REC_SCRUB | WT_REC_UPDATE_RESTORE); + else { + LF_SET(WT_REC_UPDATE_RESTORE); - /* - * Scrub if we're supposed to or toss it in sometimes - * if we are in debugging mode. - */ - if (F_ISSET(cache, WT_CACHE_EVICT_SCRUB) || - (F_ISSET(cache, WT_CACHE_EVICT_DEBUG_MODE) && - __wt_random(&session->rnd) % 3 == 0)) - LF_SET(WT_REC_SCRUB); + /* + * Scrub if we're supposed to or toss it in sometimes if we are + * in debugging mode. + */ + if (F_ISSET(cache, WT_CACHE_EVICT_SCRUB) || + (F_ISSET(cache, WT_CACHE_EVICT_DEBUG_MODE) && + __wt_random(&session->rnd) % 3 == 0)) + LF_SET(WT_REC_SCRUB); - /* - * If the cache is under pressure with many updates - * that can't be evicted, check if reconciliation - * suggests trying the lookaside table. - */ - if (F_ISSET(cache, WT_CACHE_EVICT_LOOKASIDE) && - !F_ISSET(conn, WT_CONN_EVICTION_NO_LOOKASIDE)) { - if (F_ISSET(cache, - WT_CACHE_EVICT_DEBUG_MODE) && - __wt_random(&session->rnd) % 10 == 0) { - LF_CLR(WT_REC_SCRUB | - WT_REC_UPDATE_RESTORE); - LF_SET(WT_REC_LOOKASIDE); - } - lookaside_retryp = &lookaside_retry; + /* + * If the cache is under pressure with many updates that can't + * be evicted, check if reconciliation suggests trying the + * lookaside table. + */ + if (!WT_IS_METADATA(session->dhandle) && + F_ISSET(cache, WT_CACHE_EVICT_LOOKASIDE) && + !F_ISSET(conn, WT_CONN_EVICTION_NO_LOOKASIDE)) { + if (F_ISSET(cache, WT_CACHE_EVICT_DEBUG_MODE) && + __wt_random(&session->rnd) % 10 == 0) { + LF_CLR(WT_REC_SCRUB | WT_REC_UPDATE_RESTORE); + LF_SET(WT_REC_LOOKASIDE); } + lookaside_retryp = &lookaside_retry; } } diff --git a/src/third_party/wiredtiger/src/include/btmem.h b/src/third_party/wiredtiger/src/include/btmem.h index 7729c9887d5..a7c289a7b7f 100644 --- a/src/third_party/wiredtiger/src/include/btmem.h +++ b/src/third_party/wiredtiger/src/include/btmem.h @@ -593,6 +593,14 @@ struct __wt_page { for (__refp = __pindex->index, \ __entries = __pindex->entries; __entries > 0; --__entries) {\ (ref) = *__refp++; +#define WT_INTL_FOREACH_REVERSE_BEGIN(session, page, ref) do { \ + WT_PAGE_INDEX *__pindex; \ + WT_REF **__refp; \ + uint32_t __entries; \ + WT_INTL_INDEX_GET(session, page, __pindex); \ + for (__refp = __pindex->index + __pindex->entries, \ + __entries = __pindex->entries; __entries > 0; --__entries) {\ + (ref) = *--__refp; #define WT_INTL_FOREACH_END \ } \ } while (0) @@ -897,43 +905,51 @@ struct __wt_ref { WT_PAGE_DELETED *page_del; /* Deleted page information */ WT_PAGE_LOOKASIDE *page_las; /* Lookaside information */ -/* A macro wrapper allowing us to remember the callers code location */ -#define WT_REF_CAS_STATE(session, ref, old_state, new_state) \ - __wt_ref_cas_state_int((session), (ref), (old_state), (new_state),\ - __FILE__, __LINE__) + /* + * In DIAGNOSTIC mode we overwrite the WT_REF on free to force failures. + * Don't clear the history in that case. + */ +#define WT_REF_CLEAR_SIZE (offsetof(WT_REF, hist)) + +#define WT_REF_SAVE_STATE_MAX 3 #ifdef HAVE_DIAGNOSTIC /* Capture history of ref state changes. */ struct __wt_ref_hist { WT_SESSION_IMPL *session; const char *name; - const char *file; - int line; - uint32_t state; - } hist[3]; + const char *func; + uint16_t line; + uint16_t state; + } hist[WT_REF_SAVE_STATE_MAX]; uint64_t histoff; #define WT_REF_SAVE_STATE(ref, s, f, l) do { \ (ref)->hist[(ref)->histoff].session = session; \ (ref)->hist[(ref)->histoff].name = session->name; \ - (ref)->hist[(ref)->histoff].file = (f); \ - (ref)->hist[(ref)->histoff].line = (l); \ - (ref)->hist[(ref)->histoff].state = s; \ + (ref)->hist[(ref)->histoff].func = (f); \ + (ref)->hist[(ref)->histoff].line = (uint16_t)(l); \ + (ref)->hist[(ref)->histoff].state = (uint16_t)(s); \ (ref)->histoff = \ ((ref)->histoff + 1) % WT_ELEMENTS((ref)->hist); \ } while (0) #define WT_REF_SET_STATE(ref, s) do { \ - WT_REF_SAVE_STATE(ref, s, __FILE__, __LINE__); \ + WT_REF_SAVE_STATE(ref, s, __func__, __LINE__); \ WT_PUBLISH((ref)->state, s); \ } while (0) #else #define WT_REF_SET_STATE(ref, s) WT_PUBLISH((ref)->state, s) #endif + +/* A macro wrapper allowing us to remember the callers code location */ +#define WT_REF_CAS_STATE(session, ref, old_state, new_state) \ + __wt_ref_cas_state_int( \ + session, ref, old_state, new_state, __func__, __LINE__) }; /* * WT_REF_SIZE is the expected structure size -- we verify the build to ensure * the compiler hasn't inserted padding which would break the world. */ #ifdef HAVE_DIAGNOSTIC -#define WT_REF_SIZE (56 + 3 * sizeof(WT_REF_HIST) + 8) +#define WT_REF_SIZE (56 + WT_REF_SAVE_STATE_MAX * sizeof(WT_REF_HIST) + 8) #else #define WT_REF_SIZE 56 #endif diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i index 906c615057a..5cf67d8600f 100644 --- a/src/third_party/wiredtiger/src/include/btree.i +++ b/src/third_party/wiredtiger/src/include/btree.i @@ -1508,7 +1508,8 @@ __wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags) * memory_page_max setting, when we see many deleted items, and when we * are attempting to scan without trashing the cache. * - * Fast checks if eviction is disabled for this handle, operation or + * Fast checks if flag indicates no evict, session can't perform slow + * operation, eviction is disabled for this handle, operation or * tree, then perform a general check if eviction will be possible. * * Checkpoint should not queue pages for urgent eviction if it cannot @@ -1517,7 +1518,9 @@ __wt_page_release(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags) * checkpointed, and no other thread can help with that. */ page = ref->page; - if (WT_READGEN_EVICT_SOON(page->read_gen) && + if (!LF_ISSET(WT_READ_NO_EVICT) && + __wt_session_can_wait(session) && + WT_READGEN_EVICT_SOON(page->read_gen) && btree->evict_disabled == 0 && __wt_page_can_evict(session, ref, &inmem_split)) { if (!__wt_page_evict_clean(page) && diff --git a/src/third_party/wiredtiger/src/include/cache.h b/src/third_party/wiredtiger/src/include/cache.h index 163e0a2753c..46718d9aba2 100644 --- a/src/third_party/wiredtiger/src/include/cache.h +++ b/src/third_party/wiredtiger/src/include/cache.h @@ -294,6 +294,7 @@ struct __wt_cache_pool { /* Flags used with __wt_evict */ /* AUTOMATIC FLAG VALUE GENERATION START */ -#define WT_EVICT_CALL_CLOSING 0x1u /* Closing connection or tree */ -#define WT_EVICT_CALL_NO_SPLIT 0x2u /* Splits not allowed */ +#define WT_EVICT_CALL_CLOSING 0x1u /* Closing connection or tree */ +#define WT_EVICT_CALL_NO_SPLIT 0x2u /* Splits not allowed */ +#define WT_EVICT_CALL_URGENT 0x4u /* Urgent eviction */ /* AUTOMATIC FLAG VALUE GENERATION STOP */ diff --git a/src/third_party/wiredtiger/src/include/cursor.i b/src/third_party/wiredtiger/src/include/cursor.i index 3c08f808c62..0cb3708a030 100644 --- a/src/third_party/wiredtiger/src/include/cursor.i +++ b/src/third_party/wiredtiger/src/include/cursor.i @@ -200,8 +200,10 @@ __cursor_reset(WT_CURSOR_BTREE *cbt) * If we were scanning and saw a lot of deleted records on this page, * try to evict the page when we release it. */ - if (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD) + if (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD) { __wt_page_evict_soon(session, cbt->ref); + WT_STAT_CONN_INCR(session, cache_eviction_force_delete); + } cbt->page_deleted_count = 0; /* diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h index a4706a36796..1c704be9c3e 100644 --- a/src/third_party/wiredtiger/src/include/extern.h +++ b/src/third_party/wiredtiger/src/include/extern.h @@ -36,7 +36,7 @@ extern int __wt_apply_single_idx(WT_SESSION_IMPL *session, WT_INDEX *idx, WT_CUR extern int __wt_async_create(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_async_destroy(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_async_flush(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_async_new_op(WT_SESSION_IMPL *session, const char *uri, const char *config, const char *cfg[], WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP_IMPL **opp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_async_new_op(WT_SESSION_IMPL *session, const char *uri, const char *config, WT_ASYNC_CALLBACK *cb, WT_ASYNC_OP_IMPL **opp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_async_op_enqueue(WT_SESSION_IMPL *session, WT_ASYNC_OP_IMPL *op) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_async_op_init(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_async_reconfig(WT_SESSION_IMPL *session, const char *cfg[]) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); @@ -925,7 +925,7 @@ static inline bool __wt_page_is_empty(WT_PAGE *page) WT_GCC_FUNC_DECL_ATTRIBUTE( static inline bool __wt_page_is_modified(WT_PAGE *page) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); static inline bool __wt_page_las_active(WT_SESSION_IMPL *session, WT_REF *ref) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); static inline bool __wt_rec_need_split(WT_RECONCILE *r, size_t len) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -static inline bool __wt_ref_cas_state_int(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t old_state, uint32_t new_state, const char *file, int line) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +static inline bool __wt_ref_cas_state_int(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t old_state, uint32_t new_state, const char *func, int line) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); static inline bool __wt_ref_is_root(WT_REF *ref) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); static inline bool __wt_row_leaf_key_info(WT_PAGE *page, void *copy, WT_IKEY **ikeyp, WT_CELL **cellp, void *datap, size_t *sizep) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); static inline bool __wt_row_leaf_value(WT_PAGE *page, WT_ROW *rip, WT_ITEM *value) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h index 26c030009e6..8968c5e1010 100644 --- a/src/third_party/wiredtiger/src/include/stat.h +++ b/src/third_party/wiredtiger/src/include/stat.h @@ -386,6 +386,9 @@ struct __wt_connection_stats { int64_t cache_eviction_server_evicting; int64_t cache_eviction_server_slept; int64_t cache_eviction_slow; + int64_t cache_eviction_walk_leaf_notfound; + int64_t cache_eviction_walk_internal_wait; + int64_t cache_eviction_walk_internal_yield; int64_t cache_eviction_state; int64_t cache_eviction_target_page_lt10; int64_t cache_eviction_target_page_lt32; @@ -404,11 +407,17 @@ struct __wt_connection_stats { int64_t cache_eviction_worker_evicting; int64_t cache_eviction_worker_removed; int64_t cache_eviction_stable_state_workers; - int64_t cache_eviction_force_fail; - int64_t cache_eviction_force_fail_time; int64_t cache_eviction_walks_active; int64_t cache_eviction_walks_started; int64_t cache_eviction_force_retune; + int64_t cache_eviction_force_clean; + 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_delete; + int64_t cache_eviction_force; + int64_t cache_eviction_force_fail; + int64_t cache_eviction_force_fail_time; int64_t cache_eviction_hazard; int64_t cache_hazard_checks; int64_t cache_hazard_walks; @@ -427,12 +436,9 @@ struct __wt_connection_stats { int64_t cache_eviction_deepen; int64_t cache_write_lookaside; int64_t cache_pages_inuse; - int64_t cache_eviction_force; - int64_t cache_eviction_force_time; - int64_t cache_eviction_force_delete; - int64_t cache_eviction_force_delete_time; int64_t cache_eviction_app; int64_t cache_eviction_pages_queued; + int64_t cache_eviction_pages_queued_post_lru; int64_t cache_eviction_pages_queued_urgent; int64_t cache_eviction_pages_queued_oldest; int64_t cache_read; diff --git a/src/third_party/wiredtiger/src/include/txn.h b/src/third_party/wiredtiger/src/include/txn.h index 7e73bbacf8e..ac4c4f0e2d8 100644 --- a/src/third_party/wiredtiger/src/include/txn.h +++ b/src/third_party/wiredtiger/src/include/txn.h @@ -251,6 +251,7 @@ struct __wt_txn_op { /* AUTOMATIC FLAG VALUE GENERATION START */ #define WT_TXN_OP_KEY_REPEATED 0x1u +#define WT_TXN_OP_KEY_RESERVED 0x2u /* AUTOMATIC FLAG VALUE GENERATION STOP */ uint32_t flags; }; diff --git a/src/third_party/wiredtiger/src/include/txn.i b/src/third_party/wiredtiger/src/include/txn.i index f904e62cc05..abb2b1ccc66 100644 --- a/src/third_party/wiredtiger/src/include/txn.i +++ b/src/third_party/wiredtiger/src/include/txn.i @@ -13,13 +13,13 @@ */ static inline bool __wt_ref_cas_state_int(WT_SESSION_IMPL *session, WT_REF *ref, - uint32_t old_state, uint32_t new_state, const char *file, int line) + uint32_t old_state, uint32_t new_state, const char *func, int line) { bool cas_result; /* Parameters that are used in a macro for diagnostic builds */ WT_UNUSED(session); - WT_UNUSED(file); + WT_UNUSED(func); WT_UNUSED(line); cas_result = __wt_atomic_casv32(&ref->state, old_state, new_state); @@ -31,7 +31,7 @@ __wt_ref_cas_state_int(WT_SESSION_IMPL *session, WT_REF *ref, * updated. */ if (cas_result) - WT_REF_SAVE_STATE(ref, new_state, file, line); + WT_REF_SAVE_STATE(ref, new_state, func, line); #endif return (cas_result); } @@ -1081,7 +1081,8 @@ __wt_txn_search_check(WT_SESSION_IMPL *session) * verify this transaction has one. Same if it should never have * a read timestamp. */ - if (FLD_ISSET(btree->assert_flags, WT_ASSERT_READ_TS_ALWAYS) && + if (!F_ISSET(S2C(session), WT_CONN_RECOVERING) && + FLD_ISSET(btree->assert_flags, WT_ASSERT_READ_TS_ALWAYS) && !F_ISSET(txn, WT_TXN_PUBLIC_TS_READ)) WT_RET_MSG(session, EINVAL, "read_timestamp required and " "none set on this transaction"); diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in index 484175dd43e..119d734d01f 100644 --- a/src/third_party/wiredtiger/src/include/wiredtiger.in +++ b/src/third_party/wiredtiger/src/include/wiredtiger.in @@ -498,11 +498,7 @@ struct __wt_cursor { * format type \c u). * * The WT_CURSOR::modify method can only be called from within an - * explicit transaction configured at a higher isolation level than - * \c read-uncommitted. Using \c read-committed isolation is allowed, - * but requires caution: reading a value, re-positioning the cursor - * and then modifying the value based on the initial read could lead - * to unexpected results. Using \c snapshot isolation is recommended. + * explicit transaction configured at the snapshot isolation level. * * The WT_CURSOR::modify method stores a change record in cache and * writes a change record to the log instead of the usual complete @@ -2180,7 +2176,10 @@ struct __wt_connection { /*! * Close a connection. * - * Any open sessions will be closed. + * Any open sessions will be closed. This will release the resources + * associated with the session handle, including rolling back any + * active transactions and closing any cursors that remain open in the + * session. * * @snippet ex_all.c Close a connection * @@ -5196,735 +5195,738 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); #define WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT 1060 /*! cache: eviction server unable to reach eviction goal */ #define WT_STAT_CONN_CACHE_EVICTION_SLOW 1061 +/*! cache: eviction server waiting for a leaf page */ +#define WT_STAT_CONN_CACHE_EVICTION_WALK_LEAF_NOTFOUND 1062 +/*! cache: eviction server waiting for an internal page sleep (usec) */ +#define WT_STAT_CONN_CACHE_EVICTION_WALK_INTERNAL_WAIT 1063 +/*! cache: eviction server waiting for an internal page yields */ +#define WT_STAT_CONN_CACHE_EVICTION_WALK_INTERNAL_YIELD 1064 /*! cache: eviction state */ -#define WT_STAT_CONN_CACHE_EVICTION_STATE 1062 +#define WT_STAT_CONN_CACHE_EVICTION_STATE 1065 /*! cache: eviction walk target pages histogram - 0-9 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10 1063 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10 1066 /*! cache: eviction walk target pages histogram - 10-31 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32 1064 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32 1067 /*! cache: eviction walk target pages histogram - 128 and higher */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128 1065 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128 1068 /*! cache: eviction walk target pages histogram - 32-63 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64 1066 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64 1069 /*! cache: eviction walk target pages histogram - 64-128 */ -#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128 1067 +#define WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128 1070 /*! cache: eviction walks abandoned */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED 1068 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED 1071 /*! cache: eviction walks gave up because they restarted their walk twice */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED 1069 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED 1072 /*! * cache: eviction walks gave up because they saw too many pages and * found no candidates */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS 1070 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS 1073 /*! * cache: eviction walks gave up because they saw too many pages and * found too few candidates */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO 1071 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO 1074 /*! cache: eviction walks reached end of tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED 1072 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED 1075 /*! cache: eviction walks started from root of tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT 1073 +#define WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT 1076 /*! cache: eviction walks started from saved location in tree */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS 1074 +#define WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS 1077 /*! cache: eviction worker thread active */ -#define WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS 1075 +#define WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS 1078 /*! cache: eviction worker thread created */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED 1076 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED 1079 /*! cache: eviction worker thread evicting pages */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING 1077 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING 1080 /*! cache: eviction worker thread removed */ -#define WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED 1078 +#define WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED 1081 /*! cache: eviction worker thread stable number */ -#define WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS 1079 -/*! - * cache: failed eviction of pages that exceeded the in-memory maximum - * count - */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1080 -/*! - * cache: failed eviction of pages that exceeded the in-memory maximum - * time (usecs) - */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1081 +#define WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS 1082 /*! cache: files with active eviction walks */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE 1082 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE 1083 /*! cache: files with new eviction walks started */ -#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED 1083 +#define WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED 1084 /*! cache: force re-tuning of eviction workers once in a while */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE 1084 +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE 1085 +/*! cache: forced eviction - pages evicted that were clean count */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN 1086 +/*! cache: forced eviction - pages evicted that were clean time (usecs) */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN_TIME 1087 +/*! cache: forced eviction - pages evicted that were dirty count */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY 1088 +/*! cache: forced eviction - pages evicted that were dirty time (usecs) */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY_TIME 1089 +/*! + * cache: forced eviction - pages selected because of too many deleted + * items count + */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1090 +/*! cache: forced eviction - pages selected count */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1091 +/*! cache: forced eviction - pages selected unable to be evicted count */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL 1092 +/*! cache: forced eviction - pages selected unable to be evicted time */ +#define WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME 1093 /*! cache: hazard pointer blocked page eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1085 +#define WT_STAT_CONN_CACHE_EVICTION_HAZARD 1094 /*! cache: hazard pointer check calls */ -#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1086 +#define WT_STAT_CONN_CACHE_HAZARD_CHECKS 1095 /*! cache: hazard pointer check entries walked */ -#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1087 +#define WT_STAT_CONN_CACHE_HAZARD_WALKS 1096 /*! cache: hazard pointer maximum array length */ -#define WT_STAT_CONN_CACHE_HAZARD_MAX 1088 +#define WT_STAT_CONN_CACHE_HAZARD_MAX 1097 /*! cache: in-memory page passed criteria to be split */ -#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1089 +#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1098 /*! cache: in-memory page splits */ -#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1090 +#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1099 /*! cache: internal pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1091 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1100 /*! cache: internal pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1092 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1101 /*! cache: leaf pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1093 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1102 /*! cache: maximum bytes configured */ -#define WT_STAT_CONN_CACHE_BYTES_MAX 1094 +#define WT_STAT_CONN_CACHE_BYTES_MAX 1103 /*! cache: maximum page size at eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1095 +#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1104 /*! cache: modified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1096 +#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1105 /*! cache: modified pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1097 +#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1106 /*! cache: operations timed out waiting for space in cache */ -#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1098 +#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1107 /*! cache: overflow pages read into cache */ -#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1099 +#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1108 /*! cache: page split during eviction deepened the tree */ -#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1100 +#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1109 /*! cache: page written requiring cache overflow records */ -#define WT_STAT_CONN_CACHE_WRITE_LOOKASIDE 1101 +#define WT_STAT_CONN_CACHE_WRITE_LOOKASIDE 1110 /*! cache: pages currently held in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_INUSE 1102 -/*! cache: pages evicted because they exceeded the in-memory maximum count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE 1103 -/*! - * cache: pages evicted because they exceeded the in-memory maximum time - * (usecs) - */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_TIME 1104 -/*! cache: pages evicted because they had chains of deleted items count */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE 1105 -/*! - * cache: pages evicted because they had chains of deleted items time - * (usecs) - */ -#define WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE_TIME 1106 +#define WT_STAT_CONN_CACHE_PAGES_INUSE 1111 /*! cache: pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP 1107 +#define WT_STAT_CONN_CACHE_EVICTION_APP 1112 /*! cache: pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1108 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1113 +/*! cache: pages queued for eviction post lru sorting */ +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU 1114 /*! cache: pages queued for urgent eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1109 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1115 /*! cache: pages queued for urgent eviction during walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1110 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1116 /*! cache: pages read into cache */ -#define WT_STAT_CONN_CACHE_READ 1111 +#define WT_STAT_CONN_CACHE_READ 1117 /*! cache: pages read into cache after truncate */ -#define WT_STAT_CONN_CACHE_READ_DELETED 1112 +#define WT_STAT_CONN_CACHE_READ_DELETED 1118 /*! cache: pages read into cache after truncate in prepare state */ -#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1113 +#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1119 /*! cache: pages read into cache requiring cache overflow entries */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE 1114 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE 1120 /*! cache: pages read into cache requiring cache overflow for checkpoint */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT 1115 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT 1121 /*! cache: pages read into cache skipping older cache overflow entries */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED 1116 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED 1122 /*! * cache: pages read into cache with skipped cache overflow entries * needed later */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY 1117 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY 1123 /*! * cache: pages read into cache with skipped cache overflow entries * needed later by checkpoint */ -#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT 1118 +#define WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT 1124 /*! cache: pages requested from the cache */ -#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1119 +#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1125 /*! cache: pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1120 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1126 /*! cache: pages selected for eviction unable to be evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1121 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1127 /*! cache: pages walked for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK 1122 +#define WT_STAT_CONN_CACHE_EVICTION_WALK 1128 /*! cache: pages written from cache */ -#define WT_STAT_CONN_CACHE_WRITE 1123 +#define WT_STAT_CONN_CACHE_WRITE 1129 /*! cache: pages written requiring in-memory restoration */ -#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1124 +#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1130 /*! cache: percentage overhead */ -#define WT_STAT_CONN_CACHE_OVERHEAD 1125 +#define WT_STAT_CONN_CACHE_OVERHEAD 1131 /*! cache: tracked bytes belonging to internal pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1126 +#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1132 /*! cache: tracked bytes belonging to leaf pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_LEAF 1127 +#define WT_STAT_CONN_CACHE_BYTES_LEAF 1133 /*! cache: tracked dirty bytes in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1128 +#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1134 /*! cache: tracked dirty pages in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1129 +#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1135 /*! cache: unmodified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1130 +#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1136 /*! capacity: background fsync file handles considered */ -#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1131 +#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1137 /*! capacity: background fsync file handles synced */ -#define WT_STAT_CONN_FSYNC_ALL_FH 1132 +#define WT_STAT_CONN_FSYNC_ALL_FH 1138 /*! capacity: background fsync time (msecs) */ -#define WT_STAT_CONN_FSYNC_ALL_TIME 1133 +#define WT_STAT_CONN_FSYNC_ALL_TIME 1139 /*! capacity: bytes read */ -#define WT_STAT_CONN_CAPACITY_BYTES_READ 1134 +#define WT_STAT_CONN_CAPACITY_BYTES_READ 1140 /*! capacity: bytes written for checkpoint */ -#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1135 +#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1141 /*! capacity: bytes written for eviction */ -#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1136 +#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1142 /*! capacity: bytes written for log */ -#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1137 +#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1143 /*! capacity: bytes written total */ -#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1138 +#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1144 /*! capacity: threshold to call fsync */ -#define WT_STAT_CONN_CAPACITY_THRESHOLD 1139 +#define WT_STAT_CONN_CAPACITY_THRESHOLD 1145 /*! capacity: time waiting due to total capacity (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1140 +#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1146 /*! capacity: time waiting during checkpoint (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1141 +#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1147 /*! capacity: time waiting during eviction (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1142 +#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1148 /*! capacity: time waiting during logging (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_LOG 1143 +#define WT_STAT_CONN_CAPACITY_TIME_LOG 1149 /*! capacity: time waiting during read (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_READ 1144 +#define WT_STAT_CONN_CAPACITY_TIME_READ 1150 /*! connection: auto adjusting condition resets */ -#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1145 +#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1151 /*! connection: auto adjusting condition wait calls */ -#define WT_STAT_CONN_COND_AUTO_WAIT 1146 +#define WT_STAT_CONN_COND_AUTO_WAIT 1152 /*! connection: detected system time went backwards */ -#define WT_STAT_CONN_TIME_TRAVEL 1147 +#define WT_STAT_CONN_TIME_TRAVEL 1153 /*! connection: files currently open */ -#define WT_STAT_CONN_FILE_OPEN 1148 +#define WT_STAT_CONN_FILE_OPEN 1154 /*! connection: memory allocations */ -#define WT_STAT_CONN_MEMORY_ALLOCATION 1149 +#define WT_STAT_CONN_MEMORY_ALLOCATION 1155 /*! connection: memory frees */ -#define WT_STAT_CONN_MEMORY_FREE 1150 +#define WT_STAT_CONN_MEMORY_FREE 1156 /*! connection: memory re-allocations */ -#define WT_STAT_CONN_MEMORY_GROW 1151 +#define WT_STAT_CONN_MEMORY_GROW 1157 /*! connection: pthread mutex condition wait calls */ -#define WT_STAT_CONN_COND_WAIT 1152 +#define WT_STAT_CONN_COND_WAIT 1158 /*! connection: pthread mutex shared lock read-lock calls */ -#define WT_STAT_CONN_RWLOCK_READ 1153 +#define WT_STAT_CONN_RWLOCK_READ 1159 /*! connection: pthread mutex shared lock write-lock calls */ -#define WT_STAT_CONN_RWLOCK_WRITE 1154 +#define WT_STAT_CONN_RWLOCK_WRITE 1160 /*! connection: total fsync I/Os */ -#define WT_STAT_CONN_FSYNC_IO 1155 +#define WT_STAT_CONN_FSYNC_IO 1161 /*! connection: total read I/Os */ -#define WT_STAT_CONN_READ_IO 1156 +#define WT_STAT_CONN_READ_IO 1162 /*! connection: total write I/Os */ -#define WT_STAT_CONN_WRITE_IO 1157 +#define WT_STAT_CONN_WRITE_IO 1163 /*! cursor: cached cursor count */ -#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1158 +#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1164 /*! cursor: cursor bulk loaded cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT_BULK 1159 +#define WT_STAT_CONN_CURSOR_INSERT_BULK 1165 /*! cursor: cursor close calls that result in cache */ -#define WT_STAT_CONN_CURSOR_CACHE 1160 +#define WT_STAT_CONN_CURSOR_CACHE 1166 /*! cursor: cursor create calls */ -#define WT_STAT_CONN_CURSOR_CREATE 1161 +#define WT_STAT_CONN_CURSOR_CREATE 1167 /*! cursor: cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT 1162 +#define WT_STAT_CONN_CURSOR_INSERT 1168 /*! cursor: cursor insert key and value bytes */ -#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1163 +#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1169 /*! cursor: cursor modify calls */ -#define WT_STAT_CONN_CURSOR_MODIFY 1164 +#define WT_STAT_CONN_CURSOR_MODIFY 1170 /*! cursor: cursor modify key and value bytes affected */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1165 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1171 /*! cursor: cursor modify value bytes modified */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1166 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1172 /*! cursor: cursor next calls */ -#define WT_STAT_CONN_CURSOR_NEXT 1167 +#define WT_STAT_CONN_CURSOR_NEXT 1173 /*! cursor: cursor operation restarted */ -#define WT_STAT_CONN_CURSOR_RESTART 1168 +#define WT_STAT_CONN_CURSOR_RESTART 1174 /*! cursor: cursor prev calls */ -#define WT_STAT_CONN_CURSOR_PREV 1169 +#define WT_STAT_CONN_CURSOR_PREV 1175 /*! cursor: cursor remove calls */ -#define WT_STAT_CONN_CURSOR_REMOVE 1170 +#define WT_STAT_CONN_CURSOR_REMOVE 1176 /*! cursor: cursor remove key bytes removed */ -#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1171 +#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1177 /*! cursor: cursor reserve calls */ -#define WT_STAT_CONN_CURSOR_RESERVE 1172 +#define WT_STAT_CONN_CURSOR_RESERVE 1178 /*! cursor: cursor reset calls */ -#define WT_STAT_CONN_CURSOR_RESET 1173 +#define WT_STAT_CONN_CURSOR_RESET 1179 /*! cursor: cursor search calls */ -#define WT_STAT_CONN_CURSOR_SEARCH 1174 +#define WT_STAT_CONN_CURSOR_SEARCH 1180 /*! cursor: cursor search near calls */ -#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1175 +#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1181 /*! cursor: cursor sweep buckets */ -#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1176 +#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1182 /*! cursor: cursor sweep cursors closed */ -#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1177 +#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1183 /*! cursor: cursor sweep cursors examined */ -#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1178 +#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1184 /*! cursor: cursor sweeps */ -#define WT_STAT_CONN_CURSOR_SWEEP 1179 +#define WT_STAT_CONN_CURSOR_SWEEP 1185 /*! cursor: cursor truncate calls */ -#define WT_STAT_CONN_CURSOR_TRUNCATE 1180 +#define WT_STAT_CONN_CURSOR_TRUNCATE 1186 /*! cursor: cursor update calls */ -#define WT_STAT_CONN_CURSOR_UPDATE 1181 +#define WT_STAT_CONN_CURSOR_UPDATE 1187 /*! cursor: cursor update key and value bytes */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1182 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1188 /*! cursor: cursor update value size change */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1183 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1189 /*! cursor: cursors reused from cache */ -#define WT_STAT_CONN_CURSOR_REOPEN 1184 +#define WT_STAT_CONN_CURSOR_REOPEN 1190 /*! cursor: open cursor count */ -#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1185 +#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1191 /*! data-handle: connection data handle size */ -#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1186 +#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1192 /*! data-handle: connection data handles currently active */ -#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1187 +#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1193 /*! data-handle: connection sweep candidate became referenced */ -#define WT_STAT_CONN_DH_SWEEP_REF 1188 +#define WT_STAT_CONN_DH_SWEEP_REF 1194 /*! data-handle: connection sweep dhandles closed */ -#define WT_STAT_CONN_DH_SWEEP_CLOSE 1189 +#define WT_STAT_CONN_DH_SWEEP_CLOSE 1195 /*! data-handle: connection sweep dhandles removed from hash list */ -#define WT_STAT_CONN_DH_SWEEP_REMOVE 1190 +#define WT_STAT_CONN_DH_SWEEP_REMOVE 1196 /*! data-handle: connection sweep time-of-death sets */ -#define WT_STAT_CONN_DH_SWEEP_TOD 1191 +#define WT_STAT_CONN_DH_SWEEP_TOD 1197 /*! data-handle: connection sweeps */ -#define WT_STAT_CONN_DH_SWEEPS 1192 +#define WT_STAT_CONN_DH_SWEEPS 1198 /*! data-handle: session dhandles swept */ -#define WT_STAT_CONN_DH_SESSION_HANDLES 1193 +#define WT_STAT_CONN_DH_SESSION_HANDLES 1199 /*! data-handle: session sweep attempts */ -#define WT_STAT_CONN_DH_SESSION_SWEEPS 1194 +#define WT_STAT_CONN_DH_SESSION_SWEEPS 1200 /*! lock: checkpoint lock acquisitions */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1195 +#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1201 /*! lock: checkpoint lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1196 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1202 /*! lock: checkpoint lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1197 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1203 /*! * lock: commit timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION 1198 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION 1204 /*! lock: commit timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL 1199 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL 1205 /*! lock: commit timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT 1200 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT 1206 /*! lock: commit timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT 1201 +#define WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT 1207 /*! lock: dhandle lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1202 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1208 /*! lock: dhandle lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1203 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1209 /*! lock: dhandle read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1204 +#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1210 /*! lock: dhandle write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1205 +#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1211 /*! lock: metadata lock acquisitions */ -#define WT_STAT_CONN_LOCK_METADATA_COUNT 1206 +#define WT_STAT_CONN_LOCK_METADATA_COUNT 1212 /*! lock: metadata lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1207 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1213 /*! lock: metadata lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1208 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1214 /*! * lock: read timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1209 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1215 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1210 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1216 /*! lock: read timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1211 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1217 /*! lock: read timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1212 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1218 /*! lock: schema lock acquisitions */ -#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1213 +#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1219 /*! lock: schema lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1214 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1220 /*! lock: schema lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1215 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1221 /*! * lock: table lock application thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1216 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1222 /*! * lock: table lock internal thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1217 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1223 /*! lock: table read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1218 +#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1224 /*! lock: table write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1219 +#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1225 /*! lock: txn global lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1220 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1226 /*! lock: txn global lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1221 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1227 /*! lock: txn global read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1222 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1228 /*! lock: txn global write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1223 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1229 /*! log: busy returns attempting to switch slots */ -#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1224 +#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1230 /*! log: force archive time sleeping (usecs) */ -#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1225 +#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1231 /*! log: log bytes of payload data */ -#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1226 +#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1232 /*! log: log bytes written */ -#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1227 +#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1233 /*! log: log files manually zero-filled */ -#define WT_STAT_CONN_LOG_ZERO_FILLS 1228 +#define WT_STAT_CONN_LOG_ZERO_FILLS 1234 /*! log: log flush operations */ -#define WT_STAT_CONN_LOG_FLUSH 1229 +#define WT_STAT_CONN_LOG_FLUSH 1235 /*! log: log force write operations */ -#define WT_STAT_CONN_LOG_FORCE_WRITE 1230 +#define WT_STAT_CONN_LOG_FORCE_WRITE 1236 /*! log: log force write operations skipped */ -#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1231 +#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1237 /*! log: log records compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1232 +#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1238 /*! log: log records not compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1233 +#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1239 /*! log: log records too small to compress */ -#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1234 +#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1240 /*! log: log release advances write LSN */ -#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1235 +#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1241 /*! log: log scan operations */ -#define WT_STAT_CONN_LOG_SCANS 1236 +#define WT_STAT_CONN_LOG_SCANS 1242 /*! log: log scan records requiring two reads */ -#define WT_STAT_CONN_LOG_SCAN_REREADS 1237 +#define WT_STAT_CONN_LOG_SCAN_REREADS 1243 /*! log: log server thread advances write LSN */ -#define WT_STAT_CONN_LOG_WRITE_LSN 1238 +#define WT_STAT_CONN_LOG_WRITE_LSN 1244 /*! log: log server thread write LSN walk skipped */ -#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1239 +#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1245 /*! log: log sync operations */ -#define WT_STAT_CONN_LOG_SYNC 1240 +#define WT_STAT_CONN_LOG_SYNC 1246 /*! log: log sync time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DURATION 1241 +#define WT_STAT_CONN_LOG_SYNC_DURATION 1247 /*! log: log sync_dir operations */ -#define WT_STAT_CONN_LOG_SYNC_DIR 1242 +#define WT_STAT_CONN_LOG_SYNC_DIR 1248 /*! log: log sync_dir time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1243 +#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1249 /*! log: log write operations */ -#define WT_STAT_CONN_LOG_WRITES 1244 +#define WT_STAT_CONN_LOG_WRITES 1250 /*! log: logging bytes consolidated */ -#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1245 +#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1251 /*! log: maximum log file size */ -#define WT_STAT_CONN_LOG_MAX_FILESIZE 1246 +#define WT_STAT_CONN_LOG_MAX_FILESIZE 1252 /*! log: number of pre-allocated log files to create */ -#define WT_STAT_CONN_LOG_PREALLOC_MAX 1247 +#define WT_STAT_CONN_LOG_PREALLOC_MAX 1253 /*! log: pre-allocated log files not ready and missed */ -#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1248 +#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1254 /*! log: pre-allocated log files prepared */ -#define WT_STAT_CONN_LOG_PREALLOC_FILES 1249 +#define WT_STAT_CONN_LOG_PREALLOC_FILES 1255 /*! log: pre-allocated log files used */ -#define WT_STAT_CONN_LOG_PREALLOC_USED 1250 +#define WT_STAT_CONN_LOG_PREALLOC_USED 1256 /*! log: records processed by log scan */ -#define WT_STAT_CONN_LOG_SCAN_RECORDS 1251 +#define WT_STAT_CONN_LOG_SCAN_RECORDS 1257 /*! log: slot close lost race */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1252 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1258 /*! log: slot close unbuffered waits */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1253 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1259 /*! log: slot closures */ -#define WT_STAT_CONN_LOG_SLOT_CLOSES 1254 +#define WT_STAT_CONN_LOG_SLOT_CLOSES 1260 /*! log: slot join atomic update races */ -#define WT_STAT_CONN_LOG_SLOT_RACES 1255 +#define WT_STAT_CONN_LOG_SLOT_RACES 1261 /*! log: slot join calls atomic updates raced */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1256 +#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1262 /*! log: slot join calls did not yield */ -#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1257 +#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1263 /*! log: slot join calls found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1258 +#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1264 /*! log: slot join calls slept */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1259 +#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1265 /*! log: slot join calls yielded */ -#define WT_STAT_CONN_LOG_SLOT_YIELD 1260 +#define WT_STAT_CONN_LOG_SLOT_YIELD 1266 /*! log: slot join found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1261 +#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1267 /*! log: slot joins yield time (usecs) */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1262 +#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1268 /*! log: slot transitions unable to find free slot */ -#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1263 +#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1269 /*! log: slot unbuffered writes */ -#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1264 +#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1270 /*! log: total in-memory size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_MEM 1265 +#define WT_STAT_CONN_LOG_COMPRESS_MEM 1271 /*! log: total log buffer size */ -#define WT_STAT_CONN_LOG_BUFFER_SIZE 1266 +#define WT_STAT_CONN_LOG_BUFFER_SIZE 1272 /*! log: total size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_LEN 1267 +#define WT_STAT_CONN_LOG_COMPRESS_LEN 1273 /*! log: written slots coalesced */ -#define WT_STAT_CONN_LOG_SLOT_COALESCED 1268 +#define WT_STAT_CONN_LOG_SLOT_COALESCED 1274 /*! log: yields waiting for previous log file close */ -#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1269 +#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1275 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1270 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1276 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1271 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1277 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1272 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1278 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1273 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1279 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1274 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1280 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1275 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1281 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1276 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1282 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1277 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1283 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1278 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1284 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1279 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1285 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1280 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1286 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1281 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1287 /*! perf: operation read latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1282 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1288 /*! perf: operation read latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1283 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1289 /*! perf: operation read latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1284 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1290 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1285 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1291 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1286 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1292 /*! perf: operation write latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1287 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1293 /*! perf: operation write latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1288 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1294 /*! perf: operation write latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1289 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1295 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1290 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1296 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1291 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1297 /*! reconciliation: fast-path pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1292 +#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1298 /*! reconciliation: page reconciliation calls */ -#define WT_STAT_CONN_REC_PAGES 1293 +#define WT_STAT_CONN_REC_PAGES 1299 /*! reconciliation: page reconciliation calls for eviction */ -#define WT_STAT_CONN_REC_PAGES_EVICTION 1294 +#define WT_STAT_CONN_REC_PAGES_EVICTION 1300 /*! reconciliation: pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE 1295 +#define WT_STAT_CONN_REC_PAGE_DELETE 1301 /*! reconciliation: split bytes currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1296 +#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1302 /*! reconciliation: split objects currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1297 +#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1303 /*! session: open session count */ -#define WT_STAT_CONN_SESSION_OPEN 1298 +#define WT_STAT_CONN_SESSION_OPEN 1304 /*! session: session query timestamp calls */ -#define WT_STAT_CONN_SESSION_QUERY_TS 1299 +#define WT_STAT_CONN_SESSION_QUERY_TS 1305 /*! session: table alter failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1300 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1306 /*! session: table alter successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1301 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1307 /*! session: table alter unchanged and skipped */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1302 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1308 /*! session: table compact failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1303 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1309 /*! session: table compact successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1304 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1310 /*! session: table create failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1305 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1311 /*! session: table create successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1306 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1312 /*! session: table drop failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1307 +#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1313 /*! session: table drop successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1308 +#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1314 /*! session: table import failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_IMPORT_FAIL 1309 +#define WT_STAT_CONN_SESSION_TABLE_IMPORT_FAIL 1315 /*! session: table import successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_IMPORT_SUCCESS 1310 +#define WT_STAT_CONN_SESSION_TABLE_IMPORT_SUCCESS 1316 /*! session: table rebalance failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1311 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1317 /*! session: table rebalance successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1312 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1318 /*! session: table rename failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1313 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1319 /*! session: table rename successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1314 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1320 /*! session: table salvage failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1315 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1321 /*! session: table salvage successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1316 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1322 /*! session: table truncate failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1317 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1323 /*! session: table truncate successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1318 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1324 /*! session: table verify failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1319 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1325 /*! session: table verify successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1320 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1326 /*! thread-state: active filesystem fsync calls */ -#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1321 +#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1327 /*! thread-state: active filesystem read calls */ -#define WT_STAT_CONN_THREAD_READ_ACTIVE 1322 +#define WT_STAT_CONN_THREAD_READ_ACTIVE 1328 /*! thread-state: active filesystem write calls */ -#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1323 +#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1329 /*! thread-yield: application thread time evicting (usecs) */ -#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1324 +#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1330 /*! thread-yield: application thread time waiting for cache (usecs) */ -#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1325 +#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1331 /*! * thread-yield: connection close blocked waiting for transaction state * stabilization */ -#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1326 +#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1332 /*! thread-yield: connection close yielded for lsm manager shutdown */ -#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1327 +#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1333 /*! thread-yield: data handle lock yielded */ -#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1328 +#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1334 /*! * thread-yield: get reference for page index and slot time sleeping * (usecs) */ -#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1329 +#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1335 /*! thread-yield: log server sync yielded for log write */ -#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1330 +#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1336 /*! thread-yield: page access yielded due to prepare state change */ -#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1331 +#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1337 /*! thread-yield: page acquire busy blocked */ -#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1332 +#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1338 /*! thread-yield: page acquire eviction blocked */ -#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1333 +#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1339 /*! thread-yield: page acquire locked blocked */ -#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1334 +#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1340 /*! thread-yield: page acquire read blocked */ -#define WT_STAT_CONN_PAGE_READ_BLOCKED 1335 +#define WT_STAT_CONN_PAGE_READ_BLOCKED 1341 /*! thread-yield: page acquire time sleeping (usecs) */ -#define WT_STAT_CONN_PAGE_SLEEP 1336 +#define WT_STAT_CONN_PAGE_SLEEP 1342 /*! * thread-yield: page delete rollback time sleeping for state change * (usecs) */ -#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1337 +#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1343 /*! thread-yield: page reconciliation yielded due to child modification */ -#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1338 +#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1344 /*! transaction: Number of prepared updates */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1339 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1345 /*! transaction: Number of prepared updates added to cache overflow */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_LOOKASIDE_INSERTS 1340 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_LOOKASIDE_INSERTS 1346 /*! transaction: Number of prepared updates resolved */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_RESOLVED 1341 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_RESOLVED 1347 /*! transaction: commit timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED 1342 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED 1348 /*! transaction: commit timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY 1343 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY 1349 /*! transaction: commit timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD 1344 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD 1350 /*! transaction: commit timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS 1345 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS 1351 /*! transaction: commit timestamp queue length */ -#define WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN 1346 +#define WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN 1352 /*! transaction: number of named snapshots created */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1347 +#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1353 /*! transaction: number of named snapshots dropped */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1348 +#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1354 /*! transaction: prepared transactions */ -#define WT_STAT_CONN_TXN_PREPARE 1349 +#define WT_STAT_CONN_TXN_PREPARE 1355 /*! transaction: prepared transactions committed */ -#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1350 +#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1356 /*! transaction: prepared transactions currently active */ -#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1351 +#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1357 /*! transaction: prepared transactions rolled back */ -#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1352 +#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1358 /*! transaction: query timestamp calls */ -#define WT_STAT_CONN_TXN_QUERY_TS 1353 +#define WT_STAT_CONN_TXN_QUERY_TS 1359 /*! transaction: read timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1354 +#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1360 /*! transaction: read timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1355 +#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1361 /*! transaction: read timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1356 +#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1362 /*! transaction: read timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1357 +#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1363 /*! transaction: read timestamp queue length */ -#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1358 +#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1364 /*! transaction: rollback to stable calls */ -#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1359 +#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1365 /*! transaction: rollback to stable updates aborted */ -#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1360 +#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1366 /*! transaction: rollback to stable updates removed from cache overflow */ -#define WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED 1361 +#define WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED 1367 /*! transaction: set timestamp calls */ -#define WT_STAT_CONN_TXN_SET_TS 1362 +#define WT_STAT_CONN_TXN_SET_TS 1368 /*! transaction: set timestamp commit calls */ -#define WT_STAT_CONN_TXN_SET_TS_COMMIT 1363 +#define WT_STAT_CONN_TXN_SET_TS_COMMIT 1369 /*! transaction: set timestamp commit updates */ -#define WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD 1364 +#define WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD 1370 /*! transaction: set timestamp oldest calls */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1365 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1371 /*! transaction: set timestamp oldest updates */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1366 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1372 /*! transaction: set timestamp stable calls */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE 1367 +#define WT_STAT_CONN_TXN_SET_TS_STABLE 1373 /*! transaction: set timestamp stable updates */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1368 +#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1374 /*! transaction: transaction begins */ -#define WT_STAT_CONN_TXN_BEGIN 1369 +#define WT_STAT_CONN_TXN_BEGIN 1375 /*! transaction: transaction checkpoint currently running */ -#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1370 +#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1376 /*! transaction: transaction checkpoint generation */ -#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1371 +#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1377 /*! transaction: transaction checkpoint max time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1372 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1378 /*! transaction: transaction checkpoint min time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1373 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1379 /*! transaction: transaction checkpoint most recent time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1374 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1380 /*! transaction: transaction checkpoint scrub dirty target */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1375 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1381 /*! transaction: transaction checkpoint scrub time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1376 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1382 /*! transaction: transaction checkpoint total time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1377 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1383 /*! transaction: transaction checkpoints */ -#define WT_STAT_CONN_TXN_CHECKPOINT 1378 +#define WT_STAT_CONN_TXN_CHECKPOINT 1384 /*! * transaction: transaction checkpoints skipped because database was * clean */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1379 +#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1385 /*! transaction: transaction failures due to cache overflow */ -#define WT_STAT_CONN_TXN_FAIL_CACHE 1380 +#define WT_STAT_CONN_TXN_FAIL_CACHE 1386 /*! * transaction: transaction fsync calls for checkpoint after allocating * the transaction ID */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1381 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1387 /*! * transaction: transaction fsync duration for checkpoint after * allocating the transaction ID (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1382 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1388 /*! transaction: transaction range of IDs currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_RANGE 1383 +#define WT_STAT_CONN_TXN_PINNED_RANGE 1389 /*! transaction: transaction range of IDs currently pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1384 +#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1390 /*! * transaction: transaction range of IDs currently pinned by named * snapshots */ -#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1385 +#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1391 /*! transaction: transaction range of timestamps currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1386 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1392 /*! transaction: transaction range of timestamps pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1387 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1393 /*! * transaction: transaction range of timestamps pinned by the oldest * active read timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1388 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1394 /*! * transaction: transaction range of timestamps pinned by the oldest * timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1389 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1395 /*! transaction: transaction read timestamp of the oldest active reader */ -#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1390 +#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1396 /*! transaction: transaction sync calls */ -#define WT_STAT_CONN_TXN_SYNC 1391 +#define WT_STAT_CONN_TXN_SYNC 1397 /*! transaction: transactions committed */ -#define WT_STAT_CONN_TXN_COMMIT 1392 +#define WT_STAT_CONN_TXN_COMMIT 1398 /*! transaction: transactions rolled back */ -#define WT_STAT_CONN_TXN_ROLLBACK 1393 +#define WT_STAT_CONN_TXN_ROLLBACK 1399 /*! transaction: update conflicts */ -#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1394 +#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1400 /*! * @} diff --git a/src/third_party/wiredtiger/src/lsm/lsm_manager.c b/src/third_party/wiredtiger/src/lsm/lsm_manager.c index d1eceaf2afd..aa5f08034d4 100644 --- a/src/third_party/wiredtiger/src/lsm/lsm_manager.c +++ b/src/third_party/wiredtiger/src/lsm/lsm_manager.c @@ -339,12 +339,6 @@ __wt_lsm_manager_destroy(WT_SESSION_IMPL *session) } WT_STAT_CONN_INCRV(session, lsm_work_units_discarded, removed); - /* Free resources that are allocated in connection initialize */ - __wt_spin_destroy(session, &manager->switch_lock); - __wt_spin_destroy(session, &manager->app_lock); - __wt_spin_destroy(session, &manager->manager_lock); - __wt_cond_destroy(session, &manager->work_cond); - return (ret); } diff --git a/src/third_party/wiredtiger/src/meta/meta_ckpt.c b/src/third_party/wiredtiger/src/meta/meta_ckpt.c index 35b6389bced..49b2d2a2a2d 100644 --- a/src/third_party/wiredtiger/src/meta/meta_ckpt.c +++ b/src/third_party/wiredtiger/src/meta/meta_ckpt.c @@ -351,8 +351,12 @@ __wt_meta_ckptlist_get(WT_SESSION_IMPL *session, __wt_config_getones(session, config, "checkpoint", &v)) == 0) { __wt_config_subinit(session, &ckptconf, &v); for (; __wt_config_next(&ckptconf, &k, &v) == 0; ++slot) { + /* + * Allocate a slot for a new value, plus a slot to mark + * the end. + */ WT_ERR(__wt_realloc_def( - session, &allocated, slot + 1, &ckptbase)); + session, &allocated, slot + 2, &ckptbase)); ckpt = &ckptbase[slot]; WT_ERR(__ckpt_load(session, &k, &v, ckpt)); @@ -367,9 +371,6 @@ __wt_meta_ckptlist_get(WT_SESSION_IMPL *session, if (update) { /* - * Allocate an extra slot for a new value, plus a slot to mark - * mark the end. - * * This isn't clean, but there's necessary cooperation between * the schema layer (that maintains the list of checkpoints), * the btree layer (that knows when the root page is written, @@ -377,6 +378,8 @@ __wt_meta_ckptlist_get(WT_SESSION_IMPL *session, * actually creates the checkpoint). All of that cooperation is * handled in the array of checkpoint structures referenced from * the WT_BTREE structure. + * + * Allocate a slot for a new value, plus a slot to mark the end. */ WT_ERR(__wt_realloc_def( session, &allocated, slot + 2, &ckptbase)); diff --git a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c index 2766e74f92c..9222272767b 100644 --- a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c +++ b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c @@ -424,9 +424,9 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, r->unstable_txn = first_upd->txnid; if (first_ts_upd != NULL) { WT_ASSERT(session, - first_ts_upd->prepare_state == - WT_PREPARE_INPROGRESS || - first_ts_upd->start_ts <= first_ts_upd->durable_ts); + first_ts_upd->prepare_state == + WT_PREPARE_INPROGRESS || + first_ts_upd->start_ts <= first_ts_upd->durable_ts); if (r->unstable_timestamp < first_ts_upd->start_ts) r->unstable_timestamp = first_ts_upd->start_ts; @@ -452,8 +452,8 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, * both will be set. */ WT_ASSERT(session, - upd->prepare_state == WT_PREPARE_INPROGRESS || - upd->durable_ts >= upd->start_ts); + upd->prepare_state == WT_PREPARE_INPROGRESS || + upd->durable_ts >= upd->start_ts); if (r->unstable_timestamp > upd->start_ts) r->unstable_timestamp = upd->start_ts; diff --git a/src/third_party/wiredtiger/src/reconcile/rec_write.c b/src/third_party/wiredtiger/src/reconcile/rec_write.c index 7193e6f2b2c..5a78f0df88d 100644 --- a/src/third_party/wiredtiger/src/reconcile/rec_write.c +++ b/src/third_party/wiredtiger/src/reconcile/rec_write.c @@ -639,8 +639,7 @@ __rec_init(WT_SESSION_IMPL *session, else r->las_skew_newest = LF_ISSET(WT_REC_LOOKASIDE) && LF_ISSET(WT_REC_VISIBLE_ALL); - r->las_skew_newest = - LF_ISSET(WT_REC_LOOKASIDE) && LF_ISSET(WT_REC_VISIBLE_ALL); + if (r->las_skew_newest && !__wt_btree_immediately_durable(session) && txn_global->has_stable_timestamp && diff --git a/src/third_party/wiredtiger/src/session/session_api.c b/src/third_party/wiredtiger/src/session/session_api.c index 4e1742a89db..7db62d29738 100644 --- a/src/third_party/wiredtiger/src/session/session_api.c +++ b/src/third_party/wiredtiger/src/session/session_api.c @@ -1127,6 +1127,8 @@ __session_import(WT_SESSION *wt_session, const char *uri, const char *config) WT_UNUSED(config); + value = NULL; + session = (WT_SESSION_IMPL *)wt_session; SESSION_API_CALL_NOCONF(session, import); @@ -1148,6 +1150,7 @@ err: WT_STAT_CONN_INCR(session, session_table_import_fail); else WT_STAT_CONN_INCR(session, session_table_import_success); + __wt_free(session, value); API_END_RET_NOTFOUND_MAP(session, ret); } diff --git a/src/third_party/wiredtiger/src/support/hazard.c b/src/third_party/wiredtiger/src/support/hazard.c index 52f77b5b232..a44f349e3e5 100644 --- a/src/third_party/wiredtiger/src/support/hazard.c +++ b/src/third_party/wiredtiger/src/support/hazard.c @@ -208,9 +208,7 @@ __wt_hazard_clear(WT_SESSION_IMPL *session, WT_REF *ref) * We don't publish the hazard pointer clear in the * general case. It's not required for correctness; * it gives an eviction thread faster access to the - * page were the page selected for eviction, but the - * generation number was just set, it's unlikely the - * page will be selected for eviction. + * page were the page selected for eviction. */ hp->ref = NULL; @@ -330,6 +328,10 @@ __wt_hazard_check(WT_SESSION_IMPL *session, WT_SESSION_IMPL *s; uint32_t i, j, hazard_inuse, max, session_cnt, walk_cnt; + /* If a file can never be evicted, hazard pointers aren't required. */ + if (F_ISSET(S2BT(session), WT_BTREE_IN_MEMORY)) + return (NULL); + conn = S2C(session); WT_STAT_CONN_INCR(session, cache_hazard_checks); diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c index e76930c3b38..95e04dd7d7c 100644 --- a/src/third_party/wiredtiger/src/support/stat.c +++ b/src/third_party/wiredtiger/src/support/stat.c @@ -827,6 +827,9 @@ static const char * const __stats_connection_desc[] = { "cache: eviction server evicting pages", "cache: eviction server slept, because we did not make progress with eviction", "cache: eviction server unable to reach eviction goal", + "cache: eviction server waiting for a leaf page", + "cache: eviction server waiting for an internal page sleep (usec)", + "cache: eviction server waiting for an internal page yields", "cache: eviction state", "cache: eviction walk target pages histogram - 0-9", "cache: eviction walk target pages histogram - 10-31", @@ -845,11 +848,17 @@ static const char * const __stats_connection_desc[] = { "cache: eviction worker thread evicting pages", "cache: eviction worker thread removed", "cache: eviction worker thread stable number", - "cache: failed eviction of pages that exceeded the in-memory maximum count", - "cache: failed eviction of pages that exceeded the in-memory maximum time (usecs)", "cache: files with active eviction walks", "cache: files with new eviction walks started", "cache: force re-tuning of eviction workers once in a while", + "cache: forced eviction - pages evicted that were clean count", + "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 too many deleted items count", + "cache: forced eviction - pages selected count", + "cache: forced eviction - pages selected unable to be evicted count", + "cache: forced eviction - pages selected unable to be evicted time", "cache: hazard pointer blocked page eviction", "cache: hazard pointer check calls", "cache: hazard pointer check entries walked", @@ -868,12 +877,9 @@ static const char * const __stats_connection_desc[] = { "cache: page split during eviction deepened the tree", "cache: page written requiring cache overflow records", "cache: pages currently held in the cache", - "cache: pages evicted because they exceeded the in-memory maximum count", - "cache: pages evicted because they exceeded the in-memory maximum time (usecs)", - "cache: pages evicted because they had chains of deleted items count", - "cache: pages evicted because they had chains of deleted items time (usecs)", "cache: pages evicted by application threads", "cache: pages queued for eviction", + "cache: pages queued for eviction post lru sorting", "cache: pages queued for urgent eviction", "cache: pages queued for urgent eviction during walk", "cache: pages read into cache", @@ -1264,6 +1270,9 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) stats->cache_eviction_server_evicting = 0; stats->cache_eviction_server_slept = 0; stats->cache_eviction_slow = 0; + stats->cache_eviction_walk_leaf_notfound = 0; + stats->cache_eviction_walk_internal_wait = 0; + stats->cache_eviction_walk_internal_yield = 0; /* not clearing cache_eviction_state */ stats->cache_eviction_target_page_lt10 = 0; stats->cache_eviction_target_page_lt32 = 0; @@ -1282,11 +1291,17 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) stats->cache_eviction_worker_evicting = 0; stats->cache_eviction_worker_removed = 0; /* not clearing cache_eviction_stable_state_workers */ - stats->cache_eviction_force_fail = 0; - stats->cache_eviction_force_fail_time = 0; /* not clearing cache_eviction_walks_active */ stats->cache_eviction_walks_started = 0; stats->cache_eviction_force_retune = 0; + stats->cache_eviction_force_clean = 0; + stats->cache_eviction_force_clean_time = 0; + stats->cache_eviction_force_dirty = 0; + stats->cache_eviction_force_dirty_time = 0; + stats->cache_eviction_force_delete = 0; + stats->cache_eviction_force = 0; + stats->cache_eviction_force_fail = 0; + stats->cache_eviction_force_fail_time = 0; stats->cache_eviction_hazard = 0; stats->cache_hazard_checks = 0; stats->cache_hazard_walks = 0; @@ -1305,12 +1320,9 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) stats->cache_eviction_deepen = 0; stats->cache_write_lookaside = 0; /* not clearing cache_pages_inuse */ - stats->cache_eviction_force = 0; - stats->cache_eviction_force_time = 0; - stats->cache_eviction_force_delete = 0; - stats->cache_eviction_force_delete_time = 0; stats->cache_eviction_app = 0; stats->cache_eviction_pages_queued = 0; + stats->cache_eviction_pages_queued_post_lru = 0; stats->cache_eviction_pages_queued_urgent = 0; stats->cache_eviction_pages_queued_oldest = 0; stats->cache_read = 0; @@ -1704,6 +1716,12 @@ __wt_stat_connection_aggregate( to->cache_eviction_server_slept += WT_STAT_READ(from, cache_eviction_server_slept); to->cache_eviction_slow += WT_STAT_READ(from, cache_eviction_slow); + to->cache_eviction_walk_leaf_notfound += + WT_STAT_READ(from, cache_eviction_walk_leaf_notfound); + to->cache_eviction_walk_internal_wait += + WT_STAT_READ(from, cache_eviction_walk_internal_wait); + to->cache_eviction_walk_internal_yield += + WT_STAT_READ(from, cache_eviction_walk_internal_yield); to->cache_eviction_state += WT_STAT_READ(from, cache_eviction_state); to->cache_eviction_target_page_lt10 += WT_STAT_READ(from, cache_eviction_target_page_lt10); @@ -1739,16 +1757,27 @@ __wt_stat_connection_aggregate( WT_STAT_READ(from, cache_eviction_worker_removed); to->cache_eviction_stable_state_workers += WT_STAT_READ(from, cache_eviction_stable_state_workers); - to->cache_eviction_force_fail += - WT_STAT_READ(from, cache_eviction_force_fail); - to->cache_eviction_force_fail_time += - WT_STAT_READ(from, cache_eviction_force_fail_time); to->cache_eviction_walks_active += WT_STAT_READ(from, cache_eviction_walks_active); to->cache_eviction_walks_started += WT_STAT_READ(from, cache_eviction_walks_started); to->cache_eviction_force_retune += WT_STAT_READ(from, cache_eviction_force_retune); + to->cache_eviction_force_clean += + WT_STAT_READ(from, cache_eviction_force_clean); + 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_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); + to->cache_eviction_force_fail_time += + WT_STAT_READ(from, cache_eviction_force_fail_time); to->cache_eviction_hazard += WT_STAT_READ(from, cache_eviction_hazard); to->cache_hazard_checks += WT_STAT_READ(from, cache_hazard_checks); @@ -1777,16 +1806,11 @@ __wt_stat_connection_aggregate( to->cache_write_lookaside += WT_STAT_READ(from, cache_write_lookaside); to->cache_pages_inuse += WT_STAT_READ(from, cache_pages_inuse); - to->cache_eviction_force += WT_STAT_READ(from, cache_eviction_force); - to->cache_eviction_force_time += - WT_STAT_READ(from, cache_eviction_force_time); - to->cache_eviction_force_delete += - WT_STAT_READ(from, cache_eviction_force_delete); - to->cache_eviction_force_delete_time += - WT_STAT_READ(from, cache_eviction_force_delete_time); to->cache_eviction_app += WT_STAT_READ(from, cache_eviction_app); to->cache_eviction_pages_queued += WT_STAT_READ(from, cache_eviction_pages_queued); + to->cache_eviction_pages_queued_post_lru += + WT_STAT_READ(from, cache_eviction_pages_queued_post_lru); to->cache_eviction_pages_queued_urgent += WT_STAT_READ(from, cache_eviction_pages_queued_urgent); to->cache_eviction_pages_queued_oldest += diff --git a/src/third_party/wiredtiger/src/txn/txn.c b/src/third_party/wiredtiger/src/txn/txn.c index 53bde4a499b..f7c94399710 100644 --- a/src/third_party/wiredtiger/src/txn/txn.c +++ b/src/third_party/wiredtiger/src/txn/txn.c @@ -804,13 +804,13 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[]) int64_t resolved_update_count, visited_update_count; uint32_t fileid; u_int i; - bool locked, prepare, readonly, update_timestamp; + bool locked, prepare, readonly, skip_update_assert, update_timestamp; txn = &session->txn; conn = S2C(session); txn_global = &conn->txn_global; prev_commit_timestamp = 0; /* -Wconditional-uninitialized */ - locked = false; + locked = skip_update_assert = false; resolved_update_count = visited_update_count = 0; WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING)); @@ -843,7 +843,7 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[]) "transaction"); WT_ASSERT(session, - txn->prepare_timestamp <= txn->commit_timestamp); + txn->prepare_timestamp <= txn->commit_timestamp); } else { if (F_ISSET(txn, WT_TXN_HAS_TS_PREPARE)) WT_ERR_MSG(session, EINVAL, @@ -987,10 +987,15 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[]) * it would have happened on a previous * modification in this txn. */ - if (!F_ISSET(op, WT_TXN_OP_KEY_REPEATED)) + if (!F_ISSET(op, WT_TXN_OP_KEY_REPEATED)) { + skip_update_assert = + skip_update_assert || + F_ISSET(op, WT_TXN_OP_KEY_RESERVED); WT_ERR(__wt_txn_resolve_prepared_op( session, op, true, &resolved_update_count)); + } + /* * We should resolve at least one or more * updates each time we call @@ -1015,7 +1020,8 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[]) __wt_txn_op_free(session, op); } - WT_ASSERT(session, resolved_update_count == visited_update_count); + WT_ASSERT(session, skip_update_assert || + resolved_update_count == visited_update_count); WT_STAT_CONN_INCRV(session, txn_prepared_updates_resolved, resolved_update_count); @@ -1123,8 +1129,14 @@ __wt_txn_prepare(WT_SESSION_IMPL *session, const char *cfg[]) WT_RET(__wt_session_copy_values(session)); } - /* Prepare updates. */ - for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) { + /* + * Prepare updates, traverse the modification array in reverse order + * so that we visit the update chain in newest to oldest order + * allowing us to set the key repeated flag with reserved updates in + * the chain. + */ + for (i = txn->mod_count; i > 0; i--) { + op = &txn->mod[i - 1]; /* Assert it's not an update to the lookaside file. */ WT_ASSERT(session, S2C(session)->cache->las_fileid == 0 || !F_ISSET(op->btree, WT_BTREE_LOOKASIDE)); @@ -1165,9 +1177,23 @@ __wt_txn_prepare(WT_SESSION_IMPL *session, const char *cfg[]) * Set the key repeated flag which tells us that we've * got multiple updates to the same key by the same txn. * This is later used in txn commit. + * + * When we see a reserved update we set the + * WT_UPDATE_RESERVED flag instead. We do this as we + * cannot know if our current update should specify the + * key repeated flag as we don't want to traverse the + * entire update chain to find out. i.e. if there is + * an update with our txnid after the reserved update + * we should set key repeated, but if there isn't we + * shouldn't. */ - if (upd->next != NULL && upd->txnid == upd->next->txnid) - F_SET(op, WT_TXN_OP_KEY_REPEATED); + if (upd->next != NULL && + upd->txnid == upd->next->txnid) { + if (upd->next->type == WT_UPDATE_RESERVE) + F_SET(op, WT_TXN_OP_KEY_RESERVED); + else + F_SET(op, WT_TXN_OP_KEY_REPEATED); + } break; case WT_TXN_OP_REF_DELETE: __wt_txn_op_apply_prepare_state( @@ -1209,12 +1235,13 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[]) WT_UPDATE *upd; int64_t resolved_update_count, visited_update_count; u_int i; - bool readonly; + bool readonly, skip_update_assert; WT_UNUSED(cfg); resolved_update_count = visited_update_count = 0; txn = &session->txn; readonly = txn->mod_count == 0; + skip_update_assert = false; WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING)); /* Rollback notification. */ @@ -1254,10 +1281,14 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[]) * it would have happened on a previous * modification in this txn. */ - if (!F_ISSET(op, WT_TXN_OP_KEY_REPEATED)) + if (!F_ISSET(op, WT_TXN_OP_KEY_REPEATED)) { + skip_update_assert = + skip_update_assert || + F_ISSET(op, WT_TXN_OP_KEY_RESERVED); WT_RET(__wt_txn_resolve_prepared_op( session, op, false, &resolved_update_count)); + } /* * We should resolve at least one or more * updates each time we call @@ -1290,7 +1321,8 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[]) __wt_txn_op_free(session, op); } - WT_ASSERT(session, resolved_update_count == visited_update_count); + WT_ASSERT(session, skip_update_assert || + resolved_update_count == visited_update_count); WT_STAT_CONN_INCRV(session, txn_prepared_updates_resolved, resolved_update_count); |