Import wiredtiger: 88f6cad50464648cda0dbd3a93d91cea616fdc8f from branch mongodb-master

ref: 0c0e78d747..88f6cad504
for: 5.2.0

WT-8273       Restructure the block cache

17 files changed, 299 insertions, 290 deletions

diff --git a/src/third_party/wiredtiger/dist/filelist b/src/third_party/wiredtiger/dist/filelist
index a50ec3d667c..9dae82777b8 100644
--- a/src/third_party/wiredtiger/dist/filelist
+++ b/src/third_party/wiredtiger/dist/filelist
@@ -2,13 +2,11 @@
 #	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
 src/block/block_ext.c
 src/block/block_map.c
-src/block/block_mgr.c
 src/block/block_open.c
 src/block/block_read.c
 src/block/block_session.c
@@ -16,6 +14,8 @@ src/block/block_slvg.c
 src/block/block_tiered.c
 src/block/block_vrfy.c
 src/block/block_write.c
+src/block_cache/block_cache.c
+src/block_cache/block_mgr.c
 src/bloom/bloom.c
 src/btree/bt_compact.c
 src/btree/bt_curnext.c
@@ -51,8 +51,8 @@ src/checksum/arm64/crc32-arm64.c	ARM64_HOST
 src/checksum/power8/crc32.sx		POWERPC_HOST
 src/checksum/power8/crc32_wrapper.c	POWERPC_HOST
 src/checksum/software/checksum.c
-src/checksum/x86/crc32-x86.c		X86_HOST
 src/checksum/x86/crc32-x86-alt.c	X86_HOST
+src/checksum/x86/crc32-x86.c		X86_HOST
 src/checksum/zseries/crc32-s390x.c	ZSERIES_HOST
 src/checksum/zseries/crc32le-vx.sx	ZSERIES_HOST
 src/config/config.c
@@ -100,8 +100,8 @@ src/evict/evict_page.c
 src/evict/evict_stat.c
 src/history/hs_conn.c
 src/history/hs_cursor.c
-src/history/hs_verify.c
 src/history/hs_rec.c
+src/history/hs_verify.c
 src/log/log.c
 src/log/log_auto.c
 src/log/log_slot.c
diff --git a/src/third_party/wiredtiger/dist/s_define.list b/src/third_party/wiredtiger/dist/s_define.list
index 5d329aac55c..1cb6c2c4cac 100644
--- a/src/third_party/wiredtiger/dist/s_define.list
+++ b/src/third_party/wiredtiger/dist/s_define.list
@@ -20,7 +20,6 @@ WT_ATOMIC_CAS
 WT_ATOMIC_CAS_FUNC
 WT_ATOMIC_FUNC
 WT_BACKUP_INVALID
-WT_BLKCACHE_ID_SIZE
 WT_BLOCK_DESC_SIZE
 WT_BLOCK_EXTLIST_VERSION_ORIG
 WT_BLOCK_HEADER_SIZE
diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py
index 1d69498cc01..abe9893c586 100644
--- a/src/third_party/wiredtiger/dist/stat_data.py
+++ b/src/third_party/wiredtiger/dist/stat_data.py
@@ -31,6 +31,10 @@ class Stat:
     def __cmp__(self, other):
         return cmp(self.desc.lower(), other.desc.lower())
 
+class BlockCacheStat(Stat):
+    prefix = 'block-cache'
+    def __init__(self, name, desc, flags=''):
+        Stat.__init__(self, name, BlockCacheStat.prefix, desc, flags)
 class BlockStat(Stat):
     prefix = 'block-manager'
     def __init__(self, name, desc, flags=''):
@@ -129,6 +133,7 @@ class YieldStat(Stat):
 groups = {}
 groups['cursor'] = [CursorStat.prefix, SessionOpStat.prefix]
 groups['evict'] = [
+    BlockCacheStat.prefix,
     BlockStat.prefix,
     CacheStat.prefix,
     CacheWalkStat.prefix,
@@ -177,6 +182,31 @@ conn_stats = [
     ##########################################
     # Block manager statistics
     ##########################################
+    BlockCacheStat('block_cache_blocks', 'total blocks'),
+    BlockCacheStat('block_cache_blocks_evicted', 'evicted blocks'),
+    BlockCacheStat('block_cache_blocks_insert_read', 'total blocks inserted on read path'),
+    BlockCacheStat('block_cache_blocks_insert_write', 'total blocks inserted on write path'),
+    BlockCacheStat('block_cache_blocks_removed', 'removed blocks'),
+    BlockCacheStat('block_cache_blocks_update', 'cached blocks updated'),
+    BlockCacheStat('block_cache_bypass_chkpt', 'number of put bypasses on checkpoint I/O'),
+    BlockCacheStat('block_cache_bypass_filesize', 'file size causing bypass'),
+    BlockCacheStat('block_cache_bypass_get', 'number of bypasses on get'),
+    BlockCacheStat('block_cache_bypass_overhead_put', 'number of bypasses due to overhead on put'),
+    BlockCacheStat('block_cache_bypass_put', 'number of bypasses on put because file is too small'),
+    BlockCacheStat('block_cache_bypass_writealloc', 'number of bypasses because no-write-allocate setting was on'),
+    BlockCacheStat('block_cache_bytes', 'total bytes'),
+    BlockCacheStat('block_cache_bytes_insert_read', 'total bytes inserted on read path'),
+    BlockCacheStat('block_cache_bytes_insert_write', 'total bytes inserted on write path'),
+    BlockCacheStat('block_cache_bytes_update', 'cached bytes updated'),
+    BlockCacheStat('block_cache_eviction_passes', 'number of eviction passes'),
+    BlockCacheStat('block_cache_hits', 'number of hits'),
+    BlockCacheStat('block_cache_lookups', 'lookups'),
+    BlockCacheStat('block_cache_misses', 'number of misses'),
+    BlockCacheStat('block_cache_not_evicted_overhead', 'number of blocks not evicted due to overhead'),
+
+    ##########################################
+    # Block manager statistics
+    ##########################################
     BlockStat('block_byte_map_read', 'mapped bytes read', 'size'),
     BlockStat('block_byte_read', 'bytes read', 'size'),
     BlockStat('block_byte_read_mmap', 'bytes read via memory map API', 'size'),
@@ -185,27 +215,6 @@ 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'),
diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 7c3de840f4e..af7e717ef4d 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": "0c0e78d747547675c479e8fb7e81de0031ff08cd"
+    "commit": "88f6cad50464648cda0dbd3a93d91cea616fdc8f"
 }
diff --git a/src/third_party/wiredtiger/src/block/block_ext.c b/src/third_party/wiredtiger/src/block/block_ext.c
index 32bde280e69..37916e482de 100644
--- a/src/third_party/wiredtiger/src/block/block_ext.c
+++ b/src/third_party/wiredtiger/src/block/block_ext.c
@@ -588,9 +588,6 @@ __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 0ed4c05d7b2..3f3fb1c4e76 100644
--- a/src/third_party/wiredtiger/src/block/block_read.c
+++ b/src/third_party/wiredtiger/src/block/block_read.c
@@ -16,7 +16,6 @@ int
 __wt_bm_preload(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size)
 {
     WT_BLOCK *block;
-    WT_DECL_ITEM(tmp);
     WT_DECL_RET;
     WT_FH *fh;
     WT_FILE_HANDLE *handle;
@@ -41,14 +40,6 @@ __wt_bm_preload(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t
     if (!mapped && handle->fh_advise != NULL)
         ret = handle->fh_advise(
           handle, (WT_SESSION *)session, offset, (wt_off_t)size, WT_FILE_HANDLE_WILLNEED);
-    if (ret != EBUSY && ret != ENOTSUP)
-        return (ret);
-
-    /* If preload isn't supported, do it the slow way. */
-    WT_RET(__wt_scr_alloc(session, 0, &tmp));
-    ret = __wt_bm_read(bm, session, tmp, addr, addr_size);
-    __wt_scr_free(session, &tmp);
-
     return (ret);
 }
 
@@ -217,10 +208,8 @@ __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);
@@ -252,22 +241,8 @@ __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));
-
-    /* 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);
-            }
-        }
-    }
+    WT_RET(__wt_read(session, fh, offset, size, buf->mem));
     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 227395c7a1a..442d69927f8 100644
--- a/src/third_party/wiredtiger/src/block/block_write.c
+++ b/src/third_party/wiredtiger/src/block/block_write.c
@@ -333,11 +333,6 @@ __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/block/block_cache.c b/src/third_party/wiredtiger/src/block_cache/block_cache.c
index 17fbbd974dc..f72eee6cc1c 100644
--- a/src/third_party/wiredtiger/src/block/block_cache.c
+++ b/src/third_party/wiredtiger/src/block_cache/block_cache.c
@@ -9,6 +9,31 @@
 #include "wt_internal.h"
 
 /*
+ * __blkcache_verbose --
+ *     Block cache verbose logging.
+ */
+static inline void
+__blkcache_verbose(
+  WT_SESSION_IMPL *session, const char *tag, uint64_t hash, const uint8_t *addr, size_t addr_size)
+{
+    WT_DECL_ITEM(tmp);
+    const char *addr_string;
+
+    if (!WT_VERBOSE_ISSET(session, WT_VERB_BLKCACHE))
+        return;
+
+    /*
+     * Complicate the error handling so we don't have to return a value from this function, it
+     * simplifies error handling in our callers.
+     */
+    addr_string = __wt_scr_alloc(session, 0, &tmp) == 0 ?
+      __wt_addr_string(session, addr, addr_size, tmp) :
+      "[unable to format addr]";
+    __wt_verbose(session, WT_VERB_BLKCACHE, "%s: %s, hash=%" PRIu64, tag, addr_string, hash);
+    __wt_scr_free(session, &tmp);
+}
+
+/*
  * __blkcache_aggregate_metadata --
  *     Sum the metadata for all buckets and write it into the cache wide variables.
  */
@@ -45,8 +70,6 @@ __blkcache_alloc(WT_SESSION_IMPL *session, size_t size, void **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
@@ -242,7 +265,7 @@ __blkcache_eviction_thread(void *arg)
                     __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;
+                    blkcache->bucket_metadata[i].bucket_bytes_used -= blkcache_item->data_size;
 
                     /*
                      * Update the number of removals because it is used to estimate the overhead,
@@ -252,7 +275,7 @@ __blkcache_eviction_thread(void *arg)
                     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_DECRV(session, block_cache_bytes, blkcache_item->data_size);
                     WT_STAT_CONN_DECR(session, block_cache_blocks);
                     __wt_free(session, blkcache_item);
                 } else {
@@ -265,9 +288,8 @@ __blkcache_eviction_thread(void *arg)
             if (blkcache->blkcache_exiting)
                 return (0);
         }
-        if (no_eviction_candidates) {
+        if (no_eviction_candidates)
             blkcache->min_num_references += BLKCACHE_MINREF_INCREMENT;
-        }
 
         WT_STAT_CONN_INCR(session, block_cache_eviction_passes);
     }
@@ -312,24 +334,22 @@ __blkcache_estimate_filesize(WT_SESSION_IMPL *session)
 }
 
 /*
- * __wt_blkcache_get_or_check --
- *     Get a block from the cache or check if one exists.
+ * __wt_blkcache_get --
+ *     Get a block from the cache.
  */
 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_get(WT_SESSION_IMPL *session, WT_ITEM *data, const uint8_t *addr, size_t addr_size,
+  bool *foundp, bool *skip_cachep)
 {
     WT_BLKCACHE *blkcache;
-    WT_BLKCACHE_ID id;
     WT_BLKCACHE_ITEM *blkcache_item;
+    WT_DECL_RET;
     uint64_t bucket, hash;
 
+    *foundp = *skip_cachep = false;
     blkcache = &S2C(session)->blkcache;
 
-    if (blkcache->type == BLKCACHE_UNCONFIGURED)
-        return (-1);
-
-    WT_STAT_CONN_INCR(session, block_cache_data_refs);
+    WT_STAT_CONN_INCR(session, block_cache_lookups);
 
     /*
      * We race to avoid using synchronization. We only care about an approximate value, so we accept
@@ -344,51 +364,39 @@ __wt_blkcache_get_or_check(
     if ((__blkcache_estimate_filesize(session) * blkcache->percent_file_in_os_cache) / 100 <
       blkcache->system_ram) {
         WT_STAT_CONN_INCR(session, block_cache_bypass_get);
-        return (WT_BLKCACHE_BYPASS);
+        *skip_cachep = true;
+        return (0);
     }
 
-    /*
-     * 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.
-     */
-    id.checksum = checksum;
-    id.offset = offset;
-    id.size = (uint32_t)size;
-    id.fid = S2BT(session)->id;
-    hash = __wt_hash_city64(&id, sizeof(id));
-
+    hash = __wt_hash_city64(addr, addr_size);
     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 && blkcache_item->id.fid == id.fid) {
-            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);
+        if (blkcache_item->addr_size == addr_size && blkcache_item->fid == S2BT(session)->id &&
+          memcmp(blkcache_item->addr, addr, addr_size) == 0) {
+            ret = __wt_buf_set(session, data, blkcache_item->data, blkcache_item->data_size);
+            if (ret == 0) {
+                blkcache_item->num_references++;
+                if (blkcache_item->freq_rec_counter < 0)
+                    blkcache_item->freq_rec_counter = 0;
+                blkcache_item->freq_rec_counter++;
+
+                *foundp = true;
+            }
+            break;
         }
     }
-
-    /* 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_RET(ret);
+
+    if (*foundp) {
+        WT_STAT_CONN_INCR(session, block_cache_hits);
+        __blkcache_verbose(session, "block found in cache", hash, addr, addr_size);
+    } else {
+        WT_STAT_CONN_INCR(session, block_cache_misses);
+        __blkcache_verbose(session, "block not found in cache", hash, addr, addr_size);
+    }
+    return (0);
 }
 
 /*
@@ -396,31 +404,28 @@ __wt_blkcache_get_or_check(
  *     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_put(WT_SESSION_IMPL *session, WT_ITEM *data, const uint8_t *addr, size_t addr_size,
+  bool checkpoint_io, bool write)
 {
     WT_BLKCACHE *blkcache;
-    WT_BLKCACHE_ID id;
-    WT_BLKCACHE_ITEM *blkcache_item;
+    WT_BLKCACHE_ITEM *blkcache_item, *blkcache_store;
     WT_DECL_RET;
     uint64_t bucket, hash;
     void *data_ptr;
 
     blkcache = &S2C(session)->blkcache;
+    blkcache_store = 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);
+        return (0);
     }
 
     /* Are we within cache size limits? */
     if (blkcache->bytes_used >= blkcache->max_bytes)
-        return (WT_BLKCACHE_FULL);
+        return (0);
 
     /*
      * If more than the configured fraction of the file is likely to fit into the OS buffer cache,
@@ -429,7 +434,7 @@ __wt_blkcache_put(WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32
     if ((__blkcache_estimate_filesize(session) * blkcache->percent_file_in_os_cache) / 100 <
       blkcache->system_ram) {
         WT_STAT_CONN_INCR(session, block_cache_bypass_put);
-        return (WT_BLKCACHE_BYPASS);
+        return (0);
     }
 
     /*
@@ -442,90 +447,90 @@ __wt_blkcache_put(WT_SESSION_IMPL *session, wt_off_t offset, size_t size, uint32
      */
     if ((blkcache->cache_on_checkpoint == false) && checkpoint_io) {
         WT_STAT_CONN_INCR(session, block_cache_bypass_chkpt);
-        return (WT_BLKCACHE_BYPASS);
+        return (0);
     }
 
     /* Bypass on high overhead */
     if (__blkcache_high_overhead(session) == true) {
         WT_STAT_CONN_INCR(session, block_cache_bypass_overhead_put);
-        return (WT_BLKCACHE_BYPASS);
+        return (0);
     }
-    /*
-     * 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.
+     * Allocate and initialize space in the cache outside of the critical section. In the unlikely
+     * event that we fail an allocation, free the space. NVRAM allocations can fail if there's no
+     * available memory, treat it as a cache-full failure.
      */
-    id.checksum = checksum;
-    id.offset = offset;
-    id.size = (uint32_t)size;
-    id.fid = S2BT(session)->id;
-    hash = __wt_hash_city64(&id, sizeof(id));
-
+    WT_RET(__blkcache_alloc(session, data->size, &data_ptr));
+    if (data_ptr == NULL)
+        return (0);
+    WT_ERR(__wt_calloc(session, 1, sizeof(*blkcache_store) + addr_size, &blkcache_store));
+    blkcache_store->data = data_ptr;
+    blkcache_store->data_size = WT_STORE_SIZE(data->size);
+    memcpy(blkcache_store->data, data->data, data->size);
+    blkcache_store->fid = S2BT(session)->id;
+    blkcache_store->addr_size = (uint8_t)addr_size;
+    memcpy(blkcache_store->addr, addr, addr_size);
+
+    hash = __wt_hash_city64(addr, addr_size);
     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 && blkcache_item->id.fid == id.fid)
-            goto item_exists;
-    }
 
-    WT_ERR(__wt_calloc_one(session, &blkcache_item));
-    blkcache_item->id = id;
-    blkcache_item->data = data_ptr;
+    /*
+     * In the case of a read, check if the block is already in the cache: it's possible because two
+     * readers can attempt to cache the same overflow block because overflow blocks aren't cached at
+     * the btree level. Collisions are relatively unlikely because other page types are cached at
+     * higher levels and reads of those tree pages are single-threaded so the page can be converted
+     * to its in-memory form before reader access. In summary, because collisions are unlikely, the
+     * allocation and copying remains outside of the bucket lock and collision check. Writing a
+     * block is single-threaded at a higher level, and as there should never be a collision, only
+     * check in diagnostic mode.
+     */
+#if !defined(HAVE_DIAGNOSTIC)
+    if (!write)
+#endif
+        TAILQ_FOREACH (blkcache_item, &blkcache->hash[bucket], hashq)
+            if (blkcache_item->addr_size == addr_size && blkcache_item->fid == S2BT(session)->id &&
+              memcmp(blkcache_item->addr, addr, addr_size) == 0) {
+                __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
+                WT_ASSERT(session, !write);
+
+                WT_STAT_CONN_INCRV(session, block_cache_bytes_update, data->size);
+                WT_STAT_CONN_INCR(session, block_cache_blocks_update);
+                __blkcache_verbose(session, "block already in cache", hash, addr, addr_size);
+                goto err;
+            }
 
     /*
      * 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;
+    blkcache_store->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);
+    TAILQ_INSERT_HEAD(&blkcache->hash[bucket], blkcache_store, hashq);
 
     blkcache->bucket_metadata[bucket].bucket_num_data_blocks++;
-    blkcache->bucket_metadata[bucket].bucket_bytes_used += size;
+    blkcache->bucket_metadata[bucket].bucket_bytes_used += data->size;
     blkcache->inserts++;
 
     __wt_spin_unlock(session, &blkcache->hash_locks[bucket]);
 
-    WT_STAT_CONN_INCRV(session, block_cache_bytes, size);
+    WT_STAT_CONN_INCRV(session, block_cache_bytes, data->size);
     WT_STAT_CONN_INCR(session, block_cache_blocks);
-    if (write == true) {
-        WT_STAT_CONN_INCRV(session, block_cache_bytes_insert_write, size);
+    if (write) {
+        WT_STAT_CONN_INCRV(session, block_cache_bytes_insert_write, data->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_INCRV(session, block_cache_bytes_insert_read, data->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);
+    __blkcache_verbose(session, "block inserted in cache", hash, addr, addr_size);
     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]);
+    __blkcache_free(session, blkcache_store);
     return (ret);
 }
 
@@ -534,48 +539,32 @@ err:
  *     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_remove(WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size)
 {
     WT_BLKCACHE *blkcache;
-    WT_BLKCACHE_ID id;
     WT_BLKCACHE_ITEM *blkcache_item;
     uint64_t bucket, hash;
 
     blkcache = &S2C(session)->blkcache;
 
-    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.
-     */
-    id.checksum = checksum;
-    id.offset = offset;
-    id.size = (uint32_t)size;
-    id.fid = S2BT(session)->id;
-    hash = __wt_hash_city64(&id, sizeof(id));
-
+    hash = __wt_hash_city64(addr, addr_size);
     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 && blkcache_item->id.fid == id.fid) {
+        if (blkcache_item->addr_size == addr_size && blkcache_item->fid == S2BT(session)->id &&
+          memcmp(blkcache_item->addr, addr, addr_size) == 0) {
             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->bucket_metadata[bucket].bucket_bytes_used -= blkcache_item->data_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_DECRV(session, block_cache_bytes, blkcache_item->data_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);
+            __blkcache_free(session, blkcache_item->data);
+            __wt_overwrite_and_free(session, blkcache_item);
+            __blkcache_verbose(session, "block removed from cache", hash, addr, addr_size);
             return;
         }
     }
@@ -685,7 +674,7 @@ __wt_block_cache_destroy(WT_SESSION_IMPL *session)
             __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;
+            blkcache->bucket_metadata[i].bucket_bytes_used -= blkcache_item->data_size;
             __wt_free(session, blkcache_item);
         }
         __wt_spin_unlock(session, &blkcache->hash_locks[i]);
diff --git a/src/third_party/wiredtiger/src/block/block_mgr.c b/src/third_party/wiredtiger/src/block_cache/block_mgr.c
index 983de3d7c52..f60905849d5 100644
--- a/src/third_party/wiredtiger/src/block/block_mgr.c
+++ b/src/third_party/wiredtiger/src/block_cache/block_mgr.c
@@ -331,6 +331,14 @@ __bm_compact_start_readonly(WT_BM *bm, WT_SESSION_IMPL *session)
 static int
 __bm_free(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size)
 {
+    WT_BLKCACHE *blkcache;
+
+    blkcache = &S2C(session)->blkcache;
+
+    /* Evict the freed block from the block cache */
+    if (blkcache->type != BLKCACHE_UNCONFIGURED)
+        __wt_blkcache_remove(session, addr, addr_size);
+
     return (__wt_block_free(session, bm->block, addr, addr_size));
 }
 
@@ -373,6 +381,56 @@ __bm_map_discard(WT_BM *bm, WT_SESSION_IMPL *session, void *map, size_t len)
 }
 
 /*
+ * __bm_read --
+ *     Read an address cookie referenced block into a buffer.
+ */
+static int
+__bm_read(WT_BM *bm, WT_SESSION_IMPL *session, WT_ITEM *buf, const uint8_t *addr, size_t addr_size)
+{
+    WT_BLKCACHE *blkcache;
+    bool found, skip_cache;
+
+    blkcache = &S2C(session)->blkcache;
+
+    /* Check the block cache. */
+    skip_cache = true;
+    if (blkcache->type != BLKCACHE_UNCONFIGURED) {
+        WT_RET(__wt_blkcache_get(session, buf, addr, addr_size, &found, &skip_cache));
+        if (found)
+            return (0);
+    }
+
+    /* Read the block. */
+    WT_RET(__wt_bm_read(bm, session, buf, addr, addr_size));
+
+    /* Optionally store in the block cache. */
+    if (!skip_cache)
+        WT_RET(__wt_blkcache_put(session, buf, addr, addr_size, false, false));
+    return (0);
+}
+
+/*
+ * __bm_preload --
+ *     Pre-load a page.
+ */
+static int
+__bm_preload(WT_BM *bm, WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size)
+{
+    WT_DECL_ITEM(tmp);
+    WT_DECL_RET;
+
+    /* Ignore underlying preload errors, just use them as an indication preload didn't work. */
+    if (__wt_bm_preload(bm, session, addr, addr_size) == 0)
+        return (0);
+
+    /* Do it the slow way. */
+    WT_RET(__wt_scr_alloc(session, 0, &tmp));
+    ret = __bm_read(bm, session, tmp, addr, addr_size);
+    __wt_scr_free(session, &tmp);
+    return (ret);
+}
+
+/*
  * __bm_salvage_end --
  *     End a block manager salvage.
  */
@@ -557,10 +615,19 @@ static int
 __bm_write(WT_BM *bm, WT_SESSION_IMPL *session, WT_ITEM *buf, uint8_t *addr, size_t *addr_sizep,
   bool data_checksum, bool checkpoint_io)
 {
+    WT_BLKCACHE *blkcache;
+
+    blkcache = &S2C(session)->blkcache;
+
     __wt_capacity_throttle(
       session, buf->size, checkpoint_io ? WT_THROTTLE_CKPT : WT_THROTTLE_EVICT);
-    return (
+
+    WT_RET(
       __wt_block_write(session, bm->block, buf, addr, addr_sizep, data_checksum, checkpoint_io));
+
+    if (blkcache->type != BLKCACHE_UNCONFIGURED)
+        WT_RET(__wt_blkcache_put(session, buf, addr, *addr_sizep, checkpoint_io, true));
+    return (0);
 }
 
 /*
@@ -629,8 +696,8 @@ __bm_method_set(WT_BM *bm, bool readonly)
     bm->free = __bm_free;
     bm->is_mapped = __bm_is_mapped;
     bm->map_discard = __bm_map_discard;
-    bm->preload = __wt_bm_preload;
-    bm->read = __wt_bm_read;
+    bm->preload = __bm_preload;
+    bm->read = __bm_read;
     bm->salvage_end = __bm_salvage_end;
     bm->salvage_next = __bm_salvage_next;
     bm->salvage_start = __bm_salvage_start;
diff --git a/src/third_party/wiredtiger/src/include/block_cache.h b/src/third_party/wiredtiger/src/include/block_cache.h
index 0686a3eaf66..9dfb4a2c1b6 100644
--- a/src/third_party/wiredtiger/src/include/block_cache.h
+++ b/src/third_party/wiredtiger/src/include/block_cache.h
@@ -24,33 +24,19 @@
 #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 --
- *    File ID, checksum, offset and size uniquely identify a block.
- */
-WT_PACKED_STRUCT_BEGIN(__wt_blkcache_id)
-    uint32_t fid;
-    uint32_t checksum;
-    uint32_t size;
-    wt_off_t offset;
-WT_PACKED_STRUCT_END
-#define WT_BLKCACHE_ID_SIZE (sizeof(wt_off_t) + 3 * sizeof(uint32_t))
-
-/*
  * 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 data_size;
     uint32_t num_references;
 
     /*
@@ -60,6 +46,10 @@ struct __wt_blkcache_item {
      * this counter is a metric combining frequency and recency, and hence its name.
      */
     int32_t freq_rec_counter;
+
+    uint32_t fid;      /* File ID */
+    uint8_t addr_size; /* Address cookie */
+    uint8_t addr[];
 };
 
 /*
@@ -107,14 +97,14 @@ struct __wt_blkcache {
     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.
+     * This fraction tells us the ratio of total file data to the application-declared size of the
+     * OS filesystem buffer cache, which makes the use of this block cache unnecessary. Suppose we
+     * set that fraction to 50%. Then if half of our total file data fits into whatever value the
+     * user gives us for the filesystem buffer cache, 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.
+     * E.g., if the fraction is set to 50%, our aggregate file size is 500GB, and the application
+     * declares there to be 300GB of OS filesystem buffer cache, then we will not use this block
+     * cache, because half of our total file size (250GB) would fit into such a buffer cache.
      */
     u_int percent_file_in_os_cache;
 
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index 36aea1783c9..3f4b06363d4 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -92,10 +92,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)
+extern int __wt_blkcache_get(WT_SESSION_IMPL *session, WT_ITEM *data, const uint8_t *addr,
+  size_t addr_size, bool *foundp, bool *skip_cachep)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_blkcache_put(WT_SESSION_IMPL *session, WT_ITEM *data, const uint8_t *addr,
+  size_t addr_size, 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));
@@ -1697,8 +1698,7 @@ 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_blkcache_remove(WT_SESSION_IMPL *session, const uint8_t *addr, size_t addr_size);
 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_get_progress_stats(WT_SESSION_IMPL *session, WT_BM *bm,
diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h
index f7ada3015b5..069cef7806f 100644
--- a/src/third_party/wiredtiger/src/include/stat.h
+++ b/src/third_party/wiredtiger/src/include/stat.h
@@ -346,7 +346,7 @@ struct __wt_connection_stats {
     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_lookups;
     int64_t block_cache_not_evicted_overhead;
     int64_t block_cache_bypass_writealloc;
     int64_t block_cache_bypass_overhead_put;
diff --git a/src/third_party/wiredtiger/src/include/verify_build.h b/src/third_party/wiredtiger/src/include/verify_build.h
index 1b83b6e1813..af0e81c141d 100644
--- a/src/third_party/wiredtiger/src/include/verify_build.h
+++ b/src/third_party/wiredtiger/src/include/verify_build.h
@@ -49,7 +49,6 @@ static inline void
 __wt_verify_build(void)
 {
     /* Check specific structures weren't padded. */
-    WT_SIZE_CHECK(WT_BLKCACHE_ID, WT_BLKCACHE_ID_SIZE);
     WT_SIZE_CHECK(WT_BLOCK_DESC, WT_BLOCK_DESC_SIZE);
     WT_SIZE_CHECK(WT_REF, WT_REF_SIZE);
 
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index d6c2562f270..b8c4260991a 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -5130,56 +5130,50 @@ 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 */
+/*! block-cache: cached blocks updated */
 #define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_UPDATE		1010
-/*! block-manager: block cache cached bytes updated */
+/*! block-cache: cached bytes updated */
 #define	WT_STAT_CONN_BLOCK_CACHE_BYTES_UPDATE		1011
-/*! block-manager: block cache evicted blocks */
+/*! block-cache: evicted blocks */
 #define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_EVICTED		1012
-/*! block-manager: block cache file size causing bypass */
+/*! 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
- */
+/*! block-cache: lookups */
+#define	WT_STAT_CONN_BLOCK_CACHE_LOOKUPS		1014
+/*! 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
+ * 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 */
+/*! 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 */
+/*! 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
- */
+/*! 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 */
+/*! 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 */
+/*! block-cache: number of hits */
 #define	WT_STAT_CONN_BLOCK_CACHE_HITS			1021
-/*! block-manager: block cache number of misses including existence checks */
+/*! block-cache: number of misses */
 #define	WT_STAT_CONN_BLOCK_CACHE_MISSES			1022
-/*! block-manager: block cache number of put bypasses on checkpoint I/O */
+/*! 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 */
+/*! block-cache: removed blocks */
 #define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_REMOVED		1024
-/*! block-manager: block cache total blocks */
+/*! block-cache: total blocks */
 #define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS			1025
-/*! block-manager: block cache total blocks inserted on read path */
+/*! 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 */
+/*! block-cache: total blocks inserted on write path */
 #define	WT_STAT_CONN_BLOCK_CACHE_BLOCKS_INSERT_WRITE	1027
-/*! block-manager: block cache total bytes */
+/*! block-cache: total bytes */
 #define	WT_STAT_CONN_BLOCK_CACHE_BYTES			1028
-/*! block-manager: block cache total bytes inserted on read path */
+/*! 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 */
+/*! 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			1031
diff --git a/src/third_party/wiredtiger/src/include/wt_internal.h b/src/third_party/wiredtiger/src/include/wt_internal.h
index 0d6319d6ec2..9f4b76aa5d1 100644
--- a/src/third_party/wiredtiger/src/include/wt_internal.h
+++ b/src/third_party/wiredtiger/src/include/wt_internal.h
@@ -73,8 +73,6 @@ 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;
diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c
index faefe679770..7d9bd538f32 100644
--- a/src/third_party/wiredtiger/src/support/stat.c
+++ b/src/third_party/wiredtiger/src/support/stat.c
@@ -1058,27 +1058,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-cache: cached blocks updated",
+  "block-cache: cached bytes updated",
+  "block-cache: evicted blocks",
+  "block-cache: file size causing bypass",
+  "block-cache: lookups",
+  "block-cache: number of blocks not evicted due to overhead",
+  "block-cache: number of bypasses because no-write-allocate setting was on",
+  "block-cache: number of bypasses due to overhead on put",
+  "block-cache: number of bypasses on get",
+  "block-cache: number of bypasses on put because file is too small",
+  "block-cache: number of eviction passes",
+  "block-cache: number of hits",
+  "block-cache: number of misses",
+  "block-cache: number of put bypasses on checkpoint I/O",
+  "block-cache: removed blocks",
+  "block-cache: total blocks",
+  "block-cache: total blocks inserted on read path",
+  "block-cache: total blocks inserted on write path",
+  "block-cache: total bytes",
+  "block-cache: total bytes inserted on read path",
+  "block-cache: total bytes inserted on write path",
   "block-manager: blocks pre-loaded",
   "block-manager: blocks read",
   "block-manager: blocks written",
@@ -1637,7 +1637,7 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats)
     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_lookups = 0;
     stats->block_cache_not_evicted_overhead = 0;
     stats->block_cache_bypass_writealloc = 0;
     stats->block_cache_bypass_overhead_put = 0;
@@ -2171,7 +2171,7 @@ __wt_stat_connection_aggregate(WT_CONNECTION_STATS **from, WT_CONNECTION_STATS *
     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_lookups += WT_STAT_READ(from, block_cache_lookups);
     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);
diff --git a/src/third_party/wiredtiger/test/format/wts.c b/src/third_party/wiredtiger/test/format/wts.c
index 6c893c22d8a..7c3447325de 100644
--- a/src/third_party/wiredtiger/test/format/wts.c
+++ b/src/third_party/wiredtiger/test/format/wts.c
@@ -215,8 +215,6 @@ create_database(const char *home, WT_CONNECTION **connp)
     if (GV(RUNS_IN_MEMORY) != 0)
         CONFIG_APPEND(p, ",in_memory=1");
 
-        /* FIXME WT-8314: configuring a block cache corrupts tables. */
-#if 0
     /* Block cache configuration. */
     if (GV(BLOCK_CACHE) != 0)
         CONFIG_APPEND(p,
@@ -226,7 +224,6 @@ create_database(const char *home, WT_CONNECTION **connp)
           ",size=%" PRIu32 "MB)",
           GV(BLOCK_CACHE_CACHE_ON_CHECKPOINT) == 0 ? "false" : "true",
           GV(BLOCK_CACHE_CACHE_ON_WRITES) == 0 ? "false" : "true", GV(BLOCK_CACHE_SIZE));
-#endif
 
     /* LSM configuration. */
     if (g.lsm_config)