diff --git a/dist/stat_data.py b/dist/stat_data.py index e0e08207f..5eb67c426 100644 --- a/dist/stat_data.py +++ b/dist/stat_data.py @@ -287,8 +287,6 @@ connection_stats = [ CacheStat('cache_hazard_checks', 'hazard pointer check calls'), CacheStat('cache_hazard_max', 'hazard pointer maximum array length', 'max_aggregate,no_scale'), CacheStat('cache_hazard_walks', 'hazard pointer check entries walked'), - CacheStat('cache_hs_cursor_wait_application', 'history store cursor application thread wait time (usecs)'), - CacheStat('cache_hs_cursor_wait_internal', 'history store cursor internal thread wait time (usecs)'), CacheStat('cache_hs_insert', 'history store table insert calls'), CacheStat('cache_hs_ondisk', 'history store table on-disk size', 'no_clear,no_scale,size'), CacheStat('cache_hs_ondisk_max', 'history store table max on-disk size', 'no_clear,no_scale,size'), diff --git a/src/btree/bt_debug.c b/src/btree/bt_debug.c index dd96d489b..63d2cea91 100644 --- a/src/btree/bt_debug.c +++ b/src/btree/bt_debug.c @@ -703,18 +703,22 @@ int __wt_debug_cursor_hs(void *cursor_arg, const char *ofile) WT_GCC_FUNC_ATTRIBUTE((visibility("default"))) { - WT_CONNECTION_IMPL *conn; WT_CURSOR *cursor; WT_CURSOR_BTREE *cbt; - WT_SESSION_IMPL *hs_session; + WT_DECL_RET; + WT_SESSION_IMPL *session; + uint32_t session_flags; cursor = cursor_arg; - conn = S2C((WT_SESSION_IMPL *)cursor->session); - hs_session = conn->cache->hs_session[0]; - if (hs_session == NULL) - return (0); - cbt = (WT_CURSOR_BTREE *)hs_session->hs_cursor; - return (__wt_debug_tree_all(hs_session, cbt->btree, NULL, ofile)); + session = (WT_SESSION_IMPL *)cursor->session; + session_flags = 0; /* [-Werror=maybe-uninitialized] */ + + WT_RET(__wt_hs_cursor(session, &session_flags)); + cbt = (WT_CURSOR_BTREE *)session->hs_cursor; + ret = __wt_debug_tree_all(session, cbt->btree, NULL, ofile); + WT_TRET(__wt_hs_cursor_close(session, session_flags)); + + return (ret); } /* diff --git a/src/conn/conn_cache.c b/src/conn/conn_cache.c index 0d99f44e8..573095d51 100644 --- a/src/conn/conn_cache.c +++ b/src/conn/conn_cache.c @@ -238,8 +238,6 @@ __wt_cache_create(WT_SESSION_IMPL *session, const char *cfg[]) conn, "evict pass", false, WT_SESSION_NO_DATA_HANDLES, &cache->walk_session)) != 0) WT_RET_MSG(NULL, ret, "Failed to create session for eviction walks"); - WT_RET(__wt_spin_init(session, &cache->hs_lock, "history store table")); - /* Allocate the LRU eviction queue. */ cache->evict_slots = WT_EVICT_WALK_BASE + WT_EVICT_WALK_INCR; for (i = 0; i < WT_EVICT_QUEUE_MAX; ++i) { @@ -364,7 +362,6 @@ __wt_cache_destroy(WT_SESSION_IMPL *session) __wt_spin_destroy(session, &cache->evict_pass_lock); __wt_spin_destroy(session, &cache->evict_queue_lock); __wt_spin_destroy(session, &cache->evict_walk_lock); - __wt_spin_destroy(session, &cache->hs_lock); wt_session = &cache->walk_session->iface; if (wt_session != NULL) WT_TRET(wt_session->close(wt_session, NULL)); diff --git a/src/conn/conn_dhandle.c b/src/conn/conn_dhandle.c index edf876d42..0fd648aa4 100644 --- a/src/conn/conn_dhandle.c +++ b/src/conn/conn_dhandle.c @@ -782,7 +782,7 @@ restart: } /* Shut down the history store table after all eviction is complete. */ - WT_TRET(__wt_hs_destroy(session)); + __wt_hs_destroy(session); /* * Closing the files may have resulted in entries on our default session's list of open data diff --git a/src/conn/conn_sweep.c b/src/conn/conn_sweep.c index 863ffab3d..b5a270af3 100644 --- a/src/conn/conn_sweep.c +++ b/src/conn/conn_sweep.c @@ -389,13 +389,6 @@ __wt_sweep_create(WT_SESSION_IMPL *session) __wt_open_internal_session(conn, "sweep-server", true, session_flags, &conn->sweep_session)); session = conn->sweep_session; - /* - * Sweep should have it's own history store cursor to avoid blocking reads and eviction when - * processing drops. - */ - if (F_ISSET(conn, WT_CONN_HS_OPEN)) - WT_RET(__wt_hs_cursor_open(session)); - WT_RET(__wt_cond_alloc(session, "handle sweep server", &conn->sweep_cond)); WT_RET(__wt_thread_create(session, &conn->sweep_tid, __sweep_server, session)); diff --git a/src/cursor/cur_file.c b/src/cursor/cur_file.c index 32adec887..cce07a661 100644 --- a/src/cursor/cur_file.c +++ b/src/cursor/cur_file.c @@ -720,8 +720,11 @@ __curfile_create(WT_SESSION_IMPL *session, WT_CURSOR *owner, const char *cfg[], /* * WiredTiger.wt should not be cached, doing so interferes with named checkpoints. + * WiredTigerHS.wt should not be cached <-- Needs a discussion whether we should cache HS + * cursors. */ - if (cacheable && strcmp(WT_METAFILE_URI, cursor->internal_uri) != 0) + if (cacheable && strcmp(WT_METAFILE_URI, cursor->internal_uri) != 0 && + strcmp(WT_HS_URI, cursor->internal_uri) != 0) F_SET(cursor, WT_CURSTD_CACHEABLE); WT_ERR(__wt_cursor_init(cursor, cursor->internal_uri, owner, cfg, cursorp)); diff --git a/src/history/hs.c b/src/history/hs.c index 8a7dc9a52..2ac674080 100644 --- a/src/history/hs.c +++ b/src/history/hs.c @@ -14,27 +14,6 @@ */ #define WT_HS_SESSION_FLAGS (WT_SESSION_IGNORE_CACHE_SIZE | WT_SESSION_NO_RECONCILE) -/* - * __hs_set_isolation -- - * Switch to read-uncommitted. - */ -static void -__hs_set_isolation(WT_SESSION_IMPL *session, WT_TXN_ISOLATION *saved_isolationp) -{ - *saved_isolationp = session->txn.isolation; - session->txn.isolation = WT_ISO_READ_UNCOMMITTED; -} - -/* - * __hs_restore_isolation -- - * Restore isolation. - */ -static void -__hs_restore_isolation(WT_SESSION_IMPL *session, WT_TXN_ISOLATION saved_isolation) -{ - session->txn.isolation = saved_isolation; -} - /* * __hs_store_time_pair -- * Store the time pair to use for the history store inserts. @@ -53,9 +32,42 @@ __hs_store_time_pair(WT_SESSION_IMPL *session, wt_timestamp_t timestamp, uint64_ int __wt_hs_config(WT_SESSION_IMPL *session, const char **cfg) { + WT_BTREE *btree; WT_CONFIG_ITEM cval; + WT_CONNECTION_IMPL *conn; WT_CURSOR_BTREE *hs_cursor; - WT_SESSION_IMPL *hs_session; + uint32_t session_flags; + + session_flags = 0; /* [-Werror=maybe-uninitialized] */ + + conn = S2C(session); + + /* We shouldn't get here with in-memory or readonly configurations. */ + WT_ASSERT(session, !F_ISSET(conn, WT_CONN_IN_MEMORY | WT_CONN_READONLY)); + + WT_RET(__wt_hs_cursor(session, &session_flags)); + hs_cursor = (WT_CURSOR_BTREE *)session->hs_cursor; + + /* Retrieve the btree from the cursor, rather than the session. */ + btree = hs_cursor->btree; + + WT_IGNORE_RET(__wt_hs_cursor_close(session, session_flags)); + + /* Track the history store file ID. */ + if (conn->cache->hs_fileid == 0) + conn->cache->hs_fileid = btree->id; + + /* + * Set special flags for the history store table: the history store flag (used, for example, to + * avoid writing records during reconciliation), also turn off checkpoints and logging. + * + * Test flags before setting them so updates can't race in subsequent opens (the first update is + * safe because it's single-threaded from wiredtiger_open). + */ + if (!F_ISSET(btree, WT_BTREE_HS)) + F_SET(btree, WT_BTREE_HS); + if (!F_ISSET(btree, WT_BTREE_NO_LOGGING)) + F_SET(btree, WT_BTREE_NO_LOGGING); WT_RET(__wt_config_gets(session, cfg, "history_store.file_max", &cval)); @@ -63,20 +75,11 @@ __wt_hs_config(WT_SESSION_IMPL *session, const char **cfg) WT_RET_MSG(session, EINVAL, "max history store size %" PRId64 " below minimum %d", cval.val, WT_HS_FILE_MIN); - /* This is expected for in-memory configurations. */ - hs_session = S2C(session)->cache->hs_session[0]; - WT_ASSERT(session, hs_session != NULL || F_ISSET(S2C(session), WT_CONN_IN_MEMORY)); - - if (hs_session == NULL) - return (0); - /* * We need to set file_max on the btree associated with one of the history store sessions. */ - hs_cursor = (WT_CURSOR_BTREE *)hs_session->hs_cursor; - hs_cursor->btree->file_max = (uint64_t)cval.val; - - WT_STAT_CONN_SET(session, cache_hs_ondisk_max, hs_cursor->btree->file_max); + btree->file_max = (uint64_t)cval.val; + WT_STAT_CONN_SET(session, cache_hs_ondisk_max, btree->file_max); return (0); } @@ -88,14 +91,16 @@ __wt_hs_config(WT_SESSION_IMPL *session, const char **cfg) void __wt_hs_stats_update(WT_SESSION_IMPL *session) { - WT_CACHE *cache; WT_CONNECTION_IMPL *conn; WT_CONNECTION_STATS **cstats; + WT_DECL_RET; WT_DSRC_STATS **dstats; int64_t v; + uint32_t session_flags; + + session_flags = 0; /* [-Werror=maybe-uninitialized] */ conn = S2C(session); - cache = conn->cache; /* * History store table statistics are copied from the underlying history store table data-source @@ -108,10 +113,13 @@ __wt_hs_stats_update(WT_SESSION_IMPL *session) cstats = conn->stats; /* - * We have a cursor, and we need the underlying data handle; we can get to it by way of the - * underlying btree handle, but it's a little ugly. + * Get a history store cursor, we need the underlying data handle; we can get to it by way of + * the underlying btree handle, but it's a little ugly. */ - dstats = ((WT_CURSOR_BTREE *)cache->hs_session[0]->hs_cursor)->btree->dhandle->stats; + ret = __wt_hs_cursor(session, &session_flags); + if (ret != 0) + return; /* We should report an error ?? */ + dstats = ((WT_CURSOR_BTREE *)session->hs_cursor)->btree->dhandle->stats; v = WT_STAT_READ(dstats, cursor_update); WT_STAT_SET(session, cstats, cache_hs_insert, v); @@ -125,6 +133,7 @@ __wt_hs_stats_update(WT_SESSION_IMPL *session) WT_STAT_SET(session, dstats, cursor_update, 0); WT_STAT_SET(session, dstats, cursor_remove, 0); } + WT_IGNORE_RET(__wt_hs_cursor_close(session, session_flags)); } /* @@ -134,12 +143,9 @@ __wt_hs_stats_update(WT_SESSION_IMPL *session) int __wt_hs_create(WT_SESSION_IMPL *session, const char **cfg) { - WT_CACHE *cache; WT_CONNECTION_IMPL *conn; - int i; conn = S2C(session); - cache = conn->cache; /* Read-only and in-memory configurations don't need the history store table. */ if (F_ISSET(conn, WT_CONN_IN_MEMORY | WT_CONN_READONLY)) @@ -148,16 +154,6 @@ __wt_hs_create(WT_SESSION_IMPL *session, const char **cfg) /* Re-create the table. */ WT_RET(__wt_session_create(session, WT_HS_URI, WT_HS_CONFIG)); - /* - * Open a shared internal session and cursor used for the history store table. This session - * should never perform reconciliation. - */ - for (i = 0; i < WT_HS_NUM_SESSIONS; i++) { - WT_RET(__wt_open_internal_session( - conn, "history store table", true, WT_HS_SESSION_FLAGS, &cache->hs_session[i])); - WT_RET(__wt_hs_cursor_open(cache->hs_session[i])); - } - WT_RET(__wt_hs_config(session, cfg)); /* The statistics server is already running, make sure we don't race. */ @@ -171,32 +167,10 @@ __wt_hs_create(WT_SESSION_IMPL *session, const char **cfg) * __wt_hs_destroy -- * Destroy the database's history store. */ -int +void __wt_hs_destroy(WT_SESSION_IMPL *session) { - WT_CACHE *cache; - WT_CONNECTION_IMPL *conn; - WT_DECL_RET; - WT_SESSION *wt_session; - int i; - - conn = S2C(session); - cache = conn->cache; - - F_CLR(conn, WT_CONN_HS_OPEN); - if (cache == NULL) - return (0); - - for (i = 0; i < WT_HS_NUM_SESSIONS; i++) { - if (cache->hs_session[i] == NULL) - continue; - - wt_session = &cache->hs_session[i]->iface; - WT_TRET(wt_session->close(wt_session, NULL)); - cache->hs_session[i] = NULL; - } - - return (ret); + F_CLR(S2C(session), WT_CONN_HS_OPEN); } /* @@ -206,7 +180,6 @@ __wt_hs_destroy(WT_SESSION_IMPL *session) int __wt_hs_cursor_open(WT_SESSION_IMPL *session) { - WT_BTREE *btree; WT_CURSOR *cursor; WT_DECL_RET; const char *open_cursor_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_open_cursor), NULL}; @@ -215,28 +188,6 @@ __wt_hs_cursor_open(WT_SESSION_IMPL *session) session, ret = __wt_open_cursor(session, WT_HS_URI, NULL, open_cursor_cfg, &cursor)); WT_RET(ret); - /* - * Retrieve the btree from the cursor, rather than the session because we don't always switch - * the store history handle in to the session before entering this function. - */ - btree = ((WT_CURSOR_BTREE *)cursor)->btree; - - /* Track the history store file ID. */ - if (S2C(session)->cache->hs_fileid == 0) - S2C(session)->cache->hs_fileid = btree->id; - - /* - * Set special flags for the history store table: the history store flag (used, for example, to - * avoid writing records during reconciliation), also turn off checkpoints and logging. - * - * Test flags before setting them so updates can't race in subsequent opens (the first update is - * safe because it's single-threaded from wiredtiger_open). - */ - if (!F_ISSET(btree, WT_BTREE_HS)) - F_SET(btree, WT_BTREE_HS); - if (!F_ISSET(btree, WT_BTREE_NO_LOGGING)) - F_SET(btree, WT_BTREE_NO_LOGGING); - session->hs_cursor = cursor; F_SET(session, WT_SESSION_HS_CURSOR); @@ -245,16 +196,11 @@ __wt_hs_cursor_open(WT_SESSION_IMPL *session) /* * __wt_hs_cursor -- - * Return a history store cursor. + * Return a history store cursor, open one if not already open. */ -void -__wt_hs_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags) +int +__wt_hs_cursor(WT_SESSION_IMPL *session, uint32_t *session_flags) { - WT_CACHE *cache; - int i; - - *cursorp = NULL; - /* * We don't want to get tapped for eviction after we start using the history store cursor; save * a copy of the current eviction state, we'll turn eviction off before we return. @@ -264,42 +210,16 @@ __wt_hs_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_ */ *session_flags = F_MASK(session, WT_HS_SESSION_FLAGS); - cache = S2C(session)->cache; + /* Open a cursor if this session doesn't already have one. */ + if (!F_ISSET(session, WT_SESSION_HS_CURSOR)) + WT_RET(__wt_hs_cursor_open(session)); - /* - * Some threads have their own history store table cursors, else lock the shared history store - * cursor. - */ - if (F_ISSET(session, WT_SESSION_HS_CURSOR)) - *cursorp = session->hs_cursor; - else { - for (;;) { - __wt_spin_lock(session, &cache->hs_lock); - for (i = 0; i < WT_HS_NUM_SESSIONS; i++) { - if (!cache->hs_session_inuse[i]) { - *cursorp = cache->hs_session[i]->hs_cursor; - cache->hs_session_inuse[i] = true; - break; - } - } - __wt_spin_unlock(session, &cache->hs_lock); - if (*cursorp != NULL) - break; - /* - * If all the history store sessions are busy, stall. - * - * XXX better as a condition variable. - */ - __wt_sleep(0, WT_THOUSAND); - if (F_ISSET(session, WT_SESSION_INTERNAL)) - WT_STAT_CONN_INCRV(session, cache_hs_cursor_wait_internal, WT_THOUSAND); - else - WT_STAT_CONN_INCRV(session, cache_hs_cursor_wait_application, WT_THOUSAND); - } - } + WT_ASSERT(session, session->hs_cursor != NULL); /* Configure session to access the history store table. */ F_SET(session, WT_HS_SESSION_FLAGS); + + return (0); } /* @@ -307,21 +227,14 @@ __wt_hs_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_ * Discard a history store cursor. */ int -__wt_hs_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t session_flags) +__wt_hs_cursor_close(WT_SESSION_IMPL *session, uint32_t session_flags) { - WT_CACHE *cache; - WT_CURSOR *cursor; - WT_DECL_RET; - int i; - - cache = S2C(session)->cache; - - if ((cursor = *cursorp) == NULL) + /* Nothing to do if the session doesn't have a HS cursor opened. */ + if (!F_ISSET(session, WT_SESSION_HS_CURSOR)) { + WT_ASSERT(session, session->hs_cursor == NULL); return (0); - *cursorp = NULL; - - /* Reset the cursor. */ - ret = cursor->reset(cursor); + } + WT_ASSERT(session, session->hs_cursor != NULL); /* * We turned off caching and eviction while the history store cursor was in use, restore the @@ -330,22 +243,11 @@ __wt_hs_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t ses F_CLR(session, WT_HS_SESSION_FLAGS); F_SET(session, session_flags); - /* - * Some threads have their own history store table cursors, else unlock the shared history store - * cursor. - */ - if (!F_ISSET(session, WT_SESSION_HS_CURSOR)) { - __wt_spin_lock(session, &cache->hs_lock); - for (i = 0; i < WT_HS_NUM_SESSIONS; i++) - if (cursor->session == &cache->hs_session[i]->iface) { - cache->hs_session_inuse[i] = false; - break; - } - __wt_spin_unlock(session, &cache->hs_lock); - WT_ASSERT(session, i != WT_HS_NUM_SESSIONS); - } + WT_RET(session->hs_cursor->close(session->hs_cursor)); + session->hs_cursor = NULL; + F_CLR(session, WT_SESSION_HS_CURSOR); - return (ret); + return (0); } /* @@ -492,7 +394,6 @@ __wt_hs_insert_updates(WT_CURSOR *cursor, WT_BTREE *btree, WT_RECONCILE *r, WT_M WT_PAGE *page; WT_SAVE_UPD *list; WT_SESSION_IMPL *session; - WT_TXN_ISOLATION saved_isolation; WT_UPDATE *prev_upd, *upd; WT_TIME_PAIR stop_ts_pair; wt_off_t hs_size; @@ -505,7 +406,6 @@ __wt_hs_insert_updates(WT_CURSOR *cursor, WT_BTREE *btree, WT_RECONCILE *r, WT_M page = r->page; prev_upd = NULL; session = (WT_SESSION_IMPL *)cursor->session; - saved_isolation = 0; /*[-Wconditional-uninitialized] */ insert_cnt = 0; btree_id = btree->id; local_txn = false; @@ -516,8 +416,6 @@ __wt_hs_insert_updates(WT_CURSOR *cursor, WT_BTREE *btree, WT_RECONCILE *r, WT_M /* Wrap all the updates in a transaction. */ WT_ERR(__wt_txn_begin(session, NULL)); - __hs_set_isolation(session, &saved_isolation); - local_txn = true; /* Ensure enough room for a column-store key without checking. */ @@ -756,12 +654,9 @@ err: ret = __wt_txn_commit(session, NULL); else WT_TRET(__wt_txn_rollback(session, NULL)); - __hs_restore_isolation(session, saved_isolation); F_CLR(cursor, WT_CURSTD_UPDATE_LOCAL); } - __hs_restore_isolation(session, saved_isolation); - if (ret == 0 && insert_cnt > 0) __hs_insert_updates_verbose(session, btree); @@ -887,7 +782,8 @@ __wt_find_hs_upd( WT_ERR(__wt_scr_alloc(session, 0, &hs_value)); /* Open a history store table cursor. */ - __wt_hs_cursor(session, &hs_cursor, &session_flags); + WT_ERR(__wt_hs_cursor(session, &session_flags)); + hs_cursor = session->hs_cursor; /* * After positioning our cursor, we're stepping backwards to find the correct update. Since the @@ -1042,7 +938,7 @@ err: __wt_scr_free(session, &hs_key); __wt_scr_free(session, &hs_value); - WT_TRET(__wt_hs_cursor_close(session, &hs_cursor, session_flags)); + WT_TRET(__wt_hs_cursor_close(session, session_flags)); __wt_free_update_list(session, &mod_upd); while (modifies.size > 0) { __wt_modify_vector_pop(&modifies, &upd); diff --git a/src/include/cache.h b/src/include/cache.h index 5bf478220..8e485eec8 100644 --- a/src/include/cache.h +++ b/src/include/cache.h @@ -55,7 +55,6 @@ typedef enum __wt_cache_op { } WT_CACHE_OP; #define WT_HS_FILE_MIN (100 * WT_MEGABYTE) -#define WT_HS_NUM_SESSIONS 5 /* * WiredTiger cache structure. @@ -184,15 +183,6 @@ struct __wt_cache { */ int32_t evict_hs_score; - /* - * Shared history store lock, session and cursor, used by threads accessing the history store - * table (other than eviction server and worker threads, all of which have their own history - * store cursors). - */ - WT_SPINLOCK hs_lock; - WT_SESSION_IMPL *hs_session[WT_HS_NUM_SESSIONS]; - bool hs_session_inuse[WT_HS_NUM_SESSIONS]; - uint32_t hs_fileid; /* History store table file ID */ /* diff --git a/src/include/extern.h b/src/include/extern.h index 767d1e48f..fe1c8f774 100644 --- a/src/include/extern.h +++ b/src/include/extern.h @@ -739,14 +739,14 @@ extern int __wt_hs_config(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_hs_create(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_hs_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, - uint32_t session_flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_hs_cursor(WT_SESSION_IMPL *session, uint32_t *session_flags) + WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); +extern int __wt_hs_cursor_close(WT_SESSION_IMPL *session, uint32_t session_flags) + WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_hs_cursor_open(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_hs_cursor_position(WT_SESSION_IMPL *session, WT_CURSOR *cursor, uint32_t btree_id, WT_ITEM *key, wt_timestamp_t timestamp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); -extern int __wt_hs_destroy(WT_SESSION_IMPL *session) - WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_hs_insert_updates(WT_CURSOR *cursor, WT_BTREE *btree, WT_RECONCILE *r, WT_MULTI *multi) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result)); extern int __wt_huffman_decode(WT_SESSION_IMPL *session, void *huffman_arg, const uint8_t *from_arg, @@ -1646,7 +1646,7 @@ extern void __wt_gen_drain(WT_SESSION_IMPL *session, int which, uint64_t generat extern void __wt_gen_init(WT_SESSION_IMPL *session); extern void __wt_gen_next_drain(WT_SESSION_IMPL *session, int which); extern void __wt_hazard_close(WT_SESSION_IMPL *session); -extern void __wt_hs_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags); +extern void __wt_hs_destroy(WT_SESSION_IMPL *session); extern void __wt_hs_stats_update(WT_SESSION_IMPL *session); extern void __wt_huffman_close(WT_SESSION_IMPL *session, void *huffman_arg); extern void __wt_json_close(WT_SESSION_IMPL *session, WT_CURSOR *cursor); diff --git a/src/include/stat.h b/src/include/stat.h index f65fb35b9..125606f03 100644 --- a/src/include/stat.h +++ b/src/include/stat.h @@ -386,8 +386,6 @@ struct __wt_connection_stats { int64_t cache_hazard_checks; int64_t cache_hazard_walks; int64_t cache_hazard_max; - int64_t cache_hs_cursor_wait_application; - int64_t cache_hs_cursor_wait_internal; int64_t cache_hs_score; int64_t cache_hs_insert; int64_t cache_hs_ondisk_max; diff --git a/src/include/txn.i b/src/include/txn.i index cfb6431d1..7a3adbbec 100644 --- a/src/include/txn.i +++ b/src/include/txn.i @@ -867,6 +867,8 @@ __wt_txn_begin(WT_SESSION_IMPL *session, const char *cfg[]) txn->isolation = session->isolation; txn->txn_logsync = S2C(session)->txn_logsync; + WT_ASSERT(session, !F_ISSET(txn, WT_TXN_RUNNING)); + if (cfg != NULL) WT_RET(__wt_txn_config(session, cfg)); diff --git a/src/include/wiredtiger.in b/src/include/wiredtiger.in index 599a15ec8..1c8ea04fb 100644 --- a/src/include/wiredtiger.in +++ b/src/include/wiredtiger.in @@ -5107,699 +5107,695 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection); #define WT_STAT_CONN_CACHE_HAZARD_WALKS 1089 /*! cache: hazard pointer maximum array length */ #define WT_STAT_CONN_CACHE_HAZARD_MAX 1090 -/*! cache: history store cursor application thread wait time (usecs) */ -#define WT_STAT_CONN_CACHE_HS_CURSOR_WAIT_APPLICATION 1091 -/*! cache: history store cursor internal thread wait time (usecs) */ -#define WT_STAT_CONN_CACHE_HS_CURSOR_WAIT_INTERNAL 1092 /*! cache: history store score */ -#define WT_STAT_CONN_CACHE_HS_SCORE 1093 +#define WT_STAT_CONN_CACHE_HS_SCORE 1091 /*! cache: history store table insert calls */ -#define WT_STAT_CONN_CACHE_HS_INSERT 1094 +#define WT_STAT_CONN_CACHE_HS_INSERT 1092 /*! cache: history store table max on-disk size */ -#define WT_STAT_CONN_CACHE_HS_ONDISK_MAX 1095 +#define WT_STAT_CONN_CACHE_HS_ONDISK_MAX 1093 /*! cache: history store table on-disk size */ -#define WT_STAT_CONN_CACHE_HS_ONDISK 1096 +#define WT_STAT_CONN_CACHE_HS_ONDISK 1094 /*! cache: history store table reads */ -#define WT_STAT_CONN_CACHE_HS_READ 1097 +#define WT_STAT_CONN_CACHE_HS_READ 1095 /*! cache: history store table reads missed */ -#define WT_STAT_CONN_CACHE_HS_READ_MISS 1098 +#define WT_STAT_CONN_CACHE_HS_READ_MISS 1096 /*! cache: history store table reads requiring squashed modifies */ -#define WT_STAT_CONN_CACHE_HS_READ_SQUASH 1099 +#define WT_STAT_CONN_CACHE_HS_READ_SQUASH 1097 /*! cache: history store table writes requiring squashed modifies */ -#define WT_STAT_CONN_CACHE_HS_WRITE_SQUASH 1100 +#define WT_STAT_CONN_CACHE_HS_WRITE_SQUASH 1098 /*! cache: in-memory page passed criteria to be split */ -#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1101 +#define WT_STAT_CONN_CACHE_INMEM_SPLITTABLE 1099 /*! cache: in-memory page splits */ -#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1102 +#define WT_STAT_CONN_CACHE_INMEM_SPLIT 1100 /*! cache: internal pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1103 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL 1101 /*! cache: internal pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED 1104 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED 1102 /*! cache: internal pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN 1105 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN 1103 /*! cache: internal pages seen by eviction walk that are already queued */ -#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED 1106 +#define WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED 1104 /*! cache: internal pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1107 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL 1105 /*! cache: leaf pages split during eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1108 +#define WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF 1106 /*! cache: maximum bytes configured */ -#define WT_STAT_CONN_CACHE_BYTES_MAX 1109 +#define WT_STAT_CONN_CACHE_BYTES_MAX 1107 /*! cache: maximum page size at eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1110 +#define WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE 1108 /*! cache: modified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1111 +#define WT_STAT_CONN_CACHE_EVICTION_DIRTY 1109 /*! cache: modified pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1112 +#define WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY 1110 /*! cache: operations timed out waiting for space in cache */ -#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1113 +#define WT_STAT_CONN_CACHE_TIMED_OUT_OPS 1111 /*! cache: overflow pages read into cache */ -#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1114 +#define WT_STAT_CONN_CACHE_READ_OVERFLOW 1112 /*! cache: page split during eviction deepened the tree */ -#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1115 +#define WT_STAT_CONN_CACHE_EVICTION_DEEPEN 1113 /*! cache: page written requiring history store records */ -#define WT_STAT_CONN_CACHE_WRITE_HS 1116 +#define WT_STAT_CONN_CACHE_WRITE_HS 1114 /*! cache: pages currently held in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_INUSE 1117 +#define WT_STAT_CONN_CACHE_PAGES_INUSE 1115 /*! cache: pages evicted by application threads */ -#define WT_STAT_CONN_CACHE_EVICTION_APP 1118 +#define WT_STAT_CONN_CACHE_EVICTION_APP 1116 /*! cache: pages queued for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1119 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED 1117 /*! cache: pages queued for eviction post lru sorting */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU 1120 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU 1118 /*! cache: pages queued for urgent eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1121 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT 1119 /*! cache: pages queued for urgent eviction during walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1122 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST 1120 /*! cache: pages read into cache */ -#define WT_STAT_CONN_CACHE_READ 1123 +#define WT_STAT_CONN_CACHE_READ 1121 /*! cache: pages read into cache after truncate */ -#define WT_STAT_CONN_CACHE_READ_DELETED 1124 +#define WT_STAT_CONN_CACHE_READ_DELETED 1122 /*! cache: pages read into cache after truncate in prepare state */ -#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1125 +#define WT_STAT_CONN_CACHE_READ_DELETED_PREPARED 1123 /*! cache: pages requested from the cache */ -#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1126 +#define WT_STAT_CONN_CACHE_PAGES_REQUESTED 1124 /*! cache: pages seen by eviction walk */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1127 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN 1125 /*! cache: pages seen by eviction walk that are already queued */ -#define WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED 1128 +#define WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED 1126 /*! cache: pages selected for eviction unable to be evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1129 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL 1127 /*! * cache: pages selected for eviction unable to be evicted as the parent * page has overflow items */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS 1130 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS 1128 /*! * cache: pages selected for eviction unable to be evicted because of * active children on an internal page */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE 1131 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE 1129 /*! * cache: pages selected for eviction unable to be evicted because of * failure in reconciliation */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION 1132 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION 1130 /*! * cache: pages selected for eviction unable to be evicted due to newer * modifications on a clean page */ -#define WT_STAT_CONN_CACHE_EVICTION_FAIL_WITH_NEWER_MODIFICATIONS_ON_A_CLEAN_PAGE 1133 +#define WT_STAT_CONN_CACHE_EVICTION_FAIL_WITH_NEWER_MODIFICATIONS_ON_A_CLEAN_PAGE 1131 /*! cache: pages walked for eviction */ -#define WT_STAT_CONN_CACHE_EVICTION_WALK 1134 +#define WT_STAT_CONN_CACHE_EVICTION_WALK 1132 /*! cache: pages written from cache */ -#define WT_STAT_CONN_CACHE_WRITE 1135 +#define WT_STAT_CONN_CACHE_WRITE 1133 /*! cache: pages written requiring in-memory restoration */ -#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1136 +#define WT_STAT_CONN_CACHE_WRITE_RESTORE 1134 /*! cache: percentage overhead */ -#define WT_STAT_CONN_CACHE_OVERHEAD 1137 +#define WT_STAT_CONN_CACHE_OVERHEAD 1135 /*! cache: tracked bytes belonging to internal pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1138 +#define WT_STAT_CONN_CACHE_BYTES_INTERNAL 1136 /*! cache: tracked bytes belonging to leaf pages in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_LEAF 1139 +#define WT_STAT_CONN_CACHE_BYTES_LEAF 1137 /*! cache: tracked dirty bytes in the cache */ -#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1140 +#define WT_STAT_CONN_CACHE_BYTES_DIRTY 1138 /*! cache: tracked dirty pages in the cache */ -#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1141 +#define WT_STAT_CONN_CACHE_PAGES_DIRTY 1139 /*! cache: unmodified pages evicted */ -#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1142 +#define WT_STAT_CONN_CACHE_EVICTION_CLEAN 1140 /*! capacity: background fsync file handles considered */ -#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1143 +#define WT_STAT_CONN_FSYNC_ALL_FH_TOTAL 1141 /*! capacity: background fsync file handles synced */ -#define WT_STAT_CONN_FSYNC_ALL_FH 1144 +#define WT_STAT_CONN_FSYNC_ALL_FH 1142 /*! capacity: background fsync time (msecs) */ -#define WT_STAT_CONN_FSYNC_ALL_TIME 1145 +#define WT_STAT_CONN_FSYNC_ALL_TIME 1143 /*! capacity: bytes read */ -#define WT_STAT_CONN_CAPACITY_BYTES_READ 1146 +#define WT_STAT_CONN_CAPACITY_BYTES_READ 1144 /*! capacity: bytes written for checkpoint */ -#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1147 +#define WT_STAT_CONN_CAPACITY_BYTES_CKPT 1145 /*! capacity: bytes written for eviction */ -#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1148 +#define WT_STAT_CONN_CAPACITY_BYTES_EVICT 1146 /*! capacity: bytes written for log */ -#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1149 +#define WT_STAT_CONN_CAPACITY_BYTES_LOG 1147 /*! capacity: bytes written total */ -#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1150 +#define WT_STAT_CONN_CAPACITY_BYTES_WRITTEN 1148 /*! capacity: threshold to call fsync */ -#define WT_STAT_CONN_CAPACITY_THRESHOLD 1151 +#define WT_STAT_CONN_CAPACITY_THRESHOLD 1149 /*! capacity: time waiting due to total capacity (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1152 +#define WT_STAT_CONN_CAPACITY_TIME_TOTAL 1150 /*! capacity: time waiting during checkpoint (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1153 +#define WT_STAT_CONN_CAPACITY_TIME_CKPT 1151 /*! capacity: time waiting during eviction (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1154 +#define WT_STAT_CONN_CAPACITY_TIME_EVICT 1152 /*! capacity: time waiting during logging (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_LOG 1155 +#define WT_STAT_CONN_CAPACITY_TIME_LOG 1153 /*! capacity: time waiting during read (usecs) */ -#define WT_STAT_CONN_CAPACITY_TIME_READ 1156 +#define WT_STAT_CONN_CAPACITY_TIME_READ 1154 /*! connection: auto adjusting condition resets */ -#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1157 +#define WT_STAT_CONN_COND_AUTO_WAIT_RESET 1155 /*! connection: auto adjusting condition wait calls */ -#define WT_STAT_CONN_COND_AUTO_WAIT 1158 +#define WT_STAT_CONN_COND_AUTO_WAIT 1156 /*! connection: detected system time went backwards */ -#define WT_STAT_CONN_TIME_TRAVEL 1159 +#define WT_STAT_CONN_TIME_TRAVEL 1157 /*! connection: files currently open */ -#define WT_STAT_CONN_FILE_OPEN 1160 +#define WT_STAT_CONN_FILE_OPEN 1158 /*! connection: memory allocations */ -#define WT_STAT_CONN_MEMORY_ALLOCATION 1161 +#define WT_STAT_CONN_MEMORY_ALLOCATION 1159 /*! connection: memory frees */ -#define WT_STAT_CONN_MEMORY_FREE 1162 +#define WT_STAT_CONN_MEMORY_FREE 1160 /*! connection: memory re-allocations */ -#define WT_STAT_CONN_MEMORY_GROW 1163 +#define WT_STAT_CONN_MEMORY_GROW 1161 /*! connection: pthread mutex condition wait calls */ -#define WT_STAT_CONN_COND_WAIT 1164 +#define WT_STAT_CONN_COND_WAIT 1162 /*! connection: pthread mutex shared lock read-lock calls */ -#define WT_STAT_CONN_RWLOCK_READ 1165 +#define WT_STAT_CONN_RWLOCK_READ 1163 /*! connection: pthread mutex shared lock write-lock calls */ -#define WT_STAT_CONN_RWLOCK_WRITE 1166 +#define WT_STAT_CONN_RWLOCK_WRITE 1164 /*! connection: total fsync I/Os */ -#define WT_STAT_CONN_FSYNC_IO 1167 +#define WT_STAT_CONN_FSYNC_IO 1165 /*! connection: total read I/Os */ -#define WT_STAT_CONN_READ_IO 1168 +#define WT_STAT_CONN_READ_IO 1166 /*! connection: total write I/Os */ -#define WT_STAT_CONN_WRITE_IO 1169 +#define WT_STAT_CONN_WRITE_IO 1167 /*! cursor: cached cursor count */ -#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1170 +#define WT_STAT_CONN_CURSOR_CACHED_COUNT 1168 /*! cursor: cursor bulk loaded cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT_BULK 1171 +#define WT_STAT_CONN_CURSOR_INSERT_BULK 1169 /*! cursor: cursor close calls that result in cache */ -#define WT_STAT_CONN_CURSOR_CACHE 1172 +#define WT_STAT_CONN_CURSOR_CACHE 1170 /*! cursor: cursor create calls */ -#define WT_STAT_CONN_CURSOR_CREATE 1173 +#define WT_STAT_CONN_CURSOR_CREATE 1171 /*! cursor: cursor insert calls */ -#define WT_STAT_CONN_CURSOR_INSERT 1174 +#define WT_STAT_CONN_CURSOR_INSERT 1172 /*! cursor: cursor insert key and value bytes */ -#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1175 +#define WT_STAT_CONN_CURSOR_INSERT_BYTES 1173 /*! cursor: cursor modify calls */ -#define WT_STAT_CONN_CURSOR_MODIFY 1176 +#define WT_STAT_CONN_CURSOR_MODIFY 1174 /*! cursor: cursor modify key and value bytes affected */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1177 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES 1175 /*! cursor: cursor modify value bytes modified */ -#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1178 +#define WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH 1176 /*! cursor: cursor next calls */ -#define WT_STAT_CONN_CURSOR_NEXT 1179 +#define WT_STAT_CONN_CURSOR_NEXT 1177 /*! cursor: cursor operation restarted */ -#define WT_STAT_CONN_CURSOR_RESTART 1180 +#define WT_STAT_CONN_CURSOR_RESTART 1178 /*! cursor: cursor prev calls */ -#define WT_STAT_CONN_CURSOR_PREV 1181 +#define WT_STAT_CONN_CURSOR_PREV 1179 /*! cursor: cursor remove calls */ -#define WT_STAT_CONN_CURSOR_REMOVE 1182 +#define WT_STAT_CONN_CURSOR_REMOVE 1180 /*! cursor: cursor remove key bytes removed */ -#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1183 +#define WT_STAT_CONN_CURSOR_REMOVE_BYTES 1181 /*! cursor: cursor reserve calls */ -#define WT_STAT_CONN_CURSOR_RESERVE 1184 +#define WT_STAT_CONN_CURSOR_RESERVE 1182 /*! cursor: cursor reset calls */ -#define WT_STAT_CONN_CURSOR_RESET 1185 +#define WT_STAT_CONN_CURSOR_RESET 1183 /*! cursor: cursor search calls */ -#define WT_STAT_CONN_CURSOR_SEARCH 1186 +#define WT_STAT_CONN_CURSOR_SEARCH 1184 /*! cursor: cursor search near calls */ -#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1187 +#define WT_STAT_CONN_CURSOR_SEARCH_NEAR 1185 /*! cursor: cursor sweep buckets */ -#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1188 +#define WT_STAT_CONN_CURSOR_SWEEP_BUCKETS 1186 /*! cursor: cursor sweep cursors closed */ -#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1189 +#define WT_STAT_CONN_CURSOR_SWEEP_CLOSED 1187 /*! cursor: cursor sweep cursors examined */ -#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1190 +#define WT_STAT_CONN_CURSOR_SWEEP_EXAMINED 1188 /*! cursor: cursor sweeps */ -#define WT_STAT_CONN_CURSOR_SWEEP 1191 +#define WT_STAT_CONN_CURSOR_SWEEP 1189 /*! cursor: cursor truncate calls */ -#define WT_STAT_CONN_CURSOR_TRUNCATE 1192 +#define WT_STAT_CONN_CURSOR_TRUNCATE 1190 /*! cursor: cursor update calls */ -#define WT_STAT_CONN_CURSOR_UPDATE 1193 +#define WT_STAT_CONN_CURSOR_UPDATE 1191 /*! cursor: cursor update key and value bytes */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1194 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES 1192 /*! cursor: cursor update value size change */ -#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1195 +#define WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED 1193 /*! cursor: cursors reused from cache */ -#define WT_STAT_CONN_CURSOR_REOPEN 1196 +#define WT_STAT_CONN_CURSOR_REOPEN 1194 /*! cursor: open cursor count */ -#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1197 +#define WT_STAT_CONN_CURSOR_OPEN_COUNT 1195 /*! data-handle: connection data handle size */ -#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1198 +#define WT_STAT_CONN_DH_CONN_HANDLE_SIZE 1196 /*! data-handle: connection data handles currently active */ -#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1199 +#define WT_STAT_CONN_DH_CONN_HANDLE_COUNT 1197 /*! data-handle: connection sweep candidate became referenced */ -#define WT_STAT_CONN_DH_SWEEP_REF 1200 +#define WT_STAT_CONN_DH_SWEEP_REF 1198 /*! data-handle: connection sweep dhandles closed */ -#define WT_STAT_CONN_DH_SWEEP_CLOSE 1201 +#define WT_STAT_CONN_DH_SWEEP_CLOSE 1199 /*! data-handle: connection sweep dhandles removed from hash list */ -#define WT_STAT_CONN_DH_SWEEP_REMOVE 1202 +#define WT_STAT_CONN_DH_SWEEP_REMOVE 1200 /*! data-handle: connection sweep time-of-death sets */ -#define WT_STAT_CONN_DH_SWEEP_TOD 1203 +#define WT_STAT_CONN_DH_SWEEP_TOD 1201 /*! data-handle: connection sweeps */ -#define WT_STAT_CONN_DH_SWEEPS 1204 +#define WT_STAT_CONN_DH_SWEEPS 1202 /*! data-handle: session dhandles swept */ -#define WT_STAT_CONN_DH_SESSION_HANDLES 1205 +#define WT_STAT_CONN_DH_SESSION_HANDLES 1203 /*! data-handle: session sweep attempts */ -#define WT_STAT_CONN_DH_SESSION_SWEEPS 1206 +#define WT_STAT_CONN_DH_SESSION_SWEEPS 1204 /*! history: history pages added for eviction during garbage collection */ -#define WT_STAT_CONN_HS_GC_PAGES_EVICT 1207 +#define WT_STAT_CONN_HS_GC_PAGES_EVICT 1205 /*! history: history pages removed for garbage collection */ -#define WT_STAT_CONN_HS_GC_PAGES_REMOVED 1208 +#define WT_STAT_CONN_HS_GC_PAGES_REMOVED 1206 /*! history: history pages visited for garbage collection */ -#define WT_STAT_CONN_HS_GC_PAGES_VISITED 1209 +#define WT_STAT_CONN_HS_GC_PAGES_VISITED 1207 /*! lock: checkpoint lock acquisitions */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1210 +#define WT_STAT_CONN_LOCK_CHECKPOINT_COUNT 1208 /*! lock: checkpoint lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1211 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION 1209 /*! lock: checkpoint lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1212 +#define WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL 1210 /*! lock: dhandle lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1213 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION 1211 /*! lock: dhandle lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1214 +#define WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL 1212 /*! lock: dhandle read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1215 +#define WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT 1213 /*! lock: dhandle write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1216 +#define WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT 1214 /*! * lock: durable timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION 1217 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION 1215 /*! * lock: durable timestamp queue lock internal thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL 1218 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL 1216 /*! lock: durable timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT 1219 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT 1217 /*! lock: durable timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT 1220 +#define WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT 1218 /*! lock: metadata lock acquisitions */ -#define WT_STAT_CONN_LOCK_METADATA_COUNT 1221 +#define WT_STAT_CONN_LOCK_METADATA_COUNT 1219 /*! lock: metadata lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1222 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION 1220 /*! lock: metadata lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1223 +#define WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL 1221 /*! * lock: read timestamp queue lock application thread time waiting * (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1224 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION 1222 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1225 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL 1223 /*! lock: read timestamp queue read lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1226 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT 1224 /*! lock: read timestamp queue write lock acquisitions */ -#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1227 +#define WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT 1225 /*! lock: schema lock acquisitions */ -#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1228 +#define WT_STAT_CONN_LOCK_SCHEMA_COUNT 1226 /*! lock: schema lock application thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1229 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION 1227 /*! lock: schema lock internal thread wait time (usecs) */ -#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1230 +#define WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL 1228 /*! * lock: table lock application thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1231 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION 1229 /*! * lock: table lock internal thread time waiting for the table lock * (usecs) */ -#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1232 +#define WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL 1230 /*! lock: table read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1233 +#define WT_STAT_CONN_LOCK_TABLE_READ_COUNT 1231 /*! lock: table write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1234 +#define WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT 1232 /*! lock: txn global lock application thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1235 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION 1233 /*! lock: txn global lock internal thread time waiting (usecs) */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1236 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL 1234 /*! lock: txn global read lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1237 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT 1235 /*! lock: txn global write lock acquisitions */ -#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1238 +#define WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT 1236 /*! log: busy returns attempting to switch slots */ -#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1239 +#define WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY 1237 /*! log: force archive time sleeping (usecs) */ -#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1240 +#define WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP 1238 /*! log: log bytes of payload data */ -#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1241 +#define WT_STAT_CONN_LOG_BYTES_PAYLOAD 1239 /*! log: log bytes written */ -#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1242 +#define WT_STAT_CONN_LOG_BYTES_WRITTEN 1240 /*! log: log files manually zero-filled */ -#define WT_STAT_CONN_LOG_ZERO_FILLS 1243 +#define WT_STAT_CONN_LOG_ZERO_FILLS 1241 /*! log: log flush operations */ -#define WT_STAT_CONN_LOG_FLUSH 1244 +#define WT_STAT_CONN_LOG_FLUSH 1242 /*! log: log force write operations */ -#define WT_STAT_CONN_LOG_FORCE_WRITE 1245 +#define WT_STAT_CONN_LOG_FORCE_WRITE 1243 /*! log: log force write operations skipped */ -#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1246 +#define WT_STAT_CONN_LOG_FORCE_WRITE_SKIP 1244 /*! log: log records compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1247 +#define WT_STAT_CONN_LOG_COMPRESS_WRITES 1245 /*! log: log records not compressed */ -#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1248 +#define WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS 1246 /*! log: log records too small to compress */ -#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1249 +#define WT_STAT_CONN_LOG_COMPRESS_SMALL 1247 /*! log: log release advances write LSN */ -#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1250 +#define WT_STAT_CONN_LOG_RELEASE_WRITE_LSN 1248 /*! log: log scan operations */ -#define WT_STAT_CONN_LOG_SCANS 1251 +#define WT_STAT_CONN_LOG_SCANS 1249 /*! log: log scan records requiring two reads */ -#define WT_STAT_CONN_LOG_SCAN_REREADS 1252 +#define WT_STAT_CONN_LOG_SCAN_REREADS 1250 /*! log: log server thread advances write LSN */ -#define WT_STAT_CONN_LOG_WRITE_LSN 1253 +#define WT_STAT_CONN_LOG_WRITE_LSN 1251 /*! log: log server thread write LSN walk skipped */ -#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1254 +#define WT_STAT_CONN_LOG_WRITE_LSN_SKIP 1252 /*! log: log sync operations */ -#define WT_STAT_CONN_LOG_SYNC 1255 +#define WT_STAT_CONN_LOG_SYNC 1253 /*! log: log sync time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DURATION 1256 +#define WT_STAT_CONN_LOG_SYNC_DURATION 1254 /*! log: log sync_dir operations */ -#define WT_STAT_CONN_LOG_SYNC_DIR 1257 +#define WT_STAT_CONN_LOG_SYNC_DIR 1255 /*! log: log sync_dir time duration (usecs) */ -#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1258 +#define WT_STAT_CONN_LOG_SYNC_DIR_DURATION 1256 /*! log: log write operations */ -#define WT_STAT_CONN_LOG_WRITES 1259 +#define WT_STAT_CONN_LOG_WRITES 1257 /*! log: logging bytes consolidated */ -#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1260 +#define WT_STAT_CONN_LOG_SLOT_CONSOLIDATED 1258 /*! log: maximum log file size */ -#define WT_STAT_CONN_LOG_MAX_FILESIZE 1261 +#define WT_STAT_CONN_LOG_MAX_FILESIZE 1259 /*! log: number of pre-allocated log files to create */ -#define WT_STAT_CONN_LOG_PREALLOC_MAX 1262 +#define WT_STAT_CONN_LOG_PREALLOC_MAX 1260 /*! log: pre-allocated log files not ready and missed */ -#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1263 +#define WT_STAT_CONN_LOG_PREALLOC_MISSED 1261 /*! log: pre-allocated log files prepared */ -#define WT_STAT_CONN_LOG_PREALLOC_FILES 1264 +#define WT_STAT_CONN_LOG_PREALLOC_FILES 1262 /*! log: pre-allocated log files used */ -#define WT_STAT_CONN_LOG_PREALLOC_USED 1265 +#define WT_STAT_CONN_LOG_PREALLOC_USED 1263 /*! log: records processed by log scan */ -#define WT_STAT_CONN_LOG_SCAN_RECORDS 1266 +#define WT_STAT_CONN_LOG_SCAN_RECORDS 1264 /*! log: slot close lost race */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1267 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_RACE 1265 /*! log: slot close unbuffered waits */ -#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1268 +#define WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF 1266 /*! log: slot closures */ -#define WT_STAT_CONN_LOG_SLOT_CLOSES 1269 +#define WT_STAT_CONN_LOG_SLOT_CLOSES 1267 /*! log: slot join atomic update races */ -#define WT_STAT_CONN_LOG_SLOT_RACES 1270 +#define WT_STAT_CONN_LOG_SLOT_RACES 1268 /*! log: slot join calls atomic updates raced */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1271 +#define WT_STAT_CONN_LOG_SLOT_YIELD_RACE 1269 /*! log: slot join calls did not yield */ -#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1272 +#define WT_STAT_CONN_LOG_SLOT_IMMEDIATE 1270 /*! log: slot join calls found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1273 +#define WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE 1271 /*! log: slot join calls slept */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1274 +#define WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP 1272 /*! log: slot join calls yielded */ -#define WT_STAT_CONN_LOG_SLOT_YIELD 1275 +#define WT_STAT_CONN_LOG_SLOT_YIELD 1273 /*! log: slot join found active slot closed */ -#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1276 +#define WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED 1274 /*! log: slot joins yield time (usecs) */ -#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1277 +#define WT_STAT_CONN_LOG_SLOT_YIELD_DURATION 1275 /*! log: slot transitions unable to find free slot */ -#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1278 +#define WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS 1276 /*! log: slot unbuffered writes */ -#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1279 +#define WT_STAT_CONN_LOG_SLOT_UNBUFFERED 1277 /*! log: total in-memory size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_MEM 1280 +#define WT_STAT_CONN_LOG_COMPRESS_MEM 1278 /*! log: total log buffer size */ -#define WT_STAT_CONN_LOG_BUFFER_SIZE 1281 +#define WT_STAT_CONN_LOG_BUFFER_SIZE 1279 /*! log: total size of compressed records */ -#define WT_STAT_CONN_LOG_COMPRESS_LEN 1282 +#define WT_STAT_CONN_LOG_COMPRESS_LEN 1280 /*! log: written slots coalesced */ -#define WT_STAT_CONN_LOG_SLOT_COALESCED 1283 +#define WT_STAT_CONN_LOG_SLOT_COALESCED 1281 /*! log: yields waiting for previous log file close */ -#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1284 +#define WT_STAT_CONN_LOG_CLOSE_YIELDS 1282 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1285 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 1283 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1286 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 1284 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1287 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 1285 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1288 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 1286 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1289 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 1287 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1290 +#define WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 1288 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1291 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 1289 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1292 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 1290 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1293 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 1291 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1294 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 1292 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1295 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 1293 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */ -#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1296 +#define WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 1294 /*! perf: operation read latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1297 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 1295 /*! perf: operation read latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1298 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 1296 /*! perf: operation read latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1299 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 1297 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1300 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 1298 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1301 +#define WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 1299 /*! perf: operation write latency histogram (bucket 1) - 100-249us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1302 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 1300 /*! perf: operation write latency histogram (bucket 2) - 250-499us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1303 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 1301 /*! perf: operation write latency histogram (bucket 3) - 500-999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1304 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 1302 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1305 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 1303 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */ -#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1306 +#define WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 1304 /*! reconciliation: fast-path pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1307 +#define WT_STAT_CONN_REC_PAGE_DELETE_FAST 1305 /*! reconciliation: page reconciliation calls */ -#define WT_STAT_CONN_REC_PAGES 1308 +#define WT_STAT_CONN_REC_PAGES 1306 /*! reconciliation: page reconciliation calls for eviction */ -#define WT_STAT_CONN_REC_PAGES_EVICTION 1309 +#define WT_STAT_CONN_REC_PAGES_EVICTION 1307 /*! reconciliation: pages deleted */ -#define WT_STAT_CONN_REC_PAGE_DELETE 1310 +#define WT_STAT_CONN_REC_PAGE_DELETE 1308 /*! reconciliation: split bytes currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1311 +#define WT_STAT_CONN_REC_SPLIT_STASHED_BYTES 1309 /*! reconciliation: split objects currently awaiting free */ -#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1312 +#define WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS 1310 /*! session: open session count */ -#define WT_STAT_CONN_SESSION_OPEN 1313 +#define WT_STAT_CONN_SESSION_OPEN 1311 /*! session: session query timestamp calls */ -#define WT_STAT_CONN_SESSION_QUERY_TS 1314 +#define WT_STAT_CONN_SESSION_QUERY_TS 1312 /*! session: table alter failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1315 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL 1313 /*! session: table alter successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1316 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS 1314 /*! session: table alter unchanged and skipped */ -#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1317 +#define WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP 1315 /*! session: table compact failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1318 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL 1316 /*! session: table compact successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1319 +#define WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS 1317 /*! session: table create failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1320 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL 1318 /*! session: table create successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1321 +#define WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS 1319 /*! session: table drop failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1322 +#define WT_STAT_CONN_SESSION_TABLE_DROP_FAIL 1320 /*! session: table drop successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1323 +#define WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS 1321 /*! session: table import failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_IMPORT_FAIL 1324 +#define WT_STAT_CONN_SESSION_TABLE_IMPORT_FAIL 1322 /*! session: table import successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_IMPORT_SUCCESS 1325 +#define WT_STAT_CONN_SESSION_TABLE_IMPORT_SUCCESS 1323 /*! session: table rebalance failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1326 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL 1324 /*! session: table rebalance successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1327 +#define WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS 1325 /*! session: table rename failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1328 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL 1326 /*! session: table rename successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1329 +#define WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS 1327 /*! session: table salvage failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1330 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL 1328 /*! session: table salvage successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1331 +#define WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS 1329 /*! session: table truncate failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1332 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL 1330 /*! session: table truncate successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1333 +#define WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS 1331 /*! session: table verify failed calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1334 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL 1332 /*! session: table verify successful calls */ -#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1335 +#define WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS 1333 /*! thread-state: active filesystem fsync calls */ -#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1336 +#define WT_STAT_CONN_THREAD_FSYNC_ACTIVE 1334 /*! thread-state: active filesystem read calls */ -#define WT_STAT_CONN_THREAD_READ_ACTIVE 1337 +#define WT_STAT_CONN_THREAD_READ_ACTIVE 1335 /*! thread-state: active filesystem write calls */ -#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1338 +#define WT_STAT_CONN_THREAD_WRITE_ACTIVE 1336 /*! thread-yield: application thread time evicting (usecs) */ -#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1339 +#define WT_STAT_CONN_APPLICATION_EVICT_TIME 1337 /*! thread-yield: application thread time waiting for cache (usecs) */ -#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1340 +#define WT_STAT_CONN_APPLICATION_CACHE_TIME 1338 /*! * thread-yield: connection close blocked waiting for transaction state * stabilization */ -#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1341 +#define WT_STAT_CONN_TXN_RELEASE_BLOCKED 1339 /*! thread-yield: connection close yielded for lsm manager shutdown */ -#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1342 +#define WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM 1340 /*! thread-yield: data handle lock yielded */ -#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1343 +#define WT_STAT_CONN_DHANDLE_LOCK_BLOCKED 1341 /*! * thread-yield: get reference for page index and slot time sleeping * (usecs) */ -#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1344 +#define WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED 1342 /*! thread-yield: log server sync yielded for log write */ -#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1345 +#define WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED 1343 /*! thread-yield: page access yielded due to prepare state change */ -#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1346 +#define WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE 1344 /*! thread-yield: page acquire busy blocked */ -#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1347 +#define WT_STAT_CONN_PAGE_BUSY_BLOCKED 1345 /*! thread-yield: page acquire eviction blocked */ -#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1348 +#define WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED 1346 /*! thread-yield: page acquire locked blocked */ -#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1349 +#define WT_STAT_CONN_PAGE_LOCKED_BLOCKED 1347 /*! thread-yield: page acquire read blocked */ -#define WT_STAT_CONN_PAGE_READ_BLOCKED 1350 +#define WT_STAT_CONN_PAGE_READ_BLOCKED 1348 /*! thread-yield: page acquire time sleeping (usecs) */ -#define WT_STAT_CONN_PAGE_SLEEP 1351 +#define WT_STAT_CONN_PAGE_SLEEP 1349 /*! * thread-yield: page delete rollback time sleeping for state change * (usecs) */ -#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1352 +#define WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED 1350 /*! thread-yield: page reconciliation yielded due to child modification */ -#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1353 +#define WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE 1351 /*! transaction: Number of prepared updates */ -#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1354 +#define WT_STAT_CONN_TXN_PREPARED_UPDATES_COUNT 1352 /*! transaction: durable timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_DURABLE_QUEUE_WALKED 1355 +#define WT_STAT_CONN_TXN_DURABLE_QUEUE_WALKED 1353 /*! transaction: durable timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_DURABLE_QUEUE_EMPTY 1356 +#define WT_STAT_CONN_TXN_DURABLE_QUEUE_EMPTY 1354 /*! transaction: durable timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_DURABLE_QUEUE_HEAD 1357 +#define WT_STAT_CONN_TXN_DURABLE_QUEUE_HEAD 1355 /*! transaction: durable timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_DURABLE_QUEUE_INSERTS 1358 +#define WT_STAT_CONN_TXN_DURABLE_QUEUE_INSERTS 1356 /*! transaction: durable timestamp queue length */ -#define WT_STAT_CONN_TXN_DURABLE_QUEUE_LEN 1359 +#define WT_STAT_CONN_TXN_DURABLE_QUEUE_LEN 1357 /*! transaction: number of named snapshots created */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1360 +#define WT_STAT_CONN_TXN_SNAPSHOTS_CREATED 1358 /*! transaction: number of named snapshots dropped */ -#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1361 +#define WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED 1359 /*! transaction: prepared transactions */ -#define WT_STAT_CONN_TXN_PREPARE 1362 +#define WT_STAT_CONN_TXN_PREPARE 1360 /*! transaction: prepared transactions committed */ -#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1363 +#define WT_STAT_CONN_TXN_PREPARE_COMMIT 1361 /*! transaction: prepared transactions currently active */ -#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1364 +#define WT_STAT_CONN_TXN_PREPARE_ACTIVE 1362 /*! transaction: prepared transactions rolled back */ -#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1365 +#define WT_STAT_CONN_TXN_PREPARE_ROLLBACK 1363 /*! transaction: query timestamp calls */ -#define WT_STAT_CONN_TXN_QUERY_TS 1366 +#define WT_STAT_CONN_TXN_QUERY_TS 1364 /*! transaction: read timestamp queue entries walked */ -#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1367 +#define WT_STAT_CONN_TXN_READ_QUEUE_WALKED 1365 /*! transaction: read timestamp queue insert to empty */ -#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1368 +#define WT_STAT_CONN_TXN_READ_QUEUE_EMPTY 1366 /*! transaction: read timestamp queue inserts to head */ -#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1369 +#define WT_STAT_CONN_TXN_READ_QUEUE_HEAD 1367 /*! transaction: read timestamp queue inserts total */ -#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1370 +#define WT_STAT_CONN_TXN_READ_QUEUE_INSERTS 1368 /*! transaction: read timestamp queue length */ -#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1371 +#define WT_STAT_CONN_TXN_READ_QUEUE_LEN 1369 /*! transaction: rollback to stable calls */ -#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1372 +#define WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE 1370 /*! transaction: rollback to stable updates aborted */ -#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1373 +#define WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED 1371 /*! transaction: rollback to stable updates removed from history store */ -#define WT_STAT_CONN_TXN_ROLLBACK_HS_REMOVED 1374 +#define WT_STAT_CONN_TXN_ROLLBACK_HS_REMOVED 1372 /*! transaction: set timestamp calls */ -#define WT_STAT_CONN_TXN_SET_TS 1375 +#define WT_STAT_CONN_TXN_SET_TS 1373 /*! transaction: set timestamp durable calls */ -#define WT_STAT_CONN_TXN_SET_TS_DURABLE 1376 +#define WT_STAT_CONN_TXN_SET_TS_DURABLE 1374 /*! transaction: set timestamp durable updates */ -#define WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD 1377 +#define WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD 1375 /*! transaction: set timestamp oldest calls */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1378 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST 1376 /*! transaction: set timestamp oldest updates */ -#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1379 +#define WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD 1377 /*! transaction: set timestamp stable calls */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE 1380 +#define WT_STAT_CONN_TXN_SET_TS_STABLE 1378 /*! transaction: set timestamp stable updates */ -#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1381 +#define WT_STAT_CONN_TXN_SET_TS_STABLE_UPD 1379 /*! transaction: transaction begins */ -#define WT_STAT_CONN_TXN_BEGIN 1382 +#define WT_STAT_CONN_TXN_BEGIN 1380 /*! transaction: transaction checkpoint currently running */ -#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1383 +#define WT_STAT_CONN_TXN_CHECKPOINT_RUNNING 1381 /*! transaction: transaction checkpoint generation */ -#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1384 +#define WT_STAT_CONN_TXN_CHECKPOINT_GENERATION 1382 /*! * transaction: transaction checkpoint history store file duration * (usecs) */ -#define WT_STAT_CONN_TXN_HS_CKPT_DURATION 1385 +#define WT_STAT_CONN_TXN_HS_CKPT_DURATION 1383 /*! transaction: transaction checkpoint max time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1386 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX 1384 /*! transaction: transaction checkpoint min time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1387 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN 1385 /*! transaction: transaction checkpoint most recent time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1388 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT 1386 /*! transaction: transaction checkpoint scrub dirty target */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1389 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET 1387 /*! transaction: transaction checkpoint scrub time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1390 +#define WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME 1388 /*! transaction: transaction checkpoint total time (msecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1391 +#define WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL 1389 /*! transaction: transaction checkpoints */ -#define WT_STAT_CONN_TXN_CHECKPOINT 1392 +#define WT_STAT_CONN_TXN_CHECKPOINT 1390 /*! * transaction: transaction checkpoints skipped because database was * clean */ -#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1393 +#define WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED 1391 /*! transaction: transaction failures due to history store */ -#define WT_STAT_CONN_TXN_FAIL_CACHE 1394 +#define WT_STAT_CONN_TXN_FAIL_CACHE 1392 /*! * transaction: transaction fsync calls for checkpoint after allocating * the transaction ID */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1395 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST 1393 /*! * transaction: transaction fsync duration for checkpoint after * allocating the transaction ID (usecs) */ -#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1396 +#define WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION 1394 /*! transaction: transaction range of IDs currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_RANGE 1397 +#define WT_STAT_CONN_TXN_PINNED_RANGE 1395 /*! transaction: transaction range of IDs currently pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1398 +#define WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE 1396 /*! * transaction: transaction range of IDs currently pinned by named * snapshots */ -#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1399 +#define WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE 1397 /*! transaction: transaction range of timestamps currently pinned */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1400 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP 1398 /*! transaction: transaction range of timestamps pinned by a checkpoint */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1401 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT 1399 /*! * transaction: transaction range of timestamps pinned by the oldest * active read timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1402 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER 1400 /*! * transaction: transaction range of timestamps pinned by the oldest * timestamp */ -#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1403 +#define WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST 1401 /*! transaction: transaction read timestamp of the oldest active reader */ -#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1404 +#define WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ 1402 /*! transaction: transaction sync calls */ -#define WT_STAT_CONN_TXN_SYNC 1405 +#define WT_STAT_CONN_TXN_SYNC 1403 /*! transaction: transactions committed */ -#define WT_STAT_CONN_TXN_COMMIT 1406 +#define WT_STAT_CONN_TXN_COMMIT 1404 /*! transaction: transactions rolled back */ -#define WT_STAT_CONN_TXN_ROLLBACK 1407 +#define WT_STAT_CONN_TXN_ROLLBACK 1405 /*! transaction: update conflicts */ -#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1408 +#define WT_STAT_CONN_TXN_UPDATE_CONFLICT 1406 /*! * @} diff --git a/src/reconcile/rec_write.c b/src/reconcile/rec_write.c index e238509c0..06efb1a4f 100644 --- a/src/reconcile/rec_write.c +++ b/src/reconcile/rec_write.c @@ -2278,7 +2278,6 @@ __rec_write_wrapup_err(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page) static int __rec_hs_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r) { - WT_CURSOR *cursor; WT_DECL_RET; WT_MULTI *multi; uint32_t i, session_flags; @@ -2290,11 +2289,11 @@ __rec_hs_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r) if (i == r->multi_next) return (0); - __wt_hs_cursor(session, &cursor, &session_flags); + WT_RET(__wt_hs_cursor(session, &session_flags)); for (multi = r->multi, i = 0; i < r->multi_next; ++multi, ++i) if (multi->supd != NULL) { - WT_ERR(__wt_hs_insert_updates(cursor, S2BT(session), r, multi)); + WT_ERR(__wt_hs_insert_updates(session->hs_cursor, S2BT(session), r, multi)); if (!r->leave_dirty) { __wt_free(session, multi->supd); multi->supd_entries = 0; @@ -2302,7 +2301,7 @@ __rec_hs_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r) } err: - WT_TRET(__wt_hs_cursor_close(session, &cursor, session_flags)); + WT_TRET(__wt_hs_cursor_close(session, session_flags)); return (ret); } diff --git a/src/support/stat.c b/src/support/stat.c index 94ad67fe4..8f45b9b0e 100644 --- a/src/support/stat.c +++ b/src/support/stat.c @@ -684,11 +684,9 @@ static const char *const __stats_connection_desc[] = { "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", "cache: hazard pointer maximum array length", - "cache: history store cursor application thread wait time (usecs)", - "cache: history store cursor internal thread wait time (usecs)", "cache: history store score", - "cache: history store table insert calls", "cache: history store table max on-disk size", - "cache: history store table on-disk size", "cache: history store table reads", - "cache: history store table reads missed", + "cache: history store score", "cache: history store table insert calls", + "cache: history store table max on-disk size", "cache: history store table on-disk size", + "cache: history store table reads", "cache: history store table reads missed", "cache: history store table reads requiring squashed modifies", "cache: history store table writes requiring squashed modifies", "cache: in-memory page passed criteria to be split", "cache: in-memory page splits", @@ -1030,8 +1028,6 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats) stats->cache_hazard_checks = 0; stats->cache_hazard_walks = 0; stats->cache_hazard_max = 0; - stats->cache_hs_cursor_wait_application = 0; - stats->cache_hs_cursor_wait_internal = 0; /* not clearing cache_hs_score */ stats->cache_hs_insert = 0; /* not clearing cache_hs_ondisk_max */ @@ -1462,8 +1458,6 @@ __wt_stat_connection_aggregate(WT_CONNECTION_STATS **from, WT_CONNECTION_STATS * to->cache_hazard_walks += WT_STAT_READ(from, cache_hazard_walks); if ((v = WT_STAT_READ(from, cache_hazard_max)) > to->cache_hazard_max) to->cache_hazard_max = v; - to->cache_hs_cursor_wait_application += WT_STAT_READ(from, cache_hs_cursor_wait_application); - to->cache_hs_cursor_wait_internal += WT_STAT_READ(from, cache_hs_cursor_wait_internal); to->cache_hs_score += WT_STAT_READ(from, cache_hs_score); to->cache_hs_insert += WT_STAT_READ(from, cache_hs_insert); to->cache_hs_ondisk_max += WT_STAT_READ(from, cache_hs_ondisk_max); diff --git a/src/txn/txn_rollback_to_stable.c b/src/txn/txn_rollback_to_stable.c index 2595059f8..b244191a9 100644 --- a/src/txn/txn_rollback_to_stable.c +++ b/src/txn/txn_rollback_to_stable.c @@ -37,7 +37,8 @@ __txn_rollback_to_stable_hs_fixup(WT_SESSION_IMPL *session) txn_global = &conn->txn_global; WT_ORDERED_READ(rollback_timestamp, txn_global->stable_timestamp); - __wt_hs_cursor(session, &cursor, &session_flags); + WT_RET(__wt_hs_cursor(session, &session_flags)); + cursor = session->hs_cursor; /* Discard pages we read as soon as we're done with them. */ F_SET(session, WT_SESSION_READ_WONT_NEED); @@ -67,7 +68,7 @@ __txn_rollback_to_stable_hs_fixup(WT_SESSION_IMPL *session) } WT_ERR_NOTFOUND_OK(ret); err: - WT_TRET(__wt_hs_cursor_close(session, &cursor, session_flags)); + WT_TRET(__wt_hs_cursor_close(session, session_flags)); F_CLR(session, WT_SESSION_READ_WONT_NEED);