Import wiredtiger: 98277fc751addbbab68a26dbd322e79280fc3302 from branch mongodb-master

ref: 7df81e23c4..98277fc751
for: 7.0.0-rc0

WT-9631 Estimate how much work compact would do and improve the progress message

13 files changed, 769 insertions, 324 deletions

diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok
index 10bd3eb55ed..22b327b7579 100644
--- a/src/third_party/wiredtiger/dist/s_string.ok
+++ b/src/third_party/wiredtiger/dist/s_string.ok
@@ -1278,6 +1278,7 @@ uS
 ui
 uint
 umount
+unallocated
 unbare
 unbuffered
 uncompressing
diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py
index da6f6ae6ac6..243e267b498 100644
--- a/src/third_party/wiredtiger/dist/stat_data.py
+++ b/src/third_party/wiredtiger/dist/stat_data.py
@@ -706,6 +706,7 @@ dsrc_stats = [
     BtreeStat('btree_column_variable', 'column-store variable-size leaf pages', 'no_scale,tree_walk'),
     BtreeStat('btree_compact_pages_reviewed', 'btree compact pages reviewed', 'no_clear,no_scale'),
     BtreeStat('btree_compact_pages_rewritten', 'btree compact pages rewritten', 'no_clear,no_scale'),
+    BtreeStat('btree_compact_pages_rewritten_expected', 'btree expected number of compact pages rewritten', 'no_clear,no_scale'),
     BtreeStat('btree_compact_pages_skipped', 'btree compact pages skipped', 'no_clear,no_scale'),
     BtreeStat('btree_compact_skipped', 'btree skipped by compaction as process would not reduce size', 'no_clear,no_scale'),
     BtreeStat('btree_entries', 'number of key/value pairs', 'no_scale,tree_walk'),
diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 64fdf53bac8..ac33c6deb7d 100644
--- a/src/third_party/wiredtiger/import.data
+++ b/src/third_party/wiredtiger/import.data
@@ -2,5 +2,5 @@
     "vendor": "wiredtiger",
     "github": "wiredtiger/wiredtiger.git",
     "branch": "mongodb-master",
-    "commit": "7df81e23c41275ecb1fa10cb57664369fe4d2599"
+    "commit": "98277fc751addbbab68a26dbd322e79280fc3302"
 }
diff --git a/src/third_party/wiredtiger/src/block/block_compact.c b/src/third_party/wiredtiger/src/block/block_compact.c
index af66b271f4d..fcdd3cf7bab 100644
--- a/src/third_party/wiredtiger/src/block/block_compact.c
+++ b/src/third_party/wiredtiger/src/block/block_compact.c
@@ -24,8 +24,12 @@ __wt_block_compact_start(WT_SESSION_IMPL *session, WT_BLOCK *block)
 
     /* Reset the compaction state information. */
     block->compact_pct_tenths = 0;
-    block->compact_pages_rewritten = 0;
+    block->compact_bytes_reviewed = 0;
+    block->compact_bytes_rewritten = 0;
+    block->compact_internal_pages_reviewed = 0;
     block->compact_pages_reviewed = 0;
+    block->compact_pages_rewritten = 0;
+    block->compact_pages_rewritten_expected = 0;
     block->compact_pages_skipped = 0;
 
     return (0);
@@ -56,7 +60,8 @@ __wt_block_compact_end(WT_SESSION_IMPL *session, WT_BLOCK *block)
  */
 void
 __wt_block_compact_get_progress_stats(WT_SESSION_IMPL *session, WT_BM *bm,
-  uint64_t *pages_reviewedp, uint64_t *pages_skippedp, uint64_t *pages_rewrittenp)
+  uint64_t *pages_reviewedp, uint64_t *pages_skippedp, uint64_t *pages_rewrittenp,
+  uint64_t *pages_rewritten_expectedp)
 {
     WT_BLOCK *block;
 
@@ -65,6 +70,320 @@ __wt_block_compact_get_progress_stats(WT_SESSION_IMPL *session, WT_BM *bm,
     *pages_reviewedp = block->compact_pages_reviewed;
     *pages_skippedp = block->compact_pages_skipped;
     *pages_rewrittenp = block->compact_pages_rewritten;
+    *pages_rewritten_expectedp = block->compact_pages_rewritten_expected;
+}
+
+/*
+ * __block_compact_trim_extent --
+ *     Trim the extent to the given range mask, specified via start and end offsets.
+ */
+static inline void
+__block_compact_trim_extent(WT_SESSION_IMPL *session, wt_off_t mask_start, wt_off_t mask_end,
+  wt_off_t *ext_startp, wt_off_t *ext_sizep)
+{
+    WT_UNUSED(session);
+
+    if (mask_end >= 0 && mask_end < mask_start) {
+        *ext_sizep = 0;
+        return;
+    }
+
+    /* Trim from the beginning. */
+    if (*ext_startp < mask_start) {
+        if (*ext_startp + *ext_sizep <= mask_start) {
+            *ext_sizep = 0;
+            return;
+        }
+        *ext_sizep -= mask_start - *ext_startp;
+        *ext_startp = mask_start;
+    }
+
+    /* Trim from the end. */
+    if (mask_end >= 0 && *ext_startp + *ext_sizep > mask_end) {
+        *ext_sizep = mask_end - *ext_startp;
+        if (*ext_sizep <= 0) {
+            *ext_sizep = 0;
+        }
+    }
+}
+
+/*
+ * __block_compact_skip_internal --
+ *     Return if compaction will shrink the file. This function takes a few extra parameters, so
+ *     that it can be useful for both making the actual compaction decisions as well as for
+ *     estimating the work ahead of the compaction itself: the file size, the smallest offset that
+ *     the first-fit allocation is likely to consider, and the number of available (unallocated)
+ *     bytes before that offset.
+ */
+static void
+__block_compact_skip_internal(WT_SESSION_IMPL *session, WT_BLOCK *block, bool estimate,
+  wt_off_t file_size, wt_off_t start_offset, wt_off_t avail_bytes_before_start_offset, bool *skipp,
+  int *compact_pct_tenths_p)
+{
+    WT_EXT *ext;
+    wt_off_t avail_eighty, avail_ninety, off, size, eighty, ninety;
+
+    /* IMPORTANT: We assume here that block->live_lock is locked. */
+
+    /* Sum the available bytes in the initial 80% and 90% of the file. */
+    avail_eighty = avail_ninety = avail_bytes_before_start_offset;
+    ninety = file_size - file_size / 10;
+    eighty = file_size - ((file_size / 10) * 2);
+
+    WT_EXT_FOREACH_FROM_OFFSET_INCL(ext, &block->live.avail, start_offset)
+    {
+        off = ext->off;
+        size = ext->size;
+        __block_compact_trim_extent(session, start_offset, file_size, &off, &size);
+        if (off < ninety) {
+            avail_ninety += size;
+            if (off < eighty)
+                avail_eighty += size;
+        }
+    }
+
+    /*
+     * Skip files where we can't recover at least 1MB.
+     *
+     * WiredTiger uses first-fit compaction: It finds space in the beginning of the file and moves
+     * data from the end of the file into that space. If at least 20% of the total file is available
+     * and in the first 80% of the file, we'll try compaction on the last 20% of the file; else, if
+     * at least 10% of the total file is available and in the first 90% of the file, we'll try
+     * compaction on the last 10% of the file.
+     *
+     * We could push this further, but there's diminishing returns, a mostly empty file can be
+     * processed quickly, so more aggressive compaction is less useful.
+     */
+    if (avail_eighty > WT_MEGABYTE && avail_eighty >= ((file_size / 10) * 2)) {
+        *skipp = false;
+        *compact_pct_tenths_p = 2;
+    } else if (avail_ninety > WT_MEGABYTE && avail_ninety >= file_size / 10) {
+        *skipp = false;
+        *compact_pct_tenths_p = 1;
+    } else {
+        *skipp = true;
+        *compact_pct_tenths_p = 0;
+    }
+
+    if (!estimate)
+        __wt_verbose_level(session, WT_VERB_COMPACT, WT_VERBOSE_DEBUG_1,
+          "%s: total reviewed %" PRIu64 " pages, total rewritten %" PRIu64 " pages", block->name,
+          block->compact_pages_reviewed, block->compact_pages_rewritten);
+    __wt_verbose_level(session, WT_VERB_COMPACT,
+      (estimate ? WT_VERBOSE_DEBUG_3 : WT_VERBOSE_DEBUG_1),
+      "%s:%s %" PRIuMAX "MB (%" PRIuMAX ") available space in the first 80%% of the file",
+      block->name, estimate ? " estimating --" : "", (uintmax_t)avail_eighty / WT_MEGABYTE,
+      (uintmax_t)avail_eighty);
+    __wt_verbose_level(session, WT_VERB_COMPACT,
+      (estimate ? WT_VERBOSE_DEBUG_3 : WT_VERBOSE_DEBUG_1),
+      "%s:%s %" PRIuMAX "MB (%" PRIuMAX ") available space in the first 90%% of the file",
+      block->name, estimate ? " estimating --" : "", (uintmax_t)avail_ninety / WT_MEGABYTE,
+      (uintmax_t)avail_ninety);
+    __wt_verbose_level(session, WT_VERB_COMPACT,
+      (estimate ? WT_VERBOSE_DEBUG_3 : WT_VERBOSE_DEBUG_1),
+      "%s:%s require 10%% or %" PRIuMAX "MB (%" PRIuMAX
+      ") in the first 90%% of the file to perform compaction, compaction %s",
+      block->name, estimate ? " estimating --" : "", (uintmax_t)(file_size / 10) / WT_MEGABYTE,
+      (uintmax_t)(file_size / 10), *skipp ? "skipped" : "proceeding");
+}
+
+/*
+ * __block_compact_estimate_remaining_work --
+ *     Estimate how much more work the compaction needs to do for the given file.
+ */
+static void
+__block_compact_estimate_remaining_work(WT_SESSION_IMPL *session, WT_BLOCK *block)
+{
+    WT_EXT *ext;
+    wt_off_t avg_block_size, avg_internal_block_size, depth1_subtree_size, leaves_per_internal_page;
+    wt_off_t compact_start_off, extra_space, file_size, last, off, rewrite_size, size, write_off;
+    uint64_t n, pages_to_move, pages_to_move_orig, total_pages_to_move;
+    int compact_pct_tenths, iteration;
+    bool skip;
+
+    /*
+     * We must have reviewed at least some interesting number of pages for any estimates below to be
+     * worthwhile.
+     */
+    if (block->compact_pages_reviewed < WT_THOUSAND)
+        return;
+
+    /* Assume that we have already checked whether this file can be skipped. */
+    WT_ASSERT(session, block->compact_pct_tenths > 0);
+
+    /*
+     * Get the average block size that we encountered so far during compaction. Note that we are not
+     * currently accounting for overflow pages, as compact does not currently account for them
+     * either.
+     */
+    avg_block_size = (wt_off_t)WT_ALIGN(
+      block->compact_bytes_reviewed / block->compact_pages_reviewed, block->allocsize);
+
+    /* We don't currently have a way to track the internal page size, but this should be okay. */
+    avg_internal_block_size = block->allocsize;
+
+    /*
+     * Estimate the average number of leaf pages per one internal page. This way of doing the
+     * estimate is sufficient, because we expect each internal node to have a large number of
+     * children, so that the number of higher-level internal nodes is small relative to the internal
+     * nodes at the bottom.
+     */
+    leaves_per_internal_page =
+      (wt_off_t)(block->compact_pages_reviewed / block->compact_internal_pages_reviewed);
+
+    /*
+     * Estimate the size of a "depth 1" subtree consisting of one internal page and the
+     * corresponding leaves.
+     */
+    depth1_subtree_size = avg_block_size * leaves_per_internal_page + avg_internal_block_size;
+
+    __wt_verbose_debug2(session, WT_VERB_COMPACT,
+      "%s: the average block size is %" PRId64 " bytes (based on %" PRIu64 " blocks)", block->name,
+      avg_block_size, block->compact_pages_reviewed);
+    __wt_verbose_debug2(session, WT_VERB_COMPACT, "%s: reviewed %" PRIu64 " internal pages so far",
+      block->name, block->compact_internal_pages_reviewed);
+
+    /*
+     * We would like to estimate how much data will be moved during compaction, so that we can
+     * inform users how far along we are in the process. We will estimate how many pages are in the
+     * last part of the file (typically the last 10%) and where they will be written using the
+     * first-fit allocation, and then repeat as long as we continue to make progress, to emulate the
+     * behavior of the actual compaction. This does not account for all complexities that we may
+     * encounter, but the hope is that the estimate would be still good enough.
+     */
+
+    __wt_spin_lock(session, &block->live_lock);
+
+    compact_pct_tenths = block->compact_pct_tenths;
+    extra_space = 0;
+    file_size = block->size;
+    pages_to_move = 0;
+    total_pages_to_move = 0;
+    write_off = 0;
+
+    /* Macro for estimating the number of leaf pages that can be stored within an extent. */
+#define WT_EXT_SIZE_TO_LEAF_PAGES(ext_size)                                  \
+    (uint64_t)((ext_size) / depth1_subtree_size * leaves_per_internal_page + \
+      ((ext_size) % depth1_subtree_size) / avg_block_size)
+
+    /* Now do the actual estimation, simulating one compact pass at a time. */
+    for (iteration = 0;; iteration++) {
+        compact_start_off = file_size - compact_pct_tenths * file_size / 10;
+        if (write_off >= compact_start_off)
+            break;
+        __wt_verbose_debug2(session, WT_VERB_COMPACT,
+          "%s: estimating -- pass %d: file size: %" PRId64 ", compact offset: %" PRId64
+          ", will move blocks from the last %d%% of the file",
+          block->name, iteration, file_size, compact_start_off, compact_pct_tenths * 10);
+
+        /*
+         * Estimate how many pages we would like to move, just using the live checkpoint. The
+         * checkpoint doesn't have a complete list of allocated extents, so we estimate it in two
+         * phases: We first take an inverse of the "available" list, which gives us all extents that
+         * are either currently allocated or are to be discarded at the next checkpoint. We do this
+         * by first estimating the number of pages that can fit in the inverse of the "available"
+         * list, and then we subtract the number of pages determined from the "discard" list.
+         */
+        last = compact_start_off;
+        WT_EXT_FOREACH_FROM_OFFSET_INCL(ext, &block->live.avail, compact_start_off)
+        {
+            off = ext->off;
+            size = ext->size;
+            WT_ASSERT(session, off >= compact_start_off || off + size >= compact_start_off);
+
+            __block_compact_trim_extent(session, compact_start_off, file_size, &off, &size);
+            if (off >= compact_start_off && size <= 0)
+                break;
+
+            if (off > last) {
+                n = WT_EXT_SIZE_TO_LEAF_PAGES(off - last);
+                pages_to_move += n;
+                __wt_verbose_debug3(session, WT_VERB_COMPACT,
+                  "%s: estimating -- %" PRIu64 " pages to move between %" PRId64 " and %" PRId64,
+                  block->name, n, last, off);
+            }
+            last = off + size;
+        }
+        n = WT_EXT_SIZE_TO_LEAF_PAGES(file_size - last);
+        pages_to_move += n;
+        __wt_verbose_debug3(session, WT_VERB_COMPACT,
+          "%s: estimating -- %" PRIu64 " pages to move between %" PRId64 " and %" PRId64,
+          block->name, n, last, file_size);
+
+        WT_EXT_FOREACH_FROM_OFFSET_INCL(ext, &block->live.discard, compact_start_off)
+        {
+            off = ext->off;
+            size = ext->size;
+            WT_ASSERT(session, off >= compact_start_off || off + size >= compact_start_off);
+
+            __block_compact_trim_extent(session, compact_start_off, file_size, &off, &size);
+            if (off >= compact_start_off && size <= 0)
+                break;
+
+            n = WT_EXT_SIZE_TO_LEAF_PAGES(size);
+            pages_to_move -= WT_MIN(n, pages_to_move);
+            __wt_verbose_debug3(session, WT_VERB_COMPACT,
+              "%s: estimating -- %" PRIu64 " pages on discard list between %" PRId64
+              " and %" PRId64,
+              block->name, n, off, off + size);
+        }
+        if (pages_to_move == 0)
+            break;
+
+        /* Estimate where in the file we would be when we finish moving those pages. */
+        pages_to_move_orig = pages_to_move;
+        WT_EXT_FOREACH_FROM_OFFSET_INCL(ext, &block->live.avail, write_off)
+        {
+            off = ext->off;
+            size = ext->size;
+            WT_ASSERT(session, off >= write_off || off + size >= write_off);
+
+            if (pages_to_move == 0 || off >= compact_start_off)
+                break;
+
+            __block_compact_trim_extent(session, write_off, compact_start_off, &off, &size);
+            if (off >= write_off && size <= 0)
+                break;
+
+            n = WT_EXT_SIZE_TO_LEAF_PAGES(size);
+            n = WT_MIN(n, pages_to_move);
+            pages_to_move -= n;
+            total_pages_to_move += n;
+
+            rewrite_size = (wt_off_t)n * avg_block_size +
+              (wt_off_t)n * avg_internal_block_size / leaves_per_internal_page;
+            write_off = off + rewrite_size;
+            if (pages_to_move > 0)
+                extra_space += size - rewrite_size;
+        }
+        __wt_verbose_debug2(session, WT_VERB_COMPACT,
+          "%s: estimating -- pass %d: will rewrite %" PRIu64 " pages, next write offset: %" PRId64
+          ", extra space: %" PRId64,
+          block->name, iteration, pages_to_move_orig, write_off, extra_space);
+
+        /* See if we ran out of pages to move. */
+        if (pages_to_move > 0)
+            break;
+
+        /* If there is more work that could be done, repeat with the shorter file. */
+        ext = __wt_block_off_srch_inclusive(&block->live.avail, compact_start_off);
+        file_size = ext == NULL ? compact_start_off : WT_MIN(ext->off, compact_start_off);
+        __block_compact_skip_internal(
+          session, block, true, file_size, write_off, extra_space, &skip, &compact_pct_tenths);
+        if (skip)
+            break;
+    }
+
+#undef WT_EXT_SIZE_TO_LEAF_PAGES
+
+    __wt_spin_unlock(session, &block->live_lock);
+
+    block->compact_pages_rewritten_expected = block->compact_pages_rewritten + total_pages_to_move;
+    __wt_verbose_debug1(session, WT_VERB_COMPACT,
+      "%s: expecting to move approx. %" PRIu64 " more pages (%" PRIu64 "MB), %" PRIu64 " total",
+      block->name, total_pages_to_move,
+      total_pages_to_move * (uint64_t)avg_block_size / WT_MEGABYTE,
+      block->compact_pages_rewritten_expected);
 }
 
 /*
@@ -76,6 +395,7 @@ __wt_block_compact_progress(WT_SESSION_IMPL *session, WT_BLOCK *block, u_int *ms
 {
     struct timespec cur_time;
     uint64_t time_diff;
+    int progress;
 
     if (!WT_VERBOSE_LEVEL_ISSET(session, WT_VERB_COMPACT_PROGRESS, WT_VERBOSE_DEBUG_1))
         return;
@@ -86,12 +406,32 @@ __wt_block_compact_progress(WT_SESSION_IMPL *session, WT_BLOCK *block, u_int *ms
     time_diff = WT_TIMEDIFF_SEC(cur_time, session->compact->begin);
     if (time_diff / WT_PROGRESS_MSG_PERIOD > *msg_countp) {
         ++*msg_countp;
-        __wt_verbose_debug1(session, WT_VERB_COMPACT_PROGRESS,
-          " compacting %s for %" PRIu64 " seconds; reviewed %" PRIu64 " pages, rewritten %" PRIu64
-          " pages",
-          block->name, time_diff, block->compact_pages_reviewed, block->compact_pages_rewritten);
+
+        /*
+         * If we don't have the estimate at this point, it means that we haven't reviewed even
+         * enough pages. This should almost never happen.
+         */
+        if (block->compact_pages_rewritten_expected == 0) {
+            __wt_verbose_debug1(session, WT_VERB_COMPACT_PROGRESS,
+              "compacting %s for %" PRIu64 " seconds; reviewed %" PRIu64
+              " pages, rewritten %" PRIu64 " pages (%" PRIu64 "MB)",
+              block->name, time_diff, block->compact_pages_reviewed, block->compact_pages_rewritten,
+              block->compact_bytes_rewritten / WT_MEGABYTE);
+            __wt_verbose_debug1(session, WT_VERB_COMPACT,
+              "%s: still collecting information for estimating the progress", block->name);
+        } else {
+            progress = WT_MIN(
+              (int)(100 * block->compact_pages_rewritten / block->compact_pages_rewritten_expected),
+              100);
+            __wt_verbose_debug1(session, WT_VERB_COMPACT_PROGRESS,
+              "compacting %s for %" PRIu64 " seconds; reviewed %" PRIu64
+              " pages, rewritten %" PRIu64 " pages (%" PRIu64 "MB), approx. %d%% done",
+              block->name, time_diff, block->compact_pages_reviewed, block->compact_pages_rewritten,
+              block->compact_bytes_rewritten / WT_MEGABYTE, progress);
+        }
     }
 }
+
 /*
  * __wt_block_compact_skip --
  *     Return if compaction will shrink the file.
@@ -99,10 +439,6 @@ __wt_block_compact_progress(WT_SESSION_IMPL *session, WT_BLOCK *block, u_int *ms
 int
 __wt_block_compact_skip(WT_SESSION_IMPL *session, WT_BLOCK *block, bool *skipp)
 {
-    WT_EXT *ext;
-    WT_EXTLIST *el;
-    wt_off_t avail_eighty, avail_ninety, eighty, ninety;
-
     *skipp = true; /* Return a default skip. */
 
     /*
@@ -124,52 +460,8 @@ __wt_block_compact_skip(WT_SESSION_IMPL *session, WT_BLOCK *block, bool *skipp)
     if (WT_VERBOSE_LEVEL_ISSET(session, WT_VERB_COMPACT, WT_VERBOSE_DEBUG_2))
         __block_dump_file_stat(session, block, true);
 
-    /* Sum the available bytes in the initial 80% and 90% of the file. */
-    avail_eighty = avail_ninety = 0;
-    ninety = block->size - block->size / 10;
-    eighty = block->size - ((block->size / 10) * 2);
-
-    el = &block->live.avail;
-    WT_EXT_FOREACH (ext, el->off)
-        if (ext->off < ninety) {
-            avail_ninety += ext->size;
-            if (ext->off < eighty)
-                avail_eighty += ext->size;
-        }
-
-    /*
-     * Skip files where we can't recover at least 1MB.
-     *
-     * If at least 20% of the total file is available and in the first 80% of the file, we'll try
-     * compaction on the last 20% of the file; else, if at least 10% of the total file is available
-     * and in the first 90% of the file, we'll try compaction on the last 10% of the file.
-     *
-     * We could push this further, but there's diminishing returns, a mostly empty file can be
-     * processed quickly, so more aggressive compaction is less useful.
-     */
-    if (avail_eighty > WT_MEGABYTE && avail_eighty >= ((block->size / 10) * 2)) {
-        *skipp = false;
-        block->compact_pct_tenths = 2;
-    } else if (avail_ninety > WT_MEGABYTE && avail_ninety >= block->size / 10) {
-        *skipp = false;
-        block->compact_pct_tenths = 1;
-    }
-
-    __wt_verbose_debug1(session, WT_VERB_COMPACT,
-      "%s: total reviewed %" PRIu64 " pages, total rewritten %" PRIu64 " pages", block->name,
-      block->compact_pages_reviewed, block->compact_pages_rewritten);
-    __wt_verbose_debug1(session, WT_VERB_COMPACT,
-      "%s: %" PRIuMAX "MB (%" PRIuMAX ") available space in the first 80%% of the file",
-      block->name, (uintmax_t)avail_eighty / WT_MEGABYTE, (uintmax_t)avail_eighty);
-    __wt_verbose_debug1(session, WT_VERB_COMPACT,
-      "%s: %" PRIuMAX "MB (%" PRIuMAX ") available space in the first 90%% of the file",
-      block->name, (uintmax_t)avail_ninety / WT_MEGABYTE, (uintmax_t)avail_ninety);
-    __wt_verbose_debug1(session, WT_VERB_COMPACT,
-      "%s: require 10%% or %" PRIuMAX "MB (%" PRIuMAX
-      ") in the first 90%% of the file to perform compaction, compaction %s",
-      block->name, (uintmax_t)(block->size / 10) / WT_MEGABYTE, (uintmax_t)block->size / 10,
-      *skipp ? "skipped" : "proceeding");
-
+    __block_compact_skip_internal(
+      session, block, false, block->size, 0, 0, skipp, &block->compact_pct_tenths);
     __wt_spin_unlock(session, &block->live_lock);
 
     return (0);
@@ -211,10 +503,15 @@ __compact_page_skip(
     __wt_spin_unlock(session, &block->live_lock);
 
     ++block->compact_pages_reviewed;
+    block->compact_bytes_reviewed += size;
     if (*skipp)
         ++block->compact_pages_skipped;
     else
         ++block->compact_pages_rewritten;
+
+    /* Estimate how much work is left. */
+    if (block->compact_pages_rewritten_expected == 0)
+        __block_compact_estimate_remaining_work(session, block);
 }
 
 /*
@@ -295,11 +592,15 @@ __wt_block_compact_page_rewrite(
     endp = addr;
     WT_ERR(__wt_block_addr_pack(block, &endp, objectid, new_offset, size, checksum));
     *addr_sizep = WT_PTRDIFF(endp, addr);
+    block->compact_bytes_rewritten += size;
 
     WT_STAT_CONN_INCR(session, block_write);
     WT_STAT_CONN_INCRV(session, block_byte_write, size);
 
     discard_block = false;
+    __wt_verbose_level(session, WT_VERB_COMPACT, WT_VERBOSE_DEBUG_4,
+      "%s: rewrite %" PRId64 " --> %" PRId64 " (%" PRIu32 "B)", block->name, offset, new_offset,
+      size);
 
 err:
     if (discard_block) {
@@ -364,8 +665,9 @@ __block_dump_file_stat(WT_SESSION_IMPL *session, WT_BLOCK *block, bool start)
           session, WT_VERB_COMPACT, "pages reviewed: %" PRIu64, block->compact_pages_reviewed);
         __wt_verbose_debug1(
           session, WT_VERB_COMPACT, "pages skipped: %" PRIu64, block->compact_pages_skipped);
-        __wt_verbose_debug1(
-          session, WT_VERB_COMPACT, "pages rewritten : %" PRIu64, block->compact_pages_rewritten);
+        __wt_verbose_debug1(session, WT_VERB_COMPACT,
+          "pages rewritten: %" PRIu64 " (%" PRIu64 " expected)", block->compact_pages_rewritten,
+          block->compact_pages_rewritten_expected);
     }
 
     __wt_verbose_debug1(session, WT_VERB_COMPACT,
diff --git a/src/third_party/wiredtiger/src/block/block_ext.c b/src/third_party/wiredtiger/src/block/block_ext.c
index 1ee396930e8..618add993cf 100644
--- a/src/third_party/wiredtiger/src/block/block_ext.c
+++ b/src/third_party/wiredtiger/src/block/block_ext.c
@@ -239,6 +239,24 @@ __block_off_insert(WT_SESSION_IMPL *session, WT_EXTLIST *el, wt_off_t off, wt_of
     return (__block_ext_insert(session, el, ext));
 }
 
+/*
+ * __wt_block_off_srch_inclusive --
+ *     Search a by-offset skiplist for the extent that contains the given offset, or if there is no
+ *     such extent, then get the next extent.
+ */
+WT_EXT *
+__wt_block_off_srch_inclusive(WT_EXTLIST *el, wt_off_t off)
+{
+    WT_EXT *after, *before;
+    __block_off_srch_pair(el, off, &before, &after);
+
+    /* Check if the search key is in the before extent. Otherwise return the after extent. */
+    if (before != NULL && before->off <= off && before->off + before->size > off)
+        return (before);
+    else
+        return (after);
+}
+
 #ifdef HAVE_DIAGNOSTIC
 /*
  * __block_off_match --
diff --git a/src/third_party/wiredtiger/src/btree/bt_compact.c b/src/third_party/wiredtiger/src/btree/bt_compact.c
index fd4c6b8b363..894e49c45b4 100644
--- a/src/third_party/wiredtiger/src/btree/bt_compact.c
+++ b/src/third_party/wiredtiger/src/btree/bt_compact.c
@@ -306,11 +306,13 @@ __wt_compact(WT_SESSION_IMPL *session)
     u_int i, msg_count;
     bool first, skip;
 
-    uint64_t stats_pages_rewritten; /* Pages rewritten */
-    uint64_t stats_pages_reviewed;  /* Pages reviewed */
-    uint64_t stats_pages_skipped;   /* Pages skipped */
+    uint64_t stats_pages_reviewed;           /* Pages reviewed */
+    uint64_t stats_pages_rewritten;          /* Pages rewritten */
+    uint64_t stats_pages_rewritten_expected; /* How much pages we expect to rewrite */
+    uint64_t stats_pages_skipped;            /* Pages skipped */
 
     bm = S2BT(session)->bm;
+    msg_count = 0;
     ref = NULL;
 
     WT_STAT_DATA_INCR(session, session_compact);
@@ -328,8 +330,8 @@ __wt_compact(WT_SESSION_IMPL *session)
          * Print the "skipping compaction" message only if this is the first time we are working on
          * this table.
          */
-        __wt_block_compact_get_progress_stats(
-          session, bm, &stats_pages_reviewed, &stats_pages_skipped, &stats_pages_rewritten);
+        __wt_block_compact_get_progress_stats(session, bm, &stats_pages_reviewed,
+          &stats_pages_skipped, &stats_pages_rewritten, &stats_pages_rewritten_expected);
         if (stats_pages_reviewed == 0)
             __wt_verbose_info(session, WT_VERB_COMPACT,
               "%s: there is no useful work to do - skipping compaction", bm->block->name);
@@ -342,11 +344,13 @@ __wt_compact(WT_SESSION_IMPL *session)
     for (i = 0;;) {
 
         /* Track progress. */
-        __wt_block_compact_get_progress_stats(
-          session, bm, &stats_pages_reviewed, &stats_pages_skipped, &stats_pages_rewritten);
+        __wt_block_compact_get_progress_stats(session, bm, &stats_pages_reviewed,
+          &stats_pages_skipped, &stats_pages_rewritten, &stats_pages_rewritten_expected);
         WT_STAT_DATA_SET(session, btree_compact_pages_reviewed, stats_pages_reviewed);
         WT_STAT_DATA_SET(session, btree_compact_pages_skipped, stats_pages_skipped);
         WT_STAT_DATA_SET(session, btree_compact_pages_rewritten, stats_pages_rewritten);
+        WT_STAT_DATA_SET(
+          session, btree_compact_pages_rewritten_expected, stats_pages_rewritten_expected);
 
         /*
          * Periodically check if we've timed out or eviction is stuck. Quit if eviction is stuck,
@@ -393,8 +397,10 @@ __wt_compact(WT_SESSION_IMPL *session)
          * page when it is being read in. Handle that here, by re-checking the page type now that
          * the page is in memory.
          */
-        if (F_ISSET(ref, WT_REF_FLAG_INTERNAL))
+        if (F_ISSET(ref, WT_REF_FLAG_INTERNAL)) {
+            bm->block->compact_internal_pages_reviewed++;
             WT_WITH_PAGE_INDEX(session, ret = __compact_walk_internal(session, ref));
+        }
 
         WT_ERR(ret);
     }
diff --git a/src/third_party/wiredtiger/src/include/block.h b/src/third_party/wiredtiger/src/include/block.h
index 4f6ab05bdff..b292491615f 100644
--- a/src/third_party/wiredtiger/src/include/block.h
+++ b/src/third_party/wiredtiger/src/include/block.h
@@ -115,6 +115,15 @@ struct __wt_size {
     for ((skip) = (head)[0]; (skip) != NULL; (skip) = (skip)->next[(skip)->depth])
 
 /*
+ * WT_EXT_FOREACH_FROM_OFFSET_INCL --
+ *	Walk a by-offset skiplist from the given offset, starting with the extent that contains the
+ * given offset if available.
+ */
+#define WT_EXT_FOREACH_FROM_OFFSET_INCL(skip, el, start)                        \
+    for ((skip) = __wt_block_off_srch_inclusive((el), (start)); (skip) != NULL; \
+         (skip) = (skip)->next[0])
+
+/*
  * Checkpoint cookie: carries a version number as I don't want to rev the schema
  * file version should the default block manager checkpoint format change.
  *
@@ -276,10 +285,14 @@ struct __wt_block {
     WT_CKPT *final_ckpt; /* Final live checkpoint write */
 
     /* Compaction support */
-    int compact_pct_tenths;           /* Percent to compact */
-    uint64_t compact_pages_rewritten; /* Pages rewritten */
-    uint64_t compact_pages_reviewed;  /* Pages reviewed */
-    uint64_t compact_pages_skipped;   /* Pages skipped */
+    int compact_pct_tenths;                    /* Percent to compact */
+    uint64_t compact_bytes_reviewed;           /* Bytes reviewed */
+    uint64_t compact_bytes_rewritten;          /* Bytes rewritten */
+    uint64_t compact_internal_pages_reviewed;  /* Internal pages reviewed */
+    uint64_t compact_pages_reviewed;           /* Pages reviewed */
+    uint64_t compact_pages_rewritten;          /* Pages rewritten */
+    uint64_t compact_pages_rewritten_expected; /* The expected number of pages to rewrite */
+    uint64_t compact_pages_skipped;            /* Pages skipped */
 
     /* Salvage support */
     wt_off_t slvg_off; /* Salvage file offset */
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index e050a103d4d..a3ffa3efdf8 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -1,5 +1,7 @@
 extern WT_DATA_SOURCE *__wt_schema_get_source(WT_SESSION_IMPL *session, const char *name)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern WT_EXT *__wt_block_off_srch_inclusive(WT_EXTLIST *el, wt_off_t off)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern WT_HAZARD *__wt_hazard_check(WT_SESSION_IMPL *session, WT_REF *ref,
   WT_SESSION_IMPL **sessionp) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern WT_THREAD_RET __wt_cache_pool_server(void *arg)
@@ -1780,7 +1782,8 @@ extern void __wt_blkcache_remove(WT_SESSION_IMPL *session, const uint8_t *addr,
 extern void __wt_blkcache_set_readonly(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((cold));
 extern void __wt_block_ckpt_destroy(WT_SESSION_IMPL *session, WT_BLOCK_CKPT *ci);
 extern void __wt_block_compact_get_progress_stats(WT_SESSION_IMPL *session, WT_BM *bm,
-  uint64_t *pages_reviewedp, uint64_t *pages_skippedp, uint64_t *pages_rewrittenp);
+  uint64_t *pages_reviewedp, uint64_t *pages_skippedp, uint64_t *pages_rewrittenp,
+  uint64_t *pages_rewritten_expectedp);
 extern void __wt_block_compact_progress(
   WT_SESSION_IMPL *session, WT_BLOCK *block, u_int *msg_countp);
 extern void __wt_block_configure_first_fit(WT_BLOCK *block, bool on);
diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h
index 36125f570c7..16ba8423160 100644
--- a/src/third_party/wiredtiger/src/include/stat.h
+++ b/src/third_party/wiredtiger/src/include/stat.h
@@ -969,6 +969,7 @@ struct __wt_dsrc_stats {
     int64_t btree_compact_pages_reviewed;
     int64_t btree_compact_pages_rewritten;
     int64_t btree_compact_pages_skipped;
+    int64_t btree_compact_pages_rewritten_expected;
     int64_t btree_compact_skipped;
     int64_t btree_column_fix;
     int64_t btree_column_tws;
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index 27281d38410..5c7ef060d3f 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -6854,764 +6854,766 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection);
 #define	WT_STAT_DSRC_BTREE_COMPACT_PAGES_REWRITTEN	2027
 /*! btree: btree compact pages skipped */
 #define	WT_STAT_DSRC_BTREE_COMPACT_PAGES_SKIPPED	2028
+/*! btree: btree expected number of compact pages rewritten */
+#define	WT_STAT_DSRC_BTREE_COMPACT_PAGES_REWRITTEN_EXPECTED	2029
 /*! btree: btree skipped by compaction as process would not reduce size */
-#define	WT_STAT_DSRC_BTREE_COMPACT_SKIPPED		2029
+#define	WT_STAT_DSRC_BTREE_COMPACT_SKIPPED		2030
 /*!
  * btree: column-store fixed-size leaf pages, only reported if tree_walk
  * or all statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_FIX			2030
+#define	WT_STAT_DSRC_BTREE_COLUMN_FIX			2031
 /*!
  * btree: column-store fixed-size time windows, only reported if
  * tree_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_TWS			2031
+#define	WT_STAT_DSRC_BTREE_COLUMN_TWS			2032
 /*!
  * btree: column-store internal pages, only reported if tree_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_INTERNAL		2032
+#define	WT_STAT_DSRC_BTREE_COLUMN_INTERNAL		2033
 /*!
  * btree: column-store variable-size RLE encoded values, only reported if
  * tree_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_RLE			2033
+#define	WT_STAT_DSRC_BTREE_COLUMN_RLE			2034
 /*!
  * btree: column-store variable-size deleted values, only reported if
  * tree_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_DELETED		2034
+#define	WT_STAT_DSRC_BTREE_COLUMN_DELETED		2035
 /*!
  * btree: column-store variable-size leaf pages, only reported if
  * tree_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_COLUMN_VARIABLE		2035
+#define	WT_STAT_DSRC_BTREE_COLUMN_VARIABLE		2036
 /*! btree: fixed-record size */
-#define	WT_STAT_DSRC_BTREE_FIXED_LEN			2036
+#define	WT_STAT_DSRC_BTREE_FIXED_LEN			2037
 /*! btree: maximum internal page size */
-#define	WT_STAT_DSRC_BTREE_MAXINTLPAGE			2037
+#define	WT_STAT_DSRC_BTREE_MAXINTLPAGE			2038
 /*! btree: maximum leaf page key size */
-#define	WT_STAT_DSRC_BTREE_MAXLEAFKEY			2038
+#define	WT_STAT_DSRC_BTREE_MAXLEAFKEY			2039
 /*! btree: maximum leaf page size */
-#define	WT_STAT_DSRC_BTREE_MAXLEAFPAGE			2039
+#define	WT_STAT_DSRC_BTREE_MAXLEAFPAGE			2040
 /*! btree: maximum leaf page value size */
-#define	WT_STAT_DSRC_BTREE_MAXLEAFVALUE			2040
+#define	WT_STAT_DSRC_BTREE_MAXLEAFVALUE			2041
 /*! btree: maximum tree depth */
-#define	WT_STAT_DSRC_BTREE_MAXIMUM_DEPTH		2041
+#define	WT_STAT_DSRC_BTREE_MAXIMUM_DEPTH		2042
 /*!
  * btree: number of key/value pairs, only reported if tree_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_ENTRIES			2042
+#define	WT_STAT_DSRC_BTREE_ENTRIES			2043
 /*!
  * btree: overflow pages, only reported if tree_walk or all statistics
  * are enabled
  */
-#define	WT_STAT_DSRC_BTREE_OVERFLOW			2043
+#define	WT_STAT_DSRC_BTREE_OVERFLOW			2044
 /*!
  * btree: row-store empty values, only reported if tree_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_ROW_EMPTY_VALUES		2044
+#define	WT_STAT_DSRC_BTREE_ROW_EMPTY_VALUES		2045
 /*!
  * btree: row-store internal pages, only reported if tree_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_ROW_INTERNAL			2045
+#define	WT_STAT_DSRC_BTREE_ROW_INTERNAL			2046
 /*!
  * btree: row-store leaf pages, only reported if tree_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_BTREE_ROW_LEAF			2046
+#define	WT_STAT_DSRC_BTREE_ROW_LEAF			2047
 /*! cache: bytes currently in the cache */
-#define	WT_STAT_DSRC_CACHE_BYTES_INUSE			2047
+#define	WT_STAT_DSRC_CACHE_BYTES_INUSE			2048
 /*! cache: bytes dirty in the cache cumulative */
-#define	WT_STAT_DSRC_CACHE_BYTES_DIRTY_TOTAL		2048
+#define	WT_STAT_DSRC_CACHE_BYTES_DIRTY_TOTAL		2049
 /*! cache: bytes read into cache */
-#define	WT_STAT_DSRC_CACHE_BYTES_READ			2049
+#define	WT_STAT_DSRC_CACHE_BYTES_READ			2050
 /*! cache: bytes written from cache */
-#define	WT_STAT_DSRC_CACHE_BYTES_WRITE			2050
+#define	WT_STAT_DSRC_CACHE_BYTES_WRITE			2051
 /*! cache: checkpoint blocked page eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT	2051
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT	2052
 /*!
  * cache: checkpoint of history store file blocked non-history store page
  * eviction
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS	2052
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS	2053
 /*! cache: data source pages selected for eviction unable to be evicted */
-#define	WT_STAT_DSRC_CACHE_EVICTION_FAIL		2053
+#define	WT_STAT_DSRC_CACHE_EVICTION_FAIL		2054
 /*!
  * cache: eviction gave up due to detecting a disk value without a
  * timestamp behind the last update on the chain
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_1	2054
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_1	2055
 /*!
  * cache: eviction gave up due to detecting a tombstone without a
  * timestamp ahead of the selected on disk update
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_2	2055
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_2	2056
 /*!
  * cache: eviction gave up due to detecting a tombstone without a
  * timestamp ahead of the selected on disk update after validating the
  * update chain
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_3	2056
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_3	2057
 /*!
  * cache: eviction gave up due to detecting update chain entries without
  * timestamps after the selected on disk update
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_4	2057
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_4	2058
 /*!
  * cache: eviction gave up due to needing to remove a record from the
  * history store but checkpoint is running
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_REMOVE_HS_RACE_WITH_CHECKPOINT	2058
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_REMOVE_HS_RACE_WITH_CHECKPOINT	2059
 /*! cache: eviction walk passes of a file */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_PASSES		2059
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_PASSES		2060
 /*! cache: eviction walk target pages histogram - 0-9 */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT10	2060
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT10	2061
 /*! cache: eviction walk target pages histogram - 10-31 */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT32	2061
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT32	2062
 /*! cache: eviction walk target pages histogram - 128 and higher */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_GE128	2062
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_GE128	2063
 /*! cache: eviction walk target pages histogram - 32-63 */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT64	2063
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT64	2064
 /*! cache: eviction walk target pages histogram - 64-128 */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT128	2064
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT128	2065
 /*!
  * cache: eviction walk target pages reduced due to history store cache
  * pressure
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_REDUCED	2065
+#define	WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_REDUCED	2066
 /*! cache: eviction walks abandoned */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_ABANDONED	2066
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_ABANDONED	2067
 /*! cache: eviction walks gave up because they restarted their walk twice */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_STOPPED	2067
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_STOPPED	2068
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found no candidates
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	2068
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	2069
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found too few candidates
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	2069
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	2070
 /*! cache: eviction walks reached end of tree */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_ENDED		2070
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALKS_ENDED		2071
 /*! cache: eviction walks restarted */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_RESTART	2071
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_RESTART	2072
 /*! cache: eviction walks started from root of tree */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_FROM_ROOT	2072
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_FROM_ROOT	2073
 /*! cache: eviction walks started from saved location in tree */
-#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_SAVED_POS	2073
+#define	WT_STAT_DSRC_CACHE_EVICTION_WALK_SAVED_POS	2074
 /*! cache: hazard pointer blocked page eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_HAZARD	2074
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_HAZARD	2075
 /*! cache: history store table insert calls */
-#define	WT_STAT_DSRC_CACHE_HS_INSERT			2075
+#define	WT_STAT_DSRC_CACHE_HS_INSERT			2076
 /*! cache: history store table insert calls that returned restart */
-#define	WT_STAT_DSRC_CACHE_HS_INSERT_RESTART		2076
+#define	WT_STAT_DSRC_CACHE_HS_INSERT_RESTART		2077
 /*! cache: history store table reads */
-#define	WT_STAT_DSRC_CACHE_HS_READ			2077
+#define	WT_STAT_DSRC_CACHE_HS_READ			2078
 /*! cache: history store table reads missed */
-#define	WT_STAT_DSRC_CACHE_HS_READ_MISS			2078
+#define	WT_STAT_DSRC_CACHE_HS_READ_MISS			2079
 /*! cache: history store table reads requiring squashed modifies */
-#define	WT_STAT_DSRC_CACHE_HS_READ_SQUASH		2079
+#define	WT_STAT_DSRC_CACHE_HS_READ_SQUASH		2080
 /*!
  * cache: history store table resolved updates without timestamps that
  * lose their durable timestamp
  */
-#define	WT_STAT_DSRC_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP	2080
+#define	WT_STAT_DSRC_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP	2081
 /*!
  * cache: history store table truncation by rollback to stable to remove
  * an unstable update
  */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE	2081
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE	2082
 /*!
  * cache: history store table truncation by rollback to stable to remove
  * an update
  */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS		2082
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS		2083
 /*!
  * cache: history store table truncation to remove all the keys of a
  * btree
  */
-#define	WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE		2083
+#define	WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE		2084
 /*! cache: history store table truncation to remove an update */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE		2084
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE		2085
 /*!
  * cache: history store table truncation to remove range of updates due
  * to an update without a timestamp on data page
  */
-#define	WT_STAT_DSRC_CACHE_HS_ORDER_REMOVE		2085
+#define	WT_STAT_DSRC_CACHE_HS_ORDER_REMOVE		2086
 /*!
  * cache: history store table truncation to remove range of updates due
  * to key being removed from the data page during reconciliation
  */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL	2086
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL	2087
 /*!
  * cache: history store table truncations that would have happened in
  * non-dryrun mode
  */
-#define	WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE_DRYRUN	2087
+#define	WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE_DRYRUN	2088
 /*!
  * cache: history store table truncations to remove an unstable update
  * that would have happened in non-dryrun mode
  */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE_DRYRUN	2088
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE_DRYRUN	2089
 /*!
  * cache: history store table truncations to remove an update that would
  * have happened in non-dryrun mode
  */
-#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_DRYRUN	2089
+#define	WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_DRYRUN	2090
 /*!
  * cache: history store table updates without timestamps fixed up by
  * reinserting with the fixed timestamp
  */
-#define	WT_STAT_DSRC_CACHE_HS_ORDER_REINSERT		2090
+#define	WT_STAT_DSRC_CACHE_HS_ORDER_REINSERT		2091
 /*! cache: history store table writes requiring squashed modifies */
-#define	WT_STAT_DSRC_CACHE_HS_WRITE_SQUASH		2091
+#define	WT_STAT_DSRC_CACHE_HS_WRITE_SQUASH		2092
 /*! cache: in-memory page passed criteria to be split */
-#define	WT_STAT_DSRC_CACHE_INMEM_SPLITTABLE		2092
+#define	WT_STAT_DSRC_CACHE_INMEM_SPLITTABLE		2093
 /*! cache: in-memory page splits */
-#define	WT_STAT_DSRC_CACHE_INMEM_SPLIT			2093
+#define	WT_STAT_DSRC_CACHE_INMEM_SPLIT			2094
 /*! cache: internal page split blocked its eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_INTERNAL_PAGE_SPLIT	2094
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_INTERNAL_PAGE_SPLIT	2095
 /*! cache: internal pages evicted */
-#define	WT_STAT_DSRC_CACHE_EVICTION_INTERNAL		2095
+#define	WT_STAT_DSRC_CACHE_EVICTION_INTERNAL		2096
 /*! cache: internal pages split during eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_SPLIT_INTERNAL	2096
+#define	WT_STAT_DSRC_CACHE_EVICTION_SPLIT_INTERNAL	2097
 /*! cache: leaf pages split during eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_SPLIT_LEAF		2097
+#define	WT_STAT_DSRC_CACHE_EVICTION_SPLIT_LEAF		2098
 /*! cache: modified pages evicted */
-#define	WT_STAT_DSRC_CACHE_EVICTION_DIRTY		2098
+#define	WT_STAT_DSRC_CACHE_EVICTION_DIRTY		2099
 /*!
  * cache: overflow keys on a multiblock row-store page blocked its
  * eviction
  */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_OVERFLOW_KEYS	2099
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_OVERFLOW_KEYS	2100
 /*! cache: overflow pages read into cache */
-#define	WT_STAT_DSRC_CACHE_READ_OVERFLOW		2100
+#define	WT_STAT_DSRC_CACHE_READ_OVERFLOW		2101
 /*! cache: page split during eviction deepened the tree */
-#define	WT_STAT_DSRC_CACHE_EVICTION_DEEPEN		2101
+#define	WT_STAT_DSRC_CACHE_EVICTION_DEEPEN		2102
 /*! cache: page written requiring history store records */
-#define	WT_STAT_DSRC_CACHE_WRITE_HS			2102
+#define	WT_STAT_DSRC_CACHE_WRITE_HS			2103
 /*! cache: pages read into cache */
-#define	WT_STAT_DSRC_CACHE_READ				2103
+#define	WT_STAT_DSRC_CACHE_READ				2104
 /*! cache: pages read into cache after truncate */
-#define	WT_STAT_DSRC_CACHE_READ_DELETED			2104
+#define	WT_STAT_DSRC_CACHE_READ_DELETED			2105
 /*! cache: pages read into cache after truncate in prepare state */
-#define	WT_STAT_DSRC_CACHE_READ_DELETED_PREPARED	2105
+#define	WT_STAT_DSRC_CACHE_READ_DELETED_PREPARED	2106
 /*! cache: pages requested from the cache */
-#define	WT_STAT_DSRC_CACHE_PAGES_REQUESTED		2106
+#define	WT_STAT_DSRC_CACHE_PAGES_REQUESTED		2107
 /*! cache: pages seen by eviction walk */
-#define	WT_STAT_DSRC_CACHE_EVICTION_PAGES_SEEN		2107
+#define	WT_STAT_DSRC_CACHE_EVICTION_PAGES_SEEN		2108
 /*! cache: pages written from cache */
-#define	WT_STAT_DSRC_CACHE_WRITE			2108
+#define	WT_STAT_DSRC_CACHE_WRITE			2109
 /*! cache: pages written requiring in-memory restoration */
-#define	WT_STAT_DSRC_CACHE_WRITE_RESTORE		2109
+#define	WT_STAT_DSRC_CACHE_WRITE_RESTORE		2110
 /*! cache: recent modification of a page blocked its eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_RECENTLY_MODIFIED	2110
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_RECENTLY_MODIFIED	2111
 /*! cache: reverse splits performed */
-#define	WT_STAT_DSRC_CACHE_REVERSE_SPLITS		2111
+#define	WT_STAT_DSRC_CACHE_REVERSE_SPLITS		2112
 /*!
  * cache: reverse splits skipped because of VLCS namespace gap
  * restrictions
  */
-#define	WT_STAT_DSRC_CACHE_REVERSE_SPLITS_SKIPPED_VLCS	2112
+#define	WT_STAT_DSRC_CACHE_REVERSE_SPLITS_SKIPPED_VLCS	2113
 /*! cache: the number of times full update inserted to history store */
-#define	WT_STAT_DSRC_CACHE_HS_INSERT_FULL_UPDATE	2113
+#define	WT_STAT_DSRC_CACHE_HS_INSERT_FULL_UPDATE	2114
 /*! cache: the number of times reverse modify inserted to history store */
-#define	WT_STAT_DSRC_CACHE_HS_INSERT_REVERSE_MODIFY	2114
+#define	WT_STAT_DSRC_CACHE_HS_INSERT_REVERSE_MODIFY	2115
 /*! cache: tracked dirty bytes in the cache */
-#define	WT_STAT_DSRC_CACHE_BYTES_DIRTY			2115
+#define	WT_STAT_DSRC_CACHE_BYTES_DIRTY			2116
 /*! cache: uncommitted truncate blocked page eviction */
-#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_UNCOMMITTED_TRUNCATE	2116
+#define	WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_UNCOMMITTED_TRUNCATE	2117
 /*! cache: unmodified pages evicted */
-#define	WT_STAT_DSRC_CACHE_EVICTION_CLEAN		2117
+#define	WT_STAT_DSRC_CACHE_EVICTION_CLEAN		2118
 /*!
  * cache_walk: Average difference between current eviction generation
  * when the page was last considered, only reported if cache_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_GEN_AVG_GAP		2118
+#define	WT_STAT_DSRC_CACHE_STATE_GEN_AVG_GAP		2119
 /*!
  * cache_walk: Average on-disk page image size seen, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_AVG_WRITTEN_SIZE	2119
+#define	WT_STAT_DSRC_CACHE_STATE_AVG_WRITTEN_SIZE	2120
 /*!
  * cache_walk: Average time in cache for pages that have been visited by
  * the eviction server, only reported if cache_walk or all statistics are
  * enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_AVG_VISITED_AGE	2120
+#define	WT_STAT_DSRC_CACHE_STATE_AVG_VISITED_AGE	2121
 /*!
  * cache_walk: Average time in cache for pages that have not been visited
  * by the eviction server, only reported if cache_walk or all statistics
  * are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_AVG_UNVISITED_AGE	2121
+#define	WT_STAT_DSRC_CACHE_STATE_AVG_UNVISITED_AGE	2122
 /*!
  * cache_walk: Clean pages currently in cache, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_PAGES_CLEAN		2122
+#define	WT_STAT_DSRC_CACHE_STATE_PAGES_CLEAN		2123
 /*!
  * cache_walk: Current eviction generation, only reported if cache_walk
  * or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_GEN_CURRENT		2123
+#define	WT_STAT_DSRC_CACHE_STATE_GEN_CURRENT		2124
 /*!
  * cache_walk: Dirty pages currently in cache, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_PAGES_DIRTY		2124
+#define	WT_STAT_DSRC_CACHE_STATE_PAGES_DIRTY		2125
 /*!
  * cache_walk: Entries in the root page, only reported if cache_walk or
  * all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_ROOT_ENTRIES		2125
+#define	WT_STAT_DSRC_CACHE_STATE_ROOT_ENTRIES		2126
 /*!
  * cache_walk: Internal pages currently in cache, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_PAGES_INTERNAL		2126
+#define	WT_STAT_DSRC_CACHE_STATE_PAGES_INTERNAL		2127
 /*!
  * cache_walk: Leaf pages currently in cache, only reported if cache_walk
  * or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_PAGES_LEAF		2127
+#define	WT_STAT_DSRC_CACHE_STATE_PAGES_LEAF		2128
 /*!
  * cache_walk: Maximum difference between current eviction generation
  * when the page was last considered, only reported if cache_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_GEN_MAX_GAP		2128
+#define	WT_STAT_DSRC_CACHE_STATE_GEN_MAX_GAP		2129
 /*!
  * cache_walk: Maximum page size seen, only reported if cache_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_MAX_PAGESIZE		2129
+#define	WT_STAT_DSRC_CACHE_STATE_MAX_PAGESIZE		2130
 /*!
  * cache_walk: Minimum on-disk page image size seen, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_MIN_WRITTEN_SIZE	2130
+#define	WT_STAT_DSRC_CACHE_STATE_MIN_WRITTEN_SIZE	2131
 /*!
  * cache_walk: Number of pages never visited by eviction server, only
  * reported if cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_UNVISITED_COUNT	2131
+#define	WT_STAT_DSRC_CACHE_STATE_UNVISITED_COUNT	2132
 /*!
  * cache_walk: On-disk page image sizes smaller than a single allocation
  * unit, only reported if cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_SMALLER_ALLOC_SIZE	2132
+#define	WT_STAT_DSRC_CACHE_STATE_SMALLER_ALLOC_SIZE	2133
 /*!
  * cache_walk: Pages created in memory and never written, only reported
  * if cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_MEMORY			2133
+#define	WT_STAT_DSRC_CACHE_STATE_MEMORY			2134
 /*!
  * cache_walk: Pages currently queued for eviction, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_QUEUED			2134
+#define	WT_STAT_DSRC_CACHE_STATE_QUEUED			2135
 /*!
  * cache_walk: Pages that could not be queued for eviction, only reported
  * if cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_NOT_QUEUEABLE		2135
+#define	WT_STAT_DSRC_CACHE_STATE_NOT_QUEUEABLE		2136
 /*!
  * cache_walk: Refs skipped during cache traversal, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_REFS_SKIPPED		2136
+#define	WT_STAT_DSRC_CACHE_STATE_REFS_SKIPPED		2137
 /*!
  * cache_walk: Size of the root page, only reported if cache_walk or all
  * statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_ROOT_SIZE		2137
+#define	WT_STAT_DSRC_CACHE_STATE_ROOT_SIZE		2138
 /*!
  * cache_walk: Total number of pages currently in cache, only reported if
  * cache_walk or all statistics are enabled
  */
-#define	WT_STAT_DSRC_CACHE_STATE_PAGES			2138
+#define	WT_STAT_DSRC_CACHE_STATE_PAGES			2139
 /*! checkpoint-cleanup: pages added for eviction */
-#define	WT_STAT_DSRC_CC_PAGES_EVICT			2139
+#define	WT_STAT_DSRC_CC_PAGES_EVICT			2140
 /*! checkpoint-cleanup: pages removed */
-#define	WT_STAT_DSRC_CC_PAGES_REMOVED			2140
+#define	WT_STAT_DSRC_CC_PAGES_REMOVED			2141
 /*! checkpoint-cleanup: pages skipped during tree walk */
-#define	WT_STAT_DSRC_CC_PAGES_WALK_SKIPPED		2141
+#define	WT_STAT_DSRC_CC_PAGES_WALK_SKIPPED		2142
 /*! checkpoint-cleanup: pages visited */
-#define	WT_STAT_DSRC_CC_PAGES_VISITED			2142
+#define	WT_STAT_DSRC_CC_PAGES_VISITED			2143
 /*!
  * compression: compressed page maximum internal page size prior to
  * compression
  */
-#define	WT_STAT_DSRC_COMPRESS_PRECOMP_INTL_MAX_PAGE_SIZE	2143
+#define	WT_STAT_DSRC_COMPRESS_PRECOMP_INTL_MAX_PAGE_SIZE	2144
 /*!
  * compression: compressed page maximum leaf page size prior to
  * compression
  */
-#define	WT_STAT_DSRC_COMPRESS_PRECOMP_LEAF_MAX_PAGE_SIZE	2144
+#define	WT_STAT_DSRC_COMPRESS_PRECOMP_LEAF_MAX_PAGE_SIZE	2145
 /*! compression: compressed pages read */
-#define	WT_STAT_DSRC_COMPRESS_READ			2145
+#define	WT_STAT_DSRC_COMPRESS_READ			2146
 /*! compression: compressed pages written */
-#define	WT_STAT_DSRC_COMPRESS_WRITE			2146
+#define	WT_STAT_DSRC_COMPRESS_WRITE			2147
 /*! compression: number of blocks with compress ratio greater than 64 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_MAX		2147
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_MAX		2148
 /*! compression: number of blocks with compress ratio smaller than 16 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_16		2148
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_16		2149
 /*! compression: number of blocks with compress ratio smaller than 2 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_2		2149
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_2		2150
 /*! compression: number of blocks with compress ratio smaller than 32 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_32		2150
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_32		2151
 /*! compression: number of blocks with compress ratio smaller than 4 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_4		2151
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_4		2152
 /*! compression: number of blocks with compress ratio smaller than 64 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_64		2152
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_64		2153
 /*! compression: number of blocks with compress ratio smaller than 8 */
-#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_8		2153
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_8		2154
 /*! compression: page written failed to compress */
-#define	WT_STAT_DSRC_COMPRESS_WRITE_FAIL		2154
+#define	WT_STAT_DSRC_COMPRESS_WRITE_FAIL		2155
 /*! compression: page written was too small to compress */
-#define	WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL		2155
+#define	WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL		2156
 /*! cursor: Total number of entries skipped by cursor next calls */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_TOTAL		2156
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_TOTAL		2157
 /*! cursor: Total number of entries skipped by cursor prev calls */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_TOTAL		2157
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_TOTAL		2158
 /*!
  * cursor: Total number of entries skipped to position the history store
  * cursor
  */
-#define	WT_STAT_DSRC_CURSOR_SKIP_HS_CUR_POSITION	2158
+#define	WT_STAT_DSRC_CURSOR_SKIP_HS_CUR_POSITION	2159
 /*!
  * cursor: Total number of times a search near has exited due to prefix
  * config
  */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	2159
+#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	2160
 /*!
  * cursor: Total number of times cursor fails to temporarily release
  * pinned page to encourage eviction of hot or large page
  */
-#define	WT_STAT_DSRC_CURSOR_REPOSITION_FAILED		2160
+#define	WT_STAT_DSRC_CURSOR_REPOSITION_FAILED		2161
 /*!
  * cursor: Total number of times cursor temporarily releases pinned page
  * to encourage eviction of hot or large page
  */
-#define	WT_STAT_DSRC_CURSOR_REPOSITION			2161
+#define	WT_STAT_DSRC_CURSOR_REPOSITION			2162
 /*! cursor: bulk loaded cursor insert calls */
-#define	WT_STAT_DSRC_CURSOR_INSERT_BULK			2162
+#define	WT_STAT_DSRC_CURSOR_INSERT_BULK			2163
 /*! cursor: cache cursors reuse count */
-#define	WT_STAT_DSRC_CURSOR_REOPEN			2163
+#define	WT_STAT_DSRC_CURSOR_REOPEN			2164
 /*! cursor: close calls that result in cache */
-#define	WT_STAT_DSRC_CURSOR_CACHE			2164
+#define	WT_STAT_DSRC_CURSOR_CACHE			2165
 /*! cursor: create calls */
-#define	WT_STAT_DSRC_CURSOR_CREATE			2165
+#define	WT_STAT_DSRC_CURSOR_CREATE			2166
 /*! cursor: cursor bound calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_BOUND_ERROR			2166
+#define	WT_STAT_DSRC_CURSOR_BOUND_ERROR			2167
 /*! cursor: cursor bounds cleared from reset */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_RESET		2167
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_RESET		2168
 /*! cursor: cursor bounds comparisons performed */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_COMPARISONS		2168
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_COMPARISONS		2169
 /*! cursor: cursor bounds next called on an unpositioned cursor */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_UNPOSITIONED	2169
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_UNPOSITIONED	2170
 /*! cursor: cursor bounds next early exit */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_EARLY_EXIT	2170
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_EARLY_EXIT	2171
 /*! cursor: cursor bounds prev called on an unpositioned cursor */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_PREV_UNPOSITIONED	2171
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_PREV_UNPOSITIONED	2172
 /*! cursor: cursor bounds prev early exit */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_PREV_EARLY_EXIT	2172
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_PREV_EARLY_EXIT	2173
 /*! cursor: cursor bounds search early exit */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_EARLY_EXIT	2173
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_EARLY_EXIT	2174
 /*! cursor: cursor bounds search near call repositioned cursor */
-#define	WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_NEAR_REPOSITIONED_CURSOR	2174
+#define	WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_NEAR_REPOSITIONED_CURSOR	2175
 /*! cursor: cursor cache calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_CACHE_ERROR			2175
+#define	WT_STAT_DSRC_CURSOR_CACHE_ERROR			2176
 /*! cursor: cursor close calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_CLOSE_ERROR			2176
+#define	WT_STAT_DSRC_CURSOR_CLOSE_ERROR			2177
 /*! cursor: cursor compare calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_COMPARE_ERROR		2177
+#define	WT_STAT_DSRC_CURSOR_COMPARE_ERROR		2178
 /*! cursor: cursor equals calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_EQUALS_ERROR		2178
+#define	WT_STAT_DSRC_CURSOR_EQUALS_ERROR		2179
 /*! cursor: cursor get key calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_GET_KEY_ERROR		2179
+#define	WT_STAT_DSRC_CURSOR_GET_KEY_ERROR		2180
 /*! cursor: cursor get value calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_GET_VALUE_ERROR		2180
+#define	WT_STAT_DSRC_CURSOR_GET_VALUE_ERROR		2181
 /*! cursor: cursor insert calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_INSERT_ERROR		2181
+#define	WT_STAT_DSRC_CURSOR_INSERT_ERROR		2182
 /*! cursor: cursor insert check calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_INSERT_CHECK_ERROR		2182
+#define	WT_STAT_DSRC_CURSOR_INSERT_CHECK_ERROR		2183
 /*! cursor: cursor largest key calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_LARGEST_KEY_ERROR		2183
+#define	WT_STAT_DSRC_CURSOR_LARGEST_KEY_ERROR		2184
 /*! cursor: cursor modify calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_MODIFY_ERROR		2184
+#define	WT_STAT_DSRC_CURSOR_MODIFY_ERROR		2185
 /*! cursor: cursor next calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_NEXT_ERROR			2185
+#define	WT_STAT_DSRC_CURSOR_NEXT_ERROR			2186
 /*!
  * cursor: cursor next calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_DSRC_CURSOR_NEXT_HS_TOMBSTONE		2186
+#define	WT_STAT_DSRC_CURSOR_NEXT_HS_TOMBSTONE		2187
 /*!
  * cursor: cursor next calls that skip greater than 1 and fewer than 100
  * entries
  */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_LT_100		2187
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_LT_100		2188
 /*!
  * cursor: cursor next calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_GE_100		2188
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_GE_100		2189
 /*! cursor: cursor next random calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_NEXT_RANDOM_ERROR		2189
+#define	WT_STAT_DSRC_CURSOR_NEXT_RANDOM_ERROR		2190
 /*! cursor: cursor prev calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_PREV_ERROR			2190
+#define	WT_STAT_DSRC_CURSOR_PREV_ERROR			2191
 /*!
  * cursor: cursor prev calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_DSRC_CURSOR_PREV_HS_TOMBSTONE		2191
+#define	WT_STAT_DSRC_CURSOR_PREV_HS_TOMBSTONE		2192
 /*!
  * cursor: cursor prev calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_GE_100		2192
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_GE_100		2193
 /*! cursor: cursor prev calls that skip less than 100 entries */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_LT_100		2193
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_LT_100		2194
 /*! cursor: cursor reconfigure calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_RECONFIGURE_ERROR		2194
+#define	WT_STAT_DSRC_CURSOR_RECONFIGURE_ERROR		2195
 /*! cursor: cursor remove calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_REMOVE_ERROR		2195
+#define	WT_STAT_DSRC_CURSOR_REMOVE_ERROR		2196
 /*! cursor: cursor reopen calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_REOPEN_ERROR		2196
+#define	WT_STAT_DSRC_CURSOR_REOPEN_ERROR		2197
 /*! cursor: cursor reserve calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_RESERVE_ERROR		2197
+#define	WT_STAT_DSRC_CURSOR_RESERVE_ERROR		2198
 /*! cursor: cursor reset calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_RESET_ERROR			2198
+#define	WT_STAT_DSRC_CURSOR_RESET_ERROR			2199
 /*! cursor: cursor search calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_ERROR		2199
+#define	WT_STAT_DSRC_CURSOR_SEARCH_ERROR		2200
 /*! cursor: cursor search near calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_ERROR		2200
+#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_ERROR		2201
 /*! cursor: cursor update calls that return an error */
-#define	WT_STAT_DSRC_CURSOR_UPDATE_ERROR		2201
+#define	WT_STAT_DSRC_CURSOR_UPDATE_ERROR		2202
 /*! cursor: insert calls */
-#define	WT_STAT_DSRC_CURSOR_INSERT			2202
+#define	WT_STAT_DSRC_CURSOR_INSERT			2203
 /*! cursor: insert key and value bytes */
-#define	WT_STAT_DSRC_CURSOR_INSERT_BYTES		2203
+#define	WT_STAT_DSRC_CURSOR_INSERT_BYTES		2204
 /*! cursor: modify */
-#define	WT_STAT_DSRC_CURSOR_MODIFY			2204
+#define	WT_STAT_DSRC_CURSOR_MODIFY			2205
 /*! cursor: modify key and value bytes affected */
-#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES		2205
+#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES		2206
 /*! cursor: modify value bytes modified */
-#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH		2206
+#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH		2207
 /*! cursor: next calls */
-#define	WT_STAT_DSRC_CURSOR_NEXT			2207
+#define	WT_STAT_DSRC_CURSOR_NEXT			2208
 /*! cursor: open cursor count */
-#define	WT_STAT_DSRC_CURSOR_OPEN_COUNT			2208
+#define	WT_STAT_DSRC_CURSOR_OPEN_COUNT			2209
 /*! cursor: operation restarted */
-#define	WT_STAT_DSRC_CURSOR_RESTART			2209
+#define	WT_STAT_DSRC_CURSOR_RESTART			2210
 /*! cursor: prev calls */
-#define	WT_STAT_DSRC_CURSOR_PREV			2210
+#define	WT_STAT_DSRC_CURSOR_PREV			2211
 /*! cursor: remove calls */
-#define	WT_STAT_DSRC_CURSOR_REMOVE			2211
+#define	WT_STAT_DSRC_CURSOR_REMOVE			2212
 /*! cursor: remove key bytes removed */
-#define	WT_STAT_DSRC_CURSOR_REMOVE_BYTES		2212
+#define	WT_STAT_DSRC_CURSOR_REMOVE_BYTES		2213
 /*! cursor: reserve calls */
-#define	WT_STAT_DSRC_CURSOR_RESERVE			2213
+#define	WT_STAT_DSRC_CURSOR_RESERVE			2214
 /*! cursor: reset calls */
-#define	WT_STAT_DSRC_CURSOR_RESET			2214
+#define	WT_STAT_DSRC_CURSOR_RESET			2215
 /*! cursor: search calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH			2215
+#define	WT_STAT_DSRC_CURSOR_SEARCH			2216
 /*! cursor: search history store calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_HS			2216
+#define	WT_STAT_DSRC_CURSOR_SEARCH_HS			2217
 /*! cursor: search near calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR			2217
+#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR			2218
 /*! cursor: truncate calls */
-#define	WT_STAT_DSRC_CURSOR_TRUNCATE			2218
+#define	WT_STAT_DSRC_CURSOR_TRUNCATE			2219
 /*! cursor: update calls */
-#define	WT_STAT_DSRC_CURSOR_UPDATE			2219
+#define	WT_STAT_DSRC_CURSOR_UPDATE			2220
 /*! cursor: update key and value bytes */
-#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES		2220
+#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES		2221
 /*! cursor: update value size change */
-#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED	2221
+#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED	2222
 /*! reconciliation: VLCS pages explicitly reconciled as empty */
-#define	WT_STAT_DSRC_REC_VLCS_EMPTIED_PAGES		2222
+#define	WT_STAT_DSRC_REC_VLCS_EMPTIED_PAGES		2223
 /*! reconciliation: approximate byte size of timestamps in pages written */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TS		2223
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TS		2224
 /*!
  * reconciliation: approximate byte size of transaction IDs in pages
  * written
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TXN		2224
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TXN		2225
 /*! reconciliation: dictionary matches */
-#define	WT_STAT_DSRC_REC_DICTIONARY			2225
+#define	WT_STAT_DSRC_REC_DICTIONARY			2226
 /*! reconciliation: fast-path pages deleted */
-#define	WT_STAT_DSRC_REC_PAGE_DELETE_FAST		2226
+#define	WT_STAT_DSRC_REC_PAGE_DELETE_FAST		2227
 /*!
  * reconciliation: internal page key bytes discarded using suffix
  * compression
  */
-#define	WT_STAT_DSRC_REC_SUFFIX_COMPRESSION		2227
+#define	WT_STAT_DSRC_REC_SUFFIX_COMPRESSION		2228
 /*! reconciliation: internal page multi-block writes */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL		2228
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL		2229
 /*! reconciliation: leaf page key bytes discarded using prefix compression */
-#define	WT_STAT_DSRC_REC_PREFIX_COMPRESSION		2229
+#define	WT_STAT_DSRC_REC_PREFIX_COMPRESSION		2230
 /*! reconciliation: leaf page multi-block writes */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_LEAF		2230
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_LEAF		2231
 /*! reconciliation: leaf-page overflow keys */
-#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF		2231
+#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF		2232
 /*! reconciliation: maximum blocks required for a page */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_MAX			2232
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_MAX			2233
 /*! reconciliation: overflow values written */
-#define	WT_STAT_DSRC_REC_OVERFLOW_VALUE			2233
+#define	WT_STAT_DSRC_REC_OVERFLOW_VALUE			2234
 /*! reconciliation: page checksum matches */
-#define	WT_STAT_DSRC_REC_PAGE_MATCH			2234
+#define	WT_STAT_DSRC_REC_PAGE_MATCH			2235
 /*! reconciliation: page reconciliation calls */
-#define	WT_STAT_DSRC_REC_PAGES				2235
+#define	WT_STAT_DSRC_REC_PAGES				2236
 /*! reconciliation: page reconciliation calls for eviction */
-#define	WT_STAT_DSRC_REC_PAGES_EVICTION			2236
+#define	WT_STAT_DSRC_REC_PAGES_EVICTION			2237
 /*! reconciliation: pages deleted */
-#define	WT_STAT_DSRC_REC_PAGE_DELETE			2237
+#define	WT_STAT_DSRC_REC_PAGE_DELETE			2238
 /*!
  * reconciliation: pages written including an aggregated newest start
  * durable timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	2238
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	2239
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * durable timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	2239
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	2240
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TS	2240
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TS	2241
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * transaction ID
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TXN	2241
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TXN	2242
 /*!
  * reconciliation: pages written including an aggregated newest
  * transaction ID
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_TXN		2242
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_TXN		2243
 /*!
  * reconciliation: pages written including an aggregated oldest start
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_OLDEST_START_TS	2243
+#define	WT_STAT_DSRC_REC_TIME_AGGR_OLDEST_START_TS	2244
 /*! reconciliation: pages written including an aggregated prepare */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_PREPARED		2244
+#define	WT_STAT_DSRC_REC_TIME_AGGR_PREPARED		2245
 /*! reconciliation: pages written including at least one prepare */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_PREPARED	2245
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_PREPARED	2246
 /*!
  * reconciliation: pages written including at least one start durable
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	2246
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	2247
 /*! reconciliation: pages written including at least one start timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TS	2247
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TS	2248
 /*!
  * reconciliation: pages written including at least one start transaction
  * ID
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TXN	2248
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TXN	2249
 /*!
  * reconciliation: pages written including at least one stop durable
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	2249
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	2250
 /*! reconciliation: pages written including at least one stop timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TS	2250
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TS	2251
 /*!
  * reconciliation: pages written including at least one stop transaction
  * ID
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TXN	2251
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TXN	2252
 /*! reconciliation: records written including a prepare */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PREPARED		2252
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PREPARED		2253
 /*! reconciliation: records written including a start durable timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_START_TS	2253
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_START_TS	2254
 /*! reconciliation: records written including a start timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TS		2254
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TS		2255
 /*! reconciliation: records written including a start transaction ID */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TXN		2255
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TXN		2256
 /*! reconciliation: records written including a stop durable timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_STOP_TS	2256
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_STOP_TS	2257
 /*! reconciliation: records written including a stop timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TS		2257
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TS		2258
 /*! reconciliation: records written including a stop transaction ID */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TXN		2258
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TXN		2259
 /*! session: object compaction */
-#define	WT_STAT_DSRC_SESSION_COMPACT			2259
+#define	WT_STAT_DSRC_SESSION_COMPACT			2260
 /*! transaction: checkpoint has acquired a snapshot for its transaction */
-#define	WT_STAT_DSRC_TXN_CHECKPOINT_SNAPSHOT_ACQUIRED	2260
+#define	WT_STAT_DSRC_TXN_CHECKPOINT_SNAPSHOT_ACQUIRED	2261
 /*! transaction: number of times overflow removed value is read */
-#define	WT_STAT_DSRC_TXN_READ_OVERFLOW_REMOVE		2261
+#define	WT_STAT_DSRC_TXN_READ_OVERFLOW_REMOVE		2262
 /*! transaction: race to read prepared update retry */
-#define	WT_STAT_DSRC_TXN_READ_RACE_PREPARE_UPDATE	2262
+#define	WT_STAT_DSRC_TXN_READ_RACE_PREPARE_UPDATE	2263
 /*!
  * transaction: rollback to stable history store keys that would have
  * been swept in non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS_DRYRUN	2263
+#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS_DRYRUN	2264
 /*!
  * transaction: rollback to stable history store records with stop
  * timestamps older than newer records
  */
-#define	WT_STAT_DSRC_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START	2264
+#define	WT_STAT_DSRC_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START	2265
 /*! transaction: rollback to stable inconsistent checkpoint */
-#define	WT_STAT_DSRC_TXN_RTS_INCONSISTENT_CKPT		2265
+#define	WT_STAT_DSRC_TXN_RTS_INCONSISTENT_CKPT		2266
 /*! transaction: rollback to stable keys removed */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED		2266
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED		2267
 /*! transaction: rollback to stable keys restored */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED		2267
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED		2268
 /*!
  * transaction: rollback to stable keys that would have been removed in
  * non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED_DRYRUN	2268
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED_DRYRUN	2269
 /*!
  * transaction: rollback to stable keys that would have been restored in
  * non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED_DRYRUN	2269
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED_DRYRUN	2270
 /*! transaction: rollback to stable restored tombstones from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES	2270
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES	2271
 /*! transaction: rollback to stable restored updates from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES		2271
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES		2272
 /*! transaction: rollback to stable skipping delete rle */
-#define	WT_STAT_DSRC_TXN_RTS_DELETE_RLE_SKIPPED		2272
+#define	WT_STAT_DSRC_TXN_RTS_DELETE_RLE_SKIPPED		2273
 /*! transaction: rollback to stable skipping stable rle */
-#define	WT_STAT_DSRC_TXN_RTS_STABLE_RLE_SKIPPED		2273
+#define	WT_STAT_DSRC_TXN_RTS_STABLE_RLE_SKIPPED		2274
 /*! transaction: rollback to stable sweeping history store keys */
-#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS		2274
+#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS		2275
 /*!
  * transaction: rollback to stable tombstones from history store that
  * would have been restored in non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES_DRYRUN	2275
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES_DRYRUN	2276
 /*!
  * transaction: rollback to stable updates from history store that would
  * have been restored in non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES_DRYRUN	2276
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES_DRYRUN	2277
 /*! transaction: rollback to stable updates removed from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED			2277
+#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED			2278
 /*!
  * transaction: rollback to stable updates that would have been removed
  * from history store in non-dryrun mode
  */
-#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED_DRYRUN		2278
+#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED_DRYRUN		2279
 /*! transaction: transaction checkpoints due to obsolete pages */
-#define	WT_STAT_DSRC_TXN_CHECKPOINT_OBSOLETE_APPLIED	2279
+#define	WT_STAT_DSRC_TXN_CHECKPOINT_OBSOLETE_APPLIED	2280
 /*! transaction: update conflicts */
-#define	WT_STAT_DSRC_TXN_UPDATE_CONFLICT		2280
+#define	WT_STAT_DSRC_TXN_UPDATE_CONFLICT		2281
 
 /*!
  * @}
diff --git a/src/third_party/wiredtiger/src/session/session_compact.c b/src/third_party/wiredtiger/src/session/session_compact.c
index d5a72eb0393..d7e9065dc99 100644
--- a/src/third_party/wiredtiger/src/session/session_compact.c
+++ b/src/third_party/wiredtiger/src/session/session_compact.c
@@ -258,6 +258,8 @@ __compact_worker(WT_SESSION_IMPL *session)
                 continue;
 
             __wt_timing_stress(session, WT_TIMING_STRESS_COMPACT_SLOW, NULL);
+            __wt_verbose_debug2(
+              session, WT_VERB_COMPACT, "%s: compact pass %u", session->op_handle[i]->name, loop);
 
             session->compact_state = WT_COMPACT_RUNNING;
             WT_WITH_DHANDLE(session, session->op_handle[i], ret = __wt_compact(session));
@@ -332,6 +334,8 @@ __wt_session_compact(WT_SESSION *wt_session, const char *uri, const char *config
 
     WT_STAT_CONN_SET(session, session_table_compact_running, 1);
 
+    __wt_verbose_debug1(session, WT_VERB_COMPACT, "Compacting %s", uri);
+
     /*
      * The compaction thread should not block when the cache is full: it is holding locks blocking
      * checkpoints and once the cache is full, it can spend a long time doing eviction.
diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c
index 21a350f000f..8146104970d 100644
--- a/src/third_party/wiredtiger/src/support/stat.c
+++ b/src/third_party/wiredtiger/src/support/stat.c
@@ -32,6 +32,7 @@ static const char *const __stats_dsrc_desc[] = {
   "btree: btree compact pages reviewed",
   "btree: btree compact pages rewritten",
   "btree: btree compact pages skipped",
+  "btree: btree expected number of compact pages rewritten",
   "btree: btree skipped by compaction as process would not reduce size",
   "btree: column-store fixed-size leaf pages",
   "btree: column-store fixed-size time windows",
@@ -373,6 +374,7 @@ __wt_stat_dsrc_clear_single(WT_DSRC_STATS *stats)
     /* not clearing btree_compact_pages_reviewed */
     /* not clearing btree_compact_pages_rewritten */
     /* not clearing btree_compact_pages_skipped */
+    /* not clearing btree_compact_pages_rewritten_expected */
     /* not clearing btree_compact_skipped */
     stats->btree_column_fix = 0;
     stats->btree_column_tws = 0;
@@ -673,6 +675,7 @@ __wt_stat_dsrc_aggregate_single(WT_DSRC_STATS *from, WT_DSRC_STATS *to)
     to->btree_compact_pages_reviewed += from->btree_compact_pages_reviewed;
     to->btree_compact_pages_rewritten += from->btree_compact_pages_rewritten;
     to->btree_compact_pages_skipped += from->btree_compact_pages_skipped;
+    to->btree_compact_pages_rewritten_expected += from->btree_compact_pages_rewritten_expected;
     to->btree_compact_skipped += from->btree_compact_skipped;
     to->btree_column_fix += from->btree_column_fix;
     to->btree_column_tws += from->btree_column_tws;
@@ -982,6 +985,8 @@ __wt_stat_dsrc_aggregate(WT_DSRC_STATS **from, WT_DSRC_STATS *to)
     to->btree_compact_pages_reviewed += WT_STAT_READ(from, btree_compact_pages_reviewed);
     to->btree_compact_pages_rewritten += WT_STAT_READ(from, btree_compact_pages_rewritten);
     to->btree_compact_pages_skipped += WT_STAT_READ(from, btree_compact_pages_skipped);
+    to->btree_compact_pages_rewritten_expected +=
+      WT_STAT_READ(from, btree_compact_pages_rewritten_expected);
     to->btree_compact_skipped += WT_STAT_READ(from, btree_compact_skipped);
     to->btree_column_fix += WT_STAT_READ(from, btree_column_fix);
     to->btree_column_tws += WT_STAT_READ(from, btree_column_tws);
diff --git a/src/third_party/wiredtiger/test/suite/test_compact04.py b/src/third_party/wiredtiger/test/suite/test_compact04.py
new file mode 100644
index 00000000000..06eed62b93c
--- /dev/null
+++ b/src/third_party/wiredtiger/test/suite/test_compact04.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+#
+# Public Domain 2014-present MongoDB, Inc.
+# Public Domain 2008-2014 WiredTiger, Inc.
+#
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# test_compact04.py
+#   Test the accuracy of compact work estimation.
+#
+
+import time, wiredtiger, wttest
+from wiredtiger import stat
+
+# Test the accuracy of compact work estimation.
+class test_compact04(wttest.WiredTigerTestCase):
+
+    conn_config = 'statistics=(all),cache_size=100MB'
+    # Uncomment for debugging:
+    # conn_config += ',verbose=(compact_progress,compact:4)'
+    create_params = 'key_format=i,value_format=S,allocation_size=4KB,leaf_page_max=32KB,'
+    table_numkv = 100 * 1000
+    table_uri='table:test_compact04'
+
+    delete_range_len = 10 * 1000
+    delete_ranges_count = 4
+    value_size = 1024 # The value should be small enough so that we don't create overflow pages.
+
+    # Create the table in a way that it creates a mostly empty file.
+    def test_compact04(self):
+
+        # Create the table and populate it with a lot of data
+        self.session.create(self.table_uri, self.create_params)
+        c = self.session.open_cursor(self.table_uri, None)
+        for k in range(self.table_numkv):
+            c[k] = ('%07d' % k) + '_' + 'abcd' * ((self.value_size // 4) - 2)
+        c.close()
+        self.session.checkpoint()
+
+        # Now let's delete a lot of data ranges. Create enough space so that compact runs in more
+        # than one iteration.
+        c = self.session.open_cursor(self.table_uri, None)
+        for r in range(self.delete_ranges_count):
+            start = r * self.table_numkv // self.delete_ranges_count
+            for i in range(self.delete_range_len):
+                c.set_key(start + i)
+                c.remove()
+        c.close()
+
+        # Compact!
+        self.session.compact(self.table_uri, None)
+        self.ignoreStdoutPatternIfExists('WT_VERB_COMPACT')
+        self.ignoreStderrPatternIfExists('WT_VERB_COMPACT')
+
+        # Verify the compact progress stats.
+        c_stat = self.session.open_cursor('statistics:' + self.table_uri, None, 'statistics=(all)')
+        pages_rewritten = c_stat[stat.dsrc.btree_compact_pages_rewritten][2]
+        pages_rewritten_expected = c_stat[stat.dsrc.btree_compact_pages_rewritten_expected][2]
+        c_stat.close()
+
+        self.assertGreater(pages_rewritten, 0)
+        self.assertGreater(pages_rewritten_expected, 0)
+
+        d = abs(pages_rewritten - pages_rewritten_expected) / pages_rewritten
+        self.assertLess(d, 0.15)
+
+if __name__ == '__main__':
+    wttest.run()