Add Visual Studio 2015 to AppVeyor (#5446 )

Summary: This is required to compile on Windows with Visual Studio 2015, which is used for creating the RocksJava releases. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5446 Differential Revision: D18924811 fbshipit-source-id: a183a62e79a2af5aaf59cd08235458a172fe7dcb
Don't download from (unreliable) maven.org (#6348 )
2026-11-06 11:02:36 -05:00 · 2020-02-19 13:11:39 -08:00 · 2020-02-19 13:11:32 -08:00 · 2020-02-19 13:11:25 -08:00 · 2020-02-19 13:10:45 -08:00 · 2020-01-31 13:03:51 -08:00
325 changed files with 8444 additions and 17299 deletions
@@ -6,34 +6,25 @@ os:
 compiler:
  - clang
  - gcc
-osx_image: xcode9.4
+osx_image: xcode8.3
 jdk:
  - openjdk7
 cache:
  - ccache
+  - apt

 addons:
  apt:
    sources:
      - ubuntu-toolchain-r-test
    packages:
-      - libgflags-dev
+      - curl
+      - g++-8
      - libbz2-dev
-      - liblz4-dev
+      - libgflags-dev
      - libsnappy-dev
-      - liblzma-dev  # xv
-      - libzstd-dev
+      - mingw-w64
      - zlib1g-dev
-  homebrew:
-    update: true
-    packages:
-      - ccache
-      - gflags
-      - lz4
-      - snappy
-      - xz
-      - zstd
-
 env:
  - TEST_GROUP=platform_dependent # 16-18 minutes
  - TEST_GROUP=1 # 33-35 minutes
@@ -69,21 +60,17 @@ matrix:
  - os : osx
    compiler: gcc

+# https://docs.travis-ci.com/user/caching/#ccache-cache
 install:
  - if [ "${TRAVIS_OS_NAME}" == osx ]; then
+      brew install ccache zstd lz4 snappy xz;
      PATH=$PATH:/usr/local/opt/ccache/libexec;
    fi
  - if [ "${JOB_NAME}" == cmake-gcc8 ]; then
-      sudo apt-get install -y g++-8;
      CC=gcc-8 && CXX=g++-8;
    fi
-  - if [ "${JOB_NAME}" == cmake-mingw ]; then
-      sudo apt-get install -y mingw-w64 ;
-    fi
  - if [[ "${JOB_NAME}" == cmake* ]] && [ "${TRAVIS_OS_NAME}" == linux ]; then
-      CMAKE_DIST_URL="https://rocksdb-deps.s3-us-west-2.amazonaws.com/cmake/cmake-3.14.5-Linux-$(uname -m).tar.bz2";
-      TAR_OPT="--strip-components=1 -xj";
-      mkdir cmake-dist && curl --silent --fail --show-error --location "${CMAKE_DIST_URL}" | tar -C cmake-dist ${TAR_OPT} && export PATH=$PWD/cmake-dist/bin:$PATH;
+      mkdir cmake-dist && curl --silent --fail --show-error --location https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5-Linux-x86_64.tar.gz | tar --strip-components=1 -C cmake-dist -xz && export PATH=$PWD/cmake-dist/bin:$PATH;
    fi
  - if [[ "${JOB_NAME}" == java_test ]]; then
      java -version && echo "JAVA_HOME=${JAVA_HOME}";
@@ -126,7 +113,7 @@ script:
      ;;
    cmake-mingw)
      sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix;
-      mkdir build && cd build && cmake -DJNI=1 -DWITH_GFLAGS=OFF .. -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ -DCMAKE_SYSTEM_NAME=Windows && make -j4 rocksdb rocksdbjni
+      mkdir build && cd build && cmake -DJNI=1 .. -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ -DCMAKE_SYSTEM_NAME=Windows && make -j4 rocksdb rocksdbjni
      ;;
    cmake*)
      mkdir build && cd build && cmake -DJNI=1 .. -DCMAKE_BUILD_TYPE=Release && make -j4 rocksdb rocksdbjni
@@ -45,16 +45,6 @@ if(POLICY CMP0042)
  cmake_policy(SET CMP0042 NEW)
 endif()

-if(NOT CMAKE_BUILD_TYPE)
-  if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
-    set(default_build_type "Debug")
-  else()
-    set(default_build_type "RelWithDebInfo")
-  endif()
-  set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE STRING
-    "Default BUILD_TYPE is ${default_build_type}" FORCE)
-endif()
-
 find_program(CCACHE_FOUND ccache)
 if(CCACHE_FOUND)
  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
@@ -72,7 +62,7 @@ if (WITH_WINDOWS_UTF8_FILENAMES)
 endif()
 # third-party/folly is only validated to work on Linux and Windows for now.
 # So only turn it on there by default.
-if(CMAKE_SYSTEM_NAME MATCHES "Linux|Windows")
+if(CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "Windows")
  if(MSVC AND MSVC_VERSION LESS 1910)
    # Folly does not compile with MSVC older than VS2017
    option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" OFF)
@@ -82,12 +72,10 @@ if(CMAKE_SYSTEM_NAME MATCHES "Linux|Windows")
 else()
  option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" OFF)
 endif()
-
-include(CMakeDependentOption)
-CMAKE_DEPENDENT_OPTION(WITH_GFLAGS "build with GFlags" ON
-  "NOT MSVC;NOT MINGW" OFF)
-
 if(MSVC)
+  # Defaults currently different for GFLAGS.
+  #  We will address find_package work a little later
+  option(WITH_GFLAGS "build with GFlags" OFF)
  option(WITH_XPRESS "build with windows built in compression" OFF)
  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
 else()
@@ -104,11 +92,14 @@ else()
  endif()

  # No config file for this
+  option(WITH_GFLAGS "build with GFlags" ON)
  if(WITH_GFLAGS)
-    find_package(gflags REQUIRED)
-    add_definitions(-DGFLAGS=1)
-    include_directories(${gflags_INCLUDE_DIR})
-    list(APPEND THIRDPARTY_LIBS gflags::gflags)
+    find_package(gflags)
+    if(gflags_FOUND)
+      add_definitions(-DGFLAGS=1)
+      include_directories(${gflags_INCLUDE_DIR})
+      list(APPEND THIRDPARTY_LIBS ${gflags_LIBRARIES})
+    endif()
  endif()

  if(WITH_SNAPPY)
@@ -559,7 +550,6 @@ set(SOURCES
        env/env_chroot.cc
        env/env_encryption.cc
        env/env_hdfs.cc
-        env/file_system.cc
        env/mock_env.cc
        file/delete_scheduler.cc
        file/file_prefetch_buffer.cc
@@ -646,6 +636,7 @@ set(SOURCES
        test_util/testutil.cc
        test_util/transaction_test_util.cc
        tools/block_cache_analyzer/block_cache_trace_analyzer.cc
+        tools/db_bench_tool.cc
        tools/dump/db_dump_tool.cc
        tools/ldb_cmd.cc
        tools/ldb_tool.cc
@@ -767,7 +758,6 @@ else()
  list(APPEND SOURCES
    port/port_posix.cc
    env/env_posix.cc
-    env/fs_posix.cc
    env/io_posix.cc)
 endif()

@@ -782,8 +772,7 @@ endif()

 set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
 set(ROCKSDB_SHARED_LIB rocksdb-shared${ARTIFACT_SUFFIX})
-
-option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
+set(ROCKSDB_IMPORT_LIB ${ROCKSDB_SHARED_LIB})

 option(WITH_LIBRADOS "Build with librados" OFF)
 if(WITH_LIBRADOS)
@@ -794,44 +783,40 @@ endif()

 if(WIN32)
  set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
+  set(LIBS ${ROCKSDB_STATIC_LIB} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
 else()
  set(SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT})
+  set(LIBS ${ROCKSDB_SHARED_LIB} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
+
+  add_library(${ROCKSDB_SHARED_LIB} SHARED ${SOURCES})
+  target_link_libraries(${ROCKSDB_SHARED_LIB}
+    ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
+  set_target_properties(${ROCKSDB_SHARED_LIB} PROPERTIES
+                        LINKER_LANGUAGE CXX
+                        VERSION ${rocksdb_VERSION}
+                        SOVERSION ${rocksdb_VERSION_MAJOR}
+                        CXX_STANDARD 11
+                        OUTPUT_NAME "rocksdb")
 endif()

 add_library(${ROCKSDB_STATIC_LIB} STATIC ${SOURCES})
 target_link_libraries(${ROCKSDB_STATIC_LIB}
  ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})

-if(ROCKSDB_BUILD_SHARED)
-  add_library(${ROCKSDB_SHARED_LIB} SHARED ${SOURCES})
-  target_link_libraries(${ROCKSDB_SHARED_LIB}
+if(WIN32)
+  add_library(${ROCKSDB_IMPORT_LIB} SHARED ${SOURCES})
+  target_link_libraries(${ROCKSDB_IMPORT_LIB}
    ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
-
-  if(WIN32)
-    set_target_properties(${ROCKSDB_SHARED_LIB} PROPERTIES
-      COMPILE_DEFINITIONS "ROCKSDB_DLL;ROCKSDB_LIBRARY_EXPORTS")
-    if(MSVC)
-      set_target_properties(${ROCKSDB_STATIC_LIB} PROPERTIES
-        COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_STATIC_LIB}.pdb")
-      set_target_properties(${ROCKSDB_SHARED_LIB} PROPERTIES
-        COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_SHARED_LIB}.pdb")
-    endif()
-  else()
-    set_target_properties(${ROCKSDB_SHARED_LIB} PROPERTIES
-                          LINKER_LANGUAGE CXX
-                          VERSION ${rocksdb_VERSION}
-                          SOVERSION ${rocksdb_VERSION_MAJOR}
-                          CXX_STANDARD 11
-                          OUTPUT_NAME "rocksdb")
+  set_target_properties(${ROCKSDB_IMPORT_LIB} PROPERTIES
+    COMPILE_DEFINITIONS "ROCKSDB_DLL;ROCKSDB_LIBRARY_EXPORTS")
+  if(MSVC)
+    set_target_properties(${ROCKSDB_STATIC_LIB} PROPERTIES
+      COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_STATIC_LIB}.pdb")
+    set_target_properties(${ROCKSDB_IMPORT_LIB} PROPERTIES
+      COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_IMPORT_LIB}.pdb")
  endif()
 endif()

-if(ROCKSDB_BUILD_SHARED AND NOT WIN32)
-  set(ROCKSDB_LIB ${ROCKSDB_SHARED_LIB})
-else()
-  set(ROCKSDB_LIB ${ROCKSDB_STATIC_LIB})
-endif()
-
 option(WITH_JNI "build with JNI" OFF)
 if(WITH_JNI OR JNI)
  message(STATUS "JNI library is enabled")
@@ -878,17 +863,15 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
  )

-  if(ROCKSDB_BUILD_SHARED)
-    install(
-      TARGETS ${ROCKSDB_SHARED_LIB}
-      EXPORT RocksDBTargets
-      COMPONENT runtime
-      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-    )
-  endif()
+  install(
+    TARGETS ${ROCKSDB_SHARED_LIB}
+    EXPORT RocksDBTargets
+    COMPONENT runtime
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )

  install(
    EXPORT RocksDBTargets
@@ -906,15 +889,11 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
  )
 endif()

-add_subdirectory(third-party/gtest-1.8.1/fused-src/gtest)
-add_library(testharness STATIC
-  test_util/testharness.cc)
-target_link_libraries(testharness gtest)
-
-# Tests are excluded from Release builds
-CMAKE_DEPENDENT_OPTION(WITH_TESTS "build with tests" ON
-  "CMAKE_BUILD_TYPE STREQUAL Debug" OFF)
-if(WITH_TESTS)
+option(WITH_TESTS "build with tests" ON)
+# For test libraries, utilities, and exes that are build iff WITH_TESTS=ON and
+# in Debug mode. Add test only code that is not #ifdefed for Release here.
+if(WITH_TESTS AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+  add_subdirectory(third-party/gtest-1.8.1/fused-src/gtest)
  set(TESTS
        cache/cache_test.cc
        cache/lru_cache_test.cc
@@ -1030,7 +1009,6 @@ if(WITH_TESTS)
        util/filelock_test.cc
        util/hash_test.cc
        util/heap_test.cc
-        util/random_test.cc
        util/rate_limiter_test.cc
        util/repeatable_thread_test.cc
        util/slice_transform_test.cc
@@ -1080,7 +1058,7 @@ if(WITH_TESTS)
  add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})
  set(TESTUTILLIB testutillib${ARTIFACT_SUFFIX})
  add_library(${TESTUTILLIB} STATIC ${TESTUTIL_SOURCE})
-  target_link_libraries(${TESTUTILLIB} ${ROCKSDB_LIB})
+  target_link_libraries(${TESTUTILLIB} ${LIBS})
  if(MSVC)
    set_target_properties(${TESTUTILLIB} PROPERTIES COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/testutillib${ARTIFACT_SUFFIX}.pdb")
  endif()
@@ -1090,92 +1068,67 @@ if(WITH_TESTS)
        EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
        )

-  foreach(sourcefile ${TESTS})
+  set(TEST_EXES ${TESTS})
+  foreach(sourcefile ${TEST_EXES})
      get_filename_component(exename ${sourcefile} NAME_WE)
-      add_executable(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} ${sourcefile})
+      add_executable(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} ${sourcefile}
+        $<TARGET_OBJECTS:testharness>)
      set_target_properties(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX}
        PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD_RELEASE 1
        EXCLUDE_FROM_DEFAULT_BUILD_MINRELEASE 1
        EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
        OUTPUT_NAME ${exename}${ARTIFACT_SUFFIX}
        )
-      target_link_libraries(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} testharness gtest ${ROCKSDB_LIB})
+      target_link_libraries(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} gtest ${LIBS})
      if(NOT "${exename}" MATCHES "db_sanity_test")
        add_test(NAME ${exename} COMMAND ${exename}${ARTIFACT_SUFFIX})
        add_dependencies(check ${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX})
      endif()
-  endforeach(sourcefile ${TESTS})
+  endforeach(sourcefile ${TEST_EXES})

-  if(WIN32)
-    # C executables must link to a shared object
-    if(ROCKSDB_BUILD_SHARED)
-      set(ROCKSDB_LIB_FOR_C ${ROCKSDB_SHARED_LIB})
-    else()
-      set(ROCKSDB_LIB_FOR_C OFF)
-    endif()
-  else()
-    set(ROCKSDB_LIB_FOR_C ${ROCKSDB_LIB})
-  endif()
+  # C executables must link to a shared object
+  set(C_TESTS db/c_test.c)
+  set(C_TEST_EXES ${C_TESTS})

-  if(ROCKSDB_LIB_FOR_C)
-    set(C_TESTS db/c_test.c)
-    # C executables must link to a shared object
-    add_executable(c_test db/c_test.c)
-    target_link_libraries(c_test ${ROCKSDB_SHARED_LIB} testharness)
-    add_test(NAME c_test COMMAND c_test${ARTIFACT_SUFFIX})
-    add_dependencies(check c_test)
-  endif()
+  foreach(sourcefile ${C_TEST_EXES})
+      string(REPLACE ".c" "" exename ${sourcefile})
+      string(REGEX REPLACE "^((.+)/)+" "" exename ${exename})
+      add_executable(${exename}${ARTIFACT_SUFFIX} ${sourcefile})
+      set_target_properties(${exename}${ARTIFACT_SUFFIX}
+        PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD_RELEASE 1
+        EXCLUDE_FROM_DEFAULT_BUILD_MINRELEASE 1
+        EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
+        )
+      target_link_libraries(${exename}${ARTIFACT_SUFFIX} ${ROCKSDB_IMPORT_LIB} testutillib${ARTIFACT_SUFFIX})
+      add_test(NAME ${exename} COMMAND ${exename}${ARTIFACT_SUFFIX})
+      add_dependencies(check ${exename}${ARTIFACT_SUFFIX})
+  endforeach(sourcefile ${C_TEST_EXES})
 endif()

 option(WITH_BENCHMARK_TOOLS "build with benchmarks" ON)
 if(WITH_BENCHMARK_TOOLS)
-  add_executable(db_bench
-    tools/db_bench.cc
-    tools/db_bench_tool.cc)
-  target_link_libraries(db_bench
-    ${ROCKSDB_LIB})
-
-  add_executable(cache_bench
-    cache/cache_bench.cc)
-  target_link_libraries(cache_bench
-    ${ROCKSDB_LIB})
-
-  add_executable(memtablerep_bench
-    memtable/memtablerep_bench.cc)
-  target_link_libraries(memtablerep_bench
-    ${ROCKSDB_LIB})
-
-  add_executable(range_del_aggregator_bench
-    db/range_del_aggregator_bench.cc)
-  target_link_libraries(range_del_aggregator_bench
-    ${ROCKSDB_LIB})
-
-  add_executable(table_reader_bench
-    table/table_reader_bench.cc)
-  target_link_libraries(table_reader_bench
-    ${ROCKSDB_LIB} testharness)
-
-  add_executable(filter_bench
-    util/filter_bench.cc)
-  target_link_libraries(filter_bench
-    ${ROCKSDB_LIB})
-
-  add_executable(hash_table_bench
-    utilities/persistent_cache/hash_table_bench.cc)
-  target_link_libraries(hash_table_bench
-    ${ROCKSDB_LIB})
+  if(NOT TARGET gtest)
+    add_subdirectory(third-party/gtest-1.8.1/fused-src/gtest)
+  endif()
+  set(BENCHMARKS
+        cache/cache_bench.cc
+        memtable/memtablerep_bench.cc
+        db/range_del_aggregator_bench.cc
+        tools/db_bench.cc
+        table/table_reader_bench.cc
+        util/filter_bench.cc
+        utilities/persistent_cache/hash_table_bench.cc
+  )
+  add_library(testharness OBJECT test_util/testharness.cc)
+  foreach(sourcefile ${BENCHMARKS})
+    get_filename_component(exename ${sourcefile} NAME_WE)
+    add_executable(${exename}${ARTIFACT_SUFFIX} ${sourcefile}
+      $<TARGET_OBJECTS:testharness>)
+    target_link_libraries(${exename}${ARTIFACT_SUFFIX} gtest ${LIBS})
+  endforeach(sourcefile ${BENCHMARKS})
 endif()

-option(WITH_CORE_TOOLS "build with ldb and sst_dump" ON)
 option(WITH_TOOLS "build with tools" ON)
-if(WITH_CORE_TOOLS OR WITH_TOOLS)
-  add_subdirectory(tools)
-  add_custom_target(core_tools
-    DEPENDS ${core_tool_deps})
-endif()
-
 if(WITH_TOOLS)
-  add_subdirectory(db_stress_tool)
-  add_custom_target(tools
-    DEPENDS ${tool_deps})
+  add_subdirectory(tools)
 endif()
@@ -1,44 +1,13 @@
 # Rocksdb Change Log
 ## Unreleased
-### Bug Fixes
-* Upgraded version of bzip library (1.0.6 -> 1.0.8) used with RocksJava to address potential vulnerabilities if an attacker can manipulate compressed data saved and loaded by RocksDB (not normal). See issue #6703.

-## 6.7.3 (03/18/2020)
-### Bug Fixes
-* Fix a data race that might cause crash when calling DB::GetCreationTimeOfOldestFile() by a small chance. The bug was introduced in 6.6 Release.
-
-## 6.7.2 (02/24/2020)
-### Bug Fixes
-* Fixed a bug of IO Uring partial result handling introduced in 6.7.0.
-
-
-## 6.7.1 (02/13/2020)
+## 6.6.4 (1/31/2020)
 ### Bug Fixes
 * Fixed issue #6316 that can cause a corruption of the MANIFEST file in the middle when writing to it fails due to no disk space.
-* Batched MultiGet() ignores IO errors while reading data blocks, causing it to potentially continue looking for a key and returning stale results.
-
-## 6.7.0 (01/21/2020)
-### Public API Change
-* Added a rocksdb::FileSystem class in include/rocksdb/file_system.h to encapsulate file creation/read/write operations, and an option DBOptions::file_system to allow a user to pass in an instance of rocksdb::FileSystem. If its a non-null value, this will take precendence over DBOptions::env for file operations. A new API rocksdb::FileSystem::Default() returns a platform default object. The DBOptions::env option and Env::Default() API will continue to be used for threading and other OS related functions, and where DBOptions::file_system is not specified, for file operations. For storage developers who are accustomed to rocksdb::Env, the interface in rocksdb::FileSystem is new and will probably undergo some changes as more storage systems are ported to it from rocksdb::Env. As of now, no env other than Posix has been ported to the new interface.
-* A new rocksdb::NewSstFileManager() API that allows the caller to pass in separate Env and FileSystem objects.
-* Changed Java API for RocksDB.keyMayExist functions to use Holder<byte[]> instead of StringBuilder, so that retrieved values need not decode to Strings.
-* A new `OptimisticTransactionDBOptions` Option that allows users to configure occ validation policy. The default policy changes from kValidateSerial to kValidateParallel to reduce mutex contention.

+## 6.6.3 (01/24/2020)
 ### Bug Fixes
-* Fix a bug that can cause unnecessary bg thread to be scheduled(#6104).
-* Fix crash caused by concurrent CF iterations and drops(#6147).
-* Fix a race condition for cfd->log_number_ between manifest switch and memtable switch (PR 6249) when number of column families is greater than 1.
-* Fix a bug on fractional cascading index when multiple files at the same level contain the same smallest user key, and those user keys are for merge operands. In this case, Get() the exact key may miss some merge operands.
-* Delcare kHashSearch index type feature-incompatible with index_block_restart_interval larger than 1.
-* Fixed an issue where the thread pools were not resized upon setting `max_background_jobs` dynamically through the `SetDBOptions` interface.
 * Fix a bug that can cause write threads to hang when a slowdown/stall happens and there is a mix of writers with WriteOptions::no_slowdown set/unset.
-* Fixed an issue where an incorrect "number of input records" value was used to compute the "records dropped" statistics for compactions.
-
-### New Features
-* It is now possible to enable periodic compactions for the base DB when using BlobDB.
-* BlobDB now garbage collects non-TTL blobs when `enable_garbage_collection` is set to `true` in `BlobDBOptions`. Garbage collection is performed during compaction: any valid blobs located in the oldest N files (where N is the number of non-TTL blob files multiplied by the value of `BlobDBOptions::garbage_collection_cutoff`) encountered during compaction get relocated to new blob files, and old blob files are dropped once they are no longer needed. Note: we recommend enabling periodic compactions for the base DB when using this feature to deal with the case when some old blob files are kept alive by SSTs that otherwise do not get picked for compaction.
-* `db_bench` now supports the `garbage_collection_cutoff` option for BlobDB.
-* MultiGet() can use IO Uring to parallelize read from the same SST file. This featuer is by default disabled. It can be enabled with environment variable ROCKSDB_USE_IO_URING.

 ## 6.6.2 (01/13/2020)
 ### Bug Fixes
@@ -56,10 +25,10 @@

 ## 6.6.0 (11/25/2019)
 ### Bug Fixes
-* Fix data corruption caused by output of intra-L0 compaction on ingested file not being placed in correct order in L0.
+* Fix data corruption casued by output of intra-L0 compaction on ingested file not being placed in correct order in L0.
 * Fix a data race between Version::GetColumnFamilyMetaData() and Compaction::MarkFilesBeingCompacted() for access to being_compacted (#6056). The current fix acquires the db mutex during Version::GetColumnFamilyMetaData(), which may cause regression.
 * Fix a bug in DBIter that is_blob_ state isn't updated when iterating backward using seek.
-* Fix a bug when format_version=3, partitioned filters, and prefix search are used in conjunction. The bug could result into Seek::(prefix) returning NotFound for an existing prefix.
+* 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.
 * Fix a bug causing a crash during ingest external file when background compaction cause severe error (file not found).
 * 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.
@@ -72,13 +41,13 @@
 * Universal compaction to support options.periodic_compaction_seconds. A full compaction will be triggered if any file is over the threshold.
 * `GetLiveFilesMetaData` and `GetColumnFamilyMetaData` now expose the file number of SST files as well as the oldest blob file referenced by each SST.
 * A batched MultiGet API (DB::MultiGet()) that supports retrieving keys from multiple column families.
-* Full and partitioned filters in the block-based table use an improved Bloom filter implementation, enabled with format_version 5 (or above) because previous releases cannot read this filter. This replacement is faster and more accurate, especially for high bits per key or millions of keys in a single (full) filter. For example, the new Bloom filter has the same false positive rate at 9.55 bits per key as the old one at 10 bits per key, and a lower false positive rate at 16 bits per key than the old one at 100 bits per key.
+* Full and partitioned filters in the block-based table use an improved Bloom filter implementation, enabled with format_version 5 (or above) because previous releases cannot read this filter. This replacement is faster and more accurate, especially for high bits per key or millions of keys in a single (full) filter. For example, the new Bloom filter has the same false postive rate at 9.55 bits per key as the old one at 10 bits per key, and a lower false positive rate at 16 bits per key than the old one at 100 bits per key.
 * Added AVX2 instructions to USE_SSE builds to accelerate the new Bloom filter and XXH3-based hash function on compatible x86_64 platforms (Haswell and later, ~2014).
 * Support options.ttl or options.periodic_compaction_seconds with options.max_open_files = -1. File's oldest ancester time and file creation time will be written to manifest. If it is availalbe, this information will be used instead of creation_time and file_creation_time in table properties.
 * Setting options.ttl for universal compaction now has the same meaning as setting periodic_compaction_seconds.
 * SstFileMetaData also returns file creation time and oldest ancester time.
 * 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 management 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.
+* 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.
 * When using BlobDB, a mapping is maintained and persisted in the MANIFEST between each SST file and the oldest non-TTL blob file it references.
 * `db_bench` now supports and by default issues non-TTL Puts to BlobDB. TTL Puts can be enabled by specifying a non-zero value for the `blob_db_max_ttl_range` command line parameter explicitly.
 * `sst_dump` now supports printing BlobDB blob indexes in a human-readable format. This can be enabled by specifying the `decode_blob_index` flag on the command line.
@@ -101,7 +70,7 @@

 ### Default Option Changes
 * Changed the default value of periodic_compaction_seconds to `UINT64_MAX - 1` which allows RocksDB to auto-tune periodic compaction scheduling. When using the default value, periodic compactions are now auto-enabled if a compaction filter is used. A value of `0` will turn off the feature completely.
-* Changed the default value of ttl to `UINT64_MAX - 1` which allows RocksDB to auto-tune ttl value. When using the default value, TTL will be auto-enabled to 30 days, when the feature is supported. To revert the old behavior, you can explicitly set it to 0.
+* Changed the default value of ttl to `UINT64_MAX - 1` which allows RocksDB to auto-tune ttl value. When using the default value, TTL will be auto-enabled to 30 days, when the feature is supported. To revert the old behavior, you can explictly set it to 0.

 ### Performance Improvements
 * For 64-bit hashing, RocksDB is standardizing on a slightly modified preview version of XXH3. This function is now used for many non-persisted hashes, along with fastrange64() in place of the modulus operator, and some benchmarks show a slight improvement.
@@ -142,7 +111,7 @@

 ## 6.4.0 (7/30/2019)
 ### Default Option Change
-* LRUCacheOptions.high_pri_pool_ratio is set to 0.5 (previously 0.0) by default, which means that by default midpoint insertion is enabled. The same change is made for the default value of high_pri_pool_ratio argument in NewLRUCache(). When block cache is not explicitly created, the small block cache created by BlockBasedTable will still has this option to be 0.0.
+* LRUCacheOptions.high_pri_pool_ratio is set to 0.5 (previously 0.0) by default, which means that by default midpoint insertion is enabled. The same change is made for the default value of high_pri_pool_ratio argument in NewLRUCache(). When block cache is not explictly created, the small block cache created by BlockBasedTable will still has this option to be 0.0.
 * Change BlockBasedTableOptions.cache_index_and_filter_blocks_with_high_priority's default value from false to true.

 ### Public API Change
@@ -166,7 +135,7 @@
 * Support loading custom objects in unit tests. In the affected unit tests, RocksDB will create custom Env objects based on environment variable TEST_ENV_URI. Users need to make sure custom object types are properly registered. For example, a static library should expose a `RegisterCustomObjects` function. By linking the unit test binary with the static library, the unit test can execute this function.

 ### Performance Improvements
-* Reduce iterator key comparison for upper/lower bound check.
+* Reduce iterator key comparision for upper/lower bound check.
 * Improve performance of row_cache: make reads with newer snapshots than data in an SST file share the same cache key, except in some transaction cases.
 * The compression dictionary is no longer copied to a new object upon retrieval.

@@ -262,7 +231,7 @@
 * Introduce two more stats levels, kExceptHistogramOrTimers and kExceptTimers.
 * Added a feature to perform data-block sampling for compressibility, and report stats to user.
 * Add support for trace filtering.
-* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destroying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background.
+* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destorying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background.

 ### Public API Change
 * Remove bundled fbson library.
@@ -641,7 +610,7 @@ if set to something > 0 user will see 2 changes in iterators behavior 1) only ke

 ## 5.2.0 (02/08/2017)
 ### Public API Change
-* NewLRUCache() will determine number of shard bits automatically based on capacity, if the user doesn't pass one. This also impacts the default block cache when the user doesn't explicit provide one.
+* NewLRUCache() will determine number of shard bits automatically based on capacity, if the user doesn't pass one. This also impacts the default block cache when the user doesn't explict provide one.
 * Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files.
 * Options::use_direct_writes and Options::use_direct_reads are now ready to use.
 * (Experimental) Two-level indexing that partition the index and creates a 2nd level index on the partitions. The feature can be enabled by setting kTwoLevelIndexSearch as IndexType and configuring index_per_partition.
@@ -712,7 +681,7 @@ if set to something > 0 user will see 2 changes in iterators behavior 1) only ke

 ### New Features
 * A tool to migrate DB after options change. See include/rocksdb/utilities/option_change_migration.h.
-* Add ReadOptions.background_purge_on_iterator_cleanup. If true, we avoid file deletion when destroying iterators.
+* Add ReadOptions.background_purge_on_iterator_cleanup. If true, we avoid file deletion when destorying iterators.

 ## 4.10.0 (7/5/2016)
 ### Public API Change
@@ -460,7 +460,6 @@ TESTS = \
 	env_test \
 	env_logger_test \
 	hash_test \
-	random_test \
 	thread_local_test \
 	rate_limiter_test \
 	perf_context_test \
@@ -744,8 +743,7 @@ endif  # PLATFORM_SHARED_EXT
 	release tags tags0 valgrind_check whitebox_crash_test format static_lib shared_lib all \
 	dbg rocksdbjavastatic rocksdbjava install install-static install-shared uninstall \
 	analyze tools tools_lib \
-	blackbox_crash_test_with_atomic_flush whitebox_crash_test_with_atomic_flush  \
-	blackbox_crash_test_with_txn whitebox_crash_test_with_txn
+	blackbox_crash_test_with_atomic_flush whitebox_crash_test_with_atomic_flush


 all: $(LIBRARY) $(BENCHMARKS) tools tools_lib test_libs $(TESTS)
@@ -939,7 +937,6 @@ check: all
 	fi
 	rm -rf $(TMPD)
 ifneq ($(PLATFORM), OS_AIX)
-	python tools/check_all_python.py
 ifeq ($(filter -DROCKSDB_LITE,$(OPT)),)
 	python tools/ldb_test.py
 	sh tools/rocksdb_dump_test.sh
@@ -958,8 +955,6 @@ crash_test: whitebox_crash_test blackbox_crash_test

 crash_test_with_atomic_flush: whitebox_crash_test_with_atomic_flush blackbox_crash_test_with_atomic_flush

-crash_test_with_txn: whitebox_crash_test_with_txn blackbox_crash_test_with_txn
-
 blackbox_crash_test: db_stress
 	python -u tools/db_crashtest.py --simple blackbox $(CRASH_TEST_EXT_ARGS)
 	python -u tools/db_crashtest.py blackbox $(CRASH_TEST_EXT_ARGS)
@@ -967,9 +962,6 @@ blackbox_crash_test: db_stress
 blackbox_crash_test_with_atomic_flush: db_stress
 	python -u tools/db_crashtest.py --cf_consistency blackbox $(CRASH_TEST_EXT_ARGS)

-blackbox_crash_test_with_txn: db_stress
-	python -u tools/db_crashtest.py --txn blackbox $(CRASH_TEST_EXT_ARGS)
-
 ifeq ($(CRASH_TEST_KILL_ODD),)
  CRASH_TEST_KILL_ODD=888887
 endif
@@ -984,10 +976,6 @@ whitebox_crash_test_with_atomic_flush: db_stress
 	python -u tools/db_crashtest.py --cf_consistency whitebox  --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

-whitebox_crash_test_with_txn: db_stress
-	python -u tools/db_crashtest.py --txn whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
 asan_check:
 	$(MAKE) clean
 	COMPILE_WITH_ASAN=1 $(MAKE) check -j32
@@ -1003,11 +991,6 @@ asan_crash_test_with_atomic_flush:
 	COMPILE_WITH_ASAN=1 $(MAKE) crash_test_with_atomic_flush
 	$(MAKE) clean

-asan_crash_test_with_txn:
-	$(MAKE) clean
-	COMPILE_WITH_ASAN=1 $(MAKE) crash_test_with_txn
-	$(MAKE) clean
-
 ubsan_check:
 	$(MAKE) clean
 	COMPILE_WITH_UBSAN=1 $(MAKE) check -j32
@@ -1023,11 +1006,6 @@ ubsan_crash_test_with_atomic_flush:
 	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_atomic_flush
 	$(MAKE) clean

-ubsan_crash_test_with_txn:
-	$(MAKE) clean
-	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_txn
-	$(MAKE) clean
-
 valgrind_test:
 	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

@@ -1097,9 +1075,6 @@ parallel_check: $(TESTS)
 		TMPD=$(TMPD) J=$(J) db_test=0 parloop;

 analyze: clean
-	USE_CLANG=1 $(MAKE) analyze_incremental
-
-analyze_incremental:
 	$(CLANG_SCAN_BUILD) --use-analyzer=$(CLANG_ANALYZER) \
 		--use-c++=$(CXX) --use-cc=$(CC) --status-bugs \
 		-o $(CURDIR)/scan_build_report \
@@ -1213,7 +1188,7 @@ memtablerep_bench: memtable/memtablerep_bench.o $(LIBOBJECTS) $(TESTUTIL)
 filter_bench: util/filter_bench.o $(LIBOBJECTS) $(TESTUTIL)
 	$(AM_LINK)

-db_stress: db_stress_tool/db_stress.o $(STRESSTOOLOBJECTS)
+db_stress: tools/db_stress.o $(STRESSTOOLOBJECTS)
 	$(AM_LINK)

 write_stress: tools/write_stress.o $(LIBOBJECTS) $(TESTUTIL)
@@ -1255,9 +1230,6 @@ coding_test: util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS)
 hash_test: util/hash_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-random_test: util/random_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 option_change_migration_test: utilities/option_change_migration/option_change_migration_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1789,11 +1761,11 @@ SHA256_CMD = sha256sum
 ZLIB_VER ?= 1.2.11
 ZLIB_SHA256 ?= c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1
 ZLIB_DOWNLOAD_BASE ?= http://zlib.net
-BZIP2_VER ?= 1.0.8
-BZIP2_SHA256 ?= ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269
-BZIP2_DOWNLOAD_BASE ?= https://sourceware.org/pub/bzip2
-SNAPPY_VER ?= 1.1.8
-SNAPPY_SHA256 ?= 16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f
+BZIP2_VER ?= 1.0.6
+BZIP2_SHA256 ?= a2848f34fcd5d6cf47def00461fcb528a0484d8edef8208d6d2e2909dc61d9cd
+BZIP2_DOWNLOAD_BASE ?= https://downloads.sourceforge.net/project/bzip2
+SNAPPY_VER ?= 1.1.7
+SNAPPY_SHA256 ?= 3dfa02e873ff51a11ee02b9ca391807f0c8ea0529a4924afa645fbf97163f9d4
 SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
 LZ4_VER ?= 1.9.2
 LZ4_SHA256 ?= 658ba6191fa44c92280d4aa2c271b0f4fbc0e34d249578dd05e50e76d0e5efcc
@@ -2060,7 +2032,6 @@ jtest_run:

 jtest: rocksdbjava
 	cd java;$(MAKE) sample;$(MAKE) test;
-	python tools/check_all_python.py # TODO peterd: find a better place for this check in CI targets

 jdb_bench:
 	cd java;$(MAKE) db_bench;
@@ -2108,9 +2079,6 @@ endif
 .cc.o:
 	$(AM_V_CC)$(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)

-.cpp.o:
-	$(AM_V_CC)$(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)
-
 .c.o:
 	$(AM_V_CC)$(CC) $(CFLAGS) -c $< -o $@
 endif
@@ -2121,10 +2089,6 @@ endif
 all_sources = $(LIB_SOURCES) $(MAIN_SOURCES) $(MOCK_LIB_SOURCES) $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(TEST_LIB_SOURCES) $(ANALYZER_LIB_SOURCES) $(STRESS_LIB_SOURCES)
 DEPFILES = $(all_sources:.cc=.cc.d)

-ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
-  DEPFILES += $(FOLLY_SOURCES:.cpp=.cpp.d)
-endif
-
 # Add proper dependency support so changing a .h file forces a .cc file to
 # rebuild.

@@ -2134,10 +2098,6 @@ endif
 	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
 	  -MM -MT'$@' -MT'$(<:.cc=.o)' "$<" -o '$@'

-%.cpp.d: %.cpp
-	@$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) \
-	  -MM -MT'$@' -MT'$(<:.cpp=.o)' "$<" -o '$@'
-
 ifeq ($(HAVE_POWER8),1)
 DEPFILES_C = $(LIB_SOURCES_C:.c=.c.d)
 DEPFILES_ASM = $(LIB_SOURCES_ASM:.S=.S.d)
@@ -26,7 +26,6 @@ ROCKSDB_EXTERNAL_DEPS = [
    ("lz4", None, "lz4"),
    ("zstd", None),
    ("tbb", None),
-    ("liburing", None, "uring"),
    ("googletest", None, "gtest"),
 ]

@@ -47,9 +46,7 @@ ROCKSDB_OS_PREPROCESSOR_FLAGS = [
            "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
            "-DROCKSDB_RANGESYNC_PRESENT",
            "-DROCKSDB_SCHED_GETCPU_PRESENT",
-            "-DROCKSDB_IOURING_PRESENT",
            "-DHAVE_SSE42",
-            "-DLIBURING",
            "-DNUMA",
        ],
    ),
@@ -73,7 +70,6 @@ ROCKSDB_PREPROCESSOR_FLAGS = [
    "-DZSTD_STATIC_LINKING_ONLY",
    "-DGFLAGS=gflags",
    "-DTBB",
-    "-DLIBURING",

    # Added missing flags from output of build_detect_platform
    "-DROCKSDB_BACKTRACE",
@@ -182,8 +178,6 @@ cpp_library(
        "env/env_encryption.cc",
        "env/env_hdfs.cc",
        "env/env_posix.cc",
-        "env/file_system.cc",
-        "env/fs_posix.cc",
        "env/io_posix.cc",
        "env/mock_env.cc",
        "file/delete_scheduler.cc",
@@ -405,17 +399,9 @@ cpp_library(
 cpp_library(
    name = "rocksdb_stress_lib",
    srcs = [
-        "db_stress_tool/batched_ops_stress.cc",
-        "db_stress_tool/cf_consistency_stress.cc",
-        "db_stress_tool/db_stress_common.cc",
-        "db_stress_tool/db_stress_driver.cc",
-        "db_stress_tool/db_stress_gflags.cc",
-        "db_stress_tool/db_stress_shared_state.cc",
-        "db_stress_tool/db_stress_test_base.cc",
-        "db_stress_tool/db_stress_tool.cc",
-        "db_stress_tool/no_batched_ops_stress.cc",
        "test_util/testutil.cc",
        "tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
+        "tools/db_stress_tool.cc",
        "tools/trace_analyzer_tool.cc",
    ],
    auto_headers = AutoHeaders.RECURSIVE_GLOB,
@@ -1248,13 +1234,6 @@ ROCKS_TESTS = [
        [],
        [],
    ],
-    [
-        "random_test",
-        "util/random_test.cc",
-        "serial",
-        [],
-        [],
-    ],
    [
        "range_del_aggregator_test",
        "db/range_del_aggregator_test.cc",
@@ -102,7 +102,3 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed
 
 ## 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.
-
-## Nebula Graph
-
-[Nebula Graph](https://github.com/vesoft-inc/nebula) is a distributed, scalable, lightning-fast, open source graph database capable of hosting super large scale graphs with dozens of billions of vertices (nodes) and trillions of edges, with milliseconds of latency.
@@ -32,7 +32,6 @@ ROCKSDB_EXTERNAL_DEPS = [
    ("lz4", None, "lz4"),
    ("zstd", None),
    ("tbb", None),
-    ("liburing", None, "uring"),
    ("googletest", None, "gtest"),
 ]

@@ -53,9 +52,7 @@ ROCKSDB_OS_PREPROCESSOR_FLAGS = [
            "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
            "-DROCKSDB_RANGESYNC_PRESENT",
            "-DROCKSDB_SCHED_GETCPU_PRESENT",
-            "-DROCKSDB_IOURING_PRESENT",
            "-DHAVE_SSE42",
-            "-DLIBURING",
            "-DNUMA",
        ],
    ),
@@ -79,7 +76,6 @@ ROCKSDB_PREPROCESSOR_FLAGS = [
    "-DZSTD_STATIC_LINKING_ONLY",
    "-DGFLAGS=gflags",
    "-DTBB",
-    "-DLIBURING",

    # Added missing flags from output of build_detect_platform
    "-DROCKSDB_BACKTRACE",
@@ -150,21 +150,6 @@ case "$TARGET_OS" in
            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
        fi
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
-        if test $ROCKSDB_USE_IO_URING; then
-            # check for liburing
-            $CXX $CFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
-              #include <liburing.h>
-              int main() {
-                struct io_uring ring;
-                io_uring_queue_init(1, &ring, 0);
-                return 0;
-              }
-EOF
-            if [ "$?" = 0 ]; then
-                PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring"
-                COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
-            fi
-        fi
        if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
          USE_FOLLY_DISTRIBUTED_MUTEX=1
        fi
@@ -13,7 +13,6 @@ JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b86
 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
-LIBURING_BASE=/mnt/gvfs/third-party2/liburing/79427253fd0d42677255aacfe6d13bfe63f752eb/20190828/platform007/ca4da3d
 KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/fb/platform007/da39a3e
 BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/ab9f09bba370e7066cafd4eb59752db93f2e8312/2.29.1/platform007/15a3614
 VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/platform007/ca4da3d
@@ -133,16 +133,13 @@ _TEST_NAME_TO_PARSERS = {
    'lite_test': [CompilerErrorParser, GTestErrorParser],
    'stress_crash': [CompilerErrorParser, DbCrashErrorParser],
    'stress_crash_with_atomic_flush': [CompilerErrorParser, DbCrashErrorParser],
-    'stress_crash_with_txn': [CompilerErrorParser, DbCrashErrorParser],
    'write_stress': [CompilerErrorParser, WriteStressErrorParser],
    'asan': [CompilerErrorParser, GTestErrorParser, AsanErrorParser],
    'asan_crash': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
    'asan_crash_with_atomic_flush': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
-    'asan_crash_with_txn': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
    'ubsan': [CompilerErrorParser, GTestErrorParser, UbsanErrorParser],
    'ubsan_crash': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
    'ubsan_crash_with_atomic_flush': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
-    'ubsan_crash_with_txn': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
    'valgrind': [CompilerErrorParser, GTestErrorParser, ValgrindErrorParser],
    'tsan': [CompilerErrorParser, GTestErrorParser, TsanErrorParser],
    'format_compatible': [CompilerErrorParser, CompatErrorParser],
@@ -86,15 +86,6 @@ else
 fi
 CFLAGS+=" -DTBB"

-# location of LIBURING
-LIBURING_INCLUDE=" -isystem $LIBURING_BASE/include/"
-if test -z $PIC_BUILD; then
-  LIBURING_LIBS="$LIBURING_BASE/lib/liburing.a"
-else
-  LIBURING_LIBS="$LIBURING_BASE/lib/liburing_pic.a"
-fi
-CFLAGS+=" -DLIBURING"
-
 test "$USE_SSE" || USE_SSE=1
 export USE_SSE
 test "$PORTABLE" || PORTABLE=1
@@ -103,7 +94,7 @@ export PORTABLE
 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"

-DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE"
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE"

 STDLIBS="-L $GCC_BASE/lib64"

@@ -144,10 +135,10 @@ else
 fi

 CFLAGS+=" $DEPS_INCLUDE"
-CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42 -DROCKSDB_IOURING_PRESENT"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
 CXXFLAGS+=" $CFLAGS"

-EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS"
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
 EXEC_LDFLAGS+=" -B$BINUTILS/gold"
 EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
@@ -157,7 +148,7 @@ EXEC_LDFLAGS+=" -ldl"

 PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"

-EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS $LIBURING_LIBS"
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS"

 VALGRIND_VER="$VALGRIND_BASE/bin/"

@@ -13,14 +13,9 @@ then
  echo "You didn't have clang-format-diff.py and/or clang-format available in your computer!"
  echo "You can download clang-format-diff.py by running: "
  echo "    curl --location http://goo.gl/iUW1u2 -o ${CLANG_FORMAT_DIFF}"
-  echo "You can download clang-format by running:"
+  echo "You can download clang-format by running: "
  echo "    brew install clang-format"
-  echo "  Or"
-  echo "    apt install clang-format"
-  echo "  This might work too:"
-  echo "    yum install git-clang-format"
  echo "Then, move both files (i.e. ${CLANG_FORMAT_DIFF} and clang-format) to some directory within PATH=${PATH}"
-  echo "and make sure ${CLANG_FORMAT_DIFF} is executable."
  exit 128
 fi

@@ -450,36 +450,6 @@ STRESS_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
    }
 ]"

-#
-# RocksDB stress/crash test with txn
-#
-STRESS_CRASH_TEST_WITH_TXN_COMMANDS="[
-    {
-        'name':'Rocksdb Stress and Crash Test with txn',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug stress tests',
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 db_stress || $CONTRUN_NAME=db_stress $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            {
-                'name':'Build and run RocksDB debug crash tests with txn',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test_with_txn || $CONTRUN_NAME=crash_test_with_txn $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            $UPLOAD_DB_DIR,
-        ],
-        $REPORT
-    }
-]"
-
 # RocksDB write stress test.
 # We run on disk device on purpose (i.e. no $SHM)
 # because we want to add some randomness to fsync commands
@@ -571,30 +541,6 @@ ASAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash testing with txn under address sanitizer
-#
-ASAN_CRASH_TEST_WITH_TXN_COMMANDS="[
-    {
-        'name':'Rocksdb crash test with txn under ASAN',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug asan_crash_test_with_txn',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 asan_crash_test_with_txn || $CONTRUN_NAME=asan_crash_test_with_txn $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            $UPLOAD_DB_DIR,
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB test under undefined behavior sanitizer
 #
@@ -663,30 +609,6 @@ UBSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash testing with txn under undefined behavior sanitizer
-#
-UBSAN_CRASH_TEST_WITH_TXN_COMMANDS="[
-    {
-        'name':'Rocksdb crash test with txn under UBSAN',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug ubsan_crash_test_with_txn',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG $NON_TSAN_CRASH $CLANG make J=1 ubsan_crash_test_with_txn || $CONTRUN_NAME=ubsan_crash_test_with_txn $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            $UPLOAD_DB_DIR,
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB unit test under valgrind
 #
@@ -780,30 +702,6 @@ TSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
    }
 ]"

-#
-# RocksDB crash test with txn under TSAN
-#
-TSAN_CRASH_TEST_WITH_TXN_COMMANDS="[
-    {
-        'name':'Rocksdb Crash Test with txn under TSAN',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Compile and run',
-                'timeout': 86400,
-                'shell':'set -o pipefail && $SHM $DEBUG $TSAN $TSAN_CRASH CRASH_TEST_KILL_ODD=1887 make J=1 crash_test_with_txn || $CONTRUN_NAME=tsan_crash_test_with_txn $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            $UPLOAD_DB_DIR,
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB format compatible
 #
@@ -991,9 +889,6 @@ case $1 in
  stress_crash_with_atomic_flush)
    echo $STRESS_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
    ;;
-  stress_crash_with_txn)
-    echo $STRESS_CRASH_TEST_WITH_TXN_COMMANDS
-    ;;
  write_stress)
    echo $WRITE_STRESS_COMMANDS
    ;;
@@ -1006,9 +901,6 @@ case $1 in
  asan_crash_with_atomic_flush)
    echo $ASAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
    ;;
-  asan_crash_with_txn)
-    echo $ASAN_CRASH_TEST_WITH_TXN_COMMANDS
-    ;;
  ubsan)
    echo $UBSAN_TEST_COMMANDS
    ;;
@@ -1018,9 +910,6 @@ case $1 in
  ubsan_crash_with_atomic_flush)
    echo $UBSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
    ;;
-  ubsan_crash_with_txn)
-    echo $UBSAN_CRASH_TEST_WITH_TXN_COMMANDS
-    ;;
  valgrind)
    echo $VALGRIND_TEST_COMMANDS
    ;;
@@ -1033,9 +922,6 @@ case $1 in
  tsan_crash_with_atomic_flush)
    echo $TSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS
    ;;
-  tsan_crash_with_txn)
-    echo $TSAN_CRASH_TEST_WITH_TXN_COMMANDS
-    ;;
  format_compatible)
    echo $FORMAT_COMPATIBLE_COMMANDS
    ;;
@@ -92,7 +92,6 @@ get_lib_base jemalloc   LATEST  platform007
 get_lib_base numa       LATEST  platform007
 get_lib_base libunwind  LATEST  platform007
 get_lib_base tbb        LATEST  platform007
-get_lib_base liburing   LATEST  platform007

 get_lib_base kernel-headers fb platform007
 get_lib_base binutils   LATEST centos7-native
@@ -1,29 +0,0 @@
-# - Find gflags library
-# Find the gflags includes and library
-#
-# gflags_INCLUDE_DIR - where to find gflags.h.
-# gflags_LIBRARIES - List of libraries when using gflags.
-# gflags_FOUND - True if gflags found.
-
-find_path(GFLAGS_INCLUDE_DIR
-  NAMES gflags/gflags.h)
-
-find_library(GFLAGS_LIBRARIES
-  NAMES gflags)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(gflags
-  DEFAULT_MSG GFLAGS_LIBRARIES GFLAGS_INCLUDE_DIR)
-
-mark_as_advanced(
-  GFLAGS_LIBRARIES
-  GFLAGS_INCLUDE_DIR)
-
-if(gflags_FOUND AND NOT (TARGET gflags::gflags))
-  add_library(gflags::gflags UNKNOWN IMPORTED)
-  set_target_properties(gflags::gflags
-    PROPERTIES
-      IMPORTED_LOCATION ${GFLAGS_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${GFLAGS_INCLUDE_DIR}
-      IMPORTED_LINK_INTERFACE_LANGUAGES "CXX")
-endif()
@@ -111,7 +111,7 @@ class BlobIndex {
    return Status::OK();
  }

-  std::string DebugString(bool output_hex) const {
+  std::string DebugString(bool output_hex) {
    std::ostringstream oss;

    if (IsInlined()) {
@@ -66,9 +66,8 @@ TableBuilder* NewTableBuilder(
 }

 Status BuildTable(
-    const std::string& dbname, Env* env, FileSystem* fs,
-    const ImmutableCFOptions& ioptions,
-    const MutableCFOptions& mutable_cf_options, const FileOptions& file_options,
+    const std::string& dbname, Env* env, const ImmutableCFOptions& ioptions,
+    const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
    TableCache* table_cache, InternalIterator* iter,
    std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
        range_del_iters,
@@ -116,12 +115,12 @@ Status BuildTable(
    compression_opts_for_flush.max_dict_bytes = 0;
    compression_opts_for_flush.zstd_max_train_bytes = 0;
    {
-      std::unique_ptr<FSWritableFile> file;
+      std::unique_ptr<WritableFile> file;
 #ifndef NDEBUG
-      bool use_direct_writes = file_options.use_direct_writes;
+      bool use_direct_writes = env_options.use_direct_writes;
      TEST_SYNC_POINT_CALLBACK("BuildTable:create_file", &use_direct_writes);
 #endif  // !NDEBUG
-      s = NewWritableFile(fs, fname, &file, file_options);
+      s = NewWritableFile(env, fname, &file, env_options);
      if (!s.ok()) {
        EventHelpers::LogAndNotifyTableFileCreationFinished(
            event_logger, ioptions.listeners, dbname, column_family_name, fname,
@@ -132,7 +131,7 @@ Status BuildTable(
      file->SetWriteLifeTimeHint(write_hint);

      file_writer.reset(
-          new WritableFileWriter(std::move(file), fname, file_options, env,
+          new WritableFileWriter(std::move(file), fname, env_options, env,
                                 ioptions.statistics, ioptions.listeners));
      builder = NewTableBuilder(
          ioptions, mutable_cf_options, internal_comparator,
@@ -219,7 +218,7 @@ Status BuildTable(
      // we will regrad this verification as user reads since the goal is
      // to cache it here for further user reads
      std::unique_ptr<InternalIterator> it(table_cache->NewIterator(
-          ReadOptions(), file_options, internal_comparator, *meta,
+          ReadOptions(), env_options, internal_comparator, *meta,
          nullptr /* range_del_agg */,
          mutable_cf_options.prefix_extractor.get(), nullptr,
          (internal_stats == nullptr) ? nullptr
@@ -242,7 +241,7 @@ Status BuildTable(
  }

  if (!s.ok() || meta->fd.GetFileSize() == 0) {
-    fs->DeleteFile(fname, IOOptions(), nullptr);
+    env->DeleteFile(fname);
  }

  if (meta->fd.GetFileSize() == 0) {
@@ -62,9 +62,8 @@ TableBuilder* NewTableBuilder(
 // @param column_family_name Name of the column family that is also identified
 //    by column_family_id, or empty string if unknown.
 extern Status BuildTable(
-    const std::string& dbname, Env* env, FileSystem* fs,
-    const ImmutableCFOptions& options,
-    const MutableCFOptions& mutable_cf_options, const FileOptions& file_options,
+    const std::string& dbname, Env* env, const ImmutableCFOptions& options,
+    const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
    TableCache* table_cache, InternalIterator* iter,
    std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
        range_del_iters,
@@ -671,8 +671,8 @@ rocksdb_t* rocksdb_open_column_families(
    const rocksdb_options_t* db_options,
    const char* name,
    int num_column_families,
-    const char* const* column_family_names,
-    const rocksdb_options_t* const* column_family_options,
+    const char** column_family_names,
+    const rocksdb_options_t** column_family_options,
    rocksdb_column_family_handle_t** column_family_handles,
    char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
@@ -703,8 +703,8 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
    const rocksdb_options_t* db_options,
    const char* name,
    int num_column_families,
-    const char* const* column_family_names,
-    const rocksdb_options_t* const* column_family_options,
+    const char** column_family_names,
+    const rocksdb_options_t** column_family_options,
    rocksdb_column_family_handle_t** column_family_handles,
    unsigned char error_if_log_file_exist,
    char** errptr) {
@@ -735,8 +735,8 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
 rocksdb_t* rocksdb_open_as_secondary_column_families(
    const rocksdb_options_t* db_options, const char* name,
    const char* secondary_path, int num_column_families,
-    const char* const* column_family_names,
-    const rocksdb_options_t* const* column_family_options,
+    const char** column_family_names,
+    const rocksdb_options_t** column_family_options,
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i != num_column_families; ++i) {
@@ -852,17 +852,6 @@ void rocksdb_delete_cf(
        Slice(key, keylen)));
 }

-void rocksdb_delete_range_cf(rocksdb_t* db,
-                             const rocksdb_writeoptions_t* options,
-                             rocksdb_column_family_handle_t* column_family,
-                             const char* start_key, size_t start_key_len,
-                             const char* end_key, size_t end_key_len,
-                             char** errptr) {
-  SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep,
-                                         Slice(start_key, start_key_len),
-                                         Slice(end_key, end_key_len)));
-}
-
 void rocksdb_merge(
    rocksdb_t* db,
    const rocksdb_writeoptions_t* options,
@@ -2043,17 +2032,6 @@ void rocksdb_block_based_options_set_index_type(
  options->rep.index_type = static_cast<BlockBasedTableOptions::IndexType>(v);
 }

-void rocksdb_block_based_options_set_data_block_index_type(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.data_block_index_type =
-          static_cast<BlockBasedTableOptions::DataBlockIndexType>(v);
-}
-
-void rocksdb_block_based_options_set_data_block_hash_ratio(
-    rocksdb_block_based_table_options_t* options, double v) {
-  options->rep.data_block_hash_table_util_ratio = v;
-}
-
 void rocksdb_block_based_options_set_hash_index_allow_collision(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.hash_index_allow_collision = v;
@@ -2736,12 +2714,6 @@ void rocksdb_options_set_ratelimiter(rocksdb_options_t *opt, rocksdb_ratelimiter
  }
 }

-void rocksdb_options_set_atomic_flush(
-  rocksdb_options_t *opt,
-  unsigned char atomic_flush) {
-    opt->rep.atomic_flush = atomic_flush;
-}
-
 rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
    int64_t rate_bytes_per_sec,
    int64_t refill_period_us,
@@ -3065,16 +3037,7 @@ rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(int bits_per_ke
    bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
      return rep_->KeyMayMatch(key, filter);
    }
-    // No need to override GetFilterBitsBuilder if this one is overridden
-    rocksdb::FilterBitsBuilder* GetBuilderWithContext(
-        const rocksdb::FilterBuildingContext& context) const override {
-      return rep_->GetBuilderWithContext(context);
-    }
-    rocksdb::FilterBitsReader* GetFilterBitsReader(
-        const Slice& contents) const override {
-      return rep_->GetFilterBitsReader(contents);
-    }
-    static void DoNothing(void*) {}
+    static void DoNothing(void*) { }
  };
  Wrapper* wrapper = new Wrapper;
  wrapper->rep_ = NewBloomFilterPolicy(bits_per_key, original_format);
@@ -3843,8 +3806,8 @@ rocksdb_transactiondb_t* rocksdb_transactiondb_open(
 rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
    const rocksdb_options_t* options,
    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
-    int num_column_families, const char* const* column_family_names,
-    const rocksdb_options_t* const* column_family_options,
+    int num_column_families, const char** column_family_names,
+    const rocksdb_options_t** column_family_options,
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
@@ -4221,8 +4184,8 @@ rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(
 rocksdb_optimistictransactiondb_t*
 rocksdb_optimistictransactiondb_open_column_families(
    const rocksdb_options_t* db_options, const char* name,
-    int num_column_families, const char* const* column_family_names,
-    const rocksdb_options_t* const* column_family_options,
+    int num_column_families, const char** column_family_names,
+    const rocksdb_options_t** column_family_options,
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
@@ -487,11 +487,8 @@ int main(int argc, char** argv) {
  rocksdb_options_set_paranoid_checks(options, 1);
  rocksdb_options_set_max_open_files(options, 10);
  rocksdb_options_set_base_background_compactions(options, 1);
-
  table_options = rocksdb_block_based_options_create();
  rocksdb_block_based_options_set_block_cache(table_options, cache);
-  rocksdb_block_based_options_set_data_block_index_type(table_options, 1);
-  rocksdb_block_based_options_set_data_block_hash_ratio(table_options, 0.75);
  rocksdb_options_set_block_based_table_factory(options, table_options);

  rocksdb_options_set_compression(options, rocksdb_no_compression);
@@ -1051,20 +1048,17 @@ int main(int argc, char** argv) {
  }

  StartPhase("filter");
-  for (run = 0; run <= 2; run++) {
-    // First run uses custom filter
-    // Second run uses old block-based bloom filter
-    // Third run uses full bloom filter
+  for (run = 0; run < 2; run++) {
+    // First run uses custom filter, second run uses bloom filter
    CheckNoError(err);
    rocksdb_filterpolicy_t* policy;
    if (run == 0) {
-      policy = rocksdb_filterpolicy_create(NULL, FilterDestroy, FilterCreate,
-                                           FilterKeyMatch, NULL, FilterName);
-    } else if (run == 1) {
-      policy = rocksdb_filterpolicy_create_bloom(8);
+      policy = rocksdb_filterpolicy_create(
+          NULL, FilterDestroy, FilterCreate, FilterKeyMatch, NULL, FilterName);
    } else {
-      policy = rocksdb_filterpolicy_create_bloom_full(8);
+      policy = rocksdb_filterpolicy_create_bloom(10);
    }
+
    rocksdb_block_based_options_set_filter_policy(table_options, policy);

    // Create new database
@@ -1077,24 +1071,12 @@ int main(int argc, char** argv) {
    CheckNoError(err);
    rocksdb_put(db, woptions, "bar", 3, "barvalue", 8, &err);
    CheckNoError(err);
-
-    {
-      // Add enough keys to get just one reasonably populated Bloom filter
-      const int keys_to_add = 1500;
-      int i;
-      char keybuf[100];
-      for (i = 0; i < keys_to_add; i++) {
-        snprintf(keybuf, sizeof(keybuf), "yes%020d", i);
-        rocksdb_put(db, woptions, keybuf, strlen(keybuf), "val", 3, &err);
-        CheckNoError(err);
-      }
-    }
    rocksdb_compact_range(db, NULL, 0, NULL, 0);

    fake_filter_result = 1;
    CheckGet(db, roptions, "foo", "foovalue");
    CheckGet(db, roptions, "bar", "barvalue");
-    if (run == 0) {
+    if (phase == 0) {
      // Must not find value when custom filter returns false
      fake_filter_result = 0;
      CheckGet(db, roptions, "foo", NULL);
@@ -1104,43 +1086,6 @@ int main(int argc, char** argv) {
      CheckGet(db, roptions, "foo", "foovalue");
      CheckGet(db, roptions, "bar", "barvalue");
    }
-
-    {
-      // Query some keys not added to identify Bloom filter implementation
-      // from false positive queries, using perfcontext to detect Bloom
-      // filter behavior
-      rocksdb_perfcontext_t* perf = rocksdb_perfcontext_create();
-      rocksdb_perfcontext_reset(perf);
-
-      const int keys_to_query = 10000;
-      int i;
-      char keybuf[100];
-      for (i = 0; i < keys_to_query; i++) {
-        fake_filter_result = i % 2;
-        snprintf(keybuf, sizeof(keybuf), "no%020d", i);
-        CheckGet(db, roptions, keybuf, NULL);
-      }
-
-      const int hits =
-          (int)rocksdb_perfcontext_metric(perf, rocksdb_bloom_sst_hit_count);
-      if (run == 0) {
-        // Due to half true, half false with fake filter result
-        CheckCondition(hits == keys_to_query / 2);
-      } else if (run == 1) {
-        // Essentially a fingerprint of the block-based Bloom schema
-        CheckCondition(hits == 241);
-      } else {
-        // Essentially a fingerprint of the full Bloom schema(s),
-        // format_version < 5, which vary for three different CACHE_LINE_SIZEs
-        CheckCondition(hits == 224 || hits == 180 || hits == 125);
-      }
-      CheckCondition(
-          (keys_to_query - hits) ==
-          (int)rocksdb_perfcontext_metric(perf, rocksdb_bloom_sst_miss_count));
-
-      rocksdb_perfcontext_destroy(perf);
-    }
-
    // Reset the policy
    rocksdb_block_based_options_set_filter_policy(table_options, NULL);
    rocksdb_options_set_block_based_table_factory(options, table_options);
@@ -1244,15 +1189,6 @@ int main(int argc, char** argv) {
    rocksdb_put_cf(db, woptions, handles[1], "foo", 3, "hello", 5, &err);
    CheckNoError(err);

-    rocksdb_put_cf(db, woptions, handles[1], "foobar1", 7, "hello1", 6, &err);
-    CheckNoError(err);
-    rocksdb_put_cf(db, woptions, handles[1], "foobar2", 7, "hello2", 6, &err);
-    CheckNoError(err);
-    rocksdb_put_cf(db, woptions, handles[1], "foobar3", 7, "hello3", 6, &err);
-    CheckNoError(err);
-    rocksdb_put_cf(db, woptions, handles[1], "foobar4", 7, "hello4", 6, &err);
-    CheckNoError(err);
-
    rocksdb_flushoptions_t *flush_options = rocksdb_flushoptions_create();
    rocksdb_flushoptions_set_wait(flush_options, 1);
    rocksdb_flush_cf(db, flush_options, handles[1], &err);
@@ -1265,10 +1201,6 @@ int main(int argc, char** argv) {
    rocksdb_delete_cf(db, woptions, handles[1], "foo", 3, &err);
    CheckNoError(err);

-    rocksdb_delete_range_cf(db, woptions, handles[1], "foobar2", 7, "foobar4",
-                            7, &err);
-    CheckNoError(err);
-
    CheckGetCF(db, roptions, handles[1], "foo", NULL);
    CheckPinGetCF(db, roptions, handles[1], "foo", NULL);

@@ -1321,7 +1253,7 @@ int main(int argc, char** argv) {
    for (i = 0; rocksdb_iter_valid(iter) != 0; rocksdb_iter_next(iter)) {
      i++;
    }
-    CheckCondition(i == 3);
+    CheckCondition(i == 1);
    rocksdb_iter_get_error(iter, &err);
    CheckNoError(err);
    rocksdb_iter_destroy(iter);
@@ -1345,7 +1277,7 @@ int main(int argc, char** argv) {
    for (i = 0; rocksdb_iter_valid(iter) != 0; rocksdb_iter_next(iter)) {
      i++;
    }
-    CheckCondition(i == 3);
+    CheckCondition(i == 1);
    rocksdb_iter_get_error(iter, &err);
    CheckNoError(err);
    rocksdb_iter_destroy(iter);
@@ -60,8 +60,11 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
    ColumnFamilyOptions initial_cf_options_copy = cfd_->initial_cf_options();
    JobContext job_context(0);
    mutex_->Lock();
-    bool dropped = cfd_->IsDropped();
-    if (cfd_->UnrefAndTryDelete()) {
+    if (cfd_->Unref()) {
+      bool dropped = cfd_->IsDropped();
+
+      delete cfd_;
+
      if (dropped) {
        db_->FindObsoleteFiles(&job_context, false, true);
      }
@@ -436,18 +439,13 @@ void SuperVersion::Cleanup() {
    to_delete.push_back(m);
  }
  current->Unref();
-  if (cfd->Unref()) {
-    delete cfd;
-  }
 }

-void SuperVersion::Init(ColumnFamilyData* new_cfd, MemTable* new_mem,
-                        MemTableListVersion* new_imm, Version* new_current) {
-  cfd = new_cfd;
+void SuperVersion::Init(MemTable* new_mem, MemTableListVersion* new_imm,
+                        Version* new_current) {
  mem = new_mem;
  imm = new_imm;
  current = new_current;
-  cfd->Ref();
  mem->Ref();
  imm->Ref();
  current->Ref();
@@ -475,7 +473,7 @@ ColumnFamilyData::ColumnFamilyData(
    uint32_t id, const std::string& name, Version* _dummy_versions,
    Cache* _table_cache, WriteBufferManager* write_buffer_manager,
    const ColumnFamilyOptions& cf_options, const ImmutableDBOptions& db_options,
-    const FileOptions& file_options, ColumnFamilySet* column_family_set,
+    const EnvOptions& env_options, ColumnFamilySet* column_family_set,
    BlockCacheTracer* const block_cache_tracer)
    : id_(id),
      name_(name),
@@ -517,7 +515,7 @@ ColumnFamilyData::ColumnFamilyData(
  if (_dummy_versions != nullptr) {
    internal_stats_.reset(
        new InternalStats(ioptions_.num_levels, db_options.env, this));
-    table_cache_.reset(new TableCache(ioptions_, file_options, _table_cache,
+    table_cache_.reset(new TableCache(ioptions_, env_options, _table_cache,
                                      block_cache_tracer));
    if (ioptions_.compaction_style == kCompactionStyleLevel) {
      compaction_picker_.reset(
@@ -583,7 +581,21 @@ ColumnFamilyData::~ColumnFamilyData() {
  // compaction_queue_ and we destroyed it
  assert(!queued_for_flush_);
  assert(!queued_for_compaction_);
-  assert(super_version_ == nullptr);
+
+  if (super_version_ != nullptr) {
+    // Release SuperVersion reference kept in ThreadLocalPtr.
+    // This must be done outside of mutex_ since unref handler can lock mutex.
+    super_version_->db_mutex->Unlock();
+    local_sv_.reset();
+    super_version_->db_mutex->Lock();
+
+    bool is_last_reference __attribute__((__unused__));
+    is_last_reference = super_version_->Unref();
+    assert(is_last_reference);
+    super_version_->Cleanup();
+    delete super_version_;
+    super_version_ = nullptr;
+  }

  if (dummy_versions_ != nullptr) {
    // List must be empty
@@ -603,36 +615,6 @@ ColumnFamilyData::~ColumnFamilyData() {
  }
 }

-bool ColumnFamilyData::UnrefAndTryDelete() {
-  int old_refs = refs_.fetch_sub(1);
-  assert(old_refs > 0);
-
-  if (old_refs == 1) {
-    assert(super_version_ == nullptr);
-    delete this;
-    return true;
-  }
-
-  if (old_refs == 2 && super_version_ != nullptr) {
-    // Only the super_version_ holds me
-    SuperVersion* sv = super_version_;
-    super_version_ = nullptr;
-    // Release SuperVersion reference kept in ThreadLocalPtr.
-    // This must be done outside of mutex_ since unref handler can lock mutex.
-    sv->db_mutex->Unlock();
-    local_sv_.reset();
-    sv->db_mutex->Lock();
-
-    if (sv->Unref()) {
-      // May delete this ColumnFamilyData after calling Cleanup()
-      sv->Cleanup();
-      delete sv;
-      return true;
-    }
-  }
-  return false;
-}
-
 void ColumnFamilyData::SetDropped() {
  // can't drop default CF
  assert(id_ != 0);
@@ -967,8 +949,8 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
  return write_stall_condition;
 }

-const FileOptions* ColumnFamilyData::soptions() const {
-  return &(column_family_set_->file_options_);
+const EnvOptions* ColumnFamilyData::soptions() const {
+  return &(column_family_set_->env_options_);
 }

 void ColumnFamilyData::SetCurrent(Version* current_version) {
@@ -1190,7 +1172,7 @@ void ColumnFamilyData::InstallSuperVersion(
  SuperVersion* new_superversion = sv_context->new_superversion.release();
  new_superversion->db_mutex = db_mutex;
  new_superversion->mutable_cf_options = mutable_cf_options;
-  new_superversion->Init(this, mem_, imm_.current(), current_);
+  new_superversion->Init(mem_, imm_.current(), current_);
  SuperVersion* old_superversion = super_version_;
  super_version_ = new_superversion;
  ++super_version_number_;
@@ -1247,11 +1229,6 @@ Status ColumnFamilyData::ValidateOptions(
  if (s.ok() && db_options.allow_concurrent_memtable_write) {
    s = CheckConcurrentWritesSupported(cf_options);
  }
-  if (s.ok() && db_options.unordered_write &&
-      cf_options.max_successive_merges != 0) {
-    s = Status::InvalidArgument(
-        "max_successive_merges > 0 is incompatible with unordered_write");
-  }
  if (s.ok()) {
    s = CheckCFPathsSupported(db_options, cf_options);
  }
@@ -1311,10 +1288,6 @@ Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
  // L1: medium, L2: long, ...
  if (level - base_level >= 2) {
    return Env::WLTH_EXTREME;
-  } else if (level < base_level) {
-    // There is no restriction which prevents level passed in to be smaller
-    // than base_level.
-    return Env::WLTH_MEDIUM;
  }
  return static_cast<Env::WriteLifeTimeHint>(level - base_level +
                            static_cast<int>(Env::WLTH_MEDIUM));
@@ -1347,7 +1320,7 @@ Directory* ColumnFamilyData::GetDataDir(size_t path_id) const {

 ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
                                 const ImmutableDBOptions* db_options,
-                                 const FileOptions& file_options,
+                                 const EnvOptions& env_options,
                                 Cache* table_cache,
                                 WriteBufferManager* write_buffer_manager,
                                 WriteController* write_controller,
@@ -1355,11 +1328,11 @@ ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
    : max_column_family_(0),
      dummy_cfd_(new ColumnFamilyData(
          0, "", nullptr, nullptr, nullptr, ColumnFamilyOptions(), *db_options,
-          file_options, nullptr, block_cache_tracer)),
+          env_options, nullptr, block_cache_tracer)),
      default_cfd_cache_(nullptr),
      db_name_(dbname),
      db_options_(db_options),
-      file_options_(file_options),
+      env_options_(env_options),
      table_cache_(table_cache),
      write_buffer_manager_(write_buffer_manager),
      write_controller_(write_controller),
@@ -1374,12 +1347,14 @@ ColumnFamilySet::~ColumnFamilySet() {
    // cfd destructor will delete itself from column_family_data_
    auto cfd = column_family_data_.begin()->second;
    bool last_ref __attribute__((__unused__));
-    last_ref = cfd->UnrefAndTryDelete();
+    last_ref = cfd->Unref();
    assert(last_ref);
+    delete cfd;
  }
  bool dummy_last_ref __attribute__((__unused__));
-  dummy_last_ref = dummy_cfd_->UnrefAndTryDelete();
+  dummy_last_ref = dummy_cfd_->Unref();
  assert(dummy_last_ref);
+  delete dummy_cfd_;
 }

 ColumnFamilyData* ColumnFamilySet::GetDefault() const {
@@ -1429,7 +1404,7 @@ ColumnFamilyData* ColumnFamilySet::CreateColumnFamily(
  assert(column_families_.find(name) == column_families_.end());
  ColumnFamilyData* new_cfd = new ColumnFamilyData(
      id, name, dummy_versions, table_cache_, write_buffer_manager_, options,
-      *db_options_, file_options_, this, block_cache_tracer_);
+      *db_options_, env_options_, this, block_cache_tracer_);
  column_families_.insert({name, id});
  column_family_data_.insert({id, new_cfd});
  max_column_family_ = std::max(max_column_family_, id);
@@ -198,7 +198,6 @@ class ColumnFamilyHandleInternal : public ColumnFamilyHandleImpl {
 struct SuperVersion {
  // Accessing members of this class is not thread-safe and requires external
  // synchronization (ie db mutex held or on write thread).
-  ColumnFamilyData* cfd;
  MemTable* mem;
  MemTableListVersion* imm;
  Version* current;
@@ -222,8 +221,8 @@ struct SuperVersion {
  // that needs to be deleted in to_delete vector. Unrefing those
  // objects needs to be done in the mutex
  void Cleanup();
-  void Init(ColumnFamilyData* new_cfd, MemTable* new_mem,
-            MemTableListVersion* new_imm, Version* new_current);
+  void Init(MemTable* new_mem, MemTableListVersion* new_imm,
+            Version* new_current);

  // The value of dummy is not actually used. kSVInUse takes its address as a
  // mark in the thread local storage to indicate the SuperVersion is in use
@@ -289,11 +288,6 @@ class ColumnFamilyData {
    return old_refs == 1;
  }

-  // UnrefAndTryDelete() decreases the reference count and do free if needed,
-  // return true if this is freed else false, UnrefAndTryDelete() can only
-  // be called while holding a DB mutex, or during single-threaded recovery.
-  bool UnrefAndTryDelete();
-
  // SetDropped() can only be called under following conditions:
  // 1) Holding a DB mutex,
  // 2) from single-threaded write thread, AND
@@ -324,7 +318,7 @@ class ColumnFamilyData {
  }
  FlushReason GetFlushReason() const { return flush_reason_; }
  // thread-safe
-  const FileOptions* soptions() const;
+  const EnvOptions* soptions() const;
  const ImmutableCFOptions* ioptions() const { return &ioptions_; }
  // REQUIRES: DB mutex held
  // This returns the MutableCFOptions used by current SuperVersion
@@ -510,7 +504,7 @@ class ColumnFamilyData {
                   WriteBufferManager* write_buffer_manager,
                   const ColumnFamilyOptions& options,
                   const ImmutableDBOptions& db_options,
-                   const FileOptions& file_options,
+                   const EnvOptions& env_options,
                   ColumnFamilySet* column_family_set,
                   BlockCacheTracer* const block_cache_tracer);

@@ -638,7 +632,7 @@ class ColumnFamilySet {

  ColumnFamilySet(const std::string& dbname,
                  const ImmutableDBOptions* db_options,
-                  const FileOptions& file_options, Cache* table_cache,
+                  const EnvOptions& env_options, Cache* table_cache,
                  WriteBufferManager* write_buffer_manager,
                  WriteController* write_controller,
                  BlockCacheTracer* const block_cache_tracer);
@@ -696,7 +690,7 @@ class ColumnFamilySet {

  const std::string db_name_;
  const ImmutableDBOptions* const db_options_;
-  const FileOptions file_options_;
+  const EnvOptions env_options_;
  Cache* table_cache_;
  WriteBufferManager* write_buffer_manager_;
  WriteController* write_controller_;
@@ -2365,45 +2365,6 @@ TEST_P(ColumnFamilyTest, ReadDroppedColumnFamily) {
  }
 }

-TEST_P(ColumnFamilyTest, LiveIteratorWithDroppedColumnFamily) {
-  db_options_.create_missing_column_families = true;
-  db_options_.max_open_files = 20;
-  // delete obsolete files always
-  db_options_.delete_obsolete_files_period_micros = 0;
-  Open({"default", "one", "two"});
-  ColumnFamilyOptions options;
-  options.level0_file_num_compaction_trigger = 100;
-  options.level0_slowdown_writes_trigger = 200;
-  options.level0_stop_writes_trigger = 200;
-  options.write_buffer_size = 100000;  // small write buffer size
-  Reopen({options, options, options});
-
-  // 1MB should create ~10 files for each CF
-  int kKeysNum = 10000;
-  PutRandomData(1, kKeysNum, 100);
-
-  {
-    std::unique_ptr<Iterator> iterator(
-        db_->NewIterator(ReadOptions(), handles_[1]));
-    iterator->SeekToFirst();
-
-    DropColumnFamilies({1});
-
-    // Make sure iterator created can still be used.
-    int count = 0;
-    for (; iterator->Valid(); iterator->Next()) {
-      ASSERT_OK(iterator->status());
-      ++count;
-    }
-    ASSERT_OK(iterator->status());
-    ASSERT_EQ(count, kKeysNum);
-  }
-
-  Reopen();
-  Close();
-  Destroy();
-}
-
 TEST_P(ColumnFamilyTest, FlushAndDropRaceCondition) {
  db_options_.create_missing_column_families = true;
  Open({"default", "one"});
@@ -275,7 +275,9 @@ Compaction::~Compaction() {
    input_version_->Unref();
  }
  if (cfd_ != nullptr) {
-    cfd_->UnrefAndTryDelete();
+    if (cfd_->Unref()) {
+      delete cfd_;
+    }
  }
 }

@@ -639,48 +639,28 @@ void CompactionIterator::NextFromInput() {
 }

 void CompactionIterator::PrepareOutput() {
-  if (valid_) {
-    if (compaction_filter_ && ikey_.type == kTypeBlobIndex) {
-      const auto blob_decision = compaction_filter_->PrepareBlobOutput(
-          user_key(), value_, &compaction_filter_value_);
-
-      if (blob_decision == CompactionFilter::BlobDecision::kCorruption) {
-        status_ = Status::Corruption(
-            "Corrupted blob reference encountered during GC");
-        valid_ = false;
-      } else if (blob_decision == CompactionFilter::BlobDecision::kIOError) {
-        status_ = Status::IOError("Could not relocate blob during GC");
-        valid_ = false;
-      } else if (blob_decision ==
-                 CompactionFilter::BlobDecision::kChangeValue) {
-        value_ = compaction_filter_value_;
-      }
-    }
-
-    // Zeroing out the sequence number leads to better compression.
-    // If this is the bottommost level (no files in lower levels)
-    // and the earliest snapshot is larger than this seqno
-    // and the userkey differs from the last userkey in compaction
-    // then we can squash the seqno to zero.
-    //
-    // This is safe for TransactionDB write-conflict checking since transactions
-    // only care about sequence number larger than any active snapshots.
-    //
-    // Can we do the same for levels above bottom level as long as
-    // KeyNotExistsBeyondOutputLevel() return true?
-    if (valid_ && compaction_ != nullptr &&
-        !compaction_->allow_ingest_behind() &&
-        ikeyNotNeededForIncrementalSnapshot() && bottommost_level_ &&
-        IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge) {
-      assert(ikey_.type != kTypeDeletion && ikey_.type != kTypeSingleDeletion);
-      if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion) {
-        ROCKS_LOG_FATAL(info_log_,
-                        "Unexpected key type %d for seq-zero optimization",
-                        ikey_.type);
-      }
-      ikey_.sequence = 0;
-      current_key_.UpdateInternalKey(0, ikey_.type);
+  // Zeroing out the sequence number leads to better compression.
+  // If this is the bottommost level (no files in lower levels)
+  // and the earliest snapshot is larger than this seqno
+  // and the userkey differs from the last userkey in compaction
+  // then we can squash the seqno to zero.
+  //
+  // This is safe for TransactionDB write-conflict checking since transactions
+  // only care about sequence number larger than any active snapshots.
+  //
+  // Can we do the same for levels above bottom level as long as
+  // KeyNotExistsBeyondOutputLevel() return true?
+  if ((compaction_ != nullptr && !compaction_->allow_ingest_behind()) &&
+      ikeyNotNeededForIncrementalSnapshot() && bottommost_level_ && valid_ &&
+      IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge) {
+    assert(ikey_.type != kTypeDeletion && ikey_.type != kTypeSingleDeletion);
+    if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion) {
+      ROCKS_LOG_FATAL(info_log_,
+                      "Unexpected key type %d for seq-zero optimization",
+                      ikey_.type);
    }
+    ikey_.sequence = 0;
+    current_key_.UpdateInternalKey(0, ikey_.type);
  }
 }

@@ -144,6 +144,7 @@ struct CompactionJob::SubcompactionState {

  // State during the subcompaction
  uint64_t total_bytes;
+  uint64_t num_input_records;
  uint64_t num_output_records;
  CompactionJobStats compaction_job_stats;
  uint64_t approx_size;
@@ -164,6 +165,7 @@ struct CompactionJob::SubcompactionState {
        builder(nullptr),
        current_output_file_size(0),
        total_bytes(0),
+        num_input_records(0),
        num_output_records(0),
        approx_size(size),
        grandparent_index(0),
@@ -184,6 +186,7 @@ struct CompactionJob::SubcompactionState {
    builder = std::move(o.builder);
    current_output_file_size = std::move(o.current_output_file_size);
    total_bytes = std::move(o.total_bytes);
+    num_input_records = std::move(o.num_input_records);
    num_output_records = std::move(o.num_output_records);
    compaction_job_stats = std::move(o.compaction_job_stats);
    approx_size = std::move(o.approx_size);
@@ -242,11 +245,13 @@ struct CompactionJob::CompactionState {
  Status status;

  uint64_t total_bytes;
+  uint64_t num_input_records;
  uint64_t num_output_records;

  explicit CompactionState(Compaction* c)
      : compaction(c),
        total_bytes(0),
+        num_input_records(0),
        num_output_records(0) {}

  size_t NumOutputFiles() {
@@ -284,6 +289,7 @@ struct CompactionJob::CompactionState {
 void CompactionJob::AggregateStatistics() {
  for (SubcompactionState& sc : compact_->sub_compact_states) {
    compact_->total_bytes += sc.total_bytes;
+    compact_->num_input_records += sc.num_input_records;
    compact_->num_output_records += sc.num_output_records;
  }
  if (compaction_job_stats_) {
@@ -295,7 +301,7 @@ void CompactionJob::AggregateStatistics() {

 CompactionJob::CompactionJob(
    int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
-    const FileOptions& file_options, VersionSet* versions,
+    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,
@@ -312,11 +318,10 @@ CompactionJob::CompactionJob(
      compaction_stats_(compaction->compaction_reason(), 1),
      dbname_(dbname),
      db_options_(db_options),
-      file_options_(file_options),
+      env_options_(env_options),
      env_(db_options.env),
-      fs_(db_options.fs.get()),
-      file_options_for_read_(
-          fs_->OptimizeForCompactionTableRead(file_options, db_options_)),
+      env_options_for_read_(
+          env_->OptimizeForCompactionTableRead(env_options, db_options_)),
      versions_(versions),
      shutting_down_(shutting_down),
      manual_compaction_paused_(manual_compaction_paused),
@@ -642,7 +647,7 @@ Status CompactionJob::Run() {
        // we will regard this verification as user reads since the goal is
        // to cache it here for further user reads
        InternalIterator* iter = cfd->table_cache()->NewIterator(
-            ReadOptions(), file_options_, cfd->internal_comparator(),
+            ReadOptions(), env_options_, cfd->internal_comparator(),
            *files_meta[file_idx], /*range_del_agg=*/nullptr, prefix_extractor,
            /*table_reader_ptr=*/nullptr,
            cfd->internal_stats()->GetFileReadHist(
@@ -764,12 +769,12 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
  auto stream = event_logger_->LogToBuffer(log_buffer_);
  stream << "job" << job_id_ << "event"
         << "compaction_finished"
-         << "compaction_time_micros" << stats.micros
-         << "compaction_time_cpu_micros" << stats.cpu_micros << "output_level"
-         << compact_->compaction->output_level() << "num_output_files"
-         << compact_->NumOutputFiles() << "total_output_size"
-         << compact_->total_bytes << "num_input_records"
-         << stats.num_input_records << "num_output_records"
+         << "compaction_time_micros" << compaction_stats_.micros
+         << "compaction_time_cpu_micros" << compaction_stats_.cpu_micros
+         << "output_level" << compact_->compaction->output_level()
+         << "num_output_files" << compact_->NumOutputFiles()
+         << "total_output_size" << compact_->total_bytes << "num_input_records"
+         << compact_->num_input_records << "num_output_records"
         << compact_->num_output_records << "num_subcompactions"
         << compact_->sub_compact_states.size() << "output_compression"
         << CompressionTypeToString(compact_->compaction->output_compression());
@@ -831,7 +836,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  // Although the v2 aggregator is what the level iterator(s) know about,
  // the AddTombstones calls will be propagated down to the v1 aggregator.
  std::unique_ptr<InternalIterator> input(versions_->MakeInputIterator(
-      sub_compact->compaction, &range_del_agg, file_options_for_read_));
+      sub_compact->compaction, &range_del_agg, env_options_for_read_));

  AutoThreadOperationStageUpdater stage_updater(
      ThreadStatus::STAGE_COMPACTION_PROCESS_KV);
@@ -985,6 +990,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    }
  }

+  sub_compact->num_input_records = c_iter_stats.num_input_records;
  sub_compact->compaction_job_stats.num_input_deletion_records =
      c_iter_stats.num_input_deletion_records;
  sub_compact->compaction_job_stats.num_corrupt_keys =
@@ -1451,13 +1457,13 @@ Status CompactionJob::OpenCompactionOutputFile(
      TableFileCreationReason::kCompaction);
 #endif  // !ROCKSDB_LITE
  // Make the output file
-  std::unique_ptr<FSWritableFile> writable_file;
+  std::unique_ptr<WritableFile> writable_file;
 #ifndef NDEBUG
-  bool syncpoint_arg = file_options_.use_direct_writes;
+  bool syncpoint_arg = env_options_.use_direct_writes;
  TEST_SYNC_POINT_CALLBACK("CompactionJob::OpenCompactionOutputFile",
                           &syncpoint_arg);
 #endif
-  Status s = NewWritableFile(fs_, fname, &writable_file, file_options_);
+  Status s = NewWritableFile(env_, fname, &writable_file, env_options_);
  if (!s.ok()) {
    ROCKS_LOG_ERROR(
        db_options_.info_log,
@@ -1500,14 +1506,14 @@ Status CompactionJob::OpenCompactionOutputFile(
    sub_compact->outputs.push_back(out);
  }

-  writable_file->SetIOPriority(Env::IOPriority::IO_LOW);
+  writable_file->SetIOPriority(Env::IO_LOW);
  writable_file->SetWriteLifeTimeHint(write_hint_);
  writable_file->SetPreallocationBlockSize(static_cast<size_t>(
      sub_compact->compaction->OutputFilePreallocationSize()));
  const auto& listeners =
      sub_compact->compaction->immutable_cf_options()->listeners;
  sub_compact->outfile.reset(
-      new WritableFileWriter(std::move(writable_file), fname, file_options_,
+      new WritableFileWriter(std::move(writable_file), fname, env_options_,
                             env_, db_options_.statistics.get(), listeners));

  // If the Column family flag is to only optimize filters for hits,
@@ -1582,8 +1588,6 @@ void CompactionJob::UpdateCompactionStats() {
    }
  }

-  uint64_t num_output_records = 0;
-
  for (const auto& sub_compact : compact_->sub_compact_states) {
    size_t num_output_files = sub_compact.outputs.size();
    if (sub_compact.builder != nullptr) {
@@ -1593,16 +1597,13 @@ void CompactionJob::UpdateCompactionStats() {
    }
    compaction_stats_.num_output_files += static_cast<int>(num_output_files);

-    num_output_records += sub_compact.num_output_records;
-
    for (const auto& out : sub_compact.outputs) {
      compaction_stats_.bytes_written += out.meta.fd.file_size;
    }
-  }
-
-  if (compaction_stats_.num_input_records > num_output_records) {
-    compaction_stats_.num_dropped_records =
-        compaction_stats_.num_input_records - num_output_records;
+    if (sub_compact.num_input_records > sub_compact.num_output_records) {
+      compaction_stats_.num_dropped_records +=
+          sub_compact.num_input_records - sub_compact.num_output_records;
+    }
  }
 }

@@ -1630,7 +1631,7 @@ void CompactionJob::UpdateCompactionJobStats(
    // input information
    compaction_job_stats_->total_input_bytes =
        stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
-    compaction_job_stats_->num_input_records = stats.num_input_records;
+    compaction_job_stats_->num_input_records = compact_->num_input_records;
    compaction_job_stats_->num_input_files =
        stats.num_input_files_in_non_output_levels +
        stats.num_input_files_in_output_level;
@@ -64,7 +64,7 @@ class CompactionJob {
 public:
  CompactionJob(int job_id, Compaction* compaction,
                const ImmutableDBOptions& db_options,
-                const FileOptions& file_options, VersionSet* versions,
+                const EnvOptions env_options, VersionSet* versions,
                const std::atomic<bool>* shutting_down,
                const SequenceNumber preserve_deletes_seqnum,
                LogBuffer* log_buffer, Directory* db_directory,
@@ -150,12 +150,11 @@ class CompactionJob {
  // DBImpl state
  const std::string& dbname_;
  const ImmutableDBOptions& db_options_;
-  const FileOptions file_options_;
+  const EnvOptions env_options_;

  Env* env_;
-  FileSystem* fs_;
  // env_option optimized for compaction table reads
-  FileOptions file_options_for_read_;
+  EnvOptions env_options_for_read_;
  VersionSet* versions_;
  const std::atomic<bool>* shutting_down_;
  const std::atomic<bool>* manual_compaction_paused_;
@@ -72,7 +72,6 @@ class CompactionJobTest : public testing::Test {
 public:
  CompactionJobTest()
      : env_(Env::Default()),
-        fs_(std::make_shared<LegacyFileSystemWrapper>(env_)),
        dbname_(test::PerThreadDBPath("compaction_job_test")),
        db_options_(),
        mutable_cf_options_(cf_options_),
@@ -87,8 +86,6 @@ class CompactionJobTest : public testing::Test {
        mock_table_factory_(new mock::MockTableFactory()),
        error_handler_(nullptr, db_options_, &mutex_) {
    EXPECT_OK(env_->CreateDirIfMissing(dbname_));
-    db_options_.env = env_;
-    db_options_.fs = fs_;
    db_options_.db_paths.emplace_back(dbname_,
                                      std::numeric_limits<uint64_t>::max());
  }
@@ -270,8 +267,8 @@ class CompactionJobTest : public testing::Test {
    Status s = env_->NewWritableFile(
        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
    ASSERT_OK(s);
-    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        NewLegacyWritableFileWrapper(std::move(file)), manifest, env_options_));
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(std::move(file), manifest, env_options_));
    {
      log::Writer log(std::move(file_writer), 0, false);
      std::string record;
@@ -363,7 +360,6 @@ class CompactionJobTest : public testing::Test {
  }

  Env* env_;
-  std::shared_ptr<FileSystem> fs_;
  std::string dbname_;
  EnvOptions env_options_;
  ImmutableDBOptions db_options_;
@@ -247,8 +247,7 @@ bool UniversalCompactionBuilder::IsInputFilesNonOverlapping(Compaction* c) {

    next.f = nullptr;

-    if (c->level(curr.level) != 0 &&
-        curr.index < c->num_input_files(curr.level) - 1) {
+    if (curr.level != 0 && curr.index < c->num_input_files(curr.level) - 1) {
      next.f = c->input(curr.level, curr.index + 1);
      next.level = curr.level;
      next.index = curr.index + 1;
@@ -41,16 +41,14 @@ Status VerifySstFileChecksum(const Options& options,
                             const EnvOptions& env_options,
                             const ReadOptions& read_options,
                             const std::string& file_path) {
-  std::unique_ptr<FSRandomAccessFile> file;
+  std::unique_ptr<RandomAccessFile> file;
  uint64_t file_size;
  InternalKeyComparator internal_comparator(options.comparator);
  ImmutableCFOptions ioptions(options);

-  Status s = ioptions.fs->NewRandomAccessFile(file_path,
-                                              FileOptions(env_options),
-                                              &file, nullptr);
+  Status s = ioptions.env->NewRandomAccessFile(file_path, &file, env_options);
  if (s.ok()) {
-    s = ioptions.fs->GetFileSize(file_path, IOOptions(), &file_size, nullptr);
+    s = ioptions.env->GetFileSize(file_path, &file_size);
  } else {
    return s;
  }
@@ -20,7 +20,6 @@
 #include "db/db_test_util.h"
 #include "db/log_format.h"
 #include "db/version_set.h"
-#include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/convenience.h"
@@ -190,7 +189,6 @@ class CorruptionTest : public testing::Test {
    ASSERT_TRUE(s.ok()) << s.ToString();
    Options options;
    EnvOptions env_options;
-    options.file_system.reset(new LegacyFileSystemWrapper(options.env));
    ASSERT_NOK(VerifySstFileChecksum(options, env_options, fname));
  }

@@ -541,8 +539,7 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) {
  std::unique_ptr<RandomAccessFile> file;
  ASSERT_OK(options_.env->NewRandomAccessFile(filename, &file, EnvOptions()));
  std::unique_ptr<RandomAccessFileReader> file_reader(
-      new RandomAccessFileReader(NewLegacyRandomAccessFileWrapper(file),
-                                 filename));
+      new RandomAccessFileReader(std::move(file), filename));

  uint64_t file_size;
  ASSERT_OK(options_.env->GetFileSize(filename, &file_size));
@@ -6,6 +6,7 @@
 // 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 <iostream>
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
@@ -524,7 +525,6 @@ TEST_F(DBBasicTest, Snapshot) {
    ASSERT_EQ(1U, GetNumSnapshots());
    uint64_t time_snap1 = GetTimeOldestSnapshots();
    ASSERT_GT(time_snap1, 0U);
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    Put(0, "foo", "0v2");
    Put(1, "foo", "1v2");

@@ -533,7 +533,6 @@ TEST_F(DBBasicTest, Snapshot) {
    const Snapshot* s2 = db_->GetSnapshot();
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    Put(0, "foo", "0v3");
    Put(1, "foo", "1v3");

@@ -541,7 +540,6 @@ TEST_F(DBBasicTest, Snapshot) {
      ManagedSnapshot s3(db_);
      ASSERT_EQ(3U, GetNumSnapshots());
      ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-      ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());

      Put(0, "foo", "0v4");
      Put(1, "foo", "1v4");
@@ -557,7 +555,6 @@ TEST_F(DBBasicTest, Snapshot) {

    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
@@ -572,11 +569,9 @@ TEST_F(DBBasicTest, Snapshot) {
    ASSERT_EQ("1v4", Get(1, "foo"));
    ASSERT_EQ(1U, GetNumSnapshots());
    ASSERT_LT(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s2->GetSequenceNumber());

    db_->ReleaseSnapshot(s2);
    ASSERT_EQ(0U, GetNumSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), 0);
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
  } while (ChangeOptions());
@@ -1405,91 +1400,6 @@ TEST_F(DBBasicTest, MultiGetBatchedMultiLevel) {
  }
 }

-TEST_F(DBBasicTest, MultiGetBatchedMultiLevelMerge) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(options);
-  int num_keys = 0;
-
-  for (int i = 0; i < 128; ++i) {
-    ASSERT_OK(Put("key_" + std::to_string(i), "val_l2_" + std::to_string(i)));
-    num_keys++;
-    if (num_keys == 8) {
-      Flush();
-      num_keys = 0;
-    }
-  }
-  if (num_keys > 0) {
-    Flush();
-    num_keys = 0;
-  }
-  MoveFilesToLevel(2);
-
-  for (int i = 0; i < 128; i += 3) {
-    ASSERT_OK(Merge("key_" + std::to_string(i), "val_l1_" + std::to_string(i)));
-    num_keys++;
-    if (num_keys == 8) {
-      Flush();
-      num_keys = 0;
-    }
-  }
-  if (num_keys > 0) {
-    Flush();
-    num_keys = 0;
-  }
-  MoveFilesToLevel(1);
-
-  for (int i = 0; i < 128; i += 5) {
-    ASSERT_OK(Merge("key_" + std::to_string(i), "val_l0_" + std::to_string(i)));
-    num_keys++;
-    if (num_keys == 8) {
-      Flush();
-      num_keys = 0;
-    }
-  }
-  if (num_keys > 0) {
-    Flush();
-    num_keys = 0;
-  }
-  ASSERT_EQ(0, num_keys);
-
-  for (int i = 0; i < 128; i += 9) {
-    ASSERT_OK(Merge("key_" + std::to_string(i), "val_mem_" + std::to_string(i)));
-  }
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  for (int i = 32; i < 80; ++i) {
-    keys.push_back("key_" + std::to_string(i));
-  }
-
-  values = MultiGet(keys, nullptr);
-  ASSERT_EQ(values.size(), keys.size());
-  for (unsigned int j = 0; j < 48; ++j) {
-    int key = j + 32;
-    std::string value;
-    value.append("val_l2_" + std::to_string(key));
-    if (key % 3 == 0) {
-      value.append(",");
-      value.append("val_l1_" + std::to_string(key));
-    }
-    if (key % 5 == 0) {
-      value.append(",");
-      value.append("val_l0_" + std::to_string(key));
-    }
-    if (key % 9 == 0) {
-      value.append(",");
-      value.append("val_mem_" + std::to_string(key));
-    }
-    ASSERT_EQ(values[j], value);
-  }
-}
-
 // Test class for batched MultiGet with prefix extractor
 // Param bool - If true, use partitioned filters
 //              If false, use full filter block
@@ -1796,14 +1706,6 @@ class DBBasicTestWithParallelIO
      assert(Put(Key(i), values_[i]) == Status::OK());
    }
    Flush();
-
-    for (int i = 0; i < 100; ++i) {
-      // block cannot gain space by compression
-      uncompressable_values_.emplace_back(RandomString(&rnd, 256) + '\0');
-      std::string tmp_key = "a" + Key(i);
-      assert(Put(tmp_key, uncompressable_values_[i]) == Status::OK());
-    }
-    Flush();
  }

  bool CheckValue(int i, const std::string& value) {
@@ -1813,13 +1715,6 @@ class DBBasicTestWithParallelIO
    return false;
  }

-  bool CheckUncompressableValue(int i, const std::string& value) {
-    if (uncompressable_values_[i].compare(value) == 0) {
-      return true;
-    }
-    return false;
-  }
-
  int num_lookups() { return uncompressed_cache_->num_lookups(); }
  int num_found() { return uncompressed_cache_->num_found(); }
  int num_inserts() { return uncompressed_cache_->num_inserts(); }
@@ -1969,7 +1864,6 @@ class DBBasicTestWithParallelIO
  std::shared_ptr<MyBlockCache> uncompressed_cache_;
  bool compression_enabled_;
  std::vector<std::string> values_;
-  std::vector<std::string> uncompressable_values_;
  bool fill_cache_;
 };

@@ -2034,150 +1928,8 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
    ASSERT_OK(statuses[i]);
    ASSERT_TRUE(CheckValue(key_ints[i], values[i].ToString()));
  }
-  if (compression_enabled() && !has_compressed_cache()) {
-    expected_reads += (read_from_cache ? 2 : 3);
-  } else {
-    expected_reads += (read_from_cache ? 2 : 4);
-  }
+  expected_reads += (read_from_cache ? 2 : 4);
  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
-
-  keys.resize(10);
-  statuses.resize(10);
-  std::vector<int> key_uncmp{1, 2, 15, 16, 55, 81, 82, 83, 84, 85};
-  for (size_t i = 0; i < key_uncmp.size(); ++i) {
-    key_data[i] = "a" + Key(key_uncmp[i]);
-    keys[i] = Slice(key_data[i]);
-    statuses[i] = Status::OK();
-    values[i].Reset();
-  }
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
-  for (size_t i = 0; i < key_uncmp.size(); ++i) {
-    ASSERT_OK(statuses[i]);
-    ASSERT_TRUE(CheckUncompressableValue(key_uncmp[i], values[i].ToString()));
-  }
-  if (compression_enabled() && !has_compressed_cache()) {
-    expected_reads += (read_from_cache ? 3 : 3);
-  } else {
-    expected_reads += (read_from_cache ? 4 : 4);
-  }
-  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
-
-  keys.resize(5);
-  statuses.resize(5);
-  std::vector<int> key_tr{1, 2, 15, 16, 55};
-  for (size_t i = 0; i < key_tr.size(); ++i) {
-    key_data[i] = "a" + Key(key_tr[i]);
-    keys[i] = Slice(key_data[i]);
-    statuses[i] = Status::OK();
-    values[i].Reset();
-  }
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
-  for (size_t i = 0; i < key_tr.size(); ++i) {
-    ASSERT_OK(statuses[i]);
-    ASSERT_TRUE(CheckUncompressableValue(key_tr[i], values[i].ToString()));
-  }
-  if (compression_enabled() && !has_compressed_cache()) {
-    expected_reads += (read_from_cache ? 0 : 2);
-    ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
-  } else {
-    if (has_uncompressed_cache()) {
-      expected_reads += (read_from_cache ? 0 : 3);
-      ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
-    } else {
-      // A rare case, even we enable the block compression but some of data
-      // blocks are not compressed due to content. If user only enable the
-      // compressed cache, the uncompressed blocks will not tbe cached, and
-      // block reads will be triggered. The number of reads is related to
-      // the compression algorithm.
-      ASSERT_TRUE(env_->random_read_counter_.Read() >= expected_reads);
-    }
-  }
-}
-
-TEST_P(DBBasicTestWithParallelIO, MultiGetWithChecksumMismatch) {
-  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;
-  int read_count = 0;
-  ReadOptions ro;
-  ro.fill_cache = fill_cache();
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "RetrieveMultipleBlocks:VerifyChecksum", [&](void *status) {
-      Status* s = static_cast<Status*>(status);
-      read_count++;
-      if (read_count == 2) {
-        *s = Status::Corruption();
-      }
-    });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // 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);
-  ASSERT_TRUE(CheckValue(0, values[0].ToString()));
-  //ASSERT_TRUE(CheckValue(50, values[1].ToString()));
-  ASSERT_EQ(statuses[0], Status::OK());
-  ASSERT_EQ(statuses[1], Status::Corruption());
-
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_P(DBBasicTestWithParallelIO, MultiGetWithMissingFile) {
-  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;
-  ro.fill_cache = fill_cache();
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "TableCache::MultiGet:FindTable", [&](void *status) {
-      Status* s = static_cast<Status*>(status);
-      *s = Status::IOError();
-    });
-  // DB open will create table readers unless we reduce the table cache
-  // capacity.
-  // SanitizeOptions will set max_open_files to minimum of 20. Table cache
-  // is allocated with max_open_files - 10 as capacity. So override
-  // max_open_files to 11 so table cache capacity will become 1. This will
-  // prevent file open during DB open and force the file to be opened
-  // during MultiGet
-  SyncPoint::GetInstance()->SetCallBack(
-      "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void *arg) {
-      int* max_open_files = (int*)arg;
-      *max_open_files = 11;
-    });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Reopen(CurrentOptions());
-
-  // 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);
-  ASSERT_EQ(statuses[0], Status::IOError());
-  ASSERT_EQ(statuses[1], Status::IOError());
-
-  SyncPoint::GetInstance()->DisableProcessing();
 }

 INSTANTIATE_TEST_CASE_P(
@@ -2190,15 +1942,23 @@ INSTANTIATE_TEST_CASE_P(
    ::testing::Combine(::testing::Bool(), ::testing::Bool(),
                       ::testing::Bool(), ::testing::Bool()));

-class DBBasicTestWithTimestampBase : public DBTestBase {
+class DBBasicTestWithTimestampWithParam
+    : public DBTestBase,
+      public testing::WithParamInterface<bool> {
 public:
-  explicit DBBasicTestWithTimestampBase(const std::string& dbname)
-      : DBTestBase(dbname) {}
+  DBBasicTestWithTimestampWithParam()
+      : DBTestBase("/db_basic_test_with_timestamp") {}

 protected:
-  class TestComparatorBase : public Comparator {
+  class TestComparator : public Comparator {
+   private:
+    const Comparator* cmp_without_ts_;
+
   public:
-    explicit TestComparatorBase(size_t ts_sz) : Comparator(ts_sz) {}
+    explicit TestComparator(size_t ts_sz)
+        : Comparator(ts_sz), cmp_without_ts_(nullptr) {
+      cmp_without_ts_ = BytewiseComparator();
+    }

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

@@ -2216,15 +1976,13 @@ class DBBasicTestWithTimestampBase : public DBTestBase {
          Slice(b.data() + b.size() - timestamp_size(), timestamp_size()));
    }

-    virtual int CompareImpl(const Slice& a, const Slice& b) const = 0;
-
    int CompareWithoutTimestamp(const Slice& a, const Slice& b) const override {
      assert(a.size() >= timestamp_size());
      assert(b.size() >= timestamp_size());
      Slice k1 = StripTimestampFromUserKey(a, timestamp_size());
      Slice k2 = StripTimestampFromUserKey(b, timestamp_size());

-      return CompareImpl(k1, k2);
+      return cmp_without_ts_->Compare(k1, k2);
    }

    int CompareTimestamp(const Slice& ts1, const Slice& ts2) const override {
@@ -2270,74 +2028,14 @@ class DBBasicTestWithTimestampBase : public DBTestBase {
  }
 };

-class DBBasicTestWithTimestamp : public DBBasicTestWithTimestampBase {
- public:
-  DBBasicTestWithTimestamp()
-      : DBBasicTestWithTimestampBase("/db_basic_test_with_timestamp") {}
-
- protected:
-  class TestComparator : public TestComparatorBase {
-   public:
-    const int kKeyPrefixLength =
-        3;  // 3: length of "key" in generated keys ("key" + std::to_string(j))
-    explicit TestComparator(size_t ts_sz) : TestComparatorBase(ts_sz) {}
-
-    int CompareImpl(const Slice& a, const Slice& b) const override {
-      int n1 = atoi(
-          std::string(a.data() + kKeyPrefixLength, a.size() - kKeyPrefixLength)
-              .c_str());
-      int n2 = atoi(
-          std::string(b.data() + kKeyPrefixLength, b.size() - kKeyPrefixLength)
-              .c_str());
-      return (n1 < n2) ? -1 : (n1 > n2) ? 1 : 0;
-    }
-  };
-};
-
-#ifndef ROCKSDB_LITE
-// A class which remembers the name of each flushed file.
-class FlushedFileCollector : public EventListener {
- public:
-  FlushedFileCollector() {}
-  ~FlushedFileCollector() override {}
-
-  void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
-    InstrumentedMutexLock lock(&mutex_);
-    flushed_files_.push_back(info.file_path);
-  }
-
-  std::vector<std::string> GetFlushedFiles() {
-    std::vector<std::string> result;
-    {
-      InstrumentedMutexLock lock(&mutex_);
-      result = flushed_files_;
-    }
-    return result;
-  }
-
-  void ClearFlushedFiles() {
-    InstrumentedMutexLock lock(&mutex_);
-    flushed_files_.clear();
-  }
-
- private:
-  std::vector<std::string> flushed_files_;
-  InstrumentedMutex mutex_;
-};
-
-TEST_F(DBBasicTestWithTimestamp, PutAndGetWithCompaction) {
+TEST_P(DBBasicTestWithTimestampWithParam, PutAndGet) {
  const int kNumKeysPerFile = 8192;
-  const size_t kNumTimestamps = 2;
-  const size_t kNumKeysPerTimestamp = (kNumKeysPerFile - 1) / kNumTimestamps;
-  const size_t kSplitPosBase = kNumKeysPerTimestamp / 2;
+  const size_t kNumTimestamps = 6;
+  bool memtable_only = GetParam();
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.env = env_;
  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
-
-  FlushedFileCollector* collector = new FlushedFileCollector();
-  options.listeners.emplace_back(collector);
-
  std::string tmp;
  size_t ts_sz = EncodeTimestamp(0, 0, &tmp).size();
  TestComparator test_cmp(ts_sz);
@@ -2363,26 +2061,13 @@ TEST_F(DBBasicTestWithTimestamp, PutAndGetWithCompaction) {
    WriteOptions wopts;
    wopts.timestamp = &write_ts;
    for (int cf = 0; cf != static_cast<int>(num_cfs); ++cf) {
-      for (size_t j = 0; j != kNumKeysPerTimestamp; ++j) {
+      for (size_t j = 0; j != (kNumKeysPerFile - 1) / kNumTimestamps; ++j) {
        ASSERT_OK(Put(cf, "key" + std::to_string(j),
                      "value_" + std::to_string(j) + "_" + std::to_string(i),
                      wopts));
-        if (j == kSplitPosBase + i || j == kNumKeysPerTimestamp - 1) {
-          // flush all keys with the same timestamp to two sst files, split at
-          // incremental positions such that lowerlevel[1].smallest.userkey ==
-          // higherlevel[0].largest.userkey
-          ASSERT_OK(Flush(cf));
-
-          // compact files (2 at each level) to a lower level such that all keys
-          // with the same timestamp is at one level, with newer versions at
-          // higher levels.
-          CompactionOptions compact_opt;
-          compact_opt.compression = kNoCompression;
-          db_->CompactFiles(compact_opt, handles_[cf],
-                            collector->GetFlushedFiles(),
-                            static_cast<int>(kNumTimestamps - i));
-          collector->ClearFlushedFiles();
-        }
+      }
+      if (!memtable_only) {
+        ASSERT_OK(Flush(cf));
      }
    }
  }
@@ -2392,7 +2077,7 @@ TEST_F(DBBasicTestWithTimestamp, PutAndGetWithCompaction) {
      ropts.timestamp = &read_ts_list[i];
      for (int cf = 0; cf != static_cast<int>(num_cfs); ++cf) {
        ColumnFamilyHandle* cfh = handles_[cf];
-        for (size_t j = 0; j != kNumKeysPerTimestamp; ++j) {
+        for (size_t j = 0; j != (kNumKeysPerFile - 1) / kNumTimestamps; ++j) {
          std::string value;
          ASSERT_OK(db_->Get(ropts, cfh, "key" + std::to_string(j), &value));
          ASSERT_EQ("value_" + std::to_string(j) + "_" + std::to_string(i),
@@ -2403,126 +2088,6 @@ TEST_F(DBBasicTestWithTimestamp, PutAndGetWithCompaction) {
  };
  verify_db_func();
 }
-#endif  // !ROCKSDB_LITE
-
-class DBBasicTestWithTimestampWithParam
-    : public DBBasicTestWithTimestampBase,
-      public testing::WithParamInterface<bool> {
- public:
-  DBBasicTestWithTimestampWithParam()
-      : DBBasicTestWithTimestampBase(
-            "/db_basic_test_with_timestamp_with_param") {}
-
- protected:
-  class TestComparator : public TestComparatorBase {
-   private:
-    const Comparator* cmp_without_ts_;
-
-   public:
-    explicit TestComparator(size_t ts_sz)
-        : TestComparatorBase(ts_sz), cmp_without_ts_(nullptr) {
-      cmp_without_ts_ = BytewiseComparator();
-    }
-
-    int CompareImpl(const Slice& a, const Slice& b) const override {
-      return cmp_without_ts_->Compare(a, b);
-    }
-  };
-};
-
-TEST_P(DBBasicTestWithTimestampWithParam, PutAndGet) {
-  const int kNumKeysPerFile = 8192;
-  const size_t kNumTimestamps = 6;
-  bool memtable_only = GetParam();
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.env = env_;
-  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
-  std::string tmp;
-  size_t ts_sz = EncodeTimestamp(0, 0, &tmp).size();
-  TestComparator test_cmp(ts_sz);
-  options.comparator = &test_cmp;
-  BlockBasedTableOptions bbto;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(
-      10 /*bits_per_key*/, false /*use_block_based_builder*/));
-  bbto.whole_key_filtering = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-
-  std::vector<CompressionType> compression_types;
-  compression_types.push_back(kNoCompression);
-  if (Zlib_Supported()) {
-    compression_types.push_back(kZlibCompression);
-  }
-#if LZ4_VERSION_NUMBER >= 10400  // r124+
-  compression_types.push_back(kLZ4Compression);
-  compression_types.push_back(kLZ4HCCompression);
-#endif  // LZ4_VERSION_NUMBER >= 10400
-  if (ZSTD_Supported()) {
-    compression_types.push_back(kZSTD);
-  }
-
-  // Switch compression dictionary on/off to check key extraction
-  // correctness in kBuffered state
-  std::vector<uint32_t> max_dict_bytes_list = {0, 1 << 14};  // 0 or 16KB
-
-  for (auto compression_type : compression_types) {
-    for (uint32_t max_dict_bytes : max_dict_bytes_list) {
-      options.compression = compression_type;
-      options.compression_opts.max_dict_bytes = max_dict_bytes;
-      if (compression_type == kZSTD) {
-        options.compression_opts.zstd_max_train_bytes = max_dict_bytes;
-      }
-      options.target_file_size_base = 1 << 26;  // 64MB
-
-      DestroyAndReopen(options);
-      CreateAndReopenWithCF({"pikachu"}, options);
-      size_t num_cfs = handles_.size();
-      ASSERT_EQ(2, num_cfs);
-      std::vector<std::string> write_ts_strs(kNumTimestamps);
-      std::vector<std::string> read_ts_strs(kNumTimestamps);
-      std::vector<Slice> write_ts_list;
-      std::vector<Slice> read_ts_list;
-
-      for (size_t i = 0; i != kNumTimestamps; ++i) {
-        write_ts_list.emplace_back(
-            EncodeTimestamp(i * 2, 0, &write_ts_strs[i]));
-        read_ts_list.emplace_back(
-            EncodeTimestamp(1 + i * 2, 0, &read_ts_strs[i]));
-        const Slice& write_ts = write_ts_list.back();
-        WriteOptions wopts;
-        wopts.timestamp = &write_ts;
-        for (int cf = 0; cf != static_cast<int>(num_cfs); ++cf) {
-          for (size_t j = 0; j != (kNumKeysPerFile - 1) / kNumTimestamps; ++j) {
-            ASSERT_OK(Put(
-                cf, "key" + std::to_string(j),
-                "value_" + std::to_string(j) + "_" + std::to_string(i), wopts));
-          }
-          if (!memtable_only) {
-            ASSERT_OK(Flush(cf));
-          }
-        }
-      }
-      const auto& verify_db_func = [&]() {
-        for (size_t i = 0; i != kNumTimestamps; ++i) {
-          ReadOptions ropts;
-          ropts.timestamp = &read_ts_list[i];
-          for (int cf = 0; cf != static_cast<int>(num_cfs); ++cf) {
-            ColumnFamilyHandle* cfh = handles_[cf];
-            for (size_t j = 0; j != (kNumKeysPerFile - 1) / kNumTimestamps;
-                 ++j) {
-              std::string value;
-              ASSERT_OK(
-                  db_->Get(ropts, cfh, "key" + std::to_string(j), &value));
-              ASSERT_EQ("value_" + std::to_string(j) + "_" + std::to_string(i),
-                        value);
-            }
-          }
-        }
-      };
-      verify_db_func();
-    }
-  }
-}

 INSTANTIATE_TEST_CASE_P(Timestamp, DBBasicTestWithTimestampWithParam,
                        ::testing::Bool());
@@ -10,7 +10,6 @@
 #include "cache/lru_cache.h"
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "util/compression.h"

 namespace rocksdb {

@@ -686,18 +685,16 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {

  // Try all the available libraries that support dictionary compression
  std::vector<CompressionType> compression_types;
-  if (Zlib_Supported()) {
-    compression_types.push_back(kZlibCompression);
-  }
-  if (LZ4_Supported()) {
-    compression_types.push_back(kLZ4Compression);
-    compression_types.push_back(kLZ4HCCompression);
-  }
-  if (ZSTD_Supported()) {
-    compression_types.push_back(kZSTD);
-  } else if (ZSTDNotFinal_Supported()) {
-    compression_types.push_back(kZSTDNotFinalCompression);
-  }
+#ifdef ZLIB
+  compression_types.push_back(kZlibCompression);
+#endif  // ZLIB
+#if LZ4_VERSION_NUMBER >= 10400
+  compression_types.push_back(kLZ4Compression);
+  compression_types.push_back(kLZ4HCCompression);
+#endif  // LZ4_VERSION_NUMBER >= 10400
+#if ZSTD_VERSION_NUMBER >= 500
+  compression_types.push_back(kZSTD);
+#endif  // ZSTD_VERSION_NUMBER >= 500
  Random rnd(301);
  for (auto compression_type : compression_types) {
    Options options = CurrentOptions();
@@ -400,7 +400,6 @@ TEST_F(DBCompactionTest, SkipStatsUpdateTest) {
  // The test will need to be updated if the internal behavior changes.

  Options options = DeletionTriggerOptions(CurrentOptions());
-  options.disable_auto_compactions = true;
  options.env = env_;
  DestroyAndReopen(options);
  Random rnd(301);
@@ -411,33 +410,31 @@ TEST_F(DBCompactionTest, SkipStatsUpdateTest) {
    values.push_back(RandomString(&rnd, kCDTValueSize));
    ASSERT_OK(Put(Key(k), values[k]));
  }
-
-  ASSERT_OK(Flush());
-
-  Close();
-
-  int update_acc_stats_called = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "VersionStorageInfo::UpdateAccumulatedStats",
-      [&](void* /* arg */) { ++update_acc_stats_called; });
-  SyncPoint::GetInstance()->EnableProcessing();
+  dbfull()->TEST_WaitForFlushMemTable();
+  dbfull()->TEST_WaitForCompact();

  // Reopen the DB with stats-update disabled
  options.skip_stats_update_on_db_open = true;
  options.max_open_files = 20;
+  env_->random_file_open_counter_.store(0);
  Reopen(options);

-  ASSERT_EQ(update_acc_stats_called, 0);
+  // As stats-update is disabled, we expect a very low number of
+  // random file open.
+  // Note that this number must be changed accordingly if we change
+  // the number of files needed to be opened in the DB::Open process.
+  const int kMaxFileOpenCount = 10;
+  ASSERT_LT(env_->random_file_open_counter_.load(), kMaxFileOpenCount);

  // Repeat the reopen process, but this time we enable
  // stats-update.
  options.skip_stats_update_on_db_open = false;
+  env_->random_file_open_counter_.store(0);
  Reopen(options);

-  ASSERT_GT(update_acc_stats_called, 0);
-
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->DisableProcessing();
+  // Since we do a normal stats update on db-open, there
+  // will be more random open files.
+  ASSERT_GT(env_->random_file_open_counter_.load(), kMaxFileOpenCount);
 }

 TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
@@ -1506,37 +1503,6 @@ TEST_F(DBCompactionTest, DISABLED_ManualPartialFill) {
  }
 }

-TEST_F(DBCompactionTest, ManualCompactionWithUnorderedWrite) {
-  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::WriteImpl:UnorderedWriteAfterWriteWAL",
-        "DBCompactionTest::ManualCompactionWithUnorderedWrite:WaitWriteWAL"},
-       {"DBImpl::WaitForPendingWrites:BeforeBlock",
-        "DBImpl::WriteImpl:BeforeUnorderedWriteMemtable"}});
-
-  Options options = CurrentOptions();
-  options.unordered_write = true;
-  DestroyAndReopen(options);
-  Put("foo", "v1");
-  ASSERT_OK(Flush());
-
-  Put("bar", "v1");
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  port::Thread writer([&]() { Put("foo", "v2"); });
-
-  TEST_SYNC_POINT(
-      "DBCompactionTest::ManualCompactionWithUnorderedWrite:WaitWriteWAL");
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  writer.join();
-  ASSERT_EQ(Get("foo"), "v2");
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  Reopen(options);
-  ASSERT_EQ(Get("foo"), "v2");
-}
-
 TEST_F(DBCompactionTest, DeleteFileRange) {
  Options options = CurrentOptions();
  options.write_buffer_size = 10 * 1024 * 1024;
@@ -102,7 +102,7 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
        TEST_SYNC_POINT("DBImpl::GetLiveFiles:1");
        TEST_SYNC_POINT("DBImpl::GetLiveFiles:2");
        mutex_.Lock();
-        cfd->UnrefAndTryDelete();
+        cfd->Unref();
        if (!status.ok()) {
          break;
        }
@@ -212,30 +212,6 @@ TEST_F(DBFlushTest, ManualFlushWithMinWriteBufferNumberToMerge) {
  t.join();
 }

-TEST_F(DBFlushTest, ScheduleOnlyOneBgThread) {
-  Options options = CurrentOptions();
-  Reopen(options);
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  int called = 0;
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::MaybeScheduleFlushOrCompaction:AfterSchedule:0", [&](void* arg) {
-        ASSERT_NE(nullptr, arg);
-        auto unscheduled_flushes = *reinterpret_cast<int*>(arg);
-        ASSERT_EQ(0, unscheduled_flushes);
-        ++called;
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put("a", "foo"));
-  FlushOptions flush_opts;
-  ASSERT_OK(dbfull()->Flush(flush_opts));
-  ASSERT_EQ(1, called);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_P(DBFlushDirectIOTest, DirectIO) {
  Options options;
  options.create_if_missing = true;
@@ -52,7 +52,6 @@
 #include "db/version_set.h"
 #include "db/write_batch_internal.h"
 #include "db/write_callback.h"
-#include "env/composite_env_wrapper.h"
 #include "file/file_util.h"
 #include "file/filename.h"
 #include "file/random_access_file_reader.h"
@@ -103,7 +102,6 @@
 #include "util/string_util.h"

 namespace rocksdb {
-
 const std::string kDefaultColumnFamilyName("default");
 const std::string kPersistentStatsColumnFamilyName(
    "___rocksdb_stats_history___");
@@ -143,15 +141,16 @@ void DumpSupportInfo(Logger* logger) {
  ROCKS_LOG_HEADER(logger, "Fast CRC32 supported: %s",
                   crc32c::IsFastCrc32Supported().c_str());
 }
+
+int64_t kDefaultLowPriThrottledRate = 2 * 1024 * 1024;
 }  // namespace

 DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
               const bool seq_per_batch, const bool batch_per_txn)
-    : dbname_(dbname),
+    : env_(options.env),
+      dbname_(dbname),
      own_info_log_(options.info_log == nullptr),
      initial_db_options_(SanitizeOptions(dbname, options)),
-      env_(initial_db_options_.env),
-      fs_(initial_db_options_.file_system),
      immutable_db_options_(initial_db_options_),
      mutable_db_options_(initial_db_options_),
      stats_(immutable_db_options_.statistics.get()),
@@ -159,9 +158,9 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
             immutable_db_options_.use_adaptive_mutex),
      default_cf_handle_(nullptr),
      max_total_in_memory_state_(0),
-      file_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-      file_options_for_compaction_(fs_->OptimizeForCompactionTableWrite(
-          file_options_, immutable_db_options_)),
+      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
+      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
+          env_options_, immutable_db_options_)),
      seq_per_batch_(seq_per_batch),
      batch_per_txn_(batch_per_txn),
      db_lock_(nullptr),
@@ -179,6 +178,11 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      write_thread_(immutable_db_options_),
      nonmem_write_thread_(immutable_db_options_),
      write_controller_(mutable_db_options_.delayed_write_rate),
+      // Use delayed_write_rate as a base line to determine the initial
+      // low pri write rate limit. It may be adjusted later.
+      low_pri_write_rate_limiter_(NewGenericRateLimiter(std::min(
+          static_cast<int64_t>(mutable_db_options_.delayed_write_rate / 8),
+          kDefaultLowPriThrottledRate))),
      last_batch_group_size_(0),
      unscheduled_flushes_(0),
      unscheduled_compactions_(0),
@@ -197,7 +201,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
      unable_to_release_oldest_log_(false),
      num_running_ingest_file_(0),
 #ifndef ROCKSDB_LITE
-      wal_manager_(immutable_db_options_, file_options_, seq_per_batch),
+      wal_manager_(immutable_db_options_, env_options_, seq_per_batch),
 #endif  // ROCKSDB_LITE
      event_logger_(immutable_db_options_.info_log.get()),
      bg_work_paused_(0),
@@ -243,7 +247,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
  co.metadata_charge_policy = kDontChargeCacheMetadata;
  table_cache_ = NewLRUCache(co);

-  versions_.reset(new VersionSet(dbname_, &immutable_db_options_, file_options_,
+  versions_.reset(new VersionSet(dbname_, &immutable_db_options_, env_options_,
                                 table_cache_.get(), write_buffer_manager_,
                                 &write_controller_, &block_cache_tracer_));
  column_family_memtables_.reset(
@@ -333,7 +337,7 @@ Status DBImpl::ResumeImpl() {
        mutex_.Unlock();
        s = FlushMemTable(cfd, flush_opts, FlushReason::kErrorRecovery);
        mutex_.Lock();
-        cfd->UnrefAndTryDelete();
+        cfd->Unref();
        if (!s.ok()) {
          break;
        }
@@ -421,7 +425,7 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
          mutex_.Unlock();
          FlushMemTable(cfd, FlushOptions(), FlushReason::kShutDown);
          mutex_.Lock();
-          cfd->UnrefAndTryDelete();
+          cfd->Unref();
        }
      }
    }
@@ -478,12 +482,17 @@ Status DBImpl::CloseHelper() {
  while (!flush_queue_.empty()) {
    const FlushRequest& flush_req = PopFirstFromFlushQueue();
    for (const auto& iter : flush_req) {
-      iter.first->UnrefAndTryDelete();
+      ColumnFamilyData* cfd = iter.first;
+      if (cfd->Unref()) {
+        delete cfd;
+      }
    }
  }
  while (!compaction_queue_.empty()) {
    auto cfd = PopFirstFromCompactionQueue();
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      delete cfd;
+    }
  }

  if (default_cf_handle_ != nullptr || persist_stats_cf_handle_ != nullptr) {
@@ -590,7 +599,6 @@ Status DBImpl::CloseHelper() {
      ret = s;
    }
  }
-
  if (ret.IsAborted()) {
    // Reserve IsAborted() error for those where users didn't release
    // certain resource and they can release them and come back and
@@ -1005,36 +1013,12 @@ Status DBImpl::SetDBOptions(
      }
    }
    if (s.ok()) {
-      const BGJobLimits current_bg_job_limits =
-          GetBGJobLimits(immutable_db_options_.max_background_flushes,
-                         mutable_db_options_.max_background_compactions,
-                         mutable_db_options_.max_background_jobs,
-                         /* parallelize_compactions */ true);
-      const BGJobLimits new_bg_job_limits = GetBGJobLimits(
-          immutable_db_options_.max_background_flushes,
-          new_options.max_background_compactions,
-          new_options.max_background_jobs, /* parallelize_compactions */ true);
-
-      const bool max_flushes_increased =
-          new_bg_job_limits.max_flushes > current_bg_job_limits.max_flushes;
-      const bool max_compactions_increased =
-          new_bg_job_limits.max_compactions >
-          current_bg_job_limits.max_compactions;
-
-      if (max_flushes_increased || max_compactions_increased) {
-        if (max_flushes_increased) {
-          env_->IncBackgroundThreadsIfNeeded(new_bg_job_limits.max_flushes,
-                                             Env::Priority::HIGH);
-        }
-
-        if (max_compactions_increased) {
-          env_->IncBackgroundThreadsIfNeeded(new_bg_job_limits.max_compactions,
-                                             Env::Priority::LOW);
-        }
-
+      if (new_options.max_background_compactions >
+          mutable_db_options_.max_background_compactions) {
+        env_->IncBackgroundThreadsIfNeeded(
+            new_options.max_background_compactions, Env::Priority::LOW);
        MaybeScheduleFlushOrCompaction();
      }
-
      if (new_options.stats_dump_period_sec !=
          mutable_db_options_.stats_dump_period_sec) {
        if (thread_dump_stats_) {
@@ -1075,14 +1059,14 @@ Status DBImpl::SetDBOptions(
      wal_changed = mutable_db_options_.wal_bytes_per_sync !=
                    new_options.wal_bytes_per_sync;
      mutable_db_options_ = new_options;
-      file_options_for_compaction_ = FileOptions(new_db_options);
-      file_options_for_compaction_ = fs_->OptimizeForCompactionTableWrite(
-          file_options_for_compaction_, immutable_db_options_);
-      versions_->ChangeFileOptions(mutable_db_options_);
+      env_options_for_compaction_ = EnvOptions(new_db_options);
+      env_options_for_compaction_ = env_->OptimizeForCompactionTableWrite(
+          env_options_for_compaction_, immutable_db_options_);
+      versions_->ChangeEnvOptions(mutable_db_options_);
      //TODO(xiez): clarify why apply optimize for read to write options
-      file_options_for_compaction_ = fs_->OptimizeForCompactionTableRead(
-          file_options_for_compaction_, immutable_db_options_);
-      file_options_for_compaction_.compaction_readahead_size =
+      env_options_for_compaction_ = env_->OptimizeForCompactionTableRead(
+          env_options_for_compaction_, immutable_db_options_);
+      env_options_for_compaction_.compaction_readahead_size =
          mutable_db_options_.compaction_readahead_size;
      WriteThread::Writer w;
      write_thread_.EnterUnbatched(&w, &mutex_);
@@ -1468,7 +1452,7 @@ InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
  if (s.ok()) {
    // Collect iterators for files in L0 - Ln
    if (read_options.read_tier != kMemtableTier) {
-      super_version->current->AddIterators(read_options, file_options_,
+      super_version->current->AddIterators(read_options, env_options_,
                                           &merge_iter_builder, range_del_agg);
    }
    internal_iter = merge_iter_builder.Finish();
@@ -2763,15 +2747,6 @@ const std::string& DBImpl::GetName() const { return dbname_; }

 Env* DBImpl::GetEnv() const { return env_; }

-FileSystem* DB::GetFileSystem() const {
-  static LegacyFileSystemWrapper fs_wrap(GetEnv());
-  return &fs_wrap;
-}
-
-FileSystem* DBImpl::GetFileSystem() const {
-  return immutable_db_options_.fs.get();
-}
-
 Options DBImpl::GetOptions(ColumnFamilyHandle* column_family) const {
  InstrumentedMutexLock l(&mutex_);
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
@@ -3352,12 +3327,12 @@ Status DBImpl::GetDbIdentity(std::string& identity) const {

 Status DBImpl::GetDbIdentityFromIdentityFile(std::string* identity) const {
  std::string idfilename = IdentityFileName(dbname_);
-  const FileOptions soptions;
+  const EnvOptions soptions;
  std::unique_ptr<SequentialFileReader> id_file_reader;
  Status s;
  {
-    std::unique_ptr<FSSequentialFile> idfile;
-    s = fs_->NewSequentialFile(idfilename, soptions, &idfile, nullptr);
+    std::unique_ptr<SequentialFile> idfile;
+    s = env_->NewSequentialFile(idfilename, &idfile, soptions);
    if (!s.ok()) {
      return s;
    }
@@ -3366,7 +3341,7 @@ Status DBImpl::GetDbIdentityFromIdentityFile(std::string* identity) const {
  }

  uint64_t file_size;
-  s = fs_->GetFileSize(idfilename, IOOptions(), &file_size, nullptr);
+  s = env_->GetFileSize(idfilename, &file_size);
  if (!s.ok()) {
    return s;
  }
@@ -3440,12 +3415,7 @@ Status DBImpl::Close() {
 Status DB::ListColumnFamilies(const DBOptions& db_options,
                              const std::string& name,
                              std::vector<std::string>* column_families) {
-  FileSystem* fs = db_options.file_system.get();
-  LegacyFileSystemWrapper legacy_fs(db_options.env);
-  if (!fs) {
-    fs = &legacy_fs;
-  }
-  return VersionSet::ListColumnFamilies(column_families, name, fs);
+  return VersionSet::ListColumnFamilies(column_families, name, db_options.env);
 }

 Snapshot::~Snapshot() {}
@@ -3610,8 +3580,8 @@ Status DBImpl::WriteOptionsFile(bool need_mutex_lock,

  std::string file_name =
      TempOptionsFileName(GetName(), versions_->NewFileNumber());
-  Status s = PersistRocksDBOptions(db_options, cf_names, cf_opts, file_name,
-                                   GetFileSystem());
+  Status s =
+      PersistRocksDBOptions(db_options, cf_names, cf_opts, file_name, GetEnv());

  if (s.ok()) {
    s = RenameTempFileToOptionsFile(file_name);
@@ -3955,7 +3925,7 @@ Status DBImpl::IngestExternalFiles(
  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_, file_options_,
+        env_, versions_.get(), cfd, immutable_db_options_, env_options_,
        &snapshots_, arg.options, &directories_, &event_logger_);
  }
  std::vector<std::pair<bool, Status>> exec_results;
@@ -4021,13 +3991,6 @@ Status DBImpl::IngestExternalFiles(
      nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
    }

-    // When unordered_write is enabled, the keys are writing to memtable in an
-    // unordered way. If the ingestion job checks memtable key range before the
-    // key landing in memtable, the ingestion job may skip the necessary
-    // memtable flush.
-    // So wait here to ensure there is no pending write to memtable.
-    WaitForPendingWrites();
-
    num_running_ingest_file_ += static_cast<int>(num_cfs);
    TEST_SYNC_POINT("DBImpl::IngestExternalFile:AfterIncIngestFileCounter");

@@ -4219,7 +4182,7 @@ Status DBImpl::CreateColumnFamilyWithImport(
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(*handle);
  auto cfd = cfh->cfd();
  ImportColumnFamilyJob import_job(env_, versions_.get(), cfd,
-                                   immutable_db_options_, file_options_,
+                                   immutable_db_options_, env_options_,
                                   import_options, metadata.files);

  SuperVersionContext dummy_sv_ctx(/* create_superversion */ true);
@@ -4349,7 +4312,7 @@ Status DBImpl::VerifyChecksum(const ReadOptions& read_options) {
        const auto& fd = vstorage->LevelFilesBrief(i).files[j].fd;
        std::string fname = TableFileName(cfd->ioptions()->cf_paths,
                                          fd.GetNumber(), fd.GetPathId());
-        s = rocksdb::VerifySstFileChecksum(opts, file_options_, read_options,
+        s = rocksdb::VerifySstFileChecksum(opts, env_options_, read_options,
                                           fname);
      }
    }
@@ -4375,7 +4338,7 @@ Status DBImpl::VerifyChecksum(const ReadOptions& read_options) {
      SchedulePurge();
    }
    for (auto cfd : cfd_list) {
-      cfd->UnrefAndTryDelete();
+      cfd->Unref();
    }
  }
  return s;
@@ -4495,21 +4458,13 @@ Status DBImpl::GetCreationTimeOfOldestFile(uint64_t* creation_time) {
  if (mutable_db_options_.max_open_files == -1) {
    uint64_t oldest_time = port::kMaxUint64;
    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      if (!cfd->IsDropped()) {
-        uint64_t ctime;
-        {
-          SuperVersion* sv = GetAndRefSuperVersion(cfd);
-          Version* version = sv->current;
-          version->GetCreationTimeOfOldestFile(&ctime);
-          ReturnAndCleanupSuperVersion(cfd, sv);
-        }
-
-        if (ctime < oldest_time) {
-          oldest_time = ctime;
-        }
-        if (oldest_time == 0) {
-          break;
-        }
+      uint64_t ctime;
+      cfd->current()->GetCreationTimeOfOldestFile(&ctime);
+      if (ctime < oldest_time) {
+        oldest_time = ctime;
+      }
+      if (oldest_time == 0) {
+        break;
      }
    }
    *creation_time = oldest_time;
@@ -306,7 +306,6 @@ class DBImpl : public DB {
      ColumnFamilyHandle* column_family) override;
  virtual const std::string& GetName() const override;
  virtual Env* GetEnv() const override;
-  virtual FileSystem* GetFileSystem() const override;
  using DB::GetOptions;
  virtual Options GetOptions(ColumnFamilyHandle* column_family) const override;
  using DB::GetDBOptions;
@@ -946,14 +945,13 @@ class DBImpl : public DB {
 #endif  // NDEBUG

 protected:
+  Env* const env_;
  const std::string dbname_;
  std::string db_id_;
  std::unique_ptr<VersionSet> versions_;
  // Flag to check whether we allocated and own the info log file
  bool own_info_log_;
  const DBOptions initial_db_options_;
-  Env* const env_;
-  std::shared_ptr<FileSystem> fs_;
  const ImmutableDBOptions immutable_db_options_;
  MutableDBOptions mutable_db_options_;
  Statistics* stats_;
@@ -981,10 +979,10 @@ class DBImpl : public DB {
  bool single_column_family_mode_;

  // The options to access storage files
-  const FileOptions file_options_;
+  const EnvOptions env_options_;

  // Additonal options for compaction and flush
-  FileOptions file_options_for_compaction_;
+  EnvOptions env_options_for_compaction_;

  std::unique_ptr<ColumnFamilyMemTablesImpl> column_family_memtables_;

@@ -1422,7 +1420,6 @@ class DBImpl : public DB {

  inline void WaitForPendingWrites() {
    mutex_.AssertHeld();
-    TEST_SYNC_POINT("DBImpl::WaitForPendingWrites:BeforeBlock");
    // In case of pipelined write is enabled, wait for all pending memtable
    // writers.
    if (immutable_db_options_.enable_pipelined_write) {
@@ -1838,6 +1835,8 @@ class DBImpl : public DB {

  WriteController write_controller_;

+  std::unique_ptr<RateLimiter> low_pri_write_rate_limiter_;
+
  // Size of the last batch group. In slowdown mode, next write needs to
  // sleep if it uses up the quota.
  // Note: This is to protect memtable and compaction. If the batch only writes
@@ -148,7 +148,7 @@ Status DBImpl::FlushMemTableToOutputFile(

  FlushJob flush_job(
      dbname_, cfd, immutable_db_options_, mutable_cf_options,
-      nullptr /* memtable_id */, file_options_for_compaction_, versions_.get(),
+      nullptr /* memtable_id */, env_options_for_compaction_, versions_.get(),
      &mutex_, &shutting_down_, snapshot_seqs, earliest_write_conflict_snapshot,
      snapshot_checker, job_context, log_buffer, directories_.GetDbDir(),
      GetDataDir(cfd, 0U),
@@ -332,7 +332,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
    const uint64_t* max_memtable_id = &(bg_flush_args[i].max_memtable_id_);
    jobs.emplace_back(new FlushJob(
        dbname_, cfd, immutable_db_options_, mutable_cf_options,
-        max_memtable_id, file_options_for_compaction_, versions_.get(), &mutex_,
+        max_memtable_id, env_options_for_compaction_, versions_.get(), &mutex_,
        &shutting_down_, snapshot_seqs, earliest_write_conflict_snapshot,
        snapshot_checker, job_context, log_buffer, directories_.GetDbDir(),
        data_dir, GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
@@ -968,7 +968,7 @@ Status DBImpl::CompactFilesImpl(
  CompactionJobStats compaction_job_stats;
  CompactionJob compaction_job(
      job_context->job_id, c.get(), immutable_db_options_,
-      file_options_for_compaction_, versions_.get(), &shutting_down_,
+      env_options_for_compaction_, versions_.get(), &shutting_down_,
      preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
      GetDataDir(c->column_family_data(), c->output_path_id()), stats_, &mutex_,
      &error_handler_, snapshot_seqs, earliest_write_conflict_snapshot,
@@ -1540,7 +1540,6 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
        nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
      }
    }
-    WaitForPendingWrites();

    if (!cfd->mem()->IsEmpty() || !cached_recoverable_state_empty_.load()) {
      s = SwitchMemtable(cfd, &context);
@@ -1618,16 +1617,19 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    }
    s = WaitForFlushMemTables(cfds, flush_memtable_ids,
                              (flush_reason == FlushReason::kErrorRecovery));
-    InstrumentedMutexLock lock_guard(&mutex_);
    for (auto* tmp_cfd : cfds) {
-      tmp_cfd->UnrefAndTryDelete();
+      if (tmp_cfd->Unref()) {
+        // Only one thread can reach here.
+        InstrumentedMutexLock lock_guard(&mutex_);
+        delete tmp_cfd;
+      }
    }
  }
-  TEST_SYNC_POINT("DBImpl::FlushMemTable:FlushMemTableFinished");
+  TEST_SYNC_POINT("FlushMemTableFinished");
  return s;
 }

-// Flush all elements in 'column_family_datas'
+// Flush all elments in 'column_family_datas'
 // and atomically record the result to the MANIFEST.
 Status DBImpl::AtomicFlushMemTables(
    const autovector<ColumnFamilyData*>& column_family_datas,
@@ -1663,7 +1665,6 @@ Status DBImpl::AtomicFlushMemTables(
        nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
      }
    }
-    WaitForPendingWrites();

    for (auto cfd : column_family_datas) {
      if (cfd->IsDropped()) {
@@ -1680,7 +1681,7 @@ Status DBImpl::AtomicFlushMemTables(
      }
      cfd->Ref();
      s = SwitchMemtable(cfd, &context);
-      cfd->UnrefAndTryDelete();
+      cfd->Unref();
      if (!s.ok()) {
        break;
      }
@@ -1720,9 +1721,12 @@ Status DBImpl::AtomicFlushMemTables(
    }
    s = WaitForFlushMemTables(cfds, flush_memtable_ids,
                              (flush_reason == FlushReason::kErrorRecovery));
-    InstrumentedMutexLock lock_guard(&mutex_);
    for (auto* cfd : cfds) {
-      cfd->UnrefAndTryDelete();
+      if (cfd->Unref()) {
+        // Only one thread can reach here.
+        InstrumentedMutexLock lock_guard(&mutex_);
+        delete cfd;
+      }
    }
  }
  return s;
@@ -1914,10 +1918,6 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
    fta->thread_pri_ = Env::Priority::HIGH;
    env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::HIGH, this,
                   &DBImpl::UnscheduleFlushCallback);
-    --unscheduled_flushes_;
-    TEST_SYNC_POINT_CALLBACK(
-        "DBImpl::MaybeScheduleFlushOrCompaction:AfterSchedule:0",
-        &unscheduled_flushes_);
  }

  // special case -- if high-pri (flush) thread pool is empty, then schedule
@@ -1932,7 +1932,6 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
      fta->thread_pri_ = Env::Priority::LOW;
      env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::LOW, this,
                     &DBImpl::UnscheduleFlushCallback);
-      --unscheduled_flushes_;
    }
  }

@@ -2016,6 +2015,8 @@ ColumnFamilyData* DBImpl::PopFirstFromCompactionQueue() {
 DBImpl::FlushRequest DBImpl::PopFirstFromFlushQueue() {
  assert(!flush_queue_.empty());
  FlushRequest flush_req = flush_queue_.front();
+  assert(unscheduled_flushes_ >= static_cast<int>(flush_req.size()));
+  unscheduled_flushes_ -= static_cast<int>(flush_req.size());
  flush_queue_.pop_front();
  // TODO: need to unset flush reason?
  return flush_req;
@@ -2057,7 +2058,7 @@ void DBImpl::SchedulePendingFlush(const FlushRequest& flush_req,
    cfd->Ref();
    cfd->SetFlushReason(flush_reason);
  }
-  ++unscheduled_flushes_;
+  unscheduled_flushes_ += static_cast<int>(flush_req.size());
  flush_queue_.push_back(flush_req);
 }

@@ -2203,13 +2204,16 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
    *reason = bg_flush_args[0].cfd_->GetFlushReason();
    for (auto& arg : bg_flush_args) {
      ColumnFamilyData* cfd = arg.cfd_;
-      if (cfd->UnrefAndTryDelete()) {
+      if (cfd->Unref()) {
+        delete cfd;
        arg.cfd_ = nullptr;
      }
    }
  }
  for (auto cfd : column_families_not_to_flush) {
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      delete cfd;
+    }
  }
  return status;
 }
@@ -2538,9 +2542,10 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    // reference).
    // This will all happen under a mutex so we don't have to be afraid of
    // somebody else deleting it.
-    if (cfd->UnrefAndTryDelete()) {
+    if (cfd->Unref()) {
      // This was the last reference of the column family, so no need to
      // compact.
+      delete cfd;
      return Status::OK();
    }

@@ -2747,7 +2752,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    assert(is_snapshot_supported_ || snapshots_.empty());
    CompactionJob compaction_job(
        job_context->job_id, c.get(), immutable_db_options_,
-        file_options_for_compaction_, versions_.get(), &shutting_down_,
+        env_options_for_compaction_, versions_.get(), &shutting_down_,
        preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
        GetDataDir(c->column_family_data(), c->output_path_id()), stats_,
        &mutex_, &error_handler_, snapshot_seqs,
@@ -12,7 +12,6 @@

 #include "db/builder.h"
 #include "db/error_handler.h"
-#include "env/composite_env_wrapper.h"
 #include "file/read_write_util.h"
 #include "file/sst_file_manager_impl.h"
 #include "file/writable_file_writer.h"
@@ -35,18 +34,6 @@ Options SanitizeOptions(const std::string& dbname, const Options& src) {
 DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
  DBOptions result(src);

-  if (result.file_system == nullptr) {
-    if (result.env == Env::Default()) {
-      result.file_system = FileSystem::Default();
-    } else {
-      result.file_system.reset(new LegacyFileSystemWrapper(result.env));
-    }
-  } else {
-    if (result.env == nullptr) {
-      result.env = Env::Default();
-    }
-  }
-
  // result.max_open_files means an "infinite" open files.
  if (result.max_open_files != -1) {
    int max_max_open_files = port::GetMaxOpenFiles();
@@ -267,16 +254,16 @@ Status DBImpl::NewDB() {
  ROCKS_LOG_INFO(immutable_db_options_.info_log, "Creating manifest 1 \n");
  const std::string manifest = DescriptorFileName(dbname_, 1);
  {
-    std::unique_ptr<FSWritableFile> file;
-    FileOptions file_options = fs_->OptimizeForManifestWrite(file_options_);
-    s = NewWritableFile(fs_.get(), manifest, &file, file_options);
+    std::unique_ptr<WritableFile> file;
+    EnvOptions env_options = env_->OptimizeForManifestWrite(env_options_);
+    s = NewWritableFile(env_, manifest, &file, env_options);
    if (!s.ok()) {
      return s;
    }
    file->SetPreallocationBlockSize(
        immutable_db_options_.manifest_preallocation_size);
    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        std::move(file), manifest, file_options, env_, nullptr /* stats */,
+        std::move(file), manifest, env_options, env_, nullptr /* stats */,
        immutable_db_options_.listeners));
    log::Writer log(std::move(file_writer), 0, false);
    std::string record;
@@ -290,7 +277,7 @@ Status DBImpl::NewDB() {
    // Make "CURRENT" file that points to the new manifest file.
    s = SetCurrentFile(env_, dbname_, 1, directories_.GetDbDir());
  } else {
-    fs_->DeleteFile(manifest, IOOptions(), nullptr);
+    env_->DeleteFile(manifest);
  }
  return s;
 }
@@ -363,8 +350,7 @@ Status DBImpl::Recover(
      return s;
    }

-    std::string current_fname = CurrentFileName(dbname_);
-    s = env_->FileExists(current_fname);
+    s = env_->FileExists(CurrentFileName(dbname_));
    if (s.IsNotFound()) {
      if (immutable_db_options_.create_if_missing) {
        // Has to be called only after Identity File creation is successful
@@ -377,7 +363,7 @@ Status DBImpl::Recover(
        }
      } else {
        return Status::InvalidArgument(
-            current_fname, "does not exist (create_if_missing is false)");
+            dbname_, "does not exist (create_if_missing is false)");
      }
    } else if (s.ok()) {
      if (immutable_db_options_.error_if_exists) {
@@ -389,20 +375,20 @@ Status DBImpl::Recover(
      assert(s.IsIOError());
      return s;
    }
-    // Verify compatibility of file_options_ and filesystem
+    // Verify compatibility of env_options_ and filesystem
    {
-      std::unique_ptr<FSRandomAccessFile> idfile;
-      FileOptions customized_fs(file_options_);
-      customized_fs.use_direct_reads |=
+      std::unique_ptr<RandomAccessFile> idfile;
+      EnvOptions customized_env(env_options_);
+      customized_env.use_direct_reads |=
          immutable_db_options_.use_direct_io_for_flush_and_compaction;
-      s = fs_->NewRandomAccessFile(current_fname, customized_fs, &idfile,
-                                   nullptr);
+      s = env_->NewRandomAccessFile(CurrentFileName(dbname_), &idfile,
+                                    customized_env);
      if (!s.ok()) {
        std::string error_str = s.ToString();
        // Check if unsupported Direct I/O is the root cause
-        customized_fs.use_direct_reads = false;
-        s = fs_->NewRandomAccessFile(current_fname, customized_fs, &idfile,
-                                     nullptr);
+        customized_env.use_direct_reads = false;
+        s = env_->NewRandomAccessFile(CurrentFileName(dbname_), &idfile,
+                                      customized_env);
        if (s.ok()) {
          return Status::InvalidArgument(
              "Direct I/O is not supported by the specified DB.");
@@ -422,7 +408,7 @@ Status DBImpl::Recover(
  // the very first time.
  if (db_id_.empty()) {
    // Check for the IDENTITY file and create it if not there.
-    s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
+    s = env_->FileExists(IdentityFileName(dbname_));
    // Typically Identity file is created in NewDB() and for some reason if
    // it is no longer available then at this point DB ID is not in Identity
    // file or Manifest.
@@ -762,10 +748,9 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,

    std::unique_ptr<SequentialFileReader> file_reader;
    {
-      std::unique_ptr<FSSequentialFile> file;
-      status = fs_->NewSequentialFile(fname,
-                                      fs_->OptimizeForLogRead(file_options_),
-                                      &file, nullptr);
+      std::unique_ptr<SequentialFile> file;
+      status = env_->NewSequentialFile(fname, &file,
+                                       env_->OptimizeForLogRead(env_options_));
      if (!status.ok()) {
        MaybeIgnoreError(&status);
        if (!status.ok()) {
@@ -935,7 +920,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
        ColumnFamilyData* cfd;

        while ((cfd = flush_scheduler_.TakeNextColumnFamily()) != nullptr) {
-          cfd->UnrefAndTryDelete();
+          cfd->Unref();
          // If this asserts, it means that InsertInto failed in
          // filtering updates to already-flushed column families
          assert(cfd->GetLogNumber() <= log_number);
@@ -1134,18 +1119,17 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& log_numbers) {
    // preallocated space are not needed anymore. It is likely only the last
    // log has such preallocated space, so we only truncate for the last log.
    if (log_number == log_numbers.back()) {
-      std::unique_ptr<FSWritableFile> last_log;
-      Status truncate_status = fs_->ReopenWritableFile(
-          fname,
-          fs_->OptimizeForLogWrite(
-              file_options_,
-              BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-          &last_log, nullptr);
+      std::unique_ptr<WritableFile> last_log;
+      Status truncate_status = env_->ReopenWritableFile(
+          fname, &last_log,
+          env_->OptimizeForLogWrite(
+              env_options_,
+              BuildDBOptions(immutable_db_options_, mutable_db_options_)));
      if (truncate_status.ok()) {
-        truncate_status = last_log->Truncate(log.size, IOOptions(), nullptr);
+        truncate_status = last_log->Truncate(log.size);
      }
      if (truncate_status.ok()) {
-        truncate_status = last_log->Close(IOOptions(), nullptr);
+        truncate_status = last_log->Close();
      }
      // Not a critical error if fail to truncate.
      if (!truncate_status.ok()) {
@@ -1212,8 +1196,8 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
        range_del_iters.emplace_back(range_del_iter);
      }
      s = BuildTable(
-          dbname_, env_, fs_.get(), *cfd->ioptions(), mutable_cf_options,
-          file_options_for_compaction_, cfd->table_cache(), iter.get(),
+          dbname_, env_, *cfd->ioptions(), mutable_cf_options,
+          env_options_for_compaction_, cfd->table_cache(), iter.get(),
          std::move(range_del_iters), &meta, cfd->internal_comparator(),
          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
          snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
@@ -1296,12 +1280,12 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
 Status DBImpl::CreateWAL(uint64_t log_file_num, uint64_t recycle_log_number,
                         size_t preallocate_block_size, log::Writer** new_log) {
  Status s;
-  std::unique_ptr<FSWritableFile> lfile;
+  std::unique_ptr<WritableFile> lfile;

  DBOptions db_options =
      BuildDBOptions(immutable_db_options_, mutable_db_options_);
-  FileOptions opt_file_options =
-      fs_->OptimizeForLogWrite(file_options_, db_options);
+  EnvOptions opt_env_options =
+      env_->OptimizeForLogWrite(env_options_, db_options);
  std::string log_fname =
      LogFileName(immutable_db_options_.wal_dir, log_file_num);

@@ -1311,10 +1295,10 @@ Status DBImpl::CreateWAL(uint64_t log_file_num, uint64_t recycle_log_number,
                   recycle_log_number);
    std::string old_log_fname =
        LogFileName(immutable_db_options_.wal_dir, recycle_log_number);
-    s = fs_->ReuseWritableFile(log_fname, old_log_fname, opt_file_options,
-                               &lfile, /*dbg=*/nullptr);
+    s = env_->ReuseWritableFile(log_fname, old_log_fname, &lfile,
+                                opt_env_options);
  } else {
-    s = NewWritableFile(fs_.get(), log_fname, &lfile, opt_file_options);
+    s = NewWritableFile(env_, log_fname, &lfile, opt_env_options);
  }

  if (s.ok()) {
@@ -1323,7 +1307,7 @@ Status DBImpl::CreateWAL(uint64_t log_file_num, uint64_t recycle_log_number,

    const auto& listeners = immutable_db_options_.listeners;
    std::unique_ptr<WritableFileWriter> file_writer(
-        new WritableFileWriter(std::move(lfile), log_fname, opt_file_options,
+        new WritableFileWriter(std::move(lfile), log_fname, opt_env_options,
                               env_, nullptr /* stats */, listeners));
    *new_log = new log::Writer(std::move(file_writer), log_file_num,
                               immutable_db_options_.recycle_log_file_num > 0,
@@ -144,10 +144,9 @@ Status DBImplSecondary::MaybeInitLogReader(

    std::unique_ptr<SequentialFileReader> file_reader;
    {
-      std::unique_ptr<FSSequentialFile> file;
-      Status status = fs_->NewSequentialFile(
-          fname, fs_->OptimizeForLogRead(file_options_), &file,
-          nullptr);
+      std::unique_ptr<SequentialFile> file;
+      Status status = env_->NewSequentialFile(
+          fname, &file, env_->OptimizeForLogRead(env_options_));
      if (!status.ok()) {
        *log_reader = nullptr;
        return status;
@@ -601,7 +600,7 @@ Status DB::OpenAsSecondary(
  handles->clear();
  DBImplSecondary* impl = new DBImplSecondary(tmp_opts, dbname);
  impl->versions_.reset(new ReactiveVersionSet(
-      dbname, &impl->immutable_db_options_, impl->file_options_,
+      dbname, &impl->immutable_db_options_, impl->env_options_,
      impl->table_cache_.get(), impl->write_buffer_manager_,
      &impl->write_controller_));
  impl->column_family_memtables_.reset(
@@ -131,7 +131,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                              log_used, log_ref, &seq, sub_batch_cnt,
                              pre_release_callback, kDoAssignOrder,
                              kDoPublishLastSeq, disable_memtable);
-    TEST_SYNC_POINT("DBImpl::WriteImpl:UnorderedWriteAfterWriteWAL");
    if (!status.ok()) {
      return status;
    }
@@ -139,7 +138,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      *seq_used = seq;
    }
    if (!disable_memtable) {
-      TEST_SYNC_POINT("DBImpl::WriteImpl:BeforeUnorderedWriteMemtable");
      status = UnorderedWriteMemtable(write_options, my_batch, callback,
                                      log_ref, seq, sub_batch_cnt);
    }
@@ -1256,7 +1254,7 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
  for (const auto cfd : cfds) {
    cfd->Ref();
    status = SwitchMemtable(cfd, write_context);
-    cfd->UnrefAndTryDelete();
+    cfd->Unref();
    if (!status.ok()) {
      break;
    }
@@ -1335,7 +1333,7 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
    }
    cfd->Ref();
    status = SwitchMemtable(cfd, write_context);
-    cfd->UnrefAndTryDelete();
+    cfd->Unref();
    if (!status.ok()) {
      break;
    }
@@ -1527,7 +1525,8 @@ Status DBImpl::TrimMemtableHistory(WriteContext* context) {
      cfd->InstallSuperVersion(&context->superversion_context, &mutex_);
    }

-    if (cfd->UnrefAndTryDelete()) {
+    if (cfd->Unref()) {
+      delete cfd;
      cfd = nullptr;
    }
  }
@@ -1559,7 +1558,8 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) {
    if (!cfd->mem()->IsEmpty()) {
      status = SwitchMemtable(cfd, context);
    }
-    if (cfd->UnrefAndTryDelete()) {
+    if (cfd->Unref()) {
+      delete cfd;
      cfd = nullptr;
    }
    if (!status.ok()) {
@@ -198,7 +198,7 @@ TEST_F(DBSecondaryTest, OpenAsSecondary) {
 namespace {
 class TraceFileEnv : public EnvWrapper {
 public:
-  explicit TraceFileEnv(Env* _target) : EnvWrapper(_target) {}
+  explicit TraceFileEnv(Env* target) : EnvWrapper(target) {}
  Status NewRandomAccessFile(const std::string& f,
                             std::unique_ptr<RandomAccessFile>* r,
                             const EnvOptions& env_options) override {
@@ -804,50 +804,6 @@ TEST_P(DBIteratorTest, IteratorPinsRef) {
  } while (ChangeCompactOptions());
 }

-TEST_P(DBIteratorTest, IteratorDeleteAfterCfDelete) {
-  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-
-  Put(1, "foo", "delete-cf-then-delete-iter");
-  Put(1, "hello", "value2");
-
-  ColumnFamilyHandle* cf = handles_[1];
-  ReadOptions ro;
-
-  auto* iter = db_->NewIterator(ro, cf);
-  iter->SeekToFirst();
-  ASSERT_EQ(IterStatus(iter), "foo->delete-cf-then-delete-iter");
-
-  // delete CF handle
-  db_->DestroyColumnFamilyHandle(cf);
-  handles_.erase(std::begin(handles_) + 1);
-
-  // delete Iterator after CF handle is deleted
-  iter->Next();
-  ASSERT_EQ(IterStatus(iter), "hello->value2");
-  delete iter;
-}
-
-TEST_P(DBIteratorTest, IteratorDeleteAfterCfDrop) {
-  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-
-  Put(1, "foo", "drop-cf-then-delete-iter");
-
-  ReadOptions ro;
-  ColumnFamilyHandle* cf = handles_[1];
-
-  auto* iter = db_->NewIterator(ro, cf);
-  iter->SeekToFirst();
-  ASSERT_EQ(IterStatus(iter), "foo->drop-cf-then-delete-iter");
-
-  // drop and delete CF
-  db_->DropColumnFamily(cf);
-  db_->DestroyColumnFamilyHandle(cf);
-  handles_.erase(std::begin(handles_) + 1);
-
-  // delete Iterator after CF handle is dropped
-  delete iter;
-}
-
 // SetOptions not defined in ROCKSDB LITE
 #ifndef ROCKSDB_LITE
 TEST_P(DBIteratorTest, DBIteratorBoundTest) {
@@ -1341,19 +1297,19 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {

      // Insert data to true_data map and to DB
      true_data[k] = v;
-      if (rnd.PercentTrue(merge_percentage)) {
+      if (rnd.OneIn(static_cast<int>(100.0 / merge_percentage))) {
        ASSERT_OK(db_->Merge(WriteOptions(), k, v));
      } else {
        ASSERT_OK(Put(k, v));
      }

      // Pick random keys to be used to test Seek()
-      if (rnd.PercentTrue(seeks_percentage)) {
+      if (rnd.OneIn(static_cast<int>(100.0 / seeks_percentage))) {
        random_keys.push_back(k);
      }

      // Delete some random keys
-      if (rnd.PercentTrue(delete_percentage)) {
+      if (rnd.OneIn(static_cast<int>(100.0 / delete_percentage))) {
        deleted_keys.push_back(k);
        true_data.erase(k);
        ASSERT_OK(Delete(k));
@@ -1911,7 +1867,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
  // make sure that we dont merge them while flushing but actually
  // merge them in the read path
  for (int i = 0; i < kNumKeys; i++) {
-    if (rnd.PercentTrue(kNoMergeOpPercentage)) {
+    if (rnd.OneIn(static_cast<int>(100.0 / kNoMergeOpPercentage))) {
      // Dont give merge operations for some keys
      continue;
    }
@@ -1927,7 +1883,7 @@ TEST_P(DBIteratorTest, IterPrevKeyCrossingBlocksRandomized) {
  ASSERT_OK(Flush());

  for (int i = 0; i < kNumKeys; i++) {
-    if (rnd.PercentTrue(kDeletePercentage)) {
+    if (rnd.OneIn(static_cast<int>(100.0 / kDeletePercentage))) {
      gen_key = Key(i);

      ASSERT_OK(Delete(gen_key));
@@ -423,22 +423,16 @@ TEST_F(DBOptionsTest, SetBackgroundJobs) {
            std::to_string(options.max_background_jobs)}}));
    }

-    const int expected_max_flushes = options.max_background_jobs / 4;
-
-    ASSERT_EQ(expected_max_flushes, dbfull()->TEST_BGFlushesAllowed());
+    ASSERT_EQ(options.max_background_jobs / 4,
+              dbfull()->TEST_BGFlushesAllowed());
    ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());

    auto stop_token = dbfull()->TEST_write_controler().GetStopToken();

-    const int expected_max_compactions = 3 * expected_max_flushes;
-
-    ASSERT_EQ(expected_max_flushes, dbfull()->TEST_BGFlushesAllowed());
-    ASSERT_EQ(expected_max_compactions, dbfull()->TEST_BGCompactionsAllowed());
-
-    ASSERT_EQ(expected_max_flushes,
-              env_->GetBackgroundThreads(Env::Priority::HIGH));
-    ASSERT_EQ(expected_max_compactions,
-              env_->GetBackgroundThreads(Env::Priority::LOW));
+    ASSERT_EQ(options.max_background_jobs / 4,
+              dbfull()->TEST_BGFlushesAllowed());
+    ASSERT_EQ(3 * options.max_background_jobs / 4,
+              dbfull()->TEST_BGCompactionsAllowed());
  }
 }

@@ -1705,7 +1705,6 @@ TEST_F(DBTest, Snapshot) {
    ASSERT_EQ(1U, GetNumSnapshots());
    uint64_t time_snap1 = GetTimeOldestSnapshots();
    ASSERT_GT(time_snap1, 0U);
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    Put(0, "foo", "0v2");
    Put(1, "foo", "1v2");

@@ -1714,7 +1713,6 @@ TEST_F(DBTest, Snapshot) {
    const Snapshot* s2 = db_->GetSnapshot();
    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    Put(0, "foo", "0v3");
    Put(1, "foo", "1v3");

@@ -1722,7 +1720,6 @@ TEST_F(DBTest, Snapshot) {
      ManagedSnapshot s3(db_);
      ASSERT_EQ(3U, GetNumSnapshots());
      ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-      ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());

      Put(0, "foo", "0v4");
      Put(1, "foo", "1v4");
@@ -1738,7 +1735,6 @@ TEST_F(DBTest, Snapshot) {

    ASSERT_EQ(2U, GetNumSnapshots());
    ASSERT_EQ(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s1->GetSequenceNumber());
    ASSERT_EQ("0v1", Get(0, "foo", s1));
    ASSERT_EQ("1v1", Get(1, "foo", s1));
    ASSERT_EQ("0v2", Get(0, "foo", s2));
@@ -1753,11 +1749,9 @@ TEST_F(DBTest, Snapshot) {
    ASSERT_EQ("1v4", Get(1, "foo"));
    ASSERT_EQ(1U, GetNumSnapshots());
    ASSERT_LT(time_snap1, GetTimeOldestSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), s2->GetSequenceNumber());

    db_->ReleaseSnapshot(s2);
    ASSERT_EQ(0U, GetNumSnapshots());
-    ASSERT_EQ(GetSequenceOldestSnapshots(), 0);
    ASSERT_EQ("0v4", Get(0, "foo"));
    ASSERT_EQ("1v4", Get(1, "foo"));
  } while (ChangeOptions());
@@ -4246,60 +4246,6 @@ TEST_F(DBTest2, BackgroundPurgeTest) {
  value = options.write_buffer_manager->memory_usage();
  ASSERT_EQ(base_value, value);
 }
-
-TEST_F(DBTest2, SwitchMemtableRaceWithNewManifest) {
-  Options options = CurrentOptions();
-  DestroyAndReopen(options);
-  options.max_manifest_file_size = 10;
-  options.create_if_missing = true;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-
-  ASSERT_OK(Put("foo", "value"));
-  const int kL0Files = options.level0_file_num_compaction_trigger;
-  for (int i = 0; i < kL0Files; ++i) {
-    ASSERT_OK(Put(/*cf=*/1, "a", std::to_string(i)));
-    ASSERT_OK(Flush(/*cf=*/1));
-  }
-
-  port::Thread thread([&]() { ASSERT_OK(Flush()); });
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  thread.join();
-}
-
-TEST_F(DBTest2, SameSmallestInSameLevel) {
-  // This test validates fractional casacading logic when several files at one
-  // one level only contains the same user key.
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  DestroyAndReopen(options);
-
-  ASSERT_OK(Put("key", "1"));
-  ASSERT_OK(Put("key", "2"));
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "3"));
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "4"));
-  Flush();
-  CompactRangeOptions cro;
-  cro.change_level = true;
-  cro.target_level = 2;
-  ASSERT_OK(dbfull()->CompactRange(cro, db_->DefaultColumnFamily(), nullptr,
-                                   nullptr));
-
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "5"));
-  Flush();
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "6"));
-  Flush();
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "7"));
-  Flush();
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", "8"));
-  Flush();
-  dbfull()->TEST_WaitForCompact(true);
-#ifndef ROCKSDB_LITE
-  ASSERT_EQ("0,4,1", FilesPerLevel());
-#endif  // ROCKSDB_LITE
-
-  ASSERT_EQ("2,3,4,5,6,7,8", Get("key"));
-}
 }  // namespace rocksdb

 #ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
@@ -867,13 +867,6 @@ uint64_t DBTestBase::GetTimeOldestSnapshots() {
  return int_num;
 }

-uint64_t DBTestBase::GetSequenceOldestSnapshots() {
-  uint64_t int_num;
-  EXPECT_TRUE(
-      dbfull()->GetIntProperty("rocksdb.oldest-snapshot-sequence", &int_num));
-  return int_num;
-}
-
 // Return a string that contains all key,value pairs in order,
 // formatted like "(k1->v1)(k2->v2)".
 std::string DBTestBase::Contents(int cf) {
@@ -860,8 +860,6 @@ class DBTestBase : public testing::Test {

  uint64_t GetTimeOldestSnapshots();

-  uint64_t GetSequenceOldestSnapshots();
-
  // Return a string that contains all key,value pairs in order,
  // formatted like "(k1->v1)(k2->v2)".
  std::string Contents(int cf = 0);
@@ -1753,14 +1753,13 @@ TEST_P(DBTestUniversalCompaction, RecalculateScoreAfterPicking) {
  // scheduling more; otherwise, other CFs/DBs may be delayed unnecessarily.
  const int kNumFilesTrigger = 8;
  Options options = CurrentOptions();
-  options.memtable_factory.reset(
-      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_options_universal.max_merge_width = kNumFilesTrigger / 2;
  options.compaction_options_universal.max_size_amplification_percent =
      static_cast<unsigned int>(-1);
  options.compaction_style = kCompactionStyleUniversal;
  options.level0_file_num_compaction_trigger = kNumFilesTrigger;
  options.num_levels = num_levels_;
+  options.write_buffer_size = 100 << 10;  // 100KB
  Reopen(options);

  std::atomic<int> num_compactions_attempted(0);
@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/db_test_util.h"
-#include "env/composite_env_wrapper.h"
 #include "options/options_helper.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
@@ -903,8 +902,8 @@ class RecoveryTestHelper {
      std::string fname = LogFileName(test->dbname_, current_log_number);
      std::unique_ptr<WritableFile> file;
      ASSERT_OK(db_options.env->NewWritableFile(fname, &file, env_options));
-      std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-          NewLegacyWritableFileWrapper(std::move(file)), fname, env_options));
+      std::unique_ptr<WritableFileWriter> file_writer(
+          new WritableFileWriter(std::move(file), fname, env_options));
      current_log_writer.reset(
          new log::Writer(std::move(file_writer), current_log_number,
                          db_options.recycle_log_file_num > 0));
@@ -7,7 +7,6 @@
 #include <memory>
 #include <thread>
 #include <vector>
-#include <fstream>
 #include "db/db_test_util.h"
 #include "db/write_batch_internal.h"
 #include "db/write_thread.h"
@@ -277,41 +276,6 @@ TEST_P(DBWriteTest, LockWalInEffect) {
  ASSERT_OK(dbfull()->UnlockWAL());
 }

-TEST_P(DBWriteTest, ConcurrentlyDisabledWAL) {
-    Options options = GetOptions();
-    options.statistics = rocksdb::CreateDBStatistics();
-    options.statistics->set_stats_level(StatsLevel::kAll);
-    Reopen(options);
-    std::string wal_key_prefix = "WAL_KEY_";
-    std::string no_wal_key_prefix = "K_";
-    // 100 KB value each for NO-WAL operation
-    std::string no_wal_value(1024 * 100, 'X');
-    // 1B value each for WAL operation
-    std::string wal_value = "0";
-    std::thread threads[10];
-    for (int t = 0; t < 10; t++) {
-        threads[t] = std::thread([t, wal_key_prefix, wal_value, no_wal_key_prefix, no_wal_value, this] {
-            for(int i = 0; i < 10; i++) {
-                rocksdb::WriteOptions write_option_disable;
-                write_option_disable.disableWAL = true;
-                rocksdb::WriteOptions write_option_default;
-                std::string no_wal_key = no_wal_key_prefix + std::to_string(t) + "_" + std::to_string(i);
-                this->Put(no_wal_key, no_wal_value, write_option_disable);
-                std::string wal_key = wal_key_prefix + std::to_string(i) + "_" + std::to_string(i);
-                this->Put(wal_key, wal_value, write_option_default);
-                dbfull()->SyncWAL();
-            }
-            return 0;
-        });
-    }
-    for (auto& t: threads) {
-        t.join();
-    }
-    uint64_t bytes_num = options.statistics->getTickerCount(rocksdb::Tickers::WAL_FILE_BYTES);
-    // written WAL size should less than 100KB (even included HEADER & FOOTER overhead)
-    ASSERT_LE(bytes_num, 1024 * 100);
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                        testing::Values(DBTestBase::kDefault,
                                        DBTestBase::kConcurrentWALWrites,
@@ -288,7 +288,7 @@ TEST_F(DBErrorHandlingTest, CompactionManifestWriteError) {

  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      // Wait for flush of 2nd L0 file before starting compaction
-      {{"DBImpl::FlushMemTable:FlushMemTableFinished",
+      {{"FlushMemTableFinished",
        "BackgroundCallCompaction:0"},
      // Wait for compaction to detect manifest write error
       {"BackgroundCallCompaction:1",
@@ -361,8 +361,7 @@ TEST_F(DBErrorHandlingTest, CompactionWriteError) {
      );
  listener->EnableAutoRecovery(false);
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::FlushMemTable:FlushMemTableFinished",
-        "BackgroundCallCompaction:0"}});
+      {{"FlushMemTableFinished", "BackgroundCallCompaction:0"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "BackgroundCallCompaction:0", [&](void *) {
      fault_env->SetFilesystemActive(false, Status::NoSpace("Out of space"));
@@ -398,8 +397,7 @@ TEST_F(DBErrorHandlingTest, CorruptionError) {
  ASSERT_EQ(s, Status::OK());

  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::FlushMemTable:FlushMemTableFinished",
-        "BackgroundCallCompaction:0"}});
+      {{"FlushMemTableFinished", "BackgroundCallCompaction:0"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "BackgroundCallCompaction:0", [&](void *) {
      fault_env->SetFilesystemActive(false, Status::Corruption("Corruption"));
@@ -101,15 +101,14 @@ Status ExternalSstFileIngestionJob::Prepare(
        TableFileName(cfd_->ioptions()->cf_paths, f.fd.GetNumber(),
                      f.fd.GetPathId());
    if (ingestion_options_.move_files) {
-      status =
-          fs_->LinkFile(path_outside_db, path_inside_db, IOOptions(), nullptr);
+      status = env_->LinkFile(path_outside_db, path_inside_db);
      if (status.ok()) {
        // It is unsafe to assume application had sync the file and file
        // directory before ingest the file. For integrity of RocksDB we need
        // to sync the file.
-        std::unique_ptr<FSWritableFile> file_to_sync;
-        status = fs_->ReopenWritableFile(path_inside_db, env_options_,
-                                         &file_to_sync, nullptr);
+        std::unique_ptr<WritableFile> file_to_sync;
+        status = env_->ReopenWritableFile(path_inside_db, &file_to_sync,
+                                          env_options_);
        if (status.ok()) {
          TEST_SYNC_POINT(
              "ExternalSstFileIngestionJob::BeforeSyncIngestedFile");
@@ -134,7 +133,7 @@ Status ExternalSstFileIngestionJob::Prepare(
      TEST_SYNC_POINT_CALLBACK("ExternalSstFileIngestionJob::Prepare:CopyFile",
                               nullptr);
      // CopyFile also sync the new file.
-      status = CopyFile(fs_, path_outside_db, path_inside_db, 0,
+      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
                        db_options_.use_fsync);
    }
    TEST_SYNC_POINT("ExternalSstFileIngestionJob::Prepare:FileAdded");
@@ -361,19 +360,17 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
  file_to_ingest->external_file_path = external_file;

  // Get external file size
-  Status status = fs_->GetFileSize(external_file, IOOptions(),
-                                   &file_to_ingest->file_size, nullptr);
+  Status status = env_->GetFileSize(external_file, &file_to_ingest->file_size);
  if (!status.ok()) {
    return status;
  }

  // Create TableReader for external file
  std::unique_ptr<TableReader> table_reader;
-  std::unique_ptr<FSRandomAccessFile> sst_file;
+  std::unique_ptr<RandomAccessFile> sst_file;
  std::unique_ptr<RandomAccessFileReader> sst_file_reader;

-  status = fs_->NewRandomAccessFile(external_file, env_options_,
-                                    &sst_file, nullptr);
+  status = env_->NewRandomAccessFile(external_file, &sst_file, env_options_);
  if (!status.ok()) {
    return status;
  }
@@ -654,15 +651,13 @@ Status ExternalSstFileIngestionJob::AssignGlobalSeqnoForIngestedFile(
    // Determine if we can write global_seqno to a given offset of file.
    // If the file system does not support random write, then we should not.
    // Otherwise we should.
-    std::unique_ptr<FSRandomRWFile> rwfile;
-    Status status =
-        fs_->NewRandomRWFile(file_to_ingest->internal_file_path, env_options_,
-                             &rwfile, nullptr);
+    std::unique_ptr<RandomRWFile> rwfile;
+    Status status = env_->NewRandomRWFile(file_to_ingest->internal_file_path,
+                                          &rwfile, env_options_);
    if (status.ok()) {
      std::string seqno_val;
      PutFixed64(&seqno_val, seqno);
-      status = rwfile->Write(file_to_ingest->global_seqno_offset, seqno_val,
-                             IOOptions(), nullptr);
+      status = rwfile->Write(file_to_ingest->global_seqno_offset, seqno_val);
      if (status.ok()) {
        TEST_SYNC_POINT("ExternalSstFileIngestionJob::BeforeSyncGlobalSeqno");
        status = SyncIngestedFile(rwfile.get());
@@ -720,9 +715,9 @@ template <typename TWritableFile>
 Status ExternalSstFileIngestionJob::SyncIngestedFile(TWritableFile* file) {
  assert(file != nullptr);
  if (db_options_.use_fsync) {
-    return file->Fsync(IOOptions(), nullptr);
+    return file->Fsync();
  } else {
-    return file->Sync(IOOptions(), nullptr);
+    return file->Sync();
  }
 }

@@ -74,7 +74,6 @@ class ExternalSstFileIngestionJob {
      const IngestExternalFileOptions& ingestion_options,
      Directories* directories, EventLogger* event_logger)
      : env_(env),
-        fs_(db_options.fs.get()),
        versions_(versions),
        cfd_(cfd),
        db_options_(db_options),
@@ -159,7 +158,6 @@ class ExternalSstFileIngestionJob {
  Status SyncIngestedFile(TWritableFile* file);

  Env* env_;
-  FileSystem* fs_;
  VersionSet* versions_;
  ColumnFamilyData* cfd_;
  const ImmutableDBOptions& db_options_;
@@ -1700,35 +1700,6 @@ TEST_F(ExternalSSTFileTest, SstFileWriterNonSharedKeys) {
  ASSERT_OK(DeprecatedAddFile({file_path}));
 }

-TEST_F(ExternalSSTFileTest, WithUnorderedWrite) {
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::WriteImpl:UnorderedWriteAfterWriteWAL",
-        "ExternalSSTFileTest::WithUnorderedWrite:WaitWriteWAL"},
-       {"DBImpl::WaitForPendingWrites:BeforeBlock",
-        "DBImpl::WriteImpl:BeforeUnorderedWriteMemtable"}});
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::IngestExternalFile:NeedFlush", [&](void* need_flush) {
-        ASSERT_TRUE(*reinterpret_cast<bool*>(need_flush));
-      });
-
-  Options options = CurrentOptions();
-  options.unordered_write = true;
-  DestroyAndReopen(options);
-  Put("foo", "v1");
-  SyncPoint::GetInstance()->EnableProcessing();
-  port::Thread writer([&]() { Put("bar", "v2"); });
-
-  TEST_SYNC_POINT("ExternalSSTFileTest::WithUnorderedWrite:WaitWriteWAL");
-  ASSERT_OK(GenerateAndAddExternalFile(options, {{"bar", "v3"}}, -1,
-                                       true /* allow_global_seqno */));
-  ASSERT_EQ(Get("bar"), "v3");
-
-  writer.join();
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
  Options options = CurrentOptions();
  options.IncreaseParallelism(20);
@@ -108,30 +108,26 @@ void FileIndexer::UpdateIndex(Arena* arena, const size_t num_levels,

    CalculateLB(
        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->smallest.user_key(),
-                                                b->largest.user_key());
+        [this](const FileMetaData * a, const FileMetaData * b)->int {
+          return ucmp_->Compare(a->smallest.user_key(), b->largest.user_key());
        },
        [](IndexUnit* index, int32_t f_idx) { index->smallest_lb = f_idx; });
    CalculateLB(
        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->largest.user_key(),
-                                                b->largest.user_key());
+        [this](const FileMetaData * a, const FileMetaData * b)->int {
+          return ucmp_->Compare(a->largest.user_key(), b->largest.user_key());
        },
        [](IndexUnit* index, int32_t f_idx) { index->largest_lb = f_idx; });
    CalculateRB(
        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->smallest.user_key(),
-                                                b->smallest.user_key());
+        [this](const FileMetaData * a, const FileMetaData * b)->int {
+          return ucmp_->Compare(a->smallest.user_key(), b->smallest.user_key());
        },
        [](IndexUnit* index, int32_t f_idx) { index->smallest_rb = f_idx; });
    CalculateRB(
        upper_files, lower_files, &index_level,
-        [this](const FileMetaData* a, const FileMetaData* b) -> int {
-          return ucmp_->CompareWithoutTimestamp(a->largest.user_key(),
-                                                b->smallest.user_key());
+        [this](const FileMetaData * a, const FileMetaData * b)->int {
+          return ucmp_->Compare(a->largest.user_key(), b->smallest.user_key());
        },
        [](IndexUnit* index, int32_t f_idx) { index->largest_rb = f_idx; });
  }
@@ -157,6 +153,7 @@ void FileIndexer::CalculateLB(
    if (cmp == 0) {
      set_index(&index[upper_idx], lower_idx);
      ++upper_idx;
+      ++lower_idx;
    } else if (cmp > 0) {
      // Lower level's file (largest) is smaller, a key won't hit in that
      // file. Move to next lower file
@@ -194,6 +191,7 @@ void FileIndexer::CalculateRB(
    if (cmp == 0) {
      set_index(&index[upper_idx], lower_idx);
      --upper_idx;
+      --lower_idx;
    } else if (cmp < 0) {
      // Lower level's file (smallest) is larger, a key won't hit in that
      // file. Move to next lower file.
@@ -86,7 +86,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                   const ImmutableDBOptions& db_options,
                   const MutableCFOptions& mutable_cf_options,
                   const uint64_t* max_memtable_id,
-                   const FileOptions& file_options, VersionSet* versions,
+                   const EnvOptions& env_options, VersionSet* versions,
                   InstrumentedMutex* db_mutex,
                   std::atomic<bool>* shutting_down,
                   std::vector<SequenceNumber> existing_snapshots,
@@ -103,7 +103,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
      db_options_(db_options),
      mutable_cf_options_(mutable_cf_options),
      max_memtable_id_(max_memtable_id),
-      file_options_(file_options),
+      env_options_(env_options),
      versions_(versions),
      db_mutex_(db_mutex),
      shutting_down_(shutting_down),
@@ -249,8 +249,7 @@ Status FlushJob::Run(LogsWithPrepTracker* prep_tracker,
  }
  RecordFlushIOStats();

-  // When measure_io_stats_ is true, the default 512 bytes is not enough.
-  auto stream = event_logger_->LogToBuffer(log_buffer_, 1024);
+  auto stream = event_logger_->LogToBuffer(log_buffer_);
  stream << "job" << job_context_->job_id << "event"
         << "flush_finished";
  stream << "output_compression"
@@ -372,8 +371,8 @@ Status FlushJob::WriteLevel0Table() {
      meta_.file_creation_time = current_time;

      s = BuildTable(
-          dbname_, db_options_.env, db_options_.fs.get(), *cfd_->ioptions(),
-          mutable_cf_options_, file_options_, cfd_->table_cache(), iter.get(),
+          dbname_, db_options_.env, *cfd_->ioptions(), mutable_cf_options_,
+          env_options_, cfd_->table_cache(), iter.get(),
          std::move(range_del_iters), &meta_, cfd_->internal_comparator(),
          cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
          cfd_->GetName(), existing_snapshots_,
@@ -61,7 +61,7 @@ class FlushJob {
  FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
           const ImmutableDBOptions& db_options,
           const MutableCFOptions& mutable_cf_options,
-           const uint64_t* max_memtable_id, const FileOptions& file_options,
+           const uint64_t* max_memtable_id, const EnvOptions& env_options,
           VersionSet* versions, InstrumentedMutex* db_mutex,
           std::atomic<bool>* shutting_down,
           std::vector<SequenceNumber> existing_snapshots,
@@ -108,7 +108,7 @@ class FlushJob {
  // equal to *max_memtable_id_ will be selected for flush. If null, then all
  // memtables in the column family will be selected.
  const uint64_t* max_memtable_id_;
-  const FileOptions file_options_;
+  const EnvOptions env_options_;
  VersionSet* versions_;
  InstrumentedMutex* db_mutex_;
  std::atomic<bool>* shutting_down_;
@@ -30,13 +30,16 @@ class FlushJobTest : public testing::Test {
 public:
  FlushJobTest()
      : env_(Env::Default()),
-        fs_(std::make_shared<LegacyFileSystemWrapper>(env_)),
        dbname_(test::PerThreadDBPath("flush_job_test")),
        options_(),
        db_options_(options_),
        column_family_names_({kDefaultColumnFamilyName, "foo", "bar"}),
        table_cache_(NewLRUCache(50000, 16)),
        write_buffer_manager_(db_options_.db_write_buffer_size),
+        versions_(new VersionSet(dbname_, &db_options_, env_options_,
+                                 table_cache_.get(), &write_buffer_manager_,
+                                 &write_controller_,
+                                 /*block_cache_tracer=*/nullptr)),
        shutting_down_(false),
        mock_table_factory_(new mock::MockTableFactory()) {
    EXPECT_OK(env_->CreateDirIfMissing(dbname_));
@@ -51,12 +54,6 @@ class FlushJobTest : public testing::Test {
      column_families.emplace_back(cf_name, cf_options_);
    }

-    db_options_.env = env_;
-    db_options_.fs = fs_;
-    versions_.reset(new VersionSet(dbname_, &db_options_, env_options_,
-                                   table_cache_.get(), &write_buffer_manager_,
-                                   &write_controller_,
-                                   /*block_cache_tracer=*/nullptr));
    EXPECT_OK(versions_->Recover(column_families, false));
  }

@@ -91,8 +88,8 @@ class FlushJobTest : public testing::Test {
    Status s = env_->NewWritableFile(
        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
    ASSERT_OK(s);
-    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        NewLegacyWritableFileWrapper(std::move(file)), manifest, EnvOptions()));
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(std::move(file), manifest, EnvOptions()));
    {
      log::Writer log(std::move(file_writer), 0, false);
      std::string record;
@@ -112,7 +109,6 @@ class FlushJobTest : public testing::Test {
  }

  Env* env_;
-  std::shared_ptr<FileSystem> fs_;
  std::string dbname_;
  EnvOptions env_options_;
  Options options_;
@@ -60,7 +60,9 @@ ColumnFamilyData* FlushScheduler::TakeNextColumnFamily() {
    }

    // no longer relevant, retry
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      delete cfd;
+    }
  }
 }

@@ -78,7 +80,9 @@ bool FlushScheduler::Empty() {
 void FlushScheduler::Clear() {
  ColumnFamilyData* cfd;
  while ((cfd = TakeNextColumnFamily()) != nullptr) {
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      delete cfd;
+    }
  }
  assert(head_.load(std::memory_order_relaxed) == nullptr);
 }
@@ -92,15 +92,14 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
        cfd_->ioptions()->cf_paths, f.fd.GetNumber(), f.fd.GetPathId());

    if (hardlink_files) {
-      status =
-          fs_->LinkFile(path_outside_db, path_inside_db, IOOptions(), nullptr);
+      status = env_->LinkFile(path_outside_db, path_inside_db);
      if (status.IsNotSupported()) {
        // Original file is on a different FS, use copy instead of hard linking
        hardlink_files = false;
      }
    }
    if (!hardlink_files) {
-      status = CopyFile(fs_, path_outside_db, path_inside_db, 0,
+      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
                        db_options_.use_fsync);
    }
    if (!status.ok()) {
@@ -116,8 +115,7 @@ Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
      if (f.internal_file_path.empty()) {
        break;
      }
-      const auto s =
-          fs_->DeleteFile(f.internal_file_path, IOOptions(), nullptr);
+      const auto s = env_->DeleteFile(f.internal_file_path);
      if (!s.ok()) {
        ROCKS_LOG_WARN(db_options_.info_log,
                       "AddFile() clean up for file %s failed : %s",
@@ -170,8 +168,7 @@ void ImportColumnFamilyJob::Cleanup(const Status& status) {
  if (!status.ok()) {
    // We failed to add files to the database remove all the files we copied.
    for (const auto& f : files_to_import_) {
-      const auto s =
-          fs_->DeleteFile(f.internal_file_path, IOOptions(), nullptr);
+      const auto s = env_->DeleteFile(f.internal_file_path);
      if (!s.ok()) {
        ROCKS_LOG_WARN(db_options_.info_log,
                       "AddFile() clean up for file %s failed : %s",
@@ -181,8 +178,7 @@ void ImportColumnFamilyJob::Cleanup(const Status& status) {
  } else if (status.ok() && import_options_.move_files) {
    // The files were moved and added successfully, remove original file links
    for (IngestedFileInfo& f : files_to_import_) {
-      const auto s =
-          fs_->DeleteFile(f.external_file_path, IOOptions(), nullptr);
+      const auto s = env_->DeleteFile(f.external_file_path);
      if (!s.ok()) {
        ROCKS_LOG_WARN(
            db_options_.info_log,
@@ -200,19 +196,17 @@ Status ImportColumnFamilyJob::GetIngestedFileInfo(
  file_to_import->external_file_path = external_file;

  // Get external file size
-  Status status = fs_->GetFileSize(external_file, IOOptions(),
-                                   &file_to_import->file_size, nullptr);
+  auto status = env_->GetFileSize(external_file, &file_to_import->file_size);
  if (!status.ok()) {
    return status;
  }

  // Create TableReader for external file
  std::unique_ptr<TableReader> table_reader;
-  std::unique_ptr<FSRandomAccessFile> sst_file;
+  std::unique_ptr<RandomAccessFile> sst_file;
  std::unique_ptr<RandomAccessFileReader> sst_file_reader;

-  status = fs_->NewRandomAccessFile(external_file, env_options_,
-                                    &sst_file, nullptr);
+  status = env_->NewRandomAccessFile(external_file, &sst_file, env_options_);
  if (!status.ok()) {
    return status;
  }
@@ -29,7 +29,6 @@ class ImportColumnFamilyJob {
        versions_(versions),
        cfd_(cfd),
        db_options_(db_options),
-        fs_(db_options_.fs.get()),
        env_options_(env_options),
        import_options_(import_options),
        metadata_(metadata) {}
@@ -61,7 +60,6 @@ class ImportColumnFamilyJob {
  VersionSet* versions_;
  ColumnFamilyData* cfd_;
  const ImmutableDBOptions& db_options_;
-  FileSystem* fs_;
  const EnvOptions& env_options_;
  autovector<IngestedFileInfo> files_to_import_;
  VersionEdit edit_;
@@ -231,7 +231,6 @@ static const std::string is_file_deletions_enabled =
    "is-file-deletions-enabled";
 static const std::string num_snapshots = "num-snapshots";
 static const std::string oldest_snapshot_time = "oldest-snapshot-time";
-static const std::string oldest_snapshot_sequence = "oldest-snapshot-sequence";
 static const std::string num_live_versions = "num-live-versions";
 static const std::string current_version_number =
    "current-super-version-number";
@@ -310,8 +309,6 @@ const std::string DB::Properties::kNumSnapshots =
    rocksdb_prefix + num_snapshots;
 const std::string DB::Properties::kOldestSnapshotTime =
    rocksdb_prefix + oldest_snapshot_time;
-const std::string DB::Properties::kOldestSnapshotSequence =
-    rocksdb_prefix + oldest_snapshot_sequence;
 const std::string DB::Properties::kNumLiveVersions =
    rocksdb_prefix + num_live_versions;
 const std::string DB::Properties::kCurrentSuperVersionNumber =
@@ -430,9 +427,6 @@ const std::unordered_map<std::string, DBPropertyInfo>
        {DB::Properties::kOldestSnapshotTime,
         {false, nullptr, &InternalStats::HandleOldestSnapshotTime, nullptr,
          nullptr}},
-        {DB::Properties::kOldestSnapshotSequence,
-         {false, nullptr, &InternalStats::HandleOldestSnapshotSequence, nullptr,
-          nullptr}},
        {DB::Properties::kNumLiveVersions,
         {false, nullptr, &InternalStats::HandleNumLiveVersions, nullptr,
          nullptr}},
@@ -663,6 +657,7 @@ bool InternalStats::HandleNumImmutableMemTableFlushed(uint64_t* value,

 bool InternalStats::HandleMemTableFlushPending(uint64_t* value, DBImpl* /*db*/,
                                               Version* /*version*/) {
+  // Return number of mem tables that are ready to flush (made immutable)
  *value = (cfd_->imm()->IsFlushPending() ? 1 : 0);
  return true;
 }
@@ -777,12 +772,6 @@ bool InternalStats::HandleOldestSnapshotTime(uint64_t* value, DBImpl* db,
  return true;
 }

-bool InternalStats::HandleOldestSnapshotSequence(uint64_t* value, DBImpl* db,
-                                                 Version* /*version*/) {
-  *value = static_cast<uint64_t>(db->snapshots().GetOldestSnapshotSequence());
-  return true;
-}
-
 bool InternalStats::HandleNumLiveVersions(uint64_t* value, DBImpl* /*db*/,
                                          Version* /*version*/) {
  *value = cfd_->GetNumLiveVersions();
@@ -553,8 +553,6 @@ class InternalStats {
  bool HandleEstimateNumKeys(uint64_t* value, DBImpl* db, Version* version);
  bool HandleNumSnapshots(uint64_t* value, DBImpl* db, Version* version);
  bool HandleOldestSnapshotTime(uint64_t* value, DBImpl* db, Version* version);
-  bool HandleOldestSnapshotSequence(uint64_t* value, DBImpl* db,
-                                    Version* version);
  bool HandleNumLiveVersions(uint64_t* value, DBImpl* db, Version* version);
  bool HandleCurrentSuperVersionNumber(uint64_t* value, DBImpl* db,
                                       Version* version);
@@ -9,7 +9,6 @@

 #include "db/log_reader.h"
 #include "db/log_writer.h"
-#include "env/composite_env_wrapper.h"
 #include "file/sequence_file_reader.h"
 #include "file/writable_file_writer.h"
 #include "rocksdb/env.h"
@@ -121,13 +120,6 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
    }
  };

-  inline StringSource* GetStringSourceFromLegacyReader(
-      SequentialFileReader* reader) {
-    LegacySequentialFileWrapper* file =
-        static_cast<LegacySequentialFileWrapper*>(reader->file());
-    return static_cast<StringSource*>(file->target());
-  }
-
  class ReportCollector : public Reader::Reporter {
   public:
    size_t dropped_bytes_;
@@ -141,19 +133,21 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  };

  std::string& dest_contents() {
-    auto dest = test::GetStringSinkFromLegacyWriter(writer_.file());
+    auto dest =
+      dynamic_cast<test::StringSink*>(writer_.file()->writable_file());
    assert(dest);
    return dest->contents_;
  }

  const std::string& dest_contents() const {
-    auto dest = test::GetStringSinkFromLegacyWriter(writer_.file());
+    auto dest =
+      dynamic_cast<const test::StringSink*>(writer_.file()->writable_file());
    assert(dest);
    return dest->contents_;
  }

  void reset_source_contents() {
-    auto src = GetStringSourceFromLegacyReader(reader_->file());
+    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
    assert(src);
    src->contents_ = dest_contents();
  }
@@ -220,7 +214,8 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void ShrinkSize(int bytes) {
-    auto dest = test::GetStringSinkFromLegacyWriter(writer_.file());
+    auto dest =
+      dynamic_cast<test::StringSink*>(writer_.file()->writable_file());
    assert(dest);
    dest->Drop(bytes);
  }
@@ -235,7 +230,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void ForceError(size_t position = 0) {
-    auto src = GetStringSourceFromLegacyReader(reader_->file());
+    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
    src->force_error_ = true;
    src->force_error_position_ = position;
  }
@@ -249,13 +244,13 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
  }

  void ForceEOF(size_t position = 0) {
-    auto src = GetStringSourceFromLegacyReader(reader_->file());
+    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
    src->force_eof_ = true;
    src->force_eof_position_ = position;
  }

  void UnmarkEOF() {
-    auto src = GetStringSourceFromLegacyReader(reader_->file());
+    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
    src->returned_partial_ = false;
    reader_->UnmarkEOF();
  }
@@ -757,9 +752,8 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
      s = env_->NewWritableFile(log_file_, &writable_file, env_options_);
    }
    if (s.ok()) {
-      writer_.reset(new WritableFileWriter(
-          NewLegacyWritableFileWrapper(std::move(writable_file)), log_file_,
-          env_options_));
+      writer_.reset(new WritableFileWriter(std::move(writable_file), log_file_,
+                                           env_options_));
      assert(writer_ != nullptr);
    }
    std::unique_ptr<SequentialFile> seq_file;
@@ -767,8 +761,7 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
      s = env_->NewSequentialFile(log_file_, &seq_file, env_options_);
    }
    if (s.ok()) {
-      reader_.reset(new SequentialFileReader(
-          NewLegacySequentialFileWrapper(seq_file), log_file_));
+      reader_.reset(new SequentialFileReader(std::move(seq_file), log_file_));
      assert(reader_ != nullptr);
      log_reader_.reset(new FragmentBufferedReader(
          nullptr, std::move(reader_), &report_, true /* checksum */,
@@ -779,7 +772,8 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
  }

  std::string contents() {
-    auto file = test::GetStringSinkFromLegacyWriter(log_writer_->file());
+    auto file =
+        dynamic_cast<test::StringSink*>(log_writer_->file()->writable_file());
    assert(file != nullptr);
    return file->contents_;
  }
@@ -92,7 +92,6 @@ class MemTableListTest : public testing::Test {
    CreateDB();
    // Create a mock VersionSet
    DBOptions db_options;
-    db_options.file_system = FileSystem::Default();
    ImmutableDBOptions immutable_db_options(db_options);
    EnvOptions env_options;
    std::shared_ptr<Cache> table_cache(NewLRUCache(50000, 16));
@@ -139,8 +138,6 @@ class MemTableListTest : public testing::Test {
    CreateDB();
    // Create a mock VersionSet
    DBOptions db_options;
-    db_options.file_system.reset(new LegacyFileSystemWrapper(db_options.env));
-
    ImmutableDBOptions immutable_db_options(db_options);
    EnvOptions env_options;
    std::shared_ptr<Cache> table_cache(NewLRUCache(50000, 16));
@@ -11,8 +11,8 @@
 #include "db/range_del_aggregator.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/version_edit.h"
-#include "rocksdb/comparator.h"
-#include "rocksdb/types.h"
+#include "include/rocksdb/comparator.h"
+#include "include/rocksdb/types.h"
 #include "table/internal_iterator.h"
 #include "table/scoped_arena_iterator.h"
 #include "table/table_builder.h"
@@ -19,8 +19,8 @@
 #include "db/range_del_aggregator.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/version_edit.h"
-#include "rocksdb/comparator.h"
-#include "rocksdb/types.h"
+#include "include/rocksdb/comparator.h"
+#include "include/rocksdb/types.h"
 #include "table/internal_iterator.h"
 #include "table/scoped_arena_iterator.h"
 #include "table/table_builder.h"
@@ -71,7 +71,6 @@
 #include "db/table_cache.h"
 #include "db/version_edit.h"
 #include "db/write_batch_internal.h"
-#include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "file/writable_file_writer.h"
 #include "options/cf_options.h"
@@ -349,8 +348,8 @@ class Repairer {
    if (!status.ok()) {
      return status;
    }
-    std::unique_ptr<SequentialFileReader> lfile_reader(new SequentialFileReader(
-        NewLegacySequentialFileWrapper(lfile), logname));
+    std::unique_ptr<SequentialFileReader> lfile_reader(
+        new SequentialFileReader(std::move(lfile), logname));

    // Create the log reader.
    LogReporter reporter;
@@ -422,19 +421,17 @@ class Repairer {
      if (range_del_iter != nullptr) {
        range_del_iters.emplace_back(range_del_iter);
      }
-
-      LegacyFileSystemWrapper fs(env_);
      status = BuildTable(
-          dbname_, env_, &fs, *cfd->ioptions(),
-          *cfd->GetLatestMutableCFOptions(), env_options_, table_cache_,
-          iter.get(), std::move(range_del_iters), &meta,
-          cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
-          cfd->GetID(), cfd->GetName(), {}, kMaxSequenceNumber,
-          snapshot_checker, kNoCompression, 0 /* sample_for_compression */,
-          CompressionOptions(), false, nullptr /* internal_stats */,
-          TableFileCreationReason::kRecovery, nullptr /* event_logger */,
-          0 /* job_id */, Env::IO_HIGH, nullptr /* table_properties */,
-          -1 /* level */, current_time, write_hint);
+          dbname_, env_, *cfd->ioptions(), *cfd->GetLatestMutableCFOptions(),
+          env_options_, table_cache_, iter.get(), std::move(range_del_iters),
+          &meta, cfd->internal_comparator(),
+          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
+          {}, kMaxSequenceNumber, snapshot_checker, kNoCompression,
+          0 /* sample_for_compression */, CompressionOptions(), false,
+          nullptr /* internal_stats */, TableFileCreationReason::kRecovery,
+          nullptr /* event_logger */, 0 /* job_id */, Env::IO_HIGH,
+          nullptr /* table_properties */, -1 /* level */, current_time,
+          write_hint);
      ROCKS_LOG_INFO(db_options_.info_log,
                     "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s",
                     log, counter, meta.fd.GetNumber(),
@@ -670,14 +667,8 @@ Status RepairDB(const std::string& dbname, const DBOptions& db_options,
 }

 Status RepairDB(const std::string& dbname, const Options& options) {
-  Options opts(options);
-  if (opts.file_system == nullptr) {
-    opts.file_system.reset(new LegacyFileSystemWrapper(opts.env));
-    ;
-  }
-
-  DBOptions db_options(opts);
-  ColumnFamilyOptions cf_options(opts);
+  DBOptions db_options(options);
+  ColumnFamilyOptions cf_options(options);
  Repairer repairer(dbname, db_options,
                    {}, cf_options /* default_cf_opts */,
                    cf_options /* unknown_cf_opts */,
@@ -74,9 +74,7 @@ TEST_F(RepairTest, CorruptManifest) {

  Close();
  ASSERT_OK(env_->FileExists(manifest_path));
-
-  LegacyFileSystemWrapper fs(env_);
-  CreateFile(&fs, manifest_path, "blah", false /* use_fsync */);
+  CreateFile(env_, manifest_path, "blah", false /* use_fsync */);
  ASSERT_OK(RepairDB(dbname_, CurrentOptions()));
  Reopen(CurrentOptions());

@@ -155,9 +153,7 @@ TEST_F(RepairTest, CorruptSst) {
  Flush();
  auto sst_path = GetFirstSstPath();
  ASSERT_FALSE(sst_path.empty());
-
-  LegacyFileSystemWrapper fs(env_);
-  CreateFile(&fs, sst_path, "blah", false /* use_fsync */);
+  CreateFile(env_, sst_path, "blah", false /* use_fsync */);

  Close();
  ASSERT_OK(RepairDB(dbname_, CurrentOptions()));
@@ -148,14 +148,6 @@ class SnapshotList {
    }
  }

-  int64_t GetOldestSnapshotSequence() const {
-    if (empty()) {
-      return 0;
-    } else {
-      return oldest()->GetSequenceNumber();
-    }
-  }
-
  uint64_t count() const { return count_; }

 private:
@@ -63,10 +63,10 @@ void AppendVarint64(IterKey* key, uint64_t v) {
 }  // namespace

 TableCache::TableCache(const ImmutableCFOptions& ioptions,
-                       const FileOptions& file_options, Cache* const cache,
+                       const EnvOptions& env_options, Cache* const cache,
                       BlockCacheTracer* const block_cache_tracer)
    : ioptions_(ioptions),
-      file_options_(file_options),
+      env_options_(env_options),
      cache_(cache),
      immortal_tables_(false),
      block_cache_tracer_(block_cache_tracer) {
@@ -89,7 +89,7 @@ void TableCache::ReleaseHandle(Cache::Handle* handle) {
 }

 Status TableCache::GetTableReader(
-    const FileOptions& file_options,
+    const EnvOptions& env_options,
    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
    bool sequential_mode, bool record_read_stats, HistogramImpl* file_read_hist,
    std::unique_ptr<TableReader>* table_reader,
@@ -97,14 +97,13 @@ Status TableCache::GetTableReader(
    bool prefetch_index_and_filter_in_cache) {
  std::string fname =
      TableFileName(ioptions_.cf_paths, fd.GetNumber(), fd.GetPathId());
-  std::unique_ptr<FSRandomAccessFile> file;
-  Status s = ioptions_.fs->NewRandomAccessFile(fname, file_options, &file,
-                                               nullptr);
+  std::unique_ptr<RandomAccessFile> file;
+  Status s = ioptions_.env->NewRandomAccessFile(fname, &file, env_options);

  RecordTick(ioptions_.statistics, NO_FILE_OPENS);
  if (s.ok()) {
    if (!sequential_mode && ioptions_.advise_random_on_open) {
-      file->Hint(FSRandomAccessFile::kRandom);
+      file->Hint(RandomAccessFile::RANDOM);
    }
    StopWatch sw(ioptions_.env, ioptions_.statistics, TABLE_OPEN_IO_MICROS);
    std::unique_ptr<RandomAccessFileReader> file_reader(
@@ -113,7 +112,7 @@ Status TableCache::GetTableReader(
            record_read_stats ? ioptions_.statistics : nullptr, SST_READ_MICROS,
            file_read_hist, ioptions_.rate_limiter, ioptions_.listeners));
    s = ioptions_.table_factory->NewTableReader(
-        TableReaderOptions(ioptions_, prefix_extractor, file_options,
+        TableReaderOptions(ioptions_, prefix_extractor, env_options,
                           internal_comparator, skip_filters, immortal_tables_,
                           level, fd.largest_seqno, block_cache_tracer_),
        std::move(file_reader), fd.GetFileSize(), table_reader,
@@ -130,7 +129,7 @@ void TableCache::EraseHandle(const FileDescriptor& fd, Cache::Handle* handle) {
  cache_->Erase(key);
 }

-Status TableCache::FindTable(const FileOptions& file_options,
+Status TableCache::FindTable(const EnvOptions& env_options,
                             const InternalKeyComparator& internal_comparator,
                             const FileDescriptor& fd, Cache::Handle** handle,
                             const SliceTransform* prefix_extractor,
@@ -151,7 +150,7 @@ Status TableCache::FindTable(const FileOptions& file_options,
      return Status::Incomplete("Table not found in table_cache, no_io is set");
    }
    std::unique_ptr<TableReader> table_reader;
-    s = GetTableReader(file_options, internal_comparator, fd,
+    s = GetTableReader(env_options, internal_comparator, fd,
                       false /* sequential mode */, record_read_stats,
                       file_read_hist, &table_reader, prefix_extractor,
                       skip_filters, level, prefetch_index_and_filter_in_cache);
@@ -173,7 +172,7 @@ Status TableCache::FindTable(const FileOptions& file_options,
 }

 InternalIterator* TableCache::NewIterator(
-    const ReadOptions& options, const FileOptions& file_options,
+    const ReadOptions& options, const EnvOptions& env_options,
    const InternalKeyComparator& icomparator, const FileMetaData& file_meta,
    RangeDelAggregator* range_del_agg, const SliceTransform* prefix_extractor,
    TableReader** table_reader_ptr, HistogramImpl* file_read_hist,
@@ -192,7 +191,7 @@ InternalIterator* TableCache::NewIterator(
  auto& fd = file_meta.fd;
  table_reader = fd.table_reader;
  if (table_reader == nullptr) {
-    s = FindTable(file_options, icomparator, fd, &handle, prefix_extractor,
+    s = FindTable(env_options, icomparator, fd, &handle, prefix_extractor,
                  options.read_tier == kBlockCacheTier /* no_io */,
                  !for_compaction /* record_read_stats */, file_read_hist,
                  skip_filters, level);
@@ -207,8 +206,8 @@ InternalIterator* TableCache::NewIterator(
      result = NewEmptyInternalIterator<Slice>(arena);
    } else {
      result = table_reader->NewIterator(options, prefix_extractor, arena,
-                                   skip_filters, caller,
-                                   file_options.compaction_readahead_size);
+                                         skip_filters, caller,
+                                         env_options.compaction_readahead_size);
    }
    if (handle != nullptr) {
      result->RegisterCleanup(&UnrefEntry, cache_, handle);
@@ -265,7 +264,7 @@ Status TableCache::GetRangeTombstoneIterator(
  TableReader* t = fd.table_reader;
  Cache::Handle* handle = nullptr;
  if (t == nullptr) {
-    s = FindTable(file_options_, internal_comparator, fd, &handle);
+    s = FindTable(env_options_, internal_comparator, fd, &handle);
    if (s.ok()) {
      t = GetTableReaderFromHandle(handle);
    }
@@ -382,7 +381,7 @@ Status TableCache::Get(const ReadOptions& options,
  if (!done && s.ok()) {
    if (t == nullptr) {
      s = FindTable(
-          file_options_, internal_comparator, fd, &handle, prefix_extractor,
+          env_options_, internal_comparator, fd, &handle, prefix_extractor,
          options.read_tier == kBlockCacheTier /* no_io */,
          true /* record_read_stats */, file_read_hist, skip_filters, level);
      if (s.ok()) {
@@ -482,10 +481,9 @@ Status TableCache::MultiGet(const ReadOptions& options,
  if (s.ok() && !table_range.empty()) {
    if (t == nullptr) {
      s = FindTable(
-          file_options_, internal_comparator, fd, &handle, prefix_extractor,
+          env_options_, internal_comparator, fd, &handle, prefix_extractor,
          options.read_tier == kBlockCacheTier /* no_io */,
          true /* record_read_stats */, file_read_hist, skip_filters, level);
-      TEST_SYNC_POINT_CALLBACK("TableCache::MultiGet:FindTable", &s);
      if (s.ok()) {
        t = GetTableReaderFromHandle(handle);
        assert(t);
@@ -553,7 +551,7 @@ Status TableCache::MultiGet(const ReadOptions& options,
 }

 Status TableCache::GetTableProperties(
-    const FileOptions& file_options,
+    const EnvOptions& env_options,
    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
    std::shared_ptr<const TableProperties>* properties,
    const SliceTransform* prefix_extractor, bool no_io) {
@@ -567,7 +565,7 @@ Status TableCache::GetTableProperties(
  }

  Cache::Handle* table_handle = nullptr;
-  s = FindTable(file_options, internal_comparator, fd, &table_handle,
+  s = FindTable(env_options, internal_comparator, fd, &table_handle,
                prefix_extractor, no_io);
  if (!s.ok()) {
    return s;
@@ -580,7 +578,7 @@ Status TableCache::GetTableProperties(
 }

 size_t TableCache::GetMemoryUsageByTableReader(
-    const FileOptions& file_options,
+    const EnvOptions& env_options,
    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
    const SliceTransform* prefix_extractor) {
  Status s;
@@ -591,7 +589,7 @@ size_t TableCache::GetMemoryUsageByTableReader(
  }

  Cache::Handle* table_handle = nullptr;
-  s = FindTable(file_options, internal_comparator, fd, &table_handle,
+  s = FindTable(env_options, internal_comparator, fd, &table_handle,
                prefix_extractor, true);
  if (!s.ok()) {
    return 0;
@@ -616,7 +614,7 @@ uint64_t TableCache::ApproximateOffsetOf(
  Cache::Handle* table_handle = nullptr;
  if (table_reader == nullptr) {
    const bool for_compaction = (caller == TableReaderCaller::kCompaction);
-    Status s = FindTable(file_options_, internal_comparator, fd, &table_handle,
+    Status s = FindTable(env_options_, internal_comparator, fd, &table_handle,
                         prefix_extractor, false /* no_io */,
                         !for_compaction /* record_read_stats */);
    if (s.ok()) {
@@ -643,7 +641,7 @@ uint64_t TableCache::ApproximateSize(
  Cache::Handle* table_handle = nullptr;
  if (table_reader == nullptr) {
    const bool for_compaction = (caller == TableReaderCaller::kCompaction);
-    Status s = FindTable(file_options_, internal_comparator, fd, &table_handle,
+    Status s = FindTable(env_options_, internal_comparator, fd, &table_handle,
                         prefix_extractor, false /* no_io */,
                         !for_compaction /* record_read_stats */);
    if (s.ok()) {
@@ -49,7 +49,7 @@ class HistogramImpl;
 class TableCache {
 public:
  TableCache(const ImmutableCFOptions& ioptions,
-             const FileOptions& storage_options, Cache* cache,
+             const EnvOptions& storage_options, Cache* cache,
             BlockCacheTracer* const block_cache_tracer);
  ~TableCache();

@@ -67,7 +67,7 @@ class TableCache {
  // @param skip_filters Disables loading/accessing the filter block
  // @param level The level this table is at, -1 for "not set / don't know"
  InternalIterator* NewIterator(
-      const ReadOptions& options, const FileOptions& toptions,
+      const ReadOptions& options, const EnvOptions& toptions,
      const InternalKeyComparator& internal_comparator,
      const FileMetaData& file_meta, RangeDelAggregator* range_del_agg,
      const SliceTransform* prefix_extractor, TableReader** table_reader_ptr,
@@ -128,7 +128,7 @@ class TableCache {
  // Find table reader
  // @param skip_filters Disables loading/accessing the filter block
  // @param level == -1 means not specified
-  Status FindTable(const FileOptions& toptions,
+  Status FindTable(const EnvOptions& toptions,
                   const InternalKeyComparator& internal_comparator,
                   const FileDescriptor& file_fd, Cache::Handle**,
                   const SliceTransform* prefix_extractor = nullptr,
@@ -146,7 +146,7 @@ class TableCache {
  // @returns: `properties` will be reset on success. Please note that we will
  //            return Status::Incomplete() if table is not present in cache and
  //            we set `no_io` to be true.
-  Status GetTableProperties(const FileOptions& toptions,
+  Status GetTableProperties(const EnvOptions& toptions,
                            const InternalKeyComparator& internal_comparator,
                            const FileDescriptor& file_meta,
                            std::shared_ptr<const TableProperties>* properties,
@@ -156,7 +156,7 @@ class TableCache {
  // Return total memory usage of the table reader of the file.
  // 0 if table reader of the file is not loaded.
  size_t GetMemoryUsageByTableReader(
-      const FileOptions& toptions,
+      const EnvOptions& toptions,
      const InternalKeyComparator& internal_comparator,
      const FileDescriptor& fd,
      const SliceTransform* prefix_extractor = nullptr);
@@ -193,7 +193,7 @@ class TableCache {

 private:
  // Build a table reader
-  Status GetTableReader(const FileOptions& file_options,
+  Status GetTableReader(const EnvOptions& env_options,
                        const InternalKeyComparator& internal_comparator,
                        const FileDescriptor& fd, bool sequential_mode,
                        bool record_read_stats, HistogramImpl* file_read_hist,
@@ -216,7 +216,7 @@ class TableCache {
                       size_t prefix_size, GetContext* get_context);

  const ImmutableCFOptions& ioptions_;
-  const FileOptions& file_options_;
+  const EnvOptions& env_options_;
  Cache* const cache_;
  std::string row_cache_id_;
  bool immortal_tables_;
@@ -12,7 +12,6 @@
 #include "db/db_impl/db_impl.h"
 #include "db/dbformat.h"
 #include "db/table_properties_collector.h"
-#include "env/composite_env_wrapper.h"
 #include "file/sequence_file_reader.h"
 #include "file/writable_file_writer.h"
 #include "options/cf_options.h"
@@ -49,8 +48,7 @@ void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions,
                 std::unique_ptr<TableBuilder>* builder) {
  std::unique_ptr<WritableFile> wf(new test::StringSink);
  writable->reset(
-      new WritableFileWriter(NewLegacyWritableFileWrapper(std::move(wf)),
-                             "" /* don't care */, EnvOptions()));
+      new WritableFileWriter(std::move(wf), "" /* don't care */, EnvOptions()));
  int unknown_level = -1;
  builder->reset(NewTableBuilder(
      ioptions, moptions, internal_comparator, int_tbl_prop_collector_factories,
@@ -284,9 +282,8 @@ void TestCustomizedTablePropertiesCollector(
  writer->Flush();

  // -- Step 2: Read properties
-  LegacyWritableFileWrapper* file =
-      static_cast<LegacyWritableFileWrapper*>(writer->writable_file());
-  test::StringSink* fwf = static_cast<test::StringSink*>(file->target());
+  test::StringSink* fwf =
+      static_cast<test::StringSink*>(writer->writable_file());
  std::unique_ptr<RandomAccessFileReader> fake_file_reader(
      test::GetRandomAccessFileReader(
          new test::StringSource(fwf->contents())));
@@ -425,9 +422,8 @@ void TestInternalKeyPropertiesCollector(
    ASSERT_OK(builder->Finish());
    writable->Flush();

-    LegacyWritableFileWrapper* file =
-        static_cast<LegacyWritableFileWrapper*>(writable->writable_file());
-    test::StringSink* fwf = static_cast<test::StringSink*>(file->target());
+    test::StringSink* fwf =
+        static_cast<test::StringSink*>(writable->writable_file());
    std::unique_ptr<RandomAccessFileReader> reader(
        test::GetRandomAccessFileReader(
            new test::StringSource(fwf->contents())));
@@ -42,23 +42,22 @@ TransactionLogIteratorImpl::TransactionLogIteratorImpl(
 Status TransactionLogIteratorImpl::OpenLogFile(
    const LogFile* log_file,
    std::unique_ptr<SequentialFileReader>* file_reader) {
-  FileSystem* fs = options_->fs.get();
-  std::unique_ptr<FSSequentialFile> file;
+  Env* env = options_->env;
+  std::unique_ptr<SequentialFile> file;
  std::string fname;
  Status s;
-  EnvOptions optimized_env_options = fs->OptimizeForLogRead(soptions_);
+  EnvOptions optimized_env_options = env->OptimizeForLogRead(soptions_);
  if (log_file->Type() == kArchivedLogFile) {
    fname = ArchivedLogFileName(dir_, log_file->LogNumber());
-    s = fs->NewSequentialFile(fname, optimized_env_options, &file, nullptr);
+    s = env->NewSequentialFile(fname, &file, optimized_env_options);
  } else {
    fname = LogFileName(dir_, log_file->LogNumber());
-    s = fs->NewSequentialFile(fname, optimized_env_options, &file, nullptr);
+    s = env->NewSequentialFile(fname, &file, optimized_env_options);
    if (!s.ok()) {
      //  If cannot open file in DB directory.
      //  Try the archive dir, as it could have moved in the meanwhile.
      fname = ArchivedLogFileName(dir_, log_file->LogNumber());
-      s = fs->NewSequentialFile(fname, optimized_env_options,
-                                &file, nullptr);
+      s = env->NewSequentialFile(fname, &file, optimized_env_options);
    }
  }
  if (s.ok()) {
@@ -34,7 +34,10 @@ ColumnFamilyData* TrimHistoryScheduler::TakeNextColumnFamily() {
      // success
      return cfd;
    }
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      // no longer relevant, retry
+      delete cfd;
+    }
  }
 }

@@ -46,7 +49,9 @@ bool TrimHistoryScheduler::Empty() {
 void TrimHistoryScheduler::Clear() {
  ColumnFamilyData* cfd;
  while ((cfd = TakeNextColumnFamily()) != nullptr) {
-    cfd->UnrefAndTryDelete();
+    if (cfd->Unref()) {
+      delete cfd;
+    }
  }
  assert(Empty());
 }
@@ -83,7 +83,7 @@ class VersionBuilder::Rep {
    std::unordered_map<uint64_t, FileMetaData*> added_files;
  };

-  const FileOptions& file_options_;
+  const EnvOptions& env_options_;
  Logger* info_log_;
  TableCache* table_cache_;
  VersionStorageInfo* base_vstorage_;
@@ -101,10 +101,9 @@ class VersionBuilder::Rep {
  FileComparator level_nonzero_cmp_;

 public:
-  Rep(const FileOptions& file_options, Logger* info_log,
-      TableCache* table_cache,
+  Rep(const EnvOptions& env_options, Logger* info_log, TableCache* table_cache,
      VersionStorageInfo* base_vstorage)
-      : file_options_(file_options),
+      : env_options_(env_options),
        info_log_(info_log),
        table_cache_(table_cache),
        base_vstorage_(base_vstorage),
@@ -462,7 +461,7 @@ class VersionBuilder::Rep {
        auto* file_meta = files_meta[file_idx].first;
        int level = files_meta[file_idx].second;
        statuses[file_idx] = table_cache_->FindTable(
-            file_options_, *(base_vstorage_->InternalComparator()),
+            env_options_, *(base_vstorage_->InternalComparator()),
            file_meta->fd, &file_meta->table_reader_handle, prefix_extractor,
            false /*no_io */, true /* record_read_stats */,
            internal_stats->GetFileReadHist(level), false, level,
@@ -501,11 +500,11 @@ class VersionBuilder::Rep {
  }
 };

-VersionBuilder::VersionBuilder(const FileOptions& file_options,
+VersionBuilder::VersionBuilder(const EnvOptions& env_options,
                               TableCache* table_cache,
                               VersionStorageInfo* base_vstorage,
                               Logger* info_log)
-    : rep_(new Rep(file_options, info_log, table_cache, base_vstorage)) {}
+    : rep_(new Rep(env_options, info_log, table_cache, base_vstorage)) {}

 VersionBuilder::~VersionBuilder() { delete rep_; }

@@ -8,7 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 //
 #pragma once
-#include "rocksdb/file_system.h"
+#include "rocksdb/env.h"
 #include "rocksdb/slice_transform.h"

 namespace rocksdb {
@@ -24,7 +24,7 @@ class InternalStats;
 // Versions that contain full copies of the intermediate state.
 class VersionBuilder {
 public:
-  VersionBuilder(const FileOptions& file_options, TableCache* table_cache,
+  VersionBuilder(const EnvOptions& env_options, TableCache* table_cache,
                 VersionStorageInfo* base_vstorage, Logger* info_log = nullptr);
  ~VersionBuilder();
  Status CheckConsistency(VersionStorageInfo* vstorage);
@@ -853,7 +853,7 @@ namespace {
 class LevelIterator final : public InternalIterator {
 public:
  LevelIterator(TableCache* table_cache, const ReadOptions& read_options,
-                const FileOptions& file_options,
+                const EnvOptions& env_options,
                const InternalKeyComparator& icomparator,
                const LevelFilesBrief* flevel,
                const SliceTransform* prefix_extractor, bool should_sample,
@@ -863,7 +863,7 @@ class LevelIterator final : public InternalIterator {
                    compaction_boundaries = nullptr)
      : table_cache_(table_cache),
        read_options_(read_options),
-        file_options_(file_options),
+        env_options_(env_options),
        icomparator_(icomparator),
        user_comparator_(icomparator.user_comparator()),
        flevel_(flevel),
@@ -975,7 +975,7 @@ class LevelIterator final : public InternalIterator {
    }
    CheckMayBeOutOfLowerBound();
    return table_cache_->NewIterator(
-        read_options_, file_options_, icomparator_, *file_meta.file_metadata,
+        read_options_, env_options_, icomparator_, *file_meta.file_metadata,
        range_del_agg_, prefix_extractor_,
        nullptr /* don't need reference to table */, file_read_hist_, caller_,
        /*arena=*/nullptr, skip_filters_, level_, smallest_compaction_key,
@@ -998,7 +998,7 @@ class LevelIterator final : public InternalIterator {

  TableCache* table_cache_;
  const ReadOptions read_options_;
-  const FileOptions& file_options_;
+  const EnvOptions& env_options_;
  const InternalKeyComparator& icomparator_;
  const UserComparatorWrapper user_comparator_;
  const LevelFilesBrief* flevel_;
@@ -1206,7 +1206,7 @@ class BaseReferencedVersionBuilder {
 public:
  explicit BaseReferencedVersionBuilder(ColumnFamilyData* cfd)
      : version_builder_(new VersionBuilder(
-            cfd->current()->version_set()->file_options(), cfd->table_cache(),
+            cfd->current()->version_set()->env_options(), cfd->table_cache(),
            cfd->current()->storage_info(), cfd->ioptions()->info_log)),
        version_(cfd->current()) {
    version_->Ref();
@@ -1227,7 +1227,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
  auto table_cache = cfd_->table_cache();
  auto ioptions = cfd_->ioptions();
  Status s = table_cache->GetTableProperties(
-      file_options_, cfd_->internal_comparator(), file_meta->fd, tp,
+      env_options_, cfd_->internal_comparator(), file_meta->fd, tp,
      mutable_cf_options_.prefix_extractor.get(), true /* no io */);
  if (s.ok()) {
    return s;
@@ -1241,7 +1241,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,

  // 2. Table is not present in table cache, we'll read the table properties
  // directly from the properties block in the file.
-  std::unique_ptr<FSRandomAccessFile> file;
+  std::unique_ptr<RandomAccessFile> file;
  std::string file_name;
  if (fname != nullptr) {
    file_name = *fname;
@@ -1250,8 +1250,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
      TableFileName(ioptions->cf_paths, file_meta->fd.GetNumber(),
                    file_meta->fd.GetPathId());
  }
-  s = ioptions->fs->NewRandomAccessFile(file_name, file_options_, &file,
-                                        nullptr);
+  s = ioptions->env->NewRandomAccessFile(file_name, &file, env_options_);
  if (!s.ok()) {
    return s;
  }
@@ -1421,7 +1420,7 @@ size_t Version::GetMemoryUsageByTableReaders() {
  for (auto& file_level : storage_info_.level_files_brief_) {
    for (size_t i = 0; i < file_level.num_files; i++) {
      total_usage += cfd_->table_cache()->GetMemoryUsageByTableReader(
-          file_options_, cfd_->internal_comparator(), file_level.files[i].fd,
+          env_options_, cfd_->internal_comparator(), file_level.files[i].fd,
          mutable_cf_options_.prefix_extractor.get());
    }
  }
@@ -1548,7 +1547,7 @@ double VersionStorageInfo::GetEstimatedCompressionRatioAtLevel(
 }

 void Version::AddIterators(const ReadOptions& read_options,
-                           const FileOptions& soptions,
+                           const EnvOptions& soptions,
                           MergeIteratorBuilder* merge_iter_builder,
                           RangeDelAggregator* range_del_agg) {
  assert(storage_info_.finalized_);
@@ -1560,7 +1559,7 @@ void Version::AddIterators(const ReadOptions& read_options,
 }

 void Version::AddIteratorsForLevel(const ReadOptions& read_options,
-                                   const FileOptions& soptions,
+                                   const EnvOptions& soptions,
                                   MergeIteratorBuilder* merge_iter_builder,
                                   int level,
                                   RangeDelAggregator* range_del_agg) {
@@ -1615,7 +1614,7 @@ void Version::AddIteratorsForLevel(const ReadOptions& read_options,
 }

 Status Version::OverlapWithLevelIterator(const ReadOptions& read_options,
-                                         const FileOptions& file_options,
+                                         const EnvOptions& env_options,
                                         const Slice& smallest_user_key,
                                         const Slice& largest_user_key,
                                         int level, bool* overlap) {
@@ -1639,7 +1638,7 @@ Status Version::OverlapWithLevelIterator(const ReadOptions& read_options,
        continue;
      }
      ScopedArenaIterator iter(cfd_->table_cache()->NewIterator(
-          read_options, file_options, cfd_->internal_comparator(),
+          read_options, env_options, cfd_->internal_comparator(),
          *file->file_metadata, &range_del_agg,
          mutable_cf_options_.prefix_extractor.get(), nullptr,
          cfd_->internal_stats()->GetFileReadHist(0),
@@ -1656,7 +1655,7 @@ Status Version::OverlapWithLevelIterator(const ReadOptions& read_options,
  } else if (storage_info_.LevelFilesBrief(level).num_files > 0) {
    auto mem = arena.AllocateAligned(sizeof(LevelIterator));
    ScopedArenaIterator iter(new (mem) LevelIterator(
-        cfd_->table_cache(), read_options, file_options,
+        cfd_->table_cache(), read_options, env_options,
        cfd_->internal_comparator(), &storage_info_.LevelFilesBrief(level),
        mutable_cf_options_.prefix_extractor.get(), should_sample_file_read(),
        cfd_->internal_stats()->GetFileReadHist(level),
@@ -1720,7 +1719,7 @@ VersionStorageInfo::VersionStorageInfo(
 }

 Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
-                 const FileOptions& file_opt,
+                 const EnvOptions& env_opt,
                 const MutableCFOptions mutable_cf_options,
                 uint64_t version_number)
    : env_(vset->env_),
@@ -1745,7 +1744,7 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
      next_(this),
      prev_(this),
      refs_(0),
-      file_options_(file_opt),
+      env_options_(env_opt),
      mutable_cf_options_(mutable_cf_options),
      version_number_(version_number) {}

@@ -1918,11 +1917,6 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
        &iter->max_covering_tombstone_seq, this->env_, nullptr,
        merge_operator_ ? &pinned_iters_mgr : nullptr, callback, is_blob,
        tracing_mget_id);
-    // MergeInProgress status, if set, has been transferred to the get_context
-    // state, so we set status to ok here. From now on, the iter status will
-    // be used for IO errors, and get_context state will be used for any
-    // key level errors
-    *(iter->s) = Status::OK();
  }
  int get_ctx_index = 0;
  for (auto iter = range->begin(); iter != range->end();
@@ -1967,15 +1961,6 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
    for (auto iter = file_range.begin(); iter != file_range.end(); ++iter) {
      GetContext& get_context = *iter->get_context;
      Status* status = iter->s;
-      // The Status in the KeyContext takes precedence over GetContext state
-      // Status may be an error if there were any IO errors in the table
-      // reader. We never expect Status to be NotFound(), as that is
-      // determined by get_context
-      assert(!status->IsNotFound());
-      if (!status->ok()) {
-        file_range.MarkKeyDone(iter);
-        continue;
-      }

      if (get_context.sample()) {
        sample_file_read_inc(f->file_metadata);
@@ -2126,9 +2111,6 @@ bool Version::MaybeInitializeFileMetaData(FileMetaData* file_meta) {
 }

 void VersionStorageInfo::UpdateAccumulatedStats(FileMetaData* file_meta) {
-  TEST_SYNC_POINT_CALLBACK("VersionStorageInfo::UpdateAccumulatedStats",
-                           nullptr);
-
  assert(file_meta->init_stats_from_file);
  accumulated_file_size_ += file_meta->fd.GetFileSize();
  accumulated_raw_key_size_ += file_meta->raw_key_size;
@@ -3527,7 +3509,7 @@ void AtomicGroupReadBuffer::Clear() {

 VersionSet::VersionSet(const std::string& dbname,
                       const ImmutableDBOptions* _db_options,
-                       const FileOptions& storage_options, Cache* table_cache,
+                       const EnvOptions& storage_options, Cache* table_cache,
                       WriteBufferManager* write_buffer_manager,
                       WriteController* write_controller,
                       BlockCacheTracer* const block_cache_tracer)
@@ -3535,7 +3517,6 @@ VersionSet::VersionSet(const std::string& dbname,
          dbname, _db_options, storage_options, table_cache,
          write_buffer_manager, write_controller, block_cache_tracer)),
      env_(_db_options->env),
-      fs_(_db_options->fs.get()),
      dbname_(dbname),
      db_options_(_db_options),
      next_file_number_(2),
@@ -3548,7 +3529,7 @@ VersionSet::VersionSet(const std::string& dbname,
      prev_log_number_(0),
      current_version_number_(0),
      manifest_file_size_(0),
-      file_options_(storage_options),
+      env_options_(storage_options),
      block_cache_tracer_(block_cache_tracer) {}

 VersionSet::~VersionSet() {
@@ -3674,7 +3655,7 @@ Status VersionSet::ProcessManifestWrites(
        }
      }
      if (version == nullptr) {
-        version = new Version(last_writer->cfd, this, file_options_,
+        version = new Version(last_writer->cfd, this, env_options_,
                              last_writer->mutable_cf_options,
                              current_version_number_++);
        versions.push_back(version);
@@ -3770,10 +3751,6 @@ Status VersionSet::ProcessManifestWrites(
    pending_manifest_file_number_ = manifest_file_number_;
  }

-  // Local cached copy of state variable(s). WriteCurrentStateToManifest()
-  // reads its content after releasing db mutex to avoid race with
-  // SwitchMemtable().
-  std::unordered_map<uint32_t, MutableCFState> curr_state;
  if (new_descriptor_log) {
    // if we are writing out new snapshot make sure to persist max column
    // family.
@@ -3781,14 +3758,10 @@ Status VersionSet::ProcessManifestWrites(
      first_writer.edit_list.front()->SetMaxColumnFamily(
          column_family_set_->GetMaxColumnFamily());
    }
-    for (const auto* cfd : *column_family_set_) {
-      assert(curr_state.find(cfd->GetID()) == curr_state.end());
-      curr_state[cfd->GetID()] = {cfd->GetLogNumber()};
-    }
  }

  {
-    FileOptions opt_file_opts = fs_->OptimizeForManifestWrite(file_options_);
+    EnvOptions opt_env_opts = env_->OptimizeForManifestWrite(env_options_);
    mu->Unlock();

    TEST_SYNC_POINT("VersionSet::LogAndApply:WriteManifest");
@@ -3815,19 +3788,19 @@ Status VersionSet::ProcessManifestWrites(
                     pending_manifest_file_number_);
      std::string descriptor_fname =
          DescriptorFileName(dbname_, pending_manifest_file_number_);
-      std::unique_ptr<FSWritableFile> descriptor_file;
-      s = NewWritableFile(fs_, descriptor_fname, &descriptor_file,
-                          opt_file_opts);
+      std::unique_ptr<WritableFile> descriptor_file;
+      s = NewWritableFile(env_, descriptor_fname, &descriptor_file,
+                          opt_env_opts);
      if (s.ok()) {
        descriptor_file->SetPreallocationBlockSize(
            db_options_->manifest_preallocation_size);

        std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-            std::move(descriptor_file), descriptor_fname, opt_file_opts, env_,
+            std::move(descriptor_file), descriptor_fname, opt_env_opts, env_,
            nullptr, db_options_->listeners));
        descriptor_log_.reset(
            new log::Writer(std::move(file_writer), 0, false));
-        s = WriteCurrentStateToManifest(curr_state, descriptor_log_.get());
+        s = WriteCurrentStateToManifest(descriptor_log_.get());
      }
    }

@@ -3915,7 +3888,9 @@ Status VersionSet::ProcessManifestWrites(
    } else if (first_writer.edit_list.front()->is_column_family_drop_) {
      assert(batch_edits.size() == 1);
      first_writer.cfd->SetDropped();
-      first_writer.cfd->UnrefAndTryDelete();
+      if (first_writer.cfd->Unref()) {
+        delete first_writer.cfd;
+      }
    } else {
      // Each version in versions corresponds to a column family.
      // For each column family, update its log number indicating that logs
@@ -4196,7 +4171,8 @@ Status VersionSet::ApplyOneVersionEditToBuilder(
      builders.erase(builder);
      cfd = column_family_set_->GetColumnFamily(edit.column_family_);
      assert(cfd != nullptr);
-      if (cfd->UnrefAndTryDelete()) {
+      if (cfd->Unref()) {
+        delete cfd;
        cfd = nullptr;
      } else {
        // who else can have reference to cfd!?
@@ -4281,16 +4257,15 @@ Status VersionSet::ExtractInfoFromVersionEdit(
  return Status::OK();
 }

-Status VersionSet::GetCurrentManifestPath(const std::string& dbname,
-                                          FileSystem* fs,
+Status VersionSet::GetCurrentManifestPath(const std::string& dbname, Env* env,
                                          std::string* manifest_path,
                                          uint64_t* manifest_file_number) {
-  assert(fs != nullptr);
+  assert(env != nullptr);
  assert(manifest_path != nullptr);
  assert(manifest_file_number != nullptr);

  std::string fname;
-  Status s = ReadFileToString(fs, CurrentFileName(dbname), &fname);
+  Status s = ReadFileToString(env, CurrentFileName(dbname), &fname);
  if (!s.ok()) {
    return s;
  }
@@ -4392,7 +4367,7 @@ Status VersionSet::Recover(

  // Read "CURRENT" file, which contains a pointer to the current manifest file
  std::string manifest_path;
-  Status s = GetCurrentManifestPath(dbname_, fs_, &manifest_path,
+  Status s = GetCurrentManifestPath(dbname_, env_, &manifest_path,
                                    &manifest_file_number_);
  if (!s.ok()) {
    return s;
@@ -4403,10 +4378,9 @@ Status VersionSet::Recover(

  std::unique_ptr<SequentialFileReader> manifest_file_reader;
  {
-    std::unique_ptr<FSSequentialFile> manifest_file;
-    s = fs_->NewSequentialFile(manifest_path,
-                               fs_->OptimizeForManifestRead(file_options_),
-                               &manifest_file, nullptr);
+    std::unique_ptr<SequentialFile> manifest_file;
+    s = env_->NewSequentialFile(manifest_path, &manifest_file,
+                                env_->OptimizeForManifestRead(env_options_));
    if (!s.ok()) {
      return s;
    }
@@ -4415,8 +4389,7 @@ Status VersionSet::Recover(
                                 db_options_->log_readahead_size));
  }
  uint64_t current_manifest_file_size;
-  s = fs_->GetFileSize(manifest_path, IOOptions(), &current_manifest_file_size,
-                       nullptr);
+  s = env_->GetFileSize(manifest_path, &current_manifest_file_size);
  if (!s.ok()) {
    return s;
  }
@@ -4523,7 +4496,7 @@ Status VersionSet::Recover(
          true /* is_initial_load */,
          cfd->GetLatestMutableCFOptions()->prefix_extractor.get());

-      Version* v = new Version(cfd, this, file_options_,
+      Version* v = new Version(cfd, this, env_options_,
                               *cfd->GetLatestMutableCFOptions(),
                               current_version_number_++);
      builder->SaveTo(v->storage_info());
@@ -4568,24 +4541,23 @@ Status VersionSet::Recover(
 }

 Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
-                                      const std::string& dbname,
-                                      FileSystem* fs) {
+                                      const std::string& dbname, Env* env) {
  // these are just for performance reasons, not correcntes,
  // so we're fine using the defaults
-  FileOptions soptions;
+  EnvOptions soptions;
  // Read "CURRENT" file, which contains a pointer to the current manifest file
  std::string manifest_path;
  uint64_t manifest_file_number;
-  Status s =
-      GetCurrentManifestPath(dbname, fs, &manifest_path, &manifest_file_number);
+  Status s = GetCurrentManifestPath(dbname, env, &manifest_path,
+                                    &manifest_file_number);
  if (!s.ok()) {
    return s;
  }

  std::unique_ptr<SequentialFileReader> file_reader;
  {
-    std::unique_ptr<FSSequentialFile> file;
-    s = fs->NewSequentialFile(manifest_path, soptions, &file, nullptr);
+    std::unique_ptr<SequentialFile> file;
+    s = env->NewSequentialFile(manifest_path, &file, soptions);
    if (!s.ok()) {
      return s;
  }
@@ -4639,7 +4611,7 @@ Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
 #ifndef ROCKSDB_LITE
 Status VersionSet::ReduceNumberOfLevels(const std::string& dbname,
                                        const Options* options,
-                                        const FileOptions& file_options,
+                                        const EnvOptions& env_options,
                                        int new_levels) {
  if (new_levels <= 1) {
    return Status::InvalidArgument(
@@ -4652,7 +4624,7 @@ Status VersionSet::ReduceNumberOfLevels(const std::string& dbname,
                                        options->table_cache_numshardbits));
  WriteController wc(options->delayed_write_rate);
  WriteBufferManager wb(options->db_write_buffer_size);
-  VersionSet versions(dbname, &db_options, file_options, tc.get(), &wb, &wc,
+  VersionSet versions(dbname, &db_options, env_options, tc.get(), &wb, &wc,
                      /*block_cache_tracer=*/nullptr);
  Status status;

@@ -4728,11 +4700,9 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
  std::unique_ptr<SequentialFileReader> file_reader;
  Status s;
  {
-    std::unique_ptr<FSSequentialFile> file;
-    s = options.file_system->NewSequentialFile(
-        dscname,
-        options.file_system->OptimizeForManifestRead(file_options_), &file,
-        nullptr);
+    std::unique_ptr<SequentialFile> file;
+    s = options.env->NewSequentialFile(
+        dscname, &file, env_->OptimizeForManifestRead(env_options_));
    if (!s.ok()) {
      return s;
    }
@@ -4814,7 +4784,8 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
        comparators.erase(edit.column_family_);
        cfd = column_family_set_->GetColumnFamily(edit.column_family_);
        assert(cfd != nullptr);
-        cfd->UnrefAndTryDelete();
+        cfd->Unref();
+        delete cfd;
        cfd = nullptr;
      } else {
        if (!cf_in_builders) {
@@ -4892,7 +4863,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
      assert(builders_iter != builders.end());
      auto builder = builders_iter->second->version_builder();

-      Version* v = new Version(cfd, this, file_options_,
+      Version* v = new Version(cfd, this, env_options_,
                               *cfd->GetLatestMutableCFOptions(),
                               current_version_number_++);
      builder->SaveTo(v->storage_info());
@@ -4946,9 +4917,7 @@ void VersionSet::MarkMinLogNumberToKeep2PC(uint64_t number) {
  }
 }

-Status VersionSet::WriteCurrentStateToManifest(
-    const std::unordered_map<uint32_t, MutableCFState>& curr_state,
-    log::Writer* log) {
+Status VersionSet::WriteCurrentStateToManifest(log::Writer* log) {
  // TODO: Break up into multiple records to reduce memory usage on recovery?

  // WARNING: This method doesn't hold a mutex!!
@@ -5014,10 +4983,7 @@ Status VersionSet::WriteCurrentStateToManifest(
                       f->oldest_ancester_time, f->file_creation_time);
        }
      }
-      const auto iter = curr_state.find(cfd->GetID());
-      assert(iter != curr_state.end());
-      uint64_t log_number = iter->second.log_number;
-      edit.SetLogNumber(log_number);
+      edit.SetLogNumber(cfd->GetLogNumber());
      std::string record;
      if (!edit.EncodeTo(&record)) {
        return Status::Corruption(
@@ -5274,7 +5240,7 @@ void VersionSet::AddLiveFiles(std::vector<FileDescriptor>* live_list) {

 InternalIterator* VersionSet::MakeInputIterator(
    const Compaction* c, RangeDelAggregator* range_del_agg,
-    const FileOptions& file_options_compactions) {
+    const EnvOptions& env_options_compactions) {
  auto cfd = c->column_family_data();
  ReadOptions read_options;
  read_options.verify_checksums = true;
@@ -5299,8 +5265,7 @@ InternalIterator* VersionSet::MakeInputIterator(
        const LevelFilesBrief* flevel = c->input_levels(which);
        for (size_t i = 0; i < flevel->num_files; i++) {
          list[num++] = cfd->table_cache()->NewIterator(
-              read_options, file_options_compactions,
-              cfd->internal_comparator(),
+              read_options, env_options_compactions, cfd->internal_comparator(),
              *flevel->files[i].file_metadata, range_del_agg,
              c->mutable_cf_options()->prefix_extractor.get(),
              /*table_reader_ptr=*/nullptr,
@@ -5313,7 +5278,7 @@ InternalIterator* VersionSet::MakeInputIterator(
      } else {
        // Create concatenating iterator for the files from this level
        list[num++] = new LevelIterator(
-            cfd->table_cache(), read_options, file_options_compactions,
+            cfd->table_cache(), read_options, env_options_compactions,
            cfd->internal_comparator(), c->input_levels(which),
            c->mutable_cf_options()->prefix_extractor.get(),
            /*should_sample=*/false,
@@ -5466,7 +5431,7 @@ ColumnFamilyData* VersionSet::CreateColumnFamily(

  MutableCFOptions dummy_cf_options;
  Version* dummy_versions =
-      new Version(nullptr, this, file_options_, dummy_cf_options);
+      new Version(nullptr, this, env_options_, dummy_cf_options);
  // Ref() dummy version once so that later we can call Unref() to delete it
  // by avoiding calling "delete" explicitly (~Version is private)
  dummy_versions->Ref();
@@ -5474,7 +5439,7 @@ ColumnFamilyData* VersionSet::CreateColumnFamily(
      edit->column_family_name_, edit->column_family_, dummy_versions,
      cf_options);

-  Version* v = new Version(new_cfd, this, file_options_,
+  Version* v = new Version(new_cfd, this, env_options_,
                           *new_cfd->GetLatestMutableCFOptions(),
                           current_version_number_++);

@@ -5518,11 +5483,11 @@ uint64_t VersionSet::GetTotalSstFilesSize(Version* dummy_versions) {

 ReactiveVersionSet::ReactiveVersionSet(const std::string& dbname,
                                       const ImmutableDBOptions* _db_options,
-                                       const FileOptions& _file_options,
+                                       const EnvOptions& _env_options,
                                       Cache* table_cache,
                                       WriteBufferManager* write_buffer_manager,
                                       WriteController* write_controller)
-    : VersionSet(dbname, _db_options, _file_options, table_cache,
+    : VersionSet(dbname, _db_options, _env_options, table_cache,
                 write_buffer_manager, write_controller,
                 /*block_cache_tracer=*/nullptr),
      number_of_edits_to_skip_(0) {}
@@ -5653,7 +5618,7 @@ Status ReactiveVersionSet::Recover(
      assert(builders_iter != builders.end());
      auto* builder = builders_iter->second->version_builder();

-      Version* v = new Version(cfd, this, file_options_,
+      Version* v = new Version(cfd, this, env_options_,
                               *cfd->GetLatestMutableCFOptions(),
                               current_version_number_++);
      builder->SaveTo(v->storage_info());
@@ -5846,7 +5811,8 @@ Status ReactiveVersionSet::ApplyOneVersionEditToBuilder(
    // secondary instance. (Is it possible that the ref count for cfd is 0 but
    // the ref count for its versions is higher than 0?)
    cfd->SetDropped();
-    if (cfd->UnrefAndTryDelete()) {
+    if (cfd->Unref()) {
+      delete cfd;
      cfd = nullptr;
    }
    active_version_builders_.erase(builder_iter);
@@ -5873,7 +5839,7 @@ Status ReactiveVersionSet::ApplyOneVersionEditToBuilder(
        &s);

    if (s.ok()) {
-      auto version = new Version(cfd, this, file_options_,
+      auto version = new Version(cfd, this, env_options_,
                                 *cfd->GetLatestMutableCFOptions(),
                                 current_version_number_++);
      builder->SaveTo(version->storage_info());
@@ -5916,9 +5882,9 @@ Status ReactiveVersionSet::MaybeSwitchManifest(
  Status s;
  do {
    std::string manifest_path;
-    s = GetCurrentManifestPath(dbname_, fs_, &manifest_path,
+    s = GetCurrentManifestPath(dbname_, env_, &manifest_path,
                               &manifest_file_number_);
-    std::unique_ptr<FSSequentialFile> manifest_file;
+    std::unique_ptr<SequentialFile> manifest_file;
    if (s.ok()) {
      if (nullptr == manifest_reader->get() ||
          manifest_reader->get()->file()->file_name() != manifest_path) {
@@ -5928,9 +5894,9 @@ Status ReactiveVersionSet::MaybeSwitchManifest(
        TEST_SYNC_POINT(
            "ReactiveVersionSet::MaybeSwitchManifest:"
            "AfterGetCurrentManifestPath:1");
-        s = fs_->NewSequentialFile(manifest_path,
-                                   env_->OptimizeForManifestRead(file_options_),
-                                   &manifest_file, nullptr);
+        s = env_->NewSequentialFile(
+            manifest_path, &manifest_file,
+            env_->OptimizeForManifestRead(env_options_));
      } else {
        // No need to switch manifest.
        break;
@@ -559,15 +559,15 @@ class Version {
  // Append to *iters a sequence of iterators that will
  // yield the contents of this Version when merged together.
  // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  void AddIterators(const ReadOptions&, const FileOptions& soptions,
+  void AddIterators(const ReadOptions&, const EnvOptions& soptions,
                    MergeIteratorBuilder* merger_iter_builder,
                    RangeDelAggregator* range_del_agg);

-  void AddIteratorsForLevel(const ReadOptions&, const FileOptions& soptions,
+  void AddIteratorsForLevel(const ReadOptions&, const EnvOptions& soptions,
                            MergeIteratorBuilder* merger_iter_builder,
                            int level, RangeDelAggregator* range_del_agg);

-  Status OverlapWithLevelIterator(const ReadOptions&, const FileOptions&,
+  Status OverlapWithLevelIterator(const ReadOptions&, const EnvOptions&,
                                  const Slice& smallest_user_key,
                                  const Slice& largest_user_key,
                                  int level, bool* overlap);
@@ -684,7 +684,6 @@ class Version {

 private:
  Env* env_;
-  FileSystem* fs_;
  friend class ReactiveVersionSet;
  friend class VersionSet;

@@ -730,14 +729,14 @@ class Version {
  Version* next_;               // Next version in linked list
  Version* prev_;               // Previous version in linked list
  int refs_;                    // Number of live refs to this version
-  const FileOptions file_options_;
+  const EnvOptions env_options_;
  const MutableCFOptions mutable_cf_options_;

  // A version number that uniquely represents this version. This is
  // used for debugging and logging purposes only.
  uint64_t version_number_;

-  Version(ColumnFamilyData* cfd, VersionSet* vset, const FileOptions& file_opt,
+  Version(ColumnFamilyData* cfd, VersionSet* vset, const EnvOptions& env_opt,
          MutableCFOptions mutable_cf_options, uint64_t version_number = 0);

  ~Version();
@@ -802,7 +801,7 @@ class AtomicGroupReadBuffer {
 class VersionSet {
 public:
  VersionSet(const std::string& dbname, const ImmutableDBOptions* db_options,
-             const FileOptions& file_options, Cache* table_cache,
+             const EnvOptions& env_options, Cache* table_cache,
             WriteBufferManager* write_buffer_manager,
             WriteController* write_controller,
             BlockCacheTracer* const block_cache_tracer);
@@ -864,8 +863,7 @@ class VersionSet {
      bool new_descriptor_log = false,
      const ColumnFamilyOptions* new_cf_options = nullptr);

-  static Status GetCurrentManifestPath(const std::string& dbname,
-                                       FileSystem* fs,
+  static Status GetCurrentManifestPath(const std::string& dbname, Env* env,
                                       std::string* manifest_filename,
                                       uint64_t* manifest_file_number);

@@ -878,7 +876,7 @@ class VersionSet {
  // Reads a manifest file and returns a list of column families in
  // column_families.
  static Status ListColumnFamilies(std::vector<std::string>* column_families,
-                                   const std::string& dbname, FileSystem* fs);
+                                   const std::string& dbname, Env* env);

 #ifndef ROCKSDB_LITE
  // Try to reduce the number of levels. This call is valid when
@@ -892,7 +890,7 @@ class VersionSet {
  // among [4-6] contains files.
  static Status ReduceNumberOfLevels(const std::string& dbname,
                                     const Options* options,
-                                     const FileOptions& file_options,
+                                     const EnvOptions& env_options,
                                     int new_levels);

  // printf contents (for debugging)
@@ -1006,7 +1004,7 @@ class VersionSet {
  // The caller should delete the iterator when no longer needed.
  InternalIterator* MakeInputIterator(
      const Compaction* c, RangeDelAggregator* range_del_agg,
-      const FileOptions& file_options_compactions);
+      const EnvOptions& env_options_compactions);

  // Add all files listed in any live version to *live.
  void AddLiveFiles(std::vector<FileDescriptor>* live_list);
@@ -1039,9 +1037,9 @@ class VersionSet {
                        uint64_t min_pending_output);

  ColumnFamilySet* GetColumnFamilySet() { return column_family_set_.get(); }
-  const FileOptions& file_options() { return file_options_; }
-  void ChangeFileOptions(const MutableDBOptions& new_options) {
-    file_options_.writable_file_max_buffer_size =
+  const EnvOptions& env_options() { return env_options_; }
+  void ChangeEnvOptions(const MutableDBOptions& new_options) {
+    env_options_.writable_file_max_buffer_size =
        new_options.writable_file_max_buffer_size;
  }

@@ -1075,14 +1073,8 @@ class VersionSet {
                           const Slice& start, const Slice& end,
                           TableReaderCaller caller);

-  struct MutableCFState {
-    uint64_t log_number;
-  };
-
  // Save current contents to *log
-  Status WriteCurrentStateToManifest(
-      const std::unordered_map<uint32_t, MutableCFState>& curr_state,
-      log::Writer* log);
+  Status WriteCurrentStateToManifest(log::Writer* log);

  void AppendVersion(ColumnFamilyData* column_family_data, Version* v);

@@ -1114,7 +1106,6 @@ class VersionSet {
  std::unique_ptr<ColumnFamilySet> column_family_set_;

  Env* const env_;
-  FileSystem* const fs_;
  const std::string dbname_;
  std::string db_id_;
  const ImmutableDBOptions* const db_options_;
@@ -1159,7 +1150,7 @@ class VersionSet {
  std::vector<std::string> obsolete_manifests_;

  // env options for all reads and writes except compactions
-  FileOptions file_options_;
+  EnvOptions env_options_;

  BlockCacheTracer* const block_cache_tracer_;

@@ -1183,7 +1174,7 @@ class ReactiveVersionSet : public VersionSet {
 public:
  ReactiveVersionSet(const std::string& dbname,
                     const ImmutableDBOptions* _db_options,
-                     const FileOptions& _file_options, Cache* table_cache,
+                     const EnvOptions& _env_options, Cache* table_cache,
                     WriteBufferManager* write_buffer_manager,
                     WriteController* write_controller);

@@ -610,25 +610,21 @@ class VersionSetTestBase {

  VersionSetTestBase()
      : env_(Env::Default()),
-        fs_(std::make_shared<LegacyFileSystemWrapper>(env_)),
        dbname_(test::PerThreadDBPath("version_set_test")),
        db_options_(),
        mutable_cf_options_(cf_options_),
        table_cache_(NewLRUCache(50000, 16)),
        write_buffer_manager_(db_options_.db_write_buffer_size),
+        versions_(new VersionSet(dbname_, &db_options_, env_options_,
+                                 table_cache_.get(), &write_buffer_manager_,
+                                 &write_controller_,
+                                 /*block_cache_tracer=*/nullptr)),
+        reactive_versions_(std::make_shared<ReactiveVersionSet>(
+            dbname_, &db_options_, env_options_, table_cache_.get(),
+            &write_buffer_manager_, &write_controller_)),
        shutting_down_(false),
        mock_table_factory_(std::make_shared<mock::MockTableFactory>()) {
    EXPECT_OK(env_->CreateDirIfMissing(dbname_));
-
-    db_options_.env = env_;
-    db_options_.fs = fs_;
-    versions_.reset(new VersionSet(dbname_, &db_options_, env_options_,
-                                   table_cache_.get(), &write_buffer_manager_,
-                                   &write_controller_,
-                                   /*block_cache_tracer=*/nullptr)),
-        reactive_versions_ = std::make_shared<ReactiveVersionSet>(
-            dbname_, &db_options_, env_options_, table_cache_.get(),
-            &write_buffer_manager_, &write_controller_);
    db_options_.db_paths.emplace_back(dbname_,
                                      std::numeric_limits<uint64_t>::max());
  }
@@ -673,8 +669,8 @@ class VersionSetTestBase {
    Status s = env_->NewWritableFile(
        manifest, &file, env_->OptimizeForManifestWrite(env_options_));
    ASSERT_OK(s);
-    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        NewLegacyWritableFileWrapper(std::move(file)), manifest, env_options_));
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(std::move(file), manifest, env_options_));
    {
      log_writer->reset(new log::Writer(std::move(file_writer), 0, false));
      std::string record;
@@ -713,7 +709,6 @@ class VersionSetTestBase {
  }

  Env* env_;
-  std::shared_ptr<FileSystem> fs_;
  const std::string dbname_;
  EnvOptions env_options_;
  ImmutableDBOptions db_options_;
@@ -120,7 +120,7 @@ Status WalManager::GetUpdatesSince(
    return s;
  }
  iter->reset(new TransactionLogIteratorImpl(
-      db_options_.wal_dir, &db_options_, read_options, file_options_, seq,
+      db_options_.wal_dir, &db_options_, read_options, env_options_, seq,
      std::move(wal_files), version_set, seq_per_batch_));
  return (*iter)->status();
 }
@@ -464,10 +464,9 @@ Status WalManager::ReadFirstLine(const std::string& fname,
    }
  };

-  std::unique_ptr<FSSequentialFile> file;
-  Status status = fs_->NewSequentialFile(fname,
-                                         fs_->OptimizeForLogRead(file_options_),
-                                         &file, nullptr);
+  std::unique_ptr<SequentialFile> file;
+  Status status = env_->NewSequentialFile(
+      fname, &file, env_->OptimizeForLogRead(env_options_));
  std::unique_ptr<SequentialFileReader> file_reader(
      new SequentialFileReader(std::move(file), fname));

@@ -36,11 +36,10 @@ namespace rocksdb {
 class WalManager {
 public:
  WalManager(const ImmutableDBOptions& db_options,
-             const FileOptions& file_options, const bool seq_per_batch = false)
+             const EnvOptions& env_options, const bool seq_per_batch = false)
      : db_options_(db_options),
-        file_options_(file_options),
+        env_options_(env_options),
        env_(db_options.env),
-        fs_(db_options.fs.get()),
        purge_wal_files_last_run_(0),
        seq_per_batch_(seq_per_batch),
        wal_in_db_path_(IsWalDirSameAsDBPath(&db_options)) {}
@@ -89,9 +88,8 @@ class WalManager {

  // ------- state from DBImpl ------
  const ImmutableDBOptions& db_options_;
-  const FileOptions file_options_;
+  const EnvOptions& env_options_;
  Env* env_;
-  FileSystem* fs_;

  // ------- WalManager state -------
  // cache for ReadFirstRecord() calls
@@ -47,8 +47,6 @@ class WalManagerTest : public testing::Test {
                                      std::numeric_limits<uint64_t>::max());
    db_options_.wal_dir = dbname_;
    db_options_.env = env_.get();
-    fs_.reset(new LegacyFileSystemWrapper(env_.get()));
-    db_options_.fs = fs_;

    versions_.reset(new VersionSet(dbname_, &db_options_, env_options_,
                                   table_cache_.get(), &write_buffer_manager_,
@@ -81,8 +79,8 @@ class WalManagerTest : public testing::Test {
    std::string fname = ArchivedLogFileName(dbname_, current_log_number_);
    std::unique_ptr<WritableFile> file;
    ASSERT_OK(env_->NewWritableFile(fname, &file, env_options_));
-    std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-        NewLegacyWritableFileWrapper(std::move(file)), fname, env_options_));
+    std::unique_ptr<WritableFileWriter> file_writer(
+        new WritableFileWriter(std::move(file), fname, env_options_));
    current_log_writer_.reset(new log::Writer(std::move(file_writer), 0, false));
  }

@@ -113,7 +111,6 @@ class WalManagerTest : public testing::Test {
  WriteBufferManager write_buffer_manager_;
  std::unique_ptr<VersionSet> versions_;
  std::unique_ptr<WalManager> wal_manager_;
-  std::shared_ptr<LegacyFileSystemWrapper> fs_;

  std::unique_ptr<log::Writer> current_log_writer_;
  uint64_t current_log_number_;
@@ -133,8 +130,8 @@ TEST_F(WalManagerTest, ReadFirstRecordCache) {
      wal_manager_->TEST_ReadFirstRecord(kAliveLogFile, 1 /* number */, &s));
  ASSERT_EQ(s, 0U);

-  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-      NewLegacyWritableFileWrapper(std::move(file)), path, EnvOptions()));
+  std::unique_ptr<WritableFileWriter> file_writer(
+      new WritableFileWriter(std::move(file), path, EnvOptions()));
  log::Writer writer(std::move(file_writer), 1,
                     db_options_.recycle_log_file_num > 0);
  WriteBatch batch;
@@ -451,8 +451,8 @@ size_t WriteThread::EnterAsBatchGroupLeader(Writer* leader,
      break;
    }

-    if (w->disable_wal != leader->disable_wal) {
-      // Do not mix writes that enable WAL with the ones whose
+    if (!w->disable_wal && leader->disable_wal) {
+      // Do not include a write that needs WAL into a batch that has
      // WAL disabled.
      break;
    }
@@ -1,14 +0,0 @@
-add_executable(db_stress${ARTIFACT_SUFFIX}
-  db_stress.cc
-  db_stress_tool.cc
-  batched_ops_stress.cc
-  cf_consistency_stress.cc
-  db_stress_common.cc
-  db_stress_driver.cc
-  db_stress_test_base.cc
-  db_stress_shared_state.cc
-  db_stress_gflags.cc
-  db_stress_tool.cc
-  no_batched_ops_stress.cc)
-target_link_libraries(db_stress${ARTIFACT_SUFFIX} ${ROCKSDB_LIB})
-list(APPEND tool_deps db_stress)
@@ -1,341 +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.
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_common.h"
-
-namespace rocksdb {
-class BatchedOpsStressTest : public StressTest {
- public:
-  BatchedOpsStressTest() {}
-  virtual ~BatchedOpsStressTest() {}
-
-  // Given a key K and value V, this puts ("0"+K, "0"+V), ("1"+K, "1"+V), ...
-  // ("9"+K, "9"+V) in DB atomically i.e in a single batch.
-  // Also refer BatchedOpsStressTest::TestGet
-  Status TestPut(ThreadState* thread, WriteOptions& write_opts,
-                 const ReadOptions& /* read_opts */,
-                 const std::vector<int>& rand_column_families,
-                 const std::vector<int64_t>& rand_keys, char (&value)[100],
-                 std::unique_ptr<MutexLock>& /* lock */) override {
-    uint32_t value_base =
-        thread->rand.Next() % thread->shared->UNKNOWN_SENTINEL;
-    size_t sz = GenerateValue(value_base, value, sizeof(value));
-    Slice v(value, sz);
-    std::string keys[10] = {"9", "8", "7", "6", "5", "4", "3", "2", "1", "0"};
-    std::string values[10] = {"9", "8", "7", "6", "5", "4", "3", "2", "1", "0"};
-    Slice value_slices[10];
-    WriteBatch batch;
-    Status s;
-    auto cfh = column_families_[rand_column_families[0]];
-    std::string key_str = Key(rand_keys[0]);
-    for (int i = 0; i < 10; i++) {
-      keys[i] += key_str;
-      values[i] += v.ToString();
-      value_slices[i] = values[i];
-      if (FLAGS_use_merge) {
-        batch.Merge(cfh, keys[i], value_slices[i]);
-      } else {
-        batch.Put(cfh, keys[i], value_slices[i]);
-      }
-    }
-
-    s = db_->Write(write_opts, &batch);
-    if (!s.ok()) {
-      fprintf(stderr, "multiput error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    } else {
-      // we did 10 writes each of size sz + 1
-      thread->stats.AddBytesForWrites(10, (sz + 1) * 10);
-    }
-
-    return s;
-  }
-
-  // Given a key K, this deletes ("0"+K), ("1"+K),... ("9"+K)
-  // in DB atomically i.e in a single batch. Also refer MultiGet.
-  Status TestDelete(ThreadState* thread, WriteOptions& writeoptions,
-                    const std::vector<int>& rand_column_families,
-                    const std::vector<int64_t>& rand_keys,
-                    std::unique_ptr<MutexLock>& /* lock */) override {
-    std::string keys[10] = {"9", "7", "5", "3", "1", "8", "6", "4", "2", "0"};
-
-    WriteBatch batch;
-    Status s;
-    auto cfh = column_families_[rand_column_families[0]];
-    std::string key_str = Key(rand_keys[0]);
-    for (int i = 0; i < 10; i++) {
-      keys[i] += key_str;
-      batch.Delete(cfh, keys[i]);
-    }
-
-    s = db_->Write(writeoptions, &batch);
-    if (!s.ok()) {
-      fprintf(stderr, "multidelete error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    } else {
-      thread->stats.AddDeletes(10);
-    }
-
-    return s;
-  }
-
-  Status TestDeleteRange(ThreadState* /* thread */,
-                         WriteOptions& /* write_opts */,
-                         const std::vector<int>& /* rand_column_families */,
-                         const std::vector<int64_t>& /* rand_keys */,
-                         std::unique_ptr<MutexLock>& /* lock */) override {
-    assert(false);
-    return Status::NotSupported(
-        "BatchedOpsStressTest does not support "
-        "TestDeleteRange");
-  }
-
-  void TestIngestExternalFile(
-      ThreadState* /* thread */,
-      const std::vector<int>& /* rand_column_families */,
-      const std::vector<int64_t>& /* rand_keys */,
-      std::unique_ptr<MutexLock>& /* lock */) override {
-    assert(false);
-    fprintf(stderr,
-            "BatchedOpsStressTest does not support "
-            "TestIngestExternalFile\n");
-    std::terminate();
-  }
-
-  // Given a key K, this gets values for "0"+K, "1"+K,..."9"+K
-  // in the same snapshot, and verifies that all the values are of the form
-  // "0"+V, "1"+V,..."9"+V.
-  // ASSUMES that BatchedOpsStressTest::TestPut was used to put (K, V) into
-  // the DB.
-  Status TestGet(ThreadState* thread, const ReadOptions& readoptions,
-                 const std::vector<int>& rand_column_families,
-                 const std::vector<int64_t>& rand_keys) override {
-    std::string keys[10] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
-    Slice key_slices[10];
-    std::string values[10];
-    ReadOptions readoptionscopy = readoptions;
-    readoptionscopy.snapshot = db_->GetSnapshot();
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    auto cfh = column_families_[rand_column_families[0]];
-    std::string from_db;
-    Status s;
-    for (int i = 0; i < 10; i++) {
-      keys[i] += key.ToString();
-      key_slices[i] = keys[i];
-      s = db_->Get(readoptionscopy, cfh, key_slices[i], &from_db);
-      if (!s.ok() && !s.IsNotFound()) {
-        fprintf(stderr, "get error: %s\n", s.ToString().c_str());
-        values[i] = "";
-        thread->stats.AddErrors(1);
-        // we continue after error rather than exiting so that we can
-        // find more errors if any
-      } else if (s.IsNotFound()) {
-        values[i] = "";
-        thread->stats.AddGets(1, 0);
-      } else {
-        values[i] = from_db;
-
-        char expected_prefix = (keys[i])[0];
-        char actual_prefix = (values[i])[0];
-        if (actual_prefix != expected_prefix) {
-          fprintf(stderr, "error expected prefix = %c actual = %c\n",
-                  expected_prefix, actual_prefix);
-        }
-        (values[i])[0] = ' ';  // blank out the differing character
-        thread->stats.AddGets(1, 1);
-      }
-    }
-    db_->ReleaseSnapshot(readoptionscopy.snapshot);
-
-    // Now that we retrieved all values, check that they all match
-    for (int i = 1; i < 10; i++) {
-      if (values[i] != values[0]) {
-        fprintf(stderr, "error : inconsistent values for key %s: %s, %s\n",
-                key.ToString(true).c_str(), StringToHex(values[0]).c_str(),
-                StringToHex(values[i]).c_str());
-        // we continue after error rather than exiting so that we can
-        // find more errors if any
-      }
-    }
-
-    return s;
-  }
-
-  std::vector<Status> TestMultiGet(
-      ThreadState* thread, const ReadOptions& readoptions,
-      const std::vector<int>& rand_column_families,
-      const std::vector<int64_t>& rand_keys) override {
-    size_t num_keys = rand_keys.size();
-    std::vector<Status> ret_status(num_keys);
-    std::array<std::string, 10> keys = {{"0", "1", "2", "3", "4",
-                                         "5", "6", "7", "8", "9"}};
-    size_t num_prefixes = keys.size();
-    for (size_t rand_key = 0; rand_key < num_keys; ++rand_key) {
-      std::vector<Slice> key_slices;
-      std::vector<PinnableSlice> values(num_prefixes);
-      std::vector<Status> statuses(num_prefixes);
-      ReadOptions readoptionscopy = readoptions;
-      readoptionscopy.snapshot = db_->GetSnapshot();
-      std::vector<std::string> key_str;
-      key_str.reserve(num_prefixes);
-      key_slices.reserve(num_prefixes);
-      std::string from_db;
-      ColumnFamilyHandle* cfh = column_families_[rand_column_families[0]];
-
-      for (size_t key = 0; key < num_prefixes; ++key) {
-        key_str.emplace_back(keys[key] + Key(rand_keys[rand_key]));
-        key_slices.emplace_back(key_str.back());
-      }
-      db_->MultiGet(readoptionscopy, cfh, num_prefixes, key_slices.data(),
-                    values.data(), statuses.data());
-      for (size_t i = 0; i < num_prefixes; i++) {
-        Status s = statuses[i];
-        if (!s.ok() && !s.IsNotFound()) {
-          fprintf(stderr, "get error: %s\n", s.ToString().c_str());
-          thread->stats.AddErrors(1);
-          ret_status[rand_key] = s;
-          // we continue after error rather than exiting so that we can
-          // find more errors if any
-        } else if (s.IsNotFound()) {
-          thread->stats.AddGets(1, 0);
-          ret_status[rand_key] = s;
-        } else {
-          char expected_prefix = (keys[i])[0];
-          char actual_prefix = (values[i])[0];
-          if (actual_prefix != expected_prefix) {
-            fprintf(stderr, "error expected prefix = %c actual = %c\n",
-                    expected_prefix, actual_prefix);
-          }
-          std::string str;
-          str.assign(values[i].data(), values[i].size());
-          values[i].Reset();
-          str[0] = ' ';  // blank out the differing character
-          values[i].PinSelf(str);
-          thread->stats.AddGets(1, 1);
-        }
-      }
-      db_->ReleaseSnapshot(readoptionscopy.snapshot);
-
-      // Now that we retrieved all values, check that they all match
-      for (size_t i = 1; i < num_prefixes; i++) {
-        if (values[i] != values[0]) {
-          fprintf(stderr, "error : inconsistent values for key %s: %s, %s\n",
-                  key_str[i].c_str(), StringToHex(values[0].ToString()).c_str(),
-                  StringToHex(values[i].ToString()).c_str());
-          // we continue after error rather than exiting so that we can
-          // find more errors if any
-        }
-      }
-    }
-
-    return ret_status;
-  }
-
-  // Given a key, this does prefix scans for "0"+P, "1"+P,..."9"+P
-  // in the same snapshot where P is the first FLAGS_prefix_size - 1 bytes
-  // of the key. Each of these 10 scans returns a series of values;
-  // each series should be the same length, and it is verified for each
-  // index i that all the i'th values are of the form "0"+V, "1"+V,..."9"+V.
-  // ASSUMES that MultiPut was used to put (K, V)
-  Status TestPrefixScan(ThreadState* thread, const ReadOptions& readoptions,
-                        const std::vector<int>& rand_column_families,
-                        const std::vector<int64_t>& rand_keys) override {
-    size_t prefix_to_use =
-        (FLAGS_prefix_size < 0) ? 7 : static_cast<size_t>(FLAGS_prefix_size);
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    auto cfh = column_families_[rand_column_families[0]];
-    std::string prefixes[10] = {"0", "1", "2", "3", "4",
-                                "5", "6", "7", "8", "9"};
-    Slice prefix_slices[10];
-    ReadOptions readoptionscopy[10];
-    const Snapshot* snapshot = db_->GetSnapshot();
-    Iterator* iters[10];
-    std::string upper_bounds[10];
-    Slice ub_slices[10];
-    Status s = Status::OK();
-    for (int i = 0; i < 10; i++) {
-      prefixes[i] += key.ToString();
-      prefixes[i].resize(prefix_to_use);
-      prefix_slices[i] = Slice(prefixes[i]);
-      readoptionscopy[i] = readoptions;
-      readoptionscopy[i].snapshot = snapshot;
-      if (thread->rand.OneIn(2) &&
-          GetNextPrefix(prefix_slices[i], &(upper_bounds[i]))) {
-        // For half of the time, set the upper bound to the next prefix
-        ub_slices[i] = Slice(upper_bounds[i]);
-        readoptionscopy[i].iterate_upper_bound = &(ub_slices[i]);
-      }
-      iters[i] = db_->NewIterator(readoptionscopy[i], cfh);
-      iters[i]->Seek(prefix_slices[i]);
-    }
-
-    long count = 0;
-    while (iters[0]->Valid() && iters[0]->key().starts_with(prefix_slices[0])) {
-      count++;
-      std::string values[10];
-      // get list of all values for this iteration
-      for (int i = 0; i < 10; i++) {
-        // no iterator should finish before the first one
-        assert(iters[i]->Valid() &&
-               iters[i]->key().starts_with(prefix_slices[i]));
-        values[i] = iters[i]->value().ToString();
-
-        char expected_first = (prefixes[i])[0];
-        char actual_first = (values[i])[0];
-
-        if (actual_first != expected_first) {
-          fprintf(stderr, "error expected first = %c actual = %c\n",
-                  expected_first, actual_first);
-        }
-        (values[i])[0] = ' ';  // blank out the differing character
-      }
-      // make sure all values are equivalent
-      for (int i = 0; i < 10; i++) {
-        if (values[i] != values[0]) {
-          fprintf(stderr,
-                  "error : %d, inconsistent values for prefix %s: %s, %s\n", i,
-                  prefixes[i].c_str(), StringToHex(values[0]).c_str(),
-                  StringToHex(values[i]).c_str());
-          // we continue after error rather than exiting so that we can
-          // find more errors if any
-        }
-        iters[i]->Next();
-      }
-    }
-
-    // cleanup iterators and snapshot
-    for (int i = 0; i < 10; i++) {
-      // if the first iterator finished, they should have all finished
-      assert(!iters[i]->Valid() ||
-             !iters[i]->key().starts_with(prefix_slices[i]));
-      assert(iters[i]->status().ok());
-      delete iters[i];
-    }
-    db_->ReleaseSnapshot(snapshot);
-
-    if (s.ok()) {
-      thread->stats.AddPrefixes(1, count);
-    } else {
-      fprintf(stderr, "TestPrefixScan error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    }
-
-    return s;
-  }
-
-  void VerifyDb(ThreadState* /* thread */) const override {}
-};
-
-StressTest* CreateBatchedOpsStressTest() { return new BatchedOpsStressTest(); }
-
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,583 +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.
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_common.h"
-
-namespace rocksdb {
-class CfConsistencyStressTest : public StressTest {
- public:
-  CfConsistencyStressTest() : batch_id_(0) {}
-
-  ~CfConsistencyStressTest() override {}
-
-  Status TestPut(ThreadState* thread, WriteOptions& write_opts,
-                 const ReadOptions& /* read_opts */,
-                 const std::vector<int>& rand_column_families,
-                 const std::vector<int64_t>& rand_keys, char (&value)[100],
-                 std::unique_ptr<MutexLock>& /* lock */) override {
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    uint64_t value_base = batch_id_.fetch_add(1);
-    size_t sz =
-        GenerateValue(static_cast<uint32_t>(value_base), value, sizeof(value));
-    Slice v(value, sz);
-    WriteBatch batch;
-    for (auto cf : rand_column_families) {
-      ColumnFamilyHandle* cfh = column_families_[cf];
-      if (FLAGS_use_merge) {
-        batch.Merge(cfh, key, v);
-      } else { /* !FLAGS_use_merge */
-        batch.Put(cfh, key, v);
-      }
-    }
-    Status s = db_->Write(write_opts, &batch);
-    if (!s.ok()) {
-      fprintf(stderr, "multi put or merge error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    } else {
-      auto num = static_cast<long>(rand_column_families.size());
-      thread->stats.AddBytesForWrites(num, (sz + 1) * num);
-    }
-
-    return s;
-  }
-
-  Status TestDelete(ThreadState* thread, WriteOptions& write_opts,
-                    const std::vector<int>& rand_column_families,
-                    const std::vector<int64_t>& rand_keys,
-                    std::unique_ptr<MutexLock>& /* lock */) override {
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    WriteBatch batch;
-    for (auto cf : rand_column_families) {
-      ColumnFamilyHandle* cfh = column_families_[cf];
-      batch.Delete(cfh, key);
-    }
-    Status s = db_->Write(write_opts, &batch);
-    if (!s.ok()) {
-      fprintf(stderr, "multidel error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    } else {
-      thread->stats.AddDeletes(static_cast<long>(rand_column_families.size()));
-    }
-    return s;
-  }
-
-  Status TestDeleteRange(ThreadState* thread, WriteOptions& write_opts,
-                         const std::vector<int>& rand_column_families,
-                         const std::vector<int64_t>& rand_keys,
-                         std::unique_ptr<MutexLock>& /* lock */) override {
-    int64_t rand_key = rand_keys[0];
-    auto shared = thread->shared;
-    int64_t max_key = shared->GetMaxKey();
-    if (rand_key > max_key - FLAGS_range_deletion_width) {
-      rand_key =
-          thread->rand.Next() % (max_key - FLAGS_range_deletion_width + 1);
-    }
-    std::string key_str = Key(rand_key);
-    Slice key = key_str;
-    std::string end_key_str = Key(rand_key + FLAGS_range_deletion_width);
-    Slice end_key = end_key_str;
-    WriteBatch batch;
-    for (auto cf : rand_column_families) {
-      ColumnFamilyHandle* cfh = column_families_[rand_column_families[cf]];
-      batch.DeleteRange(cfh, key, end_key);
-    }
-    Status s = db_->Write(write_opts, &batch);
-    if (!s.ok()) {
-      fprintf(stderr, "multi del range error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    } else {
-      thread->stats.AddRangeDeletions(
-          static_cast<long>(rand_column_families.size()));
-    }
-    return s;
-  }
-
-  void TestIngestExternalFile(
-      ThreadState* /* thread */,
-      const std::vector<int>& /* rand_column_families */,
-      const std::vector<int64_t>& /* rand_keys */,
-      std::unique_ptr<MutexLock>& /* lock */) override {
-    assert(false);
-    fprintf(stderr,
-            "CfConsistencyStressTest does not support TestIngestExternalFile "
-            "because it's not possible to verify the result\n");
-    std::terminate();
-  }
-
-  Status TestGet(ThreadState* thread, const ReadOptions& readoptions,
-                 const std::vector<int>& rand_column_families,
-                 const std::vector<int64_t>& rand_keys) override {
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    Status s;
-    bool is_consistent = true;
-
-    if (thread->rand.OneIn(2)) {
-      // 1/2 chance, does a random read from random CF
-      auto cfh =
-          column_families_[rand_column_families[thread->rand.Next() %
-                                                rand_column_families.size()]];
-      std::string from_db;
-      s = db_->Get(readoptions, cfh, key, &from_db);
-    } else {
-      // 1/2 chance, comparing one key is the same across all CFs
-      const Snapshot* snapshot = db_->GetSnapshot();
-      ReadOptions readoptionscopy = readoptions;
-      readoptionscopy.snapshot = snapshot;
-
-      std::string value0;
-      s = db_->Get(readoptionscopy, column_families_[rand_column_families[0]],
-                   key, &value0);
-      if (s.ok() || s.IsNotFound()) {
-        bool found = s.ok();
-        for (size_t i = 1; i < rand_column_families.size(); i++) {
-          std::string value1;
-          s = db_->Get(readoptionscopy,
-                       column_families_[rand_column_families[i]], key, &value1);
-          if (!s.ok() && !s.IsNotFound()) {
-            break;
-          }
-          if (!found && s.ok()) {
-            fprintf(stderr, "Get() return different results with key %s\n",
-                    Slice(key_str).ToString(true).c_str());
-            fprintf(stderr, "CF %s is not found\n",
-                    column_family_names_[0].c_str());
-            fprintf(stderr, "CF %s returns value %s\n",
-                    column_family_names_[i].c_str(),
-                    Slice(value1).ToString(true).c_str());
-            is_consistent = false;
-          } else if (found && s.IsNotFound()) {
-            fprintf(stderr, "Get() return different results with key %s\n",
-                    Slice(key_str).ToString(true).c_str());
-            fprintf(stderr, "CF %s returns value %s\n",
-                    column_family_names_[0].c_str(),
-                    Slice(value0).ToString(true).c_str());
-            fprintf(stderr, "CF %s is not found\n",
-                    column_family_names_[i].c_str());
-            is_consistent = false;
-          } else if (s.ok() && value0 != value1) {
-            fprintf(stderr, "Get() return different results with key %s\n",
-                    Slice(key_str).ToString(true).c_str());
-            fprintf(stderr, "CF %s returns value %s\n",
-                    column_family_names_[0].c_str(),
-                    Slice(value0).ToString(true).c_str());
-            fprintf(stderr, "CF %s returns value %s\n",
-                    column_family_names_[i].c_str(),
-                    Slice(value1).ToString(true).c_str());
-            is_consistent = false;
-          }
-          if (!is_consistent) {
-            break;
-          }
-        }
-      }
-
-      db_->ReleaseSnapshot(snapshot);
-    }
-    if (!is_consistent) {
-      fprintf(stderr, "TestGet error: is_consistent is false\n");
-      thread->stats.AddErrors(1);
-      // Fail fast to preserve the DB state.
-      thread->shared->SetVerificationFailure();
-    } else if (s.ok()) {
-      thread->stats.AddGets(1, 1);
-    } else if (s.IsNotFound()) {
-      thread->stats.AddGets(1, 0);
-    } else {
-      fprintf(stderr, "TestGet error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    }
-    return s;
-  }
-
-  std::vector<Status> TestMultiGet(
-      ThreadState* thread, const ReadOptions& read_opts,
-      const std::vector<int>& rand_column_families,
-      const std::vector<int64_t>& rand_keys) override {
-    size_t num_keys = rand_keys.size();
-    std::vector<std::string> key_str;
-    std::vector<Slice> keys;
-    keys.reserve(num_keys);
-    key_str.reserve(num_keys);
-    std::vector<PinnableSlice> values(num_keys);
-    std::vector<Status> statuses(num_keys);
-    ColumnFamilyHandle* cfh = column_families_[rand_column_families[0]];
-
-    for (size_t i = 0; i < num_keys; ++i) {
-      key_str.emplace_back(Key(rand_keys[i]));
-      keys.emplace_back(key_str.back());
-    }
-    db_->MultiGet(read_opts, cfh, num_keys, keys.data(), values.data(),
-                  statuses.data());
-    for (auto s : statuses) {
-      if (s.ok()) {
-        // found case
-        thread->stats.AddGets(1, 1);
-      } else if (s.IsNotFound()) {
-        // not found case
-        thread->stats.AddGets(1, 0);
-      } else {
-        // errors case
-        fprintf(stderr, "MultiGet error: %s\n", s.ToString().c_str());
-        thread->stats.AddErrors(1);
-      }
-    }
-    return statuses;
-  }
-
-  Status TestPrefixScan(ThreadState* thread, const ReadOptions& readoptions,
-                        const std::vector<int>& rand_column_families,
-                        const std::vector<int64_t>& rand_keys) override {
-    size_t prefix_to_use =
-        (FLAGS_prefix_size < 0) ? 7 : static_cast<size_t>(FLAGS_prefix_size);
-
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    Slice prefix = Slice(key.data(), prefix_to_use);
-
-    std::string upper_bound;
-    Slice ub_slice;
-    ReadOptions ro_copy = readoptions;
-    // Get the next prefix first and then see if we want to set upper bound.
-    // We'll use the next prefix in an assertion later on
-    if (GetNextPrefix(prefix, &upper_bound) && thread->rand.OneIn(2)) {
-      ub_slice = Slice(upper_bound);
-      ro_copy.iterate_upper_bound = &ub_slice;
-    }
-    auto cfh =
-        column_families_[rand_column_families[thread->rand.Next() %
-                                              rand_column_families.size()]];
-    Iterator* iter = db_->NewIterator(ro_copy, cfh);
-    unsigned long count = 0;
-    for (iter->Seek(prefix); iter->Valid() && iter->key().starts_with(prefix);
-         iter->Next()) {
-      ++count;
-    }
-    assert(prefix_to_use == 0 ||
-           count <= GetPrefixKeyCount(prefix.ToString(), upper_bound));
-    Status s = iter->status();
-    if (s.ok()) {
-      thread->stats.AddPrefixes(1, count);
-    } else {
-      fprintf(stderr, "TestPrefixScan error: %s\n", s.ToString().c_str());
-      thread->stats.AddErrors(1);
-    }
-    delete iter;
-    return s;
-  }
-
-  ColumnFamilyHandle* GetControlCfh(ThreadState* thread,
-                                    int /*column_family_id*/
-                                    ) override {
-    // All column families should contain the same data. Randomly pick one.
-    return column_families_[thread->rand.Next() % column_families_.size()];
-  }
-
-#ifdef ROCKSDB_LITE
-  Status TestCheckpoint(ThreadState* /* thread */,
-                        const std::vector<int>& /* rand_column_families */,
-                        const std::vector<int64_t>& /* rand_keys */) override {
-    assert(false);
-    fprintf(stderr,
-            "RocksDB lite does not support "
-            "TestCheckpoint\n");
-    std::terminate();
-  }
-#else
-  Status TestCheckpoint(ThreadState* thread,
-                        const std::vector<int>& /* rand_column_families */,
-                        const std::vector<int64_t>& /* rand_keys */) override {
-    std::string checkpoint_dir =
-        FLAGS_db + "/.checkpoint" + ToString(thread->tid);
-
-    // We need to clear DB including manifest files, so make a copy
-    Options opt_copy = options_;
-    opt_copy.env = db_stress_env->target();
-    DestroyDB(checkpoint_dir, opt_copy);
-
-    Checkpoint* checkpoint = nullptr;
-    Status s = Checkpoint::Create(db_, &checkpoint);
-    if (s.ok()) {
-      s = checkpoint->CreateCheckpoint(checkpoint_dir);
-    }
-    std::vector<ColumnFamilyHandle*> cf_handles;
-    DB* checkpoint_db = nullptr;
-    if (s.ok()) {
-      delete checkpoint;
-      checkpoint = nullptr;
-      Options options(options_);
-      options.listeners.clear();
-      std::vector<ColumnFamilyDescriptor> cf_descs;
-      // TODO(ajkr): `column_family_names_` is not safe to access here when
-      // `clear_column_family_one_in != 0`. But we can't easily switch to
-      // `ListColumnFamilies` to get names because it won't necessarily give
-      // the same order as `column_family_names_`.
-      if (FLAGS_clear_column_family_one_in == 0) {
-        for (const auto& name : column_family_names_) {
-          cf_descs.emplace_back(name, ColumnFamilyOptions(options));
-        }
-        s = DB::OpenForReadOnly(DBOptions(options), checkpoint_dir, cf_descs,
-                                &cf_handles, &checkpoint_db);
-      }
-    }
-    if (checkpoint_db != nullptr) {
-      for (auto cfh : cf_handles) {
-        delete cfh;
-      }
-      cf_handles.clear();
-      delete checkpoint_db;
-      checkpoint_db = nullptr;
-    }
-    DestroyDB(checkpoint_dir, opt_copy);
-    if (!s.ok()) {
-      fprintf(stderr, "A checkpoint operation failed with: %s\n",
-              s.ToString().c_str());
-    }
-    return s;
-  }
-#endif  // !ROCKSDB_LITE
-
-  void VerifyDb(ThreadState* thread) const override {
-    ReadOptions options(FLAGS_verify_checksum, true);
-    // We must set total_order_seek to true because we are doing a SeekToFirst
-    // on a column family whose memtables may support (by default) prefix-based
-    // iterator. In this case, NewIterator with options.total_order_seek being
-    // false returns a prefix-based iterator. Calling SeekToFirst using this
-    // iterator causes the iterator to become invalid. That means we cannot
-    // iterate the memtable using this iterator any more, although the memtable
-    // contains the most up-to-date key-values.
-    options.total_order_seek = true;
-    const auto ss_deleter = [this](const Snapshot* ss) {
-      db_->ReleaseSnapshot(ss);
-    };
-    std::unique_ptr<const Snapshot, decltype(ss_deleter)> snapshot_guard(
-        db_->GetSnapshot(), ss_deleter);
-    options.snapshot = snapshot_guard.get();
-    assert(thread != nullptr);
-    auto shared = thread->shared;
-    std::vector<std::unique_ptr<Iterator>> iters(column_families_.size());
-    for (size_t i = 0; i != column_families_.size(); ++i) {
-      iters[i].reset(db_->NewIterator(options, column_families_[i]));
-    }
-    for (auto& iter : iters) {
-      iter->SeekToFirst();
-    }
-    size_t num = column_families_.size();
-    assert(num == iters.size());
-    std::vector<Status> statuses(num, Status::OK());
-    do {
-      if (shared->HasVerificationFailedYet()) {
-        break;
-      }
-      size_t valid_cnt = 0;
-      size_t idx = 0;
-      for (auto& iter : iters) {
-        if (iter->Valid()) {
-          ++valid_cnt;
-        } else {
-          statuses[idx] = iter->status();
-        }
-        ++idx;
-      }
-      if (valid_cnt == 0) {
-        Status status;
-        for (size_t i = 0; i != num; ++i) {
-          const auto& s = statuses[i];
-          if (!s.ok()) {
-            status = s;
-            fprintf(stderr, "Iterator on cf %s has error: %s\n",
-                    column_families_[i]->GetName().c_str(),
-                    s.ToString().c_str());
-            shared->SetVerificationFailure();
-          }
-        }
-        break;
-      } else if (valid_cnt != iters.size()) {
-        shared->SetVerificationFailure();
-        for (size_t i = 0; i != num; ++i) {
-          if (!iters[i]->Valid()) {
-            if (statuses[i].ok()) {
-              fprintf(stderr, "Finished scanning cf %s\n",
-                      column_families_[i]->GetName().c_str());
-            } else {
-              fprintf(stderr, "Iterator on cf %s has error: %s\n",
-                      column_families_[i]->GetName().c_str(),
-                      statuses[i].ToString().c_str());
-            }
-          } else {
-            fprintf(stderr, "cf %s has remaining data to scan\n",
-                    column_families_[i]->GetName().c_str());
-          }
-        }
-        break;
-      }
-      if (shared->HasVerificationFailedYet()) {
-        break;
-      }
-      // If the program reaches here, then all column families' iterators are
-      // still valid.
-      if (shared->PrintingVerificationResults()) {
-        continue;
-      }
-      Slice key;
-      Slice value;
-      int num_mismatched_cfs = 0;
-      for (size_t i = 0; i != num; ++i) {
-        if (i == 0) {
-          key = iters[i]->key();
-          value = iters[i]->value();
-        } else {
-          int cmp = key.compare(iters[i]->key());
-          if (cmp != 0) {
-            ++num_mismatched_cfs;
-            if (1 == num_mismatched_cfs) {
-              fprintf(stderr, "Verification failed\n");
-              fprintf(stderr, "Latest Sequence Number: %" PRIu64 "\n",
-                      db_->GetLatestSequenceNumber());
-              fprintf(stderr, "[%s] %s => %s\n",
-                      column_families_[0]->GetName().c_str(),
-                      key.ToString(true /* hex */).c_str(),
-                      value.ToString(true /* hex */).c_str());
-            }
-            fprintf(stderr, "[%s] %s => %s\n",
-                    column_families_[i]->GetName().c_str(),
-                    iters[i]->key().ToString(true /* hex */).c_str(),
-                    iters[i]->value().ToString(true /* hex */).c_str());
-#ifndef ROCKSDB_LITE
-            Slice begin_key;
-            Slice end_key;
-            if (cmp < 0) {
-              begin_key = key;
-              end_key = iters[i]->key();
-            } else {
-              begin_key = iters[i]->key();
-              end_key = key;
-            }
-            std::vector<KeyVersion> versions;
-            const size_t kMaxNumIKeys = 8;
-            const auto print_key_versions = [&](ColumnFamilyHandle* cfh) {
-              Status s = GetAllKeyVersions(db_, cfh, begin_key, end_key,
-                                           kMaxNumIKeys, &versions);
-              if (!s.ok()) {
-                fprintf(stderr, "%s\n", s.ToString().c_str());
-                return;
-              }
-              assert(nullptr != cfh);
-              fprintf(stderr,
-                      "Internal keys in CF '%s', [%s, %s] (max %" ROCKSDB_PRIszt
-                      ")\n",
-                      cfh->GetName().c_str(),
-                      begin_key.ToString(true /* hex */).c_str(),
-                      end_key.ToString(true /* hex */).c_str(), kMaxNumIKeys);
-              for (const KeyVersion& kv : versions) {
-                fprintf(stderr, "  key %s seq %" PRIu64 " type %d\n",
-                        Slice(kv.user_key).ToString(true).c_str(), kv.sequence,
-                        kv.type);
-              }
-            };
-            if (1 == num_mismatched_cfs) {
-              print_key_versions(column_families_[0]);
-            }
-            print_key_versions(column_families_[i]);
-#endif  // ROCKSDB_LITE
-            shared->SetVerificationFailure();
-          }
-        }
-      }
-      shared->FinishPrintingVerificationResults();
-      for (auto& iter : iters) {
-        iter->Next();
-      }
-    } while (true);
-  }
-
-#ifndef ROCKSDB_LITE
-  void ContinuouslyVerifyDb(ThreadState* thread) const override {
-    assert(thread);
-    Status status;
-
-    DB* db_ptr = cmp_db_ ? cmp_db_ : db_;
-    const auto& cfhs = cmp_db_ ? cmp_cfhs_ : column_families_;
-    const auto ss_deleter = [&](const Snapshot* ss) {
-      db_ptr->ReleaseSnapshot(ss);
-    };
-    std::unique_ptr<const Snapshot, decltype(ss_deleter)> snapshot_guard(
-        db_ptr->GetSnapshot(), ss_deleter);
-    if (cmp_db_) {
-      status = cmp_db_->TryCatchUpWithPrimary();
-    }
-    SharedState* shared = thread->shared;
-    assert(shared);
-    if (!status.ok()) {
-      shared->SetShouldStopTest();
-      return;
-    }
-    assert(cmp_db_ || snapshot_guard.get());
-    const auto checksum_column_family = [](Iterator* iter,
-                                           uint32_t* checksum) -> Status {
-      assert(nullptr != checksum);
-      uint32_t ret = 0;
-      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-        ret = crc32c::Extend(ret, iter->key().data(), iter->key().size());
-        ret = crc32c::Extend(ret, iter->value().data(), iter->value().size());
-      }
-      *checksum = ret;
-      return iter->status();
-    };
-    ReadOptions ropts;
-    ropts.total_order_seek = true;
-    ropts.snapshot = snapshot_guard.get();
-    uint32_t crc = 0;
-    {
-      // Compute crc for all key-values of default column family.
-      std::unique_ptr<Iterator> it(db_ptr->NewIterator(ropts));
-      status = checksum_column_family(it.get(), &crc);
-    }
-    uint32_t tmp_crc = 0;
-    if (status.ok()) {
-      for (ColumnFamilyHandle* cfh : cfhs) {
-        if (cfh == db_ptr->DefaultColumnFamily()) {
-          continue;
-        }
-        std::unique_ptr<Iterator> it(db_ptr->NewIterator(ropts, cfh));
-        status = checksum_column_family(it.get(), &tmp_crc);
-        if (!status.ok() || tmp_crc != crc) {
-          break;
-        }
-      }
-    }
-    if (!status.ok() || tmp_crc != crc) {
-      shared->SetShouldStopTest();
-    }
-  }
-#endif  // !ROCKSDB_LITE
-
-  std::vector<int> GenerateColumnFamilies(
-      const int /* num_column_families */,
-      int /* rand_column_family */) const override {
-    std::vector<int> ret;
-    int num = static_cast<int>(column_families_.size());
-    int k = 0;
-    std::generate_n(back_inserter(ret), num, [&k]() -> int { return k++; });
-    return ret;
-  }
-
- private:
-  std::atomic<int64_t> batch_id_;
-};
-
-StressTest* CreateCfConsistencyStressTest() {
-  return new CfConsistencyStressTest();
-}
-
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,224 +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.
-//
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_common.h"
-#include <cmath>
-
-rocksdb::DbStressEnvWrapper* db_stress_env = nullptr;
-enum rocksdb::CompressionType compression_type_e = rocksdb::kSnappyCompression;
-enum rocksdb::CompressionType bottommost_compression_type_e =
-    rocksdb::kSnappyCompression;
-enum rocksdb::ChecksumType checksum_type_e = rocksdb::kCRC32c;
-enum RepFactory FLAGS_rep_factory = kSkipList;
-std::vector<double> sum_probs(100001);
-int64_t zipf_sum_size = 100000;
-
-namespace rocksdb {
-
-// Zipfian distribution is generated based on a pre-calculated array.
-// It should be used before start the stress test.
-// First, the probability distribution function (PDF) of this Zipfian follows
-// power low. P(x) = 1/(x^alpha).
-// So we calculate the PDF when x is from 0 to zipf_sum_size in first for loop
-// and add the PDF value togetger as c. So we get the total probability in c.
-// Next, we calculate inverse CDF of Zipfian and store the value of each in
-// an array (sum_probs). The rank is from 0 to zipf_sum_size. For example, for
-// integer k, its Zipfian CDF value is sum_probs[k].
-// Third, when we need to get an integer whose probability follows Zipfian
-// distribution, we use a rand_seed [0,1] which follows uniform distribution
-// as a seed and search it in the sum_probs via binary search. When we find
-// the closest sum_probs[i] of rand_seed, i is the integer that in
-// [0, zipf_sum_size] following Zipfian distribution with parameter alpha.
-// Finally, we can scale i to [0, max_key] scale.
-// In order to avoid that hot keys are close to each other and skew towards 0,
-// we use Rando64 to shuffle it.
-void InitializeHotKeyGenerator(double alpha) {
-  double c = 0;
-  for (int64_t i = 1; i <= zipf_sum_size; i++) {
-    c = c + (1.0 / std::pow(static_cast<double>(i), alpha));
-  }
-  c = 1.0 / c;
-
-  sum_probs[0] = 0;
-  for (int64_t i = 1; i <= zipf_sum_size; i++) {
-    sum_probs[i] =
-        sum_probs[i - 1] + c / std::pow(static_cast<double>(i), alpha);
-  }
-}
-
-// Generate one key that follows the Zipfian distribution. The skewness
-// is decided by the parameter alpha. Input is the rand_seed [0,1] and
-// the max of the key to be generated. If we directly return tmp_zipf_seed,
-// the closer to 0, the higher probability will be. To randomly distribute
-// the hot keys in [0, max_key], we use Random64 to shuffle it.
-int64_t GetOneHotKeyID(double rand_seed, int64_t max_key) {
-  int64_t low = 1, mid, high = zipf_sum_size, zipf = 0;
-  while (low <= high) {
-    mid = static_cast<int64_t>(std::floor((low + high) / 2));
-    if (sum_probs[mid] >= rand_seed && sum_probs[mid - 1] < rand_seed) {
-      zipf = mid;
-      break;
-    } else if (sum_probs[mid] >= rand_seed) {
-      high = mid - 1;
-    } else {
-      low = mid + 1;
-    }
-  }
-  int64_t tmp_zipf_seed = static_cast<int64_t>(
-      std::floor(zipf * max_key / (static_cast<double>(zipf_sum_size))));
-  Random64 rand_local(tmp_zipf_seed);
-  return rand_local.Next() % max_key;
-}
-
-void PoolSizeChangeThread(void* v) {
-  assert(FLAGS_compaction_thread_pool_adjust_interval > 0);
-  ThreadState* thread = reinterpret_cast<ThreadState*>(v);
-  SharedState* shared = thread->shared;
-
-  while (true) {
-    {
-      MutexLock l(shared->GetMutex());
-      if (shared->ShouldStopBgThread()) {
-        shared->IncBgThreadsFinished();
-        if (shared->BgThreadsFinished()) {
-          shared->GetCondVar()->SignalAll();
-        }
-        return;
-      }
-    }
-
-    auto thread_pool_size_base = FLAGS_max_background_compactions;
-    auto thread_pool_size_var = FLAGS_compaction_thread_pool_variations;
-    int new_thread_pool_size =
-        thread_pool_size_base - thread_pool_size_var +
-        thread->rand.Next() % (thread_pool_size_var * 2 + 1);
-    if (new_thread_pool_size < 1) {
-      new_thread_pool_size = 1;
-    }
-    db_stress_env->SetBackgroundThreads(new_thread_pool_size,
-                                        rocksdb::Env::Priority::LOW);
-    // Sleep up to 3 seconds
-    db_stress_env->SleepForMicroseconds(
-        thread->rand.Next() % FLAGS_compaction_thread_pool_adjust_interval *
-            1000 +
-        1);
-  }
-}
-
-void DbVerificationThread(void* v) {
-  assert(FLAGS_continuous_verification_interval > 0);
-  auto* thread = reinterpret_cast<ThreadState*>(v);
-  SharedState* shared = thread->shared;
-  StressTest* stress_test = shared->GetStressTest();
-  assert(stress_test != nullptr);
-  while (true) {
-    {
-      MutexLock l(shared->GetMutex());
-      if (shared->ShouldStopBgThread()) {
-        shared->IncBgThreadsFinished();
-        if (shared->BgThreadsFinished()) {
-          shared->GetCondVar()->SignalAll();
-        }
-        return;
-      }
-    }
-    if (!shared->HasVerificationFailedYet()) {
-      stress_test->ContinuouslyVerifyDb(thread);
-    }
-    db_stress_env->SleepForMicroseconds(
-        thread->rand.Next() % FLAGS_continuous_verification_interval * 1000 +
-        1);
-  }
-}
-
-void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz) {
-  if (!FLAGS_verbose) {
-    return;
-  }
-  std::string tmp;
-  tmp.reserve(sz * 2 + 16);
-  char buf[4];
-  for (size_t i = 0; i < sz; i++) {
-    snprintf(buf, 4, "%X", value[i]);
-    tmp.append(buf);
-  }
-  fprintf(stdout, "[CF %d] %" PRIi64 " == > (%" ROCKSDB_PRIszt ") %s\n", cf,
-          key, sz, tmp.c_str());
-}
-
-// Note that if hot_key_alpha != 0, it generates the key based on Zipfian
-// distribution. Keys are randomly scattered to [0, FLAGS_max_key]. It does
-// not ensure the order of the keys being generated and the keys does not have
-// the active range which is related to FLAGS_active_width.
-int64_t GenerateOneKey(ThreadState* thread, uint64_t iteration) {
-  const double completed_ratio =
-      static_cast<double>(iteration) / FLAGS_ops_per_thread;
-  const int64_t base_key = static_cast<int64_t>(
-      completed_ratio * (FLAGS_max_key - FLAGS_active_width));
-  int64_t rand_seed = base_key + thread->rand.Next() % FLAGS_active_width;
-  int64_t cur_key = rand_seed;
-  if (FLAGS_hot_key_alpha != 0) {
-    // If set the Zipfian distribution Alpha to non 0, use Zipfian
-    double float_rand =
-        (static_cast<double>(thread->rand.Next() % FLAGS_max_key)) /
-        FLAGS_max_key;
-    cur_key = GetOneHotKeyID(float_rand, FLAGS_max_key);
-  }
-  return cur_key;
-}
-
-// Note that if hot_key_alpha != 0, it generates the key based on Zipfian
-// distribution. Keys being generated are in random order.
-// If user want to generate keys based on uniform distribution, user needs to
-// set hot_key_alpha == 0. It will generate the random keys in increasing
-// order in the key array (ensure key[i] >= key[i+1]) and constrained in a
-// range related to FLAGS_active_width.
-std::vector<int64_t> GenerateNKeys(ThreadState* thread, int num_keys,
-                                   uint64_t iteration) {
-  const double completed_ratio =
-      static_cast<double>(iteration) / FLAGS_ops_per_thread;
-  const int64_t base_key = static_cast<int64_t>(
-      completed_ratio * (FLAGS_max_key - FLAGS_active_width));
-  std::vector<int64_t> keys;
-  keys.reserve(num_keys);
-  int64_t next_key = base_key + thread->rand.Next() % FLAGS_active_width;
-  keys.push_back(next_key);
-  for (int i = 1; i < num_keys; ++i) {
-    // Generate the key follows zipfian distribution
-    if (FLAGS_hot_key_alpha != 0) {
-      double float_rand =
-          (static_cast<double>(thread->rand.Next() % FLAGS_max_key)) /
-          FLAGS_max_key;
-      next_key = GetOneHotKeyID(float_rand, FLAGS_max_key);
-    } else {
-      // This may result in some duplicate keys
-      next_key = next_key + thread->rand.Next() %
-                                (FLAGS_active_width - (next_key - base_key));
-    }
-    keys.push_back(next_key);
-  }
-  return keys;
-}
-
-size_t GenerateValue(uint32_t rand, char* v, size_t max_sz) {
-  size_t value_sz =
-      ((rand % kRandomValueMaxFactor) + 1) * FLAGS_value_size_mult;
-  assert(value_sz <= max_sz && value_sz >= sizeof(uint32_t));
-  (void)max_sz;
-  *((uint32_t*)v) = rand;
-  for (size_t i = sizeof(uint32_t); i < value_sz; i++) {
-    v[i] = (char)(rand ^ i);
-  }
-  v[value_sz] = '\0';
-  return value_sz;  // the size of the value set.
-}
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,509 +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.
-//
-// The test uses an array to compare against values written to the database.
-// Keys written to the array are in 1:1 correspondence to the actual values in
-// the database according to the formula in the function GenerateValue.
-
-// Space is reserved in the array from 0 to FLAGS_max_key and values are
-// randomly written/deleted/read from those positions. During verification we
-// compare all the positions in the array. To shorten/elongate the running
-// time, you could change the settings: FLAGS_max_key, FLAGS_ops_per_thread,
-// (sometimes also FLAGS_threads).
-//
-// NOTE that if FLAGS_test_batches_snapshots is set, the test will have
-// different behavior. See comment of the flag for details.
-
-#ifdef GFLAGS
-#pragma once
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <cinttypes>
-#include <exception>
-#include <queue>
-#include <thread>
-
-#include "db/db_impl/db_impl.h"
-#include "db/version_set.h"
-#include "db_stress_tool/db_stress_env_wrapper.h"
-#include "db_stress_tool/db_stress_listener.h"
-#include "db_stress_tool/db_stress_shared_state.h"
-#include "db_stress_tool/db_stress_test_base.h"
-#include "hdfs/env_hdfs.h"
-#include "logging/logging.h"
-#include "monitoring/histogram.h"
-#include "options/options_helper.h"
-#include "port/port.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/env.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/slice_transform.h"
-#include "rocksdb/statistics.h"
-#include "rocksdb/utilities/backupable_db.h"
-#include "rocksdb/utilities/checkpoint.h"
-#include "rocksdb/utilities/db_ttl.h"
-#include "rocksdb/utilities/debug.h"
-#include "rocksdb/utilities/options_util.h"
-#include "rocksdb/utilities/transaction.h"
-#include "rocksdb/utilities/transaction_db.h"
-#include "rocksdb/write_batch.h"
-#include "util/coding.h"
-#include "util/compression.h"
-#include "util/crc32c.h"
-#include "util/gflags_compat.h"
-#include "util/mutexlock.h"
-#include "util/random.h"
-#include "util/string_util.h"
-#include "utilities/blob_db/blob_db.h"
-// SyncPoint is not supported in Released Windows Mode.
-#if !(defined NDEBUG) || !defined(OS_WIN)
-#include "test_util/sync_point.h"
-#endif  // !(defined NDEBUG) || !defined(OS_WIN)
-#include "test_util/testutil.h"
-
-#include "utilities/merge_operators.h"
-
-using GFLAGS_NAMESPACE::ParseCommandLineFlags;
-using GFLAGS_NAMESPACE::RegisterFlagValidator;
-using GFLAGS_NAMESPACE::SetUsageMessage;
-
-DECLARE_uint64(seed);
-DECLARE_bool(read_only);
-DECLARE_int64(max_key);
-DECLARE_double(hot_key_alpha);
-DECLARE_int32(max_key_len);
-DECLARE_string(key_len_percent_dist);
-DECLARE_int32(key_window_scale_factor);
-DECLARE_int32(column_families);
-DECLARE_string(options_file);
-DECLARE_int64(active_width);
-DECLARE_bool(test_batches_snapshots);
-DECLARE_bool(atomic_flush);
-DECLARE_bool(test_cf_consistency);
-DECLARE_int32(threads);
-DECLARE_int32(ttl);
-DECLARE_int32(value_size_mult);
-DECLARE_int32(compaction_readahead_size);
-DECLARE_bool(enable_pipelined_write);
-DECLARE_bool(verify_before_write);
-DECLARE_bool(histogram);
-DECLARE_bool(destroy_db_initially);
-DECLARE_bool(verbose);
-DECLARE_bool(progress_reports);
-DECLARE_uint64(db_write_buffer_size);
-DECLARE_int32(write_buffer_size);
-DECLARE_int32(max_write_buffer_number);
-DECLARE_int32(min_write_buffer_number_to_merge);
-DECLARE_int32(max_write_buffer_number_to_maintain);
-DECLARE_int64(max_write_buffer_size_to_maintain);
-DECLARE_double(memtable_prefix_bloom_size_ratio);
-DECLARE_bool(memtable_whole_key_filtering);
-DECLARE_int32(open_files);
-DECLARE_int64(compressed_cache_size);
-DECLARE_int32(compaction_style);
-DECLARE_int32(level0_file_num_compaction_trigger);
-DECLARE_int32(level0_slowdown_writes_trigger);
-DECLARE_int32(level0_stop_writes_trigger);
-DECLARE_int32(block_size);
-DECLARE_int32(format_version);
-DECLARE_int32(index_block_restart_interval);
-DECLARE_int32(max_background_compactions);
-DECLARE_int32(num_bottom_pri_threads);
-DECLARE_int32(compaction_thread_pool_adjust_interval);
-DECLARE_int32(compaction_thread_pool_variations);
-DECLARE_int32(max_background_flushes);
-DECLARE_int32(universal_size_ratio);
-DECLARE_int32(universal_min_merge_width);
-DECLARE_int32(universal_max_merge_width);
-DECLARE_int32(universal_max_size_amplification_percent);
-DECLARE_int32(clear_column_family_one_in);
-DECLARE_int32(get_live_files_and_wal_files_one_in);
-DECLARE_int32(set_options_one_in);
-DECLARE_int32(set_in_place_one_in);
-DECLARE_int64(cache_size);
-DECLARE_bool(cache_index_and_filter_blocks);
-DECLARE_bool(use_clock_cache);
-DECLARE_uint64(subcompactions);
-DECLARE_uint64(periodic_compaction_seconds);
-DECLARE_uint64(compaction_ttl);
-DECLARE_bool(allow_concurrent_memtable_write);
-DECLARE_bool(enable_write_thread_adaptive_yield);
-DECLARE_int32(reopen);
-DECLARE_double(bloom_bits);
-DECLARE_bool(use_block_based_filter);
-DECLARE_bool(partition_filters);
-DECLARE_int32(index_type);
-DECLARE_string(db);
-DECLARE_string(secondaries_base);
-DECLARE_bool(test_secondary);
-DECLARE_string(expected_values_path);
-DECLARE_bool(verify_checksum);
-DECLARE_bool(mmap_read);
-DECLARE_bool(mmap_write);
-DECLARE_bool(use_direct_reads);
-DECLARE_bool(use_direct_io_for_flush_and_compaction);
-DECLARE_bool(statistics);
-DECLARE_bool(sync);
-DECLARE_bool(use_fsync);
-DECLARE_int32(kill_random_test);
-DECLARE_string(kill_prefix_blacklist);
-DECLARE_bool(disable_wal);
-DECLARE_uint64(recycle_log_file_num);
-DECLARE_int64(target_file_size_base);
-DECLARE_int32(target_file_size_multiplier);
-DECLARE_uint64(max_bytes_for_level_base);
-DECLARE_double(max_bytes_for_level_multiplier);
-DECLARE_int32(range_deletion_width);
-DECLARE_uint64(rate_limiter_bytes_per_sec);
-DECLARE_bool(rate_limit_bg_reads);
-DECLARE_bool(use_txn);
-DECLARE_uint64(txn_write_policy);
-DECLARE_bool(unordered_write);
-DECLARE_int32(backup_one_in);
-DECLARE_int32(checkpoint_one_in);
-DECLARE_int32(ingest_external_file_one_in);
-DECLARE_int32(ingest_external_file_width);
-DECLARE_int32(compact_files_one_in);
-DECLARE_int32(compact_range_one_in);
-DECLARE_int32(flush_one_in);
-DECLARE_int32(pause_background_one_in);
-DECLARE_int32(compact_range_width);
-DECLARE_int32(acquire_snapshot_one_in);
-DECLARE_bool(compare_full_db_state_snapshot);
-DECLARE_uint64(snapshot_hold_ops);
-DECLARE_bool(long_running_snapshots);
-DECLARE_bool(use_multiget);
-DECLARE_int32(readpercent);
-DECLARE_int32(prefixpercent);
-DECLARE_int32(writepercent);
-DECLARE_int32(delpercent);
-DECLARE_int32(delrangepercent);
-DECLARE_int32(nooverwritepercent);
-DECLARE_int32(iterpercent);
-DECLARE_uint64(num_iterations);
-DECLARE_string(compression_type);
-DECLARE_string(bottommost_compression_type);
-DECLARE_int32(compression_max_dict_bytes);
-DECLARE_int32(compression_zstd_max_train_bytes);
-DECLARE_string(checksum_type);
-DECLARE_string(hdfs);
-DECLARE_string(env_uri);
-DECLARE_uint64(ops_per_thread);
-DECLARE_uint64(log2_keys_per_lock);
-DECLARE_uint64(max_manifest_file_size);
-DECLARE_bool(in_place_update);
-DECLARE_int32(secondary_catch_up_one_in);
-DECLARE_string(memtablerep);
-DECLARE_int32(prefix_size);
-DECLARE_bool(use_merge);
-DECLARE_bool(use_full_merge_v1);
-DECLARE_int32(sync_wal_one_in);
-DECLARE_bool(avoid_unnecessary_blocking_io);
-DECLARE_bool(write_dbid_to_manifest);
-DECLARE_uint64(max_write_batch_group_size_bytes);
-DECLARE_bool(level_compaction_dynamic_level_bytes);
-DECLARE_int32(verify_checksum_one_in);
-DECLARE_int32(verify_db_one_in);
-DECLARE_int32(continuous_verification_interval);
-
-#ifndef ROCKSDB_LITE
-DECLARE_bool(use_blob_db);
-DECLARE_uint64(blob_db_min_blob_size);
-DECLARE_uint64(blob_db_bytes_per_sync);
-DECLARE_uint64(blob_db_file_size);
-DECLARE_bool(blob_db_enable_gc);
-DECLARE_double(blob_db_gc_cutoff);
-#endif  // !ROCKSDB_LITE
-DECLARE_int32(approximate_size_one_in);
-
-const long KB = 1024;
-const int kRandomValueMaxFactor = 3;
-const int kValueMaxLen = 100;
-
-// wrapped posix or hdfs environment
-extern rocksdb::DbStressEnvWrapper* db_stress_env;
-
-extern enum rocksdb::CompressionType compression_type_e;
-extern enum rocksdb::CompressionType bottommost_compression_type_e;
-extern enum rocksdb::ChecksumType checksum_type_e;
-
-enum RepFactory { kSkipList, kHashSkipList, kVectorRep };
-
-inline enum RepFactory StringToRepFactory(const char* ctype) {
-  assert(ctype);
-
-  if (!strcasecmp(ctype, "skip_list"))
-    return kSkipList;
-  else if (!strcasecmp(ctype, "prefix_hash"))
-    return kHashSkipList;
-  else if (!strcasecmp(ctype, "vector"))
-    return kVectorRep;
-
-  fprintf(stdout, "Cannot parse memreptable %s\n", ctype);
-  return kSkipList;
-}
-
-extern enum RepFactory FLAGS_rep_factory;
-
-namespace rocksdb {
-inline enum rocksdb::CompressionType StringToCompressionType(
-    const char* ctype) {
-  assert(ctype);
-
-  rocksdb::CompressionType ret_compression_type;
-
-  if (!strcasecmp(ctype, "disable")) {
-    ret_compression_type = rocksdb::kDisableCompressionOption;
-  } else if (!strcasecmp(ctype, "none")) {
-    ret_compression_type = rocksdb::kNoCompression;
-  } else if (!strcasecmp(ctype, "snappy")) {
-    ret_compression_type = rocksdb::kSnappyCompression;
-  } else if (!strcasecmp(ctype, "zlib")) {
-    ret_compression_type = rocksdb::kZlibCompression;
-  } else if (!strcasecmp(ctype, "bzip2")) {
-    ret_compression_type = rocksdb::kBZip2Compression;
-  } else if (!strcasecmp(ctype, "lz4")) {
-    ret_compression_type = rocksdb::kLZ4Compression;
-  } else if (!strcasecmp(ctype, "lz4hc")) {
-    ret_compression_type = rocksdb::kLZ4HCCompression;
-  } else if (!strcasecmp(ctype, "xpress")) {
-    ret_compression_type = rocksdb::kXpressCompression;
-  } else if (!strcasecmp(ctype, "zstd")) {
-    ret_compression_type = rocksdb::kZSTD;
-  } else {
-    fprintf(stderr, "Cannot parse compression type '%s'\n", ctype);
-    ret_compression_type = rocksdb::kSnappyCompression;  // default value
-  }
-  if (ret_compression_type != rocksdb::kDisableCompressionOption &&
-      !CompressionTypeSupported(ret_compression_type)) {
-    // Use no compression will be more portable but considering this is
-    // only a stress test and snappy is widely available. Use snappy here.
-    ret_compression_type = rocksdb::kSnappyCompression;
-  }
-  return ret_compression_type;
-}
-
-inline enum rocksdb::ChecksumType StringToChecksumType(const char* ctype) {
-  assert(ctype);
-  auto iter = rocksdb::checksum_type_string_map.find(ctype);
-  if (iter != rocksdb::checksum_type_string_map.end()) {
-    return iter->second;
-  }
-  fprintf(stderr, "Cannot parse checksum type '%s'\n", ctype);
-  return rocksdb::kCRC32c;
-}
-
-inline std::string ChecksumTypeToString(rocksdb::ChecksumType ctype) {
-  auto iter = std::find_if(
-      rocksdb::checksum_type_string_map.begin(),
-      rocksdb::checksum_type_string_map.end(),
-      [&](const std::pair<std::string, rocksdb::ChecksumType>&
-              name_and_enum_val) { return name_and_enum_val.second == ctype; });
-  assert(iter != rocksdb::checksum_type_string_map.end());
-  return iter->first;
-}
-
-inline std::vector<std::string> SplitString(std::string src) {
-  std::vector<std::string> ret;
-  if (src.empty()) {
-    return ret;
-  }
-  size_t pos = 0;
-  size_t pos_comma;
-  while ((pos_comma = src.find(',', pos)) != std::string::npos) {
-    ret.push_back(src.substr(pos, pos_comma - pos));
-    pos = pos_comma + 1;
-  }
-  ret.push_back(src.substr(pos, src.length()));
-  return ret;
-}
-
-#ifdef _MSC_VER
-#pragma warning(push)
-// truncation of constant value on static_cast
-#pragma warning(disable : 4309)
-#endif
-inline bool GetNextPrefix(const rocksdb::Slice& src, std::string* v) {
-  std::string ret = src.ToString();
-  for (int i = static_cast<int>(ret.size()) - 1; i >= 0; i--) {
-    if (ret[i] != static_cast<char>(255)) {
-      ret[i] = ret[i] + 1;
-      break;
-    } else if (i != 0) {
-      ret[i] = 0;
-    } else {
-      // all FF. No next prefix
-      return false;
-    }
-  }
-  *v = ret;
-  return true;
-}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// convert long to a big-endian slice key
-extern inline std::string GetStringFromInt(int64_t val) {
-  std::string little_endian_key;
-  std::string big_endian_key;
-  PutFixed64(&little_endian_key, val);
-  assert(little_endian_key.size() == sizeof(val));
-  big_endian_key.resize(sizeof(val));
-  for (size_t i = 0; i < sizeof(val); ++i) {
-    big_endian_key[i] = little_endian_key[sizeof(val) - 1 - i];
-  }
-  return big_endian_key;
-}
-
-// A struct for maintaining the parameters for generating variable length keys
-struct KeyGenContext {
-  // Number of adjacent keys in one cycle of key lengths
-  uint64_t window;
-  // Number of keys of each possible length in a given window
-  std::vector<uint64_t> weights;
-};
-extern KeyGenContext key_gen_ctx;
-
-// Generate a variable length key string from the given int64 val. The
-// order of the keys is preserved. The key could be anywhere from 8 to
-// max_key_len * 8 bytes.
-// The algorithm picks the length based on the
-// offset of the val within a configured window and the distribution of the
-// number of keys of various lengths in that window. For example, if x, y, x are
-// the weights assigned to each possible key length, the keys generated would be
-// - {0}...{x-1}
-// {(x-1),0}..{(x-1),(y-1)},{(x-1),(y-1),0}..{(x-1),(y-1),(z-1)} and so on.
-// Additionally, a trailer of 0-7 bytes could be appended.
-extern inline std::string Key(int64_t val) {
-  uint64_t window = key_gen_ctx.window;
-  size_t levels = key_gen_ctx.weights.size();
-  std::string key;
-
-  for (size_t level = 0; level < levels; ++level) {
-    uint64_t weight = key_gen_ctx.weights[level];
-    uint64_t offset = static_cast<uint64_t>(val) % window;
-    uint64_t mult = static_cast<uint64_t>(val) / window;
-    uint64_t pfx = mult * weight + (offset >= weight ? weight - 1 : offset);
-    key.append(GetStringFromInt(pfx));
-    if (offset < weight) {
-      // Use the bottom 3 bits of offset as the number of trailing 'x's in the
-      // key. If the next key is going to be of the next level, then skip the
-      // trailer as it would break ordering. If the key length is already at max,
-      // skip the trailer.
-      if (offset < weight - 1 && level < levels - 1) {
-        size_t trailer_len = offset & 0x7;
-        key.append(trailer_len, 'x');
-      }
-      break;
-    }
-    val = offset - weight;
-    window -= weight;
-  }
-
-  return key;
-}
-
-// Given a string key, map it to an index into the expected values buffer
-extern inline bool GetIntVal(std::string big_endian_key, uint64_t* key_p) {
-  size_t size_key = big_endian_key.size();
-  std::vector<uint64_t> prefixes;
-
-  assert(size_key <= key_gen_ctx.weights.size() * sizeof(uint64_t));
-
-  // Pad with zeros to make it a multiple of 8. This function may be called
-  // with a prefix, in which case we return the first index that falls
-  // inside or outside that prefix, dependeing on whether the prefix is
-  // the start of upper bound of a scan
-  unsigned int pad = sizeof(uint64_t) - (size_key % sizeof(uint64_t));
-  if (pad < sizeof(uint64_t)) {
-    big_endian_key.append(pad, '\0');
-    size_key += pad;
-  }
-
-  std::string little_endian_key;
-  little_endian_key.resize(size_key);
-  for (size_t start = 0; start < size_key; start += sizeof(uint64_t)) {
-    size_t end = start + sizeof(uint64_t);
-    for (size_t i = 0; i < sizeof(uint64_t); ++i) {
-      little_endian_key[start + i] = big_endian_key[end - 1 - i];
-    }
-    Slice little_endian_slice =
-        Slice(&little_endian_key[start], sizeof(uint64_t));
-    uint64_t pfx;
-    if (!GetFixed64(&little_endian_slice, &pfx)) {
-      return false;
-    }
-    prefixes.emplace_back(pfx);
-  }
-
-  uint64_t key = 0;
-  for (size_t i = 0; i < prefixes.size(); ++i) {
-    uint64_t pfx = prefixes[i];
-    key += (pfx / key_gen_ctx.weights[i]) * key_gen_ctx.window +
-           pfx % key_gen_ctx.weights[i];
-  }
-  *key_p = key;
-  return true;
-}
-
-extern inline uint64_t GetPrefixKeyCount(const std::string& prefix,
-                                         const std::string& ub) {
-  uint64_t start = 0;
-  uint64_t end = 0;
-
-  if (!GetIntVal(prefix, &start) || !GetIntVal(ub, &end)) {
-    return 0;
-  }
-
-  return end - start;
-}
-
-extern inline std::string StringToHex(const std::string& str) {
-  std::string result = "0x";
-  result.append(Slice(str).ToString(true));
-  return result;
-}
-
-// Unified output format for double parameters
-extern inline std::string FormatDoubleParam(double param) {
-  return std::to_string(param);
-}
-
-// Make sure that double parameter is a value we can reproduce by
-// re-inputting the value printed.
-extern inline void SanitizeDoubleParam(double* param) {
-  *param = std::atof(FormatDoubleParam(*param).c_str());
-}
-
-extern void PoolSizeChangeThread(void* v);
-
-extern void DbVerificationThread(void* v);
-
-extern void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz);
-
-extern int64_t GenerateOneKey(ThreadState* thread, uint64_t iteration);
-
-extern std::vector<int64_t> GenerateNKeys(ThreadState* thread, int num_keys,
-                                          uint64_t iteration);
-
-extern size_t GenerateValue(uint32_t rand, char* v, size_t max_sz);
-
-extern StressTest* CreateCfConsistencyStressTest();
-extern StressTest* CreateBatchedOpsStressTest();
-extern StressTest* CreateNonBatchedOpsStressTest();
-extern void InitializeHotKeyGenerator(double alpha);
-extern int64_t GetOneHotKeyID(double rand_seed, int64_t max_key);
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,163 +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.
-//
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_common.h"
-
-namespace rocksdb {
-void ThreadBody(void* v) {
-  ThreadState* thread = reinterpret_cast<ThreadState*>(v);
-  SharedState* shared = thread->shared;
-
-  if (shared->ShouldVerifyAtBeginning()) {
-    thread->shared->GetStressTest()->VerifyDb(thread);
-  }
-  {
-    MutexLock l(shared->GetMutex());
-    shared->IncInitialized();
-    if (shared->AllInitialized()) {
-      shared->GetCondVar()->SignalAll();
-    }
-    while (!shared->Started()) {
-      shared->GetCondVar()->Wait();
-    }
-  }
-  thread->shared->GetStressTest()->OperateDb(thread);
-
-  {
-    MutexLock l(shared->GetMutex());
-    shared->IncOperated();
-    if (shared->AllOperated()) {
-      shared->GetCondVar()->SignalAll();
-    }
-    while (!shared->VerifyStarted()) {
-      shared->GetCondVar()->Wait();
-    }
-  }
-
-  thread->shared->GetStressTest()->VerifyDb(thread);
-
-  {
-    MutexLock l(shared->GetMutex());
-    shared->IncDone();
-    if (shared->AllDone()) {
-      shared->GetCondVar()->SignalAll();
-    }
-  }
-}
-
-bool RunStressTest(StressTest* stress) {
-  stress->InitDb();
-
-  SharedState shared(db_stress_env, stress);
-  if (FLAGS_read_only) {
-    stress->InitReadonlyDb(&shared);
-  }
-
-  uint32_t n = shared.GetNumThreads();
-
-  uint64_t now = db_stress_env->NowMicros();
-  fprintf(stdout, "%s Initializing worker threads\n",
-          db_stress_env->TimeToString(now / 1000000).c_str());
-  std::vector<ThreadState*> threads(n);
-  for (uint32_t i = 0; i < n; i++) {
-    threads[i] = new ThreadState(i, &shared);
-    db_stress_env->StartThread(ThreadBody, threads[i]);
-  }
-  ThreadState bg_thread(0, &shared);
-  if (FLAGS_compaction_thread_pool_adjust_interval > 0) {
-    db_stress_env->StartThread(PoolSizeChangeThread, &bg_thread);
-  }
-  ThreadState continuous_verification_thread(0, &shared);
-  if (FLAGS_continuous_verification_interval > 0) {
-    db_stress_env->StartThread(DbVerificationThread,
-                               &continuous_verification_thread);
-  }
-
-  // Each thread goes through the following states:
-  // initializing -> wait for others to init -> read/populate/depopulate
-  // wait for others to operate -> verify -> done
-
-  {
-    MutexLock l(shared.GetMutex());
-    while (!shared.AllInitialized()) {
-      shared.GetCondVar()->Wait();
-    }
-    if (shared.ShouldVerifyAtBeginning()) {
-      if (shared.HasVerificationFailedYet()) {
-        fprintf(stderr, "Crash-recovery verification failed :(\n");
-      } else {
-        fprintf(stdout, "Crash-recovery verification passed :)\n");
-      }
-    }
-
-    now = db_stress_env->NowMicros();
-    fprintf(stdout, "%s Starting database operations\n",
-            db_stress_env->TimeToString(now / 1000000).c_str());
-
-    shared.SetStart();
-    shared.GetCondVar()->SignalAll();
-    while (!shared.AllOperated()) {
-      shared.GetCondVar()->Wait();
-    }
-
-    now = db_stress_env->NowMicros();
-    if (FLAGS_test_batches_snapshots) {
-      fprintf(stdout, "%s Limited verification already done during gets\n",
-              db_stress_env->TimeToString((uint64_t)now / 1000000).c_str());
-    } else {
-      fprintf(stdout, "%s Starting verification\n",
-              db_stress_env->TimeToString((uint64_t)now / 1000000).c_str());
-    }
-
-    shared.SetStartVerify();
-    shared.GetCondVar()->SignalAll();
-    while (!shared.AllDone()) {
-      shared.GetCondVar()->Wait();
-    }
-  }
-
-  for (unsigned int i = 1; i < n; i++) {
-    threads[0]->stats.Merge(threads[i]->stats);
-  }
-  threads[0]->stats.Report("Stress Test");
-
-  for (unsigned int i = 0; i < n; i++) {
-    delete threads[i];
-    threads[i] = nullptr;
-  }
-  now = db_stress_env->NowMicros();
-  if (!FLAGS_test_batches_snapshots && !shared.HasVerificationFailedYet()) {
-    fprintf(stdout, "%s Verification successful\n",
-            db_stress_env->TimeToString(now / 1000000).c_str());
-  }
-  stress->PrintStatistics();
-
-  if (FLAGS_compaction_thread_pool_adjust_interval > 0 ||
-      FLAGS_continuous_verification_interval > 0) {
-    MutexLock l(shared.GetMutex());
-    shared.SetShouldStopBgThread();
-    while (!shared.BgThreadsFinished()) {
-      shared.GetCondVar()->Wait();
-    }
-  }
-
-  if (!stress->VerifySecondaries()) {
-    return false;
-  }
-
-  if (shared.HasVerificationFailedYet()) {
-    fprintf(stderr, "Verification failed :(\n");
-    return false;
-  }
-  return true;
-}
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,17 +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.
-
-#ifdef GFLAGS
-#pragma once
-#include "db_stress_tool/db_stress_test_base.h"
-namespace rocksdb {
-extern void ThreadBody(void* /*thread_state*/);
-extern bool RunStressTest(StressTest*);
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,36 +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.
-
-#ifdef GFLAGS
-#pragma once
-#include "db_stress_tool/db_stress_common.h"
-
-namespace rocksdb {
-class DbStressEnvWrapper : public EnvWrapper {
- public:
-  explicit DbStressEnvWrapper(Env* t) : EnvWrapper(t) {}
-
-  Status DeleteFile(const std::string& f) override {
-    // We determine whether it is a manifest file by searching a strong,
-    // so that there will be false positive if the directory path contains the
-    // keyword but it is unlikely.
-    // Checkpoint directory needs to be exempted.
-    if (!if_preserve_all_manifests ||
-        f.find("MANIFEST-") == std::string::npos ||
-        f.find("checkpoint") != std::string::npos) {
-      return target()->DeleteFile(f);
-    }
-    return Status::OK();
-  }
-
-  // If true, all manifest files will not be delted in DeleteFile().
-  bool if_preserve_all_manifests = true;
-};
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,643 +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.
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_common.h"
-
-static bool ValidateUint32Range(const char* flagname, uint64_t value) {
-  if (value > std::numeric_limits<uint32_t>::max()) {
-    fprintf(stderr, "Invalid value for --%s: %lu, overflow\n", flagname,
-            (unsigned long)value);
-    return false;
-  }
-  return true;
-}
-
-DEFINE_uint64(seed, 2341234, "Seed for PRNG");
-static const bool FLAGS_seed_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_seed, &ValidateUint32Range);
-
-DEFINE_bool(read_only, false, "True if open DB in read-only mode during tests");
-
-DEFINE_int64(max_key, 1 * KB * KB,
-             "Max number of key/values to place in database");
-
-DEFINE_int32(max_key_len, 3, "Maximum length of a key in 8-byte units");
-
-DEFINE_string(key_len_percent_dist, "",
-              "Percentages of keys of various lengths. For example, 1,30,69 "
-              "means 1% of keys are 8 bytes, 30% are 16 bytes, and 69% are "
-              "24 bytes. If not specified, it will be evenly distributed");
-
-DEFINE_int32(key_window_scale_factor, 10,
-              "This value will be multiplied by 100 to come up with a window "
-              "size for varying the key length");
-
-DEFINE_int32(column_families, 10, "Number of column families");
-
-DEFINE_double(
-    hot_key_alpha, 0,
-    "Use Zipfian distribution to generate the key "
-    "distribution. If it is not specified, write path will use random "
-    "distribution to generate the keys. The parameter is [0, double_max]). "
-    "However, the larger alpha is, the more shewed will be. If alpha is "
-    "larger than 2, it is likely that only 1 key will be accessed. The "
-    "Recommended value is [0.8-1.5]. The distribution is also related to "
-    "max_key and total iterations of generating the hot key. ");
-
-DEFINE_string(
-    options_file, "",
-    "The path to a RocksDB options file.  If specified, then db_stress will "
-    "run with the RocksDB options in the default column family of the "
-    "specified options file. Note that, when an options file is provided, "
-    "db_stress will ignore the flag values for all options that may be passed "
-    "via options file.");
-
-DEFINE_int64(
-    active_width, 0,
-    "Number of keys in active span of the key-range at any given time. The "
-    "span begins with its left endpoint at key 0, gradually moves rightwards, "
-    "and ends with its right endpoint at max_key. If set to 0, active_width "
-    "will be sanitized to be equal to max_key.");
-
-// TODO(noetzli) Add support for single deletes
-DEFINE_bool(test_batches_snapshots, false,
-            "If set, the test uses MultiGet(), MultiPut() and MultiDelete()"
-            " which read/write/delete multiple keys in a batch. In this mode,"
-            " we do not verify db content by comparing the content with the "
-            "pre-allocated array. Instead, we do partial verification inside"
-            " MultiGet() by checking various values in a batch. Benefit of"
-            " this mode:\n"
-            "\t(a) No need to acquire mutexes during writes (less cache "
-            "flushes in multi-core leading to speed up)\n"
-            "\t(b) No long validation at the end (more speed up)\n"
-            "\t(c) Test snapshot and atomicity of batch writes");
-
-DEFINE_bool(atomic_flush, false,
-            "If set, enables atomic flush in the options.\n");
-
-DEFINE_bool(test_cf_consistency, false,
-            "If set, runs the stress test dedicated to verifying writes to "
-            "multiple column families are consistent. Setting this implies "
-            "`atomic_flush=true` is set true if `disable_wal=false`.\n");
-
-DEFINE_int32(threads, 32, "Number of concurrent threads to run.");
-
-DEFINE_int32(ttl, -1,
-             "Opens the db with this ttl value if this is not -1. "
-             "Carefully specify a large value such that verifications on "
-             "deleted values don't fail");
-
-DEFINE_int32(value_size_mult, 8,
-             "Size of value will be this number times rand_int(1,3) bytes");
-
-DEFINE_int32(compaction_readahead_size, 0, "Compaction readahead size");
-
-DEFINE_bool(enable_pipelined_write, false, "Pipeline WAL/memtable writes");
-
-DEFINE_bool(verify_before_write, false, "Verify before write");
-
-DEFINE_bool(histogram, false, "Print histogram of operation timings");
-
-DEFINE_bool(destroy_db_initially, true,
-            "Destroys the database dir before start if this is true");
-
-DEFINE_bool(verbose, false, "Verbose");
-
-DEFINE_bool(progress_reports, true,
-            "If true, db_stress will report number of finished operations");
-
-DEFINE_uint64(db_write_buffer_size, rocksdb::Options().db_write_buffer_size,
-              "Number of bytes to buffer in all memtables before compacting");
-
-DEFINE_int32(write_buffer_size,
-             static_cast<int32_t>(rocksdb::Options().write_buffer_size),
-             "Number of bytes to buffer in memtable before compacting");
-
-DEFINE_int32(max_write_buffer_number,
-             rocksdb::Options().max_write_buffer_number,
-             "The number of in-memory memtables. "
-             "Each memtable is of size FLAGS_write_buffer_size.");
-
-DEFINE_int32(min_write_buffer_number_to_merge,
-             rocksdb::Options().min_write_buffer_number_to_merge,
-             "The minimum number of write buffers that will be merged together "
-             "before writing to storage. This is cheap because it is an "
-             "in-memory merge. If this feature is not enabled, then all these "
-             "write buffers are flushed to L0 as separate files and this "
-             "increases read amplification because a get request has to check "
-             "in all of these files. Also, an in-memory merge may result in "
-             "writing less data to storage if there are duplicate records in"
-             " each of these individual write buffers.");
-
-DEFINE_int32(max_write_buffer_number_to_maintain,
-             rocksdb::Options().max_write_buffer_number_to_maintain,
-             "The total maximum number of write buffers to maintain in memory "
-             "including copies of buffers that have already been flushed. "
-             "Unlike max_write_buffer_number, this parameter does not affect "
-             "flushing. This controls the minimum amount of write history "
-             "that will be available in memory for conflict checking when "
-             "Transactions are used. If this value is too low, some "
-             "transactions may fail at commit time due to not being able to "
-             "determine whether there were any write conflicts. Setting this "
-             "value to 0 will cause write buffers to be freed immediately "
-             "after they are flushed.  If this value is set to -1, "
-             "'max_write_buffer_number' will be used.");
-
-DEFINE_int64(max_write_buffer_size_to_maintain,
-             rocksdb::Options().max_write_buffer_size_to_maintain,
-             "The total maximum size of write buffers to maintain in memory "
-             "including copies of buffers that have already been flushed. "
-             "Unlike max_write_buffer_number, this parameter does not affect "
-             "flushing. This controls the minimum amount of write history "
-             "that will be available in memory for conflict checking when "
-             "Transactions are used. If this value is too low, some "
-             "transactions may fail at commit time due to not being able to "
-             "determine whether there were any write conflicts. Setting this "
-             "value to 0 will cause write buffers to be freed immediately "
-             "after they are flushed.  If this value is set to -1, "
-             "'max_write_buffer_number' will be used.");
-
-DEFINE_double(memtable_prefix_bloom_size_ratio,
-              rocksdb::Options().memtable_prefix_bloom_size_ratio,
-              "creates prefix blooms for memtables, each with size "
-              "`write_buffer_size * memtable_prefix_bloom_size_ratio`.");
-
-DEFINE_bool(memtable_whole_key_filtering,
-            rocksdb::Options().memtable_whole_key_filtering,
-            "Enable whole key filtering in memtables.");
-
-DEFINE_int32(open_files, rocksdb::Options().max_open_files,
-             "Maximum number of files to keep open at the same time "
-             "(use default if == 0)");
-
-DEFINE_int64(compressed_cache_size, -1,
-             "Number of bytes to use as a cache of compressed data."
-             " Negative means use default settings.");
-
-DEFINE_int32(compaction_style, rocksdb::Options().compaction_style, "");
-
-DEFINE_int32(level0_file_num_compaction_trigger,
-             rocksdb::Options().level0_file_num_compaction_trigger,
-             "Level0 compaction start trigger");
-
-DEFINE_int32(level0_slowdown_writes_trigger,
-             rocksdb::Options().level0_slowdown_writes_trigger,
-             "Number of files in level-0 that will slow down writes");
-
-DEFINE_int32(level0_stop_writes_trigger,
-             rocksdb::Options().level0_stop_writes_trigger,
-             "Number of files in level-0 that will trigger put stop.");
-
-DEFINE_int32(block_size,
-             static_cast<int32_t>(rocksdb::BlockBasedTableOptions().block_size),
-             "Number of bytes in a block.");
-
-DEFINE_int32(
-    format_version,
-    static_cast<int32_t>(rocksdb::BlockBasedTableOptions().format_version),
-    "Format version of SST files.");
-
-DEFINE_int32(index_block_restart_interval,
-             rocksdb::BlockBasedTableOptions().index_block_restart_interval,
-             "Number of keys between restart points "
-             "for delta encoding of keys in index block.");
-
-DEFINE_int32(max_background_compactions,
-             rocksdb::Options().max_background_compactions,
-             "The maximum number of concurrent background compactions "
-             "that can occur in parallel.");
-
-DEFINE_int32(num_bottom_pri_threads, 0,
-             "The number of threads in the bottom-priority thread pool (used "
-             "by universal compaction only).");
-
-DEFINE_int32(compaction_thread_pool_adjust_interval, 0,
-             "The interval (in milliseconds) to adjust compaction thread pool "
-             "size. Don't change it periodically if the value is 0.");
-
-DEFINE_int32(compaction_thread_pool_variations, 2,
-             "Range of background thread pool size variations when adjusted "
-             "periodically.");
-
-DEFINE_int32(max_background_flushes, rocksdb::Options().max_background_flushes,
-             "The maximum number of concurrent background flushes "
-             "that can occur in parallel.");
-
-DEFINE_int32(universal_size_ratio, 0,
-             "The ratio of file sizes that trigger"
-             " compaction in universal style");
-
-DEFINE_int32(universal_min_merge_width, 0,
-             "The minimum number of files to "
-             "compact in universal style compaction");
-
-DEFINE_int32(universal_max_merge_width, 0,
-             "The max number of files to compact"
-             " in universal style compaction");
-
-DEFINE_int32(universal_max_size_amplification_percent, 0,
-             "The max size amplification for universal style compaction");
-
-DEFINE_int32(clear_column_family_one_in, 1000000,
-             "With a chance of 1/N, delete a column family and then recreate "
-             "it again. If N == 0, never drop/create column families. "
-             "When test_batches_snapshots is true, this flag has no effect");
-
-DEFINE_int32(get_live_files_and_wal_files_one_in, 1000000,
-             "With a chance of 1/N, call GetLiveFiles, GetSortedWalFiles "
-             "and GetCurrentWalFile to verify if it returns correctly. If "
-             "N == 0, never call the three interfaces.");
-
-DEFINE_int32(set_options_one_in, 0,
-             "With a chance of 1/N, change some random options");
-
-DEFINE_int32(set_in_place_one_in, 0,
-             "With a chance of 1/N, toggle in place support option");
-
-DEFINE_int64(cache_size, 2LL * KB * KB * KB,
-             "Number of bytes to use as a cache of uncompressed data.");
-
-DEFINE_bool(cache_index_and_filter_blocks, false,
-            "True if indexes/filters should be cached in block cache.");
-
-DEFINE_bool(use_clock_cache, false,
-            "Replace default LRU block cache with clock cache.");
-
-DEFINE_uint64(subcompactions, 1,
-              "Maximum number of subcompactions to divide L0-L1 compactions "
-              "into.");
-
-DEFINE_uint64(periodic_compaction_seconds, 1000,
-              "Files older than this value will be picked up for compaction.");
-
-DEFINE_uint64(compaction_ttl, 1000,
-              "Files older than TTL will be compacted to the next level.");
-
-DEFINE_bool(allow_concurrent_memtable_write, false,
-            "Allow multi-writers to update mem tables in parallel.");
-
-DEFINE_bool(enable_write_thread_adaptive_yield, true,
-            "Use a yielding spin loop for brief writer thread waits.");
-
-#ifndef ROCKSDB_LITE
-// BlobDB Options
-DEFINE_bool(use_blob_db, false, "Use BlobDB.");
-
-DEFINE_uint64(blob_db_min_blob_size,
-              rocksdb::blob_db::BlobDBOptions().min_blob_size,
-              "Smallest blob to store in a file. Blobs smaller than this "
-              "will be inlined with the key in the LSM tree.");
-
-DEFINE_uint64(blob_db_bytes_per_sync,
-              rocksdb::blob_db::BlobDBOptions().bytes_per_sync,
-              "Sync blob files once per every N bytes written.");
-
-DEFINE_uint64(blob_db_file_size,
-              rocksdb::blob_db::BlobDBOptions().blob_file_size,
-              "Target size of each blob file.");
-
-DEFINE_bool(blob_db_enable_gc,
-            rocksdb::blob_db::BlobDBOptions().enable_garbage_collection,
-            "Enable BlobDB garbage collection.");
-
-DEFINE_double(blob_db_gc_cutoff,
-              rocksdb::blob_db::BlobDBOptions().garbage_collection_cutoff,
-              "Cutoff ratio for BlobDB garbage collection.");
-#endif  // !ROCKSDB_LITE
-
-static const bool FLAGS_subcompactions_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_subcompactions, &ValidateUint32Range);
-
-static bool ValidateInt32Positive(const char* flagname, int32_t value) {
-  if (value < 0) {
-    fprintf(stderr, "Invalid value for --%s: %d, must be >=0\n", flagname,
-            value);
-    return false;
-  }
-  return true;
-}
-DEFINE_int32(reopen, 10, "Number of times database reopens");
-static const bool FLAGS_reopen_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_reopen, &ValidateInt32Positive);
-
-DEFINE_double(bloom_bits, 10,
-              "Bloom filter bits per key. "
-              "Negative means use default settings.");
-
-DEFINE_bool(use_block_based_filter, false,
-            "use block based filter"
-            "instead of full filter for block based table");
-
-DEFINE_bool(partition_filters, false,
-            "use partitioned filters "
-            "for block-based table");
-
-DEFINE_int32(
-    index_type,
-    static_cast<int32_t>(rocksdb::BlockBasedTableOptions::kBinarySearch),
-    "Type of block-based table index (see `enum IndexType` in table.h)");
-
-DEFINE_string(db, "", "Use the db with the following name.");
-
-DEFINE_string(secondaries_base, "",
-              "Use this path as the base path for secondary instances.");
-
-DEFINE_bool(test_secondary, false, "Test secondary instance.");
-
-DEFINE_string(
-    expected_values_path, "",
-    "File where the array of expected uint32_t values will be stored. If "
-    "provided and non-empty, the DB state will be verified against these "
-    "values after recovery. --max_key and --column_family must be kept the "
-    "same across invocations of this program that use the same "
-    "--expected_values_path.");
-
-DEFINE_bool(verify_checksum, false,
-            "Verify checksum for every block read from storage");
-
-DEFINE_bool(mmap_read, rocksdb::Options().allow_mmap_reads,
-            "Allow reads to occur via mmap-ing files");
-
-DEFINE_bool(mmap_write, rocksdb::Options().allow_mmap_writes,
-            "Allow writes to occur via mmap-ing files");
-
-DEFINE_bool(use_direct_reads, rocksdb::Options().use_direct_reads,
-            "Use O_DIRECT for reading data");
-
-DEFINE_bool(use_direct_io_for_flush_and_compaction,
-            rocksdb::Options().use_direct_io_for_flush_and_compaction,
-            "Use O_DIRECT for writing data");
-
-DEFINE_bool(statistics, false, "Create database statistics");
-
-DEFINE_bool(sync, false, "Sync all writes to disk");
-
-DEFINE_bool(use_fsync, false, "If true, issue fsync instead of fdatasync");
-
-DEFINE_int32(kill_random_test, 0,
-             "If non-zero, kill at various points in source code with "
-             "probability 1/this");
-static const bool FLAGS_kill_random_test_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_kill_random_test, &ValidateInt32Positive);
-extern int rocksdb_kill_odds;
-
-DEFINE_string(kill_prefix_blacklist, "",
-              "If non-empty, kill points with prefix in the list given will be"
-              " skipped. Items are comma-separated.");
-extern std::vector<std::string> rocksdb_kill_prefix_blacklist;
-
-DEFINE_bool(disable_wal, false, "If true, do not write WAL for write.");
-
-DEFINE_uint64(recycle_log_file_num, rocksdb::Options().recycle_log_file_num,
-              "Number of old WAL files to keep around for later recycling");
-
-DEFINE_int64(target_file_size_base, rocksdb::Options().target_file_size_base,
-             "Target level-1 file size for compaction");
-
-DEFINE_int32(target_file_size_multiplier, 1,
-             "A multiplier to compute target level-N file size (N >= 2)");
-
-DEFINE_uint64(max_bytes_for_level_base,
-              rocksdb::Options().max_bytes_for_level_base,
-              "Max bytes for level-1");
-
-DEFINE_double(max_bytes_for_level_multiplier, 2,
-              "A multiplier to compute max bytes for level-N (N >= 2)");
-
-DEFINE_int32(range_deletion_width, 10,
-             "The width of the range deletion intervals.");
-
-DEFINE_uint64(rate_limiter_bytes_per_sec, 0, "Set options.rate_limiter value.");
-
-DEFINE_bool(rate_limit_bg_reads, false,
-            "Use options.rate_limiter on compaction reads");
-
-DEFINE_bool(use_txn, false,
-            "Use TransactionDB. Currently the default write policy is "
-            "TxnDBWritePolicy::WRITE_PREPARED");
-
-DEFINE_uint64(txn_write_policy, 0,
-              "The transaction write policy. Default is "
-              "TxnDBWritePolicy::WRITE_COMMITTED. Note that this should not be "
-              "changed accross crashes.");
-
-DEFINE_bool(unordered_write, false,
-            "Turn on the unordered_write feature. This options is currently "
-            "tested only in combination with use_txn=true and "
-            "txn_write_policy=TxnDBWritePolicy::WRITE_PREPARED.");
-
-DEFINE_int32(backup_one_in, 0,
-             "If non-zero, then CreateNewBackup() will be called once for "
-             "every N operations on average.  0 indicates CreateNewBackup() "
-             "is disabled.");
-
-DEFINE_int32(checkpoint_one_in, 0,
-             "If non-zero, then CreateCheckpoint() will be called once for "
-             "every N operations on average.  0 indicates CreateCheckpoint() "
-             "is disabled.");
-
-DEFINE_int32(ingest_external_file_one_in, 0,
-             "If non-zero, then IngestExternalFile() will be called once for "
-             "every N operations on average.  0 indicates IngestExternalFile() "
-             "is disabled.");
-
-DEFINE_int32(ingest_external_file_width, 1000,
-             "The width of the ingested external files.");
-
-DEFINE_int32(compact_files_one_in, 0,
-             "If non-zero, then CompactFiles() will be called once for every N "
-             "operations on average.  0 indicates CompactFiles() is disabled.");
-
-DEFINE_int32(compact_range_one_in, 0,
-             "If non-zero, then CompactRange() will be called once for every N "
-             "operations on average.  0 indicates CompactRange() is disabled.");
-
-DEFINE_int32(flush_one_in, 0,
-             "If non-zero, then Flush() will be called once for every N ops "
-             "on average.  0 indicates calls to Flush() are disabled.");
-
-DEFINE_int32(pause_background_one_in, 0,
-             "If non-zero, then PauseBackgroundWork()+Continue will be called "
-             "once for every N ops on average.  0 disables.");
-
-DEFINE_int32(compact_range_width, 10000,
-             "The width of the ranges passed to CompactRange().");
-
-DEFINE_int32(acquire_snapshot_one_in, 0,
-             "If non-zero, then acquires a snapshot once every N operations on "
-             "average.");
-
-DEFINE_bool(compare_full_db_state_snapshot, false,
-            "If set we compare state of entire db (in one of the threads) with"
-            "each snapshot.");
-
-DEFINE_uint64(snapshot_hold_ops, 0,
-              "If non-zero, then releases snapshots N operations after they're "
-              "acquired.");
-
-DEFINE_bool(long_running_snapshots, false,
-            "If set, hold on some some snapshots for much longer time.");
-
-DEFINE_bool(use_multiget, false,
-            "If set, use the batched MultiGet API for reads");
-
-static bool ValidateInt32Percent(const char* flagname, int32_t value) {
-  if (value < 0 || value > 100) {
-    fprintf(stderr, "Invalid value for --%s: %d, 0<= pct <=100 \n", flagname,
-            value);
-    return false;
-  }
-  return true;
-}
-
-DEFINE_int32(readpercent, 10,
-             "Ratio of reads to total workload (expressed as a percentage)");
-static const bool FLAGS_readpercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_readpercent, &ValidateInt32Percent);
-
-DEFINE_int32(prefixpercent, 20,
-             "Ratio of prefix iterators to total workload (expressed as a"
-             " percentage)");
-static const bool FLAGS_prefixpercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_prefixpercent, &ValidateInt32Percent);
-
-DEFINE_int32(writepercent, 45,
-             "Ratio of writes to total workload (expressed as a percentage)");
-static const bool FLAGS_writepercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_writepercent, &ValidateInt32Percent);
-
-DEFINE_int32(delpercent, 15,
-             "Ratio of deletes to total workload (expressed as a percentage)");
-static const bool FLAGS_delpercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_delpercent, &ValidateInt32Percent);
-
-DEFINE_int32(delrangepercent, 0,
-             "Ratio of range deletions to total workload (expressed as a "
-             "percentage). Cannot be used with test_batches_snapshots");
-static const bool FLAGS_delrangepercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_delrangepercent, &ValidateInt32Percent);
-
-DEFINE_int32(nooverwritepercent, 60,
-             "Ratio of keys without overwrite to total workload (expressed as "
-             " a percentage)");
-static const bool FLAGS_nooverwritepercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_nooverwritepercent, &ValidateInt32Percent);
-
-DEFINE_int32(iterpercent, 10,
-             "Ratio of iterations to total workload"
-             " (expressed as a percentage)");
-static const bool FLAGS_iterpercent_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_iterpercent, &ValidateInt32Percent);
-
-DEFINE_uint64(num_iterations, 10, "Number of iterations per MultiIterate run");
-static const bool FLAGS_num_iterations_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_num_iterations, &ValidateUint32Range);
-
-DEFINE_string(compression_type, "snappy",
-              "Algorithm to use to compress the database");
-
-DEFINE_int32(compression_max_dict_bytes, 0,
-             "Maximum size of dictionary used to prime the compression "
-             "library.");
-
-DEFINE_int32(compression_zstd_max_train_bytes, 0,
-             "Maximum size of training data passed to zstd's dictionary "
-             "trainer.");
-
-DEFINE_string(bottommost_compression_type, "disable",
-              "Algorithm to use to compress bottommost level of the database. "
-              "\"disable\" means disabling the feature");
-
-DEFINE_string(checksum_type, "kCRC32c", "Algorithm to use to checksum blocks");
-
-DEFINE_string(hdfs, "", "Name of hdfs environment");
-
-DEFINE_string(env_uri, "",
-              "URI for env lookup. Mutually exclusive with --hdfs");
-
-DEFINE_uint64(ops_per_thread, 1200000, "Number of operations per thread.");
-static const bool FLAGS_ops_per_thread_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_ops_per_thread, &ValidateUint32Range);
-
-DEFINE_uint64(log2_keys_per_lock, 2, "Log2 of number of keys per lock");
-static const bool FLAGS_log2_keys_per_lock_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_log2_keys_per_lock, &ValidateUint32Range);
-
-DEFINE_uint64(max_manifest_file_size, 16384, "Maximum size of a MANIFEST file");
-
-DEFINE_bool(in_place_update, false, "On true, does inplace update in memtable");
-
-DEFINE_int32(secondary_catch_up_one_in, 0,
-             "If non-zero, the secondaries attemp to catch up with the primary "
-             "once for every N operations on average. 0 indicates the "
-             "secondaries do not try to catch up after open.");
-
-DEFINE_string(memtablerep, "skip_list", "");
-
-inline static bool ValidatePrefixSize(const char* flagname, int32_t value) {
-  if (value < -1 || value > 8) {
-    fprintf(stderr, "Invalid value for --%s: %d. -1 <= PrefixSize <= 8\n",
-            flagname, value);
-    return false;
-  }
-  return true;
-}
-DEFINE_int32(prefix_size, 7,
-             "Control the prefix size for HashSkipListRep. "
-             "-1 is disabled.");
-static const bool FLAGS_prefix_size_dummy __attribute__((__unused__)) =
-    RegisterFlagValidator(&FLAGS_prefix_size, &ValidatePrefixSize);
-
-DEFINE_bool(use_merge, false,
-            "On true, replaces all writes with a Merge "
-            "that behaves like a Put");
-
-DEFINE_bool(use_full_merge_v1, false,
-            "On true, use a merge operator that implement the deprecated "
-            "version of FullMerge");
-
-DEFINE_int32(sync_wal_one_in, 0,
-             "If non-zero, then SyncWAL() will be called once for every N ops "
-             "on average. 0 indicates that calls to SyncWAL() are disabled.");
-
-DEFINE_bool(avoid_unnecessary_blocking_io,
-            rocksdb::Options().avoid_unnecessary_blocking_io,
-            "If true, some expensive cleaning up operations will be moved from "
-            "user reads to high-pri background threads.");
-
-DEFINE_bool(write_dbid_to_manifest, rocksdb::Options().write_dbid_to_manifest,
-            "Write DB_ID to manifest");
-
-DEFINE_uint64(max_write_batch_group_size_bytes,
-              rocksdb::Options().max_write_batch_group_size_bytes,
-              "Max write batch group size");
-
-DEFINE_bool(level_compaction_dynamic_level_bytes,
-            rocksdb::Options().level_compaction_dynamic_level_bytes,
-            "Use dynamic level");
-
-DEFINE_int32(verify_checksum_one_in, 0,
-             "If non-zero, then DB::VerifyChecksum() will be called to do"
-             " checksum verification of all the files in the database once for"
-             " every N ops on average. 0 indicates that calls to"
-             " VerifyChecksum() are disabled.");
-DEFINE_int32(verify_db_one_in, 0,
-             "If non-zero, call VerifyDb() once for every N ops. 0 indicates "
-             "that VerifyDb() will not be called in OperateDb(). Note that "
-             "enabling this can slow down tests.");
-
-DEFINE_int32(continuous_verification_interval, 1000,
-             "While test is running, verify db every N milliseconds. 0 "
-             "disables continuous verification.");
-
-DEFINE_int32(approximate_size_one_in, 64,
-             "If non-zero, DB::GetApproximateSizes() will be called against"
-             " random key ranges.");
-#endif  // GFLAGS
@@ -1,222 +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).
-
-#ifdef GFLAGS
-#pragma once
-
-#include "rocksdb/listener.h"
-#include "util/gflags_compat.h"
-
-DECLARE_int32(compact_files_one_in);
-
-namespace rocksdb {
-class DbStressListener : public EventListener {
- public:
-  DbStressListener(const std::string& db_name,
-                   const std::vector<DbPath>& db_paths,
-                   const std::vector<ColumnFamilyDescriptor>& column_families)
-      : db_name_(db_name),
-        db_paths_(db_paths),
-        column_families_(column_families),
-        num_pending_file_creations_(0) {}
-#ifndef ROCKSDB_LITE
-  ~DbStressListener() override { assert(num_pending_file_creations_ == 0); }
-  void OnFlushCompleted(DB* /*db*/, const FlushJobInfo& info) override {
-    assert(IsValidColumnFamilyName(info.cf_name));
-    VerifyFilePath(info.file_path);
-    // pretending doing some work here
-    RandomSleep();
-  }
-
-  void OnFlushBegin(DB* /*db*/,
-                    const FlushJobInfo& /*flush_job_info*/) override {
-    RandomSleep();
-  }
-
-  void OnTableFileDeleted(const TableFileDeletionInfo& /*info*/) override {
-    RandomSleep();
-  }
-
-  void OnCompactionBegin(DB* /*db*/, const CompactionJobInfo& /*ci*/) override {
-    RandomSleep();
-  }
-
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
-    assert(IsValidColumnFamilyName(ci.cf_name));
-    assert(ci.input_files.size() + ci.output_files.size() > 0U);
-    for (const auto& file_path : ci.input_files) {
-      VerifyFilePath(file_path);
-    }
-    for (const auto& file_path : ci.output_files) {
-      VerifyFilePath(file_path);
-    }
-    // pretending doing some work here
-    RandomSleep();
-  }
-
-  void OnTableFileCreationStarted(
-      const TableFileCreationBriefInfo& /*info*/) override {
-    ++num_pending_file_creations_;
-  }
-
-  void OnTableFileCreated(const TableFileCreationInfo& info) override {
-    assert(info.db_name == db_name_);
-    assert(IsValidColumnFamilyName(info.cf_name));
-    if (info.file_size) {
-      VerifyFilePath(info.file_path);
-    }
-    assert(info.job_id > 0 || FLAGS_compact_files_one_in > 0);
-    if (info.status.ok() && info.file_size > 0) {
-      assert(info.table_properties.data_size > 0 ||
-             info.table_properties.num_range_deletions > 0);
-      assert(info.table_properties.raw_key_size > 0);
-      assert(info.table_properties.num_entries > 0);
-    }
-    --num_pending_file_creations_;
-  }
-
-  void OnMemTableSealed(const MemTableInfo& /*info*/) override {
-    RandomSleep();
-  }
-
-  void OnColumnFamilyHandleDeletionStarted(
-      ColumnFamilyHandle* /*handle*/) override {
-    RandomSleep();
-  }
-
-  void OnExternalFileIngested(
-      DB* /*db*/, const ExternalFileIngestionInfo& /*info*/) override {
-    RandomSleep();
-  }
-
-  void OnBackgroundError(BackgroundErrorReason /* reason */,
-                         Status* /* bg_error */) override {
-    RandomSleep();
-  }
-
-  void OnStallConditionsChanged(const WriteStallInfo& /*info*/) override {
-    RandomSleep();
-  }
-
-  void OnFileReadFinish(const FileOperationInfo& info) override {
-    // Even empty callback is valuable because sometimes some locks are
-    // released in order to make the callback.
-
-    // Sleep carefully here as it is a frequent operation and we don't want
-    // to slow down the tests. We always sleep when the read is large.
-    // When read is small, sleep in a small chance.
-    size_t length_read = info.length;
-    if (length_read >= 1000000 || Random::GetTLSInstance()->OneIn(1000)) {
-      RandomSleep();
-    }
-  }
-
-  void OnFileWriteFinish(const FileOperationInfo& info) override {
-    // Even empty callback is valuable because sometimes some locks are
-    // released in order to make the callback.
-
-    // Sleep carefully here as it is a frequent operation and we don't want
-    // to slow down the tests. When the write is large, always sleep.
-    // Otherwise, sleep in a relatively small chance.
-    size_t length_write = info.length;
-    if (length_write >= 1000000 || Random::GetTLSInstance()->OneIn(64)) {
-      RandomSleep();
-    }
-  }
-
-  bool ShouldBeNotifiedOnFileIO() override {
-    RandomSleep();
-    return static_cast<bool>(Random::GetTLSInstance()->OneIn(1));
-  }
-
-  void OnErrorRecoveryBegin(BackgroundErrorReason /* reason */,
-                            Status /* bg_error */,
-                            bool* /* auto_recovery */) override {
-    RandomSleep();
-  }
-
-  void OnErrorRecoveryCompleted(Status /* old_bg_error */) override {
-    RandomSleep();
-  }
-
- protected:
-  bool IsValidColumnFamilyName(const std::string& cf_name) const {
-    if (cf_name == kDefaultColumnFamilyName) {
-      return true;
-    }
-    // The column family names in the stress tests are numbers.
-    for (size_t i = 0; i < cf_name.size(); ++i) {
-      if (cf_name[i] < '0' || cf_name[i] > '9') {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  void VerifyFileDir(const std::string& file_dir) {
-#ifndef NDEBUG
-    if (db_name_ == file_dir) {
-      return;
-    }
-    for (const auto& db_path : db_paths_) {
-      if (db_path.path == file_dir) {
-        return;
-      }
-    }
-    for (auto& cf : column_families_) {
-      for (const auto& cf_path : cf.options.cf_paths) {
-        if (cf_path.path == file_dir) {
-          return;
-        }
-      }
-    }
-    assert(false);
-#else
-    (void)file_dir;
-#endif  // !NDEBUG
-  }
-
-  void VerifyFileName(const std::string& file_name) {
-#ifndef NDEBUG
-    uint64_t file_number;
-    FileType file_type;
-    bool result = ParseFileName(file_name, &file_number, &file_type);
-    assert(result);
-    assert(file_type == kTableFile);
-#else
-    (void)file_name;
-#endif  // !NDEBUG
-  }
-
-  void VerifyFilePath(const std::string& file_path) {
-#ifndef NDEBUG
-    size_t pos = file_path.find_last_of("/");
-    if (pos == std::string::npos) {
-      VerifyFileName(file_path);
-    } else {
-      if (pos > 0) {
-        VerifyFileDir(file_path.substr(0, pos));
-      }
-      VerifyFileName(file_path.substr(pos));
-    }
-#else
-    (void)file_path;
-#endif  // !NDEBUG
-  }
-
-  void RandomSleep() {
-    std::this_thread::sleep_for(
-        std::chrono::microseconds(Random::GetTLSInstance()->Uniform(5000)));
-  }
-#endif  // !ROCKSDB_LITE
-
- private:
-  std::string db_name_;
-  std::vector<DbPath> db_paths_;
-  std::vector<ColumnFamilyDescriptor> column_families_;
-  std::atomic<int> num_pending_file_creations_;
-};
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,18 +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.
-//
-
-#ifdef GFLAGS
-#include "db_stress_tool/db_stress_shared_state.h"
-
-namespace rocksdb {
-const uint32_t SharedState::UNKNOWN_SENTINEL = 0xfffffffe;
-const uint32_t SharedState::DELETION_SENTINEL = 0xffffffff;
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,390 +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
-
-#ifdef GFLAGS
-#pragma once
-
-#include "db_stress_tool/db_stress_stat.h"
-#include "util/gflags_compat.h"
-
-DECLARE_uint64(seed);
-DECLARE_int64(max_key);
-DECLARE_uint64(log2_keys_per_lock);
-DECLARE_int32(threads);
-DECLARE_int32(column_families);
-DECLARE_int32(nooverwritepercent);
-DECLARE_string(expected_values_path);
-DECLARE_int32(clear_column_family_one_in);
-DECLARE_bool(test_batches_snapshots);
-DECLARE_int32(compaction_thread_pool_adjust_interval);
-DECLARE_int32(continuous_verification_interval);
-
-namespace rocksdb {
-class StressTest;
-
-// State shared by all concurrent executions of the same benchmark.
-class SharedState {
- public:
-  // indicates a key may have any value (or not be present) as an operation on
-  // it is incomplete.
-  static const uint32_t UNKNOWN_SENTINEL;
-  // indicates a key should definitely be deleted
-  static const uint32_t DELETION_SENTINEL;
-
-  SharedState(Env* env, StressTest* stress_test)
-      : cv_(&mu_),
-        seed_(static_cast<uint32_t>(FLAGS_seed)),
-        max_key_(FLAGS_max_key),
-        log2_keys_per_lock_(static_cast<uint32_t>(FLAGS_log2_keys_per_lock)),
-        num_threads_(FLAGS_threads),
-        num_initialized_(0),
-        num_populated_(0),
-        vote_reopen_(0),
-        num_done_(0),
-        start_(false),
-        start_verify_(false),
-        num_bg_threads_(0),
-        should_stop_bg_thread_(false),
-        bg_thread_finished_(0),
-        stress_test_(stress_test),
-        verification_failure_(false),
-        should_stop_test_(false),
-        no_overwrite_ids_(FLAGS_column_families),
-        values_(nullptr),
-        printing_verification_results_(false) {
-    // Pick random keys in each column family that will not experience
-    // overwrite
-
-    fprintf(stdout, "Choosing random keys with no overwrite\n");
-    Random64 rnd(seed_);
-    // Start with the identity permutation. Subsequent iterations of
-    // for loop below will start with perm of previous for loop
-    int64_t* permutation = new int64_t[max_key_];
-    for (int64_t i = 0; i < max_key_; i++) {
-      permutation[i] = i;
-    }
-    // Now do the Knuth shuffle
-    int64_t num_no_overwrite_keys = (max_key_ * FLAGS_nooverwritepercent) / 100;
-    // Only need to figure out first num_no_overwrite_keys of permutation
-    no_overwrite_ids_.reserve(num_no_overwrite_keys);
-    for (int64_t i = 0; i < num_no_overwrite_keys; i++) {
-      int64_t rand_index = i + rnd.Next() % (max_key_ - i);
-      // Swap i and rand_index;
-      int64_t temp = permutation[i];
-      permutation[i] = permutation[rand_index];
-      permutation[rand_index] = temp;
-      // Fill no_overwrite_ids_ with the first num_no_overwrite_keys of
-      // permutation
-      no_overwrite_ids_.insert(permutation[i]);
-    }
-    delete[] permutation;
-
-    size_t expected_values_size =
-        sizeof(std::atomic<uint32_t>) * FLAGS_column_families * max_key_;
-    bool values_init_needed = false;
-    Status status;
-    if (!FLAGS_expected_values_path.empty()) {
-      if (!std::atomic<uint32_t>{}.is_lock_free()) {
-        status = Status::InvalidArgument(
-            "Cannot use --expected_values_path on platforms without lock-free "
-            "std::atomic<uint32_t>");
-      }
-      if (status.ok() && FLAGS_clear_column_family_one_in > 0) {
-        status = Status::InvalidArgument(
-            "Cannot use --expected_values_path on when "
-            "--clear_column_family_one_in is greater than zero.");
-      }
-      uint64_t size = 0;
-      if (status.ok()) {
-        status = env->GetFileSize(FLAGS_expected_values_path, &size);
-      }
-      std::unique_ptr<WritableFile> wfile;
-      if (status.ok() && size == 0) {
-        const EnvOptions soptions;
-        status =
-            env->NewWritableFile(FLAGS_expected_values_path, &wfile, soptions);
-      }
-      if (status.ok() && size == 0) {
-        std::string buf(expected_values_size, '\0');
-        status = wfile->Append(buf);
-        values_init_needed = true;
-      }
-      if (status.ok()) {
-        status = env->NewMemoryMappedFileBuffer(FLAGS_expected_values_path,
-                                                &expected_mmap_buffer_);
-      }
-      if (status.ok()) {
-        assert(expected_mmap_buffer_->GetLen() == expected_values_size);
-        values_ = static_cast<std::atomic<uint32_t>*>(
-            expected_mmap_buffer_->GetBase());
-        assert(values_ != nullptr);
-      } else {
-        fprintf(stderr, "Failed opening shared file '%s' with error: %s\n",
-                FLAGS_expected_values_path.c_str(), status.ToString().c_str());
-        assert(values_ == nullptr);
-      }
-    }
-    if (values_ == nullptr) {
-      values_allocation_.reset(
-          new std::atomic<uint32_t>[FLAGS_column_families * max_key_]);
-      values_ = &values_allocation_[0];
-      values_init_needed = true;
-    }
-    assert(values_ != nullptr);
-    if (values_init_needed) {
-      for (int i = 0; i < FLAGS_column_families; ++i) {
-        for (int j = 0; j < max_key_; ++j) {
-          Delete(i, j, false /* pending */);
-        }
-      }
-    }
-
-    if (FLAGS_test_batches_snapshots) {
-      fprintf(stdout, "No lock creation because test_batches_snapshots set\n");
-      return;
-    }
-
-    long num_locks = static_cast<long>(max_key_ >> log2_keys_per_lock_);
-    if (max_key_ & ((1 << log2_keys_per_lock_) - 1)) {
-      num_locks++;
-    }
-    fprintf(stdout, "Creating %ld locks\n", num_locks * FLAGS_column_families);
-    key_locks_.resize(FLAGS_column_families);
-
-    for (int i = 0; i < FLAGS_column_families; ++i) {
-      key_locks_[i].resize(num_locks);
-      for (auto& ptr : key_locks_[i]) {
-        ptr.reset(new port::Mutex);
-      }
-    }
-    if (FLAGS_compaction_thread_pool_adjust_interval > 0) {
-      ++num_bg_threads_;
-      fprintf(stdout, "Starting compaction_thread_pool_adjust_thread\n");
-    }
-    if (FLAGS_continuous_verification_interval > 0) {
-      ++num_bg_threads_;
-      fprintf(stdout, "Starting continuous_verification_thread\n");
-    }
-  }
-
-  ~SharedState() {}
-
-  port::Mutex* GetMutex() { return &mu_; }
-
-  port::CondVar* GetCondVar() { return &cv_; }
-
-  StressTest* GetStressTest() const { return stress_test_; }
-
-  int64_t GetMaxKey() const { return max_key_; }
-
-  uint32_t GetNumThreads() const { return num_threads_; }
-
-  void IncInitialized() { num_initialized_++; }
-
-  void IncOperated() { num_populated_++; }
-
-  void IncDone() { num_done_++; }
-
-  void IncVotedReopen() { vote_reopen_ = (vote_reopen_ + 1) % num_threads_; }
-
-  bool AllInitialized() const { return num_initialized_ >= num_threads_; }
-
-  bool AllOperated() const { return num_populated_ >= num_threads_; }
-
-  bool AllDone() const { return num_done_ >= num_threads_; }
-
-  bool AllVotedReopen() { return (vote_reopen_ == 0); }
-
-  void SetStart() { start_ = true; }
-
-  void SetStartVerify() { start_verify_ = true; }
-
-  bool Started() const { return start_; }
-
-  bool VerifyStarted() const { return start_verify_; }
-
-  void SetVerificationFailure() { verification_failure_.store(true); }
-
-  bool HasVerificationFailedYet() const { return verification_failure_.load(); }
-
-  void SetShouldStopTest() { should_stop_test_.store(true); }
-
-  bool ShouldStopTest() const { return should_stop_test_.load(); }
-
-  port::Mutex* GetMutexForKey(int cf, int64_t key) {
-    return key_locks_[cf][key >> log2_keys_per_lock_].get();
-  }
-
-  void LockColumnFamily(int cf) {
-    for (auto& mutex : key_locks_[cf]) {
-      mutex->Lock();
-    }
-  }
-
-  void UnlockColumnFamily(int cf) {
-    for (auto& mutex : key_locks_[cf]) {
-      mutex->Unlock();
-    }
-  }
-
-  std::atomic<uint32_t>& Value(int cf, int64_t key) const {
-    return values_[cf * max_key_ + key];
-  }
-
-  void ClearColumnFamily(int cf) {
-    std::fill(&Value(cf, 0 /* key */), &Value(cf + 1, 0 /* key */),
-              DELETION_SENTINEL);
-  }
-
-  // @param pending True if the update may have started but is not yet
-  //    guaranteed finished. This is useful for crash-recovery testing when the
-  //    process may crash before updating the expected values array.
-  void Put(int cf, int64_t key, uint32_t value_base, bool pending) {
-    if (!pending) {
-      // prevent expected-value update from reordering before Write
-      std::atomic_thread_fence(std::memory_order_release);
-    }
-    Value(cf, key).store(pending ? UNKNOWN_SENTINEL : value_base,
-                         std::memory_order_relaxed);
-    if (pending) {
-      // prevent Write from reordering before expected-value update
-      std::atomic_thread_fence(std::memory_order_release);
-    }
-  }
-
-  uint32_t Get(int cf, int64_t key) const { return Value(cf, key); }
-
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
-  bool Delete(int cf, int64_t key, bool pending) {
-    if (Value(cf, key) == DELETION_SENTINEL) {
-      return false;
-    }
-    Put(cf, key, DELETION_SENTINEL, pending);
-    return true;
-  }
-
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
-  bool SingleDelete(int cf, int64_t key, bool pending) {
-    return Delete(cf, key, pending);
-  }
-
-  // @param pending See comment above Put()
-  // Returns number of keys deleted by the call.
-  int DeleteRange(int cf, int64_t begin_key, int64_t end_key, bool pending) {
-    int covered = 0;
-    for (int64_t key = begin_key; key < end_key; ++key) {
-      if (Delete(cf, key, pending)) {
-        ++covered;
-      }
-    }
-    return covered;
-  }
-
-  bool AllowsOverwrite(int64_t key) {
-    return no_overwrite_ids_.find(key) == no_overwrite_ids_.end();
-  }
-
-  bool Exists(int cf, int64_t key) {
-    // UNKNOWN_SENTINEL counts as exists. That assures a key for which overwrite
-    // is disallowed can't be accidentally added a second time, in which case
-    // SingleDelete wouldn't be able to properly delete the key. It does allow
-    // the case where a SingleDelete might be added which covers nothing, but
-    // that's not a correctness issue.
-    uint32_t expected_value = Value(cf, key).load();
-    return expected_value != DELETION_SENTINEL;
-  }
-
-  uint32_t GetSeed() const { return seed_; }
-
-  void SetShouldStopBgThread() { should_stop_bg_thread_ = true; }
-
-  bool ShouldStopBgThread() { return should_stop_bg_thread_; }
-
-  void IncBgThreadsFinished() { ++bg_thread_finished_; }
-
-  bool BgThreadsFinished() const {
-    return bg_thread_finished_ == num_bg_threads_;
-  }
-
-  bool ShouldVerifyAtBeginning() const {
-    return expected_mmap_buffer_.get() != nullptr;
-  }
-
-  bool PrintingVerificationResults() {
-    bool tmp = false;
-    return !printing_verification_results_.compare_exchange_strong(
-        tmp, true, std::memory_order_relaxed);
-  }
-
-  void FinishPrintingVerificationResults() {
-    printing_verification_results_.store(false, std::memory_order_relaxed);
-  }
-
- private:
-  port::Mutex mu_;
-  port::CondVar cv_;
-  const uint32_t seed_;
-  const int64_t max_key_;
-  const uint32_t log2_keys_per_lock_;
-  const int num_threads_;
-  long num_initialized_;
-  long num_populated_;
-  long vote_reopen_;
-  long num_done_;
-  bool start_;
-  bool start_verify_;
-  int num_bg_threads_;
-  bool should_stop_bg_thread_;
-  int bg_thread_finished_;
-  StressTest* stress_test_;
-  std::atomic<bool> verification_failure_;
-  std::atomic<bool> should_stop_test_;
-
-  // Keys that should not be overwritten
-  std::unordered_set<size_t> no_overwrite_ids_;
-
-  std::atomic<uint32_t>* values_;
-  std::unique_ptr<std::atomic<uint32_t>[]> values_allocation_;
-  // Has to make it owned by a smart ptr as port::Mutex is not copyable
-  // and storing it in the container may require copying depending on the impl.
-  std::vector<std::vector<std::unique_ptr<port::Mutex>>> key_locks_;
-  std::unique_ptr<MemoryMappedFileBuffer> expected_mmap_buffer_;
-  std::atomic<bool> printing_verification_results_;
-};
-
-// Per-thread state for concurrent executions of the same benchmark.
-struct ThreadState {
-  uint32_t tid;  // 0..n-1
-  Random rand;   // Has different seeds for different threads
-  SharedState* shared;
-  Stats stats;
-  struct SnapshotState {
-    const Snapshot* snapshot;
-    // The cf from which we did a Get at this snapshot
-    int cf_at;
-    // The name of the cf at the time that we did a read
-    std::string cf_at_name;
-    // The key with which we did a Get at this snapshot
-    std::string key;
-    // The status of the Get
-    Status status;
-    // The value of the Get
-    std::string value;
-    // optional state of all keys in the db
-    std::vector<bool>* key_vec;
-  };
-  std::queue<std::pair<uint64_t, SnapshotState>> snapshot_queue;
-
-  ThreadState(uint32_t index, SharedState* _shared)
-      : tid(index), rand(1000 + index + _shared->GetSeed()), shared(_shared) {}
-};
-}  // namespace rocksdb
-#endif  // GFLAGS
@@ -1,213 +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).
-
-#pragma once
-#include <cinttypes>
-#include <memory>
-#include <queue>
-#include <unordered_set>
-
-#include "monitoring/histogram.h"
-#include "port/port.h"
-#include "rocksdb/env.h"
-#include "rocksdb/snapshot.h"
-#include "rocksdb/statistics.h"
-#include "util/gflags_compat.h"
-#include "util/random.h"
-
-DECLARE_bool(histogram);
-DECLARE_bool(progress_reports);
-
-namespace rocksdb {
-// Database statistics
-static std::shared_ptr<rocksdb::Statistics> dbstats;
-static std::shared_ptr<rocksdb::Statistics> dbstats_secondaries;
-
-class Stats {
- private:
-  uint64_t start_;
-  uint64_t finish_;
-  double seconds_;
-  long done_;
-  long gets_;
-  long prefixes_;
-  long writes_;
-  long deletes_;
-  size_t single_deletes_;
-  long iterator_size_sums_;
-  long founds_;
-  long iterations_;
-  long range_deletions_;
-  long covered_by_range_deletions_;
-  long errors_;
-  long num_compact_files_succeed_;
-  long num_compact_files_failed_;
-  int next_report_;
-  size_t bytes_;
-  uint64_t last_op_finish_;
-  HistogramImpl hist_;
-
- public:
-  Stats() {}
-
-  void Start() {
-    next_report_ = 100;
-    hist_.Clear();
-    done_ = 0;
-    gets_ = 0;
-    prefixes_ = 0;
-    writes_ = 0;
-    deletes_ = 0;
-    single_deletes_ = 0;
-    iterator_size_sums_ = 0;
-    founds_ = 0;
-    iterations_ = 0;
-    range_deletions_ = 0;
-    covered_by_range_deletions_ = 0;
-    errors_ = 0;
-    bytes_ = 0;
-    seconds_ = 0;
-    num_compact_files_succeed_ = 0;
-    num_compact_files_failed_ = 0;
-    start_ = Env::Default()->NowMicros();
-    last_op_finish_ = start_;
-    finish_ = start_;
-  }
-
-  void Merge(const Stats& other) {
-    hist_.Merge(other.hist_);
-    done_ += other.done_;
-    gets_ += other.gets_;
-    prefixes_ += other.prefixes_;
-    writes_ += other.writes_;
-    deletes_ += other.deletes_;
-    single_deletes_ += other.single_deletes_;
-    iterator_size_sums_ += other.iterator_size_sums_;
-    founds_ += other.founds_;
-    iterations_ += other.iterations_;
-    range_deletions_ += other.range_deletions_;
-    covered_by_range_deletions_ = other.covered_by_range_deletions_;
-    errors_ += other.errors_;
-    bytes_ += other.bytes_;
-    seconds_ += other.seconds_;
-    num_compact_files_succeed_ += other.num_compact_files_succeed_;
-    num_compact_files_failed_ += other.num_compact_files_failed_;
-    if (other.start_ < start_) start_ = other.start_;
-    if (other.finish_ > finish_) finish_ = other.finish_;
-  }
-
-  void Stop() {
-    finish_ = Env::Default()->NowMicros();
-    seconds_ = (finish_ - start_) * 1e-6;
-  }
-
-  void FinishedSingleOp() {
-    if (FLAGS_histogram) {
-      auto now = Env::Default()->NowMicros();
-      auto micros = now - last_op_finish_;
-      hist_.Add(micros);
-      if (micros > 20000) {
-        fprintf(stdout, "long op: %" PRIu64 " micros%30s\r", micros, "");
-      }
-      last_op_finish_ = now;
-    }
-
-    done_++;
-    if (FLAGS_progress_reports) {
-      if (done_ >= next_report_) {
-        if (next_report_ < 1000)
-          next_report_ += 100;
-        else if (next_report_ < 5000)
-          next_report_ += 500;
-        else if (next_report_ < 10000)
-          next_report_ += 1000;
-        else if (next_report_ < 50000)
-          next_report_ += 5000;
-        else if (next_report_ < 100000)
-          next_report_ += 10000;
-        else if (next_report_ < 500000)
-          next_report_ += 50000;
-        else
-          next_report_ += 100000;
-        fprintf(stdout, "... finished %ld ops%30s\r", done_, "");
-      }
-    }
-  }
-
-  void AddBytesForWrites(long nwrites, size_t nbytes) {
-    writes_ += nwrites;
-    bytes_ += nbytes;
-  }
-
-  void AddGets(long ngets, long nfounds) {
-    founds_ += nfounds;
-    gets_ += ngets;
-  }
-
-  void AddPrefixes(long nprefixes, long count) {
-    prefixes_ += nprefixes;
-    iterator_size_sums_ += count;
-  }
-
-  void AddIterations(long n) { iterations_ += n; }
-
-  void AddDeletes(long n) { deletes_ += n; }
-
-  void AddSingleDeletes(size_t n) { single_deletes_ += n; }
-
-  void AddRangeDeletions(long n) { range_deletions_ += n; }
-
-  void AddCoveredByRangeDeletions(long n) { covered_by_range_deletions_ += n; }
-
-  void AddErrors(long n) { errors_ += n; }
-
-  void AddNumCompactFilesSucceed(long n) { num_compact_files_succeed_ += n; }
-
-  void AddNumCompactFilesFailed(long n) { num_compact_files_failed_ += n; }
-
-  void Report(const char* name) {
-    std::string extra;
-    if (bytes_ < 1 || done_ < 1) {
-      fprintf(stderr, "No writes or ops?\n");
-      return;
-    }
-
-    double elapsed = (finish_ - start_) * 1e-6;
-    double bytes_mb = bytes_ / 1048576.0;
-    double rate = bytes_mb / elapsed;
-    double throughput = (double)done_ / elapsed;
-
-    fprintf(stdout, "%-12s: ", name);
-    fprintf(stdout, "%.3f micros/op %ld ops/sec\n", seconds_ * 1e6 / done_,
-            (long)throughput);
-    fprintf(stdout, "%-12s: Wrote %.2f MB (%.2f MB/sec) (%ld%% of %ld ops)\n",
-            "", bytes_mb, rate, (100 * writes_) / done_, done_);
-    fprintf(stdout, "%-12s: Wrote %ld times\n", "", writes_);
-    fprintf(stdout, "%-12s: Deleted %ld times\n", "", deletes_);
-    fprintf(stdout, "%-12s: Single deleted %" ROCKSDB_PRIszt " times\n", "",
-            single_deletes_);
-    fprintf(stdout, "%-12s: %ld read and %ld found the key\n", "", gets_,
-            founds_);
-    fprintf(stdout, "%-12s: Prefix scanned %ld times\n", "", prefixes_);
-    fprintf(stdout, "%-12s: Iterator size sum is %ld\n", "",
-            iterator_size_sums_);
-    fprintf(stdout, "%-12s: Iterated %ld times\n", "", iterations_);
-    fprintf(stdout, "%-12s: Deleted %ld key-ranges\n", "", range_deletions_);
-    fprintf(stdout, "%-12s: Range deletions covered %ld keys\n", "",
-            covered_by_range_deletions_);
-
-    fprintf(stdout, "%-12s: Got errors %ld times\n", "", errors_);
-    fprintf(stdout, "%-12s: %ld CompactFiles() succeed\n", "",
-            num_compact_files_succeed_);
-    fprintf(stdout, "%-12s: %ld CompactFiles() did not succeed\n", "",
-            num_compact_files_failed_);
-
-    if (FLAGS_histogram) {
-      fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
-    }
-    fflush(stdout);
-  }
-};
-}  // namespace rocksdb