Import wiredtiger: 4eb9f719eed3e24a9e49a6fa60d8d56eadb8b189 from branch mongodb-4.4

ref: d198ee319d..4eb9f719ee
for: 4.5.1

WT-5801       Reduce runtime of Python unit tests by pruning test_compat02.py
WT-6276       Add size first to cache and btree to avoid the race that can cause cache size underflow
WT-6342       Fix external symbolizer path for PPC Evergreen tasks
WT-6366       Off-by-one overflow in block-modification bitmaps for incremental backup
WT-6373       Don't reset transaction ids when evicting mixed mode transactions
WT-6376       Minor cleanups in resolving prepared operations
WT-6378       Fix compile failure on OS X 10.12

17 files changed, 129 insertions, 58 deletions

diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py
index 49b2f4f8f27..9130bef7ed0 100644
--- a/src/third_party/wiredtiger/dist/api_data.py
+++ b/src/third_party/wiredtiger/dist/api_data.py
@@ -1286,7 +1286,7 @@ methods = {
             this setting manages the granularity of how WiredTiger maintains modification
             maps internally. The larger the granularity, the smaller amount of information
             WiredTiger need to maintain''',
-            min='1MB', max='2GB'),
+            min='4KB', max='2GB'),
         Config('src_id', '', r'''
             a string that identifies a previous checkpoint backup source as the source
             of this incremental backup. This identifier must have already been created
diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 1fd7bb991a6..049419a81f9 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-4.4",
-    "commit": "d198ee319dcb857f27358f9a75c11aab4725bedb"
+    "commit": "4eb9f719eed3e24a9e49a6fa60d8d56eadb8b189"
 }
diff --git a/src/third_party/wiredtiger/src/block/block_ckpt.c b/src/third_party/wiredtiger/src/block/block_ckpt.c
index 2f97613368a..6a10df06fff 100644
--- a/src/third_party/wiredtiger/src/block/block_ckpt.c
+++ b/src/third_party/wiredtiger/src/block/block_ckpt.c
@@ -355,16 +355,16 @@ __ckpt_add_blkmod_entry(
 
     WT_ASSERT(session, blk_mod->granularity != 0);
     /*
-     * Figure out how the starting and ending bits based on the granularity and our offset and
-     * length.
+     * Figure out the starting and ending locations in the bitmap based on its granularity and our
+     * offset and length. The bit locations are zero-based; be careful translating to sizes.
      */
     start_bit = (uint64_t)offset / blk_mod->granularity;
     end_bit = (uint64_t)(offset + len - 1) / blk_mod->granularity;
     WT_ASSERT(session, end_bit < UINT32_MAX);
     /* We want to grow the bitmap by 64 bits, or 8 bytes at a time. */
-    end_rdup_bits = WT_MAX(__wt_rduppo2((uint32_t)end_bit, 64), WT_BLOCK_MODS_LIST_MIN);
-    end_rdup_bytes = end_rdup_bits >> 3;
-    end_buf_bytes = (uint32_t)blk_mod->nbits >> 3;
+    end_rdup_bits = WT_MAX(__wt_rduppo2((uint32_t)end_bit + 1, 64), WT_BLOCK_MODS_LIST_MIN);
+    end_rdup_bytes = __bitstr_size(end_rdup_bits);
+    end_buf_bytes = __bitstr_size((uint32_t)blk_mod->nbits);
     /*
      * We are doing a lot of shifting. Make sure that the number of bytes we end up with is a
      * multiple of eight. We guarantee that in the rounding up call, but also make sure that the
@@ -384,6 +384,9 @@ __ckpt_add_blkmod_entry(
         }
         blk_mod->nbits = end_rdup_bits;
     }
+    /* Make sure we're not going to run past the end of the bitmap */
+    WT_ASSERT(session, blk_mod->bitstring.size >= __bitstr_size((uint32_t)blk_mod->nbits));
+    WT_ASSERT(session, end_bit < blk_mod->nbits);
     /* Set all the bits needed to record this offset/length pair. */
     __bit_nset(blk_mod->bitstring.mem, start_bit, end_bit);
     return (0);
diff --git a/src/third_party/wiredtiger/src/btree/row_modify.c b/src/third_party/wiredtiger/src/btree/row_modify.c
index 1ec05b29779..e71f96daa9a 100644
--- a/src/third_party/wiredtiger/src/btree/row_modify.c
+++ b/src/third_party/wiredtiger/src/btree/row_modify.c
@@ -71,13 +71,14 @@ __wt_row_modify(WT_CURSOR_BTREE *cbt, const WT_ITEM *key, const WT_ITEM *value,
      * - A key with no value to create a reserved or tombstone update to append to the update list.
      *
      * A "full update list" is distinguished from "an update" by checking whether it has a "next"
-     * update.
+     * update. The modify type should only be set if no update list provided.
      */
     WT_ASSERT(
       session, ((modify_type == WT_UPDATE_RESERVE || modify_type == WT_UPDATE_TOMBSTONE) &&
                  value == NULL && upd_arg == NULL) ||
         (!(modify_type == WT_UPDATE_RESERVE || modify_type == WT_UPDATE_TOMBSTONE) &&
                  ((value == NULL && upd_arg != NULL) || (value != NULL && upd_arg == NULL))));
+    WT_ASSERT(session, upd_arg == NULL || modify_type == WT_UPDATE_INVALID);
 
     /* If we don't yet have a modify structure, we'll need one. */
     WT_RET(__wt_page_modify_init(session, page));
diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c
index 6ef93c7bc4b..7b0b657619c 100644
--- a/src/third_party/wiredtiger/src/config/config_def.c
+++ b/src/third_party/wiredtiger/src/config/config_def.c
@@ -303,7 +303,7 @@ static const WT_CONFIG_CHECK confchk_WT_SESSION_log_flush[] = {
 static const WT_CONFIG_CHECK confchk_WT_SESSION_open_cursor_incremental_subconfigs[] = {
   {"enabled", "boolean", NULL, NULL, NULL, 0}, {"file", "string", NULL, NULL, NULL, 0},
   {"force_stop", "boolean", NULL, NULL, NULL, 0},
-  {"granularity", "int", NULL, "min=1MB,max=2GB", NULL, 0},
+  {"granularity", "int", NULL, "min=4KB,max=2GB", NULL, 0},
   {"src_id", "string", NULL, NULL, NULL, 0}, {"this_id", "string", NULL, NULL, NULL, 0},
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i
index 5a7fec77f71..87a6c66dba2 100644
--- a/src/third_party/wiredtiger/src/include/btree.i
+++ b/src/third_party/wiredtiger/src/include/btree.i
@@ -195,18 +195,22 @@ __wt_cache_page_inmem_incr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t size)
     if (size == 0)
         return;
 
-    (void)__wt_atomic_add64(&btree->bytes_inmem, size);
+    /*
+     * Always increase the size in sequence of cache, btree, and page as we may race with other
+     * threads that are trying to decrease the sizes concurrently.
+     */
     (void)__wt_atomic_add64(&cache->bytes_inmem, size);
+    (void)__wt_atomic_add64(&btree->bytes_inmem, size);
     (void)__wt_atomic_addsize(&page->memory_footprint, size);
     if (__wt_page_is_modified(page)) {
-        (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size);
         if (WT_PAGE_IS_INTERNAL(page)) {
-            (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size);
             (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size);
+            (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size);
         } else if (!btree->lsm_primary) {
-            (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size);
             (void)__wt_atomic_add64(&cache->bytes_dirty_leaf, size);
+            (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size);
         }
+        (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size);
     }
     /* Track internal size in cache. */
     if (WT_PAGE_IS_INTERNAL(page))
@@ -292,6 +296,9 @@ __wt_cache_page_byte_dirty_decr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t
      * without underflow. If we can't decrement the dirty byte counts after
      * few tries, give up: the cache's value will be wrong, but consistent,
      * and we'll fix it the next time this page is marked clean, or evicted.
+     *
+     * Always decrease the size in sequence of page, btree, and cache as we may race with other
+     * threads that are trying to increase the sizes concurrently.
      */
     for (i = 0; i < 5; ++i) {
         /*
@@ -332,10 +339,14 @@ __wt_cache_page_inmem_decr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t size)
 
     WT_ASSERT(session, size < WT_EXABYTE);
 
+    /*
+     * Always decrease the size in sequence of page, btree, and cache as we may race with other
+     * threads that are trying to increase the sizes concurrently.
+     */
+    __wt_cache_decr_check_size(session, &page->memory_footprint, size, "WT_PAGE.memory_footprint");
     __wt_cache_decr_check_uint64(
       session, &S2BT(session)->bytes_inmem, size, "WT_BTREE.bytes_inmem");
     __wt_cache_decr_check_uint64(session, &cache->bytes_inmem, size, "WT_CACHE.bytes_inmem");
-    __wt_cache_decr_check_size(session, &page->memory_footprint, size, "WT_PAGE.memory_footprint");
     if (__wt_page_is_modified(page))
         __wt_cache_page_byte_dirty_decr(session, page, size);
     /* Track internal size in cache. */
@@ -359,22 +370,25 @@ __wt_cache_dirty_incr(WT_SESSION_IMPL *session, WT_PAGE *page)
     cache = S2C(session)->cache;
 
     /*
+     * Always increase the size in sequence of cache, btree, and page as we may race with other
+     * threads that are trying to decrease the sizes concurrently.
+     *
      * Take care to read the memory_footprint once in case we are racing with updates.
      */
     size = page->memory_footprint;
     if (WT_PAGE_IS_INTERNAL(page)) {
-        (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size);
-        (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size);
         (void)__wt_atomic_add64(&cache->pages_dirty_intl, 1);
+        (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size);
+        (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size);
     } else {
+        (void)__wt_atomic_add64(&cache->pages_dirty_leaf, 1);
         if (!btree->lsm_primary) {
-            (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size);
             (void)__wt_atomic_add64(&cache->bytes_dirty_leaf, size);
+            (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size);
         }
-        (void)__wt_atomic_add64(&cache->pages_dirty_leaf, 1);
     }
-    (void)__wt_atomic_add64(&btree->bytes_dirty_total, size);
     (void)__wt_atomic_add64(&cache->bytes_dirty_total, size);
+    (void)__wt_atomic_add64(&btree->bytes_dirty_total, size);
     (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size);
 }
 
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index 4784d990ee7..ec40bc20e70 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -1086,7 +1086,7 @@ struct __wt_session {
 	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;granularity,
 	 * this setting manages the granularity of how WiredTiger maintains modification maps
 	 * internally.  The larger the granularity\, the smaller amount of information WiredTiger
-	 * need to maintain., an integer between 1MB and 2GB; default \c 16MB.}
+	 * need to maintain., an integer between 4KB and 2GB; default \c 16MB.}
 	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;src_id, a string that identifies a previous checkpoint
 	 * backup source as the source of this incremental backup.  This identifier must have
 	 * already been created by use of the 'this_id' configuration in an earlier backup.  A
diff --git a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c
index b4a054a95b1..56d3f711f10 100644
--- a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c
+++ b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c
@@ -489,7 +489,6 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, v
 
         select_tw->durable_start_ts = select_tw->durable_stop_ts;
         select_tw->start_ts = select_tw->stop_ts;
-        select_tw->start_txn = select_tw->stop_txn;
     }
 
     /*
diff --git a/src/third_party/wiredtiger/src/txn/txn.c b/src/third_party/wiredtiger/src/txn/txn.c
index 7fcb1ef940f..86aeabb9c29 100644
--- a/src/third_party/wiredtiger/src/txn/txn.c
+++ b/src/third_party/wiredtiger/src/txn/txn.c
@@ -873,15 +873,15 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit,
     WT_DECL_RET;
     WT_TXN *txn;
     WT_UPDATE *fix_upd, *tombstone, *upd;
-    size_t size;
+    size_t not_used;
     uint32_t hs_btree_id, session_flags;
     bool is_owner, upd_appended;
 
-    fix_upd = NULL;
     hs_cursor = NULL;
     txn = session->txn;
+    fix_upd = tombstone = NULL;
     session_flags = 0;
-    upd_appended = is_owner = false;
+    is_owner = upd_appended = false;
 
     WT_RET(__txn_search_prepared_op(session, op, cursorp, &upd));
 
@@ -933,15 +933,15 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit,
               true);
         if (ret == WT_NOTFOUND && !commit) {
             /*
-             * Allocate a tombstone so that when we reconcile the update chain we don't copy the
-             * prepared cell, which is now associated with a rolled back prepare, and instead write
-             * nothing.
+             * Allocate a tombstone and prepend it to the row so when we reconcile the update chain
+             * we don't copy the prepared cell, which is now associated with a rolled back prepare,
+             * and instead write nothing.
              */
-            WT_ERR(__wt_upd_alloc_tombstone(session, &tombstone, &size));
-            /* Apply the tombstone to the row. */
+            WT_ERR(__wt_upd_alloc_tombstone(session, &tombstone, &not_used));
             WT_WITH_BTREE(session, op->btree, ret = __wt_row_modify(cbt, &cbt->iface.key, NULL,
-                                                tombstone, WT_UPDATE_INVALID, true));
+                                                tombstone, WT_UPDATE_INVALID, false));
             WT_ERR(ret);
+            tombstone = NULL;
         } else
             ret = 0;
     }
@@ -1005,10 +1005,10 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit,
         WT_ERR(__txn_fixup_prepared_update(session, hs_cursor, fix_upd, commit));
 
 err:
-    if (hs_cursor != NULL)
-        ret = __wt_hs_cursor_close(session, session_flags, is_owner);
+    WT_TRET(__wt_hs_cursor_close(session, session_flags, is_owner));
     if (!upd_appended)
         __wt_free(session, fix_upd);
+    __wt_free(session, tombstone);
     return (ret);
 }
 
diff --git a/src/third_party/wiredtiger/test/csuite/incr_backup/main.c b/src/third_party/wiredtiger/test/csuite/incr_backup/main.c
index 68a4e4b26d1..fee64ff683a 100644
--- a/src/third_party/wiredtiger/test/csuite/incr_backup/main.c
+++ b/src/third_party/wiredtiger/test/csuite/incr_backup/main.c
@@ -479,6 +479,7 @@ base_backup(WT_CONNECTION *conn, WT_RAND_STATE *rand, const char *home, const ch
     int nfiles, ret;
     char buf[4096];
     char *filename;
+    char granularity_unit;
 
     nfiles = 0;
 
@@ -493,14 +494,18 @@ base_backup(WT_CONNECTION *conn, WT_RAND_STATE *rand, const char *home, const ch
     testutil_check(conn->open_session(conn, NULL, NULL, &session));
     tinfo->full_backup_number = tinfo->incr_backup_number++;
 
-    /* Half of the runs with a low granularity: 1M */
-    if (__wt_random(rand) % 2 == 0)
-        granularity = 1;
-    else
-        granularity = 1 + __wt_random(rand) % 20;
+    /* Half of the runs with very low granularity to stress bitmaps */
+    granularity = __wt_random(rand) % 20;
+    if (__wt_random(rand) % 2 == 0) {
+        granularity_unit = 'K';
+        granularity += 4;
+    } else {
+        granularity_unit = 'M';
+        granularity += 1;
+    }
     testutil_check(__wt_snprintf(buf, sizeof(buf),
-      "incremental=(granularity=%" PRIu32 "M,enabled=true,this_id=ID%d)", granularity,
-      (int)tinfo->full_backup_number));
+      "incremental=(granularity=%" PRIu32 "%c,enabled=true,this_id=ID%d)", granularity,
+      granularity_unit, (int)tinfo->full_backup_number));
     VERBOSE(3, "open_cursor(session, \"backup:\", NULL, \"%s\", &cursor)\n", buf);
     testutil_check(session->open_cursor(session, "backup:", NULL, buf, &cursor));
 
diff --git a/src/third_party/wiredtiger/test/evergreen.yml b/src/third_party/wiredtiger/test/evergreen.yml
index c2e748513e2..4cc34b03a89 100755
--- a/src/third_party/wiredtiger/test/evergreen.yml
+++ b/src/third_party/wiredtiger/test/evergreen.yml
@@ -2189,7 +2189,7 @@ tasks:
           posix_configure_flags: --enable-diagnostic --with-builtins=lz4,snappy,zlib
       - func: "format test script"
         vars:
-          test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer
+          test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer
           # run for 2 hours ( 2 * 60 = 120 minutes), don't stop at failed tests, use default config
           format_test_script_args: -t 120
 
@@ -2207,7 +2207,7 @@ tasks:
         # to emulate the original Jenkins job's test coverage, we are running the smoke test 16 times
         # run smoke tests, don't stop at failed tests, use default config
         vars:
-          test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer
+          test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer
           format_test_script_args: -S
           times: 16
 
diff --git a/src/third_party/wiredtiger/test/format/backup.c b/src/third_party/wiredtiger/test/format/backup.c
index ca87d27f098..bfe964cf871 100644
--- a/src/third_party/wiredtiger/test/format/backup.c
+++ b/src/third_party/wiredtiger/test/format/backup.c
@@ -399,15 +399,16 @@ backup(void *arg)
         if (g.c_backup_incr_flag == INCREMENTAL_BLOCK) {
             /*
              * If we're doing a full backup as the start of the incremental backup, only send in an
-             * identifier for this one.
+             * identifier for this one. Also set the block granularity.
              */
             if (incr_full) {
                 active_files_free(&active[0]);
                 active_files_free(&active[1]);
                 active_now = &active[g.backup_id % 2];
                 active_prev = NULL;
-                testutil_check(__wt_snprintf(
-                  cfg, sizeof(cfg), "incremental=(enabled,this_id=ID%" PRIu64 ")", g.backup_id++));
+                testutil_check(__wt_snprintf(cfg, sizeof(cfg),
+                  "incremental=(enabled,granularity=%" PRIu32 "K,this_id=ID%" PRIu64 ")",
+                  g.c_backup_incr_granularity, g.backup_id++));
                 full = true;
                 incr_full = false;
             } else {
diff --git a/src/third_party/wiredtiger/test/format/config.c b/src/third_party/wiredtiger/test/format/config.c
index f802d8eb36b..e2f933526bf 100644
--- a/src/third_party/wiredtiger/test/format/config.c
+++ b/src/third_party/wiredtiger/test/format/config.c
@@ -30,6 +30,7 @@
 #include "config.h"
 
 static void config_backup_incr(void);
+static void config_backup_incr_granularity(void);
 static void config_backward_compatible(void);
 static void config_cache(void);
 static void config_checkpoint(void);
@@ -280,6 +281,8 @@ config_backup_incr(void)
             if (g.c_logging_archive)
                 config_single("logging.archive=0", false);
         }
+        if (g.c_backup_incr_flag == INCREMENTAL_BLOCK)
+            config_backup_incr_granularity();
         return;
     }
 
@@ -308,11 +311,56 @@ config_backup_incr(void)
     case 9:
     case 10:
         config_single("backup.incremental=block", false);
+        config_backup_incr_granularity();
         break;
     }
 }
 
 /*
+ * config_backup_incr_granularity --
+ *     Configuration of block granularity for incremental backup
+ */
+static void
+config_backup_incr_granularity(void)
+{
+    uint32_t granularity, i;
+    char confbuf[128];
+
+    if (config_is_perm("backup.incr_granularity"))
+        return;
+
+    /*
+     * Three block sizes are interesting. 16MB is the default for WiredTiger and MongoDB. 1MB is the
+     * minimum allowed by MongoDB. Smaller sizes stress block tracking and are good for testing. The
+     * granularity is in units of KB.
+     */
+    granularity = 0;
+    i = mmrand(NULL, 1, 10);
+    switch (i) {
+    case 1: /* 50% small size for stress testing */
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+        granularity = 4 * i;
+        break;
+    case 6: /* 20% 1MB granularity */
+    case 7:
+        granularity = 1024;
+        break;
+    case 8: /* 30% 16MB granularity */
+    case 9:
+    case 10:
+        granularity = 16 * 1024;
+        break;
+    }
+
+    testutil_check(
+      __wt_snprintf(confbuf, sizeof(confbuf), "backup.incr_granularity=%u", granularity));
+    config_single(confbuf, false);
+}
+
+/*
  * config_backward_compatible --
  *     Backward compatibility configuration.
  */
diff --git a/src/third_party/wiredtiger/test/format/config.h b/src/third_party/wiredtiger/test/format/config.h
index cef2eda6142..30b8f2a09a6 100644
--- a/src/third_party/wiredtiger/test/format/config.h
+++ b/src/third_party/wiredtiger/test/format/config.h
@@ -74,6 +74,9 @@ static CONFIG c[] = {
   {"backup.incremental", "type of backup (block | log | off)", C_IGNORE | C_STRING, 0, 0, 0, NULL,
     &g.c_backup_incremental},
 
+  {"backup.incr_granularity", "incremental backup block granularity in KB", 0x0, 4, 16384, 16384,
+    &g.c_backup_incr_granularity, NULL},
+
   {"btree.bitcnt", "number of bits for fixed-length column-store files", 0x0, 1, 8, 8, &g.c_bitcnt,
     NULL},
 
diff --git a/src/third_party/wiredtiger/test/format/format.h b/src/third_party/wiredtiger/test/format/format.h
index 9416c45cd60..7f5230709fe 100644
--- a/src/third_party/wiredtiger/test/format/format.h
+++ b/src/third_party/wiredtiger/test/format/format.h
@@ -138,6 +138,7 @@ typedef struct {
     uint32_t c_assert_read_timestamp;
     uint32_t c_auto_throttle;
     char *c_backup_incremental;
+    uint32_t c_backup_incr_granularity;
     uint32_t c_backups;
     uint32_t c_bitcnt;
     uint32_t c_bloom;
diff --git a/src/third_party/wiredtiger/test/format/smoke.sh b/src/third_party/wiredtiger/test/format/smoke.sh
index de46580c078..067ef8e2589 100755
--- a/src/third_party/wiredtiger/test/format/smoke.sh
+++ b/src/third_party/wiredtiger/test/format/smoke.sh
@@ -3,6 +3,7 @@
 set -e
 
 # Smoke-test format as part of running "make check".
+args="-1 -c . "
 args="$args btree.compression=none "
 args="$args logging_compression=none"
 args="$args runs.ops=50000 "
@@ -10,18 +11,11 @@ args="$args runs.rows=10000 "
 args="$args runs.source=table "
 args="$args runs.threads=4 "
 
-# Locate format.sh from home directory.
-FORMAT_SCRIPT=$(git rev-parse --show-toplevel)/test/format/format.sh
-
 # Temporarily disabled
-# $FORMAT_SCRIPT -t 2 $args runs.type=fix
-# $FORMAT_SCRIPT -t 2 $args runs.type=row runs.source=lsm
-# $FORMAT_SCRIPT -t 2 $args runs.type=var
-
-# Run the format script for 10 minutues, distribute it across the number
-# of different test arguments.
-
-# This will run the test/format binary for 5 minutes each.
-$FORMAT_SCRIPT -t 5 $args runs.type=row
+# $TEST_WRAPPER ./t $args runs.type=fix
+# $TEST_WRAPPER ./t $args runs.type=row runs.source=lsm
+# $TEST_WRAPPER ./t $args runs.type=var
 
-$FORMAT_SCRIPT -t 5 $args runs.type=row statistics.server=1 ops.rebalance=1
+$TEST_WRAPPER ./t $args runs.type=row
+# Force a rebalance to occur with statistics logging to test the utility
+$TEST_WRAPPER ./t $args runs.type=row statistics.server=1 ops.rebalance=1
diff --git a/src/third_party/wiredtiger/test/suite/test_compat02.py b/src/third_party/wiredtiger/test/suite/test_compat02.py
index e3397d0d7ea..8d44b25d7ba 100644
--- a/src/third_party/wiredtiger/test/suite/test_compat02.py
+++ b/src/third_party/wiredtiger/test/suite/test_compat02.py
@@ -110,7 +110,9 @@ class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):
         ('basecfg_true', dict(basecfg='true')),
         ('basecfg_false', dict(basecfg='false')),
     ]
-    scenarios = make_scenarios(compat_create, compat_release, compat_min, compat_max, base_config)
+
+    scenarios = make_scenarios(compat_create, compat_release, compat_min, compat_max, base_config,
+                               prune=100, prunelong=100000)
 
     def conn_config(self):
         # Set archive false on the home directory.