Import wiredtiger: e3e77069b2b56efb1445f150bc28945af9c95157 from branch mongodb-master

ref: fafdde779d..e3e77069b2
for: 5.2.0

WT-6022       NVRAM cache

49 files changed, 2473 insertions, 650 deletions

diff --git a/src/third_party/wiredtiger/SConstruct b/src/third_party/wiredtiger/SConstruct
index 006b0bfce08..6d971e22e98 100644
--- a/src/third_party/wiredtiger/SConstruct
+++ b/src/third_party/wiredtiger/SConstruct
@@ -32,6 +32,9 @@ AddOption("--enable-diagnostic", dest="diagnostic", action="store_true", default
 AddOption("--enable-lz4", dest="lz4", type="string", nargs=1, action="store",
           help="Use LZ4 compression")
 
+AddOption("--enable-memkind", dest="memkind", type="string", nargs=1, action="store",
+          help="Enable support for Intel memkind library, needed for NVRAM block cache.")
+
 AddOption("--enable-python", dest="lang-python", type="string", nargs=1, action="store",
           help="Build Python extension, specify location of swig.exe binary")
 
@@ -113,6 +116,7 @@ useZlib = GetOption("zlib")
 useSnappy = GetOption("snappy")
 useLz4 = GetOption("lz4")
 useTcmalloc = GetOption("tcmalloc")
+useMemkind = GetOption("memkind")
 wtlibs = []
 
 conf = Configure(env)
@@ -161,6 +165,16 @@ if useTcmalloc:
         print('tcmalloc.h must be installed!')
         Exit(1)
 
+if useMemkind:
+    conf.env.Append(CPPPATH=[useMemkind + "/include"])
+    conf.env.Append(LIBPATH=[useMemkind + "/lib"])
+    if conf.CheckCHeader('memkind.h'):
+        conf.env.Append(CPPDEFINES=['HAVE_MEMKIND'])
+        wtlibs.append("memkind")
+    else:
+        print('memkind.h must be installed!')
+        Exit(1)
+
 env = conf.Finish()
 
 # Configure build environment variables
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-50r50u-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-50r50u-large.wtperf
new file mode 100644
index 00000000000..a829c7aafa0
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-50r50u-large.wtperf
@@ -0,0 +1,26 @@
+# wtperf options file: simulate MongoDB.
+# The configuration for the connection and table are from mongoDB.
+# We use multiple tables to simulate collections and indexes.
+# This test assumes that its correlating populate already completed and exists.
+#
+# Set cache to half of memory of AWS perf instance.  Enable logging and
+# checkpoints.  Collect wiredtiger stats for ftdc.
+conn_config="cache_size=16G,checkpoint=(wait=60,log_size=2GB),session_max=20000,log=(enabled),eviction=(threads_max=8)"
+create=false
+compression="snappy"
+sess_config="isolation=snapshot"
+table_config="type=file"
+table_count=2
+# close_conn as false allows this test to close/finish faster, but if running
+# as the set, the next test will need to run recovery.
+close_conn=false
+key_sz=40
+value_sz=120
+max_latency=2000
+pareto=20
+report_interval=10
+run_time=7200
+sample_interval=10
+sample_rate=1
+threads=((count=10,reads=1),(count=10,updates=1))
+warmup=120
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-populate-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-populate-large.wtperf
new file mode 100644
index 00000000000..ffb621276ec
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/500m-btree-populate-large.wtperf
@@ -0,0 +1,26 @@
+# wtperf options file: simulate MongoDB.
+# The configuration for the connection and table are from mongoDB.
+# We use multiple tables to simulate collections and indexes.
+# This test assumes that its correlating populate already completed and exists.
+#
+# Set cache to half of memory.  This value is computed from the AWS instance
+# where Jenkins perf runs which has 32G.  Enable logging and checkpoints. 
+# Collect wiredtiger stats for ftdc.
+#
+# This generates about 80 Gb of uncompressed data.  But it should compress
+# well and be small on disk.
+conn_config="cache_size=16G,checkpoint=(wait=60,log_size=2GB),session_max=20000,log=(enabled),eviction=(threads_max=8)"
+compact=true
+compression="snappy"
+sess_config="isolation=snapshot"
+table_config="internal_page_max=16K,type=file,leaf_page_max=16K,memory_page_max=10M,split_pct=90"
+table_count=2
+icount=4000000000
+key_sz=40
+value_sz=120
+max_latency=2000
+populate_threads=20
+report_interval=10
+random_value=true
+sample_interval=10
+sample_rate=1
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/checkpoint-stress-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/checkpoint-stress-large.wtperf
new file mode 100644
index 00000000000..5d31fca97c8
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/checkpoint-stress-large.wtperf
@@ -0,0 +1,27 @@
+# A stress configuration to create long running checkpoints while doing a lot
+# of updates.
+conn_config="cache_size=16GB,eviction=(threads_max=8),log=(enabled=false)"
+table_config="leaf_page_max=32k,internal_page_max=16k,allocation_size=4k,split_pct=90,type=file"
+# Enough data to fill the cache. 150 million 1k records results in two ~11GB
+# tables
+close_conn=false
+icount=1500000000
+create=true
+compression="snappy"
+checkpoint_interval=60
+checkpoint_threads=1
+populate_threads=1
+report_interval=10
+# Run for a longer duration to ensure checkpoints are completing.
+run_time=600
+# Sampling isn't being currently used by any automated test. Keeping it to be
+# used in the future
+sample_interval=10
+sample_rate=1
+# MongoDB always has multiple tables, and checkpoints behave differently when
+# there is more than a single table.
+table_count=2
+threads=((count=6,updates=1))
+value_sz=1000
+# Wait for the throughput to stabilize
+warmup=120
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large-32GB.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large-32GB.wtperf
new file mode 100644
index 00000000000..070e9903423
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large-32GB.wtperf
@@ -0,0 +1,11 @@
+# wtperf options file: evict btree configuration
+conn_config="cache_size=32G,eviction=(threads_max=8)"
+table_config="type=file"
+icount=1000000000
+report_interval=5
+run_time=120
+populate_threads=1
+threads=((count=16,reads=1))
+# Add throughput/latency monitoring
+max_latency=2000
+sample_interval=5
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large.wtperf
new file mode 100644
index 00000000000..2db9e480b1a
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-large.wtperf
@@ -0,0 +1,11 @@
+# wtperf options file: evict btree configuration
+conn_config="cache_size=50M,eviction=(threads_max=8)"
+table_config="type=file"
+icount=1000000000
+report_interval=5
+run_time=120
+populate_threads=1
+threads=((count=16,reads=1))
+# Add throughput/latency monitoring
+max_latency=2000
+sample_interval=5
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-stress-multi-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-stress-multi-large.wtperf
new file mode 100644
index 00000000000..c964a463079
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/evict-btree-stress-multi-large.wtperf
@@ -0,0 +1,13 @@
+conn_config="cache_size=1G,eviction=(threads_max=8),session_max=2000"
+table_config="type=file"
+table_count=100
+close_conn=false
+icount=1000000000
+report_interval=5
+run_time=600
+populate_threads=1
+threads=((count=100,updates=1,reads=4,ops_per_txn=30))
+# Warn if a latency over a quarter second is seen
+max_latency=250
+sample_interval=5
+sample_rate=1
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/large-lsm-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/large-lsm-large.wtperf
new file mode 100644
index 00000000000..c8a54198747
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/large-lsm-large.wtperf
@@ -0,0 +1,11 @@
+# wtperf options file: large lsm configuration
+conn_config="cache_size=20G,mmap=false,lsm_manager=(worker_thread_max=8)"
+table_config="internal_page_max=128K,lsm=(bloom_config=(leaf_page_max=8MB),bloom_bit_count=28,bloom_hash_count=19,bloom_oldest=true,chunk_max=5GB,chunk_size=100MB),type=lsm,leaf_page_max=16K,os_cache_dirty_max=16MB"
+compact=true
+compression="snappy"
+icount=4000000000
+report_interval=5
+run_time=1200
+populate_threads=1
+sample_interval=10
+threads=((count=16,reads=1))
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large-32GB.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large-32GB.wtperf
new file mode 100644
index 00000000000..ec8dc96cba4
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large-32GB.wtperf
@@ -0,0 +1,11 @@
+# wtperf options file: medium btree configuration
+conn_config="cache_size=32G"
+table_config="type=file"
+icount=1000000000
+report_interval=5
+run_time=120
+populate_threads=1
+threads=((count=16,reads=1))
+# Add throughput/latency monitoring
+max_latency=2000
+sample_interval=5
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large.wtperf
new file mode 100644
index 00000000000..2c1e30b3cee
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/medium-btree-large.wtperf
@@ -0,0 +1,11 @@
+# wtperf options file: medium btree configuration
+conn_config="cache_size=1G"
+table_config="type=file"
+icount=1000000000
+report_interval=5
+run_time=120
+populate_threads=1
+threads=((count=16,reads=1))
+# Add throughput/latency monitoring
+max_latency=2000
+sample_interval=5
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/multi-btree-zipfian-populate-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/multi-btree-zipfian-populate-large.wtperf
new file mode 100644
index 00000000000..8ed4eeabe91
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/multi-btree-zipfian-populate-large.wtperf
@@ -0,0 +1,19 @@
+# Create a set of tables with uneven distribution of data
+conn_config="cache_size=1G,eviction=(threads_max=8),file_manager=(close_idle_time=100000),checkpoint=(wait=60,log_size=2GB),session_max=1000"
+table_config="type=file"
+table_count=100
+icount=0
+random_range=1000000000
+pareto=10
+range_partition=true
+report_interval=5
+
+run_ops=1000000000
+populate_threads=0
+icount=0
+threads=((count=20,inserts=1))
+
+# Warn if a latency over 1 second is seen
+max_latency=1000
+sample_interval=5
+sample_rate=1
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/overflow-130k-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/overflow-130k-large.wtperf
new file mode 100644
index 00000000000..ec755029a91
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/overflow-130k-large.wtperf
@@ -0,0 +1,18 @@
+#
+# Run with very large overflow items and btree.
+#
+conn_config="cache_size=21G,checkpoint_sync=false,mmap=false"
+compact=true
+compression="snappy"
+sess_config="isolation=snapshot"
+table_config="internal_page_max=128K,type=file,leaf_page_max=16K,os_cache_dirty_max=16MB,leaf_value_max=32K"
+icount=1500000
+key_sz=40
+value_sz=130000
+max_latency=2000
+populate_threads=1
+report_interval=5
+random_value=true
+run_time=300
+threads=((count=10,read=1),(count=10,update=1))
+warmup=30
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/update-checkpoint-btree-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/update-checkpoint-btree-large.wtperf
new file mode 100644
index 00000000000..2a45b80b981
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/update-checkpoint-btree-large.wtperf
@@ -0,0 +1,15 @@
+# wtperf options file: btree with inserts/updates and checkpointing, in memory
+# Note:  The cache needs to be sized to approximate the amount of inserts
+# that will happen during the given run_time.
+conn_config="cache_size=25G"
+table_config="type=file"
+icount=500000000
+report_interval=5
+checkpoint_threads=1
+checkpoint_interval=10
+run_time=300
+populate_threads=1
+threads=((count=1,inserts=1),(count=2,reads=1),(count=2,updates=1))
+# Add throughput/latency monitoring
+max_latency=2000
+sample_interval=5
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/update-delta-mix1-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/update-delta-mix1-large.wtperf
new file mode 100644
index 00000000000..05e72b3bd6c
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/update-delta-mix1-large.wtperf
@@ -0,0 +1,18 @@
+# wtperf options file: Mixed workload where we grow some values and shrink
+# others.  Mixed load leaning toward growing the dataset.
+#
+conn_config="cache_size=2GB,checkpoint=(wait=30)"
+table_config="type=file,leaf_page_max=32k,leaf_value_max=128k,split_pct=90"
+# The values are starting small, insert a lot so our database grows larger than
+# cache quickly.
+icount=6000000
+report_interval=5
+run_time=300
+populate_threads=1
+#
+# Run more grow workload threads than shrink threads.
+#
+threads=((count=4,update=1,update_delta=100),(count=2,update=1,update_delta=-150))
+value_sz=20000
+value_sz_min=1000
+value_sz_max=65536
diff --git a/src/third_party/wiredtiger/bench/wtperf/runners/update-grow-stress-large.wtperf b/src/third_party/wiredtiger/bench/wtperf/runners/update-grow-stress-large.wtperf
new file mode 100644
index 00000000000..5c695759dcb
--- /dev/null
+++ b/src/third_party/wiredtiger/bench/wtperf/runners/update-grow-stress-large.wtperf
@@ -0,0 +1,15 @@
+# wtperf options file: Grow the size of documents while there is cache
+# pressure and appends are happening as well.
+conn_config="cache_size=2GB,checkpoint=(wait=30)"
+table_config="type=file,leaf_page_max=32k,leaf_value_max=128k,split_pct=90"
+# The values are starting small, insert a lot so our database grows larger than
+# cache quickly.
+icount=10000000
+report_interval=5
+run_time=240
+populate_threads=1
+# Continue inserting new records.
+threads=((count=1,inserts=1,throttle=1000),(count=4,update=1,update_delta=100))
+# Start with small values and let them grow slowly to large values.
+value_sz=10000
+value_sz_max=65536
diff --git a/src/third_party/wiredtiger/bench/wtperf/wtperf.c b/src/third_party/wiredtiger/bench/wtperf/wtperf.c
index 6e16da0a0d7..45abfa9f181 100644
--- a/src/third_party/wiredtiger/bench/wtperf/wtperf.c
+++ b/src/third_party/wiredtiger/bench/wtperf/wtperf.c
@@ -296,7 +296,7 @@ do_range_reads(WTPERF_THREAD *thread, WT_CURSOR *cursor, int64_t read_range)
 }
 
 /* pre_load_data --
- *	Pull everything into cache before starting the workload phase.
+ *  Pull everything into cache before starting the workload phase.
  */
 static void
 pre_load_data(WTPERF *wtperf)
diff --git a/src/third_party/wiredtiger/build_posix/aclocal/options.m4 b/src/third_party/wiredtiger/build_posix/aclocal/options.m4
index 651b777fee1..0fe512c0c8c 100644
--- a/src/third_party/wiredtiger/build_posix/aclocal/options.m4
+++ b/src/third_party/wiredtiger/build_posix/aclocal/options.m4
@@ -186,6 +186,23 @@ if test "$wt_cv_enable_tcmalloc" = "yes"; then
 fi
 AM_CONDITIONAL([TCMalloc], [test "$wt_cv_enable_tcmalloc" = "yes"])
 
+AC_MSG_CHECKING(if --enable-memkind option specified)
+AC_ARG_ENABLE(memkind,
+	[AS_HELP_STRING([--enable-memkind],
+	    [Memkind library enables using memory on Optane NVRAM. Enable if planning to use NVRAM block cache.])], r=$enableval, r=no)
+case "$r" in
+no)	wt_cv_enable_memkind=no;;
+*)	wt_cv_enable_memkind=yes;;
+esac
+AC_MSG_RESULT($wt_cv_enable_memkind)
+if test "$wt_cv_enable_memkind" = "yes"; then
+	AC_CHECK_HEADER(memkind.h,,
+	    [AC_MSG_ERROR([--enable-memkind requires memkind.h])])
+	AC_CHECK_LIB(memkind, memkind_get_version,,
+	    [AC_MSG_ERROR([--enable-memkind requires memkind library])])
+fi
+AM_CONDITIONAL([Memkind], [test "$wt_cv_enable_memkind" = "yes"])
+
 AH_TEMPLATE(SPINLOCK_TYPE, [Spinlock type from mutex.h.])
 AC_MSG_CHECKING(if --with-spinlock option specified)
 AC_ARG_WITH(spinlock,
diff --git a/src/third_party/wiredtiger/build_win/wiredtiger_config.h b/src/third_party/wiredtiger/build_win/wiredtiger_config.h
index a68d64a58bf..bfee99faf9b 100644
--- a/src/third_party/wiredtiger/build_win/wiredtiger_config.h
+++ b/src/third_party/wiredtiger/build_win/wiredtiger_config.h
@@ -52,6 +52,9 @@
 /* Define to 1 if you have the `lz4' library (-llz4). */
 /* #undef HAVE_LIBLZ4 */
 
+/* Define to 1 if you have the `memkind' library (-lmemkind). */
+/* #undef HAVE_LIBMEMKIND */
+
 /* Define to 1 if you have the `pthread' library (-lpthread). */
 /* #undef HAVE_LIBPTHREAD */
 
diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py
index 5cae2b9d3fc..b7913c04a0a 100644
--- a/src/third_party/wiredtiger/dist/api_data.py
+++ b/src/third_party/wiredtiger/dist/api_data.py
@@ -510,6 +510,47 @@ table_meta = format_meta + table_only_config
 
 # Connection runtime config, shared by conn.reconfigure and wiredtiger_open
 connection_runtime_config = [
+    Config('block_cache', '', r'''block cache configuration options''',
+           type='category', subconfig=[
+               Config('cache_on_checkpoint', 'true', r'''
+                      Cache blocks that are written by a checkpoint''',
+                      type='boolean'),
+               Config('cache_on_writes', 'true', r'''
+                      cache newly generated blocks''',
+                      type='boolean'),
+               Config('enabled', 'false', r'''
+                      enable block cache''',
+                      type='boolean'),
+               Config('blkcache_eviction_aggression', '1800', r'''
+               how many seconds an unused block remains in the cache before it is evicted''',
+                      min='1', max='7200'),
+               Config('full_target', '95', r'''
+                      a fraction of cache that must be full before eviction
+                      will remove unused blocks''',
+                      min='30', max='100'),
+               Config('size', '0', r'''
+                   maximum memory to allocate for the block cache''',
+                   min='0', max='6155GB'),
+               Config('hashsize', '0', r'''
+                   number of buckets in the hashtable that keeps track of blocks.''',
+                   min='512', max='256K'),
+               Config('max_percent_overhead', '10', r'''
+                   maximum tolerated overhead expressed as the number of
+                   blocks added and removed as percent of blocks looked up;
+                   cache population and eviction will be suppressed if the overhead
+                   exceeds the supplied threshold''',
+                   min='1', max='500'),
+               Config('nvram_path', '', r'''
+                   the absolute path to the file system mounted on the NVRAM device''',),
+               Config('percent_file_in_dram', '50', r'''
+                   bypass cache if that percent of file fits in DRAM''',
+                   min='0', max='100'),
+               Config('system_ram', '0', r'''
+                      amount of DRAM expected to be available on the system''',
+                      min='0', max='1024GB'),
+               Config('type', '', r'''
+                      cache location: DRAM or NVRAM'''),
+           ]),
     Config('cache_size', '100MB', r'''
         maximum heap memory to allocate for the cache. A database should
         configure either \c cache_size or \c shared_cache but not both''',
@@ -821,6 +862,7 @@ connection_runtime_config = [
             'api',
             'backup',
             'block',
+            'block_cache',
             'checkpoint',
             'checkpoint_cleanup',
             'checkpoint_progress',
@@ -832,9 +874,9 @@ connection_runtime_config = [
             'evictserver',
             'fileops',
             'handleops',
-            'log',
             'history_store',
             'history_store_activity',
+            'log',
             'lsm',
             'lsm_manager',
             'metadata',
diff --git a/src/third_party/wiredtiger/dist/filelist b/src/third_party/wiredtiger/dist/filelist
index d2a2d93cff3..0d6bc232e4c 100644
--- a/src/third_party/wiredtiger/dist/filelist
+++ b/src/third_party/wiredtiger/dist/filelist
@@ -2,6 +2,7 @@
 #	List of source files for WiredTiger library.
 
 src/block/block_addr.c
+src/block/block_cache.c
 src/block/block_ckpt.c
 src/block/block_ckpt_scan.c
 src/block/block_compact.c
@@ -201,6 +202,7 @@ src/support/hash_fnv.c
 src/support/hazard.c
 src/support/hex.c
 src/support/huffman.c
+src/support/float.c
 src/support/lock_ext.c
 src/support/modify.c
 src/support/mtx_rw.c
diff --git a/src/third_party/wiredtiger/dist/s_stat b/src/third_party/wiredtiger/dist/s_stat
index 10eba129153..747b5a96bca 100755
--- a/src/third_party/wiredtiger/dist/s_stat
+++ b/src/third_party/wiredtiger/dist/s_stat
@@ -23,18 +23,19 @@ search=`sed \
 # There are some fields that are used, but we can't detect it.
 cat << UNUSED_STAT_FIELDS
 btree_clean_checkpoint_timer
+compress_hist_ratio_max
 lock_checkpoint_count
 lock_checkpoint_wait_application
 lock_checkpoint_wait_internal
-lock_durable_timestamp_read_count
-lock_durable_timestamp_wait_application
-lock_durable_timestamp_wait_internal
-lock_durable_timestamp_write_count
 lock_dhandle_read_count
 lock_dhandle_wait
 lock_dhandle_wait_application
 lock_dhandle_wait_internal
 lock_dhandle_write_count
+lock_durable_timestamp_read_count
+lock_durable_timestamp_wait_application
+lock_durable_timestamp_wait_internal
+lock_durable_timestamp_write_count
 lock_metadata_count
 lock_metadata_wait_application
 lock_metadata_wait_internal
diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok
index 9907b019578..9bcfd210a09 100644
--- a/src/third_party/wiredtiger/dist/s_string.ok
+++ b/src/third_party/wiredtiger/dist/s_string.ok
@@ -35,6 +35,7 @@ BBBBBBBBBBBBBBBBBB
 BDB
 BDB's
 BIGENDIAN
+BLKCACHE
 BOOL
 BSR
 BTREE
@@ -225,6 +226,7 @@ Kounavis
 LANGID
 LAS
 LF
+LIBMEMKIND
 LLLLLL
 LLLLLLL
 LLVM
@@ -296,6 +298,7 @@ NOVALUE
 NOWAIT
 NUL
 NUM
+NVRAM
 NZD
 NetBSD
 NoAddr
@@ -310,6 +313,7 @@ OVFL
 ObWgfvgw
 Obama
 Opcode
+Optane
 Outfmt
 PARAM
 PFX
@@ -546,6 +550,7 @@ bitpos
 bitstring
 bitwise
 blk
+blkcache
 blkmod
 bm
 bnd
@@ -735,6 +740,7 @@ directio
 dirlist
 disjunction
 disjunctions
+disproportionally
 dlclose
 dlh
 dll
@@ -827,6 +833,7 @@ filesystems
 fillms
 firstfit
 fixup
+floatcmp
 floatnum
 fmt
 fmterr
@@ -882,6 +889,8 @@ gt
 handleops
 handlep
 hardcoded
+hashsize
+hashtable
 hashval
 havesize
 hdr
@@ -998,6 +1007,7 @@ lexicographically
 lf
 lfence
 libdatasource
+libmemkind
 libs
 libsodium
 libtool
@@ -1062,6 +1072,7 @@ memcmp
 memcpy
 memdup
 memget
+memkind
 memmove
 memset
 memsize
@@ -1130,6 +1141,7 @@ notsup
 notused
 novalue
 nowait
+ns
 nsec
 nset
 nsnap
@@ -1139,6 +1151,7 @@ nuls
 num
 numSymbols
 numbare
+nvram
 objs
 offpage
 ofh
@@ -1178,6 +1191,7 @@ pcpu
 perf
 pfx
 pluggable
+pmem
 poc
 popen
 poptable
@@ -1246,6 +1260,7 @@ readv
 realloc
 rebalance
 rebalancing
+recency
 recno
 recnos
 reconfig
@@ -1426,6 +1441,7 @@ unbuffered
 uncacheable
 uncompressed
 uncompressing
+unconfigured
 uncustomized
 undef
 underflowed
diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py
index 72cbbb3d470..087f2cee4cb 100644
--- a/src/third_party/wiredtiger/dist/stat_data.py
+++ b/src/third_party/wiredtiger/dist/stat_data.py
@@ -185,6 +185,27 @@ conn_stats = [
     BlockStat('block_byte_write_checkpoint', 'bytes written for checkpoint', 'size'),
     BlockStat('block_byte_write_mmap', 'bytes written via memory map API', 'size'),
     BlockStat('block_byte_write_syscall', 'bytes written via system call API', 'size'),
+    BlockStat('block_cache_blocks', 'block cache total blocks'),
+    BlockStat('block_cache_blocks_evicted', 'block cache evicted blocks'),
+    BlockStat('block_cache_blocks_removed', 'block cache removed blocks'),
+    BlockStat('block_cache_blocks_update', 'block cache cached blocks updated'),
+    BlockStat('block_cache_blocks_insert_read', 'block cache total blocks inserted on read path'),
+    BlockStat('block_cache_blocks_insert_write', 'block cache total blocks inserted on write path'),
+    BlockStat('block_cache_bypass_chkpt', 'block cache number of put bypasses on checkpoint I/O'),
+    BlockStat('block_cache_bypass_get', 'block cache number of bypasses on get'),
+    BlockStat('block_cache_bypass_filesize', 'block cache file size causing bypass'),
+    BlockStat('block_cache_bypass_overhead_put', 'block cache number of bypasses due to overhead on put'),
+    BlockStat('block_cache_bypass_put', 'block cache number of bypasses on put because file is too small'),
+    BlockStat('block_cache_bypass_writealloc', 'block cache number of bypasses because no-write-allocate setting was on'),
+    BlockStat('block_cache_bytes', 'block cache total bytes'),
+    BlockStat('block_cache_bytes_update', 'block cache cached bytes updated'),
+    BlockStat('block_cache_bytes_insert_read', 'block cache total bytes inserted on read path'),
+    BlockStat('block_cache_bytes_insert_write', 'block cache total bytes inserted on write path'),
+    BlockStat('block_cache_data_refs', 'block cache lookups'),
+    BlockStat('block_cache_eviction_passes', 'block cache number of eviction passes'),
+    BlockStat('block_cache_hits', 'block cache number of hits including existence checks'),
+    BlockStat('block_cache_misses', 'block cache number of misses including existence checks'),
+    BlockStat('block_cache_not_evicted_overhead', 'block cache number of blocks not evicted due to overhead'),
     BlockStat('block_map_read', 'mapped blocks read'),
     BlockStat('block_preload', 'blocks pre-loaded'),
     BlockStat('block_read', 'blocks read'),
@@ -686,9 +707,16 @@ dsrc_stats = [
     ##########################################
     # Compression statistics
     ##########################################
-    CompressStat('compress_read', 'compressed pages read'),
+    CompressStat('compress_hist_ratio_2', 'number of blocks with compress ratio smaller than 2'),
+    CompressStat('compress_hist_ratio_4', 'number of blocks with compress ratio smaller than 4'),
+    CompressStat('compress_hist_ratio_8', 'number of blocks with compress ratio smaller than 8'),
+    CompressStat('compress_hist_ratio_16', 'number of blocks with compress ratio smaller than 16'),
+    CompressStat('compress_hist_ratio_32', 'number of blocks with compress ratio smaller than 32'),
+    CompressStat('compress_hist_ratio_64', 'number of blocks with compress ratio smaller than 64'),
+    CompressStat('compress_hist_ratio_max', 'number of blocks with compress ratio greater than 64'),
     CompressStat('compress_precomp_intl_max_page_size', 'compressed page maximum internal page size prior to compression', 'no_clear,no_scale,size'),
     CompressStat('compress_precomp_leaf_max_page_size', 'compressed page maximum leaf page size prior to compression ', 'no_clear,no_scale,size'),
+    CompressStat('compress_read', 'compressed pages read'),
     CompressStat('compress_write', 'compressed pages written'),
     CompressStat('compress_write_fail', 'page written failed to compress'),
     CompressStat('compress_write_too_small', 'page written was too small to compress'),
diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 11bc6d2d893..0487e58525a 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": "fafdde779d6825b00810b164f123f64b5559bf00"
+    "commit": "e3e77069b2b56efb1445f150bc28945af9c95157"
 }
diff --git a/src/third_party/wiredtiger/src/block/block_cache.c b/src/third_party/wiredtiger/src/block/block_cache.c
new file mode 100644
index 00000000000..40e3b21b1c9
--- /dev/null
+++ b/src/third_party/wiredtiger/src/block/block_cache.c
@@ -0,0 +1,889 @@
+/*-
+ * Copyright (c) 2014-2020 MongoDB, Inc.
+ * Copyright (c) 2008-2014 WiredTiger, Inc.
+ *  All rights reserved.
+ *
+ * See the file LICENSE for redistribution information.
+ */
+
+#include "wt_internal.h"
+
+/*
+ * __blkcache_aggregate_metadata --
+ *     Sum the metadata for all buckets and write it into the cache wide variables.
+ */
+static void
+__blkcache_aggregate_metadata(WT_BLKCACHE *blkcache)
+{
+    uint64_t bytes_used, num_data_blocks;
+    u_int i;
+
+    bytes_used = num_data_blocks = 0;
+
+    for (i = 0; i < blkcache->hash_size; i++) {
+        bytes_used += blkcache->bucket_metadata[i].bucket_bytes_used;
+        num_data_blocks += blkcache->bucket_metadata[i].bucket_num_data_blocks;
+    }
+
+    blkcache->bytes_used = bytes_used;
+    blkcache->num_data_blocks = num_data_blocks;
+}
+
+/*
+ * __blkcache_alloc --
+ *     Allocate a block of memory in the cache.
+ */
+static int
+__blkcache_alloc(WT_SESSION_IMPL *session, size_t size, void **retp)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    if (blkcache->type == BLKCACHE_DRAM)
+        return (__wt_malloc(session, size, retp));
+    else if (blkcache->type == BLKCACHE_NVRAM) {
+#ifdef HAVE_LIBMEMKIND
+        *retp = memkind_malloc(blkcache->pmem_kind, size);
+        if (*retp == NULL)
+            return (WT_BLKCACHE_FULL);
+#else
+        WT_RET_MSG(session, EINVAL, "NVRAM block cache type requires libmemkind");
+#endif
+    }
+    return (0);
+}
+
+/*
+ * __blkcache_free --
+ *     Free a chunk of memory.
+ */
+static void
+__blkcache_free(WT_SESSION_IMPL *session, void *ptr)
+{
+
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    if (blkcache->type == BLKCACHE_DRAM)
+        __wt_free(session, ptr);
+    else if (blkcache->type == BLKCACHE_NVRAM) {
+#ifdef HAVE_LIBMEMKIND
+        memkind_free(blkcache->pmem_kind, ptr);
+#else
+        __wt_err(session, EINVAL, "NVRAM block cache type requires libmemkind.");
+#endif
+    }
+}
+
+/*
+ * __blkcache_update_ref_histogram --
+ *     Update the histogram of block accesses when the block is freed or on exit.
+ */
+static void
+__blkcache_update_ref_histogram(WT_SESSION_IMPL *session, WT_BLKCACHE_ITEM *blkcache_item, int type)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+    u_int bucket;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    bucket = blkcache_item->num_references / BLKCACHE_HIST_BOUNDARY;
+    if (bucket > BLKCACHE_HIST_BUCKETS - 1)
+        bucket = BLKCACHE_HIST_BUCKETS - 1;
+
+    blkcache->cache_references[bucket]++;
+
+    if (type == BLKCACHE_RM_FREE)
+        blkcache->cache_references_removed_blocks[bucket]++;
+    else if (type == BLKCACHE_RM_EVICTION)
+        blkcache->cache_references_evicted_blocks[bucket]++;
+}
+
+/*
+ * __blkcache_print_reference_hist --
+ *     Print a histogram showing how a type of block given in the header is reused.
+ */
+static void
+__blkcache_print_reference_hist(WT_SESSION_IMPL *session, const char *header, uint32_t *hist)
+{
+    int j;
+
+    __wt_verbose(session, WT_VERB_BLKCACHE, "%s:", header);
+    __wt_verbose(session, WT_VERB_BLKCACHE, "%s", "Reuses \t Number of blocks");
+    __wt_verbose(session, WT_VERB_BLKCACHE, "%s", "-----------------------------");
+    for (j = 0; j < BLKCACHE_HIST_BUCKETS; j++) {
+        __wt_verbose(session, WT_VERB_BLKCACHE, "[%d - %d] \t %u", j * BLKCACHE_HIST_BOUNDARY,
+          (j + 1) * BLKCACHE_HIST_BOUNDARY, hist[j]);
+    }
+}
+
+/*
+ * __blkcache_high_overhead --
+ *     Estimate the overhead of using the cache. The overhead comes from block insertions and
+ *     removals, which produce writes. Writes disproportionally slow down the reads on Optane NVRAM.
+ */
+static inline bool
+__blkcache_high_overhead(WT_SESSION_IMPL *session)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    if ((float)(blkcache->inserts + blkcache->removals) / (float)(blkcache->lookups) >
+      blkcache->overhead_pct)
+        return (true);
+
+    return (false);
+}
+
+/*
+ * __blkcache_should_evict --
+ *     Decide if the block should be evicted.
+ */
+static bool
+__blkcache_should_evict(WT_SESSION_IMPL *session, WT_BLKCACHE_ITEM *blkcache_item, int *reason)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    *reason = BLKCACHE_EVICT_OTHER;
+
+    /*
+     * Keep track of the smallest number of references for blocks that have not been recently
+     * accessed.
+     */
+    if ((blkcache_item->freq_rec_counter < blkcache->evict_aggressive) &&
+      (blkcache_item->num_references < blkcache->min_num_references))
+        blkcache->min_num_references = blkcache_item->num_references;
+
+    /* Don't evict if there is plenty of free space */
+    if (blkcache->bytes_used < blkcache->full_target)
+        return (false);
+
+    /*
+     * Don't evict if there is high overhead due to blocks being inserted/removed. Churn kills
+     * performance and evicting when churn is high will exacerbate the overhead.
+     */
+    if (__blkcache_high_overhead(session)) {
+        WT_STAT_CONN_INCR(session, block_cache_not_evicted_overhead);
+        return (false);
+    }
+
+    /*
+     * Evict if the block has not been accessed for the amount of time corresponding to the evict
+     * aggressive setting. Within the category of blocks that fit this criterion, choose those with
+     * the lowest number of accesses first.
+     */
+    if (blkcache_item->freq_rec_counter < blkcache->evict_aggressive &&
+      blkcache_item->num_references < (blkcache->min_num_references + BLKCACHE_MINREF_INCREMENT))
+        return (true);
+    else {
+        *reason = BLKCACHE_NOT_EVICTION_CANDIDATE;
+        return (false);
+    }
+}
+
+/*
+ * __blkcache_eviction_thread --
+ *     Periodically sweep the cache and evict unused blocks.
+ */
+static WT_THREAD_RET
+__blkcache_eviction_thread(void *arg)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLKCACHE_ITEM *blkcache_item, *blkcache_item_tmp;
+    WT_CONNECTION_IMPL *conn;
+    WT_SESSION_IMPL *session;
+    int i, reason;
+    bool no_eviction_candidates;
+
+    session = (WT_SESSION_IMPL *)arg;
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "Block cache eviction thread starting... "
+      "Aggressive target = %d, full target = %" PRIu64 ":",
+      blkcache->evict_aggressive, blkcache->full_target);
+
+    while (!blkcache->blkcache_exiting) {
+
+        /*
+         * Sweep the cache every second to ensure time-based decay of frequency/recency counters of
+         * resident blocks.
+         */
+        __wt_sleep(1, 0);
+
+        /* Check if the cache is being destroyed */
+        if (blkcache->blkcache_exiting)
+            return (0);
+
+        /* Aggregate per bucket metadata into cache wide variables. */
+        __blkcache_aggregate_metadata(blkcache);
+
+        /*
+         * Walk the cache, gathering statistics and evicting blocks that are within our target. We
+         * sweep the cache every second, decrementing the frequency/recency counter of each block.
+         * Blocks whose counter goes below the threshold will get evicted. The threshold is set
+         * according to how soon we expect the blocks to become irrelevant. For example, if the
+         * threshold is set to 1800 seconds (=30 minutes), blocks that were used once but then
+         * weren't referenced for 30 minutes will be evicted. Blocks that were referenced a lot in
+         * the past but weren't referenced in the past 30 minutes will stay in the cache a bit
+         * longer, until their frequency/recency counter drops below the threshold.
+         *
+         * As we cycle through the blocks, we keep track of the minimum number of references
+         * observed for blocks whose frequency/recency counter has gone below the threshold. We will
+         * evict blocks with the smallest counter before evicting those with a larger one.
+         */
+        no_eviction_candidates = true;
+        for (i = 0; i < (int)blkcache->hash_size; i++) {
+            __wt_spin_lock(session, &blkcache->hash_locks[i]);
+            TAILQ_FOREACH_SAFE(blkcache_item, &blkcache->hash[i], hashq, blkcache_item_tmp)
+            {
+                if (__blkcache_should_evict(session, blkcache_item, &reason)) {
+                    TAILQ_REMOVE(&blkcache->hash[i], blkcache_item, hashq);
+                    __blkcache_free(session, blkcache_item->data);
+                    __blkcache_update_ref_histogram(session, blkcache_item, BLKCACHE_RM_EVICTION);
+                    blkcache->bucket_metadata[i].bucket_num_data_blocks--;
+                    blkcache->bucket_metadata[i].bucket_bytes_used -= blkcache_item->id.size;
+
+                    /*
+                     * Update the number of removals because it is used to estimate the overhead,
+                     * and we want the overhead contributed by eviction to be part of that
+                     * calculation.
+                     */
+                    blkcache->removals++;
+
+                    WT_STAT_CONN_INCR(session, block_cache_blocks_evicted);
+                    WT_STAT_CONN_DECRV(session, block_cache_bytes, blkcache_item->id.size);
+                    WT_STAT_CONN_DECR(session, block_cache_blocks);
+                    __wt_free(session, blkcache_item);
+                } else {
+                    blkcache_item->freq_rec_counter--;
+                    if (reason != BLKCACHE_NOT_EVICTION_CANDIDATE)
+                        no_eviction_candidates = false;
+                }
+            }
+            __wt_spin_unlock(session, &blkcache->hash_locks[i]);
+            if (blkcache->blkcache_exiting)
+                return (0);
+        }
+        if (no_eviction_candidates) {
+            blkcache->min_num_references += BLKCACHE_MINREF_INCREMENT;
+        }
+
+        WT_STAT_CONN_INCR(session, block_cache_eviction_passes);
+    }
+    return (0);
+}
+
+/*
+ * __blkcache_estimate_filesize --
+ *     Estimate the size of files used by this workload.
+ */
+static size_t
+__blkcache_estimate_filesize(WT_SESSION_IMPL *session)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLOCK *block;
+    WT_CONNECTION_IMPL *conn;
+    size_t size;
+    uint64_t bucket;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    /* This is a deliberate race condition */
+    if (blkcache->refs_since_filesize_estimated++ < BLKCACHE_FILESIZE_EST_FREQ)
+        return (blkcache->estimated_file_size);
+
+    blkcache->refs_since_filesize_estimated = 0;
+
+    size = 0;
+    __wt_spin_lock(session, &conn->block_lock);
+    for (bucket = 0; bucket < conn->hash_size; bucket++) {
+        TAILQ_FOREACH (block, &conn->blockhash[bucket], hashq) {
+            size += (size_t)block->size;
+        }
+    }
+    blkcache->estimated_file_size = size;
+    __wt_spin_unlock(session, &conn->block_lock);
+
+    WT_STAT_CONN_SET(session, block_cache_bypass_filesize, blkcache->estimated_file_size);
+
+    return (blkcache->estimated_file_size);
+}
+
+/*
+ * __wt_blkcache_get_or_check --
+ *     Get a block from the cache or check if one exists.
+ */
+int
+__wt_blkcache_get_or_check(
+  WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32_t checksum, void *data_ptr)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLKCACHE_ID id;
+    WT_BLKCACHE_ITEM *blkcache_item;
+    WT_CONNECTION_IMPL *conn;
+    uint64_t bucket, hash;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    blkcache_item = NULL;
+
+    if (blkcache->type == BLKCACHE_UNCONFIGURED)
+        return (-1);
+
+    WT_STAT_CONN_INCR(session, block_cache_data_refs);
+
+    /*
+     * We race to avoid using synchronization. We only care about an approximate value, so we accept
+     * inaccuracy for the sake of avoiding synchronization on the critical path.
+     */
+    blkcache->lookups++;
+
+    /*
+     * If more than the configured fraction of all file objects is likely to fit in the OS buffer
+     * cache, don't use this cache.
+     */
+    if (blkcache->system_ram >=
+      __blkcache_estimate_filesize(session) * blkcache->fraction_in_os_cache) {
+        WT_STAT_CONN_INCR(session, block_cache_bypass_get);
+        return (WT_BLKCACHE_BYPASS);
+    }
+
+    /*
+     * We will use the item id structure as a byte array for (1) computing a hash, and
+     * (2) for comparing with the items in the hash table. We therefore need to
+     * zero the struct, because if it is padded by the compiler there could be
+     * bytes in the padding that have arbitrary values.
+     */
+    memset((void *)&id, 0, sizeof(id));
+
+    id.checksum = checksum;
+    id.offset = offset;
+    id.size = (uint32_t)size;
+    hash = __wt_hash_city64(&id, sizeof(id));
+
+    bucket = hash % blkcache->hash_size;
+    __wt_spin_lock(session, &blkcache->hash_locks[bucket]);
+    TAILQ_FOREACH (blkcache_item, &blkcache->hash[bucket], hashq) {
+        if (blkcache_item->id.checksum == id.checksum && blkcache_item->id.offset == id.offset &&
+          blkcache_item->id.size == id.size) {
+            if (data_ptr != NULL)
+                memcpy(data_ptr, blkcache_item->data, size);
+
+            blkcache_item->num_references++;
+            if (blkcache_item->freq_rec_counter < 0)
+                blkcache_item->freq_rec_counter = 0;
+            blkcache_item->freq_rec_counter++;
+
+            __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+            WT_STAT_CONN_INCR(session, block_cache_hits);
+            __wt_verbose(session, WT_VERB_BLKCACHE,
+              "block found in cache: offset=%" PRIuMAX ", size=%" WT_SIZET_FMT ", checksum=%" PRIu32
+              ", hash=%" PRIu64,
+              (uintmax_t)offset, size, checksum, hash);
+            return (0);
+        }
+    }
+
+    /* Block not found */
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "block not found in cache: offset=%" PRIuMAX ", size=%" WT_SIZET_FMT ", checksum=%" PRIu32
+      ", hash=%" PRIu64,
+      (uintmax_t)offset, size, checksum, hash);
+
+    __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+    WT_STAT_CONN_INCR(session, block_cache_misses);
+    return (-1);
+}
+
+/*
+ * __wt_blkcache_put --
+ *     Put a block into the cache.
+ */
+int
+__wt_blkcache_put(WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32_t checksum,
+  void *data, bool checkpoint_io, bool write)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLKCACHE_ID id;
+    WT_BLKCACHE_ITEM *blkcache_item;
+    WT_CONNECTION_IMPL *conn;
+    WT_DECL_RET;
+    uint64_t bucket, hash;
+    void *data_ptr;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    blkcache_item = NULL;
+    data_ptr = NULL;
+
+    if (blkcache->type == BLKCACHE_UNCONFIGURED)
+        return (-1);
+
+    /* Bypass on write if the no-write-allocate setting is on */
+    if (write && blkcache->cache_on_writes == false) {
+        WT_STAT_CONN_INCR(session, block_cache_bypass_writealloc);
+        return (-1);
+    }
+
+    /* Are we within cache size limits? */
+    if (blkcache->bytes_used >= blkcache->max_bytes)
+        return (WT_BLKCACHE_FULL);
+
+    /*
+     * If more than the configured fraction of the file is likely to fit into the OS buffer cache,
+     * don't use this cache.
+     */
+    if (blkcache->system_ram >=
+      __blkcache_estimate_filesize(session) * blkcache->fraction_in_os_cache) {
+        WT_STAT_CONN_INCR(session, block_cache_bypass_put);
+        return (WT_BLKCACHE_BYPASS);
+    }
+
+    /*
+     * Do not write allocate if this block is written as part of checkpoint. Hot blocks get written
+     * and over-written a lot as part of checkpoint, so we don't want to cache them, because (a)
+     * they are in the DRAM cache anyway, and (b) they are likely to be overwritten anyway.
+     *
+     * Writes that are not part of checkpoint I/O are done in the service of eviction. Those are the
+     * blocks that the DRAM cache would like to keep but can't, and we definitely want to keep them.
+     */
+    if ((blkcache->cache_on_checkpoint == false) && checkpoint_io) {
+        WT_STAT_CONN_INCR(session, block_cache_bypass_chkpt);
+        return (WT_BLKCACHE_BYPASS);
+    }
+
+    /* Bypass on high overhead */
+    if (__blkcache_high_overhead(session) == true) {
+        WT_STAT_CONN_INCR(session, block_cache_bypass_overhead_put);
+        return (WT_BLKCACHE_BYPASS);
+    }
+    /*
+     * Allocate space in the cache outside of the critical section. In the unlikely event that we
+     * fail to allocate metadata, or if the item exists and the caller did not check for that prior
+     * to calling this function, we will free the space.
+     */
+    WT_RET(__blkcache_alloc(session, size, &data_ptr));
+
+    /*
+     * We will use the item id structure as a byte array for (1) computing a hash, and
+     * (2) for comparing with the items in the hash table. We therefore need to
+     * zero the struct, because if it is padded by the compiler there could be
+     * bytes in the padding that have arbitrary values.
+     */
+    memset((void *)&id, 0, sizeof(id));
+
+    id.checksum = checksum;
+    id.offset = offset;
+    id.size = (uint32_t)size;
+    hash = __wt_hash_city64(&id, sizeof(id));
+
+    bucket = hash % blkcache->hash_size;
+    __wt_spin_lock(session, &blkcache->hash_locks[bucket]);
+    TAILQ_FOREACH (blkcache_item, &blkcache->hash[bucket], hashq) {
+        if (blkcache_item->id.checksum == id.checksum && blkcache_item->id.offset == id.offset &&
+          blkcache_item->id.size == id.size)
+            goto item_exists;
+    }
+
+    WT_ERR(__wt_calloc_one(session, &blkcache_item));
+    blkcache_item->id = id;
+    blkcache_item->data = data_ptr;
+
+    /*
+     * Set the recency timestamp on newly inserted blocks to the maximum value to reduce the chance
+     * of them being evicted before they are reused.
+     */
+    blkcache_item->freq_rec_counter = 1;
+
+    if (data != NULL && blkcache_item->data != NULL) /* This makes static analyzers happier. */
+        memcpy(blkcache_item->data, data, size);
+    TAILQ_INSERT_HEAD(&blkcache->hash[bucket], blkcache_item, hashq);
+
+    blkcache->bucket_metadata[bucket].bucket_num_data_blocks++;
+    blkcache->bucket_metadata[bucket].bucket_bytes_used += size;
+    blkcache->inserts++;
+
+    __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+
+    WT_STAT_CONN_INCRV(session, block_cache_bytes, size);
+    WT_STAT_CONN_INCR(session, block_cache_blocks);
+    if (write == true) {
+        WT_STAT_CONN_INCRV(session, block_cache_bytes_insert_write, size);
+        WT_STAT_CONN_INCR(session, block_cache_blocks_insert_write);
+    } else {
+        WT_STAT_CONN_INCRV(session, block_cache_bytes_insert_read, size);
+        WT_STAT_CONN_INCR(session, block_cache_blocks_insert_read);
+    }
+
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "block inserted in cache: offset=%" PRIuMAX ", size=%" WT_SIZET_FMT ", checksum=%" PRIu32
+      ", hash=%" PRIu64,
+      (uintmax_t)offset, size, checksum, hash);
+    return (0);
+
+item_exists:
+    if (write) {
+        memcpy(blkcache_item->data, data, size);
+        WT_STAT_CONN_INCRV(session, block_cache_bytes_update, size);
+        WT_STAT_CONN_INCR(session, block_cache_blocks_update);
+    }
+
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "block exists during put: offset=%" PRIuMAX ", size=%" WT_SIZET_FMT
+      ", "
+      "checksum=%" PRIu32 ", hash=%" PRIu64,
+      (uintmax_t)offset, size, checksum, hash);
+err:
+    __blkcache_free(session, data_ptr);
+    __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+    return (ret);
+}
+
+/*
+ * __wt_blkcache_remove --
+ *     Remove a block from the cache.
+ */
+void
+__wt_blkcache_remove(WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32_t checksum)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLKCACHE_ID id;
+    WT_BLKCACHE_ITEM *blkcache_item;
+    WT_CONNECTION_IMPL *conn;
+    uint64_t bucket, hash;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    blkcache_item = NULL;
+
+    if (blkcache->type == BLKCACHE_UNCONFIGURED)
+        return;
+
+    /*
+     * We will use the item id structure as a byte array for (1) computing a hash, and
+     * (2) for comparing with the items in the hash table. We therefore need to
+     * zero the struct, because if it is padded by the compiler there could be
+     * bytes in the padding that have arbitrary values.
+     */
+    memset((void *)&id, 0, sizeof(id));
+
+    id.checksum = checksum;
+    id.offset = offset;
+    id.size = (uint32_t)size;
+    hash = __wt_hash_city64(&id, sizeof(id));
+
+    bucket = hash % blkcache->hash_size;
+    __wt_spin_lock(session, &blkcache->hash_locks[bucket]);
+    TAILQ_FOREACH (blkcache_item, &blkcache->hash[bucket], hashq) {
+        if (blkcache_item->id.checksum == id.checksum && blkcache_item->id.offset == id.offset &&
+          blkcache_item->id.size == id.size) {
+            TAILQ_REMOVE(&blkcache->hash[bucket], blkcache_item, hashq);
+            blkcache->bucket_metadata[bucket].bucket_num_data_blocks--;
+            blkcache->bucket_metadata[bucket].bucket_bytes_used -= size;
+            __blkcache_update_ref_histogram(session, blkcache_item, BLKCACHE_RM_FREE);
+            __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+            __blkcache_free(session, blkcache_item->data);
+            __wt_overwrite_and_free(session, blkcache_item);
+            WT_STAT_CONN_DECRV(session, block_cache_bytes, size);
+            WT_STAT_CONN_DECR(session, block_cache_blocks);
+            WT_STAT_CONN_INCR(session, block_cache_blocks_removed);
+            blkcache->removals++;
+            __wt_verbose(session, WT_VERB_BLKCACHE,
+              "block removed from cache: offset=%" PRIuMAX ", size=%" WT_SIZET_FMT
+              ", checksum=%" PRIu32 ", hash=%" PRIu64,
+              (uintmax_t)offset, size, checksum, hash);
+            return;
+        }
+    }
+    __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+}
+
+/*
+ * __blkcache_init --
+ *     Initialize the block cache.
+ */
+static int
+__blkcache_init(WT_SESSION_IMPL *session, size_t cache_size, u_int hash_size, u_int type,
+  char *nvram_device_path, size_t system_ram, u_int percent_file_in_os_cache, bool cache_on_writes,
+  float overhead_pct, u_int evict_aggressive, uint64_t full_target, bool cache_on_checkpoint)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+    WT_DECL_RET;
+    uint64_t i;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    blkcache->cache_on_checkpoint = cache_on_checkpoint;
+    blkcache->cache_on_writes = cache_on_writes;
+    blkcache->hash_size = hash_size;
+    blkcache->fraction_in_os_cache = (float)percent_file_in_os_cache / 100;
+    blkcache->full_target = full_target;
+    blkcache->max_bytes = cache_size;
+    blkcache->overhead_pct = overhead_pct;
+    blkcache->system_ram = system_ram;
+
+    if (type == BLKCACHE_NVRAM) {
+#ifdef HAVE_LIBMEMKIND
+        if ((ret = memkind_create_pmem(nvram_device_path, 0, &blkcache->pmem_kind)) != 0)
+            WT_RET_MSG(session, ret, "block cache failed to initialize: memkind_create_pmem");
+
+        WT_RET(__wt_strndup(
+          session, nvram_device_path, strlen(nvram_device_path), &blkcache->nvram_device_path));
+        __wt_free(session, nvram_device_path);
+#else
+        (void)nvram_device_path;
+        WT_RET_MSG(session, EINVAL, "NVRAM block cache type requires libmemkind");
+#endif
+    }
+
+    WT_RET(__wt_calloc_def(session, blkcache->hash_size, &blkcache->hash));
+    WT_RET(__wt_calloc_def(session, blkcache->hash_size, &blkcache->hash_locks));
+    WT_RET(__wt_calloc_def(session, blkcache->hash_size, &blkcache->bucket_metadata));
+
+    for (i = 0; i < blkcache->hash_size; i++) {
+        TAILQ_INIT(&blkcache->hash[i]); /* Block cache hash lists */
+        WT_RET(__wt_spin_init(session, &blkcache->hash_locks[i], "block cache bucket locks"));
+    }
+
+    /* Create the eviction thread */
+    WT_RET(__wt_thread_create(
+      session, &blkcache->evict_thread_tid, __blkcache_eviction_thread, (void *)session));
+    blkcache->evict_aggressive = -((int)evict_aggressive);
+    blkcache->min_num_references = 1000; /* initialize to a large value */
+
+    blkcache->type = type;
+
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "block cache initialized: type=%s, size=%" WT_SIZET_FMT " path=%s",
+      (type == BLKCACHE_NVRAM) ? "nvram" : (type == BLKCACHE_DRAM) ? "dram" : "unconfigured",
+      cache_size, (blkcache->nvram_device_path == NULL) ? "--" : blkcache->nvram_device_path);
+
+    return (ret);
+}
+
+/*
+ * __wt_block_cache_destroy --
+ *     Destroy the block cache and free all memory.
+ */
+void
+__wt_block_cache_destroy(WT_SESSION_IMPL *session)
+{
+    WT_BLKCACHE *blkcache;
+    WT_BLKCACHE_ITEM *blkcache_item;
+    WT_CONNECTION_IMPL *conn;
+    WT_DECL_RET;
+    uint64_t i;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    blkcache_item = NULL;
+
+    __wt_verbose(session, WT_VERB_BLKCACHE,
+      "block cache with %" PRIu64 " bytes used to be destroyed", blkcache->bytes_used);
+
+    if (blkcache->type == BLKCACHE_UNCONFIGURED)
+        return;
+
+    blkcache->blkcache_exiting = true;
+    WT_TRET(__wt_thread_join(session, &blkcache->evict_thread_tid));
+    __wt_verbose(session, WT_VERB_BLKCACHE, "%s", "block cache eviction thread exited...");
+
+    __blkcache_aggregate_metadata(blkcache);
+
+    if (blkcache->bytes_used == 0)
+        goto done;
+
+    for (i = 0; i < blkcache->hash_size; i++) {
+        __wt_spin_lock(session, &blkcache->hash_locks[i]);
+        while (!TAILQ_EMPTY(&blkcache->hash[i])) {
+            blkcache_item = TAILQ_FIRST(&blkcache->hash[i]);
+            TAILQ_REMOVE(&blkcache->hash[i], blkcache_item, hashq);
+            /*
+             * Some workloads crash on freeing NVRAM arenas. If that occurs the call to free can be
+             * removed and the library/OS will clean up for us once the process exits.
+             */
+            __blkcache_free(session, blkcache_item->data);
+            __blkcache_update_ref_histogram(session, blkcache_item, BLKCACHE_RM_EXIT);
+            blkcache->bucket_metadata[i].bucket_num_data_blocks--;
+            blkcache->bucket_metadata[i].bucket_bytes_used -= blkcache_item->id.size;
+            __wt_free(session, blkcache_item);
+        }
+        __wt_spin_unlock(session, &blkcache->hash_locks[i]);
+    }
+    __blkcache_aggregate_metadata(blkcache);
+    WT_ASSERT(session, blkcache->bytes_used == 0 && blkcache->num_data_blocks == 0);
+
+done:
+    /* Print reference histograms */
+    __blkcache_print_reference_hist(session, "All blocks", blkcache->cache_references);
+    __blkcache_print_reference_hist(
+      session, "Removed blocks", blkcache->cache_references_removed_blocks);
+    __blkcache_print_reference_hist(
+      session, "Evicted blocks", blkcache->cache_references_evicted_blocks);
+
+#ifdef HAVE_LIBMEMKIND
+    if (blkcache->type == BLKCACHE_NVRAM) {
+        memkind_destroy_kind(blkcache->pmem_kind);
+        __wt_free(session, blkcache->nvram_device_path);
+    }
+#endif
+    __wt_free(session, blkcache->hash);
+    __wt_free(session, blkcache->hash_locks);
+    __wt_free(session, blkcache->bucket_metadata);
+    /*
+     * Zeroing the structure has the effect of setting the block cache type to unconfigured.
+     */
+    memset((void *)blkcache, 0, sizeof(WT_BLKCACHE));
+}
+
+/*
+ * __blkcache_reconfig --
+ *     We currently disallow reconfiguration. If and when we do, this function will destroy the
+ *     block cache, making it ready for clean initialization.
+ */
+static int
+__blkcache_reconfig(WT_SESSION_IMPL *session, bool reconfig, size_t cache_size, size_t hash_size,
+  u_int type, char *nvram_device_path, size_t system_ram, u_int percent_file_in_os_cache,
+  bool cache_on_writes, float overhead_pct, u_int evict_aggressive, uint64_t full_target,
+  bool cache_on_checkpoint)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONNECTION_IMPL *conn;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+
+    if (!reconfig || blkcache->type == BLKCACHE_UNCONFIGURED)
+        return (0);
+
+    if (blkcache->cache_on_checkpoint != cache_on_checkpoint ||
+      blkcache->cache_on_writes != cache_on_writes || blkcache->hash_size != hash_size ||
+      __wt_floatcmp(blkcache->fraction_in_os_cache, (float)percent_file_in_os_cache / 100) != 0 ||
+      blkcache->full_target != full_target || blkcache->max_bytes != cache_size ||
+      __wt_floatcmp(blkcache->overhead_pct, overhead_pct) != 0 ||
+      blkcache->system_ram != system_ram ||
+      blkcache->evict_aggressive != -((int)evict_aggressive) || blkcache->type != type ||
+      (nvram_device_path != NULL && blkcache->nvram_device_path == NULL) ||
+      (nvram_device_path == NULL && blkcache->nvram_device_path != NULL) ||
+      (nvram_device_path != NULL && blkcache->nvram_device_path != NULL &&
+        (strlen(nvram_device_path) != strlen(blkcache->nvram_device_path))) ||
+      (nvram_device_path != NULL &&
+        strncmp(nvram_device_path, blkcache->nvram_device_path, strlen(nvram_device_path)) != 0)) {
+        __wt_err(session, EINVAL, "block cache reconfiguration not supported");
+        return (WT_ERROR);
+    }
+    return (0);
+}
+
+/*
+ * __wt_block_cache_setup --
+ *     Set up the block cache.
+ */
+int
+__wt_block_cache_setup(WT_SESSION_IMPL *session, const char *cfg[], bool reconfig)
+{
+    WT_BLKCACHE *blkcache;
+    WT_CONFIG_ITEM cval;
+    WT_CONNECTION_IMPL *conn;
+    WT_DECL_RET;
+    float overhead_pct;
+    uint64_t cache_size, full_target, system_ram;
+    u_int cache_type, evict_aggressive, hash_size, percent_file_in_os_cache;
+    char *nvram_device_path;
+    bool cache_on_checkpoint, cache_on_writes;
+
+    conn = S2C(session);
+    blkcache = &conn->blkcache;
+    cache_on_checkpoint = cache_on_writes = true;
+    nvram_device_path = (char *)"";
+
+    if (blkcache->type != BLKCACHE_UNCONFIGURED && !reconfig)
+        WT_RET_MSG(session, EINVAL, "block cache setup requested for a configured cache");
+
+    /* When reconfiguring, check if there are any modifications that we care about. */
+    if (blkcache->type != BLKCACHE_UNCONFIGURED && reconfig) {
+        if ((ret = __wt_config_gets(session, cfg + 1, "block_cache", &cval)) == WT_NOTFOUND)
+            return (0);
+        WT_RET(ret);
+    }
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.enabled", &cval));
+    if (cval.val == 0)
+        return (0);
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.size", &cval));
+    if ((cache_size = (uint64_t)cval.val) <= 0)
+        WT_RET_MSG(session, EINVAL, "block cache size must be greater than zero");
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.hashsize", &cval));
+    if ((hash_size = (u_int)cval.val) == 0)
+        hash_size = BLKCACHE_HASHSIZE_DEFAULT;
+    else if (hash_size < BLKCACHE_HASHSIZE_MIN || hash_size > BLKCACHE_HASHSIZE_MAX)
+        WT_RET_MSG(session, EINVAL, "block cache hash size must be between %d and %d entries",
+          BLKCACHE_HASHSIZE_MIN, BLKCACHE_HASHSIZE_MAX);
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.type", &cval));
+    if (WT_STRING_MATCH("dram", cval.str, cval.len) || WT_STRING_MATCH("DRAM", cval.str, cval.len))
+        cache_type = BLKCACHE_DRAM;
+    else if (WT_STRING_MATCH("nvram", cval.str, cval.len) ||
+      WT_STRING_MATCH("NVRAM", cval.str, cval.len)) {
+#ifdef HAVE_LIBMEMKIND
+        cache_type = BLKCACHE_NVRAM;
+        WT_RET(__wt_config_gets(session, cfg, "block_cache.nvram_path", &cval));
+        WT_RET(__wt_strndup(session, cval.str, cval.len, &nvram_device_path));
+        WT_ASSERT(session, __wt_absolute_path(nvram_device_path));
+#else
+        WT_RET_MSG(session, EINVAL, "NVRAM block cache requires libmemkind");
+#endif
+    } else
+        WT_RET_MSG(session, EINVAL, "Invalid block cache type.");
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.system_ram", &cval));
+    system_ram = (uint64_t)cval.val;
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.percent_file_in_dram", &cval));
+    percent_file_in_os_cache = (u_int)cval.val;
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.cache_on_checkpoint", &cval));
+    if (cval.val == 0)
+        cache_on_checkpoint = false;
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.blkcache_eviction_aggression", &cval));
+    evict_aggressive = (u_int)cval.val;
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.full_target", &cval));
+    full_target = (uint64_t)((float)cache_size * (float)cval.val / (float)100);
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.cache_on_writes", &cval));
+    if (cval.val == 0)
+        cache_on_writes = false;
+
+    WT_RET(__wt_config_gets(session, cfg, "block_cache.max_percent_overhead", &cval));
+    overhead_pct = (float)cval.val / (float)100;
+
+    WT_RET(__blkcache_reconfig(session, reconfig, cache_size, hash_size, cache_type,
+      nvram_device_path, system_ram, percent_file_in_os_cache, cache_on_writes, overhead_pct,
+      evict_aggressive, full_target, cache_on_checkpoint));
+
+    return (__blkcache_init(session, cache_size, hash_size, cache_type, nvram_device_path,
+      system_ram, percent_file_in_os_cache, cache_on_writes, overhead_pct, evict_aggressive,
+      full_target, cache_on_checkpoint));
+}
diff --git a/src/third_party/wiredtiger/src/block/block_ext.c b/src/third_party/wiredtiger/src/block/block_ext.c
index 37916e482de..32bde280e69 100644
--- a/src/third_party/wiredtiger/src/block/block_ext.c
+++ b/src/third_party/wiredtiger/src/block/block_ext.c
@@ -588,6 +588,9 @@ __wt_block_free(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr,
     ret = __wt_block_off_free(session, block, objectid, offset, (wt_off_t)size);
     __wt_spin_unlock(session, &block->live_lock);
 
+    /* Evict the freed block from the block cache */
+    __wt_blkcache_remove(session, offset, size, checksum);
+
     return (ret);
 }
 
diff --git a/src/third_party/wiredtiger/src/block/block_read.c b/src/third_party/wiredtiger/src/block/block_read.c
index 3fec75acfe8..0ed4c05d7b2 100644
--- a/src/third_party/wiredtiger/src/block/block_read.c
+++ b/src/third_party/wiredtiger/src/block/block_read.c
@@ -217,8 +217,10 @@ __wt_block_read_off(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, uin
   wt_off_t offset, uint32_t size, uint32_t checksum)
 {
     WT_BLOCK_HEADER *blk, swap;
+    WT_DECL_RET;
     WT_FH *fh;
     size_t bufsize;
+    int cret;
 
     __wt_verbose(session, WT_VERB_READ, "off %" PRIuMAX ", size %" PRIu32 ", checksum %#" PRIx32,
       (uintmax_t)offset, size, checksum);
@@ -250,8 +252,22 @@ __wt_block_read_off(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, uin
           block->name, size, block->allocsize);
 
     WT_RET(__wt_buf_init(session, buf, bufsize));
+
     WT_RET(__wt_block_fh(session, block, objectid, &fh));
-    WT_RET(__wt_read(session, fh, offset, size, buf->mem));
+
+    /* Ask the block cache to give us the block. If it doesn't have it, read it. */
+    if (fh->file_type != WT_FS_OPEN_FILE_TYPE_DATA)
+        WT_RET(__wt_read(session, fh, offset, size, buf->mem));
+    else {
+        if ((cret = __wt_blkcache_get_or_check(session, offset, size, checksum, buf->mem)) != 0) {
+            WT_RET(__wt_read(session, fh, offset, size, buf->mem));
+            if (cret != WT_BLKCACHE_BYPASS) {
+                WT_TRET_ERROR_OK(
+                  __wt_blkcache_put(session, offset, size, checksum, buf->mem, false, false),
+                  WT_BLKCACHE_FULL);
+            }
+        }
+    }
     buf->size = size;
 
     /*
diff --git a/src/third_party/wiredtiger/src/block/block_write.c b/src/third_party/wiredtiger/src/block/block_write.c
index 442d69927f8..227395c7a1a 100644
--- a/src/third_party/wiredtiger/src/block/block_write.c
+++ b/src/third_party/wiredtiger/src/block/block_write.c
@@ -333,6 +333,11 @@ __block_write_off(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf, uint3
         WT_RET(ret);
     }
 
+    if (block->fh->file_type == WT_FS_OPEN_FILE_TYPE_DATA) {
+        WT_TRET_ERROR_OK(
+          __wt_blkcache_put(session, offset, align_size, checksum, buf->mem, checkpoint_io, true),
+          WT_BLKCACHE_FULL);
+    }
     /*
      * Optionally schedule writes for dirty pages in the system buffer cache, but only if the
      * current session can wait.
diff --git a/src/third_party/wiredtiger/src/btree/bt_io.c b/src/third_party/wiredtiger/src/btree/bt_io.c
index 385968a8a2c..6e22631f7d7 100644
--- a/src/third_party/wiredtiger/src/btree/bt_io.c
+++ b/src/third_party/wiredtiger/src/btree/bt_io.c
@@ -9,6 +9,11 @@
 #include "wt_internal.h"
 
 /*
+ * Define a function that increments histogram statistics compression ratios.
+ */
+WT_STAT_COMPR_RATIO_HIST_INCR_FUNC(ratio)
+
+/*
  * __wt_bt_read --
  *     Read a cookie referenced block into a buffer.
  */
@@ -23,7 +28,7 @@ __wt_bt_read(WT_SESSION_IMPL *session, WT_ITEM *buf, const uint8_t *addr, size_t
     WT_ENCRYPTOR *encryptor;
     WT_ITEM *ip;
     const WT_PAGE_HEADER *dsk;
-    size_t result_len;
+    size_t compression_ratio, result_len;
     const char *fail_msg;
 
     btree = S2BT(session);
@@ -105,6 +110,10 @@ __wt_bt_read(WT_SESSION_IMPL *session, WT_ITEM *buf, const uint8_t *addr, size_t
             fail_msg = "block decompression failed";
             goto corrupt;
         }
+
+        compression_ratio = result_len / (tmp->size - WT_BLOCK_COMPRESS_SKIP);
+        __wt_stat_compr_ratio_hist_incr(session, compression_ratio);
+
     } else {
         /*
          * If we uncompressed above, the page is in the correct buffer. If we get here the data may
diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c
index 6ea091cd3f6..25aceda326b 100644
--- a/src/third_party/wiredtiger/src/config/config_def.c
+++ b/src/third_party/wiredtiger/src/config/config_def.c
@@ -33,6 +33,19 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_query_timestamp[] = {
     NULL, 0},
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
+static const WT_CONFIG_CHECK confchk_wiredtiger_open_block_cache_subconfigs[] = {
+  {"blkcache_eviction_aggression", "int", NULL, "min=1,max=7200", NULL, 0},
+  {"cache_on_checkpoint", "boolean", NULL, NULL, NULL, 0},
+  {"cache_on_writes", "boolean", NULL, NULL, NULL, 0}, {"enabled", "boolean", NULL, NULL, NULL, 0},
+  {"full_target", "int", NULL, "min=30,max=100", NULL, 0},
+  {"hashsize", "int", NULL, "min=512,max=256K", NULL, 0},
+  {"max_percent_overhead", "int", NULL, "min=1,max=500", NULL, 0},
+  {"nvram_path", "string", NULL, NULL, NULL, 0},
+  {"percent_file_in_dram", "int", NULL, "min=0,max=100", NULL, 0},
+  {"size", "int", NULL, "min=0,max=6155GB", NULL, 0},
+  {"system_ram", "int", NULL, "min=0,max=1024GB", NULL, 0}, {"type", "string", NULL, NULL, NULL, 0},
+  {NULL, NULL, NULL, NULL, NULL, 0}};
+
 static const WT_CONFIG_CHECK confchk_wiredtiger_open_checkpoint_subconfigs[] = {
   {"log_size", "int", NULL, "min=0,max=2GB", NULL, 0},
   {"wait", "int", NULL, "min=0,max=100000", NULL, 0}, {NULL, NULL, NULL, NULL, NULL, 0}};
@@ -102,6 +115,7 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure_tiered_storage_su
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
 static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure[] = {
+  {"block_cache", "category", NULL, NULL, confchk_wiredtiger_open_block_cache_subconfigs, 12},
   {"cache_max_wait_ms", "int", NULL, "min=0", NULL, 0},
   {"cache_overhead", "int", NULL, "min=0,max=30", NULL, 0},
   {"cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0},
@@ -148,11 +162,11 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure[] = {
     "\"split_6\",\"split_7\"]",
     NULL, 0},
   {"verbose", "list", NULL,
-    "choices=[\"api\",\"backup\",\"block\",\"checkpoint\","
-    "\"checkpoint_cleanup\",\"checkpoint_progress\",\"compact\","
-    "\"compact_progress\",\"error_returns\",\"evict\",\"evict_stuck\""
-    ",\"evictserver\",\"fileops\",\"handleops\",\"log\","
-    "\"history_store\",\"history_store_activity\",\"lsm\","
+    "choices=[\"api\",\"backup\",\"block\",\"block_cache\","
+    "\"checkpoint\",\"checkpoint_cleanup\",\"checkpoint_progress\","
+    "\"compact\",\"compact_progress\",\"error_returns\",\"evict\","
+    "\"evict_stuck\",\"evictserver\",\"fileops\",\"handleops\","
+    "\"history_store\",\"history_store_activity\",\"log\",\"lsm\","
     "\"lsm_manager\",\"metadata\",\"mutex\",\"overflow\",\"read\","
     "\"reconcile\",\"recovery\",\"recovery_progress\",\"rts\","
     "\"salvage\",\"shared_cache\",\"split\",\"temporary\","
@@ -818,6 +832,7 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_transaction_sync_subconfigs
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
 static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = {
+  {"block_cache", "category", NULL, NULL, confchk_wiredtiger_open_block_cache_subconfigs, 12},
   {"buffer_alignment", "int", NULL, "min=-1,max=1MB", NULL, 0},
   {"builtin_extension_config", "string", NULL, NULL, NULL, 0},
   {"cache_cursors", "boolean", NULL, NULL, NULL, 0},
@@ -884,11 +899,11 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = {
   {"use_environment", "boolean", NULL, NULL, NULL, 0},
   {"use_environment_priv", "boolean", NULL, NULL, NULL, 0},
   {"verbose", "list", NULL,
-    "choices=[\"api\",\"backup\",\"block\",\"checkpoint\","
-    "\"checkpoint_cleanup\",\"checkpoint_progress\",\"compact\","
-    "\"compact_progress\",\"error_returns\",\"evict\",\"evict_stuck\""
-    ",\"evictserver\",\"fileops\",\"handleops\",\"log\","
-    "\"history_store\",\"history_store_activity\",\"lsm\","
+    "choices=[\"api\",\"backup\",\"block\",\"block_cache\","
+    "\"checkpoint\",\"checkpoint_cleanup\",\"checkpoint_progress\","
+    "\"compact\",\"compact_progress\",\"error_returns\",\"evict\","
+    "\"evict_stuck\",\"evictserver\",\"fileops\",\"handleops\","
+    "\"history_store\",\"history_store_activity\",\"log\",\"lsm\","
     "\"lsm_manager\",\"metadata\",\"mutex\",\"overflow\",\"read\","
     "\"reconcile\",\"recovery\",\"recovery_progress\",\"rts\","
     "\"salvage\",\"shared_cache\",\"split\",\"temporary\","
@@ -900,6 +915,7 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = {
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
 static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = {
+  {"block_cache", "category", NULL, NULL, confchk_wiredtiger_open_block_cache_subconfigs, 12},
   {"buffer_alignment", "int", NULL, "min=-1,max=1MB", NULL, 0},
   {"builtin_extension_config", "string", NULL, NULL, NULL, 0},
   {"cache_cursors", "boolean", NULL, NULL, NULL, 0},
@@ -966,11 +982,11 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = {
   {"use_environment", "boolean", NULL, NULL, NULL, 0},
   {"use_environment_priv", "boolean", NULL, NULL, NULL, 0},
   {"verbose", "list", NULL,
-    "choices=[\"api\",\"backup\",\"block\",\"checkpoint\","
-    "\"checkpoint_cleanup\",\"checkpoint_progress\",\"compact\","
-    "\"compact_progress\",\"error_returns\",\"evict\",\"evict_stuck\""
-    ",\"evictserver\",\"fileops\",\"handleops\",\"log\","
-    "\"history_store\",\"history_store_activity\",\"lsm\","
+    "choices=[\"api\",\"backup\",\"block\",\"block_cache\","
+    "\"checkpoint\",\"checkpoint_cleanup\",\"checkpoint_progress\","
+    "\"compact\",\"compact_progress\",\"error_returns\",\"evict\","
+    "\"evict_stuck\",\"evictserver\",\"fileops\",\"handleops\","
+    "\"history_store\",\"history_store_activity\",\"log\",\"lsm\","
     "\"lsm_manager\",\"metadata\",\"mutex\",\"overflow\",\"read\","
     "\"reconcile\",\"recovery\",\"recovery_progress\",\"rts\","
     "\"salvage\",\"shared_cache\",\"split\",\"temporary\","
@@ -982,6 +998,7 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = {
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
 static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = {
+  {"block_cache", "category", NULL, NULL, confchk_wiredtiger_open_block_cache_subconfigs, 12},
   {"buffer_alignment", "int", NULL, "min=-1,max=1MB", NULL, 0},
   {"builtin_extension_config", "string", NULL, NULL, NULL, 0},
   {"cache_cursors", "boolean", NULL, NULL, NULL, 0},
@@ -1043,11 +1060,11 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = {
   {"transaction_sync", "category", NULL, NULL, confchk_wiredtiger_open_transaction_sync_subconfigs,
     2},
   {"verbose", "list", NULL,
-    "choices=[\"api\",\"backup\",\"block\",\"checkpoint\","
-    "\"checkpoint_cleanup\",\"checkpoint_progress\",\"compact\","
-    "\"compact_progress\",\"error_returns\",\"evict\",\"evict_stuck\""
-    ",\"evictserver\",\"fileops\",\"handleops\",\"log\","
-    "\"history_store\",\"history_store_activity\",\"lsm\","
+    "choices=[\"api\",\"backup\",\"block\",\"block_cache\","
+    "\"checkpoint\",\"checkpoint_cleanup\",\"checkpoint_progress\","
+    "\"compact\",\"compact_progress\",\"error_returns\",\"evict\","
+    "\"evict_stuck\",\"evictserver\",\"fileops\",\"handleops\","
+    "\"history_store\",\"history_store_activity\",\"log\",\"lsm\","
     "\"lsm_manager\",\"metadata\",\"mutex\",\"overflow\",\"read\","
     "\"reconcile\",\"recovery\",\"recovery_progress\",\"rts\","
     "\"salvage\",\"shared_cache\",\"split\",\"temporary\","
@@ -1059,6 +1076,7 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = {
   {NULL, NULL, NULL, NULL, NULL, 0}};
 
 static const WT_CONFIG_CHECK confchk_wiredtiger_open_usercfg[] = {
+  {"block_cache", "category", NULL, NULL, confchk_wiredtiger_open_block_cache_subconfigs, 12},
   {"buffer_alignment", "int", NULL, "min=-1,max=1MB", NULL, 0},
   {"builtin_extension_config", "string", NULL, NULL, NULL, 0},
   {"cache_cursors", "boolean", NULL, NULL, NULL, 0},
@@ -1120,11 +1138,11 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_usercfg[] = {
   {"transaction_sync", "category", NULL, NULL, confchk_wiredtiger_open_transaction_sync_subconfigs,
     2},
   {"verbose", "list", NULL,
-    "choices=[\"api\",\"backup\",\"block\",\"checkpoint\","
-    "\"checkpoint_cleanup\",\"checkpoint_progress\",\"compact\","
-    "\"compact_progress\",\"error_returns\",\"evict\",\"evict_stuck\""
-    ",\"evictserver\",\"fileops\",\"handleops\",\"log\","
-    "\"history_store\",\"history_store_activity\",\"lsm\","
+    "choices=[\"api\",\"backup\",\"block\",\"block_cache\","
+    "\"checkpoint\",\"checkpoint_cleanup\",\"checkpoint_progress\","
+    "\"compact\",\"compact_progress\",\"error_returns\",\"evict\","
+    "\"evict_stuck\",\"evictserver\",\"fileops\",\"handleops\","
+    "\"history_store\",\"history_store_activity\",\"log\",\"lsm\","
     "\"lsm_manager\",\"metadata\",\"mutex\",\"overflow\",\"read\","
     "\"reconcile\",\"recovery\",\"recovery_progress\",\"rts\","
     "\"salvage\",\"shared_cache\",\"split\",\"temporary\","
@@ -1152,6 +1170,10 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     confchk_WT_CONNECTION_open_session, 3},
   {"WT_CONNECTION.query_timestamp", "get=all_durable", confchk_WT_CONNECTION_query_timestamp, 1},
   {"WT_CONNECTION.reconfigure",
+    "block_cache=(blkcache_eviction_aggression=1800,"
+    "cache_on_checkpoint=true,cache_on_writes=true,enabled=false,"
+    "full_target=95,hashsize=0,max_percent_overhead=10,nvram_path=,"
+    "percent_file_in_dram=50,size=0,system_ram=0,type=),"
     "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
     "checkpoint=(log_size=0,wait=0),compatibility=(release=),"
     "debug_mode=(checkpoint_retention=0,corruption_abort=true,"
@@ -1174,7 +1196,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "tiered_manager=(threads_max=8,threads_min=1,wait=0),"
     "tiered_storage=(local_retention=300,object_target_size=10M),"
     "timing_stress_for_test=,verbose=[]",
-    confchk_WT_CONNECTION_reconfigure, 29},
+    confchk_WT_CONNECTION_reconfigure, 30},
   {"WT_CONNECTION.rollback_to_stable", "", NULL, 0}, {"WT_CONNECTION.set_file_system", "", NULL, 0},
   {"WT_CONNECTION.set_timestamp",
     "commit_timestamp=,durable_timestamp=,force=false,"
@@ -1419,6 +1441,10 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "version=(major=0,minor=0),write_timestamp_usage=none",
     confchk_tiered_meta, 49},
   {"wiredtiger_open",
+    "block_cache=(blkcache_eviction_aggression=1800,"
+    "cache_on_checkpoint=true,cache_on_writes=true,enabled=false,"
+    "full_target=95,hashsize=0,max_percent_overhead=10,nvram_path=,"
+    "percent_file_in_dram=50,size=0,system_ram=0,type=),"
     "buffer_alignment=-1,builtin_extension_config=,cache_cursors=true"
     ",cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
     "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
@@ -1453,8 +1479,12 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "transaction_sync=(enabled=false,method=fsync),"
     "use_environment=true,use_environment_priv=false,verbose=[],"
     "verify_metadata=false,write_through=",
-    confchk_wiredtiger_open, 57},
+    confchk_wiredtiger_open, 58},
   {"wiredtiger_open_all",
+    "block_cache=(blkcache_eviction_aggression=1800,"
+    "cache_on_checkpoint=true,cache_on_writes=true,enabled=false,"
+    "full_target=95,hashsize=0,max_percent_overhead=10,nvram_path=,"
+    "percent_file_in_dram=50,size=0,system_ram=0,type=),"
     "buffer_alignment=-1,builtin_extension_config=,cache_cursors=true"
     ",cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
     "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
@@ -1489,8 +1519,12 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "transaction_sync=(enabled=false,method=fsync),"
     "use_environment=true,use_environment_priv=false,verbose=[],"
     "verify_metadata=false,version=(major=0,minor=0),write_through=",
-    confchk_wiredtiger_open_all, 58},
+    confchk_wiredtiger_open_all, 59},
   {"wiredtiger_open_basecfg",
+    "block_cache=(blkcache_eviction_aggression=1800,"
+    "cache_on_checkpoint=true,cache_on_writes=true,enabled=false,"
+    "full_target=95,hashsize=0,max_percent_overhead=10,nvram_path=,"
+    "percent_file_in_dram=50,size=0,system_ram=0,type=),"
     "buffer_alignment=-1,builtin_extension_config=,cache_cursors=true"
     ",cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
     "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
@@ -1524,8 +1558,12 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "object_target_size=10M),timing_stress_for_test=,"
     "transaction_sync=(enabled=false,method=fsync),verbose=[],"
     "verify_metadata=false,version=(major=0,minor=0),write_through=",
-    confchk_wiredtiger_open_basecfg, 52},
+    confchk_wiredtiger_open_basecfg, 53},
   {"wiredtiger_open_usercfg",
+    "block_cache=(blkcache_eviction_aggression=1800,"
+    "cache_on_checkpoint=true,cache_on_writes=true,enabled=false,"
+    "full_target=95,hashsize=0,max_percent_overhead=10,nvram_path=,"
+    "percent_file_in_dram=50,size=0,system_ram=0,type=),"
     "buffer_alignment=-1,builtin_extension_config=,cache_cursors=true"
     ",cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
     "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
@@ -1559,7 +1597,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {{"WT_CONNECTION.add_collator",
     "object_target_size=10M),timing_stress_for_test=,"
     "transaction_sync=(enabled=false,method=fsync),verbose=[],"
     "verify_metadata=false,write_through=",
-    confchk_wiredtiger_open_usercfg, 51},
+    confchk_wiredtiger_open_usercfg, 52},
   {NULL, NULL, NULL, 0}};
 
 int
diff --git a/src/third_party/wiredtiger/src/conn/conn_api.c b/src/third_party/wiredtiger/src/conn/conn_api.c
index 81d89fd939f..21b2f0675fa 100644
--- a/src/third_party/wiredtiger/src/conn/conn_api.c
+++ b/src/third_party/wiredtiger/src/conn/conn_api.c
@@ -1990,8 +1990,8 @@ int
 __wt_verbose_config(WT_SESSION_IMPL *session, const char *cfg[])
 {
     static const WT_NAME_FLAG verbtypes[] = {{"api", WT_VERB_API}, {"backup", WT_VERB_BACKUP},
-      {"block", WT_VERB_BLOCK}, {"checkpoint", WT_VERB_CHECKPOINT},
-      {"checkpoint_cleanup", WT_VERB_CHECKPOINT_CLEANUP},
+      {"block", WT_VERB_BLOCK}, {"block_cache", WT_VERB_BLKCACHE},
+      {"checkpoint", WT_VERB_CHECKPOINT}, {"checkpoint_cleanup", WT_VERB_CHECKPOINT_CLEANUP},
       {"checkpoint_progress", WT_VERB_CHECKPOINT_PROGRESS}, {"compact", WT_VERB_COMPACT},
       {"compact_progress", WT_VERB_COMPACT_PROGRESS}, {"error_returns", WT_VERB_ERROR_RETURNS},
       {"evict", WT_VERB_EVICT}, {"evict_stuck", WT_VERB_EVICT_STUCK},
@@ -2713,12 +2713,9 @@ wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler, const char *c
     }
     WT_ERR(__wt_verbose_config(session, cfg));
     WT_ERR(__wt_timing_stress_config(session, cfg));
-
-    /* Set up operation tracking if configured. */
+    WT_ERR(__wt_block_cache_setup(session, cfg, false));
     WT_ERR(__wt_conn_optrack_setup(session, cfg, false));
-
     WT_ERR(__conn_session_size(session, cfg, &conn->session_size));
-
     WT_ERR(__wt_config_gets(session, cfg, "session_scratch_max", &cval));
     conn->session_scratch_max = (size_t)cval.val;
 
diff --git a/src/third_party/wiredtiger/src/conn/conn_open.c b/src/third_party/wiredtiger/src/conn/conn_open.c
index 343e0046423..5d01264502d 100644
--- a/src/third_party/wiredtiger/src/conn/conn_open.c
+++ b/src/third_party/wiredtiger/src/conn/conn_open.c
@@ -86,6 +86,8 @@ __wt_connection_close(WT_CONNECTION_IMPL *conn)
     /* The default session is used to access data handles during close. */
     F_CLR(session, WT_SESSION_NO_DATA_HANDLES);
 
+    __wt_block_cache_destroy(session);
+
     /*
      * Shut down server threads. Some of these threads access btree handles and eviction, shut them
      * down before the eviction server, and shut all servers down before closing open data handles.
diff --git a/src/third_party/wiredtiger/src/conn/conn_reconfig.c b/src/third_party/wiredtiger/src/conn/conn_reconfig.c
index c8d1330d7ff..7dde0c40824 100644
--- a/src/third_party/wiredtiger/src/conn/conn_reconfig.c
+++ b/src/third_party/wiredtiger/src/conn/conn_reconfig.c
@@ -416,6 +416,7 @@ __wt_conn_reconfig(WT_SESSION_IMPL *session, const char **cfg)
      */
     WT_WITH_CHECKPOINT_LOCK(session, ret = __wt_conn_compat_config(session, cfg, true));
     WT_ERR(ret);
+    WT_ERR(__wt_block_cache_setup(session, cfg, true));
     WT_ERR(__wt_conn_optrack_setup(session, cfg, true));
     WT_ERR(__wt_conn_statistics_config(session, cfg));
     WT_ERR(__wt_cache_config(session, cfg, true));
diff --git a/src/third_party/wiredtiger/src/include/block_cache.h b/src/third_party/wiredtiger/src/include/block_cache.h
new file mode 100644
index 00000000000..a5e08c1f382
--- /dev/null
+++ b/src/third_party/wiredtiger/src/include/block_cache.h
@@ -0,0 +1,154 @@
+/*-
+ * Copyright (c) 2014-2020 MongoDB, Inc.
+ * Copyright (c) 2008-2014 WiredTiger, Inc.
+ *	All rights reserved.
+ *
+ * See the file LICENSE for redistribution information.
+ */
+
+/*
+ * WiredTiger's block cache. It is used to cache blocks identical to those that live on disk in a
+ * faster storage medium, such as NVRAM.
+ */
+
+#ifdef HAVE_LIBMEMKIND
+#include <memkind.h>
+#endif
+
+/*
+ * Determines now often we compute the total size of the files open in the block manager.
+ */
+#define BLKCACHE_FILESIZE_EST_FREQ 5000
+
+#define BLKCACHE_HASHSIZE_DEFAULT 32768
+#define BLKCACHE_HASHSIZE_MIN 512
+#define BLKCACHE_HASHSIZE_MAX WT_GIGABYTE
+
+#define WT_BLKCACHE_FULL -2
+#define WT_BLKCACHE_BYPASS -3
+
+#define BLKCACHE_MINREF_INCREMENT 20
+#define BLKCACHE_EVICT_OTHER 0
+#define BLKCACHE_NOT_EVICTION_CANDIDATE 1
+
+/*
+ * WT_BLKCACHE_ID --
+ *    Checksum, offset and size uniquely identify a block.
+ *    These are the same items used to compute the cookie.
+ */
+struct __wt_blkcache_id {
+    uint32_t checksum;
+    wt_off_t offset;
+    uint32_t size;
+};
+
+/*
+ * WT_BLKCACHE_ITEM --
+ *     Block cache item. It links with other items in the same hash bucket.
+ */
+struct __wt_blkcache_item {
+    struct __wt_blkcache_id id;
+    TAILQ_ENTRY(__wt_blkcache_item) hashq;
+    void *data;
+    uint32_t num_references;
+
+    /*
+     * This counter is incremented every time a block is referenced and decremented every time the
+     * eviction thread sweeps through the cache. This counter will be low for blocks that have not
+     * been reused or for blocks that were reused in the past but lost their appeal. In this sense,
+     * this counter is a metric combining frequency and recency, and hence its name.
+     */
+    int32_t freq_rec_counter;
+};
+
+/*
+ * WT_BLKCACHE_BUCKET_METADATA --
+ *     The metadata indicating the number of bytes in cache is accumulated per
+ *     bucket, because we do locking per bucket. Then the eviction thread accumulates
+ *     per-bucket data into a global metadata value that is stored in the block
+ *     cache structure.
+ */
+
+struct __wt_blkcache_bucket_metadata {
+    WT_CACHE_LINE_PAD_BEGIN
+    volatile uint64_t bucket_num_data_blocks; /* Number of blocks in the bucket */
+    volatile uint64_t bucket_bytes_used;      /* Bytes in the bucket */
+    WT_CACHE_LINE_PAD_END
+};
+
+/*
+ * WT_BLKCACHE --
+ *     Block cache metadata includes the hashtable of cached items, number of cached data blocks
+ * and the total amount of space they occupy.
+ */
+struct __wt_blkcache {
+    /* Locked: Block manager cache. Locks are per-bucket. */
+    TAILQ_HEAD(__wt_blkcache_hash, __wt_blkcache_item) * hash;
+    WT_SPINLOCK *hash_locks;
+    WT_BLKCACHE_BUCKET_METADATA *bucket_metadata;
+
+    wt_thread_t evict_thread_tid;
+    volatile bool blkcache_exiting; /* If destroying the cache */
+    int32_t evict_aggressive;       /* Seconds an unused block stays in the cache */
+
+    bool cache_on_checkpoint; /* Don't cache blocks written by checkpoints */
+    bool cache_on_writes;     /* Cache blocks on writes */
+
+#ifdef HAVE_LIBMEMKIND
+    struct memkind *pmem_kind; /* NVRAM connection */
+#endif
+    char *nvram_device_path; /* The absolute path of the file system on NVRAM device */
+
+    uint64_t full_target; /* Number of bytes in the block cache that triggers eviction */
+    float overhead_pct;   /* Overhead percentage that suppresses population and eviction */
+
+    size_t estimated_file_size;        /* Estimated size of all files used by the workload. */
+    int refs_since_filesize_estimated; /* Counter for recalculating the aggregate file size */
+
+    /*
+     * This fraction tells us the good enough ratio of file data cached in the DRAM
+     * resident OS buffer cache, which makes the use of this block cache unnecessary.
+     * Suppose we set that fraction to 50%. Then if half of our file data fits into
+     * system DRAM, we consider this block cache unhelpful.
+     *
+     * E.g., if the fraction is set to 50%, our aggregate file size is
+     * 500GB, and we have 300GB of RAM, then we will not use this block cache,
+     * because we know that half of our files (250GB) must be cached by the OS in DRAM.
+     */
+    float fraction_in_os_cache;
+
+    u_int hash_size;                   /* Number of block cache hash buckets */
+    u_int type;                        /* Type of block cache (NVRAM or DRAM) */
+    volatile uint64_t bytes_used;      /* Bytes in the block cache */
+    volatile uint64_t num_data_blocks; /* Number of blocks in the block cache */
+    uint64_t max_bytes;                /* Block cache size */
+    uint64_t system_ram;               /* Configured size of system RAM */
+
+    uint32_t min_num_references; /* The per-block number of references triggering eviction. */
+
+    /*
+     * Various metrics helping us measure the overhead and decide if to bypass the cache. We access
+     * some of them without synchronization despite races. These serve as heuristics, and we don't
+     * need precise values for them to be useful. If, because of races, we lose updates of these
+     * values, assuming that we lose them at the same rate for all variables, the ratio should
+     * remain roughly accurate. We care about the ratio.
+     */
+    uint64_t lookups;
+    uint64_t inserts;
+    uint64_t removals;
+
+    /* Histograms keeping track of number of references to each block */
+#define BLKCACHE_HIST_BUCKETS 11
+#define BLKCACHE_HIST_BOUNDARY 10
+    uint32_t cache_references[BLKCACHE_HIST_BUCKETS];
+    uint32_t cache_references_removed_blocks[BLKCACHE_HIST_BUCKETS];
+    uint32_t cache_references_evicted_blocks[BLKCACHE_HIST_BUCKETS];
+};
+
+#define BLKCACHE_UNCONFIGURED 0
+#define BLKCACHE_DRAM 1
+#define BLKCACHE_NVRAM 2
+
+#define BLKCACHE_RM_EXIT 1
+#define BLKCACHE_RM_FREE 2
+#define BLKCACHE_RM_EVICTION 3
diff --git a/src/third_party/wiredtiger/src/include/connection.h b/src/third_party/wiredtiger/src/include/connection.h
index aea35090604..be71d8d0157 100644
--- a/src/third_party/wiredtiger/src/include/connection.h
+++ b/src/third_party/wiredtiger/src/include/connection.h
@@ -215,6 +215,7 @@ typedef enum {
     WT_VERB_API = 0,
     WT_VERB_BACKUP,
     WT_VERB_BLOCK,
+    WT_VERB_BLKCACHE,
     WT_VERB_CHECKPOINT,
     WT_VERB_CHECKPOINT_CLEANUP,
     WT_VERB_CHECKPOINT_PROGRESS,
@@ -364,6 +365,8 @@ struct __wt_connection_impl {
     TAILQ_HEAD(__wt_blockhash, __wt_block) * blockhash;
     TAILQ_HEAD(__wt_block_qh, __wt_block) blockqh;
 
+    WT_BLKCACHE blkcache; /* Block cache */
+
     /* Locked: handles in each bucket */
     uint64_t *dh_bucket_count;
     uint64_t dhandle_count;     /* Locked: handles in the queue */
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index 2c8fc9c5aa9..c948f4e6b1a 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -90,6 +90,11 @@ extern int __wt_backup_open(WT_SESSION_IMPL *session)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_bad_object_type(WT_SESSION_IMPL *session, const char *uri)
   WT_GCC_FUNC_DECL_ATTRIBUTE((cold)) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_blkcache_get_or_check(WT_SESSION_IMPL *session, wt_off_t offset, size_t size,
+  uint32_t checksum, void *data_ptr) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_blkcache_put(WT_SESSION_IMPL *session, wt_off_t offset, size_t size,
+  uint32_t checksum, void *data, bool checkpoint_io, bool write)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_block_addr_invalid(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint8_t *addr,
   size_t addr_size, bool live) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_block_addr_pack(WT_BLOCK *block, uint8_t **pp, uint32_t objectid, wt_off_t offset,
@@ -101,6 +106,8 @@ extern int __wt_block_addr_unpack(WT_SESSION_IMPL *session, WT_BLOCK *block, con
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_block_alloc(WT_SESSION_IMPL *session, WT_BLOCK *block, wt_off_t *offp,
   wt_off_t size) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_block_cache_setup(WT_SESSION_IMPL *session, const char *cfg[], bool reconfig)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_block_checkpoint(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf,
   WT_CKPT *ckptbase, bool data_checksum) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_block_checkpoint_final(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_ITEM *buf,
@@ -756,6 +763,7 @@ extern int __wt_filename(WT_SESSION_IMPL *session, const char *name, char **path
 extern int __wt_filename_construct(WT_SESSION_IMPL *session, const char *path,
   const char *file_prefix, uintmax_t id_1, uint32_t id_2, WT_ITEM *buf)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_floatcmp(float f1, float f2) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_flush_tier(WT_SESSION_IMPL *session, const char *config)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_fopen(WT_SESSION_IMPL *session, const char *name, uint32_t open_flags,
@@ -1685,6 +1693,9 @@ extern void *__wt_ext_scr_alloc(WT_EXTENSION_API *wt_api, WT_SESSION *wt_session
 extern void __wt_abort(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((noreturn))
   WT_GCC_FUNC_DECL_ATTRIBUTE((visibility("default")));
 extern void __wt_backup_destroy(WT_SESSION_IMPL *session);
+extern void __wt_blkcache_remove(
+  WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32_t checksum);
+extern void __wt_block_cache_destroy(WT_SESSION_IMPL *session);
 extern void __wt_block_ckpt_destroy(WT_SESSION_IMPL *session, WT_BLOCK_CKPT *ci);
 extern void __wt_block_compact_progress(
   WT_SESSION_IMPL *session, WT_BLOCK *block, u_int *msg_countp);
diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h
index 309d0b50805..3882459c46a 100644
--- a/src/third_party/wiredtiger/src/include/stat.h
+++ b/src/third_party/wiredtiger/src/include/stat.h
@@ -303,6 +303,25 @@ __wt_stats_clear(void *stats_arg, int slot)
             WT_STAT_CONN_INCR(session, stat##_gt10000);                                           \
     }
 
+#define WT_STAT_COMPR_RATIO_HIST_INCR_FUNC(ratio)                                                \
+    static inline void __wt_stat_compr_ratio_hist_incr(WT_SESSION_IMPL *session, uint64_t ratio) \
+    {                                                                                            \
+        if (ratio < 2)                                                                           \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_2);                                   \
+        else if (ratio < 4)                                                                      \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_4);                                   \
+        else if (ratio < 8)                                                                      \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_8);                                   \
+        else if (ratio < 16)                                                                     \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_16);                                  \
+        else if (ratio < 32)                                                                     \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_32);                                  \
+        else if (ratio < 64)                                                                     \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_64);                                  \
+        else                                                                                     \
+            WT_STAT_DATA_INCR(session, compress_hist_ratio_max);                                 \
+    }
+
 /*
  * DO NOT EDIT: automatically built by dist/stat.py.
  */
@@ -323,6 +342,27 @@ struct __wt_connection_stats {
     int64_t lsm_work_units_done;
     int64_t lsm_work_units_created;
     int64_t lsm_work_queue_max;
+    int64_t block_cache_blocks_update;
+    int64_t block_cache_bytes_update;
+    int64_t block_cache_blocks_evicted;
+    int64_t block_cache_bypass_filesize;
+    int64_t block_cache_data_refs;
+    int64_t block_cache_not_evicted_overhead;
+    int64_t block_cache_bypass_writealloc;
+    int64_t block_cache_bypass_overhead_put;
+    int64_t block_cache_bypass_get;
+    int64_t block_cache_bypass_put;
+    int64_t block_cache_eviction_passes;
+    int64_t block_cache_hits;
+    int64_t block_cache_misses;
+    int64_t block_cache_bypass_chkpt;
+    int64_t block_cache_blocks_removed;
+    int64_t block_cache_blocks;
+    int64_t block_cache_blocks_insert_read;
+    int64_t block_cache_blocks_insert_write;
+    int64_t block_cache_bytes;
+    int64_t block_cache_bytes_insert_read;
+    int64_t block_cache_bytes_insert_write;
     int64_t block_preload;
     int64_t block_read;
     int64_t block_write;
@@ -952,6 +992,13 @@ struct __wt_dsrc_stats {
     int64_t compress_precomp_leaf_max_page_size;
     int64_t compress_read;
     int64_t compress_write;
+    int64_t compress_hist_ratio_max;
+    int64_t compress_hist_ratio_16;
+    int64_t compress_hist_ratio_2;
+    int64_t compress_hist_ratio_32;
+    int64_t compress_hist_ratio_4;
+    int64_t compress_hist_ratio_64;
+    int64_t compress_hist_ratio_8;
     int64_t compress_write_fail;
     int64_t compress_write_too_small;
     int64_t cursor_next_skip_total;
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index 63661de234f..b8637999529 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -2012,6 +2012,38 @@ struct __wt_connection {
 	 *
 	 * @param connection the connection handle
 	 * @configstart{WT_CONNECTION.reconfigure, see dist/api_data.py}
+	 * @config{block_cache = (, block cache configuration options., a set of related
+	 * configuration options defined below.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;
+	 * blkcache_eviction_aggression, how many seconds an unused block remains in the cache
+	 * before it is evicted., an integer between 1 and 7200; default \c 1800.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;cache_on_checkpoint, Cache blocks that are written by a
+	 * checkpoint., a boolean flag; default \c true.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;
+	 * cache_on_writes, cache newly generated blocks., a boolean flag; default \c true.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;enabled, enable block cache., a boolean flag; default \c
+	 * false.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;full_target, a fraction of cache that must be
+	 * full before eviction will remove unused blocks., an integer between 30 and 100; default
+	 * \c 95.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;hashsize, number of buckets in the hashtable that
+	 * keeps track of blocks., an integer between 512 and 256K; default \c 0.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;max_percent_overhead, maximum tolerated overhead
+	 * expressed as the number of blocks added and removed as percent of blocks looked up; cache
+	 * population and eviction will be suppressed if the overhead exceeds the supplied
+	 * threshold., an integer between 1 and 500; default \c 10.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;nvram_path, the absolute path to the file system mounted
+	 * on the NVRAM device., a string; default empty.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;
+	 * percent_file_in_dram, bypass cache if that percent of file fits in DRAM., an integer
+	 * between 0 and 100; default \c 50.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;size, maximum memory
+	 * to allocate for the block cache., an integer between 0 and 6155GB; default \c 0.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;system_ram, amount of DRAM expected to be available on
+	 * the system., an integer between 0 and 1024GB; default \c 0.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;type, cache location: DRAM or NVRAM., a string; default
+	 * empty.}
+	 * @config{ ),,}
 	 * @config{cache_max_wait_ms, the maximum number of milliseconds an application thread will
 	 * wait for space to be available in cache before giving up.  Default will wait forever., an
 	 * integer greater than or equal to 0; default \c 0.}
@@ -2270,14 +2302,14 @@ struct __wt_connection {
 	 * level\, such as <code>"verbose=[evictserver\,read:1\,rts:0]"</code>. Verbosity levels
 	 * that can be provided include <code>0</code> (INFO) and <code>1</code> (DEBUG)., a list\,
 	 * with values chosen from the following options: \c "api"\, \c "backup"\, \c "block"\, \c
-	 * "checkpoint"\, \c "checkpoint_cleanup"\, \c "checkpoint_progress"\, \c "compact"\, \c
-	 * "compact_progress"\, \c "error_returns"\, \c "evict"\, \c "evict_stuck"\, \c
-	 * "evictserver"\, \c "fileops"\, \c "handleops"\, \c "log"\, \c "history_store"\, \c
-	 * "history_store_activity"\, \c "lsm"\, \c "lsm_manager"\, \c "metadata"\, \c "mutex"\, \c
-	 * "overflow"\, \c "read"\, \c "reconcile"\, \c "recovery"\, \c "recovery_progress"\, \c
-	 * "rts"\, \c "salvage"\, \c "shared_cache"\, \c "split"\, \c "temporary"\, \c
-	 * "thread_group"\, \c "tiered"\, \c "timestamp"\, \c "transaction"\, \c "verify"\, \c
-	 * "version"\, \c "write"; default \c [].}
+	 * "block_cache"\, \c "checkpoint"\, \c "checkpoint_cleanup"\, \c "checkpoint_progress"\, \c
+	 * "compact"\, \c "compact_progress"\, \c "error_returns"\, \c "evict"\, \c "evict_stuck"\,
+	 * \c "evictserver"\, \c "fileops"\, \c "handleops"\, \c "history_store"\, \c
+	 * "history_store_activity"\, \c "log"\, \c "lsm"\, \c "lsm_manager"\, \c "metadata"\, \c
+	 * "mutex"\, \c "overflow"\, \c "read"\, \c "reconcile"\, \c "recovery"\, \c
+	 * "recovery_progress"\, \c "rts"\, \c "salvage"\, \c "shared_cache"\, \c "split"\, \c
+	 * "temporary"\, \c "thread_group"\, \c "tiered"\, \c "timestamp"\, \c "transaction"\, \c
+	 * "verify"\, \c "version"\, \c "write"; default \c [].}
 	 * @configend
 	 * @errors
 	 */
@@ -2669,6 +2701,34 @@ struct __wt_connection {
  * event handler is installed that writes error messages to stderr. See
  * @ref event_message_handling for more information.
  * @configstart{wiredtiger_open, see dist/api_data.py}
+ * @config{block_cache = (, block cache configuration options., a set of related configuration
+ * options defined below.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;blkcache_eviction_aggression, how many
+ * seconds an unused block remains in the cache before it is evicted., an integer between 1 and
+ * 7200; default \c 1800.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;cache_on_checkpoint, Cache blocks that
+ * are written by a checkpoint., a boolean flag; default \c true.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;
+ * cache_on_writes, cache newly generated blocks., a boolean flag; default \c true.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;enabled, enable block cache., a boolean flag; default \c false.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;full_target, a fraction of cache that must be full before
+ * eviction will remove unused blocks., an integer between 30 and 100; default \c 95.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;hashsize, number of buckets in the hashtable that keeps track of
+ * blocks., an integer between 512 and 256K; default \c 0.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;
+ * max_percent_overhead, maximum tolerated overhead expressed as the number of blocks added and
+ * removed as percent of blocks looked up; cache population and eviction will be suppressed if the
+ * overhead exceeds the supplied threshold., an integer between 1 and 500; default \c 10.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;nvram_path, the absolute path to the file system mounted on the
+ * NVRAM device., a string; default empty.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;percent_file_in_dram,
+ * bypass cache if that percent of file fits in DRAM., an integer between 0 and 100; default \c 50.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;size, maximum memory to allocate for the block cache., an integer
+ * between 0 and 6155GB; default \c 0.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;system_ram, amount of DRAM
+ * expected to be available on the system., an integer between 0 and 1024GB; default \c 0.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;type, cache location: DRAM or NVRAM., a string; default empty.}
+ * @config{ ),,}
  * @config{buffer_alignment, in-memory alignment (in bytes) for buffers used for I/O. The default
  * value of -1 indicates a platform-specific alignment value should be used (4KB on Linux systems
  * when direct I/O is configured\, zero elsewhere)., an integer between -1 and 1MB; default \c -1.}
@@ -3038,10 +3098,10 @@ struct __wt_connection {
  * list\, where each message type can optionally define an associated verbosity level\, such as
  * <code>"verbose=[evictserver\,read:1\,rts:0]"</code>. Verbosity levels that can be provided
  * include <code>0</code> (INFO) and <code>1</code> (DEBUG)., a list\, with values chosen from the
- * following options: \c "api"\, \c "backup"\, \c "block"\, \c "checkpoint"\, \c
+ * following options: \c "api"\, \c "backup"\, \c "block"\, \c "block_cache"\, \c "checkpoint"\, \c
  * "checkpoint_cleanup"\, \c "checkpoint_progress"\, \c "compact"\, \c "compact_progress"\, \c
  * "error_returns"\, \c "evict"\, \c "evict_stuck"\, \c "evictserver"\, \c "fileops"\, \c
- * "handleops"\, \c "log"\, \c "history_store"\, \c "history_store_activity"\, \c "lsm"\, \c
+ * "handleops"\, \c "history_store"\, \c "history_store_activity"\, \c "log"\, \c "lsm"\, \c
  * "lsm_manager"\, \c "metadata"\, \c "mutex"\, \c "overflow"\, \c "read"\, \c "reconcile"\, \c
  * "recovery"\, \c "recovery_progress"\, \c "rts"\, \c "salvage"\, \c "shared_cache"\, \c "split"\,
  * \c "temporary"\, \c "thread_group"\, \c "tiered"\, \c "timestamp"\, \c "transaction"\, \c
@@ -5040,1190 +5100,1241 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection);
 #define	WT_STAT_CONN_LSM_WORK_UNITS_CREATED		1008
 /*! LSM: tree queue hit maximum */
 #define	WT_STAT_CONN_LSM_WORK_QUEUE_MAX			1009
+/*! block-manager: block cache cached blocks updated */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_UPDATE		1010
+/*! block-manager: block cache cached bytes updated */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYTES_UPDATE		1011
+/*! block-manager: block cache evicted blocks */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_EVICTED		1012
+/*! block-manager: block cache file size causing bypass */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_FILESIZE	1013
+/*! block-manager: block cache lookups */
+#define	WT_STAT_CONN_BLOCK_CACHE_DATA_REFS		1014
+/*!
+ * block-manager: block cache number of blocks not evicted due to
+ * overhead
+ */
+#define	WT_STAT_CONN_BLOCK_CACHE_NOT_EVICTED_OVERHEAD	1015
+/*!
+ * block-manager: block cache number of bypasses because no-write-
+ * allocate setting was on
+ */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_WRITEALLOC	1016
+/*! block-manager: block cache number of bypasses due to overhead on put */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_OVERHEAD_PUT	1017
+/*! block-manager: block cache number of bypasses on get */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_GET		1018
+/*!
+ * block-manager: block cache number of bypasses on put because file is
+ * too small
+ */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_PUT		1019
+/*! block-manager: block cache number of eviction passes */
+#define	WT_STAT_CONN_BLOCK_CACHE_EVICTION_PASSES	1020
+/*! block-manager: block cache number of hits including existence checks */
+#define	WT_STAT_CONN_BLOCK_CACHE_HITS			1021
+/*! block-manager: block cache number of misses including existence checks */
+#define	WT_STAT_CONN_BLOCK_CACHE_MISSES			1022
+/*! block-manager: block cache number of put bypasses on checkpoint I/O */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYPASS_CHKPT		1023
+/*! block-manager: block cache removed blocks */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_REMOVED		1024
+/*! block-manager: block cache total blocks */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS			1025
+/*! block-manager: block cache total blocks inserted on read path */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_INSERT_READ	1026
+/*! block-manager: block cache total blocks inserted on write path */
+#define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_INSERT_WRITE	1027
+/*! block-manager: block cache total bytes */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYTES			1028
+/*! block-manager: block cache total bytes inserted on read path */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYTES_INSERT_READ	1029
+/*! block-manager: block cache total bytes inserted on write path */
+#define	WT_STAT_CONN_BLOCK_CACHE_BYTES_INSERT_WRITE	1030
 /*! block-manager: blocks pre-loaded */
-#define	WT_STAT_CONN_BLOCK_PRELOAD			1010
+#define	WT_STAT_CONN_BLOCK_PRELOAD			1031
 /*! block-manager: blocks read */
-#define	WT_STAT_CONN_BLOCK_READ				1011
+#define	WT_STAT_CONN_BLOCK_READ				1032
 /*! block-manager: blocks written */
-#define	WT_STAT_CONN_BLOCK_WRITE			1012
+#define	WT_STAT_CONN_BLOCK_WRITE			1033
 /*! block-manager: bytes read */
-#define	WT_STAT_CONN_BLOCK_BYTE_READ			1013
+#define	WT_STAT_CONN_BLOCK_BYTE_READ			1034
 /*! block-manager: bytes read via memory map API */
-#define	WT_STAT_CONN_BLOCK_BYTE_READ_MMAP		1014
+#define	WT_STAT_CONN_BLOCK_BYTE_READ_MMAP		1035
 /*! block-manager: bytes read via system call API */
-#define	WT_STAT_CONN_BLOCK_BYTE_READ_SYSCALL		1015
+#define	WT_STAT_CONN_BLOCK_BYTE_READ_SYSCALL		1036
 /*! block-manager: bytes written */
-#define	WT_STAT_CONN_BLOCK_BYTE_WRITE			1016
+#define	WT_STAT_CONN_BLOCK_BYTE_WRITE			1037
 /*! block-manager: bytes written for checkpoint */
-#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_CHECKPOINT	1017
+#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_CHECKPOINT	1038
 /*! block-manager: bytes written via memory map API */
-#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_MMAP		1018
+#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_MMAP		1039
 /*! block-manager: bytes written via system call API */
-#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_SYSCALL		1019
+#define	WT_STAT_CONN_BLOCK_BYTE_WRITE_SYSCALL		1040
 /*! block-manager: mapped blocks read */
-#define	WT_STAT_CONN_BLOCK_MAP_READ			1020
+#define	WT_STAT_CONN_BLOCK_MAP_READ			1041
 /*! block-manager: mapped bytes read */
-#define	WT_STAT_CONN_BLOCK_BYTE_MAP_READ		1021
+#define	WT_STAT_CONN_BLOCK_BYTE_MAP_READ		1042
 /*!
  * block-manager: number of times the file was remapped because it
  * changed size via fallocate or truncate
  */
-#define	WT_STAT_CONN_BLOCK_REMAP_FILE_RESIZE		1022
+#define	WT_STAT_CONN_BLOCK_REMAP_FILE_RESIZE		1043
 /*! block-manager: number of times the region was remapped via write */
-#define	WT_STAT_CONN_BLOCK_REMAP_FILE_WRITE		1023
+#define	WT_STAT_CONN_BLOCK_REMAP_FILE_WRITE		1044
 /*! cache: application threads page read from disk to cache count */
-#define	WT_STAT_CONN_CACHE_READ_APP_COUNT		1024
+#define	WT_STAT_CONN_CACHE_READ_APP_COUNT		1045
 /*! cache: application threads page read from disk to cache time (usecs) */
-#define	WT_STAT_CONN_CACHE_READ_APP_TIME		1025
+#define	WT_STAT_CONN_CACHE_READ_APP_TIME		1046
 /*! cache: application threads page write from cache to disk count */
-#define	WT_STAT_CONN_CACHE_WRITE_APP_COUNT		1026
+#define	WT_STAT_CONN_CACHE_WRITE_APP_COUNT		1047
 /*! cache: application threads page write from cache to disk time (usecs) */
-#define	WT_STAT_CONN_CACHE_WRITE_APP_TIME		1027
+#define	WT_STAT_CONN_CACHE_WRITE_APP_TIME		1048
 /*! cache: bytes allocated for updates */
-#define	WT_STAT_CONN_CACHE_BYTES_UPDATES		1028
+#define	WT_STAT_CONN_CACHE_BYTES_UPDATES		1049
 /*! cache: bytes belonging to page images in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_IMAGE			1029
+#define	WT_STAT_CONN_CACHE_BYTES_IMAGE			1050
 /*! cache: bytes belonging to the history store table in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_HS			1030
+#define	WT_STAT_CONN_CACHE_BYTES_HS			1051
 /*! cache: bytes currently in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_INUSE			1031
+#define	WT_STAT_CONN_CACHE_BYTES_INUSE			1052
 /*! cache: bytes dirty in the cache cumulative */
-#define	WT_STAT_CONN_CACHE_BYTES_DIRTY_TOTAL		1032
+#define	WT_STAT_CONN_CACHE_BYTES_DIRTY_TOTAL		1053
 /*! cache: bytes not belonging to page images in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_OTHER			1033
+#define	WT_STAT_CONN_CACHE_BYTES_OTHER			1054
 /*! cache: bytes read into cache */
-#define	WT_STAT_CONN_CACHE_BYTES_READ			1034
+#define	WT_STAT_CONN_CACHE_BYTES_READ			1055
 /*! cache: bytes written from cache */
-#define	WT_STAT_CONN_CACHE_BYTES_WRITE			1035
+#define	WT_STAT_CONN_CACHE_BYTES_WRITE			1056
 /*! cache: cache overflow score */
-#define	WT_STAT_CONN_CACHE_LOOKASIDE_SCORE		1036
+#define	WT_STAT_CONN_CACHE_LOOKASIDE_SCORE		1057
 /*! cache: checkpoint blocked page eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT		1037
+#define	WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT		1058
 /*!
  * cache: checkpoint of history store file blocked non-history store page
  * eviction
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS	1038
+#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS	1059
 /*! cache: eviction calls to get a page */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF		1039
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF		1060
 /*! cache: eviction calls to get a page found queue empty */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY	1040
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY	1061
 /*! cache: eviction calls to get a page found queue empty after locking */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2	1041
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2	1062
 /*! cache: eviction currently operating in aggressive mode */
-#define	WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET	1042
+#define	WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET	1063
 /*! cache: eviction empty score */
-#define	WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE		1043
+#define	WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE		1064
 /*!
  * cache: eviction gave up due to detecting an out of order on disk value
  * behind the last update on the chain
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_1	1044
+#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_1	1065
 /*!
  * cache: eviction gave up due to detecting an out of order tombstone
  * ahead of the selected on disk update
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_2	1045
+#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_2	1066
 /*!
  * cache: eviction gave up due to detecting an out of order tombstone
  * ahead of the selected on disk update after validating the update chain
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_3	1046
+#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_3	1067
 /*!
  * cache: eviction gave up due to detecting out of order timestamps on
  * the update chain after the selected on disk update
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_4	1047
+#define	WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OOO_CHECKPOINT_RACE_4	1068
 /*! cache: eviction passes of a file */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES		1048
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES		1069
 /*! cache: eviction server candidate queue empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1049
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1070
 /*! cache: eviction server candidate queue not empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1050
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1071
 /*! cache: eviction server evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1051
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1072
 /*!
  * cache: eviction server slept, because we did not make progress with
  * eviction
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT	1052
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT	1073
 /*! cache: eviction server unable to reach eviction goal */
-#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1053
+#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1074
 /*! cache: eviction server waiting for a leaf page */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_LEAF_NOTFOUND	1054
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_LEAF_NOTFOUND	1075
 /*! cache: eviction state */
-#define	WT_STAT_CONN_CACHE_EVICTION_STATE		1055
+#define	WT_STAT_CONN_CACHE_EVICTION_STATE		1076
 /*!
  * cache: eviction walk most recent sleeps for checkpoint handle
  * gathering
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SLEEPS		1056
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SLEEPS		1077
 /*! cache: eviction walk target pages histogram - 0-9 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10	1057
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10	1078
 /*! cache: eviction walk target pages histogram - 10-31 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32	1058
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32	1079
 /*! cache: eviction walk target pages histogram - 128 and higher */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128	1059
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128	1080
 /*! cache: eviction walk target pages histogram - 32-63 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64	1060
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64	1081
 /*! cache: eviction walk target pages histogram - 64-128 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128	1061
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128	1082
 /*!
  * cache: eviction walk target pages reduced due to history store cache
  * pressure
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_REDUCED	1062
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_REDUCED	1083
 /*! cache: eviction walk target strategy both clean and dirty pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_BOTH_CLEAN_AND_DIRTY	1063
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_BOTH_CLEAN_AND_DIRTY	1084
 /*! cache: eviction walk target strategy only clean pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_CLEAN	1064
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_CLEAN	1085
 /*! cache: eviction walk target strategy only dirty pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_DIRTY	1065
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_STRATEGY_DIRTY	1086
 /*! cache: eviction walks abandoned */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED	1066
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED	1087
 /*! cache: eviction walks gave up because they restarted their walk twice */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED	1067
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED	1088
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found no candidates
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	1068
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	1089
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found too few candidates
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	1069
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	1090
 /*! cache: eviction walks reached end of tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED		1070
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED		1091
 /*! cache: eviction walks restarted */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_RESTART	1071
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_RESTART	1092
 /*! cache: eviction walks started from root of tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT	1072
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT	1093
 /*! cache: eviction walks started from saved location in tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS	1073
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS	1094
 /*! cache: eviction worker thread active */
-#define	WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS	1074
+#define	WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS	1095
 /*! cache: eviction worker thread created */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED	1075
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED	1096
 /*! cache: eviction worker thread evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING	1076
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING	1097
 /*! cache: eviction worker thread removed */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED	1077
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED	1098
 /*! cache: eviction worker thread stable number */
-#define	WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS	1078
+#define	WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS	1099
 /*! cache: files with active eviction walks */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE	1079
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE	1100
 /*! cache: files with new eviction walks started */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED	1080
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED	1101
 /*! cache: force re-tuning of eviction workers once in a while */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE	1081
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE	1102
 /*!
  * cache: forced eviction - history store pages failed to evict while
  * session has history store cursor open
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS_FAIL	1082
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS_FAIL	1103
 /*!
  * cache: forced eviction - history store pages selected while session
  * has history store cursor open
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS		1083
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS		1104
 /*!
  * cache: forced eviction - history store pages successfully evicted
  * while session has history store cursor open
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS_SUCCESS	1084
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_HS_SUCCESS	1105
 /*! cache: forced eviction - pages evicted that were clean count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN		1085
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN		1106
 /*! cache: forced eviction - pages evicted that were clean time (usecs) */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN_TIME	1086
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_CLEAN_TIME	1107
 /*! cache: forced eviction - pages evicted that were dirty count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY		1087
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY		1108
 /*! cache: forced eviction - pages evicted that were dirty time (usecs) */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY_TIME	1088
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DIRTY_TIME	1109
 /*!
  * cache: forced eviction - pages selected because of a large number of
  * updates to a single item
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_LONG_UPDATE_LIST	1089
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_LONG_UPDATE_LIST	1110
 /*!
  * cache: forced eviction - pages selected because of too many deleted
  * items count
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE	1090
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE	1111
 /*! cache: forced eviction - pages selected count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE		1091
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE		1112
 /*! cache: forced eviction - pages selected unable to be evicted count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1092
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1113
 /*! cache: forced eviction - pages selected unable to be evicted time */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME	1093
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME	1114
 /*! cache: hazard pointer blocked page eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1094
+#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1115
 /*! cache: hazard pointer check calls */
-#define	WT_STAT_CONN_CACHE_HAZARD_CHECKS		1095
+#define	WT_STAT_CONN_CACHE_HAZARD_CHECKS		1116
 /*! cache: hazard pointer check entries walked */
-#define	WT_STAT_CONN_CACHE_HAZARD_WALKS			1096
+#define	WT_STAT_CONN_CACHE_HAZARD_WALKS			1117
 /*! cache: hazard pointer maximum array length */
-#define	WT_STAT_CONN_CACHE_HAZARD_MAX			1097
+#define	WT_STAT_CONN_CACHE_HAZARD_MAX			1118
 /*! cache: history store score */
-#define	WT_STAT_CONN_CACHE_HS_SCORE			1098
+#define	WT_STAT_CONN_CACHE_HS_SCORE			1119
 /*! cache: history store table insert calls */
-#define	WT_STAT_CONN_CACHE_HS_INSERT			1099
+#define	WT_STAT_CONN_CACHE_HS_INSERT			1120
 /*! cache: history store table insert calls that returned restart */
-#define	WT_STAT_CONN_CACHE_HS_INSERT_RESTART		1100
+#define	WT_STAT_CONN_CACHE_HS_INSERT_RESTART		1121
 /*! cache: history store table max on-disk size */
-#define	WT_STAT_CONN_CACHE_HS_ONDISK_MAX		1101
+#define	WT_STAT_CONN_CACHE_HS_ONDISK_MAX		1122
 /*! cache: history store table on-disk size */
-#define	WT_STAT_CONN_CACHE_HS_ONDISK			1102
+#define	WT_STAT_CONN_CACHE_HS_ONDISK			1123
 /*!
  * cache: history store table out-of-order resolved updates that lose
  * their durable timestamp
  */
-#define	WT_STAT_CONN_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP	1103
+#define	WT_STAT_CONN_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP	1124
 /*!
  * cache: history store table out-of-order updates that were fixed up by
  * reinserting with the fixed timestamp
  */
-#define	WT_STAT_CONN_CACHE_HS_ORDER_REINSERT		1104
+#define	WT_STAT_CONN_CACHE_HS_ORDER_REINSERT		1125
 /*! cache: history store table reads */
-#define	WT_STAT_CONN_CACHE_HS_READ			1105
+#define	WT_STAT_CONN_CACHE_HS_READ			1126
 /*! cache: history store table reads missed */
-#define	WT_STAT_CONN_CACHE_HS_READ_MISS			1106
+#define	WT_STAT_CONN_CACHE_HS_READ_MISS			1127
 /*! cache: history store table reads requiring squashed modifies */
-#define	WT_STAT_CONN_CACHE_HS_READ_SQUASH		1107
+#define	WT_STAT_CONN_CACHE_HS_READ_SQUASH		1128
 /*!
  * cache: history store table truncation by rollback to stable to remove
  * an unstable update
  */
-#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE	1108
+#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE	1129
 /*!
  * cache: history store table truncation by rollback to stable to remove
  * an update
  */
-#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS		1109
+#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS		1130
 /*! cache: history store table truncation to remove an update */
-#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE		1110
+#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE		1131
 /*!
  * cache: history store table truncation to remove range of updates due
  * to key being removed from the data page during reconciliation
  */
-#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL	1111
+#define	WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL	1132
 /*!
  * cache: history store table truncation to remove range of updates due
  * to out-of-order timestamp update on data page
  */
-#define	WT_STAT_CONN_CACHE_HS_ORDER_REMOVE		1112
+#define	WT_STAT_CONN_CACHE_HS_ORDER_REMOVE		1133
 /*! cache: history store table writes requiring squashed modifies */
-#define	WT_STAT_CONN_CACHE_HS_WRITE_SQUASH		1113
+#define	WT_STAT_CONN_CACHE_HS_WRITE_SQUASH		1134
 /*! cache: in-memory page passed criteria to be split */
-#define	WT_STAT_CONN_CACHE_INMEM_SPLITTABLE		1114
+#define	WT_STAT_CONN_CACHE_INMEM_SPLITTABLE		1135
 /*! cache: in-memory page splits */
-#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1115
+#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1136
 /*! cache: internal pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1116
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1137
 /*! cache: internal pages queued for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED	1117
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_QUEUED	1138
 /*! cache: internal pages seen by eviction walk */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN	1118
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_SEEN	1139
 /*! cache: internal pages seen by eviction walk that are already queued */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED	1119
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED	1140
 /*! cache: internal pages split during eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL	1120
+#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL	1141
 /*! cache: leaf pages split during eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF		1121
+#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF		1142
 /*! cache: maximum bytes configured */
-#define	WT_STAT_CONN_CACHE_BYTES_MAX			1122
+#define	WT_STAT_CONN_CACHE_BYTES_MAX			1143
 /*! cache: maximum page size at eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE	1123
+#define	WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE	1144
 /*! cache: modified pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_DIRTY		1124
+#define	WT_STAT_CONN_CACHE_EVICTION_DIRTY		1145
 /*! cache: modified pages evicted by application threads */
-#define	WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY		1125
+#define	WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY		1146
 /*! cache: operations timed out waiting for space in cache */
-#define	WT_STAT_CONN_CACHE_TIMED_OUT_OPS		1126
+#define	WT_STAT_CONN_CACHE_TIMED_OUT_OPS		1147
 /*! cache: overflow pages read into cache */
-#define	WT_STAT_CONN_CACHE_READ_OVERFLOW		1127
+#define	WT_STAT_CONN_CACHE_READ_OVERFLOW		1148
 /*! cache: page split during eviction deepened the tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_DEEPEN		1128
+#define	WT_STAT_CONN_CACHE_EVICTION_DEEPEN		1149
 /*! cache: page written requiring history store records */
-#define	WT_STAT_CONN_CACHE_WRITE_HS			1129
+#define	WT_STAT_CONN_CACHE_WRITE_HS			1150
 /*! cache: pages currently held in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1130
+#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1151
 /*! cache: pages evicted by application threads */
-#define	WT_STAT_CONN_CACHE_EVICTION_APP			1131
+#define	WT_STAT_CONN_CACHE_EVICTION_APP			1152
 /*! cache: pages evicted in parallel with checkpoint */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_IN_PARALLEL_WITH_CHECKPOINT	1132
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_IN_PARALLEL_WITH_CHECKPOINT	1153
 /*! cache: pages queued for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED	1133
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED	1154
 /*! cache: pages queued for eviction post lru sorting */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU	1134
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_POST_LRU	1155
 /*! cache: pages queued for urgent eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT	1135
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT	1156
 /*! cache: pages queued for urgent eviction during walk */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST	1136
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST	1157
 /*!
  * cache: pages queued for urgent eviction from history store due to high
  * dirty content
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT_HS_DIRTY	1137
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT_HS_DIRTY	1158
 /*! cache: pages read into cache */
-#define	WT_STAT_CONN_CACHE_READ				1138
+#define	WT_STAT_CONN_CACHE_READ				1159
 /*! cache: pages read into cache after truncate */
-#define	WT_STAT_CONN_CACHE_READ_DELETED			1139
+#define	WT_STAT_CONN_CACHE_READ_DELETED			1160
 /*! cache: pages read into cache after truncate in prepare state */
-#define	WT_STAT_CONN_CACHE_READ_DELETED_PREPARED	1140
+#define	WT_STAT_CONN_CACHE_READ_DELETED_PREPARED	1161
 /*! cache: pages requested from the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_REQUESTED		1141
+#define	WT_STAT_CONN_CACHE_PAGES_REQUESTED		1162
 /*! cache: pages seen by eviction walk */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN		1142
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN		1163
 /*! cache: pages seen by eviction walk that are already queued */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED	1143
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_ALREADY_QUEUED	1164
 /*! cache: pages selected for eviction unable to be evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL		1144
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL		1165
 /*!
  * cache: pages selected for eviction unable to be evicted as the parent
  * page has overflow items
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS	1145
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_PARENT_HAS_OVERFLOW_ITEMS	1166
 /*!
  * cache: pages selected for eviction unable to be evicted because of
  * active children on an internal page
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE	1146
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE	1167
 /*!
  * cache: pages selected for eviction unable to be evicted because of
  * failure in reconciliation
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION	1147
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_IN_RECONCILIATION	1168
 /*!
  * cache: pages selected for eviction unable to be evicted because of
  * race between checkpoint and out of order timestamps handling
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_CHECKPOINT_OUT_OF_ORDER_TS	1148
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL_CHECKPOINT_OUT_OF_ORDER_TS	1169
 /*! cache: pages walked for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1149
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1170
 /*! cache: pages written from cache */
-#define	WT_STAT_CONN_CACHE_WRITE			1150
+#define	WT_STAT_CONN_CACHE_WRITE			1171
 /*! cache: pages written requiring in-memory restoration */
-#define	WT_STAT_CONN_CACHE_WRITE_RESTORE		1151
+#define	WT_STAT_CONN_CACHE_WRITE_RESTORE		1172
 /*! cache: percentage overhead */
-#define	WT_STAT_CONN_CACHE_OVERHEAD			1152
+#define	WT_STAT_CONN_CACHE_OVERHEAD			1173
 /*! cache: the number of times full update inserted to history store */
-#define	WT_STAT_CONN_CACHE_HS_INSERT_FULL_UPDATE	1153
+#define	WT_STAT_CONN_CACHE_HS_INSERT_FULL_UPDATE	1174
 /*! cache: the number of times reverse modify inserted to history store */
-#define	WT_STAT_CONN_CACHE_HS_INSERT_REVERSE_MODIFY	1154
+#define	WT_STAT_CONN_CACHE_HS_INSERT_REVERSE_MODIFY	1175
 /*! cache: tracked bytes belonging to internal pages in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_INTERNAL		1155
+#define	WT_STAT_CONN_CACHE_BYTES_INTERNAL		1176
 /*! cache: tracked bytes belonging to leaf pages in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_LEAF			1156
+#define	WT_STAT_CONN_CACHE_BYTES_LEAF			1177
 /*! cache: tracked dirty bytes in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_DIRTY			1157
+#define	WT_STAT_CONN_CACHE_BYTES_DIRTY			1178
 /*! cache: tracked dirty pages in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1158
+#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1179
 /*! cache: unmodified pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_CLEAN		1159
+#define	WT_STAT_CONN_CACHE_EVICTION_CLEAN		1180
 /*! capacity: background fsync file handles considered */
-#define	WT_STAT_CONN_FSYNC_ALL_FH_TOTAL			1160
+#define	WT_STAT_CONN_FSYNC_ALL_FH_TOTAL			1181
 /*! capacity: background fsync file handles synced */
-#define	WT_STAT_CONN_FSYNC_ALL_FH			1161
+#define	WT_STAT_CONN_FSYNC_ALL_FH			1182
 /*! capacity: background fsync time (msecs) */
-#define	WT_STAT_CONN_FSYNC_ALL_TIME			1162
+#define	WT_STAT_CONN_FSYNC_ALL_TIME			1183
 /*! capacity: bytes read */
-#define	WT_STAT_CONN_CAPACITY_BYTES_READ		1163
+#define	WT_STAT_CONN_CAPACITY_BYTES_READ		1184
 /*! capacity: bytes written for checkpoint */
-#define	WT_STAT_CONN_CAPACITY_BYTES_CKPT		1164
+#define	WT_STAT_CONN_CAPACITY_BYTES_CKPT		1185
 /*! capacity: bytes written for eviction */
-#define	WT_STAT_CONN_CAPACITY_BYTES_EVICT		1165
+#define	WT_STAT_CONN_CAPACITY_BYTES_EVICT		1186
 /*! capacity: bytes written for log */
-#define	WT_STAT_CONN_CAPACITY_BYTES_LOG			1166
+#define	WT_STAT_CONN_CAPACITY_BYTES_LOG			1187
 /*! capacity: bytes written total */
-#define	WT_STAT_CONN_CAPACITY_BYTES_WRITTEN		1167
+#define	WT_STAT_CONN_CAPACITY_BYTES_WRITTEN		1188
 /*! capacity: threshold to call fsync */
-#define	WT_STAT_CONN_CAPACITY_THRESHOLD			1168
+#define	WT_STAT_CONN_CAPACITY_THRESHOLD			1189
 /*! capacity: time waiting due to total capacity (usecs) */
-#define	WT_STAT_CONN_CAPACITY_TIME_TOTAL		1169
+#define	WT_STAT_CONN_CAPACITY_TIME_TOTAL		1190
 /*! capacity: time waiting during checkpoint (usecs) */
-#define	WT_STAT_CONN_CAPACITY_TIME_CKPT			1170
+#define	WT_STAT_CONN_CAPACITY_TIME_CKPT			1191
 /*! capacity: time waiting during eviction (usecs) */
-#define	WT_STAT_CONN_CAPACITY_TIME_EVICT		1171
+#define	WT_STAT_CONN_CAPACITY_TIME_EVICT		1192
 /*! capacity: time waiting during logging (usecs) */
-#define	WT_STAT_CONN_CAPACITY_TIME_LOG			1172
+#define	WT_STAT_CONN_CAPACITY_TIME_LOG			1193
 /*! capacity: time waiting during read (usecs) */
-#define	WT_STAT_CONN_CAPACITY_TIME_READ			1173
+#define	WT_STAT_CONN_CAPACITY_TIME_READ			1194
 /*! checkpoint-cleanup: pages added for eviction */
-#define	WT_STAT_CONN_CC_PAGES_EVICT			1174
+#define	WT_STAT_CONN_CC_PAGES_EVICT			1195
 /*! checkpoint-cleanup: pages removed */
-#define	WT_STAT_CONN_CC_PAGES_REMOVED			1175
+#define	WT_STAT_CONN_CC_PAGES_REMOVED			1196
 /*! checkpoint-cleanup: pages skipped during tree walk */
-#define	WT_STAT_CONN_CC_PAGES_WALK_SKIPPED		1176
+#define	WT_STAT_CONN_CC_PAGES_WALK_SKIPPED		1197
 /*! checkpoint-cleanup: pages visited */
-#define	WT_STAT_CONN_CC_PAGES_VISITED			1177
+#define	WT_STAT_CONN_CC_PAGES_VISITED			1198
 /*! connection: auto adjusting condition resets */
-#define	WT_STAT_CONN_COND_AUTO_WAIT_RESET		1178
+#define	WT_STAT_CONN_COND_AUTO_WAIT_RESET		1199
 /*! connection: auto adjusting condition wait calls */
-#define	WT_STAT_CONN_COND_AUTO_WAIT			1179
+#define	WT_STAT_CONN_COND_AUTO_WAIT			1200
 /*!
  * connection: auto adjusting condition wait raced to update timeout and
  * skipped updating
  */
-#define	WT_STAT_CONN_COND_AUTO_WAIT_SKIPPED		1180
+#define	WT_STAT_CONN_COND_AUTO_WAIT_SKIPPED		1201
 /*! connection: detected system time went backwards */
-#define	WT_STAT_CONN_TIME_TRAVEL			1181
+#define	WT_STAT_CONN_TIME_TRAVEL			1202
 /*! connection: files currently open */
-#define	WT_STAT_CONN_FILE_OPEN				1182
+#define	WT_STAT_CONN_FILE_OPEN				1203
 /*! connection: hash bucket array size for data handles */
-#define	WT_STAT_CONN_BUCKETS_DH				1183
+#define	WT_STAT_CONN_BUCKETS_DH				1204
 /*! connection: hash bucket array size general */
-#define	WT_STAT_CONN_BUCKETS				1184
+#define	WT_STAT_CONN_BUCKETS				1205
 /*! connection: memory allocations */
-#define	WT_STAT_CONN_MEMORY_ALLOCATION			1185
+#define	WT_STAT_CONN_MEMORY_ALLOCATION			1206
 /*! connection: memory frees */
-#define	WT_STAT_CONN_MEMORY_FREE			1186
+#define	WT_STAT_CONN_MEMORY_FREE			1207
 /*! connection: memory re-allocations */
-#define	WT_STAT_CONN_MEMORY_GROW			1187
+#define	WT_STAT_CONN_MEMORY_GROW			1208
 /*! connection: pthread mutex condition wait calls */
-#define	WT_STAT_CONN_COND_WAIT				1188
+#define	WT_STAT_CONN_COND_WAIT				1209
 /*! connection: pthread mutex shared lock read-lock calls */
-#define	WT_STAT_CONN_RWLOCK_READ			1189
+#define	WT_STAT_CONN_RWLOCK_READ			1210
 /*! connection: pthread mutex shared lock write-lock calls */
-#define	WT_STAT_CONN_RWLOCK_WRITE			1190
+#define	WT_STAT_CONN_RWLOCK_WRITE			1211
 /*! connection: total fsync I/Os */
-#define	WT_STAT_CONN_FSYNC_IO				1191
+#define	WT_STAT_CONN_FSYNC_IO				1212
 /*! connection: total read I/Os */
-#define	WT_STAT_CONN_READ_IO				1192
+#define	WT_STAT_CONN_READ_IO				1213
 /*! connection: total write I/Os */
-#define	WT_STAT_CONN_WRITE_IO				1193
+#define	WT_STAT_CONN_WRITE_IO				1214
 /*! cursor: Total number of entries skipped by cursor next calls */
-#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_TOTAL		1194
+#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_TOTAL		1215
 /*! cursor: Total number of entries skipped by cursor prev calls */
-#define	WT_STAT_CONN_CURSOR_PREV_SKIP_TOTAL		1195
+#define	WT_STAT_CONN_CURSOR_PREV_SKIP_TOTAL		1216
 /*!
  * cursor: Total number of entries skipped to position the history store
  * cursor
  */
-#define	WT_STAT_CONN_CURSOR_SKIP_HS_CUR_POSITION	1196
+#define	WT_STAT_CONN_CURSOR_SKIP_HS_CUR_POSITION	1217
 /*!
  * cursor: Total number of times a search near has exited due to prefix
  * config
  */
-#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	1197
+#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	1218
 /*! cursor: cached cursor count */
-#define	WT_STAT_CONN_CURSOR_CACHED_COUNT		1198
+#define	WT_STAT_CONN_CURSOR_CACHED_COUNT		1219
 /*! cursor: cursor bulk loaded cursor insert calls */
-#define	WT_STAT_CONN_CURSOR_INSERT_BULK			1199
+#define	WT_STAT_CONN_CURSOR_INSERT_BULK			1220
 /*! cursor: cursor close calls that result in cache */
-#define	WT_STAT_CONN_CURSOR_CACHE			1200
+#define	WT_STAT_CONN_CURSOR_CACHE			1221
 /*! cursor: cursor create calls */
-#define	WT_STAT_CONN_CURSOR_CREATE			1201
+#define	WT_STAT_CONN_CURSOR_CREATE			1222
 /*! cursor: cursor insert calls */
-#define	WT_STAT_CONN_CURSOR_INSERT			1202
+#define	WT_STAT_CONN_CURSOR_INSERT			1223
 /*! cursor: cursor insert key and value bytes */
-#define	WT_STAT_CONN_CURSOR_INSERT_BYTES		1203
+#define	WT_STAT_CONN_CURSOR_INSERT_BYTES		1224
 /*! cursor: cursor modify calls */
-#define	WT_STAT_CONN_CURSOR_MODIFY			1204
+#define	WT_STAT_CONN_CURSOR_MODIFY			1225
 /*! cursor: cursor modify key and value bytes affected */
-#define	WT_STAT_CONN_CURSOR_MODIFY_BYTES		1205
+#define	WT_STAT_CONN_CURSOR_MODIFY_BYTES		1226
 /*! cursor: cursor modify value bytes modified */
-#define	WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH		1206
+#define	WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH		1227
 /*! cursor: cursor next calls */
-#define	WT_STAT_CONN_CURSOR_NEXT			1207
+#define	WT_STAT_CONN_CURSOR_NEXT			1228
 /*!
  * cursor: cursor next calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_CONN_CURSOR_NEXT_HS_TOMBSTONE		1208
+#define	WT_STAT_CONN_CURSOR_NEXT_HS_TOMBSTONE		1229
 /*!
  * cursor: cursor next calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_GE_100		1209
+#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_GE_100		1230
 /*! cursor: cursor next calls that skip less than 100 entries */
-#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_LT_100		1210
+#define	WT_STAT_CONN_CURSOR_NEXT_SKIP_LT_100		1231
 /*! cursor: cursor operation restarted */
-#define	WT_STAT_CONN_CURSOR_RESTART			1211
+#define	WT_STAT_CONN_CURSOR_RESTART			1232
 /*! cursor: cursor prev calls */
-#define	WT_STAT_CONN_CURSOR_PREV			1212
+#define	WT_STAT_CONN_CURSOR_PREV			1233
 /*!
  * cursor: cursor prev calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_CONN_CURSOR_PREV_HS_TOMBSTONE		1213
+#define	WT_STAT_CONN_CURSOR_PREV_HS_TOMBSTONE		1234
 /*!
  * cursor: cursor prev calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_CONN_CURSOR_PREV_SKIP_GE_100		1214
+#define	WT_STAT_CONN_CURSOR_PREV_SKIP_GE_100		1235
 /*! cursor: cursor prev calls that skip less than 100 entries */
-#define	WT_STAT_CONN_CURSOR_PREV_SKIP_LT_100		1215
+#define	WT_STAT_CONN_CURSOR_PREV_SKIP_LT_100		1236
 /*! cursor: cursor remove calls */
-#define	WT_STAT_CONN_CURSOR_REMOVE			1216
+#define	WT_STAT_CONN_CURSOR_REMOVE			1237
 /*! cursor: cursor remove key bytes removed */
-#define	WT_STAT_CONN_CURSOR_REMOVE_BYTES		1217
+#define	WT_STAT_CONN_CURSOR_REMOVE_BYTES		1238
 /*! cursor: cursor reserve calls */
-#define	WT_STAT_CONN_CURSOR_RESERVE			1218
+#define	WT_STAT_CONN_CURSOR_RESERVE			1239
 /*! cursor: cursor reset calls */
-#define	WT_STAT_CONN_CURSOR_RESET			1219
+#define	WT_STAT_CONN_CURSOR_RESET			1240
 /*! cursor: cursor search calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH			1220
+#define	WT_STAT_CONN_CURSOR_SEARCH			1241
 /*! cursor: cursor search history store calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH_HS			1221
+#define	WT_STAT_CONN_CURSOR_SEARCH_HS			1242
 /*! cursor: cursor search near calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1222
+#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1243
 /*! cursor: cursor sweep buckets */
-#define	WT_STAT_CONN_CURSOR_SWEEP_BUCKETS		1223
+#define	WT_STAT_CONN_CURSOR_SWEEP_BUCKETS		1244
 /*! cursor: cursor sweep cursors closed */
-#define	WT_STAT_CONN_CURSOR_SWEEP_CLOSED		1224
+#define	WT_STAT_CONN_CURSOR_SWEEP_CLOSED		1245
 /*! cursor: cursor sweep cursors examined */
-#define	WT_STAT_CONN_CURSOR_SWEEP_EXAMINED		1225
+#define	WT_STAT_CONN_CURSOR_SWEEP_EXAMINED		1246
 /*! cursor: cursor sweeps */
-#define	WT_STAT_CONN_CURSOR_SWEEP			1226
+#define	WT_STAT_CONN_CURSOR_SWEEP			1247
 /*! cursor: cursor truncate calls */
-#define	WT_STAT_CONN_CURSOR_TRUNCATE			1227
+#define	WT_STAT_CONN_CURSOR_TRUNCATE			1248
 /*! cursor: cursor update calls */
-#define	WT_STAT_CONN_CURSOR_UPDATE			1228
+#define	WT_STAT_CONN_CURSOR_UPDATE			1249
 /*! cursor: cursor update key and value bytes */
-#define	WT_STAT_CONN_CURSOR_UPDATE_BYTES		1229
+#define	WT_STAT_CONN_CURSOR_UPDATE_BYTES		1250
 /*! cursor: cursor update value size change */
-#define	WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED	1230
+#define	WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED	1251
 /*! cursor: cursors reused from cache */
-#define	WT_STAT_CONN_CURSOR_REOPEN			1231
+#define	WT_STAT_CONN_CURSOR_REOPEN			1252
 /*! cursor: open cursor count */
-#define	WT_STAT_CONN_CURSOR_OPEN_COUNT			1232
+#define	WT_STAT_CONN_CURSOR_OPEN_COUNT			1253
 /*! data-handle: connection data handle size */
-#define	WT_STAT_CONN_DH_CONN_HANDLE_SIZE		1233
+#define	WT_STAT_CONN_DH_CONN_HANDLE_SIZE		1254
 /*! data-handle: connection data handles currently active */
-#define	WT_STAT_CONN_DH_CONN_HANDLE_COUNT		1234
+#define	WT_STAT_CONN_DH_CONN_HANDLE_COUNT		1255
 /*! data-handle: connection sweep candidate became referenced */
-#define	WT_STAT_CONN_DH_SWEEP_REF			1235
+#define	WT_STAT_CONN_DH_SWEEP_REF			1256
 /*! data-handle: connection sweep dhandles closed */
-#define	WT_STAT_CONN_DH_SWEEP_CLOSE			1236
+#define	WT_STAT_CONN_DH_SWEEP_CLOSE			1257
 /*! data-handle: connection sweep dhandles removed from hash list */
-#define	WT_STAT_CONN_DH_SWEEP_REMOVE			1237
+#define	WT_STAT_CONN_DH_SWEEP_REMOVE			1258
 /*! data-handle: connection sweep time-of-death sets */
-#define	WT_STAT_CONN_DH_SWEEP_TOD			1238
+#define	WT_STAT_CONN_DH_SWEEP_TOD			1259
 /*! data-handle: connection sweeps */
-#define	WT_STAT_CONN_DH_SWEEPS				1239
+#define	WT_STAT_CONN_DH_SWEEPS				1260
 /*!
  * data-handle: connection sweeps skipped due to checkpoint gathering
  * handles
  */
-#define	WT_STAT_CONN_DH_SWEEP_SKIP_CKPT			1240
+#define	WT_STAT_CONN_DH_SWEEP_SKIP_CKPT			1261
 /*! data-handle: session dhandles swept */
-#define	WT_STAT_CONN_DH_SESSION_HANDLES			1241
+#define	WT_STAT_CONN_DH_SESSION_HANDLES			1262
 /*! data-handle: session sweep attempts */
-#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1242
+#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1263
 /*! lock: checkpoint lock acquisitions */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_COUNT		1243
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_COUNT		1264
 /*! lock: checkpoint lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION	1244
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION	1265
 /*! lock: checkpoint lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL	1245
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL	1266
 /*! lock: dhandle lock application thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION	1246
+#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION	1267
 /*! lock: dhandle lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL		1247
+#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL		1268
 /*! lock: dhandle read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT		1248
+#define	WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT		1269
 /*! lock: dhandle write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT		1249
+#define	WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT		1270
 /*!
  * lock: durable timestamp queue lock application thread time waiting
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION	1250
+#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_APPLICATION	1271
 /*!
  * lock: durable timestamp queue lock internal thread time waiting
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL	1251
+#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WAIT_INTERNAL	1272
 /*! lock: durable timestamp queue read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT	1252
+#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_READ_COUNT	1273
 /*! lock: durable timestamp queue write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT	1253
+#define	WT_STAT_CONN_LOCK_DURABLE_TIMESTAMP_WRITE_COUNT	1274
 /*! lock: metadata lock acquisitions */
-#define	WT_STAT_CONN_LOCK_METADATA_COUNT		1254
+#define	WT_STAT_CONN_LOCK_METADATA_COUNT		1275
 /*! lock: metadata lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION	1255
+#define	WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION	1276
 /*! lock: metadata lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL	1256
+#define	WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL	1277
 /*!
  * lock: read timestamp queue lock application thread time waiting
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION	1257
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION	1278
 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL	1258
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL	1279
 /*! lock: read timestamp queue read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT	1259
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT	1280
 /*! lock: read timestamp queue write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT	1260
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT	1281
 /*! lock: schema lock acquisitions */
-#define	WT_STAT_CONN_LOCK_SCHEMA_COUNT			1261
+#define	WT_STAT_CONN_LOCK_SCHEMA_COUNT			1282
 /*! lock: schema lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION	1262
+#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION	1283
 /*! lock: schema lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL		1263
+#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL		1284
 /*!
  * lock: table lock application thread time waiting for the table lock
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION	1264
+#define	WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION	1285
 /*!
  * lock: table lock internal thread time waiting for the table lock
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL		1265
+#define	WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL		1286
 /*! lock: table read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TABLE_READ_COUNT		1266
+#define	WT_STAT_CONN_LOCK_TABLE_READ_COUNT		1287
 /*! lock: table write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT		1267
+#define	WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT		1288
 /*! lock: txn global lock application thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION	1268
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION	1289
 /*! lock: txn global lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL	1269
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL	1290
 /*! lock: txn global read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT		1270
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT		1291
 /*! lock: txn global write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT	1271
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT	1292
 /*! log: busy returns attempting to switch slots */
-#define	WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY		1272
+#define	WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY		1293
 /*! log: force archive time sleeping (usecs) */
-#define	WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP		1273
+#define	WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP		1294
 /*! log: log bytes of payload data */
-#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1274
+#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1295
 /*! log: log bytes written */
-#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1275
+#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1296
 /*! log: log files manually zero-filled */
-#define	WT_STAT_CONN_LOG_ZERO_FILLS			1276
+#define	WT_STAT_CONN_LOG_ZERO_FILLS			1297
 /*! log: log flush operations */
-#define	WT_STAT_CONN_LOG_FLUSH				1277
+#define	WT_STAT_CONN_LOG_FLUSH				1298
 /*! log: log force write operations */
-#define	WT_STAT_CONN_LOG_FORCE_WRITE			1278
+#define	WT_STAT_CONN_LOG_FORCE_WRITE			1299
 /*! log: log force write operations skipped */
-#define	WT_STAT_CONN_LOG_FORCE_WRITE_SKIP		1279
+#define	WT_STAT_CONN_LOG_FORCE_WRITE_SKIP		1300
 /*! log: log records compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1280
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1301
 /*! log: log records not compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1281
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1302
 /*! log: log records too small to compress */
-#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1282
+#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1303
 /*! log: log release advances write LSN */
-#define	WT_STAT_CONN_LOG_RELEASE_WRITE_LSN		1283
+#define	WT_STAT_CONN_LOG_RELEASE_WRITE_LSN		1304
 /*! log: log scan operations */
-#define	WT_STAT_CONN_LOG_SCANS				1284
+#define	WT_STAT_CONN_LOG_SCANS				1305
 /*! log: log scan records requiring two reads */
-#define	WT_STAT_CONN_LOG_SCAN_REREADS			1285
+#define	WT_STAT_CONN_LOG_SCAN_REREADS			1306
 /*! log: log server thread advances write LSN */
-#define	WT_STAT_CONN_LOG_WRITE_LSN			1286
+#define	WT_STAT_CONN_LOG_WRITE_LSN			1307
 /*! log: log server thread write LSN walk skipped */
-#define	WT_STAT_CONN_LOG_WRITE_LSN_SKIP			1287
+#define	WT_STAT_CONN_LOG_WRITE_LSN_SKIP			1308
 /*! log: log sync operations */
-#define	WT_STAT_CONN_LOG_SYNC				1288
+#define	WT_STAT_CONN_LOG_SYNC				1309
 /*! log: log sync time duration (usecs) */
-#define	WT_STAT_CONN_LOG_SYNC_DURATION			1289
+#define	WT_STAT_CONN_LOG_SYNC_DURATION			1310
 /*! log: log sync_dir operations */
-#define	WT_STAT_CONN_LOG_SYNC_DIR			1290
+#define	WT_STAT_CONN_LOG_SYNC_DIR			1311
 /*! log: log sync_dir time duration (usecs) */
-#define	WT_STAT_CONN_LOG_SYNC_DIR_DURATION		1291
+#define	WT_STAT_CONN_LOG_SYNC_DIR_DURATION		1312
 /*! log: log write operations */
-#define	WT_STAT_CONN_LOG_WRITES				1292
+#define	WT_STAT_CONN_LOG_WRITES				1313
 /*! log: logging bytes consolidated */
-#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1293
+#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1314
 /*! log: maximum log file size */
-#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1294
+#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1315
 /*! log: number of pre-allocated log files to create */
-#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1295
+#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1316
 /*! log: pre-allocated log files not ready and missed */
-#define	WT_STAT_CONN_LOG_PREALLOC_MISSED		1296
+#define	WT_STAT_CONN_LOG_PREALLOC_MISSED		1317
 /*! log: pre-allocated log files prepared */
-#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1297
+#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1318
 /*! log: pre-allocated log files used */
-#define	WT_STAT_CONN_LOG_PREALLOC_USED			1298
+#define	WT_STAT_CONN_LOG_PREALLOC_USED			1319
 /*! log: records processed by log scan */
-#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1299
+#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1320
 /*! log: slot close lost race */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSE_RACE		1300
+#define	WT_STAT_CONN_LOG_SLOT_CLOSE_RACE		1321
 /*! log: slot close unbuffered waits */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF		1301
+#define	WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF		1322
 /*! log: slot closures */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1302
+#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1323
 /*! log: slot join atomic update races */
-#define	WT_STAT_CONN_LOG_SLOT_RACES			1303
+#define	WT_STAT_CONN_LOG_SLOT_RACES			1324
 /*! log: slot join calls atomic updates raced */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_RACE		1304
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_RACE		1325
 /*! log: slot join calls did not yield */
-#define	WT_STAT_CONN_LOG_SLOT_IMMEDIATE			1305
+#define	WT_STAT_CONN_LOG_SLOT_IMMEDIATE			1326
 /*! log: slot join calls found active slot closed */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE		1306
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE		1327
 /*! log: slot join calls slept */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP		1307
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP		1328
 /*! log: slot join calls yielded */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD			1308
+#define	WT_STAT_CONN_LOG_SLOT_YIELD			1329
 /*! log: slot join found active slot closed */
-#define	WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED		1309
+#define	WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED		1330
 /*! log: slot joins yield time (usecs) */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_DURATION		1310
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_DURATION		1331
 /*! log: slot transitions unable to find free slot */
-#define	WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS		1311
+#define	WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS		1332
 /*! log: slot unbuffered writes */
-#define	WT_STAT_CONN_LOG_SLOT_UNBUFFERED		1312
+#define	WT_STAT_CONN_LOG_SLOT_UNBUFFERED		1333
 /*! log: total in-memory size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1313
+#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1334
 /*! log: total log buffer size */
-#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1314
+#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1335
 /*! log: total size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1315
+#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1336
 /*! log: written slots coalesced */
-#define	WT_STAT_CONN_LOG_SLOT_COALESCED			1316
+#define	WT_STAT_CONN_LOG_SLOT_COALESCED			1337
 /*! log: yields waiting for previous log file close */
-#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1317
+#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1338
 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50	1318
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50	1339
 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100	1319
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100	1340
 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250	1320
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250	1341
 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500	1321
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500	1342
 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000	1322
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000	1343
 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000	1323
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000	1344
 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50	1324
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50	1345
 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100	1325
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100	1346
 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250	1326
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250	1347
 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500	1327
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500	1348
 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000	1328
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000	1349
 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000	1329
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000	1350
 /*! perf: operation read latency histogram (bucket 1) - 100-249us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250	1330
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250	1351
 /*! perf: operation read latency histogram (bucket 2) - 250-499us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500	1331
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500	1352
 /*! perf: operation read latency histogram (bucket 3) - 500-999us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000	1332
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000	1353
 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000	1333
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000	1354
 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000	1334
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000	1355
 /*! perf: operation write latency histogram (bucket 1) - 100-249us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250	1335
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250	1356
 /*! perf: operation write latency histogram (bucket 2) - 250-499us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500	1336
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500	1357
 /*! perf: operation write latency histogram (bucket 3) - 500-999us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000	1337
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000	1358
 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000	1338
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000	1359
 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000	1339
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000	1360
 /*! reconciliation: approximate byte size of timestamps in pages written */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TS		1340
+#define	WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TS		1361
 /*!
  * reconciliation: approximate byte size of transaction IDs in pages
  * written
  */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TXN		1341
+#define	WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TXN		1362
 /*! reconciliation: fast-path pages deleted */
-#define	WT_STAT_CONN_REC_PAGE_DELETE_FAST		1342
+#define	WT_STAT_CONN_REC_PAGE_DELETE_FAST		1363
 /*! reconciliation: internal-page overflow keys */
-#define	WT_STAT_CONN_REC_OVERFLOW_KEY_INTERNAL		1343
+#define	WT_STAT_CONN_REC_OVERFLOW_KEY_INTERNAL		1364
 /*! reconciliation: leaf-page overflow keys */
-#define	WT_STAT_CONN_REC_OVERFLOW_KEY_LEAF		1344
+#define	WT_STAT_CONN_REC_OVERFLOW_KEY_LEAF		1365
 /*! reconciliation: maximum seconds spent in a reconciliation call */
-#define	WT_STAT_CONN_REC_MAXIMUM_SECONDS		1345
+#define	WT_STAT_CONN_REC_MAXIMUM_SECONDS		1366
 /*! reconciliation: page reconciliation calls */
-#define	WT_STAT_CONN_REC_PAGES				1346
+#define	WT_STAT_CONN_REC_PAGES				1367
 /*! reconciliation: page reconciliation calls for eviction */
-#define	WT_STAT_CONN_REC_PAGES_EVICTION			1347
+#define	WT_STAT_CONN_REC_PAGES_EVICTION			1368
 /*!
  * reconciliation: page reconciliation calls that resulted in values with
  * prepared transaction metadata
  */
-#define	WT_STAT_CONN_REC_PAGES_WITH_PREPARE		1348
+#define	WT_STAT_CONN_REC_PAGES_WITH_PREPARE		1369
 /*!
  * reconciliation: page reconciliation calls that resulted in values with
  * timestamps
  */
-#define	WT_STAT_CONN_REC_PAGES_WITH_TS			1349
+#define	WT_STAT_CONN_REC_PAGES_WITH_TS			1370
 /*!
  * reconciliation: page reconciliation calls that resulted in values with
  * transaction ids
  */
-#define	WT_STAT_CONN_REC_PAGES_WITH_TXN			1350
+#define	WT_STAT_CONN_REC_PAGES_WITH_TXN			1371
 /*! reconciliation: pages deleted */
-#define	WT_STAT_CONN_REC_PAGE_DELETE			1351
+#define	WT_STAT_CONN_REC_PAGE_DELETE			1372
 /*!
  * reconciliation: pages written including an aggregated newest start
  * durable timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	1352
+#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	1373
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * durable timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	1353
+#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	1374
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TS	1354
+#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TS	1375
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * transaction ID
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TXN	1355
+#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TXN	1376
 /*!
  * reconciliation: pages written including an aggregated newest
  * transaction ID
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_TXN		1356
+#define	WT_STAT_CONN_REC_TIME_AGGR_NEWEST_TXN		1377
 /*!
  * reconciliation: pages written including an aggregated oldest start
  * timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_AGGR_OLDEST_START_TS	1357
+#define	WT_STAT_CONN_REC_TIME_AGGR_OLDEST_START_TS	1378
 /*! reconciliation: pages written including an aggregated prepare */
-#define	WT_STAT_CONN_REC_TIME_AGGR_PREPARED		1358
+#define	WT_STAT_CONN_REC_TIME_AGGR_PREPARED		1379
 /*! reconciliation: pages written including at least one prepare state */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_PREPARED	1359
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_PREPARED	1380
 /*!
  * reconciliation: pages written including at least one start durable
  * timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	1360
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	1381
 /*! reconciliation: pages written including at least one start timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TS	1361
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TS	1382
 /*!
  * reconciliation: pages written including at least one start transaction
  * ID
  */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TXN	1362
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TXN	1383
 /*!
  * reconciliation: pages written including at least one stop durable
  * timestamp
  */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	1363
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	1384
 /*! reconciliation: pages written including at least one stop timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TS	1364
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TS	1385
 /*!
  * reconciliation: pages written including at least one stop transaction
  * ID
  */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TXN	1365
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TXN	1386
 /*! reconciliation: records written including a prepare state */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_PREPARED		1366
+#define	WT_STAT_CONN_REC_TIME_WINDOW_PREPARED		1387
 /*! reconciliation: records written including a start durable timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_START_TS	1367
+#define	WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_START_TS	1388
 /*! reconciliation: records written including a start timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_START_TS		1368
+#define	WT_STAT_CONN_REC_TIME_WINDOW_START_TS		1389
 /*! reconciliation: records written including a start transaction ID */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_START_TXN		1369
+#define	WT_STAT_CONN_REC_TIME_WINDOW_START_TXN		1390
 /*! reconciliation: records written including a stop durable timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_STOP_TS	1370
+#define	WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_STOP_TS	1391
 /*! reconciliation: records written including a stop timestamp */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_STOP_TS		1371
+#define	WT_STAT_CONN_REC_TIME_WINDOW_STOP_TS		1392
 /*! reconciliation: records written including a stop transaction ID */
-#define	WT_STAT_CONN_REC_TIME_WINDOW_STOP_TXN		1372
+#define	WT_STAT_CONN_REC_TIME_WINDOW_STOP_TXN		1393
 /*! reconciliation: split bytes currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1373
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1394
 /*! reconciliation: split objects currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1374
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1395
 /*! session: attempts to remove a local object and the object is in use */
-#define	WT_STAT_CONN_LOCAL_OBJECTS_INUSE		1375
+#define	WT_STAT_CONN_LOCAL_OBJECTS_INUSE		1396
 /*! session: flush_tier operation calls */
-#define	WT_STAT_CONN_FLUSH_TIER				1376
+#define	WT_STAT_CONN_FLUSH_TIER				1397
 /*! session: local objects removed */
-#define	WT_STAT_CONN_LOCAL_OBJECTS_REMOVED		1377
+#define	WT_STAT_CONN_LOCAL_OBJECTS_REMOVED		1398
 /*! session: open session count */
-#define	WT_STAT_CONN_SESSION_OPEN			1378
+#define	WT_STAT_CONN_SESSION_OPEN			1399
 /*! session: session query timestamp calls */
-#define	WT_STAT_CONN_SESSION_QUERY_TS			1379
+#define	WT_STAT_CONN_SESSION_QUERY_TS			1400
 /*! session: table alter failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL		1380
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL		1401
 /*! session: table alter successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS	1381
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS	1402
 /*! session: table alter triggering checkpoint calls */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_TRIGGER_CHECKPOINT	1382
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_TRIGGER_CHECKPOINT	1403
 /*! session: table alter unchanged and skipped */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP		1383
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP		1404
 /*! session: table compact failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL		1384
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL		1405
 /*! session: table compact failed calls due to cache pressure */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL_CACHE_PRESSURE	1385
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL_CACHE_PRESSURE	1406
 /*! session: table compact running */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_RUNNING	1386
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_RUNNING	1407
 /*! session: table compact skipped as process would not reduce file size */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SKIPPED	1387
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SKIPPED	1408
 /*! session: table compact successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS	1388
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS	1409
 /*! session: table compact timeout */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_TIMEOUT	1389
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_TIMEOUT	1410
 /*! session: table create failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL		1390
+#define	WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL		1411
 /*! session: table create successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS	1391
+#define	WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS	1412
 /*! session: table drop failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_DROP_FAIL		1392
+#define	WT_STAT_CONN_SESSION_TABLE_DROP_FAIL		1413
 /*! session: table drop successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS		1393
+#define	WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS		1414
 /*! session: table rename failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL		1394
+#define	WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL		1415
 /*! session: table rename successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS	1395
+#define	WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS	1416
 /*! session: table salvage failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL		1396
+#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL		1417
 /*! session: table salvage successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS	1397
+#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS	1418
 /*! session: table truncate failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL	1398
+#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL	1419
 /*! session: table truncate successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS	1399
+#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS	1420
 /*! session: table verify failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL		1400
+#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL		1421
 /*! session: table verify successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS	1401
+#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS	1422
 /*! session: tiered operations dequeued and processed */
-#define	WT_STAT_CONN_TIERED_WORK_UNITS_DEQUEUED		1402
+#define	WT_STAT_CONN_TIERED_WORK_UNITS_DEQUEUED		1423
 /*! session: tiered operations scheduled */
-#define	WT_STAT_CONN_TIERED_WORK_UNITS_CREATED		1403
+#define	WT_STAT_CONN_TIERED_WORK_UNITS_CREATED		1424
 /*! session: tiered storage local retention time (secs) */
-#define	WT_STAT_CONN_TIERED_RETENTION			1404
+#define	WT_STAT_CONN_TIERED_RETENTION			1425
 /*! session: tiered storage object size */
-#define	WT_STAT_CONN_TIERED_OBJECT_SIZE			1405
+#define	WT_STAT_CONN_TIERED_OBJECT_SIZE			1426
 /*! thread-state: active filesystem fsync calls */
-#define	WT_STAT_CONN_THREAD_FSYNC_ACTIVE		1406
+#define	WT_STAT_CONN_THREAD_FSYNC_ACTIVE		1427
 /*! thread-state: active filesystem read calls */
-#define	WT_STAT_CONN_THREAD_READ_ACTIVE			1407
+#define	WT_STAT_CONN_THREAD_READ_ACTIVE			1428
 /*! thread-state: active filesystem write calls */
-#define	WT_STAT_CONN_THREAD_WRITE_ACTIVE		1408
+#define	WT_STAT_CONN_THREAD_WRITE_ACTIVE		1429
 /*! thread-yield: application thread time evicting (usecs) */
-#define	WT_STAT_CONN_APPLICATION_EVICT_TIME		1409
+#define	WT_STAT_CONN_APPLICATION_EVICT_TIME		1430
 /*! thread-yield: application thread time waiting for cache (usecs) */
-#define	WT_STAT_CONN_APPLICATION_CACHE_TIME		1410
+#define	WT_STAT_CONN_APPLICATION_CACHE_TIME		1431
 /*!
  * thread-yield: connection close blocked waiting for transaction state
  * stabilization
  */
-#define	WT_STAT_CONN_TXN_RELEASE_BLOCKED		1411
+#define	WT_STAT_CONN_TXN_RELEASE_BLOCKED		1432
 /*! thread-yield: connection close yielded for lsm manager shutdown */
-#define	WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM		1412
+#define	WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM		1433
 /*! thread-yield: data handle lock yielded */
-#define	WT_STAT_CONN_DHANDLE_LOCK_BLOCKED		1413
+#define	WT_STAT_CONN_DHANDLE_LOCK_BLOCKED		1434
 /*!
  * thread-yield: get reference for page index and slot time sleeping
  * (usecs)
  */
-#define	WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED	1414
+#define	WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED	1435
 /*! thread-yield: page access yielded due to prepare state change */
-#define	WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE	1415
+#define	WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE	1436
 /*! thread-yield: page acquire busy blocked */
-#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1416
+#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1437
 /*! thread-yield: page acquire eviction blocked */
-#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1417
+#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1438
 /*! thread-yield: page acquire locked blocked */
-#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1418
+#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1439
 /*! thread-yield: page acquire read blocked */
-#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1419
+#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1440
 /*! thread-yield: page acquire time sleeping (usecs) */
-#define	WT_STAT_CONN_PAGE_SLEEP				1420
+#define	WT_STAT_CONN_PAGE_SLEEP				1441
 /*!
  * thread-yield: page delete rollback time sleeping for state change
  * (usecs)
  */
-#define	WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED		1421
+#define	WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED		1442
 /*! thread-yield: page reconciliation yielded due to child modification */
-#define	WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE		1422
+#define	WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE		1443
 /*! transaction: Number of prepared updates */
-#define	WT_STAT_CONN_TXN_PREPARED_UPDATES		1423
+#define	WT_STAT_CONN_TXN_PREPARED_UPDATES		1444
 /*! transaction: Number of prepared updates committed */
-#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_COMMITTED	1424
+#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_COMMITTED	1445
 /*! transaction: Number of prepared updates repeated on the same key */
-#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_KEY_REPEATED	1425
+#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_KEY_REPEATED	1446
 /*! transaction: Number of prepared updates rolled back */
-#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_ROLLEDBACK	1426
+#define	WT_STAT_CONN_TXN_PREPARED_UPDATES_ROLLEDBACK	1447
 /*! transaction: prepared transactions */
-#define	WT_STAT_CONN_TXN_PREPARE			1427
+#define	WT_STAT_CONN_TXN_PREPARE			1448
 /*! transaction: prepared transactions committed */
-#define	WT_STAT_CONN_TXN_PREPARE_COMMIT			1428
+#define	WT_STAT_CONN_TXN_PREPARE_COMMIT			1449
 /*! transaction: prepared transactions currently active */
-#define	WT_STAT_CONN_TXN_PREPARE_ACTIVE			1429
+#define	WT_STAT_CONN_TXN_PREPARE_ACTIVE			1450
 /*! transaction: prepared transactions rolled back */
-#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK		1430
+#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK		1451
 /*!
  * transaction: prepared transactions rolled back and do not remove the
  * history store entry
  */
-#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK_DO_NOT_REMOVE_HS_UPDATE	1431
+#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK_DO_NOT_REMOVE_HS_UPDATE	1452
 /*!
  * transaction: prepared transactions rolled back and fix the history
  * store entry with checkpoint reserved transaction id
  */
-#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK_FIX_HS_UPDATE_WITH_CKPT_RESERVED_TXNID	1432
+#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK_FIX_HS_UPDATE_WITH_CKPT_RESERVED_TXNID	1453
 /*! transaction: query timestamp calls */
-#define	WT_STAT_CONN_TXN_QUERY_TS			1433
+#define	WT_STAT_CONN_TXN_QUERY_TS			1454
 /*! transaction: race to read prepared update retry */
-#define	WT_STAT_CONN_TXN_READ_RACE_PREPARE_UPDATE	1434
+#define	WT_STAT_CONN_TXN_READ_RACE_PREPARE_UPDATE	1455
 /*! transaction: rollback to stable calls */
-#define	WT_STAT_CONN_TXN_RTS				1435
+#define	WT_STAT_CONN_TXN_RTS				1456
 /*!
  * transaction: rollback to stable history store records with stop
  * timestamps older than newer records
  */
-#define	WT_STAT_CONN_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START	1436
+#define	WT_STAT_CONN_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START	1457
 /*! transaction: rollback to stable inconsistent checkpoint */
-#define	WT_STAT_CONN_TXN_RTS_INCONSISTENT_CKPT		1437
+#define	WT_STAT_CONN_TXN_RTS_INCONSISTENT_CKPT		1458
 /*! transaction: rollback to stable keys removed */
-#define	WT_STAT_CONN_TXN_RTS_KEYS_REMOVED		1438
+#define	WT_STAT_CONN_TXN_RTS_KEYS_REMOVED		1459
 /*! transaction: rollback to stable keys restored */
-#define	WT_STAT_CONN_TXN_RTS_KEYS_RESTORED		1439
+#define	WT_STAT_CONN_TXN_RTS_KEYS_RESTORED		1460
 /*! transaction: rollback to stable pages visited */
-#define	WT_STAT_CONN_TXN_RTS_PAGES_VISITED		1440
+#define	WT_STAT_CONN_TXN_RTS_PAGES_VISITED		1461
 /*! transaction: rollback to stable restored tombstones from history store */
-#define	WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES	1441
+#define	WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES	1462
 /*! transaction: rollback to stable restored updates from history store */
-#define	WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES		1442
+#define	WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES		1463
 /*! transaction: rollback to stable skipping delete rle */
-#define	WT_STAT_CONN_TXN_RTS_DELETE_RLE_SKIPPED		1443
+#define	WT_STAT_CONN_TXN_RTS_DELETE_RLE_SKIPPED		1464
 /*! transaction: rollback to stable skipping stable rle */
-#define	WT_STAT_CONN_TXN_RTS_STABLE_RLE_SKIPPED		1444
+#define	WT_STAT_CONN_TXN_RTS_STABLE_RLE_SKIPPED		1465
 /*! transaction: rollback to stable sweeping history store keys */
-#define	WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS		1445
+#define	WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS		1466
 /*! transaction: rollback to stable tree walk skipping pages */
-#define	WT_STAT_CONN_TXN_RTS_TREE_WALK_SKIP_PAGES	1446
+#define	WT_STAT_CONN_TXN_RTS_TREE_WALK_SKIP_PAGES	1467
 /*! transaction: rollback to stable updates aborted */
-#define	WT_STAT_CONN_TXN_RTS_UPD_ABORTED		1447
+#define	WT_STAT_CONN_TXN_RTS_UPD_ABORTED		1468
 /*! transaction: rollback to stable updates removed from history store */
-#define	WT_STAT_CONN_TXN_RTS_HS_REMOVED			1448
+#define	WT_STAT_CONN_TXN_RTS_HS_REMOVED			1469
 /*! transaction: sessions scanned in each walk of concurrent sessions */
-#define	WT_STAT_CONN_TXN_SESSIONS_WALKED		1449
+#define	WT_STAT_CONN_TXN_SESSIONS_WALKED		1470
 /*! transaction: set timestamp calls */
-#define	WT_STAT_CONN_TXN_SET_TS				1450
+#define	WT_STAT_CONN_TXN_SET_TS				1471
 /*! transaction: set timestamp durable calls */
-#define	WT_STAT_CONN_TXN_SET_TS_DURABLE			1451
+#define	WT_STAT_CONN_TXN_SET_TS_DURABLE			1472
 /*! transaction: set timestamp durable updates */
-#define	WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD		1452
+#define	WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD		1473
 /*! transaction: set timestamp oldest calls */
-#define	WT_STAT_CONN_TXN_SET_TS_OLDEST			1453
+#define	WT_STAT_CONN_TXN_SET_TS_OLDEST			1474
 /*! transaction: set timestamp oldest updates */
-#define	WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD		1454
+#define	WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD		1475
 /*! transaction: set timestamp stable calls */
-#define	WT_STAT_CONN_TXN_SET_TS_STABLE			1455
+#define	WT_STAT_CONN_TXN_SET_TS_STABLE			1476
 /*! transaction: set timestamp stable updates */
-#define	WT_STAT_CONN_TXN_SET_TS_STABLE_UPD		1456
+#define	WT_STAT_CONN_TXN_SET_TS_STABLE_UPD		1477
 /*! transaction: transaction begins */
-#define	WT_STAT_CONN_TXN_BEGIN				1457
+#define	WT_STAT_CONN_TXN_BEGIN				1478
 /*! transaction: transaction checkpoint currently running */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1458
+#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1479
 /*!
  * transaction: transaction checkpoint currently running for history
  * store file
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING_HS		1459
+#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING_HS		1480
 /*! transaction: transaction checkpoint generation */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_GENERATION		1460
+#define	WT_STAT_CONN_TXN_CHECKPOINT_GENERATION		1481
 /*!
  * transaction: transaction checkpoint history store file duration
  * (usecs)
  */
-#define	WT_STAT_CONN_TXN_HS_CKPT_DURATION		1461
+#define	WT_STAT_CONN_TXN_HS_CKPT_DURATION		1482
 /*! transaction: transaction checkpoint max time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1462
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1483
 /*! transaction: transaction checkpoint min time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1463
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1484
 /*!
  * transaction: transaction checkpoint most recent duration for gathering
  * all handles (usecs)
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION	1464
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION	1485
 /*!
  * transaction: transaction checkpoint most recent duration for gathering
  * applied handles (usecs)
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_APPLY	1465
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_APPLY	1486
 /*!
  * transaction: transaction checkpoint most recent duration for gathering
  * skipped handles (usecs)
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_SKIP	1466
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_DURATION_SKIP	1487
 /*! transaction: transaction checkpoint most recent handles applied */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_APPLIED	1467
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_APPLIED	1488
 /*! transaction: transaction checkpoint most recent handles skipped */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_SKIPPED	1468
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_SKIPPED	1489
 /*! transaction: transaction checkpoint most recent handles walked */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_WALKED	1469
+#define	WT_STAT_CONN_TXN_CHECKPOINT_HANDLE_WALKED	1490
 /*! transaction: transaction checkpoint most recent time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1470
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1491
 /*! transaction: transaction checkpoint prepare currently running */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_RUNNING	1471
+#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_RUNNING	1492
 /*! transaction: transaction checkpoint prepare max time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_MAX		1472
+#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_MAX		1493
 /*! transaction: transaction checkpoint prepare min time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_MIN		1473
+#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_MIN		1494
 /*! transaction: transaction checkpoint prepare most recent time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_RECENT		1474
+#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_RECENT		1495
 /*! transaction: transaction checkpoint prepare total time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_TOTAL		1475
+#define	WT_STAT_CONN_TXN_CHECKPOINT_PREP_TOTAL		1496
 /*! transaction: transaction checkpoint scrub dirty target */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET	1476
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET	1497
 /*! transaction: transaction checkpoint scrub time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME		1477
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME		1498
 /*! transaction: transaction checkpoint total time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1478
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1499
 /*! transaction: transaction checkpoints */
-#define	WT_STAT_CONN_TXN_CHECKPOINT			1479
+#define	WT_STAT_CONN_TXN_CHECKPOINT			1500
 /*! transaction: transaction checkpoints due to obsolete pages */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_OBSOLETE_APPLIED	1480
+#define	WT_STAT_CONN_TXN_CHECKPOINT_OBSOLETE_APPLIED	1501
 /*!
  * transaction: transaction checkpoints skipped because database was
  * clean
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED		1481
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED		1502
 /*! transaction: transaction failures due to history store */
-#define	WT_STAT_CONN_TXN_FAIL_CACHE			1482
+#define	WT_STAT_CONN_TXN_FAIL_CACHE			1503
 /*!
  * transaction: transaction fsync calls for checkpoint after allocating
  * the transaction ID
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST		1483
+#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST		1504
 /*!
  * transaction: transaction fsync duration for checkpoint after
  * allocating the transaction ID (usecs)
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION	1484
+#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION	1505
 /*! transaction: transaction range of IDs currently pinned */
-#define	WT_STAT_CONN_TXN_PINNED_RANGE			1485
+#define	WT_STAT_CONN_TXN_PINNED_RANGE			1506
 /*! transaction: transaction range of IDs currently pinned by a checkpoint */
-#define	WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE	1486
+#define	WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE	1507
 /*! transaction: transaction range of timestamps currently pinned */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP		1487
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP		1508
 /*! transaction: transaction range of timestamps pinned by a checkpoint */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT	1488
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT	1509
 /*!
  * transaction: transaction range of timestamps pinned by the oldest
  * active read timestamp
  */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER	1489
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER	1510
 /*!
  * transaction: transaction range of timestamps pinned by the oldest
  * timestamp
  */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST	1490
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST	1511
 /*! transaction: transaction read timestamp of the oldest active reader */
-#define	WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ	1491
+#define	WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ	1512
 /*! transaction: transaction rollback to stable currently running */
-#define	WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE_RUNNING	1492
+#define	WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE_RUNNING	1513
 /*! transaction: transaction walk of concurrent sessions */
-#define	WT_STAT_CONN_TXN_WALK_SESSIONS			1493
+#define	WT_STAT_CONN_TXN_WALK_SESSIONS			1514
 /*! transaction: transactions committed */
-#define	WT_STAT_CONN_TXN_COMMIT				1494
+#define	WT_STAT_CONN_TXN_COMMIT				1515
 /*! transaction: transactions rolled back */
-#define	WT_STAT_CONN_TXN_ROLLBACK			1495
+#define	WT_STAT_CONN_TXN_ROLLBACK			1516
 /*! transaction: update conflicts */
-#define	WT_STAT_CONN_TXN_UPDATE_CONFLICT		1496
+#define	WT_STAT_CONN_TXN_UPDATE_CONFLICT		1517
 
 /*!
  * @}
@@ -6649,245 +6760,259 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection);
 #define	WT_STAT_DSRC_COMPRESS_READ			2133
 /*! compression: compressed pages written */
 #define	WT_STAT_DSRC_COMPRESS_WRITE			2134
+/*! compression: number of blocks with compress ratio greater than 64 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_MAX		2135
+/*! compression: number of blocks with compress ratio smaller than 16 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_16		2136
+/*! compression: number of blocks with compress ratio smaller than 2 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_2		2137
+/*! compression: number of blocks with compress ratio smaller than 32 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_32		2138
+/*! compression: number of blocks with compress ratio smaller than 4 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_4		2139
+/*! compression: number of blocks with compress ratio smaller than 64 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_64		2140
+/*! compression: number of blocks with compress ratio smaller than 8 */
+#define	WT_STAT_DSRC_COMPRESS_HIST_RATIO_8		2141
 /*! compression: page written failed to compress */
-#define	WT_STAT_DSRC_COMPRESS_WRITE_FAIL		2135
+#define	WT_STAT_DSRC_COMPRESS_WRITE_FAIL		2142
 /*! compression: page written was too small to compress */
-#define	WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL		2136
+#define	WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL		2143
 /*! cursor: Total number of entries skipped by cursor next calls */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_TOTAL		2137
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_TOTAL		2144
 /*! cursor: Total number of entries skipped by cursor prev calls */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_TOTAL		2138
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_TOTAL		2145
 /*!
  * cursor: Total number of entries skipped to position the history store
  * cursor
  */
-#define	WT_STAT_DSRC_CURSOR_SKIP_HS_CUR_POSITION	2139
+#define	WT_STAT_DSRC_CURSOR_SKIP_HS_CUR_POSITION	2146
 /*!
  * cursor: Total number of times a search near has exited due to prefix
  * config
  */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	2140
+#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS	2147
 /*! cursor: bulk loaded cursor insert calls */
-#define	WT_STAT_DSRC_CURSOR_INSERT_BULK			2141
+#define	WT_STAT_DSRC_CURSOR_INSERT_BULK			2148
 /*! cursor: cache cursors reuse count */
-#define	WT_STAT_DSRC_CURSOR_REOPEN			2142
+#define	WT_STAT_DSRC_CURSOR_REOPEN			2149
 /*! cursor: close calls that result in cache */
-#define	WT_STAT_DSRC_CURSOR_CACHE			2143
+#define	WT_STAT_DSRC_CURSOR_CACHE			2150
 /*! cursor: create calls */
-#define	WT_STAT_DSRC_CURSOR_CREATE			2144
+#define	WT_STAT_DSRC_CURSOR_CREATE			2151
 /*!
  * cursor: cursor next calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_DSRC_CURSOR_NEXT_HS_TOMBSTONE		2145
+#define	WT_STAT_DSRC_CURSOR_NEXT_HS_TOMBSTONE		2152
 /*!
  * cursor: cursor next calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_GE_100		2146
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_GE_100		2153
 /*! cursor: cursor next calls that skip less than 100 entries */
-#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_LT_100		2147
+#define	WT_STAT_DSRC_CURSOR_NEXT_SKIP_LT_100		2154
 /*!
  * cursor: cursor prev calls that skip due to a globally visible history
  * store tombstone
  */
-#define	WT_STAT_DSRC_CURSOR_PREV_HS_TOMBSTONE		2148
+#define	WT_STAT_DSRC_CURSOR_PREV_HS_TOMBSTONE		2155
 /*!
  * cursor: cursor prev calls that skip greater than or equal to 100
  * entries
  */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_GE_100		2149
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_GE_100		2156
 /*! cursor: cursor prev calls that skip less than 100 entries */
-#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_LT_100		2150
+#define	WT_STAT_DSRC_CURSOR_PREV_SKIP_LT_100		2157
 /*! cursor: insert calls */
-#define	WT_STAT_DSRC_CURSOR_INSERT			2151
+#define	WT_STAT_DSRC_CURSOR_INSERT			2158
 /*! cursor: insert key and value bytes */
-#define	WT_STAT_DSRC_CURSOR_INSERT_BYTES		2152
+#define	WT_STAT_DSRC_CURSOR_INSERT_BYTES		2159
 /*! cursor: modify */
-#define	WT_STAT_DSRC_CURSOR_MODIFY			2153
+#define	WT_STAT_DSRC_CURSOR_MODIFY			2160
 /*! cursor: modify key and value bytes affected */
-#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES		2154
+#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES		2161
 /*! cursor: modify value bytes modified */
-#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH		2155
+#define	WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH		2162
 /*! cursor: next calls */
-#define	WT_STAT_DSRC_CURSOR_NEXT			2156
+#define	WT_STAT_DSRC_CURSOR_NEXT			2163
 /*! cursor: open cursor count */
-#define	WT_STAT_DSRC_CURSOR_OPEN_COUNT			2157
+#define	WT_STAT_DSRC_CURSOR_OPEN_COUNT			2164
 /*! cursor: operation restarted */
-#define	WT_STAT_DSRC_CURSOR_RESTART			2158
+#define	WT_STAT_DSRC_CURSOR_RESTART			2165
 /*! cursor: prev calls */
-#define	WT_STAT_DSRC_CURSOR_PREV			2159
+#define	WT_STAT_DSRC_CURSOR_PREV			2166
 /*! cursor: remove calls */
-#define	WT_STAT_DSRC_CURSOR_REMOVE			2160
+#define	WT_STAT_DSRC_CURSOR_REMOVE			2167
 /*! cursor: remove key bytes removed */
-#define	WT_STAT_DSRC_CURSOR_REMOVE_BYTES		2161
+#define	WT_STAT_DSRC_CURSOR_REMOVE_BYTES		2168
 /*! cursor: reserve calls */
-#define	WT_STAT_DSRC_CURSOR_RESERVE			2162
+#define	WT_STAT_DSRC_CURSOR_RESERVE			2169
 /*! cursor: reset calls */
-#define	WT_STAT_DSRC_CURSOR_RESET			2163
+#define	WT_STAT_DSRC_CURSOR_RESET			2170
 /*! cursor: search calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH			2164
+#define	WT_STAT_DSRC_CURSOR_SEARCH			2171
 /*! cursor: search history store calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_HS			2165
+#define	WT_STAT_DSRC_CURSOR_SEARCH_HS			2172
 /*! cursor: search near calls */
-#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR			2166
+#define	WT_STAT_DSRC_CURSOR_SEARCH_NEAR			2173
 /*! cursor: truncate calls */
-#define	WT_STAT_DSRC_CURSOR_TRUNCATE			2167
+#define	WT_STAT_DSRC_CURSOR_TRUNCATE			2174
 /*! cursor: update calls */
-#define	WT_STAT_DSRC_CURSOR_UPDATE			2168
+#define	WT_STAT_DSRC_CURSOR_UPDATE			2175
 /*! cursor: update key and value bytes */
-#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES		2169
+#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES		2176
 /*! cursor: update value size change */
-#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED	2170
+#define	WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED	2177
 /*! reconciliation: approximate byte size of timestamps in pages written */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TS		2171
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TS		2178
 /*!
  * reconciliation: approximate byte size of transaction IDs in pages
  * written
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TXN		2172
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TXN		2179
 /*! reconciliation: dictionary matches */
-#define	WT_STAT_DSRC_REC_DICTIONARY			2173
+#define	WT_STAT_DSRC_REC_DICTIONARY			2180
 /*! reconciliation: fast-path pages deleted */
-#define	WT_STAT_DSRC_REC_PAGE_DELETE_FAST		2174
+#define	WT_STAT_DSRC_REC_PAGE_DELETE_FAST		2181
 /*!
  * reconciliation: internal page key bytes discarded using suffix
  * compression
  */
-#define	WT_STAT_DSRC_REC_SUFFIX_COMPRESSION		2175
+#define	WT_STAT_DSRC_REC_SUFFIX_COMPRESSION		2182
 /*! reconciliation: internal page multi-block writes */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL		2176
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL		2183
 /*! reconciliation: internal-page overflow keys */
-#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_INTERNAL		2177
+#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_INTERNAL		2184
 /*! reconciliation: leaf page key bytes discarded using prefix compression */
-#define	WT_STAT_DSRC_REC_PREFIX_COMPRESSION		2178
+#define	WT_STAT_DSRC_REC_PREFIX_COMPRESSION		2185
 /*! reconciliation: leaf page multi-block writes */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_LEAF		2179
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_LEAF		2186
 /*! reconciliation: leaf-page overflow keys */
-#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF		2180
+#define	WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF		2187
 /*! reconciliation: maximum blocks required for a page */
-#define	WT_STAT_DSRC_REC_MULTIBLOCK_MAX			2181
+#define	WT_STAT_DSRC_REC_MULTIBLOCK_MAX			2188
 /*! reconciliation: overflow values written */
-#define	WT_STAT_DSRC_REC_OVERFLOW_VALUE			2182
+#define	WT_STAT_DSRC_REC_OVERFLOW_VALUE			2189
 /*! reconciliation: page checksum matches */
-#define	WT_STAT_DSRC_REC_PAGE_MATCH			2183
+#define	WT_STAT_DSRC_REC_PAGE_MATCH			2190
 /*! reconciliation: page reconciliation calls */
-#define	WT_STAT_DSRC_REC_PAGES				2184
+#define	WT_STAT_DSRC_REC_PAGES				2191
 /*! reconciliation: page reconciliation calls for eviction */
-#define	WT_STAT_DSRC_REC_PAGES_EVICTION			2185
+#define	WT_STAT_DSRC_REC_PAGES_EVICTION			2192
 /*! reconciliation: pages deleted */
-#define	WT_STAT_DSRC_REC_PAGE_DELETE			2186
+#define	WT_STAT_DSRC_REC_PAGE_DELETE			2193
 /*!
  * reconciliation: pages written including an aggregated newest start
  * durable timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	2187
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_START_DURABLE_TS	2194
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * durable timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	2188
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS	2195
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TS	2189
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TS	2196
 /*!
  * reconciliation: pages written including an aggregated newest stop
  * transaction ID
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TXN	2190
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TXN	2197
 /*!
  * reconciliation: pages written including an aggregated newest
  * transaction ID
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_TXN		2191
+#define	WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_TXN		2198
 /*!
  * reconciliation: pages written including an aggregated oldest start
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_OLDEST_START_TS	2192
+#define	WT_STAT_DSRC_REC_TIME_AGGR_OLDEST_START_TS	2199
 /*! reconciliation: pages written including an aggregated prepare */
-#define	WT_STAT_DSRC_REC_TIME_AGGR_PREPARED		2193
+#define	WT_STAT_DSRC_REC_TIME_AGGR_PREPARED		2200
 /*! reconciliation: pages written including at least one prepare */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_PREPARED	2194
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_PREPARED	2201
 /*!
  * reconciliation: pages written including at least one start durable
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	2195
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_START_TS	2202
 /*! reconciliation: pages written including at least one start timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TS	2196
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TS	2203
 /*!
  * reconciliation: pages written including at least one start transaction
  * ID
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TXN	2197
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TXN	2204
 /*!
  * reconciliation: pages written including at least one stop durable
  * timestamp
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	2198
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS	2205
 /*! reconciliation: pages written including at least one stop timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TS	2199
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TS	2206
 /*!
  * reconciliation: pages written including at least one stop transaction
  * ID
  */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TXN	2200
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TXN	2207
 /*! reconciliation: records written including a prepare */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_PREPARED		2201
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_PREPARED		2208
 /*! reconciliation: records written including a start durable timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_START_TS	2202
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_START_TS	2209
 /*! reconciliation: records written including a start timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TS		2203
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TS		2210
 /*! reconciliation: records written including a start transaction ID */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TXN		2204
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_START_TXN		2211
 /*! reconciliation: records written including a stop durable timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_STOP_TS	2205
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_STOP_TS	2212
 /*! reconciliation: records written including a stop timestamp */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TS		2206
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TS		2213
 /*! reconciliation: records written including a stop transaction ID */
-#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TXN		2207
+#define	WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TXN		2214
 /*! session: object compaction */
-#define	WT_STAT_DSRC_SESSION_COMPACT			2208
+#define	WT_STAT_DSRC_SESSION_COMPACT			2215
 /*! session: tiered operations dequeued and processed */
-#define	WT_STAT_DSRC_TIERED_WORK_UNITS_DEQUEUED		2209
+#define	WT_STAT_DSRC_TIERED_WORK_UNITS_DEQUEUED		2216
 /*! session: tiered operations scheduled */
-#define	WT_STAT_DSRC_TIERED_WORK_UNITS_CREATED		2210
+#define	WT_STAT_DSRC_TIERED_WORK_UNITS_CREATED		2217
 /*! session: tiered storage local retention time (secs) */
-#define	WT_STAT_DSRC_TIERED_RETENTION			2211
+#define	WT_STAT_DSRC_TIERED_RETENTION			2218
 /*! session: tiered storage object size */
-#define	WT_STAT_DSRC_TIERED_OBJECT_SIZE			2212
+#define	WT_STAT_DSRC_TIERED_OBJECT_SIZE			2219
 /*! transaction: race to read prepared update retry */
-#define	WT_STAT_DSRC_TXN_READ_RACE_PREPARE_UPDATE	2213
+#define	WT_STAT_DSRC_TXN_READ_RACE_PREPARE_UPDATE	2220
 /*!
  * 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	2214
+#define	WT_STAT_DSRC_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START	2221
 /*! transaction: rollback to stable inconsistent checkpoint */
-#define	WT_STAT_DSRC_TXN_RTS_INCONSISTENT_CKPT		2215
+#define	WT_STAT_DSRC_TXN_RTS_INCONSISTENT_CKPT		2222
 /*! transaction: rollback to stable keys removed */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED		2216
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED		2223
 /*! transaction: rollback to stable keys restored */
-#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED		2217
+#define	WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED		2224
 /*! transaction: rollback to stable restored tombstones from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES	2218
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES	2225
 /*! transaction: rollback to stable restored updates from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES		2219
+#define	WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES		2226
 /*! transaction: rollback to stable skipping delete rle */
-#define	WT_STAT_DSRC_TXN_RTS_DELETE_RLE_SKIPPED		2220
+#define	WT_STAT_DSRC_TXN_RTS_DELETE_RLE_SKIPPED		2227
 /*! transaction: rollback to stable skipping stable rle */
-#define	WT_STAT_DSRC_TXN_RTS_STABLE_RLE_SKIPPED		2221
+#define	WT_STAT_DSRC_TXN_RTS_STABLE_RLE_SKIPPED		2228
 /*! transaction: rollback to stable sweeping history store keys */
-#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS		2222
+#define	WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS		2229
 /*! transaction: rollback to stable updates removed from history store */
-#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED			2223
+#define	WT_STAT_DSRC_TXN_RTS_HS_REMOVED			2230
 /*! transaction: transaction checkpoints due to obsolete pages */
-#define	WT_STAT_DSRC_TXN_CHECKPOINT_OBSOLETE_APPLIED	2224
+#define	WT_STAT_DSRC_TXN_CHECKPOINT_OBSOLETE_APPLIED	2231
 /*! transaction: update conflicts */
-#define	WT_STAT_DSRC_TXN_UPDATE_CONFLICT		2225
+#define	WT_STAT_DSRC_TXN_UPDATE_CONFLICT		2232
 
 /*!
  * @}
diff --git a/src/third_party/wiredtiger/src/include/wt_internal.h b/src/third_party/wiredtiger/src/include/wt_internal.h
index 72c2b194f52..430c1382846 100644
--- a/src/third_party/wiredtiger/src/include/wt_internal.h
+++ b/src/third_party/wiredtiger/src/include/wt_internal.h
@@ -69,6 +69,14 @@ struct __wt_addr;
 typedef struct __wt_addr WT_ADDR;
 struct __wt_addr_copy;
 typedef struct __wt_addr_copy WT_ADDR_COPY;
+struct __wt_blkcache;
+typedef struct __wt_blkcache WT_BLKCACHE;
+struct __wt_blkcache_bucket_metadata;
+typedef struct __wt_blkcache_bucket_metadata WT_BLKCACHE_BUCKET_METADATA;
+struct __wt_blkcache_id;
+typedef struct __wt_blkcache_id WT_BLKCACHE_ID;
+struct __wt_blkcache_item;
+typedef struct __wt_blkcache_item WT_BLKCACHE_ITEM;
 struct __wt_blkincr;
 typedef struct __wt_blkincr WT_BLKINCR;
 struct __wt_block;
@@ -403,6 +411,7 @@ typedef uint64_t wt_timestamp_t;
 
 #include "api.h"
 #include "block.h"
+#include "block_cache.h"
 #include "bloom.h"
 #include "btmem.h"
 #include "btree.h"
diff --git a/src/third_party/wiredtiger/src/os_win/os_once.c b/src/third_party/wiredtiger/src/os_win/os_once.c
index da02db7ae85..5a8da364885 100644
--- a/src/third_party/wiredtiger/src/os_win/os_once.c
+++ b/src/third_party/wiredtiger/src/os_win/os_once.c
@@ -36,5 +36,5 @@ __wt_once(void (*init_routine)(void))
     INIT_ONCE once_control = INIT_ONCE_STATIC_INIT;
     PVOID lpContext = NULL;
 
-    return !InitOnceExecuteOnce(&once_control, &__wt_init_once_callback, init_routine, lpContext);
+    return (!InitOnceExecuteOnce(&once_control, &__wt_init_once_callback, init_routine, lpContext));
 }
diff --git a/src/third_party/wiredtiger/src/support/float.c b/src/third_party/wiredtiger/src/support/float.c
new file mode 100644
index 00000000000..93bec6da69a
--- /dev/null
+++ b/src/third_party/wiredtiger/src/support/float.c
@@ -0,0 +1,45 @@
+/*-
+ * 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.
+ */
+
+#include "wt_internal.h"
+#include <math.h>
+/*
+ * __wt_floatcmp --
+ *     Compares floats in a way that does not generate compiler warnings. Returns an integer greater
+ *     than, equal to, or less than 0, according to d1 being greater than, equal to, or less than
+ *     d2.
+ */
+int
+__wt_floatcmp(float f1, float f2)
+{
+#define WT_FLOAT_PRECISION 1000
+    if (fabsf(f1 - f2) < 1 / WT_FLOAT_PRECISION)
+        return (0);
+    else
+        return (int)((f1 - f2) * WT_FLOAT_PRECISION);
+}
diff --git a/src/third_party/wiredtiger/src/support/lock_ext.c b/src/third_party/wiredtiger/src/support/lock_ext.c
index 38d338892c1..e9d99aefe13 100644
--- a/src/third_party/wiredtiger/src/support/lock_ext.c
+++ b/src/third_party/wiredtiger/src/support/lock_ext.c
@@ -22,10 +22,10 @@ __wt_ext_spin_init(WT_EXTENSION_API *wt_api, WT_EXTENSION_SPINLOCK *ext_spinlock
     ext_spinlock->spinlock = NULL;
     default_session = ((WT_CONNECTION_IMPL *)wt_api->conn)->default_session;
     if ((ret = __wt_calloc_one(default_session, &lock)) != 0)
-        return ret;
+        return (ret);
     if ((ret = __wt_spin_init(default_session, lock, name)) != 0) {
         __wt_free(default_session, lock);
-        return ret;
+        return (ret);
     }
     ext_spinlock->spinlock = lock;
     return (0);
@@ -44,7 +44,6 @@ __wt_ext_spin_lock(
     WT_UNUSED(wt_api); /* Unused parameters */
     lock = ((WT_SPINLOCK *)ext_spinlock->spinlock);
     __wt_spin_lock((WT_SESSION_IMPL *)session, lock);
-    return;
 }
 
 /*
@@ -60,7 +59,6 @@ __wt_ext_spin_unlock(
     WT_UNUSED(wt_api); /* Unused parameters */
     lock = ((WT_SPINLOCK *)ext_spinlock->spinlock);
     __wt_spin_unlock((WT_SESSION_IMPL *)session, lock);
-    return;
 }
 
 /*
@@ -80,5 +78,4 @@ __wt_ext_spin_destroy(WT_EXTENSION_API *wt_api, WT_EXTENSION_SPINLOCK *ext_spinl
     __wt_spin_destroy(default_session, lock);
     __wt_free(default_session, lock);
     ext_spinlock->spinlock = NULL;
-    return;
 }
diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c
index 43527b9092a..3fa21dfebef 100644
--- a/src/third_party/wiredtiger/src/support/stat.c
+++ b/src/third_party/wiredtiger/src/support/stat.c
@@ -147,6 +147,13 @@ static const char *const __stats_dsrc_desc[] = {
   "compression: compressed page maximum leaf page size prior to compression ",
   "compression: compressed pages read",
   "compression: compressed pages written",
+  "compression: number of blocks with compress ratio greater than 64",
+  "compression: number of blocks with compress ratio smaller than 16",
+  "compression: number of blocks with compress ratio smaller than 2",
+  "compression: number of blocks with compress ratio smaller than 32",
+  "compression: number of blocks with compress ratio smaller than 4",
+  "compression: number of blocks with compress ratio smaller than 64",
+  "compression: number of blocks with compress ratio smaller than 8",
   "compression: page written failed to compress",
   "compression: page written was too small to compress",
   "cursor: Total number of entries skipped by cursor next calls",
@@ -414,6 +421,13 @@ __wt_stat_dsrc_clear_single(WT_DSRC_STATS *stats)
     /* not clearing compress_precomp_leaf_max_page_size */
     stats->compress_read = 0;
     stats->compress_write = 0;
+    stats->compress_hist_ratio_max = 0;
+    stats->compress_hist_ratio_16 = 0;
+    stats->compress_hist_ratio_2 = 0;
+    stats->compress_hist_ratio_32 = 0;
+    stats->compress_hist_ratio_4 = 0;
+    stats->compress_hist_ratio_64 = 0;
+    stats->compress_hist_ratio_8 = 0;
     stats->compress_write_fail = 0;
     stats->compress_write_too_small = 0;
     stats->cursor_next_skip_total = 0;
@@ -670,6 +684,13 @@ __wt_stat_dsrc_aggregate_single(WT_DSRC_STATS *from, WT_DSRC_STATS *to)
     to->compress_precomp_leaf_max_page_size += from->compress_precomp_leaf_max_page_size;
     to->compress_read += from->compress_read;
     to->compress_write += from->compress_write;
+    to->compress_hist_ratio_max += from->compress_hist_ratio_max;
+    to->compress_hist_ratio_16 += from->compress_hist_ratio_16;
+    to->compress_hist_ratio_2 += from->compress_hist_ratio_2;
+    to->compress_hist_ratio_32 += from->compress_hist_ratio_32;
+    to->compress_hist_ratio_4 += from->compress_hist_ratio_4;
+    to->compress_hist_ratio_64 += from->compress_hist_ratio_64;
+    to->compress_hist_ratio_8 += from->compress_hist_ratio_8;
     to->compress_write_fail += from->compress_write_fail;
     to->compress_write_too_small += from->compress_write_too_small;
     to->cursor_next_skip_total += from->cursor_next_skip_total;
@@ -930,6 +951,13 @@ __wt_stat_dsrc_aggregate(WT_DSRC_STATS **from, WT_DSRC_STATS *to)
       WT_STAT_READ(from, compress_precomp_leaf_max_page_size);
     to->compress_read += WT_STAT_READ(from, compress_read);
     to->compress_write += WT_STAT_READ(from, compress_write);
+    to->compress_hist_ratio_max += WT_STAT_READ(from, compress_hist_ratio_max);
+    to->compress_hist_ratio_16 += WT_STAT_READ(from, compress_hist_ratio_16);
+    to->compress_hist_ratio_2 += WT_STAT_READ(from, compress_hist_ratio_2);
+    to->compress_hist_ratio_32 += WT_STAT_READ(from, compress_hist_ratio_32);
+    to->compress_hist_ratio_4 += WT_STAT_READ(from, compress_hist_ratio_4);
+    to->compress_hist_ratio_64 += WT_STAT_READ(from, compress_hist_ratio_64);
+    to->compress_hist_ratio_8 += WT_STAT_READ(from, compress_hist_ratio_8);
     to->compress_write_fail += WT_STAT_READ(from, compress_write_fail);
     to->compress_write_too_small += WT_STAT_READ(from, compress_write_too_small);
     to->cursor_next_skip_total += WT_STAT_READ(from, cursor_next_skip_total);
@@ -1041,6 +1069,27 @@ static const char *const __stats_connection_desc[] = {
   "LSM: tree maintenance operations executed",
   "LSM: tree maintenance operations scheduled",
   "LSM: tree queue hit maximum",
+  "block-manager: block cache cached blocks updated",
+  "block-manager: block cache cached bytes updated",
+  "block-manager: block cache evicted blocks",
+  "block-manager: block cache file size causing bypass",
+  "block-manager: block cache lookups",
+  "block-manager: block cache number of blocks not evicted due to overhead",
+  "block-manager: block cache number of bypasses because no-write-allocate setting was on",
+  "block-manager: block cache number of bypasses due to overhead on put",
+  "block-manager: block cache number of bypasses on get",
+  "block-manager: block cache number of bypasses on put because file is too small",
+  "block-manager: block cache number of eviction passes",
+  "block-manager: block cache number of hits including existence checks",
+  "block-manager: block cache number of misses including existence checks",
+  "block-manager: block cache number of put bypasses on checkpoint I/O",
+  "block-manager: block cache removed blocks",
+  "block-manager: block cache total blocks",
+  "block-manager: block cache total blocks inserted on read path",
+  "block-manager: block cache total blocks inserted on write path",
+  "block-manager: block cache total bytes",
+  "block-manager: block cache total bytes inserted on read path",
+  "block-manager: block cache total bytes inserted on write path",
   "block-manager: blocks pre-loaded",
   "block-manager: blocks read",
   "block-manager: blocks written",
@@ -1595,6 +1644,27 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats)
     stats->lsm_work_units_done = 0;
     stats->lsm_work_units_created = 0;
     stats->lsm_work_queue_max = 0;
+    stats->block_cache_blocks_update = 0;
+    stats->block_cache_bytes_update = 0;
+    stats->block_cache_blocks_evicted = 0;
+    stats->block_cache_bypass_filesize = 0;
+    stats->block_cache_data_refs = 0;
+    stats->block_cache_not_evicted_overhead = 0;
+    stats->block_cache_bypass_writealloc = 0;
+    stats->block_cache_bypass_overhead_put = 0;
+    stats->block_cache_bypass_get = 0;
+    stats->block_cache_bypass_put = 0;
+    stats->block_cache_eviction_passes = 0;
+    stats->block_cache_hits = 0;
+    stats->block_cache_misses = 0;
+    stats->block_cache_bypass_chkpt = 0;
+    stats->block_cache_blocks_removed = 0;
+    stats->block_cache_blocks = 0;
+    stats->block_cache_blocks_insert_read = 0;
+    stats->block_cache_blocks_insert_write = 0;
+    stats->block_cache_bytes = 0;
+    stats->block_cache_bytes_insert_read = 0;
+    stats->block_cache_bytes_insert_write = 0;
     stats->block_preload = 0;
     stats->block_read = 0;
     stats->block_write = 0;
@@ -2108,6 +2178,27 @@ __wt_stat_connection_aggregate(WT_CONNECTION_STATS **from, WT_CONNECTION_STATS *
     to->lsm_work_units_done += WT_STAT_READ(from, lsm_work_units_done);
     to->lsm_work_units_created += WT_STAT_READ(from, lsm_work_units_created);
     to->lsm_work_queue_max += WT_STAT_READ(from, lsm_work_queue_max);
+    to->block_cache_blocks_update += WT_STAT_READ(from, block_cache_blocks_update);
+    to->block_cache_bytes_update += WT_STAT_READ(from, block_cache_bytes_update);
+    to->block_cache_blocks_evicted += WT_STAT_READ(from, block_cache_blocks_evicted);
+    to->block_cache_bypass_filesize += WT_STAT_READ(from, block_cache_bypass_filesize);
+    to->block_cache_data_refs += WT_STAT_READ(from, block_cache_data_refs);
+    to->block_cache_not_evicted_overhead += WT_STAT_READ(from, block_cache_not_evicted_overhead);
+    to->block_cache_bypass_writealloc += WT_STAT_READ(from, block_cache_bypass_writealloc);
+    to->block_cache_bypass_overhead_put += WT_STAT_READ(from, block_cache_bypass_overhead_put);
+    to->block_cache_bypass_get += WT_STAT_READ(from, block_cache_bypass_get);
+    to->block_cache_bypass_put += WT_STAT_READ(from, block_cache_bypass_put);
+    to->block_cache_eviction_passes += WT_STAT_READ(from, block_cache_eviction_passes);
+    to->block_cache_hits += WT_STAT_READ(from, block_cache_hits);
+    to->block_cache_misses += WT_STAT_READ(from, block_cache_misses);
+    to->block_cache_bypass_chkpt += WT_STAT_READ(from, block_cache_bypass_chkpt);
+    to->block_cache_blocks_removed += WT_STAT_READ(from, block_cache_blocks_removed);
+    to->block_cache_blocks += WT_STAT_READ(from, block_cache_blocks);
+    to->block_cache_blocks_insert_read += WT_STAT_READ(from, block_cache_blocks_insert_read);
+    to->block_cache_blocks_insert_write += WT_STAT_READ(from, block_cache_blocks_insert_write);
+    to->block_cache_bytes += WT_STAT_READ(from, block_cache_bytes);
+    to->block_cache_bytes_insert_read += WT_STAT_READ(from, block_cache_bytes_insert_read);
+    to->block_cache_bytes_insert_write += WT_STAT_READ(from, block_cache_bytes_insert_write);
     to->block_preload += WT_STAT_READ(from, block_preload);
     to->block_read += WT_STAT_READ(from, block_read);
     to->block_write += WT_STAT_READ(from, block_write);
diff --git a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
index cc6888e80d7..6b85d469c96 100644
--- a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
+++ b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
@@ -998,9 +998,8 @@ static wt_timestamp_t
 __rollback_get_ref_max_durable_timestamp(WT_SESSION_IMPL *session, WT_TIME_AGGREGATE *ta)
 {
     if (WT_IS_HS(session->dhandle))
-        return WT_MAX(ta->newest_stop_durable_ts, ta->newest_stop_ts);
-    else
-        return WT_MAX(ta->newest_start_durable_ts, ta->newest_stop_durable_ts);
+        return (WT_MAX(ta->newest_stop_durable_ts, ta->newest_stop_ts));
+    return (WT_MAX(ta->newest_start_durable_ts, ta->newest_stop_durable_ts));
 }
 
 /*
diff --git a/src/third_party/wiredtiger/src/utilities/util_dump.c b/src/third_party/wiredtiger/src/utilities/util_dump.c
index 727cf132ffc..77aa5697370 100755
--- a/src/third_party/wiredtiger/src/utilities/util_dump.c
+++ b/src/third_party/wiredtiger/src/utilities/util_dump.c
@@ -590,7 +590,7 @@ get_dump_type(bool pretty, bool hex, bool json)
     else
         result = "print";
 
-    return result;
+    return (result);
 }
 
 /*
diff --git a/src/third_party/wiredtiger/test/format/config.c b/src/third_party/wiredtiger/test/format/config.c
index 6cf7c795774..5d1e205f37e 100644
--- a/src/third_party/wiredtiger/test/format/config.c
+++ b/src/third_party/wiredtiger/test/format/config.c
@@ -455,12 +455,11 @@ config_cache(void)
     g.c_cache = WT_MAX(g.c_cache, 2 * workers * g.c_memory_page_max);
 
     /*
-     * Ensure cache size sanity for LSM runs. An LSM tree open requires 3
-     * chunks plus a page for each participant in up to three concurrent
-     * merges. Integrate a thread count into that calculation by requiring
-     * 3 chunks/pages per configured thread. That might be overkill, but
-     * LSM runs are more sensitive to small caches than other runs, and a
-     * generous cache avoids stalls we're not interested in chasing.
+     * Ensure cache size sanity for LSM runs. An LSM tree open requires 3 chunks plus a page for
+     * each participant in up to three concurrent merges. Integrate a thread count into that
+     * calculation by requiring 3 chunks/pages per configured thread. That might be overkill, but
+     * LSM runs are more sensitive to small caches than other runs, and a generous cache avoids
+     * stalls we're not interested in chasing.
      */
     if (DATASOURCE("lsm")) {
         required = WT_LSM_TREE_MINIMUM_SIZE(
diff --git a/src/third_party/wiredtiger/test/format/config.h b/src/third_party/wiredtiger/test/format/config.h
index d12c30ed756..f835ed02123 100644
--- a/src/third_party/wiredtiger/test/format/config.h
+++ b/src/third_party/wiredtiger/test/format/config.h
@@ -77,6 +77,20 @@ static CONFIG c[] = {
   {"backup.incr_granularity", "incremental backup block granularity (KB)", 0x0, 4, 16384, 16384,
     &g.c_backup_incr_granularity, NULL},
 
+  /* 10% */
+  {"block_cache", "enable the block cache", C_BOOL, 10, 0, 0, &g.c_block_cache, NULL},
+
+  /* 30 */
+  {"block_cache.cache_on_checkpoint", "block cache: cache checkpoint writes", C_BOOL, 30, 0, 0,
+    &g.c_block_cache_cache_on_checkpoint, NULL},
+
+  {"block_cache.size", "block cache size (MB)", 0x0, 1, 100, 100 * 1024, &g.c_block_cache_size,
+    NULL},
+
+  /* 60% */
+  {"block_cache.cache_on_writes", "block cache: populate the cache on writes", C_BOOL, 60, 0, 0,
+    &g.c_block_cache_cache_on_writes, NULL},
+
   {"btree.bitcnt", "fixed-length column-store object size (number of bits)", 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 cce28406706..fe3c6aad840 100644
--- a/src/third_party/wiredtiger/test/format/format.h
+++ b/src/third_party/wiredtiger/test/format/format.h
@@ -182,6 +182,10 @@ typedef struct {
     uint32_t c_backup_incr_granularity;
     uint32_t c_backups;
     uint32_t c_bitcnt;
+    uint32_t c_block_cache;
+    uint32_t c_block_cache_cache_on_checkpoint;
+    uint32_t c_block_cache_cache_on_writes;
+    uint32_t c_block_cache_size;
     uint32_t c_bloom;
     uint32_t c_bloom_bit_count;
     uint32_t c_bloom_hash_count;
diff --git a/src/third_party/wiredtiger/test/format/wts.c b/src/third_party/wiredtiger/test/format/wts.c
index 74027748246..f26ccfac1a6 100644
--- a/src/third_party/wiredtiger/test/format/wts.c
+++ b/src/third_party/wiredtiger/test/format/wts.c
@@ -209,6 +209,16 @@ create_database(const char *home, WT_CONNECTION **connp)
     if (DATASOURCE("lsm") || g.c_cache < 20)
         CONFIG_APPEND(p, ",eviction_dirty_trigger=95");
 
+    /* Block cache */
+    CONFIG_APPEND(p,
+      ",block_cache=(enabled=%s,type=\"dram\""
+      ",cache_on_checkpoint=%s"
+      ",cache_on_writes=%s"
+      ",size=%" PRIu32 "MB)",
+      g.c_block_cache == 0 ? "false" : "true",
+      g.c_block_cache_cache_on_checkpoint == 0 ? "false" : "true",
+      g.c_block_cache_cache_on_writes == 0 ? "false" : "true", g.c_block_cache_size);
+
     /* Eviction worker configuration. */
     if (g.c_evict_max != 0)
         CONFIG_APPEND(p, ",eviction=(threads_max=%" PRIu32 ")", g.c_evict_max);