Disable error as warning

The previuos change that use gcc-5 set USE_SSE to wrong flag by mistake. Fix it.

.arcconfig

@@ -1,6 +1,6 @@
 {
   "project_id" : "rocksdb",
-  "conduit_uri" : "https://phabricator.fb.com/api/",
+  "conduit_uri" : "https://reviews.facebook.net/",
   "copyright_holder" : "Facebook",
   "load" : [
     "arcanist_util"

.gitignore

@@ -37,7 +37,6 @@ util/build_version.cc
 build_tools/VALGRIND_LOGS/
 coverage/COVERAGE_REPORT
 .gdbhistory
-.gdb_history
 package/
 .phutil_module_cache
 unity.a
@@ -70,4 +69,3 @@ LOG
 db_logs/
 tp2/
 fbcode/
-fbcode

.travis.yml

@@ -1,22 +1,15 @@
 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
@@ -27,20 +20,17 @@ env:
   # 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

CMakeLists.txt

@@ -43,11 +43,6 @@ else()
     add_definitions(-DROCKSDB_JEMALLOC)
     include_directories(${JEMALLOC_INCLUDE_DIR})
   endif()
-  if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
-    # FreeBSD has jemaloc as default malloc
-    add_definitions(-DROCKSDB_JEMALLOC)
-    set(WITH_JEMALLOC ON)
-  endif()
   option(WITH_SNAPPY "build with SNAPPY" OFF)
   if(WITH_SNAPPY)
     find_package(snappy REQUIRED)
@@ -84,28 +79,24 @@ endif()
 string(REGEX REPLACE "[^0-9a-f]+" "" GIT_SHA "${GIT_SHA}")
 
 set(BUILD_VERSION_CC ${CMAKE_BINARY_DIR}/build_version.cc)
-configure_file(util/build_version.cc.in ${BUILD_VERSION_CC} @ONLY)
+file(GENERATE OUTPUT ${BUILD_VERSION_CC} CONTENT
+  "#include \"build_version.h\"
+const char* rocksdb_build_git_sha = \"rocksdb_build_git_sha:${GIT_SHA}\";
+const char* rocksdb_build_git_datetime = \"rocksdb_build_git_datetime:${GIT_DATE_TIME}\";
+const char* rocksdb_build_compile_date = __DATE__;
+")
 add_library(build_version OBJECT ${BUILD_VERSION_CC})
 target_include_directories(build_version PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/util)
 if(WIN32)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo  /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
 
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W3 /wd4127 /wd4800 /wd4996 /wd4351")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W3 /WX /wd4127 /wd4800 /wd4996 /wd4351")
 else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall -Werror")
   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")
-  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)
-if(FAIL_ON_WARNINGS)
-  if(MSVC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
-  else() # assume GCC
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -fno-omit-frame-pointer -momit-leaf-frame-pointer")
 endif()
 
 option(WITH_ASAN "build with ASAN" OFF)
@@ -402,7 +393,6 @@ set(SOURCES
         utilities/env_registry.cc
         utilities/geodb/geodb_impl.cc
         utilities/leveldb_options/leveldb_options.cc
-        utilities/lua/rocks_lua_compaction_filter.cc
         utilities/memory/memory_util.cc
         utilities/merge_operators/string_append/stringappend.cc
         utilities/merge_operators/string_append/stringappend2.cc
@@ -501,8 +491,6 @@ set(TESTS
         db/db_inplace_update_test.cc
         db/db_iter_test.cc
         db/db_log_iter_test.cc
-        db/db_memtable_test.cc
-        db/db_merge_operator_test.cc
         db/db_options_test.cc
         db/db_properties_test.cc
         db/db_table_properties_test.cc
@@ -513,7 +501,6 @@ set(TESTS
         db/db_bloom_filter_test.cc
         db/db_flush_test.cc
         db/db_iterator_test.cc
-        db/db_range_del_test.cc
         db/db_sst_test.cc
         db/external_sst_file_test.cc
         db/db_universal_compaction_test.cc
@@ -603,7 +590,6 @@ set(TESTS
         utilities/ttl/ttl_test.cc
         utilities/write_batch_with_index/write_batch_with_index_test.cc
         utilities/column_aware_encoding_test.cc
-        utilities/lua/rocks_lua_test.cc
 )
 if(WITH_LIBRADOS)
   list(APPEND TESTS utilities/env_librados_test.cc)

HISTORY.md

@@ -1,32 +1,13 @@
 # Rocksdb Change Log
-## 5.1.0 (01/13/2016)
+## 4.13.5
 ### 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.
+* Fix a regression in compaction performance.
+* Disallow calling IngestExternalFile() on a dropped column family.
+* Add EventListener::OnExternalFileIngested() event that will be called for files that are successfully ingested.
 
-### 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)
+## 4.13.4
 ### 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.
 
 ## 4.13.0 (10/18/2016)
 ### Public API Change

INSTALL.md

@@ -40,7 +40,7 @@ your make commands, like this: `PORTABLE=1 make static_lib`
 ## Supported platforms
 
 * **Linux - Ubuntu**
-    * Upgrade your gcc to version at least 4.8 to get C++11 support.
+    * Upgrade your gcc to version at least 4.7 to get C++11 support.
     * Install gflags. First, try: `sudo apt-get install libgflags-dev`
       If this doesn't work and you're using Ubuntu, here's a nice tutorial:
       (http://askubuntu.com/questions/312173/installing-gflags-12-04)
@@ -49,8 +49,8 @@ your make commands, like this: `PORTABLE=1 make static_lib`
     * Install zlib. Try: `sudo apt-get install zlib1g-dev`.
     * Install bzip2: `sudo apt-get install libbz2-dev`.
 * **Linux - CentOS**
-    * Upgrade your gcc to version at least 4.8 to get C++11 support:
-      `yum install gcc48-c++`
+    * Upgrade your gcc to version at least 4.7 to get C++11 support:
+      `yum install gcc47-c++`
     * Install gflags:
 
               wget https://gflags.googlecode.com/files/gflags-2.0-no-svn-files.tar.gz
@@ -80,7 +80,7 @@ your make commands, like this: `PORTABLE=1 make static_lib`
         * Update XCode:  run `xcode-select --install` (or install it from XCode App's settting).
         * Install via [homebrew](http://brew.sh/).
             * If you're first time developer in MacOS, you still need to run: `xcode-select --install` in your command line.
-            * run `brew tap homebrew/versions; brew install gcc48 --use-llvm` to install gcc 4.8 (or higher).
+            * run `brew tap homebrew/versions; brew install gcc47 --use-llvm` to install gcc 4.7 (or higher).
     * run `brew install rocksdb`
 
 * **iOS**:

Makefile

@@ -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
@@ -169,8 +166,6 @@ ifneq ($(filter -DROCKSDB_LITE,$(OPT)),)
 	# found
 	CFLAGS += -fno-exceptions
 	CXXFLAGS += -fno-exceptions
-	# LUA is not supported under ROCKSDB_LITE
-	LUA_PATH =
 endif
 
 # ASAN doesn't work well with jemalloc. If we're compiling with ASAN, we should use regular malloc.
@@ -190,8 +185,6 @@ ifdef COMPILE_WITH_TSAN
         # Turn off -pg when enabling TSAN testing, because that induces
         # a link failure.  TODO: find the root cause
 	PROFILING_FLAGS =
-	# LUA is not supported under TSAN
-	LUA_PATH =
 endif
 
 # USAN doesn't work well with jemalloc. If we're compiling with USAN, we should use regular malloc.
@@ -223,38 +216,6 @@ 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
-LUA_INCLUDE=$(LUA_PATH)/include
-endif
-
-LUA_INCLUDE_FILE=$(LUA_INCLUDE)/lualib.h
-
-ifeq ("$(wildcard $(LUA_INCLUDE_FILE))", "")
-# LUA_INCLUDE_FILE does not exist
-$(error Cannot find lualib.h under $(LUA_INCLUDE).  Try to specify both LUA_PATH and LUA_INCLUDE manually)
-endif
-LUA_FLAGS = -I$(LUA_INCLUDE) -DLUA -DLUA_COMPAT_ALL
-CFLAGS += $(LUA_FLAGS)
-CXXFLAGS += $(LUA_FLAGS)
-
-ifndef LUA_LIB
-LUA_LIB = $(LUA_PATH)/lib/liblua.a
-endif
-ifeq ("$(wildcard $(LUA_LIB))", "") # LUA_LIB does not exist
-$(error $(LUA_LIB) does not exist.  Try to specify both LUA_PATH and LUA_LIB manually)
-endif
-LDFLAGS += $(LUA_LIB)
-
-endif
-
-
 CFLAGS += $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CCFLAGS) $(OPT)
 CXXFLAGS += $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT) -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers
 
@@ -266,7 +227,14 @@ ifdef FORCE_GIT_SHA
 else
 	git_sha := $(shell git rev-parse HEAD 2>/dev/null)
 endif
-gen_build_version = sed -e s/@@GIT_SHA@@/$(git_sha)/ -e s/@@GIT_DATE_TIME@@/$(date)/ util/build_version.cc.in
+gen_build_version =							\
+  printf '%s\n'								\
+    '\#include "build_version.h"'					\
+    'const char* rocksdb_build_git_sha =				\
+      "rocksdb_build_git_sha:$(git_sha)";'			\
+    'const char* rocksdb_build_git_date =				\
+      "rocksdb_build_git_date:$(date)";'				\
+    'const char* rocksdb_build_compile_date = __DATE__;'
 
 # Record the version of the source that we are compiling.
 # We keep a record of the git revision in this file.  It is then built
@@ -311,10 +279,7 @@ TESTS = \
 	db_flush_test \
 	db_inplace_update_test \
 	db_iterator_test \
-	db_memtable_test \
-	db_merge_operator_test \
 	db_options_test \
-	db_range_del_test \
 	db_sst_test \
 	external_sst_file_test \
 	db_tailing_iter_test \
@@ -324,7 +289,6 @@ TESTS = \
 	db_properties_test \
 	db_table_properties_test \
 	autovector_test \
-	cleanable_test \
 	column_family_test \
 	table_properties_collector_test \
 	arena_test \
@@ -418,8 +382,6 @@ TESTS = \
 	iostats_context_test \
 	persistent_cache_test \
 	statistics_test \
-	lua_test \
-	range_del_aggregator_test \
 	lru_cache_test \
 
 PARALLEL_TEST = \
@@ -434,9 +396,7 @@ PARALLEL_TEST = \
 	fault_injection_test \
 	inlineskiplist_test \
 	manual_compaction_test \
-	persistent_cache_test \
-	table_test \
-	transaction_test
+	table_test
 
 SUBSET := $(TESTS)
 ifdef ROCKSDBTESTS_START
@@ -716,8 +676,7 @@ ifeq ($(filter -DROCKSDB_LITE,$(OPT)),)
 	sh tools/rocksdb_dump_test.sh
 endif
 
-# TODO add ldb_tests
-check_some: $(SUBSET)
+check_some: $(SUBSET) ldb_tests
 	for t in $(SUBSET); do echo "===== Running $$t"; ./$$t || exit 1; done
 
 .PHONY: ldb_tests
@@ -760,9 +719,6 @@ ubsan_crash_test:
 	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test
 	$(MAKE) clean
 
-valgrind_test:
-	DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
-
 valgrind_check: $(TESTS)
 	$(MAKE) DRIVER="$(VALGRIND_VER) $(VALGRIND_OPTS)" gen_parallel_tests
 	$(AM_V_GEN)if test "$(J)" != 1                                  \
@@ -999,18 +955,9 @@ db_inplace_update_test: db/db_inplace_update_test.o db/db_test_util.o $(LIBOBJEC
 db_iterator_test: db/db_iterator_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
-db_memtable_test: db/db_memtable_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
-db_merge_operator_test: db/db_merge_operator_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 db_options_test: db/db_options_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
-db_range_del_test: db/db_range_del_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 db_sst_test: db/db_sst_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
@@ -1148,9 +1095,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)
 
@@ -1310,11 +1254,6 @@ statistics_test: util/statistics_test.o $(LIBOBJECTS) $(TESTHARNESS)
 lru_cache_test: util/lru_cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
-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
@@ -1378,11 +1317,6 @@ else
 	JAVA_INCLUDE = -I/System/Library/Frameworks/JavaVM.framework/Headers/
 endif
 endif
-ifeq ($(PLATFORM), OS_FREEBSD)
-	JAVA_INCLUDE += -I$(JAVA_HOME)/include/freebsd
-	ROCKSDBJNILIB = librocksdbjni-freebsd$(ARCH).so
-	ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-freebsd$(ARCH).jar
-endif
 ifeq ($(PLATFORM), OS_SOLARIS)
 	ROCKSDBJNILIB = librocksdbjni-solaris$(ARCH).so
 	ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-solaris$(ARCH).jar

USERS.md

@@ -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,6 +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.

Vagrantfile

@@ -1,4 +1,3 @@
-# Vagrant file
 Vagrant.configure("2") do |config|
 
   config.vm.provider "virtualbox" do |v|

arcanist_util/config/RocksDBCommonHelper.php

@@ -12,6 +12,7 @@ define("ENV_HTTPS_APP_VALUE", "HTTPS_APP_VALUE");
 define("ENV_HTTPS_TOKEN_VALUE", "HTTPS_TOKEN_VALUE");
 
 define("PRIMARY_TOKEN_FILE", '/home/krad/.sandcastle');
+define("SECONDARY_TOKEN_FILE", '$HOME/.sandcastle');
 define("CONT_RUN_ALIAS", "leveldb");
 
 //////////////////////////////////////////////////////////////////////
@@ -21,10 +22,12 @@ 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 '
+         . 'no_proxy=facebook.com,tfbnw.net,fb.com '
+         . 'http_proxy=fwdproxy.any.facebook.com:8080 '
+         . 'https_proxy=fwdproxy.any.facebook.com:8080 arc call-conduit '
          . 'differential.updateunitresults';
   shell_exec($cmd);
 }
@@ -35,10 +38,12 @@ 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 '
+         . 'no_proxy=facebook.com,tfbnw.net,fb.com '
+         . 'http_proxy=fwdproxy.any.facebook.com:8080 '
+         . 'https_proxy=fwdproxy.any.facebook.com:8080 arc call-conduit '
          . 'differential.updateunitresults';
   return $cmd;
 }
@@ -103,7 +108,8 @@ function getSteps($applyDiff, $diffID, $username, $test) {
     // Patch the code (keep your fingures crossed).
     $patch = array(
       "name" => "Patch " . $diffID,
-      "shell" => "arc --arcrc-file ~/.arcrc "
+      "shell" => "no_proxy=facebook.com,tfbnw.net,fb.com "
+                  ."HTTPS_PROXY=fwdproxy:8080 arc --arcrc-file ~/.arcrc "
                   . "patch --nocommit --diff " . $diffID,
       "user" => "root"
     );
@@ -172,8 +178,6 @@ function getSteps($applyDiff, $diffID, $username, $test) {
 function getSandcastleConfig() {
   $sandcastle_config = array();
 
-  $cwd = getcwd();
-  $cwd_token_file = "{$cwd}/.sandcastle";
   // This is a case when we're executed from a continuous run. Fetch the values
   // from the environment.
   if (getenv(ENV_POST_RECEIVE_HOOK)) {
@@ -184,20 +188,20 @@ function getSandcastleConfig() {
     // configuration files.
     for ($i = 0; $i < 50; $i++) {
       if (file_exists(PRIMARY_TOKEN_FILE) ||
-          file_exists($cwd_token_file)) {
+          file_exists(SECONDARY_TOKEN_FILE)) {
         break;
       }
       // If we failed to fetch the tokens, sleep for 0.2 second and try again
       usleep(200000);
     }
     assert(file_exists(PRIMARY_TOKEN_FILE) ||
-           file_exists($cwd_token_file));
+           file_exists(SECONDARY_TOKEN_FILE));
 
     // Try the primary location first, followed by a secondary.
     if (file_exists(PRIMARY_TOKEN_FILE)) {
       $cmd = 'cat ' . PRIMARY_TOKEN_FILE;
     } else {
-      $cmd = 'cat ' . $cwd_token_file;
+      $cmd = 'cat ' . SECONDARY_TOKEN_FILE;
     }
 
     assert(strlen($cmd) > 0);
@@ -299,21 +303,11 @@ function getSandcastleConfig() {
   );
 
   // Submit to Sandcastle.
-  $url = 'https://interngraph.intern.facebook.com/sandcastle/create';
-
-  $job = array(
-    'command' => 'SandcastleUniversalCommand',
-    'args' => $command,
-    'capabilities' => array(
-      'vcs' => 'rocksdb-int-git',
-      'type' => 'lego',
-    ),
-    'hash' => 'origin/master',
-    'user' => $username,
-    'alias' => 'rocksdb-precommit',
-    'tags' => array('rocksdb'),
-    'description' => 'Rocksdb precommit job',
-  );
+  $url = 'https://interngraph.intern.facebook.com/sandcastle/generate?'
+          .'command=SandcastleUniversalCommand'
+          .'&vcs=rocksdb-git&revision=origin%2Fmaster&type=lego'
+          .'&user=' . $username . '&alias=rocksdb-precommit'
+          .'&command-args=' . urlencode(json_encode($command));
 
   // Fetch the configuration necessary to submit a successful HTTPS request.
   $sandcastle_config = getSandcastleConfig();
@@ -321,9 +315,8 @@ function getSandcastleConfig() {
   $app = $sandcastle_config[0];
   $token = $sandcastle_config[1];
 
-  $cmd = 'curl -s -k -F app=' . $app . ' '
-          . '-F token=' . $token . ' -F job=\'' . json_encode($job)
-          .'\' "' . $url . '"';
+  $cmd = 'https_proxy= HTTPS_PROXY= curl -s -k -F app=' . $app . ' '
+          . '-F token=' . $token . ' "' . $url . '"';
 
   $output = shell_exec($cmd);
   assert(strlen($output) > 0);

build_tools/build_detect_platform

@@ -51,12 +51,7 @@ 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
-    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
+    source "$PWD/build_tools/fbcode_config.sh"
 fi
 
 # Delete existing output, if it exists
@@ -466,4 +461,3 @@ echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
 if test -n "$JEMALLOC"; then
   echo "JEMALLOC=1" >> "$OUTPUT"
 fi
-echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"

build_tools/cont_integration.sh

@@ -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 {

build_tools/dependencies.sh

@@ -1,18 +1,19 @@
-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
+# 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

build_tools/dependencies_4.8.1.sh

@@ -15,4 +15,3 @@ TBB_BASE=/mnt/gvfs/third-party2/tbb/9d9a554877d0c5bef330fe818ab7178806dd316a/4.0
 KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/7c111ff27e0c466235163f00f280a9d617c3d2ec/4.0.9-36_fbk5_2933_gd092e3f/gcc-4.8.1-glibc-2.17/da39a3e
 BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/b7fd454c4b10c6a81015d4524ed06cdeab558490/2.26/centos6-native/da39a3e
 VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d7f4d4d86674a57668e3a96f76f0e17dd0eb8765/3.8.1/gcc-4.8.1-glibc-2.17/c3f970a
-LUA_BASE=/mnt/gvfs/third-party2/lua/61e4abf5813bbc39bc4f548757ccfcadde175a48/5.2.3/centos6-native/730f94e

build_tools/fbcode_config.sh

@@ -13,7 +13,7 @@ source "$BASEDIR/dependencies.sh"
 CFLAGS=""
 
 # libgcc
-LIBGCC_INCLUDE="$LIBGCC_BASE/include"
+LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/7.3.0"
 LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
 
 # glibc
@@ -43,12 +43,16 @@ if test -z $PIC_BUILD; then
   LZ4_INCLUDE=" -I $LZ4_BASE/include/"
   LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
   CFLAGS+=" -DLZ4"
-
-  ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
-  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
-  CFLAGS+=" -DZSTD"
 fi
 
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
+if test -z $PIC_BUILD; then
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+else
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
+fi
+CFLAGS+=" -DZSTD"
+
 # location of gflags headers and libraries
 GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
 if test -z $PIC_BUILD; then
@@ -56,7 +60,7 @@ if test -z $PIC_BUILD; then
 else
   GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
 fi
-CFLAGS+=" -DGFLAGS=google"
+CFLAGS+=" -DGFLAGS=gflags"
 
 # location of jemalloc
 JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
@@ -104,8 +108,8 @@ if [ -z "$USE_CLANG" ]; then
   CXX="$GCC_BASE/bin/g++"
 
   CFLAGS+=" -B$BINUTILS/gold"
-  CFLAGS+=" -isystem $GLIBC_INCLUDE"
   CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
   JEMALLOC=1
 else
   # clang
@@ -116,8 +120,8 @@ else
   KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
 
   CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib"
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.9.x "
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.9.x/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x/x86_64-facebook-linux "
   CFLAGS+=" -isystem $GLIBC_INCLUDE"
   CFLAGS+=" -isystem $LIBGCC_INCLUDE"
   CFLAGS+=" -isystem $CLANG_INCLUDE"
@@ -128,13 +132,14 @@ else
 fi
 
 CFLAGS+=" $DEPS_INCLUDE"
-CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
 CXXFLAGS+=" $CFLAGS"
 
 EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
-EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-4.9-glibc-2.20/lib/ld.so"
+EXEC_LDFLAGS+=" -B$BINUTILS/gold"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
-EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/gcc-4.9-glibc-2.20/lib"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform007/lib"
 # required by libtbb
 EXEC_LDFLAGS+=" -ldl"
 
@@ -144,12 +149,4 @@ EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GF
 
 VALGRIND_VER="$VALGRIND_BASE/bin/"
 
-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
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD 

build_tools/fbcode_config4.8.1.sh

@@ -110,6 +110,4 @@ EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP2_LIBS $LZ4_LIBS $ZSTD_LIBS $G
 
 VALGRIND_VER="$VALGRIND_BASE/bin/"
 
-LUA_PATH="$LUA_BASE"
-
-export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE LUA_PATH
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE

build_tools/format-diff.sh

@@ -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

build_tools/make_package.sh

@@ -65,8 +65,8 @@ function main() {
 
   if [[ -d /vagrant ]]; then
     if [[ $OS = "ubuntu" ]]; then
-      package g++-4.8
-      export CXX=g++-4.8
+      package g++-4.7
+      export CXX=g++-4.7
 
       # the deb would depend on libgflags2, but the static lib is the only thing
       # installed by make install

build_tools/rocksdb-lego-determinator

@@ -100,7 +100,7 @@ CONTRUN_NAME="ROCKSDB_CONTRUN_NAME"
 # the value of $ONCALL. If it's a diff then just call `false` to make sure
 # that errors will be properly propagated to the caller.
 if [ ! -z $ONCALL ]; then
-  TASK_CREATION_TOOL="/usr/local/bin/mysql_mtr_filter --rocksdb --oncall $ONCALL"
+  TASK_CREATION_TOOL="/usr/local/bin/mysql_mtr_filter --rocksdb"
 else
   TASK_CREATION_TOOL="false"
 fi
@@ -548,7 +548,7 @@ VALGRIND_TEST_COMMANDS="[
             {
                 'name':'Run RocksDB debug unit tests',
                 'timeout': 86400,
-                'shell':'$SHM $DEBUG make $PARALLELISM valgrind_test || $CONTRUN_NAME=valgrind_check $TASK_CREATION_TOOL',
+                'shell':'$DISABLE_JEMALLOC $SHM $DEBUG make $PARALLELISM valgrind_check || $CONTRUN_NAME=valgrind_check $TASK_CREATION_TOOL',
                 'user':'root',
                 $PARSER
             },

build_tools/update_dependencies.sh

@@ -87,7 +87,6 @@ get_lib_base tbb        4.0_update2 gcc-4.9-glibc-2.20
 get_lib_base kernel-headers LATEST 
 get_lib_base binutils   LATEST centos6-native 
 get_lib_base valgrind   3.10.0 gcc-4.9-glibc-2.20
-get_lib_base lua        5.2.3 gcc-4.9-glibc-2.20
 
 git diff $OUTPUT
 
@@ -126,6 +125,5 @@ get_lib_base tbb        4.0_update2 gcc-4.8.1-glibc-2.17
 get_lib_base kernel-headers LATEST gcc-4.8.1-glibc-2.17 
 get_lib_base binutils   LATEST centos6-native 
 get_lib_base valgrind   3.8.1  gcc-4.8.1-glibc-2.17
-get_lib_base lua        5.2.3 centos6-native
 
 git diff $OUTPUT

db/builder.cc

@@ -61,8 +61,7 @@ TableBuilder* NewTableBuilder(
 Status BuildTable(
     const std::string& dbname, Env* env, const ImmutableCFOptions& ioptions,
     const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
-    TableCache* table_cache, InternalIterator* iter,
-    std::unique_ptr<InternalIterator> range_del_iter, FileMetaData* meta,
+    TableCache* table_cache, InternalIterator* iter, FileMetaData* meta,
     const InternalKeyComparator& internal_comparator,
     const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
         int_tbl_prop_collector_factories,
@@ -82,13 +81,6 @@ Status BuildTable(
   Status s;
   meta->fd.file_size = 0;
   iter->SeekToFirst();
-  std::unique_ptr<RangeDelAggregator> range_del_agg(
-      new RangeDelAggregator(internal_comparator, snapshots));
-  s = range_del_agg->AddTombstones(std::move(range_del_iter));
-  if (!s.ok()) {
-    // may be non-ok if a range tombstone key is unparsable
-    return s;
-  }
 
   std::string fname = TableFileName(ioptions.db_paths, meta->fd.GetNumber(),
                                     meta->fd.GetPathId());
@@ -98,7 +90,7 @@ Status BuildTable(
 #endif  // !ROCKSDB_LITE
   TableProperties tp;
 
-  if (iter->Valid() || range_del_agg->ShouldAddTombstones()) {
+  if (iter->Valid()) {
     TableBuilder* builder;
     unique_ptr<WritableFileWriter> file_writer;
     {
@@ -120,6 +112,8 @@ Status BuildTable(
           compression_opts, level);
     }
 
+    std::unique_ptr<RangeDelAggregator> range_del_agg;
+    range_del_agg.reset(new RangeDelAggregator(internal_comparator, snapshots));
     MergeHelper merge(env, internal_comparator.user_comparator(),
                       ioptions.merge_operator, nullptr, ioptions.info_log,
                       mutable_cf_options.min_partial_merge_operands,
@@ -144,9 +138,6 @@ Status BuildTable(
             ThreadStatus::FLUSH_BYTES_WRITTEN, IOSTATS(bytes_written));
       }
     }
-    // nullptr for table_{min,max} so all range tombstones will be flushed
-    range_del_agg->AddToBuilder(builder, nullptr /* lower_bound */,
-                                nullptr /* upper_bound */, meta);
 
     // Finish and check for builder errors
     bool empty = builder->NumEntries() == 0;
@@ -181,8 +172,7 @@ Status BuildTable(
     if (s.ok() && !empty) {
       // Verify that the table is usable
       std::unique_ptr<InternalIterator> it(table_cache->NewIterator(
-          ReadOptions(), env_options, internal_comparator, meta->fd,
-          nullptr /* range_del_agg */, nullptr,
+          ReadOptions(), env_options, internal_comparator, meta->fd, nullptr,
           (internal_stats == nullptr) ? nullptr
                                       : internal_stats->GetFileReadHist(0),
           false /* for_compaction */, nullptr /* arena */,

db/builder.h

@@ -17,7 +17,6 @@
 #include "rocksdb/status.h"
 #include "rocksdb/table_properties.h"
 #include "rocksdb/types.h"
-#include "table/scoped_arena_iterator.h"
 #include "util/cf_options.h"
 #include "util/event_logger.h"
 
@@ -64,8 +63,7 @@ TableBuilder* NewTableBuilder(
 extern Status BuildTable(
     const std::string& dbname, Env* env, const ImmutableCFOptions& options,
     const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
-    TableCache* table_cache, InternalIterator* iter,
-    std::unique_ptr<InternalIterator> range_del_iter, FileMetaData* meta,
+    TableCache* table_cache, InternalIterator* iter, FileMetaData* meta,
     const InternalKeyComparator& internal_comparator,
     const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
         int_tbl_prop_collector_factories,

db/c.cc

@@ -30,7 +30,6 @@
 #include "rocksdb/statistics.h"
 #include "rocksdb/slice_transform.h"
 #include "rocksdb/table.h"
-#include "rocksdb/rate_limiter.h"
 #include "rocksdb/utilities/backupable_db.h"
 #include "utilities/merge_operators.h"
 
@@ -48,12 +47,10 @@ using rocksdb::WALRecoveryMode;
 using rocksdb::DB;
 using rocksdb::DBOptions;
 using rocksdb::Env;
-using rocksdb::EnvOptions;
 using rocksdb::InfoLogLevel;
 using rocksdb::FileLock;
 using rocksdb::FilterPolicy;
 using rocksdb::FlushOptions;
-using rocksdb::IngestExternalFileOptions;
 using rocksdb::Iterator;
 using rocksdb::Logger;
 using rocksdb::MergeOperator;
@@ -71,7 +68,6 @@ using rocksdb::Slice;
 using rocksdb::SliceParts;
 using rocksdb::SliceTransform;
 using rocksdb::Snapshot;
-using rocksdb::SstFileWriter;
 using rocksdb::Status;
 using rocksdb::WritableFile;
 using rocksdb::WriteBatch;
@@ -82,8 +78,6 @@ using rocksdb::BackupableDBOptions;
 using rocksdb::BackupInfo;
 using rocksdb::RestoreOptions;
 using rocksdb::CompactRangeOptions;
-using rocksdb::RateLimiter;
-using rocksdb::NewGenericRateLimiter;
 
 using std::shared_ptr;
 
@@ -104,9 +98,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; };
@@ -117,10 +108,6 @@ struct rocksdb_logger_t          { shared_ptr<Logger>  rep; };
 struct rocksdb_cache_t           { shared_ptr<Cache>   rep; };
 struct rocksdb_livefiles_t       { std::vector<LiveFileMetaData> rep; };
 struct rocksdb_column_family_handle_t  { ColumnFamilyHandle* rep; };
-struct rocksdb_envoptions_t      { EnvOptions        rep; };
-struct rocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
-struct rocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
-struct rocksdb_ratelimiter_t     { RateLimiter*      rep; };
 
 struct rocksdb_compactionfiltercontext_t {
   CompactionFilter::Context rep;
@@ -448,11 +435,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;
@@ -983,30 +966,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,
@@ -1062,11 +1021,6 @@ void rocksdb_iter_seek(rocksdb_iterator_t* iter, const char* k, size_t klen) {
   iter->rep->Seek(Slice(k, klen));
 }
 
-void rocksdb_iter_seek_for_prev(rocksdb_iterator_t* iter, const char* k,
-                                size_t klen) {
-  iter->rep->SeekForPrev(Slice(k, klen));
-}
-
 void rocksdb_iter_next(rocksdb_iterator_t* iter) {
   iter->rep->Next();
 }
@@ -1254,53 +1208,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) {
@@ -1604,13 +1511,8 @@ void rocksdb_options_set_max_bytes_for_level_base(
   opt->rep.max_bytes_for_level_base = n;
 }
 
-void rocksdb_options_set_level_compaction_dynamic_level_bytes(
-    rocksdb_options_t* opt, unsigned char v) {
-  opt->rep.level_compaction_dynamic_level_bytes = v;
-}
-
-void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt,
-                                                        double n) {
+void rocksdb_options_set_max_bytes_for_level_multiplier(
+    rocksdb_options_t* opt, int n) {
   opt->rep.max_bytes_for_level_multiplier = n;
 }
 
@@ -1723,14 +1625,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(
@@ -1791,16 +1688,6 @@ void rocksdb_options_set_bytes_per_sync(
   opt->rep.bytes_per_sync = v;
 }
 
-void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt,
-                                                         unsigned char v) {
-  opt->rep.allow_concurrent_memtable_write = v;
-}
-
-void rocksdb_options_set_enable_write_thread_adaptive_yield(
-    rocksdb_options_t* opt, unsigned char v) {
-  opt->rep.enable_write_thread_adaptive_yield = v;
-}
-
 void rocksdb_options_set_verify_checksums_in_compaction(
     rocksdb_options_t* opt, unsigned char v) {
   opt->rep.verify_checksums_in_compaction = v;
@@ -1828,11 +1715,6 @@ void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, int
   opt->rep.max_background_compactions = n;
 }
 
-void rocksdb_options_set_base_background_compactions(rocksdb_options_t* opt,
-                                                     int n) {
-  opt->rep.base_background_compactions = n;
-}
-
 void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int n) {
   opt->rep.max_background_flushes = n;
 }
@@ -1992,28 +1874,6 @@ char *rocksdb_options_statistics_get_string(rocksdb_options_t *opt) {
   return nullptr;
 }
 
-void rocksdb_options_set_ratelimiter(rocksdb_options_t *opt, rocksdb_ratelimiter_t *limiter) {
-  opt->rep.rate_limiter.reset(limiter->rep);
-  limiter->rep = nullptr;
-}
-
-rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
-    int64_t rate_bytes_per_sec,
-    int64_t refill_period_us,
-    int32_t fairness) {
-  rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t;
-  rate_limiter->rep = NewGenericRateLimiter(rate_bytes_per_sec,
-                                            refill_period_us, fairness);
-  return rate_limiter;
-}
-
-void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
-  if (limiter->rep) {
-    delete limiter->rep;
-  }
-  delete limiter;
-}
-
 /*
 TODO:
 DB::OpenForReadOnly
@@ -2251,16 +2111,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;
 }
@@ -2278,28 +2128,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;
@@ -2328,14 +2156,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();
@@ -2367,107 +2187,6 @@ void rocksdb_env_destroy(rocksdb_env_t* env) {
   delete env;
 }
 
-rocksdb_envoptions_t* rocksdb_envoptions_create() {
-  rocksdb_envoptions_t* opt = new rocksdb_envoptions_t;
-  return opt;
-}
-
-void rocksdb_envoptions_destroy(rocksdb_envoptions_t* opt) { delete opt; }
-
-rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create(
-    const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options) {
-  rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
-  writer->rep =
-      new SstFileWriter(env->rep, io_options->rep, io_options->rep.comparator);
-  return writer;
-}
-
-rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator(
-    const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options,
-    const rocksdb_comparator_t* comparator) {
-  rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
-  writer->rep =
-      new SstFileWriter(env->rep, io_options->rep, io_options->rep.comparator);
-  return writer;
-}
-
-void rocksdb_sstfilewriter_open(rocksdb_sstfilewriter_t* writer,
-                                const char* name, char** errptr) {
-  SaveError(errptr, writer->rep->Open(std::string(name)));
-}
-
-void rocksdb_sstfilewriter_add(rocksdb_sstfilewriter_t* writer, const char* key,
-                               size_t keylen, const char* val, size_t vallen,
-                               char** errptr) {
-  SaveError(errptr, writer->rep->Add(Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
-                                  char** errptr) {
-  SaveError(errptr, writer->rep->Finish(NULL));
-}
-
-void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) {
-  delete writer->rep;
-  delete writer;
-}
-
-rocksdb_ingestexternalfileoptions_t*
-rocksdb_ingestexternalfileoptions_create() {
-  rocksdb_ingestexternalfileoptions_t* opt =
-      new rocksdb_ingestexternalfileoptions_t;
-  return opt;
-}
-
-void rocksdb_ingestexternalfileoptions_set_move_files(
-    rocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files) {
-  opt->rep.move_files = move_files;
-}
-
-void rocksdb_ingestexternalfileoptions_set_snapshot_consistency(
-    rocksdb_ingestexternalfileoptions_t* opt,
-    unsigned char snapshot_consistency) {
-  opt->rep.snapshot_consistency = snapshot_consistency;
-}
-
-void rocksdb_ingestexternalfileoptions_set_allow_global_seqno(
-    rocksdb_ingestexternalfileoptions_t* opt,
-    unsigned char allow_global_seqno) {
-  opt->rep.allow_global_seqno = allow_global_seqno;
-}
-
-void rocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
-    rocksdb_ingestexternalfileoptions_t* opt,
-    unsigned char allow_blocking_flush) {
-  opt->rep.allow_blocking_flush = allow_blocking_flush;
-}
-
-void rocksdb_ingestexternalfileoptions_destroy(
-    rocksdb_ingestexternalfileoptions_t* opt) {
-  delete opt;
-}
-
-void rocksdb_ingest_external_file(
-    rocksdb_t* db, const char* const* file_list, const size_t list_len,
-    const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
-  std::vector<std::string> files(list_len);
-  for (size_t i = 0; i < list_len; ++i) {
-    files[i] = std::string(file_list[i]);
-  }
-  SaveError(errptr, db->rep->IngestExternalFile(files, opt->rep));
-}
-
-void rocksdb_ingest_external_file_cf(
-    rocksdb_t* db, rocksdb_column_family_handle_t* handle,
-    const char* const* file_list, const size_t list_len,
-    const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
-  std::vector<std::string> files(list_len);
-  for (size_t i = 0; i < list_len; ++i) {
-    files[i] = std::string(file_list[i]);
-  }
-  SaveError(errptr, db->rep->IngestExternalFile(handle->rep, files, opt->rep));
-}
-
 rocksdb_slicetransform_t* rocksdb_slicetransform_create(
     void* state,
     void (*destructor)(void*),

db/c_test.c

@@ -2,18 +2,17 @@
    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 <stdio.h>
-
 #ifndef ROCKSDB_LITE  // Lite does not support C API
 
 #include "rocksdb/c.h"
 
 #include <stddef.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #ifndef OS_WIN
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 #include <inttypes.h>
 
@@ -22,10 +21,11 @@
 
 #include <Windows.h>
 
-#define snprintf _snprintf
+# define snprintf _snprintf
 
 // Ok for uniqueness
 int geteuid() {
+
   int result = 0;
 
   result = ((int)GetCurrentProcessId() << 16);
@@ -38,13 +38,13 @@ int geteuid() {
 
 const char* phase = "";
 static char dbname[200];
-static char sstfilename[200];
 static char dbbackupname[200];
 
 static void StartPhase(const char* name) {
   fprintf(stderr, "=== Test %s\n", name);
   phase = name;
 }
+
 static const char* GetTempDir(void) {
     const char* ret = getenv("TEST_TMPDIR");
     if (ret == NULL || ret[0] == '\0')
@@ -288,11 +288,9 @@ 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;
-  rocksdb_ratelimiter_t* rate_limiter;
   char* err = NULL;
   int run = -1;
 
@@ -306,11 +304,6 @@ int main(int argc, char** argv) {
            GetTempDir(),
            ((int) geteuid()));
 
-  snprintf(sstfilename, sizeof(sstfilename),
-           "%s/rocksdb_c_test-%d-sst",
-           GetTempDir(),
-           ((int)geteuid()));
-
   StartPhase("create_objects");
   cmp = rocksdb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
   env = rocksdb_create_default_env();
@@ -324,7 +317,6 @@ int main(int argc, char** argv) {
   rocksdb_options_set_write_buffer_size(options, 100000);
   rocksdb_options_set_paranoid_checks(options, 1);
   rocksdb_options_set_max_open_files(options, 10);
-  rocksdb_options_set_base_background_compactions(options, 1);
   table_options = rocksdb_block_based_options_create();
   rocksdb_block_based_options_set_block_cache(table_options, cache);
   rocksdb_options_set_block_based_table_factory(options, table_options);
@@ -334,20 +326,14 @@ int main(int argc, char** argv) {
   int compression_levels[] = {rocksdb_no_compression, rocksdb_no_compression,
                               rocksdb_no_compression, rocksdb_no_compression};
   rocksdb_options_set_compression_per_level(options, compression_levels, 4);
-  rate_limiter = rocksdb_ratelimiter_create(1000 * 1024 * 1024, 100 * 1000, 10);
-  rocksdb_options_set_ratelimiter(options, rate_limiter);
-  rocksdb_ratelimiter_destroy(rate_limiter);
 
   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 +415,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 +431,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);
   }
 
@@ -608,10 +487,6 @@ int main(int argc, char** argv) {
     CheckIter(iter, "foo", "hello");
     rocksdb_iter_seek(iter, "b", 1);
     CheckIter(iter, "box", "c");
-    rocksdb_iter_seek_for_prev(iter, "g", 1);
-    CheckIter(iter, "foo", "hello");
-    rocksdb_iter_seek_for_prev(iter, "box", 3);
-    CheckIter(iter, "box", "c");
     rocksdb_iter_get_error(iter, &err);
     CheckNoError(err);
     rocksdb_iter_destroy(iter);
@@ -823,7 +698,7 @@ 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_set_create_if_missing(db_options, 1);
@@ -954,7 +829,6 @@ int main(int argc, char** argv) {
     rocksdb_options_set_prefix_extractor(options, rocksdb_slicetransform_create_fixed_prefix(3));
     rocksdb_options_set_hash_skip_list_rep(options, 5000, 4, 4);
     rocksdb_options_set_plain_table_factory(options, 4, 10, 0.75, 16);
-    rocksdb_options_set_allow_concurrent_memtable_write(options, 0);
 
     db = rocksdb_open(options, dbname, &err);
     CheckNoError(err);
@@ -989,19 +863,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);
   }
@@ -1111,7 +972,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);
@@ -1121,6 +981,7 @@ int main(int argc, char** argv) {
 }
 
 #else
+#include <stdio.h>
 
 int main() {
   fprintf(stderr, "SKIPPED\n");

db/column_family.cc

@@ -27,7 +27,6 @@
 #include "db/version_set.h"
 #include "db/write_controller.h"
 #include "memtable/hash_skiplist_rep.h"
-#include "table/block_based_table_factory.h"
 #include "util/autovector.h"
 #include "util/compression.h"
 #include "util/options_helper.h"
@@ -140,8 +139,10 @@ Status CheckConcurrentWritesSupported(const ColumnFamilyOptions& cf_options) {
 }
 
 ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
+                                    const InternalKeyComparator* icmp,
                                     const ColumnFamilyOptions& src) {
   ColumnFamilyOptions result = src;
+  result.comparator = icmp;
   size_t clamp_max = std::conditional<
       sizeof(size_t) == 4, std::integral_constant<size_t, 0xffffffff>,
       std::integral_constant<uint64_t, 64ull << 30>>::type::value;
@@ -352,11 +353,10 @@ ColumnFamilyData::ColumnFamilyData(
       refs_(0),
       dropped_(false),
       internal_comparator_(cf_options.comparator),
-      initial_cf_options_(SanitizeOptions(db_options, cf_options)),
+      initial_cf_options_(
+          SanitizeOptions(db_options, &internal_comparator_, cf_options)),
       ioptions_(db_options, initial_cf_options_),
       mutable_cf_options_(initial_cf_options_),
-      is_delete_range_supported_(strcmp(cf_options.table_factory->Name(),
-                                        BlockBasedTableFactory().Name()) == 0),
       write_buffer_manager_(write_buffer_manager),
       mem_(nullptr),
       imm_(ioptions_.min_write_buffer_number_to_merge,
@@ -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,39 +492,15 @@ 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;
-const double kDelayRecoverSlowdownRatio = 1.4;
+const double kSlowdownRatio = 1.2;
 
 namespace {
-// If penalize_stop is true, we further reduce slowdown rate.
 std::unique_ptr<WriteControllerToken> SetupDelay(
-    WriteController* write_controller, uint64_t compaction_needed_bytes,
-    uint64_t prev_compaction_need_bytes, bool penalize_stop,
+    uint64_t max_write_rate, WriteController* write_controller,
+    uint64_t compaction_needed_bytes, uint64_t prev_compaction_neeed_bytes,
     bool auto_comapctions_disabled) {
-  const uint64_t kMinWriteRate = 16 * 1024u;  // Minimum write rate 16KB/s.
+  const uint64_t kMinWriteRate = 1024u;  // Minimum write rate 1KB/s.
 
-  uint64_t max_write_rate = write_controller->max_delayed_write_rate();
   uint64_t write_rate = write_controller->delayed_write_rate();
 
   if (auto_comapctions_disabled) {
@@ -548,32 +523,19 @@ std::unique_ptr<WriteControllerToken> SetupDelay(
     // insert to mem tables, so we need to actively slow down before we get
     // feedback signal from compaction and flushes to avoid the full stop
     // because of hitting the max write buffer number.
-    //
-    // If DB just falled into the stop condition, we need to further reduce
-    // the write rate to avoid the stop condition.
-    if (penalize_stop) {
-      // Penalize the near stop or stop condition by more agressive slowdown.
-      // This is to provide the long term slowdown increase signal.
-      // The penalty is more than the reward of recovering to the normal
-      // condition.
-      write_rate = static_cast<uint64_t>(static_cast<double>(write_rate) *
-                                         kNearStopSlowdownRatio);
+    if (prev_compaction_neeed_bytes > 0 &&
+        prev_compaction_neeed_bytes <= compaction_needed_bytes) {
+      write_rate = static_cast<uint64_t>(static_cast<double>(write_rate) /
+                                         kSlowdownRatio);
       if (write_rate < kMinWriteRate) {
         write_rate = kMinWriteRate;
       }
-    } else if (prev_compaction_need_bytes > 0 &&
-               prev_compaction_need_bytes <= compaction_needed_bytes) {
-      write_rate = static_cast<uint64_t>(static_cast<double>(write_rate) *
-                                         kIncSlowdownRatio);
-      if (write_rate < kMinWriteRate) {
-        write_rate = kMinWriteRate;
-      }
-    } else if (prev_compaction_need_bytes > compaction_needed_bytes) {
+    } else if (prev_compaction_neeed_bytes > compaction_needed_bytes) {
       // We are speeding up by ratio of kSlowdownRatio when we have paid
       // compaction debt. But we'll never speed up to faster than the write rate
       // given by users.
       write_rate = static_cast<uint64_t>(static_cast<double>(write_rate) *
-                                         kDecSlowdownRatio);
+                                         kSlowdownRatio);
       if (write_rate > max_write_rate) {
         write_rate = max_write_rate;
       }
@@ -623,9 +585,6 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
     uint64_t compaction_needed_bytes =
         vstorage->estimated_compaction_needed_bytes();
 
-    bool was_stopped = write_controller->IsStopped();
-    bool needed_delay = write_controller->NeedsDelay();
-
     if (imm()->NumNotFlushed() >= mutable_cf_options.max_write_buffer_number) {
       write_controller_token_ = write_controller->GetStopToken();
       internal_stats_->AddCFStats(InternalStats::MEMTABLE_COMPACTION, 1);
@@ -661,8 +620,8 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
                imm()->NumNotFlushed() >=
                    mutable_cf_options.max_write_buffer_number - 1) {
       write_controller_token_ =
-          SetupDelay(write_controller, compaction_needed_bytes,
-                     prev_compaction_needed_bytes_, was_stopped,
+          SetupDelay(ioptions_.delayed_write_rate, write_controller,
+                     compaction_needed_bytes, prev_compaction_needed_bytes_,
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(InternalStats::MEMTABLE_SLOWDOWN, 1);
       Log(InfoLogLevel::WARN_LEVEL, ioptions_.info_log,
@@ -676,12 +635,9 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
                mutable_cf_options.level0_slowdown_writes_trigger >= 0 &&
                vstorage->l0_delay_trigger_count() >=
                    mutable_cf_options.level0_slowdown_writes_trigger) {
-      // L0 is the last two files from stopping.
-      bool near_stop = vstorage->l0_delay_trigger_count() >=
-                       mutable_cf_options.level0_stop_writes_trigger - 2;
       write_controller_token_ =
-          SetupDelay(write_controller, compaction_needed_bytes,
-                     prev_compaction_needed_bytes_, was_stopped || near_stop,
+          SetupDelay(ioptions_.delayed_write_rate, write_controller,
+                     compaction_needed_bytes, prev_compaction_needed_bytes_,
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(InternalStats::LEVEL0_SLOWDOWN_TOTAL, 1);
       if (compaction_picker_->IsLevel0CompactionInProgress()) {
@@ -697,20 +653,9 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
                mutable_cf_options.soft_pending_compaction_bytes_limit > 0 &&
                vstorage->estimated_compaction_needed_bytes() >=
                    mutable_cf_options.soft_pending_compaction_bytes_limit) {
-      // If the distance to hard limit is less than 1/4 of the gap between soft
-      // and
-      // hard bytes limit, we think it is near stop and speed up the slowdown.
-      bool near_stop =
-          mutable_cf_options.hard_pending_compaction_bytes_limit > 0 &&
-          (compaction_needed_bytes -
-           mutable_cf_options.soft_pending_compaction_bytes_limit) >
-              3 * (mutable_cf_options.hard_pending_compaction_bytes_limit -
-                   mutable_cf_options.soft_pending_compaction_bytes_limit) /
-                  4;
-
       write_controller_token_ =
-          SetupDelay(write_controller, compaction_needed_bytes,
-                     prev_compaction_needed_bytes_, was_stopped || near_stop,
+          SetupDelay(ioptions_.delayed_write_rate, write_controller,
+                     compaction_needed_bytes, prev_compaction_needed_bytes_,
                      mutable_cf_options.disable_auto_compactions);
       internal_stats_->AddCFStats(
           InternalStats::SOFT_PENDING_COMPACTION_BYTES_LIMIT, 1);
@@ -719,43 +664,31 @@ void ColumnFamilyData::RecalculateWriteStallConditions(
           "bytes %" PRIu64 " rate %" PRIu64,
           name_.c_str(), vstorage->estimated_compaction_needed_bytes(),
           write_controller->delayed_write_rate());
-    } else {
-      if (vstorage->l0_delay_trigger_count() >=
-          GetL0ThresholdSpeedupCompaction(
-              mutable_cf_options.level0_file_num_compaction_trigger,
-              mutable_cf_options.level0_slowdown_writes_trigger)) {
-        write_controller_token_ =
-            write_controller->GetCompactionPressureToken();
+    } else if (vstorage->l0_delay_trigger_count() >=
+               GetL0ThresholdSpeedupCompaction(
+                   mutable_cf_options.level0_file_num_compaction_trigger,
+                   mutable_cf_options.level0_slowdown_writes_trigger)) {
+      write_controller_token_ = write_controller->GetCompactionPressureToken();
+      Log(InfoLogLevel::WARN_LEVEL, ioptions_.info_log,
+          "[%s] Increasing compaction threads because we have %d level-0 "
+          "files ",
+          name_.c_str(), vstorage->l0_delay_trigger_count());
+    } else if (vstorage->estimated_compaction_needed_bytes() >=
+               mutable_cf_options.soft_pending_compaction_bytes_limit / 4) {
+      // Increase compaction threads if bytes needed for compaction exceeds
+      // 1/4 of threshold for slowing down.
+      // If soft pending compaction byte limit is not set, always speed up
+      // compaction.
+      write_controller_token_ = write_controller->GetCompactionPressureToken();
+      if (mutable_cf_options.soft_pending_compaction_bytes_limit > 0) {
         Log(InfoLogLevel::WARN_LEVEL, ioptions_.info_log,
-            "[%s] Increasing compaction threads because we have %d level-0 "
-            "files ",
-            name_.c_str(), vstorage->l0_delay_trigger_count());
-      } else if (vstorage->estimated_compaction_needed_bytes() >=
-                 mutable_cf_options.soft_pending_compaction_bytes_limit / 4) {
-        // Increase compaction threads if bytes needed for compaction exceeds
-        // 1/4 of threshold for slowing down.
-        // If soft pending compaction byte limit is not set, always speed up
-        // compaction.
-        write_controller_token_ =
-            write_controller->GetCompactionPressureToken();
-        if (mutable_cf_options.soft_pending_compaction_bytes_limit > 0) {
-          Log(InfoLogLevel::WARN_LEVEL, ioptions_.info_log,
-              "[%s] Increasing compaction threads because of estimated pending "
-              "compaction "
-              "bytes %" PRIu64,
-              name_.c_str(), vstorage->estimated_compaction_needed_bytes());
-        }
-      } else {
-        write_controller_token_.reset();
-      }
-      // If the DB recovers from delay conditions, we reward with reducing
-      // double the slowdown ratio. This is to balance the long term slowdown
-      // increase signal.
-      if (needed_delay) {
-        uint64_t write_rate = write_controller->delayed_write_rate();
-        write_controller->set_delayed_write_rate(static_cast<uint64_t>(
-            static_cast<double>(write_rate) * kDelayRecoverSlowdownRatio));
+            "[%s] Increasing compaction threads because of estimated pending "
+            "compaction "
+            "bytes %" PRIu64,
+            name_.c_str(), vstorage->estimated_compaction_needed_bytes());
       }
+    } else {
+      write_controller_token_.reset();
     }
     prev_compaction_needed_bytes_ = compaction_needed_bytes;
   }

db/column_family.h

@@ -42,7 +42,7 @@ class LogBuffer;
 class InstrumentedMutex;
 class InstrumentedMutexLock;
 
-extern const double kIncSlowdownRatio;
+extern const double kSlowdownRatio;
 
 // ColumnFamilyHandleImpl is the class that clients use to access different
 // column families. It has non-trivial destructor, which gets called when client
@@ -137,6 +137,7 @@ extern Status CheckConcurrentWritesSupported(
     const ColumnFamilyOptions& cf_options);
 
 extern ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
+                                           const InternalKeyComparator* icmp,
                                            const ColumnFamilyOptions& src);
 // Wrap user defined table proproties collector factories `from cf_options`
 // into internal ones in int_tbl_prop_collector_factories. Add a system internal
@@ -220,8 +221,6 @@ class ColumnFamilyData {
   // options.
   ColumnFamilyOptions GetLatestCFOptions() const;
 
-  bool is_delete_range_supported() { return is_delete_range_supported_; }
-
 #ifndef ROCKSDB_LITE
   // REQUIRES: DB mutex held
   Status SetOptions(
@@ -239,9 +238,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);
@@ -359,8 +355,6 @@ class ColumnFamilyData {
   const ImmutableCFOptions ioptions_;
   MutableCFOptions mutable_cf_options_;
 
-  const bool is_delete_range_supported_;
-
   std::unique_ptr<TableCache> table_cache_;
 
   std::unique_ptr<InternalStats> internal_stats_;
@@ -407,9 +401,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

db/column_family_test.cc

@@ -1056,7 +1056,6 @@ TEST_F(ColumnFamilyTest, DifferentWriteBufferSizes) {
 
 #ifndef ROCKSDB_LITE  // Cuckoo is not supported in lite
 TEST_F(ColumnFamilyTest, MemtableNotSupportSnapshot) {
-  db_options_.allow_concurrent_memtable_write = false;
   Open();
   auto* s1 = dbfull()->GetSnapshot();
   ASSERT_TRUE(s1 != nullptr);
@@ -2189,8 +2188,8 @@ TEST_F(ColumnFamilyTest, SanitizeOptions) {
             original.write_buffer_size =
                 l * 4 * 1024 * 1024 + i * 1024 * 1024 + j * 1024 + k;
 
-            ColumnFamilyOptions result =
-                SanitizeOptions(ImmutableDBOptions(db_options), original);
+            ColumnFamilyOptions result = SanitizeOptions(
+                ImmutableDBOptions(db_options), nullptr, original);
             ASSERT_TRUE(result.level0_stop_writes_trigger >=
                         result.level0_slowdown_writes_trigger);
             ASSERT_TRUE(result.level0_slowdown_writes_trigger >=
@@ -2440,7 +2439,7 @@ TEST_F(ColumnFamilyTest, CreateAndDropRace) {
 #endif  // !ROCKSDB_LITE
 
 TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
-  const uint64_t kBaseRate = 800000u;
+  const uint64_t kBaseRate = 810000u;
   db_options_.delayed_write_rate = kBaseRate;
   db_options_.base_background_compactions = 2;
   db_options_.max_background_compactions = 6;
@@ -2475,7 +2474,7 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
   ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed());
 
@@ -2483,14 +2482,14 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(450);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(205);
@@ -2526,7 +2525,7 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(2001);
@@ -2544,7 +2543,7 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(100);
@@ -2556,14 +2555,15 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate, dbfull()->TEST_write_controler().delayed_write_rate());
+  ASSERT_EQ(kBaseRate / 1.2,
+            dbfull()->TEST_write_controler().delayed_write_rate());
   ASSERT_EQ(6, dbfull()->TEST_BGCompactionsAllowed());
 
   vstorage->set_l0_delay_trigger_count(101);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->set_l0_delay_trigger_count(0);
@@ -2571,21 +2571,21 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->set_l0_delay_trigger_count(101);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2 / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(200);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->set_l0_delay_trigger_count(0);
@@ -2626,7 +2626,7 @@ TEST_F(ColumnFamilyTest, WriteStallSingleColumnFamily) {
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 }
 
@@ -2743,35 +2743,35 @@ TEST_F(ColumnFamilyTest, WriteStallTwoColumnFamilies) {
   cfd1->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(300);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage1->TEST_set_estimated_compaction_needed_bytes(700);
   cfd1->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage->TEST_set_estimated_compaction_needed_bytes(500);
   cfd->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25 / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2 / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 
   vstorage1->TEST_set_estimated_compaction_needed_bytes(600);
   cfd1->RecalculateWriteStallConditions(mutable_cf_options);
   ASSERT_TRUE(!dbfull()->TEST_write_controler().IsStopped());
   ASSERT_TRUE(dbfull()->TEST_write_controler().NeedsDelay());
-  ASSERT_EQ(kBaseRate / 1.25,
+  ASSERT_EQ(kBaseRate / 1.2,
             dbfull()->TEST_write_controler().delayed_write_rate());
 }
 

db/compact_files_test.cc

@@ -253,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) {

db/compacted_db_impl.cc

@@ -46,7 +46,7 @@ Status CompactedDBImpl::Get(const ReadOptions& options,
      ColumnFamilyHandle*, const Slice& key, std::string* value) {
   GetContext get_context(user_comparator_, nullptr, nullptr, nullptr,
                          GetContext::kNotFound, key, value, nullptr, nullptr,
-                         nullptr, nullptr);
+                         nullptr);
   LookupKey lkey(key, kMaxSequenceNumber);
   files_.files[FindFile(key)].fd.table_reader->Get(
       options, lkey.internal_key(), &get_context);
@@ -77,7 +77,7 @@ std::vector<Status> CompactedDBImpl::MultiGet(const ReadOptions& options,
     if (r != nullptr) {
       GetContext get_context(user_comparator_, nullptr, nullptr, nullptr,
                              GetContext::kNotFound, keys[idx], &(*values)[idx],
-                             nullptr, nullptr, nullptr, nullptr);
+                             nullptr, nullptr, nullptr);
       LookupKey lkey(keys[idx], kMaxSequenceNumber);
       r->Get(options, lkey.internal_key(), &get_context);
       if (get_context.State() == GetContext::kFound) {

db/compaction.cc

@@ -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 {

db/compaction.h

@@ -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_;

db/compaction_iteration_stats.h

@@ -1,33 +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.
-
-#pragma once
-
-struct CompactionIterationStats {
-  // Compaction statistics
-
-  // Doesn't include records skipped because of
-  // CompactionFilter::Decision::kRemoveAndSkipUntil.
-  int64_t num_record_drop_user = 0;
-
-  int64_t num_record_drop_hidden = 0;
-  int64_t num_record_drop_obsolete = 0;
-  int64_t num_record_drop_range_del = 0;
-  int64_t num_range_del_drop_obsolete = 0;
-  uint64_t total_filter_time = 0;
-
-  // Input statistics
-  // TODO(noetzli): The stats are incomplete. They are lacking everything
-  // consumed by MergeHelper.
-  uint64_t num_input_records = 0;
-  uint64_t num_input_deletion_records = 0;
-  uint64_t num_input_corrupt_records = 0;
-  uint64_t total_input_raw_key_bytes = 0;
-  uint64_t total_input_raw_value_bytes = 0;
-
-  // Single-Delete diagnostics for exceptional situations
-  uint64_t num_single_del_fallthru = 0;
-  uint64_t num_single_del_mismatch = 0;
-};

db/compaction_iterator.cc

@@ -16,23 +16,7 @@ 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)
-    : 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) {}
-
-CompactionIterator::CompactionIterator(
-    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-    SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-    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)
+    LogBuffer* log_buffer)
     : input_(input),
       cmp_(cmp),
       merge_helper_(merge_helper),
@@ -41,9 +25,9 @@ CompactionIterator::CompactionIterator(
       env_(env),
       expect_valid_internal_key_(expect_valid_internal_key),
       range_del_agg_(range_del_agg),
-      compaction_(std::move(compaction)),
+      compaction_(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_ =
@@ -79,8 +63,6 @@ void CompactionIterator::ResetRecordCounts() {
   iter_stats_.num_record_drop_user = 0;
   iter_stats_.num_record_drop_hidden = 0;
   iter_stats_.num_record_drop_obsolete = 0;
-  iter_stats_.num_record_drop_range_del = 0;
-  iter_stats_.num_range_del_drop_obsolete = 0;
 }
 
 void CompactionIterator::SeekToFirst() {
@@ -126,7 +108,7 @@ void CompactionIterator::Next() {
   }
 
   if (valid_) {
-    // Record that we've outputted a record for the current key.
+    // Record that we've ouputted a record for the current key.
     has_outputted_key_ = true;
   }
 
@@ -137,7 +119,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++;
@@ -167,13 +149,6 @@ void CompactionIterator::NextFromInput() {
     iter_stats_.total_input_raw_key_bytes += key_.size();
     iter_stats_.total_input_raw_value_bytes += value_.size();
 
-    // If need_skip is true, we should seek the input iterator
-    // to internal key skip_until and continue from there.
-    bool need_skip = false;
-    // Points either into compaction_filter_skip_until_ or into
-    // merge_helper_->compaction_filter_skip_until_.
-    Slice skip_until;
-
     // Check whether the user key changed. After this if statement current_key_
     // is a copy of the current input key (maybe converted to a delete by the
     // compaction filter). ikey_.user_key is pointing to the copy.
@@ -196,42 +171,26 @@ void CompactionIterator::NextFromInput() {
         // number is greater than any external snapshot, then invoke the
         // filter. If the return value of the compaction filter is true,
         // replace the entry with a deletion marker.
-        CompactionFilter::Decision filter;
+        bool value_changed = false;
+        bool to_delete = false;
         compaction_filter_value_.clear();
-        compaction_filter_skip_until_.Clear();
         {
           StopWatchNano timer(env_, true);
-          filter = compaction_filter_->FilterV2(
-              compaction_->level(), ikey_.user_key,
-              CompactionFilter::ValueType::kValue, value_,
-              &compaction_filter_value_, compaction_filter_skip_until_.rep());
+          to_delete = compaction_filter_->Filter(
+              compaction_->level(), ikey_.user_key, value_,
+              &compaction_filter_value_, &value_changed);
           iter_stats_.total_filter_time +=
               env_ != nullptr ? timer.ElapsedNanos() : 0;
         }
-
-        if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil &&
-            cmp_->Compare(*compaction_filter_skip_until_.rep(),
-                          ikey_.user_key) <= 0) {
-          // Can't skip to a key smaller than the current one.
-          // Keep the key as per FilterV2 documentation.
-          filter = CompactionFilter::Decision::kKeep;
-        }
-
-        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()
+        if (to_delete) {
+          // convert the current key to a delete
           ikey_.type = kTypeDeletion;
           current_key_.UpdateInternalKey(ikey_.sequence, kTypeDeletion);
           // no value associated with delete
           value_.clear();
           iter_stats_.num_record_drop_user++;
-        } else if (filter == CompactionFilter::Decision::kChangeValue) {
+        } else if (value_changed) {
           value_ = compaction_filter_value_;
-        } else if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil) {
-          need_skip = true;
-          compaction_filter_skip_until_.ConvertFromUserKey(kMaxSequenceNumber,
-                                                           kValueTypeForSeek);
-          skip_until = compaction_filter_skip_until_.Encode();
         }
       }
     } else {
@@ -258,9 +217,7 @@ void CompactionIterator::NextFromInput() {
             ? earliest_snapshot_
             : findEarliestVisibleSnapshot(ikey_.sequence, &prev_snapshot);
 
-    if (need_skip) {
-      // This case is handled below.
-    } else if (clear_and_output_next_key_) {
+    if (clear_and_output_next_key_) {
       // In the previous iteration we encountered a single delete that we could
       // not compact out.  We will keep this Put, but can drop it's data.
       // (See Optimization 3, below.)
@@ -351,6 +308,7 @@ void CompactionIterator::NextFromInput() {
             // to know that a write happened in this snapshot (Rule 2 above).
             // Clear the value and output the SingleDelete. (The value will be
             // outputted on the next iteration.)
+            ++iter_stats_.num_record_drop_hidden;
 
             // Setting valid_ to true will output the current SingleDelete
             valid_ = true;
@@ -424,6 +382,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 +393,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();
@@ -462,32 +418,18 @@ void CompactionIterator::NextFromInput() {
         // coming after the merges
         has_current_user_key_ = false;
         pinned_iters_mgr_.ReleasePinnedData();
-
-        if (merge_helper_->FilteredUntil(&skip_until)) {
-          need_skip = true;
-        }
       }
     } 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_, true /* for_compaction */);
       if (should_delete) {
-        ++iter_stats_.num_record_drop_hidden;
-        ++iter_stats_.num_record_drop_range_del;
         input_->Next();
       } else {
         valid_ = true;
       }
     }
-
-    if (need_skip) {
-      input_->Seek(skip_until);
-    }
-  }
-
-  if (!valid_ && IsShuttingDown()) {
-    status_ = Status::ShutdownInProgress();
   }
 }
 

db/compaction_iterator.h

@@ -12,46 +12,37 @@
 #include <vector>
 
 #include "db/compaction.h"
-#include "db/compaction_iteration_stats.h"
 #include "db/merge_helper.h"
 #include "db/pinned_iterators_manager.h"
 #include "db/range_del_aggregator.h"
 #include "rocksdb/compaction_filter.h"
+#include "util/log_buffer.h"
 
 namespace rocksdb {
 
+struct CompactionIteratorStats {
+  // Compaction statistics
+  int64_t num_record_drop_user = 0;
+  int64_t num_record_drop_hidden = 0;
+  int64_t num_record_drop_obsolete = 0;
+  uint64_t total_filter_time = 0;
+
+  // Input statistics
+  // TODO(noetzli): The stats are incomplete. They are lacking everything
+  // consumed by MergeHelper.
+  uint64_t num_input_records = 0;
+  uint64_t num_input_deletion_records = 0;
+  uint64_t num_input_corrupt_records = 0;
+  uint64_t total_input_raw_key_bytes = 0;
+  uint64_t total_input_raw_value_bytes = 0;
+
+  // Single-Delete diagnostics for exceptional situations
+  uint64_t num_single_del_fallthru = 0;
+  uint64_t num_single_del_mismatch = 0;
+};
+
 class CompactionIterator {
  public:
-  // A wrapper around Compaction. Has a much smaller interface, only what
-  // CompactionIterator uses. Tests can override it.
-  class CompactionProxy {
-   public:
-    explicit CompactionProxy(const Compaction* compaction)
-        : compaction_(compaction) {}
-
-    virtual ~CompactionProxy() = default;
-    virtual int level(size_t compaction_input_level = 0) const {
-      return compaction_->level();
-    }
-    virtual bool KeyNotExistsBeyondOutputLevel(
-        const Slice& user_key, std::vector<size_t>* level_ptrs) const {
-      return compaction_->KeyNotExistsBeyondOutputLevel(user_key, level_ptrs);
-    }
-    virtual bool bottommost_level() const {
-      return compaction_->bottommost_level();
-    }
-    virtual int number_levels() const { return compaction_->number_levels(); }
-    virtual Slice GetLargestUserKey() const {
-      return compaction_->GetLargestUserKey();
-    }
-
-   protected:
-    CompactionProxy() = default;
-
-   private:
-    const Compaction* compaction_;
-  };
-
   CompactionIterator(InternalIterator* input, const Comparator* cmp,
                      MergeHelper* merge_helper, SequenceNumber last_sequence,
                      std::vector<SequenceNumber>* snapshots,
@@ -60,18 +51,7 @@ class CompactionIterator {
                      RangeDelAggregator* range_del_agg,
                      const Compaction* compaction = nullptr,
                      const CompactionFilter* compaction_filter = nullptr,
-                     const std::atomic<bool>* shutting_down = nullptr);
-
-  // Constructor with custom CompactionProxy, used for tests.
-  CompactionIterator(InternalIterator* input, const Comparator* cmp,
-                     MergeHelper* merge_helper, SequenceNumber last_sequence,
-                     std::vector<SequenceNumber>* snapshots,
-                     SequenceNumber earliest_write_conflict_snapshot, Env* env,
-                     bool expect_valid_internal_key,
-                     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();
 
@@ -94,7 +74,7 @@ class CompactionIterator {
   const ParsedInternalKey& ikey() const { return ikey_; }
   bool Valid() const { return valid_; }
   const Slice& user_key() const { return current_user_key_; }
-  const CompactionIterationStats& iter_stats() const { return iter_stats_; }
+  const CompactionIteratorStats& iter_stats() const { return iter_stats_; }
 
  private:
   // Processes the input stream to find the next output
@@ -122,9 +102,9 @@ class CompactionIterator {
   Env* env_;
   bool expect_valid_internal_key_;
   RangeDelAggregator* range_del_agg_;
-  std::unique_ptr<CompactionProxy> compaction_;
+  const Compaction* compaction_;
   const CompactionFilter* compaction_filter_;
-  const std::atomic<bool>* shutting_down_;
+  LogBuffer* log_buffer_;
   bool bottommost_level_;
   bool valid_ = false;
   bool visible_at_tip_;
@@ -170,7 +150,6 @@ class CompactionIterator {
   // merge operands and then releasing them after consuming them.
   PinnedIteratorsManager pinned_iters_mgr_;
   std::string compaction_filter_value_;
-  InternalKey compaction_filter_skip_until_;
   // "level_ptrs" holds indices that remember which file of an associated
   // level we were last checking during the last call to compaction->
   // KeyNotExistsBeyondOutputLevel(). This allows future calls to the function
@@ -178,11 +157,6 @@ class CompactionIterator {
   // increasing so a later call to the function must be looking for a key that
   // 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);
-  }
+  CompactionIteratorStats iter_stats_;
 };
 }  // namespace rocksdb

db/compaction_iterator_test.cc

@@ -13,150 +13,6 @@
 
 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 {
-    enum class Type {
-      SEEK_TO_FIRST,
-      SEEK,
-      NEXT,
-    };
-
-    Type type;
-    std::string arg;
-
-    explicit Action(Type _type, std::string _arg = "")
-        : type(_type), arg(_arg) {}
-
-    bool operator==(const Action& rhs) const {
-      return std::tie(type, arg) == std::tie(rhs.type, rhs.arg);
-    }
-  };
-
-  LoggingForwardVectorIterator(const std::vector<std::string>& keys,
-                               const std::vector<std::string>& values)
-      : keys_(keys), values_(values), current_(keys.size()) {
-    assert(keys_.size() == values_.size());
-  }
-
-  virtual bool Valid() const override { return current_ < keys_.size(); }
-
-  virtual void SeekToFirst() override {
-    log.emplace_back(Action::Type::SEEK_TO_FIRST);
-    current_ = 0;
-  }
-  virtual void SeekToLast() override { assert(false); }
-
-  virtual void Seek(const Slice& target) override {
-    log.emplace_back(Action::Type::SEEK, target.ToString());
-    current_ = std::lower_bound(keys_.begin(), keys_.end(), target.ToString()) -
-               keys_.begin();
-  }
-
-  virtual void SeekForPrev(const Slice& target) override { assert(false); }
-
-  virtual void Next() override {
-    assert(Valid());
-    log.emplace_back(Action::Type::NEXT);
-    current_++;
-  }
-  virtual void Prev() override { assert(false); }
-
-  virtual Slice key() const override {
-    assert(Valid());
-    return Slice(keys_[current_]);
-  }
-  virtual Slice value() const override {
-    assert(Valid());
-    return Slice(values_[current_]);
-  }
-
-  virtual Status status() const override { return Status::OK(); }
-
-  std::vector<Action> log;
-
- private:
-  std::vector<std::string> keys_;
-  std::vector<std::string> values_;
-  size_t current_;
-};
-
-class FakeCompaction : public CompactionIterator::CompactionProxy {
- public:
-  FakeCompaction() = default;
-
-  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;
-  }
-  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 {
  public:
   CompactionIteratorTest()
@@ -166,29 +22,19 @@ class CompactionIteratorTest : public testing::Test {
                      const std::vector<std::string>& vs,
                      const std::vector<std::string>& range_del_ks,
                      const std::vector<std::string>& range_del_vs,
-                     SequenceNumber last_sequence,
-                     MergeOperator* merge_op = nullptr,
-                     CompactionFilter* filter = nullptr) {
+                     SequenceNumber last_sequence) {
     std::unique_ptr<InternalIterator> range_del_iter(
         new test::VectorIterator(range_del_ks, range_del_vs));
     range_del_agg_.reset(new RangeDelAggregator(icmp_, snapshots_));
     ASSERT_OK(range_del_agg_->AddTombstones(std::move(range_del_iter)));
 
-    std::unique_ptr<CompactionIterator::CompactionProxy> compaction;
-    if (filter) {
-      compaction_proxy_ = new FakeCompaction();
-      compaction.reset(compaction_proxy_);
-    }
-
-    merge_helper_.reset(new MergeHelper(Env::Default(), cmp_, merge_op, filter,
-                                        nullptr, 0U, false, 0, 0, nullptr,
-                                        &shutting_down_));
-    iter_.reset(new LoggingForwardVectorIterator(ks, vs));
+    merge_helper_.reset(new MergeHelper(Env::Default(), cmp_, nullptr, nullptr,
+                                        nullptr, 0U, false, 0));
+    iter_.reset(new test::VectorIterator(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_));
+        kMaxSequenceNumber, Env::Default(), false, range_del_agg_.get()));
   }
 
   void AddSnapshot(SequenceNumber snapshot) { snapshots_.push_back(snapshot); }
@@ -197,11 +43,9 @@ class CompactionIteratorTest : public testing::Test {
   const InternalKeyComparator icmp_;
   std::vector<SequenceNumber> snapshots_;
   std::unique_ptr<MergeHelper> merge_helper_;
-  std::unique_ptr<LoggingForwardVectorIterator> iter_;
+  std::unique_ptr<test::VectorIterator> 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
@@ -272,187 +116,6 @@ TEST_F(CompactionIteratorTest, RangeDeletionWithSnapshots) {
   ASSERT_FALSE(c_iter_->Valid());
 }
 
-TEST_F(CompactionIteratorTest, CompactionFilterSkipUntil) {
-  class Filter : public CompactionFilter {
-    virtual Decision FilterV2(int level, const Slice& key, ValueType t,
-                              const Slice& existing_value,
-                              std::string* new_value,
-                              std::string* skip_until) const override {
-      std::string k = key.ToString();
-      std::string v = existing_value.ToString();
-      // See InitIterators() call below for the sequence of keys and their
-      // filtering decisions. Here we closely assert that compaction filter is
-      // called with the expected keys and only them, and with the right values.
-      if (k == "a") {
-        EXPECT_EQ(ValueType::kValue, t);
-        EXPECT_EQ("av50", v);
-        return Decision::kKeep;
-      }
-      if (k == "b") {
-        EXPECT_EQ(ValueType::kValue, t);
-        EXPECT_EQ("bv60", v);
-        *skip_until = "d+";
-        return Decision::kRemoveAndSkipUntil;
-      }
-      if (k == "e") {
-        EXPECT_EQ(ValueType::kMergeOperand, t);
-        EXPECT_EQ("em71", v);
-        return Decision::kKeep;
-      }
-      if (k == "f") {
-        if (v == "fm65") {
-          EXPECT_EQ(ValueType::kMergeOperand, t);
-          *skip_until = "f";
-        } else {
-          EXPECT_EQ("fm30", v);
-          EXPECT_EQ(ValueType::kMergeOperand, t);
-          *skip_until = "g+";
-        }
-        return Decision::kRemoveAndSkipUntil;
-      }
-      if (k == "h") {
-        EXPECT_EQ(ValueType::kValue, t);
-        EXPECT_EQ("hv91", v);
-        return Decision::kKeep;
-      }
-      if (k == "i") {
-        EXPECT_EQ(ValueType::kMergeOperand, t);
-        EXPECT_EQ("im95", v);
-        *skip_until = "z";
-        return Decision::kRemoveAndSkipUntil;
-      }
-      ADD_FAILURE();
-      return Decision::kKeep;
-    }
-
-    const char* Name() const override {
-      return "CompactionIteratorTest.CompactionFilterSkipUntil::Filter";
-    }
-  };
-
-  NoMergingMergeOp merge_op;
-  Filter filter;
-  InitIterators(
-      {test::KeyStr("a", 50, kTypeValue),  // keep
-       test::KeyStr("a", 45, kTypeMerge),
-       test::KeyStr("b", 60, kTypeValue),  // skip to "d+"
-       test::KeyStr("b", 40, kTypeValue), test::KeyStr("c", 35, kTypeValue),
-       test::KeyStr("d", 70, kTypeMerge),
-       test::KeyStr("e", 71, kTypeMerge),  // keep
-       test::KeyStr("f", 65, kTypeMerge),  // skip to "f", aka keep
-       test::KeyStr("f", 30, kTypeMerge),  // skip to "g+"
-       test::KeyStr("f", 25, kTypeValue), test::KeyStr("g", 90, kTypeValue),
-       test::KeyStr("h", 91, kTypeValue),  // keep
-       test::KeyStr("i", 95, kTypeMerge),  // skip to "z"
-       test::KeyStr("j", 99, kTypeValue)},
-      {"av50", "am45", "bv60", "bv40", "cv35", "dm70", "em71", "fm65", "fm30",
-       "fv25", "gv90", "hv91", "im95", "jv99"},
-      {}, {}, kMaxSequenceNumber, &merge_op, &filter);
-
-  // Compaction should output just "a", "e" and "h" keys.
-  c_iter_->SeekToFirst();
-  ASSERT_TRUE(c_iter_->Valid());
-  ASSERT_EQ(test::KeyStr("a", 50, kTypeValue), c_iter_->key().ToString());
-  ASSERT_EQ("av50", c_iter_->value().ToString());
-  c_iter_->Next();
-  ASSERT_TRUE(c_iter_->Valid());
-  ASSERT_EQ(test::KeyStr("e", 71, kTypeMerge), c_iter_->key().ToString());
-  ASSERT_EQ("em71", c_iter_->value().ToString());
-  c_iter_->Next();
-  ASSERT_TRUE(c_iter_->Valid());
-  ASSERT_EQ(test::KeyStr("h", 91, kTypeValue), c_iter_->key().ToString());
-  ASSERT_EQ("hv91", c_iter_->value().ToString());
-  c_iter_->Next();
-  ASSERT_FALSE(c_iter_->Valid());
-
-  // Check that the compaction iterator did the correct sequence of calls on
-  // the underlying iterator.
-  using A = LoggingForwardVectorIterator::Action;
-  using T = A::Type;
-  std::vector<A> expected_actions = {
-      A(T::SEEK_TO_FIRST),
-      A(T::NEXT),
-      A(T::NEXT),
-      A(T::SEEK, test::KeyStr("d+", kMaxSequenceNumber, kValueTypeForSeek)),
-      A(T::NEXT),
-      A(T::NEXT),
-      A(T::SEEK, test::KeyStr("g+", kMaxSequenceNumber, kValueTypeForSeek)),
-      A(T::NEXT),
-      A(T::SEEK, test::KeyStr("z", kMaxSequenceNumber, kValueTypeForSeek))};
-  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};
-  std::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};
-  std::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) {

db/compaction_job.cc

@@ -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,
@@ -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();
@@ -770,12 +771,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
                sub_compact->ShouldStopBefore(
                    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);
-      RecordDroppedKeys(range_del_out_stats,
-                        &sub_compact->compaction_job_stats);
+                                          range_del_agg.get());
       if (!status.ok()) {
         break;
       }
@@ -867,12 +864,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
       if (c_iter->Valid()) {
         next_key = &c_iter->key();
       }
-      CompactionIterationStats range_del_out_stats;
       status = FinishCompactionOutputFile(input_status, sub_compact,
-                                          range_del_agg.get(),
-                                          &range_del_out_stats, next_key);
-      RecordDroppedKeys(range_del_out_stats,
-                        &sub_compact->compaction_job_stats);
+                                          range_del_agg.get(), next_key);
       if (sub_compact->outputs.size() == 1) {
         // Use dictionary from first output file for compression of subsequent
         // files.
@@ -902,35 +895,21 @@ 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) {
-    CompactionIterationStats range_del_out_stats;
-    Status s = FinishCompactionOutputFile(
-        status, sub_compact, range_del_agg.get(), &range_del_out_stats);
-    if (status.ok()) {
-      status = s;
-    }
-    RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
+  if (status.ok() && sub_compact->builder != nullptr) {
+    status = FinishCompactionOutputFile(input->status(), sub_compact,
+                                        range_del_agg.get());
+  }
+  if (status.ok()) {
+    status = input->status();
   }
 
   if (measure_io_stats_) {
@@ -953,7 +932,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
 }
 
 void CompactionJob::RecordDroppedKeys(
-    const CompactionIterationStats& c_iter_stats,
+    const CompactionIteratorStats& c_iter_stats,
     CompactionJobStats* compaction_job_stats) {
   if (c_iter_stats.num_record_drop_user > 0) {
     RecordTick(stats_, COMPACTION_KEY_DROP_USER,
@@ -975,20 +954,11 @@ void CompactionJob::RecordDroppedKeys(
           c_iter_stats.num_record_drop_obsolete;
     }
   }
-  if (c_iter_stats.num_record_drop_range_del > 0) {
-    RecordTick(stats_, COMPACTION_KEY_DROP_RANGE_DEL,
-               c_iter_stats.num_record_drop_range_del);
-  }
-  if (c_iter_stats.num_range_del_drop_obsolete > 0) {
-    RecordTick(stats_, COMPACTION_RANGE_DEL_DROP_OBSOLETE,
-               c_iter_stats.num_range_del_drop_obsolete);
-  }
 }
 
 Status CompactionJob::FinishCompactionOutputFile(
     const Status& input_status, SubcompactionState* sub_compact,
     RangeDelAggregator* range_del_agg,
-    CompactionIterationStats* range_del_out_stats,
     const Slice* next_table_min_key /* = nullptr */) {
   AutoThreadOperationStageUpdater stage_updater(
       ThreadStatus::STAGE_COMPACTION_SYNC_FILE);
@@ -1005,34 +975,14 @@ Status CompactionJob::FinishCompactionOutputFile(
   Status s = input_status;
   auto meta = &sub_compact->current_output()->meta;
   if (s.ok()) {
-    Slice lower_bound_guard, upper_bound_guard;
-    const Slice *lower_bound, *upper_bound;
-    if (sub_compact->outputs.size() == 1) {
-      // For the first output table, include range tombstones before the min key
-      // but after the subcompaction boundary.
-      lower_bound = sub_compact->start;
-    } else if (meta->smallest.size() > 0) {
-      // For subsequent output tables, only include range tombstones from min
-      // key onwards since the previous file was extended to contain range
-      // tombstones falling before min key.
-      lower_bound_guard = meta->smallest.user_key();
-      lower_bound = &lower_bound_guard;
-    } else {
-      lower_bound = nullptr;
-    }
-    if (next_table_min_key != nullptr) {
-      // This isn't the last file in the subcompaction, so extend until the next
-      // file starts.
-      upper_bound_guard = ExtractUserKey(*next_table_min_key);
-      upper_bound = &upper_bound_guard;
-    } else {
-      // This is the last file in the subcompaction, so extend until the
-      // subcompaction ends.
-      upper_bound = sub_compact->end;
-    }
-    range_del_agg->AddToBuilder(sub_compact->builder.get(), lower_bound,
-                                upper_bound, meta, range_del_out_stats,
-                                bottommost_level_);
+    // For the first output table, include range tombstones before the min key
+    // boundary. For subsequent output tables, this is unnecessary because we
+    // extend each file's max key boundary up until the next file's min key when
+    // range tombstones fall in the gap.
+    range_del_agg->AddToBuilder(
+        sub_compact->builder.get(),
+        sub_compact->outputs.size() == 1 /* extend_before_min_key */,
+        next_table_min_key, meta, bottommost_level_);
   }
   const uint64_t current_entries = sub_compact->builder->NumEntries();
   meta->marked_for_compaction = sub_compact->builder->NeedCompact();
@@ -1062,9 +1012,8 @@ Status CompactionJob::FinishCompactionOutputFile(
     // Verify that the table is usable
     InternalIterator* iter = cfd->table_cache()->NewIterator(
         ReadOptions(), env_options_, cfd->internal_comparator(), meta->fd,
-        nullptr /* range_del_agg */, nullptr,
-        cfd->internal_stats()->GetFileReadHist(
-            compact_->compaction->output_level()),
+        nullptr, cfd->internal_stats()->GetFileReadHist(
+                     compact_->compaction->output_level()),
         false);
     s = iter->status();
 
@@ -1094,7 +1043,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 +1060,6 @@ Status CompactionJob::FinishCompactionOutputFile(
       }
     }
   }
-#endif
 
   sub_compact->builder.reset();
   sub_compact->current_output_file_size = 0;
@@ -1273,7 +1220,8 @@ void CompactionJob::UpdateCompactionStats() {
   for (int input_level = 0;
        input_level < static_cast<int>(compaction->num_input_levels());
        ++input_level) {
-    if (compaction->level(input_level) != compaction->output_level()) {
+    if (compaction->start_level() + input_level
+        != compaction->output_level()) {
       UpdateCompactionInputStatsHelper(
           &compaction_stats_.num_input_files_in_non_output_levels,
           &compaction_stats_.bytes_read_non_output_levels,

db/compaction_job.h

@@ -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,
@@ -96,18 +96,17 @@ class CompactionJob {
   // kv-pairs
   void ProcessKeyValueCompaction(SubcompactionState* sub_compact);
 
-  Status FinishCompactionOutputFile(
-      const Status& input_status, SubcompactionState* sub_compact,
-      RangeDelAggregator* range_del_agg,
-      CompactionIterationStats* range_del_out_stats,
-      const Slice* next_table_min_key = nullptr);
+  Status FinishCompactionOutputFile(const Status& input_status,
+                                    SubcompactionState* sub_compact,
+                                    RangeDelAggregator* range_del_agg = nullptr,
+                                    const Slice* next_table_min_key = nullptr);
   Status InstallCompactionResults(const MutableCFOptions& mutable_cf_options);
   void RecordCompactionIOStats();
   Status OpenCompactionOutputFile(SubcompactionState* sub_compact);
   void CleanupCompaction();
   void UpdateCompactionJobStats(
     const InternalStats::CompactionStats& stats) const;
-  void RecordDroppedKeys(const CompactionIterationStats& c_iter_stats,
+  void RecordDroppedKeys(const CompactionIteratorStats& c_iter_stats,
                          CompactionJobStats* compaction_job_stats = nullptr);
 
   void UpdateCompactionStats();
@@ -131,7 +130,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_;

db/compaction_picker.cc

@@ -451,14 +451,13 @@ bool CompactionPicker::SetupOtherInputs(
   vstorage->GetOverlappingInputs(output_level, &smallest, &largest,
                                  &output_level_inputs->files, *parent_index,
                                  parent_index);
+  if (!output_level_inputs->empty()) {
+    ExpandWhileOverlapping(cf_name, vstorage, output_level_inputs);
+  }
+
   if (FilesInCompaction(output_level_inputs->files)) {
     return false;
   }
-  if (!output_level_inputs->empty()) {
-    if (!ExpandWhileOverlapping(cf_name, vstorage, output_level_inputs)) {
-      return false;
-    }
-  }
 
   // See if we can further grow the number of inputs in "level" without
   // changing the number of "level+1" files we pick up. We also choose NOT
@@ -485,15 +484,11 @@ bool CompactionPicker::SetupOtherInputs(
         !vstorage->HasOverlappingUserKey(&expanded0.files, input_level)) {
       InternalKey new_start, new_limit;
       GetRange(expanded0, &new_start, &new_limit);
-      CompactionInputFiles expanded1;
-      expanded1.level = output_level;
+      std::vector<FileMetaData*> expanded1;
       vstorage->GetOverlappingInputs(output_level, &new_start, &new_limit,
-                                     &expanded1.files, *parent_index,
-                                     parent_index);
-      assert(!expanded1.empty());
-      if (!FilesInCompaction(expanded1.files) &&
-          ExpandWhileOverlapping(cf_name, vstorage, &expanded1) &&
-          expanded1.size() == output_level_inputs->size()) {
+                                     &expanded1, *parent_index, parent_index);
+      if (expanded1.size() == output_level_inputs->size() &&
+          !FilesInCompaction(expanded1)) {
         Log(InfoLogLevel::INFO_LEVEL, ioptions_.info_log,
             "[%s] Expanding@%d %" ROCKSDB_PRIszt "+%" ROCKSDB_PRIszt "(%" PRIu64
             "+%" PRIu64 " bytes) to %" ROCKSDB_PRIszt "+%" ROCKSDB_PRIszt
@@ -504,7 +499,7 @@ bool CompactionPicker::SetupOtherInputs(
         smallest = new_start;
         largest = new_limit;
         inputs->files = expanded0.files;
-        output_level_inputs->files = expanded1.files;
+        output_level_inputs->files = expanded1;
       }
     }
   }
@@ -1184,8 +1179,7 @@ uint32_t LevelCompactionPicker::GetPathId(
         return p;
       } else {
         current_path_size -= level_size;
-        level_size = static_cast<uint64_t>(
-            level_size * mutable_cf_options.max_bytes_for_level_multiplier);
+        level_size *= mutable_cf_options.max_bytes_for_level_multiplier;
         cur_level++;
         continue;
       }

db/compaction_picker.h

@@ -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,

db/compaction_picker_test.cc

@@ -121,7 +121,6 @@ class CompactionPickerTest : public testing::Test {
     vstorage_->GenerateLevelFilesBrief();
     vstorage_->ComputeCompactionScore(ioptions_, mutable_cf_options_);
     vstorage_->GenerateLevel0NonOverlapping();
-    vstorage_->ComputeFilesMarkedForCompaction();
     vstorage_->SetFinalized();
   }
 };
@@ -694,70 +693,6 @@ TEST_F(CompactionPickerTest, OverlappingUserKeys4) {
   ASSERT_EQ(7U, compaction->input(1, 0)->fd.GetNumber());
 }
 
-TEST_F(CompactionPickerTest, OverlappingUserKeys5) {
-  NewVersionStorage(6, kCompactionStyleLevel);
-  // Overlapping user keys on same level and output level
-  Add(1, 1U, "200", "400", 1000000000U);
-  Add(1, 2U, "400", "500", 1U, 0, 0);
-  Add(2, 3U, "000", "100", 1U);
-  Add(2, 4U, "100", "600", 1U, 0, 0);
-  Add(2, 5U, "600", "700", 1U, 0, 0);
-
-  vstorage_->LevelFiles(2)[2]->being_compacted = true;
-
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, vstorage_.get(), &log_buffer_));
-  ASSERT_TRUE(compaction.get() == nullptr);
-}
-
-TEST_F(CompactionPickerTest, OverlappingUserKeys6) {
-  NewVersionStorage(6, kCompactionStyleLevel);
-  // Overlapping user keys on same level and output level
-  Add(1, 1U, "200", "400", 1U, 0, 0);
-  Add(1, 2U, "401", "500", 1U, 0, 0);
-  Add(2, 3U, "000", "100", 1U);
-  Add(2, 4U, "100", "300", 1U, 0, 0);
-  Add(2, 5U, "305", "450", 1U, 0, 0);
-  Add(2, 6U, "460", "600", 1U, 0, 0);
-  Add(2, 7U, "600", "700", 1U, 0, 0);
-
-  vstorage_->LevelFiles(1)[0]->marked_for_compaction = true;
-  vstorage_->LevelFiles(1)[1]->marked_for_compaction = true;
-
-  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_EQ(2U, compaction->num_input_levels());
-  ASSERT_EQ(1U, compaction->num_input_files(0));
-  ASSERT_EQ(3U, compaction->num_input_files(1));
-}
-
-TEST_F(CompactionPickerTest, OverlappingUserKeys7) {
-  NewVersionStorage(6, kCompactionStyleLevel);
-  mutable_cf_options_.max_compaction_bytes = 100000000000u;
-  // Overlapping user keys on same level and output level
-  Add(1, 1U, "200", "400", 1U, 0, 0);
-  Add(1, 2U, "401", "500", 1000000000U, 0, 0);
-  Add(2, 3U, "100", "250", 1U);
-  Add(2, 4U, "300", "600", 1U, 0, 0);
-  Add(2, 5U, "600", "800", 1U, 0, 0);
-
-  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_EQ(2U, compaction->num_input_levels());
-  ASSERT_GE(1U, compaction->num_input_files(0));
-  ASSERT_GE(2U, compaction->num_input_files(1));
-  // File 5 has to be included in the compaction
-  ASSERT_EQ(5U, compaction->inputs(1)->back()->fd.GetNumber());
-}
-
 TEST_F(CompactionPickerTest, NotScheduleL1IfL0WithHigherPri1) {
   NewVersionStorage(6, kCompactionStyleLevel);
   mutable_cf_options_.level0_file_num_compaction_trigger = 2;
@@ -1177,50 +1112,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) {

db/cuckoo_table_db_test.cc

@@ -41,7 +41,6 @@ class CuckooTableDBTest : public testing::Test {
     options.memtable_factory.reset(NewHashLinkListRepFactory(4, 0, 3, true));
     options.allow_mmap_reads = true;
     options.create_if_missing = true;
-    options.allow_concurrent_memtable_write = false;
     return options;
   }
 

db/db_bloom_filter_test.cc

@@ -810,7 +810,6 @@ TEST_F(DBBloomFilterTest, PrefixScan) {
     options.max_background_compactions = 2;
     options.create_if_missing = true;
     options.memtable_factory.reset(NewHashSkipListRepFactory(16));
-    options.allow_concurrent_memtable_write = false;
 
     BlockBasedTableOptions table_options;
     table_options.no_block_cache = true;

db/db_compaction_filter_test.cc

@@ -13,7 +13,6 @@
 namespace rocksdb {
 
 static int cfilter_count = 0;
-static int cfilter_skips = 0;
 
 // This is a static filter used for filtering
 // kvs during the compaction process.
@@ -66,30 +65,6 @@ class DeleteISFilter : public CompactionFilter {
   virtual const char* Name() const override { return "DeleteFilter"; }
 };
 
-// Skip x if floor(x/10) is even, use range skips. Requires that keys are
-// zero-padded to length 10.
-class SkipEvenFilter : public CompactionFilter {
- public:
-  virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
-                            const Slice& existing_value, std::string* new_value,
-                            std::string* skip_until) const override {
-    cfilter_count++;
-    int i = std::stoi(key.ToString());
-    if (i / 10 % 2 == 0) {
-      char key_str[100];
-      snprintf(key_str, sizeof(key), "%010d", i / 10 * 10 + 10);
-      *skip_until = key_str;
-      ++cfilter_skips;
-      return Decision::kRemoveAndSkipUntil;
-    }
-    return Decision::kKeep;
-  }
-
-  virtual bool IgnoreSnapshots() const override { return true; }
-
-  virtual const char* Name() const override { return "DeleteFilter"; }
-};
-
 class DelayFilter : public CompactionFilter {
  public:
   explicit DelayFilter(DBTestBase* d) : db_test(d) {}
@@ -199,20 +174,6 @@ class DeleteISFilterFactory : public CompactionFilterFactory {
   virtual const char* Name() const override { return "DeleteFilterFactory"; }
 };
 
-class SkipEvenFilterFactory : public CompactionFilterFactory {
- public:
-  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-      const CompactionFilter::Context& context) override {
-    if (context.is_manual_compaction) {
-      return std::unique_ptr<CompactionFilter>(new SkipEvenFilter());
-    } else {
-      return std::unique_ptr<CompactionFilter>(nullptr);
-    }
-  }
-
-  virtual const char* Name() const override { return "SkipEvenFilterFactory"; }
-};
-
 class DelayFilterFactory : public CompactionFilterFactory {
  public:
   explicit DelayFilterFactory(DBTestBase* d) : db_test(d) {}
@@ -300,10 +261,8 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
   int total = 0;
   Arena arena;
   {
-    InternalKeyComparator icmp(options.comparator);
-    RangeDelAggregator range_del_agg(icmp, {} /* snapshots */);
     ScopedArenaIterator iter(
-        dbfull()->NewInternalIterator(&arena, &range_del_agg, handles_[1]));
+        dbfull()->NewInternalIterator(&arena, handles_[1]));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
@@ -390,10 +349,8 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
   // level Lmax because this record is at the tip
   count = 0;
   {
-    InternalKeyComparator icmp(options.comparator);
-    RangeDelAggregator range_del_agg(icmp, {} /* snapshots */);
     ScopedArenaIterator iter(
-        dbfull()->NewInternalIterator(&arena, &range_del_agg, handles_[1]));
+        dbfull()->NewInternalIterator(&arena, handles_[1]));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
@@ -609,10 +566,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
     int count = 0;
     int total = 0;
     Arena arena;
-    InternalKeyComparator icmp(options.comparator);
-    RangeDelAggregator range_del_agg(icmp, {} /* snapshots */);
-    ScopedArenaIterator iter(
-        dbfull()->NewInternalIterator(&arena, &range_del_agg));
+    ScopedArenaIterator iter(dbfull()->NewInternalIterator(&arena));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
@@ -758,47 +712,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
 }
 #endif  // ROCKSDB_LITE
 
-TEST_F(DBTestCompactionFilter, SkipUntil) {
-  Options options = CurrentOptions();
-  options.compaction_filter_factory = std::make_shared<SkipEvenFilterFactory>();
-  options.disable_auto_compactions = true;
-  options.create_if_missing = true;
-  DestroyAndReopen(options);
-
-  // Write 100K keys, these are written to a few files in L0.
-  for (int table = 0; table < 4; ++table) {
-    // Key ranges in tables are [0, 38], [106, 149], [212, 260], [318, 371].
-    for (int i = table * 6; i < 39 + table * 11; ++i) {
-      char key[100];
-      snprintf(key, sizeof(key), "%010d", table * 100 + i);
-      Put(key, std::to_string(table * 1000 + i));
-    }
-    Flush();
-  }
-
-  cfilter_skips = 0;
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  // Numberof skips in tables: 2, 3, 3, 3.
-  ASSERT_EQ(11, cfilter_skips);
-
-  for (int table = 0; table < 4; ++table) {
-    for (int i = table * 6; i < 39 + table * 11; ++i) {
-      int k = table * 100 + i;
-      char key[100];
-      snprintf(key, sizeof(key), "%010d", table * 100 + i);
-      auto expected = std::to_string(table * 1000 + i);
-      std::string val;
-      Status s = db_->Get(ReadOptions(), key, &val);
-      if (k / 10 % 2 == 0) {
-        ASSERT_TRUE(s.IsNotFound());
-      } else {
-        ASSERT_OK(s);
-        ASSERT_EQ(expected, val);
-      }
-    }
-  }
-}
-
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_compaction_test.cc

@@ -305,8 +305,8 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
   dbfull()->TEST_WaitForCompact();
   // Preloading iterator issues one table cache lookup and creates
   // a new table reader. One file is created for flush and one for compaction.
-  // Compaction inputs make no table cache look-up for data/range deletion
-  // iterators
+  // Compaction inputs make no table cache look-up for data iterators or
+  // range tombstone iterators since they're already cached.
   ASSERT_EQ(num_table_cache_lookup, 2);
   // Create new iterator for:
   // (1) 1 for verifying flush results
@@ -327,8 +327,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
   cro.target_level = 2;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   db_->CompactRange(cro, nullptr, nullptr);
-  // Only verifying compaction outputs issues one table cache lookup
-  // for both data block and range deletion block).
+  // Only verifying compaction outputs issues one table cache lookup.
   ASSERT_EQ(num_table_cache_lookup, 1);
   // One for compaction input, one for verifying compaction results.
   ASSERT_EQ(num_new_table_reader, 2);
@@ -1260,8 +1259,7 @@ TEST_F(DBCompactionTest, ManualPartialFill) {
   uint64_t target_size = 4 * options.max_bytes_for_level_base;
   for (int32_t i = 1; i < options.num_levels; i++) {
     ASSERT_LE(SizeAtLevel(i), target_size);
-    target_size = static_cast<uint64_t>(target_size *
-                                        options.max_bytes_for_level_multiplier);
+    target_size *= options.max_bytes_for_level_multiplier;
   }
 
   TEST_SYNC_POINT("DBCompaction::PartialFill:2");
@@ -1338,8 +1336,7 @@ TEST_F(DBCompactionTest, DeleteFileRange) {
   uint64_t target_size = 4 * options.max_bytes_for_level_base;
   for (int32_t i = 1; i < options.num_levels; i++) {
     ASSERT_LE(SizeAtLevel(i), target_size);
-    target_size = static_cast<uint64_t>(target_size *
-                                        options.max_bytes_for_level_multiplier);
+    target_size *= options.max_bytes_for_level_multiplier;
   }
 
   size_t old_num_files = CountFiles();

db/db_dynamic_level_test.cc

@@ -406,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;
 

db/db_filesnapshot.cc

@@ -27,6 +27,7 @@
 #include "util/file_util.h"
 #include "util/mutexlock.h"
 #include "util/sync_point.h"
+#include "util/testharness.h"
 
 namespace rocksdb {
 

db/db_flush_test.cc

@@ -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) {

db/db_impl.cc

@@ -51,7 +51,6 @@
 #include "db/memtable_list.h"
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
-#include "db/range_del_aggregator.h"
 #include "db/table_cache.h"
 #include "db/table_properties_collector.h"
 #include "db/transaction_log_impl.h"
@@ -123,11 +122,12 @@ struct DBImpl::WriteContext {
 };
 
 Options SanitizeOptions(const std::string& dbname,
+                        const InternalKeyComparator* icmp,
                         const Options& src) {
   auto db_options = SanitizeOptions(dbname, DBOptions(src));
   ImmutableDBOptions immutable_db_options(db_options);
   auto cf_options =
-      SanitizeOptions(immutable_db_options, ColumnFamilyOptions(src));
+      SanitizeOptions(immutable_db_options, icmp, ColumnFamilyOptions(src));
   return Options(db_options, cf_options);
 }
 
@@ -255,17 +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. ");
+        "then os caching (allow_os_buffer) must also be enabled. ");
   }
 
   return Status::OK();
@@ -277,28 +271,36 @@ CompressionType GetCompressionFlush(
   // Compressing memtable flushes might not help unless the sequential load
   // optimization is used for leveled compaction. Otherwise the CPU and
   // latency overhead is not offset by saving much space.
+
+  bool can_compress;
+
   if (ioptions.compaction_style == kCompactionStyleUniversal) {
-    if (ioptions.compaction_options_universal.compression_size_percent < 0) {
-      return mutable_cf_options.compression;
-    } else {
-      return kNoCompression;
-    }
-  } else if (!ioptions.compression_per_level.empty()) {
-    // For leveled compress when min_level_to_compress != 0.
-    return ioptions.compression_per_level[0];
+    can_compress =
+        (ioptions.compaction_options_universal.compression_size_percent < 0);
   } else {
+    // For leveled compress when min_level_to_compress == 0.
+    can_compress = ioptions.compression_per_level.empty() ||
+                   ioptions.compression_per_level[0] != kNoCompression;
+  }
+
+  if (can_compress) {
     return mutable_cf_options.compression;
+  } else {
+    return kNoCompression;
   }
 }
 
 void DumpSupportInfo(Logger* logger) {
-  Header(logger, "Compression algorithms supported:");
-  Header(logger, "\tSnappy supported: %d", Snappy_Supported());
-  Header(logger, "\tZlib supported: %d", Zlib_Supported());
-  Header(logger, "\tBzip supported: %d", BZip2_Supported());
-  Header(logger, "\tLZ4 supported: %d", LZ4_Supported());
-  Header(logger, "\tZSTD supported: %d", ZSTD_Supported());
-  Header(logger, "Fast CRC32 supported: %d", crc32c::IsFastCrc32Supported());
+  Log(InfoLogLevel::INFO_LEVEL, logger, "Compression algorithms supported:");
+  Log(InfoLogLevel::INFO_LEVEL, logger, "\tSnappy supported: %d",
+      Snappy_Supported());
+  Log(InfoLogLevel::INFO_LEVEL, logger, "\tZlib supported: %d",
+      Zlib_Supported());
+  Log(InfoLogLevel::INFO_LEVEL, logger, "\tBzip supported: %d",
+      BZip2_Supported());
+  Log(InfoLogLevel::INFO_LEVEL, logger, "\tLZ4 supported: %d", LZ4_Supported());
+  Log(InfoLogLevel::INFO_LEVEL, logger, "Fast CRC32 supported: %d",
+      crc32c::IsFastCrc32Supported());
 }
 
 }  // namespace
@@ -328,7 +330,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
                         ? immutable_db_options_.write_thread_max_yield_usec
                         : 0,
                     immutable_db_options_.write_thread_slow_yield_usec),
-      write_controller_(mutable_db_options_.delayed_write_rate),
+      write_controller_(immutable_db_options_.delayed_write_rate),
       last_batch_group_size_(0),
       unscheduled_flushes_(0),
       unscheduled_compactions_(0),
@@ -338,11 +340,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
@@ -380,12 +383,8 @@ 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) {
+      has_unpersisted_data_) {
     for (auto cfd : *versions_->GetColumnFamilySet()) {
       if (!cfd->IsDropped() && !cfd->mem()->IsEmpty()) {
         cfd->Ref();
@@ -507,8 +506,6 @@ DBImpl::~DBImpl() {
     env_->UnlockFile(db_lock_);
   }
 
-  Log(InfoLogLevel::INFO_LEVEL, immutable_db_options_.info_log,
-      "Shutdown complete");
   LogFlush(immutable_db_options_.info_log);
 }
 
@@ -643,20 +640,13 @@ void DBImpl::MaybeDumpStats() {
       default_cf_internal_stats_->GetStringProperty(
           *db_property_info, DB::Properties::kDBStats, &stats);
     }
+    if (immutable_db_options_.dump_malloc_stats) {
+      DumpMallocStats(&stats);
+    }
     Log(InfoLogLevel::WARN_LEVEL, immutable_db_options_.info_log,
         "------- DUMPING STATS -------");
     Log(InfoLogLevel::WARN_LEVEL, immutable_db_options_.info_log, "%s",
         stats.c_str());
-    if (immutable_db_options_.dump_malloc_stats) {
-      stats.clear();
-      DumpMallocStats(&stats);
-      if (!stats.empty()) {
-        Log(InfoLogLevel::WARN_LEVEL, immutable_db_options_.info_log,
-            "------- Malloc STATS -------");
-        Log(InfoLogLevel::WARN_LEVEL, immutable_db_options_.info_log, "%s",
-            stats.c_str());
-      }
-    }
 #endif  // !ROCKSDB_LITE
 
     PrintStatistics();
@@ -664,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
@@ -712,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;
 
@@ -755,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
@@ -790,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) {
@@ -807,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;
     }
   }
 
@@ -841,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();
 
@@ -1537,6 +1515,18 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
         }
       }
 
+      bool no_prev_seq = true;
+      if (!immutable_db_options_.allow_2pc) {
+        *next_sequence = sequence;
+      } else {
+        if (*next_sequence == kMaxSequenceNumber) {
+          *next_sequence = sequence;
+        } else {
+          no_prev_seq = false;
+          WriteBatchInternal::SetSequence(&batch, *next_sequence);
+        }
+      }
+
 #ifndef ROCKSDB_LITE
       if (immutable_db_options_.wal_filter != nullptr) {
         WriteBatch new_batch;
@@ -1619,10 +1609,25 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
       // we just ignore the update.
       // That's why we set ignore missing column families to true
       bool has_valid_writes = false;
+      // If we pass DB through and options.max_successive_merges is hit
+      // during recovery, Get() will be issued which will try to acquire
+      // DB mutex and cause deadlock, as DB mutex is already held.
+      // The DB pointer is not needed unless 2PC is used.
+      // TODO(sdong) fix the allow_2pc case too.
       status = WriteBatchInternal::InsertInto(
           &batch, column_family_memtables_.get(), &flush_scheduler_, true,
-          log_number, this, false /* concurrent_memtable_writes */,
-          next_sequence, &has_valid_writes);
+          log_number, immutable_db_options_.allow_2pc ? this : nullptr,
+          false /* concurrent_memtable_writes */, next_sequence,
+          &has_valid_writes);
+      // If it is the first log file and there is no column family updated
+      // after replaying the file, this file may be a stale file. We ignore
+      // sequence IDs from the file. Otherwise, if a newer stale log file that
+      // has been deleted, the sequenceID may be wrong.
+      if (immutable_db_options_.allow_2pc) {
+        if (no_prev_seq && !has_valid_writes) {
+          *next_sequence = kMaxSequenceNumber;
+        }
+      }
       MaybeIgnoreError(&status);
       if (!status.ok()) {
         // We are treating this as a failure while reading since we read valid
@@ -1724,7 +1729,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
           flushed = true;
 
           cfd->CreateNewMemtable(*cfd->GetLatestMutableCFOptions(),
-                                 versions_->LastSequence());
+                                 *next_sequence);
         }
         data_seen = true;
       }
@@ -1800,9 +1805,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
 
       s = BuildTable(
           dbname_, env_, *cfd->ioptions(), mutable_cf_options, env_options_,
-          cfd->table_cache(), iter.get(),
-          std::unique_ptr<InternalIterator>(mem->NewRangeTombstoneIterator(ro)),
-          &meta, cfd->internal_comparator(),
+          cfd->table_cache(), iter.get(), &meta, cfd->internal_comparator(),
           cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
           snapshot_seqs, earliest_write_conflict_snapshot,
           GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
@@ -1842,7 +1845,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_;
@@ -1879,7 +1881,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;
     }
   }
@@ -1930,8 +1931,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()) {
@@ -1956,6 +1955,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) {
@@ -1969,7 +1969,6 @@ Status DBImpl::FlushMemTableToOutputFile(
             "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached");
       }
     }
-#endif  // ROCKSDB_LITE
   }
   return s;
 }
@@ -2149,7 +2148,7 @@ Status DBImpl::CompactFiles(
                        immutable_db_options_.info_log.get());
 
   // Perform CompactFiles
-  SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);
+  SuperVersion* sv = GetAndRefSuperVersion(cfd);
   {
     InstrumentedMutexLock l(&mutex_);
 
@@ -2161,12 +2160,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
   {
@@ -2519,14 +2513,8 @@ Status DBImpl::SetDBOptions(
         MaybeScheduleFlushOrCompaction();
       }
 
-      write_controller_.set_max_delayed_write_rate(new_options.delayed_write_rate);
-
       mutable_db_options_ = new_options;
 
-      if (total_log_size_ > GetMaxTotalWalSize()) {
-        MaybeFlushColumnFamilies();
-      }
-
       persist_options_status = PersistOptions();
     }
   }
@@ -2771,7 +2759,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();
 }
@@ -2904,8 +2892,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
 }
 
 InternalIterator* DBImpl::NewInternalIterator(
-    Arena* arena, RangeDelAggregator* range_del_agg,
-    ColumnFamilyHandle* column_family) {
+    Arena* arena, ColumnFamilyHandle* column_family) {
   ColumnFamilyData* cfd;
   if (column_family == nullptr) {
     cfd = default_cf_handle_->cfd();
@@ -2918,8 +2905,7 @@ InternalIterator* DBImpl::NewInternalIterator(
   SuperVersion* super_version = cfd->GetSuperVersion()->Ref();
   mutex_.Unlock();
   ReadOptions roptions;
-  return NewInternalIterator(roptions, cfd, super_version, arena,
-                             range_del_agg);
+  return NewInternalIterator(roptions, cfd, super_version, arena);
 }
 
 Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
@@ -3809,12 +3795,11 @@ bool DBImpl::MCOverlap(ManualCompaction* m, ManualCompaction* m1) {
 }
 
 size_t DBImpl::GetWalPreallocateBlockSize(uint64_t write_buffer_size) const {
-  mutex_.AssertHeld();
   size_t bsize = write_buffer_size / 10 + write_buffer_size;
   // Some users might set very high write_buffer_size and rely on
   // max_total_wal_size or other parameters to control the WAL size.
-  if (mutable_db_options_.max_total_wal_size > 0) {
-    bsize = std::min<size_t>(bsize, mutable_db_options_.max_total_wal_size);
+  if (immutable_db_options_.max_total_wal_size > 0) {
+    bsize = std::min<size_t>(bsize, immutable_db_options_.max_total_wal_size);
   }
   if (immutable_db_options_.db_write_buffer_size > 0) {
     bsize = std::min<size_t>(bsize, immutable_db_options_.db_write_buffer_size);
@@ -3880,13 +3865,12 @@ static void CleanupIteratorState(void* arg1, void* arg2) {
 }
 }  // namespace
 
-InternalIterator* DBImpl::NewInternalIterator(
-    const ReadOptions& read_options, ColumnFamilyData* cfd,
-    SuperVersion* super_version, Arena* arena,
-    RangeDelAggregator* range_del_agg) {
+InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
+                                              ColumnFamilyData* cfd,
+                                              SuperVersion* super_version,
+                                              Arena* arena) {
   InternalIterator* internal_iter;
   assert(arena != nullptr);
-  assert(range_del_agg != nullptr);
   // Need to create internal iterator from the arena.
   MergeIteratorBuilder merge_iter_builder(
       &cfd->internal_comparator(), arena,
@@ -3895,34 +3879,18 @@ InternalIterator* DBImpl::NewInternalIterator(
   // Collect iterator for mutable mem
   merge_iter_builder.AddIterator(
       super_version->mem->NewIterator(read_options, arena));
-  std::unique_ptr<InternalIterator> range_del_iter;
-  Status s;
-  if (!read_options.ignore_range_deletions) {
-    range_del_iter.reset(
-        super_version->mem->NewRangeTombstoneIterator(read_options));
-    s = range_del_agg->AddTombstones(std::move(range_del_iter));
-  }
   // Collect all needed child iterators for immutable memtables
-  if (s.ok()) {
-    super_version->imm->AddIterators(read_options, &merge_iter_builder);
-    if (!read_options.ignore_range_deletions) {
-      s = super_version->imm->AddRangeTombstoneIterators(read_options, arena,
-                                                         range_del_agg);
-    }
-  }
-  if (s.ok()) {
-    // Collect iterators for files in L0 - Ln
-    super_version->current->AddIterators(read_options, env_options_,
-                                         &merge_iter_builder, range_del_agg);
-    internal_iter = merge_iter_builder.Finish();
-    IterState* cleanup =
-        new IterState(this, &mutex_, super_version,
-                      read_options.background_purge_on_iterator_cleanup);
-    internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);
+  super_version->imm->AddIterators(read_options, &merge_iter_builder);
+  // Collect iterators for files in L0 - Ln
+  super_version->current->AddIterators(read_options, env_options_,
+                                       &merge_iter_builder);
+  internal_iter = merge_iter_builder.Finish();
+  IterState* cleanup =
+      new IterState(this, &mutex_, super_version,
+                    read_options.background_purge_on_iterator_cleanup);
+  internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);
 
-    return internal_iter;
-  }
-  return NewErrorInternalIterator(s);
+  return internal_iter;
 }
 
 ColumnFamilyHandle* DBImpl::DefaultColumnFamily() const {
@@ -4007,7 +3975,6 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
   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);
 
   Status s;
   // First look in the memtable, then in the immutable memtable (if any).
@@ -4020,24 +3987,18 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
       (read_options.read_tier == kPersistedTier && has_unpersisted_data_);
   bool done = false;
   if (!skip_memtable) {
-    if (sv->mem->Get(lkey, value, &s, &merge_context, &range_del_agg,
-                     read_options)) {
+    if (sv->mem->Get(lkey, value, &s, &merge_context)) {
       done = true;
       RecordTick(stats_, MEMTABLE_HIT);
-    } else if ((s.ok() || s.IsMergeInProgress()) &&
-               sv->imm->Get(lkey, value, &s, &merge_context, &range_del_agg,
-                            read_options)) {
+    } else if (sv->imm->Get(lkey, value, &s, &merge_context)) {
       done = true;
       RecordTick(stats_, MEMTABLE_HIT);
     }
-    if (!done && !s.ok() && !s.IsMergeInProgress()) {
-      return s;
-    }
   }
   if (!done) {
     PERF_TIMER_GUARD(get_from_output_files_time);
     sv->current->Get(read_options, lkey, value, &s, &merge_context,
-                     &range_del_agg, value_found);
+                     value_found);
     RecordTick(stats_, MEMTABLE_MISS);
   }
 
@@ -4115,8 +4076,6 @@ std::vector<Status> DBImpl::MultiGet(
 
     LookupKey lkey(keys[i], snapshot);
     auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family[i]);
-    RangeDelAggregator range_del_agg(cfh->cfd()->internal_comparator(),
-                                     snapshot);
     auto mgd_iter = multiget_cf_data.find(cfh->cfd()->GetID());
     assert(mgd_iter != multiget_cf_data.end());
     auto mgd = mgd_iter->second;
@@ -4125,20 +4084,18 @@ std::vector<Status> DBImpl::MultiGet(
         (read_options.read_tier == kPersistedTier && has_unpersisted_data_);
     bool done = false;
     if (!skip_memtable) {
-      if (super_version->mem->Get(lkey, value, &s, &merge_context,
-                                  &range_del_agg, read_options)) {
+      if (super_version->mem->Get(lkey, value, &s, &merge_context)) {
         done = true;
         // TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
-      } else if (super_version->imm->Get(lkey, value, &s, &merge_context,
-                                         &range_del_agg, read_options)) {
+      } else if (super_version->imm->Get(lkey, value, &s, &merge_context)) {
         done = true;
         // TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
       }
     }
     if (!done) {
       PERF_TIMER_GUARD(get_from_output_files_time);
-      super_version->current->Get(read_options, lkey, value, &s, &merge_context,
-                                  &range_del_agg);
+      super_version->current->Get(read_options, lkey, value, &s,
+                                  &merge_context);
       // TODO(?): RecordTick(stats_, MEMTABLE_MISS)?
     }
 
@@ -4464,8 +4421,7 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
         read_options.total_order_seek);
 
     InternalIterator* internal_iter =
-        NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(),
-                            db_iter->GetRangeDelAggregator());
+        NewInternalIterator(read_options, cfd, sv, db_iter->GetArena());
     db_iter->SetIterUnderDBIter(internal_iter);
 
     return db_iter;
@@ -4538,8 +4494,7 @@ Status DBImpl::NewIterators(
           sv->mutable_cf_options.max_sequential_skip_in_iterations,
           sv->version_number, nullptr, false, read_options.pin_data);
       InternalIterator* internal_iter =
-          NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(),
-                              db_iter->GetRangeDelAggregator());
+          NewInternalIterator(read_options, cfd, sv, db_iter->GetArena());
       db_iter->SetIterUnderDBIter(internal_iter);
       iterators->push_back(db_iter);
     }
@@ -4716,9 +4671,34 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   assert(!single_column_family_mode_ ||
          versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1);
 
+  uint64_t max_total_wal_size = (immutable_db_options_.max_total_wal_size == 0)
+                                    ? 4 * max_total_in_memory_state_
+                                    : immutable_db_options_.max_total_wal_size;
   if (UNLIKELY(!single_column_family_mode_ &&
-               total_log_size_ > GetMaxTotalWalSize())) {
-    MaybeFlushColumnFamilies();
+               alive_log_files_.begin()->getting_flushed == false &&
+               total_log_size_ > max_total_wal_size)) {
+    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,
+        flush_column_family_if_log_file, total_log_size_, max_total_wal_size);
+    // 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->GetLogNumber() <= flush_column_family_if_log_file) {
+        status = SwitchMemtable(cfd, &context);
+        if (!status.ok()) {
+          break;
+        }
+        cfd->imm()->FlushRequested();
+        SchedulePendingFlush(cfd);
+      }
+    }
+    MaybeScheduleFlushOrCompaction();
   } 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
@@ -4775,7 +4755,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     // for previous one. It might create a fairness issue that expiration
     // might happen for smaller writes but larger writes can go through.
     // Can optimize it if it is an issue.
-    status = DelayWrite(last_batch_group_size_, write_options);
+    status = DelayWrite(last_batch_group_size_);
     PERF_TIMER_START(write_pre_and_post_process_time);
   }
 
@@ -4785,7 +4765,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   bool need_log_sync = !write_options.disableWAL && write_options.sync;
   bool need_log_dir_sync = need_log_sync && !log_dir_synced_;
 
-  bool logs_getting_synced = false;
   if (status.ok()) {
     if (need_log_sync) {
       while (logs_.front().getting_synced) {
@@ -4795,7 +4774,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
         assert(!log.getting_synced);
         log.getting_synced = true;
       }
-      logs_getting_synced = true;
     }
 
     // Add to log and apply to memtable.  We can release the lock
@@ -5015,7 +4993,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   PERF_TIMER_START(write_pre_and_post_process_time);
 
   if (immutable_db_options_.paranoid_checks && !status.ok() &&
-      !w.CallbackFailed() && !status.IsBusy() && !status.IsIncomplete()) {
+      !w.CallbackFailed() && !status.IsBusy()) {
     mutex_.Lock();
     if (bg_error_.ok()) {
       bg_error_ = status;  // stop compaction & fail any further writes
@@ -5023,7 +5001,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     mutex_.Unlock();
   }
 
-  if (logs_getting_synced) {
+  if (need_log_sync) {
     mutex_.Lock();
     MarkLogsSynced(logfile_number_, need_log_dir_sync, status);
     mutex_.Unlock();
@@ -5036,91 +5014,15 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   return status;
 }
 
-void DBImpl::MaybeFlushColumnFamilies() {
-  mutex_.AssertHeld();
-
-  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;
-
-  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());
-  // 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) {
-      auto status = SwitchMemtable(cfd, &context);
-      if (!status.ok()) {
-        break;
-      }
-      cfd->imm()->FlushRequested();
-      SchedulePendingFlush(cfd);
-    }
-  }
-  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 {
-  mutex_.AssertHeld();
-  return mutable_db_options_.max_total_wal_size == 0
-             ? 4 * max_total_in_memory_state_
-             : mutable_db_options_.max_total_wal_size;
-}
-
 // REQUIRES: mutex_ is held
 // REQUIRES: this thread is currently at the front of the writer queue
-Status DBImpl::DelayWrite(uint64_t num_bytes,
-                          const WriteOptions& write_options) {
+Status DBImpl::DelayWrite(uint64_t num_bytes) {
   uint64_t time_delayed = 0;
   bool delayed = false;
   {
     StopWatch sw(env_, stats_, WRITE_STALL, &time_delayed);
     auto delay = write_controller_.GetDelay(env_, num_bytes);
     if (delay > 0) {
-      if (write_options.no_slowdown) {
-        return Status::Incomplete();
-      }
       mutex_.Unlock();
       delayed = true;
       TEST_SYNC_POINT("DBImpl::DelayWrite:Sleep");
@@ -5130,15 +5032,11 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
     }
 
     while (bg_error_.ok() && write_controller_.IsStopped()) {
-      if (write_options.no_slowdown) {
-        return Status::Incomplete();
-      }
       delayed = true;
       TEST_SYNC_POINT("DBImpl::DelayWrite:Wait");
       bg_cv_.Wait();
     }
   }
-  assert(!delayed || !write_options.no_slowdown);
   if (delayed) {
     default_cf_internal_stats_->AddDBStats(InternalStats::WRITE_STALL_MICROS,
                                            time_delayed);
@@ -5215,8 +5113,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   int num_imm_unflushed = cfd->imm()->NumNotFlushed();
   DBOptions db_options =
       BuildDBOptions(immutable_db_options_, mutable_db_options_);
-  const auto preallocate_block_size =
-    GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
   mutex_.Unlock();
   Status s;
   {
@@ -5238,10 +5134,8 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
       if (s.ok()) {
         // Our final size should be less than write_buffer_size
         // (compression, etc) but err on the side of caution.
-
-        // use preallocate_block_size instead
-        // of calling GetWalPreallocateBlockSize()
-        lfile->SetPreallocationBlockSize(preallocate_block_size);
+        lfile->SetPreallocationBlockSize(
+            GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size));
         unique_ptr<WritableFileWriter> file_writer(
             new WritableFileWriter(std::move(lfile), opt_env_opt));
         new_log =
@@ -5394,24 +5288,6 @@ bool DBImpl::GetProperty(ColumnFamilyHandle* column_family,
   return false;
 }
 
-bool DBImpl::GetMapProperty(ColumnFamilyHandle* column_family,
-                            const Slice& property,
-                            std::map<std::string, double>* value) {
-  const DBPropertyInfo* property_info = GetPropertyInfo(property);
-  value->clear();
-  auto cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family)->cfd();
-  if (property_info == nullptr) {
-    return false;
-  } else if (property_info->handle_map) {
-    InstrumentedMutexLock l(&mutex_);
-    return cfd->internal_stats()->GetMapProperty(*property_info, property,
-                                                 value);
-  }
-  // If we reach this point it means that handle_map is not provided for the
-  // requested property
-  return false;
-}
-
 bool DBImpl::GetIntProperty(ColumnFamilyHandle* column_family,
                             const Slice& property, uint64_t* value) {
   const DBPropertyInfo* property_info = GetPropertyInfo(property);
@@ -5920,14 +5796,6 @@ Status DB::SingleDelete(const WriteOptions& opt,
   return Write(opt, &batch);
 }
 
-Status DB::DeleteRange(const WriteOptions& opt,
-                       ColumnFamilyHandle* column_family,
-                       const Slice& begin_key, const Slice& end_key) {
-  WriteBatch batch;
-  batch.DeleteRange(column_family, begin_key, end_key);
-  return Write(opt, &batch);
-}
-
 Status DB::Merge(const WriteOptions& opt, ColumnFamilyHandle* column_family,
                  const Slice& key, const Slice& value) {
   WriteBatch batch;
@@ -6118,7 +5986,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) {
@@ -6137,7 +6004,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,
@@ -6368,7 +6234,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 {
@@ -6439,10 +6305,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
                                        bool* found_record_for_key) {
   Status s;
   MergeContext merge_context;
-  RangeDelAggregator range_del_agg(sv->mem->GetInternalKeyComparator(),
-                                   kMaxSequenceNumber);
 
-  ReadOptions read_options;
   SequenceNumber current_seq = versions_->LastSequence();
   LookupKey lkey(key, current_seq);
 
@@ -6450,8 +6313,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
   *found_record_for_key = false;
 
   // Check if there is a record for this key in the latest memtable
-  sv->mem->Get(lkey, nullptr, &s, &merge_context, &range_del_agg, seq,
-               read_options);
+  sv->mem->Get(lkey, nullptr, &s, &merge_context, seq);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
     // unexpected error reading memtable.
@@ -6469,8 +6331,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
   }
 
   // Check if there is a record for this key in the immutable memtables
-  sv->imm->Get(lkey, nullptr, &s, &merge_context, &range_del_agg, seq,
-               read_options);
+  sv->imm->Get(lkey, nullptr, &s, &merge_context, seq);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
     // unexpected error reading memtable.
@@ -6488,8 +6349,7 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
   }
 
   // Check if there is a record for this key in the immutable memtables
-  sv->imm->GetFromHistory(lkey, nullptr, &s, &merge_context, &range_del_agg,
-                          seq, read_options);
+  sv->imm->GetFromHistory(lkey, nullptr, &s, &merge_context, seq);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
     // unexpected error reading memtable.
@@ -6510,9 +6370,10 @@ Status DBImpl::GetLatestSequenceForKey(SuperVersion* sv, const Slice& key,
   // SST files if cache_only=true?
   if (!cache_only) {
     // Check tables
+    ReadOptions read_options;
+
     sv->current->Get(read_options, lkey, nullptr, &s, &merge_context,
-                     &range_del_agg, nullptr /* value_found */,
-                     found_record_for_key, seq);
+                     nullptr /* value_found */, found_record_for_key, seq);
 
     if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
       // unexpected error reading SST files

db/db_impl.h

@@ -13,7 +13,6 @@
 #include <functional>
 #include <limits>
 #include <list>
-#include <map>
 #include <queue>
 #include <set>
 #include <string>
@@ -125,10 +124,6 @@ class DBImpl : public DB {
   using DB::GetProperty;
   virtual bool GetProperty(ColumnFamilyHandle* column_family,
                            const Slice& property, std::string* value) override;
-  using DB::GetMapProperty;
-  virtual bool GetMapProperty(ColumnFamilyHandle* column_family,
-                              const Slice& property,
-                              std::map<std::string, double>* value) override;
   using DB::GetIntProperty;
   virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
                               const Slice& property, uint64_t* value) override;
@@ -296,8 +291,7 @@ class DBImpl : public DB {
   // The keys of this iterator are internal keys (see format.h).
   // The returned iterator should be deleted when no longer needed.
   InternalIterator* NewInternalIterator(
-      Arena* arena, RangeDelAggregator* range_del_agg,
-      ColumnFamilyHandle* column_family = nullptr);
+      Arena* arena, ColumnFamilyHandle* column_family = nullptr);
 
 #ifndef NDEBUG
   // Extra methods (for testing) that are not in the public DB interface
@@ -308,16 +302,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);
@@ -390,8 +374,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
@@ -544,8 +526,7 @@ class DBImpl : public DB {
   InternalIterator* NewInternalIterator(const ReadOptions&,
                                         ColumnFamilyData* cfd,
                                         SuperVersion* super_version,
-                                        Arena* arena,
-                                        RangeDelAggregator* range_del_agg);
+                                        Arena* arena);
 
   // Except in DB::Open(), WriteOptionsFile can only be called when:
   // 1. WriteThread::Writer::EnterUnbatched() is used.
@@ -664,7 +645,7 @@ class DBImpl : public DB {
 
   // num_bytes: for slowdown case, delay time is calculated based on
   //            `num_bytes` going through.
-  Status DelayWrite(uint64_t num_bytes, const WriteOptions& write_options);
+  Status DelayWrite(uint64_t num_bytes);
 
   Status ScheduleFlushes(WriteContext* context);
 
@@ -744,10 +725,6 @@ class DBImpl : public DB {
   // REQUIRES: mutex locked
   Status PersistOptions();
 
-  void MaybeFlushColumnFamilies();
-
-  uint64_t GetMaxTotalWalSize() const;
-
   // table_cache_ provides its own synchronization
   std::shared_ptr<Cache> table_cache_;
 
@@ -988,9 +965,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_;
@@ -1004,15 +980,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;
@@ -1126,6 +1093,7 @@ class DBImpl : public DB {
 };
 
 extern Options SanitizeOptions(const std::string& db,
+                               const InternalKeyComparator* icmp,
                                const Options& src);
 
 extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src);

db/db_impl_debug.cc

@@ -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;

db/db_impl_readonly.cc

@@ -8,9 +8,8 @@
 
 #include "db/compacted_db_impl.h"
 #include "db/db_impl.h"
-#include "db/db_iter.h"
 #include "db/merge_context.h"
-#include "db/range_del_aggregator.h"
+#include "db/db_iter.h"
 #include "util/perf_context_imp.h"
 
 namespace rocksdb {
@@ -38,14 +37,11 @@ Status DBImplReadOnly::Get(const ReadOptions& read_options,
   auto cfd = cfh->cfd();
   SuperVersion* super_version = cfd->GetSuperVersion();
   MergeContext merge_context;
-  RangeDelAggregator range_del_agg(cfd->internal_comparator(), snapshot);
   LookupKey lkey(key, snapshot);
-  if (super_version->mem->Get(lkey, value, &s, &merge_context, &range_del_agg,
-                              read_options)) {
+  if (super_version->mem->Get(lkey, value, &s, &merge_context)) {
   } else {
     PERF_TIMER_GUARD(get_from_output_files_time);
-    super_version->current->Get(read_options, lkey, value, &s, &merge_context,
-                                &range_del_agg);
+    super_version->current->Get(read_options, lkey, value, &s, &merge_context);
   }
   return s;
 }
@@ -64,9 +60,8 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& read_options,
            : latest_snapshot),
       super_version->mutable_cf_options.max_sequential_skip_in_iterations,
       super_version->version_number);
-  auto internal_iter =
-      NewInternalIterator(read_options, cfd, super_version, db_iter->GetArena(),
-                          db_iter->GetRangeDelAggregator());
+  auto internal_iter = NewInternalIterator(
+      read_options, cfd, super_version, db_iter->GetArena());
   db_iter->SetIterUnderDBIter(internal_iter);
   return db_iter;
 }
@@ -93,9 +88,8 @@ Status DBImplReadOnly::NewIterators(
              : latest_snapshot),
         sv->mutable_cf_options.max_sequential_skip_in_iterations,
         sv->version_number);
-    auto* internal_iter =
-        NewInternalIterator(read_options, cfd, sv, db_iter->GetArena(),
-                            db_iter->GetRangeDelAggregator());
+    auto* internal_iter = NewInternalIterator(
+        read_options, cfd, sv, db_iter->GetArena());
     db_iter->SetIterUnderDBIter(internal_iter);
     iterators->push_back(db_iter);
   }

db/db_inplace_update_test.cc

@@ -23,8 +23,6 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdate) {
     options.inplace_update_support = true;
     options.env = env_;
     options.write_buffer_size = 100000;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Update key with values of smaller size
@@ -47,8 +45,6 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateLargeNewValue) {
     options.inplace_update_support = true;
     options.env = env_;
     options.write_buffer_size = 100000;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Update key with values of larger size
@@ -74,8 +70,6 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerSize) {
     options.write_buffer_size = 100000;
     options.inplace_callback =
       rocksdb::DBTestInPlaceUpdate::updateInPlaceSmallerSize;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Update key with values of smaller size
@@ -103,8 +97,6 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerVarintSize) {
     options.write_buffer_size = 100000;
     options.inplace_callback =
       rocksdb::DBTestInPlaceUpdate::updateInPlaceSmallerVarintSize;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Update key with values of smaller varint size
@@ -132,8 +124,6 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackLargeNewValue) {
     options.write_buffer_size = 100000;
     options.inplace_callback =
       rocksdb::DBTestInPlaceUpdate::updateInPlaceLargerSize;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Update key with values of larger size
@@ -158,9 +148,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackNoAction) {
     options.env = env_;
     options.write_buffer_size = 100000;
     options.inplace_callback =
-        rocksdb::DBTestInPlaceUpdate::updateInPlaceNoAction;
-    options.allow_concurrent_memtable_write = false;
-    Reopen(options);
+      rocksdb::DBTestInPlaceUpdate::updateInPlaceNoAction;
     CreateAndReopenWithCF({"pikachu"}, options);
 
     // Callback function requests no actions from db

db/db_io_failure_test.cc

@@ -33,7 +33,7 @@ TEST_F(DBIOFailureTest, DropWrites) {
     // Force out-of-space errors
     env_->drop_writes_.store(true, std::memory_order_release);
     env_->sleep_counter_.Reset();
-    env_->no_slowdown_ = true;
+    env_->no_sleep_ = true;
     for (int i = 0; i < 5; i++) {
       if (option_config_ != kUniversalCompactionMultiLevel &&
           option_config_ != kUniversalSubcompactions) {

db/db_iter.cc

@@ -122,9 +122,7 @@ class DBIter: public Iterator {
         iterate_upper_bound_(iterate_upper_bound),
         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 */) {
+        total_order_seek_(total_order_seek) {
     RecordTick(statistics_, NO_ITERATORS);
     prefix_extractor_ = ioptions.prefix_extractor;
     max_skip_ = max_sequential_skip_in_iterations;
@@ -153,10 +151,6 @@ class DBIter: public Iterator {
     iter_ = iter;
     iter_->SetPinnedItersMgr(&pinned_iters_mgr_);
   }
-  virtual RangeDelAggregator* GetRangeDelAggregator() {
-    return &range_del_agg_;
-  }
-
   virtual bool Valid() const override { return valid_; }
   virtual Slice key() const override {
     assert(valid_);
@@ -279,7 +273,6 @@ class DBIter: public Iterator {
   const bool total_order_seek_;
   // List of operands for merge operator.
   MergeContext merge_context_;
-  RangeDelAggregator range_del_agg_;
   LocalStatistics local_stats_;
   PinnedIteratorsManager pinned_iters_mgr_;
 
@@ -340,7 +333,7 @@ void DBIter::Next() {
 //           saved_value_             => the merged value
 //
 // NOTE: In between, saved_key_ can point to a user key that has
-//       a delete marker or a sequence number higher than sequence_
+//       a delete marker
 //
 // The prefix_check parameter controls whether we check the iterated
 // keys against the prefix of the seeked key. Set to false when
@@ -357,140 +350,71 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
   assert(iter_->Valid());
   assert(direction_ == kForward);
   current_entry_is_merged_ = false;
-
-  // How many times in a row we have skipped an entry with user key less than
-  // or equal to saved_key_. We could skip these entries either because
-  // sequence numbers were too high or because skipping = true.
-  // What saved_key_ contains throughout this method:
-  //  - if skipping        : saved_key_ contains the key that we need to skip,
-  //                         and we haven't seen any keys greater than that,
-  //  - if num_skipped > 0 : saved_key_ contains the key that we have skipped
-  //                         num_skipped times, and we haven't seen any keys
-  //                         greater than that,
-  //  - none of the above  : saved_key_ can contain anything, it doesn't matter.
   uint64_t num_skipped = 0;
-
   do {
     ParsedInternalKey ikey;
 
-    if (!ParseKey(&ikey)) {
-      // Skip corrupted keys.
-      iter_->Next();
-      continue;
-    }
+    if (ParseKey(&ikey)) {
+      if (iterate_upper_bound_ != nullptr &&
+          user_comparator_->Compare(ikey.user_key, *iterate_upper_bound_) >= 0) {
+        break;
+      }
 
-    if (iterate_upper_bound_ != nullptr &&
-        user_comparator_->Compare(ikey.user_key, *iterate_upper_bound_) >= 0) {
-      break;
-    }
+      if (prefix_extractor_ && prefix_check &&
+          prefix_extractor_->Transform(ikey.user_key).compare(prefix_start_key_) != 0) {
+        break;
+      }
 
-    if (prefix_extractor_ && prefix_check &&
-        prefix_extractor_->Transform(ikey.user_key)
-          .compare(prefix_start_key_) != 0) {
-      break;
-    }
-
-    if (ikey.sequence <= sequence_) {
-      if (skipping &&
-          user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) <= 0) {
-        num_skipped++;  // skip this entry
-        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
-      } else {
-        num_skipped = 0;
-        switch (ikey.type) {
-          case kTypeDeletion:
-          case kTypeSingleDeletion:
-            // Arrange to skip all upcoming entries for this key since
-            // they are hidden by this deletion.
-            saved_key_.SetKey(
-                ikey.user_key,
-                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-            skipping = true;
-            PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-            break;
-          case kTypeValue:
-            saved_key_.SetKey(
-                ikey.user_key,
-                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-            if (range_del_agg_.ShouldDelete(
-                    ikey, RangeDelAggregator::RangePositioningMode::
-                              kForwardTraversal)) {
+      if (ikey.sequence <= sequence_) {
+        if (skipping &&
+           user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) <= 0) {
+          num_skipped++;  // skip this entry
+          PERF_COUNTER_ADD(internal_key_skipped_count, 1);
+        } else {
+          switch (ikey.type) {
+            case kTypeDeletion:
+            case kTypeSingleDeletion:
               // Arrange to skip all upcoming entries for this key since
               // they are hidden by this deletion.
+              saved_key_.SetKey(
+                  ikey.user_key,
+                  !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
               skipping = true;
               num_skipped = 0;
               PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-            } else {
+              break;
+            case kTypeValue:
               valid_ = true;
+              saved_key_.SetKey(
+                  ikey.user_key,
+                  !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
               return;
-            }
-            break;
-          case kTypeMerge:
-            saved_key_.SetKey(
-                ikey.user_key,
-                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-            if (range_del_agg_.ShouldDelete(
-                    ikey, RangeDelAggregator::RangePositioningMode::
-                              kForwardTraversal)) {
-              // Arrange to skip all upcoming entries for this key since
-              // they are hidden by this deletion.
-              skipping = true;
-              num_skipped = 0;
-              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-            } else {
-              // By now, we are sure the current ikey is going to yield a
-              // value
+            case kTypeMerge:
+              // By now, we are sure the current ikey is going to yield a value
+              saved_key_.SetKey(
+                  ikey.user_key,
+                  !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
               current_entry_is_merged_ = true;
               valid_ = true;
               MergeValuesNewToOld();  // Go to a different state machine
               return;
-            }
-            break;
-          default:
-            assert(false);
-            break;
+            default:
+              assert(false);
+              break;
+          }
         }
       }
-    } else {
-      // This key was inserted after our snapshot was taken.
-      PERF_COUNTER_ADD(internal_recent_skipped_count, 1);
-
-      // Here saved_key_ may contain some old key, or the default empty key, or
-      // key assigned by some random other method. We don't care.
-      if (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) <= 0) {
-        num_skipped++;
-      } else {
-        saved_key_.SetKey(
-                ikey.user_key,
-                !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
-        skipping = false;
-        num_skipped = 0;
-      }
     }
-
-    // If we have sequentially iterated via numerous equal keys, then it's
-    // better to seek so that we can avoid too many key comparisons.
-    if (num_skipped > max_skip_) {
+    // If we have sequentially iterated via numerous keys and still not
+    // found the next user-key, then it is better to seek so that we can
+    // avoid too many key comparisons. We seek to the last occurrence of
+    // our current key by looking for sequence number 0 and type deletion
+    // (the smallest type).
+    if (skipping && num_skipped > max_skip_) {
       num_skipped = 0;
       std::string last_key;
-      if (skipping) {
-        // We're looking for the next user-key but all we see are the same
-        // user-key with decreasing sequence numbers. Fast forward to
-        // sequence number 0 and type deletion (the smallest type).
-        AppendInternalKey(&last_key, ParsedInternalKey(saved_key_.GetKey(), 0,
-                                                       kTypeDeletion));
-        // Don't set skipping = false because we may still see more user-keys
-        // equal to saved_key_.
-      } else {
-        // We saw multiple entries with this user key and sequence numbers
-        // higher than sequence_. Fast forward to sequence_.
-        // Note that this only covers a case when a higher key was overwritten
-        // many times since our snapshot was taken, not the case when a lot of
-        // different keys were inserted after our snapshot was taken.
-        AppendInternalKey(&last_key,
-                          ParsedInternalKey(saved_key_.GetKey(), sequence_,
-                                            kValueTypeForSeek));
-      }
+      AppendInternalKey(&last_key, ParsedInternalKey(saved_key_.GetKey(), 0,
+                                                     kTypeDeletion));
       iter_->Seek(last_key);
       RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
     } else {
@@ -523,7 +447,6 @@ void DBIter::MergeValuesNewToOld() {
                              iter_->IsValuePinned() /* operand_pinned */);
 
   ParsedInternalKey ikey;
-  Status s;
   for (iter_->Next(); iter_->Valid(); iter_->Next()) {
     if (!ParseKey(&ikey)) {
       // skip corrupted key
@@ -533,10 +456,7 @@ void DBIter::MergeValuesNewToOld() {
     if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetKey())) {
       // 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)) {
+    } else if (kTypeDeletion == ikey.type || kTypeSingleDeletion == ikey.type) {
       // hit a delete with the same user key, stop right here
       // iter_ is positioned after delete
       iter_->Next();
@@ -546,12 +466,9 @@ void DBIter::MergeValuesNewToOld() {
       // final result in saved_value_. We are done!
       // ignore corruption if there is any.
       const Slice val = iter_->value();
-      s = MergeHelper::TimedFullMerge(
-          merge_operator_, ikey.user_key, &val, merge_context_.GetOperands(),
-          &saved_value_, logger_, statistics_, env_, &pinned_value_);
-      if (!s.ok()) {
-        status_ = s;
-      }
+      MergeHelper::TimedFullMerge(merge_operator_, ikey.user_key, &val,
+                                  merge_context_.GetOperands(), &saved_value_,
+                                  logger_, statistics_, env_, &pinned_value_);
       // iter_ is positioned after put
       iter_->Next();
       return;
@@ -560,7 +477,6 @@ void DBIter::MergeValuesNewToOld() {
       // when complete, add result to operands and continue.
       merge_context_.PushOperand(iter_->value(),
                                  iter_->IsValuePinned() /* operand_pinned */);
-      PERF_COUNTER_ADD(internal_merge_count, 1);
     } else {
       assert(false);
     }
@@ -570,12 +486,9 @@ void DBIter::MergeValuesNewToOld() {
   // a deletion marker.
   // feed null as the existing value to the merge operator, such that
   // client can differentiate this scenario and do things accordingly.
-  s = MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(), nullptr,
-                                  merge_context_.GetOperands(), &saved_value_,
-                                  logger_, statistics_, env_, &pinned_value_);
-  if (!s.ok()) {
-    status_ = s;
-  }
+  MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(), nullptr,
+                              merge_context_.GetOperands(), &saved_value_,
+                              logger_, statistics_, env_, &pinned_value_);
 }
 
 void DBIter::Prev() {
@@ -605,7 +518,6 @@ void DBIter::ReverseToForward() {
   direction_ = kForward;
   if (!iter_->Valid()) {
     iter_->SeekToFirst();
-    range_del_agg_.InvalidateTombstoneMapPositions();
   }
 }
 
@@ -621,17 +533,11 @@ void DBIter::ReverseToBackward() {
     // previous key.
     if (!iter_->Valid()) {
       iter_->SeekToLast();
-      range_del_agg_.InvalidateTombstoneMapPositions();
     }
     ParsedInternalKey ikey;
     FindParseableKey(&ikey, kReverse);
     while (iter_->Valid() &&
            user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) > 0) {
-      if (ikey.sequence > sequence_) {
-        PERF_COUNTER_ADD(internal_recent_skipped_count, 1);
-      } else {
-        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
-      }
       iter_->Prev();
       FindParseableKey(&ikey, kReverse);
     }
@@ -718,17 +624,10 @@ 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)) {
-          last_key_entry_type = kTypeRangeDeletion;
-          PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-        } else {
-          assert(iter_->IsValuePinned());
-          pinned_value_ = iter_->value();
-        }
         merge_context_.Clear();
-        last_not_merge_type = last_key_entry_type;
+        assert(iter_->IsValuePinned());
+        pinned_value_ = iter_->value();
+        last_not_merge_type = kTypeValue;
         break;
       case kTypeDeletion:
       case kTypeSingleDeletion:
@@ -737,19 +636,9 @@ bool DBIter::FindValueForCurrentKey() {
         PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
         break;
       case kTypeMerge:
-        if (range_del_agg_.ShouldDelete(
-                ikey,
-                RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
-          merge_context_.Clear();
-          last_key_entry_type = kTypeRangeDeletion;
-          last_not_merge_type = last_key_entry_type;
-          PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-        } else {
-          assert(merge_operator_ != nullptr);
-          merge_context_.PushOperandBack(
-              iter_->value(), iter_->IsValuePinned() /* operand_pinned */);
-          PERF_COUNTER_ADD(internal_merge_count, 1);
-        }
+        assert(merge_operator_ != nullptr);
+        merge_context_.PushOperandBack(
+            iter_->value(), iter_->IsValuePinned() /* operand_pinned */);
         break;
       default:
         assert(false);
@@ -762,28 +651,25 @@ bool DBIter::FindValueForCurrentKey() {
     FindParseableKey(&ikey, kReverse);
   }
 
-  Status s;
   switch (last_key_entry_type) {
     case kTypeDeletion:
     case kTypeSingleDeletion:
-    case kTypeRangeDeletion:
       valid_ = false;
       return false;
     case kTypeMerge:
       current_entry_is_merged_ = true;
       if (last_not_merge_type == kTypeDeletion ||
-          last_not_merge_type == kTypeSingleDeletion ||
-          last_not_merge_type == kTypeRangeDeletion) {
-        s = MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(),
-                                        nullptr, merge_context_.GetOperands(),
-                                        &saved_value_, logger_, statistics_,
-                                        env_, &pinned_value_);
+          last_not_merge_type == kTypeSingleDeletion) {
+        MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(),
+                                    nullptr, merge_context_.GetOperands(),
+                                    &saved_value_, logger_, statistics_, env_,
+                                    &pinned_value_);
       } else {
         assert(last_not_merge_type == kTypeValue);
-        s = MergeHelper::TimedFullMerge(
-            merge_operator_, saved_key_.GetKey(), &pinned_value_,
-            merge_context_.GetOperands(), &saved_value_, logger_, statistics_,
-            env_, &pinned_value_);
+        MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(),
+                                    &pinned_value_,
+                                    merge_context_.GetOperands(), &saved_value_,
+                                    logger_, statistics_, env_, &pinned_value_);
       }
       break;
     case kTypeValue:
@@ -794,9 +680,6 @@ bool DBIter::FindValueForCurrentKey() {
       break;
   }
   valid_ = true;
-  if (!s.ok()) {
-    status_ = s;
-  }
   return true;
 }
 
@@ -816,46 +699,37 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
   ParsedInternalKey ikey;
   FindParseableKey(&ikey, kForward);
 
-  if (ikey.type == kTypeDeletion || ikey.type == kTypeSingleDeletion ||
-      range_del_agg_.ShouldDelete(
-          ikey, RangeDelAggregator::RangePositioningMode::kBackwardTraversal)) {
+  if (ikey.type == kTypeValue || ikey.type == kTypeDeletion ||
+      ikey.type == kTypeSingleDeletion) {
+    if (ikey.type == kTypeValue) {
+      assert(iter_->IsValuePinned());
+      pinned_value_ = iter_->value();
+      valid_ = true;
+      return true;
+    }
     valid_ = false;
     return false;
   }
-  if (ikey.type == kTypeValue) {
-    assert(iter_->IsValuePinned());
-    pinned_value_ = iter_->value();
-    valid_ = true;
-    return true;
-  }
 
   // kTypeMerge. We need to collect all kTypeMerge values and save them
   // 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) {
     merge_context_.PushOperand(iter_->value(),
                                iter_->IsValuePinned() /* operand_pinned */);
-    PERF_COUNTER_ADD(internal_merge_count, 1);
     iter_->Next();
     FindParseableKey(&ikey, kForward);
   }
 
-  Status s;
   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)) {
-    s = MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(),
-                                    nullptr, merge_context_.GetOperands(),
-                                    &saved_value_, logger_, statistics_, env_,
-                                    &pinned_value_);
+      ikey.type == kTypeDeletion || ikey.type == kTypeSingleDeletion) {
+    MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(), nullptr,
+                                merge_context_.GetOperands(), &saved_value_,
+                                logger_, statistics_, env_, &pinned_value_);
     // Make iter_ valid and point to saved_key_
     if (!iter_->Valid() ||
         !user_comparator_->Equal(ikey.user_key, saved_key_.GetKey())) {
@@ -863,20 +737,14 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
       RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
     }
     valid_ = true;
-    if (!s.ok()) {
-      status_ = s;
-    }
     return true;
   }
 
   const Slice& val = iter_->value();
-  s = MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(), &val,
-                                  merge_context_.GetOperands(), &saved_value_,
-                                  logger_, statistics_, env_, &pinned_value_);
+  MergeHelper::TimedFullMerge(merge_operator_, saved_key_.GetKey(), &val,
+                              merge_context_.GetOperands(), &saved_value_,
+                              logger_, statistics_, env_, &pinned_value_);
   valid_ = true;
-  if (!s.ok()) {
-    status_ = s;
-  }
   return true;
 }
 
@@ -921,11 +789,6 @@ void DBIter::FindPrevUserKey() {
         ++num_skipped;
       }
     }
-    if (ikey.sequence > sequence_) {
-      PERF_COUNTER_ADD(internal_recent_skipped_count, 1);
-    } else {
-      PERF_COUNTER_ADD(internal_key_skipped_count, 1);
-    }
     iter_->Prev();
     FindParseableKey(&ikey, kReverse);
   }
@@ -946,13 +809,12 @@ void DBIter::Seek(const Slice& target) {
   StopWatch sw(env_, statistics_, DB_SEEK);
   ReleaseTempPinnedData();
   saved_key_.Clear();
-  // now saved_key is used to store internal key.
+  // 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()) {
@@ -992,7 +854,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);
@@ -1034,7 +895,6 @@ void DBIter::SeekToFirst() {
   {
     PERF_TIMER_GUARD(seek_internal_seek_time);
     iter_->SeekToFirst();
-    range_del_agg_.InvalidateTombstoneMapPositions();
   }
 
   RecordTick(statistics_, NUMBER_DB_SEEK);
@@ -1068,14 +928,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())) {
@@ -1114,10 +972,6 @@ ArenaWrappedDBIter::~ArenaWrappedDBIter() { db_iter_->~DBIter(); }
 
 void ArenaWrappedDBIter::SetDBIter(DBIter* iter) { db_iter_ = iter; }
 
-RangeDelAggregator* ArenaWrappedDBIter::GetRangeDelAggregator() {
-  return db_iter_->GetRangeDelAggregator();
-}
-
 void ArenaWrappedDBIter::SetIterUnderDBIter(InternalIterator* iter) {
   static_cast<DBIter*>(db_iter_)->SetIter(iter);
 }

db/db_iter.h

@@ -11,7 +11,6 @@
 #include <stdint.h>
 #include <string>
 #include "db/dbformat.h"
-#include "db/range_del_aggregator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/iterator.h"
 #include "util/arena.h"
@@ -47,7 +46,6 @@ class ArenaWrappedDBIter : public Iterator {
   // Get the arena to be used to allocate memory for DBIter to be wrapped,
   // as well as child iterators in it.
   virtual Arena* GetArena() { return &arena_; }
-  virtual RangeDelAggregator* GetRangeDelAggregator();
 
   // Set the DB Iterator to be wrapped
 

db/db_iterator_test.cc

@@ -7,13 +7,11 @@
 // 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"
 #include "rocksdb/iostats_context.h"
 #include "rocksdb/perf_context.h"
+#include "port/port.h"
 
 namespace rocksdb {
 
@@ -1700,14 +1698,13 @@ TEST_F(DBIteratorTest, IteratorWithLocalStatistics) {
     t.join();
   }
 
-  ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_NEXT), (uint64_t)total_next);
+  ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_NEXT), total_next);
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_NEXT_FOUND),
-            (uint64_t)total_next_found);
-  ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_PREV), (uint64_t)total_prev);
+            total_next_found);
+  ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_PREV), total_prev);
   ASSERT_EQ(TestGetTickerCount(options, NUMBER_DB_PREV_FOUND),
-            (uint64_t)total_prev_found);
-  ASSERT_EQ(TestGetTickerCount(options, ITER_BYTES_READ), (uint64_t)total_bytes);
-
+            total_prev_found);
+  ASSERT_EQ(TestGetTickerCount(options, ITER_BYTES_READ), total_bytes);
 }
 
 TEST_F(DBIteratorTest, ReadAhead) {
@@ -1780,62 +1777,6 @@ TEST_F(DBIteratorTest, ReadAhead) {
   delete iter;
 }
 
-// Insert a key, create a snapshot iterator, overwrite key lots of times,
-// seek to a smaller key. Expect DBIter to fall back to a seek instead of
-// going through all the overwrites linearly.
-TEST_F(DBIteratorTest, DBIteratorSkipRecentDuplicatesTest) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.max_sequential_skip_in_iterations = 3;
-  options.prefix_extractor = nullptr;
-  options.write_buffer_size = 1 << 27;  // big enough to avoid flush
-  options.statistics = rocksdb::CreateDBStatistics();
-  DestroyAndReopen(options);
-
-  // Insert.
-  ASSERT_OK(Put("b", "0"));
-
-  // Create iterator.
-  ReadOptions ro;
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
-
-  // Insert a lot.
-  for (int i = 0; i < 100; ++i) {
-    ASSERT_OK(Put("b", std::to_string(i + 1).c_str()));
-  }
-
-#ifndef ROCKSDB_LITE
-  // Check that memtable wasn't flushed.
-  std::string val;
-  ASSERT_TRUE(db_->GetProperty("rocksdb.num-files-at-level0", &val));
-  EXPECT_EQ("0", val);
-#endif
-
-  // Seek iterator to a smaller key.
-  perf_context.Reset();
-  iter->Seek("a");
-  ASSERT_TRUE(iter->Valid());
-  EXPECT_EQ("b", iter->key().ToString());
-  EXPECT_EQ("0", iter->value().ToString());
-
-  // Check that the seek didn't do too much work.
-  // Checks are not tight, just make sure that everything is well below 100.
-  EXPECT_LT(perf_context.internal_key_skipped_count, 4);
-  EXPECT_LT(perf_context.internal_recent_skipped_count, 8);
-  EXPECT_LT(perf_context.seek_on_memtable_count, 10);
-  EXPECT_LT(perf_context.next_on_memtable_count, 10);
-  EXPECT_LT(perf_context.prev_on_memtable_count, 10);
-
-  // Check that iterator did something like what we expect.
-  EXPECT_EQ(perf_context.internal_delete_skipped_count, 0);
-  EXPECT_EQ(perf_context.internal_merge_count, 0);
-  EXPECT_GE(perf_context.internal_recent_skipped_count, 2);
-  EXPECT_GE(perf_context.seek_on_memtable_count, 2);
-  EXPECT_EQ(1, options.statistics->getTickerCount(
-                 NUMBER_OF_RESEEKS_IN_ITERATION));
-}
-
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_memtable_test.cc

@@ -1,163 +0,0 @@
-//  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 <memory>
-#include <string>
-
-#include "db/db_test_util.h"
-#include "db/memtable.h"
-#include "port/stack_trace.h"
-#include "rocksdb/memtablerep.h"
-#include "rocksdb/slice_transform.h"
-
-namespace rocksdb {
-
-class DBMemTableTest : public DBTestBase {
- public:
-  DBMemTableTest() : DBTestBase("/db_memtable_test") {}
-};
-
-class MockMemTableRep : public MemTableRep {
- public:
-  explicit MockMemTableRep(MemTableAllocator* allocator, MemTableRep* rep)
-      : MemTableRep(allocator), rep_(rep), num_insert_with_hint_(0) {}
-
-  virtual KeyHandle Allocate(const size_t len, char** buf) override {
-    return rep_->Allocate(len, buf);
-  }
-
-  virtual void Insert(KeyHandle handle) override {
-    return rep_->Insert(handle);
-  }
-
-  virtual void InsertWithHint(KeyHandle handle, void** hint) override {
-    num_insert_with_hint_++;
-    ASSERT_NE(nullptr, hint);
-    last_hint_in_ = *hint;
-    rep_->InsertWithHint(handle, hint);
-    last_hint_out_ = *hint;
-  }
-
-  virtual bool Contains(const char* key) const override {
-    return rep_->Contains(key);
-  }
-
-  virtual void Get(const LookupKey& k, void* callback_args,
-                   bool (*callback_func)(void* arg,
-                                         const char* entry)) override {
-    rep_->Get(k, callback_args, callback_func);
-  }
-
-  virtual size_t ApproximateMemoryUsage() override {
-    return rep_->ApproximateMemoryUsage();
-  }
-
-  virtual Iterator* GetIterator(Arena* arena) override {
-    return rep_->GetIterator(arena);
-  }
-
-  void* last_hint_in() { return last_hint_in_; }
-  void* last_hint_out() { return last_hint_out_; }
-  int num_insert_with_hint() { return num_insert_with_hint_; }
-
- private:
-  std::unique_ptr<MemTableRep> rep_;
-  void* last_hint_in_;
-  void* last_hint_out_;
-  int num_insert_with_hint_;
-};
-
-class MockMemTableRepFactory : public MemTableRepFactory {
- public:
-  virtual MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator& cmp,
-                                         MemTableAllocator* allocator,
-                                         const SliceTransform* transform,
-                                         Logger* logger) override {
-    SkipListFactory factory;
-    MemTableRep* skiplist_rep =
-        factory.CreateMemTableRep(cmp, allocator, transform, logger);
-    mock_rep_ = new MockMemTableRep(allocator, skiplist_rep);
-    return mock_rep_;
-  }
-
-  virtual const char* Name() const override { return "MockMemTableRepFactory"; }
-
-  MockMemTableRep* rep() { return mock_rep_; }
-
-  bool IsInsertConcurrentlySupported() const override { return false; }
-
- private:
-  MockMemTableRep* mock_rep_;
-};
-
-class TestPrefixExtractor : public SliceTransform {
- public:
-  virtual const char* Name() const override { return "TestPrefixExtractor"; }
-
-  virtual Slice Transform(const Slice& key) const override {
-    const char* p = separator(key);
-    if (p == nullptr) {
-      return Slice();
-    }
-    return Slice(key.data(), p - key.data() + 1);
-  }
-
-  virtual bool InDomain(const Slice& key) const override {
-    return separator(key) != nullptr;
-  }
-
-  virtual bool InRange(const Slice& key) const override { return false; }
-
- private:
-  const char* separator(const Slice& key) const {
-    return reinterpret_cast<const char*>(memchr(key.data(), '_', key.size()));
-  }
-};
-
-TEST_F(DBMemTableTest, InsertWithHint) {
-  Options options;
-  options.allow_concurrent_memtable_write = false;
-  options.create_if_missing = true;
-  options.memtable_factory.reset(new MockMemTableRepFactory());
-  options.memtable_insert_with_hint_prefix_extractor.reset(
-      new TestPrefixExtractor());
-  Reopen(options);
-  MockMemTableRep* rep =
-      reinterpret_cast<MockMemTableRepFactory*>(options.memtable_factory.get())
-          ->rep();
-  ASSERT_OK(Put("foo_k1", "foo_v1"));
-  ASSERT_EQ(nullptr, rep->last_hint_in());
-  void* hint_foo = rep->last_hint_out();
-  ASSERT_OK(Put("foo_k2", "foo_v2"));
-  ASSERT_EQ(hint_foo, rep->last_hint_in());
-  ASSERT_EQ(hint_foo, rep->last_hint_out());
-  ASSERT_OK(Put("foo_k3", "foo_v3"));
-  ASSERT_EQ(hint_foo, rep->last_hint_in());
-  ASSERT_EQ(hint_foo, rep->last_hint_out());
-  ASSERT_OK(Put("bar_k1", "bar_v1"));
-  ASSERT_EQ(nullptr, rep->last_hint_in());
-  void* hint_bar = rep->last_hint_out();
-  ASSERT_NE(hint_foo, hint_bar);
-  ASSERT_OK(Put("bar_k2", "bar_v2"));
-  ASSERT_EQ(hint_bar, rep->last_hint_in());
-  ASSERT_EQ(hint_bar, rep->last_hint_out());
-  ASSERT_EQ(5, rep->num_insert_with_hint());
-  ASSERT_OK(Put("whitelisted", "vvv"));
-  ASSERT_EQ(5, rep->num_insert_with_hint());
-  ASSERT_EQ("foo_v1", Get("foo_k1"));
-  ASSERT_EQ("foo_v2", Get("foo_k2"));
-  ASSERT_EQ("foo_v3", Get("foo_k3"));
-  ASSERT_EQ("bar_v1", Get("bar_k1"));
-  ASSERT_EQ("bar_v2", Get("bar_k2"));
-  ASSERT_EQ("vvv", Get("whitelisted"));
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/db_merge_operator_test.cc

@@ -1,98 +0,0 @@
-//  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 <string>
-#include <vector>
-
-#include "db/db_test_util.h"
-#include "db/forward_iterator.h"
-#include "port/stack_trace.h"
-#include "utilities/merge_operators.h"
-
-namespace rocksdb {
-
-// Test merge operator functionality.
-class DBMergeOperatorTest : public DBTestBase {
- public:
-  DBMergeOperatorTest() : DBTestBase("/db_merge_operator_test") {}
-};
-
-// A test merge operator mimics put but also fails if one of merge operands is
-// "corrupted".
-class TestPutOperator : public MergeOperator {
- public:
-  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
-                           MergeOperationOutput* merge_out) const override {
-    if (merge_in.existing_value != nullptr &&
-        *(merge_in.existing_value) == "corrupted") {
-      return false;
-    }
-    for (auto value : merge_in.operand_list) {
-      if (value == "corrupted") {
-        return false;
-      }
-    }
-    merge_out->existing_operand = merge_in.operand_list.back();
-    return true;
-  }
-
-  virtual const char* Name() const override { return "TestPutOperator"; }
-};
-
-TEST_F(DBMergeOperatorTest, MergeErrorOnRead) {
-  Options options;
-  options.create_if_missing = true;
-  options.merge_operator.reset(new TestPutOperator());
-  Reopen(options);
-  ASSERT_OK(Merge("k1", "v1"));
-  ASSERT_OK(Merge("k1", "corrupted"));
-  std::string value;
-  ASSERT_TRUE(db_->Get(ReadOptions(), "k1", &value).IsCorruption());
-  VerifyDBInternal({{"k1", "corrupted"}, {"k1", "v1"}});
-}
-
-TEST_F(DBMergeOperatorTest, MergeErrorOnWrite) {
-  Options options;
-  options.create_if_missing = true;
-  options.merge_operator.reset(new TestPutOperator());
-  options.max_successive_merges = 3;
-  Reopen(options);
-  ASSERT_OK(Merge("k1", "v1"));
-  ASSERT_OK(Merge("k1", "v2"));
-  // Will trigger a merge when hitting max_successive_merges and the merge
-  // will fail. The delta will be inserted nevertheless.
-  ASSERT_OK(Merge("k1", "corrupted"));
-  // Data should stay unmerged after the error.
-  VerifyDBInternal({{"k1", "corrupted"}, {"k1", "v2"}, {"k1", "v1"}});
-}
-
-TEST_F(DBMergeOperatorTest, MergeErrorOnIteration) {
-  Options options;
-  options.create_if_missing = true;
-  options.merge_operator.reset(new TestPutOperator());
-
-  DestroyAndReopen(options);
-  ASSERT_OK(Merge("k1", "v1"));
-  ASSERT_OK(Merge("k1", "corrupted"));
-  ASSERT_OK(Put("k2", "v2"));
-  VerifyDBFromMap({{"k1", ""}, {"k2", "v2"}}, nullptr, false,
-                  {{"k1", Status::Corruption()}});
-  VerifyDBInternal({{"k1", "corrupted"}, {"k1", "v1"}, {"k2", "v2"}});
-
-  DestroyAndReopen(options);
-  ASSERT_OK(Merge("k1", "v1"));
-  ASSERT_OK(Put("k2", "v2"));
-  ASSERT_OK(Merge("k2", "corrupted"));
-  VerifyDBFromMap({{"k1", "v1"}, {"k2", ""}}, nullptr, false,
-                  {{"k2", Status::Corruption()}});
-  VerifyDBInternal({{"k1", "v1"}, {"k2", "corrupted"}, {"k2", "v2"}});
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/db_options_test.cc

@@ -64,7 +64,7 @@ class DBOptionsTest : public DBTestBase {
     Options options;
     ImmutableDBOptions db_options(options);
     test::RandomInitCFOptions(&options, rnd);
-    auto sanitized_options = SanitizeOptions(db_options, options);
+    auto sanitized_options = SanitizeOptions(db_options, nullptr, options);
     auto opt_map = GetMutableCFOptionsMap(sanitized_options);
     delete options.compaction_filter;
     return opt_map;
@@ -256,107 +256,6 @@ TEST_F(DBOptionsTest, SetBackgroundCompactionThreads) {
   ASSERT_EQ(3, dbfull()->TEST_BGCompactionsAllowed());
 }
 
-TEST_F(DBOptionsTest, AvoidFlushDuringShutdown) {
-  Options options;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  WriteOptions write_without_wal;
-  write_without_wal.disableWAL = true;
-
-  ASSERT_FALSE(options.avoid_flush_during_shutdown);
-  DestroyAndReopen(options);
-  ASSERT_OK(Put("foo", "v1", write_without_wal));
-  Reopen(options);
-  ASSERT_EQ("v1", Get("foo"));
-  ASSERT_EQ("1", FilesPerLevel());
-
-  DestroyAndReopen(options);
-  ASSERT_OK(Put("foo", "v2", write_without_wal));
-  ASSERT_OK(dbfull()->SetDBOptions({{"avoid_flush_during_shutdown", "true"}}));
-  Reopen(options);
-  ASSERT_EQ("NOT_FOUND", Get("foo"));
-  ASSERT_EQ("", FilesPerLevel());
-}
-
-TEST_F(DBOptionsTest, SetDelayedWriteRateOption) {
-  Options options;
-  options.create_if_missing = true;
-  options.delayed_write_rate = 2 * 1024U * 1024U;
-  Reopen(options);
-  ASSERT_EQ(2 * 1024U * 1024U, dbfull()->TEST_write_controler().max_delayed_write_rate());
-
-  ASSERT_OK(dbfull()->SetDBOptions({{"delayed_write_rate", "20000"}}));
-  ASSERT_EQ(20000, dbfull()->TEST_write_controler().max_delayed_write_rate());
-}
-
-TEST_F(DBOptionsTest, MaxTotalWalSizeChange) {
-  Random rnd(1044);
-  const auto value_size = size_t(1024);
-  std::string value;
-  test::RandomString(&rnd, value_size, &value);
-
-  Options options;
-  options.create_if_missing = true;
-  CreateColumnFamilies({"1", "2", "3"}, options);
-  ReopenWithColumnFamilies({"default", "1", "2", "3"}, options);
-
-  WriteOptions write_options;
-
-  const int key_count = 100;
-  for (int i = 0; i < key_count; ++i) {
-    for (size_t cf = 0; cf < handles_.size(); ++cf) {
-      ASSERT_OK(Put(static_cast<int>(cf), Key(i), value));
-    }
-  }
-  ASSERT_OK(dbfull()->SetDBOptions({{"max_total_wal_size", "10"}}));
-
-  for (size_t cf = 0; cf < handles_.size(); ++cf) {
-    dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
-    ASSERT_EQ("1", FilesPerLevel(static_cast<int>(cf)));
-  }
-}
-
-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

db/db_properties_test.cc

@@ -34,7 +34,6 @@ TEST_F(DBPropertiesTest, Empty) {
     Options options;
     options.env = env_;
     options.write_buffer_size = 100000;  // Small write buffer
-    options.allow_concurrent_memtable_write = false;
     options = CurrentOptions(options);
     CreateAndReopenWithCF({"pikachu"}, options);
 
@@ -492,7 +491,6 @@ TEST_F(DBPropertiesTest, NumImmutableMemTable) {
 
     std::string big_value(1000000 * 2, 'x');
     std::string num;
-    uint64_t value;
     SetPerfLevel(kEnableTime);
     ASSERT_TRUE(GetPerfLevel() == kEnableTime);
 
@@ -557,11 +555,11 @@ TEST_F(DBPropertiesTest, NumImmutableMemTable) {
     ASSERT_TRUE(dbfull()->GetProperty(
         handles_[1], DB::Properties::kNumImmutableMemTableFlushed, &num));
     ASSERT_EQ(num, "3");
-    ASSERT_TRUE(dbfull()->GetIntProperty(
-        handles_[1], "rocksdb.cur-size-active-mem-table", &value));
-    // "192" is the size of the metadata of two empty skiplists, this would
+    ASSERT_TRUE(dbfull()->GetProperty(
+        handles_[1], "rocksdb.cur-size-active-mem-table", &num));
+    // "384" is the size of the metadata of two empty skiplists, this would
     // break if we change the default skiplist implementation
-    ASSERT_GE(value, 192);
+    ASSERT_EQ(num, "384");
 
     uint64_t int_num;
     uint64_t base_total_size;

db/db_range_del_test.cc

@@ -1,717 +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 "db/db_test_util.h"
-#include "port/stack_trace.h"
-#include "util/testutil.h"
-#include "utilities/merge_operators.h"
-
-namespace rocksdb {
-
-class DBRangeDelTest : public DBTestBase {
- public:
-  DBRangeDelTest() : DBTestBase("/db_range_del_test") {}
-
-  std::string GetNumericStr(int key) {
-    uint64_t uint64_key = static_cast<uint64_t>(key);
-    std::string str;
-    str.resize(8);
-    memcpy(&str[0], static_cast<void*>(&uint64_key), 8);
-    return str;
-  }
-};
-
-// PlainTableFactory and NumTableFilesAtLevel() are not supported in
-// ROCKSDB_LITE
-#ifndef ROCKSDB_LITE
-TEST_F(DBRangeDelTest, NonBlockBasedTableNotSupported) {
-  Options opts = CurrentOptions();
-  opts.table_factory.reset(new PlainTableFactory());
-  opts.prefix_extractor.reset(NewNoopTransform());
-  opts.allow_mmap_reads = true;
-  opts.max_sequential_skip_in_iterations = 999999;
-  Reopen(opts);
-
-  ASSERT_TRUE(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "dr1", "dr1")
-          .IsNotSupported());
-}
-
-TEST_F(DBRangeDelTest, FlushOutputHasOnlyRangeTombstones) {
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "dr1",
-                             "dr2"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-}
-
-TEST_F(DBRangeDelTest, CompactionOutputHasOnlyRangeTombstone) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  opts.statistics = CreateDBStatistics();
-  Reopen(opts);
-
-  // snapshot protects range tombstone from dropping due to becoming obsolete.
-  const Snapshot* snapshot = db_->GetSnapshot();
-  db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "z");
-  db_->Flush(FlushOptions());
-
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-  ASSERT_EQ(0, NumTableFilesAtLevel(1));
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
-                              true /* disallow_trivial_move */);
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_EQ(1, NumTableFilesAtLevel(1));
-  ASSERT_EQ(0, TestGetTickerCount(opts, COMPACTION_RANGE_DEL_DROP_OBSOLETE));
-  db_->ReleaseSnapshot(snapshot);
-}
-
-TEST_F(DBRangeDelTest, CompactionOutputFilesExactlyFilled) {
-  // regression test for exactly filled compaction output files. Previously
-  // another file would be generated containing all range deletions, which
-  // could invalidate the non-overlapping file boundary invariant.
-  const int kNumPerFile = 4, kNumFiles = 2, kFileBytes = 9 << 10;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.level0_file_num_compaction_trigger = kNumFiles;
-  options.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  options.num_levels = 2;
-  options.target_file_size_base = kFileBytes;
-  BlockBasedTableOptions table_options;
-  table_options.block_size_deviation = 50;  // each block holds two keys
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  Reopen(options);
-
-  // snapshot protects range tombstone from dropping due to becoming obsolete.
-  const Snapshot* snapshot = db_->GetSnapshot();
-  db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), Key(0), Key(1));
-
-  Random rnd(301);
-  for (int i = 0; i < kNumFiles; ++i) {
-    std::vector<std::string> values;
-    // Write 12K (4 values, each 3K)
-    for (int j = 0; j < kNumPerFile; j++) {
-      values.push_back(RandomString(&rnd, 3 << 10));
-      ASSERT_OK(Put(Key(i * kNumPerFile + j), values[j]));
-      if (j == 0 && i > 0) {
-        dbfull()->TEST_WaitForFlushMemTable();
-      }
-    }
-  }
-  // put extra key to trigger final flush
-  ASSERT_OK(Put("", ""));
-  dbfull()->TEST_WaitForFlushMemTable();
-  ASSERT_EQ(kNumFiles, NumTableFilesAtLevel(0));
-  ASSERT_EQ(0, NumTableFilesAtLevel(1));
-
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
-                              true /* disallow_trivial_move */);
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_EQ(2, NumTableFilesAtLevel(1));
-  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(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "c"));
-  db_->Put(WriteOptions(), "b2", "val");
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "b"));
-  // first iteration verifies query correctness in memtable, second verifies
-  // query correctness for a single SST file
-  for (int i = 0; i < 2; ++i) {
-    if (i > 0) {
-      ASSERT_OK(db_->Flush(FlushOptions()));
-      ASSERT_EQ(1, NumTableFilesAtLevel(0));
-    }
-    std::string value;
-    ASSERT_TRUE(db_->Get(ReadOptions(), "b1", &value).IsNotFound());
-    ASSERT_OK(db_->Get(ReadOptions(), "b2", &value));
-  }
-}
-
-TEST_F(DBRangeDelTest, CompactRangeDelsSameStartKey) {
-  db_->Put(WriteOptions(), "unused", "val");  // prevents empty after compaction
-  db_->Put(WriteOptions(), "b1", "val");
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "c"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_OK(
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "a", "b"));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_EQ(3, NumTableFilesAtLevel(0));
-
-  for (int i = 0; i < 2; ++i) {
-    if (i > 0) {
-      dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr,
-                                  true /* disallow_trivial_move */);
-      ASSERT_EQ(0, NumTableFilesAtLevel(0));
-      ASSERT_EQ(1, NumTableFilesAtLevel(1));
-    }
-    std::string value;
-    ASSERT_TRUE(db_->Get(ReadOptions(), "b1", &value).IsNotFound());
-  }
-}
-#endif  // ROCKSDB_LITE
-
-TEST_F(DBRangeDelTest, FlushRemovesCoveredKeys) {
-  const int kNum = 300, kRangeBegin = 50, kRangeEnd = 250;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  Reopen(opts);
-
-  // Write a third before snapshot, a third between snapshot and tombstone, and
-  // a third after the tombstone. Keys older than snapshot or newer than the
-  // tombstone should be preserved.
-  const Snapshot* snapshot = nullptr;
-  for (int i = 0; i < kNum; ++i) {
-    if (i == kNum / 3) {
-      snapshot = db_->GetSnapshot();
-    } else if (i == 2 * kNum / 3) {
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                       GetNumericStr(kRangeBegin), GetNumericStr(kRangeEnd));
-    }
-    db_->Put(WriteOptions(), GetNumericStr(i), "val");
-  }
-  db_->Flush(FlushOptions());
-
-  for (int i = 0; i < kNum; ++i) {
-    ReadOptions read_opts;
-    read_opts.ignore_range_deletions = true;
-    std::string value;
-    if (i < kRangeBegin || i > kRangeEnd || i < kNum / 3 || i >= 2 * kNum / 3) {
-      ASSERT_OK(db_->Get(read_opts, GetNumericStr(i), &value));
-    } else {
-      ASSERT_TRUE(db_->Get(read_opts, GetNumericStr(i), &value).IsNotFound());
-    }
-  }
-  db_->ReleaseSnapshot(snapshot);
-}
-
-// NumTableFilesAtLevel() is not supported in ROCKSDB_LITE
-#ifndef ROCKSDB_LITE
-TEST_F(DBRangeDelTest, CompactionRemovesCoveredKeys) {
-  const int kNumPerFile = 100, kNumFiles = 4;
-  Options opts = CurrentOptions();
-  opts.comparator = test::Uint64Comparator();
-  opts.disable_auto_compactions = true;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  opts.num_levels = 2;
-  opts.statistics = CreateDBStatistics();
-  Reopen(opts);
-
-  for (int i = 0; i < kNumFiles; ++i) {
-    if (i > 0) {
-      // range tombstone covers first half of the previous file
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                       GetNumericStr((i - 1) * kNumPerFile),
-                       GetNumericStr((i - 1) * kNumPerFile + kNumPerFile / 2));
-    }
-    // Make sure a given key appears in each file so compaction won't be able to
-    // use trivial move, which would happen if the ranges were non-overlapping.
-    // Also, we need an extra element since flush is only triggered when the
-    // number of keys is one greater than SpecialSkipListFactory's limit.
-    // We choose a key outside the key-range used by the test to avoid conflict.
-    db_->Put(WriteOptions(), GetNumericStr(kNumPerFile * kNumFiles), "val");
-
-    for (int j = 0; j < kNumPerFile; ++j) {
-      db_->Put(WriteOptions(), GetNumericStr(i * kNumPerFile + j), "val");
-    }
-    dbfull()->TEST_WaitForFlushMemTable();
-    ASSERT_EQ(i + 1, NumTableFilesAtLevel(0));
-  }
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_GT(NumTableFilesAtLevel(1), 0);
-  ASSERT_EQ((kNumFiles - 1) * kNumPerFile / 2,
-            TestGetTickerCount(opts, COMPACTION_KEY_DROP_RANGE_DEL));
-
-  for (int i = 0; i < kNumFiles; ++i) {
-    for (int j = 0; j < kNumPerFile; ++j) {
-      ReadOptions read_opts;
-      read_opts.ignore_range_deletions = true;
-      std::string value;
-      if (i == kNumFiles - 1 || j >= kNumPerFile / 2) {
-        ASSERT_OK(
-            db_->Get(read_opts, GetNumericStr(i * kNumPerFile + j), &value));
-      } else {
-        ASSERT_TRUE(
-            db_->Get(read_opts, GetNumericStr(i * kNumPerFile + j), &value)
-                .IsNotFound());
-      }
-    }
-  }
-}
-
-TEST_F(DBRangeDelTest, ValidLevelSubcompactionBoundaries) {
-  const int kNumPerFile = 100, kNumFiles = 4, kFileBytes = 100 << 10;
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = kNumFiles;
-  options.max_bytes_for_level_base = 2 * kFileBytes;
-  options.max_subcompactions = 4;
-  options.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  options.num_levels = 3;
-  options.target_file_size_base = kFileBytes;
-  options.target_file_size_multiplier = 1;
-  Reopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < kNumFiles; ++j) {
-      if (i > 0) {
-        // delete [95,105) in two files, [295,305) in next two
-        int mid = (j + (1 - j % 2)) * kNumPerFile;
-        db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                         Key(mid - 5), Key(mid + 5));
-      }
-      std::vector<std::string> values;
-      // Write 100KB (100 values, each 1K)
-      for (int k = 0; k < kNumPerFile; k++) {
-        values.push_back(RandomString(&rnd, 990));
-        ASSERT_OK(Put(Key(j * kNumPerFile + k), values[k]));
-      }
-      // put extra key to trigger flush
-      ASSERT_OK(Put("", ""));
-      dbfull()->TEST_WaitForFlushMemTable();
-      if (j < kNumFiles - 1) {
-        // background compaction may happen early for kNumFiles'th file
-        ASSERT_EQ(NumTableFilesAtLevel(0), j + 1);
-      }
-      if (j == options.level0_file_num_compaction_trigger - 1) {
-        // When i == 1, compaction will output some files to L1, at which point
-        // L1 is not bottommost so range deletions cannot be compacted away. The
-        // new L1 files must be generated with non-overlapping key ranges even
-        // though multiple subcompactions see the same ranges deleted, else an
-        // assertion will fail.
-        dbfull()->TEST_WaitForCompact();
-        ASSERT_EQ(NumTableFilesAtLevel(0), 0);
-        ASSERT_GT(NumTableFilesAtLevel(1), 0);
-        ASSERT_GT(NumTableFilesAtLevel(2), 0);
-      }
-    }
-  }
-}
-
-TEST_F(DBRangeDelTest, ValidUniversalSubcompactionBoundaries) {
-  const int kNumPerFile = 100, kFilesPerLevel = 4, kNumLevels = 4;
-  Options options = CurrentOptions();
-  options.compaction_options_universal.min_merge_width = kFilesPerLevel;
-  options.compaction_options_universal.max_merge_width = kFilesPerLevel;
-  options.compaction_options_universal.size_ratio = 10;
-  options.compaction_style = kCompactionStyleUniversal;
-  options.level0_file_num_compaction_trigger = kFilesPerLevel;
-  options.max_subcompactions = 4;
-  options.memtable_factory.reset(new SpecialSkipListFactory(kNumPerFile));
-  options.num_levels = kNumLevels;
-  options.target_file_size_base = kNumPerFile << 10;
-  options.target_file_size_multiplier = 1;
-  Reopen(options);
-
-  Random rnd(301);
-  for (int i = 0; i < kNumLevels - 1; ++i) {
-    for (int j = 0; j < kFilesPerLevel; ++j) {
-      if (i == kNumLevels - 2) {
-        // insert range deletions [95,105) in two files, [295,305) in next two
-        // to prepare L1 for later manual compaction.
-        int mid = (j + (1 - j % 2)) * kNumPerFile;
-        db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                         Key(mid - 5), Key(mid + 5));
-      }
-      std::vector<std::string> values;
-      // Write 100KB (100 values, each 1K)
-      for (int k = 0; k < kNumPerFile; k++) {
-        values.push_back(RandomString(&rnd, 990));
-        ASSERT_OK(Put(Key(j * kNumPerFile + k), values[k]));
-      }
-      // put extra key to trigger flush
-      ASSERT_OK(Put("", ""));
-      dbfull()->TEST_WaitForFlushMemTable();
-      if (j < kFilesPerLevel - 1) {
-        // background compaction may happen early for kFilesPerLevel'th file
-        ASSERT_EQ(NumTableFilesAtLevel(0), j + 1);
-      }
-    }
-    dbfull()->TEST_WaitForCompact();
-    ASSERT_EQ(NumTableFilesAtLevel(0), 0);
-    ASSERT_GT(NumTableFilesAtLevel(kNumLevels - 1 - i), kFilesPerLevel - 1);
-  }
-  // Now L1-L3 are full, when we compact L1->L2 we should see (1) subcompactions
-  // happen since input level > 0; (2) range deletions are not dropped since
-  // output level is not bottommost. If no file boundary assertion fails, that
-  // probably means universal compaction + subcompaction + range deletion are
-  // compatible.
-  ASSERT_OK(dbfull()->RunManualCompaction(
-      reinterpret_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
-          ->cfd(),
-      1 /* input_level */, 2 /* output_level */, 0 /* output_path_id */,
-      nullptr /* begin */, nullptr /* end */, true /* exclusive */,
-      true /* disallow_trivial_move */));
-}
-#endif  // ROCKSDB_LITE
-
-TEST_F(DBRangeDelTest, CompactionRemovesCoveredMergeOperands) {
-  const int kNumPerFile = 3, kNumFiles = 3;
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  opts.memtable_factory.reset(new SpecialSkipListFactory(2 * kNumPerFile));
-  opts.merge_operator = MergeOperators::CreateUInt64AddOperator();
-  opts.num_levels = 2;
-  Reopen(opts);
-
-  // Iterates kNumFiles * kNumPerFile + 1 times since flushing the last file
-  // requires an extra entry.
-  for (int i = 0; i <= kNumFiles * kNumPerFile; ++i) {
-    if (i % kNumPerFile == 0 && i / kNumPerFile == kNumFiles - 1) {
-      // Delete merge operands from all but the last file
-      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "key",
-                       "key_");
-    }
-    std::string val;
-    PutFixed64(&val, i);
-    db_->Merge(WriteOptions(), "key", val);
-    // we need to prevent trivial move using Puts so compaction will actually
-    // process the merge operands.
-    db_->Put(WriteOptions(), "prevent_trivial_move", "");
-    if (i > 0 && i % kNumPerFile == 0) {
-      dbfull()->TEST_WaitForFlushMemTable();
-    }
-  }
-
-  ReadOptions read_opts;
-  read_opts.ignore_range_deletions = true;
-  std::string expected, actual;
-  ASSERT_OK(db_->Get(read_opts, "key", &actual));
-  PutFixed64(&expected, 45);  // 1+2+...+9
-  ASSERT_EQ(expected, actual);
-
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  expected.clear();
-  ASSERT_OK(db_->Get(read_opts, "key", &actual));
-  uint64_t tmp;
-  Slice tmp2(actual);
-  GetFixed64(&tmp2, &tmp);
-  PutFixed64(&expected, 30);  // 6+7+8+9 (earlier operands covered by tombstone)
-  ASSERT_EQ(expected, actual);
-}
-
-// NumTableFilesAtLevel() is not supported in ROCKSDB_LITE
-#ifndef ROCKSDB_LITE
-TEST_F(DBRangeDelTest, ObsoleteTombstoneCleanup) {
-  // During compaction to bottommost level, verify range tombstones older than
-  // the oldest snapshot are removed, while others are preserved.
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  opts.num_levels = 2;
-  opts.statistics = CreateDBStatistics();
-  Reopen(opts);
-
-  db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "dr1",
-                   "dr1");  // obsolete after compaction
-  db_->Put(WriteOptions(), "key", "val");
-  db_->Flush(FlushOptions());
-  const Snapshot* snapshot = db_->GetSnapshot();
-  db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), "dr2",
-                   "dr2");  // protected by snapshot
-  db_->Put(WriteOptions(), "key", "val");
-  db_->Flush(FlushOptions());
-
-  ASSERT_EQ(2, NumTableFilesAtLevel(0));
-  ASSERT_EQ(0, NumTableFilesAtLevel(1));
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  ASSERT_EQ(1, NumTableFilesAtLevel(1));
-  ASSERT_EQ(1, TestGetTickerCount(opts, COMPACTION_RANGE_DEL_DROP_OBSOLETE));
-
-  db_->ReleaseSnapshot(snapshot);
-}
-#endif  // ROCKSDB_LITE
-
-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);
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/db_sst_test.cc

@@ -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({
@@ -296,31 +299,8 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DeleteScheduler::BackgroundEmptyTrash:Wait",
       [&](void* arg) { penalties.push_back(*(static_cast<int*>(arg))); });
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        // Turn timed wait into a simulated sleep
-        uint64_t* abs_time_us = static_cast<uint64_t*>(arg);
-        int64_t cur_time = 0;
-        env_->GetCurrentTime(&cur_time);
-        if (*abs_time_us > static_cast<uint64_t>(cur_time)) {
-          env_->addon_time_.fetch_add(*abs_time_us -
-                                      static_cast<uint64_t>(cur_time));
-        }
-
-        // Randomly sleep shortly
-        env_->addon_time_.fetch_add(
-            static_cast<uint64_t>(Random::GetTLSInstance()->Uniform(10)));
-
-        // Set wait until time to before current to force not to sleep.
-        int64_t real_cur_time = 0;
-        Env::Default()->GetCurrentTime(&real_cur_time);
-        *abs_time_us = static_cast<uint64_t>(real_cur_time);
-      });
-
   rocksdb::SyncPoint::GetInstance()->EnableProcessing();
 
-  env_->no_slowdown_ = true;
-  env_->time_elapse_only_sleep_ = true;
   Options options = CurrentOptions();
   options.disable_auto_compactions = true;
   options.env = env_;
@@ -368,7 +348,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
     ASSERT_EQ(expected_penlty, penalties[i]);
   }
   ASSERT_GT(time_spent_deleting, expected_penlty * 0.9);
-  ASSERT_LT(time_spent_deleting, expected_penlty * 1.1);
 
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
@@ -479,6 +458,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 +556,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

db/db_tailing_iter_test.cc

@@ -305,7 +305,6 @@ TEST_F(DBTestTailingIterator, TailingIteratorPrefixSeek) {
   options.disable_auto_compactions = true;
   options.prefix_extractor.reset(NewFixedPrefixTransform(2));
   options.memtable_factory.reset(NewHashSkipListRepFactory(16));
-  options.allow_concurrent_memtable_write = false;
   DestroyAndReopen(options);
   CreateAndReopenWithCF({"pikachu"}, options);
 
@@ -429,59 +428,6 @@ TEST_F(DBTestTailingIterator, TailingIteratorUpperBound) {
   ASSERT_EQ(0, immutable_seeks);
 }
 
-TEST_F(DBTestTailingIterator, TailingIteratorGap) {
-  // level 1:            [20, 25]  [35, 40]
-  // level 2:  [10 - 15]                    [45 - 50]
-  // level 3:            [20,    30,    40]
-  // Previously there is a bug in tailing_iterator that if there is a gap in
-  // lower level, the key will be skipped if it is within the range between
-  // the largest key of index n file and the smallest key of index n+1 file
-  // if both file fit in that gap. In this example, 25 < key < 35
-  // https://github.com/facebook/rocksdb/issues/1372
-  CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-
-  ReadOptions read_options;
-  read_options.tailing = true;
-
-  ASSERT_OK(Put(1, "20", "20"));
-  ASSERT_OK(Put(1, "30", "30"));
-  ASSERT_OK(Put(1, "40", "40"));
-  ASSERT_OK(Flush(1));
-  MoveFilesToLevel(3, 1);
-
-  ASSERT_OK(Put(1, "10", "10"));
-  ASSERT_OK(Put(1, "15", "15"));
-  ASSERT_OK(Flush(1));
-  ASSERT_OK(Put(1, "45", "45"));
-  ASSERT_OK(Put(1, "50", "50"));
-  ASSERT_OK(Flush(1));
-  MoveFilesToLevel(2, 1);
-
-  ASSERT_OK(Put(1, "20", "20"));
-  ASSERT_OK(Put(1, "25", "25"));
-  ASSERT_OK(Flush(1));
-  ASSERT_OK(Put(1, "35", "35"));
-  ASSERT_OK(Put(1, "40", "40"));
-  ASSERT_OK(Flush(1));
-  MoveFilesToLevel(1, 1);
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(handles_[1], &meta);
-
-  std::unique_ptr<Iterator> it(db_->NewIterator(read_options, handles_[1]));
-  it->Seek("30");
-  ASSERT_TRUE(it->Valid());
-  ASSERT_EQ("30", it->key().ToString());
-
-  it->Next();
-  ASSERT_TRUE(it->Valid());
-  ASSERT_EQ("35", it->key().ToString());
-
-  it->Next();
-  ASSERT_TRUE(it->Valid());
-  ASSERT_EQ("40", it->key().ToString());
-}
-
 TEST_F(DBTestTailingIterator, ManagedTailingIteratorSingle) {
   ReadOptions read_options;
   read_options.tailing = true;
@@ -626,7 +572,6 @@ TEST_F(DBTestTailingIterator, ManagedTailingIteratorPrefixSeek) {
   options.disable_auto_compactions = true;
   options.prefix_extractor.reset(NewFixedPrefixTransform(2));
   options.memtable_factory.reset(NewHashSkipListRepFactory(16));
-  options.allow_concurrent_memtable_write = false;
   DestroyAndReopen(options);
   CreateAndReopenWithCF({"pikachu"}, options);
 

db/db_test.cc

@@ -197,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_;
@@ -228,50 +215,6 @@ TEST_F(DBTest, WriteEmptyBatch) {
   ASSERT_EQ("bar", Get(1, "foo"));
 }
 
-TEST_F(DBTest, SkipDelay) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.write_buffer_size = 100000;
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  for (bool sync : {true, false}) {
-    for (bool disableWAL : {true, false}) {
-      // Use a small number to ensure a large delay that is still effective
-      // when we do Put
-      // TODO(myabandeh): this is time dependent and could potentially make
-      // the test flaky
-      auto token = dbfull()->TEST_write_controler().GetDelayToken(1);
-      std::atomic<int> sleep_count(0);
-      rocksdb::SyncPoint::GetInstance()->SetCallBack(
-          "DBImpl::DelayWrite:Sleep",
-          [&](void* arg) { sleep_count.fetch_add(1); });
-      std::atomic<int> wait_count(0);
-      rocksdb::SyncPoint::GetInstance()->SetCallBack(
-          "DBImpl::DelayWrite:Wait",
-          [&](void* arg) { wait_count.fetch_add(1); });
-      rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-      WriteOptions wo;
-      wo.sync = sync;
-      wo.disableWAL = disableWAL;
-      wo.no_slowdown = true;
-      dbfull()->Put(wo, "foo", "bar");
-      // We need the 2nd write to trigger delay. This is because delay is
-      // estimated based on the last write size which is 0 for the first write.
-      ASSERT_NOK(dbfull()->Put(wo, "foo2", "bar2"));
-      ASSERT_GE(sleep_count.load(), 0);
-      ASSERT_GE(wait_count.load(), 0);
-      token.reset();
-
-      token = dbfull()->TEST_write_controler().GetDelayToken(1000000000);
-      wo.no_slowdown = false;
-      ASSERT_OK(dbfull()->Put(wo, "foo3", "bar3"));
-      ASSERT_GE(sleep_count.load(), 1);
-      token.reset();
-    }
-  }
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(DBTest, ReadOnlyDB) {
   ASSERT_OK(Put("foo", "v1"));
@@ -1309,9 +1252,7 @@ TEST_F(DBTest, MinLevelToCompress2) {
   MinLevelHelper(this, options);
 }
 
-// This test may fail because of a legit case that multiple L0 files
-// are trivial moved to L1.
-TEST_F(DBTest, DISABLED_RepeatedWritesToSameKey) {
+TEST_F(DBTest, RepeatedWritesToSameKey) {
   do {
     Options options = CurrentOptions();
     options.env = env_;
@@ -2526,13 +2467,11 @@ class MultiThreadedDBTest : public DBTest,
 TEST_P(MultiThreadedDBTest, MultiThreaded) {
   anon::OptionsOverride options_override;
   options_override.skip_policy = kSkipNoSnapshot;
-  Options options = CurrentOptions(options_override);
   std::vector<std::string> cfs;
   for (int i = 1; i < kColumnFamilies; ++i) {
     cfs.push_back(ToString(i));
   }
-  Reopen(options);
-  CreateAndReopenWithCF(cfs, options);
+  CreateAndReopenWithCF(cfs, CurrentOptions(options_override));
   // Initialize state
   MTState mt;
   mt.test = this;
@@ -2799,12 +2738,6 @@ class ModelDB : public DB {
                               const Slice& property, uint64_t* value) override {
     return false;
   }
-  using DB::GetMapProperty;
-  virtual bool GetMapProperty(ColumnFamilyHandle* column_family,
-                              const Slice& property,
-                              std::map<std::string, double>* value) override {
-    return false;
-  }
   using DB::GetAggregatedIntProperty;
   virtual bool GetAggregatedIntProperty(const Slice& property,
                                         uint64_t* value) override {
@@ -3409,21 +3342,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
@@ -3678,7 +3609,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) {
@@ -3713,24 +3644,14 @@ TEST_F(DBTest, GetThreadStatus) {
       env_->SetBackgroundThreads(kHighPriCounts[test], Env::HIGH);
       env_->SetBackgroundThreads(kLowPriCounts[test], Env::LOW);
       // Wait to ensure the all threads has been registered
+      env_->SleepForMicroseconds(100000);
+      s = env_->GetThreadList(&thread_list);
+      ASSERT_OK(s);
       unsigned int thread_type_counts[ThreadStatus::NUM_THREAD_TYPES];
-      // Try up to 60 seconds.
-      for (int num_try = 0; num_try < 60000; num_try++) {
-        env_->SleepForMicroseconds(1000);
-        thread_list.clear();
-        s = env_->GetThreadList(&thread_list);
-        ASSERT_OK(s);
-        memset(thread_type_counts, 0, sizeof(thread_type_counts));
-        for (auto thread : thread_list) {
-          ASSERT_LT(thread.thread_type, ThreadStatus::NUM_THREAD_TYPES);
-          thread_type_counts[thread.thread_type]++;
-        }
-        if (thread_type_counts[ThreadStatus::HIGH_PRIORITY] ==
-                kHighPriCounts[test] &&
-            thread_type_counts[ThreadStatus::LOW_PRIORITY] ==
-                kLowPriCounts[test]) {
-          break;
-        }
+      memset(thread_type_counts, 0, sizeof(thread_type_counts));
+      for (auto thread : thread_list) {
+        ASSERT_LT(thread.thread_type, ThreadStatus::NUM_THREAD_TYPES);
+        thread_type_counts[thread.thread_type]++;
       }
       // Verify the total number of threades
       ASSERT_EQ(thread_type_counts[ThreadStatus::HIGH_PRIORITY] +
@@ -4953,7 +4874,7 @@ TEST_F(DBTest, MergeTestTime) {
   SetPerfLevel(kEnableTime);
   this->env_->addon_time_.store(0);
   this->env_->time_elapse_only_sleep_ = true;
-  this->env_->no_slowdown_ = true;
+  this->env_->no_sleep_ = true;
   Options options = CurrentOptions();
   options.statistics = rocksdb::CreateDBStatistics();
   options.merge_operator.reset(new DelayedMergeOperator(this));
@@ -4985,7 +4906,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;
@@ -5393,12 +5314,12 @@ TEST_F(DBTest, FlushesInParallelWithCompactRange) {
 
 TEST_F(DBTest, DelayedWriteRate) {
   const int kEntriesPerMemTable = 100;
-  const int kTotalFlushes = 12;
+  const int kTotalFlushes = 20;
 
   Options options = CurrentOptions();
   env_->SetBackgroundThreads(1, Env::LOW);
   options.env = env_;
-  env_->no_slowdown_ = true;
+  env_->no_sleep_ = true;
   options.write_buffer_size = 100000000;
   options.max_write_buffer_number = 256;
   options.max_background_compactions = 1;
@@ -5443,8 +5364,8 @@ TEST_F(DBTest, DelayedWriteRate) {
     dbfull()->TEST_WaitForFlushMemTable();
     estimated_sleep_time += size_memtable * 1000000u / cur_rate;
     // Slow down twice. One for memtable switch and one for flush finishes.
-    cur_rate = static_cast<uint64_t>(static_cast<double>(cur_rate) *
-                                     kIncSlowdownRatio * kIncSlowdownRatio);
+    cur_rate = static_cast<uint64_t>(static_cast<double>(cur_rate) /
+                                     kSlowdownRatio / kSlowdownRatio);
   }
   // Estimate the total sleep time fall into the rough range.
   ASSERT_GT(env_->addon_time_.load(),
@@ -5452,7 +5373,7 @@ TEST_F(DBTest, DelayedWriteRate) {
   ASSERT_LT(env_->addon_time_.load(),
             static_cast<int64_t>(estimated_sleep_time * 2));
 
-  env_->no_slowdown_ = false;
+  env_->no_sleep_ = false;
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
   sleeping_task_low.WakeUp();
   sleeping_task_low.WaitUntilDone();

db/db_test2.cc

@@ -145,22 +145,6 @@ TEST_F(DBTest2, CacheIndexAndFilterWithDBRestart) {
   value = Get(1, "a");
 }
 
-TEST_F(DBTest2, MaxSuccessiveMergesChangeWithDBRecovery) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  options.max_successive_merges = 3;
-  options.merge_operator = MergeOperators::CreatePutOperator();
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-  Put("poi", "Finch");
-  db_->Merge(WriteOptions(), "poi", "Reese");
-  db_->Merge(WriteOptions(), "poi", "Shaw");
-  db_->Merge(WriteOptions(), "poi", "Root");
-  options.max_successive_merges = 2;
-  Reopen(options);
-}
-
 #ifndef ROCKSDB_LITE
 class DBTestSharedWriteBufferAcrossCFs
     : public DBTestBase,
@@ -956,7 +940,6 @@ TEST_F(DBTest2, PresetCompressionDict) {
   const int kNumL0Files = 5;
 
   Options options;
-  options.allow_concurrent_memtable_write = false;
   options.arena_block_size = kBlockSizeBytes;
   options.compaction_style = kCompactionStyleUniversal;
   options.create_if_missing = true;
@@ -1470,10 +1453,6 @@ class MockPersistentCache : public PersistentCache {
 
   virtual ~MockPersistentCache() {}
 
-  PersistentCache::StatsType Stats() override {
-    return PersistentCache::StatsType();
-  }
-
   Status Insert(const Slice& page_key, const char* data,
                 const size_t size) override {
     MutexLock _(&lock_);
@@ -1505,10 +1484,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;
@@ -1914,6 +1889,23 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) {
 }
 #endif  // ROCKSDB_LITE
 
+TEST_F(DBTest2, MaxSuccessiveMergesInRecovery) {
+  Options options;
+  options = CurrentOptions(options);
+  options.merge_operator = MergeOperators::CreatePutOperator();
+  DestroyAndReopen(options);
+
+  db_->Put(WriteOptions(), "foo", "bar");
+  ASSERT_OK(db_->Merge(WriteOptions(), "foo", "bar"));
+  ASSERT_OK(db_->Merge(WriteOptions(), "foo", "bar"));
+  ASSERT_OK(db_->Merge(WriteOptions(), "foo", "bar"));
+  ASSERT_OK(db_->Merge(WriteOptions(), "foo", "bar"));
+  ASSERT_OK(db_->Merge(WriteOptions(), "foo", "bar"));
+
+  options.max_successive_merges = 3;
+  Reopen(options);
+}
+
 size_t GetEncodedEntrySize(size_t key_size, size_t value_size) {
   std::string buffer;
 
@@ -2094,26 +2086,8 @@ TEST_F(DBTest2, AutomaticCompactionOverlapManualCompaction) {
   cro.target_level = 2;
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
 
-  auto get_stat = [](std::string level_str, LevelStatType type,
-                     std::map<std::string, double> props) {
-    auto prop_str =
-        level_str + "." +
-        InternalStats::compaction_level_stats.at(type).property_name.c_str();
-    auto prop_item = props.find(prop_str);
-    return prop_item == props.end() ? 0 : prop_item->second;
-  };
-
   // Trivial move 2 files to L2
   ASSERT_EQ("0,0,2", FilesPerLevel());
-  // Also test that the stats GetMapProperty API reporting the same result
-  {
-    std::map<std::string, double> prop;
-    ASSERT_TRUE(dbfull()->GetMapProperty("rocksdb.cfstats", &prop));
-    ASSERT_EQ(0, get_stat("L0", LevelStatType::NUM_FILES, prop));
-    ASSERT_EQ(0, get_stat("L1", LevelStatType::NUM_FILES, prop));
-    ASSERT_EQ(2, get_stat("L2", LevelStatType::NUM_FILES, prop));
-    ASSERT_EQ(2, get_stat("Sum", LevelStatType::NUM_FILES, prop));
-  }
 
   // While the compaction is running, we will create 2 new files that
   // can fit in L2, these 2 files will be moved to L2 and overlap with
@@ -2140,13 +2114,6 @@ TEST_F(DBTest2, AutomaticCompactionOverlapManualCompaction) {
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
 
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-
-  // Test that the stats GetMapProperty API reporting 1 file in L2
-  {
-    std::map<std::string, double> prop;
-    ASSERT_TRUE(dbfull()->GetMapProperty("rocksdb.cfstats", &prop));
-    ASSERT_EQ(1, get_stat("L2", LevelStatType::NUM_FILES, prop));
-  }
 }
 
 TEST_F(DBTest2, ManualCompactionOverlapManualCompaction) {
@@ -2216,18 +2183,6 @@ 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
 
 }  // namespace rocksdb

db/db_test_util.cc

@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "db/db_test_util.h"
-#include "db/forward_iterator.h"
 
 namespace rocksdb {
 
@@ -20,7 +19,7 @@ SpecialEnv::SpecialEnv(Env* base)
       sleep_counter_(this),
       addon_time_(0),
       time_elapse_only_sleep_(false),
-      no_slowdown_(false) {
+      no_sleep_(false) {
   delay_sstable_sync_.store(false, std::memory_order_release);
   drop_writes_.store(false, std::memory_order_release);
   no_space_.store(false, std::memory_order_release);
@@ -234,7 +233,6 @@ Options DBTestBase::CurrentOptions(
     case kHashSkipList:
       options.prefix_extractor.reset(NewFixedPrefixTransform(1));
       options.memtable_factory.reset(NewHashSkipListRepFactory(16));
-      options.allow_concurrent_memtable_write = false;
       break;
     case kPlainTableFirstBytePrefix:
       options.table_factory.reset(new PlainTableFactory());
@@ -266,18 +264,15 @@ Options DBTestBase::CurrentOptions(
       break;
     case kVectorRep:
       options.memtable_factory.reset(new VectorRepFactory(100));
-      options.allow_concurrent_memtable_write = false;
       break;
     case kHashLinkList:
       options.prefix_extractor.reset(NewFixedPrefixTransform(1));
       options.memtable_factory.reset(
           NewHashLinkListRepFactory(4, 0, 3, true, 4));
-      options.allow_concurrent_memtable_write = false;
       break;
     case kHashCuckoo:
       options.memtable_factory.reset(
           NewHashCuckooRepFactory(options.write_buffer_size));
-      options.allow_concurrent_memtable_write = false;
       break;
 #endif  // ROCKSDB_LITE
     case kMergePut:
@@ -308,7 +303,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;
@@ -478,22 +472,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());
@@ -519,15 +497,6 @@ Status DBTestBase::Put(int cf, const Slice& k, const Slice& v,
   }
 }
 
-Status DBTestBase::Merge(const Slice& k, const Slice& v, WriteOptions wo) {
-  return db_->Merge(wo, k, v);
-}
-
-Status DBTestBase::Merge(int cf, const Slice& k, const Slice& v,
-                         WriteOptions wo) {
-  return db_->Merge(wo, handles_[cf], k, v);
-}
-
 Status DBTestBase::Delete(const std::string& k) {
   return db_->Delete(WriteOptions(), k);
 }
@@ -616,15 +585,11 @@ std::string DBTestBase::Contents(int cf) {
 
 std::string DBTestBase::AllEntriesFor(const Slice& user_key, int cf) {
   Arena arena;
-  auto options = CurrentOptions();
-  InternalKeyComparator icmp(options.comparator);
-  RangeDelAggregator range_del_agg(icmp, {} /* snapshots */);
   ScopedArenaIterator iter;
   if (cf == 0) {
-    iter.set(dbfull()->NewInternalIterator(&arena, &range_del_agg));
+    iter.set(dbfull()->NewInternalIterator(&arena));
   } else {
-    iter.set(
-        dbfull()->NewInternalIterator(&arena, &range_del_agg, handles_[cf]));
+    iter.set(dbfull()->NewInternalIterator(&arena, handles_[cf]));
   }
   InternalKey target(user_key, kMaxSequenceNumber, kTypeValue);
   iter->Seek(target.Encode());
@@ -1025,14 +990,10 @@ UpdateStatus DBTestBase::updateInPlaceNoAction(char* prevValue,
 void DBTestBase::validateNumberOfEntries(int numValues, int cf) {
   ScopedArenaIterator iter;
   Arena arena;
-  auto options = CurrentOptions();
-  InternalKeyComparator icmp(options.comparator);
-  RangeDelAggregator range_del_agg(icmp, {} /* snapshots */);
   if (cf != 0) {
-    iter.set(
-        dbfull()->NewInternalIterator(&arena, &range_del_agg, handles_[cf]));
+    iter.set(dbfull()->NewInternalIterator(&arena, handles_[cf]));
   } else {
-    iter.set(dbfull()->NewInternalIterator(&arena, &range_del_agg));
+    iter.set(dbfull()->NewInternalIterator(&arena));
   }
   iter->SeekToFirst();
   ASSERT_EQ(iter->status().ok(), true);
@@ -1116,18 +1077,11 @@ std::vector<std::uint64_t> DBTestBase::ListTableFiles(Env* env,
 }
 
 void DBTestBase::VerifyDBFromMap(std::map<std::string, std::string> true_data,
-                                 size_t* total_reads_res, bool tailing_iter,
-                                 std::map<std::string, Status> status) {
+                                 size_t* total_reads_res, bool tailing_iter) {
   size_t total_reads = 0;
 
   for (auto& kv : true_data) {
-    Status s = status[kv.first];
-    if (s.ok()) {
-      ASSERT_EQ(Get(kv.first), kv.second);
-    } else {
-      std::string value;
-      ASSERT_EQ(s, db_->Get(ReadOptions(), kv.first, &value));
-    }
+    ASSERT_EQ(Get(kv.first), kv.second);
     total_reads++;
   }
 
@@ -1140,40 +1094,21 @@ void DBTestBase::VerifyDBFromMap(std::map<std::string, std::string> true_data,
     // Verify Iterator::Next()
     iter_cnt = 0;
     auto data_iter = true_data.begin();
-    Status s;
     for (iter->SeekToFirst(); iter->Valid(); iter->Next(), data_iter++) {
       ASSERT_EQ(iter->key().ToString(), data_iter->first);
-      Status current_status = status[data_iter->first];
-      if (!current_status.ok()) {
-        s = current_status;
-      }
-      ASSERT_EQ(iter->status(), s);
-      if (current_status.ok()) {
-        ASSERT_EQ(iter->value().ToString(), data_iter->second);
-      }
+      ASSERT_EQ(iter->value().ToString(), data_iter->second);
       iter_cnt++;
       total_reads++;
     }
     ASSERT_EQ(data_iter, true_data.end()) << iter_cnt << " / "
                                           << true_data.size();
-    delete iter;
 
     // Verify Iterator::Prev()
-    // Use a new iterator to make sure its status is clean.
-    iter = db_->NewIterator(ro);
     iter_cnt = 0;
-    s = Status::OK();
     auto data_rev = true_data.rbegin();
     for (iter->SeekToLast(); iter->Valid(); iter->Prev(), data_rev++) {
       ASSERT_EQ(iter->key().ToString(), data_rev->first);
-      Status current_status = status[data_rev->first];
-      if (!current_status.ok()) {
-        s = current_status;
-      }
-      ASSERT_EQ(iter->status(), s);
-      if (current_status.ok()) {
-        ASSERT_EQ(iter->value().ToString(), data_rev->second);
-      }
+      ASSERT_EQ(iter->value().ToString(), data_rev->second);
       iter_cnt++;
       total_reads++;
     }
@@ -1187,6 +1122,7 @@ void DBTestBase::VerifyDBFromMap(std::map<std::string, std::string> true_data,
       ASSERT_EQ(kv.second, iter->value().ToString());
       total_reads++;
     }
+
     delete iter;
   }
 
@@ -1228,25 +1164,6 @@ void DBTestBase::VerifyDBFromMap(std::map<std::string, std::string> true_data,
   }
 }
 
-void DBTestBase::VerifyDBInternal(
-    std::vector<std::pair<std::string, std::string>> true_data) {
-  Arena arena;
-  InternalKeyComparator icmp(last_options_.comparator);
-  RangeDelAggregator range_del_agg(icmp, {});
-  auto iter = dbfull()->NewInternalIterator(&arena, &range_del_agg);
-  iter->SeekToFirst();
-  for (auto p : true_data) {
-    ASSERT_TRUE(iter->Valid());
-    ParsedInternalKey ikey;
-    ASSERT_TRUE(ParseInternalKey(iter->key(), &ikey));
-    ASSERT_EQ(p.first, ikey.user_key);
-    ASSERT_EQ(p.second, iter->value());
-    iter->Next();
-  };
-  ASSERT_FALSE(iter->Valid());
-  iter->~InternalIterator();
-}
-
 #ifndef ROCKSDB_LITE
 
 uint64_t DBTestBase::GetNumberOfSstFilesForColumnFamily(

db/db_test_util.h

@@ -193,10 +193,6 @@ class SpecialSkipListFactory : public MemTableRepFactory {
   }
   virtual const char* Name() const override { return "SkipListFactory"; }
 
-  bool IsInsertConcurrentlySupported() const override {
-    return factory_.IsInsertConcurrentlySupported();
-  }
-
  private:
   SkipListFactory factory_;
   int num_entries_flush_;
@@ -432,10 +428,10 @@ class SpecialEnv : public EnvWrapper {
 
   virtual void SleepForMicroseconds(int micros) override {
     sleep_counter_.Increment();
-    if (no_slowdown_ || time_elapse_only_sleep_) {
+    if (no_sleep_ || time_elapse_only_sleep_) {
       addon_time_.fetch_add(micros);
     }
-    if (!no_slowdown_) {
+    if (!no_sleep_) {
       target()->SleepForMicroseconds(micros);
     }
   }
@@ -524,7 +520,7 @@ class SpecialEnv : public EnvWrapper {
 
   bool time_elapse_only_sleep_;
 
-  bool no_slowdown_;
+  bool no_sleep_;
 
   std::atomic<bool> is_wal_sync_thread_safe_{true};
 };
@@ -692,8 +688,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());
@@ -701,12 +695,6 @@ class DBTestBase : public testing::Test {
   Status Put(int cf, const Slice& k, const Slice& v,
              WriteOptions wo = WriteOptions());
 
-  Status Merge(const Slice& k, const Slice& v,
-               WriteOptions wo = WriteOptions());
-
-  Status Merge(int cf, const Slice& k, const Slice& v,
-               WriteOptions wo = WriteOptions());
-
   Status Delete(const std::string& k);
 
   Status Delete(int cf, const std::string& k);
@@ -833,13 +821,9 @@ 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 VerifyDBInternal(
-      std::vector<std::pair<std::string, std::string>> true_data);
+  void VerifyDBFromMap(std::map<std::string, std::string> true_data,
+                       size_t* total_reads_res = nullptr,
+                       bool tailing_iter = false);
 
 #ifndef ROCKSDB_LITE
   uint64_t GetNumberOfSstFilesForColumnFamily(DB* db,

db/db_universal_compaction_test.cc

@@ -1044,7 +1044,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
   options.num_levels = 15;
   options.write_buffer_size = 100 << 10;  // 100KB
   options.level0_file_num_compaction_trigger = 8;
-  options.max_background_compactions = 1;
+  options.max_background_compactions = 4;
   options.target_file_size_base = 64 * 1024;
   DestroyAndReopen(options);
   CreateAndReopenWithCF({"pikachu"}, options);

db/db_wal_test.cc

@@ -645,6 +645,8 @@ TEST_F(DBWALTest, PartOfWritesWithWALDisabled) {
   Options options = CurrentOptions();
   options.env = fault_env.get();
   options.disable_auto_compactions = true;
+  // TODO(yiwu): fix for 2PC.
+  options.allow_2pc = false;
   WriteOptions wal_on, wal_off;
   wal_on.sync = true;
   wal_on.disableWAL = false;

db/dbformat.cc

@@ -48,11 +48,6 @@ void AppendInternalKey(std::string* result, const ParsedInternalKey& key) {
   PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
 }
 
-void AppendInternalKeyFooter(std::string* result, SequenceNumber s,
-                             ValueType t) {
-  PutFixed64(result, PackSequenceAndType(s, t));
-}
-
 std::string ParsedInternalKey::DebugString(bool hex) const {
   char buf[50];
   snprintf(buf, sizeof(buf), "' @ %" PRIu64 ": %d", sequence,

db/dbformat.h

@@ -99,11 +99,6 @@ extern void UnPackSequenceAndType(uint64_t packed, uint64_t* seq, ValueType* t);
 // Append the serialization of "key" to *result.
 extern void AppendInternalKey(std::string* result,
                               const ParsedInternalKey& key);
-// Serialized internal key consists of user key followed by footer.
-// This function appends the footer to *result, assuming that *result already
-// contains the user key at the end.
-extern void AppendInternalKeyFooter(std::string* result, SequenceNumber s,
-                                    ValueType t);
 
 // Attempt to parse an internal key from "internal_key".  On success,
 // stores the parsed data in "*result", and returns true.
@@ -202,16 +197,6 @@ class InternalKey {
 
   void Clear() { rep_.clear(); }
 
-  // The underlying representation.
-  // Intended only to be used together with ConvertFromUserKey().
-  std::string* rep() { return &rep_; }
-
-  // Assuming that *rep() contains a user key, this method makes internal key
-  // out of it in-place. This saves a memcpy compared to Set()/SetFrom().
-  void ConvertFromUserKey(SequenceNumber s, ValueType t) {
-    AppendInternalKeyFooter(&rep_, s, t);
-  }
-
   std::string DebugString(bool hex = false) const;
 };
 
@@ -528,11 +513,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;

db/event_helpers.cc

@@ -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

db/external_sst_file_ingestion_job.cc

@@ -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()) {
@@ -393,14 +391,8 @@ Status ExternalSstFileIngestionJob::AssignLevelForIngestedFile(
       bool overlap_with_level = false;
       MergeIteratorBuilder merge_iter_builder(&cfd_->internal_comparator(),
                                               &arena);
-      RangeDelAggregator range_del_agg(cfd_->internal_comparator(),
-                                       {} /* snapshots */);
       sv->current->AddIteratorsForLevel(ro, env_options_, &merge_iter_builder,
-                                        lvl, &range_del_agg);
-      if (!range_del_agg.IsEmpty()) {
-        return Status::NotSupported(
-            "file ingestion with range tombstones is currently unsupported");
-      }
+                                        lvl);
       ScopedArenaIterator level_iter(merge_iter_builder.Finish());
 
       status = IngestedFileOverlapWithIteratorRange(

db/external_sst_file_test.cc

@@ -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));
@@ -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

db/fault_injection_test.cc

@@ -228,7 +228,7 @@ class FaultInjectionTest : public testing::Test,
     return Status::OK();
   }
 
-#if __clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 9)
+#if defined(__clang__)
 __attribute__((__no_sanitize__("undefined")))
 #elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
 __attribute__((__no_sanitize_undefined__))

db/file_indexer.cc

@@ -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 {
 

db/flush_job.cc

@@ -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);
@@ -247,11 +241,7 @@ Status FlushJob::WriteLevel0Table() {
     if (log_buffer_) {
       log_buffer_->FlushBufferToLog();
     }
-    // memtables and range_del_iters store internal iterators over each data
-    // memtable and its associated range deletion memtable, respectively, at
-    // corresponding indexes.
     std::vector<InternalIterator*> memtables;
-    std::vector<InternalIterator*> range_del_iters;
     ReadOptions ro;
     ro.total_order_seek = true;
     Arena arena;
@@ -262,10 +252,6 @@ Status FlushJob::WriteLevel0Table() {
           "[%s] [JOB %d] Flushing memtable with next log file: %" PRIu64 "\n",
           cfd_->GetName().c_str(), job_context_->job_id, m->GetNextLogNumber());
       memtables.push_back(m->NewIterator(ro, &arena));
-      auto* range_del_iter = m->NewRangeTombstoneIterator(ro);
-      if (range_del_iter != nullptr) {
-        range_del_iters.push_back(range_del_iter);
-      }
       total_num_entries += m->num_entries();
       total_num_deletes += m->num_deletes();
       total_memory_usage += m->ApproximateMemoryUsage();
@@ -282,10 +268,6 @@ Status FlushJob::WriteLevel0Table() {
       ScopedArenaIterator iter(
           NewMergingIterator(&cfd_->internal_comparator(), &memtables[0],
                              static_cast<int>(memtables.size()), &arena));
-      std::unique_ptr<InternalIterator> range_del_iter(NewMergingIterator(
-          &cfd_->internal_comparator(),
-          range_del_iters.empty() ? nullptr : &range_del_iters[0],
-          static_cast<int>(range_del_iters.size())));
       Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
           "[%s] [JOB %d] Level-0 flush table #%" PRIu64 ": started",
           cfd_->GetName().c_str(), job_context_->job_id, meta_.fd.GetNumber());
@@ -294,10 +276,9 @@ Status FlushJob::WriteLevel0Table() {
                                &output_compression_);
       s = BuildTable(
           dbname_, db_options_.env, *cfd_->ioptions(), mutable_cf_options_,
-          env_options_, cfd_->table_cache(), iter.get(),
-          std::move(range_del_iter), &meta_, cfd_->internal_comparator(),
-          cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
-          cfd_->GetName(), existing_snapshots_,
+          env_options_, cfd_->table_cache(), iter.get(), &meta_,
+          cfd_->internal_comparator(), cfd_->int_tbl_prop_collector_factories(),
+          cfd_->GetID(), cfd_->GetName(), existing_snapshots_,
           earliest_write_conflict_snapshot_, output_compression_,
           cfd_->ioptions()->compression_opts,
           mutable_cf_options_.paranoid_file_checks, cfd_->internal_stats(),

db/flush_job.h

@@ -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:

db/flush_job_test.cc

@@ -115,19 +115,18 @@ TEST_F(FlushJobTest, NonEmpty) {
   // Test data:
   //   seqno [    1,    2 ... 8998, 8999, 9000, 9001, 9002 ... 9999 ]
   //   key   [ 1001, 1002 ... 9998, 9999,    0,    1,    2 ...  999 ]
-  //   range-delete "9995" -> "9999" at seqno 10000
+  // Expected:
+  //   smallest_key   = "0"
+  //   largest_key    = "9999"
+  //   smallest_seqno = 1
+  //   smallest_seqno = 9999
   for (int i = 1; i < 10000; ++i) {
     std::string key(ToString((i + 1000) % 10000));
     std::string value("value" + key);
     new_mem->Add(SequenceNumber(i), kTypeValue, key, value);
-    if ((i + 1000) % 10000 < 9995) {
-      InternalKey internal_key(key, SequenceNumber(i), kTypeValue);
-      inserted_keys.insert({internal_key.Encode().ToString(), value});
-    }
+    InternalKey internal_key(key, SequenceNumber(i), kTypeValue);
+    inserted_keys.insert({internal_key.Encode().ToString(), value});
   }
-  new_mem->Add(SequenceNumber(10000), kTypeRangeDeletion, "9995", "9999a");
-  InternalKey internal_key("9995", SequenceNumber(10000), kTypeRangeDeletion);
-  inserted_keys.insert({internal_key.Encode().ToString(), "9999a"});
 
   autovector<MemTable*> to_delete;
   cfd->imm()->Add(new_mem, &to_delete);
@@ -147,10 +146,9 @@ TEST_F(FlushJobTest, NonEmpty) {
   ASSERT_OK(flush_job.Run(&fd));
   mutex_.Unlock();
   ASSERT_EQ(ToString(0), fd.smallest.user_key().ToString());
-  ASSERT_EQ("9999a",
-            fd.largest.user_key().ToString());  // range tombstone end key
+  ASSERT_EQ(ToString(9999), fd.largest.user_key().ToString());
   ASSERT_EQ(1, fd.smallest_seqno);
-  ASSERT_EQ(10000, fd.largest_seqno);  // range tombstone seqnum 10000
+  ASSERT_EQ(9999, fd.largest_seqno);
   mock_table_factory_->AssertSingleFile(inserted_keys);
   job_context.Clean();
 }

db/forward_iterator.cc

@@ -71,8 +71,8 @@ class LevelIterator : public InternalIterator {
 
     file_iter_ = cfd_->table_cache()->NewIterator(
         read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
-        files_[file_index_]->fd, nullptr /* range_del_agg */,
-        nullptr /* table_reader_ptr */, nullptr, false);
+        files_[file_index_]->fd, nullptr /* table_reader_ptr */, nullptr,
+        false);
 
     file_iter_->SetPinnedItersMgr(pinned_iters_mgr_);
   }
@@ -365,19 +365,61 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
       }
     }
 
+    int32_t search_left_bound = 0;
+    int32_t search_right_bound = FileIndexer::kLevelMaxIndex;
     for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
       const std::vector<FileMetaData*>& level_files =
           vstorage->LevelFiles(level);
       if (level_files.empty()) {
+        search_left_bound = 0;
+        search_right_bound = FileIndexer::kLevelMaxIndex;
         continue;
       }
       if (level_iters_[level - 1] == nullptr) {
         continue;
       }
       uint32_t f_idx = 0;
+      const auto& indexer = vstorage->file_indexer();
       if (!seek_to_first) {
-        f_idx = FindFileInRange(level_files, internal_key, 0,
-                                static_cast<uint32_t>(level_files.size()));
+        if (search_left_bound == search_right_bound) {
+          f_idx = search_left_bound;
+        } else if (search_left_bound < search_right_bound) {
+          f_idx =
+              FindFileInRange(level_files, internal_key, search_left_bound,
+                              search_right_bound == FileIndexer::kLevelMaxIndex
+                                  ? static_cast<uint32_t>(level_files.size())
+                                  : search_right_bound);
+        } else {
+          // search_left_bound > search_right_bound
+          // There are only 2 cases this can happen:
+          // (1) target key is smaller than left most file
+          // (2) target key is larger than right most file
+          assert(search_left_bound == (int32_t)level_files.size() ||
+                 search_right_bound == -1);
+          if (search_right_bound == -1) {
+            assert(search_left_bound == 0);
+            f_idx = 0;
+          } else {
+            indexer.GetNextLevelIndex(
+                level, level_files.size() - 1,
+                1, 1, &search_left_bound, &search_right_bound);
+            continue;
+          }
+        }
+
+        // Prepare hints for the next level
+        if (f_idx < level_files.size()) {
+          int cmp_smallest = user_comparator_->Compare(
+              user_key, level_files[f_idx]->smallest.user_key());
+          assert(user_comparator_->Compare(
+                     user_key, level_files[f_idx]->largest.user_key()) <= 0);
+          indexer.GetNextLevelIndex(level, f_idx, cmp_smallest, -1,
+                                    &search_left_bound, &search_right_bound);
+        } else {
+          indexer.GetNextLevelIndex(
+              level, level_files.size() - 1,
+              1, 1, &search_left_bound, &search_right_bound);
+        }
       }
 
       // Seek
@@ -574,8 +616,7 @@ void ForwardIterator::RebuildIterators(bool refresh_sv) {
       continue;
     }
     l0_iters_.push_back(cfd_->table_cache()->NewIterator(
-        read_options_, *cfd_->soptions(), cfd_->internal_comparator(), l0->fd,
-        nullptr /* range_del_agg */));
+        read_options_, *cfd_->soptions(), cfd_->internal_comparator(), l0->fd));
   }
   BuildLevelIterators(vstorage);
   current_ = nullptr;
@@ -630,7 +671,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, nullptr /* range_del_agg */));
+        l0_files_new[inew]->fd));
   }
 
   for (auto* f : l0_iters_) {
@@ -682,7 +723,7 @@ void ForwardIterator::ResetIncompleteIterators() {
     DeleteIterator(l0_iters_[i]);
     l0_iters_[i] = cfd_->table_cache()->NewIterator(
         read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
-        l0_files[i]->fd, nullptr /* range_del_agg */);
+        l0_files[i]->fd);
     l0_iters_[i]->SetPinnedItersMgr(pinned_iters_mgr_);
   }
 

db/forward_iterator_bench.cc

@@ -330,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);

db/inlineskiplist.h

@@ -44,7 +44,6 @@
 #pragma once
 #include <assert.h>
 #include <stdlib.h>
-#include <algorithm>
 #include <atomic>
 #include "port/port.h"
 #include "util/allocator.h"
@@ -56,11 +55,8 @@ template <class Comparator>
 class InlineSkipList {
  private:
   struct Node;
-  struct Splice;
 
  public:
-  static const uint16_t kMaxPossibleHeight = 32;
-
   // Create a new InlineSkipList object that will use "cmp" for comparing
   // keys, and will allocate memory using "*allocator".  Objects allocated
   // in the allocator must remain allocated for the lifetime of the
@@ -74,58 +70,22 @@ class InlineSkipList {
   // is thread-safe.
   char* AllocateKey(size_t key_size);
 
-  // Allocate a splice using allocator.
-  Splice* AllocateSplice();
-
   // Inserts a key allocated by AllocateKey, after the actual key value
   // has been filled in.
   //
   // REQUIRES: nothing that compares equal to key is currently in the list.
-  // REQUIRES: no concurrent calls to any of inserts.
+  // REQUIRES: no concurrent calls to INSERT
   void Insert(const char* key);
 
-  // Inserts a key allocated by AllocateKey with a hint of last insert
-  // position in the skip-list. If hint points to nullptr, a new hint will be
-  // populated, which can be used in subsequent calls.
-  //
-  // It can be used to optimize the workload where there are multiple groups
-  // of keys, and each key is likely to insert to a location close to the last
-  // inserted key in the same group. One example is sequential inserts.
-  //
-  // REQUIRES: nothing that compares equal to key is currently in the list.
-  // REQUIRES: no concurrent calls to any of inserts.
-  void InsertWithHint(const char* key, void** hint);
-
   // Like Insert, but external synchronization is not required.
   void InsertConcurrently(const char* key);
 
-  // Inserts a node into the skip list.  key must have been allocated by
-  // AllocateKey and then filled in by the caller.  If UseCAS is true,
-  // then external synchronization is not required, otherwise this method
-  // may not be called concurrently with any other insertions.
-  //
-  // Regardless of whether UseCAS is true, the splice must be owned
-  // exclusively by the current thread.  If allow_partial_splice_fix is
-  // true, then the cost of insertion is amortized O(log D), where D is
-  // the distance from the splice to the inserted key (measured as the
-  // number of intervening nodes).  Note that this bound is very good for
-  // sequential insertions!  If allow_partial_splice_fix is false then
-  // the existing splice will be ignored unless the current key is being
-  // inserted immediately after the splice.  allow_partial_splice_fix ==
-  // false has worse running time for the non-sequential case O(log N),
-  // but a better constant factor.
-  template <bool UseCAS>
-  void Insert(const char* key, Splice* splice, bool allow_partial_splice_fix);
-
   // Returns true iff an entry that compares equal to key is in the list.
   bool Contains(const char* key) const;
 
   // Return estimated number of entries smaller than `key`.
   uint64_t EstimateCount(const char* key) const;
 
-  // Validate correctness of the skip-list.
-  void TEST_Validate() const;
-
   // Iteration over the contents of a skip list
   class Iterator {
    public:
@@ -174,6 +134,8 @@ class InlineSkipList {
   };
 
  private:
+  enum MaxPossibleHeightEnum : uint16_t { kMaxPossibleHeight = 32 };
+
   const uint16_t kMaxHeight_;
   const uint16_t kBranching_;
   const uint32_t kScaledInverseBranching_;
@@ -188,10 +150,13 @@ class InlineSkipList {
   // values are ok.
   std::atomic<int> max_height_;  // Height of the entire list
 
-  // seq_splice_ is a Splice used for insertions in the non-concurrent
-  // case.  It caches the prev and next found during the most recent
-  // non-concurrent insertion.
-  Splice* seq_splice_;
+  // Used for optimizing sequential insert patterns.  Tricky.  prev_height_
+  // of zero means prev_ is undefined.  Otherwise: prev_[i] for i up
+  // to max_height_ - 1 (inclusive) is the predecessor of prev_[0], and
+  // prev_height_ is the height of prev_[0].  prev_[0] can only be equal
+  // to head when max_height_ and prev_height_ are both 1.
+  Node** prev_;
+  std::atomic<int32_t> prev_height_;
 
   inline int GetMaxHeight() const {
     return max_height_.load(std::memory_order_relaxed);
@@ -210,7 +175,7 @@ class InlineSkipList {
   }
 
   // Return true if key is greater than the data stored in "n".  Null n
-  // is considered infinite.  n should not be head_.
+  // is considered infinite.
   bool KeyIsAfterNode(const char* key, Node* n) const;
 
   // Returns the earliest node with a key >= key.
@@ -223,13 +188,6 @@ class InlineSkipList {
   // level in [0..max_height_-1], if prev is non-null.
   Node* FindLessThan(const char* key, Node** prev = nullptr) const;
 
-  // Return the latest node with a key < key on bottom_level. Start searching
-  // from root node on the level below top_level.
-  // Fills prev[level] with pointer to previous node at "level" for every
-  // level in [bottom_level..top_level-1], if prev is non-null.
-  Node* FindLessThan(const char* key, Node** prev, Node* root, int top_level,
-                     int bottom_level) const;
-
   // Return the last node in the list.
   // Return head_ if list is empty.
   Node* FindLast() const;
@@ -240,13 +198,8 @@ class InlineSkipList {
   // point to a node that is before the key, and after should point to
   // a node that is after the key.  after should be nullptr if a good after
   // node isn't conveniently available.
-  void FindSpliceForLevel(const char* key, Node* before, Node* after, int level,
-                          Node** out_prev, Node** out_next);
-
-  // Recomputes Splice levels from highest_level (inclusive) down to
-  // lowest_level (inclusive).
-  void RecomputeSpliceLevels(const char* key, Splice* splice,
-                             int recompute_level);
+  void FindLevelSplice(const char* key, Node* before, Node* after, int level,
+                       Node** out_prev, Node** out_next);
 
   // No copying allowed
   InlineSkipList(const InlineSkipList&);
@@ -255,19 +208,6 @@ class InlineSkipList {
 
 // Implementation details follow
 
-template <class Comparator>
-struct InlineSkipList<Comparator>::Splice {
-  // The invariant of a Splice is that prev_[i+1].key <= prev_[i].key <
-  // next_[i].key <= next_[i+1].key for all i.  That means that if a
-  // key is bracketed by prev_[i] and next_[i] then it is bracketed by
-  // all higher levels.  It is _not_ required that prev_[i]->Next(i) ==
-  // next_[i] (it probably did at some point in the past, but intervening
-  // or concurrent operations might have inserted nodes in between).
-  int height_ = 0;
-  Node** prev_;
-  Node** next_;
-};
-
 // The Node data type is more of a pointer into custom-managed memory than
 // a traditional C++ struct.  The key is stored in the bytes immediately
 // after the struct, and the next_ pointers for nodes with height > 1 are
@@ -325,14 +265,6 @@ struct InlineSkipList<Comparator>::Node {
     next_[-n].store(x, std::memory_order_relaxed);
   }
 
-  // Insert node after prev on specific level.
-  void InsertAfter(Node* prev, int level) {
-    // NoBarrier_SetNext() suffices since we will add a barrier when
-    // we publish a pointer to "this" in prev.
-    NoBarrier_SetNext(level, prev->NoBarrier_Next(level));
-    prev->SetNext(level, this);
-  }
-
  private:
   // next_[0] is the lowest level link (level 0).  Higher levels are
   // stored _earlier_, so level 1 is at next_[-1].
@@ -430,7 +362,6 @@ template <class Comparator>
 bool InlineSkipList<Comparator>::KeyIsAfterNode(const char* key,
                                                 Node* n) const {
   // nullptr n is considered infinite
-  assert(n != head_);
   return (n != nullptr) && (compare_(n->Key(), key) < 0);
 }
 
@@ -470,17 +401,8 @@ InlineSkipList<Comparator>::FindGreaterOrEqual(const char* key) const {
 template <class Comparator>
 typename InlineSkipList<Comparator>::Node*
 InlineSkipList<Comparator>::FindLessThan(const char* key, Node** prev) const {
-  return FindLessThan(key, prev, head_, GetMaxHeight(), 0);
-}
-
-template <class Comparator>
-typename InlineSkipList<Comparator>::Node*
-InlineSkipList<Comparator>::FindLessThan(const char* key, Node** prev,
-                                         Node* root, int top_level,
-                                         int bottom_level) const {
-  assert(top_level > bottom_level);
-  int level = top_level - 1;
-  Node* x = root;
+  Node* x = head_;
+  int level = GetMaxHeight() - 1;
   // KeyIsAfter(key, last_not_after) is definitely false
   Node* last_not_after = nullptr;
   while (true) {
@@ -494,10 +416,10 @@ InlineSkipList<Comparator>::FindLessThan(const char* key, Node** prev,
       if (prev != nullptr) {
         prev[level] = x;
       }
-      if (level == bottom_level) {
+      if (level == 0) {
         return x;
       } else {
-        // Switch to next list, reuse KeyIsAfterNode() result
+        // Switch to next list, reuse KeyIUsAfterNode() result
         last_not_after = next;
         level--;
       }
@@ -561,14 +483,19 @@ InlineSkipList<Comparator>::InlineSkipList(const Comparator cmp,
       allocator_(allocator),
       head_(AllocateNode(0, max_height)),
       max_height_(1),
-      seq_splice_(AllocateSplice()) {
+      prev_height_(1) {
   assert(max_height > 0 && kMaxHeight_ == static_cast<uint32_t>(max_height));
   assert(branching_factor > 1 &&
          kBranching_ == static_cast<uint32_t>(branching_factor));
   assert(kScaledInverseBranching_ > 0);
-
-  for (int i = 0; i < kMaxHeight_; ++i) {
+  // Allocate the prev_ Node* array, directly from the passed-in allocator.
+  // prev_ does not need to be freed, as its life cycle is tied up with
+  // the allocator as a whole.
+  prev_ = reinterpret_cast<Node**>(
+      allocator_->AllocateAligned(sizeof(Node*) * kMaxHeight_));
+  for (int i = 0; i < kMaxHeight_; i++) {
     head_->SetNext(i, nullptr);
+    prev_[i] = head_;
   }
 }
 
@@ -601,50 +528,71 @@ InlineSkipList<Comparator>::AllocateNode(size_t key_size, int height) {
   return x;
 }
 
-template <class Comparator>
-typename InlineSkipList<Comparator>::Splice*
-InlineSkipList<Comparator>::AllocateSplice() {
-  // size of prev_ and next_
-  size_t array_size = sizeof(Node*) * (kMaxHeight_ + 1);
-  char* raw = allocator_->AllocateAligned(sizeof(Splice) + array_size * 2);
-  Splice* splice = reinterpret_cast<Splice*>(raw);
-  splice->height_ = 0;
-  splice->prev_ = reinterpret_cast<Node**>(raw + sizeof(Splice));
-  splice->next_ = reinterpret_cast<Node**>(raw + sizeof(Splice) + array_size);
-  return splice;
-}
-
 template <class Comparator>
 void InlineSkipList<Comparator>::Insert(const char* key) {
-  Insert<false>(key, seq_splice_, false);
-}
+  // InsertConcurrently often can't maintain the prev_ invariants, so
+  // it just sets prev_height_ to zero, letting us know that we should
+  // ignore it.  A relaxed load suffices here because write thread
+  // synchronization separates Insert calls from InsertConcurrently calls.
+  auto prev_height = prev_height_.load(std::memory_order_relaxed);
 
-template <class Comparator>
-void InlineSkipList<Comparator>::InsertConcurrently(const char* key) {
-  Node* prev[kMaxPossibleHeight];
-  Node* next[kMaxPossibleHeight];
-  Splice splice;
-  splice.prev_ = prev;
-  splice.next_ = next;
-  Insert<true>(key, &splice, false);
-}
+  // fast path for sequential insertion
+  if (prev_height > 0 && !KeyIsAfterNode(key, prev_[0]->NoBarrier_Next(0)) &&
+      (prev_[0] == head_ || KeyIsAfterNode(key, prev_[0]))) {
+    assert(prev_[0] != head_ || (prev_height == 1 && GetMaxHeight() == 1));
 
-template <class Comparator>
-void InlineSkipList<Comparator>::InsertWithHint(const char* key, void** hint) {
-  assert(hint != nullptr);
-  Splice* splice = reinterpret_cast<Splice*>(*hint);
-  if (splice == nullptr) {
-    splice = AllocateSplice();
-    *hint = reinterpret_cast<void*>(splice);
+    // Outside of this method prev_[1..max_height_] is the predecessor
+    // of prev_[0], and prev_height_ refers to prev_[0].  Inside Insert
+    // prev_[0..max_height - 1] is the predecessor of key.  Switch from
+    // the external state to the internal
+    for (int i = 1; i < prev_height; i++) {
+      prev_[i] = prev_[0];
+    }
+  } else {
+    // TODO(opt): we could use a NoBarrier predecessor search as an
+    // optimization for architectures where memory_order_acquire needs
+    // a synchronization instruction.  Doesn't matter on x86
+    FindLessThan(key, prev_);
   }
-  Insert<false>(key, splice, true);
+
+  // Our data structure does not allow duplicate insertion
+  assert(prev_[0]->Next(0) == nullptr || !Equal(key, prev_[0]->Next(0)->Key()));
+
+  // Find the Node that we placed before the key in AllocateKey
+  Node* x = reinterpret_cast<Node*>(const_cast<char*>(key)) - 1;
+  int height = x->UnstashHeight();
+  assert(height >= 1 && height <= kMaxHeight_);
+
+  if (height > GetMaxHeight()) {
+    for (int i = GetMaxHeight(); i < height; i++) {
+      prev_[i] = head_;
+    }
+
+    // It is ok to mutate max_height_ without any synchronization
+    // with concurrent readers.  A concurrent reader that observes
+    // the new value of max_height_ will see either the old value of
+    // new level pointers from head_ (nullptr), or a new value set in
+    // the loop below.  In the former case the reader will
+    // immediately drop to the next level since nullptr sorts after all
+    // keys.  In the latter case the reader will use the new node.
+    max_height_.store(height, std::memory_order_relaxed);
+  }
+
+  for (int i = 0; i < height; i++) {
+    // NoBarrier_SetNext() suffices since we will add a barrier when
+    // we publish a pointer to "x" in prev[i].
+    x->NoBarrier_SetNext(i, prev_[i]->NoBarrier_Next(i));
+    prev_[i]->SetNext(i, x);
+  }
+  prev_[0] = x;
+  prev_height_.store(height, std::memory_order_relaxed);
 }
 
 template <class Comparator>
-void InlineSkipList<Comparator>::FindSpliceForLevel(const char* key,
-                                                    Node* before, Node* after,
-                                                    int level, Node** out_prev,
-                                                    Node** out_next) {
+void InlineSkipList<Comparator>::FindLevelSplice(const char* key, Node* before,
+                                                 Node* after, int level,
+                                                 Node** out_prev,
+                                                 Node** out_next) {
   while (true) {
     Node* next = before->Next(level);
     assert(before == head_ || next == nullptr ||
@@ -661,28 +609,27 @@ void InlineSkipList<Comparator>::FindSpliceForLevel(const char* key,
 }
 
 template <class Comparator>
-void InlineSkipList<Comparator>::RecomputeSpliceLevels(const char* key,
-                                                       Splice* splice,
-                                                       int recompute_level) {
-  assert(recompute_level > 0);
-  assert(recompute_level <= splice->height_);
-  for (int i = recompute_level - 1; i >= 0; --i) {
-    FindSpliceForLevel(key, splice->prev_[i + 1], splice->next_[i + 1], i,
-                       &splice->prev_[i], &splice->next_[i]);
-  }
-}
-
-template <class Comparator>
-template <bool UseCAS>
-void InlineSkipList<Comparator>::Insert(const char* key, Splice* splice,
-                                        bool allow_partial_splice_fix) {
+void InlineSkipList<Comparator>::InsertConcurrently(const char* key) {
   Node* x = reinterpret_cast<Node*>(const_cast<char*>(key)) - 1;
   int height = x->UnstashHeight();
   assert(height >= 1 && height <= kMaxHeight_);
 
+  // We don't have a lock-free algorithm for updating prev_, but we do have
+  // the option of invalidating the entire sequential-insertion cache.
+  // prev_'s invariant is that prev_[i] (i > 0) is the predecessor of
+  // prev_[0] at that level.  We're only going to violate that if height
+  // > 1 and key lands after prev_[height - 1] but before prev_[0].
+  // Comparisons are pretty expensive, so an easier version is to just
+  // clear the cache if height > 1.  We only write to prev_height_ if the
+  // nobody else has, to avoid invalidating the root of the skip list in
+  // all of the other CPU caches.
+  if (height > 1 && prev_height_.load(std::memory_order_relaxed) != 0) {
+    prev_height_.store(0, std::memory_order_relaxed);
+  }
+
   int max_height = max_height_.load(std::memory_order_relaxed);
   while (height > max_height) {
-    if (max_height_.compare_exchange_weak(max_height, height)) {
+    if (max_height_.compare_exchange_strong(max_height, height)) {
       // successfully updated it
       max_height = height;
       break;
@@ -692,159 +639,28 @@ void InlineSkipList<Comparator>::Insert(const char* key, Splice* splice,
   }
   assert(max_height <= kMaxPossibleHeight);
 
-  int recompute_height = 0;
-  if (splice->height_ < max_height) {
-    // Either splice has never been used or max_height has grown since
-    // last use.  We could potentially fix it in the latter case, but
-    // that is tricky.
-    splice->prev_[max_height] = head_;
-    splice->next_[max_height] = nullptr;
-    splice->height_ = max_height;
-    recompute_height = max_height;
-  } else {
-    // Splice is a valid proper-height splice that brackets some
-    // key, but does it bracket this one?  We need to validate it and
-    // recompute a portion of the splice (levels 0..recompute_height-1)
-    // that is a superset of all levels that don't bracket the new key.
-    // Several choices are reasonable, because we have to balance the work
-    // saved against the extra comparisons required to validate the Splice.
-    //
-    // One strategy is just to recompute all of orig_splice_height if the
-    // bottom level isn't bracketing.  This pessimistically assumes that
-    // we will either get a perfect Splice hit (increasing sequential
-    // inserts) or have no locality.
-    //
-    // Another strategy is to walk up the Splice's levels until we find
-    // a level that brackets the key.  This strategy lets the Splice
-    // hint help for other cases: it turns insertion from O(log N) into
-    // O(log D), where D is the number of nodes in between the key that
-    // produced the Splice and the current insert (insertion is aided
-    // whether the new key is before or after the splice).  If you have
-    // a way of using a prefix of the key to map directly to the closest
-    // Splice out of O(sqrt(N)) Splices and we make it so that splices
-    // can also be used as hints during read, then we end up with Oshman's
-    // and Shavit's SkipTrie, which has O(log log N) lookup and insertion
-    // (compare to O(log N) for skip list).
-    //
-    // We control the pessimistic strategy with allow_partial_splice_fix.
-    // A good strategy is probably to be pessimistic for seq_splice_,
-    // optimistic if the caller actually went to the work of providing
-    // a Splice.
-    while (recompute_height < max_height) {
-      if (splice->prev_[recompute_height]->Next(recompute_height) !=
-          splice->next_[recompute_height]) {
-        // splice isn't tight at this level, there must have been some inserts
-        // to this
-        // location that didn't update the splice.  We might only be a little
-        // stale, but if
-        // the splice is very stale it would be O(N) to fix it.  We haven't used
-        // up any of
-        // our budget of comparisons, so always move up even if we are
-        // pessimistic about
-        // our chances of success.
-        ++recompute_height;
-      } else if (splice->prev_[recompute_height] != head_ &&
-                 !KeyIsAfterNode(key, splice->prev_[recompute_height])) {
-        // key is from before splice
-        if (allow_partial_splice_fix) {
-          // skip all levels with the same node without more comparisons
-          Node* bad = splice->prev_[recompute_height];
-          while (splice->prev_[recompute_height] == bad) {
-            ++recompute_height;
-          }
-        } else {
-          // we're pessimistic, recompute everything
-          recompute_height = max_height;
-        }
-      } else if (KeyIsAfterNode(key, splice->next_[recompute_height])) {
-        // key is from after splice
-        if (allow_partial_splice_fix) {
-          Node* bad = splice->next_[recompute_height];
-          while (splice->next_[recompute_height] == bad) {
-            ++recompute_height;
-          }
-        } else {
-          recompute_height = max_height;
-        }
-      } else {
-        // this level brackets the key, we won!
+  Node* prev[kMaxPossibleHeight + 1];
+  Node* next[kMaxPossibleHeight + 1];
+  prev[max_height] = head_;
+  next[max_height] = nullptr;
+  for (int i = max_height - 1; i >= 0; --i) {
+    FindLevelSplice(key, prev[i + 1], next[i + 1], i, &prev[i], &next[i]);
+  }
+  for (int i = 0; i < height; ++i) {
+    while (true) {
+      x->NoBarrier_SetNext(i, next[i]);
+      if (prev[i]->CASNext(i, next[i], x)) {
+        // success
         break;
       }
+      // CAS failed, we need to recompute prev and next. It is unlikely
+      // to be helpful to try to use a different level as we redo the
+      // search, because it should be unlikely that lots of nodes have
+      // been inserted between prev[i] and next[i]. No point in using
+      // next[i] as the after hint, because we know it is stale.
+      FindLevelSplice(key, prev[i], nullptr, i, &prev[i], &next[i]);
     }
   }
-  assert(recompute_height <= max_height);
-  if (recompute_height > 0) {
-    RecomputeSpliceLevels(key, splice, recompute_height);
-  }
-
-  bool splice_is_valid = true;
-  if (UseCAS) {
-    for (int i = 0; i < height; ++i) {
-      while (true) {
-        assert(splice->next_[i] == nullptr ||
-               compare_(x->Key(), splice->next_[i]->Key()) < 0);
-        assert(splice->prev_[i] == head_ ||
-               compare_(splice->prev_[i]->Key(), x->Key()) < 0);
-        x->NoBarrier_SetNext(i, splice->next_[i]);
-        if (splice->prev_[i]->CASNext(i, splice->next_[i], x)) {
-          // success
-          break;
-        }
-        // CAS failed, we need to recompute prev and next. It is unlikely
-        // to be helpful to try to use a different level as we redo the
-        // search, because it should be unlikely that lots of nodes have
-        // been inserted between prev[i] and next[i]. No point in using
-        // next[i] as the after hint, because we know it is stale.
-        FindSpliceForLevel(key, splice->prev_[i], nullptr, i, &splice->prev_[i],
-                           &splice->next_[i]);
-
-        // Since we've narrowed the bracket for level i, we might have
-        // violated the Splice constraint between i and i-1.  Make sure
-        // we recompute the whole thing next time.
-        if (i > 0) {
-          splice_is_valid = false;
-        }
-      }
-    }
-  } else {
-    for (int i = 0; i < height; ++i) {
-      if (i >= recompute_height &&
-          splice->prev_[i]->Next(i) != splice->next_[i]) {
-        FindSpliceForLevel(key, splice->prev_[i], nullptr, i, &splice->prev_[i],
-                           &splice->next_[i]);
-      }
-      assert(splice->next_[i] == nullptr ||
-             compare_(x->Key(), splice->next_[i]->Key()) < 0);
-      assert(splice->prev_[i] == head_ ||
-             compare_(splice->prev_[i]->Key(), x->Key()) < 0);
-      assert(splice->prev_[i]->Next(i) == splice->next_[i]);
-      x->NoBarrier_SetNext(i, splice->next_[i]);
-      splice->prev_[i]->SetNext(i, x);
-    }
-  }
-  if (splice_is_valid) {
-    for (int i = 0; i < height; ++i) {
-      splice->prev_[i] = x;
-    }
-    assert(splice->prev_[splice->height_] == head_);
-    assert(splice->next_[splice->height_] == nullptr);
-    for (int i = 0; i < splice->height_; ++i) {
-      assert(splice->next_[i] == nullptr ||
-             compare_(key, splice->next_[i]->Key()) < 0);
-      assert(splice->prev_[i] == head_ ||
-             compare_(splice->prev_[i]->Key(), key) <= 0);
-      assert(splice->prev_[i + 1] == splice->prev_[i] ||
-             splice->prev_[i + 1] == head_ ||
-             compare_(splice->prev_[i + 1]->Key(), splice->prev_[i]->Key()) <
-                 0);
-      assert(splice->next_[i + 1] == splice->next_[i] ||
-             splice->next_[i + 1] == nullptr ||
-             compare_(splice->next_[i]->Key(), splice->next_[i + 1]->Key()) <
-                 0);
-    }
-  } else {
-    splice->height_ = 0;
-  }
 }
 
 template <class Comparator>
@@ -857,44 +673,4 @@ bool InlineSkipList<Comparator>::Contains(const char* key) const {
   }
 }
 
-template <class Comparator>
-void InlineSkipList<Comparator>::TEST_Validate() const {
-  // Interate over all levels at the same time, and verify nodes appear in
-  // the right order, and nodes appear in upper level also appear in lower
-  // levels.
-  Node* nodes[kMaxPossibleHeight];
-  int max_height = GetMaxHeight();
-  for (int i = 0; i < max_height; i++) {
-    nodes[i] = head_;
-  }
-  while (nodes[0] != nullptr) {
-    Node* l0_next = nodes[0]->Next(0);
-    if (l0_next == nullptr) {
-      break;
-    }
-    assert(nodes[0] == head_ || compare_(nodes[0]->Key(), l0_next->Key()) < 0);
-    nodes[0] = l0_next;
-
-    int i = 1;
-    while (i < max_height) {
-      Node* next = nodes[i]->Next(i);
-      if (next == nullptr) {
-        break;
-      }
-      auto cmp = compare_(nodes[0]->Key(), next->Key());
-      assert(cmp <= 0);
-      if (cmp == 0) {
-        assert(next == nodes[0]);
-        nodes[i] = next;
-      } else {
-        break;
-      }
-      i++;
-    }
-  }
-  for (int i = 1; i < max_height; i++) {
-    assert(nodes[i]->Next(i) == nullptr);
-  }
-}
-
 }  // namespace rocksdb

db/inlineskiplist_test.cc

@@ -9,7 +9,6 @@
 
 #include "db/inlineskiplist.h"
 #include <set>
-#include <unordered_set>
 #include "rocksdb/env.h"
 #include "util/concurrent_arena.h"
 #include "util/hash.h"
@@ -43,48 +42,7 @@ struct TestComparator {
   }
 };
 
-typedef InlineSkipList<TestComparator> TestInlineSkipList;
-
-class InlineSkipTest : public testing::Test {
- public:
-  void Insert(TestInlineSkipList* list, Key key) {
-    char* buf = list->AllocateKey(sizeof(Key));
-    memcpy(buf, &key, sizeof(Key));
-    list->Insert(buf);
-    keys_.insert(key);
-  }
-
-  void InsertWithHint(TestInlineSkipList* list, Key key, void** hint) {
-    char* buf = list->AllocateKey(sizeof(Key));
-    memcpy(buf, &key, sizeof(Key));
-    list->InsertWithHint(buf, hint);
-    keys_.insert(key);
-  }
-
-  void Validate(TestInlineSkipList* list) {
-    // Check keys exist.
-    for (Key key : keys_) {
-      ASSERT_TRUE(list->Contains(Encode(&key)));
-    }
-    // Iterate over the list, make sure keys appears in order and no extra
-    // keys exist.
-    TestInlineSkipList::Iterator iter(list);
-    ASSERT_FALSE(iter.Valid());
-    Key zero = 0;
-    iter.Seek(Encode(&zero));
-    for (Key key : keys_) {
-      ASSERT_TRUE(iter.Valid());
-      ASSERT_EQ(key, Decode(iter.key()));
-      iter.Next();
-    }
-    ASSERT_FALSE(iter.Valid());
-    // Validate the list is well-formed.
-    list->TEST_Validate();
-  }
-
- private:
-  std::set<Key> keys_;
-};
+class InlineSkipTest : public testing::Test {};
 
 TEST_F(InlineSkipTest, Empty) {
   Arena arena;
@@ -195,103 +153,6 @@ TEST_F(InlineSkipTest, InsertAndLookup) {
   }
 }
 
-TEST_F(InlineSkipTest, InsertWithHint_Sequential) {
-  const int N = 100000;
-  Arena arena;
-  TestComparator cmp;
-  TestInlineSkipList list(cmp, &arena);
-  void* hint = nullptr;
-  for (int i = 0; i < N; i++) {
-    Key key = i;
-    InsertWithHint(&list, key, &hint);
-  }
-  Validate(&list);
-}
-
-TEST_F(InlineSkipTest, InsertWithHint_MultipleHints) {
-  const int N = 100000;
-  const int S = 100;
-  Random rnd(534);
-  Arena arena;
-  TestComparator cmp;
-  TestInlineSkipList list(cmp, &arena);
-  void* hints[S];
-  Key last_key[S];
-  for (int i = 0; i < S; i++) {
-    hints[i] = nullptr;
-    last_key[i] = 0;
-  }
-  for (int i = 0; i < N; i++) {
-    Key s = rnd.Uniform(S);
-    Key key = (s << 32) + (++last_key[s]);
-    InsertWithHint(&list, key, &hints[s]);
-  }
-  Validate(&list);
-}
-
-TEST_F(InlineSkipTest, InsertWithHint_MultipleHintsRandom) {
-  const int N = 100000;
-  const int S = 100;
-  Random rnd(534);
-  Arena arena;
-  TestComparator cmp;
-  TestInlineSkipList list(cmp, &arena);
-  void* hints[S];
-  for (int i = 0; i < S; i++) {
-    hints[i] = nullptr;
-  }
-  for (int i = 0; i < N; i++) {
-    Key s = rnd.Uniform(S);
-    Key key = (s << 32) + rnd.Next();
-    InsertWithHint(&list, key, &hints[s]);
-  }
-  Validate(&list);
-}
-
-TEST_F(InlineSkipTest, InsertWithHint_CompatibleWithInsertWithoutHint) {
-  const int N = 100000;
-  const int S1 = 100;
-  const int S2 = 100;
-  Random rnd(534);
-  Arena arena;
-  TestComparator cmp;
-  TestInlineSkipList list(cmp, &arena);
-  std::unordered_set<Key> used;
-  Key with_hint[S1];
-  Key without_hint[S2];
-  void* hints[S1];
-  for (int i = 0; i < S1; i++) {
-    hints[i] = nullptr;
-    while (true) {
-      Key s = rnd.Next();
-      if (used.insert(s).second) {
-        with_hint[i] = s;
-        break;
-      }
-    }
-  }
-  for (int i = 0; i < S2; i++) {
-    while (true) {
-      Key s = rnd.Next();
-      if (used.insert(s).second) {
-        without_hint[i] = s;
-        break;
-      }
-    }
-  }
-  for (int i = 0; i < N; i++) {
-    Key s = rnd.Uniform(S1 + S2);
-    if (s < S1) {
-      Key key = (with_hint[s] << 32) + rnd.Next();
-      InsertWithHint(&list, key, &hints[s]);
-    } else {
-      Key key = (without_hint[s - S1] << 32) + rnd.Next();
-      Insert(&list, key);
-    }
-  }
-  Validate(&list);
-}
-
 // We want to make sure that with a single writer and multiple
 // concurrent readers (with no synchronization other than when a
 // reader's iterator is created), the reader always observes all the

db/internal_stats.cc

@@ -25,146 +25,62 @@
 namespace rocksdb {
 
 #ifndef ROCKSDB_LITE
-
-const std::map<LevelStatType, LevelStat> InternalStats::compaction_level_stats =
-    {
-        {LevelStatType::NUM_FILES, LevelStat{"NumFiles", "Files"}},
-        {LevelStatType::COMPACTED_FILES,
-         LevelStat{"CompactedFiles", "CompactedFiles"}},
-        {LevelStatType::SIZE_MB, LevelStat{"SizeMB", "Size(MB}"}},
-        {LevelStatType::SCORE, LevelStat{"Score", "Score"}},
-        {LevelStatType::READ_GB, LevelStat{"ReadGB", "Read(GB}"}},
-        {LevelStatType::RN_GB, LevelStat{"RnGB", "Rn(GB}"}},
-        {LevelStatType::RNP1_GB, LevelStat{"Rnp1GB", "Rnp1(GB}"}},
-        {LevelStatType::WRITE_GB, LevelStat{"WriteGB", "Write(GB}"}},
-        {LevelStatType::W_NEW_GB, LevelStat{"WnewGB", "Wnew(GB}"}},
-        {LevelStatType::MOVED_GB, LevelStat{"MovedGB", "Moved(GB}"}},
-        {LevelStatType::WRITE_AMP, LevelStat{"WriteAmp", "W-Amp"}},
-        {LevelStatType::READ_MBPS, LevelStat{"ReadMBps", "Rd(MB/s}"}},
-        {LevelStatType::WRITE_MBPS, LevelStat{"WriteMBps", "Wr(MB/s}"}},
-        {LevelStatType::COMP_SEC, LevelStat{"CompSec", "Comp(sec}"}},
-        {LevelStatType::COMP_COUNT, LevelStat{"CompCount", "Comp(cnt}"}},
-        {LevelStatType::AVG_SEC, LevelStat{"AvgSec", "Avg(sec}"}},
-        {LevelStatType::KEY_IN, LevelStat{"KeyIn", "KeyIn"}},
-        {LevelStatType::KEY_DROP, LevelStat{"KeyDrop", "KeyDrop"}},
-};
-
 namespace {
 const double kMB = 1048576.0;
 const double kGB = kMB * 1024;
 const double kMicrosInSec = 1000000.0;
 
 void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
-  int written_size =
-      snprintf(buf, len, "\n** Compaction Stats [%s] **\n", cf_name.c_str());
-  auto hdr = [](LevelStatType t) {
-    return InternalStats::compaction_level_stats.at(t).header_name.c_str();
-  };
-  int line_size = snprintf(
-      buf + written_size, len - written_size,
-      "Level    %s   %s %s %s  %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
-      // Note that we skip COMPACTED_FILES and merge it with Files column
-      hdr(LevelStatType::NUM_FILES), hdr(LevelStatType::SIZE_MB),
-      hdr(LevelStatType::SCORE), hdr(LevelStatType::READ_GB),
-      hdr(LevelStatType::RN_GB), hdr(LevelStatType::RNP1_GB),
-      hdr(LevelStatType::WRITE_GB), hdr(LevelStatType::W_NEW_GB),
-      hdr(LevelStatType::MOVED_GB), hdr(LevelStatType::WRITE_AMP),
-      hdr(LevelStatType::READ_MBPS), hdr(LevelStatType::WRITE_MBPS),
-      hdr(LevelStatType::COMP_SEC), hdr(LevelStatType::COMP_COUNT),
-      hdr(LevelStatType::AVG_SEC), hdr(LevelStatType::KEY_IN),
-      hdr(LevelStatType::KEY_DROP));
-
-  written_size += line_size;
-  snprintf(buf + written_size, len - written_size, "%s\n",
-           std::string(line_size, '-').c_str());
+  snprintf(
+      buf, len,
+      "\n** Compaction Stats [%s] **\n"
+      "Level    Files   Size(MB) Score Read(GB)  Rn(GB) Rnp1(GB) "
+      "Write(GB) Wnew(GB) Moved(GB) W-Amp Rd(MB/s) Wr(MB/s) "
+      "Comp(sec) Comp(cnt) Avg(sec) KeyIn KeyDrop\n"
+      "--------------------------------------------------------------------"
+      "-----------------------------------------------------------"
+      "--------------------------------------\n",
+      cf_name.c_str());
 }
 
-void PrepareLevelStats(std::map<LevelStatType, double>* level_stats,
-                       int num_files, int being_compacted,
-                       double total_file_size, double score, double w_amp,
-                       const InternalStats::CompactionStats& stats) {
+void PrintLevelStats(char* buf, size_t len, const std::string& name,
+  int num_files, int being_compacted, double total_file_size,
+  double score, double w_amp,
+  const InternalStats::CompactionStats& stats) {
   uint64_t bytes_read =
       stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
   int64_t bytes_new =
       stats.bytes_written - stats.bytes_read_output_level;
   double elapsed = (stats.micros + 1) / kMicrosInSec;
+  std::string num_input_records = NumberToHumanString(stats.num_input_records);
+  std::string num_dropped_records =
+      NumberToHumanString(stats.num_dropped_records);
 
-  (*level_stats)[LevelStatType::NUM_FILES] = num_files;
-  (*level_stats)[LevelStatType::COMPACTED_FILES] = being_compacted;
-  (*level_stats)[LevelStatType::SIZE_MB] = total_file_size / kMB;
-  (*level_stats)[LevelStatType::SCORE] = score;
-  (*level_stats)[LevelStatType::READ_GB] = bytes_read / kGB;
-  (*level_stats)[LevelStatType::RN_GB] =
-      stats.bytes_read_non_output_levels / kGB;
-  (*level_stats)[LevelStatType::RNP1_GB] = stats.bytes_read_output_level / kGB;
-  (*level_stats)[LevelStatType::WRITE_GB] = stats.bytes_written / kGB;
-  (*level_stats)[LevelStatType::W_NEW_GB] = bytes_new / kGB;
-  (*level_stats)[LevelStatType::MOVED_GB] = stats.bytes_moved / kGB;
-  (*level_stats)[LevelStatType::WRITE_AMP] = w_amp;
-  (*level_stats)[LevelStatType::READ_MBPS] = bytes_read / kMB / elapsed;
-  (*level_stats)[LevelStatType::WRITE_MBPS] =
-      stats.bytes_written / kMB / elapsed;
-  (*level_stats)[LevelStatType::COMP_SEC] = stats.micros / kMicrosInSec;
-  (*level_stats)[LevelStatType::COMP_COUNT] = stats.count;
-  (*level_stats)[LevelStatType::AVG_SEC] =
-      stats.count == 0 ? 0 : stats.micros / kMicrosInSec / stats.count;
-  (*level_stats)[LevelStatType::KEY_IN] =
-      static_cast<double>(stats.num_input_records);
-  (*level_stats)[LevelStatType::KEY_DROP] =
-      static_cast<double>(stats.num_dropped_records);
-}
-
-void PrintLevelStats(char* buf, size_t len, const std::string& name,
-                     const std::map<LevelStatType, double>& stat_value) {
   snprintf(buf, len,
-           "%4s %6d/%-3d %8.2f %5.1f " /*  Level, Files, Size(MB), Score */
-           "%8.1f "                    /*  Read(GB) */
-           "%7.1f "                    /*  Rn(GB) */
-           "%8.1f "                    /*  Rnp1(GB) */
-           "%9.1f "                    /*  Write(GB) */
-           "%8.1f "                    /*  Wnew(GB) */
-           "%9.1f "                    /*  Moved(GB) */
-           "%5.1f "                    /*  W-Amp */
-           "%8.1f "                    /*  Rd(MB/s) */
-           "%8.1f "                    /*  Wr(MB/s) */
-           "%9.0f "                    /*  Comp(sec) */
-           "%9d "                      /*  Comp(cnt) */
-           "%8.3f "                    /*  Avg(sec) */
-           "%7s "                      /*  KeyIn */
-           "%6s\n",                    /*  KeyDrop */
+           "%4s %6d/%-3d %8.2f %5.1f " /* Level, Files, Size(MB), Score */
+           "%8.1f "                    /* Read(GB) */
+           "%7.1f "                    /* Rn(GB) */
+           "%8.1f "                    /* Rnp1(GB) */
+           "%9.1f "                    /* Write(GB) */
+           "%8.1f "                    /* Wnew(GB) */
+           "%9.1f "                    /* Moved(GB) */
+           "%5.1f "                    /* W-Amp */
+           "%8.1f "                    /* Rd(MB/s) */
+           "%8.1f "                    /* Wr(MB/s) */
+           "%9.0f "                    /* Comp(sec) */
+           "%9d "                      /* Comp(cnt) */
+           "%8.3f "                    /* Avg(sec) */
+           "%7s "   /* KeyIn */
+           "%6s\n", /* KeyDrop */
            name.c_str(),
-           static_cast<int>(stat_value.at(LevelStatType::NUM_FILES)),
-           static_cast<int>(stat_value.at(LevelStatType::COMPACTED_FILES)),
-           stat_value.at(LevelStatType::SIZE_MB),
-           stat_value.at(LevelStatType::SCORE),
-           stat_value.at(LevelStatType::READ_GB),
-           stat_value.at(LevelStatType::RN_GB),
-           stat_value.at(LevelStatType::RNP1_GB),
-           stat_value.at(LevelStatType::WRITE_GB),
-           stat_value.at(LevelStatType::W_NEW_GB),
-           stat_value.at(LevelStatType::MOVED_GB),
-           stat_value.at(LevelStatType::WRITE_AMP),
-           stat_value.at(LevelStatType::READ_MBPS),
-           stat_value.at(LevelStatType::WRITE_MBPS),
-           stat_value.at(LevelStatType::COMP_SEC),
-           static_cast<int>(stat_value.at(LevelStatType::COMP_COUNT)),
-           stat_value.at(LevelStatType::AVG_SEC),
-           NumberToHumanString(
-               static_cast<std::int64_t>(stat_value.at(LevelStatType::KEY_IN)))
-               .c_str(),
-           NumberToHumanString(static_cast<std::int64_t>(
-                                   stat_value.at(LevelStatType::KEY_DROP)))
-               .c_str());
-}
-
-void PrintLevelStats(char* buf, size_t len, const std::string& name,
-                     int num_files, int being_compacted, double total_file_size,
-                     double score, double w_amp,
-                     const InternalStats::CompactionStats& stats) {
-  std::map<LevelStatType, double> level_stats;
-  PrepareLevelStats(&level_stats, num_files, being_compacted, total_file_size,
-                    score, w_amp, stats);
-  PrintLevelStats(buf, len, name, level_stats);
+           num_files, being_compacted, total_file_size / kMB, score,
+           bytes_read / kGB, stats.bytes_read_non_output_levels / kGB,
+           stats.bytes_read_output_level / kGB, stats.bytes_written / kGB,
+           bytes_new / kGB, stats.bytes_moved / kGB, w_amp,
+           bytes_read / kMB / elapsed, stats.bytes_written / kMB / elapsed,
+           stats.micros / kMicrosInSec, stats.count,
+           stats.count == 0 ? 0 : stats.micros / kMicrosInSec / stats.count,
+           num_input_records.c_str(), num_dropped_records.c_str());
 }
 
 // Assumes that trailing numbers represent an optional argument. This requires
@@ -221,7 +137,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 +201,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;
@@ -298,93 +211,73 @@ const std::string DB::Properties::kAggregatedTableProperties =
 const std::string DB::Properties::kAggregatedTablePropertiesAtLevel =
     rocksdb_prefix + aggregated_table_properties_at_level;
 
-const std::unordered_map<std::string, DBPropertyInfo>
-    InternalStats::ppt_name_to_info = {
-        {DB::Properties::kNumFilesAtLevelPrefix,
-         {false, &InternalStats::HandleNumFilesAtLevel, nullptr, nullptr}},
-        {DB::Properties::kCompressionRatioAtLevelPrefix,
-         {false, &InternalStats::HandleCompressionRatioAtLevelPrefix, nullptr,
-          nullptr}},
-        {DB::Properties::kLevelStats,
-         {false, &InternalStats::HandleLevelStats, nullptr, nullptr}},
-        {DB::Properties::kStats,
-         {false, &InternalStats::HandleStats, nullptr, nullptr}},
-        {DB::Properties::kCFStats,
-         {false, &InternalStats::HandleCFStats, nullptr,
-          &InternalStats::HandleCFMapStats}},
-        {DB::Properties::kDBStats,
-         {false, &InternalStats::HandleDBStats, nullptr, nullptr}},
-        {DB::Properties::kSSTables,
-         {false, &InternalStats::HandleSsTables, nullptr, nullptr}},
-        {DB::Properties::kAggregatedTableProperties,
-         {false, &InternalStats::HandleAggregatedTableProperties, nullptr,
-          nullptr}},
-        {DB::Properties::kAggregatedTablePropertiesAtLevel,
-         {false, &InternalStats::HandleAggregatedTablePropertiesAtLevel,
-          nullptr, nullptr}},
-        {DB::Properties::kNumImmutableMemTable,
-         {false, nullptr, &InternalStats::HandleNumImmutableMemTable, nullptr}},
-        {DB::Properties::kNumImmutableMemTableFlushed,
-         {false, nullptr, &InternalStats::HandleNumImmutableMemTableFlushed,
-          nullptr}},
-        {DB::Properties::kMemTableFlushPending,
-         {false, nullptr, &InternalStats::HandleMemTableFlushPending, nullptr}},
-        {DB::Properties::kCompactionPending,
-         {false, nullptr, &InternalStats::HandleCompactionPending, nullptr}},
-        {DB::Properties::kBackgroundErrors,
-         {false, nullptr, &InternalStats::HandleBackgroundErrors, nullptr}},
-        {DB::Properties::kCurSizeActiveMemTable,
-         {false, nullptr, &InternalStats::HandleCurSizeActiveMemTable,
-          nullptr}},
-        {DB::Properties::kCurSizeAllMemTables,
-         {false, nullptr, &InternalStats::HandleCurSizeAllMemTables, nullptr}},
-        {DB::Properties::kSizeAllMemTables,
-         {false, nullptr, &InternalStats::HandleSizeAllMemTables, nullptr}},
-        {DB::Properties::kNumEntriesActiveMemTable,
-         {false, nullptr, &InternalStats::HandleNumEntriesActiveMemTable,
-          nullptr}},
-        {DB::Properties::kNumEntriesImmMemTables,
-         {false, nullptr, &InternalStats::HandleNumEntriesImmMemTables,
-          nullptr}},
-        {DB::Properties::kNumDeletesActiveMemTable,
-         {false, nullptr, &InternalStats::HandleNumDeletesActiveMemTable,
-          nullptr}},
-        {DB::Properties::kNumDeletesImmMemTables,
-         {false, nullptr, &InternalStats::HandleNumDeletesImmMemTables,
-          nullptr}},
-        {DB::Properties::kEstimateNumKeys,
-         {false, nullptr, &InternalStats::HandleEstimateNumKeys, nullptr}},
-        {DB::Properties::kEstimateTableReadersMem,
-         {true, nullptr, &InternalStats::HandleEstimateTableReadersMem,
-          nullptr}},
-        {DB::Properties::kIsFileDeletionsEnabled,
-         {false, nullptr, &InternalStats::HandleIsFileDeletionsEnabled,
-          nullptr}},
-        {DB::Properties::kNumSnapshots,
-         {false, nullptr, &InternalStats::HandleNumSnapshots, nullptr}},
-        {DB::Properties::kOldestSnapshotTime,
-         {false, nullptr, &InternalStats::HandleOldestSnapshotTime, nullptr}},
-        {DB::Properties::kNumLiveVersions,
-         {false, nullptr, &InternalStats::HandleNumLiveVersions, nullptr}},
-        {DB::Properties::kCurrentSuperVersionNumber,
-         {false, nullptr, &InternalStats::HandleCurrentSuperVersionNumber,
-          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,
-         {false, nullptr, &InternalStats::HandleTotalSstFilesSize, nullptr}},
-        {DB::Properties::kEstimatePendingCompactionBytes,
-         {false, nullptr, &InternalStats::HandleEstimatePendingCompactionBytes,
-          nullptr}},
-        {DB::Properties::kNumRunningFlushes,
-         {false, nullptr, &InternalStats::HandleNumRunningFlushes, nullptr}},
-        {DB::Properties::kNumRunningCompactions,
-         {false, nullptr, &InternalStats::HandleNumRunningCompactions,
-          nullptr}},
+const std::unordered_map<std::string,
+                         DBPropertyInfo> InternalStats::ppt_name_to_info = {
+    {DB::Properties::kNumFilesAtLevelPrefix,
+     {false, &InternalStats::HandleNumFilesAtLevel, nullptr}},
+    {DB::Properties::kCompressionRatioAtLevelPrefix,
+     {false, &InternalStats::HandleCompressionRatioAtLevelPrefix, nullptr}},
+    {DB::Properties::kLevelStats,
+     {false, &InternalStats::HandleLevelStats, nullptr}},
+    {DB::Properties::kStats, {false, &InternalStats::HandleStats, nullptr}},
+    {DB::Properties::kCFStats, {false, &InternalStats::HandleCFStats, nullptr}},
+    {DB::Properties::kDBStats, {false, &InternalStats::HandleDBStats, nullptr}},
+    {DB::Properties::kSSTables,
+     {false, &InternalStats::HandleSsTables, nullptr}},
+    {DB::Properties::kAggregatedTableProperties,
+     {false, &InternalStats::HandleAggregatedTableProperties, nullptr}},
+    {DB::Properties::kAggregatedTablePropertiesAtLevel,
+     {false, &InternalStats::HandleAggregatedTablePropertiesAtLevel, nullptr}},
+    {DB::Properties::kNumImmutableMemTable,
+     {false, nullptr, &InternalStats::HandleNumImmutableMemTable}},
+    {DB::Properties::kNumImmutableMemTableFlushed,
+     {false, nullptr, &InternalStats::HandleNumImmutableMemTableFlushed}},
+    {DB::Properties::kMemTableFlushPending,
+     {false, nullptr, &InternalStats::HandleMemTableFlushPending}},
+    {DB::Properties::kCompactionPending,
+     {false, nullptr, &InternalStats::HandleCompactionPending}},
+    {DB::Properties::kBackgroundErrors,
+     {false, nullptr, &InternalStats::HandleBackgroundErrors}},
+    {DB::Properties::kCurSizeActiveMemTable,
+     {false, nullptr, &InternalStats::HandleCurSizeActiveMemTable}},
+    {DB::Properties::kCurSizeAllMemTables,
+     {false, nullptr, &InternalStats::HandleCurSizeAllMemTables}},
+    {DB::Properties::kSizeAllMemTables,
+     {false, nullptr, &InternalStats::HandleSizeAllMemTables}},
+    {DB::Properties::kNumEntriesActiveMemTable,
+     {false, nullptr, &InternalStats::HandleNumEntriesActiveMemTable}},
+    {DB::Properties::kNumEntriesImmMemTables,
+     {false, nullptr, &InternalStats::HandleNumEntriesImmMemTables}},
+    {DB::Properties::kNumDeletesActiveMemTable,
+     {false, nullptr, &InternalStats::HandleNumDeletesActiveMemTable}},
+    {DB::Properties::kNumDeletesImmMemTables,
+     {false, nullptr, &InternalStats::HandleNumDeletesImmMemTables}},
+    {DB::Properties::kEstimateNumKeys,
+     {false, nullptr, &InternalStats::HandleEstimateNumKeys}},
+    {DB::Properties::kEstimateTableReadersMem,
+     {true, nullptr, &InternalStats::HandleEstimateTableReadersMem}},
+    {DB::Properties::kIsFileDeletionsEnabled,
+     {false, nullptr, &InternalStats::HandleIsFileDeletionsEnabled}},
+    {DB::Properties::kNumSnapshots,
+     {false, nullptr, &InternalStats::HandleNumSnapshots}},
+    {DB::Properties::kOldestSnapshotTime,
+     {false, nullptr, &InternalStats::HandleOldestSnapshotTime}},
+    {DB::Properties::kNumLiveVersions,
+     {false, nullptr, &InternalStats::HandleNumLiveVersions}},
+    {DB::Properties::kCurrentSuperVersionNumber,
+     {false, nullptr, &InternalStats::HandleCurrentSuperVersionNumber}},
+    {DB::Properties::kEstimateLiveDataSize,
+     {true, nullptr, &InternalStats::HandleEstimateLiveDataSize}},
+    {DB::Properties::kBaseLevel,
+     {false, nullptr, &InternalStats::HandleBaseLevel}},
+    {DB::Properties::kTotalSstFilesSize,
+     {false, nullptr, &InternalStats::HandleTotalSstFilesSize}},
+    {DB::Properties::kEstimatePendingCompactionBytes,
+     {false, nullptr, &InternalStats::HandleEstimatePendingCompactionBytes}},
+    {DB::Properties::kNumRunningFlushes,
+     {false, nullptr, &InternalStats::HandleNumRunningFlushes}},
+    {DB::Properties::kNumRunningCompactions,
+     {false, nullptr, &InternalStats::HandleNumRunningCompactions}},
 };
 
 const DBPropertyInfo* GetPropertyInfo(const Slice& property) {
@@ -405,14 +298,6 @@ bool InternalStats::GetStringProperty(const DBPropertyInfo& property_info,
   return (this->*(property_info.handle_string))(value, arg);
 }
 
-bool InternalStats::GetMapProperty(const DBPropertyInfo& property_info,
-                                   const Slice& property,
-                                   std::map<std::string, double>* value) {
-  assert(value != nullptr);
-  assert(property_info.handle_map != nullptr);
-  return (this->*(property_info.handle_map))(value);
-}
-
 bool InternalStats::GetIntProperty(const DBPropertyInfo& property_info,
                                    uint64_t* value, DBImpl* db) {
   assert(value != nullptr);
@@ -485,11 +370,6 @@ bool InternalStats::HandleStats(std::string* value, Slice suffix) {
   return true;
 }
 
-bool InternalStats::HandleCFMapStats(std::map<std::string, double>* cf_stats) {
-  DumpCFMapStats(cf_stats);
-  return true;
-}
-
 bool InternalStats::HandleCFStats(std::string* value, Slice suffix) {
   DumpCFStats(value);
   return true;
@@ -710,12 +590,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
@@ -842,32 +716,7 @@ void InternalStats::DumpDBStats(std::string* value) {
   db_stats_snapshot_.write_stall_micros = write_stall_micros;
 }
 
-/**
- * Dump Compaction Level stats to a map of stat name to value in double.
- * The level in stat name is represented with a prefix "Lx" where "x"
- * is the level number. A special level "Sum" represents the sum of a stat
- * for all levels.
- */
-void InternalStats::DumpCFMapStats(std::map<std::string, double>* cf_stats) {
-  CompactionStats compaction_stats_sum(0);
-  std::map<int, std::map<LevelStatType, double>> levels_stats;
-  DumpCFMapStats(&levels_stats, &compaction_stats_sum);
-  for (auto const& level_ent : levels_stats) {
-    auto level_str =
-        level_ent.first == -1 ? "Sum" : "L" + ToString(level_ent.first);
-    for (auto const& stat_ent : level_ent.second) {
-      auto stat_type = stat_ent.first;
-      auto key_str =
-          level_str + "." +
-          InternalStats::compaction_level_stats.at(stat_type).property_name;
-      (*cf_stats)[key_str] = stat_ent.second;
-    }
-  }
-}
-
-int InternalStats::DumpCFMapStats(
-    std::map<int, std::map<LevelStatType, double>>* levels_stats,
-    CompactionStats* compaction_stats_sum) {
+void InternalStats::DumpCFStats(std::string* value) {
   const VersionStorageInfo* vstorage = cfd_->current()->storage_info();
 
   int num_levels_to_check =
@@ -875,7 +724,7 @@ int InternalStats::DumpCFMapStats(
           ? vstorage->num_levels() - 1
           : 1;
 
-  // Compaction scores are sorted based on its value. Restore them to the
+  // Compaction scores are sorted base on its value. Restore them to the
   // level order
   std::vector<double> compaction_score(number_levels_, 0);
   for (int i = 0; i < num_levels_to_check; ++i) {
@@ -892,6 +741,12 @@ int InternalStats::DumpCFMapStats(
     }
   }
 
+  char buf[1000];
+  // Per-ColumnFamily stats
+  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
+  value->append(buf);
+
+  CompactionStats stats_sum(0);
   int total_files = 0;
   int total_files_being_compacted = 0;
   double total_file_size = 0;
@@ -900,67 +755,40 @@ int InternalStats::DumpCFMapStats(
     total_files += files;
     total_files_being_compacted += files_being_compacted[level];
     if (comp_stats_[level].micros > 0 || files > 0) {
-      compaction_stats_sum->Add(comp_stats_[level]);
+      stats_sum.Add(comp_stats_[level]);
       total_file_size += vstorage->NumLevelBytes(level);
       double w_amp =
-          (comp_stats_[level].bytes_read_non_output_levels == 0)
-              ? 0.0
-              : static_cast<double>(comp_stats_[level].bytes_written) /
-                    comp_stats_[level].bytes_read_non_output_levels;
-      std::map<LevelStatType, double> level_stats;
-      PrepareLevelStats(&level_stats, files, files_being_compacted[level],
-                        static_cast<double>(vstorage->NumLevelBytes(level)),
-                        compaction_score[level], w_amp, comp_stats_[level]);
-      (*levels_stats)[level] = level_stats;
+          (comp_stats_[level].bytes_read_non_output_levels == 0) ? 0.0
+          : static_cast<double>(comp_stats_[level].bytes_written) /
+            comp_stats_[level].bytes_read_non_output_levels;
+      PrintLevelStats(buf, sizeof(buf), "L" + ToString(level), files,
+                      files_being_compacted[level],
+                      static_cast<double>(vstorage->NumLevelBytes(level)),
+                      compaction_score[level],
+                      w_amp, comp_stats_[level]);
+      value->append(buf);
     }
   }
   uint64_t flush_ingest = cf_stats_value_[BYTES_FLUSHED];
   uint64_t add_file_ingest = cf_stats_value_[BYTES_INGESTED_ADD_FILE];
   uint64_t curr_ingest = flush_ingest + add_file_ingest;
-  // Cumulative summary
-  double w_amp = compaction_stats_sum->bytes_written /
-                 static_cast<double>(curr_ingest + 1);
-  // Stats summary across levels
-  std::map<LevelStatType, double> sum_stats;
-  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];
-  // Per-ColumnFamily stats
-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
-  value->append(buf);
-
-  // Print stats for each level
-  std::map<int, std::map<LevelStatType, double>> levels_stats;
-  CompactionStats compaction_stats_sum(0);
-  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);
-    }
-  }
-  // Print sum of level stats
-  PrintLevelStats(buf, sizeof(buf), "Sum", levels_stats[-1]);
-  value->append(buf);
-
-  uint64_t flush_ingest = cf_stats_value_[BYTES_FLUSHED];
-  uint64_t add_file_ingest = cf_stats_value_[BYTES_INGESTED_ADD_FILE];
   uint64_t ingest_files_addfile = cf_stats_value_[INGESTED_NUM_FILES_TOTAL];
   uint64_t ingest_l0_files_addfile =
       cf_stats_value_[INGESTED_LEVEL0_NUM_FILES_TOTAL];
   uint64_t ingest_keys_addfile = cf_stats_value_[INGESTED_NUM_KEYS_TOTAL];
   // Cumulative summary
+  double w_amp = stats_sum.bytes_written / static_cast<double>(curr_ingest + 1);
   uint64_t total_stall_count =
       cf_stats_count_[LEVEL0_SLOWDOWN_TOTAL] +
       cf_stats_count_[LEVEL0_NUM_FILES_TOTAL] +
       cf_stats_count_[SOFT_PENDING_COMPACTION_BYTES_LIMIT] +
       cf_stats_count_[HARD_PENDING_COMPACTION_BYTES_LIMIT] +
       cf_stats_count_[MEMTABLE_COMPACTION] + cf_stats_count_[MEMTABLE_SLOWDOWN];
+  // Stats summary across levels
+  PrintLevelStats(buf, sizeof(buf), "Sum", total_files,
+                  total_files_being_compacted, total_file_size, 0, w_amp,
+                  stats_sum);
+  value->append(buf);
   // Interval summary
   uint64_t interval_flush_ingest =
       flush_ingest - cf_stats_snapshot_.ingest_bytes_flush;
@@ -968,10 +796,9 @@ void InternalStats::DumpCFStats(std::string* value) {
       add_file_ingest - cf_stats_snapshot_.ingest_bytes_addfile;
   uint64_t interval_ingest =
       interval_flush_ingest + interval_add_file_inget + 1;
-  CompactionStats interval_stats(compaction_stats_sum);
+  CompactionStats interval_stats(stats_sum);
   interval_stats.Subtract(cf_stats_snapshot_.comp_stats);
-  double w_amp =
-      interval_stats.bytes_written / static_cast<double>(interval_ingest);
+  w_amp = interval_stats.bytes_written / static_cast<double>(interval_ingest);
   PrintLevelStats(buf, sizeof(buf), "Int", 0, 0, 0, 0, w_amp, interval_stats);
   value->append(buf);
 
@@ -1082,7 +909,7 @@ void InternalStats::DumpCFStats(std::string* value) {
   cf_stats_snapshot_.ingest_files_addfile = ingest_files_addfile;
   cf_stats_snapshot_.ingest_l0_files_addfile = ingest_l0_files_addfile;
   cf_stats_snapshot_.ingest_keys_addfile = ingest_keys_addfile;
-  cf_stats_snapshot_.comp_stats = compaction_stats_sum;
+  cf_stats_snapshot_.comp_stats = stats_sum;
   cf_stats_snapshot_.stall_count = total_stall_count;
 }
 

db/internal_stats.h

@@ -9,12 +9,11 @@
 //
 
 #pragma once
-#include <map>
-#include <string>
-#include <vector>
-
 #include "db/version_set.h"
 
+#include <vector>
+#include <string>
+
 class ColumnFamilyData;
 
 namespace rocksdb {
@@ -42,47 +41,13 @@ struct DBPropertyInfo {
   //      holding db mutex, which is only supported for int properties.
   bool (InternalStats::*handle_int)(uint64_t* value, DBImpl* db,
                                     Version* version);
-  bool (InternalStats::*handle_map)(
-      std::map<std::string, double>* compaction_stats);
 };
 
 extern const DBPropertyInfo* GetPropertyInfo(const Slice& property);
 
 #ifndef ROCKSDB_LITE
-enum class LevelStatType {
-  INVALID = 0,
-  NUM_FILES,
-  COMPACTED_FILES,
-  SIZE_MB,
-  SCORE,
-  READ_GB,
-  RN_GB,
-  RNP1_GB,
-  WRITE_GB,
-  W_NEW_GB,
-  MOVED_GB,
-  WRITE_AMP,
-  READ_MBPS,
-  WRITE_MBPS,
-  COMP_SEC,
-  COMP_COUNT,
-  AVG_SEC,
-  KEY_IN,
-  KEY_DROP,
-  TOTAL  // total number of types
-};
-
-struct LevelStat {
-  // This what will be L?.property_name in the flat map returned to the user
-  std::string property_name;
-  // This will be what we will print in the header in the cli
-  std::string header_name;
-};
-
 class InternalStats {
  public:
-  static const std::map<LevelStatType, LevelStat> compaction_level_stats;
-
   enum InternalCFStatsType {
     LEVEL0_SLOWDOWN_TOTAL,
     LEVEL0_SLOWDOWN_WITH_COMPACTION,
@@ -256,10 +221,6 @@ class InternalStats {
   bool GetStringProperty(const DBPropertyInfo& property_info,
                          const Slice& property, std::string* value);
 
-  bool GetMapProperty(const DBPropertyInfo& property_info,
-                      const Slice& property,
-                      std::map<std::string, double>* value);
-
   bool GetIntProperty(const DBPropertyInfo& property_info, uint64_t* value,
                       DBImpl* db);
 
@@ -272,10 +233,6 @@ class InternalStats {
 
  private:
   void DumpDBStats(std::string* value);
-  void DumpCFMapStats(std::map<std::string, double>* cf_stats);
-  int DumpCFMapStats(
-      std::map<int, std::map<LevelStatType, double>>* level_stats,
-      CompactionStats* compaction_stats_sum);
   void DumpCFStats(std::string* value);
 
   // Per-DB stats
@@ -356,7 +313,6 @@ class InternalStats {
   bool HandleCompressionRatioAtLevelPrefix(std::string* value, Slice suffix);
   bool HandleLevelStats(std::string* value, Slice suffix);
   bool HandleStats(std::string* value, Slice suffix);
-  bool HandleCFMapStats(std::map<std::string, double>* compaction_stats);
   bool HandleCFStats(std::string* value, Slice suffix);
   bool HandleDBStats(std::string* value, Slice suffix);
   bool HandleSsTables(std::string* value, Slice suffix);
@@ -401,7 +357,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
@@ -493,12 +448,6 @@ class InternalStats {
     return false;
   }
 
-  bool GetMapProperty(const DBPropertyInfo& property_info,
-                      const Slice& property,
-                      std::map<std::string, double>* value) {
-    return false;
-  }
-
   bool GetIntProperty(const DBPropertyInfo& property_info, uint64_t* value,
                       DBImpl* db) const {
     return false;

db/listener_test.cc

@@ -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);

db/memtable.cc

@@ -17,7 +17,6 @@
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
 #include "db/pinned_iterators_manager.h"
-#include "port/port.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
@@ -25,12 +24,9 @@
 #include "rocksdb/slice_transform.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/internal_iterator.h"
-#include "table/iterator_wrapper.h"
 #include "table/merger.h"
 #include "util/arena.h"
-#include "util/autovector.h"
 #include "util/coding.h"
-#include "util/memory_usage.h"
 #include "util/murmurhash.h"
 #include "util/mutexlock.h"
 #include "util/perf_context_imp.h"
@@ -75,7 +71,6 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
       range_del_table_(SkipListFactory().CreateMemTableRep(
           comparator_, &allocator_, nullptr /* transform */,
           ioptions.info_log)),
-      is_range_del_table_empty_(true),
       data_size_(0),
       num_entries_(0),
       num_deletes_(0),
@@ -91,9 +86,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
                  : 0),
       prefix_extractor_(ioptions.prefix_extractor),
       flush_state_(FLUSH_NOT_REQUESTED),
-      env_(ioptions.env),
-      insert_with_hint_prefix_extractor_(
-          ioptions.memtable_insert_with_hint_prefix_extractor) {
+      env_(ioptions.env) {
   UpdateFlushState();
   // something went wrong if we need to flush before inserting anything
   assert(!ShouldScheduleFlush());
@@ -109,21 +102,17 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
 MemTable::~MemTable() { assert(refs_ == 0); }
 
 size_t MemTable::ApproximateMemoryUsage() {
-  autovector<size_t> usages = {arena_.ApproximateMemoryUsage(),
-                               table_->ApproximateMemoryUsage(),
-                               range_del_table_->ApproximateMemoryUsage(),
-                               rocksdb::ApproximateMemoryUsage(insert_hints_)};
-  size_t total_usage = 0;
-  for (size_t usage : usages) {
-    // If usage + total_usage >= kMaxSizet, return kMaxSizet.
-    // the following variation is to avoid numeric overflow.
-    if (usage >= port::kMaxSizet - total_usage) {
-      return port::kMaxSizet;
-    }
-    total_usage += usage;
+  size_t arena_usage = arena_.ApproximateMemoryUsage();
+  size_t table_usage = table_->ApproximateMemoryUsage();
+  table_usage += range_del_table_->ApproximateMemoryUsage();
+  // let MAX_USAGE =  std::numeric_limits<size_t>::max()
+  // then if arena_usage + total_usage >= MAX_USAGE, return MAX_USAGE.
+  // the following variation is to avoid numeric overflow.
+  if (arena_usage >= std::numeric_limits<size_t>::max() - table_usage) {
+    return std::numeric_limits<size_t>::max();
   }
   // otherwise, return the actual usage
-  return total_usage;
+  return arena_usage + table_usage;
 }
 
 bool MemTable::ShouldFlushNow() const {
@@ -322,13 +311,11 @@ class MemTableIterator : public InternalIterator {
     valid_ = iter_->Valid();
   }
   virtual void Next() override {
-    PERF_COUNTER_ADD(next_on_memtable_count, 1);
     assert(Valid());
     iter_->Next();
     valid_ = iter_->Valid();
   }
   virtual void Prev() override {
-    PERF_COUNTER_ADD(prev_on_memtable_count, 1);
     assert(Valid());
     iter_->Prev();
     valid_ = iter_->Valid();
@@ -377,12 +364,11 @@ InternalIterator* MemTable::NewIterator(const ReadOptions& read_options,
 }
 
 InternalIterator* MemTable::NewRangeTombstoneIterator(
-    const ReadOptions& read_options) {
-  if (read_options.ignore_range_deletions || is_range_del_table_empty_) {
-    return nullptr;
-  }
-  return new MemTableIterator(*this, read_options, nullptr /* arena */,
-                              true /* use_range_del_table */);
+    const ReadOptions& read_options, Arena* arena) {
+  assert(arena != nullptr);
+  auto mem = arena->AllocateAligned(sizeof(MemTableIterator));
+  return new (mem) MemTableIterator(*this, read_options, arena,
+                                    true /* use_range_del_table */);
 }
 
 port::RWMutex* MemTable::GetLock(const Slice& key) {
@@ -433,7 +419,6 @@ void MemTable::Add(SequenceNumber s, ValueType type,
 
   char* p = EncodeVarint32(buf, internal_key_size);
   memcpy(p, key.data(), key_size);
-  Slice key_slice(p, key_size);
   p += key_size;
   uint64_t packed = PackSequenceAndType(s, type);
   EncodeFixed64(p, packed);
@@ -442,14 +427,7 @@ void MemTable::Add(SequenceNumber s, ValueType type,
   memcpy(p, value.data(), val_size);
   assert((unsigned)(p + val_size - buf) == (unsigned)encoded_len);
   if (!allow_concurrent) {
-    // Extract prefix for insert with hint.
-    if (insert_with_hint_prefix_extractor_ != nullptr &&
-        insert_with_hint_prefix_extractor_->InDomain(key_slice)) {
-      Slice prefix = insert_with_hint_prefix_extractor_->Transform(key_slice);
-      table->InsertWithHint(handle, &insert_hints_[prefix]);
-    } else {
-      table->Insert(handle);
-    }
+    table->Insert(handle);
 
     // this is a bit ugly, but is the way to avoid locked instructions
     // when incrementing an atomic
@@ -507,9 +485,6 @@ void MemTable::Add(SequenceNumber s, ValueType type,
         !first_seqno_.compare_exchange_weak(cur_earliest_seqno, s)) {
     }
   }
-  if (is_range_del_table_empty_ && type == kTypeRangeDeletion) {
-    is_range_del_table_empty_ = false;
-  }
 }
 
 // Callback from MemTable::Get()
@@ -525,7 +500,6 @@ struct Saver {
   const MergeOperator* merge_operator;
   // the merge operations encountered;
   MergeContext* merge_context;
-  RangeDelAggregator* range_del_agg;
   MemTable* mem;
   Logger* logger;
   Statistics* statistics;
@@ -537,10 +511,9 @@ struct Saver {
 static bool SaveValue(void* arg, const char* entry) {
   Saver* s = reinterpret_cast<Saver*>(arg);
   MergeContext* merge_context = s->merge_context;
-  RangeDelAggregator* range_del_agg = s->range_del_agg;
   const MergeOperator* merge_operator = s->merge_operator;
 
-  assert(s != nullptr && merge_context != nullptr && range_del_agg != nullptr);
+  assert(s != nullptr && merge_context != nullptr);
 
   // entry format is:
   //    klength  varint32
@@ -560,10 +533,6 @@ static bool SaveValue(void* arg, const char* entry) {
     ValueType type;
     UnPackSequenceAndType(tag, &s->seq, &type);
 
-    if ((type == kTypeValue || type == kTypeMerge) &&
-        range_del_agg->ShouldDelete(Slice(key_ptr, key_length))) {
-      type = kTypeRangeDeletion;
-    }
     switch (type) {
       case kTypeValue: {
         if (s->inplace_update_support) {
@@ -586,8 +555,7 @@ static bool SaveValue(void* arg, const char* entry) {
         return false;
       }
       case kTypeDeletion:
-      case kTypeSingleDeletion:
-      case kTypeRangeDeletion: {
+      case kTypeSingleDeletion: {
         if (*(s->merge_in_progress)) {
           *(s->status) = MergeHelper::TimedFullMerge(
               merge_operator, s->key->user_key(), nullptr,
@@ -627,9 +595,7 @@ static bool SaveValue(void* arg, const char* entry) {
 }
 
 bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
-                   MergeContext* merge_context,
-                   RangeDelAggregator* range_del_agg, SequenceNumber* seq,
-                   const ReadOptions& read_opts) {
+                   MergeContext* merge_context, SequenceNumber* seq) {
   // The sequence number is updated synchronously in version_set.h
   if (IsEmpty()) {
     // Avoiding recording stats for speed.
@@ -652,13 +618,6 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
     if (prefix_bloom_) {
       PERF_COUNTER_ADD(bloom_memtable_hit_count, 1);
     }
-    std::unique_ptr<InternalIterator> range_del_iter(
-        NewRangeTombstoneIterator(read_opts));
-    Status status = range_del_agg->AddTombstones(std::move(range_del_iter));
-    if (!status.ok()) {
-      *s = status;
-      return false;
-    }
     Saver saver;
     saver.status = s;
     saver.found_final_value = &found_final_value;
@@ -668,7 +627,6 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
     saver.seq = kMaxSequenceNumber;
     saver.mem = this;
     saver.merge_context = merge_context;
-    saver.range_del_agg = range_del_agg;
     saver.merge_operator = moptions_.merge_operator;
     saver.logger = moptions_.info_log;
     saver.inplace_update_support = moptions_.inplace_update_support;
@@ -717,22 +675,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;
       }
     }
   }

db/memtable.h

@@ -13,11 +13,9 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <unordered_map>
 #include <vector>
 #include "db/dbformat.h"
 #include "db/memtable_allocator.h"
-#include "db/range_del_aggregator.h"
 #include "db/skiplist.h"
 #include "db/version_edit.h"
 #include "rocksdb/db.h"
@@ -26,7 +24,6 @@
 #include "util/cf_options.h"
 #include "util/concurrent_arena.h"
 #include "util/dynamic_bloom.h"
-#include "util/hash.h"
 #include "util/instrumented_mutex.h"
 
 namespace rocksdb {
@@ -161,7 +158,8 @@ class MemTable {
   //        those allocated in arena.
   InternalIterator* NewIterator(const ReadOptions& read_options, Arena* arena);
 
-  InternalIterator* NewRangeTombstoneIterator(const ReadOptions& read_options);
+  InternalIterator* NewRangeTombstoneIterator(const ReadOptions& read_options,
+                                              Arena* arena);
 
   // Add an entry into memtable that maps key to value at the
   // specified sequence number and with the specified type.
@@ -187,14 +185,12 @@ class MemTable {
   // On success, *s may be set to OK, NotFound, or MergeInProgress.  Any other
   // status returned indicates a corruption or other unexpected error.
   bool Get(const LookupKey& key, std::string* value, Status* s,
-           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           SequenceNumber* seq, const ReadOptions& read_opts);
+           MergeContext* merge_context, SequenceNumber* seq);
 
   bool Get(const LookupKey& key, std::string* value, Status* s,
-           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           const ReadOptions& read_opts) {
+           MergeContext* merge_context) {
     SequenceNumber seq;
-    return Get(key, value, s, merge_context, range_del_agg, &seq, read_opts);
+    return Get(key, value, s, merge_context, &seq);
   }
 
   // Attempts to update the new_value inplace, else does normal Add
@@ -352,7 +348,6 @@ class MemTable {
   MemTableAllocator allocator_;
   unique_ptr<MemTableRep> table_;
   unique_ptr<MemTableRep> range_del_table_;
-  bool is_range_del_table_empty_;
 
   // Total data size of all data inserted
   std::atomic<uint64_t> data_size_;
@@ -392,12 +387,6 @@ class MemTable {
 
   Env* env_;
 
-  // Extract sequential insert prefixes.
-  const SliceTransform* insert_with_hint_prefix_extractor_;
-
-  // Insert hints for each prefix.
-  std::unordered_map<Slice, void*, SliceHasher> insert_hints_;
-
   // Returns a heuristic flush decision
   bool ShouldFlushNow() const;
 

db/memtable_list.cc

@@ -102,36 +102,27 @@ int MemTableList::NumFlushed() const {
 // Operands stores the list of merge operations to apply, so far.
 bool MemTableListVersion::Get(const LookupKey& key, std::string* value,
                               Status* s, MergeContext* merge_context,
-                              RangeDelAggregator* range_del_agg,
-                              SequenceNumber* seq,
-                              const ReadOptions& read_opts) {
-  return GetFromList(&memlist_, key, value, s, merge_context, range_del_agg,
-                     seq, read_opts);
+                              SequenceNumber* seq) {
+  return GetFromList(&memlist_, key, value, s, merge_context, seq);
 }
 
 bool MemTableListVersion::GetFromHistory(const LookupKey& key,
                                          std::string* value, Status* s,
                                          MergeContext* merge_context,
-                                         RangeDelAggregator* range_del_agg,
-                                         SequenceNumber* seq,
-                                         const ReadOptions& read_opts) {
-  return GetFromList(&memlist_history_, key, value, s, merge_context,
-                     range_del_agg, seq, read_opts);
+                                         SequenceNumber* seq) {
+  return GetFromList(&memlist_history_, key, value, s, merge_context, seq);
 }
 
 bool MemTableListVersion::GetFromList(std::list<MemTable*>* list,
                                       const LookupKey& key, std::string* value,
                                       Status* s, MergeContext* merge_context,
-                                      RangeDelAggregator* range_del_agg,
-                                      SequenceNumber* seq,
-                                      const ReadOptions& read_opts) {
+                                      SequenceNumber* seq) {
   *seq = kMaxSequenceNumber;
 
   for (auto& memtable : *list) {
     SequenceNumber current_seq = kMaxSequenceNumber;
 
-    bool done = memtable->Get(key, value, s, merge_context, range_del_agg,
-                              &current_seq, read_opts);
+    bool done = memtable->Get(key, value, s, merge_context, &current_seq);
     if (*seq == kMaxSequenceNumber) {
       // Store the most recent sequence number of any operation on this key.
       // Since we only care about the most recent change, we only need to
@@ -144,28 +135,10 @@ bool MemTableListVersion::GetFromList(std::list<MemTable*>* list,
       assert(*seq != kMaxSequenceNumber);
       return true;
     }
-    if (!done && !s->ok() && !s->IsMergeInProgress() && !s->IsNotFound()) {
-      return false;
-    }
   }
   return false;
 }
 
-Status MemTableListVersion::AddRangeTombstoneIterators(
-    const ReadOptions& read_opts, Arena* arena,
-    RangeDelAggregator* range_del_agg) {
-  assert(range_del_agg != nullptr);
-  for (auto& m : memlist_) {
-    std::unique_ptr<InternalIterator> range_del_iter(
-        m->NewRangeTombstoneIterator(read_opts));
-    Status s = range_del_agg->AddTombstones(std::move(range_del_iter));
-    if (!s.ok()) {
-      return s;
-    }
-  }
-  return Status::OK();
-}
-
 void MemTableListVersion::AddIterators(
     const ReadOptions& options, std::vector<InternalIterator*>* iterator_list,
     Arena* arena) {

db/memtable_list.h

@@ -14,7 +14,6 @@
 #include "db/dbformat.h"
 #include "db/filename.h"
 #include "db/memtable.h"
-#include "db/range_del_aggregator.h"
 #include "db/skiplist.h"
 #include "rocksdb/db.h"
 #include "rocksdb/iterator.h"
@@ -54,14 +53,12 @@ class MemTableListVersion {
   // will be stored in *seq on success (regardless of whether true/false is
   // returned).  Otherwise, *seq will be set to kMaxSequenceNumber.
   bool Get(const LookupKey& key, std::string* value, Status* s,
-           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           SequenceNumber* seq, const ReadOptions& read_opts);
+           MergeContext* merge_context, SequenceNumber* seq);
 
   bool Get(const LookupKey& key, std::string* value, Status* s,
-           MergeContext* merge_context, RangeDelAggregator* range_del_agg,
-           const ReadOptions& read_opts) {
+           MergeContext* merge_context) {
     SequenceNumber seq;
-    return Get(key, value, s, merge_context, range_del_agg, &seq, read_opts);
+    return Get(key, value, s, merge_context, &seq);
   }
 
   // Similar to Get(), but searches the Memtable history of memtables that
@@ -69,21 +66,13 @@ class MemTableListVersion {
   // queries (such as Transaction validation) as the history may contain
   // writes that are also present in the SST files.
   bool GetFromHistory(const LookupKey& key, std::string* value, Status* s,
-                      MergeContext* merge_context,
-                      RangeDelAggregator* range_del_agg, SequenceNumber* seq,
-                      const ReadOptions& read_opts);
+                      MergeContext* merge_context, SequenceNumber* seq);
   bool GetFromHistory(const LookupKey& key, std::string* value, Status* s,
-                      MergeContext* merge_context,
-                      RangeDelAggregator* range_del_agg,
-                      const ReadOptions& read_opts) {
+                      MergeContext* merge_context) {
     SequenceNumber seq;
-    return GetFromHistory(key, value, s, merge_context, range_del_agg, &seq,
-                          read_opts);
+    return GetFromHistory(key, value, s, merge_context, &seq);
   }
 
-  Status AddRangeTombstoneIterators(const ReadOptions& read_opts, Arena* arena,
-                                    RangeDelAggregator* range_del_agg);
-
   void AddIterators(const ReadOptions& options,
                     std::vector<InternalIterator*>* iterator_list,
                     Arena* arena);
@@ -113,8 +102,7 @@ class MemTableListVersion {
 
   bool GetFromList(std::list<MemTable*>* list, const LookupKey& key,
                    std::string* value, Status* s, MergeContext* merge_context,
-                   RangeDelAggregator* range_del_agg, SequenceNumber* seq,
-                   const ReadOptions& read_opts);
+                   SequenceNumber* seq);
 
   void AddMemTable(MemTable* m);
 
@@ -221,8 +209,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&);

db/memtable_list_test.cc

@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 #include "db/merge_context.h"
-#include "db/range_del_aggregator.h"
 #include "db/version_set.h"
 #include "db/write_controller.h"
 #include "rocksdb/db.h"
@@ -117,13 +116,10 @@ TEST_F(MemTableListTest, GetTest) {
   std::string value;
   Status s;
   MergeContext merge_context;
-  InternalKeyComparator ikey_cmp(options.comparator);
-  RangeDelAggregator range_del_agg(ikey_cmp, {} /* snapshots */);
   autovector<MemTable*> to_delete;
 
   LookupKey lkey("key1", seq);
-  bool found = list.current()->Get(lkey, &value, &s, &merge_context,
-                                   &range_del_agg, ReadOptions());
+  bool found = list.current()->Get(lkey, &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   // Create a MemTable
@@ -145,20 +141,17 @@ TEST_F(MemTableListTest, GetTest) {
 
   // Fetch the newly written keys
   merge_context.Clear();
-  found = mem->Get(LookupKey("key1", seq), &value, &s, &merge_context,
-                   &range_del_agg, ReadOptions());
+  found = mem->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ(value, "value1");
 
   merge_context.Clear();
-  found = mem->Get(LookupKey("key1", 2), &value, &s, &merge_context,
-                   &range_del_agg, ReadOptions());
+  found = mem->Get(LookupKey("key1", 2), &value, &s, &merge_context);
   // MemTable found out that this key is *not* found (at this sequence#)
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
-  found = mem->Get(LookupKey("key2", seq), &value, &s, &merge_context,
-                   &range_del_agg, ReadOptions());
+  found = mem->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ(value, "value2.2");
 
@@ -184,25 +177,24 @@ TEST_F(MemTableListTest, GetTest) {
 
   // Fetch keys via MemTableList
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key1", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
   found = list.current()->Get(LookupKey("key1", saved_seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+                              &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ("value1", value);
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ(value, "value2.3");
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", 1), &value, &s, &merge_context,
-                              &range_del_agg, ReadOptions());
+  found = list.current()->Get(LookupKey("key2", 1), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   ASSERT_EQ(2, list.NumNotFlushed());
@@ -224,13 +216,10 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
   std::string value;
   Status s;
   MergeContext merge_context;
-  InternalKeyComparator ikey_cmp(options.comparator);
-  RangeDelAggregator range_del_agg(ikey_cmp, {} /* snapshots */);
   autovector<MemTable*> to_delete;
 
   LookupKey lkey("key1", seq);
-  bool found = list.current()->Get(lkey, &value, &s, &merge_context,
-                                   &range_del_agg, ReadOptions());
+  bool found = list.current()->Get(lkey, &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   // Create a MemTable
@@ -251,14 +240,12 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
 
   // Fetch the newly written keys
   merge_context.Clear();
-  found = mem->Get(LookupKey("key1", seq), &value, &s, &merge_context,
-                   &range_del_agg, ReadOptions());
+  found = mem->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   // MemTable found out that this key is *not* found (at this sequence#)
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
-  found = mem->Get(LookupKey("key2", seq), &value, &s, &merge_context,
-                   &range_del_agg, ReadOptions());
+  found = mem->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ(value, "value2.2");
 
@@ -268,13 +255,13 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
 
   // Fetch keys via MemTableList
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key1", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_TRUE(s.ok() && found);
   ASSERT_EQ("value2.2", value);
 
@@ -293,26 +280,24 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
 
   // Verify keys are no longer in MemTableList
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key1", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   // Verify keys are present in history
   merge_context.Clear();
   found = list.current()->GetFromHistory(LookupKey("key1", seq), &value, &s,
-                                         &merge_context, &range_del_agg,
-                                         ReadOptions());
+                                         &merge_context);
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
   found = list.current()->GetFromHistory(LookupKey("key2", seq), &value, &s,
-                                         &merge_context, &range_del_agg,
-                                         ReadOptions());
+                                         &merge_context);
   ASSERT_TRUE(found);
   ASSERT_EQ("value2.2", value);
 
@@ -353,38 +338,36 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
 
   // Verify keys are no longer in MemTableList
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key1", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key1", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key3", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key3", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   // Verify that the second memtable's keys are in the history
   merge_context.Clear();
   found = list.current()->GetFromHistory(LookupKey("key1", seq), &value, &s,
-                                         &merge_context, &range_del_agg,
-                                         ReadOptions());
+                                         &merge_context);
   ASSERT_TRUE(found && s.IsNotFound());
 
   merge_context.Clear();
   found = list.current()->GetFromHistory(LookupKey("key3", seq), &value, &s,
-                                         &merge_context, &range_del_agg,
-                                         ReadOptions());
+                                         &merge_context);
   ASSERT_TRUE(found);
   ASSERT_EQ("value3", value);
 
   // Verify that key2 from the first memtable is no longer in the history
   merge_context.Clear();
-  found = list.current()->Get(LookupKey("key2", seq), &value, &s,
-                              &merge_context, &range_del_agg, ReadOptions());
+  found =
+      list.current()->Get(LookupKey("key2", seq), &value, &s, &merge_context);
   ASSERT_FALSE(found);
 
   // Cleanup

db/merge_helper.cc

@@ -83,7 +83,6 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
   assert(HasOperator());
   keys_.clear();
   merge_context_.Clear();
-  has_compaction_filter_skip_until_ = false;
   assert(user_merge_operator_);
   bool first_key = true;
 
@@ -104,10 +103,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());
 
@@ -150,8 +145,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
 
       // TODO(noetzli) If the merge operator returns false, we are currently
       // (almost) silently dropping the put/delete. That's probably not what we
-      // want. Also if we're in compaction and it's a put, it would be nice to
-      // run compaction filter on it.
+      // want.
       const Slice val = iter->value();
       const Slice* val_ptr = (kTypeValue == ikey.type) ? &val : nullptr;
       std::string merge_result;
@@ -191,20 +185,10 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       // 1) it's included in one of the snapshots. in that case we *must* write
       // it out, no matter what compaction filter says
       // 2) it's not filtered by a compaction filter
-      CompactionFilter::Decision filter =
-          ikey.sequence <= latest_snapshot_
-              ? CompactionFilter::Decision::kKeep
-              : FilterMerge(orig_ikey.user_key, value_slice);
-      if (range_del_agg != nullptr &&
-
-          range_del_agg->ShouldDelete(
-              iter->key(),
-              RangeDelAggregator::RangePositioningMode::kForwardTraversal) &&
-          filter != CompactionFilter::Decision::kRemoveAndSkipUntil) {
-        filter = CompactionFilter::Decision::kRemove;
-      }
-      if (filter == CompactionFilter::Decision::kKeep ||
-          filter == CompactionFilter::Decision::kChangeValue) {
+      if ((ikey.sequence <= latest_snapshot_ ||
+           !FilterMerge(orig_ikey.user_key, value_slice)) &&
+          (range_del_agg == nullptr ||
+           !range_del_agg->ShouldDelete(iter->key()))) {
         if (original_key_is_iter) {
           // this is just an optimization that saves us one memcpy
           keys_.push_front(std::move(original_key));
@@ -216,21 +200,8 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
           // original_key before
           ParseInternalKey(keys_.back(), &orig_ikey);
         }
-        if (filter == CompactionFilter::Decision::kKeep) {
-          merge_context_.PushOperand(
-              value_slice, iter->IsValuePinned() /* operand_pinned */);
-        } else {  // kChangeValue
-          // Compaction filter asked us to change the operand from value_slice
-          // to compaction_filter_value_.
-          merge_context_.PushOperand(compaction_filter_value_, false);
-        }
-      } else if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil) {
-        // Compaction filter asked us to remove this key altogether
-        // (not just this operand), along with some keys following it.
-        keys_.clear();
-        merge_context_.Clear();
-        has_compaction_filter_skip_until_ = true;
-        return Status::OK();
+        merge_context_.PushOperand(value_slice,
+                                   iter->IsValuePinned() /* operand_pinned */);
       }
     }
   }
@@ -282,6 +253,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_) {
@@ -330,32 +305,17 @@ void MergeOutputIterator::Next() {
   ++it_values_;
 }
 
-CompactionFilter::Decision MergeHelper::FilterMerge(const Slice& user_key,
-                                                    const Slice& value_slice) {
+bool MergeHelper::FilterMerge(const Slice& user_key, const Slice& value_slice) {
   if (compaction_filter_ == nullptr) {
-    return CompactionFilter::Decision::kKeep;
+    return false;
   }
   if (stats_ != nullptr) {
     filter_timer_.Start();
   }
-  compaction_filter_value_.clear();
-  compaction_filter_skip_until_.Clear();
-  auto ret = compaction_filter_->FilterV2(
-      level_, user_key, CompactionFilter::ValueType::kMergeOperand, value_slice,
-      &compaction_filter_value_, compaction_filter_skip_until_.rep());
-  if (ret == CompactionFilter::Decision::kRemoveAndSkipUntil) {
-    if (user_comparator_->Compare(*compaction_filter_skip_until_.rep(),
-                                  user_key) <= 0) {
-      // Invalid skip_until returned from compaction filter.
-      // Keep the key as per FilterV2 documentation.
-      ret = CompactionFilter::Decision::kKeep;
-    } else {
-      compaction_filter_skip_until_.ConvertFromUserKey(kMaxSequenceNumber,
-                                                       kValueTypeForSeek);
-    }
-  }
+  bool to_delete =
+      compaction_filter_->FilterMergeOperand(level_, user_key, value_slice);
   total_filter_time_ += filter_timer_.ElapsedNanosSafe();
-  return ret;
+  return to_delete;
 }
 
 } // namespace rocksdb

db/merge_helper.h

@@ -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),
@@ -71,7 +69,6 @@ class MergeHelper {
   //     - a Put/Delete,
   //     - a different user key,
   //     - a specific sequence number (snapshot boundary),
-  //     - REMOVE_AND_SKIP_UNTIL returned from compaction filter,
   //  or - the end of iteration
   // iter: (IN)  points to the first merge type entry
   //       (OUT) points to the first entry not included in the merge process
@@ -83,12 +80,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,
@@ -97,11 +92,8 @@ class MergeHelper {
                     const bool at_bottom = false);
 
   // Filters a merge operand using the compaction filter specified
-  // in the constructor. Returns the decision that the filter made.
-  // Uses compaction_filter_value_ and compaction_filter_skip_until_ for the
-  // optional outputs of compaction filter.
-  CompactionFilter::Decision FilterMerge(const Slice& user_key,
-                                         const Slice& value_slice);
+  // in the constructor. Returns true if the operand should be filtered out.
+  bool FilterMerge(const Slice& user_key, const Slice& value_slice);
 
   // Query the merge result
   // These are valid until the next MergeUntil call
@@ -135,26 +127,11 @@ class MergeHelper {
   uint64_t TotalFilterTime() const { return total_filter_time_; }
   bool HasOperator() const { return user_merge_operator_ != nullptr; }
 
-  // If compaction filter returned REMOVE_AND_SKIP_UNTIL, this method will
-  // return true and fill *until with the key to which we should skip.
-  // If true, keys() and values() are empty.
-  bool FilteredUntil(Slice* skip_until) const {
-    if (!has_compaction_filter_skip_until_) {
-      return false;
-    }
-    assert(compaction_filter_ != nullptr);
-    assert(skip_until != nullptr);
-    assert(compaction_filter_skip_until_.Valid());
-    *skip_until = compaction_filter_skip_until_.Encode();
-    return true;
-  }
-
  private:
   Env* env_;
   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?
@@ -172,15 +149,6 @@ class MergeHelper {
   StopWatchNano filter_timer_;
   uint64_t total_filter_time_;
   Statistics* stats_;
-
-  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.

db/pinned_iterators_manager.h

@@ -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:

db/plain_table_db_test.cc

@@ -142,7 +142,6 @@ class PlainTableDBTest : public testing::Test,
 
     options.prefix_extractor.reset(NewFixedPrefixTransform(8));
     options.allow_mmap_reads = mmap_mode_;
-    options.allow_concurrent_memtable_write = false;
     return options;
   }
 

db/prefix_test.cc

@@ -222,7 +222,6 @@ class PrefixTest : public testing::Test {
     bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
     bbto.whole_key_filtering = false;
     options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-    options.allow_concurrent_memtable_write = false;
 
     Status s = DB::Open(options, kDbName,  &db);
     EXPECT_OK(s);

db/range_del_aggregator.cc

@@ -11,156 +11,61 @@ 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) {
-  InitRep(snapshots);
-}
-
-RangeDelAggregator::RangeDelAggregator(const InternalKeyComparator& icmp,
-                                       SequenceNumber snapshot,
-                                       bool collapse_deletions /* = false */)
-    : upper_bound_(snapshot),
-      icmp_(icmp),
-      collapse_deletions_(collapse_deletions) {}
-
-void RangeDelAggregator::InitRep(const std::vector<SequenceNumber>& snapshots) {
-  assert(rep_ == nullptr);
-  rep_.reset(new Rep());
+    const std::vector<SequenceNumber>& snapshots)
+    : icmp_(icmp) {
+  pinned_iters_mgr_.StartPinning();
   for (auto snapshot : snapshots) {
-    rep_->stripe_map_.emplace(
+    stripe_map_.emplace(
         snapshot,
-        PositionalTombstoneMap(TombstoneMap(
-            stl_wrappers::LessOfComparator(icmp_.user_comparator()))));
+        TombstoneMap(stl_wrappers::LessOfComparator(icmp_.user_comparator())));
   }
   // Data newer than any snapshot falls in this catch-all stripe
-  rep_->stripe_map_.emplace(
-      kMaxSequenceNumber,
-      PositionalTombstoneMap(TombstoneMap(
-          stl_wrappers::LessOfComparator(icmp_.user_comparator()))));
-  rep_->pinned_iters_mgr_.StartPinning();
+  stripe_map_.emplace(kMaxSequenceNumber, TombstoneMap());
 }
 
-bool RangeDelAggregator::ShouldDelete(
-    const Slice& internal_key, RangeDelAggregator::RangePositioningMode mode) {
-  if (rep_ == nullptr) {
-    return false;
-  }
+bool RangeDelAggregator::ShouldDelete(const Slice& internal_key,
+                                      bool for_compaction /* = false */) {
   ParsedInternalKey parsed;
   if (!ParseInternalKey(internal_key, &parsed)) {
     assert(false);
   }
-  return ShouldDelete(parsed, mode);
-}
-
-bool RangeDelAggregator::ShouldDelete(
-    const ParsedInternalKey& parsed,
-    RangeDelAggregator::RangePositioningMode mode) {
   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;
+
+  // Starting point is the snapshot stripe in which the key lives, then need to
+  // search all earlier stripes too, unless it's for compaction.
+  for (auto stripe_map_iter = GetStripeMapIter(parsed.sequence);
+       stripe_map_iter != stripe_map_.end(); ++stripe_map_iter) {
+    const auto& tombstone_map = stripe_map_iter->second;
+    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;
       }
-      return false;
-    case kForwardTraversal:
-      assert(collapse_deletions_ && tombstone_map_iter != tombstone_map.end());
-      if (tombstone_map_iter == tombstone_map.begin() &&
+      if (parsed.sequence < tombstone.seq_ &&
           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;
+                                           tombstone.end_key_) <= 0) {
+        return true;
       }
+    }
+    if (for_compaction) {
       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;
-      break;
+    }
   }
-  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;
-  }
-  auto stripe_map_iter = rep_->stripe_map_.begin();
-  assert(stripe_map_iter != rep_->stripe_map_.end());
+  auto stripe_map_iter = stripe_map_.begin();
+  assert(stripe_map_iter != stripe_map_.end());
   if (bottommost_level) {
     // 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;
   }
-  while (stripe_map_iter != rep_->stripe_map_.end()) {
-    if (!stripe_map_iter->second.raw_map.empty()) {
+  while (stripe_map_iter != stripe_map_.end()) {
+    if (!stripe_map_iter->second.empty()) {
       return true;
     }
     ++stripe_map_iter;
@@ -168,215 +73,46 @@ bool RangeDelAggregator::ShouldAddTombstones(
   return false;
 }
 
+Status RangeDelAggregator::AddTombstones(ScopedArenaIterator input) {
+  return AddTombstones(input.release(), true /* arena */);
+}
+
 Status RangeDelAggregator::AddTombstones(
     std::unique_ptr<InternalIterator> input) {
-  if (input == nullptr) {
-    return Status::OK();
-  }
+  return AddTombstones(input.release(), false /* arena */);
+}
+
+Status RangeDelAggregator::AddTombstones(InternalIterator* input, bool arena) {
+  pinned_iters_mgr_.PinIterator(input, arena);
   input->SeekToFirst();
-  bool first_iter = true;
   while (input->Valid()) {
-    if (first_iter) {
-      if (rep_ == nullptr) {
-        InitRep({upper_bound_});
-      } else {
-        InvalidateTombstoneMapPositions();
-      }
-      first_iter = false;
-    }
     ParsedInternalKey parsed_key;
     if (!ParseInternalKey(input->key(), &parsed_key)) {
       return Status::Corruption("Unable to parse range tombstone InternalKey");
     }
     RangeTombstone tombstone(parsed_key, input->value());
-    AddTombstone(std::move(tombstone));
+    auto& tombstone_map = GetStripeMapIter(tombstone.seq_)->second;
+    tombstone_map.emplace(tombstone.start_key_.ToString(),
+                          std::move(tombstone));
     input->Next();
   }
-  if (!first_iter) {
-    rep_->pinned_iters_mgr_.PinIterator(input.release(), false /* arena */);
-  }
   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) {
-  assert(rep_ != nullptr);
+RangeDelAggregator::StripeMap::iterator RangeDelAggregator::GetStripeMapIter(
+    SequenceNumber seq) {
   // The stripe includes seqnum for the snapshot above and excludes seqnum for
   // the snapshot below.
   StripeMap::iterator iter;
   if (seq > 0) {
     // upper_bound() checks strict inequality so need to subtract one
-    iter = rep_->stripe_map_.upper_bound(seq - 1);
+    iter = stripe_map_.upper_bound(seq - 1);
   } else {
-    iter = rep_->stripe_map_.begin();
+    iter = stripe_map_.begin();
   }
   // catch-all stripe justifies this assertion in either of above cases
-  assert(iter != rep_->stripe_map_.end());
-  return iter->second;
+  assert(iter != stripe_map_.end());
+  return iter;
 }
 
 // TODO(andrewkr): We should implement an iterator over range tombstones in our
@@ -384,27 +120,14 @@ RangeDelAggregator::GetPositionalTombstoneMap(SequenceNumber seq) {
 // tombstones are known to be available, without the code duplication we have
 // in ShouldAddTombstones(). It'll also allow us to move the table-modifying
 // code into more coherent places: CompactionJob and BuildTable().
-void RangeDelAggregator::AddToBuilder(
-    TableBuilder* builder, const Slice* lower_bound, const Slice* upper_bound,
-    FileMetaData* meta,
-    CompactionIterationStats* range_del_out_stats /* = nullptr */,
-    bool bottommost_level /* = false */) {
-  if (rep_ == nullptr) {
-    return;
-  }
-  auto stripe_map_iter = rep_->stripe_map_.begin();
-  assert(stripe_map_iter != rep_->stripe_map_.end());
+void RangeDelAggregator::AddToBuilder(TableBuilder* builder,
+                                      bool extend_before_min_key,
+                                      const Slice* next_table_min_key,
+                                      FileMetaData* meta,
+                                      bool bottommost_level /* = false */) {
+  auto stripe_map_iter = stripe_map_.begin();
+  assert(stripe_map_iter != 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);
-    }
     // 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;
@@ -413,38 +136,23 @@ void RangeDelAggregator::AddToBuilder(
   // Note the order in which tombstones are stored is insignificant since we
   // 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;
-      }
-      if (upper_bound != nullptr &&
-          icmp_.user_comparator()->Compare(*upper_bound,
-                                           tombstone.start_key_) <= 0) {
-        // Tombstones starting at upper_bound or later only need to be included
-        // in the next table. Break because subsequent tombstones will start
-        // even later.
+  while (stripe_map_iter != stripe_map_.end()) {
+    for (const auto& start_key_and_tombstone : stripe_map_iter->second) {
+      const auto& tombstone = start_key_and_tombstone.second;
+      if (next_table_min_key != nullptr &&
+          icmp_.user_comparator()->Compare(*next_table_min_key,
+                                           tombstone.start_key_) < 0) {
+        // Tombstones starting after next_table_min_key only need to be included
+        // in the next table.
         break;
       }
-      if (lower_bound != nullptr &&
+      if (!extend_before_min_key && meta->smallest.size() != 0 &&
           icmp_.user_comparator()->Compare(tombstone.end_key_,
-                                           *lower_bound) <= 0) {
-        // Tombstones ending before or at lower_bound only need to be included
-        // in the prev table. Continue because subsequent tombstones may still
-        // overlap [lower_bound, upper_bound).
+                                           meta->smallest.user_key()) < 0) {
+        // Tombstones ending before this table's smallest key can conditionally
+        // be excluded, e.g., when this table is a non-first compaction output,
+        // we know such tombstones are included in the previous table. In that
+        // case extend_before_min_key would be false.
         continue;
       }
 
@@ -452,49 +160,35 @@ void RangeDelAggregator::AddToBuilder(
       builder->Add(ikey_and_end_key.first.Encode(), ikey_and_end_key.second);
       if (!first_added) {
         first_added = true;
-        InternalKey smallest_candidate = std::move(ikey_and_end_key.first);;
-        if (lower_bound != nullptr &&
-            icmp_.user_comparator()->Compare(smallest_candidate.user_key(),
-                                             *lower_bound) <= 0) {
-          // Pretend the smallest key has the same user key as lower_bound
-          // (the max key in the previous table or subcompaction) in order for
-          // files to appear key-space partitioned.
-          //
-          // Choose lowest seqnum so this file's smallest internal key comes
-          // after the previous file's/subcompaction's largest. The fake seqnum
-          // is OK because the read path's file-picking code only considers user
-          // key.
-          smallest_candidate = InternalKey(*lower_bound, 0, kTypeRangeDeletion);
-        }
-        if (meta->smallest.size() == 0 ||
-            icmp_.Compare(smallest_candidate, meta->smallest) < 0) {
-          meta->smallest = std::move(smallest_candidate);
+        if (extend_before_min_key &&
+            (meta->smallest.size() == 0 ||
+             icmp_.Compare(ikey_and_end_key.first, meta->smallest) < 0)) {
+          meta->smallest = ikey_and_end_key.first;
         }
       }
-      InternalKey largest_candidate = tombstone.SerializeEndKey();
-      if (upper_bound != nullptr &&
-          icmp_.user_comparator()->Compare(*upper_bound,
-                                           largest_candidate.user_key()) <= 0) {
-        // Pretend the largest key has the same user key as upper_bound (the
-        // min key in the following table or subcompaction) in order for files
-        // to appear key-space partitioned.
-        //
-        // Choose highest seqnum so this file's largest internal key comes
-        // before the next file's/subcompaction's smallest. The fake seqnum is
-        // OK because the read path's file-picking code only considers the user
-        // key portion.
-        //
-        // Note Seek() also creates InternalKey with (user_key,
-        // kMaxSequenceNumber), but with kTypeDeletion (0x7) instead of
-        // kTypeRangeDeletion (0xF), so the range tombstone comes before the
-        // Seek() key in InternalKey's ordering. So Seek() will look in the
-        // next file for the user key.
-        largest_candidate = InternalKey(*upper_bound, kMaxSequenceNumber,
-                                        kTypeRangeDeletion);
-      }
+      auto end_ikey = tombstone.SerializeEndKey();
       if (meta->largest.size() == 0 ||
-          icmp_.Compare(meta->largest, largest_candidate) < 0) {
-        meta->largest = std::move(largest_candidate);
+          icmp_.Compare(meta->largest, end_ikey) < 0) {
+        if (next_table_min_key != nullptr &&
+            icmp_.Compare(*next_table_min_key, end_ikey.Encode()) < 0) {
+          // Pretend the largest key has the same user key as the min key in the
+          // following table in order for files to appear key-space partitioned.
+          // Choose highest seqnum so this file's largest comes before the next
+          // file's smallest. The fake seqnum is OK because the read path's
+          // file-picking code only considers the user key portion.
+          //
+          // Note Seek() also creates InternalKey with (user_key,
+          // kMaxSequenceNumber), but with kTypeDeletion (0x7) instead of
+          // kTypeRangeDeletion (0xF), so the range tombstone comes before the
+          // Seek() key in InternalKey's ordering. So Seek() will look in the
+          // next file for the user key.
+          ParsedInternalKey parsed;
+          ParseInternalKey(*next_table_min_key, &parsed);
+          meta->largest = InternalKey(parsed.user_key, kMaxSequenceNumber,
+                                      kTypeRangeDeletion);
+        } else {
+          meta->largest = std::move(end_ikey);
+        }
       }
       meta->smallest_seqno = std::min(meta->smallest_seqno, tombstone.seq_);
       meta->largest_seqno = std::max(meta->largest_seqno, tombstone.seq_);
@@ -503,17 +197,4 @@ void RangeDelAggregator::AddToBuilder(
   }
 }
 
-bool RangeDelAggregator::IsEmpty() {
-  if (rep_ == nullptr) {
-    return true;
-  }
-  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()) {
-      return false;
-    }
-  }
-  return true;
-}
-
 }  // namespace rocksdb

db/range_del_aggregator.h

@@ -9,7 +9,6 @@
 #include <string>
 #include <vector>
 
-#include "db/compaction_iteration_stats.h"
 #include "db/dbformat.h"
 #include "db/pinned_iterators_manager.h"
 #include "db/version_edit.h"
@@ -21,141 +20,34 @@
 #include "util/kv_map.h"
 
 namespace rocksdb {
-
-// A RangeDelAggregator aggregates range deletion tombstones as they are
-// encountered in memtables/SST files. It provides methods that check whether a
-// key is covered by range tombstones or write the relevant tombstones to a new
-// SST file.
 class RangeDelAggregator {
  public:
-  // @param snapshots These are used to organize the tombstones into snapshot
-  //    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.
-  // 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().
-  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,
-  };
-
-  // 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 Slice& internal_key, bool for_compaction = false);
   bool ShouldAddTombstones(bool bottommost_level = false);
-
-  // Adds tombstones to the tombstone aggregation structure maintained by this
-  // object.
-  // @return non-OK status if any of the tombstone keys are corrupted.
+  Status AddTombstones(ScopedArenaIterator input);
   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;
-  //    otherwise, it starts from meta->smallest.
-  // @param lower_bound/upper_bound Any range deletion with [start_key, end_key)
-  //    that overlaps the target range [*lower_bound, *upper_bound) is added to
-  //    the builder. If lower_bound is nullptr, the target range extends
-  //    infinitely to the left. If upper_bound is nullptr, the target range
-  //    extends infinitely to the right. If both are nullptr, the target range
-  //    extends infinitely in both directions, i.e., all range deletions are
-  //    added to the builder.
-  // @param meta The file's metadata. We modify the begin and end keys according
-  //    to the range tombstones added to this file such that the read path does
-  //    not miss range tombstones that cover gaps before/after/between files in
-  //    a level. lower_bound/upper_bound above constrain how far file boundaries
-  //    can be extended.
-  // @param bottommost_level If true, we will filter out any tombstones
-  //    belonging to the oldest snapshot stripe, because all keys potentially
-  //    covered by this tombstone are guaranteed to have been deleted by
-  //    compaction.
-  void AddToBuilder(TableBuilder* builder, const Slice* lower_bound,
-                    const Slice* upper_bound, FileMetaData* meta,
-                    CompactionIterationStats* range_del_out_stats = nullptr,
+  // write tombstones covering a range to a table builder
+  // usually don't add to a max-level table builder
+  void AddToBuilder(TableBuilder* builder, bool extend_before_min_key,
+                    const Slice* next_table_min_key, FileMetaData* meta,
                     bool bottommost_level = false);
-  bool IsEmpty();
 
  private:
-  // Maps tombstone user start key -> tombstone object
-  typedef std::multimap<Slice, RangeTombstone, stl_wrappers::LessOfComparator>
+  // Maps tombstone start key -> tombstone object
+  typedef std::map<std::string, 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_;
-    PinnedIteratorsManager pinned_iters_mgr_;
-  };
-  // Initializes rep_ lazily. This aggregator object is constructed for every
-  // read, so expensive members should only be created when necessary, i.e.,
-  // once the first range deletion is encountered.
-  void InitRep(const std::vector<SequenceNumber>& snapshots);
+  Status AddTombstones(InternalIterator* input, bool arena);
+  StripeMap::iterator GetStripeMapIter(SequenceNumber seq);
 
-  PositionalTombstoneMap& GetPositionalTombstoneMap(SequenceNumber seq);
-  Status AddTombstone(RangeTombstone tombstone);
-
-  SequenceNumber upper_bound_;
-  std::unique_ptr<Rep> rep_;
-  const InternalKeyComparator& icmp_;
-  // collapse range deletions so they're binary searchable
-  const bool collapse_deletions_;
+  PinnedIteratorsManager pinned_iters_mgr_;
+  StripeMap stripe_map_;
+  const InternalKeyComparator icmp_;
 };
-
 }  // namespace rocksdb

db/range_del_aggregator_test.cc

@@ -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();
-}

db/repair.cc

@@ -380,12 +380,11 @@ class Repairer {
       ScopedArenaIterator iter(mem->NewIterator(ro, &arena));
       status = BuildTable(
           dbname_, env_, *cfd->ioptions(), *cfd->GetLatestMutableCFOptions(),
-          env_options_, table_cache_, iter.get(),
-          std::unique_ptr<InternalIterator>(mem->NewRangeTombstoneIterator(ro)),
-          &meta, cfd->internal_comparator(),
-          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
-          {}, kMaxSequenceNumber, kNoCompression, CompressionOptions(), false,
-          nullptr /* internal_stats */, TableFileCreationReason::kRecovery);
+          env_options_, table_cache_, iter.get(), &meta,
+          cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
+          cfd->GetID(), cfd->GetName(), {}, kMaxSequenceNumber, kNoCompression,
+          CompressionOptions(), false, nullptr /* internal_stats */,
+          TableFileCreationReason::kRecovery);
       Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
           "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s", log,
           counter, meta.fd.GetNumber(), status.ToString().c_str());
@@ -467,8 +466,7 @@ class Repairer {
     }
     if (status.ok()) {
       InternalIterator* iter = table_cache_->NewIterator(
-          ReadOptions(), env_options_, cfd->internal_comparator(), t->meta.fd,
-          nullptr /* range_del_agg */);
+          ReadOptions(), env_options_, cfd->internal_comparator(), t->meta.fd);
       bool empty = true;
       ParsedInternalKey parsed;
       t->min_sequence = 0;