Bump up version to 6.5.3

Update HISTORY.md with the recent memtable trimming fixes
Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/6194 Differential Revision: D19125292 Pulled By: ltamasi fbshipit-source-id: d41aca2755ec4bec07feedd6b561e8d18606a931
2026-11-07 11:32:34 -05:00 · 2020-01-10 09:58:14 -08:00 · 2020-01-10 09:57:50 -08:00 · 2020-01-10 09:54:56 -08:00 · 2020-01-10 09:53:31 -08:00 · 2020-01-10 09:53:31 -08:00
260 changed files with 4878 additions and 5891 deletions
@@ -481,7 +481,6 @@ set(SOURCES
        cache/clock_cache.cc
        cache/lru_cache.cc
        cache/sharded_cache.cc
-        db/arena_wrapped_db_iter.cc
        db/builder.cc
        db/c.cc
        db/column_family.cc
@@ -547,15 +546,9 @@ set(SOURCES
        env/env_hdfs.cc
        env/mock_env.cc
        file/delete_scheduler.cc
-        file/file_prefetch_buffer.cc
        file/file_util.cc
        file/filename.cc
-        file/random_access_file_reader.cc
-        file/read_write_util.cc
-        file/readahead_raf.cc
-        file/sequence_file_reader.cc
        file/sst_file_manager_impl.cc
-        file/writable_file_writer.cc
        logging/auto_roll_logger.cc
        logging/event_logger.cc
        logging/log_buffer.cc
@@ -645,6 +638,7 @@ set(SOURCES
        util/concurrent_task_limiter_impl.cc
        util/crc32c.cc
        util/dynamic_bloom.cc
+        util/file_reader_writer.cc
        util/filter_policy.cc
        util/hash.cc
        util/murmurhash.cc
@@ -1,26 +1,35 @@
 # Rocksdb Change Log
-## Unreleased
+## 6.5.3 (1/10/2020)
+### Bug Fixes
+* Fixed two performance issues related to memtable history trimming. First, a new SuperVersion is now created only if some memtables were actually trimmed. Second, trimming is only scheduled if there is at least one flushed memtable that is kept in memory for the purposes of transaction conflict checking.
+
+## 6.5.2 (11/15/2019)
+### Bug Fixes
+* Fix a assertion failure in MultiGe4t() when BlockBasedTableOptions::no_block_cache is true and there is no compressed block cache
+* Fix a buffer overrun problem in BlockBasedTable::MultiGet() when compression is enabled and no compressed block cache is configured.
+* If a call to BackupEngine::PurgeOldBackups or BackupEngine::DeleteBackup suffered a crash, power failure, or I/O error, files could be left over from old backups that could only be purged with a call to GarbageCollect. Any call to PurgeOldBackups, DeleteBackup, or GarbageCollect should now suffice to purge such files.
+
+## 6.5.1 (10/16/2019)
+### Bug Fixes
+* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strange results when reseek happens with a different iterator upper bound.
+* Fix a bug in BlockBasedTableIterator that might return incorrect results when reseek happens with a different iterator upper bound.
+* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand.
+
+## 6.5.0 (9/13/2019)
 ### Bug Fixes
 * Fixed a number of data races in BlobDB.
 * Fix a bug where the compaction snapshot refresh feature is not disabled as advertised when `snap_refresh_nanos` is set to 0..
 * Fix bloom filter lookups by the MultiGet batching API when BlockBasedTableOptions::whole_key_filtering is false, by checking that a key is in the perfix_extractor domain and extracting the prefix before looking up.
 * Fix a bug in file ingestion caused by incorrect file number allocation when the number of column families involved in the ingestion exceeds 2.
-* Fix a bug when format_version=3, partitioned fitlers, and prefix search are used in conjunction. The bug could result into Seek::(prefix) returning NotFound for an existing prefix.
-* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strong results when reseek happens with a different iterator upper bound.
 ### New Features
 * Introduced DBOptions::max_write_batch_group_size_bytes to configure maximum limit on number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit.
 * VerifyChecksum() by default will issue readahead. Allow ReadOptions to be passed in to those functions to override the readhead size. For checksum verifying before external SST file ingestion, a new option IngestExternalFileOptions.verify_checksums_readahead_size, is added for this readahead setting.
 * When user uses options.force_consistency_check in RocksDb, instead of crashing the process, we now pass the error back to the users without killing the process.
 * Add an option `memtable_insert_hint_per_batch` to WriteOptions. If it is true, each WriteBatch will maintain its own insert hints for each memtable in concurrent write. See include/rocksdb/options.h for more details.
-* The `sst_dump` command line tool `recompress` command now displays how many blocks were compressed and how many were not, in particular how many were not compressed because the compression ratio was not met (12.5% threshold for GoodCompressionRatio), as seen in the `number.block.not_compressed` counter stat since version 6.0.0.
-* The block cache usage is now takes into account the overhead of metadata per each entry. This results into more accurate managment of memory. A side-effect of this feature is that less items are fit into the block cache of the same size, which would result to higher cache miss rates. This can be remedied by increasing the block cache size or passing kDontChargeCacheMetadata to its constuctor to restore the old behavior.
 ### Public API Change
 * Added max_write_buffer_size_to_maintain option to better control memory usage of immutable memtables.
 * Added a lightweight API GetCurrentWalFile() to get last live WAL filename and size. Meant to be used as a helper for backup/restore tooling in a larger ecosystem such as MySQL with a MyRocks storage engine.
 * The MemTable Bloom filter, when enabled, now always uses cache locality. Options::bloom_locality now only affects the PlainTable SST format.
-* Deprecate `snap_refresh_nanos` option.
-* Added DisableManualCompaction/EnableManualCompaction to stop and resume manual compaction.
-* Add TryCatchUpWithPrimary() to StackableDB in non-LITE mode.
 ### Performance Improvements
 * Improve the speed of the MemTable Bloom filter, reducing the write overhead of enabling it by 1/3 to 1/2, with similar benefit to read performance.

@@ -1509,10 +1509,10 @@ util_merge_operators_test: utilities/util_merge_operators_test.o $(LIBOBJECTS) $
 options_file_test: db/options_file_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-deletefile_test: db/deletefile_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
+deletefile_test: db/deletefile_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-obsolete_files_test: db/obsolete_files_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
+obsolete_files_test: db/obsolete_files_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 rocksdb_dump: tools/dump/rocksdb_dump.o $(LIBOBJECTS)
@@ -108,7 +108,6 @@ cpp_library(
        "cache/clock_cache.cc",
        "cache/lru_cache.cc",
        "cache/sharded_cache.cc",
-        "db/arena_wrapped_db_iter.cc",
        "db/builder.cc",
        "db/c.cc",
        "db/column_family.cc",
@@ -176,15 +175,9 @@ cpp_library(
        "env/io_posix.cc",
        "env/mock_env.cc",
        "file/delete_scheduler.cc",
-        "file/file_prefetch_buffer.cc",
        "file/file_util.cc",
        "file/filename.cc",
-        "file/random_access_file_reader.cc",
-        "file/read_write_util.cc",
-        "file/readahead_raf.cc",
-        "file/sequence_file_reader.cc",
        "file/sst_file_manager_impl.cc",
-        "file/writable_file_writer.cc",
        "logging/auto_roll_logger.cc",
        "logging/event_logger.cc",
        "logging/log_buffer.cc",
@@ -273,6 +266,7 @@ cpp_library(
        "util/concurrent_task_limiter_impl.cc",
        "util/crc32c.cc",
        "util/dynamic_bloom.cc",
+        "util/file_reader_writer.cc",
        "util/filter_policy.cc",
        "util/hash.cc",
        "util/murmurhash.cc",
@@ -97,8 +97,5 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed
 ## IOTA Foundation
 [IOTA Foundation](https://www.iota.org/) is using RocksDB in the [IOTA Reference Implementation (IRI)](https://github.com/iotaledger/iri) to store the local state of the Tangle. The Tangle is the first open-source distributed ledger powering the future of the Internet of Things.
 
-## Avrio Project
- [Avrio Project](http://avrio-project.github.io/avrio.network/) is using RocksDB in [Avrio ](https://github.com/avrio-project/avrio) to store blocks, account balances and data and other blockchain-releated data. Avrio is a multiblockchain decentralized cryptocurrency empowering monetary transactions.
- 
 ## Crux
 [Crux](https://github.com/juxt/crux) is a document database that uses RocksDB for local [EAV](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model) index storage to enable point-in-time bitemporal Datalog queries. The "unbundled" architecture uses Kafka to provide horizontal scalability.
@@ -56,10 +56,10 @@ if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
    if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
      # we need this to build with MySQL. Don't use for other purposes.
      source "$PWD/build_tools/fbcode_config4.8.1.sh"
-    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007" ]; then
-      source "$PWD/build_tools/fbcode_config_platform007.sh"
-    else
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
      source "$PWD/build_tools/fbcode_config.sh"
+    else
+      source "$PWD/build_tools/fbcode_config_platform007.sh"
    fi
 fi

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+#
+# Copyright (c) 2016, Facebook. All rights reserved.
+#
+# Overall wrapper script for RocksDB continuous builds. The implementation is a
+# trivial pulling scheme. We loop infinitely, check if any new changes have been
+# committed, if yes then trigger a Sandcastle run, and finally go to sleep again
+# for a certain interval.
+#
+
+SRC_GIT_REPO=/data/git/rocksdb-public
+error=0
+
+function log {
+  DATE=`date +%Y-%m-%d:%H:%M:%S`
+  # shellcheck disable=SC2068
+  echo $DATE $@
+}
+
+function log_err {
+  # shellcheck disable=SC2145
+  log "ERROR: $@ Error code: $error."
+}
+
+function update_repo_status {
+  # Update the parent first.
+  pushd $SRC_GIT_REPO
+
+  # This is a fatal error. Something in the environment isn't right and we will
+  # terminate the execution.
+  error=$?
+  if [ ! $error -eq 0 ]; then
+    log_err "Where is $SRC_GIT_REPO?"
+    exit $error
+  fi
+
+  HTTPS_PROXY=fwdproxy:8080 git fetch -f
+
+  error=$?
+  if [ ! $error -eq 0 ]; then
+    log_err "git fetch -f failed."
+    popd
+    return $error
+  fi
+
+  git update-ref refs/heads/master refs/remotes/origin/master
+
+  error=$?
+  if [ ! $error -eq 0 ]; then
+    log_err "git update-ref failed."
+    popd
+    return $error
+  fi
+
+  popd
+
+  # We're back in an instance-specific directory. Get the latest changes.
+  git pull --rebase
+
+  error=$?
+  if [ ! $error -eq 0 ]; then
+    log_err "git pull --rebase failed."
+    return $error
+  fi
+}
+
+#
+# Execution starts here.
+#
+
+# Path to the determinator from the root of the RocksDB repo.
+CONTRUN_DETERMINATOR=./build_tools/RocksDBCommonHelper.php
+
+# Value of the previous commit.
+PREV_COMMIT=
+
+log "Starting to monitor for new RocksDB changes ..."
+log "Running under `pwd` as `whoami`."
+
+# Paranoia. Make sure that we're using the right branch.
+git checkout master
+
+error=$?
+if [ ! $error -eq 0 ]; then
+  log_err "This is not good. Can't checkout master. Bye-bye!"
+  exit 1
+fi
+
+# We'll run forever and let the execution environment terminate us if we'll
+# exceed whatever timeout is set for the job.
+while true;
+do
+  # Get the latest changes committed.
+  update_repo_status
+
+  error=$?
+  if [  $error -eq 0 ]; then
+    LAST_COMMIT=`git log -1 | head -1 | grep commit | awk '{ print $2; }'`
+
+    log "Last commit is '$LAST_COMMIT', previous commit is '$PREV_COMMIT'."
+
+    if [ "$PREV_COMMIT" == "$LAST_COMMIT" ]; then
+      log "There were no changes since the last time I checked. Going to sleep."
+    else
+      if [ ! -z "$LAST_COMMIT" ]; then
+        log "New code has been committed or previous commit not known. " \
+            "Will trigger the tests."
+
+        PREV_COMMIT=$LAST_COMMIT
+        log "Updated previous commit to '$PREV_COMMIT'."
+
+        #
+        # This is where we'll trigger the Sandcastle run. The values for
+        # HTTPS_APP_VALUE and HTTPS_APP_VALUE will be set in the container we're
+        # running in.
+        #
+        POST_RECEIVE_HOOK=1 php $CONTRUN_DETERMINATOR
+
+        error=$?
+        if [ $error -eq 0 ]; then
+          log "Sandcastle run successfully triggered."
+        else
+          log_err "Failed to trigger Sandcastle run."
+        fi
+      else
+        log_err "Previous commit not updated. Don't know what the last one is."
+      fi
+    fi
+  else
+    log_err "Getting latest changes failed. Will skip running tests for now."
+  fi
+
+  # Always sleep, even if errors happens while trying to determine the latest
+  # commit. This will prevent us terminating in case of transient errors.
+  log "Will go to sleep for 5 minutes."
+  sleep 5m
+done
@@ -1,19 +1,19 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/5.x/centos7-native/c447969
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/1bd23f9917738974ad0ff305aa23eb5f93f18305/9.0.0/centos7-native/c9f9104
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/5.x/gcc-5-glibc-2.23/339d858
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.23/gcc-5-glibc-2.23/ca1d1c0
+GCC_BASE=/mnt/gvfs/third-party2/gcc/112ec378fec7002ad3e09afde022e656049f7191/5.x/centos7-native/c447969
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/04999bdb3ce81a11073535dcb00b5e13dc1cbaf5/stable/centos7-native/c9f9104
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/92b0c8e5c8eecc71eb042594ce1ab3413799b385/5.x/gcc-5-glibc-2.23/339d858
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/3d8698d5973ba94f41620a80a67e4457fdf01e90/2.23/gcc-5-glibc-2.23/ca1d1c0
 SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/gcc-5-glibc-2.23/9bc6787
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/gcc-5-glibc-2.23/9bc6787
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/22c2d65676fb7c23cfa797c4f6937f38b026f3cf/1.2.8/gcc-5-glibc-2.23/9bc6787
 BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/gcc-5-glibc-2.23/9bc6787
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/gcc-5-glibc-2.23/9bc6787
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/gcc-5-glibc-2.23/03859b5
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/907b498203d297947f3bb70b9466f47e100f1873/r131/gcc-5-glibc-2.23/9bc6787
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/af6628a46758f1a15484a1760cd7294164bc5ba1/1.3.5/gcc-5-glibc-2.23/03859b5
 GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/gcc-5-glibc-2.23/9bc6787
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/gcc-5-glibc-2.23/0c8f76d
-NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/gcc-5-glibc-2.23/9bc6787
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/gcc-5-glibc-2.23/b443de1
-TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/gcc-5-glibc-2.23/9bc6787
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/2e3cb7d119b3cea5f1e738cc13a1ac69f49eb875/2.29.1/centos7-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/gcc-5-glibc-2.23/9bc6787
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/b1a0e56c1e3e6929813a4331ade3a58ff083afbb/master/gcc-5-glibc-2.23/aa64d6b
+NUMA_BASE=/mnt/gvfs/third-party2/numa/9cbf2460284c669ed19c3ccb200a71f7dd7e53c7/2.0.11/gcc-5-glibc-2.23/9bc6787
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/bf3d7497fe4e6d007354f0adffa16ce3003f8338/1.3/gcc-5-glibc-2.23/b443de1
+TBB_BASE=/mnt/gvfs/third-party2/tbb/ff4e0b093534704d8abab678a4fd7f5ea7b094c7/2018_U5/gcc-5-glibc-2.23/9bc6787
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/b5c4a61a5c483ba24722005ae07895971a2ac707/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/55031de95a2b46c82948743419a603b3d6aefe28/2.29.1/centos7-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/f3f697a28122e6bcd513273dd9c1ff23852fc59f/3.13.0/gcc-5-glibc-2.23/9bc6787
 LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.2.3/gcc-5-glibc-2.23/65372bd
@@ -1,19 +1,19 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/7.x/centos7-native/b2ef2b6
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/1bd23f9917738974ad0ff305aa23eb5f93f18305/9.0.0/centos7-native/c9f9104
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/7.x/platform007/5620abc
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.26/platform007/f259413
+GCC_BASE=/mnt/gvfs/third-party2/gcc/6e8e715624fd15256a7970073387793dfcf79b46/7.x/centos7-native/b2ef2b6
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/ef37e1faa1c29782abfac1ae65a291b9b7966f6d/stable/centos7-native/c9f9104
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/c67031f0f739ac61575a061518d6ef5038f99f90/7.x/platform007/5620abc
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/60d6f124a78798b73944f5ba87c2306ae3460153/2.26/platform007/f259413
 SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/platform007/ca4da3d
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/platform007/ca4da3d
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/22c2d65676fb7c23cfa797c4f6937f38b026f3cf/1.2.8/platform007/ca4da3d
 BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/platform007/ca4da3d
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/platform007/ca4da3d
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/platform007/15a3614
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/907b498203d297947f3bb70b9466f47e100f1873/r131/platform007/ca4da3d
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/3ee276cbacfad3074e3f07bf826ac47f06970f4e/1.3.5/platform007/15a3614
 GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/platform007/ca4da3d
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/platform007/c26c002
-NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/platform007/ca4da3d
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/platform007/6f3e0a9
-TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/platform007/ca4da3d
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/fb/platform007/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/2e3cb7d119b3cea5f1e738cc13a1ac69f49eb875/2.29.1/centos7-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/platform007/ca4da3d
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/9c910d36d6235cc40e8ff559358f1833452300ca/master/platform007/5b0f53e
+NUMA_BASE=/mnt/gvfs/third-party2/numa/9cbf2460284c669ed19c3ccb200a71f7dd7e53c7/2.0.11/platform007/ca4da3d
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/bf3d7497fe4e6d007354f0adffa16ce3003f8338/1.3/platform007/6f3e0a9
+TBB_BASE=/mnt/gvfs/third-party2/tbb/ff4e0b093534704d8abab678a4fd7f5ea7b094c7/2018_U5/platform007/ca4da3d
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/b5c4a61a5c483ba24722005ae07895971a2ac707/fb/platform007/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/92ff90349e2f43ea0a8246d8b1cf17b6869013e3/2.29.1/centos7-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/f3f697a28122e6bcd513273dd9c1ff23852fc59f/3.13.0/platform007/ca4da3d
 LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.3.4/platform007/5007832
@@ -54,25 +54,15 @@ fi
 set -e

 uncommitted_code=`git diff HEAD`
+LAST_MASTER=`git merge-base master HEAD`

 # If there's no uncommitted changes, we assume user are doing post-commit
-# format check, in which case we'll try to check the modified lines vs. the
-# facebook/rocksdb.git master branch. Otherwise, we'll check format of the
-# uncommitted code only.
+# format check, in which case we'll check the modified lines since last commit
+# from master. Otherwise, we'll check format of the uncommitted code only.
 if [ -z "$uncommitted_code" ]
 then
-  # Attempt to get name of facebook/rocksdb.git remote.
-  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(git remote -v | grep 'facebook/rocksdb.git' | head -n 1 | cut -f 1)"
-  # Fall back on 'origin' if that fails
-  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE=origin
-  # Use master branch from that remote
-  [ "$FORMAT_UPSTREAM" ] || FORMAT_UPSTREAM="$FORMAT_REMOTE/master"
-  # Get the common ancestor with that remote branch. Everything after that
-  # common ancestor would be considered the contents of a pull request, so
-  # should be relevant for formatting fixes.
-  FORMAT_UPSTREAM_MERGE_BASE="$(git merge-base "$FORMAT_UPSTREAM" HEAD)"
-  # Get the differences
-  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -p 1)
+  # Check the format of last commit
+  diffs=$(git diff -U0 $LAST_MASTER^ | $CLANG_FORMAT_DIFF -p 1)
 else
  # Check the format of uncommitted lines,
  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1)
@@ -86,12 +76,12 @@ fi

 # Highlight the insertion/deletion from the clang-format-diff.py's output
 COLOR_END="\033[0m"
-COLOR_RED="\033[0;31m"
-COLOR_GREEN="\033[0;32m"
+COLOR_RED="\033[0;31m" 
+COLOR_GREEN="\033[0;32m" 

 echo -e "Detect lines that doesn't follow the format rules:\r"
 # Add the color to the diff. lines added will be green; lines removed will be red.
-echo "$diffs" |
+echo "$diffs" | 
  sed -e "s/\(^-.*$\)/`echo -e \"$COLOR_RED\1$COLOR_END\"`/" |
  sed -e "s/\(^+.*$\)/`echo -e \"$COLOR_GREEN\1$COLOR_END\"`/"

@@ -114,7 +104,7 @@ fi
 # Do in-place format adjustment.
 if [ -z "$uncommitted_code" ]
 then
-  git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -i -p 1
+  git diff -U0 $LAST_MASTER^ | $CLANG_FORMAT_DIFF -i -p 1
 else
  git diff -U0 HEAD^ | $CLANG_FORMAT_DIFF -i -p 1
 fi
@@ -6,12 +6,6 @@
 BASEDIR=$(dirname $0)
 OUTPUT=""

-function log_header()
-{
-  echo "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved." >> "$OUTPUT"
-}
-
-
 function log_variable()
 {
  echo "$1=${!1}" >> "$OUTPUT"
@@ -75,7 +69,6 @@ echo "Writing dependencies to $OUTPUT"
 GCC_BASE=`readlink -f $TP2_LATEST/gcc/7.x/centos7-native/*/`
 CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos7-native/*/`

-log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE

@@ -115,7 +108,6 @@ echo "Writing dependencies to $OUTPUT"
 GCC_BASE=`readlink -f $TP2_LATEST/gcc/5.x/centos7-native/*/`
 CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos7-native/*/`

-log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE

@@ -155,7 +147,6 @@ echo "Writing 4.8.1 dependencies to $OUTPUT"
 GCC_BASE=`readlink -f $TP2_LATEST/gcc/4.8.1/centos6-native/*/`
 CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos6-native/*/`

-log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE

@@ -11,9 +11,9 @@ int main() {
 }
 #else

-#include <stdio.h>
-#include <sys/types.h>
 #include <cinttypes>
+#include <sys/types.h>
+#include <stdio.h>

 #include "port/port.h"
 #include "rocksdb/cache.h"
@@ -86,22 +86,14 @@ class CacheTest : public testing::TestWithParam<std::string> {
    return nullptr;
  }

-  std::shared_ptr<Cache> NewCache(
-      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      CacheMetadataChargePolicy charge_policy = kDontChargeCacheMetadata) {
+  std::shared_ptr<Cache> NewCache(size_t capacity, int num_shard_bits,
+                                  bool strict_capacity_limit) {
    auto type = GetParam();
    if (type == kLRU) {
-      LRUCacheOptions co;
-      co.capacity = capacity;
-      co.num_shard_bits = num_shard_bits;
-      co.strict_capacity_limit = strict_capacity_limit;
-      co.high_pri_pool_ratio = 0;
-      co.metadata_charge_policy = charge_policy;
-      return NewLRUCache(co);
+      return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit, 0.0);
    }
    if (type == kClock) {
-      return NewClockCache(capacity, num_shard_bits, strict_capacity_limit,
-                           charge_policy);
+      return NewClockCache(capacity, num_shard_bits, strict_capacity_limit);
    }
    return nullptr;
  }
@@ -151,15 +143,10 @@ class CacheTest : public testing::TestWithParam<std::string> {
 };
 CacheTest* CacheTest::current_;

-class LRUCacheTest : public CacheTest {};
-
 TEST_P(CacheTest, UsageTest) {
  // cache is std::shared_ptr and will be automatically cleaned up.
  const uint64_t kCapacity = 100000;
-  auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
-  auto precise_cache = NewCache(kCapacity, 0, false, kFullChargeCacheMetadata);
-  ASSERT_EQ(0, cache->GetUsage());
-  ASSERT_EQ(0, precise_cache->GetUsage());
+  auto cache = NewCache(kCapacity, 8, false);

  size_t usage = 0;
  char value[10] = "abcdef";
@@ -168,45 +155,31 @@ TEST_P(CacheTest, UsageTest) {
    std::string key(i, 'a');
    auto kv_size = key.size() + 5;
    cache->Insert(key, reinterpret_cast<void*>(value), kv_size, dumbDeleter);
-    precise_cache->Insert(key, reinterpret_cast<void*>(value), kv_size,
-                          dumbDeleter);
    usage += kv_size;
    ASSERT_EQ(usage, cache->GetUsage());
-    ASSERT_LT(usage, precise_cache->GetUsage());
  }

-  cache->EraseUnRefEntries();
-  precise_cache->EraseUnRefEntries();
-  ASSERT_EQ(0, cache->GetUsage());
-  ASSERT_EQ(0, precise_cache->GetUsage());
-
  // make sure the cache will be overloaded
  for (uint64_t i = 1; i < kCapacity; ++i) {
    auto key = ToString(i);
    cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
                  dumbDeleter);
-    precise_cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                          dumbDeleter);
  }

  // the usage should be close to the capacity
  ASSERT_GT(kCapacity, cache->GetUsage());
-  ASSERT_GT(kCapacity, precise_cache->GetUsage());
  ASSERT_LT(kCapacity * 0.95, cache->GetUsage());
-  ASSERT_LT(kCapacity * 0.95, precise_cache->GetUsage());
 }

 TEST_P(CacheTest, PinnedUsageTest) {
  // cache is std::shared_ptr and will be automatically cleaned up.
-  const uint64_t kCapacity = 200000;
-  auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
-  auto precise_cache = NewCache(kCapacity, 8, false, kFullChargeCacheMetadata);
+  const uint64_t kCapacity = 100000;
+  auto cache = NewCache(kCapacity, 8, false);

  size_t pinned_usage = 0;
  char value[10] = "abcdef";

  std::forward_list<Cache::Handle*> unreleased_handles;
-  std::forward_list<Cache::Handle*> unreleased_handles_in_precise_cache;

  // Add entries. Unpin some of them after insertion. Then, pin some of them
  // again. Check GetPinnedUsage().
@@ -214,72 +187,40 @@ TEST_P(CacheTest, PinnedUsageTest) {
    std::string key(i, 'a');
    auto kv_size = key.size() + 5;
    Cache::Handle* handle;
-    Cache::Handle* handle_in_precise_cache;
    cache->Insert(key, reinterpret_cast<void*>(value), kv_size, dumbDeleter,
                  &handle);
-    assert(handle);
-    precise_cache->Insert(key, reinterpret_cast<void*>(value), kv_size,
-                          dumbDeleter, &handle_in_precise_cache);
-    assert(handle_in_precise_cache);
    pinned_usage += kv_size;
    ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
-    ASSERT_LT(pinned_usage, precise_cache->GetPinnedUsage());
    if (i % 2 == 0) {
      cache->Release(handle);
-      precise_cache->Release(handle_in_precise_cache);
      pinned_usage -= kv_size;
      ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
-      ASSERT_LT(pinned_usage, precise_cache->GetPinnedUsage());
    } else {
      unreleased_handles.push_front(handle);
-      unreleased_handles_in_precise_cache.push_front(handle_in_precise_cache);
    }
    if (i % 3 == 0) {
      unreleased_handles.push_front(cache->Lookup(key));
-      auto x = precise_cache->Lookup(key);
-      assert(x);
-      unreleased_handles_in_precise_cache.push_front(x);
      // If i % 2 == 0, then the entry was unpinned before Lookup, so pinned
      // usage increased
      if (i % 2 == 0) {
        pinned_usage += kv_size;
      }
      ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
-      ASSERT_LT(pinned_usage, precise_cache->GetPinnedUsage());
    }
  }
-  auto precise_cache_pinned_usage = precise_cache->GetPinnedUsage();
-  ASSERT_LT(pinned_usage, precise_cache_pinned_usage);

  // check that overloading the cache does not change the pinned usage
  for (uint64_t i = 1; i < 2 * kCapacity; ++i) {
    auto key = ToString(i);
    cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
                  dumbDeleter);
-    precise_cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                          dumbDeleter);
  }
  ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
-  ASSERT_EQ(precise_cache_pinned_usage, precise_cache->GetPinnedUsage());
-
-  cache->EraseUnRefEntries();
-  precise_cache->EraseUnRefEntries();
-  ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
-  ASSERT_EQ(precise_cache_pinned_usage, precise_cache->GetPinnedUsage());

  // release handles for pinned entries to prevent memory leaks
  for (auto handle : unreleased_handles) {
    cache->Release(handle);
  }
-  for (auto handle : unreleased_handles_in_precise_cache) {
-    precise_cache->Release(handle);
-  }
-  ASSERT_EQ(0, cache->GetPinnedUsage());
-  ASSERT_EQ(0, precise_cache->GetPinnedUsage());
-  cache->EraseUnRefEntries();
-  precise_cache->EraseUnRefEntries();
-  ASSERT_EQ(0, cache->GetUsage());
-  ASSERT_EQ(0, precise_cache->GetUsage());
 }

 TEST_P(CacheTest, HitAndMiss) {
@@ -609,10 +550,10 @@ TEST_P(CacheTest, SetCapacity) {
  }
 }

-TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
+TEST_P(CacheTest, SetStrictCapacityLimit) {
  // test1: set the flag to false. Insert more keys than capacity. See if they
  // all go through.
-  std::shared_ptr<Cache> cache = NewCache(5, 0, false);
+  std::shared_ptr<Cache> cache = NewLRUCache(5, 0, false);
  std::vector<Cache::Handle*> handles(10);
  Status s;
  for (size_t i = 0; i < 10; i++) {
@@ -638,7 +579,7 @@ TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
  }

  // test3: init with flag being true.
-  std::shared_ptr<Cache> cache2 = NewCache(5, 0, true);
+  std::shared_ptr<Cache> cache2 = NewLRUCache(5, 0, true);
  for (size_t i = 0; i < 5; i++) {
    std::string key = ToString(i + 1);
    s = cache2->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
@@ -756,14 +697,13 @@ TEST_P(CacheTest, GetCharge) {
 }

 #ifdef SUPPORT_CLOCK_CACHE
-std::shared_ptr<Cache> (*new_clock_cache_func)(
-    size_t, int, bool, CacheMetadataChargePolicy) = NewClockCache;
+std::shared_ptr<Cache> (*new_clock_cache_func)(size_t, int,
+                                               bool) = NewClockCache;
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
                        testing::Values(kLRU, kClock));
 #else
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest, testing::Values(kLRU));
 #endif  // SUPPORT_CLOCK_CACHE
-INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest, testing::Values(kLRU));

 }  // namespace rocksdb

@@ -13,9 +13,8 @@

 namespace rocksdb {

-std::shared_ptr<Cache> NewClockCache(
-    size_t /*capacity*/, int /*num_shard_bits*/, bool /*strict_capacity_limit*/,
-    CacheMetadataChargePolicy /*metadata_charge_policy*/) {
+std::shared_ptr<Cache> NewClockCache(size_t /*capacity*/, int /*num_shard_bits*/,
+                                     bool /*strict_capacity_limit*/) {
  // Clock cache not supported.
  return nullptr;
 }
@@ -36,7 +35,6 @@ std::shared_ptr<Cache> NewClockCache(
 #include "tbb/concurrent_hash_map.h"

 #include "cache/sharded_cache.h"
-#include "port/malloc.h"
 #include "port/port.h"
 #include "util/autovector.h"
 #include "util/mutexlock.h"
@@ -204,27 +202,6 @@ struct CacheHandle {
    deleter = a.deleter;
    return *this;
  }
-
-  inline static size_t CalcTotalCharge(
-      Slice key, size_t charge,
-      CacheMetadataChargePolicy metadata_charge_policy) {
-    size_t meta_charge = 0;
-    if (metadata_charge_policy == kFullChargeCacheMetadata) {
-      meta_charge += sizeof(CacheHandle);
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      meta_charge +=
-          malloc_usable_size(static_cast<void*>(const_cast<char*>(key.data())));
-#else
-      meta_charge += key.size();
-#endif
-    }
-    return charge + meta_charge;
-  }
-
-  inline size_t CalcTotalCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) {
-    return CalcTotalCharge(key, charge, metadata_charge_policy);
-  }
 };

 // Key of hash map. We store hash value with the key for convenience.
@@ -427,12 +404,11 @@ void ClockCacheShard::RecycleHandle(CacheHandle* handle,
  assert(!InCache(handle->flags) && CountRefs(handle->flags) == 0);
  context->to_delete_key.push_back(handle->key.data());
  context->to_delete_value.emplace_back(*handle);
-  size_t total_charge = handle->CalcTotalCharge(metadata_charge_policy_);
  handle->key.clear();
  handle->value = nullptr;
  handle->deleter = nullptr;
  recycle_.push_back(handle);
-  usage_.fetch_sub(total_charge, std::memory_order_relaxed);
+  usage_.fetch_sub(handle->charge, std::memory_order_relaxed);
 }

 void ClockCacheShard::Cleanup(const CleanupContext& context) {
@@ -458,8 +434,7 @@ bool ClockCacheShard::Ref(Cache::Handle* h) {
                                            std::memory_order_relaxed)) {
      if (CountRefs(flags) == 0) {
        // No reference count before the operation.
-        size_t total_charge = handle->CalcTotalCharge(metadata_charge_policy_);
-        pinned_usage_.fetch_add(total_charge, std::memory_order_relaxed);
+        pinned_usage_.fetch_add(handle->charge, std::memory_order_relaxed);
      }
      return true;
    }
@@ -479,8 +454,7 @@ bool ClockCacheShard::Unref(CacheHandle* handle, bool set_usage,
  assert(CountRefs(flags) > 0);
  if (CountRefs(flags) == 1) {
    // this is the last reference.
-    size_t total_charge = handle->CalcTotalCharge(metadata_charge_policy_);
-    pinned_usage_.fetch_sub(total_charge, std::memory_order_relaxed);
+    pinned_usage_.fetch_sub(handle->charge, std::memory_order_relaxed);
    // Cleanup if it is the last reference.
    if (!InCache(flags)) {
      MutexLock l(&mutex_);
@@ -565,10 +539,8 @@ CacheHandle* ClockCacheShard::Insert(
    const Slice& key, uint32_t hash, void* value, size_t charge,
    void (*deleter)(const Slice& key, void* value), bool hold_reference,
    CleanupContext* context) {
-  size_t total_charge =
-      CacheHandle::CalcTotalCharge(key, charge, metadata_charge_policy_);
  MutexLock l(&mutex_);
-  bool success = EvictFromCache(total_charge, context);
+  bool success = EvictFromCache(charge, context);
  bool strict = strict_capacity_limit_.load(std::memory_order_relaxed);
  if (!success && (strict || !hold_reference)) {
    context->to_delete_key.push_back(key.data());
@@ -603,9 +575,9 @@ CacheHandle* ClockCacheShard::Insert(
  }
  table_.insert(HashTable::value_type(CacheKey(key, hash), handle));
  if (hold_reference) {
-    pinned_usage_.fetch_add(total_charge, std::memory_order_relaxed);
+    pinned_usage_.fetch_add(charge, std::memory_order_relaxed);
  }
-  usage_.fetch_add(total_charge, std::memory_order_relaxed);
+  usage_.fetch_add(charge, std::memory_order_relaxed);
  return handle;
 }

@@ -702,14 +674,10 @@ void ClockCacheShard::EraseUnRefEntries() {

 class ClockCache final : public ShardedCache {
 public:
-  ClockCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-             CacheMetadataChargePolicy metadata_charge_policy)
+  ClockCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit)
      : ShardedCache(capacity, num_shard_bits, strict_capacity_limit) {
    int num_shards = 1 << num_shard_bits;
    shards_ = new ClockCacheShard[num_shards];
-    for (int i = 0; i < num_shards; i++) {
-      shards_[i].set_metadata_charge_policy(metadata_charge_policy);
-    }
    SetCapacity(capacity);
    SetStrictCapacityLimit(strict_capacity_limit);
  }
@@ -746,14 +714,13 @@ class ClockCache final : public ShardedCache {

 }  // end anonymous namespace

-std::shared_ptr<Cache> NewClockCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    CacheMetadataChargePolicy metadata_charge_policy) {
+std::shared_ptr<Cache> NewClockCache(size_t capacity, int num_shard_bits,
+                                     bool strict_capacity_limit) {
  if (num_shard_bits < 0) {
    num_shard_bits = GetDefaultCacheShardBits(capacity);
  }
-  return std::make_shared<ClockCache>(
-      capacity, num_shard_bits, strict_capacity_limit, metadata_charge_policy);
+  return std::make_shared<ClockCache>(capacity, num_shard_bits,
+                                      strict_capacity_limit);
 }

 }  // namespace rocksdb
@@ -97,8 +97,7 @@ void LRUHandleTable::Resize() {

 LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
                             double high_pri_pool_ratio,
-                             bool use_adaptive_mutex,
-                             CacheMetadataChargePolicy metadata_charge_policy)
+                             bool use_adaptive_mutex)
    : capacity_(0),
      high_pri_pool_usage_(0),
      strict_capacity_limit_(strict_capacity_limit),
@@ -107,7 +106,6 @@ LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
      usage_(0),
      lru_usage_(0),
      mutex_(use_adaptive_mutex) {
-  set_metadata_charge_policy(metadata_charge_policy);
  // Make empty circular linked list
  lru_.next = &lru_;
  lru_.prev = &lru_;
@@ -126,9 +124,7 @@ void LRUCacheShard::EraseUnRefEntries() {
      LRU_Remove(old);
      table_.Remove(old->key(), old->hash);
      old->SetInCache(false);
-      size_t total_charge = old->CalcTotalCharge(metadata_charge_policy_);
-      assert(usage_ >= total_charge);
-      usage_ -= total_charge;
+      usage_ -= old->charge;
      last_reference_list.push_back(old);
    }
  }
@@ -184,19 +180,16 @@ void LRUCacheShard::LRU_Remove(LRUHandle* e) {
  e->next->prev = e->prev;
  e->prev->next = e->next;
  e->prev = e->next = nullptr;
-  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
-  assert(lru_usage_ >= total_charge);
-  lru_usage_ -= total_charge;
+  lru_usage_ -= e->charge;
  if (e->InHighPriPool()) {
-    assert(high_pri_pool_usage_ >= total_charge);
-    high_pri_pool_usage_ -= total_charge;
+    assert(high_pri_pool_usage_ >= e->charge);
+    high_pri_pool_usage_ -= e->charge;
  }
 }

 void LRUCacheShard::LRU_Insert(LRUHandle* e) {
  assert(e->next == nullptr);
  assert(e->prev == nullptr);
-  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
  if (high_pri_pool_ratio_ > 0 && (e->IsHighPri() || e->HasHit())) {
    // Inset "e" to head of LRU list.
    e->next = &lru_;
@@ -204,7 +197,7 @@ void LRUCacheShard::LRU_Insert(LRUHandle* e) {
    e->prev->next = e;
    e->next->prev = e;
    e->SetInHighPriPool(true);
-    high_pri_pool_usage_ += total_charge;
+    high_pri_pool_usage_ += e->charge;
    MaintainPoolSize();
  } else {
    // Insert "e" to the head of low-pri pool. Note that when
@@ -216,7 +209,7 @@ void LRUCacheShard::LRU_Insert(LRUHandle* e) {
    e->SetInHighPriPool(false);
    lru_low_pri_ = e;
  }
-  lru_usage_ += total_charge;
+  lru_usage_ += e->charge;
 }

 void LRUCacheShard::MaintainPoolSize() {
@@ -225,10 +218,7 @@ void LRUCacheShard::MaintainPoolSize() {
    lru_low_pri_ = lru_low_pri_->next;
    assert(lru_low_pri_ != &lru_);
    lru_low_pri_->SetInHighPriPool(false);
-    size_t total_charge =
-        lru_low_pri_->CalcTotalCharge(metadata_charge_policy_);
-    assert(high_pri_pool_usage_ >= total_charge);
-    high_pri_pool_usage_ -= total_charge;
+    high_pri_pool_usage_ -= lru_low_pri_->charge;
  }
 }

@@ -241,9 +231,7 @@ void LRUCacheShard::EvictFromLRU(size_t charge,
    LRU_Remove(old);
    table_.Remove(old->key(), old->hash);
    old->SetInCache(false);
-    size_t old_total_charge = old->CalcTotalCharge(metadata_charge_policy_);
-    assert(usage_ >= old_total_charge);
-    usage_ -= old_total_charge;
+    usage_ -= old->charge;
    deleted->push_back(old);
  }
 }
@@ -323,9 +311,7 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool force_erase) {
      }
    }
    if (last_reference) {
-      size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
-      assert(usage_ >= total_charge);
-      usage_ -= total_charge;
+      usage_ -= e->charge;
    }
  }

@@ -359,16 +345,15 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  e->SetInCache(true);
  e->SetPriority(priority);
  memcpy(e->key_data, key.data(), key.size());
-  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);

  {
    MutexLock l(&mutex_);

    // Free the space following strict LRU policy until enough space
    // is freed or the lru list is empty
-    EvictFromLRU(total_charge, &last_reference_list);
+    EvictFromLRU(charge, &last_reference_list);

-    if ((usage_ + total_charge) > capacity_ &&
+    if ((usage_ + charge) > capacity_ &&
        (strict_capacity_limit_ || handle == nullptr)) {
      if (handle == nullptr) {
        // Don't insert the entry but still return ok, as if the entry inserted
@@ -384,17 +369,14 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
      // Insert into the cache. Note that the cache might get larger than its
      // capacity if not enough space was freed up.
      LRUHandle* old = table_.Insert(e);
-      usage_ += total_charge;
+      usage_ += e->charge;
      if (old != nullptr) {
        assert(old->InCache());
        old->SetInCache(false);
        if (!old->HasRefs()) {
          // old is on LRU because it's in cache and its reference count is 0
          LRU_Remove(old);
-          size_t old_total_charge =
-              old->CalcTotalCharge(metadata_charge_policy_);
-          assert(usage_ >= old_total_charge);
-          usage_ -= old_total_charge;
+          usage_ -= old->charge;
          last_reference_list.push_back(old);
        }
      }
@@ -427,9 +409,7 @@ void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
      if (!e->HasRefs()) {
        // The entry is in LRU since it's in hash and has no external references
        LRU_Remove(e);
-        size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
-        assert(usage_ >= total_charge);
-        usage_ -= total_charge;
+        usage_ -= e->charge;
        last_reference = true;
      }
    }
@@ -467,8 +447,7 @@ std::string LRUCacheShard::GetPrintableOptions() const {
 LRUCache::LRUCache(size_t capacity, int num_shard_bits,
                   bool strict_capacity_limit, double high_pri_pool_ratio,
                   std::shared_ptr<MemoryAllocator> allocator,
-                   bool use_adaptive_mutex,
-                   CacheMetadataChargePolicy metadata_charge_policy)
+                   bool use_adaptive_mutex)
    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
                   std::move(allocator)) {
  num_shards_ = 1 << num_shard_bits;
@@ -478,7 +457,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
  for (int i = 0; i < num_shards_; i++) {
    new (&shards_[i])
        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio,
-                      use_adaptive_mutex, metadata_charge_policy);
+            use_adaptive_mutex);
  }
 }

@@ -547,15 +526,15 @@ std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
  return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
                     cache_opts.strict_capacity_limit,
                     cache_opts.high_pri_pool_ratio,
-                     cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
-                     cache_opts.metadata_charge_policy);
+                     cache_opts.memory_allocator,
+                     cache_opts.use_adaptive_mutex);
 }

 std::shared_ptr<Cache> NewLRUCache(
    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
    double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy) {
+    std::shared_ptr<MemoryAllocator> memory_allocator,
+    bool use_adaptive_mutex) {
  if (num_shard_bits >= 20) {
    return nullptr;  // the cache cannot be sharded into too many fine pieces
  }
@@ -566,9 +545,10 @@ std::shared_ptr<Cache> NewLRUCache(
  if (num_shard_bits < 0) {
    num_shard_bits = GetDefaultCacheShardBits(capacity);
  }
-  return std::make_shared<LRUCache>(
-      capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      std::move(memory_allocator), use_adaptive_mutex, metadata_charge_policy);
+  return std::make_shared<LRUCache>(capacity, num_shard_bits,
+                                    strict_capacity_limit, high_pri_pool_ratio,
+                                    std::move(memory_allocator),
+                                    use_adaptive_mutex);
 }

 }  // namespace rocksdb
@@ -12,7 +12,6 @@

 #include "cache/sharded_cache.h"

-#include "port/malloc.h"
 #include "port/port.h"
 #include "util/autovector.h"

@@ -129,22 +128,6 @@ struct LRUHandle {
    }
    delete[] reinterpret_cast<char*>(this);
  }
-
-  // Caclculate the memory usage by metadata
-  inline size_t CalcTotalCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) {
-    assert(key_length);
-    size_t meta_charge = 0;
-    if (metadata_charge_policy == kFullChargeCacheMetadata) {
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      meta_charge += malloc_usable_size(static_cast<void*>(this));
-#else
-      // This is the size that is used when a new handle is created
-      meta_charge += sizeof(LRUHandle) - 1 + key_length;
-#endif
-    }
-    return charge + meta_charge;
-  }
 };

 // We provide our own simple hash table since it removes a whole bunch
@@ -193,8 +176,7 @@ class LRUHandleTable {
 class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 public:
  LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                double high_pri_pool_ratio, bool use_adaptive_mutex,
-                CacheMetadataChargePolicy metadata_charge_policy);
+                double high_pri_pool_ratio, bool use_adaptive_mutex);
  virtual ~LRUCacheShard() override = default;

  // Separate from constructor so caller can easily make an array of LRUCache
@@ -315,9 +297,7 @@ class LRUCache
  LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
           double high_pri_pool_ratio,
           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-           bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
-           CacheMetadataChargePolicy metadata_charge_policy =
-               kDontChargeCacheMetadata);
+           bool use_adaptive_mutex = kDefaultToAdaptiveMutex);
  virtual ~LRUCache();
  virtual const char* Name() const override { return "LRUCache"; }
  virtual CacheShard* GetShard(int shard) override;
@@ -31,8 +31,7 @@ class LRUCacheTest : public testing::Test {
    cache_ = reinterpret_cast<LRUCacheShard*>(
        port::cacheline_aligned_alloc(sizeof(LRUCacheShard)));
    new (cache_) LRUCacheShard(capacity, false /*strict_capcity_limit*/,
-                               high_pri_pool_ratio, use_adaptive_mutex,
-                               kDontChargeCacheMetadata);
+                               high_pri_pool_ratio, use_adaptive_mutex);
  }

  void Insert(const std::string& key,
@@ -40,13 +40,6 @@ class CacheShard {
                                      bool thread_safe) = 0;
  virtual void EraseUnRefEntries() = 0;
  virtual std::string GetPrintableOptions() const { return ""; }
-  void set_metadata_charge_policy(
-      CacheMetadataChargePolicy metadata_charge_policy) {
-    metadata_charge_policy_ = metadata_charge_policy;
-  }
-
- protected:
-  CacheMetadataChargePolicy metadata_charge_policy_ = kDontChargeCacheMetadata;
 };

 // Generic cache interface which shards cache by hash of keys. 2^num_shard_bits
@@ -1,106 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "db/arena_wrapped_db_iter.h"
-#include "memory/arena.h"
-#include "rocksdb/env.h"
-#include "rocksdb/iterator.h"
-#include "rocksdb/options.h"
-#include "table/internal_iterator.h"
-#include "table/iterator_wrapper.h"
-#include "util/user_comparator_wrapper.h"
-
-namespace rocksdb {
-
-Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
-                                       std::string* prop) {
-  if (prop_name == "rocksdb.iterator.super-version-number") {
-    // First try to pass the value returned from inner iterator.
-    if (!db_iter_->GetProperty(prop_name, prop).ok()) {
-      *prop = ToString(sv_number_);
-    }
-    return Status::OK();
-  }
-  return db_iter_->GetProperty(prop_name, prop);
-}
-
-void ArenaWrappedDBIter::Init(Env* env, const ReadOptions& read_options,
-                              const ImmutableCFOptions& cf_options,
-                              const MutableCFOptions& mutable_cf_options,
-                              const SequenceNumber& sequence,
-                              uint64_t max_sequential_skip_in_iteration,
-                              uint64_t version_number,
-                              ReadCallback* read_callback, DBImpl* db_impl,
-                              ColumnFamilyData* cfd, bool allow_blob,
-                              bool allow_refresh) {
-  auto mem = arena_.AllocateAligned(sizeof(DBIter));
-  db_iter_ = new (mem) DBIter(env, read_options, cf_options, mutable_cf_options,
-                              cf_options.user_comparator, nullptr, sequence,
-                              true, max_sequential_skip_in_iteration,
-                              read_callback, db_impl, cfd, allow_blob);
-  sv_number_ = version_number;
-  allow_refresh_ = allow_refresh;
-}
-
-Status ArenaWrappedDBIter::Refresh() {
-  if (cfd_ == nullptr || db_impl_ == nullptr || !allow_refresh_) {
-    return Status::NotSupported("Creating renew iterator is not allowed.");
-  }
-  assert(db_iter_ != nullptr);
-  // TODO(yiwu): For last_seq_same_as_publish_seq_==false, this is not the
-  // correct behavior. Will be corrected automatically when we take a snapshot
-  // here for the case of WritePreparedTxnDB.
-  SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
-  uint64_t cur_sv_number = cfd_->GetSuperVersionNumber();
-  if (sv_number_ != cur_sv_number) {
-    Env* env = db_iter_->env();
-    db_iter_->~DBIter();
-    arena_.~Arena();
-    new (&arena_) Arena();
-
-    SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex());
-    if (read_callback_) {
-      read_callback_->Refresh(latest_seq);
-    }
-    Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
-         latest_seq, sv->mutable_cf_options.max_sequential_skip_in_iterations,
-         cur_sv_number, read_callback_, db_impl_, cfd_, allow_blob_,
-         allow_refresh_);
-
-    InternalIterator* internal_iter = db_impl_->NewInternalIterator(
-        read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator(),
-        latest_seq);
-    SetIterUnderDBIter(internal_iter);
-  } else {
-    db_iter_->set_sequence(latest_seq);
-    db_iter_->set_valid(false);
-  }
-  return Status::OK();
-}
-
-ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options,
-    const ImmutableCFOptions& cf_options,
-    const MutableCFOptions& mutable_cf_options, const SequenceNumber& sequence,
-    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-    ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
-    bool allow_blob, bool allow_refresh) {
-  ArenaWrappedDBIter* iter = new ArenaWrappedDBIter();
-  iter->Init(env, read_options, cf_options, mutable_cf_options, sequence,
-             max_sequential_skip_in_iterations, version_number, read_callback,
-             db_impl, cfd, allow_blob, allow_refresh);
-  if (db_impl != nullptr && cfd != nullptr && allow_refresh) {
-    iter->StoreRefreshInfo(read_options, db_impl, cfd, read_callback,
-                           allow_blob);
-  }
-
-  return iter;
-}
-
-}  // namespace rocksdb
@@ -1,112 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <stdint.h>
-#include <string>
-#include "db/db_impl/db_impl.h"
-#include "db/db_iter.h"
-#include "db/dbformat.h"
-#include "db/range_del_aggregator.h"
-#include "memory/arena.h"
-#include "options/cf_options.h"
-#include "rocksdb/db.h"
-#include "rocksdb/iterator.h"
-#include "util/autovector.h"
-
-namespace rocksdb {
-
-class Arena;
-
-// A wrapper iterator which wraps DB Iterator and the arena, with which the DB
-// iterator is supposed to be allocated. This class is used as an entry point of
-// a iterator hierarchy whose memory can be allocated inline. In that way,
-// accessing the iterator tree can be more cache friendly. It is also faster
-// to allocate.
-// When using the class's Iterator interface, the behavior is exactly
-// the same as the inner DBIter.
-class ArenaWrappedDBIter : public Iterator {
- public:
-  virtual ~ArenaWrappedDBIter() { db_iter_->~DBIter(); }
-
-  // Get the arena to be used to allocate memory for DBIter to be wrapped,
-  // as well as child iterators in it.
-  virtual Arena* GetArena() { return &arena_; }
-  virtual ReadRangeDelAggregator* GetRangeDelAggregator() {
-    return db_iter_->GetRangeDelAggregator();
-  }
-
-  // Set the internal iterator wrapped inside the DB Iterator. Usually it is
-  // a merging iterator.
-  virtual void SetIterUnderDBIter(InternalIterator* iter) {
-    static_cast<DBIter*>(db_iter_)->SetIter(iter);
-  }
-
-  virtual bool Valid() const override { return db_iter_->Valid(); }
-  virtual void SeekToFirst() override { db_iter_->SeekToFirst(); }
-  virtual void SeekToLast() override { db_iter_->SeekToLast(); }
-  virtual void Seek(const Slice& target) override { db_iter_->Seek(target); }
-  virtual void SeekForPrev(const Slice& target) override {
-    db_iter_->SeekForPrev(target);
-  }
-  virtual void Next() override { db_iter_->Next(); }
-  virtual void Prev() override { db_iter_->Prev(); }
-  virtual Slice key() const override { return db_iter_->key(); }
-  virtual Slice value() const override { return db_iter_->value(); }
-  virtual Status status() const override { return db_iter_->status(); }
-  bool IsBlob() const { return db_iter_->IsBlob(); }
-
-  virtual Status GetProperty(std::string prop_name, std::string* prop) override;
-
-  virtual Status Refresh() override;
-
-  void Init(Env* env, const ReadOptions& read_options,
-            const ImmutableCFOptions& cf_options,
-            const MutableCFOptions& mutable_cf_options,
-            const SequenceNumber& sequence,
-            uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-            ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
-            bool allow_blob, bool allow_refresh);
-
-  // Store some parameters so we can refresh the iterator at a later point
-  // with these same params
-  void StoreRefreshInfo(const ReadOptions& read_options, DBImpl* db_impl,
-                        ColumnFamilyData* cfd, ReadCallback* read_callback,
-                        bool allow_blob) {
-    read_options_ = read_options;
-    db_impl_ = db_impl;
-    cfd_ = cfd;
-    read_callback_ = read_callback;
-    allow_blob_ = allow_blob;
-  }
-
- private:
-  DBIter* db_iter_;
-  Arena arena_;
-  uint64_t sv_number_;
-  ColumnFamilyData* cfd_ = nullptr;
-  DBImpl* db_impl_ = nullptr;
-  ReadOptions read_options_;
-  ReadCallback* read_callback_;
-  bool allow_blob_ = false;
-  bool allow_refresh_ = true;
-};
-
-// Generate the arena wrapped iterator class.
-// `db_impl` and `cfd` are used for reneweal. If left null, renewal will not
-// be supported.
-extern ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options,
-    const ImmutableCFOptions& cf_options,
-    const MutableCFOptions& mutable_cf_options, const SequenceNumber& sequence,
-    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
-    ReadCallback* read_callback, DBImpl* db_impl = nullptr,
-    ColumnFamilyData* cfd = nullptr, bool allow_blob = false,
-    bool allow_refresh = true);
-}  // namespace rocksdb
@@ -22,8 +22,6 @@
 #include "db/table_cache.h"
 #include "db/version_edit.h"
 #include "file/filename.h"
-#include "file/read_write_util.h"
-#include "file/writable_file_writer.h"
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/thread_status_util.h"
 #include "rocksdb/db.h"
@@ -35,6 +33,7 @@
 #include "table/format.h"
 #include "table/internal_iterator.h"
 #include "test_util/sync_point.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"

 namespace rocksdb {
@@ -2272,6 +2272,11 @@ void rocksdb_options_set_max_bytes_for_level_base(
  opt->rep.max_bytes_for_level_base = n;
 }

+void rocksdb_options_set_snap_refresh_nanos(rocksdb_options_t* opt,
+                                            uint64_t n) {
+  opt->rep.snap_refresh_nanos = n;
+}
+
 void rocksdb_options_set_level_compaction_dynamic_level_bytes(
    rocksdb_options_t* opt, unsigned char v) {
  opt->rep.level_compaction_dynamic_level_bytes = v;
@@ -9,11 +9,11 @@

 #include "db/column_family.h"

-#include <algorithm>
 #include <cinttypes>
-#include <limits>
-#include <string>
 #include <vector>
+#include <string>
+#include <algorithm>
+#include <limits>

 #include "db/compaction/compaction_picker.h"
 #include "db/compaction/compaction_picker_fifo.h"
@@ -38,7 +38,7 @@ CompactionIterator::CompactionIterator(
    const CompactionFilter* compaction_filter,
    const std::atomic<bool>* shutting_down,
    const SequenceNumber preserve_deletes_seqnum,
-    const std::atomic<bool>* manual_compaction_paused)
+    SnapshotListFetchCallback* snap_list_callback)
    : CompactionIterator(
          input, cmp, merge_helper, last_sequence, snapshots,
          earliest_write_conflict_snapshot, snapshot_checker, env,
@@ -46,7 +46,7 @@ CompactionIterator::CompactionIterator(
          std::unique_ptr<CompactionProxy>(
              compaction ? new CompactionProxy(compaction) : nullptr),
          compaction_filter, shutting_down, preserve_deletes_seqnum,
-          manual_compaction_paused) {}
+          snap_list_callback) {}

 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
@@ -59,7 +59,7 @@ CompactionIterator::CompactionIterator(
    const CompactionFilter* compaction_filter,
    const std::atomic<bool>* shutting_down,
    const SequenceNumber preserve_deletes_seqnum,
-    const std::atomic<bool>* manual_compaction_paused)
+    SnapshotListFetchCallback* snap_list_callback)
    : input_(input),
      cmp_(cmp),
      merge_helper_(merge_helper),
@@ -73,12 +73,12 @@ CompactionIterator::CompactionIterator(
      compaction_(std::move(compaction)),
      compaction_filter_(compaction_filter),
      shutting_down_(shutting_down),
-      manual_compaction_paused_(manual_compaction_paused),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
      current_user_key_sequence_(0),
      current_user_key_snapshot_(0),
      merge_out_iter_(merge_helper_),
-      current_key_committed_(false) {
+      current_key_committed_(false),
+      snap_list_callback_(snap_list_callback) {
  assert(compaction_filter_ == nullptr || compaction_ != nullptr);
  assert(snapshots_ != nullptr);
  bottommost_level_ =
@@ -86,24 +86,7 @@ CompactionIterator::CompactionIterator(
  if (compaction_ != nullptr) {
    level_ptrs_ = std::vector<size_t>(compaction_->number_levels(), 0);
  }
-  if (snapshots_->size() == 0) {
-    // optimize for fast path if there are no snapshots
-    visible_at_tip_ = true;
-    earliest_snapshot_iter_ = snapshots_->end();
-    earliest_snapshot_ = kMaxSequenceNumber;
-    latest_snapshot_ = 0;
-  } else {
-    visible_at_tip_ = false;
-    earliest_snapshot_iter_ = snapshots_->begin();
-    earliest_snapshot_ = snapshots_->at(0);
-    latest_snapshot_ = snapshots_->back();
-  }
-#ifndef NDEBUG
-  // findEarliestVisibleSnapshot assumes this ordering.
-  for (size_t i = 1; i < snapshots_->size(); ++i) {
-    assert(snapshots_->at(i - 1) < snapshots_->at(i));
-  }
-#endif
+  ProcessSnapshotList();
  input_->SetPinnedItersMgr(&pinned_iters_mgr_);
  TEST_SYNC_POINT_CALLBACK("CompactionIterator:AfterInit", compaction_.get());
 }
@@ -225,12 +208,33 @@ void CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
  }
 }

+void CompactionIterator::ProcessSnapshotList() {
+#ifndef NDEBUG
+  // findEarliestVisibleSnapshot assumes this ordering.
+  for (size_t i = 1; i < snapshots_->size(); ++i) {
+    assert(snapshots_->at(i - 1) < snapshots_->at(i));
+  }
+#endif
+  if (snapshots_->size() == 0) {
+    // optimize for fast path if there are no snapshots
+    visible_at_tip_ = true;
+    earliest_snapshot_iter_ = snapshots_->end();
+    earliest_snapshot_ = kMaxSequenceNumber;
+    latest_snapshot_ = 0;
+  } else {
+    visible_at_tip_ = false;
+    earliest_snapshot_iter_ = snapshots_->begin();
+    earliest_snapshot_ = snapshots_->at(0);
+    latest_snapshot_ = snapshots_->back();
+  }
+  released_snapshots_.clear();
+}
+
 void CompactionIterator::NextFromInput() {
  at_next_ = false;
  valid_ = false;

-  while (!valid_ && input_->Valid() && !IsPausingManualCompaction() &&
-         !IsShuttingDown()) {
+  while (!valid_ && input_->Valid() && !IsShuttingDown()) {
    key_ = input_->key();
    value_ = input_->value();
    iter_stats_.num_input_records++;
@@ -273,6 +277,13 @@ void CompactionIterator::NextFromInput() {
    // compaction filter). ikey_.user_key is pointing to the copy.
    if (!has_current_user_key_ ||
        !cmp_->Equal(ikey_.user_key, current_user_key_)) {
+      num_keys_++;
+      // Use num_keys_ to reduce the overhead of reading current time
+      if (snap_list_callback_ && snapshots_->size() &&
+          snap_list_callback_->TimeToRefresh(num_keys_)) {
+        snap_list_callback_->Refresh(snapshots_, latest_snapshot_);
+        ProcessSnapshotList();
+      }
      // First occurrence of this user key
      // Copy key for output
      key_ = current_key_.SetInternalKey(key_, &ikey_);
@@ -601,10 +612,6 @@ void CompactionIterator::NextFromInput() {
  if (!valid_ && IsShuttingDown()) {
    status_ = Status::ShutdownInProgress();
  }
-
-  if (IsPausingManualCompaction()) {
-    status_ = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
-  }
 }

 void CompactionIterator::PrepareOutput() {
@@ -21,6 +21,54 @@

 namespace rocksdb {

+// This callback can be used to refresh the snapshot list from the db. It
+// includes logics to exponentially decrease the refresh rate to limit the
+// overhead of refresh.
+class SnapshotListFetchCallback {
+ public:
+  SnapshotListFetchCallback(Env* env, uint64_t snap_refresh_nanos,
+                            size_t every_nth_key = 1024)
+      : timer_(env, /*auto restart*/ true),
+        snap_refresh_nanos_(snap_refresh_nanos),
+        every_nth_key_minus_one_(every_nth_key - 1) {
+    assert(every_nth_key > 0);
+    assert((ceil(log2(every_nth_key)) == floor(log2(every_nth_key))));
+  }
+  // Refresh the snapshot list. snapshots will bre replacted with the new list.
+  // max is the upper bound. Note: this function will acquire the db_mutex_.
+  virtual void Refresh(std::vector<SequenceNumber>* snapshots,
+                       SequenceNumber max) = 0;
+  inline bool TimeToRefresh(const size_t key_index) {
+    assert(snap_refresh_nanos_ != 0);
+    // skip the key if key_index % every_nth_key (which is of power 2) is not 0.
+    if ((key_index & every_nth_key_minus_one_) != 0) {
+      return false;
+    }
+    const uint64_t elapsed = timer_.ElapsedNanos();
+    auto ret = elapsed > snap_refresh_nanos_;
+    // pre-compute the next time threshold
+    if (ret) {
+      // inc next refresh period exponentially (by x4)
+      auto next_refresh_threshold = snap_refresh_nanos_ << 2;
+      // make sure the shift has not overflown the highest 1 bit
+      snap_refresh_nanos_ =
+          std::max(snap_refresh_nanos_, next_refresh_threshold);
+    }
+    return ret;
+  }
+  static constexpr SnapshotListFetchCallback* kDisabled = nullptr;
+
+  virtual ~SnapshotListFetchCallback() {}
+
+ private:
+  // Time since the callback was created
+  StopWatchNano timer_;
+  // The delay before calling ::Refresh. To be increased exponentially.
+  uint64_t snap_refresh_nanos_;
+  // Skip evey nth key. Number n if of power 2. The math will require n-1.
+  const uint64_t every_nth_key_minus_one_;
+};
+
 class CompactionIterator {
 public:
  // A wrapper around Compaction. Has a much smaller interface, only what
@@ -59,32 +107,32 @@ class CompactionIterator {
    const Compaction* compaction_;
  };

-  CompactionIterator(
-      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_write_conflict_snapshot,
-      const SnapshotChecker* snapshot_checker, Env* env,
-      bool report_detailed_time, bool expect_valid_internal_key,
-      CompactionRangeDelAggregator* range_del_agg,
-      const Compaction* compaction = nullptr,
-      const CompactionFilter* compaction_filter = nullptr,
-      const std::atomic<bool>* shutting_down = nullptr,
-      const SequenceNumber preserve_deletes_seqnum = 0,
-      const std::atomic<bool>* manual_compaction_paused = nullptr);
+  CompactionIterator(InternalIterator* input, const Comparator* cmp,
+                     MergeHelper* merge_helper, SequenceNumber last_sequence,
+                     std::vector<SequenceNumber>* snapshots,
+                     SequenceNumber earliest_write_conflict_snapshot,
+                     const SnapshotChecker* snapshot_checker, Env* env,
+                     bool report_detailed_time, bool expect_valid_internal_key,
+                     CompactionRangeDelAggregator* range_del_agg,
+                     const Compaction* compaction = nullptr,
+                     const CompactionFilter* compaction_filter = nullptr,
+                     const std::atomic<bool>* shutting_down = nullptr,
+                     const SequenceNumber preserve_deletes_seqnum = 0,
+                     SnapshotListFetchCallback* snap_list_callback = nullptr);

  // Constructor with custom CompactionProxy, used for tests.
-  CompactionIterator(
-      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_write_conflict_snapshot,
-      const SnapshotChecker* snapshot_checker, Env* env,
-      bool report_detailed_time, bool expect_valid_internal_key,
-      CompactionRangeDelAggregator* range_del_agg,
-      std::unique_ptr<CompactionProxy> compaction,
-      const CompactionFilter* compaction_filter = nullptr,
-      const std::atomic<bool>* shutting_down = nullptr,
-      const SequenceNumber preserve_deletes_seqnum = 0,
-      const std::atomic<bool>* manual_compaction_paused = nullptr);
+  CompactionIterator(InternalIterator* input, const Comparator* cmp,
+                     MergeHelper* merge_helper, SequenceNumber last_sequence,
+                     std::vector<SequenceNumber>* snapshots,
+                     SequenceNumber earliest_write_conflict_snapshot,
+                     const SnapshotChecker* snapshot_checker, Env* env,
+                     bool report_detailed_time, bool expect_valid_internal_key,
+                     CompactionRangeDelAggregator* range_del_agg,
+                     std::unique_ptr<CompactionProxy> compaction,
+                     const CompactionFilter* compaction_filter = nullptr,
+                     const std::atomic<bool>* shutting_down = nullptr,
+                     const SequenceNumber preserve_deletes_seqnum = 0,
+                     SnapshotListFetchCallback* snap_list_callback = nullptr);

  ~CompactionIterator();

@@ -112,6 +160,8 @@ class CompactionIterator {
 private:
  // Processes the input stream to find the next output
  void NextFromInput();
+  // Process snapshots_ and assign related variables
+  void ProcessSnapshotList();

  // Do last preparations before presenting the output to the callee. At this
  // point this only zeroes out the sequence number if possible for better
@@ -146,7 +196,7 @@ class CompactionIterator {
  InternalIterator* input_;
  const Comparator* cmp_;
  MergeHelper* merge_helper_;
-  const std::vector<SequenceNumber>* snapshots_;
+  std::vector<SequenceNumber>* snapshots_;
  // List of snapshots released during compaction.
  // findEarliestVisibleSnapshot() find them out from return of
  // snapshot_checker, and make sure they will not be returned as
@@ -163,7 +213,6 @@ class CompactionIterator {
  std::unique_ptr<CompactionProxy> compaction_;
  const CompactionFilter* compaction_filter_;
  const std::atomic<bool>* shutting_down_;
-  const std::atomic<bool>* manual_compaction_paused_;
  const SequenceNumber preserve_deletes_seqnum_;
  bool bottommost_level_;
  bool valid_ = false;
@@ -222,16 +271,13 @@ class CompactionIterator {
  // Used to avoid purging uncommitted values. The application can specify
  // uncommitted values by providing a SnapshotChecker object.
  bool current_key_committed_;
+  SnapshotListFetchCallback* snap_list_callback_;
+  // number of distinct keys processed
+  size_t num_keys_ = 0;

  bool IsShuttingDown() {
    // This is a best-effort facility, so memory_order_relaxed is sufficient.
    return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
  }
-
-  bool IsPausingManualCompaction() {
-    // This is a best-effort facility, so memory_order_relaxed is sufficient.
-    return manual_compaction_paused_ &&
-           manual_compaction_paused_->load(std::memory_order_relaxed);
-  }
 };
 }  // namespace rocksdb
@@ -7,8 +7,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

-#include <algorithm>
 #include <cinttypes>
+#include <algorithm>
 #include <functional>
 #include <list>
 #include <memory>
@@ -34,9 +34,7 @@
 #include "db/range_del_aggregator.h"
 #include "db/version_set.h"
 #include "file/filename.h"
-#include "file/read_write_util.h"
 #include "file/sst_file_manager_impl.h"
-#include "file/writable_file_writer.h"
 #include "logging/log_buffer.h"
 #include "logging/logging.h"
 #include "monitoring/iostats_context_imp.h"
@@ -54,6 +52,7 @@
 #include "table/table_builder.h"
 #include "test_util/sync_point.h"
 #include "util/coding.h"
+#include "util/file_reader_writer.h"
 #include "util/mutexlock.h"
 #include "util/random.h"
 #include "util/stop_watch.h"
@@ -311,7 +310,7 @@ CompactionJob::CompactionJob(
    const SnapshotChecker* snapshot_checker, std::shared_ptr<Cache> table_cache,
    EventLogger* event_logger, bool paranoid_file_checks, bool measure_io_stats,
    const std::string& dbname, CompactionJobStats* compaction_job_stats,
-    Env::Priority thread_pri, const std::atomic<bool>* manual_compaction_paused)
+    Env::Priority thread_pri, SnapshotListFetchCallback* snap_list_callback)
    : job_id_(job_id),
      compact_(new CompactionState(compaction)),
      compaction_job_stats_(compaction_job_stats),
@@ -324,7 +323,6 @@ CompactionJob::CompactionJob(
          env_->OptimizeForCompactionTableRead(env_options, db_options_)),
      versions_(versions),
      shutting_down_(shutting_down),
-      manual_compaction_paused_(manual_compaction_paused),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
      log_buffer_(log_buffer),
      db_directory_(db_directory),
@@ -333,6 +331,7 @@ CompactionJob::CompactionJob(
      db_mutex_(db_mutex),
      db_error_handler_(db_error_handler),
      existing_snapshots_(std::move(existing_snapshots)),
+      snap_list_callback_(snap_list_callback),
      earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
      snapshot_checker_(snapshot_checker),
      table_cache_(std::move(table_cache)),
@@ -867,13 +866,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      false /* internal key corruption is expected */,
      existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
      snapshot_checker_, compact_->compaction->level(),
-      db_options_.statistics.get());
+      db_options_.statistics.get(), shutting_down_);

  TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionJob::Run():PausingManualCompaction:1",
-      reinterpret_cast<void*>(
-          const_cast<std::atomic<bool>*>(manual_compaction_paused_)));

  Slice* start = sub_compact->start;
  Slice* end = sub_compact->end;
@@ -891,7 +886,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      &existing_snapshots_, earliest_write_conflict_snapshot_,
      snapshot_checker_, env_, ShouldReportDetailedTime(env_, stats_), false,
      &range_del_agg, sub_compact->compaction, compaction_filter,
-      shutting_down_, preserve_deletes_seqnum_, manual_compaction_paused_));
+      shutting_down_, preserve_deletes_seqnum_,
+      // Currently range_del_agg is incompatible with snapshot refresh feature.
+      range_del_agg.IsEmpty() ? snap_list_callback_ : nullptr));
  auto c_iter = sub_compact->c_iter.get();
  c_iter->SeekToFirst();
  if (c_iter->Valid() && sub_compact->compaction->output_level() != 0) {
@@ -955,14 +952,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      input_status = input->status();
      output_file_ended = true;
    }
-    TEST_SYNC_POINT_CALLBACK(
-        "CompactionJob::Run():PausingManualCompaction:2",
-        reinterpret_cast<void*>(
-            const_cast<std::atomic<bool>*>(manual_compaction_paused_)));
    c_iter->Next();
-    if (c_iter->status().IsManualCompactionPaused()) {
-      break;
-    }
    if (!output_file_ended && c_iter->Valid() &&
        sub_compact->compaction->output_level() != 0 &&
        sub_compact->ShouldStopBefore(c_iter->key(),
@@ -1015,11 +1005,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      shutting_down_->load(std::memory_order_relaxed)) {
    status = Status::ShutdownInProgress("Database shutdown");
  }
-  if ((status.ok() || status.IsColumnFamilyDropped()) &&
-      (manual_compaction_paused_ &&
-       manual_compaction_paused_->load(std::memory_order_relaxed))) {
-    status = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
-  }
  if (status.ok()) {
    status = input->status();
  }
@@ -62,23 +62,20 @@ class VersionSet;
 // if needed.
 class CompactionJob {
 public:
-  CompactionJob(int job_id, Compaction* compaction,
-                const ImmutableDBOptions& db_options,
-                const EnvOptions env_options, VersionSet* versions,
-                const std::atomic<bool>* shutting_down,
-                const SequenceNumber preserve_deletes_seqnum,
-                LogBuffer* log_buffer, Directory* db_directory,
-                Directory* output_directory, Statistics* stats,
-                InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-                std::vector<SequenceNumber> existing_snapshots,
-                SequenceNumber earliest_write_conflict_snapshot,
-                const SnapshotChecker* snapshot_checker,
-                std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
-                bool paranoid_file_checks, bool measure_io_stats,
-                const std::string& dbname,
-                CompactionJobStats* compaction_job_stats,
-                Env::Priority thread_pri,
-                const std::atomic<bool>* manual_compaction_paused = nullptr);
+  CompactionJob(
+      int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
+      const EnvOptions env_options, VersionSet* versions,
+      const std::atomic<bool>* shutting_down,
+      const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
+      Directory* db_directory, Directory* output_directory, Statistics* stats,
+      InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
+      std::vector<SequenceNumber> existing_snapshots,
+      SequenceNumber earliest_write_conflict_snapshot,
+      const SnapshotChecker* snapshot_checker,
+      std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
+      bool paranoid_file_checks, bool measure_io_stats,
+      const std::string& dbname, CompactionJobStats* compaction_job_stats,
+      Env::Priority thread_pri, SnapshotListFetchCallback* snap_list_callback);

  ~CompactionJob();

@@ -157,7 +154,6 @@ class CompactionJob {
  EnvOptions env_options_for_read_;
  VersionSet* versions_;
  const std::atomic<bool>* shutting_down_;
-  const std::atomic<bool>* manual_compaction_paused_;
  const SequenceNumber preserve_deletes_seqnum_;
  LogBuffer* log_buffer_;
  Directory* db_directory_;
@@ -170,6 +166,7 @@ class CompactionJob {
  // entirely within s1 and s2, then the earlier version of k1 can be safely
  // deleted because that version is not visible in any snapshot.
  std::vector<SequenceNumber> existing_snapshots_;
+  SnapshotListFetchCallback* snap_list_callback_;

  // This is the earliest snapshot that could be used for write-conflict
  // checking by a transaction.  For any user-key newer than this snapshot, we
@@ -7,8 +7,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

-#include <algorithm>
 #include <cinttypes>
+#include <algorithm>
 #include <iostream>
 #include <mutex>
 #include <queue>
@@ -5,9 +5,9 @@

 #ifndef ROCKSDB_LITE

+#include <cinttypes>
 #include <algorithm>
 #include <array>
-#include <cinttypes>
 #include <map>
 #include <string>
 #include <tuple>
@@ -17,7 +17,6 @@
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/version_set.h"
-#include "file/writable_file_writer.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/db.h"
 #include "rocksdb/options.h"
@@ -25,6 +24,7 @@
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
+#include "util/file_reader_writer.h"
 #include "util/string_util.h"
 #include "utilities/merge_operators.h"

@@ -250,7 +250,9 @@ class CompactionJobTest : public testing::Test {
      const stl_wrappers::KVMap& expected_results,
      const std::vector<SequenceNumber>& snapshots = {},
      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
-      int output_level = 1, bool verify = true) {
+      int output_level = 1, bool verify = true,
+      SnapshotListFetchCallback* snapshot_fetcher =
+          SnapshotListFetchCallback::kDisabled) {
    auto cfd = versions_->GetColumnFamilySet()->GetDefault();

    size_t num_input_files = 0;
@@ -283,7 +285,7 @@ class CompactionJobTest : public testing::Test {
        nullptr, nullptr, &mutex_, &error_handler_, snapshots,
        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
        &event_logger, false, false, dbname_, &compaction_job_stats_,
-        Env::Priority::USER);
+        Env::Priority::USER, snapshot_fetcher);
    VerifyInitializationOfCompactionJobStats(compaction_job_stats_);

    compaction_job.Prepare();
@@ -960,6 +962,105 @@ TEST_F(CompactionJobTest, CorruptionAfterDeletion) {
  RunCompaction({files}, expected_results);
 }

+// Test the snapshot fetcher in compaction
+TEST_F(CompactionJobTest, SnapshotRefresh) {
+  uint64_t time_seed = env_->NowMicros();
+  printf("time_seed is %" PRIu64 "\n", time_seed);  // would help to reproduce
+  Random64 rand(time_seed);
+  std::vector<SequenceNumber> db_snapshots;
+  class SnapshotListFetchCallbackTest : public SnapshotListFetchCallback {
+   public:
+    SnapshotListFetchCallbackTest(Env* env, Random64& rand,
+                                  std::vector<SequenceNumber>* snapshots)
+        : SnapshotListFetchCallback(env, 1 /*short time delay*/,
+                                    1 /*fetch after each key*/),
+          rand_(rand),
+          snapshots_(snapshots) {}
+    virtual void Refresh(std::vector<SequenceNumber>* snapshots,
+                         SequenceNumber) override {
+      assert(snapshots->size());
+      assert(snapshots_->size());
+      assert(snapshots_->size() == snapshots->size());
+      if (rand_.OneIn(2)) {
+        uint64_t release_index = rand_.Uniform(snapshots_->size());
+        snapshots_->erase(snapshots_->begin() + release_index);
+        *snapshots = *snapshots_;
+      }
+    }
+
+   private:
+    Random64 rand_;
+    std::vector<SequenceNumber>* snapshots_;
+  } snapshot_fetcher(env_, rand, &db_snapshots);
+
+  std::vector<std::pair<const std::string, std::string>> file1_kvs, file2_kvs;
+  std::array<ValueType, 4> types = {kTypeValue, kTypeDeletion,
+                                    kTypeSingleDeletion};
+  SequenceNumber last_seq = 0;
+  for (int i = 1; i < 100; i++) {
+    SequenceNumber seq = last_seq + 1;
+    last_seq = seq;
+    if (rand.OneIn(2)) {
+      auto type = types[rand.Uniform(types.size())];
+      file1_kvs.push_back(
+          {test::KeyStr("k" + ToString(i), seq, type), "v" + ToString(i)});
+    }
+  }
+  auto file1 = mock::MakeMockFile(file1_kvs);
+  for (int i = 1; i < 100; i++) {
+    SequenceNumber seq = last_seq + 1;
+    last_seq++;
+    if (rand.OneIn(2)) {
+      auto type = types[rand.Uniform(types.size())];
+      file2_kvs.push_back(
+          {test::KeyStr("k" + ToString(i), seq, type), "v" + ToString(i)});
+    }
+  }
+  auto file2 = mock::MakeMockFile(file2_kvs);
+  for (SequenceNumber i = 1; i < last_seq + 1; i++) {
+    if (rand.OneIn(5)) {
+      db_snapshots.push_back(i);
+    }
+  }
+
+  const bool kVerify = true;
+  const int output_level_0 = 0;
+  NewDB();
+  AddMockFile(file1);
+  AddMockFile(file2);
+  SetLastSequence(last_seq);
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  // put the output on L0 since it is easier to feed them again to the 2nd
+  // compaction
+  RunCompaction({files}, file1, db_snapshots, kMaxSequenceNumber,
+                output_level_0, !kVerify, &snapshot_fetcher);
+
+  // Now db_snapshots are changed. Run the compaction again without snapshot
+  // fetcher but with the updated snapshot list.
+  compaction_job_stats_.Reset();
+  files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, file1, db_snapshots, kMaxSequenceNumber,
+                output_level_0 + 1, !kVerify);
+  // The result should be what we get if we run compaction without snapshot
+  // fetcher on the updated list of snapshots
+  auto expected = mock_table_factory_->output();
+
+  NewDB();
+  AddMockFile(file1);
+  AddMockFile(file2);
+  SetLastSequence(last_seq);
+  files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected, db_snapshots, kMaxSequenceNumber,
+                output_level_0, !kVerify);
+  // The 2nd compaction above would get rid of useless delete markers. To get
+  // the output here exactly as what we got above after two compactions, we also
+  // run the compaction for 2nd time.
+  compaction_job_stats_.Reset();
+  files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected, db_snapshots, kMaxSequenceNumber,
+                output_level_0 + 1, !kVerify);
+}
+
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -25,98 +25,6 @@

 namespace rocksdb {
 namespace {
-// A helper class that form universal compactions. The class is used by
-// UniversalCompactionPicker::PickCompaction().
-// The usage is to create the class, and get the compaction object by calling
-// PickCompaction().
-class UniversalCompactionBuilder {
- public:
-  UniversalCompactionBuilder(const ImmutableCFOptions& ioptions,
-                             const InternalKeyComparator* icmp,
-                             const std::string& cf_name,
-                             const MutableCFOptions& mutable_cf_options,
-                             VersionStorageInfo* vstorage,
-                             UniversalCompactionPicker* picker,
-                             LogBuffer* log_buffer)
-      : ioptions_(ioptions),
-        icmp_(icmp),
-        cf_name_(cf_name),
-        mutable_cf_options_(mutable_cf_options),
-        vstorage_(vstorage),
-        picker_(picker),
-        log_buffer_(log_buffer) {}
-
-  // Form and return the compaction object. The caller owns return object.
-  Compaction* PickCompaction();
-
- private:
-  struct SortedRun {
-    SortedRun(int _level, FileMetaData* _file, uint64_t _size,
-              uint64_t _compensated_file_size, bool _being_compacted)
-        : level(_level),
-          file(_file),
-          size(_size),
-          compensated_file_size(_compensated_file_size),
-          being_compacted(_being_compacted) {
-      assert(compensated_file_size > 0);
-      assert(level != 0 || file != nullptr);
-    }
-
-    void Dump(char* out_buf, size_t out_buf_size,
-              bool print_path = false) const;
-
-    // sorted_run_count is added into the string to print
-    void DumpSizeInfo(char* out_buf, size_t out_buf_size,
-                      size_t sorted_run_count) const;
-
-    int level;
-    // `file` Will be null for level > 0. For level = 0, the sorted run is
-    // for this file.
-    FileMetaData* file;
-    // For level > 0, `size` and `compensated_file_size` are sum of sizes all
-    // files in the level. `being_compacted` should be the same for all files
-    // in a non-zero level. Use the value here.
-    uint64_t size;
-    uint64_t compensated_file_size;
-    bool being_compacted;
-  };
-
-  // Pick Universal compaction to limit read amplification
-  Compaction* PickCompactionToReduceSortedRuns(
-      unsigned int ratio, unsigned int max_number_of_files_to_compact);
-
-  // Pick Universal compaction to limit space amplification.
-  Compaction* PickCompactionToReduceSizeAmp();
-
-  Compaction* PickDeleteTriggeredCompaction();
-
-  // Used in universal compaction when the enabled_trivial_move
-  // option is set. Checks whether there are any overlapping files
-  // in the input. Returns true if the input files are non
-  // overlapping.
-  bool IsInputFilesNonOverlapping(Compaction* c);
-
-  const ImmutableCFOptions& ioptions_;
-  const InternalKeyComparator* icmp_;
-  double score_;
-  std::vector<SortedRun> sorted_runs_;
-  const std::string& cf_name_;
-  const MutableCFOptions& mutable_cf_options_;
-  VersionStorageInfo* vstorage_;
-  UniversalCompactionPicker* picker_;
-  LogBuffer* log_buffer_;
-
-  static std::vector<SortedRun> CalculateSortedRuns(
-      const VersionStorageInfo& vstorage, const ImmutableCFOptions& ioptions,
-      const MutableCFOptions& mutable_cf_options);
-
-  // Pick a path ID to place a newly generated file, with its estimated file
-  // size.
-  static uint32_t GetPathId(const ImmutableCFOptions& ioptions,
-                            const MutableCFOptions& mutable_cf_options,
-                            uint64_t file_size);
-};
-
 // Used in universal compaction when trivial move is enabled.
 // This structure is used for the construction of min heap
 // that contains the file meta data, the level of the file
@@ -205,7 +113,7 @@ void GetSmallestLargestSeqno(const std::vector<FileMetaData*>& files,

 // Algorithm that checks to see if there are any overlapping
 // files in the input
-bool UniversalCompactionBuilder::IsInputFilesNonOverlapping(Compaction* c) {
+bool UniversalCompactionPicker::IsInputFilesNonOverlapping(Compaction* c) {
  auto comparator = icmp_->user_comparator();
  int first_iter = 1;

@@ -259,18 +167,9 @@ bool UniversalCompactionPicker::NeedsCompaction(
  return false;
 }

-Compaction* UniversalCompactionPicker::PickCompaction(
-    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-    VersionStorageInfo* vstorage, LogBuffer* log_buffer) {
-  UniversalCompactionBuilder builder(ioptions_, icmp_, cf_name,
-                                     mutable_cf_options, vstorage, this,
-                                     log_buffer);
-  return builder.PickCompaction();
-}
-
-void UniversalCompactionBuilder::SortedRun::Dump(char* out_buf,
-                                                 size_t out_buf_size,
-                                                 bool print_path) const {
+void UniversalCompactionPicker::SortedRun::Dump(char* out_buf,
+                                                size_t out_buf_size,
+                                                bool print_path) const {
  if (level == 0) {
    assert(file != nullptr);
    if (file->fd.GetPathId() == 0 || !print_path) {
@@ -286,7 +185,7 @@ void UniversalCompactionBuilder::SortedRun::Dump(char* out_buf,
  }
 }

-void UniversalCompactionBuilder::SortedRun::DumpSizeInfo(
+void UniversalCompactionPicker::SortedRun::DumpSizeInfo(
    char* out_buf, size_t out_buf_size, size_t sorted_run_count) const {
  if (level == 0) {
    assert(file != nullptr);
@@ -305,11 +204,11 @@ void UniversalCompactionBuilder::SortedRun::DumpSizeInfo(
  }
 }

-std::vector<UniversalCompactionBuilder::SortedRun>
-UniversalCompactionBuilder::CalculateSortedRuns(
+std::vector<UniversalCompactionPicker::SortedRun>
+UniversalCompactionPicker::CalculateSortedRuns(
    const VersionStorageInfo& vstorage, const ImmutableCFOptions& /*ioptions*/,
    const MutableCFOptions& mutable_cf_options) {
-  std::vector<UniversalCompactionBuilder::SortedRun> ret;
+  std::vector<UniversalCompactionPicker::SortedRun> ret;
  for (FileMetaData* f : vstorage.LevelFiles(0)) {
    ret.emplace_back(0, f, f->fd.GetFileSize(), f->compensated_file_size,
                     f->being_compacted);
@@ -332,8 +231,8 @@ UniversalCompactionBuilder::CalculateSortedRuns(
        // non-zero level, all the files should share the same being_compacted
        // value.
        // This assumption is only valid when
-        // mutable_cf_options.compaction_options_universal.allow_trivial_move
-        // is false
+        // mutable_cf_options.compaction_options_universal.allow_trivial_move is
+        // false
        assert(is_first || f->being_compacted == being_compacted);
      }
      if (is_first) {
@@ -351,59 +250,65 @@ UniversalCompactionBuilder::CalculateSortedRuns(

 // Universal style of compaction. Pick files that are contiguous in
 // time-range to compact.
-Compaction* UniversalCompactionBuilder::PickCompaction() {
+Compaction* UniversalCompactionPicker::PickCompaction(
+    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+    VersionStorageInfo* vstorage, LogBuffer* log_buffer) {
  const int kLevel0 = 0;
-  score_ = vstorage_->CompactionScore(kLevel0);
-  sorted_runs_ =
-      CalculateSortedRuns(*vstorage_, ioptions_, mutable_cf_options_);
+  double score = vstorage->CompactionScore(kLevel0);
+  std::vector<SortedRun> sorted_runs =
+      CalculateSortedRuns(*vstorage, ioptions_, mutable_cf_options);

-  if (sorted_runs_.size() == 0 ||
-      (vstorage_->FilesMarkedForCompaction().empty() &&
-       sorted_runs_.size() < (unsigned int)mutable_cf_options_
-                                 .level0_file_num_compaction_trigger)) {
-    ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: nothing to do\n",
-                     cf_name_.c_str());
-    TEST_SYNC_POINT_CALLBACK(
-        "UniversalCompactionBuilder::PickCompaction:Return", nullptr);
+  if (sorted_runs.size() == 0 ||
+      (vstorage->FilesMarkedForCompaction().empty() &&
+       sorted_runs.size() < (unsigned int)mutable_cf_options
+                                .level0_file_num_compaction_trigger)) {
+    ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: nothing to do\n",
+                     cf_name.c_str());
+    TEST_SYNC_POINT_CALLBACK("UniversalCompactionPicker::PickCompaction:Return",
+                             nullptr);
    return nullptr;
  }
  VersionStorageInfo::LevelSummaryStorage tmp;
  ROCKS_LOG_BUFFER_MAX_SZ(
-      log_buffer_, 3072,
+      log_buffer, 3072,
      "[%s] Universal: sorted runs files(%" ROCKSDB_PRIszt "): %s\n",
-      cf_name_.c_str(), sorted_runs_.size(), vstorage_->LevelSummary(&tmp));
+      cf_name.c_str(), sorted_runs.size(), vstorage->LevelSummary(&tmp));

  // Check for size amplification first.
  Compaction* c = nullptr;
-  if (sorted_runs_.size() >=
+  if (sorted_runs.size() >=
      static_cast<size_t>(
-          mutable_cf_options_.level0_file_num_compaction_trigger)) {
-    if ((c = PickCompactionToReduceSizeAmp()) != nullptr) {
-      ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: compacting for size amp\n",
-                       cf_name_.c_str());
+          mutable_cf_options.level0_file_num_compaction_trigger)) {
+    if ((c = PickCompactionToReduceSizeAmp(cf_name, mutable_cf_options,
+                                           vstorage, score, sorted_runs,
+                                           log_buffer)) != nullptr) {
+      ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: compacting for size amp\n",
+                       cf_name.c_str());
    } else {
      // Size amplification is within limits. Try reducing read
      // amplification while maintaining file size ratios.
      unsigned int ratio =
-          mutable_cf_options_.compaction_options_universal.size_ratio;
+          mutable_cf_options.compaction_options_universal.size_ratio;

-      if ((c = PickCompactionToReduceSortedRuns(ratio, UINT_MAX)) != nullptr) {
-        ROCKS_LOG_BUFFER(log_buffer_,
+      if ((c = PickCompactionToReduceSortedRuns(
+               cf_name, mutable_cf_options, vstorage, score, ratio, UINT_MAX,
+               sorted_runs, log_buffer)) != nullptr) {
+        ROCKS_LOG_BUFFER(log_buffer,
                         "[%s] Universal: compacting for size ratio\n",
-                         cf_name_.c_str());
+                         cf_name.c_str());
      } else {
        // Size amplification and file size ratios are within configured limits.
        // If max read amplification is exceeding configured limits, then force
        // compaction without looking at filesize ratios and try to reduce
        // the number of files to fewer than level0_file_num_compaction_trigger.
        // This is guaranteed by NeedsCompaction()
-        assert(sorted_runs_.size() >=
+        assert(sorted_runs.size() >=
               static_cast<size_t>(
-                   mutable_cf_options_.level0_file_num_compaction_trigger));
+                   mutable_cf_options.level0_file_num_compaction_trigger));
        // Get the total number of sorted runs that are not being compacted
        int num_sr_not_compacted = 0;
-        for (size_t i = 0; i < sorted_runs_.size(); i++) {
-          if (sorted_runs_[i].being_compacted == false) {
+        for (size_t i = 0; i < sorted_runs.size(); i++) {
+          if (sorted_runs[i].being_compacted == false) {
            num_sr_not_compacted++;
          }
        }
@@ -411,15 +316,16 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
        // The number of sorted runs that are not being compacted is greater
        // than the maximum allowed number of sorted runs
        if (num_sr_not_compacted >
-            mutable_cf_options_.level0_file_num_compaction_trigger) {
+            mutable_cf_options.level0_file_num_compaction_trigger) {
          unsigned int num_files =
              num_sr_not_compacted -
-              mutable_cf_options_.level0_file_num_compaction_trigger + 1;
-          if ((c = PickCompactionToReduceSortedRuns(UINT_MAX, num_files)) !=
-              nullptr) {
-            ROCKS_LOG_BUFFER(log_buffer_,
+              mutable_cf_options.level0_file_num_compaction_trigger + 1;
+          if ((c = PickCompactionToReduceSortedRuns(
+                   cf_name, mutable_cf_options, vstorage, score, UINT_MAX,
+                   num_files, sorted_runs, log_buffer)) != nullptr) {
+            ROCKS_LOG_BUFFER(log_buffer,
                             "[%s] Universal: compacting for file num -- %u\n",
-                             cf_name_.c_str(), num_files);
+                             cf_name.c_str(), num_files);
          }
        }
      }
@@ -427,20 +333,22 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
  }

  if (c == nullptr) {
-    if ((c = PickDeleteTriggeredCompaction()) != nullptr) {
-      ROCKS_LOG_BUFFER(log_buffer_,
+    if ((c = PickDeleteTriggeredCompaction(cf_name, mutable_cf_options,
+                                           vstorage, score, sorted_runs,
+                                           log_buffer)) != nullptr) {
+      ROCKS_LOG_BUFFER(log_buffer,
                       "[%s] Universal: delete triggered compaction\n",
-                       cf_name_.c_str());
+                       cf_name.c_str());
    }
  }

  if (c == nullptr) {
-    TEST_SYNC_POINT_CALLBACK(
-        "UniversalCompactionBuilder::PickCompaction:Return", nullptr);
+    TEST_SYNC_POINT_CALLBACK("UniversalCompactionPicker::PickCompaction:Return",
+                             nullptr);
    return nullptr;
  }

-  if (mutable_cf_options_.compaction_options_universal.allow_trivial_move ==
+  if (mutable_cf_options.compaction_options_universal.allow_trivial_move ==
      true) {
    c->set_is_trivial_move(IsInputFilesNonOverlapping(c));
  }
@@ -486,15 +394,15 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
  RecordInHistogram(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION,
                    c->inputs(0)->size());

-  picker_->RegisterCompaction(c);
-  vstorage_->ComputeCompactionScore(ioptions_, mutable_cf_options_);
+  RegisterCompaction(c);
+  vstorage->ComputeCompactionScore(ioptions_, mutable_cf_options);

-  TEST_SYNC_POINT_CALLBACK("UniversalCompactionBuilder::PickCompaction:Return",
+  TEST_SYNC_POINT_CALLBACK("UniversalCompactionPicker::PickCompaction:Return",
                           c);
  return c;
 }

-uint32_t UniversalCompactionBuilder::GetPathId(
+uint32_t UniversalCompactionPicker::GetPathId(
    const ImmutableCFOptions& ioptions,
    const MutableCFOptions& mutable_cf_options, uint64_t file_size) {
  // Two conditions need to be satisfied:
@@ -532,12 +440,15 @@ uint32_t UniversalCompactionBuilder::GetPathId(
 // Consider compaction files based on their size differences with
 // the next file in time order.
 //
-Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
-    unsigned int ratio, unsigned int max_number_of_files_to_compact) {
+Compaction* UniversalCompactionPicker::PickCompactionToReduceSortedRuns(
+    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+    VersionStorageInfo* vstorage, double score, unsigned int ratio,
+    unsigned int max_number_of_files_to_compact,
+    const std::vector<SortedRun>& sorted_runs, LogBuffer* log_buffer) {
  unsigned int min_merge_width =
-      mutable_cf_options_.compaction_options_universal.min_merge_width;
+      mutable_cf_options.compaction_options_universal.min_merge_width;
  unsigned int max_merge_width =
-      mutable_cf_options_.compaction_options_universal.max_merge_width;
+      mutable_cf_options.compaction_options_universal.max_merge_width;

  const SortedRun* sr = nullptr;
  bool done = false;
@@ -551,16 +462,16 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
  // Caller checks the size before executing this function. This invariant is
  // important because otherwise we may have a possible integer underflow when
  // dealing with unsigned types.
-  assert(sorted_runs_.size() > 0);
+  assert(sorted_runs.size() > 0);

  // Considers a candidate file only if it is smaller than the
  // total size accumulated so far.
-  for (size_t loop = 0; loop < sorted_runs_.size(); loop++) {
+  for (size_t loop = 0; loop < sorted_runs.size(); loop++) {
    candidate_count = 0;

    // Skip files that are already being compacted
-    for (sr = nullptr; loop < sorted_runs_.size(); loop++) {
-      sr = &sorted_runs_[loop];
+    for (sr = nullptr; loop < sorted_runs.size(); loop++) {
+      sr = &sorted_runs[loop];

      if (!sr->being_compacted) {
        candidate_count = 1;
@@ -568,10 +479,10 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
      }
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf));
-      ROCKS_LOG_BUFFER(log_buffer_,
+      ROCKS_LOG_BUFFER(log_buffer,
                       "[%s] Universal: %s"
                       "[%d] being compacted, skipping",
-                       cf_name_.c_str(), file_num_buf, loop);
+                       cf_name.c_str(), file_num_buf, loop);

      sr = nullptr;
    }
@@ -582,16 +493,15 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
    if (sr != nullptr) {
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf), true);
-      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: Possible candidate %s[%d].",
-                       cf_name_.c_str(), file_num_buf, loop);
+      ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: Possible candidate %s[%d].",
+                       cf_name.c_str(), file_num_buf, loop);
    }

    // Check if the succeeding files need compaction.
    for (size_t i = loop + 1;
-         candidate_count < max_files_to_compact && i < sorted_runs_.size();
+         candidate_count < max_files_to_compact && i < sorted_runs.size();
         i++) {
-      const SortedRun* succeeding_sr = &sorted_runs_[i];
+      const SortedRun* succeeding_sr = &sorted_runs[i];
      if (succeeding_sr->being_compacted) {
        break;
      }
@@ -605,7 +515,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
      if (sz < static_cast<double>(succeeding_sr->size)) {
        break;
      }
-      if (mutable_cf_options_.compaction_options_universal.stop_style ==
+      if (mutable_cf_options.compaction_options_universal.stop_style ==
          kCompactionStopStyleSimilarSize) {
        // Similar-size stopping rule: also check the last picked file isn't
        // far larger than the next candidate file.
@@ -631,12 +541,12 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
      break;
    } else {
      for (size_t i = loop;
-           i < loop + candidate_count && i < sorted_runs_.size(); i++) {
-        const SortedRun* skipping_sr = &sorted_runs_[i];
+           i < loop + candidate_count && i < sorted_runs.size(); i++) {
+        const SortedRun* skipping_sr = &sorted_runs[i];
        char file_num_buf[256];
        skipping_sr->DumpSizeInfo(file_num_buf, sizeof(file_num_buf), loop);
-        ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: Skipping %s",
-                         cf_name_.c_str(), file_num_buf);
+        ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: Skipping %s",
+                         cf_name.c_str(), file_num_buf);
      }
    }
  }
@@ -648,16 +558,16 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
  // size ratio of compression.
  bool enable_compression = true;
  int ratio_to_compress =
-      mutable_cf_options_.compaction_options_universal.compression_size_percent;
+      mutable_cf_options.compaction_options_universal.compression_size_percent;
  if (ratio_to_compress >= 0) {
    uint64_t total_size = 0;
-    for (auto& sorted_run : sorted_runs_) {
+    for (auto& sorted_run : sorted_runs) {
      total_size += sorted_run.compensated_file_size;
    }

    uint64_t older_file_size = 0;
-    for (size_t i = sorted_runs_.size() - 1; i >= first_index_after; i--) {
-      older_file_size += sorted_runs_[i].size;
+    for (size_t i = sorted_runs.size() - 1; i >= first_index_after; i--) {
+      older_file_size += sorted_runs[i].size;
      if (older_file_size * 100L >= total_size * (long)ratio_to_compress) {
        enable_compression = false;
        break;
@@ -667,46 +577,46 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(

  uint64_t estimated_total_size = 0;
  for (unsigned int i = 0; i < first_index_after; i++) {
-    estimated_total_size += sorted_runs_[i].size;
+    estimated_total_size += sorted_runs[i].size;
  }
  uint32_t path_id =
-      GetPathId(ioptions_, mutable_cf_options_, estimated_total_size);
-  int start_level = sorted_runs_[start_index].level;
+      GetPathId(ioptions_, mutable_cf_options, estimated_total_size);
+  int start_level = sorted_runs[start_index].level;
  int output_level;
-  if (first_index_after == sorted_runs_.size()) {
-    output_level = vstorage_->num_levels() - 1;
-  } else if (sorted_runs_[first_index_after].level == 0) {
+  if (first_index_after == sorted_runs.size()) {
+    output_level = vstorage->num_levels() - 1;
+  } else if (sorted_runs[first_index_after].level == 0) {
    output_level = 0;
  } else {
-    output_level = sorted_runs_[first_index_after].level - 1;
+    output_level = sorted_runs[first_index_after].level - 1;
  }

  // last level is reserved for the files ingested behind
  if (ioptions_.allow_ingest_behind &&
-      (output_level == vstorage_->num_levels() - 1)) {
+      (output_level == vstorage->num_levels() - 1)) {
    assert(output_level > 1);
    output_level--;
  }

-  std::vector<CompactionInputFiles> inputs(vstorage_->num_levels());
+  std::vector<CompactionInputFiles> inputs(vstorage->num_levels());
  for (size_t i = 0; i < inputs.size(); ++i) {
    inputs[i].level = start_level + static_cast<int>(i);
  }
  for (size_t i = start_index; i < first_index_after; i++) {
-    auto& picking_sr = sorted_runs_[i];
+    auto& picking_sr = sorted_runs[i];
    if (picking_sr.level == 0) {
      FileMetaData* picking_file = picking_sr.file;
      inputs[0].files.push_back(picking_file);
    } else {
      auto& files = inputs[picking_sr.level - start_level].files;
-      for (auto* f : vstorage_->LevelFiles(picking_sr.level)) {
+      for (auto* f : vstorage->LevelFiles(picking_sr.level)) {
        files.push_back(f);
      }
    }
    char file_num_buf[256];
    picking_sr.DumpSizeInfo(file_num_buf, sizeof(file_num_buf), i);
-    ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: Picking %s",
-                     cf_name_.c_str(), file_num_buf);
+    ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: Picking %s", cf_name.c_str(),
+                     file_num_buf);
  }

  CompactionReason compaction_reason;
@@ -716,17 +626,16 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
    compaction_reason = CompactionReason::kUniversalSortedRunNum;
  }
  return new Compaction(
-      vstorage_, ioptions_, mutable_cf_options_, std::move(inputs),
-      output_level,
-      MaxFileSizeForLevel(mutable_cf_options_, output_level,
+      vstorage, ioptions_, mutable_cf_options, std::move(inputs), output_level,
+      MaxFileSizeForLevel(mutable_cf_options, output_level,
                          kCompactionStyleUniversal),
      LLONG_MAX, path_id,
-      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_, start_level,
+      GetCompressionType(ioptions_, vstorage, mutable_cf_options, start_level,
                         1, enable_compression),
-      GetCompressionOptions(ioptions_, vstorage_, start_level,
+      GetCompressionOptions(ioptions_, vstorage, start_level,
                            enable_compression),
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
-      score_, false /* deletion_compaction */, compaction_reason);
+      score, false /* deletion_compaction */, compaction_reason);
 }

 // Look at overall size amplification. If size amplification
@@ -735,9 +644,12 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
 // base file (overrides configured values of file-size ratios,
 // min_merge_width and max_merge_width).
 //
-Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
+Compaction* UniversalCompactionPicker::PickCompactionToReduceSizeAmp(
+    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+    VersionStorageInfo* vstorage, double score,
+    const std::vector<SortedRun>& sorted_runs, LogBuffer* log_buffer) {
  // percentage flexibility while reducing size amplification
-  uint64_t ratio = mutable_cf_options_.compaction_options_universal
+  uint64_t ratio = mutable_cf_options.compaction_options_universal
                       .max_size_amplification_percent;

  unsigned int candidate_count = 0;
@@ -745,23 +657,21 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  size_t start_index = 0;
  const SortedRun* sr = nullptr;

-  assert(!sorted_runs_.empty());
-  if (sorted_runs_.back().being_compacted) {
+  if (sorted_runs.back().being_compacted) {
    return nullptr;
  }

  // Skip files that are already being compacted
-  for (size_t loop = 0; loop < sorted_runs_.size() - 1; loop++) {
-    sr = &sorted_runs_[loop];
+  for (size_t loop = 0; loop < sorted_runs.size() - 1; loop++) {
+    sr = &sorted_runs[loop];
    if (!sr->being_compacted) {
      start_index = loop;  // Consider this as the first candidate.
      break;
    }
    char file_num_buf[kFormatFileNumberBufSize];
    sr->Dump(file_num_buf, sizeof(file_num_buf), true);
-    ROCKS_LOG_BUFFER(log_buffer_,
-                     "[%s] Universal: skipping %s[%d] compacted %s",
-                     cf_name_.c_str(), file_num_buf, loop,
+    ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: skipping %s[%d] compacted %s",
+                     cf_name.c_str(), file_num_buf, loop,
                     " cannot be a candidate to reduce size amp.\n");
    sr = nullptr;
  }
@@ -773,20 +683,20 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
    char file_num_buf[kFormatFileNumberBufSize];
    sr->Dump(file_num_buf, sizeof(file_num_buf), true);
    ROCKS_LOG_BUFFER(
-        log_buffer_,
+        log_buffer,
        "[%s] Universal: First candidate %s[%" ROCKSDB_PRIszt "] %s",
-        cf_name_.c_str(), file_num_buf, start_index, " to reduce size amp.\n");
+        cf_name.c_str(), file_num_buf, start_index, " to reduce size amp.\n");
  }

  // keep adding up all the remaining files
-  for (size_t loop = start_index; loop < sorted_runs_.size() - 1; loop++) {
-    sr = &sorted_runs_[loop];
+  for (size_t loop = start_index; loop < sorted_runs.size() - 1; loop++) {
+    sr = &sorted_runs[loop];
    if (sr->being_compacted) {
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf), true);
      ROCKS_LOG_BUFFER(
-          log_buffer_, "[%s] Universal: Possible candidate %s[%d] %s",
-          cf_name_.c_str(), file_num_buf, start_index,
+          log_buffer, "[%s] Universal: Possible candidate %s[%d] %s",
+          cf_name.c_str(), file_num_buf, start_index,
          " is already being compacted. No size amp reduction possible.\n");
      return nullptr;
    }
@@ -798,58 +708,58 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  }

  // size of earliest file
-  uint64_t earliest_file_size = sorted_runs_.back().size;
+  uint64_t earliest_file_size = sorted_runs.back().size;

  // size amplification = percentage of additional size
  if (candidate_size * 100 < ratio * earliest_file_size) {
    ROCKS_LOG_BUFFER(
-        log_buffer_,
+        log_buffer,
        "[%s] Universal: size amp not needed. newer-files-total-size %" PRIu64
        " earliest-file-size %" PRIu64,
-        cf_name_.c_str(), candidate_size, earliest_file_size);
+        cf_name.c_str(), candidate_size, earliest_file_size);
    return nullptr;
  } else {
    ROCKS_LOG_BUFFER(
-        log_buffer_,
+        log_buffer,
        "[%s] Universal: size amp needed. newer-files-total-size %" PRIu64
        " earliest-file-size %" PRIu64,
-        cf_name_.c_str(), candidate_size, earliest_file_size);
+        cf_name.c_str(), candidate_size, earliest_file_size);
  }
-  assert(start_index < sorted_runs_.size() - 1);
+  assert(start_index < sorted_runs.size() - 1);

  // Estimate total file size
  uint64_t estimated_total_size = 0;
-  for (size_t loop = start_index; loop < sorted_runs_.size(); loop++) {
-    estimated_total_size += sorted_runs_[loop].size;
+  for (size_t loop = start_index; loop < sorted_runs.size(); loop++) {
+    estimated_total_size += sorted_runs[loop].size;
  }
  uint32_t path_id =
-      GetPathId(ioptions_, mutable_cf_options_, estimated_total_size);
-  int start_level = sorted_runs_[start_index].level;
+      GetPathId(ioptions_, mutable_cf_options, estimated_total_size);
+  int start_level = sorted_runs[start_index].level;

-  std::vector<CompactionInputFiles> inputs(vstorage_->num_levels());
+  std::vector<CompactionInputFiles> inputs(vstorage->num_levels());
  for (size_t i = 0; i < inputs.size(); ++i) {
    inputs[i].level = start_level + static_cast<int>(i);
  }
  // We always compact all the files, so always compress.
-  for (size_t loop = start_index; loop < sorted_runs_.size(); loop++) {
-    auto& picking_sr = sorted_runs_[loop];
+  for (size_t loop = start_index; loop < sorted_runs.size(); loop++) {
+    auto& picking_sr = sorted_runs[loop];
    if (picking_sr.level == 0) {
      FileMetaData* f = picking_sr.file;
      inputs[0].files.push_back(f);
    } else {
      auto& files = inputs[picking_sr.level - start_level].files;
-      for (auto* f : vstorage_->LevelFiles(picking_sr.level)) {
+      for (auto* f : vstorage->LevelFiles(picking_sr.level)) {
        files.push_back(f);
      }
    }
    char file_num_buf[256];
    picking_sr.DumpSizeInfo(file_num_buf, sizeof(file_num_buf), loop);
-    ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: size amp picking %s",
-                     cf_name_.c_str(), file_num_buf);
+    ROCKS_LOG_BUFFER(log_buffer, "[%s] Universal: size amp picking %s",
+                     cf_name.c_str(), file_num_buf);
  }

  // output files at the bottom most level, unless it's reserved
-  int output_level = vstorage_->num_levels() - 1;
+  int output_level = vstorage->num_levels() - 1;
  // last level is reserved for the files ingested behind
  if (ioptions_.allow_ingest_behind) {
    assert(output_level > 1);
@@ -857,27 +767,29 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  }

  return new Compaction(
-      vstorage_, ioptions_, mutable_cf_options_, std::move(inputs),
-      output_level,
-      MaxFileSizeForLevel(mutable_cf_options_, output_level,
+      vstorage, ioptions_, mutable_cf_options, std::move(inputs), output_level,
+      MaxFileSizeForLevel(mutable_cf_options, output_level,
                          kCompactionStyleUniversal),
      /* max_grandparent_overlap_bytes */ LLONG_MAX, path_id,
-      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_,
-                         output_level, 1),
-      GetCompressionOptions(ioptions_, vstorage_, output_level),
+      GetCompressionType(ioptions_, vstorage, mutable_cf_options, output_level,
+                         1),
+      GetCompressionOptions(ioptions_, vstorage, output_level),
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
-      score_, false /* deletion_compaction */,
+      score, false /* deletion_compaction */,
      CompactionReason::kUniversalSizeAmplification);
 }

 // Pick files marked for compaction. Typically, files are marked by
 // CompactOnDeleteCollector due to the presence of tombstones.
-Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
+Compaction* UniversalCompactionPicker::PickDeleteTriggeredCompaction(
+    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+    VersionStorageInfo* vstorage, double score,
+    const std::vector<SortedRun>& /*sorted_runs*/, LogBuffer* /*log_buffer*/) {
  CompactionInputFiles start_level_inputs;
  int output_level;
  std::vector<CompactionInputFiles> inputs;

-  if (vstorage_->num_levels() == 1) {
+  if (vstorage->num_levels() == 1) {
    // This is single level universal. Since we're basically trying to reclaim
    // space by processing files marked for compaction due to high tombstone
    // density, let's do the same thing as compaction to reduce size amp which
@@ -887,7 +799,7 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
    start_level_inputs.level = 0;
    start_level_inputs.files.clear();
    output_level = 0;
-    for (FileMetaData* f : vstorage_->LevelFiles(0)) {
+    for (FileMetaData* f : vstorage->LevelFiles(0)) {
      if (f->marked_for_compaction) {
        compact = true;
      }
@@ -906,24 +818,24 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
    // For multi-level universal, the strategy is to make this look more like
    // leveled. We pick one of the files marked for compaction and compact with
    // overlapping files in the adjacent level.
-    picker_->PickFilesMarkedForCompaction(cf_name_, vstorage_, &start_level,
-                                          &output_level, &start_level_inputs);
+    PickFilesMarkedForCompaction(cf_name, vstorage, &start_level, &output_level,
+                                 &start_level_inputs);
    if (start_level_inputs.empty()) {
      return nullptr;
    }

    // Pick the first non-empty level after the start_level
-    for (output_level = start_level + 1; output_level < vstorage_->num_levels();
+    for (output_level = start_level + 1; output_level < vstorage->num_levels();
         output_level++) {
-      if (vstorage_->NumLevelFiles(output_level) != 0) {
+      if (vstorage->NumLevelFiles(output_level) != 0) {
        break;
      }
    }

    // If all higher levels are empty, pick the highest level as output level
-    if (output_level == vstorage_->num_levels()) {
+    if (output_level == vstorage->num_levels()) {
      if (start_level == 0) {
-        output_level = vstorage_->num_levels() - 1;
+        output_level = vstorage->num_levels() - 1;
      } else {
        // If start level is non-zero and all higher levels are empty, this
        // compaction will translate into a trivial move. Since the idea is
@@ -933,15 +845,15 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      }
    }
    if (ioptions_.allow_ingest_behind &&
-        output_level == vstorage_->num_levels() - 1) {
+        output_level == vstorage->num_levels() - 1) {
      assert(output_level > 1);
      output_level--;
    }

    if (output_level != 0) {
      if (start_level == 0) {
-        if (!picker_->GetOverlappingL0Files(vstorage_, &start_level_inputs,
-                                            output_level, nullptr)) {
+        if (!GetOverlappingL0Files(vstorage, &start_level_inputs, output_level,
+                                   nullptr)) {
          return nullptr;
        }
      }
@@ -950,16 +862,16 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      int parent_index = -1;

      output_level_inputs.level = output_level;
-      if (!picker_->SetupOtherInputs(cf_name_, mutable_cf_options_, vstorage_,
-                                     &start_level_inputs, &output_level_inputs,
-                                     &parent_index, -1)) {
+      if (!SetupOtherInputs(cf_name, mutable_cf_options, vstorage,
+                            &start_level_inputs, &output_level_inputs,
+                            &parent_index, -1)) {
        return nullptr;
      }
      inputs.push_back(start_level_inputs);
      if (!output_level_inputs.empty()) {
        inputs.push_back(output_level_inputs);
      }
-      if (picker_->FilesRangeOverlapWithCompaction(inputs, output_level)) {
+      if (FilesRangeOverlapWithCompaction(inputs, output_level)) {
        return nullptr;
      }
    } else {
@@ -969,22 +881,21 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {

  uint64_t estimated_total_size = 0;
  // Use size of the output level as estimated file size
-  for (FileMetaData* f : vstorage_->LevelFiles(output_level)) {
+  for (FileMetaData* f : vstorage->LevelFiles(output_level)) {
    estimated_total_size += f->fd.GetFileSize();
  }
  uint32_t path_id =
-      GetPathId(ioptions_, mutable_cf_options_, estimated_total_size);
+      GetPathId(ioptions_, mutable_cf_options, estimated_total_size);
  return new Compaction(
-      vstorage_, ioptions_, mutable_cf_options_, std::move(inputs),
-      output_level,
-      MaxFileSizeForLevel(mutable_cf_options_, output_level,
+      vstorage, ioptions_, mutable_cf_options, std::move(inputs), output_level,
+      MaxFileSizeForLevel(mutable_cf_options, output_level,
                          kCompactionStyleUniversal),
      /* max_grandparent_overlap_bytes */ LLONG_MAX, path_id,
-      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_,
-                         output_level, 1),
-      GetCompressionOptions(ioptions_, vstorage_, output_level),
+      GetCompressionType(ioptions_, vstorage, mutable_cf_options, output_level,
+                         1),
+      GetCompressionOptions(ioptions_, vstorage, output_level),
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ true,
-      score_, false /* deletion_compaction */,
+      score, false /* deletion_compaction */,
      CompactionReason::kFilesMarkedForCompaction);
 }
 }  // namespace rocksdb
@@ -27,6 +27,72 @@ class UniversalCompactionPicker : public CompactionPicker {

  virtual bool NeedsCompaction(
      const VersionStorageInfo* vstorage) const override;
+
+ private:
+  struct SortedRun {
+    SortedRun(int _level, FileMetaData* _file, uint64_t _size,
+              uint64_t _compensated_file_size, bool _being_compacted)
+        : level(_level),
+          file(_file),
+          size(_size),
+          compensated_file_size(_compensated_file_size),
+          being_compacted(_being_compacted) {
+      assert(compensated_file_size > 0);
+      assert(level != 0 || file != nullptr);
+    }
+
+    void Dump(char* out_buf, size_t out_buf_size,
+              bool print_path = false) const;
+
+    // sorted_run_count is added into the string to print
+    void DumpSizeInfo(char* out_buf, size_t out_buf_size,
+                      size_t sorted_run_count) const;
+
+    int level;
+    // `file` Will be null for level > 0. For level = 0, the sorted run is
+    // for this file.
+    FileMetaData* file;
+    // For level > 0, `size` and `compensated_file_size` are sum of sizes all
+    // files in the level. `being_compacted` should be the same for all files
+    // in a non-zero level. Use the value here.
+    uint64_t size;
+    uint64_t compensated_file_size;
+    bool being_compacted;
+  };
+
+  // Pick Universal compaction to limit read amplification
+  Compaction* PickCompactionToReduceSortedRuns(
+      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+      VersionStorageInfo* vstorage, double score, unsigned int ratio,
+      unsigned int num_files, const std::vector<SortedRun>& sorted_runs,
+      LogBuffer* log_buffer);
+
+  // Pick Universal compaction to limit space amplification.
+  Compaction* PickCompactionToReduceSizeAmp(
+      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+      VersionStorageInfo* vstorage, double score,
+      const std::vector<SortedRun>& sorted_runs, LogBuffer* log_buffer);
+
+  Compaction* PickDeleteTriggeredCompaction(
+      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
+      VersionStorageInfo* vstorage, double score,
+      const std::vector<SortedRun>& sorted_runs, LogBuffer* log_buffer);
+
+  // Used in universal compaction when the enabled_trivial_move
+  // option is set. Checks whether there are any overlapping files
+  // in the input. Returns true if the input files are non
+  // overlapping.
+  bool IsInputFilesNonOverlapping(Compaction* c);
+
+  static std::vector<SortedRun> CalculateSortedRuns(
+      const VersionStorageInfo& vstorage, const ImmutableCFOptions& ioptions,
+      const MutableCFOptions& mutable_cf_options);
+
+  // Pick a path ID to place a newly generated file, with its estimated file
+  // size.
+  static uint32_t GetPathId(const ImmutableCFOptions& ioptions,
+                            const MutableCFOptions& mutable_cf_options,
+                            uint64_t file_size);
 };
 }  // namespace rocksdb
 #endif  // !ROCKSDB_LITE
@@ -369,6 +369,13 @@ TEST_F(CorruptionTest, VerifyChecksumReadahead) {
  ASSERT_GE(senv.random_read_counter_.Read(), 213);
  ASSERT_LE(senv.random_read_counter_.Read(), 447);

+  // Test readahead shouldn't break mmap mode (where it should be
+  // disabled).
+  options.allow_mmap_reads = true;
+  Reopen(&options);
+  dbi = static_cast<DBImpl*>(db_);
+  ASSERT_OK(dbi->VerifyChecksum(ro));
+
  CloseDb();
 }

@@ -11,6 +11,7 @@
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/utilities/debug.h"
+#include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/block_builder.h"
 #include "test_util/fault_injection_test_env.h"
 #if !defined(ROCKSDB_LITE)
@@ -1356,9 +1357,9 @@ TEST_F(DBBasicTest, MultiGetBatchedMultiLevel) {
 // Test class for batched MultiGet with prefix extractor
 // Param bool - If true, use partitioned filters
 //              If false, use full filter block
-class MultiGetPrefixExtractorTest : public DBBasicTest,
-                                    public ::testing::WithParamInterface<bool> {
-};
+class MultiGetPrefixExtractorTest
+    : public DBBasicTest,
+      public ::testing::WithParamInterface<bool> {};

 TEST_P(MultiGetPrefixExtractorTest, Batched) {
  Options options = CurrentOptions();
@@ -1396,12 +1397,14 @@ TEST_P(MultiGetPrefixExtractorTest, Batched) {
  ASSERT_EQ(get_perf_context()->bloom_sst_hit_count, 4);
 }

-INSTANTIATE_TEST_CASE_P(MultiGetPrefix, MultiGetPrefixExtractorTest,
-                        ::testing::Bool());
+INSTANTIATE_TEST_CASE_P(
+    MultiGetPrefix, MultiGetPrefixExtractorTest,
+    ::testing::Bool());

 #ifndef ROCKSDB_LITE
-class DBMultiGetRowCacheTest : public DBBasicTest,
-                               public ::testing::WithParamInterface<bool> {};
+class DBMultiGetRowCacheTest
+    : public DBBasicTest,
+      public ::testing::WithParamInterface<bool> {};

 TEST_P(DBMultiGetRowCacheTest, MultiGetBatched) {
  do {
@@ -1539,11 +1542,51 @@ TEST_F(DBBasicTest, GetAllKeyVersions) {
 }
 #endif  // !ROCKSDB_LITE

+TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
+  Options options = CurrentOptions();
+  Random rnd(301);
+  BlockBasedTableOptions table_options;
+  table_options.pin_l0_filter_and_index_blocks_in_cache = true;
+  table_options.block_size = 16 * 1024;
+  assert(table_options.block_size >
+          BlockBasedTable::kMultiGetReadStackBufSize);
+  options.table_factory.reset(new BlockBasedTableFactory(table_options));
+  Reopen(options);
+
+  std::string zero_str(128, '\0');
+  for (int i = 0; i < 100; ++i) {
+    // Make the value compressible. A purely random string doesn't compress
+    // and the resultant data block will not be compressed
+    std::string value(RandomString(&rnd, 128) + zero_str);
+    assert(Put(Key(i), value) == Status::OK());
+  }
+  Flush();
+
+  std::vector<std::string> key_data(10);
+  std::vector<Slice> keys;
+  // We cannot resize a PinnableSlice vector, so just set initial size to
+  // largest we think we will need
+  std::vector<PinnableSlice> values(10);
+  std::vector<Status> statuses;
+  ReadOptions ro;
+
+  // Warm up the cache first
+  key_data.emplace_back(Key(0));
+  keys.emplace_back(Slice(key_data.back()));
+  key_data.emplace_back(Key(50));
+  keys.emplace_back(Slice(key_data.back()));
+  statuses.resize(keys.size());
+
+  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
+                     keys.data(), values.data(), statuses.data(), true);
+}
+
 class DBBasicTestWithParallelIO
    : public DBTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool, bool, bool>> {
+      public testing::WithParamInterface<std::tuple<bool,bool,bool,bool>> {
 public:
-  DBBasicTestWithParallelIO() : DBTestBase("/db_basic_test_with_parallel_io") {
+  DBBasicTestWithParallelIO()
+      : DBTestBase("/db_basic_test_with_parallel_io") {
    bool compressed_cache = std::get<0>(GetParam());
    bool uncompressed_cache = std::get<1>(GetParam());
    compression_enabled_ = std::get<2>(GetParam());
@@ -1563,11 +1606,15 @@ class DBBasicTestWithParallelIO
    Options options = CurrentOptions();
    Random rnd(301);
    BlockBasedTableOptions table_options;
-    table_options.pin_l0_filter_and_index_blocks_in_cache = true;
    table_options.block_cache = uncompressed_cache_;
+    if (table_options.block_cache == nullptr) {
+      table_options.no_block_cache = true;
+    } else {
+      table_options.pin_l0_filter_and_index_blocks_in_cache = true;
+    }
    table_options.block_cache_compressed = compressed_cache_;
    table_options.flush_block_policy_factory.reset(
-        new MyFlushBlockPolicyFactory());
+                      new MyFlushBlockPolicyFactory());
    options.table_factory.reset(new BlockBasedTableFactory(table_options));
    if (!compression_enabled_) {
      options.compression = kNoCompression;
@@ -1595,17 +1642,27 @@ class DBBasicTestWithParallelIO
  int num_found() { return uncompressed_cache_->num_found(); }
  int num_inserts() { return uncompressed_cache_->num_inserts(); }

-  int num_lookups_compressed() { return compressed_cache_->num_lookups(); }
-  int num_found_compressed() { return compressed_cache_->num_found(); }
-  int num_inserts_compressed() { return compressed_cache_->num_inserts(); }
+  int num_lookups_compressed() {
+    return compressed_cache_->num_lookups();
+  }
+  int num_found_compressed() {
+    return compressed_cache_->num_found();
+  }
+  int num_inserts_compressed() {
+    return compressed_cache_->num_inserts();
+  }

  bool fill_cache() { return fill_cache_; }
+  bool compression_enabled() { return compression_enabled_; }
+  bool has_compressed_cache() { return compressed_cache_ != nullptr; }
+  bool has_uncompressed_cache() { return uncompressed_cache_ != nullptr; }

  static void SetUpTestCase() {}
  static void TearDownTestCase() {}

 private:
-  class MyFlushBlockPolicyFactory : public FlushBlockPolicyFactory {
+  class MyFlushBlockPolicyFactory
+    : public FlushBlockPolicyFactory {
   public:
    MyFlushBlockPolicyFactory() {}

@@ -1620,10 +1677,11 @@ class DBBasicTestWithParallelIO
    }
  };

-  class MyFlushBlockPolicy : public FlushBlockPolicy {
+  class MyFlushBlockPolicy
+    : public FlushBlockPolicy {
   public:
    explicit MyFlushBlockPolicy(const BlockBuilder& data_block_builder)
-        : num_keys_(0), data_block_builder_(data_block_builder) {}
+      : num_keys_(0), data_block_builder_(data_block_builder) {}

    bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
      if (data_block_builder_.empty()) {
@@ -1645,10 +1703,11 @@ class DBBasicTestWithParallelIO
    const BlockBuilder& data_block_builder_;
  };

-  class MyBlockCache : public Cache {
+  class MyBlockCache
+    : public Cache {
   public:
    explicit MyBlockCache(std::shared_ptr<Cache>& target)
-        : target_(target), num_lookups_(0), num_found_(0), num_inserts_(0) {}
+      : target_(target), num_lookups_(0), num_found_(0), num_inserts_(0) {}

    virtual const char* Name() const override { return "MyBlockCache"; }

@@ -1670,7 +1729,9 @@ class DBBasicTestWithParallelIO
      return handle;
    }

-    virtual bool Ref(Handle* handle) override { return target_->Ref(handle); }
+    virtual bool Ref(Handle* handle) override {
+      return target_->Ref(handle);
+    }

    virtual bool Release(Handle* handle, bool force_erase = false) override {
      return target_->Release(handle, force_erase);
@@ -1680,8 +1741,12 @@ class DBBasicTestWithParallelIO
      return target_->Value(handle);
    }

-    virtual void Erase(const Slice& key) override { target_->Erase(key); }
-    virtual uint64_t NewId() override { return target_->NewId(); }
+    virtual void Erase(const Slice& key) override {
+      target_->Erase(key);
+    }
+    virtual uint64_t NewId() override {
+      return target_->NewId();
+    }

    virtual void SetCapacity(size_t capacity) override {
      target_->SetCapacity(capacity);
@@ -1699,7 +1764,9 @@ class DBBasicTestWithParallelIO
      return target_->GetCapacity();
    }

-    virtual size_t GetUsage() const override { return target_->GetUsage(); }
+    virtual size_t GetUsage() const override {
+      return target_->GetUsage();
+    }

    virtual size_t GetUsage(Handle* handle) const override {
      return target_->GetUsage(handle);
@@ -1725,7 +1792,6 @@ class DBBasicTestWithParallelIO
    int num_found() { return num_found_; }

    int num_inserts() { return num_inserts_; }
-
   private:
    std::shared_ptr<Cache> target_;
    int num_lookups_;
@@ -1758,7 +1824,7 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
  statuses.resize(keys.size());

  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
+           keys.data(), values.data(), statuses.data(), true);
  ASSERT_TRUE(CheckValue(0, values[0].ToString()));
  ASSERT_TRUE(CheckValue(50, values[1].ToString()));

@@ -1770,16 +1836,25 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
  values[0].Reset();
  values[1].Reset();
  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
+           keys.data(), values.data(), statuses.data(), true);
  ASSERT_TRUE(CheckValue(1, values[0].ToString()));
  ASSERT_TRUE(CheckValue(51, values[1].ToString()));

-  int expected_reads = random_reads + (fill_cache() ? 0 : 2);
+  bool read_from_cache = false;
+  if (fill_cache()) {
+    if (has_uncompressed_cache()) {
+      read_from_cache = true;
+    } else if (has_compressed_cache() && compression_enabled()) {
+      read_from_cache = true;
+    }
+  }
+
+  int expected_reads = random_reads + (read_from_cache ? 0 : 2);
  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);

  keys.resize(10);
  statuses.resize(10);
-  std::vector<int> key_ints{1, 2, 15, 16, 55, 81, 82, 83, 84, 85};
+  std::vector<int> key_ints{1,2,15,16,55,81,82,83,84,85};
  for (size_t i = 0; i < key_ints.size(); ++i) {
    key_data[i] = Key(key_ints[i]);
    keys[i] = Slice(key_data[i]);
@@ -1787,12 +1862,12 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
    values[i].Reset();
  }
  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
+           keys.data(), values.data(), statuses.data(), true);
  for (size_t i = 0; i < key_ints.size(); ++i) {
    ASSERT_OK(statuses[i]);
    ASSERT_TRUE(CheckValue(key_ints[i], values[i].ToString()));
  }
-  expected_reads += (fill_cache() ? 2 : 4);
+  expected_reads += (read_from_cache ? 2 : 4);
  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
 }

@@ -1803,12 +1878,8 @@ INSTANTIATE_TEST_CASE_P(
    // Param 1 - Uncompressed cache enabled
    // Param 2 - Data compression enabled
    // Param 3 - ReadOptions::fill_cache
-    ::testing::Values(std::make_tuple(false, true, true, true),
-                      std::make_tuple(true, true, true, true),
-                      std::make_tuple(false, true, false, true),
-                      std::make_tuple(false, true, true, false),
-                      std::make_tuple(true, true, true, false),
-                      std::make_tuple(false, true, false, false)));
+    ::testing::Combine(::testing::Bool(), ::testing::Bool(),
+                       ::testing::Bool(), ::testing::Bool()));

 class DBBasicTestWithTimestampWithParam
    : public DBTestBase,
@@ -12,7 +12,6 @@
 #include <utility>
 #include <vector>

-#include "db/arena_wrapped_db_iter.h"
 #include "db/column_family.h"
 #include "db/db_iter.h"
 #include "db/db_test_util.h"
@@ -380,13 +380,8 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
  options.statistics = rocksdb::CreateDBStatistics();
  BlockBasedTableOptions table_options;
  table_options.cache_index_and_filter_blocks = true;
-  LRUCacheOptions co;
  // 500 bytes are enough to hold the first two blocks
-  co.capacity = 500;
-  co.num_shard_bits = 0;
-  co.strict_capacity_limit = false;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  std::shared_ptr<Cache> cache = NewLRUCache(co);
+  std::shared_ptr<Cache> cache = NewLRUCache(500, 0, false);
  table_options.block_cache = cache;
  table_options.filter_policy.reset(NewBloomFilterPolicy(20, true));
  options.table_factory.reset(new BlockBasedTableFactory(table_options));
@@ -4664,7 +4664,7 @@ TEST_F(DBCompactionTest, ConsistencyFailTest) {

  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "VersionBuilder::CheckConsistency", [&](void* arg) {
-        auto p =
+      auto p =
            reinterpret_cast<std::pair<FileMetaData**, FileMetaData**>*>(arg);
        // just swap the two FileMetaData so that we hit error
        // in CheckConsistency funcion
@@ -6,9 +6,9 @@

 #ifndef ROCKSDB_LITE

+#include <cinttypes>
 #include <stdint.h>
 #include <algorithm>
-#include <cinttypes>
 #include <string>
 #include "db/db_impl/db_impl.h"
 #include "db/job_context.h"
@@ -172,6 +172,7 @@ Status DBImpl::GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) {

  return wal_manager_.GetLiveWalFile(current_logfile_number, current_log_file);
 }
+
 }

 #endif  // ROCKSDB_LITE
@@ -25,7 +25,6 @@
 #include <utility>
 #include <vector>

-#include "db/arena_wrapped_db_iter.h"
 #include "db/builder.h"
 #include "db/compaction/compaction_job.h"
 #include "db/db_info_dumper.h"
@@ -54,7 +53,6 @@
 #include "db/write_callback.h"
 #include "file/file_util.h"
 #include "file/filename.h"
-#include "file/random_access_file_reader.h"
 #include "file/sst_file_manager_impl.h"
 #include "logging/auto_roll_logger.h"
 #include "logging/log_buffer.h"
@@ -97,6 +95,7 @@
 #include "util/coding.h"
 #include "util/compression.h"
 #include "util/crc32c.h"
+#include "util/file_reader_writer.h"
 #include "util/mutexlock.h"
 #include "util/stop_watch.h"
 #include "util/string_util.h"
@@ -165,7 +164,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      batch_per_txn_(batch_per_txn),
      db_lock_(nullptr),
      shutting_down_(false),
-      manual_compaction_paused_(false),
      bg_cv_(&mutex_),
      logfile_number_(0),
      log_dir_synced_(false),
@@ -241,11 +239,8 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
  const int table_cache_size = (mutable_db_options_.max_open_files == -1)
                                   ? TableCache::kInfiniteCapacity
                                   : mutable_db_options_.max_open_files - 10;
-  LRUCacheOptions co;
-  co.capacity = table_cache_size;
-  co.num_shard_bits = immutable_db_options_.table_cache_numshardbits;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  table_cache_ = NewLRUCache(co);
+  table_cache_ = NewLRUCache(table_cache_size,
+                             immutable_db_options_.table_cache_numshardbits);

  versions_.reset(new VersionSet(dbname_, &immutable_db_options_, env_options_,
                                 table_cache_.get(), write_buffer_manager_,
@@ -1314,28 +1309,32 @@ void DBImpl::SchedulePurge() {
 void DBImpl::BackgroundCallPurge() {
  mutex_.Lock();

-  while (!logs_to_free_queue_.empty()) {
-    assert(!logs_to_free_queue_.empty());
-    log::Writer* log_writer = *(logs_to_free_queue_.begin());
-    logs_to_free_queue_.pop_front();
-    mutex_.Unlock();
-    delete log_writer;
-    mutex_.Lock();
-  }
-  for (const auto& file : purge_files_) {
-    const PurgeFileInfo& purge_file = file.second;
-    const std::string& fname = purge_file.fname;
-    const std::string& dir_to_sync = purge_file.dir_to_sync;
-    FileType type = purge_file.type;
-    uint64_t number = purge_file.number;
-    int job_id = purge_file.job_id;
+  // We use one single loop to clear both queues so that after existing the loop
+  // both queues are empty. This is stricter than what is needed, but can make
+  // it easier for us to reason the correctness.
+  while (!purge_queue_.empty() || !logs_to_free_queue_.empty()) {
+    // Check logs_to_free_queue_ first and close log writers.
+    if (!logs_to_free_queue_.empty()) {
+      assert(!logs_to_free_queue_.empty());
+      log::Writer* log_writer = *(logs_to_free_queue_.begin());
+      logs_to_free_queue_.pop_front();
+      mutex_.Unlock();
+      delete log_writer;
+      mutex_.Lock();
+    } else {
+      auto purge_file = purge_queue_.begin();
+      auto fname = purge_file->fname;
+      auto dir_to_sync = purge_file->dir_to_sync;
+      auto type = purge_file->type;
+      auto number = purge_file->number;
+      auto job_id = purge_file->job_id;
+      purge_queue_.pop_front();

-    mutex_.Unlock();
-    DeleteObsoleteFileImpl(job_id, fname, dir_to_sync, type, number);
-    mutex_.Lock();
+      mutex_.Unlock();
+      DeleteObsoleteFileImpl(job_id, fname, dir_to_sync, type, number);
+      mutex_.Lock();
+    }
  }
-  purge_files_.clear();
-
  bg_purge_scheduled_--;

  bg_cv_.SignalAll();
@@ -3286,8 +3285,9 @@ Status DestroyDB(const std::string& dbname, const Options& options,
        if (type == kMetaDatabase) {
          del = DestroyDB(path_to_delete, options);
        } else if (type == kTableFile || type == kLogFile) {
-          del = DeleteDBFile(&soptions, path_to_delete, dbname,
-                             /*force_bg=*/false, /*force_fg=*/!wal_in_db_path);
+          del =
+              DeleteDBFile(&soptions, path_to_delete, dbname,
+                           /*force_bg=*/false, /*force_fg=*/!wal_in_db_path);
        } else {
          del = env->DeleteFile(path_to_delete);
        }
@@ -3762,9 +3762,9 @@ Status DBImpl::IngestExternalFiles(
  std::vector<ExternalSstFileIngestionJob> ingestion_jobs;
  for (const auto& arg : args) {
    auto* cfd = static_cast<ColumnFamilyHandleImpl*>(arg.column_family)->cfd();
-    ingestion_jobs.emplace_back(
-        env_, versions_.get(), cfd, immutable_db_options_, env_options_,
-        &snapshots_, arg.options, &directories_, &event_logger_);
+    ingestion_jobs.emplace_back(env_, versions_.get(), cfd,
+                                immutable_db_options_, env_options_,
+                                &snapshots_, arg.options, &directories_);
  }
  std::vector<std::pair<bool, Status>> exec_results;
  for (size_t i = 0; i != num_cfs; ++i) {
@@ -3894,21 +3894,19 @@ Status DBImpl::IngestExternalFiles(
      }
    }
    if (status.ok()) {
-      int consumed_seqno_count =
-          ingestion_jobs[0].ConsumedSequenceNumbersCount();
+      bool should_increment_last_seqno =
+          ingestion_jobs[0].ShouldIncrementLastSequence();
 #ifndef NDEBUG
      for (size_t i = 1; i != num_cfs; ++i) {
-        assert(!!consumed_seqno_count ==
-               !!ingestion_jobs[i].ConsumedSequenceNumbersCount());
-        consumed_seqno_count +=
-            ingestion_jobs[i].ConsumedSequenceNumbersCount();
+        assert(should_increment_last_seqno ==
+               ingestion_jobs[i].ShouldIncrementLastSequence());
      }
 #endif
-      if (consumed_seqno_count > 0) {
+      if (should_increment_last_seqno) {
        const SequenceNumber last_seqno = versions_->LastSequence();
-        versions_->SetLastAllocatedSequence(last_seqno + consumed_seqno_count);
-        versions_->SetLastPublishedSequence(last_seqno + consumed_seqno_count);
-        versions_->SetLastSequence(last_seqno + consumed_seqno_count);
+        versions_->SetLastAllocatedSequence(last_seqno + 1);
+        versions_->SetLastPublishedSequence(last_seqno + 1);
+        versions_->SetLastSequence(last_seqno + 1);
      }
      autovector<ColumnFamilyData*> cfds_to_commit;
      autovector<const MutableCFOptions*> mutable_cf_options_list;
@@ -4002,7 +4000,8 @@ Status DBImpl::IngestExternalFiles(
 Status DBImpl::CreateColumnFamilyWithImport(
    const ColumnFamilyOptions& options, const std::string& column_family_name,
    const ImportColumnFamilyOptions& import_options,
-    const ExportImportFilesMetaData& metadata, ColumnFamilyHandle** handle) {
+    const ExportImportFilesMetaData& metadata,
+    ColumnFamilyHandle** handle) {
  assert(handle != nullptr);
  assert(*handle == nullptr);
  std::string cf_comparator_name = options.comparator->Name();
@@ -4043,7 +4042,8 @@ Status DBImpl::CreateColumnFamilyWithImport(
      // reuse the file number that has already assigned to the internal file,
      // and this will overwrite the external file. To protect the external
      // file, we have to make sure the file number will never being reused.
-      next_file_number = versions_->FetchAddFileNumber(metadata.files.size());
+      next_file_number =
+          versions_->FetchAddFileNumber(metadata.files.size());
      auto cf_options = cfd->GetLatestMutableCFOptions();
      status = versions_->LogAndApply(cfd, *cf_options, &dummy_edit, &mutex_,
                                      directories_.GetDbDir());
@@ -282,9 +282,6 @@ class DBImpl : public DB {
  virtual Status EnableAutoCompaction(
      const std::vector<ColumnFamilyHandle*>& column_family_handles) override;

-  virtual void EnableManualCompaction() override;
-  virtual void DisableManualCompaction() override;
-
  using DB::SetOptions;
  Status SetOptions(
      ColumnFamilyHandle* column_family,
@@ -347,8 +344,7 @@ class DBImpl : public DB {
                              uint64_t* manifest_file_size,
                              bool flush_memtable = true) override;
  virtual Status GetSortedWalFiles(VectorLogPtr& files) override;
-  virtual Status GetCurrentWalFile(
-      std::unique_ptr<LogFile>* current_log_file) override;
+  virtual Status GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) override;

  virtual Status GetUpdatesSince(
      SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter,
@@ -1642,7 +1638,6 @@ class DBImpl : public DB {
  InstrumentedMutex log_write_mutex_;

  std::atomic<bool> shutting_down_;
-  std::atomic<bool> manual_compaction_paused_;
  // This condition variable is signaled on these conditions:
  // * whenever bg_compaction_scheduled_ goes down to 0
  // * if AnyManualCompaction, whenever a compaction finishes, even if it hasn't
@@ -1785,12 +1780,12 @@ class DBImpl : public DB {
  // ColumnFamilyData::pending_compaction_ == true)
  std::deque<ColumnFamilyData*> compaction_queue_;

-  // A map to store file numbers and filenames of the files to be purged
-  std::unordered_map<uint64_t, PurgeFileInfo> purge_files_;
+  // A queue to store filenames of the files to be purged
+  std::deque<PurgeFileInfo> purge_queue_;

  // A vector to store the file numbers that have been assigned to certain
  // JobContext. Current implementation tracks ssts only.
-  std::unordered_set<uint64_t> files_grabbed_for_purge_;
+  std::vector<uint64_t> files_grabbed_for_purge_;

  // A queue to store log writers to close
  std::deque<log::Writer*> logs_to_free_queue_;
@@ -800,6 +800,31 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
  return s;
 }

+namespace {
+class SnapshotListFetchCallbackImpl : public SnapshotListFetchCallback {
+ public:
+  SnapshotListFetchCallbackImpl(DBImpl* db_impl, Env* env,
+                                uint64_t snap_refresh_nanos, Logger* info_log)
+      : SnapshotListFetchCallback(env, snap_refresh_nanos),
+        db_impl_(db_impl),
+        info_log_(info_log) {}
+  virtual void Refresh(std::vector<SequenceNumber>* snapshots,
+                       SequenceNumber max) override {
+    size_t prev = snapshots->size();
+    snapshots->clear();
+    db_impl_->LoadSnapshots(snapshots, nullptr, max);
+    size_t now = snapshots->size();
+    ROCKS_LOG_DEBUG(info_log_,
+                    "Compaction snapshot count refreshed from %zu to %zu", prev,
+                    now);
+  }
+
+ private:
+  DBImpl* db_impl_;
+  Logger* info_log_;
+};
+}  // namespace
+
 Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
                            ColumnFamilyHandle* column_family,
                            const std::vector<std::string>& input_file_names,
@@ -892,9 +917,6 @@ Status DBImpl::CompactFilesImpl(
  if (shutting_down_.load(std::memory_order_acquire)) {
    return Status::ShutdownInProgress();
  }
-  if (manual_compaction_paused_.load(std::memory_order_acquire)) {
-    return Status::Incomplete(Status::SubCode::kManualCompactionPaused);
-  }

  std::unordered_set<uint64_t> input_set;
  for (const auto& file_name : input_file_names) {
@@ -974,6 +996,9 @@ Status DBImpl::CompactFilesImpl(

  assert(is_snapshot_supported_ || snapshots_.empty());
  CompactionJobStats compaction_job_stats;
+  SnapshotListFetchCallbackImpl fetch_callback(
+      this, env_, c->mutable_cf_options()->snap_refresh_nanos,
+      immutable_db_options_.info_log.get());
  CompactionJob compaction_job(
      job_context->job_id, c.get(), immutable_db_options_,
      env_options_for_compaction_, versions_.get(), &shutting_down_,
@@ -983,7 +1008,11 @@ Status DBImpl::CompactFilesImpl(
      snapshot_checker, table_cache_, &event_logger_,
      c->mutable_cf_options()->paranoid_file_checks,
      c->mutable_cf_options()->report_bg_io_stats, dbname_,
-      &compaction_job_stats, Env::Priority::USER, &manual_compaction_paused_);
+      &compaction_job_stats, Env::Priority::USER,
+      immutable_db_options_.max_subcompactions <= 1 &&
+              c->mutable_cf_options()->snap_refresh_nanos > 0
+          ? &fetch_callback
+          : nullptr);

  // Creating a compaction influences the compaction score because the score
  // takes running compactions into account (by skipping files that are already
@@ -1029,12 +1058,6 @@ Status DBImpl::CompactFilesImpl(
    // Done
  } else if (status.IsColumnFamilyDropped() || status.IsShutdownInProgress()) {
    // Ignore compaction errors found during shutting down
-  } else if (status.IsManualCompactionPaused()) {
-    // Don't report stopping manual compaction as error
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "[%s] [JOB %d] Stopping manual compaction",
-                   c->column_family_data()->GetName().c_str(),
-                   job_context->job_id);
  } else {
    ROCKS_LOG_WARN(immutable_db_options_.info_log,
                   "[%s] [JOB %d] Compaction error: %s",
@@ -1105,10 +1128,6 @@ void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
  if (shutting_down_.load(std::memory_order_acquire)) {
    return;
  }
-  if (c->is_manual_compaction() &&
-      manual_compaction_paused_.load(std::memory_order_acquire)) {
-    return;
-  }
  Version* current = cfd->current();
  current->Ref();
  // release lock while notifying events
@@ -1171,10 +1190,6 @@ void DBImpl::NotifyOnCompactionCompleted(
  if (shutting_down_.load(std::memory_order_acquire)) {
    return;
  }
-  if (c->is_manual_compaction() &&
-      manual_compaction_paused_.load(std::memory_order_acquire)) {
-    return;
-  }
  Version* current = cfd->current();
  current->Ref();
  // release lock while notifying events
@@ -1565,8 +1580,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
          if (stats_cf_flush_needed) {
            ROCKS_LOG_INFO(immutable_db_options_.info_log,
                           "Force flushing stats CF with manual flush of %s "
-                           "to avoid holding old logs",
-                           cfd->GetName().c_str());
+                           "to avoid holding old logs", cfd->GetName().c_str());
            s = SwitchMemtable(cfd_stats, &context);
            flush_memtable_id = cfd_stats->imm()->GetLatestMemTableID();
            flush_req.emplace_back(cfd_stats, flush_memtable_id);
@@ -1865,14 +1879,6 @@ Status DBImpl::EnableAutoCompaction(
  return s;
 }

-void DBImpl::DisableManualCompaction() {
-  manual_compaction_paused_.store(true, std::memory_order_release);
-}
-
-void DBImpl::EnableManualCompaction() {
-  manual_compaction_paused_.store(false, std::memory_order_release);
-}
-
 void DBImpl::MaybeScheduleFlushOrCompaction() {
  mutex_.AssertHeld();
  if (!opened_successfully_) {
@@ -2058,7 +2064,7 @@ void DBImpl::SchedulePendingPurge(std::string fname, std::string dir_to_sync,
                                  FileType type, uint64_t number, int job_id) {
  mutex_.AssertHeld();
  PurgeFileInfo file_info(fname, dir_to_sync, type, number, job_id);
-  purge_files_.insert({{number, std::move(file_info)}});
+  purge_queue_.push_back(std::move(file_info));
 }

 void DBImpl::BGWorkFlush(void* arg) {
@@ -2313,7 +2319,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
      env_->SleepForMicroseconds(10000);  // prevent hot loop
      mutex_.Lock();
    } else if (!s.ok() && !s.IsShutdownInProgress() &&
-               !s.IsManualCompactionPaused() && !s.IsColumnFamilyDropped()) {
+               !s.IsColumnFamilyDropped()) {
      // Wait a little bit before retrying background compaction in
      // case this is an environmental problem and we do not want to
      // chew up resources for failed compactions for the duration of
@@ -2330,11 +2336,6 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
      LogFlush(immutable_db_options_.info_log);
      env_->SleepForMicroseconds(1000000);
      mutex_.Lock();
-    } else if (s.IsManualCompactionPaused()) {
-      ManualCompactionState* m = prepicked_compaction->manual_compaction_state;
-      assert(m);
-      ROCKS_LOG_BUFFER(&log_buffer, "[%s] [JOB %d] Manual compaction paused",
-                       m->cfd->GetName().c_str(), job_context.job_id);
    }

    ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem);
@@ -2343,7 +2344,6 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
    // have created (they might not be all recorded in job_context in case of a
    // failure). Thus, we force full scan in FindObsoleteFiles()
    FindObsoleteFiles(&job_context, !s.ok() && !s.IsShutdownInProgress() &&
-                                        !s.IsManualCompactionPaused() &&
                                        !s.IsColumnFamilyDropped());
    TEST_SYNC_POINT("DBImpl::BackgroundCallCompaction:FoundObsoleteFiles");

@@ -2427,9 +2427,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
  if (!error_handler_.IsBGWorkStopped()) {
    if (shutting_down_.load(std::memory_order_acquire)) {
      status = Status::ShutdownInProgress();
-    } else if (is_manual &&
-               manual_compaction_paused_.load(std::memory_order_acquire)) {
-      status = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
    }
  } else {
    status = error_handler_.GetBGError();
@@ -2731,6 +2728,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    GetSnapshotContext(job_context, &snapshot_seqs,
                       &earliest_write_conflict_snapshot, &snapshot_checker);
    assert(is_snapshot_supported_ || snapshots_.empty());
+    SnapshotListFetchCallbackImpl fetch_callback(
+        this, env_, c->mutable_cf_options()->snap_refresh_nanos,
+        immutable_db_options_.info_log.get());
    CompactionJob compaction_job(
        job_context->job_id, c.get(), immutable_db_options_,
        env_options_for_compaction_, versions_.get(), &shutting_down_,
@@ -2741,7 +2741,10 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
        c->mutable_cf_options()->report_bg_io_stats, dbname_,
        &compaction_job_stats, thread_pri,
-        is_manual ? &manual_compaction_paused_ : nullptr);
+        immutable_db_options_.max_subcompactions <= 1 &&
+                c->mutable_cf_options()->snap_refresh_nanos > 0
+            ? &fetch_callback
+            : nullptr);
    compaction_job.Prepare();

    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
@@ -2781,8 +2784,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                compaction_job_stats, job_context->job_id);
  }

-  if (status.ok() || status.IsCompactionTooLarge() ||
-      status.IsManualCompactionPaused()) {
+  if (status.ok() || status.IsCompactionTooLarge()) {
    // Done
  } else if (status.IsColumnFamilyDropped() || status.IsShutdownInProgress()) {
    // Ignore compaction errors found during shutting down
@@ -3037,20 +3039,34 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
 }

 // ShouldPurge is called by FindObsoleteFiles when doing a full scan,
-// and db mutex (mutex_) should already be held.
+// and db mutex (mutex_) should already be held. This function performs a
+// linear scan of an vector (files_grabbed_for_purge_) in search of a
+// certain element. We expect FindObsoleteFiles with full scan to occur once
+// every 10 hours by default, and the size of the vector is small.
+// Therefore, the cost is affordable even if the mutex is held.
 // Actually, the current implementation of FindObsoleteFiles with
 // full_scan=true can issue I/O requests to obtain list of files in
 // directories, e.g. env_->getChildren while holding db mutex.
+// In the future, if we want to reduce the cost of search, we may try to keep
+// the vector sorted.
 bool DBImpl::ShouldPurge(uint64_t file_number) const {
-  return files_grabbed_for_purge_.find(file_number) ==
-             files_grabbed_for_purge_.end() &&
-         purge_files_.find(file_number) == purge_files_.end();
+  for (auto fn : files_grabbed_for_purge_) {
+    if (file_number == fn) {
+      return false;
+    }
+  }
+  for (const auto& purge_file_info : purge_queue_) {
+    if (purge_file_info.number == file_number) {
+      return false;
+    }
+  }
+  return true;
 }

 // MarkAsGrabbedForPurge is called by FindObsoleteFiles, and db mutex
 // (mutex_) should already be held.
 void DBImpl::MarkAsGrabbedForPurge(uint64_t file_number) {
-  files_grabbed_for_purge_.insert(file_number);
+  files_grabbed_for_purge_.emplace_back(file_number);
 }

 void DBImpl::SetSnapshotChecker(SnapshotChecker* snapshot_checker) {
@@ -15,7 +15,6 @@
 #include "db/memtable_list.h"
 #include "file/file_util.h"
 #include "file/sst_file_manager_impl.h"
-#include "util/autovector.h"

 namespace rocksdb {

@@ -379,12 +378,6 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    }
  }

-  // Close WALs before trying to delete them.
-  for (const auto w : state.logs_to_free) {
-    // TODO: maybe check the return value of Close.
-    w->Close();
-  }
-
  std::unordered_set<uint64_t> files_to_del;
  for (const auto& candidate_file : candidate_files) {
    const std::string& to_delete = candidate_file.file_name;
@@ -484,6 +477,11 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    }
 #endif  // !ROCKSDB_LITE

+    for (const auto w : state.logs_to_free) {
+      // TODO: maybe check the return value of Close.
+      w->Close();
+    }
+
    Status file_deletion_status;
    if (schedule_only) {
      InstrumentedMutexLock guard_lock(&mutex_);
@@ -497,15 +495,13 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
    // After purging obsolete files, remove them from files_grabbed_for_purge_.
    // Use a temporary vector to perform bulk deletion via swap.
    InstrumentedMutexLock guard_lock(&mutex_);
-    autovector<uint64_t> to_be_removed;
+    std::vector<uint64_t> tmp;
    for (auto fn : files_grabbed_for_purge_) {
-      if (files_to_del.count(fn) != 0) {
-        to_be_removed.emplace_back(fn);
+      if (files_to_del.count(fn) == 0) {
+        tmp.emplace_back(fn);
      }
    }
-    for (auto fn : to_be_removed) {
-      files_grabbed_for_purge_.erase(fn);
-    }
+    files_grabbed_for_purge_.swap(tmp);
  }

  // Delete old info log files.
@@ -12,9 +12,7 @@

 #include "db/builder.h"
 #include "db/error_handler.h"
-#include "file/read_write_util.h"
 #include "file/sst_file_manager_impl.h"
-#include "file/writable_file_writer.h"
 #include "monitoring/persistent_stats_history.h"
 #include "options/options_helper.h"
 #include "rocksdb/wal_filter.h"
@@ -135,9 +133,9 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
    std::vector<std::string> filenames;
    result.env->GetChildren(result.wal_dir, &filenames);
    for (std::string& filename : filenames) {
-      if (filename.find(".log.trash", filename.length() -
-                                          std::string(".log.trash").length()) !=
-          std::string::npos) {
+      if (filename.find(".log.trash",
+                  filename.length() - std::string(".log.trash").length()) !=
+                  std::string::npos) {
        std::string trash_file = result.wal_dir + "/" + filename;
        result.env->DeleteFile(trash_file);
      }
@@ -228,11 +226,6 @@ Status DBImpl::ValidateOptions(const DBOptions& db_options) {
        "unordered_write is incompatible with enable_pipelined_write");
  }

-  if (db_options.atomic_flush && db_options.enable_pipelined_write) {
-    return Status::InvalidArgument(
-        "atomic_flush is incompatible with enable_pipelined_write");
-  }
-
  return Status::OK();
 }

@@ -1058,8 +1051,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
      versions_->MarkFileNumberUsed(max_log_number + 1);
      status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                      edit, &mutex_);
-      TEST_SYNC_POINT_CALLBACK("DBImpl::RecoverLogFiles:AfterLogAndApply",
-                               nullptr);
      if (!status.ok()) {
        // Recovery failed
        break;
@@ -1359,7 +1350,8 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    return s;
  }

-  impl->wal_in_db_path_ = IsWalDirSameAsDBPath(&impl->immutable_db_options_);
+  impl->wal_in_db_path_ =
+      IsWalDirSameAsDBPath(&impl->immutable_db_options_);

  impl->mutex_.Lock();
  // Handles create_if_missing, error_if_exists
@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).

 #include "db/db_impl/db_impl_readonly.h"
-#include "db/arena_wrapped_db_iter.h"

 #include "db/compacted_db_impl.h"
 #include "db/db_impl/db_impl.h"
@@ -7,7 +7,7 @@

 #include <cinttypes>

-#include "db/arena_wrapped_db_iter.h"
+#include "db/db_iter.h"
 #include "db/merge_context.h"
 #include "logging/auto_roll_logger.h"
 #include "monitoring/perf_context_imp.h"
@@ -588,7 +588,8 @@ Status DB::OpenAsSecondary(
      &impl->write_controller_));
  impl->column_family_memtables_.reset(
      new ColumnFamilyMemTablesImpl(impl->versions_->GetColumnFamilySet()));
-  impl->wal_in_db_path_ = IsWalDirSameAsDBPath(&impl->immutable_db_options_);
+  impl->wal_in_db_path_ =
+      IsWalDirSameAsDBPath(&impl->immutable_db_options_);

  impl->mutex_.Lock();
  s = impl->Recover(column_families, true, false, false);
@@ -1499,12 +1499,14 @@ Status DBImpl::TrimMemtableHistory(WriteContext* context) {
  for (auto& cfd : cfds) {
    autovector<MemTable*> to_delete;
    cfd->imm()->TrimHistory(&to_delete, cfd->mem()->ApproximateMemoryUsage());
-    for (auto m : to_delete) {
-      delete m;
+    if (!to_delete.empty()) {
+      for (auto m : to_delete) {
+        delete m;
+      }
+      context->superversion_context.NewSuperVersion();
+      assert(context->superversion_context.new_superversion.get() != nullptr);
+      cfd->InstallSuperVersion(&context->superversion_context, &mutex_);
    }
-    context->superversion_context.NewSuperVersion();
-    assert(context->superversion_context.new_superversion.get() != nullptr);
-    cfd->InstallSuperVersion(&context->superversion_context, &mutex_);

    if (cfd->Unref()) {
      delete cfd;
@@ -605,9 +605,9 @@ TEST_F(DBSecondaryTest, SwitchWAL) {
 TEST_F(DBSecondaryTest, SwitchWALMultiColumnFamilies) {
  const int kNumKeysPerMemtable = 1;
  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::BackgroundCallFlush:ContextCleanedUp",
-        "DBSecondaryTest::SwitchWALMultipleColumnFamilies:BeforeCatchUp"}});
+  SyncPoint::GetInstance()->LoadDependency({
+      {"DBImpl::BackgroundCallFlush:ContextCleanedUp",
+       "DBSecondaryTest::SwitchWALMultipleColumnFamilies:BeforeCatchUp"}});
  SyncPoint::GetInstance()->EnableProcessing();
  const std::string kCFName1 = "pikachu";
  Options options;
@@ -662,8 +662,7 @@ TEST_F(DBSecondaryTest, SwitchWALMultiColumnFamilies) {
        Put(0 /*cf*/, "key" + std::to_string(k), "value" + std::to_string(k)));
    ASSERT_OK(
        Put(1 /*cf*/, "key" + std::to_string(k), "value" + std::to_string(k)));
-    TEST_SYNC_POINT(
-        "DBSecondaryTest::SwitchWALMultipleColumnFamilies:BeforeCatchUp");
+    TEST_SYNC_POINT("DBSecondaryTest::SwitchWALMultipleColumnFamilies:BeforeCatchUp");
    ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
    verify_db(dbfull(), handles_, db_secondary_, handles_secondary_);
    SyncPoint::GetInstance()->ClearTrace();
@@ -5,10 +5,10 @@

 #include "db/db_info_dumper.h"

-#include <stdio.h>
-#include <algorithm>
 #include <cinttypes>
+#include <stdio.h>
 #include <string>
+#include <algorithm>
 #include <vector>

 #include "file/filename.h"
@@ -46,74 +46,323 @@ static void DumpInternalIter(Iterator* iter) {
 }
 #endif

-DBIter::DBIter(Env* _env, const ReadOptions& read_options,
-               const ImmutableCFOptions& cf_options,
-               const MutableCFOptions& mutable_cf_options,
-               const Comparator* cmp, InternalIterator* iter, SequenceNumber s,
-               bool arena_mode, uint64_t max_sequential_skip_in_iterations,
-               ReadCallback* read_callback, DBImpl* db_impl,
-               ColumnFamilyData* cfd, bool allow_blob)
-    : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
-      env_(_env),
-      logger_(cf_options.info_log),
-      user_comparator_(cmp),
-      merge_operator_(cf_options.merge_operator),
-      iter_(iter),
-      read_callback_(read_callback),
-      sequence_(s),
-      statistics_(cf_options.statistics),
-      num_internal_keys_skipped_(0),
-      iterate_lower_bound_(read_options.iterate_lower_bound),
-      iterate_upper_bound_(read_options.iterate_upper_bound),
-      direction_(kForward),
-      valid_(false),
-      current_entry_is_merged_(false),
-      is_key_seqnum_zero_(false),
-      prefix_same_as_start_(mutable_cf_options.prefix_extractor
-                                ? read_options.prefix_same_as_start
-                                : false),
-      pin_thru_lifetime_(read_options.pin_data),
-      total_order_seek_(read_options.total_order_seek),
-      allow_blob_(allow_blob),
-      is_blob_(false),
-      arena_mode_(arena_mode),
-      range_del_agg_(&cf_options.internal_comparator, s),
-      db_impl_(db_impl),
-      cfd_(cfd),
-      start_seqnum_(read_options.iter_start_seqnum) {
-  RecordTick(statistics_, NO_ITERATOR_CREATED);
-  max_skip_ = max_sequential_skip_in_iterations;
-  max_skippable_internal_keys_ = read_options.max_skippable_internal_keys;
-  if (pin_thru_lifetime_) {
-    pinned_iters_mgr_.StartPinning();
+// Memtables and sstables that make the DB representation contain
+// (userkey,seq,type) => uservalue entries.  DBIter
+// combines multiple entries for the same userkey found in the DB
+// representation into a single entry while accounting for sequence
+// numbers, deletion markers, overwrites, etc.
+class DBIter final: public Iterator {
+ public:
+  // The following is grossly complicated. TODO: clean it up
+  // Which direction is the iterator currently moving?
+  // (1) When moving forward:
+  //   (1a) if current_entry_is_merged_ = false, the internal iterator is
+  //        positioned at the exact entry that yields this->key(), this->value()
+  //   (1b) if current_entry_is_merged_ = true, the internal iterator is
+  //        positioned immediately after the last entry that contributed to the
+  //        current this->value(). That entry may or may not have key equal to
+  //        this->key().
+  // (2) When moving backwards, the internal iterator is positioned
+  //     just before all entries whose user key == this->key().
+  enum Direction {
+    kForward,
+    kReverse
+  };
+
+  // LocalStatistics contain Statistics counters that will be aggregated per
+  // each iterator instance and then will be sent to the global statistics when
+  // the iterator is destroyed.
+  //
+  // The purpose of this approach is to avoid perf regression happening
+  // when multiple threads bump the atomic counters from a DBIter::Next().
+  struct LocalStatistics {
+    explicit LocalStatistics() { ResetCounters(); }
+
+    void ResetCounters() {
+      next_count_ = 0;
+      next_found_count_ = 0;
+      prev_count_ = 0;
+      prev_found_count_ = 0;
+      bytes_read_ = 0;
+      skip_count_ = 0;
+    }
+
+    void BumpGlobalStatistics(Statistics* global_statistics) {
+      RecordTick(global_statistics, NUMBER_DB_NEXT, next_count_);
+      RecordTick(global_statistics, NUMBER_DB_NEXT_FOUND, next_found_count_);
+      RecordTick(global_statistics, NUMBER_DB_PREV, prev_count_);
+      RecordTick(global_statistics, NUMBER_DB_PREV_FOUND, prev_found_count_);
+      RecordTick(global_statistics, ITER_BYTES_READ, bytes_read_);
+      RecordTick(global_statistics, NUMBER_ITER_SKIP, skip_count_);
+      PERF_COUNTER_ADD(iter_read_bytes, bytes_read_);
+      ResetCounters();
+    }
+
+    // Map to Tickers::NUMBER_DB_NEXT
+    uint64_t next_count_;
+    // Map to Tickers::NUMBER_DB_NEXT_FOUND
+    uint64_t next_found_count_;
+    // Map to Tickers::NUMBER_DB_PREV
+    uint64_t prev_count_;
+    // Map to Tickers::NUMBER_DB_PREV_FOUND
+    uint64_t prev_found_count_;
+    // Map to Tickers::ITER_BYTES_READ
+    uint64_t bytes_read_;
+    // Map to Tickers::NUMBER_ITER_SKIP
+    uint64_t skip_count_;
+  };
+
+  DBIter(Env* _env, const ReadOptions& read_options,
+         const ImmutableCFOptions& cf_options,
+         const MutableCFOptions& mutable_cf_options, const Comparator* cmp,
+         InternalIterator* iter, SequenceNumber s, bool arena_mode,
+         uint64_t max_sequential_skip_in_iterations,
+         ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
+         bool allow_blob)
+      : env_(_env),
+        logger_(cf_options.info_log),
+        user_comparator_(cmp),
+        merge_operator_(cf_options.merge_operator),
+        iter_(iter),
+        read_callback_(read_callback),
+        sequence_(s),
+        statistics_(cf_options.statistics),
+        num_internal_keys_skipped_(0),
+        iterate_lower_bound_(read_options.iterate_lower_bound),
+        iterate_upper_bound_(read_options.iterate_upper_bound),
+        direction_(kForward),
+        valid_(false),
+        current_entry_is_merged_(false),
+        is_key_seqnum_zero_(false),
+        prefix_same_as_start_(read_options.prefix_same_as_start),
+        pin_thru_lifetime_(read_options.pin_data),
+        total_order_seek_(read_options.total_order_seek),
+        allow_blob_(allow_blob),
+        is_blob_(false),
+        arena_mode_(arena_mode),
+        range_del_agg_(&cf_options.internal_comparator, s),
+        db_impl_(db_impl),
+        cfd_(cfd),
+        start_seqnum_(read_options.iter_start_seqnum) {
+    RecordTick(statistics_, NO_ITERATOR_CREATED);
+    prefix_extractor_ = mutable_cf_options.prefix_extractor.get();
+    max_skip_ = max_sequential_skip_in_iterations;
+    max_skippable_internal_keys_ = read_options.max_skippable_internal_keys;
+    if (pin_thru_lifetime_) {
+      pinned_iters_mgr_.StartPinning();
+    }
+    if (iter_.iter()) {
+      iter_.iter()->SetPinnedItersMgr(&pinned_iters_mgr_);
+    }
  }
-  if (iter_.iter()) {
+  // No copying allowed
+  DBIter(const DBIter&) = delete;
+  void operator=(const DBIter&) = delete;
+
+  ~DBIter() override {
+    // Release pinned data if any
+    if (pinned_iters_mgr_.PinningEnabled()) {
+      pinned_iters_mgr_.ReleasePinnedData();
+    }
+    RecordTick(statistics_, NO_ITERATOR_DELETED);
+    ResetInternalKeysSkippedCounter();
+    local_stats_.BumpGlobalStatistics(statistics_);
+    iter_.DeleteIter(arena_mode_);
+  }
+  virtual void SetIter(InternalIterator* iter) {
+    assert(iter_.iter() == nullptr);
+    iter_.Set(iter);
    iter_.iter()->SetPinnedItersMgr(&pinned_iters_mgr_);
  }
-}
-
-Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
-  if (prop == nullptr) {
-    return Status::InvalidArgument("prop is nullptr");
+  virtual ReadRangeDelAggregator* GetRangeDelAggregator() {
+    return &range_del_agg_;
  }
-  if (prop_name == "rocksdb.iterator.super-version-number") {
-    // First try to pass the value returned from inner iterator.
-    return iter_.iter()->GetProperty(prop_name, prop);
-  } else if (prop_name == "rocksdb.iterator.is-key-pinned") {
-    if (valid_) {
-      *prop = (pin_thru_lifetime_ && saved_key_.IsKeyPinned()) ? "1" : "0";
+
+  bool Valid() const override { return valid_; }
+  Slice key() const override {
+    assert(valid_);
+    if(start_seqnum_ > 0) {
+      return saved_key_.GetInternalKey();
    } else {
-      *prop = "Iterator is not valid.";
+      return saved_key_.GetUserKey();
    }
-    return Status::OK();
-  } else if (prop_name == "rocksdb.iterator.internal-key") {
-    *prop = saved_key_.GetUserKey().ToString();
-    return Status::OK();
  }
-  return Status::InvalidArgument("Unidentified property.");
-}
+  Slice value() const override {
+    assert(valid_);
+    if (current_entry_is_merged_) {
+      // If pinned_value_ is set then the result of merge operator is one of
+      // the merge operands and we should return it.
+      return pinned_value_.data() ? pinned_value_ : saved_value_;
+    } else if (direction_ == kReverse) {
+      return pinned_value_;
+    } else {
+      return iter_.value();
+    }
+  }
+  Status status() const override {
+    if (status_.ok()) {
+      return iter_.status();
+    } else {
+      assert(!valid_);
+      return status_;
+    }
+  }
+  bool IsBlob() const {
+    assert(valid_ && (allow_blob_ || !is_blob_));
+    return is_blob_;
+  }

-bool DBIter::ParseKey(ParsedInternalKey* ikey) {
+  Status GetProperty(std::string prop_name, std::string* prop) override {
+    if (prop == nullptr) {
+      return Status::InvalidArgument("prop is nullptr");
+    }
+    if (prop_name == "rocksdb.iterator.super-version-number") {
+      // First try to pass the value returned from inner iterator.
+      return iter_.iter()->GetProperty(prop_name, prop);
+    } else if (prop_name == "rocksdb.iterator.is-key-pinned") {
+      if (valid_) {
+        *prop = (pin_thru_lifetime_ && saved_key_.IsKeyPinned()) ? "1" : "0";
+      } else {
+        *prop = "Iterator is not valid.";
+      }
+      return Status::OK();
+    } else if (prop_name == "rocksdb.iterator.internal-key") {
+      *prop = saved_key_.GetUserKey().ToString();
+      return Status::OK();
+    }
+    return Status::InvalidArgument("Unidentified property.");
+  }
+
+  inline void Next() final override;
+  inline void Prev() final override;
+  inline void Seek(const Slice& target) final override;
+  inline void SeekForPrev(const Slice& target) final override;
+  inline void SeekToFirst() final override;
+  inline void SeekToLast() final override;
+  Env* env() { return env_; }
+  void set_sequence(uint64_t s) {
+    sequence_ = s;
+    if (read_callback_) {
+      read_callback_->Refresh(s);
+    }
+  }
+  void set_valid(bool v) { valid_ = v; }
+
+ private:
+  // For all methods in this block:
+  // PRE: iter_->Valid() && status_.ok()
+  // Return false if there was an error, and status() is non-ok, valid_ = false;
+  // in this case callers would usually stop what they were doing and return.
+  bool ReverseToForward();
+  bool ReverseToBackward();
+  bool FindValueForCurrentKey();
+  bool FindValueForCurrentKeyUsingSeek();
+  bool FindUserKeyBeforeSavedKey();
+  inline bool FindNextUserEntry(bool skipping, bool prefix_check);
+  inline bool FindNextUserEntryInternal(bool skipping, bool prefix_check);
+  bool ParseKey(ParsedInternalKey* key);
+  bool MergeValuesNewToOld();
+
+  void PrevInternal();
+  bool TooManyInternalKeysSkipped(bool increment = true);
+  inline bool IsVisible(SequenceNumber sequence);
+
+  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
+  // is called
+  void TempPinData() {
+    if (!pin_thru_lifetime_) {
+      pinned_iters_mgr_.StartPinning();
+    }
+  }
+
+  // Release blocks pinned by TempPinData()
+  void ReleaseTempPinnedData() {
+    if (!pin_thru_lifetime_ && pinned_iters_mgr_.PinningEnabled()) {
+      pinned_iters_mgr_.ReleasePinnedData();
+    }
+  }
+
+  inline void ClearSavedValue() {
+    if (saved_value_.capacity() > 1048576) {
+      std::string empty;
+      swap(empty, saved_value_);
+    } else {
+      saved_value_.clear();
+    }
+  }
+
+  inline void ResetInternalKeysSkippedCounter() {
+    local_stats_.skip_count_ += num_internal_keys_skipped_;
+    if (valid_) {
+      local_stats_.skip_count_--;
+    }
+    num_internal_keys_skipped_ = 0;
+  }
+
+  const SliceTransform* prefix_extractor_;
+  Env* const env_;
+  Logger* logger_;
+  UserComparatorWrapper user_comparator_;
+  const MergeOperator* const merge_operator_;
+  IteratorWrapper iter_;
+  ReadCallback* read_callback_;
+  // Max visible sequence number. It is normally the snapshot seq unless we have
+  // uncommitted data in db as in WriteUnCommitted.
+  SequenceNumber sequence_;
+
+  IterKey saved_key_;
+  // Reusable internal key data structure. This is only used inside one function
+  // and should not be used across functions. Reusing this object can reduce
+  // overhead of calling construction of the function if creating it each time.
+  ParsedInternalKey ikey_;
+  std::string saved_value_;
+  Slice pinned_value_;
+  // for prefix seek mode to support prev()
+  Statistics* statistics_;
+  uint64_t max_skip_;
+  uint64_t max_skippable_internal_keys_;
+  uint64_t num_internal_keys_skipped_;
+  const Slice* iterate_lower_bound_;
+  const Slice* iterate_upper_bound_;
+
+  IterKey prefix_start_buf_;
+
+  Status status_;
+  Slice prefix_start_key_;
+  Direction direction_;
+  bool valid_;
+  bool current_entry_is_merged_;
+  // True if we know that the current entry's seqnum is 0.
+  // This information is used as that the next entry will be for another
+  // user key.
+  bool is_key_seqnum_zero_;
+  const bool prefix_same_as_start_;
+  // Means that we will pin all data blocks we read as long the Iterator
+  // is not deleted, will be true if ReadOptions::pin_data is true
+  const bool pin_thru_lifetime_;
+  const bool total_order_seek_;
+  bool allow_blob_;
+  bool is_blob_;
+  bool arena_mode_;
+  // List of operands for merge operator.
+  MergeContext merge_context_;
+  ReadRangeDelAggregator range_del_agg_;
+  LocalStatistics local_stats_;
+  PinnedIteratorsManager pinned_iters_mgr_;
+#ifdef ROCKSDB_LITE
+  ROCKSDB_FIELD_UNUSED
+#endif
+  DBImpl* db_impl_;
+#ifdef ROCKSDB_LITE
+  ROCKSDB_FIELD_UNUSED
+#endif
+  ColumnFamilyData* cfd_;
+  // for diff snapshots we want the lower bound on the seqnum;
+  // if this value > 0 iterator will return internal keys
+  SequenceNumber start_seqnum_;
+};
+
+inline bool DBIter::ParseKey(ParsedInternalKey* ikey) {
  if (!ParseInternalKey(iter_.key(), ikey)) {
    status_ = Status::Corruption("corrupted internal key in DBIter");
    valid_ = false;
@@ -154,13 +403,8 @@ void DBIter::Next() {

  local_stats_.next_count_++;
  if (ok && iter_.Valid()) {
-    Slice prefix;
-    if (prefix_same_as_start_) {
-      assert(prefix_extractor_ != nullptr);
-      prefix = prefix_.GetUserKey();
-    }
    FindNextUserEntry(true /* skipping the current user key */,
-                      prefix_same_as_start_ ? &prefix : nullptr);
+                      prefix_same_as_start_);
  } else {
    is_key_seqnum_zero_ = false;
    valid_ = false;
@@ -171,7 +415,7 @@ void DBIter::Next() {
  }
 }

-// PRE: saved_key_ has the current user key if skipping_saved_key
+// PRE: saved_key_ has the current user key if skipping
 // POST: saved_key_ should have the next user key if valid_,
 //       if the current entry is a result of merge
 //           current_entry_is_merged_ => true
@@ -181,17 +425,17 @@ void DBIter::Next() {
 //       a delete marker or a sequence number higher than sequence_
 //       saved_key_ MUST have a proper user_key before calling this function
 //
-// The prefix parameter, if not null, indicates that we need to iterator
-// within the prefix, and the iterator needs to be made invalid, if no
-// more entry for the prefix can be found.
-bool DBIter::FindNextUserEntry(bool skipping_saved_key, const Slice* prefix) {
+// The prefix_check parameter controls whether we check the iterated
+// keys against the prefix of the seeked key. Set to false when
+// performing a seek without a key (e.g. SeekToFirst). Set to
+// prefix_same_as_start_ for other iterations.
+inline bool DBIter::FindNextUserEntry(bool skipping, bool prefix_check) {
  PERF_TIMER_GUARD(find_next_user_entry_time);
-  return FindNextUserEntryInternal(skipping_saved_key, prefix);
+  return FindNextUserEntryInternal(skipping, prefix_check);
 }

 // Actual implementation of DBIter::FindNextUserEntry()
-bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
-                                       const Slice* prefix) {
+inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
  // Loop until we hit an acceptable entry to yield
  assert(iter_.Valid());
  assert(status_.ok());
@@ -200,10 +444,9 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,

  // How many times in a row we have skipped an entry with user key less than
  // or equal to saved_key_. We could skip these entries either because
-  // sequence numbers were too high or because skipping_saved_key = true.
+  // sequence numbers were too high or because skipping = true.
  // What saved_key_ contains throughout this method:
-  //  - if skipping_saved_key        : saved_key_ contains the key that we need
-  //  to skip,
+  //  - if skipping        : saved_key_ contains the key that we need to skip,
  //                         and we haven't seen any keys greater than that,
  //  - if num_skipped > 0 : saved_key_ contains the key that we have skipped
  //                         num_skipped times, and we haven't seen any keys
@@ -236,10 +479,9 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
      break;
    }

-    assert(prefix == nullptr || prefix_extractor_ != nullptr);
-    if (prefix != nullptr &&
-        prefix_extractor_->Transform(ikey_.user_key).compare(*prefix) != 0) {
-      assert(prefix_same_as_start_);
+    if (prefix_extractor_ && prefix_check &&
+        prefix_extractor_->Transform(ikey_.user_key)
+                .compare(prefix_start_key_) != 0) {
      break;
    }

@@ -252,15 +494,14 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
      // possibly be skipped. This condition can potentially be relaxed to
      // prev_key.seq <= ikey_.sequence. We are cautious because it will be more
      // prone to bugs causing the same user key with the same sequence number.
-      if (!is_prev_key_seqnum_zero && skipping_saved_key &&
+      if (!is_prev_key_seqnum_zero && skipping &&
          user_comparator_.Compare(ikey_.user_key, saved_key_.GetUserKey()) <=
              0) {
        num_skipped++;  // skip this entry
        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
      } else {
-        assert(!skipping_saved_key ||
-               user_comparator_.Compare(ikey_.user_key,
-                                        saved_key_.GetUserKey()) > 0);
+        assert(!skipping || user_comparator_.Compare(
+                                ikey_.user_key, saved_key_.GetUserKey()) > 0);
        num_skipped = 0;
        reseek_done = false;
        switch (ikey_.type) {
@@ -281,7 +522,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
              saved_key_.SetUserKey(
                  ikey_.user_key, !pin_thru_lifetime_ ||
                                      !iter_.iter()->IsKeyPinned() /* copy */);
-              skipping_saved_key = true;
+              skipping = true;
              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
            }
            break;
@@ -299,12 +540,12 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
                return true;
              } else {
                // this key and all previous versions shouldn't be included,
-                // skipping_saved_key
+                // skipping
                saved_key_.SetUserKey(
                    ikey_.user_key,
                    !pin_thru_lifetime_ ||
                        !iter_.iter()->IsKeyPinned() /* copy */);
-                skipping_saved_key = true;
+                skipping = true;
              }
            } else {
              saved_key_.SetUserKey(
@@ -314,7 +555,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
                      ikey_, RangeDelPositioningMode::kForwardTraversal)) {
                // Arrange to skip all upcoming entries for this key since
                // they are hidden by this deletion.
-                skipping_saved_key = true;
+                skipping = true;
                num_skipped = 0;
                reseek_done = false;
                PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
@@ -345,7 +586,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
                    ikey_, RangeDelPositioningMode::kForwardTraversal)) {
              // Arrange to skip all upcoming entries for this key since
              // they are hidden by this deletion.
-              skipping_saved_key = true;
+              skipping = true;
              num_skipped = 0;
              reseek_done = false;
              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
@@ -370,13 +611,13 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
      // to seek to the target sequence number.
      int cmp =
          user_comparator_.Compare(ikey_.user_key, saved_key_.GetUserKey());
-      if (cmp == 0 || (skipping_saved_key && cmp <= 0)) {
+      if (cmp == 0 || (skipping && cmp <= 0)) {
        num_skipped++;
      } else {
        saved_key_.SetUserKey(
            ikey_.user_key,
            !iter_.iter()->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-        skipping_saved_key = false;
+        skipping = false;
        num_skipped = 0;
        reseek_done = false;
      }
@@ -396,14 +637,14 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
      num_skipped = 0;
      reseek_done = true;
      std::string last_key;
-      if (skipping_saved_key) {
+      if (skipping) {
        // We're looking for the next user-key but all we see are the same
        // user-key with decreasing sequence numbers. Fast forward to
        // sequence number 0 and type deletion (the smallest type).
        AppendInternalKey(&last_key, ParsedInternalKey(saved_key_.GetUserKey(),
                                                       0, kTypeDeletion));
-        // Don't set skipping_saved_key = false because we may still see more
-        // user-keys equal to saved_key_.
+        // Don't set skipping = false because we may still see more user-keys
+        // equal to saved_key_.
      } else {
        // We saw multiple entries with this user key and sequence numbers
        // higher than sequence_. Fast forward to sequence_.
@@ -544,14 +785,8 @@ void DBIter::Prev() {
    }
  }
  if (ok) {
-    Slice prefix;
-    if (prefix_same_as_start_) {
-      assert(prefix_extractor_ != nullptr);
-      prefix = prefix_.GetUserKey();
-    }
-    PrevInternal(prefix_same_as_start_ ? &prefix : nullptr);
+    PrevInternal();
  }
-
  if (statistics_ != nullptr) {
    local_stats_.prev_count_++;
    if (valid_) {
@@ -629,17 +864,15 @@ bool DBIter::ReverseToBackward() {
  return FindUserKeyBeforeSavedKey();
 }

-void DBIter::PrevInternal(const Slice* prefix) {
+void DBIter::PrevInternal() {
  while (iter_.Valid()) {
    saved_key_.SetUserKey(
        ExtractUserKey(iter_.key()),
        !iter_.iter()->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);

-    assert(prefix == nullptr || prefix_extractor_ != nullptr);
-    if (prefix != nullptr &&
+    if (prefix_extractor_ && prefix_same_as_start_ &&
        prefix_extractor_->Transform(saved_key_.GetUserKey())
-                .compare(*prefix) != 0) {
-      assert(prefix_same_as_start_);
+                .compare(prefix_start_key_) != 0) {
      // Current key does not have the same prefix as start
      valid_ = false;
      return;
@@ -1065,22 +1298,71 @@ bool DBIter::IsVisible(SequenceNumber sequence) {
  }
 }

-void DBIter::SetSavedKeyToSeekTarget(const Slice& target) {
+void DBIter::Seek(const Slice& target) {
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
+  StopWatch sw(env_, statistics_, DB_SEEK);
+  status_ = Status::OK();
+  ReleaseTempPinnedData();
+  ResetInternalKeysSkippedCounter();
  is_key_seqnum_zero_ = false;
+
  SequenceNumber seq = sequence_;
  saved_key_.Clear();
  saved_key_.SetInternalKey(target, seq);

+#ifndef ROCKSDB_LITE
+  if (db_impl_ != nullptr && cfd_ != nullptr) {
+    db_impl_->TraceIteratorSeek(cfd_->GetID(), target);
+  }
+#endif  // ROCKSDB_LITE
+
  if (iterate_lower_bound_ != nullptr &&
      user_comparator_.Compare(saved_key_.GetUserKey(), *iterate_lower_bound_) <
          0) {
-    // Seek key is smaller than the lower bound.
    saved_key_.Clear();
    saved_key_.SetInternalKey(*iterate_lower_bound_, seq);
  }
+
+  {
+    PERF_TIMER_GUARD(seek_internal_seek_time);
+    iter_.Seek(saved_key_.GetInternalKey());
+    range_del_agg_.InvalidateRangeDelMapPositions();
+  }
+  RecordTick(statistics_, NUMBER_DB_SEEK);
+  if (iter_.Valid()) {
+    if (prefix_extractor_ && prefix_same_as_start_) {
+      prefix_start_key_ = prefix_extractor_->Transform(target);
+    }
+    direction_ = kForward;
+    ClearSavedValue();
+    FindNextUserEntry(false /* not skipping */, prefix_same_as_start_);
+    if (!valid_) {
+      prefix_start_key_.clear();
+    }
+    if (statistics_ != nullptr) {
+      if (valid_) {
+        // Decrement since we don't want to count this key as skipped
+        RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
+        RecordTick(statistics_, ITER_BYTES_READ, key().size() + value().size());
+        PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
+      }
+    }
+  } else {
+    valid_ = false;
+  }
+
+  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
+    prefix_start_buf_.SetUserKey(prefix_start_key_);
+    prefix_start_key_ = prefix_start_buf_.GetUserKey();
+  }
 }

-void DBIter::SetSavedKeyToSeekForPrevTarget(const Slice& target) {
+void DBIter::SeekForPrev(const Slice& target) {
+  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
+  StopWatch sw(env_, statistics_, DB_SEEK);
+  status_ = Status::OK();
+  ReleaseTempPinnedData();
+  ResetInternalKeysSkippedCounter();
  is_key_seqnum_zero_ = false;
  saved_key_.Clear();
  // now saved_key is used to store internal key.
@@ -1093,74 +1375,12 @@ void DBIter::SetSavedKeyToSeekForPrevTarget(const Slice& target) {
    saved_key_.Clear();
    saved_key_.SetInternalKey(*iterate_upper_bound_, kMaxSequenceNumber);
  }
-}

-void DBIter::Seek(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
-  StopWatch sw(env_, statistics_, DB_SEEK);
-
-#ifndef ROCKSDB_LITE
-  if (db_impl_ != nullptr && cfd_ != nullptr) {
-    db_impl_->TraceIteratorSeek(cfd_->GetID(), target);
-  }
-#endif  // ROCKSDB_LITE
-
-  status_ = Status::OK();
-  ReleaseTempPinnedData();
-  ResetInternalKeysSkippedCounter();
-
-  // Seek the inner iterator based on the target key.
  {
    PERF_TIMER_GUARD(seek_internal_seek_time);
-
-    SetSavedKeyToSeekTarget(target);
-    iter_.Seek(saved_key_.GetInternalKey());
-
+    iter_.SeekForPrev(saved_key_.GetInternalKey());
    range_del_agg_.InvalidateRangeDelMapPositions();
-    RecordTick(statistics_, NUMBER_DB_SEEK);
  }
-  if (!iter_.Valid()) {
-    valid_ = false;
-    return;
-  }
-  direction_ = kForward;
-
-  // Now the inner iterator is placed to the target position. From there,
-  // we need to find out the next key that is visible to the user.
-  //
-  ClearSavedValue();
-  if (prefix_same_as_start_) {
-    // The case where the iterator needs to be invalidated if it has exausted
-    // keys within the same prefix of the seek key.
-    assert(prefix_extractor_ != nullptr);
-    Slice target_prefix;
-    target_prefix = prefix_extractor_->Transform(target);
-    FindNextUserEntry(false /* not skipping saved_key */,
-                      &target_prefix /* prefix */);
-    if (valid_) {
-      // Remember the prefix of the seek key for the future Prev() call to
-      // check.
-      prefix_.SetUserKey(target_prefix);
-    }
-  } else {
-    FindNextUserEntry(false /* not skipping saved_key */, nullptr);
-  }
-  if (!valid_) {
-    return;
-  }
-
-  // Updating stats and perf context counters.
-  if (statistics_ != nullptr) {
-    // Decrement since we don't want to count this key as skipped
-    RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
-    RecordTick(statistics_, ITER_BYTES_READ, key().size() + value().size());
-  }
-  PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
-}
-
-void DBIter::SeekForPrev(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
-  StopWatch sw(env_, statistics_, DB_SEEK);

 #ifndef ROCKSDB_LITE
  if (db_impl_ != nullptr && cfd_ != nullptr) {
@@ -1168,49 +1388,30 @@ void DBIter::SeekForPrev(const Slice& target) {
  }
 #endif  // ROCKSDB_LITE

-  status_ = Status::OK();
-  ReleaseTempPinnedData();
-  ResetInternalKeysSkippedCounter();
-
-  // Seek the inner iterator based on the target key.
-  {
-    PERF_TIMER_GUARD(seek_internal_seek_time);
-    SetSavedKeyToSeekForPrevTarget(target);
-    iter_.SeekForPrev(saved_key_.GetInternalKey());
-    range_del_agg_.InvalidateRangeDelMapPositions();
-    RecordTick(statistics_, NUMBER_DB_SEEK);
-  }
-  if (!iter_.Valid()) {
-    valid_ = false;
-    return;
-  }
-  direction_ = kReverse;
-
-  // Now the inner iterator is placed to the target position. From there,
-  // we need to find out the first key that is visible to the user in the
-  // backward direction.
-  ClearSavedValue();
-  if (prefix_same_as_start_) {
-    // The case where the iterator needs to be invalidated if it has exausted
-    // keys within the same prefix of the seek key.
-    assert(prefix_extractor_ != nullptr);
-    Slice target_prefix;
-    target_prefix = prefix_extractor_->Transform(target);
-    PrevInternal(&target_prefix);
-    if (valid_) {
-      // Remember the prefix of the seek key for the future Prev() call to
-      // check.
-      prefix_.SetUserKey(target_prefix);
+  RecordTick(statistics_, NUMBER_DB_SEEK);
+  if (iter_.Valid()) {
+    if (prefix_extractor_ && prefix_same_as_start_) {
+      prefix_start_key_ = prefix_extractor_->Transform(target);
+    }
+    direction_ = kReverse;
+    ClearSavedValue();
+    PrevInternal();
+    if (!valid_) {
+      prefix_start_key_.clear();
+    }
+    if (statistics_ != nullptr) {
+      if (valid_) {
+        RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
+        RecordTick(statistics_, ITER_BYTES_READ, key().size() + value().size());
+        PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
+      }
    }
  } else {
-    PrevInternal(nullptr);
+    valid_ = false;
  }
-
-  // Report stats and perf context.
-  if (statistics_ != nullptr && valid_) {
-    RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
-    RecordTick(statistics_, ITER_BYTES_READ, key().size() + value().size());
-    PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
+  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
+    prefix_start_buf_.SetUserKey(prefix_start_key_);
+    prefix_start_key_ = prefix_start_buf_.GetUserKey();
  }
 }

@@ -1243,8 +1444,7 @@ void DBIter::SeekToFirst() {
    saved_key_.SetUserKey(
        ExtractUserKey(iter_.key()),
        !iter_.iter()->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-    FindNextUserEntry(false /* not skipping saved_key */,
-                      nullptr /* no prefix check */);
+    FindNextUserEntry(false /* not skipping */, false /* no prefix check */);
    if (statistics_ != nullptr) {
      if (valid_) {
        RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
@@ -1255,9 +1455,10 @@ void DBIter::SeekToFirst() {
  } else {
    valid_ = false;
  }
-  if (valid_ && prefix_same_as_start_) {
-    assert(prefix_extractor_ != nullptr);
-    prefix_.SetUserKey(prefix_extractor_->Transform(saved_key_.GetUserKey()));
+  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
+    prefix_start_buf_.SetUserKey(
+        prefix_extractor_->Transform(saved_key_.GetUserKey()));
+    prefix_start_key_ = prefix_start_buf_.GetUserKey();
  }
 }

@@ -1267,7 +1468,7 @@ void DBIter::SeekToLast() {
    SeekForPrev(*iterate_upper_bound_);
    if (Valid() && user_comparator_.Equal(*iterate_upper_bound_, key())) {
      ReleaseTempPinnedData();
-      PrevInternal(nullptr);
+      PrevInternal();
    }
    return;
  }
@@ -1290,7 +1491,7 @@ void DBIter::SeekToLast() {
    iter_.SeekToLast();
    range_del_agg_.InvalidateRangeDelMapPositions();
  }
-  PrevInternal(nullptr);
+  PrevInternal();
  if (statistics_ != nullptr) {
    RecordTick(statistics_, NUMBER_DB_SEEK);
    if (valid_) {
@@ -1299,9 +1500,10 @@ void DBIter::SeekToLast() {
      PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
    }
  }
-  if (valid_ && prefix_same_as_start_) {
-    assert(prefix_extractor_ != nullptr);
-    prefix_.SetUserKey(prefix_extractor_->Transform(saved_key_.GetUserKey()));
+  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
+    prefix_start_buf_.SetUserKey(
+        prefix_extractor_->Transform(saved_key_.GetUserKey()));
+    prefix_start_key_ = prefix_start_buf_.GetUserKey();
  }
 }

@@ -1321,4 +1523,114 @@ Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
  return db_iter;
 }

+ArenaWrappedDBIter::~ArenaWrappedDBIter() { db_iter_->~DBIter(); }
+
+ReadRangeDelAggregator* ArenaWrappedDBIter::GetRangeDelAggregator() {
+  return db_iter_->GetRangeDelAggregator();
+}
+
+void ArenaWrappedDBIter::SetIterUnderDBIter(InternalIterator* iter) {
+  static_cast<DBIter*>(db_iter_)->SetIter(iter);
+}
+
+inline bool ArenaWrappedDBIter::Valid() const { return db_iter_->Valid(); }
+inline void ArenaWrappedDBIter::SeekToFirst() { db_iter_->SeekToFirst(); }
+inline void ArenaWrappedDBIter::SeekToLast() { db_iter_->SeekToLast(); }
+inline void ArenaWrappedDBIter::Seek(const Slice& target) {
+  db_iter_->Seek(target);
+}
+inline void ArenaWrappedDBIter::SeekForPrev(const Slice& target) {
+  db_iter_->SeekForPrev(target);
+}
+inline void ArenaWrappedDBIter::Next() { db_iter_->Next(); }
+inline void ArenaWrappedDBIter::Prev() { db_iter_->Prev(); }
+inline Slice ArenaWrappedDBIter::key() const { return db_iter_->key(); }
+inline Slice ArenaWrappedDBIter::value() const { return db_iter_->value(); }
+inline Status ArenaWrappedDBIter::status() const { return db_iter_->status(); }
+bool ArenaWrappedDBIter::IsBlob() const { return db_iter_->IsBlob(); }
+inline Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
+                                              std::string* prop) {
+  if (prop_name == "rocksdb.iterator.super-version-number") {
+    // First try to pass the value returned from inner iterator.
+    if (!db_iter_->GetProperty(prop_name, prop).ok()) {
+      *prop = ToString(sv_number_);
+    }
+    return Status::OK();
+  }
+  return db_iter_->GetProperty(prop_name, prop);
+}
+
+void ArenaWrappedDBIter::Init(Env* env, const ReadOptions& read_options,
+                              const ImmutableCFOptions& cf_options,
+                              const MutableCFOptions& mutable_cf_options,
+                              const SequenceNumber& sequence,
+                              uint64_t max_sequential_skip_in_iteration,
+                              uint64_t version_number,
+                              ReadCallback* read_callback, DBImpl* db_impl,
+                              ColumnFamilyData* cfd, bool allow_blob,
+                              bool allow_refresh) {
+  auto mem = arena_.AllocateAligned(sizeof(DBIter));
+  db_iter_ = new (mem) DBIter(env, read_options, cf_options, mutable_cf_options,
+                              cf_options.user_comparator, nullptr, sequence,
+                              true, max_sequential_skip_in_iteration,
+                              read_callback, db_impl, cfd, allow_blob);
+  sv_number_ = version_number;
+  allow_refresh_ = allow_refresh;
+}
+
+Status ArenaWrappedDBIter::Refresh() {
+  if (cfd_ == nullptr || db_impl_ == nullptr || !allow_refresh_) {
+    return Status::NotSupported("Creating renew iterator is not allowed.");
+  }
+  assert(db_iter_ != nullptr);
+  // TODO(yiwu): For last_seq_same_as_publish_seq_==false, this is not the
+  // correct behavior. Will be corrected automatically when we take a snapshot
+  // here for the case of WritePreparedTxnDB.
+  SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
+  uint64_t cur_sv_number = cfd_->GetSuperVersionNumber();
+  if (sv_number_ != cur_sv_number) {
+    Env* env = db_iter_->env();
+    db_iter_->~DBIter();
+    arena_.~Arena();
+    new (&arena_) Arena();
+
+    SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex());
+    if (read_callback_) {
+      read_callback_->Refresh(latest_seq);
+    }
+    Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
+         latest_seq, sv->mutable_cf_options.max_sequential_skip_in_iterations,
+         cur_sv_number, read_callback_, db_impl_, cfd_, allow_blob_,
+         allow_refresh_);
+
+    InternalIterator* internal_iter = db_impl_->NewInternalIterator(
+        read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator(),
+        latest_seq);
+    SetIterUnderDBIter(internal_iter);
+  } else {
+    db_iter_->set_sequence(latest_seq);
+    db_iter_->set_valid(false);
+  }
+  return Status::OK();
+}
+
+ArenaWrappedDBIter* NewArenaWrappedDbIterator(
+    Env* env, const ReadOptions& read_options,
+    const ImmutableCFOptions& cf_options,
+    const MutableCFOptions& mutable_cf_options, const SequenceNumber& sequence,
+    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
+    ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
+    bool allow_blob, bool allow_refresh) {
+  ArenaWrappedDBIter* iter = new ArenaWrappedDBIter();
+  iter->Init(env, read_options, cf_options, mutable_cf_options, sequence,
+             max_sequential_skip_in_iterations, version_number, read_callback,
+             db_impl, cfd, allow_blob, allow_refresh);
+  if (db_impl != nullptr && cfd != nullptr && allow_refresh) {
+    iter->StoreRefreshInfo(read_options, db_impl, cfd, read_callback,
+                           allow_blob);
+  }
+
+  return iter;
+}
+
 }  // namespace rocksdb
@@ -17,7 +17,6 @@
 #include "options/cf_options.h"
 #include "rocksdb/db.h"
 #include "rocksdb/iterator.h"
-#include "table/iterator_wrapper.h"
 #include "util/autovector.h"

 namespace rocksdb {
@@ -47,282 +46,9 @@ namespace rocksdb {
 //    key: BBB  value: v1
 //    key: BBC  value: v1
 //
+class Arena;
+class DBIter;

-// Memtables and sstables that make the DB representation contain
-// (userkey,seq,type) => uservalue entries.  DBIter
-// combines multiple entries for the same userkey found in the DB
-// representation into a single entry while accounting for sequence
-// numbers, deletion markers, overwrites, etc.
-class DBIter final : public Iterator {
- public:
-  // The following is grossly complicated. TODO: clean it up
-  // Which direction is the iterator currently moving?
-  // (1) When moving forward:
-  //   (1a) if current_entry_is_merged_ = false, the internal iterator is
-  //        positioned at the exact entry that yields this->key(), this->value()
-  //   (1b) if current_entry_is_merged_ = true, the internal iterator is
-  //        positioned immediately after the last entry that contributed to the
-  //        current this->value(). That entry may or may not have key equal to
-  //        this->key().
-  // (2) When moving backwards, the internal iterator is positioned
-  //     just before all entries whose user key == this->key().
-  enum Direction { kForward, kReverse };
-
-  // LocalStatistics contain Statistics counters that will be aggregated per
-  // each iterator instance and then will be sent to the global statistics when
-  // the iterator is destroyed.
-  //
-  // The purpose of this approach is to avoid perf regression happening
-  // when multiple threads bump the atomic counters from a DBIter::Next().
-  struct LocalStatistics {
-    explicit LocalStatistics() { ResetCounters(); }
-
-    void ResetCounters() {
-      next_count_ = 0;
-      next_found_count_ = 0;
-      prev_count_ = 0;
-      prev_found_count_ = 0;
-      bytes_read_ = 0;
-      skip_count_ = 0;
-    }
-
-    void BumpGlobalStatistics(Statistics* global_statistics) {
-      RecordTick(global_statistics, NUMBER_DB_NEXT, next_count_);
-      RecordTick(global_statistics, NUMBER_DB_NEXT_FOUND, next_found_count_);
-      RecordTick(global_statistics, NUMBER_DB_PREV, prev_count_);
-      RecordTick(global_statistics, NUMBER_DB_PREV_FOUND, prev_found_count_);
-      RecordTick(global_statistics, ITER_BYTES_READ, bytes_read_);
-      RecordTick(global_statistics, NUMBER_ITER_SKIP, skip_count_);
-      PERF_COUNTER_ADD(iter_read_bytes, bytes_read_);
-      ResetCounters();
-    }
-
-    // Map to Tickers::NUMBER_DB_NEXT
-    uint64_t next_count_;
-    // Map to Tickers::NUMBER_DB_NEXT_FOUND
-    uint64_t next_found_count_;
-    // Map to Tickers::NUMBER_DB_PREV
-    uint64_t prev_count_;
-    // Map to Tickers::NUMBER_DB_PREV_FOUND
-    uint64_t prev_found_count_;
-    // Map to Tickers::ITER_BYTES_READ
-    uint64_t bytes_read_;
-    // Map to Tickers::NUMBER_ITER_SKIP
-    uint64_t skip_count_;
-  };
-
-  DBIter(Env* _env, const ReadOptions& read_options,
-         const ImmutableCFOptions& cf_options,
-         const MutableCFOptions& mutable_cf_options, const Comparator* cmp,
-         InternalIterator* iter, SequenceNumber s, bool arena_mode,
-         uint64_t max_sequential_skip_in_iterations,
-         ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
-         bool allow_blob);
-
-  // No copying allowed
-  DBIter(const DBIter&) = delete;
-  void operator=(const DBIter&) = delete;
-
-  ~DBIter() override {
-    // Release pinned data if any
-    if (pinned_iters_mgr_.PinningEnabled()) {
-      pinned_iters_mgr_.ReleasePinnedData();
-    }
-    RecordTick(statistics_, NO_ITERATOR_DELETED);
-    ResetInternalKeysSkippedCounter();
-    local_stats_.BumpGlobalStatistics(statistics_);
-    iter_.DeleteIter(arena_mode_);
-  }
-  virtual void SetIter(InternalIterator* iter) {
-    assert(iter_.iter() == nullptr);
-    iter_.Set(iter);
-    iter_.iter()->SetPinnedItersMgr(&pinned_iters_mgr_);
-  }
-  virtual ReadRangeDelAggregator* GetRangeDelAggregator() {
-    return &range_del_agg_;
-  }
-
-  bool Valid() const override { return valid_; }
-  Slice key() const override {
-    assert(valid_);
-    if (start_seqnum_ > 0) {
-      return saved_key_.GetInternalKey();
-    } else {
-      return saved_key_.GetUserKey();
-    }
-  }
-  Slice value() const override {
-    assert(valid_);
-    if (current_entry_is_merged_) {
-      // If pinned_value_ is set then the result of merge operator is one of
-      // the merge operands and we should return it.
-      return pinned_value_.data() ? pinned_value_ : saved_value_;
-    } else if (direction_ == kReverse) {
-      return pinned_value_;
-    } else {
-      return iter_.value();
-    }
-  }
-  Status status() const override {
-    if (status_.ok()) {
-      return iter_.status();
-    } else {
-      assert(!valid_);
-      return status_;
-    }
-  }
-  bool IsBlob() const {
-    assert(valid_ && (allow_blob_ || !is_blob_));
-    return is_blob_;
-  }
-
-  Status GetProperty(std::string prop_name, std::string* prop) override;
-
-  void Next() final override;
-  void Prev() final override;
-  void Seek(const Slice& target) final override;
-  void SeekForPrev(const Slice& target) final override;
-  void SeekToFirst() final override;
-  void SeekToLast() final override;
-  Env* env() { return env_; }
-  void set_sequence(uint64_t s) {
-    sequence_ = s;
-    if (read_callback_) {
-      read_callback_->Refresh(s);
-    }
-  }
-  void set_valid(bool v) { valid_ = v; }
-
- private:
-  // For all methods in this block:
-  // PRE: iter_->Valid() && status_.ok()
-  // Return false if there was an error, and status() is non-ok, valid_ = false;
-  // in this case callers would usually stop what they were doing and return.
-  bool ReverseToForward();
-  bool ReverseToBackward();
-  // Set saved_key_ to the seek key to target, with proper sequence number set.
-  // It might get adjusted if the seek key is smaller than iterator lower bound.
-  void SetSavedKeyToSeekTarget(const Slice& /*target*/);
-  // Set saved_key_ to the seek key to target, with proper sequence number set.
-  // It might get adjusted if the seek key is larger than iterator upper bound.
-  void SetSavedKeyToSeekForPrevTarget(const Slice& /*target*/);
-  bool FindValueForCurrentKey();
-  bool FindValueForCurrentKeyUsingSeek();
-  bool FindUserKeyBeforeSavedKey();
-  // If `skipping_saved_key` is true, the function will keep iterating until it
-  // finds a user key that is larger than `saved_key_`.
-  // If `prefix` is not null, the iterator needs to stop when all keys for the
-  // prefix are exhausted and the interator is set to invalid.
-  bool FindNextUserEntry(bool skipping_saved_key, const Slice* prefix);
-  // Internal implementation of FindNextUserEntry().
-  bool FindNextUserEntryInternal(bool skipping_saved_key, const Slice* prefix);
-  bool ParseKey(ParsedInternalKey* key);
-  bool MergeValuesNewToOld();
-
-  // If prefix is not null, we need to set the iterator to invalid if no more
-  // entry can be found within the prefix.
-  void PrevInternal(const Slice* /*prefix*/);
-  bool TooManyInternalKeysSkipped(bool increment = true);
-  bool IsVisible(SequenceNumber sequence);
-
-  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
-  // is called
-  void TempPinData() {
-    if (!pin_thru_lifetime_) {
-      pinned_iters_mgr_.StartPinning();
-    }
-  }
-
-  // Release blocks pinned by TempPinData()
-  void ReleaseTempPinnedData() {
-    if (!pin_thru_lifetime_ && pinned_iters_mgr_.PinningEnabled()) {
-      pinned_iters_mgr_.ReleasePinnedData();
-    }
-  }
-
-  inline void ClearSavedValue() {
-    if (saved_value_.capacity() > 1048576) {
-      std::string empty;
-      swap(empty, saved_value_);
-    } else {
-      saved_value_.clear();
-    }
-  }
-
-  inline void ResetInternalKeysSkippedCounter() {
-    local_stats_.skip_count_ += num_internal_keys_skipped_;
-    if (valid_) {
-      local_stats_.skip_count_--;
-    }
-    num_internal_keys_skipped_ = 0;
-  }
-
-  const SliceTransform* prefix_extractor_;
-  Env* const env_;
-  Logger* logger_;
-  UserComparatorWrapper user_comparator_;
-  const MergeOperator* const merge_operator_;
-  IteratorWrapper iter_;
-  ReadCallback* read_callback_;
-  // Max visible sequence number. It is normally the snapshot seq unless we have
-  // uncommitted data in db as in WriteUnCommitted.
-  SequenceNumber sequence_;
-
-  IterKey saved_key_;
-  // Reusable internal key data structure. This is only used inside one function
-  // and should not be used across functions. Reusing this object can reduce
-  // overhead of calling construction of the function if creating it each time.
-  ParsedInternalKey ikey_;
-  std::string saved_value_;
-  Slice pinned_value_;
-  // for prefix seek mode to support prev()
-  Statistics* statistics_;
-  uint64_t max_skip_;
-  uint64_t max_skippable_internal_keys_;
-  uint64_t num_internal_keys_skipped_;
-  const Slice* iterate_lower_bound_;
-  const Slice* iterate_upper_bound_;
-
-  // The prefix of the seek key. It is only used when prefix_same_as_start_
-  // is true and prefix extractor is not null. In Next() or Prev(), current keys
-  // will be checked against this prefix, so that the iterator can be
-  // invalidated if the keys in this prefix has been exhausted. Set it using
-  // SetUserKey() and use it using GetUserKey().
-  IterKey prefix_;
-
-  Status status_;
-  Direction direction_;
-  bool valid_;
-  bool current_entry_is_merged_;
-  // True if we know that the current entry's seqnum is 0.
-  // This information is used as that the next entry will be for another
-  // user key.
-  bool is_key_seqnum_zero_;
-  const bool prefix_same_as_start_;
-  // Means that we will pin all data blocks we read as long the Iterator
-  // is not deleted, will be true if ReadOptions::pin_data is true
-  const bool pin_thru_lifetime_;
-  const bool total_order_seek_;
-  bool allow_blob_;
-  bool is_blob_;
-  bool arena_mode_;
-  // List of operands for merge operator.
-  MergeContext merge_context_;
-  ReadRangeDelAggregator range_del_agg_;
-  LocalStatistics local_stats_;
-  PinnedIteratorsManager pinned_iters_mgr_;
-#ifdef ROCKSDB_LITE
-  ROCKSDB_FIELD_UNUSED
-#endif
-  DBImpl* db_impl_;
-#ifdef ROCKSDB_LITE
-  ROCKSDB_FIELD_UNUSED
-#endif
-  ColumnFamilyData* cfd_;
-  // for diff snapshots we want the lower bound on the seqnum;
-  // if this value > 0 iterator will return internal keys
-  SequenceNumber start_seqnum_;
-};
 // Return a new iterator that converts internal keys (yielded by
 // "*internal_iter") that were live at the specified `sequence` number
 // into appropriate user keys.
@@ -335,4 +61,79 @@ extern Iterator* NewDBIterator(
    ReadCallback* read_callback, DBImpl* db_impl = nullptr,
    ColumnFamilyData* cfd = nullptr, bool allow_blob = false);

+// A wrapper iterator which wraps DB Iterator and the arena, with which the DB
+// iterator is supposed be allocated. This class is used as an entry point of
+// a iterator hierarchy whose memory can be allocated inline. In that way,
+// accessing the iterator tree can be more cache friendly. It is also faster
+// to allocate.
+// When using the class's Iterator interface, the behavior is exactly
+// the same as the inner DBIter.
+class ArenaWrappedDBIter : public Iterator {
+ public:
+  virtual ~ArenaWrappedDBIter();
+
+  // Get the arena to be used to allocate memory for DBIter to be wrapped,
+  // as well as child iterators in it.
+  virtual Arena* GetArena() { return &arena_; }
+  virtual ReadRangeDelAggregator* GetRangeDelAggregator();
+
+  // Set the internal iterator wrapped inside the DB Iterator. Usually it is
+  // a merging iterator.
+  virtual void SetIterUnderDBIter(InternalIterator* iter);
+  virtual bool Valid() const override;
+  virtual void SeekToFirst() override;
+  virtual void SeekToLast() override;
+  virtual void Seek(const Slice& target) override;
+  virtual void SeekForPrev(const Slice& target) override;
+  virtual void Next() override;
+  virtual void Prev() override;
+  virtual Slice key() const override;
+  virtual Slice value() const override;
+  virtual Status status() const override;
+  virtual Status Refresh() override;
+  bool IsBlob() const;
+
+  virtual Status GetProperty(std::string prop_name, std::string* prop) override;
+
+  void Init(Env* env, const ReadOptions& read_options,
+            const ImmutableCFOptions& cf_options,
+            const MutableCFOptions& mutable_cf_options,
+            const SequenceNumber& sequence,
+            uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
+            ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
+            bool allow_blob, bool allow_refresh);
+
+  void StoreRefreshInfo(const ReadOptions& read_options, DBImpl* db_impl,
+                        ColumnFamilyData* cfd, ReadCallback* read_callback,
+                        bool allow_blob) {
+    read_options_ = read_options;
+    db_impl_ = db_impl;
+    cfd_ = cfd;
+    read_callback_ = read_callback;
+    allow_blob_ = allow_blob;
+  }
+
+ private:
+  DBIter* db_iter_;
+  Arena arena_;
+  uint64_t sv_number_;
+  ColumnFamilyData* cfd_ = nullptr;
+  DBImpl* db_impl_ = nullptr;
+  ReadOptions read_options_;
+  ReadCallback* read_callback_;
+  bool allow_blob_ = false;
+  bool allow_refresh_ = true;
+};
+
+// Generate the arena wrapped iterator class.
+// `db_impl` and `cfd` are used for reneweal. If left null, renewal will not
+// be supported.
+extern ArenaWrappedDBIter* NewArenaWrappedDbIterator(
+    Env* env, const ReadOptions& read_options,
+    const ImmutableCFOptions& cf_options,
+    const MutableCFOptions& mutable_cf_options, const SequenceNumber& sequence,
+    uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
+    ReadCallback* read_callback, DBImpl* db_impl = nullptr,
+    ColumnFamilyData* cfd = nullptr, bool allow_blob = false,
+    bool allow_refresh = true);
 }  // namespace rocksdb
@@ -9,7 +9,6 @@

 #include <functional>

-#include "db/arena_wrapped_db_iter.h"
 #include "db/db_iter.h"
 #include "db/db_test_util.h"
 #include "port/port.h"
@@ -1097,8 +1096,7 @@ TEST_P(DBIteratorTest, IndexWithFirstKey) {
        BlockBasedTableOptions::IndexShorteningMode::kNoShortening;
    table_options.flush_block_policy_factory =
        std::make_shared<FlushBlockEveryKeyPolicyFactory>();
-    table_options.block_cache =
-        NewLRUCache(8000);  // fits all blocks and their cache metadata overhead
+    table_options.block_cache = NewLRUCache(1000);  // fits all blocks
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));

    DestroyAndReopen(options);
@@ -210,11 +210,13 @@ void VerifySimilar(uint64_t a, uint64_t b, double bias) {
  }
 }

-void VerifyTableProperties(
-    const TableProperties& base_tp, const TableProperties& new_tp,
-    double filter_size_bias = CACHE_LINE_SIZE >= 256 ? 0.15 : 0.1,
-    double index_size_bias = 0.1, double data_size_bias = 0.1,
-    double num_data_blocks_bias = 0.05) {
+void VerifyTableProperties(const TableProperties& base_tp,
+                           const TableProperties& new_tp,
+                           double filter_size_bias =
+                               CACHE_LINE_SIZE >= 256 ? 0.15 : 0.1,
+                           double index_size_bias = 0.1,
+                           double data_size_bias = 0.1,
+                           double num_data_blocks_bias = 0.05) {
  VerifySimilar(base_tp.data_size, new_tp.data_size, data_size_bias);
  VerifySimilar(base_tp.index_size, new_tp.index_size, index_size_bias);
  VerifySimilar(base_tp.filter_size, new_tp.filter_size, filter_size_bias);
@@ -1631,11 +1633,7 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {

  // Test with empty block cache.
  constexpr size_t kCapacity = 100;
-  LRUCacheOptions co;
-  co.capacity = kCapacity;
-  co.num_shard_bits = 0;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  auto block_cache = NewLRUCache(co);
+  auto block_cache = NewLRUCache(kCapacity, 0 /*num_shard_bits*/);
  table_options.block_cache = block_cache;
  table_options.no_block_cache = false;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
@@ -62,6 +62,7 @@
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/compression.h"
+#include "util/file_reader_writer.h"
 #include "util/mutexlock.h"
 #include "util/rate_limiter.h"
 #include "util/string_util.h"
@@ -2737,10 +2738,6 @@ class ModelDB : public DB {
    return Status::NotSupported("Not supported operation.");
  }

-  void EnableManualCompaction() override { return; }
-
-  void DisableManualCompaction() override { return; }
-
  using DB::NumberLevels;
  int NumberLevels(ColumnFamilyHandle* /*column_family*/) override { return 1; }

@@ -2793,8 +2790,7 @@ class ModelDB : public DB {
    return Status::OK();
  }

-  Status GetCurrentWalFile(
-      std::unique_ptr<LogFile>* /*current_log_file*/) override {
+  Status GetCurrentWalFile(std::unique_ptr<LogFile>* /*current_log_file*/) override {
    return Status::OK();
  }

@@ -6266,7 +6262,7 @@ TEST_F(DBTest, LargeBlockSizeTest) {
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_OK(Put(0, "foo", "bar"));
  BlockBasedTableOptions table_options;
-  table_options.block_size = 8LL * 1024 * 1024 * 1024LL;
+  table_options.block_size = 8LL*1024*1024*1024LL;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  ASSERT_NOK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
 }
@@ -16,7 +16,6 @@
 #include "port/stack_trace.h"
 #include "rocksdb/persistent_cache.h"
 #include "rocksdb/wal_filter.h"
-#include "test_util/fault_injection_test_env.h"

 namespace rocksdb {

@@ -2403,215 +2402,6 @@ TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }

-TEST_F(DBTest2, PausingManualCompaction1) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.num_levels = 7;
-
-  DestroyAndReopen(options);
-  Random rnd(301);
-  // Generate a file containing 10 keys.
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-
-  // Generate another file containing same keys
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-
-  int manual_compactions_paused = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():PausingManualCompaction:1", [&](void* arg) {
-        auto paused = reinterpret_cast<std::atomic<bool>*>(arg);
-        ASSERT_FALSE(paused->load(std::memory_order_acquire));
-        paused->store(true, std::memory_order_release);
-        manual_compactions_paused += 1;
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<std::string> files_before_compact, files_after_compact;
-  // Remember file name before compaction is triggered
-  std::vector<LiveFileMetaData> files_meta;
-  dbfull()->GetLiveFilesMetaData(&files_meta);
-  for (auto file : files_meta) {
-    files_before_compact.push_back(file.name);
-  }
-
-  // OK, now trigger a manual compaction
-  dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  // Wait for compactions to get scheduled and stopped
-  dbfull()->TEST_WaitForCompact(true);
-
-  // Get file names after compaction is stopped
-  files_meta.clear();
-  dbfull()->GetLiveFilesMetaData(&files_meta);
-  for (auto file : files_meta) {
-    files_after_compact.push_back(file.name);
-  }
-
-  // Like nothing happened
-  ASSERT_EQ(files_before_compact, files_after_compact);
-  ASSERT_EQ(manual_compactions_paused, 1);
-
-  manual_compactions_paused = 0;
-  // Now make sure CompactFiles also not run
-  dbfull()->CompactFiles(rocksdb::CompactionOptions(), files_before_compact, 0);
-  // Wait for manual compaction to get scheduled and finish
-  dbfull()->TEST_WaitForCompact(true);
-
-  files_meta.clear();
-  files_after_compact.clear();
-  dbfull()->GetLiveFilesMetaData(&files_meta);
-  for (auto file : files_meta) {
-    files_after_compact.push_back(file.name);
-  }
-
-  ASSERT_EQ(files_before_compact, files_after_compact);
-  // CompactFiles returns at entry point
-  ASSERT_EQ(manual_compactions_paused, 0);
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// PausingManualCompaction does not affect auto compaction
-TEST_F(DBTest2, PausingManualCompaction2) {
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  options.disable_auto_compactions = false;
-
-  DestroyAndReopen(options);
-  dbfull()->DisableManualCompaction();
-
-  Random rnd(301);
-  for (int i = 0; i < 2; i++) {
-    // Generate a file containing 10 keys.
-    for (int j = 0; j < 100; j++) {
-      ASSERT_OK(Put(Key(j), RandomString(&rnd, 50)));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact(true));
-
-  std::vector<LiveFileMetaData> files_meta;
-  dbfull()->GetLiveFilesMetaData(&files_meta);
-  ASSERT_EQ(files_meta.size(), 1);
-}
-
-TEST_F(DBTest2, PausingManualCompaction3) {
-  CompactRangeOptions compact_options;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.num_levels = 7;
-
-  Random rnd(301);
-  auto generate_files = [&]() {
-    for (int i = 0; i < options.num_levels; i++) {
-      for (int j = 0; j < options.num_levels - i + 1; j++) {
-        for (int k = 0; k < 1000; k++) {
-          ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50)));
-        }
-        Flush();
-      }
-
-      for (int l = 1; l < options.num_levels - i; l++) {
-        MoveFilesToLevel(l);
-      }
-    }
-  };
-
-  DestroyAndReopen(options);
-  generate_files();
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2,3,4,5,6,7,8", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-  int run_manual_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():PausingManualCompaction:1",
-      [&](void* /*arg*/) { run_manual_compactions++; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  dbfull()->DisableManualCompaction();
-  dbfull()->CompactRange(compact_options, nullptr, nullptr);
-  dbfull()->TEST_WaitForCompact(true);
-  // As manual compaction disabled, not even reach sync point
-  ASSERT_EQ(run_manual_compactions, 0);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2,3,4,5,6,7,8", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-
-  rocksdb::SyncPoint::GetInstance()->ClearCallBack(
-      "CompactionJob::Run():PausingManualCompaction:1");
-  dbfull()->EnableManualCompaction();
-  dbfull()->CompactRange(compact_options, nullptr, nullptr);
-  dbfull()->TEST_WaitForCompact(true);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBTest2, PausingManualCompaction4) {
-  CompactRangeOptions compact_options;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.num_levels = 7;
-
-  Random rnd(301);
-  auto generate_files = [&]() {
-    for (int i = 0; i < options.num_levels; i++) {
-      for (int j = 0; j < options.num_levels - i + 1; j++) {
-        for (int k = 0; k < 1000; k++) {
-          ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50)));
-        }
-        Flush();
-      }
-
-      for (int l = 1; l < options.num_levels - i; l++) {
-        MoveFilesToLevel(l);
-      }
-    }
-  };
-
-  DestroyAndReopen(options);
-  generate_files();
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2,3,4,5,6,7,8", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-  int run_manual_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Run():PausingManualCompaction:2", [&](void* arg) {
-        auto paused = reinterpret_cast<std::atomic<bool>*>(arg);
-        ASSERT_FALSE(paused->load(std::memory_order_acquire));
-        paused->store(true, std::memory_order_release);
-        run_manual_compactions++;
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  dbfull()->EnableManualCompaction();
-  dbfull()->CompactRange(compact_options, nullptr, nullptr);
-  dbfull()->TEST_WaitForCompact(true);
-  ASSERT_EQ(run_manual_compactions, 1);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("2,3,4,5,6,7,8", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-
-  rocksdb::SyncPoint::GetInstance()->ClearCallBack(
-      "CompactionJob::Run():PausingManualCompaction:2");
-  dbfull()->EnableManualCompaction();
-  dbfull()->CompactRange(compact_options, nullptr, nullptr);
-  dbfull()->TEST_WaitForCompact(true);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBTest2, OptimizeForPointLookup) {
  Options options = CurrentOptions();
  Close();
@@ -3986,51 +3776,11 @@ TEST_F(DBTest2, CloseWithUnreleasedSnapshot) {
  db_ = nullptr;
 }

-TEST_F(DBTest2, PrefixBloomReseek) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.prefix_extractor.reset(NewCappedPrefixTransform(3));
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.whole_key_filtering = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  DestroyAndReopen(options);
-
-  // Construct two L1 files with keys:
-  // f1:[aaa1 ccc1] f2:[ddd0]
-  ASSERT_OK(Put("aaa1", ""));
-  ASSERT_OK(Put("ccc1", ""));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("ddd0", ""));
-  ASSERT_OK(Flush());
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-
-  ASSERT_OK(Put("bbb1", ""));
-
-  Iterator* iter = db_->NewIterator(ReadOptions());
-
-  // Seeking into f1, the iterator will check bloom filter which returns the
-  // file iterator ot be invalidate, and the cursor will put into f2, with
-  // the next key to be "ddd0".
-  iter->Seek("bbb1");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bbb1", iter->key().ToString());
-
-  // Reseek ccc1, the L1 iterator needs to go back to f1 and reseek.
-  iter->Seek("ccc1");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("ccc1", iter->key().ToString());
-
-  delete iter;
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(DBTest2, RowCacheSnapshot) {
  Options options = CurrentOptions();
  options.statistics = rocksdb::CreateDBStatistics();
-  options.row_cache = NewLRUCache(8 * 8192);
+  options.row_cache = NewLRUCache(8192);
  DestroyAndReopen(options);

  ASSERT_OK(Put("foo", "bar1"));
@@ -4071,65 +3821,6 @@ TEST_F(DBTest2, RowCacheSnapshot) {
  db_->ReleaseSnapshot(s3);
 }
 #endif  // ROCKSDB_LITE
-
-// Disabled but the test is failing.
-// When DB is reopened with multiple column families, the manifest file
-// is written after the first CF is flushed, and it is written again
-// after each flush. If DB crashes between the flushes, the flushed CF
-// flushed will pass the latest log file, and now we require it not
-// to be corrupted, and triggering a corruption report.
-// We need to fix the bug and enable the test.
-TEST_F(DBTest2, DISABLED_CrashInRecoveryMultipleCF) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_OK(Put("foo", "bar"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put(1, "foo", "bar"));
-  ASSERT_OK(Flush(1));
-  ASSERT_OK(Put("foo", "bar"));
-  ASSERT_OK(Put(1, "foo", "bar"));
-  // The value is large enough to be divided to two blocks.
-  std::string large_value(400, ' ');
-  ASSERT_OK(Put("foo1", large_value));
-  ASSERT_OK(Put("foo2", large_value));
-  Close();
-
-  // Corrupt the log file in the middle, so that it is not corrupted
-  // in the tail.
-  std::vector<std::string> filenames;
-  ASSERT_OK(env_->GetChildren(dbname_, &filenames));
-  for (const auto& f : filenames) {
-    uint64_t number;
-    FileType type;
-    if (ParseFileName(f, &number, &type) && type == FileType::kLogFile) {
-      std::string fname = dbname_ + "/" + f;
-      std::string file_content;
-      ASSERT_OK(ReadFileToString(env_, fname, &file_content));
-      file_content[400] = 'h';
-      file_content[401] = 'a';
-      ASSERT_OK(WriteStringToFile(env_, file_content, fname));
-      break;
-    }
-  }
-
-  // Reopen and freeze the file system after the first manifest write.
-  FaultInjectionTestEnv fit_env(options.env);
-  options.env = &fit_env;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::RecoverLogFiles:AfterLogAndApply",
-      [&](void* /*arg*/) { fit_env.SetFilesystemActive(false); });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  ASSERT_NOK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-
-  fit_env.SetFilesystemActive(true);
-  // If we continue using failure ingestion Env, it will conplain something
-  // when renaming current file, which is not expected. Need to investigate why.
-  options.env = env_;
-  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
-}
 }  // namespace rocksdb

 #ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
@@ -48,7 +48,9 @@ ROT13BlockCipher rot13Cipher_(16);
 #endif  // ROCKSDB_LITE

 DBTestBase::DBTestBase(const std::string path)
-    : mem_env_(nullptr), encrypted_env_(nullptr), option_config_(kDefault) {
+    : mem_env_(nullptr),
+      encrypted_env_(nullptr),
+      option_config_(kDefault) {
  Env* base_env = Env::Default();
 #ifndef ROCKSDB_LITE
  const char* test_env_uri = getenv("TEST_ENV_URI");
@@ -584,8 +586,7 @@ void DBTestBase::CreateColumnFamilies(const std::vector<std::string>& cfs,
  size_t cfi = handles_.size();
  handles_.resize(cfi + cfs.size());
  for (auto cf : cfs) {
-    Status s = db_->CreateColumnFamily(cf_opts, cf, &handles_[cfi++]);
-    ASSERT_OK(s);
+    ASSERT_OK(db_->CreateColumnFamily(cf_opts, cf, &handles_[cfi++]));
  }
 }

@@ -397,7 +397,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
  int total_picked_compactions = 0;
  int total_size_amp_compactions = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
+      "UniversalCompactionPicker::PickCompaction:Return", [&](void* arg) {
        if (arg) {
          total_picked_compactions++;
          Compaction* c = static_cast<Compaction*>(arg);
@@ -452,7 +452,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
                                                     &mutable_cf_options));
  ASSERT_EQ(110u, mutable_cf_options.compaction_options_universal
-                      .max_size_amplification_percent);
+                     .max_size_amplification_percent);

  dbfull()->TEST_WaitForCompact();
  // Verify that size amplification did happen
@@ -478,7 +478,7 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
  int total_picked_compactions = 0;
  int total_size_ratio_compactions = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
+      "UniversalCompactionPicker::PickCompaction:Return", [&](void* arg) {
        if (arg) {
          total_picked_compactions++;
          Compaction* c = static_cast<Compaction*>(arg);
@@ -534,10 +534,8 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
                                                     &mutable_cf_options));
  ASSERT_EQ(mutable_cf_options.compaction_options_universal.size_ratio, 100u);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.min_merge_width,
-            2u);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width,
-            2u);
+  ASSERT_EQ(mutable_cf_options.compaction_options_universal.min_merge_width, 2u);
+  ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width, 2u);

  dbfull()->TEST_WaitForCompact();

@@ -839,14 +837,14 @@ TEST_P(DBTestUniversalCompactionParallel, PickByFileNumberBug) {
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"DBTestUniversalCompactionParallel::PickByFileNumberBug:0",
        "BackgroundCallCompaction:0"},
-       {"UniversalCompactionBuilder::PickCompaction:Return",
+       {"UniversalCompactionPicker::PickCompaction:Return",
        "DBTestUniversalCompactionParallel::PickByFileNumberBug:1"},
       {"DBTestUniversalCompactionParallel::PickByFileNumberBug:2",
        "CompactionJob::Run():Start"}});

  int total_picked_compactions = 0;
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
+      "UniversalCompactionPicker::PickCompaction:Return", [&](void* arg) {
        if (arg) {
          total_picked_compactions++;
        }
@@ -8,8 +8,8 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #include "db/dbformat.h"

-#include <stdio.h>
 #include <cinttypes>
+#include <stdio.h>
 #include "monitoring/perf_context_imp.h"
 #include "port/port.h"
 #include "util/coding.h"
@@ -14,11 +14,9 @@
 #include <string>
 #include <vector>
 #include "db/db_impl/db_impl.h"
-#include "db/db_test_util.h"
 #include "db/version_set.h"
 #include "db/write_batch_internal.h"
 #include "file/filename.h"
-#include "port/stack_trace.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/transaction_log.h"
@@ -29,26 +27,58 @@

 namespace rocksdb {

-class DeleteFileTest : public DBTestBase {
+class DeleteFileTest : public testing::Test {
 public:
-  const int numlevels_;
-  const std::string wal_dir_;
+  std::string dbname_;
+  Options options_;
+  DB* db_;
+  Env* env_;
+  int numlevels_;

-  DeleteFileTest()
-      : DBTestBase("/deletefile_test"),
-        numlevels_(7),
-        wal_dir_(dbname_ + "/wal_files") {}
+  DeleteFileTest() {
+    db_ = nullptr;
+    env_ = Env::Default();
+    options_.delete_obsolete_files_period_micros = 0;  // always do full purge
+    options_.enable_thread_tracking = true;
+    options_.write_buffer_size = 1024*1024*1000;
+    options_.target_file_size_base = 1024*1024*1000;
+    options_.max_bytes_for_level_base = 1024*1024*1000;
+    options_.WAL_ttl_seconds = 300; // Used to test log files
+    options_.WAL_size_limit_MB = 1024; // Used to test log files
+    dbname_ = test::PerThreadDBPath("deletefile_test");
+    options_.wal_dir = dbname_ + "/wal_files";

-  void SetOptions(Options* options) {
-    assert(options);
-    options->delete_obsolete_files_period_micros = 0;  // always do full purge
-    options->enable_thread_tracking = true;
-    options->write_buffer_size = 1024 * 1024 * 1000;
-    options->target_file_size_base = 1024 * 1024 * 1000;
-    options->max_bytes_for_level_base = 1024 * 1024 * 1000;
-    options->WAL_ttl_seconds = 300;     // Used to test log files
-    options->WAL_size_limit_MB = 1024;  // Used to test log files
-    options->wal_dir = wal_dir_;
+    // clean up all the files that might have been there before
+    std::vector<std::string> old_files;
+    env_->GetChildren(dbname_, &old_files);
+    for (auto file : old_files) {
+      env_->DeleteFile(dbname_ + "/" + file);
+    }
+    env_->GetChildren(options_.wal_dir, &old_files);
+    for (auto file : old_files) {
+      env_->DeleteFile(options_.wal_dir + "/" + file);
+    }
+
+    DestroyDB(dbname_, options_);
+    numlevels_ = 7;
+    EXPECT_OK(ReopenDB(true));
+  }
+
+  Status ReopenDB(bool create) {
+    delete db_;
+    if (create) {
+      DestroyDB(dbname_, options_);
+    }
+    db_ = nullptr;
+    options_.create_if_missing = create;
+    Status s = DB::Open(options_, dbname_, &db_);
+    assert(db_);
+    return s;
+  }
+
+  void CloseDB() {
+    delete db_;
+    db_ = nullptr;
  }

  void AddKeys(int numkeys, int startkey = 0) {
@@ -90,20 +120,23 @@ class DeleteFileTest : public DBTestBase {

  void CreateTwoLevels() {
    AddKeys(50000, 10000);
-    ASSERT_OK(dbfull()->TEST_FlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
+    ASSERT_OK(dbi->TEST_FlushMemTable());
+    ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
    for (int i = 0; i < 2; ++i) {
-      ASSERT_OK(dbfull()->TEST_CompactRange(i, nullptr, nullptr));
+      ASSERT_OK(dbi->TEST_CompactRange(i, nullptr, nullptr));
    }

    AddKeys(50000, 10000);
-    ASSERT_OK(dbfull()->TEST_FlushMemTable());
-    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
+    ASSERT_OK(dbi->TEST_FlushMemTable());
+    ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
+    ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
  }

-  void CheckFileTypeCounts(const std::string& dir, int required_log,
-                           int required_sst, int required_manifest) {
+  void CheckFileTypeCounts(std::string& dir,
+                            int required_log,
+                            int required_sst,
+                            int required_manifest) {
    std::vector<std::string> filenames;
    env_->GetChildren(dir, &filenames);

@@ -134,12 +167,6 @@ class DeleteFileTest : public DBTestBase {
 };

 TEST_F(DeleteFileTest, AddKeysAndQueryLevels) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  CreateTwoLevels();
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);
@@ -181,19 +208,15 @@ TEST_F(DeleteFileTest, AddKeysAndQueryLevels) {

  // Lowest level file deletion should succeed.
  ASSERT_OK(db_->DeleteFile(level2file));
+
+  CloseDB();
 }

 TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  CreateTwoLevels();
  // there should be only one (empty) log file because CreateTwoLevels()
  // flushes the memtables to disk
-  CheckFileTypeCounts(wal_dir_, 1, 0, 0);
+  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
  // 2 ssts, 1 manifest
  CheckFileTypeCounts(dbname_, 0, 2, 1);
  std::string first("0"), last("999999");
@@ -206,7 +229,7 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
  CheckFileTypeCounts(dbname_, 0, 1, 1);

  // this time, we keep an iterator alive
-  Reopen(options);
+  ReopenDB(true);
  Iterator *itr = nullptr;
  CreateTwoLevels();
  itr = db_->NewIterator(ReadOptions());
@@ -216,15 +239,11 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
  delete itr;
  // 1 sst after iterator deletion
  CheckFileTypeCounts(dbname_, 0, 1, 1);
+
+  CloseDB();
 }

 TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  std::string first("0"), last("999999");
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
@@ -234,9 +253,9 @@ TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
  // We keep an iterator alive
  Iterator* itr = nullptr;
  CreateTwoLevels();
-  ReadOptions read_options;
-  read_options.background_purge_on_iterator_cleanup = true;
-  itr = db_->NewIterator(read_options);
+  ReadOptions options;
+  options.background_purge_on_iterator_cleanup = true;
+  itr = db_->NewIterator(options);
  db_->CompactRange(compact_options, &first_slice, &last_slice);
  // 3 sst after compaction with live iterator
  CheckFileTypeCounts(dbname_, 0, 3, 1);
@@ -258,15 +277,11 @@ TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
  sleeping_task_after.WaitUntilDone();
  // 1 sst after iterator deletion
  CheckFileTypeCounts(dbname_, 0, 1, 1);
+
+  CloseDB();
 }

 TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  auto do_test = [&](bool bg_purge) {
    ColumnFamilyOptions co;
    co.max_write_buffer_size_to_maintain =
@@ -313,24 +328,20 @@ TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
        "DBImpl::BGWorkPurge:start"}});
  SyncPoint::GetInstance()->EnableProcessing();

-  options.avoid_unnecessary_blocking_io = true;
-  options.create_if_missing = false;
-  Reopen(options);
+  options_.avoid_unnecessary_blocking_io = true;
+  ASSERT_OK(ReopenDB(false));
  {
    SCOPED_TRACE("avoid_unnecessary_blocking_io = true");
    do_test(true);
  }
+
+  CloseDB();
+  SyncPoint::GetInstance()->DisableProcessing();
 }

 // This test is to reproduce a bug that read invalid ReadOption in iterator
 // cleanup function
 TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  std::string first("0"), last("999999");
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
@@ -340,13 +351,12 @@ TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
  // We keep an iterator alive
  Iterator* itr = nullptr;
  CreateTwoLevels();
-  {
-    ReadOptions read_options;
-    read_options.background_purge_on_iterator_cleanup = true;
-    itr = db_->NewIterator(read_options);
-    // ReadOptions is deleted, but iterator cleanup function should not be
-    // affected
-  }
+  ReadOptions* options = new ReadOptions();
+  options->background_purge_on_iterator_cleanup = true;
+  itr = db_->NewIterator(*options);
+  // ReadOptions is deleted, but iterator cleanup function should not be
+  // affected
+  delete options;

  db_->CompactRange(compact_options, &first_slice, &last_slice);
  // 3 sst after compaction with live iterator
@@ -362,15 +372,11 @@ TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
  sleeping_task_after.WaitUntilDone();
  // 1 sst after iterator deletion
  CheckFileTypeCounts(dbname_, 0, 1, 1);
+
+  CloseDB();
 }

 TEST_F(DeleteFileTest, BackgroundPurgeTestMultipleJobs) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  std::string first("0"), last("999999");
  CompactRangeOptions compact_options;
  compact_options.change_level = true;
@@ -379,16 +385,15 @@ TEST_F(DeleteFileTest, BackgroundPurgeTestMultipleJobs) {

  // We keep an iterator alive
  CreateTwoLevels();
-  ReadOptions read_options;
-  read_options.background_purge_on_iterator_cleanup = true;
-  Iterator* itr1 = db_->NewIterator(read_options);
+  ReadOptions options;
+  options.background_purge_on_iterator_cleanup = true;
+  Iterator* itr1 = db_->NewIterator(options);
  CreateTwoLevels();
-  Iterator* itr2 = db_->NewIterator(read_options);
+  Iterator* itr2 = db_->NewIterator(options);
  db_->CompactRange(compact_options, &first_slice, &last_slice);
  // 5 sst files after 2 compactions with 2 live iterators
  CheckFileTypeCounts(dbname_, 0, 5, 1);

-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  // ~DBImpl should wait until all BGWorkPurge are finished
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"DBImpl::~DBImpl:WaitJob", "DBImpl::BGWorkPurge"},
@@ -400,29 +405,24 @@ TEST_F(DeleteFileTest, BackgroundPurgeTestMultipleJobs) {
  env_->Schedule(&DeleteFileTest::DoSleep, this, Env::Priority::HIGH);
  delete itr2;
  env_->Schedule(&DeleteFileTest::GuardFinish, nullptr, Env::Priority::HIGH);
-  Close();
+  CloseDB();

  TEST_SYNC_POINT("DeleteFileTest::BackgroundPurgeTestMultipleJobs:DBClose");
  // 1 sst after iterator deletion
  CheckFileTypeCounts(dbname_, 0, 1, 1);
+  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }

 TEST_F(DeleteFileTest, DeleteFileWithIterator) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  CreateTwoLevels();
-  ReadOptions read_options;
-  Iterator* it = db_->NewIterator(read_options);
+  ReadOptions options;
+  Iterator* it = db_->NewIterator(options);
  std::vector<LiveFileMetaData> metadata;
  db_->GetLiveFilesMetaData(&metadata);

-  std::string level2file;
+  std::string level2file = "";

-  ASSERT_EQ(metadata.size(), static_cast<size_t>(2));
+  ASSERT_EQ((int)metadata.size(), 2);
  if (metadata[0].level == 1) {
    level2file = metadata[1].name;
  } else {
@@ -441,15 +441,10 @@ TEST_F(DeleteFileTest, DeleteFileWithIterator) {
  }
  ASSERT_EQ(numKeysIterated, 50000);
  delete it;
+  CloseDB();
 }

 TEST_F(DeleteFileTest, DeleteLogFiles) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-
  AddKeys(10, 0);
  VectorLogPtr logfiles;
  db_->GetSortedWalFiles(logfiles);
@@ -458,11 +453,11 @@ TEST_F(DeleteFileTest, DeleteLogFiles) {
  // Should not succeed because live logs are not allowed to be deleted
  std::unique_ptr<LogFile> alive_log = std::move(logfiles.back());
  ASSERT_EQ(alive_log->Type(), kAliveLogFile);
-  ASSERT_OK(env_->FileExists(wal_dir_ + "/" + alive_log->PathName()));
+  ASSERT_OK(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
  fprintf(stdout, "Deleting alive log file %s\n",
          alive_log->PathName().c_str());
  ASSERT_TRUE(!db_->DeleteFile(alive_log->PathName()).ok());
-  ASSERT_OK(env_->FileExists(wal_dir_ + "/" + alive_log->PathName()));
+  ASSERT_OK(env_->FileExists(options_.wal_dir + "/" + alive_log->PathName()));
  logfiles.clear();

  // Call Flush to bring about a new working log file and add more keys
@@ -476,36 +471,43 @@ TEST_F(DeleteFileTest, DeleteLogFiles) {
  ASSERT_GT(logfiles.size(), 0UL);
  std::unique_ptr<LogFile> archived_log = std::move(logfiles.front());
  ASSERT_EQ(archived_log->Type(), kArchivedLogFile);
-  ASSERT_OK(env_->FileExists(wal_dir_ + "/" + archived_log->PathName()));
+  ASSERT_OK(
+      env_->FileExists(options_.wal_dir + "/" + archived_log->PathName()));
  fprintf(stdout, "Deleting archived log file %s\n",
          archived_log->PathName().c_str());
  ASSERT_OK(db_->DeleteFile(archived_log->PathName()));
-  ASSERT_EQ(Status::NotFound(),
-            env_->FileExists(wal_dir_ + "/" + archived_log->PathName()));
+  ASSERT_EQ(Status::NotFound(), env_->FileExists(options_.wal_dir + "/" +
+                                                 archived_log->PathName()));
+  CloseDB();
 }

 TEST_F(DeleteFileTest, DeleteNonDefaultColumnFamily) {
-  Options options = CurrentOptions();
-  SetOptions(&options);
-  Destroy(options);
-  options.create_if_missing = true;
-  Reopen(options);
-  CreateAndReopenWithCF({"new_cf"}, options);
+  CloseDB();
+  DBOptions db_options;
+  db_options.create_if_missing = true;
+  db_options.create_missing_column_families = true;
+  std::vector<ColumnFamilyDescriptor> column_families;
+  column_families.emplace_back();
+  column_families.emplace_back("new_cf", ColumnFamilyOptions());
+
+  std::vector<rocksdb::ColumnFamilyHandle*> handles;
+  rocksdb::DB* db;
+  ASSERT_OK(DB::Open(db_options, dbname_, column_families, &handles, &db));

  Random rnd(5);
  for (int i = 0; i < 1000; ++i) {
-    ASSERT_OK(db_->Put(WriteOptions(), handles_[1], test::RandomKey(&rnd, 10),
-                       test::RandomKey(&rnd, 10)));
+    ASSERT_OK(db->Put(WriteOptions(), handles[1], test::RandomKey(&rnd, 10),
+                      test::RandomKey(&rnd, 10)));
  }
-  ASSERT_OK(db_->Flush(FlushOptions(), handles_[1]));
+  ASSERT_OK(db->Flush(FlushOptions(), handles[1]));
  for (int i = 0; i < 1000; ++i) {
-    ASSERT_OK(db_->Put(WriteOptions(), handles_[1], test::RandomKey(&rnd, 10),
-                       test::RandomKey(&rnd, 10)));
+    ASSERT_OK(db->Put(WriteOptions(), handles[1], test::RandomKey(&rnd, 10),
+                      test::RandomKey(&rnd, 10)));
  }
-  ASSERT_OK(db_->Flush(FlushOptions(), handles_[1]));
+  ASSERT_OK(db->Flush(FlushOptions(), handles[1]));

  std::vector<LiveFileMetaData> metadata;
-  db_->GetLiveFilesMetaData(&metadata);
+  db->GetLiveFilesMetaData(&metadata);
  ASSERT_EQ(2U, metadata.size());
  ASSERT_EQ("new_cf", metadata[0].column_family_name);
  ASSERT_EQ("new_cf", metadata[1].column_family_name);
@@ -515,11 +517,11 @@ TEST_F(DeleteFileTest, DeleteNonDefaultColumnFamily) {
  auto new_file = metadata[0].smallest_seqno > metadata[1].smallest_seqno
                      ? metadata[0].name
                      : metadata[1].name;
-  ASSERT_TRUE(db_->DeleteFile(new_file).IsInvalidArgument());
-  ASSERT_OK(db_->DeleteFile(old_file));
+  ASSERT_TRUE(db->DeleteFile(new_file).IsInvalidArgument());
+  ASSERT_OK(db->DeleteFile(old_file));

  {
-    std::unique_ptr<Iterator> itr(db_->NewIterator(ReadOptions(), handles_[1]));
+    std::unique_ptr<Iterator> itr(db->NewIterator(ReadOptions(), handles[1]));
    int count = 0;
    for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
      ASSERT_OK(itr->status());
@@ -528,11 +530,13 @@ TEST_F(DeleteFileTest, DeleteNonDefaultColumnFamily) {
    ASSERT_EQ(count, 1000);
  }

-  Close();
-  ReopenWithColumnFamilies({kDefaultColumnFamilyName, "new_cf"}, options);
+  delete handles[0];
+  delete handles[1];
+  delete db;

+  ASSERT_OK(DB::Open(db_options, dbname_, column_families, &handles, &db));
  {
-    std::unique_ptr<Iterator> itr(db_->NewIterator(ReadOptions(), handles_[1]));
+    std::unique_ptr<Iterator> itr(db->NewIterator(ReadOptions(), handles[1]));
    int count = 0;
    for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
      ASSERT_OK(itr->status());
@@ -540,22 +544,16 @@ TEST_F(DeleteFileTest, DeleteNonDefaultColumnFamily) {
    }
    ASSERT_EQ(count, 1000);
  }
+
+  delete handles[0];
+  delete handles[1];
+  delete db;
 }

 } //namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }

@@ -1070,47 +1070,6 @@ TEST_P(ExternalSSTFileBasicTest, IngestExternalFileWithCorruptedPropsBlock) {
  } while (ChangeOptionsForFileIngestionTest());
 }

-TEST_F(ExternalSSTFileBasicTest, OverlappingFiles) {
-  Options options = CurrentOptions();
-
-  std::vector<std::string> files;
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file1 = sst_files_dir_ + "file1.sst";
-    ASSERT_OK(sst_file_writer.Open(file1));
-    ASSERT_OK(sst_file_writer.Put("a", "z"));
-    ASSERT_OK(sst_file_writer.Put("i", "m"));
-    ExternalSstFileInfo file1_info;
-    ASSERT_OK(sst_file_writer.Finish(&file1_info));
-    files.push_back(std::move(file1));
-  }
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file2 = sst_files_dir_ + "file2.sst";
-    ASSERT_OK(sst_file_writer.Open(file2));
-    ASSERT_OK(sst_file_writer.Put("i", "k"));
-    ExternalSstFileInfo file2_info;
-    ASSERT_OK(sst_file_writer.Finish(&file2_info));
-    files.push_back(std::move(file2));
-  }
-
-  IngestExternalFileOptions ifo;
-  ASSERT_OK(db_->IngestExternalFile(files, ifo));
-  ASSERT_EQ(Get("a"), "z");
-  ASSERT_EQ(Get("i"), "k");
-
-  int total_keys = 0;
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ASSERT_OK(iter->status());
-    total_keys++;
-  }
-  delete iter;
-  ASSERT_EQ(total_keys, 2);
-
-  ASSERT_EQ(2, NumTableFilesAtLevel(0));
-}
-
 INSTANTIATE_TEST_CASE_P(ExternalSSTFileBasicTest, ExternalSSTFileBasicTest,
                        testing::Values(std::make_tuple(true, true),
                                        std::make_tuple(true, false),
@@ -16,12 +16,12 @@
 #include "db/db_impl/db_impl.h"
 #include "db/version_edit.h"
 #include "file/file_util.h"
-#include "file/random_access_file_reader.h"
 #include "table/merging_iterator.h"
 #include "table/scoped_arena_iterator.h"
 #include "table/sst_file_writer_collectors.h"
 #include "table/table_builder.h"
 #include "test_util/sync_point.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"

 namespace rocksdb {
@@ -71,22 +71,18 @@ Status ExternalSstFileIngestionJob::Prepare(
    for (size_t i = 0; i < num_files - 1; i++) {
      if (sstableKeyCompare(ucmp, sorted_files[i]->largest_internal_key,
                            sorted_files[i + 1]->smallest_internal_key) >= 0) {
-        files_overlap_ = true;
-        break;
+        return Status::NotSupported("Files have overlapping ranges");
      }
    }
  }

-  if (ingestion_options_.ingest_behind && files_overlap_) {
-    return Status::NotSupported("Files have overlapping ranges");
-  }
-
  for (IngestedFileInfo& f : files_to_ingest_) {
    if (f.num_entries == 0 && f.num_range_deletions == 0) {
      return Status::InvalidArgument("File contain no entries");
    }

-    if (!f.smallest_internal_key.Valid() || !f.largest_internal_key.Valid()) {
+    if (!f.smallest_internal_key.Valid() ||
+        !f.largest_internal_key.Valid()) {
      return Status::Corruption("Generated table have corrupted keys");
    }
  }
@@ -216,7 +212,7 @@ Status ExternalSstFileIngestionJob::Run() {
  }
  // It is safe to use this instead of LastAllocatedSequence since we are
  // the only active writer, and hence they are equal
-  SequenceNumber last_seqno = versions_->LastSequence();
+  const SequenceNumber last_seqno = versions_->LastSequence();
  edit_.SetColumnFamily(cfd_->GetID());
  // The levels that the files will be ingested into

@@ -226,8 +222,8 @@ Status ExternalSstFileIngestionJob::Run() {
      status = CheckLevelForIngestedBehindFile(&f);
    } else {
      status = AssignLevelAndSeqnoForIngestedFile(
-          super_version, force_global_seqno, cfd_->ioptions()->compaction_style,
-          last_seqno, &f, &assigned_seqno);
+         super_version, force_global_seqno, cfd_->ioptions()->compaction_style,
+         &f, &assigned_seqno);
    }
    if (!status.ok()) {
      return status;
@@ -235,10 +231,8 @@ Status ExternalSstFileIngestionJob::Run() {
    status = AssignGlobalSeqnoForIngestedFile(&f, assigned_seqno);
    TEST_SYNC_POINT_CALLBACK("ExternalSstFileIngestionJob::Run",
                             &assigned_seqno);
-    if (assigned_seqno > last_seqno) {
-      assert(assigned_seqno == last_seqno + 1);
-      last_seqno = assigned_seqno;
-      ++consumed_seqno_count_;
+    if (assigned_seqno == last_seqno + 1) {
+      consumed_seqno_ = true;
    }
    if (!status.ok()) {
      return status;
@@ -256,13 +250,6 @@ void ExternalSstFileIngestionJob::UpdateStats() {
  uint64_t total_keys = 0;
  uint64_t total_l0_files = 0;
  uint64_t total_time = env_->NowMicros() - job_start_time_;
-
-  EventLoggerStream stream = event_logger_->Log();
-  stream << "event"
-         << "ingest_finished";
-  stream << "files_ingested";
-  stream.StartArray();
-
  for (IngestedFileInfo& f : files_to_ingest_) {
    InternalStats::CompactionStats stats(CompactionReason::kExternalSstIngestion, 1);
    stats.micros = total_time;
@@ -290,18 +277,7 @@ void ExternalSstFileIngestionJob::UpdateStats() {
        "(global_seqno=%" PRIu64 ")\n",
        f.external_file_path.c_str(), f.picked_level,
        f.internal_file_path.c_str(), f.assigned_seqno);
-    stream << "file" << f.internal_file_path << "level" << f.picked_level;
  }
-  stream.EndArray();
-
-  stream << "lsm_state";
-  stream.StartArray();
-  auto vstorage = cfd_->current()->storage_info();
-  for (int level = 0; level < vstorage->num_levels(); ++level) {
-    stream << vstorage->NumLevelFiles(level);
-  }
-  stream.EndArray();
-
  cfd_->internal_stats()->AddCFStats(InternalStats::INGESTED_NUM_KEYS_TOTAL,
                                     total_keys);
  cfd_->internal_stats()->AddCFStats(InternalStats::INGESTED_NUM_FILES_TOTAL,
@@ -325,8 +301,7 @@ void ExternalSstFileIngestionJob::Cleanup(const Status& status) {
                       f.internal_file_path.c_str(), s.ToString().c_str());
      }
    }
-    consumed_seqno_count_ = 0;
-    files_overlap_ = false;
+    consumed_seqno_ = false;
  } else if (status.ok() && ingestion_options_.move_files) {
    // The files were moved and added successfully, remove original file links
    for (IngestedFileInfo& f : files_to_ingest_) {
@@ -447,10 +422,8 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
      table_reader->NewRangeTombstoneIterator(ro));

  // Get first (smallest) and last (largest) key from file.
-  file_to_ingest->smallest_internal_key =
-      InternalKey("", 0, ValueType::kTypeValue);
-  file_to_ingest->largest_internal_key =
-      InternalKey("", 0, ValueType::kTypeValue);
+  file_to_ingest->smallest_internal_key = InternalKey("", 0, ValueType::kTypeValue);
+  file_to_ingest->largest_internal_key = InternalKey("", 0, ValueType::kTypeValue);
  bool bounds_set = false;
  iter->SeekToFirst();
  if (iter->Valid()) {
@@ -486,15 +459,11 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
      RangeTombstone tombstone(key, range_del_iter->value());

      InternalKey start_key = tombstone.SerializeKey();
-      if (!bounds_set ||
-          sstableKeyCompare(ucmp, start_key,
-                            file_to_ingest->smallest_internal_key) < 0) {
+      if (!bounds_set || sstableKeyCompare(ucmp, start_key, file_to_ingest->smallest_internal_key) < 0) {
        file_to_ingest->smallest_internal_key = start_key;
      }
      InternalKey end_key = tombstone.SerializeEndKey();
-      if (!bounds_set ||
-          sstableKeyCompare(ucmp, end_key,
-                            file_to_ingest->largest_internal_key) > 0) {
+      if (!bounds_set || sstableKeyCompare(ucmp, end_key, file_to_ingest->largest_internal_key) > 0) {
        file_to_ingest->largest_internal_key = end_key;
      }
      bounds_set = true;
@@ -510,13 +479,13 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(

 Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
    SuperVersion* sv, bool force_global_seqno, CompactionStyle compaction_style,
-    SequenceNumber last_seqno, IngestedFileInfo* file_to_ingest,
-    SequenceNumber* assigned_seqno) {
+    IngestedFileInfo* file_to_ingest, SequenceNumber* assigned_seqno) {
  Status status;
  *assigned_seqno = 0;
+  const SequenceNumber last_seqno = versions_->LastSequence();
  if (force_global_seqno) {
    *assigned_seqno = last_seqno + 1;
-    if (compaction_style == kCompactionStyleUniversal || files_overlap_) {
+    if (compaction_style == kCompactionStyleUniversal) {
      file_to_ingest->picked_level = 0;
      return status;
    }
@@ -536,10 +505,9 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(

    if (vstorage->NumLevelFiles(lvl) > 0) {
      bool overlap_with_level = false;
-      status = sv->current->OverlapWithLevelIterator(
-          ro, env_options_, file_to_ingest->smallest_internal_key.user_key(),
-          file_to_ingest->largest_internal_key.user_key(), lvl,
-          &overlap_with_level);
+      status = sv->current->OverlapWithLevelIterator(ro, env_options_,
+          file_to_ingest->smallest_internal_key.user_key(), file_to_ingest->largest_internal_key.user_key(),
+          lvl, &overlap_with_level);
      if (!status.ok()) {
        return status;
      }
@@ -579,12 +547,6 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
      target_level = lvl;
    }
  }
-  // If files overlap, we have to ingest them at level 0 and assign the newest
-  // sequence number
-  if (files_overlap_) {
-    target_level = 0;
-    *assigned_seqno = last_seqno + 1;
-  }
 TEST_SYNC_POINT_CALLBACK(
      "ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile",
      &overlap_with_db);
@@ -678,8 +640,7 @@ bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
  }

  auto* vstorage = cfd_->current()->storage_info();
-  Slice file_smallest_user_key(
-      file_to_ingest->smallest_internal_key.user_key());
+  Slice file_smallest_user_key(file_to_ingest->smallest_internal_key.user_key());
  Slice file_largest_user_key(file_to_ingest->largest_internal_key.user_key());

  if (vstorage->OverlapInLevel(level, &file_smallest_user_key,
@@ -12,7 +12,6 @@
 #include "db/dbformat.h"
 #include "db/internal_stats.h"
 #include "db/snapshot_impl.h"
-#include "logging/event_logger.h"
 #include "options/db_options.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
@@ -72,7 +71,7 @@ class ExternalSstFileIngestionJob {
      const ImmutableDBOptions& db_options, const EnvOptions& env_options,
      SnapshotList* db_snapshots,
      const IngestExternalFileOptions& ingestion_options,
-      Directories* directories, EventLogger* event_logger)
+      Directories* directories)
      : env_(env),
        versions_(versions),
        cfd_(cfd),
@@ -81,9 +80,8 @@ class ExternalSstFileIngestionJob {
        db_snapshots_(db_snapshots),
        ingestion_options_(ingestion_options),
        directories_(directories),
-        event_logger_(event_logger),
        job_start_time_(env_->NowMicros()),
-        consumed_seqno_count_(0) {
+        consumed_seqno_(false) {
    assert(directories != nullptr);
  }

@@ -118,8 +116,8 @@ class ExternalSstFileIngestionJob {
    return files_to_ingest_;
  }

-  // How many sequence numbers did we consume as part of the ingest job?
-  int ConsumedSequenceNumbersCount() const { return consumed_seqno_count_; }
+  // Whether to increment VersionSet's seqno after this job runs
+  bool ShouldIncrementLastSequence() const { return consumed_seqno_; }

 private:
  // Open the external file and populate `file_to_ingest` with all the
@@ -134,7 +132,6 @@ class ExternalSstFileIngestionJob {
  Status AssignLevelAndSeqnoForIngestedFile(SuperVersion* sv,
                                            bool force_global_seqno,
                                            CompactionStyle compaction_style,
-                                            SequenceNumber last_seqno,
                                            IngestedFileInfo* file_to_ingest,
                                            SequenceNumber* assigned_seqno);

@@ -166,13 +163,9 @@ class ExternalSstFileIngestionJob {
  autovector<IngestedFileInfo> files_to_ingest_;
  const IngestExternalFileOptions& ingestion_options_;
  Directories* directories_;
-  EventLogger* event_logger_;
  VersionEdit edit_;
  uint64_t job_start_time_;
-  int consumed_seqno_count_;
-  // Set in ExternalSstFileIngestionJob::Prepare(), if true all files are
-  // ingested in L0
-  bool files_overlap_{false};
+  bool consumed_seqno_;
 };

 }  // namespace rocksdb
@@ -11,12 +11,12 @@
 #include "db/db_impl/db_impl.h"
 #include "db/flush_job.h"
 #include "db/version_set.h"
-#include "file/writable_file_writer.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
+#include "util/file_reader_writer.h"
 #include "util/string_util.h"

 namespace rocksdb {
@@ -2,18 +2,18 @@

 #include "db/import_column_family_job.h"

-#include <algorithm>
 #include <cinttypes>
+#include <algorithm>
 #include <string>
 #include <vector>

 #include "db/version_edit.h"
 #include "file/file_util.h"
-#include "file/random_access_file_reader.h"
 #include "table/merging_iterator.h"
 #include "table/scoped_arena_iterator.h"
 #include "table/sst_file_writer_collectors.h"
 #include "table/table_builder.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"

 namespace rocksdb {
@@ -64,8 +64,7 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,

      for (size_t i = 0; i < sorted_files.size() - 1; i++) {
        if (sstableKeyCompare(ucmp, sorted_files[i]->largest_internal_key,
-                              sorted_files[i + 1]->smallest_internal_key) >=
-            0) {
+                              sorted_files[i + 1]->smallest_internal_key) >= 0) {
          return Status::InvalidArgument("Files have overlapping ranges");
        }
      }
@@ -77,7 +76,8 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
      return Status::InvalidArgument("File contain no entries");
    }

-    if (!f.smallest_internal_key.Valid() || !f.largest_internal_key.Valid()) {
+    if (!f.smallest_internal_key.Valid() ||
+        !f.largest_internal_key.Valid()) {
      return Status::Corruption("File has corrupted keys");
    }
  }
@@ -198,8 +198,8 @@ Status ImportColumnFamilyJob::GetIngestedFileInfo(
  if (!status.ok()) {
    return status;
  }
-  sst_file_reader.reset(
-      new RandomAccessFileReader(std::move(sst_file), external_file));
+  sst_file_reader.reset(new RandomAccessFileReader(std::move(sst_file),
+                                                   external_file));

  status = cfd_->ioptions()->table_factory->NewTableReader(
      TableReaderOptions(*cfd_->ioptions(),
@@ -20,11 +20,11 @@ namespace rocksdb {
 // to ExternalSstFileIngestionJob.
 class ImportColumnFamilyJob {
 public:
-  ImportColumnFamilyJob(Env* env, VersionSet* versions, ColumnFamilyData* cfd,
-                        const ImmutableDBOptions& db_options,
-                        const EnvOptions& env_options,
-                        const ImportColumnFamilyOptions& import_options,
-                        const std::vector<LiveFileMetaData>& metadata)
+  ImportColumnFamilyJob(
+      Env* env, VersionSet* versions, ColumnFamilyData* cfd,
+      const ImmutableDBOptions& db_options, const EnvOptions& env_options,
+      const ImportColumnFamilyOptions& import_options,
+      const std::vector<LiveFileMetaData>& metadata)
      : env_(env),
        versions_(versions),
        cfd_(cfd),
@@ -45,7 +45,8 @@ class ImportColumnFamilyTest : public DBTestBase {
    test::DestroyDir(env_, export_files_dir_);
  }

-  LiveFileMetaData LiveFileMetaDataInit(std::string name, std::string path,
+  LiveFileMetaData LiveFileMetaDataInit(std::string name,
+                                        std::string path,
                                        int level,
                                        SequenceNumber smallest_seqno,
                                        SequenceNumber largest_seqno) {
@@ -63,7 +64,7 @@ class ImportColumnFamilyTest : public DBTestBase {
  std::string export_files_dir_;
  ColumnFamilyHandle* import_cfh_;
  ColumnFamilyHandle* import_cfh2_;
-  ExportImportFilesMetaData* metadata_ptr_;
+  ExportImportFilesMetaData *metadata_ptr_;
 };

 TEST_F(ImportColumnFamilyTest, ImportSSTFileWriterFiles) {
@@ -544,6 +545,7 @@ TEST_F(ImportColumnFamilyTest, ImportColumnFamilyNegativeTest) {
                                                metadata, &import_cfh_));
    ASSERT_NE(import_cfh_, nullptr);
  }
+
 }

 }  // namespace rocksdb
@@ -10,8 +10,8 @@

 #include "db/internal_stats.h"

-#include <algorithm>
 #include <cinttypes>
+#include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
@@ -10,11 +10,10 @@
 #include "db/log_reader.h"

 #include <stdio.h>
-#include "file/sequence_file_reader.h"
 #include "rocksdb/env.h"
-#include "test_util/sync_point.h"
 #include "util/coding.h"
 #include "util/crc32c.h"
+#include "util/file_reader_writer.h"
 #include "util/util.h"

 namespace rocksdb {
@@ -12,12 +12,13 @@
 #include <stdint.h>

 #include "db/log_format.h"
-#include "file/sequence_file_reader.h"
-#include "rocksdb/options.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
+#include "rocksdb/options.h"

 namespace rocksdb {
+
+class SequentialFileReader;
 class Logger;

 namespace log {
@@ -9,13 +9,12 @@

 #include "db/log_reader.h"
 #include "db/log_writer.h"
-#include "file/sequence_file_reader.h"
-#include "file/writable_file_writer.h"
 #include "rocksdb/env.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/coding.h"
 #include "util/crc32c.h"
+#include "util/file_reader_writer.h"
 #include "util/random.h"

 namespace rocksdb {
@@ -10,10 +10,10 @@
 #include "db/log_writer.h"

 #include <stdint.h>
-#include "file/writable_file_writer.h"
 #include "rocksdb/env.h"
 #include "util/coding.h"
 #include "util/crc32c.h"
+#include "util/file_reader_writer.h"

 namespace rocksdb {
 namespace log {
@@ -135,7 +135,7 @@ class MemTable {

  // As a cheap version of `ApproximateMemoryUsage()`, this function doens't
  // require external synchronization. The value may be less accurate though
-  size_t ApproximateMemoryUsageFast() {
+  size_t ApproximateMemoryUsageFast() const {
    return approximate_memory_usage_.load(std::memory_order_relaxed);
  }

@@ -266,7 +266,7 @@ void MemTableListVersion::Remove(MemTable* m,
 }

 // return the total memory usage assuming the oldest flushed memtable is dropped
-size_t MemTableListVersion::ApproximateMemoryUsageExcludingLast() {
+size_t MemTableListVersion::ApproximateMemoryUsageExcludingLast() const {
  size_t total_memtable_size = 0;
  for (auto& memtable : memlist_) {
    total_memtable_size += memtable->ApproximateMemoryUsage();
@@ -480,7 +480,7 @@ Status MemTableList::TryInstallMemtableFlushResults(
                           cfd->GetName().c_str(), m->file_number_, mem_id);
          assert(m->file_number_ > 0);
          current_->Remove(m, to_delete);
-          UpdateMemoryUsageExcludingLast();
+          UpdateCachedValuesFromMemTableListVersion();
          ResetTrimHistoryNeeded();
          ++mem_id;
        }
@@ -521,14 +521,14 @@ void MemTableList::Add(MemTable* m, autovector<MemTable*>* to_delete) {
  if (num_flush_not_started_ == 1) {
    imm_flush_needed.store(true, std::memory_order_release);
  }
-  UpdateMemoryUsageExcludingLast();
+  UpdateCachedValuesFromMemTableListVersion();
  ResetTrimHistoryNeeded();
 }

 void MemTableList::TrimHistory(autovector<MemTable*>* to_delete, size_t usage) {
  InstallNewVersion();
  current_->TrimHistory(to_delete, usage);
-  UpdateMemoryUsageExcludingLast();
+  UpdateCachedValuesFromMemTableListVersion();
  ResetTrimHistoryNeeded();
 }

@@ -543,18 +543,25 @@ size_t MemTableList::ApproximateUnflushedMemTablesMemoryUsage() {

 size_t MemTableList::ApproximateMemoryUsage() { return current_memory_usage_; }

-size_t MemTableList::ApproximateMemoryUsageExcludingLast() {
-  size_t usage =
+size_t MemTableList::ApproximateMemoryUsageExcludingLast() const {
+  const size_t usage =
      current_memory_usage_excluding_last_.load(std::memory_order_relaxed);
  return usage;
 }

-// Update current_memory_usage_excluding_last_, need to call whenever state
-// changes for MemtableListVersion (whenever InstallNewVersion() is called)
-void MemTableList::UpdateMemoryUsageExcludingLast() {
-  size_t total_memtable_size = current_->ApproximateMemoryUsageExcludingLast();
+bool MemTableList::HasHistory() const {
+  const bool has_history = current_has_history_.load(std::memory_order_relaxed);
+  return has_history;
+}
+
+void MemTableList::UpdateCachedValuesFromMemTableListVersion() {
+  const size_t total_memtable_size =
+      current_->ApproximateMemoryUsageExcludingLast();
  current_memory_usage_excluding_last_.store(total_memtable_size,
                                             std::memory_order_relaxed);
+
+  const bool has_history = current_->HasHistory();
+  current_has_history_.store(has_history, std::memory_order_relaxed);
 }

 uint64_t MemTableList::ApproximateOldestKeyTime() const {
@@ -684,7 +691,7 @@ Status InstallMemtableAtomicFlushResults(
                         cfds[i]->GetName().c_str(), m->GetFileNumber(),
                         mem_id);
        imm->current_->Remove(m, to_delete);
-        imm->UpdateMemoryUsageExcludingLast();
+        imm->UpdateCachedValuesFromMemTableListVersion();
        imm->ResetTrimHistoryNeeded();
      }
    }
@@ -727,7 +734,8 @@ void MemTableList::RemoveOldMemTables(uint64_t log_number,
      imm_flush_needed.store(false, std::memory_order_release);
    }
  }
-  UpdateMemoryUsageExcludingLast();
+
+  UpdateCachedValuesFromMemTableListVersion();
  ResetTrimHistoryNeeded();
 }

@@ -157,7 +157,11 @@ class MemTableListVersion {
  // excluding the last MemTable in memlist_history_. The reason for excluding
  // the last MemTable is to see if dropping the last MemTable will keep total
  // memory usage above or equal to max_write_buffer_size_to_maintain_
-  size_t ApproximateMemoryUsageExcludingLast();
+  size_t ApproximateMemoryUsageExcludingLast() const;
+
+  // Whether this version contains flushed memtables that are only kept around
+  // for transaction conflict checking.
+  bool HasHistory() const { return !memlist_history_.empty(); }

  bool MemtableLimitExceeded(size_t usage);

@@ -206,7 +210,8 @@ class MemTableList {
        commit_in_progress_(false),
        flush_requested_(false),
        current_memory_usage_(0),
-        current_memory_usage_excluding_last_(0) {
+        current_memory_usage_excluding_last_(0),
+        current_has_history_(false) {
    current_->Ref();
  }

@@ -260,11 +265,16 @@ class MemTableList {
  // Returns an estimate of the number of bytes of data in use.
  size_t ApproximateMemoryUsage();

-  // Returns the cached current_memory_usage_excluding_last_ value
-  size_t ApproximateMemoryUsageExcludingLast();
+  // Returns the cached current_memory_usage_excluding_last_ value.
+  size_t ApproximateMemoryUsageExcludingLast() const;

-  // Update current_memory_usage_excluding_last_ from MemtableListVersion
-  void UpdateMemoryUsageExcludingLast();
+  // Returns the cached current_has_history_ value.
+  bool HasHistory() const;
+
+  // Updates current_memory_usage_excluding_last_ and current_has_history_
+  // from MemTableListVersion. Must be called whenever InstallNewVersion is
+  // called.
+  void UpdateCachedValuesFromMemTableListVersion();

  // `usage` is the current size of the mutable Memtable. When
  // max_write_buffer_size_to_maintain is used, total size of mutable and
@@ -382,7 +392,11 @@ class MemTableList {
  // The current memory usage.
  size_t current_memory_usage_;

+  // Cached value of current_->ApproximateMemoryUsageExcludingLast().
  std::atomic<size_t> current_memory_usage_excluding_last_;
+
+  // Cached value of current_->HasHistory().
+  std::atomic<bool> current_has_history_;
 };

 // Installs memtable atomic flush results.
@@ -14,11 +14,9 @@
 #include <string>
 #include <vector>
 #include "db/db_impl/db_impl.h"
-#include "db/db_test_util.h"
 #include "db/version_set.h"
 #include "db/write_batch_internal.h"
 #include "file/filename.h"
-#include "port/stack_trace.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/transaction_log.h"
@@ -34,10 +32,60 @@ using std::flush;

 namespace rocksdb {

-class ObsoleteFilesTest : public DBTestBase {
+class ObsoleteFilesTest : public testing::Test {
 public:
-  ObsoleteFilesTest()
-      : DBTestBase("/obsolete_files_test"), wal_dir_(dbname_ + "/wal_files") {}
+  std::string dbname_;
+  Options options_;
+  DB* db_;
+  Env* env_;
+  int numlevels_;
+
+  ObsoleteFilesTest() {
+    db_ = nullptr;
+    env_ = Env::Default();
+    // Trigger compaction when the number of level 0 files reaches 2.
+    options_.level0_file_num_compaction_trigger = 2;
+    options_.disable_auto_compactions = false;
+    options_.delete_obsolete_files_period_micros = 0;  // always do full purge
+    options_.enable_thread_tracking = true;
+    options_.write_buffer_size = 1024*1024*1000;
+    options_.target_file_size_base = 1024*1024*1000;
+    options_.max_bytes_for_level_base = 1024*1024*1000;
+    options_.WAL_ttl_seconds = 300; // Used to test log files
+    options_.WAL_size_limit_MB = 1024; // Used to test log files
+    dbname_ = test::PerThreadDBPath("obsolete_files_test");
+    options_.wal_dir = dbname_ + "/wal_files";
+
+    // clean up all the files that might have been there before
+    std::vector<std::string> old_files;
+    env_->GetChildren(dbname_, &old_files);
+    for (auto file : old_files) {
+      env_->DeleteFile(dbname_ + "/" + file);
+    }
+    env_->GetChildren(options_.wal_dir, &old_files);
+    for (auto file : old_files) {
+      env_->DeleteFile(options_.wal_dir + "/" + file);
+    }
+
+    DestroyDB(dbname_, options_);
+    numlevels_ = 7;
+    EXPECT_OK(ReopenDB(true));
+  }
+
+  Status ReopenDB(bool create) {
+    delete db_;
+    if (create) {
+      DestroyDB(dbname_, options_);
+    }
+    db_ = nullptr;
+    options_.create_if_missing = create;
+    return DB::Open(options_, dbname_, &db_);
+  }
+
+  void CloseDB() {
+    delete db_;
+    db_ = nullptr;
+  }

  void AddKeys(int numkeys, int startkey) {
    WriteOptions options;
@@ -50,24 +98,50 @@ class ObsoleteFilesTest : public DBTestBase {
    }
  }

+  int numKeysInLevels(
+    std::vector<LiveFileMetaData> &metadata,
+    std::vector<int> *keysperlevel = nullptr) {
+
+    if (keysperlevel != nullptr) {
+      keysperlevel->resize(numlevels_);
+    }
+
+    int numKeys = 0;
+    for (size_t i = 0; i < metadata.size(); i++) {
+      int startkey = atoi(metadata[i].smallestkey.c_str());
+      int endkey = atoi(metadata[i].largestkey.c_str());
+      int numkeysinfile = (endkey - startkey + 1);
+      numKeys += numkeysinfile;
+      if (keysperlevel != nullptr) {
+        (*keysperlevel)[(int)metadata[i].level] += numkeysinfile;
+      }
+      fprintf(stderr, "level %d name %s smallest %s largest %s\n",
+              metadata[i].level, metadata[i].name.c_str(),
+              metadata[i].smallestkey.c_str(),
+              metadata[i].largestkey.c_str());
+    }
+    return numKeys;
+  }
+
  void createLevel0Files(int numFiles, int numKeysPerFile) {
    int startKey = 0;
+    DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
    for (int i = 0; i < numFiles; i++) {
      AddKeys(numKeysPerFile, startKey);
      startKey += numKeysPerFile;
-      ASSERT_OK(dbfull()->TEST_FlushMemTable());
-      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+      ASSERT_OK(dbi->TEST_FlushMemTable());
+      ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
    }
  }

-  void CheckFileTypeCounts(const std::string& dir, int required_log,
-                           int required_sst, int required_manifest) {
+  void CheckFileTypeCounts(std::string& dir,
+                            int required_log,
+                            int required_sst,
+                            int required_manifest) {
    std::vector<std::string> filenames;
    env_->GetChildren(dir, &filenames);

-    int log_cnt = 0;
-    int sst_cnt = 0;
-    int manifest_cnt = 0;
+    int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
    for (auto file : filenames) {
      uint64_t number;
      FileType type;
@@ -81,31 +155,9 @@ class ObsoleteFilesTest : public DBTestBase {
    ASSERT_EQ(required_sst, sst_cnt);
    ASSERT_EQ(required_manifest, manifest_cnt);
  }
-
-  void ReopenDB() {
-    Options options = CurrentOptions();
-    // Trigger compaction when the number of level 0 files reaches 2.
-    options.create_if_missing = true;
-    options.level0_file_num_compaction_trigger = 2;
-    options.disable_auto_compactions = false;
-    options.delete_obsolete_files_period_micros = 0;  // always do full purge
-    options.enable_thread_tracking = true;
-    options.write_buffer_size = 1024 * 1024 * 1000;
-    options.target_file_size_base = 1024 * 1024 * 1000;
-    options.max_bytes_for_level_base = 1024 * 1024 * 1000;
-    options.WAL_ttl_seconds = 300;     // Used to test log files
-    options.WAL_size_limit_MB = 1024;  // Used to test log files
-    options.wal_dir = wal_dir_;
-    Destroy(options);
-    Reopen(options);
-  }
-
-  const std::string wal_dir_;
 };

 TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
-  ReopenDB();
-  SyncPoint::GetInstance()->DisableProcessing();
  SyncPoint::GetInstance()->LoadDependency({
      {"DBImpl::BackgroundCallCompaction:FoundObsoleteFiles",
       "ObsoleteFilesTest::RaceForObsoleteFileDeletion:1"},
@@ -119,33 +171,35 @@ TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
      });
  SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::CloseHelper:PendingPurgeFinished", [&](void* arg) {
-        std::unordered_set<uint64_t>* files_grabbed_for_purge_ptr =
-            reinterpret_cast<std::unordered_set<uint64_t>*>(arg);
+        std::vector<uint64_t>* files_grabbed_for_purge_ptr =
+            reinterpret_cast<std::vector<uint64_t>*>(arg);
        ASSERT_TRUE(files_grabbed_for_purge_ptr->empty());
      });
  SyncPoint::GetInstance()->EnableProcessing();

  createLevel0Files(2, 50000);
-  CheckFileTypeCounts(wal_dir_, 1, 0, 0);
+  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);

-  port::Thread user_thread([this]() {
+  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
+  port::Thread user_thread([&]() {
    JobContext jobCxt(0);
    TEST_SYNC_POINT("ObsoleteFilesTest::RaceForObsoleteFileDeletion:1");
-    dbfull()->TEST_LockMutex();
-    dbfull()->FindObsoleteFiles(&jobCxt, true /* force=true */,
-                                false /* no_full_scan=false */);
-    dbfull()->TEST_UnlockMutex();
+    dbi->TEST_LockMutex();
+    dbi->FindObsoleteFiles(&jobCxt,
+      true /* force=true */, false /* no_full_scan=false */);
+    dbi->TEST_UnlockMutex();
    TEST_SYNC_POINT("ObsoleteFilesTest::RaceForObsoleteFileDeletion:2");
-    dbfull()->PurgeObsoleteFiles(jobCxt);
+    dbi->PurgeObsoleteFiles(jobCxt);
    jobCxt.Clean();
  });

  user_thread.join();
+
+  CloseDB();
+  SyncPoint::GetInstance()->DisableProcessing();
 }

 TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
-  ReopenDB();
-  SyncPoint::GetInstance()->DisableProcessing();
  std::vector<uint64_t> optsfiles_nums;
  std::vector<bool> optsfiles_keep;
  SyncPoint::GetInstance()->SetCallBack(
@@ -159,22 +213,23 @@ TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
  SyncPoint::GetInstance()->EnableProcessing();

  createLevel0Files(2, 50000);
-  CheckFileTypeCounts(wal_dir_, 1, 0, 0);
+  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);

-  ASSERT_OK(dbfull()->DisableFileDeletions());
+  DBImpl* dbi = static_cast<DBImpl*>(db_);
+  ASSERT_OK(dbi->DisableFileDeletions());
  for (int i = 0; i != 4; ++i) {
    if (i % 2) {
-      ASSERT_OK(dbfull()->SetOptions(dbfull()->DefaultColumnFamily(),
-                                     {{"paranoid_file_checks", "false"}}));
+      ASSERT_OK(dbi->SetOptions(dbi->DefaultColumnFamily(),
+                                {{"paranoid_file_checks", "false"}}));
    } else {
-      ASSERT_OK(dbfull()->SetOptions(dbfull()->DefaultColumnFamily(),
-                                     {{"paranoid_file_checks", "true"}}));
+      ASSERT_OK(dbi->SetOptions(dbi->DefaultColumnFamily(),
+                                {{"paranoid_file_checks", "true"}}));
    }
  }
-  ASSERT_OK(dbfull()->EnableFileDeletions(true /* force */));
+  ASSERT_OK(dbi->EnableFileDeletions(true /* force */));
  ASSERT_EQ(optsfiles_nums.size(), optsfiles_keep.size());

-  Close();
+  CloseDB();

  std::vector<std::string> files;
  int opts_file_count = 0;
@@ -191,22 +246,13 @@ TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
    }
  }
  ASSERT_EQ(2, opts_file_count);
+  SyncPoint::GetInstance()->DisableProcessing();
 }

 } //namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }

@@ -745,19 +745,20 @@ TEST_P(PlainTableDBTest, BloomSchema) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  for (int bloom_locality = 0; bloom_locality <= 1; bloom_locality++) {
-    options.bloom_locality = bloom_locality;
+   options.bloom_locality = bloom_locality;
    PlainTableOptions plain_table_options;
    plain_table_options.user_key_len = 16;
-    plain_table_options.bloom_bits_per_key = 3;  // high FP rate for test
+    plain_table_options.bloom_bits_per_key = 3; // high FP rate for test
    plain_table_options.hash_table_ratio = 0.75;
    plain_table_options.index_sparseness = 16;
    plain_table_options.huge_page_tlb_size = 0;
    plain_table_options.encoding_type = kPlain;

+
    bool expect_bloom_not_match = false;
    options.table_factory.reset(new TestPlainTableFactory(
-        &expect_bloom_not_match, plain_table_options, 0 /* column_family_id */,
-        kDefaultColumnFamilyName));
+        &expect_bloom_not_match, plain_table_options,
+        0 /* column_family_id */, kDefaultColumnFamilyName));
    DestroyAndReopen(&options);

    for (unsigned i = 0; i < 2345; ++i) {
@@ -781,7 +782,7 @@ TEST_P(PlainTableDBTest, BloomSchema) {
        pattern = 163905UL;
      }
      bool expect_fp = pattern & (1UL << i);
-      // fprintf(stderr, "expect_fp@%u: %d\n", i, (int)expect_fp);
+      //fprintf(stderr, "expect_fp@%u: %d\n", i, (int)expect_fp);
      expect_bloom_not_match = !expect_fp;
      ASSERT_EQ("NOT_FOUND", Get(NthKey(i, 'n')));
    }
@@ -9,8 +9,8 @@
 #include <functional>
 #include <set>

-#include <stdio.h>
 #include <cinttypes>
+#include <stdio.h>

 #include "util/autovector.h"
 #include "util/kv_map.h"
@@ -71,7 +71,6 @@
 #include "db/version_edit.h"
 #include "db/write_batch_internal.h"
 #include "file/filename.h"
-#include "file/writable_file_writer.h"
 #include "options/cf_options.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
@@ -79,6 +78,7 @@
 #include "rocksdb/options.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/scoped_arena_iterator.h"
+#include "util/file_reader_writer.h"
 #include "util/string_util.h"

 namespace rocksdb {
@@ -14,7 +14,7 @@
 #include "db/snapshot_impl.h"
 #include "db/version_edit.h"
 #include "file/filename.h"
-#include "file/random_access_file_reader.h"
+
 #include "monitoring/perf_context_imp.h"
 #include "rocksdb/statistics.h"
 #include "table/block_based/block_based_table_reader.h"
@@ -27,6 +27,7 @@
 #include "test_util/sync_point.h"
 #include "util/cast_util.h"
 #include "util/coding.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"

 namespace rocksdb {
@@ -277,11 +278,10 @@ Status TableCache::GetRangeTombstoneIterator(
 }

 #ifndef ROCKSDB_LITE
-void TableCache::CreateRowCacheKeyPrefix(const ReadOptions& options,
-                                         const FileDescriptor& fd,
-                                         const Slice& internal_key,
-                                         GetContext* get_context,
-                                         IterKey& row_cache_key) {
+void TableCache::CreateRowCacheKeyPrefix(
+        const ReadOptions& options,
+        const FileDescriptor& fd, const Slice& internal_key,
+        GetContext* get_context, IterKey& row_cache_key) {
  uint64_t fd_number = fd.GetNumber();
  // We use the user key as cache key instead of the internal key,
  // otherwise the whole cache would be invalidated every time the
@@ -313,11 +313,13 @@ void TableCache::CreateRowCacheKeyPrefix(const ReadOptions& options,
  AppendVarint64(&row_cache_key, seq_no);
 }

-bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
-                                 size_t prefix_size, GetContext* get_context) {
+bool TableCache::GetFromRowCache(
+          const Slice& user_key, IterKey& row_cache_key,
+          size_t prefix_size, GetContext* get_context) {
  bool found = false;

-  row_cache_key.TrimAppend(prefix_size, user_key.data(), user_key.size());
+  row_cache_key.TrimAppend(prefix_size, user_key.data(),
+                           user_key.size());
  if (auto row_handle =
          ioptions_.row_cache->Lookup(row_cache_key.GetUserKey())) {
    // Cleanable routine to release the cache entry
@@ -326,8 +328,8 @@ bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
                                       void* cache_handle) {
      ((Cache*)cache_to_clean)->Release((Cache::Handle*)cache_handle);
    };
-    auto found_row_cache_entry =
-        static_cast<const std::string*>(ioptions_.row_cache->Value(row_handle));
+    auto found_row_cache_entry = static_cast<const std::string*>(
+        ioptions_.row_cache->Value(row_handle));
    // If it comes here value is located on the cache.
    // found_row_cache_entry points to the value on cache,
    // and value_pinner has cleanup procedure for the cached entry.
@@ -441,15 +443,14 @@ Status TableCache::MultiGet(const ReadOptions& options,
  Status s;
  TableReader* t = fd.table_reader;
  Cache::Handle* handle = nullptr;
-  MultiGetRange table_range(*mget_range, mget_range->begin(),
-                            mget_range->end());
+  MultiGetRange table_range(*mget_range, mget_range->begin(), mget_range->end());
 #ifndef ROCKSDB_LITE
  autovector<std::string, MultiGetContext::MAX_BATCH_SIZE> row_cache_entries;
  IterKey row_cache_key;
  size_t row_cache_key_prefix_size = 0;
  KeyContext& first_key = *table_range.begin();
-  bool lookup_row_cache =
-      ioptions_.row_cache && !first_key.get_context->NeedToReadSequence();
+  bool lookup_row_cache = ioptions_.row_cache &&
+          !first_key.get_context->NeedToReadSequence();

  // Check row cache if enabled. Since row cache does not currently store
  // sequence numbers, we cannot use it if we need to fetch the sequence.
@@ -459,10 +460,8 @@ Status TableCache::MultiGet(const ReadOptions& options,
                            row_cache_key);
    row_cache_key_prefix_size = row_cache_key.Size();

-    for (auto miter = table_range.begin(); miter != table_range.end();
-         ++miter) {
-      const Slice& user_key = miter->ukey;
-      ;
+    for (auto miter = table_range.begin(); miter != table_range.end(); ++miter) {
+      const Slice& user_key = miter->ukey;;
      GetContext* get_context = miter->get_context;

      if (GetFromRowCache(user_key, row_cache_key, row_cache_key_prefix_size,
@@ -521,11 +520,9 @@ Status TableCache::MultiGet(const ReadOptions& options,
  if (lookup_row_cache) {
    size_t row_idx = 0;

-    for (auto miter = table_range.begin(); miter != table_range.end();
-         ++miter) {
+    for (auto miter = table_range.begin(); miter != table_range.end(); ++miter) {
      std::string& row_cache_entry = row_cache_entries[row_idx++];
-      const Slice& user_key = miter->ukey;
-      ;
+      const Slice& user_key = miter->ukey;;
      GetContext* get_context = miter->get_context;

      get_context->SetReplayLog(nullptr);
@@ -208,7 +208,8 @@ class TableCache {
  void CreateRowCacheKeyPrefix(const ReadOptions& options,
                               const FileDescriptor& fd,
                               const Slice& internal_key,
-                               GetContext* get_context, IterKey& row_cache_key);
+                               GetContext* get_context,
+                               IterKey& row_cache_key);

  // Helper function to lookup the row cache for a key. It appends the
  // user key to row_cache_key at offset prefix_size
@@ -9,11 +9,10 @@
 #include <utility>
 #include <vector>

-#include "db/db_impl/db_impl.h"
 #include "db/dbformat.h"
 #include "db/table_properties_collector.h"
-#include "file/sequence_file_reader.h"
-#include "file/writable_file_writer.h"
+
+#include "db/db_impl/db_impl.h"
 #include "options/cf_options.h"
 #include "rocksdb/table.h"
 #include "table/block_based/block_based_table_factory.h"
@@ -23,6 +22,7 @@
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/coding.h"
+#include "util/file_reader_writer.h"

 namespace rocksdb {

@@ -8,7 +8,7 @@
 #include "db/transaction_log_impl.h"
 #include <cinttypes>
 #include "db/write_batch_internal.h"
-#include "file/sequence_file_reader.h"
+#include "util/file_reader_writer.h"

 namespace rocksdb {

@@ -9,9 +9,9 @@

 #include "db/version_builder.h"

+#include <cinttypes>
 #include <algorithm>
 #include <atomic>
-#include <cinttypes>
 #include <functional>
 #include <map>
 #include <set>
@@ -173,13 +173,14 @@ class VersionBuilder::Rep {
                      " vs. file with global_seqno %" PRIu64 "\n",
                      f1->fd.smallest_seqno, f1->fd.largest_seqno,
                      external_file_seqno);
-              return Status::Corruption(
-                  "L0 file with seqno " +
-                  NumberToString(f1->fd.smallest_seqno) + " " +
-                  NumberToString(f1->fd.largest_seqno) +
-                  " vs. file with global_seqno" +
-                  NumberToString(external_file_seqno) + " with fileNumber " +
-                  NumberToString(f1->fd.GetNumber()));
+              return Status::Corruption("L0 file with seqno " +
+                                        NumberToString(f1->fd.smallest_seqno) +
+                                        " " +
+                                        NumberToString(f1->fd.largest_seqno) +
+                                        " vs. file with global_seqno" +
+                                        NumberToString(external_file_seqno) +
+                                        " with fileNumber " +
+                                        NumberToString(f1->fd.GetNumber()));
            }
          } else if (f1->fd.smallest_seqno <= f2->fd.smallest_seqno) {
            fprintf(stderr,
@@ -52,7 +52,7 @@ struct FileDescriptor {
        smallest_seqno(_smallest_seqno),
        largest_seqno(_largest_seqno) {}

-  FileDescriptor(const FileDescriptor& fd) { *this = fd; }
+  FileDescriptor(const FileDescriptor& fd) { *this=fd; }

  FileDescriptor& operator=(const FileDescriptor& fd) {
    table_reader = fd.table_reader;
@@ -191,10 +191,6 @@ struct LevelFilesBrief {
  }
 };

-// The state of a DB at any given time is referred to as a Version.
-// Any modification to the Version is considered a Version Edit. A Version is
-// constructed by joining a sequence of Version Edits. Version Edits are written
-// to the MANIFEST file.
 class VersionEdit {
 public:
  VersionEdit() { Clear(); }
@@ -30,9 +30,6 @@
 #include "db/table_cache.h"
 #include "db/version_builder.h"
 #include "file/filename.h"
-#include "file/random_access_file_reader.h"
-#include "file/read_write_util.h"
-#include "file/writable_file_writer.h"
 #include "monitoring/file_read_sample.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/persistent_stats_history.h"
@@ -50,6 +47,7 @@
 #include "table/two_level_iterator.h"
 #include "test_util/sync_point.h"
 #include "util/coding.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"
 #include "util/string_util.h"
 #include "util/user_comparator_wrapper.h"
@@ -5726,8 +5724,7 @@ Status ReactiveVersionSet::ApplyOneVersionEditToBuilder(
    return Status::OK();
  }
  if (active_version_builders_.find(edit.column_family_) ==
-          active_version_builders_.end() &&
-      !cfd->IsDropped()) {
+      active_version_builders_.end() && !cfd->IsDropped()) {
    std::unique_ptr<BaseReferencedVersionBuilder> builder_guard(
        new BaseReferencedVersionBuilder(cfd));
    active_version_builders_.insert(
@@ -9,10 +9,10 @@

 #include "db/wal_manager.h"

-#include <algorithm>
 #include <cinttypes>
-#include <memory>
+#include <algorithm>
 #include <vector>
+#include <memory>

 #include "db/log_reader.h"
 #include "db/log_writer.h"
@@ -20,7 +20,6 @@
 #include "db/write_batch_internal.h"
 #include "file/file_util.h"
 #include "file/filename.h"
-#include "file/sequence_file_reader.h"
 #include "logging/logging.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
@@ -29,6 +28,7 @@
 #include "test_util/sync_point.h"
 #include "util/cast_util.h"
 #include "util/coding.h"
+#include "util/file_reader_writer.h"
 #include "util/mutexlock.h"
 #include "util/string_util.h"

@@ -415,13 +415,12 @@ Status WalManager::ReadFirstRecord(const WalFileType type,
  return s;
 }

-Status WalManager::GetLiveWalFile(uint64_t number,
-                                  std::unique_ptr<LogFile>* log_file) {
+Status WalManager::GetLiveWalFile(uint64_t number, std::unique_ptr<LogFile>* log_file) {
  if (!log_file) {
    return Status::InvalidArgument("log_file not preallocated.");
  }

-  if (!number) {
+  if(!number) {
    return Status::PathNotFound("log file not available");
  }

@@ -434,13 +433,16 @@ Status WalManager::GetLiveWalFile(uint64_t number,
    return s;
  }

-  log_file->reset(new LogFileImpl(number, kAliveLogFile,
-                                  0,  // SequenceNumber
-                                  size_bytes));
+  log_file->reset(new LogFileImpl(
+      number,
+      kAliveLogFile,
+      0,      // SequenceNumber
+      size_bytes));

  return Status::OK();
 }

+
 // the function returns status.ok() and sequence == 0 if the file exists, but is
 // empty
 Status WalManager::ReadFirstLine(const std::string& fname,
@@ -18,10 +18,10 @@
 #include "db/version_set.h"
 #include "db/wal_manager.h"
 #include "env/mock_env.h"
-#include "file/writable_file_writer.h"
 #include "table/mock_table.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
+#include "util/file_reader_writer.h"
 #include "util/string_util.h"

 namespace rocksdb {
@@ -293,7 +293,7 @@ TEST_F(WalManagerTest, TransactionLogIteratorJustEmptyFile) {
  // Check that an empty iterator is returned
  ASSERT_TRUE(!iter->Valid());
 }
-
+  
 TEST_F(WalManagerTest, TransactionLogIteratorNewFileWhileScanning) {
  Init();
  CreateArchiveLogs(2, 100);
@@ -307,7 +307,7 @@ TEST_F(WalManagerTest, TransactionLogIteratorNewFileWhileScanning) {
  // A new log file was added after the iterator was created.
  // TryAgain indicates a new iterator is needed to fetch the new data
  ASSERT_TRUE(iter->status().IsTryAgain());
-
+  
  iter = OpenTransactionLogIter(0);
  i = 0;
  for (; iter->Valid(); iter->Next()) {
@@ -334,7 +334,9 @@ void WriteBatch::Clear() {
  wal_term_point_.clear();
 }

-uint32_t WriteBatch::Count() const { return WriteBatchInternal::Count(this); }
+uint32_t WriteBatch::Count() const {
+  return WriteBatchInternal::Count(this);
+}

 uint32_t WriteBatch::ComputeContentFlags() const {
  auto rv = content_flags_.load(std::memory_order_relaxed);
@@ -1784,14 +1786,28 @@ class MemTableInserter : public WriteBatch::Handler {
    // check if memtable_list size exceeds max_write_buffer_size_to_maintain
    if (trim_history_scheduler_ != nullptr) {
      auto* cfd = cf_mems_->current();
-      assert(cfd != nullptr);
-      if (cfd->ioptions()->max_write_buffer_size_to_maintain > 0 &&
-          cfd->mem()->ApproximateMemoryUsageFast() +
-                  cfd->imm()->ApproximateMemoryUsageExcludingLast() >=
-              static_cast<size_t>(
-                  cfd->ioptions()->max_write_buffer_size_to_maintain) &&
-          cfd->imm()->MarkTrimHistoryNeeded()) {
-        trim_history_scheduler_->ScheduleWork(cfd);
+
+      assert(cfd);
+      assert(cfd->ioptions());
+
+      const size_t size_to_maintain = static_cast<size_t>(
+          cfd->ioptions()->max_write_buffer_size_to_maintain);
+
+      if (size_to_maintain > 0) {
+        MemTableList* const imm = cfd->imm();
+        assert(imm);
+
+        if (imm->HasHistory()) {
+          const MemTable* const mem = cfd->mem();
+          assert(mem);
+
+          if (mem->ApproximateMemoryUsageFast() +
+                      imm->ApproximateMemoryUsageExcludingLast() >=
+                  size_to_maintain &&
+              imm->MarkTrimHistoryNeeded()) {
+            trim_history_scheduler_->ScheduleWork(cfd);
+          }
+        }
      }
    }
  }
@@ -11,6 +11,13 @@
 #include <sys/ioctl.h>
 #endif

+#ifdef ROCKSDB_MALLOC_USABLE_SIZE
+#ifdef OS_FREEBSD
+#include <malloc_np.h>
+#else
+#include <malloc.h>
+#endif
+#endif
 #include <sys/types.h>

 #include <iostream>
@@ -32,7 +39,6 @@

 #include "env/env_chroot.h"
 #include "logging/log_buffer.h"
-#include "port/malloc.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
 #include "test_util/sync_point.h"
@@ -1110,8 +1116,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) {
  // Create file.
  {
    std::unique_ptr<WritableFile> wfile;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && \
-    !defined(OS_AIX)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX)
    if (soptions.use_direct_writes) {
      soptions.use_direct_writes = false;
    }
@@ -1138,8 +1143,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) {
      data.emplace_back(NewAligned(kSectorSize, 0));
      reqs[i].scratch = data.back().get();
    }
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && \
-    !defined(OS_AIX)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX)
    if (soptions.use_direct_reads) {
      soptions.use_direct_reads = false;
    }
@@ -1147,7 +1151,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) {
    ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions));
    ASSERT_OK(file->MultiRead(reqs.data(), reqs.size()));
    for (size_t i = 0; i < reqs.size(); ++i) {
-      auto buf = NewAligned(kSectorSize * 8, static_cast<char>(i * 2 + 1));
+      auto buf = NewAligned(kSectorSize * 8, static_cast<char>(i*2 + 1));
      ASSERT_OK(reqs[i].status);
      ASSERT_EQ(memcmp(reqs[i].scratch, buf.get(), kSectorSize), 0);
    }
@@ -14,8 +14,8 @@
 // run for a while, tailing the logs of the primary. After process with primary
 // instance exits, this process will keep running until you hit 'CTRL+C'.

-#include <chrono>
 #include <cinttypes>
+#include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
@@ -3,8 +3,8 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

-#include <atomic>
 #include <cinttypes>
+#include <atomic>
 #include <thread>
 #include <vector>

@@ -1,133 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "file/file_prefetch_buffer.h"
-
-#include <algorithm>
-#include <mutex>
-
-#include "file/random_access_file_reader.h"
-#include "monitoring/histogram.h"
-#include "monitoring/iostats_context_imp.h"
-#include "port/port.h"
-#include "test_util/sync_point.h"
-#include "util/random.h"
-#include "util/rate_limiter.h"
-
-namespace rocksdb {
-Status FilePrefetchBuffer::Prefetch(RandomAccessFileReader* reader,
-                                    uint64_t offset, size_t n,
-                                    bool for_compaction) {
-  size_t alignment = reader->file()->GetRequiredBufferAlignment();
-  size_t offset_ = static_cast<size_t>(offset);
-  uint64_t rounddown_offset = Rounddown(offset_, alignment);
-  uint64_t roundup_end = Roundup(offset_ + n, alignment);
-  uint64_t roundup_len = roundup_end - rounddown_offset;
-  assert(roundup_len >= alignment);
-  assert(roundup_len % alignment == 0);
-
-  // Check if requested bytes are in the existing buffer_.
-  // If all bytes exist -- return.
-  // If only a few bytes exist -- reuse them & read only what is really needed.
-  //     This is typically the case of incremental reading of data.
-  // If no bytes exist in buffer -- full pread.
-
-  Status s;
-  uint64_t chunk_offset_in_buffer = 0;
-  uint64_t chunk_len = 0;
-  bool copy_data_to_new_buffer = false;
-  if (buffer_.CurrentSize() > 0 && offset >= buffer_offset_ &&
-      offset <= buffer_offset_ + buffer_.CurrentSize()) {
-    if (offset + n <= buffer_offset_ + buffer_.CurrentSize()) {
-      // All requested bytes are already in the buffer. So no need to Read
-      // again.
-      return s;
-    } else {
-      // Only a few requested bytes are in the buffer. memmove those chunk of
-      // bytes to the beginning, and memcpy them back into the new buffer if a
-      // new buffer is created.
-      chunk_offset_in_buffer =
-          Rounddown(static_cast<size_t>(offset - buffer_offset_), alignment);
-      chunk_len = buffer_.CurrentSize() - chunk_offset_in_buffer;
-      assert(chunk_offset_in_buffer % alignment == 0);
-      assert(chunk_len % alignment == 0);
-      assert(chunk_offset_in_buffer + chunk_len <=
-             buffer_offset_ + buffer_.CurrentSize());
-      if (chunk_len > 0) {
-        copy_data_to_new_buffer = true;
-      } else {
-        // this reset is not necessary, but just to be safe.
-        chunk_offset_in_buffer = 0;
-      }
-    }
-  }
-
-  // Create a new buffer only if current capacity is not sufficient, and memcopy
-  // bytes from old buffer if needed (i.e., if chunk_len is greater than 0).
-  if (buffer_.Capacity() < roundup_len) {
-    buffer_.Alignment(alignment);
-    buffer_.AllocateNewBuffer(static_cast<size_t>(roundup_len),
-                              copy_data_to_new_buffer, chunk_offset_in_buffer,
-                              static_cast<size_t>(chunk_len));
-  } else if (chunk_len > 0) {
-    // New buffer not needed. But memmove bytes from tail to the beginning since
-    // chunk_len is greater than 0.
-    buffer_.RefitTail(static_cast<size_t>(chunk_offset_in_buffer),
-                      static_cast<size_t>(chunk_len));
-  }
-
-  Slice result;
-  s = reader->Read(rounddown_offset + chunk_len,
-                   static_cast<size_t>(roundup_len - chunk_len), &result,
-                   buffer_.BufferStart() + chunk_len, for_compaction);
-  if (s.ok()) {
-    buffer_offset_ = rounddown_offset;
-    buffer_.Size(static_cast<size_t>(chunk_len) + result.size());
-  }
-  return s;
-}
-
-bool FilePrefetchBuffer::TryReadFromCache(uint64_t offset, size_t n,
-                                          Slice* result, bool for_compaction) {
-  if (track_min_offset_ && offset < min_offset_read_) {
-    min_offset_read_ = static_cast<size_t>(offset);
-  }
-  if (!enable_ || offset < buffer_offset_) {
-    return false;
-  }
-
-  // If the buffer contains only a few of the requested bytes:
-  //    If readahead is enabled: prefetch the remaining bytes + readadhead bytes
-  //        and satisfy the request.
-  //    If readahead is not enabled: return false.
-  if (offset + n > buffer_offset_ + buffer_.CurrentSize()) {
-    if (readahead_size_ > 0) {
-      assert(file_reader_ != nullptr);
-      assert(max_readahead_size_ >= readahead_size_);
-      Status s;
-      if (for_compaction) {
-        s = Prefetch(file_reader_, offset, std::max(n, readahead_size_),
-                     for_compaction);
-      } else {
-        s = Prefetch(file_reader_, offset, n + readahead_size_, for_compaction);
-      }
-      if (!s.ok()) {
-        return false;
-      }
-      readahead_size_ = std::min(max_readahead_size_, readahead_size_ * 2);
-    } else {
-      return false;
-    }
-  }
-
-  uint64_t offset_in_buffer = offset - buffer_offset_;
-  *result = Slice(buffer_.BufferStart() + offset_in_buffer, n);
-  return true;
-}
-}  // namespace rocksdb
@@ -1,97 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <atomic>
-#include <sstream>
-#include <string>
-#include "file/random_access_file_reader.h"
-#include "port/port.h"
-#include "rocksdb/env.h"
-#include "util/aligned_buffer.h"
-
-namespace rocksdb {
-
-// FilePrefetchBuffer is a smart buffer to store and read data from a file.
-class FilePrefetchBuffer {
- public:
-  // Constructor.
-  //
-  // All arguments are optional.
-  // file_reader        : the file reader to use. Can be a nullptr.
-  // readahead_size     : the initial readahead size.
-  // max_readahead_size : the maximum readahead size.
-  //   If max_readahead_size > readahead_size, the readahead size will be
-  //   doubled on every IO until max_readahead_size is hit.
-  //   Typically this is set as a multiple of readahead_size.
-  //   max_readahead_size should be greater than equal to readahead_size.
-  // enable : controls whether reading from the buffer is enabled.
-  //   If false, TryReadFromCache() always return false, and we only take stats
-  //   for the minimum offset if track_min_offset = true.
-  // track_min_offset : Track the minimum offset ever read and collect stats on
-  //   it. Used for adaptable readahead of the file footer/metadata.
-  //
-  // Automatic readhead is enabled for a file if file_reader, readahead_size,
-  // and max_readahead_size are passed in.
-  // If file_reader is a nullptr, setting readadhead_size and max_readahead_size
-  // does not make any sense. So it does nothing.
-  // A user can construct a FilePrefetchBuffer without any arguments, but use
-  // `Prefetch` to load data into the buffer.
-  FilePrefetchBuffer(RandomAccessFileReader* file_reader = nullptr,
-                     size_t readadhead_size = 0, size_t max_readahead_size = 0,
-                     bool enable = true, bool track_min_offset = false)
-      : buffer_offset_(0),
-        file_reader_(file_reader),
-        readahead_size_(readadhead_size),
-        max_readahead_size_(max_readahead_size),
-        min_offset_read_(port::kMaxSizet),
-        enable_(enable),
-        track_min_offset_(track_min_offset) {}
-
-  // Load data into the buffer from a file.
-  // reader : the file reader.
-  // offset : the file offset to start reading from.
-  // n      : the number of bytes to read.
-  // for_compaction : if prefetch is done for compaction read.
-  Status Prefetch(RandomAccessFileReader* reader, uint64_t offset, size_t n,
-                  bool for_compaction = false);
-
-  // Tries returning the data for a file raed from this buffer, if that data is
-  // in the buffer.
-  // It handles tracking the minimum read offset if track_min_offset = true.
-  // It also does the exponential readahead when readadhead_size is set as part
-  // of the constructor.
-  //
-  // offset : the file offset.
-  // n      : the number of bytes.
-  // result : output buffer to put the data into.
-  // for_compaction : if cache read is done for compaction read.
-  bool TryReadFromCache(uint64_t offset, size_t n, Slice* result,
-                        bool for_compaction = false);
-
-  // The minimum `offset` ever passed to TryReadFromCache(). This will nly be
-  // tracked if track_min_offset = true.
-  size_t min_offset_read() const { return min_offset_read_; }
-
- private:
-  AlignedBuffer buffer_;
-  uint64_t buffer_offset_;
-  RandomAccessFileReader* file_reader_;
-  size_t readahead_size_;
-  size_t max_readahead_size_;
-  // The minimum `offset` ever passed to TryReadFromCache().
-  size_t min_offset_read_;
-  // if false, TryReadFromCache() always return false, and we only take stats
-  // for track_min_offset_ if track_min_offset_ = true
-  bool enable_;
-  // If true, track minimum `offset` ever passed to TryReadFromCache(), which
-  // can be fetched from min_offset_read().
-  bool track_min_offset_;
-};
-}  // namespace rocksdb
@@ -8,11 +8,9 @@
 #include <string>
 #include <algorithm>

-#include "file/random_access_file_reader.h"
-#include "file/sequence_file_reader.h"
 #include "file/sst_file_manager_impl.h"
-#include "file/writable_file_writer.h"
 #include "rocksdb/env.h"
+#include "util/file_reader_writer.h"

 namespace rocksdb {

@@ -12,10 +12,10 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <vector>
-#include "file/writable_file_writer.h"
 #include "logging/logging.h"
 #include "rocksdb/env.h"
 #include "test_util/sync_point.h"
+#include "util/file_reader_writer.h"
 #include "util/stop_watch.h"
 #include "util/string_util.h"

@@ -1,188 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "file/random_access_file_reader.h"
-
-#include <algorithm>
-#include <mutex>
-
-#include "monitoring/histogram.h"
-#include "monitoring/iostats_context_imp.h"
-#include "port/port.h"
-#include "test_util/sync_point.h"
-#include "util/random.h"
-#include "util/rate_limiter.h"
-
-namespace rocksdb {
-Status RandomAccessFileReader::Read(uint64_t offset, size_t n, Slice* result,
-                                    char* scratch, bool for_compaction) const {
-  Status s;
-  uint64_t elapsed = 0;
-  {
-    StopWatch sw(env_, stats_, hist_type_,
-                 (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
-                 true /*delay_enabled*/);
-    auto prev_perf_level = GetPerfLevel();
-    IOSTATS_TIMER_GUARD(read_nanos);
-    if (use_direct_io()) {
-#ifndef ROCKSDB_LITE
-      size_t alignment = file_->GetRequiredBufferAlignment();
-      size_t aligned_offset =
-          TruncateToPageBoundary(alignment, static_cast<size_t>(offset));
-      size_t offset_advance = static_cast<size_t>(offset) - aligned_offset;
-      size_t read_size =
-          Roundup(static_cast<size_t>(offset + n), alignment) - aligned_offset;
-      AlignedBuffer buf;
-      buf.Alignment(alignment);
-      buf.AllocateNewBuffer(read_size);
-      while (buf.CurrentSize() < read_size) {
-        size_t allowed;
-        if (for_compaction && rate_limiter_ != nullptr) {
-          allowed = rate_limiter_->RequestToken(
-              buf.Capacity() - buf.CurrentSize(), buf.Alignment(),
-              Env::IOPriority::IO_LOW, stats_, RateLimiter::OpType::kRead);
-        } else {
-          assert(buf.CurrentSize() == 0);
-          allowed = read_size;
-        }
-        Slice tmp;
-
-        FileOperationInfo::TimePoint start_ts;
-        uint64_t orig_offset = 0;
-        if (ShouldNotifyListeners()) {
-          start_ts = std::chrono::system_clock::now();
-          orig_offset = aligned_offset + buf.CurrentSize();
-        }
-        {
-          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
-          s = file_->Read(aligned_offset + buf.CurrentSize(), allowed, &tmp,
-                          buf.Destination());
-        }
-        if (ShouldNotifyListeners()) {
-          auto finish_ts = std::chrono::system_clock::now();
-          NotifyOnFileReadFinish(orig_offset, tmp.size(), start_ts, finish_ts,
-                                 s);
-        }
-
-        buf.Size(buf.CurrentSize() + tmp.size());
-        if (!s.ok() || tmp.size() < allowed) {
-          break;
-        }
-      }
-      size_t res_len = 0;
-      if (s.ok() && offset_advance < buf.CurrentSize()) {
-        res_len = buf.Read(scratch, offset_advance,
-                           std::min(buf.CurrentSize() - offset_advance, n));
-      }
-      *result = Slice(scratch, res_len);
-#endif  // !ROCKSDB_LITE
-    } else {
-      size_t pos = 0;
-      const char* res_scratch = nullptr;
-      while (pos < n) {
-        size_t allowed;
-        if (for_compaction && rate_limiter_ != nullptr) {
-          if (rate_limiter_->IsRateLimited(RateLimiter::OpType::kRead)) {
-            sw.DelayStart();
-          }
-          allowed = rate_limiter_->RequestToken(n - pos, 0 /* alignment */,
-                                                Env::IOPriority::IO_LOW, stats_,
-                                                RateLimiter::OpType::kRead);
-          if (rate_limiter_->IsRateLimited(RateLimiter::OpType::kRead)) {
-            sw.DelayStop();
-          }
-        } else {
-          allowed = n;
-        }
-        Slice tmp_result;
-
-#ifndef ROCKSDB_LITE
-        FileOperationInfo::TimePoint start_ts;
-        if (ShouldNotifyListeners()) {
-          start_ts = std::chrono::system_clock::now();
-        }
-#endif
-        {
-          IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
-          s = file_->Read(offset + pos, allowed, &tmp_result, scratch + pos);
-        }
-#ifndef ROCKSDB_LITE
-        if (ShouldNotifyListeners()) {
-          auto finish_ts = std::chrono::system_clock::now();
-          NotifyOnFileReadFinish(offset + pos, tmp_result.size(), start_ts,
-                                 finish_ts, s);
-        }
-#endif
-
-        if (res_scratch == nullptr) {
-          // we can't simply use `scratch` because reads of mmap'd files return
-          // data in a different buffer.
-          res_scratch = tmp_result.data();
-        } else {
-          // make sure chunks are inserted contiguously into `res_scratch`.
-          assert(tmp_result.data() == res_scratch + pos);
-        }
-        pos += tmp_result.size();
-        if (!s.ok() || tmp_result.size() < allowed) {
-          break;
-        }
-      }
-      *result = Slice(res_scratch, s.ok() ? pos : 0);
-    }
-    IOSTATS_ADD_IF_POSITIVE(bytes_read, result->size());
-    SetPerfLevel(prev_perf_level);
-  }
-  if (stats_ != nullptr && file_read_hist_ != nullptr) {
-    file_read_hist_->Add(elapsed);
-  }
-
-  return s;
-}
-
-Status RandomAccessFileReader::MultiRead(ReadRequest* read_reqs,
-                                         size_t num_reqs) const {
-  Status s;
-  uint64_t elapsed = 0;
-  assert(!use_direct_io());
-  {
-    StopWatch sw(env_, stats_, hist_type_,
-                 (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
-                 true /*delay_enabled*/);
-    auto prev_perf_level = GetPerfLevel();
-    IOSTATS_TIMER_GUARD(read_nanos);
-
-#ifndef ROCKSDB_LITE
-    FileOperationInfo::TimePoint start_ts;
-    if (ShouldNotifyListeners()) {
-      start_ts = std::chrono::system_clock::now();
-    }
-#endif  // ROCKSDB_LITE
-    {
-      IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_);
-      s = file_->MultiRead(read_reqs, num_reqs);
-    }
-    for (size_t i = 0; i < num_reqs; ++i) {
-#ifndef ROCKSDB_LITE
-      if (ShouldNotifyListeners()) {
-        auto finish_ts = std::chrono::system_clock::now();
-        NotifyOnFileReadFinish(read_reqs[i].offset, read_reqs[i].result.size(),
-                               start_ts, finish_ts, read_reqs[i].status);
-      }
-#endif  // ROCKSDB_LITE
-      IOSTATS_ADD_IF_POSITIVE(bytes_read, read_reqs[i].result.size());
-    }
-    SetPerfLevel(prev_perf_level);
-  }
-  if (stats_ != nullptr && file_read_hist_ != nullptr) {
-    file_read_hist_->Add(elapsed);
-  }
-
-  return s;
-}
-}  // namespace rocksdb
@@ -1,120 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <atomic>
-#include <sstream>
-#include <string>
-#include "port/port.h"
-#include "rocksdb/env.h"
-#include "rocksdb/listener.h"
-#include "rocksdb/rate_limiter.h"
-#include "util/aligned_buffer.h"
-
-namespace rocksdb {
-
-class Statistics;
-class HistogramImpl;
-
-// RandomAccessFileReader is a wrapper on top of Env::RnadomAccessFile. It is
-// responsible for:
-// - Handling Buffered and Direct reads appropriately.
-// - Rate limiting compaction reads.
-// - Notifying any interested listeners on the completion of a read.
-// - Updating IO stats.
-class RandomAccessFileReader {
- private:
-#ifndef ROCKSDB_LITE
-  void NotifyOnFileReadFinish(uint64_t offset, size_t length,
-                              const FileOperationInfo::TimePoint& start_ts,
-                              const FileOperationInfo::TimePoint& finish_ts,
-                              const Status& status) const {
-    FileOperationInfo info(file_name_, start_ts, finish_ts);
-    info.offset = offset;
-    info.length = length;
-    info.status = status;
-
-    for (auto& listener : listeners_) {
-      listener->OnFileReadFinish(info);
-    }
-  }
-#endif  // ROCKSDB_LITE
-
-  bool ShouldNotifyListeners() const { return !listeners_.empty(); }
-
-  std::unique_ptr<RandomAccessFile> file_;
-  std::string file_name_;
-  Env* env_;
-  Statistics* stats_;
-  uint32_t hist_type_;
-  HistogramImpl* file_read_hist_;
-  RateLimiter* rate_limiter_;
-  std::vector<std::shared_ptr<EventListener>> listeners_;
-
- public:
-  explicit RandomAccessFileReader(
-      std::unique_ptr<RandomAccessFile>&& raf, std::string _file_name,
-      Env* env = nullptr, Statistics* stats = nullptr, uint32_t hist_type = 0,
-      HistogramImpl* file_read_hist = nullptr,
-      RateLimiter* rate_limiter = nullptr,
-      const std::vector<std::shared_ptr<EventListener>>& listeners = {})
-      : file_(std::move(raf)),
-        file_name_(std::move(_file_name)),
-        env_(env),
-        stats_(stats),
-        hist_type_(hist_type),
-        file_read_hist_(file_read_hist),
-        rate_limiter_(rate_limiter),
-        listeners_() {
-#ifndef ROCKSDB_LITE
-    std::for_each(listeners.begin(), listeners.end(),
-                  [this](const std::shared_ptr<EventListener>& e) {
-                    if (e->ShouldBeNotifiedOnFileIO()) {
-                      listeners_.emplace_back(e);
-                    }
-                  });
-#else  // !ROCKSDB_LITE
-    (void)listeners;
-#endif
-  }
-
-  RandomAccessFileReader(RandomAccessFileReader&& o) ROCKSDB_NOEXCEPT {
-    *this = std::move(o);
-  }
-
-  RandomAccessFileReader& operator=(RandomAccessFileReader&& o)
-      ROCKSDB_NOEXCEPT {
-    file_ = std::move(o.file_);
-    env_ = std::move(o.env_);
-    stats_ = std::move(o.stats_);
-    hist_type_ = std::move(o.hist_type_);
-    file_read_hist_ = std::move(o.file_read_hist_);
-    rate_limiter_ = std::move(o.rate_limiter_);
-    return *this;
-  }
-
-  RandomAccessFileReader(const RandomAccessFileReader&) = delete;
-  RandomAccessFileReader& operator=(const RandomAccessFileReader&) = delete;
-
-  Status Read(uint64_t offset, size_t n, Slice* result, char* scratch,
-              bool for_compaction = false) const;
-
-  Status MultiRead(ReadRequest* reqs, size_t num_reqs) const;
-
-  Status Prefetch(uint64_t offset, size_t n) const {
-    return file_->Prefetch(offset, n);
-  }
-
-  RandomAccessFile* file() { return file_.get(); }
-
-  std::string file_name() const { return file_name_; }
-
-  bool use_direct_io() const { return file_->use_direct_io(); }
-};
-}  // namespace rocksdb
@@ -1,66 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "file/read_write_util.h"
-
-#include <sstream>
-#include "test_util/sync_point.h"
-
-namespace rocksdb {
-Status NewWritableFile(Env* env, const std::string& fname,
-                       std::unique_ptr<WritableFile>* result,
-                       const EnvOptions& options) {
-  Status s = env->NewWritableFile(fname, result, options);
-  TEST_KILL_RANDOM("NewWritableFile:0", rocksdb_kill_odds * REDUCE_ODDS2);
-  return s;
-}
-
-bool ReadOneLine(std::istringstream* iss, SequentialFile* seq_file,
-                 std::string* output, bool* has_data, Status* result) {
-  const int kBufferSize = 8192;
-  char buffer[kBufferSize + 1];
-  Slice input_slice;
-
-  std::string line;
-  bool has_complete_line = false;
-  while (!has_complete_line) {
-    if (std::getline(*iss, line)) {
-      has_complete_line = !iss->eof();
-    } else {
-      has_complete_line = false;
-    }
-    if (!has_complete_line) {
-      // if we're not sure whether we have a complete line,
-      // further read from the file.
-      if (*has_data) {
-        *result = seq_file->Read(kBufferSize, &input_slice, buffer);
-      }
-      if (input_slice.size() == 0) {
-        // meaning we have read all the data
-        *has_data = false;
-        break;
-      } else {
-        iss->str(line + input_slice.ToString());
-        // reset the internal state of iss so that we can keep reading it.
-        iss->clear();
-        *has_data = (input_slice.size() == kBufferSize);
-        continue;
-      }
-    }
-  }
-  *output = line;
-  return *has_data || has_complete_line;
-}
-
-#ifndef NDEBUG
-bool IsFileSectorAligned(const size_t off, size_t sector_size) {
-  return off % sector_size == 0;
-}
-#endif  // NDEBUG
-}  // namespace rocksdb
@@ -1,32 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <atomic>
-#include "rocksdb/env.h"
-
-namespace rocksdb {
-// Returns a WritableFile.
-//
-// env     : the Env.
-// fname   : the file name.
-// result  : output arg. A WritableFile based on `fname` returned.
-// options : the Env Options.
-extern Status NewWritableFile(Env* env, const std::string& fname,
-                              std::unique_ptr<WritableFile>* result,
-                              const EnvOptions& options);
-
-// Read a single line from a file.
-bool ReadOneLine(std::istringstream* iss, SequentialFile* seq_file,
-                 std::string* output, bool* has_data, Status* result);
-
-#ifndef NDEBUG
-bool IsFileSectorAligned(const size_t off, size_t sector_size);
-#endif  // NDEBUG
-}  // namespace rocksdb
@@ -1,162 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "file/readahead_raf.h"
-
-#include <algorithm>
-#include <mutex>
-#include "file/read_write_util.h"
-#include "util/aligned_buffer.h"
-#include "util/rate_limiter.h"
-
-namespace rocksdb {
-namespace {
-class ReadaheadRandomAccessFile : public RandomAccessFile {
- public:
-  ReadaheadRandomAccessFile(std::unique_ptr<RandomAccessFile>&& file,
-                            size_t readahead_size)
-      : file_(std::move(file)),
-        alignment_(file_->GetRequiredBufferAlignment()),
-        readahead_size_(Roundup(readahead_size, alignment_)),
-        buffer_(),
-        buffer_offset_(0) {
-    buffer_.Alignment(alignment_);
-    buffer_.AllocateNewBuffer(readahead_size_);
-  }
-
-  ReadaheadRandomAccessFile(const ReadaheadRandomAccessFile&) = delete;
-
-  ReadaheadRandomAccessFile& operator=(const ReadaheadRandomAccessFile&) =
-      delete;
-
-  Status Read(uint64_t offset, size_t n, Slice* result,
-              char* scratch) const override {
-    // Read-ahead only make sense if we have some slack left after reading
-    if (n + alignment_ >= readahead_size_) {
-      return file_->Read(offset, n, result, scratch);
-    }
-
-    std::unique_lock<std::mutex> lk(lock_);
-
-    size_t cached_len = 0;
-    // Check if there is a cache hit, meaning that [offset, offset + n) is
-    // either completely or partially in the buffer. If it's completely cached,
-    // including end of file case when offset + n is greater than EOF, then
-    // return.
-    if (TryReadFromCache(offset, n, &cached_len, scratch) &&
-        (cached_len == n || buffer_.CurrentSize() < readahead_size_)) {
-      // We read exactly what we needed, or we hit end of file - return.
-      *result = Slice(scratch, cached_len);
-      return Status::OK();
-    }
-    size_t advanced_offset = static_cast<size_t>(offset + cached_len);
-    // In the case of cache hit advanced_offset is already aligned, means that
-    // chunk_offset equals to advanced_offset
-    size_t chunk_offset = TruncateToPageBoundary(alignment_, advanced_offset);
-
-    Status s = ReadIntoBuffer(chunk_offset, readahead_size_);
-    if (s.ok()) {
-      // The data we need is now in cache, so we can safely read it
-      size_t remaining_len;
-      TryReadFromCache(advanced_offset, n - cached_len, &remaining_len,
-                       scratch + cached_len);
-      *result = Slice(scratch, cached_len + remaining_len);
-    }
-    return s;
-  }
-
-  Status Prefetch(uint64_t offset, size_t n) override {
-    if (n < readahead_size_) {
-      // Don't allow smaller prefetches than the configured `readahead_size_`.
-      // `Read()` assumes a smaller prefetch buffer indicates EOF was reached.
-      return Status::OK();
-    }
-
-    std::unique_lock<std::mutex> lk(lock_);
-
-    size_t offset_ = static_cast<size_t>(offset);
-    size_t prefetch_offset = TruncateToPageBoundary(alignment_, offset_);
-    if (prefetch_offset == buffer_offset_) {
-      return Status::OK();
-    }
-    return ReadIntoBuffer(prefetch_offset,
-                          Roundup(offset_ + n, alignment_) - prefetch_offset);
-  }
-
-  size_t GetUniqueId(char* id, size_t max_size) const override {
-    return file_->GetUniqueId(id, max_size);
-  }
-
-  void Hint(AccessPattern pattern) override { file_->Hint(pattern); }
-
-  Status InvalidateCache(size_t offset, size_t length) override {
-    std::unique_lock<std::mutex> lk(lock_);
-    buffer_.Clear();
-    return file_->InvalidateCache(offset, length);
-  }
-
-  bool use_direct_io() const override { return file_->use_direct_io(); }
-
- private:
-  // Tries to read from buffer_ n bytes starting at offset. If anything was read
-  // from the cache, it sets cached_len to the number of bytes actually read,
-  // copies these number of bytes to scratch and returns true.
-  // If nothing was read sets cached_len to 0 and returns false.
-  bool TryReadFromCache(uint64_t offset, size_t n, size_t* cached_len,
-                        char* scratch) const {
-    if (offset < buffer_offset_ ||
-        offset >= buffer_offset_ + buffer_.CurrentSize()) {
-      *cached_len = 0;
-      return false;
-    }
-    uint64_t offset_in_buffer = offset - buffer_offset_;
-    *cached_len = std::min(
-        buffer_.CurrentSize() - static_cast<size_t>(offset_in_buffer), n);
-    memcpy(scratch, buffer_.BufferStart() + offset_in_buffer, *cached_len);
-    return true;
-  }
-
-  // Reads into buffer_ the next n bytes from file_ starting at offset.
-  // Can actually read less if EOF was reached.
-  // Returns the status of the read operastion on the file.
-  Status ReadIntoBuffer(uint64_t offset, size_t n) const {
-    if (n > buffer_.Capacity()) {
-      n = buffer_.Capacity();
-    }
-    assert(IsFileSectorAligned(offset, alignment_));
-    assert(IsFileSectorAligned(n, alignment_));
-    Slice result;
-    Status s = file_->Read(offset, n, &result, buffer_.BufferStart());
-    if (s.ok()) {
-      buffer_offset_ = offset;
-      buffer_.Size(result.size());
-      assert(result.size() == 0 || buffer_.BufferStart() == result.data());
-    }
-    return s;
-  }
-
-  const std::unique_ptr<RandomAccessFile> file_;
-  const size_t alignment_;
-  const size_t readahead_size_;
-
-  mutable std::mutex lock_;
-  // The buffer storing the prefetched data
-  mutable AlignedBuffer buffer_;
-  // The offset in file_, corresponding to data stored in buffer_
-  mutable uint64_t buffer_offset_;
-};
-}  // namespace
-
-std::unique_ptr<RandomAccessFile> NewReadaheadRandomAccessFile(
-    std::unique_ptr<RandomAccessFile>&& file, size_t readahead_size) {
-  std::unique_ptr<RandomAccessFile> result(
-      new ReadaheadRandomAccessFile(std::move(file), readahead_size));
-  return result;
-}
-}  // namespace rocksdb
@@ -1,27 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-#include <atomic>
-#include "rocksdb/env.h"
-
-namespace rocksdb {
-// This file provides the following main abstractions:
-// SequentialFileReader : wrapper over Env::SequentialFile
-// RandomAccessFileReader : wrapper over Env::RandomAccessFile
-// WritableFileWriter : wrapper over Env::WritableFile
-// In addition, it also exposed NewReadaheadRandomAccessFile, NewWritableFile,
-// and ReadOneLine primitives.
-
-// NewReadaheadRandomAccessFile provides a wrapper over RandomAccessFile to
-// always prefetch additional data with every read. This is mainly used in
-// Compaction Table Readers.
-std::unique_ptr<RandomAccessFile> NewReadaheadRandomAccessFile(
-    std::unique_ptr<RandomAccessFile>&& file, size_t readahead_size);
-}  // namespace rocksdb
@@ -1,233 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "file/sequence_file_reader.h"
-
-#include <algorithm>
-#include <mutex>
-
-#include "file/read_write_util.h"
-#include "monitoring/histogram.h"
-#include "monitoring/iostats_context_imp.h"
-#include "port/port.h"
-#include "test_util/sync_point.h"
-#include "util/aligned_buffer.h"
-#include "util/random.h"
-#include "util/rate_limiter.h"
-
-namespace rocksdb {
-Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) {
-  Status s;
-  if (use_direct_io()) {
-#ifndef ROCKSDB_LITE
-    size_t offset = offset_.fetch_add(n);
-    size_t alignment = file_->GetRequiredBufferAlignment();
-    size_t aligned_offset = TruncateToPageBoundary(alignment, offset);
-    size_t offset_advance = offset - aligned_offset;
-    size_t size = Roundup(offset + n, alignment) - aligned_offset;
-    size_t r = 0;
-    AlignedBuffer buf;
-    buf.Alignment(alignment);
-    buf.AllocateNewBuffer(size);
-    Slice tmp;
-    s = file_->PositionedRead(aligned_offset, size, &tmp, buf.BufferStart());
-    if (s.ok() && offset_advance < tmp.size()) {
-      buf.Size(tmp.size());
-      r = buf.Read(scratch, offset_advance,
-                   std::min(tmp.size() - offset_advance, n));
-    }
-    *result = Slice(scratch, r);
-#endif  // !ROCKSDB_LITE
-  } else {
-    s = file_->Read(n, result, scratch);
-  }
-  IOSTATS_ADD(bytes_read, result->size());
-  return s;
-}
-
-Status SequentialFileReader::Skip(uint64_t n) {
-#ifndef ROCKSDB_LITE
-  if (use_direct_io()) {
-    offset_ += static_cast<size_t>(n);
-    return Status::OK();
-  }
-#endif  // !ROCKSDB_LITE
-  return file_->Skip(n);
-}
-
-namespace {
-// This class wraps a SequentialFile, exposing same API, with the differenece
-// of being able to prefetch up to readahead_size bytes and then serve them
-// from memory, avoiding the entire round-trip if, for example, the data for the
-// file is actually remote.
-class ReadaheadSequentialFile : public SequentialFile {
- public:
-  ReadaheadSequentialFile(std::unique_ptr<SequentialFile>&& file,
-                          size_t readahead_size)
-      : file_(std::move(file)),
-        alignment_(file_->GetRequiredBufferAlignment()),
-        readahead_size_(Roundup(readahead_size, alignment_)),
-        buffer_(),
-        buffer_offset_(0),
-        read_offset_(0) {
-    buffer_.Alignment(alignment_);
-    buffer_.AllocateNewBuffer(readahead_size_);
-  }
-
-  ReadaheadSequentialFile(const ReadaheadSequentialFile&) = delete;
-
-  ReadaheadSequentialFile& operator=(const ReadaheadSequentialFile&) = delete;
-
-  Status Read(size_t n, Slice* result, char* scratch) override {
-    std::unique_lock<std::mutex> lk(lock_);
-
-    size_t cached_len = 0;
-    // Check if there is a cache hit, meaning that [offset, offset + n) is
-    // either completely or partially in the buffer. If it's completely cached,
-    // including end of file case when offset + n is greater than EOF, then
-    // return.
-    if (TryReadFromCache(n, &cached_len, scratch) &&
-        (cached_len == n || buffer_.CurrentSize() < readahead_size_)) {
-      // We read exactly what we needed, or we hit end of file - return.
-      *result = Slice(scratch, cached_len);
-      return Status::OK();
-    }
-    n -= cached_len;
-
-    Status s;
-    // Read-ahead only make sense if we have some slack left after reading
-    if (n + alignment_ >= readahead_size_) {
-      s = file_->Read(n, result, scratch + cached_len);
-      if (s.ok()) {
-        read_offset_ += result->size();
-        *result = Slice(scratch, cached_len + result->size());
-      }
-      buffer_.Clear();
-      return s;
-    }
-
-    s = ReadIntoBuffer(readahead_size_);
-    if (s.ok()) {
-      // The data we need is now in cache, so we can safely read it
-      size_t remaining_len;
-      TryReadFromCache(n, &remaining_len, scratch + cached_len);
-      *result = Slice(scratch, cached_len + remaining_len);
-    }
-    return s;
-  }
-
-  Status Skip(uint64_t n) override {
-    std::unique_lock<std::mutex> lk(lock_);
-    Status s = Status::OK();
-    // First check if we need to skip already cached data
-    if (buffer_.CurrentSize() > 0) {
-      // Do we need to skip beyond cached data?
-      if (read_offset_ + n >= buffer_offset_ + buffer_.CurrentSize()) {
-        // Yes. Skip whaterver is in memory and adjust offset accordingly
-        n -= buffer_offset_ + buffer_.CurrentSize() - read_offset_;
-        read_offset_ = buffer_offset_ + buffer_.CurrentSize();
-      } else {
-        // No. The entire section to be skipped is entirely i cache.
-        read_offset_ += n;
-        n = 0;
-      }
-    }
-    if (n > 0) {
-      // We still need to skip more, so call the file API for skipping
-      s = file_->Skip(n);
-      if (s.ok()) {
-        read_offset_ += n;
-      }
-      buffer_.Clear();
-    }
-    return s;
-  }
-
-  Status PositionedRead(uint64_t offset, size_t n, Slice* result,
-                        char* scratch) override {
-    return file_->PositionedRead(offset, n, result, scratch);
-  }
-
-  Status InvalidateCache(size_t offset, size_t length) override {
-    std::unique_lock<std::mutex> lk(lock_);
-    buffer_.Clear();
-    return file_->InvalidateCache(offset, length);
-  }
-
-  bool use_direct_io() const override { return file_->use_direct_io(); }
-
- private:
-  // Tries to read from buffer_ n bytes. If anything was read from the cache, it
-  // sets cached_len to the number of bytes actually read, copies these number
-  // of bytes to scratch and returns true.
-  // If nothing was read sets cached_len to 0 and returns false.
-  bool TryReadFromCache(size_t n, size_t* cached_len, char* scratch) {
-    if (read_offset_ < buffer_offset_ ||
-        read_offset_ >= buffer_offset_ + buffer_.CurrentSize()) {
-      *cached_len = 0;
-      return false;
-    }
-    uint64_t offset_in_buffer = read_offset_ - buffer_offset_;
-    *cached_len = std::min(
-        buffer_.CurrentSize() - static_cast<size_t>(offset_in_buffer), n);
-    memcpy(scratch, buffer_.BufferStart() + offset_in_buffer, *cached_len);
-    read_offset_ += *cached_len;
-    return true;
-  }
-
-  // Reads into buffer_ the next n bytes from file_.
-  // Can actually read less if EOF was reached.
-  // Returns the status of the read operastion on the file.
-  Status ReadIntoBuffer(size_t n) {
-    if (n > buffer_.Capacity()) {
-      n = buffer_.Capacity();
-    }
-    assert(IsFileSectorAligned(n, alignment_));
-    Slice result;
-    Status s = file_->Read(n, &result, buffer_.BufferStart());
-    if (s.ok()) {
-      buffer_offset_ = read_offset_;
-      buffer_.Size(result.size());
-      assert(result.size() == 0 || buffer_.BufferStart() == result.data());
-    }
-    return s;
-  }
-
-  const std::unique_ptr<SequentialFile> file_;
-  const size_t alignment_;
-  const size_t readahead_size_;
-
-  std::mutex lock_;
-  // The buffer storing the prefetched data
-  AlignedBuffer buffer_;
-  // The offset in file_, corresponding to data stored in buffer_
-  uint64_t buffer_offset_;
-  // The offset up to which data was read from file_. In fact, it can be larger
-  // than the actual file size, since the file_->Skip(n) call doesn't return the
-  // actual number of bytes that were skipped, which can be less than n.
-  // This is not a problemm since read_offset_ is monotonically increasing and
-  // its only use is to figure out if next piece of data should be read from
-  // buffer_ or file_ directly.
-  uint64_t read_offset_;
-};
-}  // namespace
-
-std::unique_ptr<SequentialFile>
-SequentialFileReader::NewReadaheadSequentialFile(
-    std::unique_ptr<SequentialFile>&& file, size_t readahead_size) {
-  if (file->GetRequiredBufferAlignment() >= readahead_size) {
-    // Short-circuit and return the original file if readahead_size is
-    // too small and hence doesn't make sense to be used for prefetching.
-    return std::move(file);
-  }
-  std::unique_ptr<SequentialFile> result(
-      new ReadaheadSequentialFile(std::move(file), readahead_size));
-  return result;
-}
-}  // namespace rocksdb
Author	SHA1	Message	Date
Levi Tamasi	f48aa1c308	Bump up version to 6.5.3	2020-01-10 09:58:14 -08:00
Levi Tamasi	e7d7b1075e	Update HISTORY.md with the recent memtable trimming fixes Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/6194 Differential Revision: D19125292 Pulled By: ltamasi fbshipit-source-id: d41aca2755ec4bec07feedd6b561e8d18606a931	2020-01-10 09:57:50 -08:00
Levi Tamasi	c0a5673aa7	Fix a data race related to memtable trimming (#6187 ) Summary: https://github.com/facebook/rocksdb/pull/6177 introduced a data race involving `MemTableList::InstallNewVersion` and `MemTableList::NumFlushed`. The patch fixes this by caching whether the current version has any memtable history (i.e. flushed memtables that are kept around for transaction conflict checking) in an `std::atomic<bool>` member called `current_has_history_`, similarly to how `current_memory_usage_excluding_last_` is handled. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6187 Test Plan: ``` make clean COMPILE_WITH_TSAN=1 make db_test -j24 ./db_test ``` Differential Revision: D19084059 Pulled By: ltamasi fbshipit-source-id: 327a5af9700fb7102baea2cc8903c085f69543b9	2020-01-10 09:54:56 -08:00
Levi Tamasi	8f121d86a4	Do not schedule memtable trimming if there is no history (#6177 ) Summary: We have observed an increase in CPU load caused by frequent calls to `ColumnFamilyData::InstallSuperVersion` from `DBImpl::TrimMemtableHistory` when using `max_write_buffer_size_to_maintain` to limit the amount of memtable history maintained for transaction conflict checking. Part of the issue is that trimming can potentially be scheduled even if there is no memtable history. The patch adds a check that fixes this. See also https://github.com/facebook/rocksdb/pull/6169. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6177 Test Plan: Compared `perf` output for ``` ./db_bench -benchmarks=randomtransaction -optimistic_transaction_db=1 -statistics -stats_interval_seconds=1 -duration=90 -num=500000 --max_write_buffer_size_to_maintain=16000000 --transaction_set_snapshot=1 --threads=32 ``` before and after the change. There is a significant reduction for the call chain `rocksdb::DBImpl::TrimMemtableHistory` -> `rocksdb::ColumnFamilyData::InstallSuperVersion` -> `rocksdb::ThreadLocalPtr::StaticMeta::Scrape` even without https://github.com/facebook/rocksdb/pull/6169. Differential Revision: D19057445 Pulled By: ltamasi fbshipit-source-id: dff81882d7b280e17eda7d9b072a2d4882c50f79	2020-01-10 09:53:31 -08:00
Levi Tamasi	afbfb3f567	Do not create/install new SuperVersion if nothing was deleted during memtable trim (#6169 ) Summary: We have observed an increase in CPU load caused by frequent calls to `ColumnFamilyData::InstallSuperVersion` from `DBImpl::TrimMemtableHistory` when using `max_write_buffer_size_to_maintain` to limit the amount of memtable history maintained for transaction conflict checking. As it turns out, this is caused by the code creating and installing a new `SuperVersion` even if no memtables were actually trimmed. The patch adds a check to avoid this. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6169 Test Plan: Compared `perf` output for ``` ./db_bench -benchmarks=randomtransaction -optimistic_transaction_db=1 -statistics -stats_interval_seconds=1 -duration=90 -num=500000 --max_write_buffer_size_to_maintain=16000000 --transaction_set_snapshot=1 --threads=32 ``` before and after the change. With the fix, the call chain `rocksdb::DBImpl::TrimMemtableHistory` -> `rocksdb::ColumnFamilyData::InstallSuperVersion` -> `rocksdb::ThreadLocalPtr::StaticMeta::Scrape` no longer registers in the `perf` report. Differential Revision: D19031509 Pulled By: ltamasi fbshipit-source-id: 02686fce594e5b50eba0710e4b28a9b808c8aa20	2020-01-10 09:53:31 -08:00
Fosco Marotto	4cfbd87afd	Update history and version for 6.5.2	2019-11-15 13:56:29 -08:00
Peter Dillinger	8a72bb14bd	More fixes to auto-GarbageCollect in BackupEngine (#6023 ) Summary: Production: * Fixes GarbageCollect (and auto-GC triggered by PurgeOldBackups, DeleteBackup, or CreateNewBackup) to clean up backup directory independent of current settings (except max_valid_backups_to_open; see issue https://github.com/facebook/rocksdb/issues/4997) and prior settings used with same backup directory. * Fixes GarbageCollect (and auto-GC) not to attempt to remove "." and ".." entries from directories. * Clarifies contract with users in modifying BackupEngine operations. In short, leftovers from any incomplete operation are cleaned up by any subsequent call to that same kind of operation (PurgeOldBackups and DeleteBackup considered the same kind of operation). GarbageCollect is available to clean up after all kinds. (NB: right now PurgeOldBackups and DeleteBackup will clean up after incomplete CreateNewBackup, but we aren't promising to continue that behavior.) Pull Request resolved: https://github.com/facebook/rocksdb/pull/6023 Test Plan: * Refactors open parameters to use an option enum, for readability, etc. (Also fixes an unused parameter bug in the redundant OpenDBAndBackupEngineShareWithChecksum.) * Fixes an apparent bug in ShareTableFilesWithChecksumsTransition in which old backup data was destroyed in the transition to be tested. That test is now augmented to ensure GarbageCollect (or auto-GC) does not remove shared files when BackupEngine is opened with share_table_files=false. * Augments DeleteTmpFiles test to ensure that CreateNewBackup does auto-GC when an incompletely created backup is detected. Differential Revision: D18453559 Pulled By: pdillinger fbshipit-source-id: 5e54e7b08d711b161bc9c656181012b69a8feac4	2019-11-15 12:15:12 -08:00
Peter Dillinger	a6d418384d	Auto-GarbageCollect on PurgeOldBackups and DeleteBackup (#6015 ) Summary: Only if there is a crash, power failure, or I/O error in DeleteBackup, shared or private files from the backup might be left behind that are not cleaned up by PurgeOldBackups or DeleteBackup-- only by GarbageCollect. This makes the BackupEngine API "leaky by default." Even if it means a modest performance hit, I think we should make Delete and Purge do as they say, with ongoing best effort: i.e. future calls will attempt to finish any incomplete work from earlier calls. This change does that by having DeleteBackup and PurgeOldBackups do a GarbageCollect, unless (to minimize performance hit) this BackupEngine has already done a GarbageCollect and there have been no deletion-related I/O errors in that GarbageCollect or since then. Rejected alternative 1: remove meta file last instead of first. This would in theory turn partially deleted backups into corrupted backups, but code changes would be needed to allow the missing files and consider it acceptably corrupt, rather than failing to open the BackupEngine. This might be a reasonable choice, but I mostly rejected it because it doesn't solve the legacy problem of cleaning up existing lingering files. Rejected alternative 2: use a deletion marker file. If deletion started with creating a file that marks a backup as flagged for deletion, then we could reliably detect partially deleted backups and efficiently finish removing them. In addition to not solving the legacy problem, this could be precarious if there's a disk full situation, and we try to create a new file in order to delete some files. Ugh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6015 Test Plan: Updated unit tests Differential Revision: D18401333 Pulled By: pdillinger fbshipit-source-id: 12944e372ce6809f3f5a4c416c3b321a8927d925	2019-11-15 12:15:12 -08:00
anand76	cb1dc29655	Fix a buffer overrun problem in BlockBasedTable::MultiGet (#6014 ) Summary: The calculation in BlockBasedTable::MultiGet for the required buffer length for reading in compressed blocks is incorrect. It needs to take the 5-byte block trailer into account. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6014 Test Plan: Add a unit test DBBasicTest.MultiGetBufferOverrun that fails in asan_check before the fix, and passes after. Differential Revision: D18412753 Pulled By: anand1976 fbshipit-source-id: 754dfb66be1d5f161a7efdf87be872198c7e3b72	2019-11-12 10:57:32 -08:00
anand76	98e5189fb0	Fix MultiGet crash when no_block_cache is set (#5991 ) Summary: This PR fixes https://github.com/facebook/rocksdb/issues/5975. In ```BlockBasedTable::RetrieveMultipleBlocks()```, we were calling ```MaybeReadBlocksAndLoadToCache()```, which is a no-op if neither uncompressed nor compressed block cache are configured. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5991 Test Plan: 1. Add unit tests that fail with the old code and pass with the new 2. make check and asan_check Cc spetrunia Differential Revision: D18272744 Pulled By: anand1976 fbshipit-source-id: e62fa6090d1a6adf84fcd51dfd6859b03c6aebfe	2019-11-12 10:56:03 -08:00
Vijay Nadimpalli	3353b7141d	Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 ) Summary: Making platform 007 (gcc 7) default in build_detect_platform.sh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5947 Differential Revision: D18038837 Pulled By: vjnadimpalli fbshipit-source-id: 9ac2ddaa93bf328a416faec028970e039886378e	2019-10-30 10:32:53 -07:00
sdong	d72cceb443	Fix VerifyChecksum readahead with mmap mode (#5945 ) Summary: A recent change introduced readahead inside VerifyChecksum(). However it is not compatible with mmap mode and generated wrong checksum verification failure. Fix it by not enabling readahead in mmap mode. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5945 Test Plan: Add a unit test that used to fail. Differential Revision: D18021443 fbshipit-source-id: 6f2eb600f81b26edb02222563a4006869d576bff	2019-10-22 11:42:36 -07:00
myabandeh	1d5083a007	Bump up the version to 6.5.1	2019-10-16 10:55:02 -07:00
Maysam Yabandeh	6ea6aa77cd	Update HISTORY for SeekForPrev bug fix (#5925 ) Summary: Update history for the bug fix in https://github.com/facebook/rocksdb/pull/5907 Pull Request resolved: https://github.com/facebook/rocksdb/pull/5925 Differential Revision: D17952605 Pulled By: maysamyabandeh fbshipit-source-id: 609afcbb2e4087f9153822c4d11193a75a7b0e7a	2019-10-16 10:52:59 -07:00
Maysam Yabandeh	4229f6df50	Fix SeekForPrev bug with Partitioned Filters and Prefix (#5907 ) Summary: Partition Filters make use of a top-level index to find the partition that might have the bloom hash of the key. The index is with internal key format (before format version 3). Each partition contains the i) blooms of the keys in that range ii) bloom of prefixes of keys in that range, iii) the bloom of the prefix of the last key in the previous partition. When ::SeekForPrev(key), we first perform a prefix bloom test on the SST file. The partition however is identified using the full internal key, rather than the prefix key. The reason is to be compatible with the internal key format of the top-level index. This creates a corner case. Example: - SST k, Partition N: P1K1, P1K2 - SST k, top-level index: P1K2 - SST k+1, Partition 1: P2K1, P3K1 - SST k+1 top-level index: P3K1 When SeekForPrev(P1K3), it should point us to P1K2. However SST k top-level index would reject P1K3 since it is out of range. One possible fix would be to search with the prefix P1 (instead of full internal key P1K3) however the details of properly comparing prefix with full internal key might get complicated. The fix we apply in this PR is to look into the last partition anyway even if the key is out of range. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5907 Differential Revision: D17889918 Pulled By: maysamyabandeh fbshipit-source-id: 169fd7b3c71dbc08808eae5a8340611ebe5bdc1e	2019-10-16 10:51:46 -07:00
anand76	73a35c6e17	Update HISTORY.md with a bug fix Summary: Test Plan: Reviewers: Subscribers: Tasks: Tags:	2019-10-07 16:54:33 -07:00
anand76	fc53ac86f6	Fix data block upper bound checking for iterator reseek case (#5883 ) Summary: When an iterator reseek happens with the user specifying a new iterate_upper_bound in ReadOptions, and the new seek position is at the end of the same data block, the Seek() ends up using a stale value of data_block_within_upper_bound_ and may return incorrect results. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5883 Test Plan: Added a new test case DBIteratorTest.IterReseekNewUpperBound. Verified that it failed due to the assertion failure without the fix, and passes with the fix. Differential Revision: D17752740 Pulled By: anand1976 fbshipit-source-id: f9b635ff5d6aeb0e1bef102cf8b2f900efd378e3	2019-10-07 16:39:18 -07:00
sdong	2060a008b0	Fix a previous revert	2019-10-01 16:58:47 -07:00
sdong	89865776b7	Revert "Merging iterator to avoid child iterator reseek for some cases (#5286 )" (#5871 ) Summary: This reverts commit `9fad3e21eb`. Iterator verification in stress tests sometimes fail for assertion table/block_based/block_based_table_reader.cc:2973: void rocksdb::BlockBasedTableIterator<TBlockIter, TValue>::FindBlockForward() [with TBlockIter = rocksdb::DataBlockIter; TValue = rocksdb::Slice]: Assertion `!next_block_is_out_of_bound \|\| user_comparator_.Compare(*read_options_.iterate_upper_bound, index_iter_->user_key()) <= 0' failed. It is likely to be linked to https://github.com/facebook/rocksdb/pull/5286 together with https://github.com/facebook/rocksdb/pull/5468 as the former PR makes some child iterator's seek being avoided, so that upper bound condition fails to be updated there. Strictly speaking, the former PR was merged before the latter one, but the latter one feels a more important improvement so I choose to revert the former one for now. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5871 Differential Revision: D17689196 fbshipit-source-id: 4ded5be68f67bee2782d31a29cb72ea68f59dd8c	2019-10-01 14:41:58 -07:00
Fosco Marotto	749b35d019	Update history and version for 6.5 branch	2019-09-13 11:53:36 -07:00