Bump version to 5.0.1

Reduce compaction iterator status checks
Summary: seems it's expensive to check status since the underlying merge iterator checks status of all its children. so only do it when it's really necessary to get the status before invoking Next(), i.e., when we're advancing to get the first key in the next file. Closes https://github.com/facebook/rocksdb/pull/1691 Differential Revision: D4343446 Pulled By: siying fbshipit-source-id: 70ab315
2026-11-07 11:32:34 -05:00 · 2016-12-16 17:49:01 -08:00 · 2016-12-16 17:48:27 -08:00 · 2016-12-16 11:20:08 -08:00 · 2016-12-14 13:27:12 -08:00 · 2016-12-14 13:26:40 -08:00
267 changed files with 3124 additions and 7880 deletions
@@ -1,48 +1,38 @@
 sudo: false
-dist: trusty
 language: cpp
 os:
  - linux
  - osx
 compiler:
  - clang
-  - gcc
 jdk:
  - oraclejdk7
-cache:
-  - ccache
-  - apt

 addons:
   apt:
      sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6']
-      packages: ['clang-3.6' , 'g++-6', 'zlib1g-dev', 'libbz2-dev', 'libsnappy-dev', 'curl', 'libgflags-dev']
+      packages: ['clang-3.6' , 'zlib1g-dev', 'libbz2-dev', 'libsnappy-dev', 'curl', 'gflags']
 env:
  # Run all tests before db_block_cache_test (db_test, db_test2)
  - JOB_NAME=unittests ROCKSDBTESTS_END=db_block_cache_test
-  # Run all tests starting from db_block_cache_test (db_block_cache_test, ..., plain_table_db_test)
-  - JOB_NAME=unittests ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=comparator_db_test
-  # Run all tests starting from db_block_cache_test (comparator_db_test, ...)
-  - JOB_NAME=unittests ROCKSDBTESTS_START=comparator_db_test
+  # Run all tests starting from db_block_cache_test (db_block_cache_test, db_iter_test, ...)
+  - JOB_NAME=unittests ROCKSDBTESTS_START=db_block_cache_test
  # Run java tests
  - JOB_NAME=java_test
  # Build ROCKSDB_LITE
  - JOB_NAME=lite_build

-matrix:
-  exclude:
-  - os: osx
-    compiler: gcc
+install:
+  # Build gflags
+  # TODO(noetzli): Remove when gflags available through Travis
+  - pushd /tmp/ && curl -L https://github.com/gflags/gflags/archive/v2.1.2.tar.gz -o gflags.tar.gz && tar xfz gflags.tar.gz && cd gflags-2.1.2 && cmake . && make && popd

 before_script:
-  - if [[ "${TRAVIS_OS_NAME}" == 'linux' && "${CXX}" == 'clang++' ]]; then CXX=clang++-3.6; fi
-  # test one linux g++ build with g++-6
-  - if [[ "${TRAVIS_OS_NAME}" == 'linux' && "${CXX}" == 'g++' && "${JOB_NAME}" == 'unittests' ]]; then CXX=g++-6; fi
+  - if [[ "${TRAVIS_OS_NAME}" == 'linux' ]]; then CXX=clang++-3.6; fi
  # Limit the maximum number of open file descriptors to 8192
  - ulimit -n 8192 || true

 script:
-  - ${CXX} --version
  - if [[ "${JOB_NAME}" == 'unittests' ]]; then OPT=-DTRAVIS V=1 make -j4 check_some; fi
  - if [[ "${JOB_NAME}" == 'java_test' ]]; then OPT=-DTRAVIS V=1 make clean jclean rocksdbjava jtest; fi
  - if [[ "${JOB_NAME}" == 'lite_build' ]]; then OPT="-DTRAVIS -DROCKSDB_LITE" V=1 make -j4 static_lib; fi
@@ -1,5 +1,4 @@
-# Prerequisites for Windows:
-#     This cmake build is for Windows 64-bit only.
+# This cmake build is for Windows 64-bit only.
 #
 # Prerequisites:
 #     You must have at least Visual Studio 2015 Update 3. Start the Developer Command Prompt window that is a part of Visual Studio installation.
@@ -25,12 +24,6 @@
 # 5. And release mode (/m[:<N>] is also supported)
 #        msbuild rocksdb.sln /p:Configuration=Release
 #
-# Linux:
-#
-# 1. Install a recent toolchain such as devtoolset-3 if you're on a older distro. C++11 required.
-# 2. mkdir build; cd build
-# 3. cmake ..
-# 4. make -j

 cmake_minimum_required(VERSION 2.6)
 project(rocksdb)
@@ -90,21 +83,6 @@ endif()

 string(REGEX REPLACE "[^0-9a-f]+" "" GIT_SHA "${GIT_SHA}")

-if (NOT WIN32)
-  execute_process(COMMAND
-      "./build_tools/version.sh" "full"
-      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-      OUTPUT_VARIABLE ROCKSDB_VERSION
-  )
-  string(STRIP "${ROCKSDB_VERSION}" ROCKSDB_VERSION)
-  execute_process(COMMAND
-      "./build_tools/version.sh" "major"
-      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-      OUTPUT_VARIABLE ROCKSDB_VERSION_MAJOR
-  )
-  string(STRIP "${ROCKSDB_VERSION_MAJOR}" ROCKSDB_VERSION_MAJOR)
-endif()
-
 set(BUILD_VERSION_CC ${CMAKE_BINARY_DIR}/build_version.cc)
 configure_file(util/build_version.cc.in ${BUILD_VERSION_CC} @ONLY)
 add_library(build_version OBJECT ${BUILD_VERSION_CC})
@@ -118,14 +96,7 @@ else()
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-  if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
-    include(CheckCXXCompilerFlag)
-    CHECK_CXX_COMPILER_FLAG("-momit-leaf-frame-pointer" HAVE_OMIT_LEAF_FRAME_POINTER)
-    if(HAVE_OMIT_LEAF_FRAME_POINTER)
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -momit-leaf-frame-pointer")
-    endif()
-  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -momit-leaf-frame-pointer")
 endif()

 option(FAIL_ON_WARNINGS "Treat compile warnings as errors" ON)
@@ -258,9 +229,19 @@ endif()
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
 include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.7.0/fused-src)
+
 find_package(Threads REQUIRED)
+if(WIN32)
+  set(SYSTEM_LIBS ${SYSTEM_LIBS} Shlwapi.lib Rpcrt4.lib)
+else()
+  set(SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+set(ROCKSDB_LIBS rocksdblib${ARTIFACT_SUFFIX})
+set(LIBS ${ROCKSDB_LIBS} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})

 add_subdirectory(third-party/gtest-1.7.0/fused-src/gtest)
+add_subdirectory(tools)

 # Main library source code

@@ -338,7 +319,7 @@ set(SOURCES
        table/full_filter_block.cc
        table/get_context.cc
        table/iterator.cc
-        table/merging_iterator.cc
+        table/merger.cc
        table/sst_file_writer.cc
        table/meta_blocks.cc
        table/plain_table_builder.cc
@@ -377,7 +358,6 @@ set(SOURCES
        util/histogram_windowing.cc
        util/instrumented_mutex.cc
        util/iostats_context.cc
-        
        util/lru_cache.cc
        tools/ldb_cmd.cc
        tools/ldb_tool.cc
@@ -419,6 +399,7 @@ set(SOURCES
        utilities/document/json_document.cc
        utilities/document/json_document_builder.cc
        utilities/env_mirror.cc
+        utilities/env_registry.cc
        utilities/geodb/geodb_impl.cc
        utilities/leveldb_options/leveldb_options.cc
        utilities/lua/rocks_lua_compaction_filter.cc
@@ -462,7 +443,6 @@ if(WIN32)
    port/win/env_default.cc
    port/win/port_win.cc
    port/win/win_logger.cc
-    port/win/win_thread.cc
    port/win/xpress_win.cc)
 else()
  list(APPEND SOURCES
@@ -471,29 +451,6 @@ else()
    util/io_posix.cc)
 endif()

-if(WIN32)
-  set(SYSTEM_LIBS ${SYSTEM_LIBS} Shlwapi.lib Rpcrt4.lib)
-  set(ROCKSDB_STATIC_LIB rocksdblib${ARTIFACT_SUFFIX})
-  set(ROCKSDB_IMPORT_LIB rocksdb${ARTIFACT_SUFFIX})
-  set(LIBS ${ROCKSDB_STATIC_LIB} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
-else()
-  set(SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT} rt)
-  set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
-  set(ROCKSDB_SHARED_LIB rocksdb-shared)
-  set(ROCKSDB_IMPORT_LIB ${ROCKSDB_SHARED_LIB})
-  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()
-
 option(WITH_LIBRADOS "Build with librados" OFF)
 if(WITH_LIBRADOS)
  list(APPEND SOURCES
@@ -501,22 +458,22 @@ if(WITH_LIBRADOS)
  list(APPEND THIRDPARTY_LIBS rados)
 endif()

-add_library(${ROCKSDB_STATIC_LIB} STATIC ${SOURCES})
-target_link_libraries(${ROCKSDB_STATIC_LIB}
+add_library(rocksdblib${ARTIFACT_SUFFIX} STATIC ${SOURCES})
+target_link_libraries(rocksdblib${ARTIFACT_SUFFIX}
  ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})

 if(WIN32)
-  set_target_properties(${ROCKSDB_STATIC_LIB} PROPERTIES
-    COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_STATIC_LIB}.pdb")
+  set_target_properties(rocksdblib${ARTIFACT_SUFFIX} PROPERTIES
+    COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/rocksdblib${ARTIFACT_SUFFIX}.pdb")
 endif()

+add_library(rocksdb${ARTIFACT_SUFFIX} SHARED ${SOURCES})
+target_link_libraries(rocksdb${ARTIFACT_SUFFIX}
+  ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
+
 if(WIN32)
-  add_library(${ROCKSDB_IMPORT_LIB} SHARED ${SOURCES})
-  target_link_libraries(${ROCKSDB_IMPORT_LIB}
-    ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
-  set_target_properties(${ROCKSDB_IMPORT_LIB} PROPERTIES
-    COMPILE_FLAGS "-DROCKSDB_DLL -DROCKSDB_LIBRARY_EXPORTS /Fd${CMAKE_CFG_INTDIR}/${ROCKSDB_IMPORT_LIB}.pdb")
-else()
+  set_target_properties(rocksdb${ARTIFACT_SUFFIX} PROPERTIES
+    COMPILE_FLAGS "-DROCKSDB_DLL -DROCKSDB_LIBRARY_EXPORTS /Fd${CMAKE_CFG_INTDIR}/rocksdb${ARTIFACT_SUFFIX}.pdb")
 endif()

 option(WITH_JNI "build with JNI" OFF)
@@ -630,7 +587,7 @@ set(TESTS
        utilities/date_tiered/date_tiered_test.cc
        utilities/document/document_db_test.cc
        utilities/document/json_document_test.cc
-        utilities/object_registry_test.cc
+        utilities/env_registry_test.cc
        utilities/geodb/geodb_test.cc
        utilities/memory/memory_test.cc
        utilities/merge_operators/string_append/stringappend_test.cc
@@ -664,7 +621,7 @@ 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})
+  target_link_libraries(${exename}${ARTIFACT_SUFFIX} ${LIBS} gtest)
 endforeach(sourcefile ${BENCHMARKS})

 # For test util library that is build only in DEBUG mode
@@ -702,7 +659,7 @@ foreach(sourcefile ${TEST_EXES})
      EXCLUDE_FROM_DEFAULT_BUILD_MINRELEASE 1
      EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
      )
-    target_link_libraries(${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} gtest ${LIBS})
+    target_link_libraries(${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} ${LIBS} gtest)
    if(NOT "${exename}" MATCHES "db_sanity_test")
      add_test(NAME ${exename} COMMAND ${exename}${ARTIFACT_SUFFIX})
      add_dependencies(check ${exename}${ARTIFACT_SUFFIX})
@@ -722,18 +679,7 @@ foreach(sourcefile ${C_TEST_EXES})
      EXCLUDE_FROM_DEFAULT_BUILD_MINRELEASE 1
      EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
      )
-    target_link_libraries(${exename}${ARTIFACT_SUFFIX} ${ROCKSDB_IMPORT_LIB} testutillib${ARTIFACT_SUFFIX})
+    target_link_libraries(${exename}${ARTIFACT_SUFFIX} rocksdb${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX})
    add_test(NAME ${exename} COMMAND ${exename}${ARTIFACT_SUFFIX})
    add_dependencies(check ${exename}${ARTIFACT_SUFFIX})
 endforeach(sourcefile ${C_TEST_EXES})
-add_subdirectory(tools)
-
-# Installation and packaging for Linux
-if (NOT WIN32)
-install(TARGETS ${ROCKSDB_STATIC_LIB} COMPONENT devel ARCHIVE DESTINATION lib64)
-install(TARGETS ${ROCKSDB_SHARED_LIB} COMPONENT runtime DESTINATION lib64)
-install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/rocksdb/"
-        COMPONENT devel
-        DESTINATION include/rocksdb)
-set(CMAKE_INSTALL_PREFIX /usr)
-endif()
@@ -1,11 +1,4 @@
 # RocksDB default options change log
-## Unreleased
-* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files.
-
-## 5.0 (11/17/2016)
-* Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default
-* Options.level0_stop_writes_trigger default value changes from 24 to 32.
-
 ## 4.8.0 (5/2/2016)
 * options.max_open_files changes from 5000 to -1. It improves performance, but users need to set file descriptor limit to be large enough and watch memory usage for index and bloom filters.
 * options.base_background_compactions changes from max_background_compactions to 1. When users set higher max_background_compactions but the write throughput is not high, the writes are less spiky to disks.
@@ -1,31 +1,4 @@
 # Rocksdb Change Log
-## Unreleased
-
-## 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 explict provide one.
-* Change the default of delayed slowdown value to 16MB/s and further increase the L0 stop condition to 36 files.
-* (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.
-
-### New Features
-* Added new overloaded function GetApproximateSizes that allows to specify if memtable stats should be computed only without computing SST files' stats approximations.
-* Added new function GetApproximateMemTableStats that approximates both number of records and size of memtables.
-
-### Bug Fixes
-* RangeSync() should work if ROCKSDB_FALLOCATE_PRESENT is not set
-* Fix wrong results in a data race case in Get()
-* Some fixes related to 2PC.
-* Fix several bugs in Direct I/O supports.
-
-## 5.1.0 (01/13/2017)
-* Support dynamically change `delete_obsolete_files_period_micros` option via SetDBOptions().
-* Added EventListener::OnExternalFileIngested which will be called when IngestExternalFile() add a file successfully.
-* BackupEngine::Open and BackupEngineReadOnly::Open now always return error statuses matching those of the backup Env.
-
-### Bug Fixes
-* Fix the bug that if 2PC is enabled, checkpoints may loss some recent transactions.
-* When file copying is needed when creating checkpoints or bulk loading files, fsync the file after the file copying.
-
 ## 5.0.0 (11/17/2016)
 ### Public API Change
 * Options::max_bytes_for_level_multiplier is now a double along with all getters and setters.
@@ -6,9 +6,6 @@

 #-----------------------------------------------

-BASH_EXISTS := $(shell which bash)
-SHELL := $(shell which bash)
-
 CLEAN_FILES = # deliberately empty, so we can append below.
 CFLAGS += ${EXTRA_CFLAGS}
 CXXFLAGS += ${EXTRA_CXXFLAGS}
@@ -140,7 +137,7 @@ endif

 AM_LINK = $(AM_V_CCLD)$(CXX) $^ $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
 # detect what platform we're building on
-dummy := $(shell (export ROCKSDB_ROOT="$(CURDIR)"; export PORTABLE="$(PORTABLE)"; "$(CURDIR)/build_tools/build_detect_platform" "$(CURDIR)/make_config.mk"))
+dummy := $(shell (export ROCKSDB_ROOT="$(CURDIR)"; "$(CURDIR)/build_tools/build_detect_platform" "$(CURDIR)/make_config.mk"))
 # this file is generated by the previous line to set build flags and sources
 include make_config.mk
 CLEAN_FILES += make_config.mk
@@ -223,6 +220,11 @@ default: all
 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
  -Wno-unused-parameter

+ifndef DISABLE_WARNING_AS_ERROR
+	WARNING_FLAGS += -Werror
+endif
+
+
 ifdef LUA_PATH

 ifndef LUA_INCLUDE
@@ -319,7 +321,6 @@ TESTS = \
 	db_properties_test \
 	db_table_properties_test \
 	autovector_test \
-	cleanable_test \
 	column_family_test \
 	table_properties_collector_test \
 	arena_test \
@@ -414,9 +415,7 @@ TESTS = \
 	persistent_cache_test \
 	statistics_test \
 	lua_test \
-	range_del_aggregator_test \
 	lru_cache_test \
-	object_registry_test \

 PARALLEL_TEST = \
 	backupable_db_test \
@@ -1081,7 +1080,7 @@ env_librados_test: utilities/env_librados_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_V_CCLD)$(CXX) $^ $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
 endif

-object_registry_test: utilities/object_registry_test.o $(LIBOBJECTS) $(TESTHARNESS)
+env_registry_test: utilities/env_registry_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 ttl_test: utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS)
@@ -1144,9 +1143,6 @@ full_filter_block_test: table/full_filter_block_test.o $(LIBOBJECTS) $(TESTHARNE
 log_test: db/log_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-cleanable_test: table/cleanable_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 table_test: table/table_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1309,9 +1305,6 @@ lru_cache_test: util/lru_cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
 lua_test: utilities/lua/rocks_lua_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-range_del_aggregator_test: db/range_del_aggregator_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 #-------------------------------------------------
 # make install related stuff
 INSTALL_PATH ?= /usr/local
@@ -1386,11 +1379,11 @@ ifeq ($(PLATFORM), OS_SOLARIS)
 endif

 libz.a:
-	-rm -rf zlib-1.2.10
-	curl -O -L http://zlib.net/zlib-1.2.10.tar.gz
-	tar xvzf zlib-1.2.10.tar.gz
-	cd zlib-1.2.10 && CFLAGS='-fPIC' ./configure --static && make
-	cp zlib-1.2.10/libz.a .
+	-rm -rf zlib-1.2.8
+	curl -O -L http://zlib.net/zlib-1.2.8.tar.gz
+	tar xvzf zlib-1.2.8.tar.gz
+	cd zlib-1.2.8 && CFLAGS='-fPIC' ./configure --static && make
+	cp zlib-1.2.8/libz.a .

 libbz2.a:
 	-rm -rf bzip2-1.0.6
@@ -1420,7 +1413,7 @@ java_static_libobjects = $(patsubst %,jls/%,$(LIBOBJECTS))
 CLEAN_FILES += jls

 JAVA_STATIC_FLAGS = -DZLIB -DBZIP2 -DSNAPPY -DLZ4
-JAVA_STATIC_INCLUDES = -I./zlib-1.2.10 -I./bzip2-1.0.6 -I./snappy-1.1.3 -I./lz4-r127/lib
+JAVA_STATIC_INCLUDES = -I./zlib-1.2.8 -I./bzip2-1.0.6 -I./snappy-1.1.3 -I./lz4-r127/lib

 $(java_static_libobjects): jls/%.o: %.cc libz.a libbz2.a libsnappy.a liblz4.a
 	$(AM_V_CC)mkdir -p $(@D) && $(CXX) $(CXXFLAGS) $(JAVA_STATIC_FLAGS) $(JAVA_STATIC_INCLUDES) -fPIC -c $< -o $@ $(COVERAGEFLAGS)
@@ -7,7 +7,7 @@ At Facebook, we use RocksDB as storage engines in multiple data management servi
 2. MongoRocks -- https://github.com/mongodb-partners/mongo-rocks
 3. ZippyDB --  Facebook's distributed key-value store with Paxos-style replication, built on top of RocksDB.[*] https://www.youtube.com/watch?v=DfiN7pG0D0khtt
 4. Laser -- Laser is a high query throughput, low (millisecond) latency, key-value storage service built on top of RocksDB.[*]
-4. Dragon -- a distributed graph query engine. https://code.facebook.com/posts/1737605303120405/dragon-a-distributed-graph-query-engine/
+4. Dragan -- a distributed graph query engine. https://code.facebook.com/posts/1737605303120405/dragon-a-distributed-graph-query-engine/
 5. Stylus -- a low-level stream processing framework writtenin C++.[*]

 [*] https://research.facebook.com/publications/realtime-data-processing-at-facebook/
@@ -64,7 +64,7 @@ Pinterest's Object Retrieval System uses RocksDB for storage: https://www.youtub
 quasardb uses a heavily tuned RocksDB as its persistence layer.

 ## Netflix
-[Netflix](http://techblog.netflix.com/2016/05/application-data-caching-using-ssds.html) Netflix uses RocksDB on AWS EC2 instances with local SSD drives to cache application data.
+[Netflix](http://techblog.netflix.com/2016/05/application-data-caching-using-ssds.html) uses RocksDB on spinning disks to cache application data.

 ## TiKV
 [TiKV](https://github.com/pingcap/tikv) is a GEO-replicated, high-performance, distributed, transactional key-value database. TiKV is powered by Rust and Raft. TiKV uses RocksDB as its persistence layer.
@@ -74,9 +74,3 @@ quasardb uses a heavily tuned RocksDB as its persistence layer.

 ## Dgraph
 [Dgraph](https://github.com/dgraph-io/dgraph) is an open-source, scalable, distributed, low latency, high throughput Graph database .They use RocksDB to store state locally on a machine.
-
-## Uber
-[Uber](http://eng.uber.com/cherami/) uses RocksDB as a durable and and scalable task queue.
-
-## 360 Pika
-[360](http://www.360.cn/) [Pika](https://github.com/Qihoo360/pika) is a nosql compatible with redis. With the huge amount of data stored, redis may suffer for a capacity bottleneck, and pika was born for solving it. It has widely been widely used in many company
@@ -11,7 +11,7 @@ build:
  verbosity: minimal
 test:
 test_script:
- ps: build_tools\run_ci_db_test.ps1 -Run db_test2 -Concurrency 8
- ps: build_tools\run_ci_db_test.ps1 -Run db_test -Concurrency 8
- ps: build_tools\run_ci_db_test.ps1 -Run env_test,env_basic_test -Concurrency 2
+- ps: build_tools\run_ci_db_test.ps1 -EnableRerun -Run db_test2 -Concurrency 8
+- ps: build_tools\run_ci_db_test.ps1 -EnableRerun -Run db_test -Exclude DBTest.GroupCommitTest -Concurrency 10
+- ps: build_tools\run_ci_db_test.ps1 -Run env_test -Concurrency 1

@@ -9,13 +9,6 @@ require('RocksDBCommonHelper.php');
 define("DIFF_COMMAND", "diff");

 class FacebookArcanistConfiguration extends ArcanistConfiguration {
-  public function getCustomArgumentsForCommand($command) {
-    if ($command == "land") {
-      return array(
-          'async' => array('help' => 'Just to make tools happy'));
-    }
-    return array();
-  }

  public function didRunWorkflow($command,
                                 ArcanistWorkflow $workflow,
@@ -9,13 +9,6 @@ require('RocksDBCommonHelper.php');
 define("DIFF_COMMAND", "diff");

 class FacebookArcanistConfiguration extends ArcanistConfiguration {
-  public function getCustomArgumentsForCommand($command) {
-    if ($command == "land") {
-      return array(
-          'async' => array('help' => 'Just to make tools happy'));
-    }
-    return array();
-  }

  public function didRunWorkflow($command,
                                 ArcanistBaseWorkflow $workflow,
@@ -21,7 +21,7 @@ function postURL($diffID, $url) {
  assert(is_numeric($diffID));
  assert(strlen($url) > 0);

-  $cmd = 'echo \'{"diff_id": ' . $diffID . ', '
+  $cmd = 'echo \'{"diff_id": "' . $diffID . '", '
         . '"name":"click here for sandcastle tests for D' . $diffID . '", '
         . '"link":"' . $url . '"}\' | '
         . 'arc call-conduit '
@@ -35,7 +35,7 @@ function buildUpdateTestStatusCmd($diffID, $test, $status) {
  assert(strlen($test) > 0);
  assert(strlen($status) > 0);

-  $cmd = 'echo \'{"diff_id": ' . $diffID . ', '
+  $cmd = 'echo \'{"diff_id": "' . $diffID . '", '
         . '"name":"' . $test . '", '
         . '"result":"' . $status . '"}\' | '
         . 'arc call-conduit '
@@ -51,7 +51,12 @@ if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
    FBCODE_BUILD="true"
    # If we're compiling with TSAN we need pic build
    PIC_BUILD=$COMPILE_WITH_TSAN
-    source "$PWD/build_tools/fbcode_config.sh"
+    if [ -z "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
+      source "$PWD/build_tools/fbcode_config.sh"
+    else
+      # we need this to build with MySQL. Don't use for other purposes.
+      source "$PWD/build_tools/fbcode_config4.8.1.sh"
+    fi
 fi

 # Delete existing output, if it exists
@@ -8,7 +8,7 @@
 # for a certain interval.
 #

-SRC_GIT_REPO=/data/git/rocksdb-public
+SRC_GIT_REPO=/data/git/rocksdb
 error=0

 function log {
@@ -1,19 +1,18 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/7.x/centos7-native/b2ef2b6
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/963d9aeda70cc4779885b1277484fe7544a04e3e/9.0.0/platform007/9e92d53/
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/7.x/platform007/5620abc
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.26/platform007/f259413
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/platform007/ca4da3d
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/platform007/ca4da3d
-BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/platform007/ca4da3d
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/platform007/ca4da3d
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/platform007/15a3614
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/platform007/ca4da3d
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/platform007/c26c002
-NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/platform007/ca4da3d
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/platform007/6f3e0a9
-TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/platform007/ca4da3d
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/fb/platform007/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/ab9f09bba370e7066cafd4eb59752db93f2e8312/2.29.1/platform007/15a3614
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/platform007/ca4da3d
-LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.3.4/platform007/5007832
+GCC_BASE=/mnt/gvfs/third-party2/gcc/cf7d14c625ce30bae1a4661c2319c5a283e4dd22/4.9.x/centos6-native/108cf83
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/8598c375b0e94e1448182eb3df034704144a838d/stable/centos6-native/3f16ddd
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/d6e0a7da6faba45f5e5b1638f9edd7afc2f34e7d/4.9.x/gcc-4.9-glibc-2.20/024dbc3
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/d282e6e8f3d20f4e40a516834847bdc038e07973/2.20/gcc-4.9-glibc-2.20/500e281
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/8c38a4c1e52b4c2cc8a9cdc31b9c947ed7dbfcb4/1.1.3/gcc-4.9-glibc-2.20/e9936bf
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/0882df3713c7a84f15abe368dc004581f20b39d7/1.2.8/gcc-5-glibc-2.23/9bc6787
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/740325875f6729f42d28deaa2147b0854f3a347e/1.0.6/gcc-5-glibc-2.23/9bc6787
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0e790b441e2d9acd68d51e1d2e028f88c6a79ddf/r131/gcc-5-glibc-2.23/9bc6787
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/9455f75ff7f4831dc9fda02a6a0f8c68922fad8f/1.0.0/gcc-5-glibc-2.23/9bc6787
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/f001a51b2854957676d07306ef3abf67186b5c8b/2.1.1/gcc-4.8.1-glibc-2.17/c3f970a
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/fc8a13ca1fffa4d0765c716c5a0b49f0c107518f/master/gcc-5-glibc-2.23/1c32b4b
+NUMA_BASE=/mnt/gvfs/third-party2/numa/17c514c4d102a25ca15f4558be564eeed76f4b6a/2.0.8/gcc-5-glibc-2.23/9bc6787
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/ad576de2a1ea560c4d3434304f0fc4e079bede42/trunk/gcc-5-glibc-2.23/b1847cb
+TBB_BASE=/mnt/gvfs/third-party2/tbb/9d9a554877d0c5bef330fe818ab7178806dd316a/4.0_update2/gcc-4.9-glibc-2.20/e9936bf
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/7c111ff27e0c466235163f00f280a9d617c3d2ec/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/b7fd454c4b10c6a81015d4524ed06cdeab558490/2.26/centos6-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d7f4d4d86674a57668e3a96f76f0e17dd0eb8765/3.10.0/gcc-4.9-glibc-2.20/e9936bf
+LUA_BASE=/mnt/gvfs/third-party2/lua/61e4abf5813bbc39bc4f548757ccfcadde175a48/5.2.3/gcc-4.9-glibc-2.20/690f0d7
@@ -13,7 +13,7 @@ source "$BASEDIR/dependencies.sh"
 CFLAGS=""

 # libgcc
-LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/7.3.0"
+LIBGCC_INCLUDE="$LIBGCC_BASE/include"
 LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"

 # glibc
@@ -43,15 +43,11 @@ if test -z $PIC_BUILD; then
  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
  CFLAGS+=" -DLZ4"
-fi

-ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
-if test -z $PIC_BUILD; then
+  ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
-else
-  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
+  CFLAGS+=" -DZSTD"
 fi
-CFLAGS+=" -DZSTD"

 # location of gflags headers and libraries
 GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
@@ -60,7 +56,7 @@ if test -z $PIC_BUILD; then
 else
  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
 fi
-CFLAGS+=" -DGFLAGS=gflags"
+CFLAGS+=" -DGFLAGS=google"

 # location of jemalloc
 JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
@@ -108,8 +104,8 @@ if [ -z "$USE_CLANG" ]; then
  CXX="$GCC_BASE/bin/g++"

  CFLAGS+=" -B$BINUTILS/gold"
-  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
  JEMALLOC=1
 else
  # clang
@@ -120,8 +116,8 @@ else
  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"

  CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib"
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x "
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.9.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.9.x/x86_64-facebook-linux "
  CFLAGS+=" -isystem $GLIBC_INCLUDE"
  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
  CFLAGS+=" -isystem $CLANG_INCLUDE"
@@ -132,14 +128,13 @@ 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"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE"
 CXXFLAGS+=" $CFLAGS"

 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+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-4.9-glibc-2.20/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
-EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform007/lib"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/gcc-4.9-glibc-2.20/lib"
 # required by libtbb
 EXEC_LDFLAGS+=" -ldl"

@@ -149,4 +144,12 @@ EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GF

 VALGRIND_VER="$VALGRIND_BASE/bin/"

-export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD 
+LUA_PATH="$LUA_BASE"
+
+if test -z $PIC_BUILD; then
+  LUA_LIB=" $LUA_PATH/lib/liblua.a"
+else
+  LUA_LIB=" $LUA_PATH/lib/liblua_pic.a"
+fi
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -11,8 +11,7 @@ if ! which $CLANG_FORMAT_DIFF &> /dev/null
 then
  echo "You didn't have clang-format-diff.py available in your computer!"
  echo "You can download it by running: "
-  echo "    curl --location http://goo.gl/iUW1u2 -o ${CLANG_FORMAT_DIFF}"
-  echo "and move ${CLANG_FORMAT_DIFF} to some directory within PATH=${PATH}"
+  echo "    curl http://goo.gl/iUW1u2"
  exit 128
 fi

@@ -51,15 +50,14 @@ fi
 set -e

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

 # If there's no uncommitted changes, we assume user are doing post-commit
-# format check, in which case we'll check the modified lines since last commit
-# from master. Otherwise, we'll check format of the uncommitted code only.
+# format check, in which case we'll check the modified lines from latest commit.
+# Otherwise, we'll check format of the uncommitted code only.
 if [ -z "$uncommitted_code" ]
 then
  # Check the format of last commit
-  diffs=$(git diff -U0 $LAST_MASTER^ | $CLANG_FORMAT_DIFF -p 1)
+  diffs=$(git diff -U0 HEAD^ | $CLANG_FORMAT_DIFF -p 1)
 else
  # Check the format of uncommitted lines,
  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1)
@@ -99,12 +97,7 @@ then
 fi

 # Do in-place format adjustment.
-if [ -z "$uncommitted_code" ]
-then
-  git diff -U0 $LAST_MASTER^ | $CLANG_FORMAT_DIFF -i -p 1
-else
-  git diff -U0 HEAD^ | $CLANG_FORMAT_DIFF -i -p 1
-fi
+git diff -U0 HEAD^ | $CLANG_FORMAT_DIFF -i -p 1
 echo "Files reformatted!"

 # Amend to last commit if user do the post-commit format check
@@ -1,4 +1,4 @@
-#!/usr/local/fbcode/gcc-4.9-glibc-2.20-fb/bin/python2.7
+#!/usr/local/fbcode/gcc-4.8.1-glibc-2.17-fb/bin/python2.7

 from __future__ import absolute_import
 from __future__ import division
@@ -1,9 +1,8 @@
 #!/bin/sh
 if [ "$#" = "0" ]; then
-  echo "Usage: $0 major|minor|patch|full"
+  echo "Usage: $0 major|minor|patch"
  exit 1
 fi
-
 if [ "$1" = "major" ]; then
  cat include/rocksdb/version.h  | grep MAJOR | head -n1 | awk '{print $3}'
 fi
@@ -13,10 +12,3 @@ fi
 if [ "$1" = "patch" ]; then
  cat include/rocksdb/version.h  | grep PATCH | head -n1 | awk '{print $3}'
 fi
-if [ "$1" = "full" ]; then
-  awk '/#define ROCKSDB/ { env[$2] = $3 }
-       END { printf "%s.%s.%s\n", env["ROCKSDB_MAJOR"],
-                                  env["ROCKSDB_MINOR"],
-                                  env["ROCKSDB_PATCH"] }'  \
-      include/rocksdb/version.h
-fi
@@ -271,7 +271,7 @@ TEST_F(AutoRollLoggerTest, LogFlushWhileRolling) {
  AutoRollLogger* auto_roll_logger =
      dynamic_cast<AutoRollLogger*>(logger.get());
  ASSERT_TRUE(auto_roll_logger);
-  rocksdb::port::Thread flush_thread;
+  std::thread flush_thread;

  // Notes:
  // (1) Need to pin the old logger before beginning the roll, as rolling grabs
@@ -293,7 +293,7 @@ TEST_F(AutoRollLoggerTest, LogFlushWhileRolling) {
       {"AutoRollLogger::Flush:PinnedLogger", "PosixLogger::Flush:Begin2"}});
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  flush_thread = port::Thread ([&]() { auto_roll_logger->Flush(); });
+  flush_thread = std::thread([&]() { auto_roll_logger->Flush(); });
  TEST_SYNC_POINT(
      "AutoRollLoggerTest::LogFlushWhileRolling:PreRollAndPostThreadInit");
  RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size,
@@ -104,9 +104,6 @@ struct rocksdb_readoptions_t {
 };
 struct rocksdb_writeoptions_t    { WriteOptions      rep; };
 struct rocksdb_options_t         { Options           rep; };
-struct rocksdb_compactoptions_t {
-  CompactRangeOptions rep;
-};
 struct rocksdb_block_based_table_options_t  { BlockBasedTableOptions rep; };
 struct rocksdb_cuckoo_table_options_t  { CuckooTableOptions rep; };
 struct rocksdb_seqfile_t         { SequentialFile*   rep; };
@@ -448,11 +445,7 @@ rocksdb_backup_engine_t* rocksdb_backup_engine_open(
    const rocksdb_options_t* options, const char* path, char** errptr) {
  BackupEngine* be;
  if (SaveError(errptr, BackupEngine::Open(options->rep.env,
-                                           BackupableDBOptions(path,
-                                                               nullptr,
-                                                               true,
-                                                               options->rep.info_log.get()),
-                                           &be))) {
+                                           BackupableDBOptions(path), &be))) {
    return nullptr;
  }
  rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
@@ -901,17 +894,6 @@ char* rocksdb_property_value(
  }
 }

-int rocksdb_property_int(
-    rocksdb_t* db,
-    const char* propname,
-    uint64_t *out_val) {
-  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
 char* rocksdb_property_value_cf(
    rocksdb_t* db,
    rocksdb_column_family_handle_t* column_family,
@@ -994,30 +976,6 @@ void rocksdb_compact_range_cf(
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
 }

-void rocksdb_compact_range_opt(rocksdb_t* db, rocksdb_compactoptions_t* opt,
-                               const char* start_key, size_t start_key_len,
-                               const char* limit_key, size_t limit_key_len) {
-  Slice a, b;
-  db->rep->CompactRange(
-      opt->rep,
-      // Pass nullptr Slice if corresponding "const char*" is nullptr
-      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
-      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
-}
-
-void rocksdb_compact_range_cf_opt(rocksdb_t* db,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  rocksdb_compactoptions_t* opt,
-                                  const char* start_key, size_t start_key_len,
-                                  const char* limit_key, size_t limit_key_len) {
-  Slice a, b;
-  db->rep->CompactRange(
-      opt->rep, column_family->rep,
-      // Pass nullptr Slice if corresponding "const char*" is nullptr
-      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
-      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
-}
-
 void rocksdb_flush(
    rocksdb_t* db,
    const rocksdb_flushoptions_t* options,
@@ -1265,53 +1223,6 @@ void rocksdb_writebatch_deletev_cf(
  b->rep.Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
 }

-void rocksdb_writebatch_delete_range(rocksdb_writebatch_t* b,
-                                     const char* start_key,
-                                     size_t start_key_len, const char* end_key,
-                                     size_t end_key_len) {
-  b->rep.DeleteRange(Slice(start_key, start_key_len),
-                     Slice(end_key, end_key_len));
-}
-
-void rocksdb_writebatch_delete_range_cf(
-    rocksdb_writebatch_t* b, 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) {
-  b->rep.DeleteRange(column_family->rep, Slice(start_key, start_key_len),
-                     Slice(end_key, end_key_len));
-}
-
-void rocksdb_writebatch_delete_rangev(rocksdb_writebatch_t* b, int num_keys,
-                                      const char* const* start_keys_list,
-                                      const size_t* start_keys_list_sizes,
-                                      const char* const* end_keys_list,
-                                      const size_t* end_keys_list_sizes) {
-  std::vector<Slice> start_key_slices(num_keys);
-  std::vector<Slice> end_key_slices(num_keys);
-  for (int i = 0; i < num_keys; i++) {
-    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
-    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
-  }
-  b->rep.DeleteRange(SliceParts(start_key_slices.data(), num_keys),
-                     SliceParts(end_key_slices.data(), num_keys));
-}
-
-void rocksdb_writebatch_delete_rangev_cf(
-    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* start_keys_list,
-    const size_t* start_keys_list_sizes, const char* const* end_keys_list,
-    const size_t* end_keys_list_sizes) {
-  std::vector<Slice> start_key_slices(num_keys);
-  std::vector<Slice> end_key_slices(num_keys);
-  for (int i = 0; i < num_keys; i++) {
-    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
-    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
-  }
-  b->rep.DeleteRange(column_family->rep,
-                     SliceParts(start_key_slices.data(), num_keys),
-                     SliceParts(end_key_slices.data(), num_keys));
-}
-
 void rocksdb_writebatch_put_log_data(
    rocksdb_writebatch_t* b,
    const char* blob, size_t len) {
@@ -1347,15 +1258,6 @@ const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) {
  return b->rep.Data().c_str();
 }

-void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) {
-  b->rep.SetSavePoint();
-}
-
-void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b,
-                                               char** errptr) {
-  SaveError(errptr, b->rep.RollbackToSavePoint());
-}
-
 rocksdb_block_based_table_options_t*
 rocksdb_block_based_options_create() {
  return new rocksdb_block_based_table_options_t;
@@ -1498,14 +1400,6 @@ void rocksdb_options_set_cuckoo_table_factory(
  }
 }

-void rocksdb_set_options(
-    rocksdb_t* db, int count, const char* const keys[], const char* const values[], char** errptr) {
-        std::unordered_map<std::string, std::string> options_map;
-        for (int i=0; i<count; i++)
-            options_map[keys[i]] = values[i];
-        SaveError(errptr,
-            db->rep->SetOptions(options_map));
-    }

 rocksdb_options_t* rocksdb_options_create() {
  return new rocksdb_options_t;
@@ -1751,14 +1645,9 @@ void rocksdb_options_set_manifest_preallocation_size(
 void rocksdb_options_set_purge_redundant_kvs_while_flush(rocksdb_options_t* opt,
                                                         unsigned char v) {}

-void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt,
-                                          unsigned char v) {
-  opt->rep.use_direct_reads = v;
-}
-
-void rocksdb_options_set_use_direct_writes(rocksdb_options_t* opt,
-                                           unsigned char v) {
-  opt->rep.use_direct_writes = v;
+void rocksdb_options_set_allow_os_buffer(rocksdb_options_t* opt,
+                                         unsigned char v) {
+  opt->rep.allow_os_buffer = v;
 }

 void rocksdb_options_set_allow_mmap_reads(
@@ -1890,14 +1779,6 @@ void rocksdb_options_set_hard_rate_limit(rocksdb_options_t* opt, double v) {
  opt->rep.hard_rate_limit = v;
 }

-void rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
-  opt->rep.soft_pending_compaction_bytes_limit = v;
-}
-
-void rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
-  opt->rep.hard_pending_compaction_bytes_limit = v;
-}
-
 void rocksdb_options_set_rate_limit_delay_max_milliseconds(
    rocksdb_options_t* opt, unsigned int v) {
  opt->rep.rate_limit_delay_max_milliseconds = v;
@@ -1927,10 +1808,6 @@ void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, int di
  opt->rep.disable_auto_compactions = disable;
 }

-void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, int v) {
-  opt->rep.optimize_filters_for_hits = v;
-}
-
 void rocksdb_options_set_delete_obsolete_files_period_micros(
    rocksdb_options_t* opt, uint64_t v) {
  opt->rep.delete_obsolete_files_period_micros = v;
@@ -2049,7 +1926,7 @@ rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(

 void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
  if (limiter->rep) {
-    delete limiter->rep;
+	delete limiter->rep;
  }
  delete limiter;
 }
@@ -2291,16 +2168,6 @@ void rocksdb_readoptions_set_readahead_size(
  opt->rep.readahead_size = v;
 }

-void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt,
-                                      unsigned char v) {
-  opt->rep.pin_data = v;
-}
-
-void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt,
-                                              unsigned char v) {
-  opt->rep.total_order_seek = v;
-}
-
 rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
  return new rocksdb_writeoptions_t;
 }
@@ -2318,28 +2185,6 @@ void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, int disable)
  opt->rep.disableWAL = disable;
 }

-rocksdb_compactoptions_t* rocksdb_compactoptions_create() {
-  return new rocksdb_compactoptions_t;
-}
-
-void rocksdb_compactoptions_destroy(rocksdb_compactoptions_t* opt) {
-  delete opt;
-}
-
-void rocksdb_compactoptions_set_exclusive_manual_compaction(
-    rocksdb_compactoptions_t* opt, unsigned char v) {
-  opt->rep.exclusive_manual_compaction = v;
-}
-
-void rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t* opt,
-                                             unsigned char v) {
-  opt->rep.change_level = v;
-}
-
-void rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t* opt,
-                                             int n) {
-  opt->rep.target_level = n;
-}

 rocksdb_flushoptions_t* rocksdb_flushoptions_create() {
  return new rocksdb_flushoptions_t;
@@ -2368,14 +2213,6 @@ void rocksdb_cache_set_capacity(rocksdb_cache_t* cache, size_t capacity) {
  cache->rep->SetCapacity(capacity);
 }

-size_t rocksdb_cache_get_usage(rocksdb_cache_t* cache) {
-  return cache->rep->GetUsage();
-}
-
-size_t rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache) {
-  return cache->rep->GetPinnedUsage();
-}
-
 rocksdb_env_t* rocksdb_create_default_env() {
  rocksdb_env_t* result = new rocksdb_env_t;
  result->rep = Env::Default();
@@ -288,7 +288,6 @@ int main(int argc, char** argv) {
  rocksdb_cache_t* cache;
  rocksdb_env_t* env;
  rocksdb_options_t* options;
-  rocksdb_compactoptions_t* coptions;
  rocksdb_block_based_table_options_t* table_options;
  rocksdb_readoptions_t* roptions;
  rocksdb_writeoptions_t* woptions;
@@ -340,14 +339,11 @@ int main(int argc, char** argv) {

  roptions = rocksdb_readoptions_create();
  rocksdb_readoptions_set_verify_checksums(roptions, 1);
-  rocksdb_readoptions_set_fill_cache(roptions, 1);
+  rocksdb_readoptions_set_fill_cache(roptions, 0);

  woptions = rocksdb_writeoptions_create();
  rocksdb_writeoptions_set_sync(woptions, 1);

-  coptions = rocksdb_compactoptions_create();
-  rocksdb_compactoptions_set_exclusive_manual_compaction(coptions, 1);
-
  StartPhase("destroy");
  rocksdb_destroy_db(options, dbname, &err);
  Free(&err);
@@ -429,95 +425,6 @@ int main(int argc, char** argv) {
  rocksdb_compact_range(db, "a", 1, "z", 1);
  CheckGet(db, roptions, "foo", "hello");

-  StartPhase("compactallopt");
-  rocksdb_compact_range_opt(db, coptions, NULL, 0, NULL, 0);
-  CheckGet(db, roptions, "foo", "hello");
-
-  StartPhase("compactrangeopt");
-  rocksdb_compact_range_opt(db, coptions, "a", 1, "z", 1);
-  CheckGet(db, roptions, "foo", "hello");
-
-  // Simple check cache usage
-  StartPhase("cache_usage");
-  {
-    rocksdb_readoptions_set_pin_data(roptions, 1);
-    rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);
-    rocksdb_iter_seek(iter, "foo", 3);
-
-    size_t usage = rocksdb_cache_get_usage(cache);
-    CheckCondition(usage > 0);
-
-    size_t pin_usage = rocksdb_cache_get_pinned_usage(cache);
-    CheckCondition(pin_usage > 0);
-
-    rocksdb_iter_next(iter);
-    rocksdb_iter_destroy(iter);
-    rocksdb_readoptions_set_pin_data(roptions, 0);
-  }
-
-  StartPhase("addfile");
-  {
-    rocksdb_envoptions_t* env_opt = rocksdb_envoptions_create();
-    rocksdb_options_t* io_options = rocksdb_options_create();
-    rocksdb_sstfilewriter_t* writer =
-        rocksdb_sstfilewriter_create(env_opt, io_options);
-
-    unlink(sstfilename);
-    rocksdb_sstfilewriter_open(writer, sstfilename, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk1", 5, "v1", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk2", 5, "v2", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk3", 5, "v3", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_finish(writer, &err);
-    CheckNoError(err);
-
-    rocksdb_ingestexternalfileoptions_t* ing_opt =
-        rocksdb_ingestexternalfileoptions_create();
-    const char* file_list[1] = {sstfilename};
-    rocksdb_ingest_external_file(db, file_list, 1, ing_opt, &err);
-    CheckNoError(err);
-    CheckGet(db, roptions, "sstk1", "v1");
-    CheckGet(db, roptions, "sstk2", "v2");
-    CheckGet(db, roptions, "sstk3", "v3");
-
-    unlink(sstfilename);
-    rocksdb_sstfilewriter_open(writer, sstfilename, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk2", 5, "v4", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk22", 6, "v5", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_add(writer, "sstk3", 5, "v6", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_finish(writer, &err);
-    CheckNoError(err);
-
-    rocksdb_ingest_external_file(db, file_list, 1, ing_opt, &err);
-    CheckNoError(err);
-    CheckGet(db, roptions, "sstk1", "v1");
-    CheckGet(db, roptions, "sstk2", "v4");
-    CheckGet(db, roptions, "sstk22", "v5");
-    CheckGet(db, roptions, "sstk3", "v6");
-
-    rocksdb_ingestexternalfileoptions_destroy(ing_opt);
-    rocksdb_sstfilewriter_destroy(writer);
-    rocksdb_options_destroy(io_options);
-    rocksdb_envoptions_destroy(env_opt);
-
-    // Delete all keys we just ingested
-    rocksdb_delete(db, woptions, "sstk1", 5, &err);
-    CheckNoError(err);
-    rocksdb_delete(db, woptions, "sstk2", 5, &err);
-    CheckNoError(err);
-    rocksdb_delete(db, woptions, "sstk22", 6, &err);
-    CheckNoError(err);
-    rocksdb_delete(db, woptions, "sstk3", 5, &err);
-    CheckNoError(err);
-  }
-
  StartPhase("writebatch");
  {
    rocksdb_writebatch_t* wb = rocksdb_writebatch_create();
@@ -534,24 +441,6 @@ int main(int argc, char** argv) {
    int pos = 0;
    rocksdb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
    CheckCondition(pos == 3);
-    rocksdb_writebatch_clear(wb);
-    rocksdb_writebatch_put(wb, "bar", 3, "b", 1);
-    rocksdb_writebatch_put(wb, "bay", 3, "d", 1);
-    rocksdb_writebatch_delete_range(wb, "bar", 3, "bay", 3);
-    rocksdb_write(db, woptions, wb, &err);
-    CheckNoError(err);
-    CheckGet(db, roptions, "bar", NULL);
-    CheckGet(db, roptions, "bay", "d");
-    rocksdb_writebatch_clear(wb);
-    const char* start_list[1] = {"bay"};
-    const size_t start_sizes[1] = {3};
-    const char* end_list[1] = {"baz"};
-    const size_t end_sizes[1] = {3};
-    rocksdb_writebatch_delete_rangev(wb, 1, start_list, start_sizes, end_list,
-                                     end_sizes);
-    rocksdb_write(db, woptions, wb, &err);
-    CheckNoError(err);
-    CheckGet(db, roptions, "bay", NULL);
    rocksdb_writebatch_destroy(wb);
  }

@@ -573,23 +462,6 @@ int main(int argc, char** argv) {
    rocksdb_writebatch_destroy(wb);
  }

-  StartPhase("writebatch_savepoint");
-  {
-    rocksdb_writebatch_t* wb = rocksdb_writebatch_create();
-    rocksdb_writebatch_set_save_point(wb);
-    const char* k_list[2] = {"z", "ap"};
-    const size_t k_sizes[2] = {1, 2};
-    const char* v_list[3] = {"x", "y", "z"};
-    const size_t v_sizes[3] = {1, 1, 1};
-    rocksdb_writebatch_putv(wb, 2, k_list, k_sizes, 3, v_list, v_sizes);
-    rocksdb_writebatch_rollback_to_save_point(wb, &err);
-    CheckNoError(err);
-    rocksdb_write(db, woptions, wb, &err);
-    CheckNoError(err);
-    CheckGet(db, roptions, "zap", NULL);
-    rocksdb_writebatch_destroy(wb);
-  }
-
  StartPhase("writebatch_rep");
  {
    rocksdb_writebatch_t* wb1 = rocksdb_writebatch_create();
@@ -707,6 +579,59 @@ int main(int argc, char** argv) {
    rocksdb_release_snapshot(db, snap);
  }

+  StartPhase("addfile");
+  {
+    rocksdb_envoptions_t* env_opt = rocksdb_envoptions_create();
+    rocksdb_options_t* io_options = rocksdb_options_create();
+    rocksdb_sstfilewriter_t* writer =
+        rocksdb_sstfilewriter_create(env_opt, io_options);
+
+    unlink(sstfilename);
+    rocksdb_sstfilewriter_open(writer, sstfilename, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk1", 5, "v1", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk2", 5, "v2", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk3", 5, "v3", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_finish(writer, &err);
+    CheckNoError(err);
+
+    rocksdb_ingestexternalfileoptions_t* ing_opt =
+        rocksdb_ingestexternalfileoptions_create();
+    const char* file_list[1] = {sstfilename};
+    rocksdb_ingest_external_file(db, file_list, 1, ing_opt, &err);
+    CheckNoError(err);
+    CheckGet(db, roptions, "sstk1", "v1");
+    CheckGet(db, roptions, "sstk2", "v2");
+    CheckGet(db, roptions, "sstk3", "v3");
+
+    unlink(sstfilename);
+    rocksdb_sstfilewriter_open(writer, sstfilename, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk2", 5, "v4", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk22", 6, "v5", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_add(writer, "sstk3", 5, "v6", 2, &err);
+    CheckNoError(err);
+    rocksdb_sstfilewriter_finish(writer, &err);
+    CheckNoError(err);
+
+    rocksdb_ingest_external_file(db, file_list, 1, ing_opt, &err);
+    CheckNoError(err);
+    CheckGet(db, roptions, "sstk1", "v1");
+    CheckGet(db, roptions, "sstk2", "v4");
+    CheckGet(db, roptions, "sstk22", "v5");
+    CheckGet(db, roptions, "sstk3", "v6");
+
+    rocksdb_ingestexternalfileoptions_destroy(ing_opt);
+    rocksdb_sstfilewriter_destroy(writer);
+    rocksdb_options_destroy(io_options);
+    rocksdb_envoptions_destroy(env_opt);
+  }
+
  StartPhase("repair");
  {
    // If we do not compact here, then the lazy deletion of
@@ -840,9 +765,9 @@ int main(int argc, char** argv) {
  {
    rocksdb_close(db);
    rocksdb_destroy_db(options, dbname, &err);
-    CheckNoError(err);
+    CheckNoError(err)

-    rocksdb_options_t* db_options = rocksdb_options_create();
+        rocksdb_options_t* db_options = rocksdb_options_create();
    rocksdb_options_set_create_if_missing(db_options, 1);
    db = rocksdb_open(db_options, dbname, &err);
    CheckNoError(err)
@@ -1006,19 +931,6 @@ int main(int argc, char** argv) {
    CheckNoError(err);
    rocksdb_iter_destroy(iter);

-    rocksdb_readoptions_set_total_order_seek(roptions, 1);
-    iter = rocksdb_create_iterator(db, roptions);
-    CheckCondition(!rocksdb_iter_valid(iter));
-
-    rocksdb_iter_seek(iter, "ba", 2);
-    rocksdb_iter_get_error(iter, &err);
-    CheckNoError(err);
-    CheckCondition(rocksdb_iter_valid(iter));
-    CheckIter(iter, "bar1", "bar");
-
-    rocksdb_iter_destroy(iter);
-    rocksdb_readoptions_set_total_order_seek(roptions, 0);
-
    rocksdb_close(db);
    rocksdb_destroy_db(options, dbname, &err);
  }
@@ -1128,7 +1040,6 @@ int main(int argc, char** argv) {
  rocksdb_block_based_options_destroy(table_options);
  rocksdb_readoptions_destroy(roptions);
  rocksdb_writeoptions_destroy(woptions);
-  rocksdb_compactoptions_destroy(coptions);
  rocksdb_cache_destroy(cache);
  rocksdb_comparator_destroy(cmp);
  rocksdb_env_destroy(env);
@@ -370,8 +370,7 @@ ColumnFamilyData::ColumnFamilyData(
      column_family_set_(column_family_set),
      pending_flush_(false),
      pending_compaction_(false),
-      prev_compaction_needed_bytes_(0),
-      allow_2pc_(db_options.allow_2pc) {
+      prev_compaction_needed_bytes_(0) {
  Ref();

  // Convert user defined table properties collector factories to internal ones.
@@ -493,25 +492,6 @@ ColumnFamilyOptions ColumnFamilyData::GetLatestCFOptions() const {
  return BuildColumnFamilyOptions(initial_cf_options_, mutable_cf_options_);
 }

-uint64_t ColumnFamilyData::OldestLogToKeep() {
-  auto current_log = GetLogNumber();
-
-  if (allow_2pc_) {
-    auto imm_prep_log = imm()->GetMinLogContainingPrepSection();
-    auto mem_prep_log = mem()->GetMinLogContainingPrepSection();
-
-    if (imm_prep_log > 0 && imm_prep_log < current_log) {
-      current_log = imm_prep_log;
-    }
-
-    if (mem_prep_log > 0 && mem_prep_log < current_log) {
-      current_log = mem_prep_log;
-    }
-  }
-
-  return current_log;
-}
-
 const double kIncSlowdownRatio = 0.8;
 const double kDecSlowdownRatio = 1 / kIncSlowdownRatio;
 const double kNearStopSlowdownRatio = 0.6;
@@ -239,9 +239,6 @@ class ColumnFamilyData {
  uint64_t GetTotalSstFilesSize() const;  // REQUIRE: DB mutex held
  void SetMemtable(MemTable* new_mem) { mem_ = new_mem; }

-  // calculate the oldest log needed for the durability of this column family
-  uint64_t OldestLogToKeep();
-
  // See Memtable constructor for explanation of earliest_seq param.
  MemTable* ConstructNewMemtable(const MutableCFOptions& mutable_cf_options,
                                 SequenceNumber earliest_seq);
@@ -407,9 +404,6 @@ class ColumnFamilyData {
  bool pending_compaction_;

  uint64_t prev_compaction_needed_bytes_;
-
-  // if the database was opened with 2pc enabled
-  bool allow_2pc_;
 };

 // ColumnFamilySet has interesting thread-safety requirements
@@ -15,7 +15,6 @@

 #include "db/db_impl.h"
 #include "db/db_test_util.h"
-#include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
@@ -1269,7 +1268,7 @@ TEST_F(ColumnFamilyTest, MultipleManualCompactions) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  threads.emplace_back([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
@@ -1377,7 +1376,7 @@ TEST_F(ColumnFamilyTest, AutomaticAndManualCompactions) {
    WaitForFlush(2);
    AssertFilesPerLevel(ToString(i + 1), 2);
  }
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -1465,7 +1464,7 @@ TEST_F(ColumnFamilyTest, ManualAndAutomaticCompactions) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -1558,7 +1557,7 @@ TEST_F(ColumnFamilyTest, SameCFManualManualCompactions) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = true;
    ASSERT_OK(
@@ -1578,7 +1577,7 @@ TEST_F(ColumnFamilyTest, SameCFManualManualCompactions) {
                        1);
  }

-  rocksdb::port::Thread threads1([&] {
+  std::thread threads1([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -1656,7 +1655,7 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactions) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -1748,7 +1747,7 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactionsLevel) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -1859,7 +1858,7 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticConflict) {
      });

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    CompactRangeOptions compact_options;
    compact_options.exclusive_manual_compaction = false;
    ASSERT_OK(
@@ -2324,7 +2323,7 @@ TEST_F(ColumnFamilyTest, FlushAndDropRaceCondition) {
  int kKeysNum = 10000;
  PutRandomData(1, kKeysNum, 100);

-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  threads.emplace_back([&] { ASSERT_OK(db_->DropColumnFamily(handles_[1])); });

  sleeping_task.WakeUp();
@@ -2425,7 +2424,7 @@ TEST_F(ColumnFamilyTest, CreateAndDropRace) {

  // Start a thread that will drop the first column family
  // and its comparator
-  rocksdb::port::Thread drop_cf_thread(DropSingleColumnFamily, this, 1, &comparators);
+  std::thread drop_cf_thread(DropSingleColumnFamily, this, 1, &comparators);

  DropColumnFamilies({2});

@@ -3079,7 +3078,7 @@ TEST_F(ColumnFamilyTest, LogSyncConflictFlush) {

  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  rocksdb::port::Thread thread([&] { db_->SyncWAL(); });
+  std::thread thread([&] { db_->SyncWAL(); });

  TEST_SYNC_POINT("ColumnFamilyTest::LogSyncConflictFlush:1");
  Flush(1);
@@ -11,7 +11,6 @@
 #include <vector>

 #include "db/db_impl.h"
-#include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "util/string_util.h"
@@ -232,7 +231,7 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Start compacting files.
-  rocksdb::port::Thread compaction_thread(
+  std::thread compaction_thread(
      [&] { EXPECT_OK(db->CompactFiles(CompactionOptions(), l0_files, 1)); });

  // In the meantime flush another file.
@@ -254,61 +253,6 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
  delete db;
 }

-TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
-  class FilterWithGet : public CompactionFilter {
-   public:
-    virtual bool Filter(int level, const Slice& key, const Slice& value,
-                        std::string* new_value,
-                        bool* value_changed) const override {
-      if (db_ == nullptr) {
-        return true;
-      }
-      std::string res;
-      db_->Get(ReadOptions(), "", &res);
-      return true;
-    }
-
-    void SetDB(DB* db) {
-      db_ = db;
-    }
-
-    virtual const char* Name() const override { return "FilterWithGet"; }
-
-   private:
-    DB* db_;
-  };
-
-
-  std::shared_ptr<FilterWithGet> cf(new FilterWithGet());
-
-  Options options;
-  options.create_if_missing = true;
-  options.compaction_filter = cf.get();
-
-  DB* db = nullptr;
-  DestroyDB(db_name_, options);
-  Status s = DB::Open(options, db_name_, &db);
-  ASSERT_OK(s);
-
-  cf->SetDB(db);
-
-  // Write one L0 file
-  db->Put(WriteOptions(), "K1", "V1");
-  db->Flush(FlushOptions());
-
-  // Compact all L0 files using CompactFiles
-  rocksdb::ColumnFamilyMetaData meta;
-  db->GetColumnFamilyMetaData(&meta);
-  for (auto& file : meta.levels[0].files) {
-    std::string fname = file.db_path + "/" + file.name;
-    ASSERT_OK(
-        db->CompactFiles(rocksdb::CompactionOptions(), {fname}, 0));
-  }
-
-
-  delete db;
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -76,13 +76,6 @@ class CompactedDBImpl : public DBImpl {
                       ColumnFamilyHandle* column_family) override {
    return Status::NotSupported("Not supported in compacted db mode.");
  }
-  using DB::IngestExternalFile;
-  virtual Status IngestExternalFile(
-      ColumnFamilyHandle* column_family,
-      const std::vector<std::string>& external_files,
-      const IngestExternalFileOptions& ingestion_options) override {
-    return Status::NotSupported("Not supported in compacted db mode.");
-  }

 private:
  friend class DB;
@@ -150,8 +150,7 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
                       bool _manual_compaction, double _score,
                       bool _deletion_compaction,
                       CompactionReason _compaction_reason)
-    : input_vstorage_(vstorage),
-      start_level_(_inputs[0].level),
+    : start_level_(_inputs[0].level),
      output_level_(_output_level),
      max_output_file_size_(_target_file_size),
      max_compaction_bytes_(_max_compaction_bytes),
@@ -205,10 +204,11 @@ Compaction::~Compaction() {
 }

 bool Compaction::InputCompressionMatchesOutput() const {
-  int base_level = input_vstorage_->base_level();
-  bool matches = (GetCompressionType(immutable_cf_options_, input_vstorage_,
-                                     mutable_cf_options_, start_level_,
-                                     base_level) == output_compression_);
+  VersionStorageInfo* vstorage = input_version_->storage_info();
+  int base_level = vstorage->base_level();
+  bool matches =
+      (GetCompressionType(*cfd_->ioptions(), vstorage, mutable_cf_options_,
+                          start_level_, base_level) == output_compression_);
  if (matches) {
    TEST_SYNC_POINT("Compaction::InputCompressionMatchesOutput:Matches");
    return true;
@@ -225,14 +225,15 @@ bool Compaction::IsTrivialMove() const {
  // filter to be applied to that level, and thus cannot be a trivial move.

  // Check if start level have files with overlapping ranges
-  if (start_level_ == 0 && input_vstorage_->level0_non_overlapping() == false) {
+  if (start_level_ == 0 &&
+      input_version_->storage_info()->level0_non_overlapping() == false) {
    // We cannot move files from L0 to L1 if the files are overlapping
    return false;
  }

  if (is_manual_compaction_ &&
-      (immutable_cf_options_.compaction_filter != nullptr ||
-       immutable_cf_options_.compaction_filter_factory != nullptr)) {
+      (cfd_->ioptions()->compaction_filter != nullptr ||
+       cfd_->ioptions()->compaction_filter_factory != nullptr)) {
    // This is a manual compaction and we have a compaction filter that should
    // be executed, we cannot do a trivial move
    return false;
@@ -240,34 +241,15 @@ bool Compaction::IsTrivialMove() const {

  // Used in universal compaction, where trivial move can be done if the
  // input files are non overlapping
-  if ((immutable_cf_options_.compaction_options_universal.allow_trivial_move) &&
+  if ((cfd_->ioptions()->compaction_options_universal.allow_trivial_move) &&
      (output_level_ != 0)) {
    return is_trivial_move_;
  }

-  if (!(start_level_ != output_level_ && num_input_levels() == 1 &&
+  return (start_level_ != output_level_ && num_input_levels() == 1 &&
          input(0, 0)->fd.GetPathId() == output_path_id() &&
-          InputCompressionMatchesOutput())) {
-    return false;
-  }
-
-  // assert inputs_.size() == 1
-
-  for (const auto& file : inputs_.front().files) {
-    std::vector<FileMetaData*> file_grand_parents;
-    if (output_level_ + 1 >= number_levels_) {
-      continue;
-    }
-    input_vstorage_->GetOverlappingInputs(output_level_ + 1, &file->smallest,
-                                          &file->largest, &file_grand_parents);
-    const auto compaction_size =
-        file->fd.GetFileSize() + TotalFileSize(file_grand_parents);
-    if (compaction_size > max_compaction_bytes_) {
-      return false;
-    }
-  }
-
-  return true;
+          InputCompressionMatchesOutput() &&
+          TotalFileSize(grandparents_) <= max_compaction_bytes_);
 }

 void Compaction::AddInputDeletions(VersionEdit* out_edit) {
@@ -290,7 +272,8 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
  // Maybe use binary search to find right entry instead of linear search?
  const Comparator* user_cmp = cfd_->user_comparator();
  for (int lvl = output_level_ + 1; lvl < number_levels_; lvl++) {
-    const std::vector<FileMetaData*>& files = input_vstorage_->LevelFiles(lvl);
+    const std::vector<FileMetaData*>& files =
+        input_version_->storage_info()->LevelFiles(lvl);
    for (; level_ptrs->at(lvl) < files.size(); level_ptrs->at(lvl)++) {
      auto* f = files[level_ptrs->at(lvl)];
      if (user_cmp->Compare(user_key, f->largest.user_key()) <= 0) {
@@ -362,7 +345,7 @@ void Compaction::ReleaseCompactionFiles(Status status) {

 void Compaction::ResetNextCompactionIndex() {
  assert(input_version_ != nullptr);
-  input_vstorage_->ResetNextCompactionIndex(start_level_);
+  input_version_->storage_info()->ResetNextCompactionIndex(start_level_);
 }

 namespace {
@@ -258,8 +258,6 @@ class Compaction {
  static bool IsFullCompaction(VersionStorageInfo* vstorage,
                               const std::vector<CompactionInputFiles>& inputs);

-  VersionStorageInfo* input_vstorage_;
-
  const int start_level_;    // the lowest level to be compacted
  const int output_level_;  // levels to which output files are stored
  uint64_t max_output_file_size_;
@@ -16,14 +16,14 @@ CompactionIterator::CompactionIterator(
    SequenceNumber earliest_write_conflict_snapshot, Env* env,
    bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
    const Compaction* compaction, const CompactionFilter* compaction_filter,
-    const std::atomic<bool>* shutting_down)
+    LogBuffer* log_buffer)
    : CompactionIterator(
          input, cmp, merge_helper, last_sequence, snapshots,
          earliest_write_conflict_snapshot, env, expect_valid_internal_key,
          range_del_agg,
          std::unique_ptr<CompactionProxy>(
              compaction ? new CompactionProxy(compaction) : nullptr),
-          compaction_filter, shutting_down) {}
+          compaction_filter, log_buffer) {}

 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
@@ -31,8 +31,7 @@ CompactionIterator::CompactionIterator(
    SequenceNumber earliest_write_conflict_snapshot, Env* env,
    bool expect_valid_internal_key, RangeDelAggregator* range_del_agg,
    std::unique_ptr<CompactionProxy> compaction,
-    const CompactionFilter* compaction_filter,
-    const std::atomic<bool>* shutting_down)
+    const CompactionFilter* compaction_filter, LogBuffer* log_buffer)
    : input_(input),
      cmp_(cmp),
      merge_helper_(merge_helper),
@@ -43,7 +42,7 @@ CompactionIterator::CompactionIterator(
      range_del_agg_(range_del_agg),
      compaction_(std::move(compaction)),
      compaction_filter_(compaction_filter),
-      shutting_down_(shutting_down),
+      log_buffer_(log_buffer),
      merge_out_iter_(merge_helper_) {
  assert(compaction_filter_ == nullptr || compaction_ != nullptr);
  bottommost_level_ =
@@ -137,7 +136,7 @@ void CompactionIterator::NextFromInput() {
  at_next_ = false;
  valid_ = false;

-  while (!valid_ && input_->Valid() && !IsShuttingDown()) {
+  while (!valid_ && input_->Valid()) {
    key_ = input_->key();
    value_ = input_->value();
    iter_stats_.num_input_records++;
@@ -218,8 +217,7 @@ void CompactionIterator::NextFromInput() {
        }

        if (filter == CompactionFilter::Decision::kRemove) {
-          // convert the current key to a delete; key_ is pointing into
-          // current_key_ at this point, so updating current_key_ updates key()
+          // convert the current key to a delete
          ikey_.type = kTypeDeletion;
          current_key_.UpdateInternalKey(ikey_.sequence, kTypeDeletion);
          // no value associated with delete
@@ -424,6 +422,7 @@ void CompactionIterator::NextFromInput() {
      input_->Next();
    } else if (ikey_.type == kTypeMerge) {
      if (!merge_helper_->HasOperator()) {
+        LogToBuffer(log_buffer_, "Options::merge_operator is null.");
        status_ = Status::InvalidArgument(
            "merge_operator is not properly initialized.");
        return;
@@ -434,14 +433,11 @@ void CompactionIterator::NextFromInput() {
      // have hit (A)
      // We encapsulate the merge related state machine in a different
      // object to minimize change to the existing flow.
-      Status s = merge_helper_->MergeUntil(input_, range_del_agg_,
-                                           prev_snapshot, bottommost_level_);
+      merge_helper_->MergeUntil(input_, range_del_agg_, prev_snapshot,
+                                bottommost_level_);
      merge_out_iter_.SeekToFirst();

-      if (!s.ok() && !s.IsMergeInProgress()) {
-        status_ = s;
-        return;
-      } else if (merge_out_iter_.Valid()) {
+      if (merge_out_iter_.Valid()) {
        // NOTE: key, value, and ikey_ refer to old entries.
        //       These will be correctly set below.
        key_ = merge_out_iter_.key();
@@ -470,8 +466,7 @@ void CompactionIterator::NextFromInput() {
    } else {
      // 1. new user key -OR-
      // 2. different snapshot stripe
-      bool should_delete = range_del_agg_->ShouldDelete(
-          key_, RangeDelAggregator::RangePositioningMode::kForwardTraversal);
+      bool should_delete = range_del_agg_->ShouldDelete(key_);
      if (should_delete) {
        ++iter_stats_.num_record_drop_hidden;
        ++iter_stats_.num_record_drop_range_del;
@@ -485,10 +480,6 @@ void CompactionIterator::NextFromInput() {
      input_->Seek(skip_until);
    }
  }
-
-  if (!valid_ && IsShuttingDown()) {
-    status_ = Status::ShutdownInProgress();
-  }
 }

 void CompactionIterator::PrepareOutput() {
@@ -17,6 +17,7 @@
 #include "db/pinned_iterators_manager.h"
 #include "db/range_del_aggregator.h"
 #include "rocksdb/compaction_filter.h"
+#include "util/log_buffer.h"

 namespace rocksdb {

@@ -60,7 +61,7 @@ class CompactionIterator {
                     RangeDelAggregator* range_del_agg,
                     const Compaction* compaction = nullptr,
                     const CompactionFilter* compaction_filter = nullptr,
-                     const std::atomic<bool>* shutting_down = nullptr);
+                     LogBuffer* log_buffer = nullptr);

  // Constructor with custom CompactionProxy, used for tests.
  CompactionIterator(InternalIterator* input, const Comparator* cmp,
@@ -71,7 +72,7 @@ class CompactionIterator {
                     RangeDelAggregator* range_del_agg,
                     std::unique_ptr<CompactionProxy> compaction,
                     const CompactionFilter* compaction_filter = nullptr,
-                     const std::atomic<bool>* shutting_down = nullptr);
+                     LogBuffer* log_buffer = nullptr);

  ~CompactionIterator();

@@ -124,7 +125,7 @@ class CompactionIterator {
  RangeDelAggregator* range_del_agg_;
  std::unique_ptr<CompactionProxy> compaction_;
  const CompactionFilter* compaction_filter_;
-  const std::atomic<bool>* shutting_down_;
+  LogBuffer* log_buffer_;
  bool bottommost_level_;
  bool valid_ = false;
  bool visible_at_tip_;
@@ -179,10 +180,5 @@ class CompactionIterator {
  // is in or beyond the last file checked during the previous call
  std::vector<size_t> level_ptrs_;
  CompactionIterationStats iter_stats_;
-
-  bool IsShuttingDown() {
-    // This is a best-effort facility, so memory_order_relaxed is sufficient.
-    return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
-  }
 };
 }  // namespace rocksdb
@@ -8,70 +8,11 @@
 #include <string>
 #include <vector>

-#include "port/port.h"
 #include "util/testharness.h"
 #include "util/testutil.h"

 namespace rocksdb {

-// Expects no merging attempts.
-class NoMergingMergeOp : public MergeOperator {
- public:
-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
-    ADD_FAILURE();
-    return false;
-  }
-  bool PartialMergeMulti(const Slice& key,
-                         const std::deque<Slice>& operand_list,
-                         std::string* new_value,
-                         Logger* logger) const override {
-    ADD_FAILURE();
-    return false;
-  }
-  const char* Name() const override {
-    return "CompactionIteratorTest NoMergingMergeOp";
-  }
-};
-
-// Compaction filter that gets stuck when it sees a particular key,
-// then gets unstuck when told to.
-// Always returns Decition::kRemove.
-class StallingFilter : public CompactionFilter {
- public:
-  virtual Decision FilterV2(int level, const Slice& key, ValueType t,
-                            const Slice& existing_value, std::string* new_value,
-                            std::string* skip_until) const override {
-    int k = std::atoi(key.ToString().c_str());
-    last_seen.store(k);
-    while (k >= stall_at.load()) {
-      std::this_thread::yield();
-    }
-    return Decision::kRemove;
-  }
-
-  const char* Name() const override {
-    return "CompactionIteratorTest StallingFilter";
-  }
-
-  // Wait until the filter sees a key >= k and stalls at that key.
-  // If `exact`, asserts that the seen key is equal to k.
-  void WaitForStall(int k, bool exact = true) {
-    stall_at.store(k);
-    while (last_seen.load() < k) {
-      std::this_thread::yield();
-    }
-    if (exact) {
-      EXPECT_EQ(k, last_seen.load());
-    }
-  }
-
-  // Filter will stall on key >= stall_at. Advance stall_at to unstall.
-  mutable std::atomic<int> stall_at{0};
-  // Last key the filter was called with.
-  mutable std::atomic<int> last_seen{0};
-};
-
 class LoggingForwardVectorIterator : public InternalIterator {
 public:
  struct Action {
@@ -147,15 +88,13 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {
  virtual int level(size_t compaction_input_level) const { return 0; }
  virtual bool KeyNotExistsBeyondOutputLevel(
      const Slice& user_key, std::vector<size_t>* level_ptrs) const {
-    return key_not_exists_beyond_output_level;
+    return false;
  }
  virtual bool bottommost_level() const { return false; }
  virtual int number_levels() const { return 1; }
  virtual Slice GetLargestUserKey() const {
    return "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
  }
-
-  bool key_not_exists_beyond_output_level = false;
 };

 class CompactionIteratorTest : public testing::Test {
@@ -177,19 +116,17 @@ class CompactionIteratorTest : public testing::Test {

    std::unique_ptr<CompactionIterator::CompactionProxy> compaction;
    if (filter) {
-      compaction_proxy_ = new FakeCompaction();
-      compaction.reset(compaction_proxy_);
+      compaction.reset(new FakeCompaction());
    }

    merge_helper_.reset(new MergeHelper(Env::Default(), cmp_, merge_op, filter,
-                                        nullptr, 0U, false, 0, 0, nullptr,
-                                        &shutting_down_));
+                                        nullptr, 0U, false, 0));
    iter_.reset(new LoggingForwardVectorIterator(ks, vs));
    iter_->SeekToFirst();
    c_iter_.reset(new CompactionIterator(
        iter_.get(), cmp_, merge_helper_.get(), last_sequence, &snapshots_,
        kMaxSequenceNumber, Env::Default(), false, range_del_agg_.get(),
-        std::move(compaction), filter, &shutting_down_));
+        std::move(compaction), filter));
  }

  void AddSnapshot(SequenceNumber snapshot) { snapshots_.push_back(snapshot); }
@@ -201,8 +138,6 @@ class CompactionIteratorTest : public testing::Test {
  std::unique_ptr<LoggingForwardVectorIterator> iter_;
  std::unique_ptr<CompactionIterator> c_iter_;
  std::unique_ptr<RangeDelAggregator> range_del_agg_;
-  std::atomic<bool> shutting_down_{false};
-  FakeCompaction* compaction_proxy_;
 };

 // It is possible that the output of the compaction iterator is empty even if
@@ -274,6 +209,26 @@ TEST_F(CompactionIteratorTest, RangeDeletionWithSnapshots) {
 }

 TEST_F(CompactionIteratorTest, CompactionFilterSkipUntil) {
+  // Expect no merging attempts.
+  class MergeOp : public MergeOperator {
+   public:
+    bool FullMergeV2(const MergeOperationInput& merge_in,
+                     MergeOperationOutput* merge_out) const override {
+      ADD_FAILURE();
+      return false;
+    }
+    bool PartialMergeMulti(const Slice& key,
+                           const std::deque<Slice>& operand_list,
+                           std::string* new_value,
+                           Logger* logger) const override {
+      ADD_FAILURE();
+      return false;
+    }
+    const char* Name() const override {
+      return "CompactionIteratorTest.CompactionFilterSkipUntil::MergeOp";
+    }
+  };
+
  class Filter : public CompactionFilter {
    virtual Decision FilterV2(int level, const Slice& key, ValueType t,
                              const Slice& existing_value,
@@ -331,7 +286,7 @@ TEST_F(CompactionIteratorTest, CompactionFilterSkipUntil) {
    }
  };

-  NoMergingMergeOp merge_op;
+  MergeOp merge_op;
  Filter filter;
  InitIterators(
      {test::KeyStr("a", 50, kTypeValue),  // keep
@@ -383,77 +338,6 @@ TEST_F(CompactionIteratorTest, CompactionFilterSkipUntil) {
  ASSERT_EQ(expected_actions, iter_->log);
 }

-TEST_F(CompactionIteratorTest, ShuttingDownInFilter) {
-  NoMergingMergeOp merge_op;
-  StallingFilter filter;
-  InitIterators(
-      {test::KeyStr("1", 1, kTypeValue), test::KeyStr("2", 2, kTypeValue),
-       test::KeyStr("3", 3, kTypeValue), test::KeyStr("4", 4, kTypeValue)},
-      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, &merge_op, &filter);
-  // Don't leave tombstones (kTypeDeletion) for filtered keys.
-  compaction_proxy_->key_not_exists_beyond_output_level = true;
-
-  std::atomic<bool> seek_done{false};
-  rocksdb::port::Thread compaction_thread([&] {
-    c_iter_->SeekToFirst();
-    EXPECT_FALSE(c_iter_->Valid());
-    EXPECT_TRUE(c_iter_->status().IsShutdownInProgress());
-    seek_done.store(true);
-  });
-
-  // Let key 1 through.
-  filter.WaitForStall(1);
-
-  // Shutdown during compaction filter call for key 2.
-  filter.WaitForStall(2);
-  shutting_down_.store(true);
-  EXPECT_FALSE(seek_done.load());
-
-  // Unstall filter and wait for SeekToFirst() to return.
-  filter.stall_at.store(3);
-  compaction_thread.join();
-  assert(seek_done.load());
-
-  // Check that filter was never called again.
-  EXPECT_EQ(2, filter.last_seen.load());
-}
-
-// Same as ShuttingDownInFilter, but shutdown happens during filter call for
-// a merge operand, not for a value.
-TEST_F(CompactionIteratorTest, ShuttingDownInMerge) {
-  NoMergingMergeOp merge_op;
-  StallingFilter filter;
-  InitIterators(
-      {test::KeyStr("1", 1, kTypeValue), test::KeyStr("2", 2, kTypeMerge),
-       test::KeyStr("3", 3, kTypeMerge), test::KeyStr("4", 4, kTypeValue)},
-      {"v1", "v2", "v3", "v4"}, {}, {}, kMaxSequenceNumber, &merge_op, &filter);
-  compaction_proxy_->key_not_exists_beyond_output_level = true;
-
-  std::atomic<bool> seek_done{false};
-  rocksdb::port::Thread compaction_thread([&] {
-    c_iter_->SeekToFirst();
-    ASSERT_FALSE(c_iter_->Valid());
-    ASSERT_TRUE(c_iter_->status().IsShutdownInProgress());
-    seek_done.store(true);
-  });
-
-  // Let key 1 through.
-  filter.WaitForStall(1);
-
-  // Shutdown during compaction filter call for key 2.
-  filter.WaitForStall(2);
-  shutting_down_.store(true);
-  EXPECT_FALSE(seek_done.load());
-
-  // Unstall filter and wait for SeekToFirst() to return.
-  filter.stall_at.store(3);
-  compaction_thread.join();
-  assert(seek_done.load());
-
-  // Check that filter was never called again.
-  EXPECT_EQ(2, filter.last_seen.load());
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -45,7 +45,7 @@
 #include "rocksdb/table.h"
 #include "table/block.h"
 #include "table/block_based_table_factory.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "table/table_builder.h"
 #include "util/coding.h"
 #include "util/file_reader_writer.h"
@@ -264,7 +264,7 @@ void CompactionJob::AggregateStatistics() {
 CompactionJob::CompactionJob(
    int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
    const EnvOptions& env_options, VersionSet* versions,
-    const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
+    std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
    Directory* db_directory, Directory* output_directory, Statistics* stats,
    InstrumentedMutex* db_mutex, Status* db_bg_error,
    std::vector<SequenceNumber> existing_snapshots,
@@ -522,7 +522,7 @@ Status CompactionJob::Run() {
  const uint64_t start_micros = env_->NowMicros();

  // Launch a thread for each of subcompactions 1...num_threads-1
-  std::vector<port::Thread> thread_pool;
+  std::vector<std::thread> thread_pool;
  thread_pool.reserve(num_threads - 1);
  for (size_t i = 1; i < compact_->sub_compact_states.size(); i++) {
    thread_pool.emplace_back(&CompactionJob::ProcessKeyValueCompaction, this,
@@ -724,8 +724,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      mutable_cf_options->min_partial_merge_operands,
      false /* internal key corruption is expected */,
      existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
-      compact_->compaction->level(), db_options_.statistics.get(),
-      shutting_down_);
+      compact_->compaction->level(), db_options_.statistics.get());

  TEST_SYNC_POINT("CompactionJob::Run():Inprogress");

@@ -743,8 +742,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  sub_compact->c_iter.reset(new CompactionIterator(
      input.get(), cfd->user_comparator(), &merge, versions_->LastSequence(),
      &existing_snapshots_, earliest_write_conflict_snapshot_, env_, false,
-      range_del_agg.get(), sub_compact->compaction, compaction_filter,
-      shutting_down_));
+      range_del_agg.get(), sub_compact->compaction, compaction_filter));
  auto c_iter = sub_compact->c_iter.get();
  c_iter->SeekToFirst();
  const auto& c_iter_stats = c_iter->iter_stats();
@@ -755,7 +753,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  std::string compression_dict;
  compression_dict.reserve(cfd->ioptions()->compression_opts.max_dict_bytes);

-  while (status.ok() && !cfd->IsDropped() && c_iter->Valid()) {
+  // TODO(noetzli): check whether we could check !shutting_down_->... only
+  // only occasionally (see diff D42687)
+  while (status.ok() && !shutting_down_->load(std::memory_order_acquire) &&
+         !cfd->IsDropped() && c_iter->Valid()) {
    // Invariant: c_iter.status() is guaranteed to be OK if c_iter->Valid()
    // returns true.
    const Slice& key = c_iter->key();
@@ -771,9 +772,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
                   key, sub_compact->current_output_file_size) &&
               sub_compact->builder != nullptr) {
      CompactionIterationStats range_del_out_stats;
-      status = FinishCompactionOutputFile(input->status(), sub_compact,
-                                          range_del_agg.get(),
-                                          &range_del_out_stats, &key);
+      status =
+          FinishCompactionOutputFile(input->status(), sub_compact,
+                                     range_del_agg.get(), &range_del_out_stats);
      RecordDroppedKeys(range_del_out_stats,
                        &sub_compact->compaction_job_stats);
      if (!status.ok()) {
@@ -902,36 +903,27 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
  RecordCompactionIOStats();

-  if (status.ok() && (shutting_down_->load(std::memory_order_relaxed) ||
-                      cfd->IsDropped())) {
+  if (status.ok() &&
+      (shutting_down_->load(std::memory_order_acquire) || cfd->IsDropped())) {
    status = Status::ShutdownInProgress(
        "Database shutdown or Column family drop during compaction");
  }
-  if (status.ok()) {
-    status = input->status();
-  }
-  if (status.ok()) {
-    status = c_iter->status();
-  }
-
  if (status.ok() && sub_compact->builder == nullptr &&
      sub_compact->outputs.size() == 0 &&
      range_del_agg->ShouldAddTombstones(bottommost_level_)) {
    // handle subcompaction containing only range deletions
    status = OpenCompactionOutputFile(sub_compact);
  }
-
-  // Call FinishCompactionOutputFile() even if status is not ok: it needs to
-  // close the output file.
-  if (sub_compact->builder != nullptr) {
+  if (status.ok() && sub_compact->builder != nullptr) {
    CompactionIterationStats range_del_out_stats;
-    Status s = FinishCompactionOutputFile(
-        status, sub_compact, range_del_agg.get(), &range_del_out_stats);
-    if (status.ok()) {
-      status = s;
-    }
+    status =
+        FinishCompactionOutputFile(input->status(), sub_compact,
+                                   range_del_agg.get(), &range_del_out_stats);
    RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
  }
+  if (status.ok()) {
+    status = input->status();
+  }

  if (measure_io_stats_) {
    sub_compact->compaction_job_stats.file_write_nanos +=
@@ -1094,7 +1086,6 @@ Status CompactionJob::FinishCompactionOutputFile(
      event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname,
      job_id_, meta->fd, tp, TableFileCreationReason::kCompaction, s);

-#ifndef ROCKSDB_LITE
  // Report new file to SstFileManagerImpl
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
@@ -1112,7 +1103,6 @@ Status CompactionJob::FinishCompactionOutputFile(
      }
    }
  }
-#endif

  sub_compact->builder.reset();
  sub_compact->current_output_file_size = 0;
@@ -57,7 +57,7 @@ class CompactionJob {
  CompactionJob(int job_id, Compaction* compaction,
                const ImmutableDBOptions& db_options,
                const EnvOptions& env_options, VersionSet* versions,
-                const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
+                std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
                Directory* db_directory, Directory* output_directory,
                Statistics* stats, InstrumentedMutex* db_mutex,
                Status* db_bg_error,
@@ -131,7 +131,7 @@ class CompactionJob {

  Env* env_;
  VersionSet* versions_;
-  const std::atomic<bool>* shutting_down_;
+  std::atomic<bool>* shutting_down_;
  LogBuffer* log_buffer_;
  Directory* db_directory_;
  Directory* output_directory_;
@@ -119,6 +119,9 @@ class CompactionPicker {
                                  const Slice& largest_user_key,
                                  int level) const;

+ protected:
+  int NumberLevels() const { return ioptions_.num_levels; }
+
  // Stores the minimal range that covers all entries in inputs in
  // *smallest, *largest.
  // REQUIRES: inputs is not empty
@@ -138,9 +141,6 @@ class CompactionPicker {
  void GetRange(const std::vector<CompactionInputFiles>& inputs,
                InternalKey* smallest, InternalKey* largest) const;

- protected:
-  int NumberLevels() const { return ioptions_.num_levels; }
-
  // Add more files to the inputs on "level" to make sure that
  // no newer version of a key is compacted to "level+1" while leaving an older
  // version in a "level". Otherwise, any Get() will search "level" first,
@@ -1177,50 +1177,6 @@ TEST_F(CompactionPickerTest, MaxCompactionBytesNotHit) {
  ASSERT_EQ(5U, compaction->input(1, 0)->fd.GetNumber());
 }

-TEST_F(CompactionPickerTest, IsTrivialMoveOn) {
-  mutable_cf_options_.max_bytes_for_level_base = 10000u;
-  mutable_cf_options_.max_compaction_bytes = 10001u;
-  ioptions_.level_compaction_dynamic_level_bytes = false;
-  NewVersionStorage(6, kCompactionStyleLevel);
-  // A compaction should be triggered and pick file 2
-  Add(1, 1U, "100", "150", 3000U);
-  Add(1, 2U, "151", "200", 3001U);
-  Add(1, 3U, "201", "250", 3000U);
-  Add(1, 4U, "251", "300", 3000U);
-
-  Add(3, 5U, "120", "130", 7000U);
-  Add(3, 6U, "170", "180", 7000U);
-  Add(3, 5U, "220", "230", 7000U);
-  Add(3, 5U, "270", "280", 7000U);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
-    cf_name_, mutable_cf_options_, vstorage_.get(), &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_TRUE(compaction->IsTrivialMove());
-}
-
-TEST_F(CompactionPickerTest, IsTrivialMoveOff) {
-  mutable_cf_options_.max_bytes_for_level_base = 1000000u;
-  mutable_cf_options_.max_compaction_bytes = 10000u;
-  ioptions_.level_compaction_dynamic_level_bytes = false;
-  NewVersionStorage(6, kCompactionStyleLevel);
-  // A compaction should be triggered and pick all files from level 1
-  Add(1, 1U, "100", "150", 300000U, 0, 0);
-  Add(1, 2U, "150", "200", 300000U, 0, 0);
-  Add(1, 3U, "200", "250", 300000U, 0, 0);
-  Add(1, 4U, "250", "300", 300000U, 0, 0);
-
-  Add(3, 5U, "120", "130", 6000U);
-  Add(3, 6U, "140", "150", 6000U);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
-    cf_name_, mutable_cf_options_, vstorage_.get(), &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_FALSE(compaction->IsTrivialMove());
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -41,10 +41,7 @@ class CorruptionTest : public testing::Test {
  DB* db_;

  CorruptionTest() {
-    // If LRU cache shard bit is smaller than 2 (or -1 which will automatically
-    // set it to 0), test SequenceNumberRecovery will fail, likely because of a
-    // bug in recovery code. Keep it 4 for now to make the test passes.
-    tiny_cache_ = NewLRUCache(100, 4);
+    tiny_cache_ = NewLRUCache(100);
    options_.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
    options_.env = &env_;
    dbname_ = test::TmpDir() + "/corruption_test";
@@ -9,7 +9,6 @@

 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "port/port.h"
 #include "rocksdb/experimental.h"
 #include "rocksdb/utilities/convenience.h"
 #include "util/sync_point.h"
@@ -1102,7 +1101,7 @@ TEST_P(DBCompactionTestWithParam, ManualCompactionPartial) {
  ASSERT_EQ(trivial_move, 6);
  ASSERT_EQ(non_trivial_move, 0);

-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    compact_options.change_level = false;
    compact_options.exclusive_manual_compaction = false;
    std::string begin_string = Key(0);
@@ -1234,7 +1233,7 @@ TEST_F(DBCompactionTest, ManualPartialFill) {
  ASSERT_EQ(trivial_move, 2);
  ASSERT_EQ(non_trivial_move, 0);

-  rocksdb::port::Thread threads([&] {
+  std::thread threads([&] {
    compact_options.change_level = false;
    compact_options.exclusive_manual_compaction = false;
    std::string begin_string = Key(0);
@@ -13,7 +13,6 @@
 #if !defined(ROCKSDB_LITE)

 #include "db/db_test_util.h"
-#include "port/port.h"
 #include "port/stack_trace.h"

 namespace rocksdb {
@@ -252,7 +251,7 @@ TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBase2) {
  });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  rocksdb::port::Thread thread([this] {
+  std::thread thread([this] {
    TEST_SYNC_POINT("DynamicLevelMaxBytesBase2:compact_range_start");
    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
    TEST_SYNC_POINT("DynamicLevelMaxBytesBase2:compact_range_finish");
@@ -407,7 +406,7 @@ TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBaseInc) {
  env_->SetBackgroundThreads(1, Env::HIGH);
 }

-TEST_F(DBTestDynamicLevel, DISABLED_MigrateToDynamicLevelMaxBytesBase) {
+TEST_F(DBTestDynamicLevel, MigrateToDynamicLevelMaxBytesBase) {
  Random rnd(301);
  const int kMaxKey = 2000;

@@ -463,7 +462,7 @@ TEST_F(DBTestDynamicLevel, DISABLED_MigrateToDynamicLevelMaxBytesBase) {
  compaction_finished = false;
  // Issue manual compaction in one thread and still verify DB state
  // in main thread.
-  rocksdb::port::Thread t([&]() {
+  std::thread t([&]() {
    CompactRangeOptions compact_options;
    compact_options.change_level = true;
    compact_options.target_level = options.num_levels - 1;
@@ -27,6 +27,7 @@
 #include "util/file_util.h"
 #include "util/mutexlock.h"
 #include "util/sync_point.h"
+#include "util/testharness.h"

 namespace rocksdb {

@@ -9,7 +9,6 @@

 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "util/fault_injection_test_env.h"
 #include "util/sync_point.h"

 namespace rocksdb {
@@ -48,38 +47,6 @@ TEST_F(DBFlushTest, FlushWhileWritingManifest) {
 #endif  // ROCKSDB_LITE
 }

-TEST_F(DBFlushTest, SyncFail) {
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options;
-  options.disable_auto_compactions = true;
-  options.env = fault_injection_env.get();
-
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBFlushTest::SyncFail:1", "DBImpl::SyncClosedLogs:Start"},
-       {"DBImpl::SyncClosedLogs:Failed", "DBFlushTest::SyncFail:2"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Reopen(options);
-  Put("key", "value");
-  auto* cfd =
-      reinterpret_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
-          ->cfd();
-  int refs_before = cfd->current()->TEST_refs();
-  FlushOptions flush_options;
-  flush_options.wait = false;
-  ASSERT_OK(dbfull()->Flush(flush_options));
-  fault_injection_env->SetFilesystemActive(false);
-  TEST_SYNC_POINT("DBFlushTest::SyncFail:1");
-  TEST_SYNC_POINT("DBFlushTest::SyncFail:2");
-  fault_injection_env->SetFilesystemActive(true);
-  dbfull()->TEST_WaitForFlushMemTable();
-  ASSERT_EQ("", FilesPerLevel());  // flush failed.
-  // Flush job should release ref count to current version.
-  ASSERT_EQ(refs_before, cfd->current()->TEST_refs());
-  Destroy(options);
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -76,7 +76,7 @@
 #include "rocksdb/write_buffer_manager.h"
 #include "table/block.h"
 #include "table/block_based_table_factory.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "table/table_builder.h"
 #include "table/two_level_iterator.h"
 #include "util/autovector.h"
@@ -255,21 +255,11 @@ static Status ValidateOptions(
        "More than four DB paths are not supported yet. ");
  }

-  if (db_options.allow_mmap_reads && db_options.use_direct_reads) {
+  if (db_options.allow_mmap_reads && !db_options.allow_os_buffer) {
    // Protect against assert in PosixMMapReadableFile constructor
    return Status::NotSupported(
        "If memory mapped reads (allow_mmap_reads) are enabled "
-        "then direct I/O reads (use_direct_reads) must be disabled. ");
-  }
-
-  if (db_options.allow_mmap_writes && db_options.use_direct_writes) {
-    return Status::NotSupported(
-        "If memory mapped writes (allow_mmap_writes) are enabled "
-        "then direct I/O writes (use_direct_writes) must be disabled. ");
-  }
-
-  if (db_options.keep_log_file_num == 0) {
-    return Status::InvalidArgument("keep_log_file_num must be greater than 0");
+        "then os caching (allow_os_buffer) must also be enabled. ");
  }

  return Status::OK();
@@ -342,11 +332,12 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
      num_running_flushes_(0),
      bg_purge_scheduled_(0),
      disable_delete_obsolete_files_(0),
-      delete_obsolete_files_last_run_(env_->NowMicros()),
+      delete_obsolete_files_next_run_(
+          env_->NowMicros() +
+          immutable_db_options_.delete_obsolete_files_period_micros),
      last_stats_dump_time_microsec_(0),
      next_job_id_(1),
      has_unpersisted_data_(false),
-      unable_to_flush_oldest_log_(false),
      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
      num_running_ingest_file_(0),
 #ifndef ROCKSDB_LITE
@@ -384,9 +375,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
 void DBImpl::CancelAllBackgroundWork(bool wait) {
  InstrumentedMutexLock l(&mutex_);

-  Log(InfoLogLevel::INFO_LEVEL, immutable_db_options_.info_log,
-      "Shutdown: canceling all background work");
-
  if (!shutting_down_.load(std::memory_order_acquire) &&
      has_unpersisted_data_ &&
      !mutable_db_options_.avoid_flush_during_shutdown) {
@@ -511,8 +499,6 @@ DBImpl::~DBImpl() {
    env_->UnlockFile(db_lock_);
  }

-  Log(InfoLogLevel::INFO_LEVEL, immutable_db_options_.info_log,
-      "Shutdown complete");
  LogFlush(immutable_db_options_.info_log);
 }

@@ -668,10 +654,6 @@ void DBImpl::MaybeDumpStats() {
 }

 uint64_t DBImpl::FindMinPrepLogReferencedByMemTable() {
-  if (!allow_2pc()) {
-    return 0;
-  }
-
  uint64_t min_log = 0;

  // we must look through the memtables for two phase transactions
@@ -716,11 +698,6 @@ void DBImpl::MarkLogAsContainingPrepSection(uint64_t log) {
 }

 uint64_t DBImpl::FindMinLogContainingOutstandingPrep() {
-
-  if (!allow_2pc()) {
-    return 0;
-  }
-
  std::lock_guard<std::mutex> lock(prep_heap_mutex_);
  uint64_t min_log = 0;

@@ -759,34 +736,6 @@ void DBImpl::ScheduleBgLogWriterClose(JobContext* job_context) {
  }
 }

-uint64_t DBImpl::MinLogNumberToKeep() {
-  uint64_t log_number = versions_->MinLogNumber();
-
-  if (allow_2pc()) {
-    // if are 2pc we must consider logs containing prepared
-    // sections of outstanding transactions.
-    //
-    // We must check min logs with outstanding prep before we check
-    // logs referneces by memtables because a log referenced by the
-    // first data structure could transition to the second under us.
-    //
-    // TODO(horuff): iterating over all column families under db mutex.
-    // should find more optimial solution
-    auto min_log_in_prep_heap = FindMinLogContainingOutstandingPrep();
-
-    if (min_log_in_prep_heap != 0 && min_log_in_prep_heap < log_number) {
-      log_number = min_log_in_prep_heap;
-    }
-
-    auto min_log_refed_by_mem = FindMinPrepLogReferencedByMemTable();
-
-    if (min_log_refed_by_mem != 0 && min_log_refed_by_mem < log_number) {
-      log_number = min_log_refed_by_mem;
-    }
-  }
-  return log_number;
-}
-
 // * Returns the list of live files in 'sst_live'
 // If it's doing full scan:
 // * Returns the list of all files in the filesystem in
@@ -794,7 +743,7 @@ uint64_t DBImpl::MinLogNumberToKeep() {
 // Otherwise, gets obsolete files from VersionSet.
 // no_full_scan = true -- never do the full scan using GetChildren()
 // force = false -- don't force the full scan, except every
-//  mutable_db_options_.delete_obsolete_files_period_micros
+//  immutable_db_options_.delete_obsolete_files_period_micros
 // force = true -- force the full scan
 void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
                               bool no_full_scan) {
@@ -811,15 +760,15 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  if (no_full_scan) {
    doing_the_full_scan = false;
  } else if (force ||
-             mutable_db_options_.delete_obsolete_files_period_micros == 0) {
+             immutable_db_options_.delete_obsolete_files_period_micros == 0) {
    doing_the_full_scan = true;
  } else {
    const uint64_t now_micros = env_->NowMicros();
-    if ((delete_obsolete_files_last_run_ +
-         mutable_db_options_.delete_obsolete_files_period_micros) <
-        now_micros) {
+    if (delete_obsolete_files_next_run_ < now_micros) {
      doing_the_full_scan = true;
-      delete_obsolete_files_last_run_ = now_micros;
+      delete_obsolete_files_next_run_ =
+          now_micros +
+          immutable_db_options_.delete_obsolete_files_period_micros;
    }
  }

@@ -845,7 +794,32 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  job_context->manifest_file_number = versions_->manifest_file_number();
  job_context->pending_manifest_file_number =
      versions_->pending_manifest_file_number();
-  job_context->log_number = MinLogNumberToKeep();
+  job_context->log_number = versions_->MinLogNumber();
+
+  if (allow_2pc()) {
+    // if are 2pc we must consider logs containing prepared
+    // sections of outstanding transactions.
+    //
+    // We must check min logs with outstanding prep before we check
+    // logs referneces by memtables because a log referenced by the
+    // first data structure could transition to the second under us.
+    //
+    // TODO(horuff): iterating over all column families under db mutex.
+    // should find more optimial solution
+    auto min_log_in_prep_heap = FindMinLogContainingOutstandingPrep();
+
+    if (min_log_in_prep_heap != 0 &&
+        min_log_in_prep_heap < job_context->log_number) {
+      job_context->log_number = min_log_in_prep_heap;
+    }
+
+    auto min_log_refed_by_mem = FindMinPrepLogReferencedByMemTable();
+
+    if (min_log_refed_by_mem != 0 &&
+        min_log_refed_by_mem < job_context->log_number) {
+      job_context->log_number = min_log_refed_by_mem;
+    }
+  }

  job_context->prev_log_number = versions_->prev_log_number();

@@ -1846,7 +1820,6 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
 }

 Status DBImpl::SyncClosedLogs(JobContext* job_context) {
-  TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
  mutex_.AssertHeld();
  autovector<log::Writer*, 1> logs_to_sync;
  uint64_t current_log_number = logfile_number_;
@@ -1883,7 +1856,6 @@ Status DBImpl::SyncClosedLogs(JobContext* job_context) {
    MarkLogsSynced(current_log_number - 1, true, s);
    if (!s.ok()) {
      bg_error_ = s;
-      TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Failed");
      return s;
    }
  }
@@ -1934,8 +1906,6 @@ Status DBImpl::FlushMemTableToOutputFile(
  // is unlocked by the current thread.
  if (s.ok()) {
    s = flush_job.Run(&file_meta);
-  } else {
-    flush_job.Cancel();
  }

  if (s.ok()) {
@@ -1960,6 +1930,7 @@ Status DBImpl::FlushMemTableToOutputFile(
    // may temporarily unlock and lock the mutex.
    NotifyOnFlushCompleted(cfd, &file_meta, mutable_cf_options,
                           job_context->job_id, flush_job.GetTableProperties());
+#endif  // ROCKSDB_LITE
    auto sfm = static_cast<SstFileManagerImpl*>(
        immutable_db_options_.sst_file_manager.get());
    if (sfm) {
@@ -1973,7 +1944,6 @@ Status DBImpl::FlushMemTableToOutputFile(
            "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached");
      }
    }
-#endif  // ROCKSDB_LITE
  }
  return s;
 }
@@ -2153,7 +2123,7 @@ Status DBImpl::CompactFiles(
                       immutable_db_options_.info_log.get());

  // Perform CompactFiles
-  SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);
+  SuperVersion* sv = GetAndRefSuperVersion(cfd);
  {
    InstrumentedMutexLock l(&mutex_);

@@ -2165,12 +2135,7 @@ Status DBImpl::CompactFiles(
                         input_file_names, output_level,
                         output_path_id, &job_context, &log_buffer);
  }
-  if (sv->Unref()) {
-    mutex_.Lock();
-    sv->Cleanup();
-    mutex_.Unlock();
-    delete sv;
-  }
+  ReturnAndCleanupSuperVersion(cfd, sv);

  // Find and delete obsolete files
  {
@@ -2528,7 +2493,7 @@ Status DBImpl::SetDBOptions(
      mutable_db_options_ = new_options;

      if (total_log_size_ > GetMaxTotalWalSize()) {
-        MaybeFlushColumnFamilies();
+        FlushColumnFamilies();
      }

      persist_options_status = PersistOptions();
@@ -2775,7 +2740,7 @@ void DBImpl::MarkLogsSynced(
      ++it;
    }
  }
-  assert(!status.ok() || logs_.empty() || logs_[0].number > up_to ||
+  assert(logs_.empty() || logs_[0].number > up_to ||
         (logs_.size() == 1 && !logs_[0].getting_synced));
  log_sync_cv_.SignalAll();
 }
@@ -4000,32 +3965,15 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();

-  // Acquire SuperVersion
-  SuperVersion* sv = GetAndRefSuperVersion(cfd);
-
-  TEST_SYNC_POINT("DBImpl::GetImpl:1");
-  TEST_SYNC_POINT("DBImpl::GetImpl:2");
-
  SequenceNumber snapshot;
  if (read_options.snapshot != nullptr) {
    snapshot = reinterpret_cast<const SnapshotImpl*>(
        read_options.snapshot)->number_;
  } else {
-    // Since we get and reference the super version before getting
-    // the snapshot number, without a mutex protection, it is possible
-    // that a memtable switch happened in the middle and not all the
-    // data for this snapshot is available. But it will contain all
-    // the data available in the super version we have, which is also
-    // a valid snapshot to read from.
-    // We shouldn't get snapshot before finding and referencing the
-    // super versipon because a flush happening in between may compact
-    // away data for the snapshot, but the snapshot is earlier than the
-    // data overwriting it, so users may see wrong results.
    snapshot = versions_->LastSequence();
  }
-  TEST_SYNC_POINT("DBImpl::GetImpl:3");
-  TEST_SYNC_POINT("DBImpl::GetImpl:4");
-
+  // Acquire SuperVersion
+  SuperVersion* sv = GetAndRefSuperVersion(cfd);
  // Prepare to store a list of merge operations if merge occurs.
  MergeContext merge_context;
  RangeDelAggregator range_del_agg(cfd->internal_comparator(), snapshot);
@@ -4738,8 +4686,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
         versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1);

  if (UNLIKELY(!single_column_family_mode_ &&
+               !alive_log_files_.begin()->getting_flushed &&
               total_log_size_ > GetMaxTotalWalSize())) {
-    MaybeFlushColumnFamilies();
+    FlushColumnFamilies();
  } else if (UNLIKELY(write_buffer_manager_->ShouldFlush())) {
    // Before a new memtable is added in SwitchMemtable(),
    // write_buffer_manager_->ShouldFlush() will keep returning true. If another
@@ -4824,7 +4773,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // and protects against concurrent loggers and concurrent writes
    // into memtables
  }
-  log::Writer* cur_log_writer = logs_.back().writer;

  mutex_.Unlock();

@@ -4912,7 +4860,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      WriteBatchInternal::SetSequence(merged_batch, current_sequence);

      Slice log_entry = WriteBatchInternal::Contents(merged_batch);
-      status = cur_log_writer->AddRecord(log_entry);
+      status = logs_.back().writer->AddRecord(log_entry);
      total_log_size_ += log_entry.size();
      alive_log_files_.back().AddSize(log_entry.size());
      log_empty_ = false;
@@ -5058,40 +5006,28 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  return status;
 }

-void DBImpl::MaybeFlushColumnFamilies() {
+void DBImpl::FlushColumnFamilies() {
  mutex_.AssertHeld();

+  WriteContext context;
+
  if (alive_log_files_.begin()->getting_flushed) {
    return;
  }

-  auto oldest_alive_log = alive_log_files_.begin()->number;
-  auto oldest_log_with_uncommited_prep = FindMinLogContainingOutstandingPrep();
-
-  if (allow_2pc() &&
-      unable_to_flush_oldest_log_ &&
-      oldest_log_with_uncommited_prep > 0 &&
-      oldest_log_with_uncommited_prep <= oldest_alive_log) {
-    // we already attempted to flush all column families dependent on
-    // the oldest alive log but the log still contained uncommited transactions.
-    // the oldest alive log STILL contains uncommited transaction so there
-    // is still nothing that we can do.
-    return;
-  }
-
-  WriteContext context;
-
+  uint64_t flush_column_family_if_log_file = alive_log_files_.begin()->number;
+  alive_log_files_.begin()->getting_flushed = true;
  Log(InfoLogLevel::INFO_LEVEL, immutable_db_options_.info_log,
      "Flushing all column families with data in WAL number %" PRIu64
      ". Total log size is %" PRIu64 " while max_total_wal_size is %" PRIu64,
-      oldest_alive_log, total_log_size_, GetMaxTotalWalSize());
+      flush_column_family_if_log_file, total_log_size_, GetMaxTotalWalSize());
  // no need to refcount because drop is happening in write thread, so can't
  // happen while we're in the write thread
  for (auto cfd : *versions_->GetColumnFamilySet()) {
    if (cfd->IsDropped()) {
      continue;
    }
-    if (cfd->OldestLogToKeep() <= oldest_alive_log) {
+    if (cfd->GetLogNumber() <= flush_column_family_if_log_file) {
      auto status = SwitchMemtable(cfd, &context);
      if (!status.ok()) {
        break;
@@ -5101,26 +5037,6 @@ void DBImpl::MaybeFlushColumnFamilies() {
    }
  }
  MaybeScheduleFlushOrCompaction();
-
-  // we only mark this log as getting flushed if we have successfully
-  // flushed all data in this log. If this log contains outstanding prepred
-  // transactions then we cannot flush this log until those transactions are commited.
-
-  unable_to_flush_oldest_log_ = false;
-
-  if (allow_2pc()) {
-    if (oldest_log_with_uncommited_prep == 0 ||
-        oldest_log_with_uncommited_prep > oldest_alive_log) {
-      // this log contains no outstanding prepared transactions
-      alive_log_files_.begin()->getting_flushed = true;
-    } else {
-      Log(InfoLogLevel::WARN_LEVEL, immutable_db_options_.info_log,
-          "Unable to release oldest log due to uncommited transaction");
-      unable_to_flush_oldest_log_ = true;
-    }
-  } else {
-    alive_log_files_.begin()->getting_flushed = true;
-  }
 }

 uint64_t DBImpl::GetMaxTotalWalSize() const {
@@ -5516,6 +5432,22 @@ SuperVersion* DBImpl::GetAndRefSuperVersion(uint32_t column_family_id) {
  return GetAndRefSuperVersion(cfd);
 }

+// REQUIRED:  mutex is NOT held
+SuperVersion* DBImpl::GetAndRefSuperVersionUnlocked(uint32_t column_family_id) {
+  ColumnFamilyData* cfd;
+  {
+    InstrumentedMutexLock l(&mutex_);
+    auto column_family_set = versions_->GetColumnFamilySet();
+    cfd = column_family_set->GetColumnFamily(column_family_id);
+  }
+
+  if (!cfd) {
+    return nullptr;
+  }
+
+  return GetAndRefSuperVersion(cfd);
+}
+
 void DBImpl::ReturnAndCleanupSuperVersion(ColumnFamilyData* cfd,
                                          SuperVersion* sv) {
  bool unref_sv = !cfd->ReturnThreadLocalSuperVersion(sv);
@@ -5546,6 +5478,22 @@ void DBImpl::ReturnAndCleanupSuperVersion(uint32_t column_family_id,
  ReturnAndCleanupSuperVersion(cfd, sv);
 }

+// REQUIRED: Mutex should NOT be held.
+void DBImpl::ReturnAndCleanupSuperVersionUnlocked(uint32_t column_family_id,
+                                                  SuperVersion* sv) {
+  ColumnFamilyData* cfd;
+  {
+    InstrumentedMutexLock l(&mutex_);
+    auto column_family_set = versions_->GetColumnFamilySet();
+    cfd = column_family_set->GetColumnFamily(column_family_id);
+  }
+
+  // If SuperVersion is held, and we successfully fetched a cfd using
+  // GetAndRefSuperVersion(), it must still exist.
+  assert(cfd != nullptr);
+  ReturnAndCleanupSuperVersion(cfd, sv);
+}
+
 // REQUIRED: this function should only be called on the write thread or if the
 // mutex is held.
 ColumnFamilyHandle* DBImpl::GetColumnFamilyHandle(uint32_t column_family_id) {
@@ -5558,33 +5506,23 @@ ColumnFamilyHandle* DBImpl::GetColumnFamilyHandle(uint32_t column_family_id) {
  return cf_memtables->GetColumnFamilyHandle();
 }

-void DBImpl::GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
-                                         const Range& range,
-                                         uint64_t* const count,
-                                         uint64_t* const size) {
-  ColumnFamilyHandleImpl* cfh =
-      reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
-  ColumnFamilyData* cfd = cfh->cfd();
-  SuperVersion* sv = GetAndRefSuperVersion(cfd);
+// REQUIRED: mutex is NOT held.
+ColumnFamilyHandle* DBImpl::GetColumnFamilyHandleUnlocked(
+    uint32_t column_family_id) {
+  ColumnFamilyMemTables* cf_memtables = column_family_memtables_.get();

-  // Convert user_key into a corresponding internal key.
-  InternalKey k1(range.start, kMaxSequenceNumber, kValueTypeForSeek);
-  InternalKey k2(range.limit, kMaxSequenceNumber, kValueTypeForSeek);
-  MemTable::MemTableStats memStats =
-      sv->mem->ApproximateStats(k1.Encode(), k2.Encode());
-  MemTable::MemTableStats immStats =
-      sv->imm->ApproximateStats(k1.Encode(), k2.Encode());
-  *count = memStats.count + immStats.count;
-  *size = memStats.size + immStats.size;
+  InstrumentedMutexLock l(&mutex_);

-  ReturnAndCleanupSuperVersion(cfd, sv);
+  if (!cf_memtables->Seek(column_family_id)) {
+    return nullptr;
+  }
+
+  return cf_memtables->GetColumnFamilyHandle();
 }

 void DBImpl::GetApproximateSizes(ColumnFamilyHandle* column_family,
                                 const Range* range, int n, uint64_t* sizes,
-                                 uint8_t include_flags) {
-  assert(include_flags & DB::SizeApproximationFlags::INCLUDE_FILES ||
-         include_flags & DB::SizeApproximationFlags::INCLUDE_MEMTABLES);
+                                 bool include_memtable) {
  Version* v;
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();
@@ -5595,13 +5533,10 @@ void DBImpl::GetApproximateSizes(ColumnFamilyHandle* column_family,
    // Convert user_key into a corresponding internal key.
    InternalKey k1(range[i].start, kMaxSequenceNumber, kValueTypeForSeek);
    InternalKey k2(range[i].limit, kMaxSequenceNumber, kValueTypeForSeek);
-    sizes[i] = 0;
-    if (include_flags & DB::SizeApproximationFlags::INCLUDE_FILES) {
-      sizes[i] += versions_->ApproximateSize(v, k1.Encode(), k2.Encode());
-    }
-    if (include_flags & DB::SizeApproximationFlags::INCLUDE_MEMTABLES) {
-      sizes[i] += sv->mem->ApproximateStats(k1.Encode(), k2.Encode()).size;
-      sizes[i] += sv->imm->ApproximateStats(k1.Encode(), k2.Encode()).size;
+    sizes[i] = versions_->ApproximateSize(v, k1.Encode(), k2.Encode());
+    if (include_memtable) {
+      sizes[i] += sv->mem->ApproximateSize(k1.Encode(), k2.Encode());
+      sizes[i] += sv->imm->ApproximateSize(k1.Encode(), k2.Encode());
    }
  }

@@ -6121,7 +6056,6 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
  }
  impl->mutex_.Unlock();

-#ifndef ROCKSDB_LITE
  auto sfm = static_cast<SstFileManagerImpl*>(
      impl->immutable_db_options_.sst_file_manager.get());
  if (s.ok() && sfm) {
@@ -6140,7 +6074,6 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
      }
    }
  }
-#endif  // !ROCKSDB_LITE

  if (s.ok()) {
    Log(InfoLogLevel::INFO_LEVEL, impl->immutable_db_options_.info_log,
@@ -6371,7 +6304,7 @@ Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name) {
 #endif  // !ROCKSDB_LITE
 }

-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS

 void DBImpl::NewThreadStatusCfInfo(
    ColumnFamilyData* cfd) const {
@@ -138,13 +138,7 @@ class DBImpl : public DB {
  using DB::GetApproximateSizes;
  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
                                   const Range* range, int n, uint64_t* sizes,
-                                   uint8_t include_flags
-                                   = INCLUDE_FILES) override;
-  using DB::GetApproximateMemTableStats;
-  virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
-                                           const Range& range,
-                                           uint64_t* const count,
-                                           uint64_t* const size) override;
+                                   bool include_memtable = false) override;
  using DB::CompactRange;
  virtual Status CompactRange(const CompactRangeOptions& options,
                              ColumnFamilyHandle* column_family,
@@ -314,16 +308,6 @@ class DBImpl : public DB {
                           ColumnFamilyHandle* column_family = nullptr,
                           bool disallow_trivial_move = false);

-  void TEST_MaybeFlushColumnFamilies();
-
-  bool TEST_UnableToFlushOldestLog() {
-    return unable_to_flush_oldest_log_;
-  }
-
-  bool TEST_IsLogGettingFlushed() {
-    return alive_log_files_.begin()->getting_flushed;
-  }
-
  // Force current memtable contents to be flushed.
  Status TEST_FlushMemTable(bool wait = true,
                            ColumnFamilyHandle* cfh = nullptr);
@@ -396,8 +380,6 @@ class DBImpl : public DB {
  // schedule a purge
  void ScheduleBgLogWriterClose(JobContext* job_context);

-  uint64_t MinLogNumberToKeep();
-
  // Returns the list of live files in 'live' and the list
  // of all files in the filesystem in 'candidate_files'.
  // If force == false and the last call was less than
@@ -436,6 +418,9 @@ class DBImpl : public DB {
  // mutex is held.
  SuperVersion* GetAndRefSuperVersion(uint32_t column_family_id);

+  // Same as above, should called without mutex held and not on write thread.
+  SuperVersion* GetAndRefSuperVersionUnlocked(uint32_t column_family_id);
+
  // Un-reference the super version and return it to thread local cache if
  // needed. If it is the last reference of the super version. Clean it up
  // after un-referencing it.
@@ -446,11 +431,18 @@ class DBImpl : public DB {
  // REQUIRED: this function should only be called on the write thread.
  void ReturnAndCleanupSuperVersion(uint32_t colun_family_id, SuperVersion* sv);

+  // Same as above, should called without mutex held and not on write thread.
+  void ReturnAndCleanupSuperVersionUnlocked(uint32_t colun_family_id,
+                                            SuperVersion* sv);
+
  // REQUIRED: this function should only be called on the write thread or if the
  // mutex is held.  Return value only valid until next call to this function or
  // mutex is released.
  ColumnFamilyHandle* GetColumnFamilyHandle(uint32_t column_family_id);

+  // Same as above, should called without mutex held and not on write thread.
+  ColumnFamilyHandle* GetColumnFamilyHandleUnlocked(uint32_t column_family_id);
+
  // Returns the number of currently running flushes.
  // REQUIREMENT: mutex_ must be held when calling this function.
  int num_running_flushes() {
@@ -740,7 +732,7 @@ class DBImpl : public DB {
  // REQUIRES: mutex locked
  Status PersistOptions();

-  void MaybeFlushColumnFamilies();
+  void FlushColumnFamilies();

  uint64_t GetMaxTotalWalSize() const;

@@ -984,9 +976,8 @@ class DBImpl : public DB {
  // without any synchronization
  int disable_delete_obsolete_files_;

-  // last time when DeleteObsoleteFiles with full scan was executed. Originaly
-  // initialized with startup time.
-  uint64_t delete_obsolete_files_last_run_;
+  // next time when we should run DeleteObsoleteFiles with full scan
+  uint64_t delete_obsolete_files_next_run_;

  // last time stats were dumped to LOG
  std::atomic<uint64_t> last_stats_dump_time_microsec_;
@@ -1000,15 +991,6 @@ class DBImpl : public DB {
  // Used when disableWAL is true.
  bool has_unpersisted_data_;

-
-  // if an attempt was made to flush all column families that
-  // the oldest log depends on but uncommited data in the oldest
-  // log prevents the log from being released.
-  // We must attempt to free the dependent memtables again
-  // at a later time after the transaction in the oldest
-  // log is fully commited.
-  bool unable_to_flush_oldest_log_;
-
  static const int KEEP_LOG_FILE_NUM = 1000;
  // MSVC version 1800 still does not have constexpr for ::max()
  static const uint64_t kNoTimeOut = port::kMaxUint64;
@@ -19,11 +19,6 @@ uint64_t DBImpl::TEST_GetLevel0TotalSize() {
  return default_cf_handle_->cfd()->current()->storage_info()->NumLevelBytes(0);
 }

-void DBImpl::TEST_MaybeFlushColumnFamilies() {
-  InstrumentedMutexLock l(&mutex_);
-  MaybeFlushColumnFamilies();
-}
-
 int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes(
    ColumnFamilyHandle* column_family) {
  ColumnFamilyData* cfd;
@@ -79,6 +79,7 @@ class DBImplReadOnly : public DBImpl {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

+#ifndef ROCKSDB_LITE
  virtual Status DisableFileDeletions() override {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
@@ -91,6 +92,7 @@ class DBImplReadOnly : public DBImpl {
                              bool flush_memtable = true) override {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
+#endif  // ROCKSDB_LITE

  using DBImpl::Flush;
  virtual Status Flush(const FlushOptions& options,
@@ -103,14 +105,6 @@ class DBImplReadOnly : public DBImpl {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

-  using DB::IngestExternalFile;
-  virtual Status IngestExternalFile(
-      ColumnFamilyHandle* column_family,
-      const std::vector<std::string>& external_files,
-      const IngestExternalFileOptions& ingestion_options) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
 private:
  friend class DB;

@@ -123,8 +123,7 @@ class DBIter: public Iterator {
        prefix_same_as_start_(prefix_same_as_start),
        pin_thru_lifetime_(pin_data),
        total_order_seek_(total_order_seek),
-        range_del_agg_(ioptions.internal_comparator, s,
-                       true /* collapse_deletions */) {
+        range_del_agg_(ioptions.internal_comparator, s) {
    RecordTick(statistics_, NO_ITERATORS);
    prefix_extractor_ = ioptions.prefix_extractor;
    max_skip_ = max_sequential_skip_in_iterations;
@@ -341,7 +340,6 @@ void DBIter::Next() {
 //
 // NOTE: In between, saved_key_ can point to a user key that has
 //       a delete marker or a sequence number higher than sequence_
-//       saved_key_ MUST have a proper user_key before calling this function
 //
 // The prefix_check parameter controls whether we check the iterated
 // keys against the prefix of the seeked key. Set to false when
@@ -413,9 +411,7 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
            saved_key_.SetKey(
                ikey.user_key,
                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-            if (range_del_agg_.ShouldDelete(
-                    ikey, RangeDelAggregator::RangePositioningMode::
-                              kForwardTraversal)) {
+            if (range_del_agg_.ShouldDelete(ikey)) {
              // Arrange to skip all upcoming entries for this key since
              // they are hidden by this deletion.
              skipping = true;
@@ -430,9 +426,7 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
            saved_key_.SetKey(
                ikey.user_key,
                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-            if (range_del_agg_.ShouldDelete(
-                    ikey, RangeDelAggregator::RangePositioningMode::
-                              kForwardTraversal)) {
+            if (range_del_agg_.ShouldDelete(ikey)) {
              // Arrange to skip all upcoming entries for this key since
              // they are hidden by this deletion.
              skipping = true;
@@ -535,9 +529,7 @@ void DBIter::MergeValuesNewToOld() {
      // hit the next user key, stop right here
      break;
    } else if (kTypeDeletion == ikey.type || kTypeSingleDeletion == ikey.type ||
-               range_del_agg_.ShouldDelete(
-                   ikey, RangeDelAggregator::RangePositioningMode::
-                             kForwardTraversal)) {
+               range_del_agg_.ShouldDelete(ikey)) {
      // hit a delete with the same user key, stop right here
      // iter_ is positioned after delete
      iter_->Next();
@@ -606,7 +598,6 @@ void DBIter::ReverseToForward() {
  direction_ = kForward;
  if (!iter_->Valid()) {
    iter_->SeekToFirst();
-    range_del_agg_.InvalidateTombstoneMapPositions();
  }
 }

@@ -622,7 +613,6 @@ void DBIter::ReverseToBackward() {
    // previous key.
    if (!iter_->Valid()) {
      iter_->SeekToLast();
-      range_del_agg_.InvalidateTombstoneMapPositions();
    }
    ParsedInternalKey ikey;
    FindParseableKey(&ikey, kReverse);
@@ -719,9 +709,7 @@ bool DBIter::FindValueForCurrentKey() {
    last_key_entry_type = ikey.type;
    switch (last_key_entry_type) {
      case kTypeValue:
-        if (range_del_agg_.ShouldDelete(
-                ikey,
-                RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+        if (range_del_agg_.ShouldDelete(ikey)) {
          last_key_entry_type = kTypeRangeDeletion;
          PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
        } else {
@@ -738,9 +726,7 @@ bool DBIter::FindValueForCurrentKey() {
        PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
        break;
      case kTypeMerge:
-        if (range_del_agg_.ShouldDelete(
-                ikey,
-                RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+        if (range_del_agg_.ShouldDelete(ikey)) {
          merge_context_.Clear();
          last_key_entry_type = kTypeRangeDeletion;
          last_not_merge_type = last_key_entry_type;
@@ -818,8 +804,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
  FindParseableKey(&ikey, kForward);

  if (ikey.type == kTypeDeletion || ikey.type == kTypeSingleDeletion ||
-      range_del_agg_.ShouldDelete(
-          ikey, RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+      range_del_agg_.ShouldDelete(ikey)) {
    valid_ = false;
    return false;
  }
@@ -834,12 +819,9 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
  // in operands
  current_entry_is_merged_ = true;
  merge_context_.Clear();
-  while (
-      iter_->Valid() &&
-      user_comparator_->Equal(ikey.user_key, saved_key_.GetKey()) &&
-      ikey.type == kTypeMerge &&
-      !range_del_agg_.ShouldDelete(
-          ikey, RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+  while (iter_->Valid() &&
+         user_comparator_->Equal(ikey.user_key, saved_key_.GetKey()) &&
+         ikey.type == kTypeMerge && !range_del_agg_.ShouldDelete(ikey)) {
    merge_context_.PushOperand(iter_->value(),
                               iter_->IsValuePinned() /* operand_pinned */);
    PERF_COUNTER_ADD(internal_merge_count, 1);
@@ -851,8 +833,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
  if (!iter_->Valid() ||
      !user_comparator_->Equal(ikey.user_key, saved_key_.GetKey()) ||
      ikey.type == kTypeDeletion || ikey.type == kTypeSingleDeletion ||
-      range_del_agg_.ShouldDelete(
-          ikey, RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+      range_del_agg_.ShouldDelete(ikey)) {
    s = MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(),
                                    nullptr, merge_context_.GetOperands(),
                                    &saved_value_, logger_, statistics_, env_,
@@ -947,12 +928,12 @@ void DBIter::Seek(const Slice& target) {
  StopWatch sw(env_, statistics_, DB_SEEK);
  ReleaseTempPinnedData();
  saved_key_.Clear();
+  // now savved_key is used to store internal key.
  saved_key_.SetInternalKey(target, sequence_);

  {
    PERF_TIMER_GUARD(seek_internal_seek_time);
    iter_->Seek(saved_key_.GetKey());
-    range_del_agg_.InvalidateTombstoneMapPositions();
  }
  RecordTick(statistics_, NUMBER_DB_SEEK);
  if (iter_->Valid()) {
@@ -961,9 +942,6 @@ void DBIter::Seek(const Slice& target) {
    }
    direction_ = kForward;
    ClearSavedValue();
-    // convert the InternalKey to UserKey in saved_key_ before
-    // passed to FindNextUserEntry
-    saved_key_.Reserve(saved_key_.Size() - 8);
    FindNextUserEntry(false /* not skipping */, prefix_same_as_start_);
    if (!valid_) {
      prefix_start_key_.clear();
@@ -995,7 +973,6 @@ void DBIter::SeekForPrev(const Slice& target) {
  {
    PERF_TIMER_GUARD(seek_internal_seek_time);
    iter_->SeekForPrev(saved_key_.GetKey());
-    range_del_agg_.InvalidateTombstoneMapPositions();
  }

  RecordTick(statistics_, NUMBER_DB_SEEK);
@@ -1037,13 +1014,10 @@ void DBIter::SeekToFirst() {
  {
    PERF_TIMER_GUARD(seek_internal_seek_time);
    iter_->SeekToFirst();
-    range_del_agg_.InvalidateTombstoneMapPositions();
  }

  RecordTick(statistics_, NUMBER_DB_SEEK);
  if (iter_->Valid()) {
-    saved_key_.SetKey(ExtractUserKey(iter_->key()),
-                      !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
    FindNextUserEntry(false /* not skipping */, false /* no prefix check */);
    if (statistics_ != nullptr) {
      if (valid_) {
@@ -1073,14 +1047,12 @@ void DBIter::SeekToLast() {
  {
    PERF_TIMER_GUARD(seek_internal_seek_time);
    iter_->SeekToLast();
-    range_del_agg_.InvalidateTombstoneMapPositions();
  }
  // When the iterate_upper_bound is set to a value,
  // it will seek to the last key before the
  // ReadOptions.iterate_upper_bound
  if (iter_->Valid() && iterate_upper_bound_ != nullptr) {
    SeekForPrev(*iterate_upper_bound_);
-    range_del_agg_.InvalidateTombstoneMapPositions();
    if (!Valid()) {
      return;
    } else if (user_comparator_->Equal(*iterate_upper_bound_, key())) {
@@ -16,7 +16,7 @@
 #include "rocksdb/slice.h"
 #include "rocksdb/statistics.h"
 #include "table/iterator_wrapper.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "util/string_util.h"
 #include "util/sync_point.h"
 #include "util/testharness.h"
@@ -1897,66 +1897,6 @@ TEST_F(DBIteratorTest, DBIterator12) {
  ASSERT_FALSE(db_iter->Valid());
 }

-TEST_F(DBIteratorTest, DBIterator13) {
-  Options options;
-  options.merge_operator = nullptr;
-
-  std::string key;
-  key.resize(9);
-  key.assign(9, static_cast<char>(0));
-  key[0] = 'b';
-
-  TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-  internal_iter->AddPut(key, "0");
-  internal_iter->AddPut(key, "1");
-  internal_iter->AddPut(key, "2");
-  internal_iter->AddPut(key, "3");
-  internal_iter->AddPut(key, "4");
-  internal_iter->AddPut(key, "5");
-  internal_iter->AddPut(key, "6");
-  internal_iter->AddPut(key, "7");
-  internal_iter->AddPut(key, "8");
-  internal_iter->Finish();
-
-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 2, 3, 0));
-  db_iter->Seek("b");
-  ASSERT_TRUE(db_iter->Valid());
-  ASSERT_EQ(db_iter->key().ToString(), key);
-  ASSERT_EQ(db_iter->value().ToString(), "2");
-}
-
-TEST_F(DBIteratorTest, DBIterator14) {
-  Options options;
-  options.merge_operator = nullptr;
-
-  std::string key("b");
-  TestIterator* internal_iter = new TestIterator(BytewiseComparator());
-  internal_iter->AddPut("b", "0");
-  internal_iter->AddPut("b", "1");
-  internal_iter->AddPut("b", "2");
-  internal_iter->AddPut("b", "3");
-  internal_iter->AddPut("a", "4");
-  internal_iter->AddPut("a", "5");
-  internal_iter->AddPut("a", "6");
-  internal_iter->AddPut("c", "7");
-  internal_iter->AddPut("c", "8");
-  internal_iter->AddPut("c", "9");
-  internal_iter->Finish();
-
-  std::unique_ptr<Iterator> db_iter(
-      NewDBIterator(env_, ImmutableCFOptions(options), BytewiseComparator(),
-                    internal_iter, 4, 1, 0));
-  db_iter->Seek("b");
-  ASSERT_TRUE(db_iter->Valid());
-  ASSERT_EQ(db_iter->key().ToString(), "b");
-  ASSERT_EQ(db_iter->value().ToString(), "3");
-  db_iter->SeekToFirst();
-  ASSERT_EQ(db_iter->key().ToString(), "a");
-  ASSERT_EQ(db_iter->value().ToString(), "4");
-}
-
 class DBIterWithMergeIterTest : public testing::Test {
 public:
  DBIterWithMergeIterTest()
@@ -7,8 +7,6 @@
 // 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 <functional>
-
 #include "db/db_test_util.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
@@ -1644,7 +1642,7 @@ TEST_F(DBIteratorTest, IteratorWithLocalStatistics) {
  std::atomic<uint64_t> total_prev_found(0);
  std::atomic<uint64_t> total_bytes(0);

-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  std::function<void()> reader_func_next = [&]() {
    Iterator* iter = db_->NewIterator(ReadOptions());

@@ -316,47 +316,6 @@ TEST_F(DBOptionsTest, MaxTotalWalSizeChange) {
  }
 }

-static void assert_candidate_files_empty(DBImpl* dbfull, const bool empty) {
-  dbfull->TEST_LockMutex();
-  JobContext job_context(0);
-  dbfull->FindObsoleteFiles(&job_context, false);
-  ASSERT_EQ(empty, job_context.full_scan_candidate_files.empty());
-  job_context.Clean();
-  dbfull->TEST_UnlockMutex();
-}
-
-TEST_F(DBOptionsTest, DeleteObsoleteFilesPeriodChange) {
-  SpecialEnv env(Env::Default());
-  env.time_elapse_only_sleep_ = true;
-  Options options;
-  options.env = &env;
-  options.create_if_missing = true;
-  ASSERT_OK(TryReopen(options));
-
-  // Verify that candidate files set is empty when no full scan requested.
-  assert_candidate_files_empty(dbfull(), true);
-
-  ASSERT_OK(
-      dbfull()->SetDBOptions({{"delete_obsolete_files_period_micros", "0"}}));
-
-  // After delete_obsolete_files_period_micros updated to 0, the next call
-  // to FindObsoleteFiles should make a full scan
-  assert_candidate_files_empty(dbfull(), false);
-
-  ASSERT_OK(
-      dbfull()->SetDBOptions({{"delete_obsolete_files_period_micros", "20"}}));
-
-  assert_candidate_files_empty(dbfull(), true);
-
-  env.addon_time_.store(20);
-  assert_candidate_files_empty(dbfull(), true);
-
-  env.addon_time_.store(21);
-  assert_candidate_files_empty(dbfull(), false);
-
-  Close();
-}
-
 #endif  // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -41,7 +41,7 @@ TEST_F(DBRangeDelTest, NonBlockBasedTableNotSupported) {

 TEST_F(DBRangeDelTest, FlushOutputHasOnlyRangeTombstones) {
  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "dr1",
-                             "dr2"));
+                             "dr1"));
  ASSERT_OK(db_->Flush(FlushOptions()));
  ASSERT_EQ(1, NumTableFilesAtLevel(0));
 }
@@ -112,81 +112,6 @@ TEST_F(DBRangeDelTest, CompactionOutputFilesExactlyFilled) {
  db_->ReleaseSnapshot(snapshot);
 }

-TEST_F(DBRangeDelTest, MaxCompactionBytesCutsOutputFiles) {
-  // Ensures range deletion spanning multiple compaction output files that are
-  // cut by max_compaction_bytes will have non-overlapping key-ranges.
-  // https://github.com/facebook/rocksdb/issues/1778
-  const int kNumFiles = 2, kNumPerFile = 1 << 8, kBytesPerVal = 1 << 12;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  opts.disable_auto_compactions = true;
-  opts.level0_file_num_compaction_trigger = kNumFiles;
-  opts.max_compaction_bytes = kNumPerFile * kBytesPerVal;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  // Want max_compaction_bytes to trigger the end of compaction output file, not
-  // target_file_size_base, so make the latter much bigger
-  opts.target_file_size_base = 100 * opts.max_compaction_bytes;
-  Reopen(opts);
-
-  // snapshot protects range tombstone from dropping due to becoming obsolete.
-  const Snapshot* snapshot = db_->GetSnapshot();
-
-  // It spans the whole key-range, thus will be included in all output files
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                             GetNumericStr(0),
-                             GetNumericStr(kNumFiles * kNumPerFile - 1)));
-  Random rnd(301);
-  for (int i = 0; i < kNumFiles; ++i) {
-    std::vector<std::string> values;
-    // Write 1MB (256 values, each 4K)
-    for (int j = 0; j < kNumPerFile; j++) {
-      values.push_back(RandomString(&rnd, kBytesPerVal));
-      ASSERT_OK(Put(GetNumericStr(kNumPerFile * i + j), values[j]));
-    }
-    // extra entry to trigger SpecialSkipListFactory's flush
-    ASSERT_OK(Put(GetNumericStr(kNumPerFile), ""));
-    dbfull()->TEST_WaitForFlushMemTable();
-    ASSERT_EQ(i + 1, NumTableFilesAtLevel(0));
-  }
-
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
-                              true /* disallow_trivial_move */);
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_GE(NumTableFilesAtLevel(1), 2);
-
-  std::vector<std::vector<FileMetaData>> files;
-  dbfull()->TEST_GetFilesMetaData(db_->DefaultColumnFamily(), &files);
-
-  for (size_t i = 0; i < files[1].size() - 1; ++i) {
-    ASSERT_TRUE(InternalKeyComparator(opts.comparator)
-                    .Compare(files[1][i].largest, files[1][i + 1].smallest) <
-                0);
-  }
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, SentinelsOmittedFromOutputFile) {
-  // Regression test for bug where sentinel range deletions (i.e., ones with
-  // sequence number of zero) were included in output files.
-  // snapshot protects range tombstone from dropping due to becoming obsolete.
-  const Snapshot* snapshot = db_->GetSnapshot();
-
-  // gaps between ranges creates sentinels in our internal representation
-  std::vector<std::pair<std::string, std::string>> range_dels = {{"a", "b"}, {"c", "d"}, {"e", "f"}};
-  for (const auto& range_del : range_dels) {
-    ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                               range_del.first, range_del.second));
-  }
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-
-  std::vector<std::vector<FileMetaData>> files;
-  dbfull()->TEST_GetFilesMetaData(db_->DefaultColumnFamily(), &files);
-  ASSERT_GT(files[0][0].smallest_seqno, 0);
-
-  db_->ReleaseSnapshot(snapshot);
-}
-
 TEST_F(DBRangeDelTest, FlushRangeDelsSameStartKey) {
  db_->Put(WriteOptions(), "b1", "val");
  ASSERT_OK(
@@ -503,310 +428,6 @@ TEST_F(DBRangeDelTest, ObsoleteTombstoneCleanup) {

  db_->ReleaseSnapshot(snapshot);
 }
-
-TEST_F(DBRangeDelTest, TableEvictedDuringScan) {
-  // The RangeDelAggregator holds pointers into range deletion blocks created by
-  // table readers. This test ensures the aggregator can still access those
-  // blocks even if it outlives the table readers that created them.
-  //
-  // DBIter always keeps readers open for L0 files. So, in order to test
-  // aggregator outliving reader, we need to have deletions in L1 files, which
-  // are opened/closed on-demand during the scan. This is accomplished by
-  // setting kNumRanges > level0_stop_writes_trigger, which prevents deletions
-  // from all lingering in L0 (there is at most one range deletion per L0 file).
-  //
-  // The first L1 file will contain a range deletion since its begin key is 0.
-  // SeekToFirst() references that table's reader and adds its range tombstone
-  // to the aggregator. Upon advancing beyond that table's key-range via Next(),
-  // the table reader will be unreferenced by the iterator. Since we manually
-  // call Evict() on all readers before the full scan, this unreference causes
-  // the reader's refcount to drop to zero and thus be destroyed.
-  //
-  // When it is destroyed, we do not remove its range deletions from the
-  // aggregator. So, subsequent calls to Next() must be able to use these
-  // deletions to decide whether a key is covered. This will work as long as
-  // the aggregator properly references the range deletion block.
-  const int kNum = 25, kRangeBegin = 0, kRangeEnd = 7, kNumRanges = 5;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  opts.level0_file_num_compaction_trigger = 4;
-  opts.level0_stop_writes_trigger = 4;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(1));
-  opts.num_levels = 2;
-  BlockBasedTableOptions bbto;
-  bbto.cache_index_and_filter_blocks = true;
-  bbto.block_cache = NewLRUCache(8 << 20);
-  opts.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(opts);
-
-  // Hold a snapshot so range deletions can't become obsolete during compaction
-  // to bottommost level (i.e., L1).
-  const Snapshot* snapshot = db_->GetSnapshot();
-  for (int i = 0; i < kNum; ++i) {
-    db_->Put(WriteOptions(), GetNumericStr(i), "val");
-    if (i > 0) {
-      dbfull()->TEST_WaitForFlushMemTable();
-    }
-    if (i >= kNum / 2 && i < kNum / 2 + kNumRanges) {
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                       GetNumericStr(kRangeBegin), GetNumericStr(kRangeEnd));
-    }
-  }
-  // Must be > 1 so the first L1 file can be closed before scan finishes
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_GT(NumTableFilesAtLevel(1), 1);
-  std::vector<uint64_t> file_numbers = ListTableFiles(env_, dbname_);
-
-  ReadOptions read_opts;
-  auto* iter = db_->NewIterator(read_opts);
-  int expected = kRangeEnd;
-  iter->SeekToFirst();
-  for (auto file_number : file_numbers) {
-    // This puts table caches in the state of being externally referenced only
-    // so they are destroyed immediately upon iterator unreferencing.
-    TableCache::Evict(dbfull()->TEST_table_cache(), file_number);
-  }
-  for (; iter->Valid(); iter->Next()) {
-    ASSERT_EQ(GetNumericStr(expected), iter->key());
-    ++expected;
-    // Keep clearing block cache's LRU so range deletion block can be freed as
-    // soon as its refcount drops to zero.
-    bbto.block_cache->EraseUnRefEntries();
-  }
-  ASSERT_EQ(kNum, expected);
-  delete iter;
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, GetCoveredKeyFromMutableMemtable) {
-  db_->Put(WriteOptions(), "key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-
-  ReadOptions read_opts;
-  std::string value;
-  ASSERT_TRUE(db_->Get(read_opts, "key", &value).IsNotFound());
-}
-
-TEST_F(DBRangeDelTest, GetCoveredKeyFromImmutableMemtable) {
-  Options opts = CurrentOptions();
-  opts.max_write_buffer_number = 3;
-  opts.min_write_buffer_number_to_merge = 2;
-  // SpecialSkipListFactory lets us specify maximum number of elements the
-  // memtable can hold. It switches the active memtable to immutable (flush is
-  // prevented by the above options) upon inserting an element that would
-  // overflow the memtable.
-  opts.memtable_factory.reset(new SpecialSkipListFactory(1));
-  Reopen(opts);
-
-  db_->Put(WriteOptions(), "key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  db_->Put(WriteOptions(), "blah", "val");
-
-  ReadOptions read_opts;
-  std::string value;
-  ASSERT_TRUE(db_->Get(read_opts, "key", &value).IsNotFound());
-}
-
-TEST_F(DBRangeDelTest, GetCoveredKeyFromSst) {
-  db_->Put(WriteOptions(), "key", "val");
-  // snapshot prevents key from being deleted during flush
-  const Snapshot* snapshot = db_->GetSnapshot();
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-
-  ReadOptions read_opts;
-  std::string value;
-  ASSERT_TRUE(db_->Get(read_opts, "key", &value).IsNotFound());
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, GetCoveredMergeOperandFromMemtable) {
-  const int kNumMergeOps = 10;
-  Options opts = CurrentOptions();
-  opts.merge_operator = MergeOperators::CreateUInt64AddOperator();
-  Reopen(opts);
-
-  for (int i = 0; i < kNumMergeOps; ++i) {
-    std::string val;
-    PutFixed64(&val, i);
-    db_->Merge(WriteOptions(), "key", val);
-    if (i == kNumMergeOps / 2) {
-      // deletes [0, 5]
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "key",
-                       "key_");
-    }
-  }
-
-  ReadOptions read_opts;
-  std::string expected, actual;
-  ASSERT_OK(db_->Get(read_opts, "key", &actual));
-  PutFixed64(&expected, 30);  // 6+7+8+9
-  ASSERT_EQ(expected, actual);
-
-  expected.clear();
-  read_opts.ignore_range_deletions = true;
-  ASSERT_OK(db_->Get(read_opts, "key", &actual));
-  PutFixed64(&expected, 45);  // 0+1+2+...+9
-  ASSERT_EQ(expected, actual);
-}
-
-TEST_F(DBRangeDelTest, GetIgnoresRangeDeletions) {
-  Options opts = CurrentOptions();
-  opts.max_write_buffer_number = 4;
-  opts.min_write_buffer_number_to_merge = 3;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(1));
-  Reopen(opts);
-
-  db_->Put(WriteOptions(), "sst_key", "val");
-  // snapshot prevents key from being deleted during flush
-  const Snapshot* snapshot = db_->GetSnapshot();
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  db_->Put(WriteOptions(), "imm_key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  db_->Put(WriteOptions(), "mem_key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-
-  ReadOptions read_opts;
-  read_opts.ignore_range_deletions = true;
-  for (std::string key : {"sst_key", "imm_key", "mem_key"}) {
-    std::string value;
-    ASSERT_OK(db_->Get(read_opts, key, &value));
-  }
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, IteratorRemovesCoveredKeys) {
-  const int kNum = 200, kRangeBegin = 50, kRangeEnd = 150, kNumPerFile = 25;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  Reopen(opts);
-
-  // Write half of the keys before the tombstone and half after the tombstone.
-  // Only covered keys (i.e., within the range and older than the tombstone)
-  // should be deleted.
-  for (int i = 0; i < kNum; ++i) {
-    if (i == kNum / 2) {
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                       GetNumericStr(kRangeBegin), GetNumericStr(kRangeEnd));
-    }
-    db_->Put(WriteOptions(), GetNumericStr(i), "val");
-  }
-  ReadOptions read_opts;
-  auto* iter = db_->NewIterator(read_opts);
-
-  int expected = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ASSERT_EQ(GetNumericStr(expected), iter->key());
-    if (expected == kRangeBegin - 1) {
-      expected = kNum / 2;
-    } else {
-      ++expected;
-    }
-  }
-  ASSERT_EQ(kNum, expected);
-  delete iter;
-}
-
-TEST_F(DBRangeDelTest, IteratorOverUserSnapshot) {
-  const int kNum = 200, kRangeBegin = 50, kRangeEnd = 150, kNumPerFile = 25;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  Reopen(opts);
-
-  const Snapshot* snapshot = nullptr;
-  // Put a snapshot before the range tombstone, verify an iterator using that
-  // snapshot sees all inserted keys.
-  for (int i = 0; i < kNum; ++i) {
-    if (i == kNum / 2) {
-      snapshot = db_->GetSnapshot();
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                       GetNumericStr(kRangeBegin), GetNumericStr(kRangeEnd));
-    }
-    db_->Put(WriteOptions(), GetNumericStr(i), "val");
-  }
-  ReadOptions read_opts;
-  read_opts.snapshot = snapshot;
-  auto* iter = db_->NewIterator(read_opts);
-
-  int expected = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ASSERT_EQ(GetNumericStr(expected), iter->key());
-    ++expected;
-  }
-  ASSERT_EQ(kNum / 2, expected);
-  delete iter;
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, IteratorIgnoresRangeDeletions) {
-  Options opts = CurrentOptions();
-  opts.max_write_buffer_number = 4;
-  opts.min_write_buffer_number_to_merge = 3;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(1));
-  Reopen(opts);
-
-  db_->Put(WriteOptions(), "sst_key", "val");
-  // snapshot prevents key from being deleted during flush
-  const Snapshot* snapshot = db_->GetSnapshot();
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  db_->Put(WriteOptions(), "imm_key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-  db_->Put(WriteOptions(), "mem_key", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-
-  ReadOptions read_opts;
-  read_opts.ignore_range_deletions = true;
-  auto* iter = db_->NewIterator(read_opts);
-  int i = 0;
-  std::string expected[] = {"imm_key", "mem_key", "sst_key"};
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next(), ++i) {
-    std::string key;
-    ASSERT_EQ(expected[i], iter->key());
-  }
-  ASSERT_EQ(3, i);
-  delete iter;
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, TailingIteratorRangeTombstoneUnsupported) {
-  db_->Put(WriteOptions(), "key", "val");
-  // snapshot prevents key from being deleted during flush
-  const Snapshot* snapshot = db_->GetSnapshot();
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z"));
-
-  // iterations check unsupported in memtable, l0, and then l1
-  for (int i = 0; i < 3; ++i) {
-    ReadOptions read_opts;
-    read_opts.tailing = true;
-    auto* iter = db_->NewIterator(read_opts);
-    if (i == 2) {
-      // For L1+, iterators over files are created on-demand, so need seek
-      iter->SeekToFirst();
-    }
-    ASSERT_TRUE(iter->status().IsNotSupported());
-    delete iter;
-    if (i == 0) {
-      ASSERT_OK(db_->Flush(FlushOptions()));
-    } else if (i == 1) {
-      MoveFilesToLevel(1);
-    }
-  }
-  db_->ReleaseSnapshot(snapshot);
-}
 #endif  // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -221,6 +221,8 @@ TEST_F(DBSSTTest, DeleteObsoleteFilesPendingOutputs) {
  listener->VerifyMatchedCount(1);
 }

+#endif  // ROCKSDB_LITE
+
 TEST_F(DBSSTTest, DBWithSstFileManager) {
  std::shared_ptr<SstFileManager> sst_file_manager(NewSstFileManager(env_));
  auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
@@ -285,6 +287,7 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }

+#ifndef ROCKSDB_LITE
 TEST_F(DBSSTTest, RateLimitedDelete) {
  Destroy(last_options_);
  rocksdb::SyncPoint::GetInstance()->LoadDependency({
@@ -479,6 +482,7 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
  // We have deleted the 4 sst files in the delete_scheduler
  ASSERT_EQ(bg_delete_file, 4);
 }
+#endif  // ROCKSDB_LITE

 TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {
  std::shared_ptr<SstFileManager> sst_file_manager(NewSstFileManager(env_));
@@ -576,6 +580,7 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
  ASSERT_GT(reached_max_space_on_compaction, 0);
 }

+#ifndef ROCKSDB_LITE
 TEST_F(DBSSTTest, OpenDBWithInfiniteMaxOpenFiles) {
  // Open DB with infinite max open files
  //  - First iteration use 1 thread to open files
@@ -613,7 +618,7 @@ TEST_F(DBSSTTest, OpenDBWithInfiniteMaxOpenFiles) {
    }
    Close();

-    // Reopening the DB will load all existing files
+    // Reopening the DB will load all exisitng files
    Reopen(options);
    ASSERT_EQ("12,0,12", FilesPerLevel(0));
    std::vector<std::vector<FileMetaData>> files;
@@ -31,7 +31,6 @@
 #include "db/version_set.h"
 #include "db/write_batch_internal.h"
 #include "memtable/hash_linklist_rep.h"
-#include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/compaction_filter.h"
@@ -198,19 +197,6 @@ TEST_F(DBTest, MemEnvTest) {
 }
 #endif  // ROCKSDB_LITE

-TEST_F(DBTest, OpenWhenOpen) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  rocksdb::DB* db2 = nullptr;
-  rocksdb::Status s = DB::Open(options, dbname_, &db2);
-
-  ASSERT_EQ(Status::Code::kIOError, s.code());
-  ASSERT_EQ(Status::SubCode::kNone, s.subcode());
-  ASSERT_TRUE(strstr(s.getState(), "lock ") != nullptr);
-
-  delete db2;
-}
-
 TEST_F(DBTest, WriteEmptyBatch) {
  Options options = CurrentOptions();
  options.env = env_;
@@ -999,7 +985,7 @@ TEST_F(DBTest, FlushSchedule) {
  options.max_write_buffer_number = 2;
  options.write_buffer_size = 120 * 1024;
  CreateAndReopenWithCF({"pikachu"}, options);
-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;

  std::atomic<int> thread_num(0);
  // each column family will have 5 thread, each thread generating 2 memtables.
@@ -1408,19 +1394,17 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  std::string start = Key(50);
  std::string end = Key(60);
  Range r(start, end);
-  uint8_t include_both = DB::SizeApproximationFlags::INCLUDE_FILES |
-                         DB::SizeApproximationFlags::INCLUDE_MEMTABLES;
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);
  ASSERT_LT(size, 204800);
  // Zero if not including mem table
-  db_->GetApproximateSizes(&r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, false);
  ASSERT_EQ(size, 0);

  start = Key(500);
  end = Key(600);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  for (int i = 0; i < N; i++) {
@@ -1430,13 +1414,13 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(500);
  end = Key(600);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(100);
  end = Key(1020);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  options.max_write_buffer_number = 8;
@@ -1459,28 +1443,28 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(100);
  end = Key(300);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_GT(size, 6000);

  start = Key(2100);
  end = Key(2300);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size, include_both);
+  db_->GetApproximateSizes(&r, 1, &size, true);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  uint64_t size_with_mt, size_without_mt;
-  db_->GetApproximateSizes(&r, 1, &size_with_mt, include_both);
+  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
  ASSERT_GT(size_with_mt, 6000);
-  db_->GetApproximateSizes(&r, 1, &size_without_mt);
+  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_EQ(size_without_mt, 0);

  Flush();
@@ -1492,65 +1476,12 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
-  db_->GetApproximateSizes(&r, 1, &size_with_mt, include_both);
-  db_->GetApproximateSizes(&r, 1, &size_without_mt);
+  db_->GetApproximateSizes(&r, 1, &size_with_mt, true);
+  db_->GetApproximateSizes(&r, 1, &size_without_mt, false);
  ASSERT_GT(size_with_mt, size_without_mt);
  ASSERT_GT(size_without_mt, 6000);
 }

-TEST_F(DBTest, GetApproximateMemTableStats) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 100000000;
-  options.compression = kNoCompression;
-  options.create_if_missing = true;
-  DestroyAndReopen(options);
-
-  const int N = 128;
-  Random rnd(301);
-  for (int i = 0; i < N; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
-  }
-
-  uint64_t count;
-  uint64_t size;
-
-  std::string start = Key(50);
-  std::string end = Key(60);
-  Range r(start, end);
-  db_->GetApproximateMemTableStats(r, &count, &size);
-  ASSERT_GT(count, 0);
-  ASSERT_LE(count, N);
-  ASSERT_GT(size, 6000);
-  ASSERT_LT(size, 204800);
-
-  start = Key(500);
-  end = Key(600);
-  r = Range(start, end);
-  db_->GetApproximateMemTableStats(r, &count, &size);
-  ASSERT_EQ(count, 0);
-  ASSERT_EQ(size, 0);
-
-  Flush();
-
-  start = Key(50);
-  end = Key(60);
-  r = Range(start, end);
-  db_->GetApproximateMemTableStats(r, &count, &size);
-  ASSERT_EQ(count, 0);
-  ASSERT_EQ(size, 0);
-
-  for (int i = 0; i < N; i++) {
-    ASSERT_OK(Put(Key(1000 + i), RandomString(&rnd, 1024)));
-  }
-
-  start = Key(100);
-  end = Key(1020);
-  r = Range(start, end);
-  db_->GetApproximateMemTableStats(r, &count, &size);
-  ASSERT_GT(count, 20);
-  ASSERT_GT(size, 6000);
-}
-
 TEST_F(DBTest, ApproximateSizes) {
  do {
    Options options = CurrentOptions();
@@ -2869,20 +2800,11 @@ class ModelDB : public DB {
  using DB::GetApproximateSizes;
  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
                                   const Range* range, int n, uint64_t* sizes,
-                                   uint8_t include_flags
-                                   = INCLUDE_FILES) override {
+                                   bool include_memtable) override {
    for (int i = 0; i < n; i++) {
      sizes[i] = 0;
    }
  }
-  using DB::GetApproximateMemTableStats;
-  virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
-                                           const Range& range,
-                                           uint64_t* const count,
-                                           uint64_t* const size) override {
-    *count = 0;
-    *size = 0;
-  }
  using DB::CompactRange;
  virtual Status CompactRange(const CompactRangeOptions& options,
                              ColumnFamilyHandle* column_family,
@@ -3474,21 +3396,19 @@ TEST_F(DBTest, TableOptionsSanitizeTest) {
 TEST_F(DBTest, MmapAndBufferOptions) {
  Options options = CurrentOptions();

-  options.use_direct_reads = true;
+  options.allow_os_buffer = false;
  options.allow_mmap_reads = true;
  ASSERT_NOK(TryReopen(options));

  // All other combinations are acceptable
-  options.use_direct_reads = false;
+  options.allow_os_buffer = true;
  ASSERT_OK(TryReopen(options));

-  if (IsDirectIOSupported()) {
-    options.use_direct_reads = true;
-    options.allow_mmap_reads = false;
-    ASSERT_OK(TryReopen(options));
-  }
+  options.allow_os_buffer = false;
+  options.allow_mmap_reads = false;
+  ASSERT_OK(TryReopen(options));

-  options.use_direct_reads = false;
+  options.allow_os_buffer = true;
  ASSERT_OK(TryReopen(options));
 }
 #endif
@@ -3557,7 +3477,7 @@ TEST_F(DBTest, SanitizeNumThreads) {
 }

 TEST_F(DBTest, WriteSingleThreadEntry) {
-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  dbfull()->TEST_LockMutex();
  auto w = dbfull()->TEST_BeginWrite();
  threads.emplace_back([&] { Put("a", "b"); });
@@ -3743,7 +3663,7 @@ TEST_F(DBTest, DynamicMemtableOptions) {
 }
 #endif  // ROCKSDB_LITE

-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
 namespace {
 void VerifyOperationCount(Env* env, ThreadStatus::OperationType op_type,
                          int expected_count) {
@@ -5050,7 +4970,7 @@ TEST_F(DBTest, MergeTestTime) {

  ASSERT_EQ(1, count);
  ASSERT_EQ(2000000, TestGetTickerCount(options, MERGE_OPERATION_TOTAL_TIME));
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  ASSERT_GT(TestGetTickerCount(options, FLUSH_WRITE_BYTES), 0);
 #endif  // ROCKSDB_USING_THREAD_STATUS
  this->env_->time_elapse_only_sleep_ = false;
@@ -5435,7 +5355,7 @@ TEST_F(DBTest, FlushesInParallelWithCompactRange) {
    }
    rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-    std::vector<port::Thread> threads;
+    std::vector<std::thread> threads;
    threads.emplace_back([&]() { Compact("a", "z"); });

    TEST_SYNC_POINT("DBTest::FlushesInParallelWithCompactRange:1");
@@ -5841,7 +5761,7 @@ TEST_F(DBTest, PauseBackgroundWorkTest) {
  options.write_buffer_size = 100000;  // Small write buffer
  Reopen(options);

-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  std::atomic<bool> done(false);
  db_->PauseBackgroundWork();
  threads.emplace_back([&]() {
@@ -11,7 +11,6 @@
 #include <functional>

 #include "db/db_test_util.h"
-#include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/persistent_cache.h"
 #include "rocksdb/wal_filter.h"
@@ -1506,10 +1505,6 @@ class MockPersistentCache : public PersistentCache {

  bool IsCompressed() override { return is_compressed_; }

-  std::string GetPrintableOptions() const override {
-    return "MockPersistentCache";
-  }
-
  port::Mutex lock_;
  std::map<std::string, std::string> data_;
  const bool is_compressed_ = true;
@@ -1617,8 +1612,8 @@ TEST_F(DBTest2, SyncPointMarker) {
    CountSyncPoint();
  };

-  auto thread1 = port::Thread(func1);
-  auto thread2 = port::Thread(func2);
+  auto thread1 = std::thread(func1);
+  auto thread2 = std::thread(func2);
  thread1.join();
  thread2.join();

@@ -1907,8 +1902,8 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) {
    delete iter;
  };

-  rocksdb::port::Thread writer_thread(writer_func);
-  rocksdb::port::Thread reader_thread(reader_func);
+  std::thread writer_thread(writer_func);
+  std::thread reader_thread(reader_func);

  writer_thread.join();
  reader_thread.join();
@@ -2179,7 +2174,7 @@ TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {
    cro.exclusive_manual_compaction = false;
    ASSERT_OK(db_->CompactRange(cro, &k1s, &k2s));
  };
-  rocksdb::port::Thread bg_thread;
+  std::thread bg_thread;

  // While the compaction is running, we will create 2 new files that
  // can fit in L1, these 2 files will be moved to L1 and overlap with
@@ -2200,7 +2195,7 @@ TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {
        ASSERT_OK(Flush());

        // Start a non-exclusive manual compaction in a bg thread
-        bg_thread = port::Thread(bg_manual_compact);
+        bg_thread = std::thread(bg_manual_compact);
        // This manual compaction conflict with the other manual compaction
        // so it should wait until the first compaction finish
        env_->SleepForMicroseconds(1000000);
@@ -2217,87 +2212,8 @@ TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {

  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
-
-TEST_F(DBTest2, OptimizeForPointLookup) {
-  Options options = CurrentOptions();
-  Close();
-  options.OptimizeForPointLookup(2);
-  ASSERT_OK(DB::Open(options, dbname_, &db_));
-
-  ASSERT_OK(Put("foo", "v1"));
-  ASSERT_EQ("v1", Get("foo"));
-  Flush();
-  ASSERT_EQ("v1", Get("foo"));
-}
-
 #endif  // ROCKSDB_LITE

-TEST_F(DBTest2, GetRaceFlush1) {
-  ASSERT_OK(Put("foo", "v1"));
-
-  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::GetImpl:1", "DBTest2::GetRaceFlush:1"},
-       {"DBTest2::GetRaceFlush:2", "DBImpl::GetImpl:2"}});
-
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  rocksdb::port::Thread t1([&] {
-    TEST_SYNC_POINT("DBTest2::GetRaceFlush:1");
-    ASSERT_OK(Put("foo", "v2"));
-    Flush();
-    TEST_SYNC_POINT("DBTest2::GetRaceFlush:2");
-  });
-
-  // Get() is issued after the first Put(), so it should see either
-  // "v1" or "v2".
-  ASSERT_NE("NOT_FOUND", Get("foo"));
-  t1.join();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBTest2, GetRaceFlush2) {
-  ASSERT_OK(Put("foo", "v1"));
-
-  rocksdb::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::GetImpl:3", "DBTest2::GetRaceFlush:1"},
-       {"DBTest2::GetRaceFlush:2", "DBImpl::GetImpl:4"}});
-
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  port::Thread t1([&] {
-    TEST_SYNC_POINT("DBTest2::GetRaceFlush:1");
-    ASSERT_OK(Put("foo", "v2"));
-    Flush();
-    TEST_SYNC_POINT("DBTest2::GetRaceFlush:2");
-  });
-
-  // Get() is issued after the first Put(), so it should see either
-  // "v1" or "v2".
-  ASSERT_NE("NOT_FOUND", Get("foo"));
-  t1.join();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(DBTest2, DirectIO) {
-  if (!IsDirectIOSupported()) {
-    return;
-  }
-  Options options = CurrentOptions();
-  options.use_direct_reads = options.use_direct_writes = true;
-  options.allow_mmap_reads = options.allow_mmap_writes = false;
-  DestroyAndReopen(options);
-
-  ASSERT_OK(Put(Key(0), "a"));
-  ASSERT_OK(Put(Key(5), "a"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(Key(10), "a"));
-  ASSERT_OK(Put(Key(15), "a"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  Reopen(options);
-}
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -72,12 +72,7 @@ DBTestBase::~DBTestBase() {
  options.db_paths.emplace_back(dbname_ + "_2", 0);
  options.db_paths.emplace_back(dbname_ + "_3", 0);
  options.db_paths.emplace_back(dbname_ + "_4", 0);
-
-  if (getenv("KEEP_DB")) {
-    printf("DB is still at %s\n", dbname_.c_str());
-  } else {
-    EXPECT_OK(DestroyDB(dbname_, options));
-  }
+  EXPECT_OK(DestroyDB(dbname_, options));
  delete env_;
 }

@@ -313,7 +308,6 @@ Options DBTestBase::CurrentOptions(
      break;
    case kManifestFileSize:
      options.max_manifest_file_size = 50;  // 50 bytes
-      break;
    case kPerfOptions:
      options.soft_rate_limit = 2.0;
      options.delayed_write_rate = 8 * 1024 * 1024;
@@ -353,11 +347,6 @@ Options DBTestBase::CurrentOptions(
      options.prefix_extractor.reset(NewNoopTransform());
      break;
    }
-    case kBlockBasedTableWithPartitionedIndex: {
-      table_options.index_type = BlockBasedTableOptions::kTwoLevelIndexSearch;
-      options.prefix_extractor.reset(NewNoopTransform());
-      break;
-    }
    case kBlockBasedTableWithIndexRestartInterval: {
      table_options.index_block_restart_interval = 8;
      break;
@@ -488,22 +477,6 @@ Status DBTestBase::TryReopen(const Options& options) {
  return DB::Open(options, dbname_, &db_);
 }

-bool DBTestBase::IsDirectIOSupported() {
-  EnvOptions env_options;
-  env_options.use_mmap_writes = false;
-  env_options.use_direct_writes = true;
-  std::string tmp = TempFileName(dbname_, 999);
-  Status s;
-  {
-    unique_ptr<WritableFile> file;
-    s = env_->NewWritableFile(tmp, &file, env_options);
-  }
-  if (s.ok()) {
-    s = env_->DeleteFile(tmp);
-  }
-  return s.ok();
-}
-
 Status DBTestBase::Flush(int cf) {
  if (cf == 0) {
    return db_->Flush(FlushOptions());
@@ -231,20 +231,6 @@ class SpecialEnv : public EnvWrapper {
          return base_->Append(data);
        }
      }
-      Status PositionedAppend(const Slice& data, uint64_t offset) override {
-        if (env_->table_write_callback_) {
-          (*env_->table_write_callback_)();
-        }
-        if (env_->drop_writes_.load(std::memory_order_acquire)) {
-          // Drop writes on the floor
-          return Status::OK();
-        } else if (env_->no_space_.load(std::memory_order_acquire)) {
-          return Status::NoSpace("No space left on device");
-        } else {
-          env_->bytes_written_ += data.size();
-          return base_->PositionedAppend(data, offset);
-        }
-      }
      Status Truncate(uint64_t size) override { return base_->Truncate(size); }
      Status Close() override {
 // SyncPoint is not supported in Released Windows Mode.
@@ -271,9 +257,6 @@ class SpecialEnv : public EnvWrapper {
      Env::IOPriority GetIOPriority() override {
        return base_->GetIOPriority();
      }
-      bool use_direct_io() const override {
-        return base_->use_direct_io();
-      }
    };
    class ManifestFile : public WritableFile {
     public:
@@ -375,14 +358,7 @@ class SpecialEnv : public EnvWrapper {
      return Status::IOError("simulated write error");
    }

-    EnvOptions optimized = soptions;
-    if (strstr(f.c_str(), "MANIFEST") != nullptr ||
-        strstr(f.c_str(), "log") != nullptr) {
-      optimized.use_mmap_writes = false;
-      optimized.use_direct_writes = false;
-    }
-
-    Status s = target()->NewWritableFile(f, r, optimized);
+    Status s = target()->NewWritableFile(f, r, soptions);
    if (s.ok()) {
      if (strstr(f.c_str(), ".sst") != nullptr) {
        r->reset(new SSTableFile(this, std::move(*r)));
@@ -618,7 +594,6 @@ class DBTestBase : public testing::Test {
    kLevelSubcompactions = 31,
    kUniversalSubcompactions = 32,
    kBlockBasedTableWithIndexRestartInterval = 33,
-    kBlockBasedTableWithPartitionedIndex = 34,
  };
  int option_config_;

@@ -717,8 +692,6 @@ class DBTestBase : public testing::Test {

  Status TryReopen(const Options& options);

-  bool IsDirectIOSupported();
-
  Status Flush(int cf = 0);

  Status Put(const Slice& k, const Slice& v, WriteOptions wo = WriteOptions());
@@ -858,10 +831,10 @@ class DBTestBase : public testing::Test {

  std::vector<std::uint64_t> ListTableFiles(Env* env, const std::string& path);

-  void VerifyDBFromMap(
-      std::map<std::string, std::string> true_data,
-      size_t* total_reads_res = nullptr, bool tailing_iter = false,
-      std::map<std::string, Status> status = std::map<std::string, Status>());
+  void VerifyDBFromMap(std::map<std::string, std::string> true_data,
+                       size_t* total_reads_res = nullptr,
+                       bool tailing_iter = false,
+                       std::map<std::string, Status> status = {});

  void VerifyDBInternal(
      std::vector<std::pair<std::string, std::string>> true_data);
@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/db_test_util.h"
-#include "port/port.h"
 #include "port/stack_trace.h"
 #include "util/fault_injection_test_env.h"
 #include "util/options_helper.h"
@@ -87,7 +86,7 @@ TEST_F(DBWALTest, SyncWALNotBlockWrite) {
  });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  rocksdb::port::Thread thread([&]() { ASSERT_OK(db_->SyncWAL()); });
+  std::thread thread([&]() { ASSERT_OK(db_->SyncWAL()); });

  TEST_SYNC_POINT("DBWALTest::SyncWALNotBlockWrite:1");
  ASSERT_OK(Put("foo2", "bar2"));
@@ -119,7 +118,7 @@ TEST_F(DBWALTest, SyncWALNotWaitWrite) {
  });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  rocksdb::port::Thread thread([&]() { ASSERT_OK(Put("foo2", "bar2")); });
+  std::thread thread([&]() { ASSERT_OK(Put("foo2", "bar2")); });
  TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:1");
  ASSERT_OK(db_->SyncWAL());
  TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:2");
@@ -528,11 +528,10 @@ struct RangeTombstone {
  Slice start_key_;
  Slice end_key_;
  SequenceNumber seq_;
-  RangeTombstone() = default;
-  RangeTombstone(Slice sk, Slice ek, SequenceNumber sn)
+  explicit RangeTombstone(Slice sk, Slice ek, SequenceNumber sn)
      : start_key_(sk), end_key_(ek), seq_(sn) {}

-  RangeTombstone(ParsedInternalKey parsed_key, Slice value) {
+  explicit RangeTombstone(ParsedInternalKey parsed_key, Slice value) {
    start_key_ = parsed_key.user_key;
    seq_ = parsed_key.sequence;
    end_key_ = value;
@@ -128,7 +128,7 @@ void EventHelpers::LogAndNotifyTableFileDeletion(
  info.job_id = job_id;
  info.file_path = file_path;
  info.status = status;
-  for (auto& listener : listeners) {
+  for (auto listener : listeners) {
    listener->OnTableFileDeleted(info);
  }
 #endif  // !ROCKSDB_LITE
@@ -13,7 +13,7 @@
 #include <vector>

 #include "db/version_edit.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "table/scoped_arena_iterator.h"
 #include "table/sst_file_writer_collectors.h"
 #include "table/table_builder.h"
@@ -96,12 +96,10 @@ Status ExternalSstFileIngestionJob::Prepare(
      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
-        status = CopyFile(env_, path_outside_db, path_inside_db, 0,
-                          db_options_.use_fsync);
+        status = CopyFile(env_, path_outside_db, path_inside_db, 0);
      }
    } else {
-      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
-                        db_options_.use_fsync);
+      status = CopyFile(env_, path_outside_db, path_inside_db, 0);
    }
    TEST_SYNC_POINT("DBImpl::AddFile:FileCopied");
    if (!status.ok()) {
@@ -306,16 +304,8 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
    if (file_to_ingest->global_seqno_offset == 0) {
      return Status::Corruption("Was not able to find file global seqno field");
    }
-  } else if (file_to_ingest->version == 1) {
-    // SST file V1 should not have global seqno field
-    assert(seqno_iter == uprops.end());
-    if (ingestion_options_.allow_blocking_flush ||
-            ingestion_options_.allow_global_seqno) {
-      return Status::InvalidArgument(
-            "External SST file V1 does not support global seqno");
-    }
  } else {
-    return Status::InvalidArgument("External file version is not supported");
+    return Status::InvalidArgument("external file version is not supported");
  }
  // Get number of entries in table
  file_to_ingest->num_entries = props->num_entries;
@@ -3,8 +3,6 @@
 //  LICENSE file in the root directory of this source tree. An additional grant
 //  of patent rights can be found in the PATENTS file in the same directory.

-#include <functional>
-
 #include "db/db_test_util.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
@@ -141,9 +139,6 @@ TEST_F(ExternalSSTFileTest, Basic) {

    SstFileWriter sst_file_writer(EnvOptions(), options, options.comparator);

-    // Current file size should be 0 after sst_file_writer init and before open a file.
-    ASSERT_EQ(sst_file_writer.FileSize(), 0);
-
    // file1.sst (0 => 99)
    std::string file1 = sst_files_dir_ + "file1.sst";
    ASSERT_OK(sst_file_writer.Open(file1));
@@ -153,10 +148,6 @@ TEST_F(ExternalSSTFileTest, Basic) {
    ExternalSstFileInfo file1_info;
    Status s = sst_file_writer.Finish(&file1_info);
    ASSERT_TRUE(s.ok()) << s.ToString();
-
-    // Current file size should be non-zero after success write.
-    ASSERT_GT(sst_file_writer.FileSize(), 0);
-
    ASSERT_EQ(file1_info.file_path, file1);
    ASSERT_EQ(file1_info.num_entries, 100);
    ASSERT_EQ(file1_info.smallest_key, Key(0));
@@ -191,10 +182,7 @@ TEST_F(ExternalSSTFileTest, Basic) {
    }
    ExternalSstFileInfo file3_info;
    s = sst_file_writer.Finish(&file3_info);
-
    ASSERT_TRUE(s.ok()) << s.ToString();
-    // Current file size should be non-zero after success finish.
-    ASSERT_GT(sst_file_writer.FileSize(), 0);
    ASSERT_EQ(file3_info.file_path, file3);
    ASSERT_EQ(file3_info.num_entries, 105);
    ASSERT_EQ(file3_info.smallest_key, Key(195));
@@ -258,11 +246,11 @@ TEST_F(ExternalSSTFileTest, Basic) {
      ASSERT_EQ(Get(Key(k)), Key(k) + "_val");
    }

-    // This file has overlapping values with the existing data
+    // This file has overlapping values with the exisitng data
    s = DeprecatedAddFile({file3});
    ASSERT_FALSE(s.ok()) << s.ToString();

-    // This file has overlapping values with the existing data
+    // This file has overlapping values with the exisitng data
    s = DeprecatedAddFile({file4});
    ASSERT_FALSE(s.ok()) << s.ToString();

@@ -510,7 +498,7 @@ TEST_F(ExternalSSTFileTest, AddList) {
      ASSERT_EQ(user_props["xyz_Count"], "100");
    }

-    // This file list has overlapping values with the existing data
+    // This file list has overlapping values with the exisitng data
    s = DeprecatedAddFile(file_list3);
    ASSERT_FALSE(s.ok()) << s.ToString();

@@ -705,7 +693,7 @@ TEST_F(ExternalSSTFileTest, NoCopy) {
  ASSERT_TRUE(s.ok()) << s.ToString();
  ASSERT_OK(env_->FileExists(file2));

-  // This file have overlapping values with the existing data
+  // This file have overlapping values with the exisitng data
  s = DeprecatedAddFile({file2}, true /* move file */);
  ASSERT_FALSE(s.ok()) << s.ToString();
  ASSERT_OK(env_->FileExists(file3));
@@ -821,7 +809,7 @@ TEST_F(ExternalSSTFileTest, MultiThreaded) {
      ASSERT_TRUE(s.ok()) << s.ToString();
    };
    // Write num_files files in parallel
-    std::vector<port::Thread> sst_writer_threads;
+    std::vector<std::thread> sst_writer_threads;
    for (int i = 0; i < num_files; ++i) {
      sst_writer_threads.emplace_back(write_file_func);
    }
@@ -864,7 +852,7 @@ TEST_F(ExternalSSTFileTest, MultiThreaded) {
    };

    // Bulk load num_files files in parallel
-    std::vector<port::Thread> add_file_threads;
+    std::vector<std::thread> add_file_threads;
    DestroyAndReopen(options);
    for (int i = 0; i < num_files; ++i) {
      add_file_threads.emplace_back(load_file_func);
@@ -1108,13 +1096,13 @@ TEST_F(ExternalSSTFileTest, PickedLevelBug) {
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // While writing the MANIFEST start a thread that will ask for compaction
-  rocksdb::port::Thread bg_compact([&]() {
+  std::thread bg_compact([&]() {
    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  });
  TEST_SYNC_POINT("ExternalSSTFileTest::PickedLevelBug:2");

  // Start a thread that will ingest a new file
-  rocksdb::port::Thread bg_addfile([&]() {
+  std::thread bg_addfile([&]() {
    file_keys = {1, 2, 3};
    ASSERT_OK(GenerateAndAddExternalFile(options, file_keys, 1));
  });
@@ -1169,7 +1157,7 @@ TEST_F(ExternalSSTFileTest, CompactDuringAddFileRandom) {
    ASSERT_OK(GenerateAndAddExternalFile(options, file_keys, range_id));
  };

-  std::vector<port::Thread> threads;
+  std::vector<std::thread> threads;
  while (range_id < 5000) {
    int range_start = range_id * 10;
    int range_end = range_start + 10;
@@ -1728,7 +1716,7 @@ TEST_F(ExternalSSTFileTest, CompactionDeadlock) {
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

  // Start ingesting and extrnal file in the background
-  rocksdb::port::Thread bg_ingest_file([&]() {
+  std::thread bg_ingest_file([&]() {
    running_threads += 1;
    ASSERT_OK(GenerateAndAddExternalFile(options, {5, 6}));
    running_threads -= 1;
@@ -1748,7 +1736,7 @@ TEST_F(ExternalSSTFileTest, CompactionDeadlock) {

  // This thread will try to insert into the memtable but since we have 4 L0
  // files this thread will be blocked and hold the writer thread
-  rocksdb::port::Thread bg_block_put([&]() {
+  std::thread bg_block_put([&]() {
    running_threads += 1;
    ASSERT_OK(Put(Key(10), "memtable"));
    running_threads -= 1;
@@ -1760,6 +1748,8 @@ TEST_F(ExternalSSTFileTest, CompactionDeadlock) {
  // `DBImpl::AddFile:Start` will wait until we be here
  TEST_SYNC_POINT("ExternalSSTFileTest::DeadLock:1");

+  ASSERT_EQ(running_threads.load(), 2);
+
  // Wait for IngestExternalFile() to start and aquire mutex
  TEST_SYNC_POINT("ExternalSSTFileTest::DeadLock:2");

@@ -1945,47 +1935,6 @@ TEST_F(ExternalSSTFileTest, SnapshotInconsistencyBug) {
  db_->ReleaseSnapshot(snap);
 }

-TEST_F(ExternalSSTFileTest, FadviseTrigger) {
-  Options options = CurrentOptions();
-  const int kNumKeys = 10000;
-
-  size_t total_fadvised_bytes = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileWriter::InvalidatePageCache", [&](void* arg) {
-        size_t fadvise_size = *(reinterpret_cast<size_t*>(arg));
-        total_fadvised_bytes += fadvise_size;
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::unique_ptr<SstFileWriter> sst_file_writer;
-
-  std::string sst_file_path = sst_files_dir_ + "file_fadvise_disable.sst";
-  sst_file_writer.reset(new SstFileWriter(EnvOptions(), options,
-                                          options.comparator, nullptr, false));
-  ASSERT_OK(sst_file_writer->Open(sst_file_path));
-  for (int i = 0; i < kNumKeys; i++) {
-    ASSERT_OK(sst_file_writer->Add(Key(i), Key(i)));
-  }
-  ASSERT_OK(sst_file_writer->Finish());
-  // fadvise disabled
-  ASSERT_EQ(total_fadvised_bytes, 0);
-
-
-  sst_file_path = sst_files_dir_ + "file_fadvise_enable.sst";
-  sst_file_writer.reset(new SstFileWriter(EnvOptions(), options,
-                                          options.comparator, nullptr, true));
-  ASSERT_OK(sst_file_writer->Open(sst_file_path));
-  for (int i = 0; i < kNumKeys; i++) {
-    ASSERT_OK(sst_file_writer->Add(Key(i), Key(i)));
-  }
-  ASSERT_OK(sst_file_writer->Finish());
-  // fadvise enabled
-  ASSERT_EQ(total_fadvised_bytes, sst_file_writer->FileSize());
-  ASSERT_GT(total_fadvised_bytes, 0);
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 #endif  // ROCKSDB_LITE

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

 #include "db/file_indexer.h"
 #include <algorithm>
-#include <functional>
-#include "db/version_edit.h"
 #include "rocksdb/comparator.h"
+#include "db/version_edit.h"

 namespace rocksdb {

@@ -38,7 +38,7 @@
 #include "rocksdb/table.h"
 #include "table/block.h"
 #include "table/block_based_table_factory.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "table/table_builder.h"
 #include "table/two_level_iterator.h"
 #include "util/coding.h"
@@ -230,12 +230,6 @@ Status FlushJob::Run(FileMetaData* file_meta) {
  return s;
 }

-void FlushJob::Cancel() {
-  db_mutex_->AssertHeld();
-  assert(base_ != nullptr);
-  base_->Unref();
-}
-
 Status FlushJob::WriteLevel0Table() {
  AutoThreadOperationStageUpdater stage_updater(
      ThreadStatus::STAGE_FLUSH_WRITE_L0);
@@ -67,11 +67,9 @@ class FlushJob {

  ~FlushJob();

-  // Require db_mutex held.
-  // Once PickMemTable() is called, either Run() or Cancel() has to be call.
+  // Require db_mutex held
  void PickMemTable();
  Status Run(FileMetaData* file_meta = nullptr);
-  void Cancel();
  TableProperties GetTableProperties() const { return table_properties_; }

 private:
@@ -18,7 +18,7 @@
 #include "rocksdb/env.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/slice_transform.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "util/string_util.h"
 #include "util/sync_point.h"

@@ -69,18 +69,12 @@ class LevelIterator : public InternalIterator {
      delete file_iter_;
    }

-    RangeDelAggregator range_del_agg(
-        cfd_->internal_comparator(), {} /* snapshots */);
    file_iter_ = cfd_->table_cache()->NewIterator(
        read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
-        files_[file_index_]->fd, read_options_.ignore_range_deletions ? nullptr : &range_del_agg,
+        files_[file_index_]->fd, nullptr /* range_del_agg */,
        nullptr /* table_reader_ptr */, nullptr, false);
+
    file_iter_->SetPinnedItersMgr(pinned_iters_mgr_);
-    if (!range_del_agg.IsEmpty()) {
-      status_ = Status::NotSupported(
-          "Range tombstones unsupported with ForwardIterator");
-      valid_ = false;
-    }
  }
  void SeekToLast() override {
    status_ = Status::NotSupported("LevelIterator::SeekToLast()");
@@ -564,17 +558,8 @@ void ForwardIterator::RebuildIterators(bool refresh_sv) {
    // New
    sv_ = cfd_->GetReferencedSuperVersion(&(db_->mutex_));
  }
-  RangeDelAggregator range_del_agg(
-      InternalKeyComparator(cfd_->internal_comparator()), {} /* snapshots */);
  mutable_iter_ = sv_->mem->NewIterator(read_options_, &arena_);
  sv_->imm->AddIterators(read_options_, &imm_iters_, &arena_);
-  if (!read_options_.ignore_range_deletions) {
-    std::unique_ptr<InternalIterator> range_del_iter(
-        sv_->mem->NewRangeTombstoneIterator(read_options_));
-    range_del_agg.AddTombstones(std::move(range_del_iter));
-    sv_->imm->AddRangeTombstoneIterators(read_options_, &arena_,
-                                         &range_del_agg);
-  }
  has_iter_trimmed_for_upper_bound_ = false;

  const auto* vstorage = sv_->current->storage_info();
@@ -590,18 +575,13 @@ void ForwardIterator::RebuildIterators(bool refresh_sv) {
    }
    l0_iters_.push_back(cfd_->table_cache()->NewIterator(
        read_options_, *cfd_->soptions(), cfd_->internal_comparator(), l0->fd,
-        read_options_.ignore_range_deletions ? nullptr : &range_del_agg));
+        nullptr /* range_del_agg */));
  }
  BuildLevelIterators(vstorage);
  current_ = nullptr;
  is_prev_set_ = false;

  UpdateChildrenPinnedItersMgr();
-  if (!range_del_agg.IsEmpty()) {
-    status_ = Status::NotSupported(
-        "Range tombstones unsupported with ForwardIterator");
-    valid_ = false;
-  }
 }

 void ForwardIterator::RenewIterators() {
@@ -619,15 +599,6 @@ void ForwardIterator::RenewIterators() {

  mutable_iter_ = svnew->mem->NewIterator(read_options_, &arena_);
  svnew->imm->AddIterators(read_options_, &imm_iters_, &arena_);
-  RangeDelAggregator range_del_agg(
-      InternalKeyComparator(cfd_->internal_comparator()), {} /* snapshots */);
-  if (!read_options_.ignore_range_deletions) {
-    std::unique_ptr<InternalIterator> range_del_iter(
-        svnew->mem->NewRangeTombstoneIterator(read_options_));
-    range_del_agg.AddTombstones(std::move(range_del_iter));
-    sv_->imm->AddRangeTombstoneIterators(read_options_, &arena_,
-                                         &range_del_agg);
-  }

  const auto* vstorage = sv_->current->storage_info();
  const auto& l0_files = vstorage->LevelFiles(0);
@@ -659,8 +630,7 @@ void ForwardIterator::RenewIterators() {
    }
    l0_iters_new.push_back(cfd_->table_cache()->NewIterator(
        read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
-        l0_files_new[inew]->fd,
-        read_options_.ignore_range_deletions ? nullptr : &range_del_agg));
+        l0_files_new[inew]->fd, nullptr /* range_del_agg */));
  }

  for (auto* f : l0_iters_) {
@@ -680,11 +650,6 @@ void ForwardIterator::RenewIterators() {
  sv_ = svnew;

  UpdateChildrenPinnedItersMgr();
-  if (!range_del_agg.IsEmpty()) {
-    status_ = Status::NotSupported(
-        "Range tombstones unsupported with ForwardIterator");
-    valid_ = false;
-  }
 }

 void ForwardIterator::BuildLevelIterators(const VersionStorageInfo* vstorage) {
@@ -34,7 +34,6 @@ int main() { return 0; }
 #include "rocksdb/db.h"
 #include "rocksdb/status.h"
 #include "rocksdb/table.h"
-#include "port/port.h"
 #include "util/testharness.h"

 const int MAX_SHARDS = 100000;
@@ -95,7 +94,7 @@ struct Reader {
  explicit Reader(std::vector<ShardState>* shard_states, rocksdb::DB* db)
      : shard_states_(shard_states), db_(db) {
    sem_init(&sem_, 0, 0);
-    thread_ = port::Thread(&Reader::run, this);
+    thread_ = std::thread(&Reader::run, this);
  }

  void run() {
@@ -194,7 +193,7 @@ struct Reader {
  char pad1[128] __attribute__((__unused__));
  std::vector<ShardState>* shard_states_;
  rocksdb::DB* db_;
-  rocksdb::port::Thread thread_;
+  std::thread thread_;
  sem_t sem_;
  std::mutex queue_mutex_;
  std::bitset<MAX_SHARDS + 1> shards_pending_set_;
@@ -207,7 +206,7 @@ struct Writer {
  explicit Writer(std::vector<ShardState>* shard_states, rocksdb::DB* db)
      : shard_states_(shard_states), db_(db) {}

-  void start() { thread_ = port::Thread(&Writer::run, this); }
+  void start() { thread_ = std::thread(&Writer::run, this); }

  void run() {
    std::queue<std::chrono::steady_clock::time_point> workq;
@@ -264,7 +263,7 @@ struct Writer {
  char pad1[128] __attribute__((__unused__));
  std::vector<ShardState>* shard_states_;
  rocksdb::DB* db_;
-  rocksdb::port::Thread thread_;
+  std::thread thread_;
  char pad2[128] __attribute__((__unused__));
 };

@@ -314,7 +313,7 @@ struct StatsThread {
  rocksdb::DB* db_;
  std::mutex cvm_;
  std::condition_variable cv_;
-  rocksdb::port::Thread thread_;
+  std::thread thread_;
  std::atomic<bool> done_{false};
 };

@@ -331,7 +330,7 @@ int main(int argc, char** argv) {
  options.compaction_style = rocksdb::CompactionStyle::kCompactionStyleNone;
  options.level0_slowdown_writes_trigger = 99999;
  options.level0_stop_writes_trigger = 99999;
-  options.use_direct_writes = true;
+  options.allow_os_buffer = false;
  options.write_buffer_size = FLAGS_memtable_size;
  rocksdb::BlockBasedTableOptions table_options;
  table_options.block_cache = rocksdb::NewLRUCache(FLAGS_block_cache_size);
@@ -221,7 +221,6 @@ static const std::string num_live_versions = "num-live-versions";
 static const std::string current_version_number =
    "current-super-version-number";
 static const std::string estimate_live_data_size = "estimate-live-data-size";
-static const std::string min_log_number_to_keep = "min-log-number-to-keep";
 static const std::string base_level = "base-level";
 static const std::string total_sst_files_size = "total-sst-files-size";
 static const std::string estimate_pending_comp_bytes =
@@ -286,8 +285,6 @@ const std::string DB::Properties::kCurrentSuperVersionNumber =
    rocksdb_prefix + current_version_number;
 const std::string DB::Properties::kEstimateLiveDataSize =
                      rocksdb_prefix + estimate_live_data_size;
-const std::string DB::Properties::kMinLogNumberToKeep =
-    rocksdb_prefix + min_log_number_to_keep;
 const std::string DB::Properties::kTotalSstFilesSize =
                      rocksdb_prefix + total_sst_files_size;
 const std::string DB::Properties::kBaseLevel = rocksdb_prefix + base_level;
@@ -371,8 +368,6 @@ const std::unordered_map<std::string, DBPropertyInfo>
          nullptr}},
        {DB::Properties::kEstimateLiveDataSize,
         {true, nullptr, &InternalStats::HandleEstimateLiveDataSize, nullptr}},
-        {DB::Properties::kMinLogNumberToKeep,
-         {false, nullptr, &InternalStats::HandleMinLogNumberToKeep, nullptr}},
        {DB::Properties::kBaseLevel,
         {false, nullptr, &InternalStats::HandleBaseLevel, nullptr}},
        {DB::Properties::kTotalSstFilesSize,
@@ -710,12 +705,6 @@ bool InternalStats::HandleEstimateLiveDataSize(uint64_t* value, DBImpl* db,
  return true;
 }

-bool InternalStats::HandleMinLogNumberToKeep(uint64_t* value, DBImpl* db,
-                                             Version* version) {
-  *value = db->MinLogNumberToKeep();
-  return true;
-}
-
 void InternalStats::DumpDBStats(std::string* value) {
  char buf[1000];
  // DB-level stats, only available from default column family
@@ -865,7 +854,7 @@ void InternalStats::DumpCFMapStats(std::map<std::string, double>* cf_stats) {
  }
 }

-void InternalStats::DumpCFMapStats(
+int InternalStats::DumpCFMapStats(
    std::map<int, std::map<LevelStatType, double>>* levels_stats,
    CompactionStats* compaction_stats_sum) {
  const VersionStorageInfo* vstorage = cfd_->current()->storage_info();
@@ -925,10 +914,11 @@ void InternalStats::DumpCFMapStats(
  PrepareLevelStats(&sum_stats, total_files, total_files_being_compacted,
                    total_file_size, 0, w_amp, *compaction_stats_sum);
  (*levels_stats)[-1] = sum_stats;  //  -1 is for the Sum level
+  return num_levels_to_check;
 }

 void InternalStats::DumpCFStats(std::string* value) {
-  char buf[2000];
+  char buf[1000];
  // Per-ColumnFamily stats
  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
  value->append(buf);
@@ -936,8 +926,8 @@ void InternalStats::DumpCFStats(std::string* value) {
  // Print stats for each level
  std::map<int, std::map<LevelStatType, double>> levels_stats;
  CompactionStats compaction_stats_sum(0);
-  DumpCFMapStats(&levels_stats, &compaction_stats_sum);
-  for (int l = 0; l < number_levels_; ++l) {
+  int levels = DumpCFMapStats(&levels_stats, &compaction_stats_sum);
+  for (int l = 0; l < levels; ++l) {
    if (levels_stats.find(l) != levels_stats.end()) {
      PrintLevelStats(buf, sizeof(buf), "L" + ToString(l), levels_stats[l]);
      value->append(buf);
@@ -273,7 +273,7 @@ class InternalStats {
 private:
  void DumpDBStats(std::string* value);
  void DumpCFMapStats(std::map<std::string, double>* cf_stats);
-  void DumpCFMapStats(
+  int DumpCFMapStats(
      std::map<int, std::map<LevelStatType, double>>* level_stats,
      CompactionStats* compaction_stats_sum);
  void DumpCFStats(std::string* value);
@@ -401,7 +401,6 @@ class InternalStats {
                                     Version* version);
  bool HandleEstimateLiveDataSize(uint64_t* value, DBImpl* db,
                                  Version* version);
-  bool HandleMinLogNumberToKeep(uint64_t* value, DBImpl* db, Version* version);

  // Total number of background errors encountered. Every time a flush task
  // or compaction task fails, this counter is incremented. The failure can
@@ -119,7 +119,7 @@ TEST_F(EventListenerTest, OnSingleDBCompactionTest) {
  options.max_bytes_for_level_base = options.target_file_size_base * 2;
  options.max_bytes_for_level_multiplier = 2;
  options.compression = kNoCompression;
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  options.enable_thread_tracking = true;
 #endif  // ROCKSDB_USING_THREAD_STATUS
  options.level0_file_num_compaction_trigger = kNumL0Files;
@@ -176,7 +176,7 @@ class TestFlushListener : public EventListener {
    ASSERT_GT(info.table_properties.num_data_blocks, 0U);
    ASSERT_GT(info.table_properties.num_entries, 0U);

-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
    // Verify the id of the current thread that created this table
    // file matches the id of any active flush or compaction thread.
    uint64_t thread_id = env_->GetThreadID();
@@ -232,7 +232,7 @@ class TestFlushListener : public EventListener {
 TEST_F(EventListenerTest, OnSingleDBFlushTest) {
  Options options;
  options.write_buffer_size = k110KB;
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  options.enable_thread_tracking = true;
 #endif  // ROCKSDB_USING_THREAD_STATUS
  TestFlushListener* listener = new TestFlushListener(options.env);
@@ -268,7 +268,7 @@ TEST_F(EventListenerTest, OnSingleDBFlushTest) {
 TEST_F(EventListenerTest, MultiCF) {
  Options options;
  options.write_buffer_size = k110KB;
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  options.enable_thread_tracking = true;
 #endif  // ROCKSDB_USING_THREAD_STATUS
  TestFlushListener* listener = new TestFlushListener(options.env);
@@ -302,7 +302,7 @@ TEST_F(EventListenerTest, MultiCF) {

 TEST_F(EventListenerTest, MultiDBMultiListeners) {
  Options options;
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  options.enable_thread_tracking = true;
 #endif  // ROCKSDB_USING_THREAD_STATUS
  options.table_properties_collector_factories.push_back(
@@ -384,7 +384,7 @@ TEST_F(EventListenerTest, MultiDBMultiListeners) {

 TEST_F(EventListenerTest, DisableBGCompaction) {
  Options options;
-#ifdef ROCKSDB_USING_THREAD_STATUS
+#if ROCKSDB_USING_THREAD_STATUS
  options.enable_thread_tracking = true;
 #endif  // ROCKSDB_USING_THREAD_STATUS
  TestFlushListener* listener = new TestFlushListener(options.env);
@@ -19,7 +19,7 @@
 #include "rocksdb/env.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/slice_transform.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "util/xfunc.h"

 namespace rocksdb {
@@ -26,7 +26,7 @@
 #include "rocksdb/write_buffer_manager.h"
 #include "table/internal_iterator.h"
 #include "table/iterator_wrapper.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "util/arena.h"
 #include "util/autovector.h"
 #include "util/coding.h"
@@ -390,16 +390,16 @@ port::RWMutex* MemTable::GetLock(const Slice& key) {
  return &locks_[hash(key) % locks_.size()];
 }

-MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
-                                                   const Slice& end_ikey) {
+uint64_t MemTable::ApproximateSize(const Slice& start_ikey,
+                                   const Slice& end_ikey) {
  uint64_t entry_count = table_->ApproximateNumEntries(start_ikey, end_ikey);
  entry_count += range_del_table_->ApproximateNumEntries(start_ikey, end_ikey);
  if (entry_count == 0) {
-    return {0, 0};
+    return 0;
  }
  uint64_t n = num_entries_.load(std::memory_order_relaxed);
  if (n == 0) {
-    return {0, 0};
+    return 0;
  }
  if (entry_count > n) {
    // (range_del_)table_->ApproximateNumEntries() is just an estimate so it can
@@ -408,7 +408,7 @@ MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
    entry_count = n;
  }
  uint64_t data_size = data_size_.load(std::memory_order_relaxed);
-  return {entry_count * (data_size / n), entry_count};
+  return entry_count * (data_size / n);
 }

 void MemTable::Add(SequenceNumber s, ValueType type,
@@ -560,7 +560,7 @@ static bool SaveValue(void* arg, const char* entry) {
    ValueType type;
    UnPackSequenceAndType(tag, &s->seq, &type);

-    if ((type == kTypeValue || type == kTypeMerge) &&
+    if ((type == kTypeValue || type == kTypeDeletion) &&
        range_del_agg->ShouldDelete(Slice(key_ptr, key_length))) {
      type = kTypeRangeDeletion;
    }
@@ -717,22 +717,29 @@ void MemTable::Update(SequenceNumber seq,
      ValueType type;
      SequenceNumber unused;
      UnPackSequenceAndType(tag, &unused, &type);
-      if (type == kTypeValue) {
-        Slice prev_value = GetLengthPrefixedSlice(key_ptr + key_length);
-        uint32_t prev_size = static_cast<uint32_t>(prev_value.size());
-        uint32_t new_size = static_cast<uint32_t>(value.size());
+      switch (type) {
+        case kTypeValue: {
+          Slice prev_value = GetLengthPrefixedSlice(key_ptr + key_length);
+          uint32_t prev_size = static_cast<uint32_t>(prev_value.size());
+          uint32_t new_size = static_cast<uint32_t>(value.size());

-        // Update value, if new value size  <= previous value size
-        if (new_size <= prev_size ) {
-          char* p = EncodeVarint32(const_cast<char*>(key_ptr) + key_length,
-                                   new_size);
-          WriteLock wl(GetLock(lkey.user_key()));
-          memcpy(p, value.data(), value.size());
-          assert((unsigned)((p + value.size()) - entry) ==
-                 (unsigned)(VarintLength(key_length) + key_length +
-                            VarintLength(value.size()) + value.size()));
-          return;
+          // Update value, if new value size  <= previous value size
+          if (new_size <= prev_size ) {
+            char* p = EncodeVarint32(const_cast<char*>(key_ptr) + key_length,
+                                     new_size);
+            WriteLock wl(GetLock(lkey.user_key()));
+            memcpy(p, value.data(), value.size());
+            assert((unsigned)((p + value.size()) - entry) ==
+                   (unsigned)(VarintLength(key_length) + key_length +
+                              VarintLength(value.size()) + value.size()));
+            return;
+          }
        }
+        default:
+          // If the latest value is kTypeDeletion, kTypeMerge or kTypeLogData
+          // we don't have enough space for update inplace
+            Add(seq, kTypeValue, key, value);
+            return;
      }
    }
  }
@@ -326,13 +326,7 @@ class MemTable {
    return table_->IsSnapshotSupported() && !moptions_.inplace_update_support;
  }

-  struct MemTableStats {
-    uint64_t size;
-    uint64_t count;
-  };
-
-  MemTableStats ApproximateStats(const Slice& start_ikey,
-                                 const Slice& end_ikey);
+  uint64_t ApproximateSize(const Slice& start_ikey, const Slice& end_ikey);

  // Get the lock associated for the key
  port::RWMutex* GetLock(const Slice& key);
@@ -16,7 +16,7 @@
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "util/coding.h"
 #include "util/log_buffer.h"
 #include "util/sync_point.h"
@@ -190,15 +190,13 @@ uint64_t MemTableListVersion::GetTotalNumEntries() const {
  return total_num;
 }

-MemTable::MemTableStats MemTableListVersion::ApproximateStats(
-    const Slice& start_ikey, const Slice& end_ikey) {
-  MemTable::MemTableStats total_stats = {0, 0};
+uint64_t MemTableListVersion::ApproximateSize(const Slice& start_ikey,
+                                              const Slice& end_ikey) {
+  uint64_t total_size = 0;
  for (auto& m : memlist_) {
-    auto mStats = m->ApproximateStats(start_ikey, end_ikey);
-    total_stats.size += mStats.size;
-    total_stats.count += mStats.count;
+    total_size += m->ApproximateSize(start_ikey, end_ikey);
  }
-  return total_stats;
+  return total_size;
 }

 uint64_t MemTableListVersion::GetTotalNumDeletes() const {
@@ -95,8 +95,7 @@ class MemTableListVersion {

  uint64_t GetTotalNumDeletes() const;

-  MemTable::MemTableStats ApproximateStats(const Slice& start_ikey,
-                                           const Slice& end_ikey);
+  uint64_t ApproximateSize(const Slice& start_ikey, const Slice& end_ikey);

  // Returns the value of MemTable::GetEarliestSequenceNumber() on the most
  // recent MemTable in this list or kMaxSequenceNumber if the list is empty.
@@ -222,8 +221,6 @@ class MemTableList {
  // PickMemtablesToFlush() is called.
  void FlushRequested() { flush_requested_ = true; }

-  bool HasFlushRequested() { return flush_requested_; }
-
  // Copying allowed
  // MemTableList(const MemTableList&);
  // void operator=(const MemTableList&);
@@ -426,7 +426,7 @@ class Benchmark {
  virtual ~Benchmark() {}
  virtual void Run() {
    std::cout << "Number of threads: " << num_threads_ << std::endl;
-    std::vector<port::Thread> threads;
+    std::vector<std::thread> threads;
    uint64_t bytes_written = 0;
    uint64_t bytes_read = 0;
    uint64_t read_hits = 0;
@@ -457,7 +457,7 @@ class Benchmark {
    }
  }

-  virtual void RunThreads(std::vector<port::Thread>* threads,
+  virtual void RunThreads(std::vector<std::thread>* threads,
                          uint64_t* bytes_written, uint64_t* bytes_read,
                          bool write, uint64_t* read_hits) = 0;

@@ -478,7 +478,7 @@ class FillBenchmark : public Benchmark {
    num_write_ops_per_thread_ = FLAGS_num_operations;
  }

-  void RunThreads(std::vector<port::Thread>* threads, uint64_t* bytes_written,
+  void RunThreads(std::vector<std::thread>* threads, uint64_t* bytes_written,
                  uint64_t* bytes_read, bool write,
                  uint64_t* read_hits) override {
    FillBenchmarkThread(table_, key_gen_, bytes_written, bytes_read, sequence_,
@@ -494,7 +494,7 @@ class ReadBenchmark : public Benchmark {
    num_read_ops_per_thread_ = FLAGS_num_operations / FLAGS_num_threads;
  }

-  void RunThreads(std::vector<port::Thread>* threads, uint64_t* bytes_written,
+  void RunThreads(std::vector<std::thread>* threads, uint64_t* bytes_written,
                  uint64_t* bytes_read, bool write,
                  uint64_t* read_hits) override {
    for (int i = 0; i < FLAGS_num_threads; ++i) {
@@ -518,7 +518,7 @@ class SeqReadBenchmark : public Benchmark {
    num_read_ops_per_thread_ = FLAGS_num_scans;
  }

-  void RunThreads(std::vector<port::Thread>* threads, uint64_t* bytes_written,
+  void RunThreads(std::vector<std::thread>* threads, uint64_t* bytes_written,
                  uint64_t* bytes_read, bool write,
                  uint64_t* read_hits) override {
    for (int i = 0; i < FLAGS_num_threads; ++i) {
@@ -545,7 +545,7 @@ class ReadWriteBenchmark : public Benchmark {
    num_write_ops_per_thread_ = FLAGS_num_operations;
  }

-  void RunThreads(std::vector<port::Thread>* threads, uint64_t* bytes_written,
+  void RunThreads(std::vector<std::thread>* threads, uint64_t* bytes_written,
                  uint64_t* bytes_read, bool write,
                  uint64_t* read_hits) override {
    std::atomic_int threads_done;
@@ -104,10 +104,6 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
  Status s;
  bool hit_the_next_user_key = false;
  for (; iter->Valid(); iter->Next(), original_key_is_iter = false) {
-    if (IsShuttingDown()) {
-      return Status::ShutdownInProgress();
-    }
-
    ParsedInternalKey ikey;
    assert(keys_.size() == merge_context_.GetNumOperands());

@@ -196,10 +192,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
              ? CompactionFilter::Decision::kKeep
              : FilterMerge(orig_ikey.user_key, value_slice);
      if (range_del_agg != nullptr &&
-
-          range_del_agg->ShouldDelete(
-              iter->key(),
-              RangeDelAggregator::RangePositioningMode::kForwardTraversal) &&
+          range_del_agg->ShouldDelete(iter->key()) &&
          filter != CompactionFilter::Decision::kRemoveAndSkipUntil) {
        filter = CompactionFilter::Decision::kRemove;
      }
@@ -282,6 +275,10 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
    // We haven't seen the beginning of the key nor a Put/Delete.
    // Attempt to use the user's associative merge function to
    // merge the stacked merge operands into a single operand.
+    //
+    // TODO(noetzli) The docblock of MergeUntil suggests that a successful
+    // partial merge returns Status::OK(). Should we change the status code
+    // after a successful partial merge?
    s = Status::MergeInProgress();
    if (merge_context_.GetNumOperands() >= 2 &&
        merge_context_.GetNumOperands() >= min_partial_merge_operands_) {
@@ -34,13 +34,11 @@ class MergeHelper {
              const CompactionFilter* compaction_filter, Logger* logger,
              unsigned min_partial_merge_operands,
              bool assert_valid_internal_key, SequenceNumber latest_snapshot,
-              int level = 0, Statistics* stats = nullptr,
-              const std::atomic<bool>* shutting_down = nullptr)
+              int level = 0, Statistics* stats = nullptr)
      : env_(env),
        user_comparator_(user_comparator),
        user_merge_operator_(user_merge_operator),
        compaction_filter_(compaction_filter),
-        shutting_down_(shutting_down),
        logger_(logger),
        min_partial_merge_operands_(min_partial_merge_operands),
        assert_valid_internal_key_(assert_valid_internal_key),
@@ -83,12 +81,10 @@ class MergeHelper {
  //
  // Returns one of the following statuses:
  // - OK: Entries were successfully merged.
-  // - MergeInProgress: Put/Delete not encountered, and didn't reach the start
-  //   of key's history. Output consists of merge operands only.
+  // - MergeInProgress: Put/Delete not encountered and unable to merge operands.
  // - Corruption: Merge operator reported unsuccessful merge or a corrupted
  //   key has been encountered and not expected (applies only when compiling
  //   with asserts removed).
-  // - ShutdownInProgress: interrupted by shutdown (*shutting_down == true).
  //
  // REQUIRED: The first key in the input is not corrupted.
  Status MergeUntil(InternalIterator* iter,
@@ -154,7 +150,6 @@ class MergeHelper {
  const Comparator* user_comparator_;
  const MergeOperator* user_merge_operator_;
  const CompactionFilter* compaction_filter_;
-  const std::atomic<bool>* shutting_down_;
  Logger* logger_;
  unsigned min_partial_merge_operands_;
  bool assert_valid_internal_key_; // enforce no internal key corruption?
@@ -176,11 +171,6 @@ class MergeHelper {
  bool has_compaction_filter_skip_until_ = false;
  std::string compaction_filter_value_;
  InternalKey compaction_filter_skip_until_;
-
-  bool IsShuttingDown() {
-    // This is a best-effort facility, so memory_order_relaxed is sufficient.
-    return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
-  }
 };

 // MergeOutputIterator can be used to iterate over the result of a merge.
@@ -12,7 +12,6 @@
 #include "rocksdb/memtablerep.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/slice_transform.h"
-#include "port/port.h"
 #include "util/histogram.h"
 #include "util/instrumented_mutex.h"
 #include "util/stop_watch.h"
@@ -562,7 +561,7 @@ TEST_F(PerfContextTest, DBMutexLockCounter) {
    for (int c = 0; c < 2; ++c) {
    InstrumentedMutex mutex(nullptr, Env::Default(), stats_code[c]);
    mutex.Lock();
-    rocksdb::port::Thread child_thread([&] {
+    std::thread child_thread([&] {
      SetPerfLevel(perf_level);
      perf_context.Reset();
      ASSERT_EQ(perf_context.db_mutex_lock_nanos, 0);
@@ -16,7 +16,7 @@ namespace rocksdb {
 // PinnedIteratorsManager will be notified whenever we need to pin an Iterator
 // and it will be responsible for deleting pinned Iterators when they are
 // not needed anymore.
-class PinnedIteratorsManager : public Cleanable {
+class PinnedIteratorsManager {
 public:
  PinnedIteratorsManager() : pinning_enabled(false) {}
  ~PinnedIteratorsManager() {
@@ -59,16 +59,16 @@ class PinnedIteratorsManager : public Cleanable {

    // Remove duplicate pointers
    std::sort(pinned_ptrs_.begin(), pinned_ptrs_.end());
-    auto unique_end = std::unique(pinned_ptrs_.begin(), pinned_ptrs_.end());
+    std::unique(pinned_ptrs_.begin(), pinned_ptrs_.end());

-    for (auto i = pinned_ptrs_.begin(); i != unique_end; ++i) {
-      void* ptr = i->first;
-      ReleaseFunction release_func = i->second;
+    for (size_t i = 0; i < pinned_ptrs_.size(); i++) {
+      assert(i == 0 || pinned_ptrs_[i].first != pinned_ptrs_[i - 1].first);
+
+      void* ptr = pinned_ptrs_[i].first;
+      ReleaseFunction release_func = pinned_ptrs_[i].second;
      release_func(ptr);
    }
    pinned_ptrs_.clear();
-    // Also do cleanups from the base Cleanable
-    Cleanable::Reset();
  }

 private:
@@ -11,40 +11,29 @@ namespace rocksdb {

 RangeDelAggregator::RangeDelAggregator(
    const InternalKeyComparator& icmp,
-    const std::vector<SequenceNumber>& snapshots,
-    bool collapse_deletions /* = true */)
-    : upper_bound_(kMaxSequenceNumber),
-      icmp_(icmp),
-      collapse_deletions_(collapse_deletions) {
+    const std::vector<SequenceNumber>& snapshots)
+    : upper_bound_(kMaxSequenceNumber), icmp_(icmp) {
  InitRep(snapshots);
 }

 RangeDelAggregator::RangeDelAggregator(const InternalKeyComparator& icmp,
-                                       SequenceNumber snapshot,
-                                       bool collapse_deletions /* = false */)
-    : upper_bound_(snapshot),
-      icmp_(icmp),
-      collapse_deletions_(collapse_deletions) {}
+                                       SequenceNumber snapshot)
+    : upper_bound_(snapshot), icmp_(icmp) {}

 void RangeDelAggregator::InitRep(const std::vector<SequenceNumber>& snapshots) {
  assert(rep_ == nullptr);
  rep_.reset(new Rep());
  for (auto snapshot : snapshots) {
    rep_->stripe_map_.emplace(
-        snapshot,
-        PositionalTombstoneMap(TombstoneMap(
-            stl_wrappers::LessOfComparator(icmp_.user_comparator()))));
+        snapshot, TombstoneMap(stl_wrappers::LessOfComparator(&icmp_)));
  }
  // Data newer than any snapshot falls in this catch-all stripe
  rep_->stripe_map_.emplace(
-      kMaxSequenceNumber,
-      PositionalTombstoneMap(TombstoneMap(
-          stl_wrappers::LessOfComparator(icmp_.user_comparator()))));
+      kMaxSequenceNumber, TombstoneMap(stl_wrappers::LessOfComparator(&icmp_)));
  rep_->pinned_iters_mgr_.StartPinning();
 }

-bool RangeDelAggregator::ShouldDelete(
-    const Slice& internal_key, RangeDelAggregator::RangePositioningMode mode) {
+bool RangeDelAggregator::ShouldDelete(const Slice& internal_key) {
  if (rep_ == nullptr) {
    return false;
  }
@@ -52,103 +41,32 @@ bool RangeDelAggregator::ShouldDelete(
  if (!ParseInternalKey(internal_key, &parsed)) {
    assert(false);
  }
-  return ShouldDelete(parsed, mode);
+  return ShouldDelete(parsed);
 }

-bool RangeDelAggregator::ShouldDelete(
-    const ParsedInternalKey& parsed,
-    RangeDelAggregator::RangePositioningMode mode) {
+bool RangeDelAggregator::ShouldDelete(const ParsedInternalKey& parsed) {
  assert(IsValueType(parsed.type));
  if (rep_ == nullptr) {
    return false;
  }
-  auto& positional_tombstone_map = GetPositionalTombstoneMap(parsed.sequence);
-  const auto& tombstone_map = positional_tombstone_map.raw_map;
-  if (tombstone_map.empty()) {
-    return false;
-  }
-  auto& tombstone_map_iter = positional_tombstone_map.iter;
-  if (tombstone_map_iter == tombstone_map.end() &&
-      (mode == kForwardTraversal || mode == kBackwardTraversal)) {
-    // invalid (e.g., if AddTombstones() changed the deletions), so need to
-    // reseek
-    mode = kBinarySearch;
-  }
-  switch (mode) {
-    case kFullScan:
-      assert(!collapse_deletions_);
-      // The maintained state (PositionalTombstoneMap::iter) isn't useful when
-      // we linear scan from the beginning each time, but we maintain it anyways
-      // for consistency.
-      tombstone_map_iter = tombstone_map.begin();
-      while (tombstone_map_iter != tombstone_map.end()) {
-        const auto& tombstone = tombstone_map_iter->second;
-        if (icmp_.user_comparator()->Compare(parsed.user_key,
-                                             tombstone.start_key_) < 0) {
-          break;
-        }
-        if (parsed.sequence < tombstone.seq_ &&
-            icmp_.user_comparator()->Compare(parsed.user_key,
-                                             tombstone.end_key_) < 0) {
-          return true;
-        }
-        ++tombstone_map_iter;
-      }
-      return false;
-    case kForwardTraversal:
-      assert(collapse_deletions_ && tombstone_map_iter != tombstone_map.end());
-      if (tombstone_map_iter == tombstone_map.begin() &&
-          icmp_.user_comparator()->Compare(parsed.user_key,
-                                           tombstone_map_iter->first) < 0) {
-        // before start of deletion intervals
-        return false;
-      }
-      while (std::next(tombstone_map_iter) != tombstone_map.end() &&
-             icmp_.user_comparator()->Compare(
-                 std::next(tombstone_map_iter)->first, parsed.user_key) <= 0) {
-        ++tombstone_map_iter;
-      }
-      break;
-    case kBackwardTraversal:
-      assert(collapse_deletions_ && tombstone_map_iter != tombstone_map.end());
-      while (tombstone_map_iter != tombstone_map.begin() &&
-             icmp_.user_comparator()->Compare(parsed.user_key,
-                                              tombstone_map_iter->first) < 0) {
-        --tombstone_map_iter;
-      }
-      if (tombstone_map_iter == tombstone_map.begin() &&
-          icmp_.user_comparator()->Compare(parsed.user_key,
-                                           tombstone_map_iter->first) < 0) {
-        // before start of deletion intervals
-        return false;
-      }
-      break;
-    case kBinarySearch:
-      assert(collapse_deletions_);
-      tombstone_map_iter =
-          tombstone_map.upper_bound(parsed.user_key);
-      if (tombstone_map_iter == tombstone_map.begin()) {
-        // before start of deletion intervals
-        return false;
-      }
-      --tombstone_map_iter;
+  const auto& tombstone_map = GetTombstoneMap(parsed.sequence);
+  for (const auto& start_key_and_tombstone : tombstone_map) {
+    const auto& tombstone = start_key_and_tombstone.second;
+    if (icmp_.user_comparator()->Compare(parsed.user_key,
+                                         tombstone.start_key_) < 0) {
      break;
+    }
+    if (parsed.sequence < tombstone.seq_ &&
+        icmp_.user_comparator()->Compare(parsed.user_key, tombstone.end_key_) <
+            0) {
+      return true;
+    }
  }
-  assert(mode != kFullScan);
-  assert(tombstone_map_iter != tombstone_map.end() &&
-         icmp_.user_comparator()->Compare(tombstone_map_iter->first,
-                                          parsed.user_key) <= 0);
-  assert(std::next(tombstone_map_iter) == tombstone_map.end() ||
-         icmp_.user_comparator()->Compare(
-             parsed.user_key, std::next(tombstone_map_iter)->first) < 0);
-  return parsed.sequence < tombstone_map_iter->second.seq_;
+  return false;
 }

 bool RangeDelAggregator::ShouldAddTombstones(
    bool bottommost_level /* = false */) {
-  // TODO(andrewkr): can we just open a file and throw it away if it ends up
-  // empty after AddToBuilder()? This function doesn't take into subcompaction
-  // boundaries so isn't completely accurate.
  if (rep_ == nullptr) {
    return false;
  }
@@ -160,7 +78,7 @@ bool RangeDelAggregator::ShouldAddTombstones(
    ++stripe_map_iter;
  }
  while (stripe_map_iter != rep_->stripe_map_.end()) {
-    if (!stripe_map_iter->second.raw_map.empty()) {
+    if (!stripe_map_iter->second.empty()) {
      return true;
    }
    ++stripe_map_iter;
@@ -179,8 +97,6 @@ Status RangeDelAggregator::AddTombstones(
    if (first_iter) {
      if (rep_ == nullptr) {
        InitRep({upper_bound_});
-      } else {
-        InvalidateTombstoneMapPositions();
      }
      first_iter = false;
    }
@@ -189,7 +105,8 @@ Status RangeDelAggregator::AddTombstones(
      return Status::Corruption("Unable to parse range tombstone InternalKey");
    }
    RangeTombstone tombstone(parsed_key, input->value());
-    AddTombstone(std::move(tombstone));
+    auto& tombstone_map = GetTombstoneMap(tombstone.seq_);
+    tombstone_map.emplace(input->key(), std::move(tombstone));
    input->Next();
  }
  if (!first_iter) {
@@ -198,172 +115,8 @@ Status RangeDelAggregator::AddTombstones(
  return Status::OK();
 }

-void RangeDelAggregator::InvalidateTombstoneMapPositions() {
-  if (rep_ == nullptr) {
-    return;
-  }
-  for (auto stripe_map_iter = rep_->stripe_map_.begin();
-       stripe_map_iter != rep_->stripe_map_.end(); ++stripe_map_iter) {
-    stripe_map_iter->second.iter = stripe_map_iter->second.raw_map.end();
-  }
-}
-
-Status RangeDelAggregator::AddTombstone(RangeTombstone tombstone) {
-  auto& positional_tombstone_map = GetPositionalTombstoneMap(tombstone.seq_);
-  auto& tombstone_map = positional_tombstone_map.raw_map;
-  if (collapse_deletions_) {
-    // In collapsed mode, we only fill the seq_ field in the TombstoneMap's
-    // values. The end_key is unneeded because we assume the tombstone extends
-    // until the next tombstone starts. For gaps between real tombstones and
-    // for the last real tombstone, we denote end keys by inserting fake
-    // tombstones with sequence number zero.
-    std::vector<RangeTombstone> new_range_dels{
-        tombstone, RangeTombstone(tombstone.end_key_, Slice(), 0)};
-    auto new_range_dels_iter = new_range_dels.begin();
-    // Position at the first overlapping existing tombstone; if none exists,
-    // insert until we find an existing one overlapping a new point
-    const Slice* tombstone_map_begin = nullptr;
-    if (!tombstone_map.empty()) {
-      tombstone_map_begin = &tombstone_map.begin()->first;
-    }
-    auto last_range_dels_iter = new_range_dels_iter;
-    while (new_range_dels_iter != new_range_dels.end() &&
-           (tombstone_map_begin == nullptr ||
-            icmp_.user_comparator()->Compare(new_range_dels_iter->start_key_,
-                                             *tombstone_map_begin) < 0)) {
-      tombstone_map.emplace(
-          new_range_dels_iter->start_key_,
-          RangeTombstone(Slice(), Slice(), new_range_dels_iter->seq_));
-      last_range_dels_iter = new_range_dels_iter;
-      ++new_range_dels_iter;
-    }
-    if (new_range_dels_iter == new_range_dels.end()) {
-      return Status::OK();
-    }
-    // above loop advances one too far
-    new_range_dels_iter = last_range_dels_iter;
-    auto tombstone_map_iter =
-        tombstone_map.upper_bound(new_range_dels_iter->start_key_);
-    // if nothing overlapped we would've already inserted all the new points
-    // and returned early
-    assert(tombstone_map_iter != tombstone_map.begin());
-    tombstone_map_iter--;
-
-    // untermed_seq is non-kMaxSequenceNumber when we covered an existing point
-    // but haven't seen its corresponding endpoint. It's used for (1) deciding
-    // whether to forcibly insert the new interval's endpoint; and (2) possibly
-    // raising the seqnum for the to-be-inserted element (we insert the max
-    // seqnum between the next new interval and the unterminated interval).
-    SequenceNumber untermed_seq = kMaxSequenceNumber;
-    while (tombstone_map_iter != tombstone_map.end() &&
-           new_range_dels_iter != new_range_dels.end()) {
-      const Slice *tombstone_map_iter_end = nullptr,
-                  *new_range_dels_iter_end = nullptr;
-      if (tombstone_map_iter != tombstone_map.end()) {
-        auto next_tombstone_map_iter = std::next(tombstone_map_iter);
-        if (next_tombstone_map_iter != tombstone_map.end()) {
-          tombstone_map_iter_end = &next_tombstone_map_iter->first;
-        }
-      }
-      if (new_range_dels_iter != new_range_dels.end()) {
-        auto next_new_range_dels_iter = std::next(new_range_dels_iter);
-        if (next_new_range_dels_iter != new_range_dels.end()) {
-          new_range_dels_iter_end = &next_new_range_dels_iter->start_key_;
-        }
-      }
-
-      // our positions in existing/new tombstone collections should always
-      // overlap. The non-overlapping cases are handled above and below this
-      // loop.
-      assert(new_range_dels_iter_end == nullptr ||
-             icmp_.user_comparator()->Compare(tombstone_map_iter->first,
-                                              *new_range_dels_iter_end) < 0);
-      assert(tombstone_map_iter_end == nullptr ||
-             icmp_.user_comparator()->Compare(new_range_dels_iter->start_key_,
-                                              *tombstone_map_iter_end) < 0);
-
-      int new_to_old_start_cmp = icmp_.user_comparator()->Compare(
-          new_range_dels_iter->start_key_, tombstone_map_iter->first);
-      // nullptr end means extends infinitely rightwards, set new_to_old_end_cmp
-      // accordingly so we can use common code paths later.
-      int new_to_old_end_cmp;
-      if (new_range_dels_iter_end == nullptr &&
-          tombstone_map_iter_end == nullptr) {
-        new_to_old_end_cmp = 0;
-      } else if (new_range_dels_iter_end == nullptr) {
-        new_to_old_end_cmp = 1;
-      } else if (tombstone_map_iter_end == nullptr) {
-        new_to_old_end_cmp = -1;
-      } else {
-        new_to_old_end_cmp = icmp_.user_comparator()->Compare(
-            *new_range_dels_iter_end, *tombstone_map_iter_end);
-      }
-
-      if (new_to_old_start_cmp < 0) {
-        // the existing one's left endpoint comes after, so raise/delete it if
-        // it's covered.
-        if (tombstone_map_iter->second.seq_ < new_range_dels_iter->seq_) {
-          untermed_seq = tombstone_map_iter->second.seq_;
-          if (tombstone_map_iter != tombstone_map.begin() &&
-              std::prev(tombstone_map_iter)->second.seq_ ==
-                  new_range_dels_iter->seq_) {
-            tombstone_map_iter = tombstone_map.erase(tombstone_map_iter);
-            --tombstone_map_iter;
-          } else {
-            tombstone_map_iter->second.seq_ = new_range_dels_iter->seq_;
-          }
-        }
-      } else if (new_to_old_start_cmp > 0) {
-        if (untermed_seq != kMaxSequenceNumber ||
-            tombstone_map_iter->second.seq_ < new_range_dels_iter->seq_) {
-          auto seq = tombstone_map_iter->second.seq_;
-          // need to adjust this element if not intended to span beyond the new
-          // element (i.e., was_tombstone_map_iter_raised == true), or if it
-          // can be raised
-          tombstone_map_iter = tombstone_map.emplace(
-              new_range_dels_iter->start_key_,
-              RangeTombstone(
-                  Slice(), Slice(),
-                  std::max(
-                      untermed_seq == kMaxSequenceNumber ? 0 : untermed_seq,
-                      new_range_dels_iter->seq_)));
-          untermed_seq = seq;
-        }
-      } else {
-        // their left endpoints coincide, so raise the existing one if needed
-        if (tombstone_map_iter->second.seq_ < new_range_dels_iter->seq_) {
-          untermed_seq = tombstone_map_iter->second.seq_;
-          tombstone_map_iter->second.seq_ = new_range_dels_iter->seq_;
-        }
-      }
-
-      // advance whichever one ends earlier, or both if their right endpoints
-      // coincide
-      if (new_to_old_end_cmp < 0) {
-        ++new_range_dels_iter;
-      } else if (new_to_old_end_cmp > 0) {
-        ++tombstone_map_iter;
-        untermed_seq = kMaxSequenceNumber;
-      } else {
-        ++new_range_dels_iter;
-        ++tombstone_map_iter;
-        untermed_seq = kMaxSequenceNumber;
-      }
-    }
-    while (new_range_dels_iter != new_range_dels.end()) {
-      tombstone_map.emplace(
-          new_range_dels_iter->start_key_,
-          RangeTombstone(Slice(), Slice(), new_range_dels_iter->seq_));
-      ++new_range_dels_iter;
-    }
-  } else {
-    tombstone_map.emplace(tombstone.start_key_, std::move(tombstone));
-  }
-  return Status::OK();
-}
-
-RangeDelAggregator::PositionalTombstoneMap&
-RangeDelAggregator::GetPositionalTombstoneMap(SequenceNumber seq) {
+RangeDelAggregator::TombstoneMap& RangeDelAggregator::GetTombstoneMap(
+    SequenceNumber seq) {
  assert(rep_ != nullptr);
  // The stripe includes seqnum for the snapshot above and excludes seqnum for
  // the snapshot below.
@@ -395,16 +148,10 @@ void RangeDelAggregator::AddToBuilder(
  auto stripe_map_iter = rep_->stripe_map_.begin();
  assert(stripe_map_iter != rep_->stripe_map_.end());
  if (bottommost_level) {
-    // TODO(andrewkr): these are counted for each compaction output file, so
-    // lots of double-counting.
-    if (!stripe_map_iter->second.raw_map.empty()) {
-      range_del_out_stats->num_range_del_drop_obsolete +=
-          static_cast<int64_t>(stripe_map_iter->second.raw_map.size()) -
-          (collapse_deletions_ ? 1 : 0);
-      range_del_out_stats->num_record_drop_obsolete +=
-          static_cast<int64_t>(stripe_map_iter->second.raw_map.size()) -
-          (collapse_deletions_ ? 1 : 0);
-    }
+    range_del_out_stats->num_range_del_drop_obsolete +=
+        static_cast<int64_t>(stripe_map_iter->second.size());
+    range_del_out_stats->num_record_drop_obsolete +=
+        static_cast<int64_t>(stripe_map_iter->second.size());
    // For the bottommost level, keys covered by tombstones in the first
    // (oldest) stripe have been compacted away, so the tombstones are obsolete.
    ++stripe_map_iter;
@@ -414,23 +161,8 @@ void RangeDelAggregator::AddToBuilder(
  // insert them into a std::map on the read path.
  bool first_added = false;
  while (stripe_map_iter != rep_->stripe_map_.end()) {
-    for (auto tombstone_map_iter = stripe_map_iter->second.raw_map.begin();
-         tombstone_map_iter != stripe_map_iter->second.raw_map.end();
-         ++tombstone_map_iter) {
-      RangeTombstone tombstone;
-      if (collapse_deletions_) {
-        auto next_tombstone_map_iter = std::next(tombstone_map_iter);
-        if (next_tombstone_map_iter == stripe_map_iter->second.raw_map.end() ||
-            tombstone_map_iter->second.seq_ == 0) {
-          // it's a sentinel tombstone
-          continue;
-        }
-        tombstone.start_key_ = tombstone_map_iter->first;
-        tombstone.end_key_ = next_tombstone_map_iter->first;
-        tombstone.seq_ = tombstone_map_iter->second.seq_;
-      } else {
-        tombstone = tombstone_map_iter->second;
-      }
+    for (const auto& start_key_and_tombstone : stripe_map_iter->second) {
+      const auto& tombstone = start_key_and_tombstone.second;
      if (upper_bound != nullptr &&
          icmp_.user_comparator()->Compare(*upper_bound,
                                           tombstone.start_key_) <= 0) {
@@ -509,7 +241,7 @@ bool RangeDelAggregator::IsEmpty() {
  }
  for (auto stripe_map_iter = rep_->stripe_map_.begin();
       stripe_map_iter != rep_->stripe_map_.end(); ++stripe_map_iter) {
-    if (!stripe_map_iter->second.raw_map.empty()) {
+    if (!stripe_map_iter->second.empty()) {
      return false;
    }
  }
@@ -32,51 +32,27 @@ class RangeDelAggregator {
  //    stripes, which is the seqnum range between consecutive snapshots,
  //    including the higher snapshot and excluding the lower one. Currently,
  //    this is used by ShouldDelete() to prevent deletion of keys that are
-  //    covered by range tombstones in other snapshot stripes. This constructor
-  //    is used for writes (flush/compaction). All DB snapshots are provided
-  //    such that no keys are removed that are uncovered according to any DB
-  //    snapshot.
+  //    covered by range tombstones in other snapshot stripes. In case of writes
+  //    (flush/compaction), all DB snapshots are provided such that no keys are
+  //    removed that are uncovered according to any DB snapshot. In case of read
+  //    (get/iterator), only the user snapshot is provided such that the seqnum
+  //    space is divided into two stripes, where only tombstones in the older
+  //    stripe are considered by ShouldDelete().
  // Note this overload does not lazily initialize Rep.
  RangeDelAggregator(const InternalKeyComparator& icmp,
-                     const std::vector<SequenceNumber>& snapshots,
-                     bool collapse_deletions = true);
+                     const std::vector<SequenceNumber>& snapshots);

  // @param upper_bound Similar to snapshots above, except with a single
  //    snapshot, which allows us to store the snapshot on the stack and defer
  //    initialization of heap-allocating members (in Rep) until the first range
-  //    deletion is encountered. This constructor is used in case of reads (get/
-  //    iterator), for which only the user snapshot (upper_bound) is provided
-  //    such that the seqnum space is divided into two stripes. Only the older
-  //    stripe will be used by ShouldDelete().
+  //    deletion is encountered.
  RangeDelAggregator(const InternalKeyComparator& icmp,
-                     SequenceNumber upper_bound,
-                     bool collapse_deletions = false);
-
-  // We maintain position in the tombstone map across calls to ShouldDelete. The
-  // caller may wish to specify a mode to optimize positioning the iterator
-  // during the next call to ShouldDelete. The non-kFullScan modes are only
-  // available when deletion collapsing is enabled.
-  //
-  // For example, if we invoke Next() on an iterator, kForwardTraversal should
-  // be specified to advance one-by-one through deletions until one is found
-  // with its interval containing the key. This will typically be faster than
-  // doing a full binary search (kBinarySearch).
-  enum RangePositioningMode {
-    kFullScan,  // used iff collapse_deletions_ == false
-    kForwardTraversal,
-    kBackwardTraversal,
-    kBinarySearch,
-  };
+                     SequenceNumber upper_bound);

  // Returns whether the key should be deleted, which is the case when it is
  // covered by a range tombstone residing in the same snapshot stripe.
-  // @param mode If collapse_deletions_ is true, this dictates how we will find
-  //             the deletion whose interval contains this key. Otherwise, its
-  //             value must be kFullScan indicating linear scan from beginning..
-  bool ShouldDelete(const ParsedInternalKey& parsed,
-                    RangePositioningMode mode = kFullScan);
-  bool ShouldDelete(const Slice& internal_key,
-                    RangePositioningMode mode = kFullScan);
+  bool ShouldDelete(const ParsedInternalKey& parsed);
+  bool ShouldDelete(const Slice& internal_key);
  bool ShouldAddTombstones(bool bottommost_level = false);

  // Adds tombstones to the tombstone aggregation structure maintained by this
@@ -84,13 +60,6 @@ class RangeDelAggregator {
  // @return non-OK status if any of the tombstone keys are corrupted.
  Status AddTombstones(std::unique_ptr<InternalIterator> input);

-  // Resets iterators maintained across calls to ShouldDelete(). This may be
-  // called when the tombstones change, or the owner may call explicitly, e.g.,
-  // if it's an iterator that just seeked to an arbitrary position. The effect
-  // of invalidation is that the following call to ShouldDelete() will binary
-  // search for its tombstone.
-  void InvalidateTombstoneMapPositions();
-
  // Writes tombstones covering a range to a table builder.
  // @param extend_before_min_key If true, the range of tombstones to be added
  //    to the TableBuilder starts from the beginning of the key-range;
@@ -118,26 +87,12 @@ class RangeDelAggregator {
  bool IsEmpty();

 private:
-  // Maps tombstone user start key -> tombstone object
-  typedef std::multimap<Slice, RangeTombstone, stl_wrappers::LessOfComparator>
+  // Maps tombstone internal start key -> tombstone object
+  typedef std::map<Slice, RangeTombstone, stl_wrappers::LessOfComparator>
      TombstoneMap;
-  // Also maintains position in TombstoneMap last seen by ShouldDelete(). The
-  // end iterator indicates invalidation (e.g., if AddTombstones() changes the
-  // underlying map). End iterator cannot be invalidated.
-  struct PositionalTombstoneMap {
-    explicit PositionalTombstoneMap(TombstoneMap _raw_map)
-        : raw_map(std::move(_raw_map)), iter(raw_map.end()) {}
-    PositionalTombstoneMap(const PositionalTombstoneMap&) = delete;
-    PositionalTombstoneMap(PositionalTombstoneMap&& other)
-        : raw_map(std::move(other.raw_map)), iter(raw_map.end()) {}
-
-    TombstoneMap raw_map;
-    TombstoneMap::const_iterator iter;
-  };
-
  // Maps snapshot seqnum -> map of tombstones that fall in that stripe, i.e.,
  // their seqnums are greater than the next smaller snapshot's seqnum.
-  typedef std::map<SequenceNumber, PositionalTombstoneMap> StripeMap;
+  typedef std::map<SequenceNumber, TombstoneMap> StripeMap;

  struct Rep {
    StripeMap stripe_map_;
@@ -148,14 +103,11 @@ class RangeDelAggregator {
  // once the first range deletion is encountered.
  void InitRep(const std::vector<SequenceNumber>& snapshots);

-  PositionalTombstoneMap& GetPositionalTombstoneMap(SequenceNumber seq);
-  Status AddTombstone(RangeTombstone tombstone);
+  TombstoneMap& GetTombstoneMap(SequenceNumber seq);

  SequenceNumber upper_bound_;
  std::unique_ptr<Rep> rep_;
  const InternalKeyComparator& icmp_;
-  // collapse range deletions so they're binary searchable
-  const bool collapse_deletions_;
 };

 }  // namespace rocksdb
@@ -1,157 +0,0 @@
-//  Copyright (c) 2016-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under the BSD-style license found in the
-//  LICENSE file in the root directory of this source tree. An additional grant
-//  of patent rights can be found in the PATENTS file in the same directory.
-
-#include <algorithm>
-
-#include "db/db_test_util.h"
-#include "db/range_del_aggregator.h"
-#include "rocksdb/comparator.h"
-#include "util/testutil.h"
-
-namespace rocksdb {
-
-class RangeDelAggregatorTest : public testing::Test {};
-
-namespace {
-
-struct ExpectedPoint {
-  Slice begin;
-  SequenceNumber seq;
-};
-
-enum Direction {
-  kForward,
-  kReverse,
-};
-
-void VerifyRangeDels(const std::vector<RangeTombstone>& range_dels,
-                     const std::vector<ExpectedPoint>& expected_points) {
-  // Test same result regardless of which order the range deletions are added.
-  for (Direction dir : {kForward, kReverse}) {
-    auto icmp = InternalKeyComparator(BytewiseComparator());
-    RangeDelAggregator range_del_agg(icmp, {} /* snapshots */, true);
-    std::vector<std::string> keys, values;
-    for (const auto& range_del : range_dels) {
-      auto key_and_value = range_del.Serialize();
-      keys.push_back(key_and_value.first.Encode().ToString());
-      values.push_back(key_and_value.second.ToString());
-    }
-    if (dir == kReverse) {
-      std::reverse(keys.begin(), keys.end());
-      std::reverse(values.begin(), values.end());
-    }
-    std::unique_ptr<test::VectorIterator> range_del_iter(
-        new test::VectorIterator(keys, values));
-    range_del_agg.AddTombstones(std::move(range_del_iter));
-
-    for (const auto expected_point : expected_points) {
-      ParsedInternalKey parsed_key;
-      parsed_key.user_key = expected_point.begin;
-      parsed_key.sequence = expected_point.seq;
-      parsed_key.type = kTypeValue;
-      ASSERT_FALSE(range_del_agg.ShouldDelete(
-          parsed_key,
-          RangeDelAggregator::RangePositioningMode::kForwardTraversal));
-      if (parsed_key.sequence > 0) {
-        --parsed_key.sequence;
-        ASSERT_TRUE(range_del_agg.ShouldDelete(
-            parsed_key,
-            RangeDelAggregator::RangePositioningMode::kForwardTraversal));
-      }
-    }
-  }
-}
-
-}  // anonymous namespace
-
-TEST_F(RangeDelAggregatorTest, Empty) { VerifyRangeDels({}, {{"a", 0}}); }
-
-TEST_F(RangeDelAggregatorTest, SameStartAndEnd) {
-  VerifyRangeDels({{"a", "a", 5}}, {{" ", 0}, {"a", 0}, {"b", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, Single) {
-  VerifyRangeDels({{"a", "b", 10}}, {{" ", 0}, {"a", 10}, {"b", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, OverlapAboveLeft) {
-  VerifyRangeDels({{"a", "c", 10}, {"b", "d", 5}},
-                  {{" ", 0}, {"a", 10}, {"c", 5}, {"d", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, OverlapAboveRight) {
-  VerifyRangeDels({{"a", "c", 5}, {"b", "d", 10}},
-                  {{" ", 0}, {"a", 5}, {"b", 10}, {"d", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, OverlapAboveMiddle) {
-  VerifyRangeDels({{"a", "d", 5}, {"b", "c", 10}},
-                  {{" ", 0}, {"a", 5}, {"b", 10}, {"c", 5}, {"d", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, OverlapFully) {
-  VerifyRangeDels({{"a", "d", 10}, {"b", "c", 5}},
-                  {{" ", 0}, {"a", 10}, {"d", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, OverlapPoint) {
-  VerifyRangeDels({{"a", "b", 5}, {"b", "c", 10}},
-                  {{" ", 0}, {"a", 5}, {"b", 10}, {"c", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, SameStartKey) {
-  VerifyRangeDels({{"a", "c", 5}, {"a", "b", 10}},
-                  {{" ", 0}, {"a", 10}, {"b", 5}, {"c", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, SameEndKey) {
-  VerifyRangeDels({{"a", "d", 5}, {"b", "d", 10}},
-                  {{" ", 0}, {"a", 5}, {"b", 10}, {"d", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, GapsBetweenRanges) {
-  VerifyRangeDels(
-      {{"a", "b", 5}, {"c", "d", 10}, {"e", "f", 15}},
-      {{" ", 0}, {"a", 5}, {"b", 0}, {"c", 10}, {"d", 0}, {"e", 15}, {"f", 0}});
-}
-
-// Note the Cover* tests also test cases where tombstones are inserted under a
-// larger one when VerifyRangeDels() runs them in reverse
-TEST_F(RangeDelAggregatorTest, CoverMultipleFromLeft) {
-  VerifyRangeDels(
-      {{"b", "d", 5}, {"c", "f", 10}, {"e", "g", 15}, {"a", "f", 20}},
-      {{" ", 0}, {"a", 20}, {"f", 15}, {"g", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, CoverMultipleFromRight) {
-  VerifyRangeDels(
-      {{"b", "d", 5}, {"c", "f", 10}, {"e", "g", 15}, {"c", "h", 20}},
-      {{" ", 0}, {"b", 5}, {"c", 20}, {"h", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, CoverMultipleFully) {
-  VerifyRangeDels(
-      {{"b", "d", 5}, {"c", "f", 10}, {"e", "g", 15}, {"a", "h", 20}},
-      {{" ", 0}, {"a", 20}, {"h", 0}});
-}
-
-TEST_F(RangeDelAggregatorTest, AlternateMultipleAboveBelow) {
-  VerifyRangeDels(
-      {{"b", "d", 15}, {"c", "f", 10}, {"e", "g", 20}, {"a", "h", 5}},
-      {{" ", 0},
-       {"a", 5},
-       {"b", 15},
-       {"d", 10},
-       {"e", 20},
-       {"g", 5},
-       {"h", 0}});
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -16,7 +16,6 @@
 #include <inttypes.h>
 #include <algorithm>
 #include <atomic>
-#include <functional>
 #include <set>
 #include <thread>
 #include <unordered_map>
@@ -28,7 +27,6 @@
 #include "db/internal_stats.h"
 #include "db/table_cache.h"
 #include "db/version_set.h"
-#include "port/port.h"
 #include "table/table_reader.h"

 namespace rocksdb {
@@ -360,7 +358,7 @@ class VersionBuilder::Rep {
    if (max_threads <= 1) {
      load_handlers_func();
    } else {
-      std::vector<port::Thread> threads;
+      std::vector<std::thread> threads;
      for (int i = 0; i < max_threads; i++) {
        threads.emplace_back(load_handlers_func);
      }
@@ -40,7 +40,7 @@
 #include "table/format.h"
 #include "table/get_context.h"
 #include "table/internal_iterator.h"
-#include "table/merging_iterator.h"
+#include "table/merger.h"
 #include "table/meta_blocks.h"
 #include "table/plain_table_factory.h"
 #include "table/table_reader.h"
@@ -520,8 +520,6 @@ class Version {
    return next_;
  }

-  int TEST_refs() const { return refs_; }
-
  VersionStorageInfo* storage_info() { return &storage_info_; }

  VersionSet* version_set() { return vset_; }
@@ -5,7 +5,6 @@

 #ifndef ROCKSDB_LITE

-#include <functional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -14,7 +13,6 @@
 #include "db/write_callback.h"
 #include "rocksdb/db.h"
 #include "rocksdb/write_batch.h"
-#include "port/port.h"
 #include "util/logging.h"
 #include "util/sync_point.h"
 #include "util/testharness.h"
@@ -242,7 +240,7 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
          rocksdb::SyncPoint::GetInstance()->EnableProcessing();

          // do all the writes
-          std::vector<port::Thread> threads;
+          std::vector<std::thread> threads;
          for (uint32_t i = 0; i < write_group.size(); i++) {
            threads.emplace_back(write_with_callback_func);
          }
@@ -317,7 +317,7 @@ void WriteThread::LaunchParallelFollowers(ParallelGroup* pg,

  while (w != pg->last_writer) {
    // Writers that won't write don't get sequence allotment
-    if (!w->CallbackFailed() && w->ShouldWriteToMemtable()) {
+    if (!w->CallbackFailed()) {
      sequence += WriteBatchInternal::Count(w->batch);
    }
    w = w->link_newer;
@@ -1,26 +0,0 @@
---
-title: RocksDB 5.0.1 Released!
-layout: post
-author: yiwu
-category: blog
---
-
-### Public API Change
-
-  * Options::max_bytes_for_level_multiplier is now a double along with all getters and setters.
-  * Support dynamically change `delayed_write_rate` and `max_total_wal_size` options via SetDBOptions().
-  * Introduce DB::DeleteRange for optimized deletion of large ranges of contiguous keys.
-  * Support dynamically change `delayed_write_rate` option via SetDBOptions().
-  * Options::allow_concurrent_memtable_write and Options::enable_write_thread_adaptive_yield are now true by default.
-  * Remove Tickers::SEQUENCE_NUMBER to avoid confusion if statistics object is shared among RocksDB instance. Alternatively DB::GetLatestSequenceNumber() can be used to get the same value.
-  * Options.level0_stop_writes_trigger default value changes from 24 to 32.
-  * New compaction filter API: CompactionFilter::FilterV2(). Allows to drop ranges of keys.
-  * Removed flashcache support.
-  * DB::AddFile() is deprecated and is replaced with DB::IngestExternalFile(). DB::IngestExternalFile() remove all the restrictions that existed for DB::AddFile.
-
-### New Features
-
-  * Add avoid_flush_during_shutdown option, which speeds up DB shutdown by not flushing unpersisted data (i.e. with disableWAL = true). Unpersisted data will be lost. The options is dynamically changeable via SetDBOptions().
-  * Add memtable_insert_with_hint_prefix_extractor option. The option is mean to reduce CPU usage for inserting keys into memtable, if keys can be group by prefix and insert for each prefix are sequential or almost sequential. See include/rocksdb/options.h for more details.
-  * Add LuaCompactionFilter in utilities.  This allows developers to write compaction filters in Lua.  To use this feature, LUA_PATH needs to be set to the root directory of Lua.
-  * No longer populate "LATEST_BACKUP" file in backup directory, which formerly contained the number of the latest backup. The latest backup can be determined by finding the highest numbered file in the "meta/" subdirectory.
@@ -1,15 +0,0 @@
---
-title: RocksDB 5.1.2 Released!
-layout: post
-author: maysamyabandeh
-category: blog
---
-
-### Public API Change
-* Support dynamically change `delete_obsolete_files_period_micros` option via SetDBOptions().
-* Added EventListener::OnExternalFileIngested which will be called when IngestExternalFile() add a file successfully.
-* BackupEngine::Open and BackupEngineReadOnly::Open now always return error statuses matching those of the backup Env.
-
-### Bug Fixes
-* Fix the bug that if 2PC is enabled, checkpoints may loss some recent transactions.
-* When file copying is needed when creating checkpoints or bulk loading files, fsync the file after the file copying.
@@ -10,7 +10,7 @@ endif
 	
 .PHONY: clean librocksdb

-all: simple_example column_families_example compact_files_example c_simple_example optimistic_transaction_example transaction_example compaction_filter_example options_file_example
+all: simple_example column_families_example compact_files_example c_simple_example optimistic_transaction_example transaction_example compaction_filter_example

 simple_example: librocksdb simple_example.cc
 	$(CXX) $(CXXFLAGS) $@.cc -o$@ ../librocksdb.a -I../include -O2 -std=c++11 $(PLATFORM_LDFLAGS) $(PLATFORM_CXXFLAGS) $(EXEC_LDFLAGS)
@@ -40,7 +40,7 @@ options_file_example: librocksdb options_file_example.cc
 	$(CXX) $(CXXFLAGS) $@.cc -o$@ ../librocksdb.a -I../include -O2 -std=c++11 $(PLATFORM_LDFLAGS) $(PLATFORM_CXXFLAGS) $(EXEC_LDFLAGS)

 clean:
-	rm -rf ./simple_example ./column_families_example ./compact_files_example ./compaction_filter_example ./c_simple_example c_simple_example.o ./optimistic_transaction_example ./transaction_example ./options_file_example
+	rm -rf ./simple_example ./column_families_example ./compact_files_example ./compaction_filter_example ./c_simple_example c_simple_example.o ./optimistic_transaction_example ./transaction_example

 librocksdb:
 	cd .. && $(MAKE) static_lib
@@ -1,8 +1,3 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-// This source code is licensed under the BSD-style license found in the
-// LICENSE file in the root directory of this source tree. An additional grant
-// of patent rights can be found in the PATENTS file in the same directory.
-
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -73,13 +73,12 @@
  error_if_exists=false
  recycle_log_file_num=0
  skip_log_error_on_recovery=false
+  allow_mmap_reads=false
+  allow_os_buffer=true
  db_log_dir=
  new_table_reader_for_compaction_inputs=true
-  allow_mmap_reads=false
  allow_mmap_writes=false
-  use_direct_reads=false
-  use_direct_writes=false
-
+  

 [CFOptions "default"]
  compaction_style=kCompactionStyleLevel
@@ -128,7 +127,7 @@
  write_buffer_size=134217728
  disable_auto_compactions=false
  inplace_update_support=false
-
+  
 [TableOptions/BlockBasedTable "default"]
  format_version=2
  whole_key_filtering=true
@@ -2,7 +2,6 @@
 // This source code is licensed under the BSD-style license found in the
 // LICENSE file in the root directory of this source tree. An additional grant
 // of patent rights can be found in the PATENTS file in the same directory.
-
 #include <cstdio>
 #include <string>

@@ -90,7 +90,6 @@ typedef struct rocksdb_iterator_t        rocksdb_iterator_t;
 typedef struct rocksdb_logger_t          rocksdb_logger_t;
 typedef struct rocksdb_mergeoperator_t   rocksdb_mergeoperator_t;
 typedef struct rocksdb_options_t         rocksdb_options_t;
-typedef struct rocksdb_compactoptions_t rocksdb_compactoptions_t;
 typedef struct rocksdb_block_based_table_options_t
    rocksdb_block_based_table_options_t;
 typedef struct rocksdb_cuckoo_table_options_t
@@ -289,10 +288,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_release_snapshot(
   Else returns a pointer to a malloc()-ed null-terminated value. */
 extern ROCKSDB_LIBRARY_API char* rocksdb_property_value(rocksdb_t* db,
                                                        const char* propname);
-/* returns 0 on success, -1 otherwise */
-int rocksdb_property_int(
-    rocksdb_t* db,
-    const char* propname, uint64_t *out_val);

 extern ROCKSDB_LIBRARY_API char* rocksdb_property_value_cf(
    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
@@ -320,15 +315,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_cf(
    const char* start_key, size_t start_key_len, const char* limit_key,
    size_t limit_key_len);

-extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_opt(
-    rocksdb_t* db, rocksdb_compactoptions_t* opt, const char* start_key,
-    size_t start_key_len, const char* limit_key, size_t limit_key_len);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_cf_opt(
-    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
-    rocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len,
-    const char* limit_key, size_t limit_key_len);
-
 extern ROCKSDB_LIBRARY_API void rocksdb_delete_file(rocksdb_t* db,
                                                    const char* name);

@@ -428,22 +414,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_deletev(
 extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_deletev_cf(
    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
    int num_keys, const char* const* keys_list, const size_t* keys_list_sizes);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_range(
-    rocksdb_writebatch_t* b, const char* start_key, size_t start_key_len,
-    const char* end_key, size_t end_key_len);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_range_cf(
-    rocksdb_writebatch_t* b, 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);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_rangev(
-    rocksdb_writebatch_t* b, int num_keys, const char* const* start_keys_list,
-    const size_t* start_keys_list_sizes, const char* const* end_keys_list,
-    const size_t* end_keys_list_sizes);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_rangev_cf(
-    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* start_keys_list,
-    const size_t* start_keys_list_sizes, const char* const* end_keys_list,
-    const size_t* end_keys_list_sizes);
 extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data(
    rocksdb_writebatch_t*, const char* blob, size_t len);
 extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate(
@@ -452,10 +422,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate(
    void (*deleted)(void*, const char* k, size_t klen));
 extern ROCKSDB_LIBRARY_API const char* rocksdb_writebatch_data(
    rocksdb_writebatch_t*, size_t* size);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point(
-    rocksdb_writebatch_t*);
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point(
-    rocksdb_writebatch_t*, char** errptr);

 /* Block based table options */

@@ -529,8 +495,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cuckoo_table_factory(
    rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options);

 /* Options */
-extern ROCKSDB_LIBRARY_API void rocksdb_set_options(
-    rocksdb_t* db, int count, const char* const keys[], const char* const values[], char** errptr);

 extern ROCKSDB_LIBRARY_API rocksdb_options_t* rocksdb_options_create();
 extern ROCKSDB_LIBRARY_API void rocksdb_options_destroy(rocksdb_options_t*);
@@ -640,10 +604,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_soft_rate_limit(
    rocksdb_options_t*, double);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_hard_rate_limit(
    rocksdb_options_t*, double);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_soft_pending_compaction_bytes_limit(
-    rocksdb_options_t* opt, size_t v);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_hard_pending_compaction_bytes_limit(
-    rocksdb_options_t* opt, size_t v);
 extern ROCKSDB_LIBRARY_API void
 rocksdb_options_set_rate_limit_delay_max_milliseconds(rocksdb_options_t*,
                                                      unsigned int);
@@ -671,14 +631,12 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_manifest_preallocation_size(
 extern ROCKSDB_LIBRARY_API void
 rocksdb_options_set_purge_redundant_kvs_while_flush(rocksdb_options_t*,
                                                    unsigned char);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_os_buffer(
+    rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_mmap_reads(
    rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_mmap_writes(
    rocksdb_options_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_direct_reads(
-    rocksdb_options_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_direct_writes(
-    rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_is_fd_close_on_exec(
    rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_skip_log_error_on_recovery(
@@ -709,8 +667,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disable_data_sync(
    rocksdb_options_t*, int);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disable_auto_compactions(
    rocksdb_options_t*, int);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_optimize_filters_for_hits(
-    rocksdb_options_t*, int);
 extern ROCKSDB_LIBRARY_API void
 rocksdb_options_set_delete_obsolete_files_period_micros(rocksdb_options_t*,
                                                        uint64_t);
@@ -893,10 +849,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_tailing(
    rocksdb_readoptions_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_readahead_size(
    rocksdb_readoptions_t*, size_t);
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_pin_data(
-    rocksdb_readoptions_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_total_order_seek(
-    rocksdb_readoptions_t*, unsigned char);

 /* Write options */

@@ -909,20 +861,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_sync(
 extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_disable_WAL(
    rocksdb_writeoptions_t* opt, int disable);

-/* Compact range options */
-
-extern ROCKSDB_LIBRARY_API rocksdb_compactoptions_t*
-rocksdb_compactoptions_create();
-extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_destroy(
-    rocksdb_compactoptions_t*);
-extern ROCKSDB_LIBRARY_API void
-rocksdb_compactoptions_set_exclusive_manual_compaction(
-    rocksdb_compactoptions_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_change_level(
-    rocksdb_compactoptions_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_target_level(
-    rocksdb_compactoptions_t*, int);
-
 /* Flush options */

 extern ROCKSDB_LIBRARY_API rocksdb_flushoptions_t*
@@ -939,10 +877,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_lru(
 extern ROCKSDB_LIBRARY_API void rocksdb_cache_destroy(rocksdb_cache_t* cache);
 extern ROCKSDB_LIBRARY_API void rocksdb_cache_set_capacity(
    rocksdb_cache_t* cache, size_t capacity);
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_cache_get_usage(rocksdb_cache_t* cache);
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache);

 /* Env */

@@ -24,7 +24,6 @@

 #include <stdint.h>
 #include <memory>
-#include <string>
 #include "rocksdb/slice.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
@@ -39,10 +38,8 @@ class Cache;
 // is set, insert to the cache will fail when cache is full. User can also
 // set percentage of the cache reserves for high priority entries via
 // high_pri_pool_pct.
-// num_shard_bits = -1 means it is automatically determined: every shard
-// will be at least 512KB and number of shard bits will not exceed 6.
 extern std::shared_ptr<Cache> NewLRUCache(size_t capacity,
-                                          int num_shard_bits = -1,
+                                          int num_shard_bits = 6,
                                          bool strict_capacity_limit = false,
                                          double high_pri_pool_ratio = 0.0);

@@ -52,7 +49,7 @@ extern std::shared_ptr<Cache> NewLRUCache(size_t capacity,
 //
 // Return nullptr if it is not supported.
 extern std::shared_ptr<Cache> NewClockCache(size_t capacity,
-                                            int num_shard_bits = -1,
+                                            int num_shard_bits = 6,
                                            bool strict_capacity_limit = false);

 class Cache {
@@ -104,12 +101,6 @@ class Cache {
  // function.
  virtual Handle* Lookup(const Slice& key, Statistics* stats = nullptr) = 0;

-  // Increments the reference count for the handle if it refers to an entry in
-  // the cache. Returns true if refcount was incremented; otherwise, returns
-  // false.
-  // REQUIRES: handle must have been returned by a method on *this.
-  virtual bool Ref(Handle* handle) = 0;
-
  // Release a mapping returned by a previous Lookup().
  // REQUIRES: handle must not have been released yet.
  // REQUIRES: handle must have been returned by a method on *this.
@@ -176,8 +167,6 @@ class Cache {
  // Prerequisit: no entry is referenced.
  virtual void EraseUnRefEntries() = 0;

-  virtual std::string GetPrintableOptions() const { return ""; }
-
 private:
  // No copying allowed
  Cache(const Cache&);
@@ -140,12 +140,6 @@ class CompactionFilter {
  //      by kRemoveAndSkipUntil can disappear from a snapshot - beware
  //      if you're using TransactionDB or DB::GetSnapshot().
  //
-  //      Another warning: if value for a key was overwritten or merged into
-  //      (multiple Put()s or Merge()s), and compaction filter skips this key
-  //      with kRemoveAndSkipUntil, it's possible that it will remove only
-  //      the new value, exposing the old value that was supposed to be
-  //      overwritten.
-  //
  //      If you use kRemoveAndSkipUntil, consider also reducing
  //      compaction_readahead_size option.
  //
@@ -288,8 +288,6 @@ Status GetStringFromColumnFamilyOptions(std::string* opts_str,
 Status GetStringFromCompressionType(std::string* compression_str,
                                    CompressionType compression_type);

-std::vector<CompressionType> GetSupportedCompressions();
-
 Status GetBlockBasedTableOptionsFromString(
    const BlockBasedTableOptions& table_options,
    const std::string& opts_str,
Author	SHA1	Message	Date
Islam AbdelRahman	e14eaa31fd	Bump version to 5.0.1	2016-12-16 17:49:01 -08:00
Andrew Kryczka	8e5a257bfe	Reduce compaction iterator status checks Summary: seems it's expensive to check status since the underlying merge iterator checks status of all its children. so only do it when it's really necessary to get the status before invoking Next(), i.e., when we're advancing to get the first key in the next file. Closes https://github.com/facebook/rocksdb/pull/1691 Differential Revision: D4343446 Pulled By: siying fbshipit-source-id: 70ab315	2016-12-16 17:48:27 -08:00
Yi Wu	a0cdf54bd3	Iterator should be in corrupted status if merge operator return false Summary: Iterator should be in corrupted status if merge operator return false. Also add test to make sure if max_successive_merges is hit during write, data will not be lost. Closes https://github.com/facebook/rocksdb/pull/1665 Differential Revision: D4322695 Pulled By: yiwu-arbug fbshipit-source-id: b327b05	2016-12-16 11:20:08 -08:00
Islam AbdelRahman	935ce6d386	break Flush wait for dropped CF Summary: In FlushJob we dont do the Flush if the CF is dropped https://github.com/facebook/rocksdb/blob/master/db/flush_job.cc#L184-L188 but inside WaitForFlushMemTable we keep waiting forever even if the CF is dropped. Closes https://github.com/facebook/rocksdb/pull/1664 Differential Revision: D4321032 Pulled By: IslamAbdelRahman fbshipit-source-id: 6e2b25d	2016-12-14 13:27:12 -08:00
Islam AbdelRahman	c93f7848c6	Disallow ingesting files into dropped CFs Summary: This PR update IngestExternalFile to return an error if we try to ingest a file into a dropped CF. Right now if IngestExternalFile want to flush a memtable, and it's ingesting a file into a dropped CF, it will wait forever since flushing is not possible for the dropped CF Closes https://github.com/facebook/rocksdb/pull/1657 Differential Revision: D4318657 Pulled By: IslamAbdelRahman fbshipit-source-id: ed6ea2b	2016-12-14 13:26:40 -08:00
Islam AbdelRahman	882e706400	Fix issue where IngestExternalFile insert blocks in block cache with g_seqno=0 Summary: When we Ingest an external file we open it to read some metadata and first/last key during doing that we insert blocks into the block cache with global_seqno = 0 If we move the file (did not copy it) into the DB, we will use these blocks with the wrong seqno in the read path Closes https://github.com/facebook/rocksdb/pull/1627 Differential Revision: D4293332 Pulled By: yiwu-arbug fbshipit-source-id: 3ce5523	2016-12-14 13:26:27 -08:00
Islam AbdelRahman	f04765f7cf	Add EventListener::OnExternalFileIngested() event Summary: Add EventListener::OnExternalFileIngested() to allow user to subscribe to external file ingestion events Closes https://github.com/facebook/rocksdb/pull/1623 Differential Revision: D4285844 Pulled By: IslamAbdelRahman fbshipit-source-id: 0b95a88	2016-12-14 13:25:48 -08:00
Islam AbdelRahman	7768975517	Allow user to specify a CF for SST files generated by SstFileWriter Summary: Allow user to explicitly specify that the generated file by SstFileWriter will be ingested in a specific CF. This allow us to persist the CF id in the generated file Closes https://github.com/facebook/rocksdb/pull/1615 Differential Revision: D4270422 Pulled By: IslamAbdelRahman fbshipit-source-id: 7fb954e	2016-12-14 13:24:14 -08:00
Mike Kolupaev	314828c973	Fixed a crash in debug build in flush_job.cc Summary: It was doing `&range_del_iters[0]` on an empty vector. Even though the resulting pointer is never dereferenced, it's still bad for two reasons: * the practical reason: it crashes with `std::out_of_range` exception in our debug build, * the "C++ standard lawyer" reason: it's undefined behavior because, in `std::vector` implementation, it probably "dereferences" a null pointer, which is invalid even though it doesn't actually read the pointed memory, just converts a pointer into a reference (and then flush_job.cc converts it back to pointer); nullptr references are undefined behavior. Closes https://github.com/facebook/rocksdb/pull/1612 Differential Revision: D4265625 Pulled By: al13n321 fbshipit-source-id: db26fb9	2016-12-14 13:08:37 -08:00
Yi Wu	8a6d7a349a	Mention IngestExternalFile changes in HISTORY.md Summary: I hit the land button too fast and didn't include the line. Closes https://github.com/facebook/rocksdb/pull/1622 Differential Revision: D4281316 Pulled By: yiwu-arbug fbshipit-source-id: c7b38e0	2016-12-05 16:15:03 -08:00
Yi Wu	1991ad0409	Update HISTORY.md for 5.0 branch Summary: These changes are included in the new branch-cut. Closes https://github.com/facebook/rocksdb/pull/1621 Differential Revision: D4281015 Pulled By: yiwu-arbug fbshipit-source-id: d88858b	2016-12-05 16:14:44 -08:00
Mike Kolupaev	2be7301d42	Fixed CompactionFilter::Decision::kRemoveAndSkipUntil Summary: Embarassingly enough, the first time I tried to use my new feature in logdevice it crashed with this assertion failure: db/pinned_iterators_manager.h:30: void rocksdb::PinnedIteratorsManager::StartPinning(): Assertion `pinning_enabled == false' failed The issue was that `pinned_iters_mgr_.StartPinning()` was called but `pinned_iters_mgr_.ReleasePinnedData()` wasn't. Closes https://github.com/facebook/rocksdb/pull/1611 Differential Revision: D4265622 Pulled By: al13n321 fbshipit-source-id: 747b10f	2016-12-05 15:35:20 -08:00