diff options
Diffstat (limited to 'src/third_party')
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{ + * 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{ cache_on_checkpoint, Cache blocks that are written by a + * checkpoint., a boolean flag; default \c true.} + * @config{ + * cache_on_writes, cache newly generated blocks., a boolean flag; default \c true.} + * @config{ enabled, enable block cache., a boolean flag; default \c + * false.} + * @config{ 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{ hashsize, number of buckets in the hashtable that + * keeps track of blocks., an integer between 512 and 256K; default \c 0.} + * @config{ 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{ nvram_path, the absolute path to the file system mounted + * on the NVRAM device., a string; default empty.} + * @config{ + * percent_file_in_dram, bypass cache if that percent of file fits in DRAM., an integer + * between 0 and 100; default \c 50.} + * @config{ size, maximum memory + * to allocate for the block cache., an integer between 0 and 6155GB; default \c 0.} + * @config{ system_ram, amount of DRAM expected to be available on + * the system., an integer between 0 and 1024GB; default \c 0.} + * @config{ 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{ 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{ cache_on_checkpoint, Cache blocks that + * are written by a checkpoint., a boolean flag; default \c true.} + * @config{ + * cache_on_writes, cache newly generated blocks., a boolean flag; default \c true.} + * @config{ enabled, enable block cache., a boolean flag; default \c false.} + * @config{ 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{ hashsize, number of buckets in the hashtable that keeps track of + * blocks., an integer between 512 and 256K; default \c 0.} + * @config{ + * 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{ nvram_path, the absolute path to the file system mounted on the + * NVRAM device., a string; default empty.} + * @config{ percent_file_in_dram, + * bypass cache if that percent of file fits in DRAM., an integer between 0 and 100; default \c 50.} + * @config{ size, maximum memory to allocate for the block cache., an integer + * between 0 and 6155GB; default \c 0.} + * @config{ system_ram, amount of DRAM + * expected to be available on the system., an integer between 0 and 1024GB; default \c 0.} + * @config{ 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); |