Disable error as warning

Add one more #include<functional>
Add some include<functional>
2026-11-06 19:12:36 -05:00 · 2019-11-05 11:03:42 -08:00 · 2019-11-05 11:03:40 -08:00 · 2019-10-31 14:30:44 -07:00 · 2019-10-31 14:30:43 -07:00 · 2017-07-17 22:21:57 -07:00
311 changed files with 15523 additions and 18605 deletions
@@ -1,29 +1,24 @@
 sudo: false
 language: cpp
-os:
-  - linux
-  - osx
-compiler:
-  - clang

-addons:
-   apt:
-      sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6']
-      packages: ['clang-3.6' , 'zlib1g-dev', 'libbz2-dev', 'libsnappy-dev', 'curl']
-env:
-  # Run all tests before db_block_cache_test (db_test, db_test2)
-  - JOB_NAME=unittests ROCKSDBTESTS_END=db_block_cache_test
-  # Run all tests starting from db_block_cache_test (db_block_cache_test, db_iter_test, ...)
-  - JOB_NAME=unittests ROCKSDBTESTS_START=db_block_cache_test
-  # Run java tests
-  - JOB_NAME=java_test
-  # Build ROCKSDB_LITE
-  - JOB_NAME=lite_build
+matrix:
+  include:
+    - os: linux
+      compiler: clang
+      env: COMPILER=clang++-3.6
+      addons:
+         apt:
+            sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6']
+            packages: ['clang-3.6', 'clang-format-3.6', 'zlib1g-dev', 'libbz2-dev', 'libsnappy-dev', 'curl']
+    - os: osx
+      compiler: clang

 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
+  # Download clang-format-diff.py to check source code formatting
+  - pushd /tmp/ && curl -L http://llvm.org/svn/llvm-project/cfe/trunk/tools/clang-format/clang-format-diff.py -o clang-format-diff.py && chmod +x clang-format-diff.py && popd

 before_script:
  # Add gflags to include/library paths
@@ -31,15 +26,16 @@ before_script:
  - export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/tmp/gflags-2.1.2/lib"
  - export LIBRARY_PATH="$LIBRARY_PATH:/tmp/gflags-2.1.2/lib"
  - export CPLUS_INCLUDE_PATH="$CPLUS_INCLUDE_PATH:/tmp/gflags-2.1.2/include"
-  - if [[ "${TRAVIS_OS_NAME}" == 'linux' ]]; then CXX=clang++-3.6; fi
+  - if [ -n "${COMPILER}" ]; then CXX=${COMPILER}; fi
  - if [[ "${TRAVIS_OS_NAME}" == 'osx' ]]; then brew install gflags snappy; fi
-  # Limit the maximum number of open file descriptors to 2000
  - ulimit -n 2000 || true

+# Lousy hack to disable use and testing of fallocate, which doesn't behave quite
+# as EnvPosixTest::AllocateTest expects within the Travis OpenVZ environment.
 script:
-  - 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
+  - if [[ "${TRAVIS_OS_NAME}" == 'linux' ]]; then OPT=-DTRAVIS CLANG_FORMAT_DIFF=/tmp/clang-format-diff.py make format || true; fi
+  - OPT=-DTRAVIS V=1 make -j4 check && OPT=-DTRAVIS V=1 make clean jclean rocksdbjava jtest && make clean && OPT="-DTRAVIS -DROCKSDB_LITE" V=1 make -j4 static_lib
+
 notifications:
    email:
      - leveldb@fb.com
@@ -82,7 +82,7 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Oxt /Zp8 /Gm- /Gy /MD")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG")

-add_definitions(-DWIN32 -DOS_WIN -D_MBCS -DWIN64 -DNOMINMAX)
+add_definitions(-DWIN32 -DOS_WIN -D_MBCS -DWIN64)

 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
@@ -90,7 +90,7 @@ include_directories(${PROJECT_SOURCE_DIR}/third-party/gtest-1.7.0/fused-src)

 set(ROCKSDB_LIBS rocksdblib${ARTIFACT_SUFFIX})
 set(THIRDPARTY_LIBS ${THIRDPARTY_LIBS} gtest)
-set(SYSTEM_LIBS ${SYSTEM_LIBS} Shlwapi.lib Rpcrt4.lib)
+set(SYSTEM_LIBS Shlwapi.lib Rpcrt4.lib)

 set(LIBS ${ROCKSDB_LIBS} ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})

@@ -156,7 +156,6 @@ set(SOURCES
        port/win/env_win.cc
        port/win/port_win.cc
        port/win/win_logger.cc
-        port/win/xpress_win.cc
        table/adaptive_table_factory.cc
        table/block.cc
        table/block_based_filter_block.cc
@@ -208,7 +207,6 @@ set(SOURCES
        util/filter_policy.cc
        util/hash.cc
        util/histogram.cc
-        util/histogram_windowing.cc
        util/instrumented_mutex.cc
        util/iostats_context.cc
        tools/ldb_cmd.cc
@@ -240,7 +238,6 @@ set(SOURCES
        util/thread_status_updater.cc
        util/thread_status_util.cc
        util/thread_status_util_debug.cc
-        util/transaction_test_util.cc
        util/xfunc.cc
        util/xxhash.cc
        utilities/backupable/backupable_db.cc
@@ -311,7 +308,6 @@ set(APPS
        tools/db_stress.cc
        tools/write_stress.cc
        tools/db_repl_stress.cc
-        tools/ldb.cc
        tools/sst_dump.cc
        tools/dump/rocksdb_dump.cc
        tools/dump/rocksdb_undump.cc
@@ -343,9 +339,6 @@ set(TESTS
        db/db_test.cc
        db/db_test2.cc
        db/db_block_cache_test.cc
-        db/db_bloom_filter_test.cc
-        db/db_iterator_test.cc
-        db/db_sst_test.cc
        db/db_universal_compaction_test.cc
        db/db_wal_test.cc
        db/dbformat_test.cc
@@ -365,7 +358,6 @@ set(TESTS
        db/perf_context_test.cc
        db/plain_table_db_test.cc
        db/prefix_test.cc
-        db/repair_test.cc
        db/skiplist_test.cc
        db/table_properties_collector_test.cc
        db/version_builder_test.cc
@@ -404,7 +396,6 @@ set(TESTS
        util/iostats_context_test.cc
        util/memenv_test.cc
        util/mock_env_test.cc
-        util/options_settable_test.cc
        util/options_test.cc
        util/rate_limiter_test.cc
        util/slice_transform_test.cc
@@ -1,14 +0,0 @@
-# RocksDB default options change log
-## 4.8.0 (5/2/2016)
-* options.max_open_files changes from 5000 to -1. It improves performance, but users need to set file descriptor limit to be large enough and watch memory usage for index and bloom filters.
-* options.base_background_compactions changes from max_background_compactions to 1. When users set higher max_background_compactions but the write throughput is not high, the writes are less spiky to disks.
-* options.wal_recovery_mode changes from kTolerateCorruptedTailRecords to kPointInTimeRecovery. Avoid some false positive when file system or hardware reorder the writes for file data and metadata.
-
-## 4.7.0 (4/8/2016)
-* options.write_buffer_size changes from 4MB to 64MB.
-* options.target_file_size_base changes from 2MB to 64MB.
-* options.max_bytes_for_level_base changes from 10MB to 256MB.
-* options.soft_pending_compaction_bytes_limit changes from 0 (disabled) to 64GB.
-* options.hard_pending_compaction_bytes_limit changes from 0 (disabled) to 256GB.
-* table_cache_numshardbits changes from 4 to 6.
-* max_file_opening_threads changes from 1 to 16.
@@ -1,18 +1,4 @@
 # Rocksdb Change Log
-## 4.8.0 (5/2/2016)
-### Public API Change
-* Allow preset compression dictionary for improved compression of block-based tables. This is supported for zlib, zstd, and lz4. The compression dictionary's size is configurable via CompressionOptions::max_dict_bytes.
-* Delete deprecated classes for creating backups (BackupableDB) and restoring from backups (RestoreBackupableDB). Now, BackupEngine should be used for creating backups, and BackupEngineReadOnly should be used for restorations. For more details, see https://github.com/facebook/rocksdb/wiki/How-to-backup-RocksDB%3F
-* Expose estimate of per-level compression ratio via DB property: "rocksdb.compression-ratio-at-levelN".
-* Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
-### New Features
-* Add ReadOptions::readahead_size. If non-zero, NewIterator will create a new table reader which performs reads of the given size.
-
-## 4.7.0 (4/8/2016)
-### Public API Change
-* rename options compaction_measure_io_stats to report_bg_io_stats and include flush too.
-* Change some default options. Now default options will optimize for server-workloads. Also enable slowdown and full stop triggers for pending compaction bytes. These changes may cause sub-optimal performance or significant increase of resource usage. To avoid these risks, users can open existing RocksDB with options extracted from RocksDB option files. See https://github.com/facebook/rocksdb/wiki/RocksDB-Options-File for how to use RocksDB option files. Or you can call Options.OldDefaults() to recover old defaults. DEFAULT_OPTIONS_HISTORY.md will track change history of default options.
-
 ## 4.6.0 (3/10/2016)
 ### Public API Changes
 * Change default of BlockBasedTableOptions.format_version to 2. It means default DB created by 4.6 or up cannot be opened by RocksDB version 3.9 or earlier.
@@ -1,11 +0,0 @@
-This is the list of all known third-party language bindings for RocksDB. If something is missing, please open a pull request to add it.
-
-* Java - https://github.com/facebook/rocksdb/tree/master/java
-* Python - http://pyrocksdb.readthedocs.org/en/latest/
-* Perl - https://metacpan.org/pod/RocksDB
-* Node.js - https://npmjs.org/package/rocksdb
-* Go - https://github.com/tecbot/gorocksdb
-* Ruby - http://rubygems.org/gems/rocksdb-ruby
-* Haskell - https://hackage.haskell.org/package/rocksdb-haskell
-* PHP - https://github.com/Photonios/rocksdb-php
-* C# - https://github.com/warrenfalk/rocksdb-sharp
@@ -15,9 +15,7 @@ ARFLAGS = rs

 # Transform parallel LOG output into something more readable.
 perl_command = perl -n \
-  -e '@a=split("\t",$$_,-1); $$t=$$a[8];'				\
-  -e '$$t =~ /.*if\s\[\[\s"(.*?\.[\w\/]+)/ and $$t=$$1;'		\
-  -e '$$t =~ s,^\./,,;'							\
+  -e '@a=split("\t",$$_,-1); $$t=$$a[8]; $$t =~ s,^\./,,;'		\
  -e '$$t =~ s, >.*,,; chomp $$t;'					\
  -e '$$t =~ /.*--gtest_filter=(.*?\.[\w\/]+)/ and $$t=$$1;'		\
  -e 'printf "%7.3f %s %s\n", $$a[3], $$a[6] == 0 ? "PASS" : "FAIL", $$t'
@@ -171,22 +169,12 @@ ifdef COMPILE_WITH_TSAN
 	PLATFORM_CXXFLAGS += -fsanitize=thread -fPIC -DROCKSDB_TSAN_RUN
        # Turn off -pg when enabling TSAN testing, because that induces
        # a link failure.  TODO: find the root cause
-	PROFILING_FLAGS =
-endif
-
-# USAN doesn't work well with jemalloc. If we're compiling with USAN, we should use regular malloc.
-ifdef COMPILE_WITH_UBSAN
-	DISABLE_JEMALLOC=1
-	EXEC_LDFLAGS += -fsanitize=undefined
-	PLATFORM_CCFLAGS += -fsanitize=undefined
-	PLATFORM_CXXFLAGS += -fsanitize=undefined
+	pg =
+else
+	pg = -pg
 endif

 ifndef DISABLE_JEMALLOC
-	ifdef JEMALLOC
-		PLATFORM_CXXFLAGS += "-DROCKSDB_JEMALLOC"
-		PLATFORM_CCFLAGS +=  "-DROCKSDB_JEMALLOC"
-	endif
 	EXEC_LDFLAGS := $(JEMALLOC_LIB) $(EXEC_LDFLAGS)
 	PLATFORM_CXXFLAGS += $(JEMALLOC_INCLUDE)
 	PLATFORM_CCFLAGS += $(JEMALLOC_INCLUDE)
@@ -203,10 +191,6 @@ default: all
 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
  -Wno-unused-parameter

-ifndef DISABLE_WARNING_AS_ERROR
-	WARNING_FLAGS += -Werror
-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

@@ -259,15 +243,12 @@ TESTS = \
 	db_test \
 	db_test2 \
 	db_block_cache_test \
-	db_bloom_filter_test \
 	db_iter_test \
 	db_log_iter_test \
 	db_compaction_filter_test \
 	db_compaction_test \
 	db_dynamic_level_test \
 	db_inplace_update_test \
-	db_iterator_test \
-	db_sst_test \
 	db_tailing_iter_test \
 	db_universal_compaction_test \
 	db_wal_test \
@@ -336,7 +317,6 @@ TESTS = \
 	rate_limiter_test \
 	delete_scheduler_test \
 	options_test \
-	options_settable_test \
 	options_util_test \
 	event_logger_test \
 	cuckoo_table_builder_test \
@@ -360,26 +340,7 @@ TESTS = \
 	ldb_cmd_test \
 	iostats_context_test

-PARALLEL_TEST = \
-	backupable_db_test \
-	compact_on_deletion_collector_test \
-	db_compaction_filter_test \
-	db_compaction_test \
-	db_test \
-	db_universal_compaction_test \
-	fault_injection_test \
-	inlineskiplist_test \
-	manual_compaction_test \
-	table_test
-
-SUBSET := $(TESTS)
-ifdef ROCKSDBTESTS_START
-        SUBSET := $(shell echo $(SUBSET) | sed 's/^.*$(ROCKSDBTESTS_START)/$(ROCKSDBTESTS_START)/')
-endif
-
-ifdef ROCKSDBTESTS_END
-        SUBSET := $(shell echo $(SUBSET) | sed 's/$(ROCKSDBTESTS_END).*//')
-endif
+SUBSET :=  $(shell echo $(TESTS) |sed s/^.*$(ROCKSDBTESTS_START)/$(ROCKSDBTESTS_START)/)

 TOOLS = \
 	sst_dump \
@@ -480,26 +441,7 @@ coverage:
        # Delete intermediate files
 	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;

-ifneq (,$(filter check parallel_check,$(MAKECMDGOALS)),)
-# Use /dev/shm if it has the sticky bit set (otherwise, /tmp),
-# and create a randomly-named rocksdb.XXXX directory therein.
-# We'll use that directory in the "make check" rules.
-ifeq ($(TMPD),)
-TMPD := $(shell f=/dev/shm; test -k $$f || f=/tmp;			\
-  perl -le 'use File::Temp "tempdir";'					\
-    -e 'print tempdir("'$$f'/rocksdb.XXXX", CLEANUP => 0)')
-endif
-endif
-
-# Run all tests in parallel, accumulating per-test logs in t/log-*.
-#
-# Each t/run-* file is a tiny generated bourne shell script that invokes one of
-# sub-tests. Why use a file for this?  Because that makes the invocation of
-# parallel below simpler, which in turn makes the parsing of parallel's
-# LOG simpler (the latter is for live monitoring as parallel
-# tests run).
-#
-# Test names are extracted by running tests with --gtest_list_tests.
+# Extract the names of its tests by running db_test with --gtest_list_tests.
 # This filter removes the "#"-introduced comments, and expands to
 # fully-qualified names by changing input like this:
 #
@@ -517,33 +459,52 @@ endif
 #   MultiThreaded/MultiThreadedDBTest.MultiThreaded/0
 #   MultiThreaded/MultiThreadedDBTest.MultiThreaded/1
 #
+test_names = \
+  ./db_test --gtest_list_tests						\
+    | perl -n								\
+      -e 's/ *\#.*//;'							\
+      -e '/^(\s*)(\S+)/; !$$1 and do {$$p=$$2; break};'			\
+      -e 'print qq! $$p$$2!'

-parallel_tests = $(patsubst %,parallel_%,$(PARALLEL_TEST))
-.PHONY: gen_parallel_tests $(parallel_tests)
-$(parallel_tests): $(PARALLEL_TEST)
-	$(AM_V_at)TEST_BINARY=$(patsubst parallel_%,%,$@); \
-  TEST_NAMES=` \
-    ./$$TEST_BINARY --gtest_list_tests \
-    | perl -n \
-      -e 's/ *\#.*//;' \
-      -e '/^(\s*)(\S+)/; !$$1 and do {$$p=$$2; break};'	\
-      -e 'print qq! $$p$$2!'`; \
-	for TEST_NAME in $$TEST_NAMES; do \
-		TEST_SCRIPT=t/run-$$TEST_BINARY-$${TEST_NAME//\//-}; \
-		echo "  GEN     " $$TEST_SCRIPT; \
-    printf '%s\n' \
-      '#!/bin/sh' \
-      "d=\$(TMPD)$$TEST_SCRIPT" \
-      'mkdir -p $$d' \
-			"TEST_TMPDIR=\$$d ./$$TEST_BINARY --gtest_filter=$$TEST_NAME" \
-		> $$TEST_SCRIPT; \
-		chmod a=rx $$TEST_SCRIPT; \
-	done
+ifneq (,$(filter check parallel_check,$(MAKECMDGOALS)),)
+# Use /dev/shm if it has the sticky bit set (otherwise, /tmp),
+# and create a randomly-named rocksdb.XXXX directory therein.
+# We'll use that directory in the "make check" rules.
+ifeq ($(TMPD),)
+TMPD := $(shell f=/dev/shm; test -k $$f || f=/tmp;			\
+  perl -le 'use File::Temp "tempdir";'					\
+    -e 'print tempdir("'$$f'/rocksdb.XXXX", CLEANUP => 0)')
+endif
+endif

-gen_parallel_tests:
-	$(AM_V_at)mkdir -p t
-	$(AM_V_at)rm -f t/run-*
-	$(MAKE) $(parallel_tests)
+ifneq ($(T),)
+
+# Run all tests in parallel, accumulating per-test logs in t/log-*.
+
+# t_sanitized is each $(T) with "-" in place of each "/".
+t_sanitized = $(subst /,-,$(T))
+
+# t_run is each sanitized name with a leading "t/".
+t_run = $(patsubst %,t/%,$(t_sanitized))
+
+# Each t_run file is a tiny generated bourne shell script
+# that invokes one of db_tests's sub-tests. Why use a file
+# for this?  Because that makes the invocation of parallel
+# below simpler, which in turn makes the parsing of parallel's
+# LOG simpler (the latter is for live monitoring as parallel
+# tests run).
+filter = --gtest_filter=$(subst -,/,$(@F))
+$(t_run): Makefile db_test
+	$(AM_V_GEN)mkdir -p t
+	$(AM_V_at)rm -f $@ $@-t
+	$(AM_V_at)printf '%s\n'						\
+	    '#!/bin/sh'							\
+	    'd=$(TMPD)/$(@F)'						\
+	    'mkdir -p $$d'						\
+	    'TEST_TMPDIR=$$d ./db_test $(filter)'			\
+	  > $@-t
+	$(AM_V_at)chmod a=rx $@-t
+	$(AM_V_at)mv $@-t $@

 # Reorder input lines (which are one per test) so that the
 # longest-running tests appear first in the output.
@@ -562,7 +523,7 @@ gen_parallel_tests:
 # 107.816 PASS t/DBTest.EncodeDecompressedBlockSizeTest
 #
 slow_test_regexp = \
-	^t/run-table_test-HarnessTest.Randomized$$|^t/run-db_test-.*(?:FileCreationRandomFailure|EncodeDecompressedBlockSizeTest)$$
+  ^t/DBTest\.(?:FileCreationRandomFailure|EncodeDecompressedBlockSizeTest)$$
 prioritize_long_running_tests =						\
  perl -pe 's,($(slow_test_regexp)),100 $$1,'				\
    | sort -k1,1gr							\
@@ -573,43 +534,26 @@ prioritize_long_running_tests =						\
 # Run with "make J=200% check" to run two parallel jobs per core.
 # The default is to run one job per core (J=100%).
 # See "man parallel" for its "-j ..." option.
-J ?= 100%
+J = 100%

 # Use this regexp to select the subset of tests whose names match.
 tests-regexp = .

-t_run = $(wildcard t/run-*)
 .PHONY: check_0
-check_0:
-	$(AM_V_GEN)export TEST_TMPDIR=$(TMPD); \
-	printf '%s\n' ''						\
-	  'To monitor subtest <duration,pass/fail,name>,'		\
-	  '  run "make watch-log" in a separate window' '';		\
-	test -t 1 && eta=--eta || eta=; \
-	{ \
-		printf './%s\n' $(filter-out $(PARALLEL_TEST),$(TESTS)); \
-		printf '%s\n' $(t_run); \
-	} \
-	  | $(prioritize_long_running_tests)				\
-	  | grep -E '$(tests-regexp)'					\
-	  | parallel -j$(J) --joblog=LOG $$eta --gnu '{} >& t/log-{/}'
-
-.PHONY: valgrind_check_0
-valgrind_check_0:
+check_0: $(t_run)
 	$(AM_V_GEN)export TEST_TMPDIR=$(TMPD);				\
 	printf '%s\n' ''						\
 	  'To monitor subtest <duration,pass/fail,name>,'		\
 	  '  run "make watch-log" in a separate window' '';		\
 	test -t 1 && eta=--eta || eta=;					\
 	{								\
-	  printf './%s\n' $(filter-out $(PARALLEL_TEST) %skiplist_test options_settable_test, $(TESTS));		\
+	  printf './%s\n' $(filter-out db_test, $(TESTS));		\
 	  printf '%s\n' $(t_run);					\
 	}								\
 	  | $(prioritize_long_running_tests)				\
 	  | grep -E '$(tests-regexp)'					\
-	  | parallel -j$(J) --joblog=LOG $$eta --gnu \
-      'if [[ "{}" == "./"* ]] ; then $(DRIVER) {} >& t/valgrind_log-{/}; ' \
-      'else {} >& t/valgrind_log-{/}; fi'
+	  | parallel -j$(J) --joblog=LOG $$eta --gnu '{} >& t/log-{/}'
+endif

 CLEAN_FILES += t LOG $(TMPD)

@@ -626,11 +570,11 @@ watch-log:
 # If J != 1 and GNU parallel is installed, run the tests in parallel,
 # via the check_0 rule above.  Otherwise, run them sequentially.
 check: all
-	$(MAKE) gen_parallel_tests
 	$(AM_V_GEN)if test "$(J)" != 1                                  \
 	    && (parallel --gnu --help 2>/dev/null) |                    \
 	        grep -q 'GNU Parallel';                                 \
 	then                                                            \
+	    t=$$($(test_names));                                        \
 	    $(MAKE) T="$$t" TMPD=$(TMPD) check_0;                       \
 	else                                                            \
 	    for t in $(TESTS); do                                       \
@@ -652,7 +596,7 @@ ldb_tests: ldb
 crash_test: whitebox_crash_test blackbox_crash_test

 blackbox_crash_test: db_stress
-	python -u tools/db_crashtest.py --simple blackbox
+	python -u tools/db_crashtest.py --simple blackbox 
 	python -u tools/db_crashtest.py blackbox

 whitebox_crash_test: db_stress
@@ -669,33 +613,14 @@ asan_crash_test:
 	COMPILE_WITH_ASAN=1 $(MAKE) crash_test
 	$(MAKE) clean

-ubsan_check:
-	$(MAKE) clean
-	COMPILE_WITH_UBSAN=1 $(MAKE) check -j32
-	$(MAKE) clean
-
-ubsan_crash_test:
-	$(MAKE) clean
-	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test
-	$(MAKE) clean
-
 valgrind_check: $(TESTS)
-	$(MAKE) gen_parallel_tests
-	$(AM_V_GEN)if test "$(J)" != 1                                  \
-	    && (parallel --gnu --help 2>/dev/null) |                    \
-	        grep -q 'GNU Parallel';                                 \
-	then                                                            \
-      $(MAKE) TMPD=$(TMPD)                                        \
-      DRIVER="$(VALGRIND_VER) $(VALGRIND_OPTS)" valgrind_check_0; \
-	else                                                            \
-		for t in $(filter-out %skiplist_test options_settable_test,$(TESTS)); do \
-			$(VALGRIND_VER) $(VALGRIND_OPTS) ./$$t; \
-			ret_code=$$?; \
-			if [ $$ret_code -ne 0 ]; then \
-				exit $$ret_code; \
-			fi; \
-		done; \
-	fi
+	for t in $(filter-out %skiplist_test,$(TESTS)); do \
+		$(VALGRIND_VER) $(VALGRIND_OPTS) ./$$t; \
+		ret_code=$$?; \
+		if [ $$ret_code -ne 0 ]; then \
+			exit $$ret_code; \
+		fi; \
+	done


 ifneq ($(PAR_TEST),)
@@ -719,13 +644,6 @@ parloop:
 	exit $$ret_bad;
 endif

-test_names = \
-  ./db_test --gtest_list_tests						\
-    | perl -n								\
-      -e 's/ *\#.*//;'							\
-      -e '/^(\s*)(\S+)/; !$$1 and do {$$p=$$2; break};'			\
-      -e 'print qq! $$p$$2!'
-
 parallel_check: $(TESTS)
 	$(AM_V_GEN)if test "$(J)" > 1                                  \
 	    && (parallel --gnu --help 2>/dev/null) |                    \
@@ -876,9 +794,6 @@ db_test2: db/db_test2.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 db_block_cache_test: db/db_block_cache_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-db_bloom_filter_test: db/db_bloom_filter_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 db_log_iter_test: db/db_log_iter_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -894,12 +809,6 @@ db_dynamic_level_test: db/db_dynamic_level_test.o db/db_test_util.o $(LIBOBJECTS
 db_inplace_update_test: db/db_inplace_update_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-db_iterator_test: db/db_iterator_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)
-
 db_tailing_iter_test: db/db_tailing_iter_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -919,7 +828,7 @@ db_table_properties_test: db/db_table_properties_test.o db/db_test_util.o $(LIBO
 	$(AM_LINK)

 log_write_bench: util/log_write_bench.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK) $(PROFILING_FLAGS)
+	$(AM_LINK) $(pg)

 plain_table_db_test: db/plain_table_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
@@ -928,7 +837,7 @@ comparator_db_test: db/comparator_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 table_reader_bench: table/table_reader_bench.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK) $(PROFILING_FLAGS)
+	$(AM_LINK) $(pg)

 perf_context_test: db/perf_context_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_V_CCLD)$(CXX) $^ $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
@@ -1092,9 +1001,6 @@ compact_files_test: db/compact_files_test.o $(LIBOBJECTS) $(TESTHARNESS)
 options_test: util/options_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-options_settable_test: util/options_settable_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 options_util_test: utilities/options/options_util_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1137,9 +1043,6 @@ transaction_test: utilities/transactions/transaction_test.o $(LIBOBJECTS) $(TEST
 sst_dump: tools/sst_dump.o $(LIBOBJECTS)
 	$(AM_LINK)

-repair_test: db/repair_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 ldb_cmd_test: tools/ldb_cmd_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1311,7 +1214,7 @@ jdb_bench:

 commit_prereq: build_tools/rocksdb-lego-determinator \
               build_tools/precommit_checker.py
-	J=$(J) build_tools/precommit_checker.py unit unit_481 clang_unit tsan asan ubsan lite
+	J=$(J) build_tools/precommit_checker.py unit unit_481 clang_unit tsan asan lite
 	$(MAKE) clean && $(MAKE) jclean && $(MAKE) rocksdbjava;

 xfunc:
@@ -9,7 +9,7 @@ At Facebook, we use RocksDB as a backend for many different stateful services. W
 ## LinkedIn
 Two different use cases at Linkedin are using RocksDB as a storage engine:

-1. LinkedIn's follow feed for storing user's activities. Check out the blog post: https://engineering.linkedin.com/blog/2016/03/followfeed--linkedin-s-feed-made-faster-and-smarter
+1. LinkedIn's follow feed for storing user's activities
 2. Apache Samza, open source framework for stream processing

 Learn more about those use cases in a Tech Talk by Ankit Gupta and Naveen Somasundaram: http://www.youtube.com/watch?v=plqVp_OnSzg
@@ -52,7 +52,3 @@ Pinterest's Object Retrieval System uses RocksDB for storage: https://www.youtub

 ## VWO, Wingify
 [VWO's](https://vwo.com/) Smart Code checker and URL helper uses RocksDB to store all the URLs where VWO's Smart Code is installed.
-
-## quasardb
-[quasardb](https://www.quasardb.net) is a high-performance, distributed, transactional key-value database that integrates well with in-memory analytics engines such as Apache Spark. 
-quasardb uses a heavily tuned RocksDB as its persistence layer.
@@ -92,13 +92,12 @@ class FacebookArcanistConfiguration extends ArcanistConfiguration {
    // Run the actual command
    $this->updateTest($diffID, $test);
    $cmd = $this->updateTestCommand($diffID, $test, "running") . ";"
-           . "./build_tools/precommit_checker.py " . $test
-           . "; exit_code=$?; ([[ \$exit_code -eq 0 ]] &&"
+           . "(./build_tools/precommit_checker.py " . $test
+           . "&& "
           . $this->updateTestCommand($diffID, $test, "pass") . ")"
-           . "||" . $this->updateTestCommand($diffID, $test, "fail")
+           . "|| " . $this->updateTestCommand($diffID, $test, "fail")
           . "; cat /tmp/precommit-check.log"
-           . "; for f in `ls t/log-*`; do echo \$f; cat \$f; done;"
-           . "[[ \$exit_code -eq 0 ]]";
+           . "; for f in `ls t/log-*`; do echo \$f; cat \$f; done";

    $run_test = array(
      "name" => "Run " . $test,
@@ -2714,7 +2714,7 @@ def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):

    # Look for < that is not surrounded by spaces.  This is only
    # triggered if both sides are missing spaces, even though
-    # technically should flag if at least one side is missing a
+    # technically should should flag if at least one side is missing a
    # space.  This is done to avoid some false positives with shifts.
    match = Search(r'[^\s<]<([^\s=<].*)', reduced_line)
    if (match and
@@ -52,12 +52,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
@@ -299,14 +294,13 @@ EOF

    # Test whether jemalloc is available
    if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null -ljemalloc \
-      2>/dev/null; then
+      2>/dev/null; then 
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ljemalloc"
        JAVA_LDFLAGS="$JAVA_LDFLAGS -ljemalloc"
-        JEMALLOC=1
    else
        # jemalloc is not available. Let's try tcmalloc
        if echo 'int main() {}' | $CXX $CFLAGS -x c++ - -o /dev/null \
-          -ltcmalloc 2>/dev/null; then
+          -ltcmalloc 2>/dev/null; then 
            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc"
            JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc"
        fi
@@ -323,55 +317,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_MALLOC_USABLE_SIZE"
    fi
-
-    # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
-    $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
-      #include <pthread.h>
-      int main() {
-        int x = PTHREAD_MUTEX_ADAPTIVE_NP;
-        return 0;
-      }
-EOF
-    if [ "$?" = 0 ]; then
-        COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_PTHREAD_ADAPTIVE_MUTEX"
-    fi
-
-    # Test whether backtrace is available
-    $CXX $CFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
-      #include <execinfo.h>>
-      int main() {
-        void* frames[1];
-        backtrace_symbols(frames, backtrace(frames, 1));
-        return 0;
-      }
-EOF
-    if [ "$?" = 0 ]; then
-        COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
-    else
-        # Test whether execinfo library is installed
-        $CXX $CFLAGS -lexecinfo -x c++ - -o /dev/null 2>/dev/null  <<EOF
-          #include <execinfo.h>
-          int main() {
-            void* frames[1];
-            backtrace_symbols(frames, backtrace(frames, 1));
-          }
-EOF
-        if [ "$?" = 0 ]; then
-            COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
-            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lexecinfo"
-            JAVA_LDFLAGS="$JAVA_LDFLAGS -lexecinfo"
-        fi
-    fi
-
-    # Test if -pg is supported
-    $CXX $CFLAGS -pg -x c++ - -o /dev/null 2>/dev/null  <<EOF
-      int main() {
-        return 0;
-      }
-EOF
-    if [ "$?" = 0 ]; then
-        PROFILING_FLAGS=-pg
-    fi
 fi

 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
@@ -452,7 +397,3 @@ echo "ROCKSDB_MINOR=$ROCKSDB_MINOR" >> "$OUTPUT"
 echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT"
 echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT"
 echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
-echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
-if test -n "$JEMALLOC"; then
-  echo "JEMALLOC=1" >> "$OUTPUT"
-fi
@@ -1,16 +1,19 @@
-GCC_BASE=/mnt/vol/engshare/fbcode/third-party2/gcc/4.9.x/centos6-native/1317bc4/
-CLANG_BASE=/mnt/gvfs/third-party2/clang/fc904e50a9266b9d7b98cae1993afa0c5aae1440/3.7.1/centos6-native/9d9ecb9/
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/f97108c12512b3b0789ac4515d836bdb1eae1142/4.9.x/gcc-4.9-glibc-2.20/024dbc3
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/f5484f168c0e4d19823d41df052c5870c6e575a4/2.20/gcc-4.9-glibc-2.20/500e281
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/cbf6f1f209e5bd160bdc5d971744e039f36b1566/1.1.3/gcc-4.9-glibc-2.20/e9936bf
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/6d39cb54708049f527e713ad19f2aadb9d3667e8/1.2.8/gcc-4.9-glibc-2.20/e9936bf
-BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/2ddd45f0853bfc8bb1c27f0f447236a1a26c338a/1.0.6/gcc-4.9-glibc-2.20/e9936bf
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/6858fac689e0f92e584224d91bdb0e39f6c8320d/r131/gcc-4.9-glibc-2.20/e9936bf
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/cb6c4880fcb4fee471574ba6af63a3882155a16a/0.5.1/gcc-4.9-glibc-2.20/e9936bf
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/c7275a4ceae0aca0929e56964a31dafc53c1ee96/2.1.1/gcc-4.8.1-glibc-2.17/c3f970a
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/d9acac8a9a2c9378eb696e22ffa8bd0e97d9206b/master/gcc-4.9-glibc-2.20/a6c5e1e
-NUMA_BASE=/mnt/gvfs/third-party2/numa/ae54a5ed22cdabb1c6446dce4e8ffae5b4446d73/2.0.8/gcc-4.9-glibc-2.20/e9936bf
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/41bfa3759ce52c071f5fd547ec9ecd2522929f0a/trunk/gcc-4.9-glibc-2.20/12266b1
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/1a48835975c66d30e47770ec419758ed3b9ba010/3.10.62-62_fbk17_03959_ge29cc63/gcc-4.9-glibc-2.20/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/71454c53fffcb716a0beb9a90047aff7fb5c984a/2.26/centos6-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/af85c56f424cd5edfc2c97588299b44ecdec96bb/3.10.0/gcc-4.9-glibc-2.20/e9936bf
+# 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
@@ -1,6 +1,6 @@
-GCC_BASE=/mnt/vol/engshare/fbcode/third-party2/gcc/4.8.1/centos6-native/cc6c9dc/
+GCC_BASE=/mnt/gvfs/third-party2/gcc/ebc96bc2fb751b5a0300b8d91a95bdf24ac1d88b/4.8.1/centos6-native/cc6c9dc
 CLANG_BASE=/mnt/gvfs/third-party2/clang/fc904e50a9266b9d7b98cae1993afa0c5aae1440/3.7.1/centos6-native/9d9ecb9/
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/f97108c12512b3b0789ac4515d836bdb1eae1142/4.8.1/gcc-4.8.1-glibc-2.17/8aac7fc
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/ea2fd1278810d3af2ea52218d2767e09d786dbd0/4.8.1/gcc-4.8.1-glibc-2.17/8aac7fc
 GLIBC_BASE=/mnt/gvfs/third-party2/glibc/f5484f168c0e4d19823d41df052c5870c6e575a4/2.17/gcc-4.8.1-glibc-2.17/99df8fc
 SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/cbf6f1f209e5bd160bdc5d971744e039f36b1566/1.1.3/gcc-4.8.1-glibc-2.17/c3f970a
 ZLIB_BASE=/mnt/gvfs/third-party2/zlib/6d39cb54708049f527e713ad19f2aadb9d3667e8/1.2.8/gcc-4.8.1-glibc-2.17/c3f970a
@@ -8,9 +8,9 @@ BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/2ddd45f0853bfc8bb1c27f0f447236a1a26c338a
 LZ4_BASE=/mnt/gvfs/third-party2/lz4/6858fac689e0f92e584224d91bdb0e39f6c8320d/r131/gcc-4.8.1-glibc-2.17/c3f970a
 ZSTD_BASE=/mnt/gvfs/third-party2/zstd/cb6c4880fcb4fee471574ba6af63a3882155a16a/0.5.1/gcc-4.8.1-glibc-2.17/c3f970a
 GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/c7275a4ceae0aca0929e56964a31dafc53c1ee96/2.1.1/gcc-4.8.1-glibc-2.17/c3f970a
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/d9acac8a9a2c9378eb696e22ffa8bd0e97d9206b/master/gcc-4.8.1-glibc-2.17/8d31e51
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/40791a3fef9206a77f2c4bc51f8169e5bf10d68e/master/gcc-4.8.1-glibc-2.17/8d31e51
 NUMA_BASE=/mnt/gvfs/third-party2/numa/ae54a5ed22cdabb1c6446dce4e8ffae5b4446d73/2.0.8/gcc-4.8.1-glibc-2.17/c3f970a
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/41bfa3759ce52c071f5fd547ec9ecd2522929f0a/trunk/gcc-4.8.1-glibc-2.17/675d945
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/303048f72efc92ae079e62dfc84823401aecfd94/trunk/gcc-4.8.1-glibc-2.17/675d945
 KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/1a48835975c66d30e47770ec419758ed3b9ba010/3.10.62-62_fbk17_03959_ge29cc63/gcc-4.8.1-glibc-2.17/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/71454c53fffcb716a0beb9a90047aff7fb5c984a/2.26/centos6-native/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/a5b8152b2a15ce8a98808cf954fbccec825a97bc/2.25/centos6-native/da39a3e
 VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/af85c56f424cd5edfc2c97588299b44ecdec96bb/3.8.1/gcc-4.8.1-glibc-2.17/c3f970a
@@ -1,164 +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.
-
-'''Filter for error messages in test output:
-    - Receives merged stdout/stderr from test on stdin
-    - Finds patterns of known error messages for test name (first argument)
-    - Prints those error messages to stdout
-'''
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import re
-import sys
-
-
-class ErrorParserBase(object):
-    def parse_error(self, line):
-        '''Parses a line of test output. If it contains an error, returns a
-        formatted message describing the error; otherwise, returns None.
-        Subclasses must override this method.
-        '''
-        raise NotImplementedError
-
-
-class GTestErrorParser(ErrorParserBase):
-    '''A parser that remembers the last test that began running so it can print
-    that test's name upon detecting failure.
-    '''
-    _GTEST_NAME_PATTERN = re.compile(r'\[ RUN      \] (\S+)$')
-    # format: '<filename or "unknown file">:<line #>: Failure'
-    _GTEST_FAIL_PATTERN = re.compile(r'(unknown file|\S+:\d+): Failure$')
-
-    def __init__(self):
-        self._last_gtest_name = 'Unknown test'
-
-    def parse_error(self, line):
-        gtest_name_match = self._GTEST_NAME_PATTERN.match(line)
-        if gtest_name_match:
-            self._last_gtest_name = gtest_name_match.group(1)
-            return None
-        gtest_fail_match = self._GTEST_FAIL_PATTERN.match(line)
-        if gtest_fail_match:
-            return '%s failed: %s' % (
-                    self._last_gtest_name, gtest_fail_match.group(1))
-        return None
-
-
-class MatchErrorParser(ErrorParserBase):
-    '''A simple parser that returns the whole line if it matches the pattern.
-    '''
-    def __init__(self, pattern):
-        self._pattern = re.compile(pattern)
-
-    def parse_error(self, line):
-        if self._pattern.match(line):
-            return line
-        return None
-
-
-class CompilerErrorParser(MatchErrorParser):
-    def __init__(self):
-        # format: '<filename>:<line #>:<column #>: error: <error msg>'
-        super(CompilerErrorParser, self).__init__(r'\S+:\d+:\d+: error:')
-
-
-class ScanBuildErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(ScanBuildErrorParser, self).__init__(
-                r'scan-build: \d+ bugs found.$')
-
-
-class DbCrashErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(DbCrashErrorParser, self).__init__(r'\*\*\*.*\^$|TEST FAILED.')
-
-
-class WriteStressErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(WriteStressErrorParser, self).__init__(
-                r'ERROR: write_stress died with exitcode=\d+')
-
-
-class AsanErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(AsanErrorParser, self).__init__(
-                r'==\d+==ERROR: AddressSanitizer:')
-
-
-class UbsanErrorParser(MatchErrorParser):
-    def __init__(self):
-        # format: '<filename>:<line #>:<column #>: runtime error: <error msg>'
-        super(UbsanErrorParser, self).__init__(r'\S+:\d+:\d+: runtime error:')
-
-
-class ValgrindErrorParser(MatchErrorParser):
-    def __init__(self):
-        # just grab the summary, valgrind doesn't clearly distinguish errors
-        # from other log messages.
-        super(ValgrindErrorParser, self).__init__(r'==\d+== ERROR SUMMARY:')
-
-
-class CompatErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(CompatErrorParser, self).__init__(r'==== .*[Ee]rror.* ====$')
-
-
-class TsanErrorParser(MatchErrorParser):
-    def __init__(self):
-        super(TsanErrorParser, self).__init__(r'WARNING: ThreadSanitizer:')
-
-
-_TEST_NAME_TO_PARSERS = {
-    'punit': [CompilerErrorParser, GTestErrorParser],
-    'unit': [CompilerErrorParser, GTestErrorParser],
-    'unit_481': [CompilerErrorParser, GTestErrorParser],
-    'clang_unit': [CompilerErrorParser, GTestErrorParser],
-    'clang_analyze': [CompilerErrorParser, ScanBuildErrorParser],
-    'code_cov': [CompilerErrorParser, GTestErrorParser],
-    'unity': [CompilerErrorParser, GTestErrorParser],
-    'lite': [CompilerErrorParser],
-    'lite_test': [CompilerErrorParser, GTestErrorParser],
-    'stress_crash': [CompilerErrorParser, DbCrashErrorParser],
-    'write_stress': [CompilerErrorParser, WriteStressErrorParser],
-    'asan': [CompilerErrorParser, GTestErrorParser, AsanErrorParser],
-    'asan_crash': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
-    'ubsan': [CompilerErrorParser, GTestErrorParser, UbsanErrorParser],
-    'ubsan_crash': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
-    'valgrind': [CompilerErrorParser, GTestErrorParser, ValgrindErrorParser],
-    'tsan': [CompilerErrorParser, GTestErrorParser, TsanErrorParser],
-    'format_compatible': [CompilerErrorParser, CompatErrorParser],
-    'run_format_compatible': [CompilerErrorParser, CompatErrorParser],
-    'no_compression': [CompilerErrorParser, GTestErrorParser],
-    'run_no_compression': [CompilerErrorParser, GTestErrorParser],
-    'regression': [CompilerErrorParser],
-    'run_regression': [CompilerErrorParser],
-}
-
-
-def main():
-    if len(sys.argv) != 2:
-        return 'Usage: %s <test name>' % sys.argv[0]
-    test_name = sys.argv[1]
-    if test_name not in _TEST_NAME_TO_PARSERS:
-        return 'Unknown test name: %s' % test_name
-
-    error_parsers = []
-    for parser_cls in _TEST_NAME_TO_PARSERS[test_name]:
-        error_parsers.append(parser_cls())
-
-    for line in sys.stdin:
-        line = line.strip()
-        for error_parser in error_parsers:
-            error_msg = error_parser.parse_error(line)
-            if error_msg is not None:
-                print(error_msg)
-
-
-if __name__ == '__main__':
-    sys.exit(main())
@@ -13,8 +13,8 @@ source "$BASEDIR/dependencies.sh"
 CFLAGS=""

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

 # glibc
 GLIBC_INCLUDE="$GLIBC_BASE/include"
@@ -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/"
@@ -72,13 +76,22 @@ if test -z $PIC_BUILD; then
  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
 fi

+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
+CFLAGS+=" -DTBB"
+
 # use Intel SSE support for checksum calculations
 export USE_SSE=1

 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"

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

 STDLIBS="-L $GCC_BASE/lib64"

@@ -87,7 +100,7 @@ CLANG_LIB="$CLANG_BASE/lib"
 CLANG_SRC="$CLANG_BASE/../../src"

 CLANG_ANALYZER="$CLANG_BIN/clang++"
-CLANG_SCAN_BUILD="$CLANG_SRC/clang/tools/scan-build/scan-build"
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build"

 if [ -z "$USE_CLANG" ]; then
  # gcc
@@ -95,41 +108,45 @@ 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
-  CLANG_INCLUDE="$CLANG_LIB/clang/*/include"
+  CLANG_INCLUDE="$CLANG_LIB/clang/stable/include"
  CC="$CLANG_BIN/clang"
  CXX="$CLANG_BIN/clang++"

  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"
  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
+  CFLAGS+=" -Wno-expansion-to-defined "
  CXXFLAGS="-nostdinc++"
 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"
-EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-4.9-glibc-2.20/lib/ld.so"
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
+EXEC_LDFLAGS+=" -B$BINUTILS/gold"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
-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"

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

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

 VALGRIND_VER="$VALGRIND_BASE/bin/"

-export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD 
@@ -66,7 +66,6 @@ if [ -z "$USE_CLANG" ]; then
  CFLAGS="-B$BINUTILS/gold -m64 -mtune=generic"
  CFLAGS+=" -isystem $GLIBC_INCLUDE"
  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
-  JEMALLOC=1
 else
  # clang
  CLANG_BIN="$CLANG_BASE/bin"
@@ -184,7 +184,7 @@ parser = argparse.ArgumentParser(description='RocksDB pre-commit checker.')

 # <test ....>
 parser.add_argument('test', nargs='+',
-                    help='CI test(s) to run. e.g: unit punit asan tsan ubsan')
+                    help='CI test(s) to run. e.g: unit punit asan tsan')

 print("Please follow log %s" % Log.LOG_FILE)

@@ -67,11 +67,8 @@ ASAN="COMPILE_WITH_ASAN=1"
 CLANG="USE_CLANG=1"
 LITE="OPT=-DROCKSDB_LITE"
 TSAN="COMPILE_WITH_TSAN=1"
-UBSAN="COMPILE_WITH_UBSAN=1"
 DISABLE_JEMALLOC="DISABLE_JEMALLOC=1"
-HTTP_PROXY="https_proxy=http://fwdproxy.29.prn1:8080 http_proxy=http://fwdproxy.29.prn1:8080 ftp_proxy=http://fwdproxy.29.prn1:8080"
-SETUP_JAVA_ENV="export $HTTP_PROXY; export JAVA_HOME=/usr/local/jdk-7u10-64/; export PATH=\$PATH:\$JAVA_HOME/bin"
-PARSER="'parser':'python build_tools/error_filter.py $1'"
+PARSER="'parser':'egrep \'Failure|^#|Abort|Expected|Actual|GoogleTestFailure|^==\''"

 ARTIFACTS=" 'artifacts': [
    {
@@ -379,48 +376,6 @@ ASAN_CRASH_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB test under undefined behavior sanitizer
-#
-UBSAN_TEST_COMMANDS="[
-    {
-        'name':'Rocksdb Unit Test under UBSAN',
-        'oncall':'$ONCALL',
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Test RocksDB debug under UBSAN',
-                'shell':'set -o pipefail && $SHM $UBSAN $DEBUG make J=1 ubsan_check',
-                'user':'root',
-                $PARSER
-            }
-        ],
-        $REPORT
-    }
-]"
-
-#
-# RocksDB crash testing under udnefined behavior sanitizer
-#
-UBSAN_CRASH_TEST_COMMANDS="[
-    {
-        'name':'Rocksdb crash test under UBSAN',
-        'oncall':'$ONCALL',
-        'timeout': 86400,
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build and run RocksDB debug ubsan_crash_test',
-                'timeout': 86400,
-                'shell':'$SHM $DEBUG make J=1 ubsan_crash_test',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-
 #
 # RocksDB unit test under valgrind
 #
@@ -507,9 +462,9 @@ run_format_compatible()
  if [ -e "build_detect_platform" ]
  then
    sed "s/tcmalloc/nothingnothingnothing/g" build_detect_platform > $TEST_TMPDIR/temp_build_file
-    rm -rf build_detect_platform
+    rm -rf build_detect_platform 
    cp $TEST_TMPDIR/temp_build_file build_detect_platform
-    chmod +x build_detect_platform
+    chmod +x build_detect_platform 
  fi

  make ldb -j32
@@ -637,27 +592,6 @@ REGRESSION_COMMANDS="[
    }
 ]"

-#
-# RocksDB Java build
-#
-JAVA_BUILD_TEST_COMMANDS="[
-    {
-        'name':'Rocksdb Java Build',
-        'oncall':'$ONCALL',
-        'steps': [
-            $CLEANUP_ENV,
-            {
-                'name':'Build RocksDB for Java',
-                'shell':'$SETUP_JAVA_ENV; $SHM make rocksdbjava',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-
-
 case $1 in
  punit)
    echo $PARALLEL_UNIT_TEST_COMMANDS
@@ -698,12 +632,6 @@ case $1 in
  asan_crash)
    echo $ASAN_CRASH_TEST_COMMANDS
    ;;
-  ubsan)
-    echo $UBSAN_TEST_COMMANDS
-    ;;
-  ubsan_crash)
-    echo $UBSAN_CRASH_TEST_COMMANDS
-    ;;
  valgrind)
    echo $VALGRIND_TEST_COMMANDS
    ;;
@@ -731,9 +659,6 @@ case $1 in
  run_regression)
    run_regression
    ;;
-  java_build)
-    echo $JAVA_BUILD_TEST_COMMANDS
-    ;;
  *)
    echo "Invalid determinator command"
    ;;
@@ -9,7 +9,7 @@ Param(
  [string]$WorkFolder = "",  # Direct tests to use that folder
  [int]$Limit = -1, # -1 means run all otherwise limit for testing purposes
  [string]$Exclude = "", # Expect a comma separated list, no spaces
-  [string]$Run = "db_test",  # Run db_test|db_test2|tests|testname1,testname2...
+  [string]$Run = "db_test",  # Run db_test|tests|testname1,testname2...
   # Number of async tasks that would run concurrently. Recommend a number below 64.
   # However, CPU utlization really depends on the storage media. Recommend ram based disk.
   # a value of 1 will run everything serially
@@ -46,25 +46,15 @@ if($WorkFolder -eq "") {
  $Env:TEST_TMPDIR = $WorkFolder
 }

-Write-Output "Root: $RootFolder, WorkFolder: $WorkFolder"
-
 # Use JEMALLOC executables
-if($Run -ceq "db_test" -or
-   $Run -ceq "db_test2" ) {
-
-   $file_name = $Run
-
-   if($EnableJE) {
-     $file_name += "_je"
-   }
-
-   $file_name += ".exe"
-
-   $db_test = -Join ($BinariesFolder, $file_name)
-
-   Write-Output "Binaries: $BinariesFolder db_test: $db_test"
+if($EnableJE) {
+    $db_test = -Join ($BinariesFolder, "db_test_je.exe")
+} else {
+    $db_test = -Join ($BinariesFolder, "db_test.exe")
 }

+Write-Output "Root: $RootFolder, WorkFolder: $WorkFolder"
+Write-Output "Binaries: $BinariesFolder db_test: $db_test"

 #Exclusions that we do not want to run
 $ExcludeTests = New-Object System.Collections.Generic.HashSet[string]
@@ -163,8 +153,7 @@ function Discover-TestBinaries([string]$Pattern, $HashTable) {

 $TestsToRun = [ordered]@{}

-if($Run -ceq "db_test" -or
-   $Run -ceq "db_test2") {
+if($Run -ceq "db_test") {
    Normalize-DbTests -HashTable $TestsToRun
 } elseif($Run -ceq "tests") {
    if($EnableJE) {
@@ -236,8 +225,7 @@ function RunJobs($TestToLog, [int]$ConcurrencyVal, [bool]$AddForRerun)
            Write-Host "Starting $k"
            $log_path = ($TestToLog.$k)

-            if($Run -ceq "db_test" -or
-               $Run -ceq "db_test2") {
+            if($Run -ceq "db_test") {
              $job = Start-Job -Name $k -ScriptBlock $InvokeTestCase -ArgumentList @($db_test,$k,$log_path)
            } else {
              [string]$Exe =  -Join ($BinariesFolder, $k)
@@ -64,7 +64,7 @@ touch "$OUTPUT"
 echo "Writing dependencies to $OUTPUT"

 # Compilers locations
-GCC_BASE=`ls -d1 $TP2_LATEST/gcc/4.9.x/centos6-native/*/ | head -n1`
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/4.9.x/centos6-native/*/`
 CLANG_BASE=`ls -d1 /mnt/gvfs/third-party2/clang/fc904e50a9266b9d7b98cae1993afa0c5aae1440/3.7.1/centos6-native/*/ | head -n1`

 log_variable GCC_BASE
@@ -101,7 +101,7 @@ touch "$OUTPUT"
 echo "Writing 4.8.1 dependencies to $OUTPUT"

 # Compilers locations
-GCC_BASE=`ls -d1 $TP2_LATEST/gcc/4.8.1/centos6-native/*/ | head -n1`
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/4.8.1/centos6-native/*/`
 CLANG_BASE=`ls -d1 /mnt/gvfs/third-party2/clang/fc904e50a9266b9d7b98cae1993afa0c5aae1440/3.7.1/centos6-native/*/ | head -n1`

 log_variable GCC_BASE
@@ -458,16 +458,7 @@ TEST_F(AutoRollLoggerTest, LogHeaderTest) {
 TEST_F(AutoRollLoggerTest, LogFileExistence) {
  rocksdb::DB* db;
  rocksdb::Options options;
-#ifdef OS_WIN
-  // Replace all slashes in the path so windows CompSpec does not
-  // become confused
-  std::string testDir(kTestDir);
-  std::replace_if(testDir.begin(), testDir.end(),
-    [](char ch) { return ch == '/'; }, '\\');
-  std::string deleteCmd = "if exist " + testDir + " rd /s /q " + testDir;
-#else
  string deleteCmd = "rm -rf " + kTestDir;
-#endif
  ASSERT_EQ(system(deleteCmd.c_str()), 0);
  options.max_log_file_size = 100 * 1024 * 1024;
  options.create_if_missing = true;
@@ -15,7 +15,6 @@

 #include "db/compaction_iterator.h"
 #include "db/dbformat.h"
-#include "db/event_helpers.h"
 #include "db/filename.h"
 #include "db/internal_stats.h"
 #include "db/merge_helper.h"
@@ -42,18 +41,13 @@ TableBuilder* NewTableBuilder(
    const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
-    uint32_t column_family_id, const std::string& column_family_name,
-    WritableFileWriter* file, const CompressionType compression_type,
-    const CompressionOptions& compression_opts,
-    const std::string* compression_dict, const bool skip_filters) {
-  assert((column_family_id ==
-          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
-         column_family_name.empty());
+    uint32_t column_family_id, WritableFileWriter* file,
+    const CompressionType compression_type,
+    const CompressionOptions& compression_opts, const bool skip_filters) {
  return ioptions.table_factory->NewTableBuilder(
      TableBuilderOptions(ioptions, internal_comparator,
                          int_tbl_prop_collector_factories, compression_type,
-                          compression_opts, compression_dict, skip_filters,
-                          column_family_name),
+                          compression_opts, skip_filters),
      column_family_id, file);
 }

@@ -64,17 +58,12 @@ Status BuildTable(
    const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
-    uint32_t column_family_id, const std::string& column_family_name,
-    std::vector<SequenceNumber> snapshots,
+    uint32_t column_family_id, std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    const CompressionType compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
-    InternalStats* internal_stats, TableFileCreationReason reason,
-    EventLogger* event_logger, int job_id, const Env::IOPriority io_priority,
-    TableProperties* table_properties, int level) {
-  assert((column_family_id ==
-          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
-         column_family_name.empty());
+    InternalStats* internal_stats, const Env::IOPriority io_priority,
+    TableProperties* table_properties) {
  // Reports the IOStats for flush for every following bytes.
  const size_t kReportFlushIOStatsEvery = 1048576;
  Status s;
@@ -83,12 +72,6 @@ Status BuildTable(

  std::string fname = TableFileName(ioptions.db_paths, meta->fd.GetNumber(),
                                    meta->fd.GetPathId());
-#ifndef ROCKSDB_LITE
-  EventHelpers::NotifyTableFileCreationStarted(
-      ioptions.listeners, dbname, column_family_name, fname, job_id, reason);
-#endif  // !ROCKSDB_LITE
-  TableProperties tp;
-
  if (iter->Valid()) {
    TableBuilder* builder;
    unique_ptr<WritableFileWriter> file_writer;
@@ -96,9 +79,6 @@ Status BuildTable(
      unique_ptr<WritableFile> file;
      s = NewWritableFile(env, fname, &file, env_options);
      if (!s.ok()) {
-        EventHelpers::LogAndNotifyTableFileCreationFinished(
-            event_logger, ioptions.listeners, dbname, column_family_name, fname,
-            job_id, meta->fd, tp, reason, s);
        return s;
      }
      file->SetIOPriority(io_priority);
@@ -107,8 +87,7 @@ Status BuildTable(

      builder = NewTableBuilder(
          ioptions, internal_comparator, int_tbl_prop_collector_factories,
-          column_family_id, column_family_name, file_writer.get(), compression,
-          compression_opts);
+          column_family_id, file_writer.get(), compression, compression_opts);
    }

    MergeHelper merge(env, internal_comparator.user_comparator(),
@@ -146,13 +125,11 @@ Status BuildTable(
    }

    if (s.ok() && !empty) {
-      uint64_t file_size = builder->FileSize();
-      meta->fd.file_size = file_size;
+      meta->fd.file_size = builder->FileSize();
      meta->marked_for_compaction = builder->NeedCompact();
      assert(meta->fd.GetFileSize() > 0);
-      tp = builder->GetTableProperties();
      if (table_properties) {
-        *table_properties = tp;
+        *table_properties = builder->GetTableProperties();
      }
    }
    delete builder;
@@ -172,8 +149,7 @@ Status BuildTable(
          ReadOptions(), env_options, internal_comparator, meta->fd, nullptr,
          (internal_stats == nullptr) ? nullptr
                                      : internal_stats->GetFileReadHist(0),
-          false /* for_compaction */, nullptr /* arena */,
-          false /* skip_filter */, level));
+          false));
      s = it->status();
      if (s.ok() && paranoid_file_checks) {
        for (it->SeekToFirst(); it->Valid(); it->Next()) {
@@ -191,12 +167,6 @@ Status BuildTable(
  if (!s.ok() || meta->fd.GetFileSize() == 0) {
    env->DeleteFile(fname);
  }
-
-  // Output to event logger and fire events.
-  EventHelpers::LogAndNotifyTableFileCreationFinished(
-      event_logger, ioptions.listeners, dbname, column_family_name, fname,
-      job_id, meta->fd, tp, reason, s);
-
  return s;
 }

@@ -12,13 +12,11 @@
 #include "db/table_properties_collector.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/env.h"
-#include "rocksdb/immutable_options.h"
-#include "rocksdb/listener.h"
-#include "rocksdb/options.h"
 #include "rocksdb/status.h"
-#include "rocksdb/table_properties.h"
 #include "rocksdb/types.h"
-#include "util/event_logger.h"
+#include "rocksdb/options.h"
+#include "rocksdb/immutable_options.h"
+#include "rocksdb/table_properties.h"

 namespace rocksdb {

@@ -35,20 +33,14 @@ class WritableFileWriter;
 class InternalStats;
 class InternalIterator;

-// @param column_family_name Name of the column family that is also identified
-//    by column_family_id, or empty string if unknown. It must outlive the
-//    TableBuilder returned by this function.
-// @param compression_dict Data for presetting the compression library's
-//    dictionary, or nullptr.
 TableBuilder* NewTableBuilder(
    const ImmutableCFOptions& options,
    const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
-    uint32_t column_family_id, const std::string& column_family_name,
-    WritableFileWriter* file, const CompressionType compression_type,
+    uint32_t column_family_id, WritableFileWriter* file,
+    const CompressionType compression_type,
    const CompressionOptions& compression_opts,
-    const std::string* compression_dict = nullptr,
    const bool skip_filters = false);

 // Build a Table file from the contents of *iter.  The generated file
@@ -56,9 +48,6 @@ TableBuilder* NewTableBuilder(
 // *meta will be filled with metadata about the generated table.
 // If no data is present in *iter, meta->file_size will be set to
 // zero, and no Table file will be produced.
-//
-// @param column_family_name Name of the column family that is also identified
-//    by column_family_id, or empty string if unknown.
 extern Status BuildTable(
    const std::string& dbname, Env* env, const ImmutableCFOptions& options,
    const EnvOptions& env_options, TableCache* table_cache,
@@ -66,14 +55,12 @@ extern Status BuildTable(
    const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
-    uint32_t column_family_id, const std::string& column_family_name,
-    std::vector<SequenceNumber> snapshots,
+    uint32_t column_family_id, std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    const CompressionType compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
-    InternalStats* internal_stats, TableFileCreationReason reason,
-    EventLogger* event_logger = nullptr, int job_id = 0,
+    InternalStats* internal_stats,
    const Env::IOPriority io_priority = Env::IO_HIGH,
-    TableProperties* table_properties = nullptr, int level = -1);
+    TableProperties* table_properties = nullptr);

 }  // namespace rocksdb
@@ -446,12 +446,6 @@ void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
  SaveError(errptr, be->rep->CreateNewBackup(db->rep));
 }

-void rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t* be,
-                                             uint32_t num_backups_to_keep,
-                                             char** errptr) {
-  SaveError(errptr, be->rep->PurgeOldBackups(num_backups_to_keep));
-}
-
 rocksdb_restore_options_t* rocksdb_restore_options_create() {
  return new rocksdb_restore_options_t;
 }
@@ -831,31 +825,6 @@ rocksdb_iterator_t* rocksdb_create_iterator_cf(
  return result;
 }

-void rocksdb_create_iterators(
-    rocksdb_t *db,
-    rocksdb_readoptions_t* opts,
-    rocksdb_column_family_handle_t** column_families,
-    rocksdb_iterator_t** iterators,
-    size_t size,
-    char** errptr) {
-  std::vector<ColumnFamilyHandle*> column_families_vec;
-  for (size_t i = 0; i < size; i++) {
-    column_families_vec.push_back(column_families[i]->rep);
-  }
-
-  std::vector<Iterator*> res;
-  Status status = db->rep->NewIterators(opts->rep, column_families_vec, &res);
-  assert(res.size() == size);
-  if (SaveError(errptr, status)) {
-    return;
-  }
-
-  for (size_t i = 0; i < size; i++) {
-    iterators[i] = new rocksdb_iterator_t;
-    iterators[i]->rep = res[i];
-  }
-}
-
 const rocksdb_snapshot_t* rocksdb_create_snapshot(
    rocksdb_t* db) {
  rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
@@ -1319,11 +1288,6 @@ void rocksdb_block_based_options_set_cache_index_and_filter_blocks(
  options->rep.cache_index_and_filter_blocks = v;
 }

-void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
-    rocksdb_block_based_table_options_t* options, unsigned char v) {
-  options->rep.pin_l0_filter_and_index_blocks_in_cache = v;
-}
-
 void rocksdb_block_based_options_set_skip_table_builder_flush(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.skip_table_builder_flush = v;
@@ -1424,11 +1388,6 @@ void rocksdb_options_set_compaction_filter_factory(
      std::shared_ptr<CompactionFilterFactory>(factory);
 }

-void rocksdb_options_compaction_readahead_size(
-    rocksdb_options_t* opt, size_t s) {
-  opt->rep.compaction_readahead_size = s;
-}
-
 void rocksdb_options_set_comparator(
    rocksdb_options_t* opt,
    rocksdb_comparator_t* cmp) {
@@ -1572,13 +1531,11 @@ void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt,
  }
 }

-void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits,
-                                             int level, int strategy,
-                                             int max_dict_bytes) {
+void rocksdb_options_set_compression_options(
+    rocksdb_options_t* opt, int w_bits, int level, int strategy) {
  opt->rep.compression_opts.window_bits = w_bits;
  opt->rep.compression_opts.level = level;
  opt->rep.compression_opts.strategy = strategy;
-  opt->rep.compression_opts.max_dict_bytes = max_dict_bytes;
 }

 void rocksdb_options_set_prefix_extractor(
@@ -2170,13 +2127,6 @@ rocksdb_env_t* rocksdb_create_default_env() {
  return result;
 }

-rocksdb_env_t* rocksdb_create_mem_env() {
-  rocksdb_env_t* result = new rocksdb_env_t;
-  result->rep = rocksdb::NewMemEnv(Env::Default());
-  result->is_default = false;
-  return result;
-}
-
 void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) {
  env->rep->SetBackgroundThreads(n);
 }
@@ -322,7 +322,7 @@ int main(int argc, char** argv) {
  rocksdb_options_set_block_based_table_factory(options, table_options);

  rocksdb_options_set_compression(options, rocksdb_no_compression);
-  rocksdb_options_set_compression_options(options, -14, -1, 0, 0);
+  rocksdb_options_set_compression_options(options, -14, -1, 0);
  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);
@@ -365,24 +365,6 @@ int main(int argc, char** argv) {
    rocksdb_backup_engine_create_new_backup(be, db, &err);
    CheckNoError(err);

-    // need a change to trigger a new backup
-    rocksdb_delete(db, woptions, "does-not-exist", 14, &err);
-    CheckNoError(err);
-
-    rocksdb_backup_engine_create_new_backup(be, db, &err);
-    CheckNoError(err);
-
-    const rocksdb_backup_engine_info_t* bei = rocksdb_backup_engine_get_backup_info(be);
-    CheckCondition(rocksdb_backup_engine_info_count(bei) > 1);
-    rocksdb_backup_engine_info_destroy(bei);
-
-    rocksdb_backup_engine_purge_old_backups(be, 1, &err);
-    CheckNoError(err);
-
-    bei = rocksdb_backup_engine_get_backup_info(be);
-    CheckCondition(rocksdb_backup_engine_info_count(bei) == 1);
-    rocksdb_backup_engine_info_destroy(bei);
-
    rocksdb_delete(db, woptions, "foo", 3, &err);
    CheckNoError(err);

@@ -786,30 +768,6 @@ int main(int argc, char** argv) {
    CheckNoError(err);
    rocksdb_iter_destroy(iter);

-    rocksdb_column_family_handle_t* iters_cf_handles[2] = { handles[0], handles[1] };
-    rocksdb_iterator_t* iters_handles[2];
-    rocksdb_create_iterators(db, roptions, iters_cf_handles, iters_handles, 2, &err);
-    CheckNoError(err);
-
-    iter = iters_handles[0];
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_seek_to_first(iter);
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_destroy(iter);
-
-    iter = iters_handles[1];
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_seek_to_first(iter);
-    CheckCondition(rocksdb_iter_valid(iter));
-
-    for (i = 0; rocksdb_iter_valid(iter) != 0; rocksdb_iter_next(iter)) {
-      i++;
-    }
-    CheckCondition(i == 1);
-    rocksdb_iter_get_error(iter, &err);
-    CheckNoError(err);
-    rocksdb_iter_destroy(iter);
-
    rocksdb_drop_column_family(db, handles[1], &err);
    CheckNoError(err);
    for (i = 0; i < 2; i++) {
@@ -147,10 +147,13 @@ ColumnFamilyOptions SanitizeOptions(const DBOptions& db_options,
                                    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;
-  ClipToRange(&result.write_buffer_size, ((size_t)64) << 10, clamp_max);
+#ifdef OS_MACOSX
+  // TODO(icanadi) make write_buffer_size uint64_t instead of size_t
+  ClipToRange(&result.write_buffer_size, ((size_t)64) << 10, ((size_t)1) << 30);
+#else
+  ClipToRange(&result.write_buffer_size,
+              ((size_t)64) << 10, ((size_t)64) << 30);
+#endif
  // if user sets arena_block_size, we trust user to use this value. Otherwise,
  // calculate a proper value from writer_buffer_size;
  if (result.arena_block_size <= 0) {
@@ -209,7 +209,7 @@ class ColumnFamilyData {
  const ImmutableCFOptions* ioptions() const { return &ioptions_; }
  // REQUIRES: DB mutex held
  // This returns the MutableCFOptions used by current SuperVersion
-  // You should use this API to reference MutableCFOptions most of the time.
+  // You shoul use this API to reference MutableCFOptions most of the time.
  const MutableCFOptions* GetCurrentMutableCFOptions() const {
    return &(super_version_->mutable_cf_options);
  }
@@ -465,8 +465,6 @@ class ColumnFamilySet {
  // Don't call while iterating over ColumnFamilySet
  void FreeDeadColumnFamilies();

-  Cache* get_table_cache() { return table_cache_; }
-
 private:
  friend class ColumnFamilyData;
  // helper function that gets called from cfd destructor
@@ -1042,7 +1042,6 @@ TEST_F(ColumnFamilyTest, AutomaticAndManualCompactions) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1135,7 +1134,6 @@ TEST_F(ColumnFamilyTest, ManualAndAutomaticCompactions) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1231,7 +1229,6 @@ TEST_F(ColumnFamilyTest, SameCFManualManualCompactions) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1330,7 +1327,6 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactions) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1420,7 +1416,6 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticCompactionsLevel) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1517,7 +1512,6 @@ TEST_F(ColumnFamilyTest, SameCFManualAutomaticConflict) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -1637,7 +1631,6 @@ TEST_F(ColumnFamilyTest, SameCFAutomaticManualCompactions) {
  db_options_.max_open_files = 20;  // only 10 files in file cache
  db_options_.disableDataSync = true;
  db_options_.max_background_compactions = 3;
-  db_options_.base_background_compactions = 3;

  default_cf.compaction_style = kCompactionStyleLevel;
  default_cf.num_levels = 3;
@@ -2564,9 +2557,6 @@ TEST_F(ColumnFamilyTest, CompactionSpeedupTwoColumnFamilies) {
  ASSERT_EQ(2, dbfull()->BGCompactionsAllowed());
 }

-// Disable on windows because SyncWAL requires env->IsSyncThreadSafe()
-// to return true which is not so in unbuffered mode.
-#ifndef OS_WIN
 TEST_F(ColumnFamilyTest, LogSyncConflictFlush) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two"});
@@ -2596,7 +2586,6 @@ TEST_F(ColumnFamilyTest, LogSyncConflictFlush) {
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
  Close();
 }
-#endif
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -93,7 +93,7 @@ Status CompactedDBImpl::Init(const Options& options) {
  mutex_.Lock();
  ColumnFamilyDescriptor cf(kDefaultColumnFamilyName,
                            ColumnFamilyOptions(options));
-  Status s = Recover({cf}, true /* read only */, false, true);
+  Status s = Recover({ cf }, true /* read only */, false);
  if (s.ok()) {
    cfd_ = reinterpret_cast<ColumnFamilyHandleImpl*>(
              DefaultColumnFamily())->cfd();
@@ -162,6 +162,9 @@ Compaction::Compaction(VersionStorageInfo* vstorage,
      deletion_compaction_(_deletion_compaction),
      inputs_(std::move(_inputs)),
      grandparents_(std::move(_grandparents)),
+      grandparent_index_(0),
+      seen_key_(false),
+      overlapped_bytes_(0),
      score_(_score),
      bottommost_level_(IsBottommostLevel(output_level_, vstorage, inputs_)),
      is_full_compaction_(IsFullCompaction(vstorage, inputs_)),
@@ -287,6 +290,32 @@ bool Compaction::KeyNotExistsBeyondOutputLevel(
  return true;
 }

+bool Compaction::ShouldStopBefore(const Slice& internal_key) {
+  // Scan to find earliest grandparent file that contains key.
+  const InternalKeyComparator* icmp = &cfd_->internal_comparator();
+  while (grandparent_index_ < grandparents_.size() &&
+      icmp->Compare(internal_key,
+                    grandparents_[grandparent_index_]->largest.Encode()) > 0) {
+    if (seen_key_) {
+      overlapped_bytes_ += grandparents_[grandparent_index_]->fd.GetFileSize();
+    }
+    assert(grandparent_index_ + 1 >= grandparents_.size() ||
+           icmp->Compare(grandparents_[grandparent_index_]->largest.Encode(),
+                         grandparents_[grandparent_index_+1]->smallest.Encode())
+                         < 0);
+    grandparent_index_++;
+  }
+  seen_key_ = true;
+
+  if (overlapped_bytes_ > max_grandparent_overlap_bytes_) {
+    // Too much overlap for current output; start new output
+    overlapped_bytes_ = 0;
+    return true;
+  } else {
+    return false;
+  }
+}
+
 // Mark (or clear) each file that is being compacted
 void Compaction::MarkFilesBeingCompacted(bool mark_as_compacted) {
  for (size_t i = 0; i < num_input_levels(); i++) {
@@ -392,7 +421,7 @@ void Compaction::Summary(char* output, int len) {
  snprintf(output + write, len - write, "]");
 }

-uint64_t Compaction::OutputFilePreallocationSize() const {
+uint64_t Compaction::OutputFilePreallocationSize() {
  uint64_t preallocation_size = 0;

  if (cfd_->ioptions()->compaction_style == kCompactionStyleLevel ||
@@ -104,7 +104,7 @@ class Compaction {
  }

  // Returns the LevelFilesBrief of the specified compaction input level.
-  const LevelFilesBrief* input_levels(size_t compaction_input_level) const {
+  LevelFilesBrief* input_levels(size_t compaction_input_level) {
    return &input_levels_[compaction_input_level];
  }

@@ -132,6 +132,10 @@ class Compaction {
  bool KeyNotExistsBeyondOutputLevel(const Slice& user_key,
                                     std::vector<size_t>* level_ptrs) const;

+  // Returns true iff we should stop building the current output
+  // before processing "internal_key".
+  bool ShouldStopBefore(const Slice& internal_key);
+
  // Clear all files to indicate that they are not being compacted
  // Delete this compaction from the list of running compactions.
  //
@@ -147,13 +151,13 @@ class Compaction {
  double score() const { return score_; }

  // Is this compaction creating a file in the bottom most level?
-  bool bottommost_level() const { return bottommost_level_; }
+  bool bottommost_level() { return bottommost_level_; }

  // Does this compaction include all sst files?
-  bool is_full_compaction() const { return is_full_compaction_; }
+  bool is_full_compaction() { return is_full_compaction_; }

  // Was this compaction triggered manually by the client?
-  bool is_manual_compaction() const { return is_manual_compaction_; }
+  bool is_manual_compaction() { return is_manual_compaction_; }

  // Used when allow_trivial_move option is set in
  // Universal compaction. If all the input files are
@@ -166,21 +170,19 @@ class Compaction {
  // Used when allow_trivial_move option is set in
  // Universal compaction. Returns true, if the input files
  // are non-overlapping and can be trivially moved.
-  bool is_trivial_move() const { return is_trivial_move_; }
+  bool is_trivial_move() { return is_trivial_move_; }

  // How many total levels are there?
  int number_levels() const { return number_levels_; }

  // Return the MutableCFOptions that should be used throughout the compaction
  // procedure
-  const MutableCFOptions* mutable_cf_options() const {
-    return &mutable_cf_options_;
-  }
+  const MutableCFOptions* mutable_cf_options() { return &mutable_cf_options_; }

  // Returns the size in bytes that the output file should be preallocated to.
  // In level compaction, that is max_file_size_. In universal compaction, that
  // is the sum of all input file sizes.
-  uint64_t OutputFilePreallocationSize() const;
+  uint64_t OutputFilePreallocationSize();

  void SetInputVersion(Version* input_version);

@@ -223,14 +225,6 @@ class Compaction {

  CompactionReason compaction_reason() { return compaction_reason_; }

-  const std::vector<FileMetaData*>& grandparents() const {
-    return grandparents_;
-  }
-
-  uint64_t max_grandparent_overlap_bytes() const {
-    return max_grandparent_overlap_bytes_;
-  }
-
 private:
  // mark (or clear) all files that are being compacted
  void MarkFilesBeingCompacted(bool mark_as_compacted);
@@ -271,9 +265,13 @@ class Compaction {
  // A copy of inputs_, organized more closely in memory
  autovector<LevelFilesBrief, 2> input_levels_;

-  // State used to check for number of overlapping grandparent files
+  // State used to check for number of of overlapping grandparent files
  // (grandparent == "output_level_ + 1")
  std::vector<FileMetaData*> grandparents_;
+  size_t grandparent_index_;   // Index in grandparent_starts_
+  bool seen_key_;              // Some output key has been seen
+  uint64_t overlapped_bytes_;  // Bytes of overlap between current output
+                               // and grandparent files
  const double score_;         // score that was used to pick this compaction.

  // Is this compaction creating a file in the bottom most level?
@@ -14,7 +14,7 @@ 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, const Compaction* compaction,
+    bool expect_valid_internal_key, Compaction* compaction,
    const CompactionFilter* compaction_filter, LogBuffer* log_buffer)
    : input_(input),
      cmp_(cmp),
@@ -423,15 +423,15 @@ void CompactionIterator::PrepareOutput() {
 inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
    SequenceNumber in, SequenceNumber* prev_snapshot) {
  assert(snapshots_->size());
-  SequenceNumber prev __attribute__((__unused__)) = kMaxSequenceNumber;
+  SequenceNumber prev __attribute__((unused)) = 0;
  for (const auto cur : *snapshots_) {
-    assert(prev == kMaxSequenceNumber || prev <= cur);
+    assert(prev <= cur);
    if (cur >= in) {
-      *prev_snapshot = prev == kMaxSequenceNumber ? 0 : prev;
+      *prev_snapshot = prev;
      return cur;
    }
    prev = cur;
-    assert(prev < kMaxSequenceNumber);
+    assert(prev);
  }
  *prev_snapshot = prev;
  return kMaxSequenceNumber;
@@ -42,7 +42,7 @@ class CompactionIterator {
                     std::vector<SequenceNumber>* snapshots,
                     SequenceNumber earliest_write_conflict_snapshot, Env* env,
                     bool expect_valid_internal_key,
-                     const Compaction* compaction = nullptr,
+                     Compaction* compaction = nullptr,
                     const CompactionFilter* compaction_filter = nullptr,
                     LogBuffer* log_buffer = nullptr);

@@ -92,7 +92,7 @@ class CompactionIterator {
  const SequenceNumber earliest_write_conflict_snapshot_;
  Env* env_;
  bool expect_valid_internal_key_;
-  const Compaction* compaction_;
+  Compaction* compaction_;
  const CompactionFilter* compaction_filter_;
  LogBuffer* log_buffer_;
  bool bottommost_level_;
@@ -16,13 +16,12 @@
 #include <inttypes.h>
 #include <algorithm>
 #include <functional>
-#include <list>
+#include <vector>
 #include <memory>
-#include <random>
+#include <list>
 #include <set>
 #include <thread>
 #include <utility>
-#include <vector>

 #include "db/builder.h"
 #include "db/db_iter.h"
@@ -64,7 +63,7 @@ namespace rocksdb {

 // Maintains state for each sub-compaction
 struct CompactionJob::SubcompactionState {
-  const Compaction* compaction;
+  Compaction* compaction;
  std::unique_ptr<CompactionIterator> c_iter;

  // The boundaries of the key-range this compaction is interested in. No two
@@ -105,14 +104,6 @@ struct CompactionJob::SubcompactionState {
  uint64_t num_output_records;
  CompactionJobStats compaction_job_stats;
  uint64_t approx_size;
-  // An index that used to speed up ShouldStopBefore().
-  size_t grandparent_index = 0;
-  // The number of bytes overlapping between the current output and
-  // grandparent files used in ShouldStopBefore().
-  uint64_t overlapped_bytes = 0;
-  // A flag determine whether the key has been seen in ShouldStopBefore()
-  bool seen_key = false;
-  std::string compression_dict;

  SubcompactionState(Compaction* c, Slice* _start, Slice* _end,
                     uint64_t size = 0)
@@ -124,11 +115,7 @@ struct CompactionJob::SubcompactionState {
        total_bytes(0),
        num_input_records(0),
        num_output_records(0),
-        approx_size(size),
-        grandparent_index(0),
-        overlapped_bytes(0),
-        seen_key(false),
-        compression_dict() {
+        approx_size(size) {
    assert(compaction != nullptr);
  }

@@ -147,10 +134,6 @@ struct CompactionJob::SubcompactionState {
    num_output_records = std::move(o.num_output_records);
    compaction_job_stats = std::move(o.compaction_job_stats);
    approx_size = std::move(o.approx_size);
-    grandparent_index = std::move(o.grandparent_index);
-    overlapped_bytes = std::move(o.overlapped_bytes);
-    seen_key = std::move(o.seen_key);
-    compression_dict = std::move(o.compression_dict);
    return *this;
  }

@@ -158,38 +141,6 @@ struct CompactionJob::SubcompactionState {
  SubcompactionState(const SubcompactionState&) = delete;

  SubcompactionState& operator=(const SubcompactionState&) = delete;
-
-  // Returns true iff we should stop building the current output
-  // before processing "internal_key".
-  bool ShouldStopBefore(const Slice& internal_key) {
-    const InternalKeyComparator* icmp =
-        &compaction->column_family_data()->internal_comparator();
-    const std::vector<FileMetaData*>& grandparents = compaction->grandparents();
-
-    // Scan to find earliest grandparent file that contains key.
-    while (grandparent_index < grandparents.size() &&
-           icmp->Compare(internal_key,
-                         grandparents[grandparent_index]->largest.Encode()) >
-               0) {
-      if (seen_key) {
-        overlapped_bytes += grandparents[grandparent_index]->fd.GetFileSize();
-      }
-      assert(grandparent_index + 1 >= grandparents.size() ||
-             icmp->Compare(
-                 grandparents[grandparent_index]->largest.Encode(),
-                 grandparents[grandparent_index + 1]->smallest.Encode()) <= 0);
-      grandparent_index++;
-    }
-    seen_key = true;
-
-    if (overlapped_bytes > compaction->max_grandparent_overlap_bytes()) {
-      // Too much overlap for current output; start new output
-      overlapped_bytes = 0;
-      return true;
-    }
-
-    return false;
-  }
 };

 // Maintains state for the entire compaction
@@ -669,31 +620,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  }

  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
-  const MutableCFOptions* mutable_cf_options =
-      sub_compact->compaction->mutable_cf_options();
-
-  // To build compression dictionary, we sample the first output file, assuming
-  // it'll reach the maximum length, and then use the dictionary for compressing
-  // subsequent output files. The dictionary may be less than max_dict_bytes if
-  // the first output file's length is less than the maximum.
-  const int kSampleLenShift = 6;  // 2^6 = 64-byte samples
-  std::set<size_t> sample_begin_offsets;
-  if (bottommost_level_ &&
-      cfd->ioptions()->compression_opts.max_dict_bytes > 0) {
-    const size_t kMaxSamples =
-        cfd->ioptions()->compression_opts.max_dict_bytes >> kSampleLenShift;
-    const size_t kOutFileLen = mutable_cf_options->MaxFileSizeForLevel(
-        compact_->compaction->output_level());
-    if (kOutFileLen != port::kMaxSizet) {
-      const size_t kOutFileNumSamples = kOutFileLen >> kSampleLenShift;
-      Random64 generator{versions_->NewFileNumber()};
-      for (size_t i = 0; i < kMaxSamples; ++i) {
-        sample_begin_offsets.insert(generator.Uniform(kOutFileNumSamples)
-                                    << kSampleLenShift);
-      }
-    }
-  }
-
  auto compaction_filter = cfd->ioptions()->compaction_filter;
  std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
  if (compaction_filter == nullptr) {
@@ -729,13 +655,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  auto c_iter = sub_compact->c_iter.get();
  c_iter->SeekToFirst();
  const auto& c_iter_stats = c_iter->iter_stats();
-  auto sample_begin_offset_iter = sample_begin_offsets.cbegin();
-  // data_begin_offset and compression_dict are only valid while generating
-  // dictionary from the first output file.
-  size_t data_begin_offset = 0;
-  std::string compression_dict;
-  compression_dict.reserve(cfd->ioptions()->compression_opts.max_dict_bytes);
-
  // 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) &&
@@ -750,7 +669,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    if (end != nullptr &&
        cfd->user_comparator()->Compare(c_iter->user_key(), *end) >= 0) {
      break;
-    } else if (sub_compact->ShouldStopBefore(key) &&
+    } else if (sub_compact->compaction->ShouldStopBefore(key) &&
               sub_compact->builder != nullptr) {
      status = FinishCompactionOutputFile(input->status(), sub_compact);
      if (!status.ok()) {
@@ -779,55 +698,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
        key, c_iter->ikey().sequence);
    sub_compact->num_output_records++;

-    if (sub_compact->outputs.size() == 1) {  // first output file
-      // Check if this key/value overlaps any sample intervals; if so, appends
-      // overlapping portions to the dictionary.
-      for (const auto& data_elmt : {key, value}) {
-        size_t data_end_offset = data_begin_offset + data_elmt.size();
-        while (sample_begin_offset_iter != sample_begin_offsets.cend() &&
-               *sample_begin_offset_iter < data_end_offset) {
-          size_t sample_end_offset =
-              *sample_begin_offset_iter + (1 << kSampleLenShift);
-          // Invariant: Because we advance sample iterator while processing the
-          // data_elmt containing the sample's last byte, the current sample
-          // cannot end before the current data_elmt.
-          assert(data_begin_offset < sample_end_offset);
-
-          size_t data_elmt_copy_offset, data_elmt_copy_len;
-          if (*sample_begin_offset_iter <= data_begin_offset) {
-            // The sample starts before data_elmt starts, so take bytes starting
-            // at the beginning of data_elmt.
-            data_elmt_copy_offset = 0;
-          } else {
-            // data_elmt starts before the sample starts, so take bytes starting
-            // at the below offset into data_elmt.
-            data_elmt_copy_offset =
-                *sample_begin_offset_iter - data_begin_offset;
-          }
-          if (sample_end_offset <= data_end_offset) {
-            // The sample ends before data_elmt ends, so take as many bytes as
-            // needed.
-            data_elmt_copy_len =
-                sample_end_offset - (data_begin_offset + data_elmt_copy_offset);
-          } else {
-            // data_elmt ends before the sample ends, so take all remaining
-            // bytes in data_elmt.
-            data_elmt_copy_len =
-                data_end_offset - (data_begin_offset + data_elmt_copy_offset);
-          }
-          compression_dict.append(&data_elmt.data()[data_elmt_copy_offset],
-                                  data_elmt_copy_len);
-          if (sample_end_offset > data_end_offset) {
-            // Didn't finish sample. Try to finish it with the next data_elmt.
-            break;
-          }
-          // Next sample may require bytes from same data_elmt.
-          sample_begin_offset_iter++;
-        }
-        data_begin_offset = data_end_offset;
-      }
-    }
-
    // Close output file if it is big enough
    // TODO(aekmekji): determine if file should be closed earlier than this
    // during subcompactions (i.e. if output size, estimated by input size, is
@@ -836,12 +706,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    if (sub_compact->builder->FileSize() >=
        sub_compact->compaction->max_output_file_size()) {
      status = FinishCompactionOutputFile(input->status(), sub_compact);
-      if (sub_compact->outputs.size() == 1) {
-        // Use dictionary from first output file for compression of subsequent
-        // files.
-        sub_compact->compression_dict = std::move(compression_dict);
-      }
    }
+
    c_iter->Next();
  }

@@ -954,10 +820,9 @@ Status CompactionJob::FinishCompactionOutputFile(
  }
  sub_compact->outfile.reset();

-  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
-  TableProperties tp;
  if (s.ok() && current_entries > 0) {
    // Verify that the table is usable
+    ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
    InternalIterator* iter = cfd->table_cache()->NewIterator(
        ReadOptions(), env_options_, cfd->internal_comparator(), meta->fd,
        nullptr, cfd->internal_stats()->GetFileReadHist(
@@ -971,30 +836,34 @@ Status CompactionJob::FinishCompactionOutputFile(
    }

    delete iter;
-
-    // Output to event logger and fire events.
    if (s.ok()) {
-      tp = sub_compact->builder->GetTableProperties();
+      auto tp = sub_compact->builder->GetTableProperties();
      sub_compact->current_output()->table_properties =
          std::make_shared<TableProperties>(tp);
+      TableFileCreationInfo info(std::move(tp));
+      info.db_name = dbname_;
+      info.cf_name = cfd->GetName();
+      info.file_path =
+          TableFileName(cfd->ioptions()->db_paths, meta->fd.GetNumber(),
+                        meta->fd.GetPathId());
+      info.file_size = meta->fd.GetFileSize();
+      info.job_id = job_id_;
      Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
          "[%s] [JOB %d] Generated table #%" PRIu64 ": %" PRIu64
          " keys, %" PRIu64 " bytes%s",
          cfd->GetName().c_str(), job_id_, output_number, current_entries,
          current_bytes,
          meta->marked_for_compaction ? " (need compaction)" : "");
+      EventHelpers::LogAndNotifyTableFileCreation(
+          event_logger_, cfd->ioptions()->listeners, meta->fd, info);
    }
  }
-  std::string fname = TableFileName(db_options_.db_paths, meta->fd.GetNumber(),
-                                    meta->fd.GetPathId());
-  EventHelpers::LogAndNotifyTableFileCreationFinished(
-      event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname,
-      job_id_, meta->fd, tp, TableFileCreationReason::kCompaction, s);

  // Report new file to SstFileManagerImpl
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
  if (sfm && meta->fd.GetPathId() == 0) {
+    ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
    auto fn = TableFileName(cfd->ioptions()->db_paths, meta->fd.GetNumber(),
                            meta->fd.GetPathId());
    sfm->OnAddFile(fn);
@@ -1070,17 +939,10 @@ Status CompactionJob::OpenCompactionOutputFile(
  assert(sub_compact->builder == nullptr);
  // no need to lock because VersionSet::next_file_number_ is atomic
  uint64_t file_number = versions_->NewFileNumber();
-  std::string fname = TableFileName(db_options_.db_paths, file_number,
-                                    sub_compact->compaction->output_path_id());
-  // Fire events.
-  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
-#ifndef ROCKSDB_LITE
-  EventHelpers::NotifyTableFileCreationStarted(
-      cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname, job_id_,
-      TableFileCreationReason::kCompaction);
-#endif  // !ROCKSDB_LITE
  // Make the output file
  unique_ptr<WritableFile> writable_file;
+  std::string fname = TableFileName(db_options_.db_paths, file_number,
+                                    sub_compact->compaction->output_path_id());
  Status s = NewWritableFile(env_, fname, &writable_file, env_options_);
  if (!s.ok()) {
    Log(InfoLogLevel::ERROR_LEVEL, db_options_.info_log,
@@ -1089,13 +951,8 @@ Status CompactionJob::OpenCompactionOutputFile(
        sub_compact->compaction->column_family_data()->GetName().c_str(),
        job_id_, file_number, s.ToString().c_str());
    LogFlush(db_options_.info_log);
-    EventHelpers::LogAndNotifyTableFileCreationFinished(
-        event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(),
-        fname, job_id_, FileDescriptor(), TableProperties(),
-        TableFileCreationReason::kCompaction, s);
    return s;
  }
-
  SubcompactionState::Output out;
  out.meta.fd =
      FileDescriptor(file_number, sub_compact->compaction->output_path_id(), 0);
@@ -1108,6 +965,7 @@ Status CompactionJob::OpenCompactionOutputFile(
  sub_compact->outfile.reset(
      new WritableFileWriter(std::move(writable_file), env_options_));

+  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
  // If the Column family flag is to only optimize filters for hits,
  // we can skip creating filters if this is the bottommost_level where
  // data is going to be found
@@ -1115,10 +973,9 @@ Status CompactionJob::OpenCompactionOutputFile(
      cfd->ioptions()->optimize_filters_for_hits && bottommost_level_;
  sub_compact->builder.reset(NewTableBuilder(
      *cfd->ioptions(), cfd->internal_comparator(),
-      cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
+      cfd->int_tbl_prop_collector_factories(), cfd->GetID(),
      sub_compact->outfile.get(), sub_compact->compaction->output_compression(),
-      cfd->ioptions()->compression_opts, &sub_compact->compression_dict,
-      skip_filters));
+      cfd->ioptions()->compression_opts, skip_filters));
  LogFlush(db_options_.info_log);
  return s;
 }
@@ -624,10 +624,7 @@ CompressionType GetAnyCompression() {
    return kBZip2Compression;
  } else if (LZ4_Supported()) {
    return kLZ4Compression;
-  } else if (XPRESS_Supported()) {
-    return kXpressCompression;
  }
-
  return kNoCompression;
 }

@@ -663,7 +660,7 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
  options.max_subcompactions = max_subcompactions_;
  options.bytes_per_sync = 512 * 1024;

-  options.report_bg_io_stats = true;
+  options.compaction_measure_io_stats = true;
  for (int test = 0; test < 2; ++test) {
    DestroyAndReopen(options);
    CreateAndReopenWithCF({"pikachu"}, options);
@@ -79,7 +79,7 @@ class CompactionPickerTest : public testing::Test {
  }

  void Add(int level, uint32_t file_number, const char* smallest,
-           const char* largest, uint64_t file_size = 1, uint32_t path_id = 0,
+           const char* largest, uint64_t file_size = 0, uint32_t path_id = 0,
           SequenceNumber smallest_seq = 100,
           SequenceNumber largest_seq = 100) {
    assert(level < vstorage_->num_levels());
@@ -195,7 +195,6 @@ TEST_F(CompactionPickerTest, LevelMaxScore) {
  NewVersionStorage(6, kCompactionStyleLevel);
  mutable_cf_options_.target_file_size_base = 10000000;
  mutable_cf_options_.target_file_size_multiplier = 10;
-  mutable_cf_options_.max_bytes_for_level_base = 10 * 1024 * 1024;
  Add(0, 1U, "150", "200", 1000000000U);
  // Level 1 score 1.2
  Add(1, 66U, "150", "200", 6000000U);
@@ -320,7 +319,6 @@ TEST_F(CompactionPickerTest, Level0TriggerDynamic4) {
  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
  mutable_cf_options_.max_bytes_for_level_base = 200;
  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-
  NewVersionStorage(num_levels, kCompactionStyleLevel);
  Add(0, 1U, "150", "200");
  Add(0, 2U, "200", "250");
@@ -353,7 +351,6 @@ TEST_F(CompactionPickerTest, LevelTriggerDynamic4) {
  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
  mutable_cf_options_.max_bytes_for_level_base = 200;
  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-  mutable_cf_options_.compaction_pri = kMinOverlappingRatio;
  NewVersionStorage(num_levels, kCompactionStyleLevel);
  Add(0, 1U, "150", "200");
  Add(num_levels - 1, 3U, "200", "250", 300U);
@@ -369,9 +366,11 @@ TEST_F(CompactionPickerTest, LevelTriggerDynamic4) {
      cf_name_, mutable_cf_options_, vstorage_.get(), &log_buffer_));
  ASSERT_TRUE(compaction.get() != nullptr);
  ASSERT_EQ(1U, compaction->num_input_files(0));
-  ASSERT_EQ(5U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(0, compaction->num_input_files(1));
-  ASSERT_EQ(1U, compaction->num_input_levels());
+  ASSERT_EQ(6U, compaction->input(0, 0)->fd.GetNumber());
+  ASSERT_EQ(2U, compaction->num_input_files(1));
+  ASSERT_EQ(3U, compaction->input(1, 0)->fd.GetNumber());
+  ASSERT_EQ(4U, compaction->input(1, 1)->fd.GetNumber());
+  ASSERT_EQ(2U, compaction->num_input_levels());
  ASSERT_EQ(num_levels - 1, compaction->output_level());
 }

@@ -492,7 +491,6 @@ TEST_F(CompactionPickerTest, CompactionPriMinOverlapping1) {
  NewVersionStorage(6, kCompactionStyleLevel);
  mutable_cf_options_.target_file_size_base = 10000000;
  mutable_cf_options_.target_file_size_multiplier = 10;
-  mutable_cf_options_.max_bytes_for_level_base = 10 * 1024 * 1024;
  mutable_cf_options_.compaction_pri = kMinOverlappingRatio;

  Add(2, 6U, "150", "179", 50000000U);
@@ -519,7 +517,6 @@ TEST_F(CompactionPickerTest, CompactionPriMinOverlapping2) {
  NewVersionStorage(6, kCompactionStyleLevel);
  mutable_cf_options_.target_file_size_base = 10000000;
  mutable_cf_options_.target_file_size_multiplier = 10;
-  mutable_cf_options_.max_bytes_for_level_base = 10 * 1024 * 1024;
  mutable_cf_options_.compaction_pri = kMinOverlappingRatio;

  Add(2, 6U, "150", "175",
@@ -547,21 +544,20 @@ TEST_F(CompactionPickerTest, CompactionPriMinOverlapping2) {

 TEST_F(CompactionPickerTest, CompactionPriMinOverlapping3) {
  NewVersionStorage(6, kCompactionStyleLevel);
-  mutable_cf_options_.max_bytes_for_level_base = 10000000;
-  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
+  mutable_cf_options_.target_file_size_base = 10000000;
+  mutable_cf_options_.target_file_size_multiplier = 10;
  mutable_cf_options_.compaction_pri = kMinOverlappingRatio;

  // file 7 and 8 over lap with the same file, but file 8 is smaller so
  // it will be picked.
-  Add(2, 6U, "150", "167", 60000000U);  // Overlaps with file 26, 27
-  Add(2, 7U, "168", "169", 60000000U);  // Overlaps with file 27
-  Add(2, 8U, "201", "300", 61000000U);  // Overlaps with file 28, but the file
-                                        // itself is larger. Should be picked.
+  Add(2, 6U, "150", "175", 60000000U);  // Overlaps with file 26, 27
+  Add(2, 7U, "176", "200", 60000000U);  // Overlaps with file 27
+  Add(2, 8U, "201", "300", 61000000U);  // Overlaps with file 27

  Add(3, 26U, "160", "165", 260000000U);
-  Add(3, 27U, "166", "170", 260000000U);
-  Add(3, 28U, "180", "400", 260000000U);
-  Add(3, 29U, "401", "500", 260000000U);
+  Add(3, 26U, "166", "170", 260000000U);
+  Add(3, 27U, "180", "400", 260000000U);
+  Add(3, 28U, "401", "500", 260000000U);
  UpdateVersionStorageInfo();

  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
@@ -599,8 +595,6 @@ TEST_F(CompactionPickerTest, ParentIndexResetBug) {
 // ranges (with different sequence numbers) in the input files.
 TEST_F(CompactionPickerTest, OverlappingUserKeys) {
  NewVersionStorage(6, kCompactionStyleLevel);
-  mutable_cf_options_.compaction_pri = kByCompensatedSize;
-
  Add(1, 1U, "100", "150", 1U);
  // Overlapping user keys
  Add(1, 2U, "200", "400", 1U);
@@ -42,7 +42,6 @@ class CorruptionTest : public testing::Test {

  CorruptionTest() {
    tiny_cache_ = NewLRUCache(100);
-    options_.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
    options_.env = &env_;
    dbname_ = test::TmpDir() + "/corruption_test";
    DestroyDB(dbname_, options_);
@@ -12,6 +12,11 @@

 namespace rocksdb {

+static uint64_t TestGetTickerCount(const Options& options,
+                                   Tickers ticker_type) {
+  return options.statistics->getTickerCount(ticker_type);
+}
+
 class DBBlockCacheTest : public DBTestBase {
 private:
  size_t miss_count_ = 0;
@@ -161,12 +166,10 @@ TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {
  }
 }

-#ifdef SNAPPY
 TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
  ReadOptions read_options;
  auto table_options = GetTableOptions();
  auto options = GetOptions(table_options);
-  options.compression = CompressionType::kSnappyCompression;
  InitTable(options);

  std::shared_ptr<Cache> cache = NewLRUCache(0, 0, false);
@@ -224,226 +227,6 @@ TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
  delete iter;
  iter = nullptr;
 }
-#endif  // SNAPPY
-
-#ifndef ROCKSDB_LITE
-
-// Make sure that when options.block_cache is set, after a new table is
-// created its index/filter blocks are added to block cache.
-TEST_F(DBBlockCacheTest, IndexAndFilterBlocksOfNewTableAddedToCache) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  ASSERT_OK(Put(1, "key", "val"));
-  // Create a new table.
-  ASSERT_OK(Flush(1));
-
-  // index/filter blocks added to block cache right after table creation.
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(2, /* only index/filter were added */
-            TestGetTickerCount(options, BLOCK_CACHE_ADD));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));
-  uint64_t int_num;
-  ASSERT_TRUE(
-      dbfull()->GetIntProperty("rocksdb.estimate-table-readers-mem", &int_num));
-  ASSERT_EQ(int_num, 0U);
-
-  // Make sure filter block is in cache.
-  std::string value;
-  ReadOptions ropt;
-  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
-
-  // Miss count should remain the same.
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-
-  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-
-  // Make sure index block is in cache.
-  auto index_block_hit = TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT);
-  value = Get(1, "key");
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(index_block_hit + 1,
-            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-
-  value = Get(1, "key");
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(index_block_hit + 2,
-            TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-}
-
-TEST_F(DBBlockCacheTest, ParanoidFileChecks) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  options.level0_file_num_compaction_trigger = 2;
-  options.paranoid_file_checks = true;
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = false;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  ASSERT_OK(Put(1, "1_key", "val"));
-  ASSERT_OK(Put(1, "9_key", "val"));
-  // Create a new table.
-  ASSERT_OK(Flush(1));
-  ASSERT_EQ(1, /* read and cache data block */
-            TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  ASSERT_OK(Put(1, "1_key2", "val2"));
-  ASSERT_OK(Put(1, "9_key2", "val2"));
-  // Create a new SST file. This will further trigger a compaction
-  // and generate another file.
-  ASSERT_OK(Flush(1));
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(3, /* Totally 3 files created up to now */
-            TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  // After disabling options.paranoid_file_checks. NO further block
-  // is added after generating a new file.
-  ASSERT_OK(
-      dbfull()->SetOptions(handles_[1], {{"paranoid_file_checks", "false"}}));
-
-  ASSERT_OK(Put(1, "1_key3", "val3"));
-  ASSERT_OK(Put(1, "9_key3", "val3"));
-  ASSERT_OK(Flush(1));
-  ASSERT_OK(Put(1, "1_key4", "val4"));
-  ASSERT_OK(Put(1, "9_key4", "val4"));
-  ASSERT_OK(Flush(1));
-  dbfull()->TEST_WaitForCompact();
-  ASSERT_EQ(3, /* Totally 3 files created up to now */
-            TestGetTickerCount(options, BLOCK_CACHE_ADD));
-}
-
-TEST_F(DBBlockCacheTest, CompressedCache) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-  int num_iter = 80;
-
-  // Run this test three iterations.
-  // Iteration 1: only a uncompressed block cache
-  // Iteration 2: only a compressed block cache
-  // Iteration 3: both block cache and compressed cache
-  // Iteration 4: both block cache and compressed cache, but DB is not
-  // compressed
-  for (int iter = 0; iter < 4; iter++) {
-    Options options = CurrentOptions();
-    options.write_buffer_size = 64 * 1024;  // small write buffer
-    options.statistics = rocksdb::CreateDBStatistics();
-
-    BlockBasedTableOptions table_options;
-    switch (iter) {
-      case 0:
-        // only uncompressed block cache
-        table_options.block_cache = NewLRUCache(8 * 1024);
-        table_options.block_cache_compressed = nullptr;
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 1:
-        // no block cache, only compressed cache
-        table_options.no_block_cache = true;
-        table_options.block_cache = nullptr;
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 2:
-        // both compressed and uncompressed block cache
-        table_options.block_cache = NewLRUCache(1024);
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 3:
-        // both block cache and compressed cache, but DB is not compressed
-        // also, make block cache sizes bigger, to trigger block cache hits
-        table_options.block_cache = NewLRUCache(1024 * 1024);
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        options.compression = kNoCompression;
-        break;
-      default:
-        ASSERT_TRUE(false);
-    }
-    CreateAndReopenWithCF({"pikachu"}, options);
-    // default column family doesn't have block cache
-    Options no_block_cache_opts;
-    no_block_cache_opts.statistics = options.statistics;
-    no_block_cache_opts = CurrentOptions(no_block_cache_opts);
-    BlockBasedTableOptions table_options_no_bc;
-    table_options_no_bc.no_block_cache = true;
-    no_block_cache_opts.table_factory.reset(
-        NewBlockBasedTableFactory(table_options_no_bc));
-    ReopenWithColumnFamilies(
-        {"default", "pikachu"},
-        std::vector<Options>({no_block_cache_opts, options}));
-
-    Random rnd(301);
-
-    // Write 8MB (80 values, each 100K)
-    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
-    std::vector<std::string> values;
-    std::string str;
-    for (int i = 0; i < num_iter; i++) {
-      if (i % 4 == 0) {  // high compression ratio
-        str = RandomString(&rnd, 1000);
-      }
-      values.push_back(str);
-      ASSERT_OK(Put(1, Key(i), values[i]));
-    }
-
-    // flush all data from memtable so that reads are from block cache
-    ASSERT_OK(Flush(1));
-
-    for (int i = 0; i < num_iter; i++) {
-      ASSERT_EQ(Get(1, Key(i)), values[i]);
-    }
-
-    // check that we triggered the appropriate code paths in the cache
-    switch (iter) {
-      case 0:
-        // only uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 1:
-        // no block cache, only compressed cache
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 2:
-        // both compressed and uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 3:
-        // both compressed and uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_HIT), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        // compressed doesn't have any hits since blocks are not compressed on
-        // storage
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT), 0);
-        break;
-      default:
-        ASSERT_TRUE(false);
-    }
-
-    options.create_if_missing = true;
-    DestroyAndReopen(options);
-  }
-}
-
-#endif  // ROCKSDB_LITE

 }  // namespace rocksdb

@@ -368,10 +368,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
 // entries are deleted. The compaction should create bunch of 'DeleteFile'
 // entries in VersionEdit, but none of the 'AddFile's.
 TEST_F(DBTestCompactionFilter, CompactionFilterDeletesAll) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // put some data
@@ -399,10 +400,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilterDeletesAll) {

 TEST_F(DBTestCompactionFilter, CompactionFilterWithValueChange) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.num_levels = 3;
    options.compaction_filter_factory =
      std::make_shared<ChangeFilterFactory>();
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Write 100K+1 keys, these are written to a few files
@@ -465,7 +467,8 @@ TEST_F(DBTestCompactionFilter, CompactionFilterWithMergeOperator) {
  PutFixed64(&three, 3);
  PutFixed64(&four, 4);

-  Options options = CurrentOptions();
+  Options options;
+  options = CurrentOptions(options);
  options.create_if_missing = true;
  options.merge_operator = MergeOperators::CreateUInt64AddOperator();
  options.num_levels = 3;
@@ -618,10 +621,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextCfId) {
 // Compaction filters should only be applied to records that are newer than the
 // latest snapshot. This test inserts records and applies a delete filter.
 TEST_F(DBTestCompactionFilter, CompactionFilterSnapshot) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_filter_factory = std::make_shared<DeleteFilterFactory>();
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // Put some data.
@@ -655,10 +659,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilterSnapshot) {
 // records newer than the snapshot will also be processed
 TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
  std::string five = ToString(5);
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_filter_factory = std::make_shared<DeleteISFilterFactory>();
  options.disable_auto_compactions = true;
  options.create_if_missing = true;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // Put some data.
@@ -40,6 +40,34 @@ class DBCompactionTestWithParam
 };

 namespace {
+class OnFileDeletionListener : public EventListener {
+ public:
+  OnFileDeletionListener() :
+      matched_count_(0),
+      expected_file_name_("") {}
+
+  void SetExpectedFileName(
+      const std::string file_name) {
+    expected_file_name_ = file_name;
+  }
+
+  void VerifyMatchedCount(size_t expected_value) {
+    ASSERT_EQ(matched_count_, expected_value);
+  }
+
+  void OnTableFileDeleted(
+      const TableFileDeletionInfo& info) override {
+    if (expected_file_name_ != "") {
+      ASSERT_EQ(expected_file_name_, info.file_path);
+      expected_file_name_ = "";
+      matched_count_++;
+    }
+  }
+
+ private:
+  size_t matched_count_;
+  std::string expected_file_name_;
+};

 class FlushedFileCollector : public EventListener {
 public:
@@ -70,7 +98,8 @@ class FlushedFileCollector : public EventListener {
 static const int kCDTValueSize = 1000;
 static const int kCDTKeysPerBuffer = 4;
 static const int kCDTNumLevels = 8;
-Options DeletionTriggerOptions(Options options) {
+Options DeletionTriggerOptions() {
+  Options options;
  options.compression = kNoCompression;
  options.write_buffer_size = kCDTKeysPerBuffer * (kCDTValueSize + 24);
  options.min_write_buffer_number_to_merge = 1;
@@ -173,7 +202,7 @@ const SstFileMetaData* PickFileRandomly(
 TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
  for (int tid = 0; tid < 3; ++tid) {
    uint64_t db_size[2];
-    Options options = DeletionTriggerOptions(CurrentOptions());
+    Options options = CurrentOptions(DeletionTriggerOptions());
    options.max_subcompactions = max_subcompactions_;

    if (tid == 1) {
@@ -216,7 +245,8 @@ TEST_F(DBCompactionTest, SkipStatsUpdateTest) {
  // the compaction behavior when there are many of deletion entries.
  // The test will need to be updated if the internal behavior changes.

-  Options options = DeletionTriggerOptions(CurrentOptions());
+  Options options = DeletionTriggerOptions();
+  options = CurrentOptions(options);
  options.env = env_;
  DestroyAndReopen(options);
  Random rnd(301);
@@ -258,7 +288,8 @@ TEST_F(DBCompactionTest, SkipStatsUpdateTest) {
 }

 TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
-  Options options = CurrentOptions();
+  Options options;
+  options = CurrentOptions(options);
  options.env = env_;
  options.new_table_reader_for_compaction_inputs = true;
  options.max_open_files = 100;
@@ -347,7 +378,7 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
 TEST_P(DBCompactionTestWithParam, CompactionDeletionTriggerReopen) {
  for (int tid = 0; tid < 2; ++tid) {
    uint64_t db_size[3];
-    Options options = DeletionTriggerOptions(CurrentOptions());
+    Options options = CurrentOptions(DeletionTriggerOptions());
    options.max_subcompactions = max_subcompactions_;

    if (tid == 1) {
@@ -404,7 +435,7 @@ TEST_P(DBCompactionTestWithParam, CompactionDeletionTriggerReopen) {
 TEST_F(DBCompactionTest, DisableStatsUpdateReopen) {
  uint64_t db_size[3];
  for (int test = 0; test < 2; ++test) {
-    Options options = DeletionTriggerOptions(CurrentOptions());
+    Options options = CurrentOptions(DeletionTriggerOptions());
    options.skip_stats_update_on_db_open = (test == 0);

    env_->random_read_counter_.Reset();
@@ -462,13 +493,14 @@ TEST_F(DBCompactionTest, DisableStatsUpdateReopen) {
 TEST_P(DBCompactionTestWithParam, CompactionTrigger) {
  const int kNumKeysPerFile = 100;

-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
  options.num_levels = 3;
  options.level0_file_num_compaction_trigger = 3;
  options.max_subcompactions = max_subcompactions_;
  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
+  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  Random rnd(301);
@@ -506,7 +538,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {
  // and see number of compactions scheduled to be less than allowed.
  const int kNumKeysPerFile = 100;

-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
  options.num_levels = 3;
@@ -517,6 +549,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {
  options.base_background_compactions = 1;
  options.max_background_compactions = 3;
  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
+  options = CurrentOptions(options);

  // Block all threads in thread pool.
  const size_t kTotalTasks = 4;
@@ -599,9 +632,10 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {
 }

 TEST_P(DBCompactionTestWithParam, CompactionsGenerateMultipleFiles) {
-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 100000000;        // Large write buffer
  options.max_subcompactions = max_subcompactions_;
+  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  Random rnd(301);
@@ -628,8 +662,9 @@ TEST_P(DBCompactionTestWithParam, CompactionsGenerateMultipleFiles) {

 TEST_F(DBCompactionTest, MinorCompactionsHappen) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.write_buffer_size = 10000;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    const int N = 500;
@@ -654,7 +689,7 @@ TEST_F(DBCompactionTest, MinorCompactionsHappen) {
 }

 TEST_F(DBCompactionTest, ZeroSeqIdCompaction) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleLevel;
  options.level0_file_num_compaction_trigger = 3;

@@ -668,6 +703,7 @@ TEST_F(DBCompactionTest, ZeroSeqIdCompaction) {
  const size_t key_len =
    static_cast<size_t>(compact_opt.output_file_size_limit) / 5;

+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  std::vector<const Snapshot*> snaps;
@@ -711,8 +747,10 @@ TEST_F(DBCompactionTest, ZeroSeqIdCompaction) {
 // if the database is shutdown during the memtable compaction.
 TEST_F(DBCompactionTest, RecoverDuringMemtableCompaction) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.env = env_;
+    options.write_buffer_size = 1000000;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Trigger a long memtable compaction and reopen the database during it
@@ -736,9 +774,10 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveOneFile) {
      [&](void* arg) { trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 100000000;
  options.max_subcompactions = max_subcompactions_;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t num_keys = 80;
@@ -956,9 +995,7 @@ TEST_P(DBCompactionTestWithParam, ManualCompactionPartial) {
  bool second = true;
  rocksdb::SyncPoint::GetInstance()->LoadDependency(
      {{"DBCompaction::ManualPartial:4", "DBCompaction::ManualPartial:1"},
-       {"DBCompaction::ManualPartial:2", "DBCompaction::ManualPartial:3"},
-       {"DBCompaction::ManualPartial:5",
-        "DBImpl::BackgroundCompaction:NonTrivial:AfterRun"}});
+       {"DBCompaction::ManualPartial:2", "DBCompaction::ManualPartial:3"}});
  rocksdb::SyncPoint::GetInstance()->SetCallBack(
      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun", [&](void* arg) {
        if (first) {
@@ -1069,8 +1106,6 @@ TEST_P(DBCompactionTestWithParam, ManualCompactionPartial) {

  // 3 files in L0
  ASSERT_EQ("3,0,0,0,0,1,2", FilesPerLevel(0));
-  TEST_SYNC_POINT("DBCompaction::ManualPartial:5");
-
  // 1 file in L6, 1 file in L1
  dbfull()->TEST_WaitForFlushMemTable();
  dbfull()->TEST_WaitForCompact();
@@ -1334,9 +1369,10 @@ TEST_P(DBCompactionTestWithParam, TrivialMoveToLastLevelWithFiles) {
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 100000000;
  options.max_subcompactions = max_subcompactions_;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB
@@ -1625,7 +1661,7 @@ TEST_P(DBCompactionTestWithParam, ConvertCompactionStyle) {
  int max_key_universal_insert = 600;

  // Stage 1: generate a db with level compaction
-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
  options.num_levels = 4;
@@ -1635,6 +1671,7 @@ TEST_P(DBCompactionTestWithParam, ConvertCompactionStyle) {
  options.target_file_size_base = 200 << 10;  // 200KB
  options.target_file_size_multiplier = 1;
  options.max_subcompactions = max_subcompactions_;
+  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  for (int i = 0; i <= max_key_level_insert; i++) {
@@ -2349,9 +2386,10 @@ TEST_P(DBCompactionTestWithParam, ForceBottommostLevelCompaction) {
      [&](void* arg) { non_trivial_move++; });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 100000000;
  options.max_subcompactions = max_subcompactions_;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  int32_t value_size = 10 * 1024;  // 10 KB
@@ -2441,14 +2479,14 @@ class CompactionPriTest : public DBTestBase,
 };

 TEST_P(CompactionPriTest, Test) {
-  Options options = CurrentOptions();
+  Options options;
  options.write_buffer_size = 16 * 1024;
  options.compaction_pri = static_cast<CompactionPri>(compaction_pri_);
  options.hard_pending_compaction_bytes_limit = 256 * 1024;
  options.max_bytes_for_level_base = 64 * 1024;
  options.max_bytes_for_level_multiplier = 4;
  options.compression = kNoCompression;
-
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  Random rnd(301);
@@ -12,14 +12,12 @@
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif
+
 #include <inttypes.h>
 #include <stdint.h>
 #ifdef OS_SOLARIS
 #include <alloca.h>
 #endif
-#ifdef ROCKSDB_JEMALLOC
-#include "jemalloc/jemalloc.h"
-#endif

 #include <algorithm>
 #include <climits>
@@ -203,44 +201,6 @@ Status SanitizeOptionsByTable(
  return Status::OK();
 }

-static Status ValidateOptions(
-    const DBOptions& db_options,
-    const std::vector<ColumnFamilyDescriptor>& column_families) {
-  Status s;
-
-  for (auto& cfd : column_families) {
-    s = CheckCompressionSupported(cfd.options);
-    if (s.ok() && db_options.allow_concurrent_memtable_write) {
-      s = CheckConcurrentWritesSupported(cfd.options);
-    }
-    if (!s.ok()) {
-      return s;
-    }
-    if (db_options.db_paths.size() > 1) {
-      if ((cfd.options.compaction_style != kCompactionStyleUniversal) &&
-          (cfd.options.compaction_style != kCompactionStyleLevel)) {
-        return Status::NotSupported(
-            "More than one DB paths are only supported in "
-            "universal and level compaction styles. ");
-      }
-    }
-  }
-
-  if (db_options.db_paths.size() > 4) {
-    return Status::NotSupported(
-        "More than four DB paths are not supported yet. ");
-  }
-
-  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 os caching (allow_os_buffer) must also be enabled. ");
-  }
-
-  return Status::OK();
-}
-
 CompressionType GetCompressionFlush(const ImmutableCFOptions& ioptions) {
  // Compressing memtable flushes might not help unless the sequential load
  // optimization is used for leveled compaction. Otherwise the CPU and
@@ -445,21 +405,6 @@ DBImpl::~DBImpl() {
  }
  logs_.clear();

-  // Table cache may have table handles holding blocks from the block cache.
-  // We need to release them before the block cache is destroyed. The block
-  // cache may be destroyed inside versions_.reset(), when column family data
-  // list is destroyed, so leaving handles in table cache after
-  // versions_.reset() may cause issues.
-  // Here we clean all unreferenced handles in table cache.
-  // Now we assume all user queries have finished, so only version set itself
-  // can possibly hold the blocks from block cache. After releasing unreferenced
-  // handles here, only handles held by version set left and inside
-  // versions_.reset(), we will release them. There, we need to make sure every
-  // time a handle is released, we erase it from the cache too. By doing that,
-  // we can guarantee that after versions_.reset(), table cache is empty
-  // so the cache can be safely destroyed.
-  table_cache_->EraseUnRefEntries();
-
  // versions need to be destroyed before table_cache since it can hold
  // references to table_cache.
  versions_.reset();
@@ -536,39 +481,6 @@ void DBImpl::PrintStatistics() {
  }
 }

-#ifndef ROCKSDB_LITE
-#ifdef ROCKSDB_JEMALLOC
-typedef struct {
-  char* cur;
-  char* end;
-} MallocStatus;
-
-static void GetJemallocStatus(void* mstat_arg, const char* status) {
-  MallocStatus* mstat = reinterpret_cast<MallocStatus*>(mstat_arg);
-  size_t status_len = status ? strlen(status) : 0;
-  size_t buf_size = (size_t)(mstat->end - mstat->cur);
-  if (!status_len || status_len > buf_size) {
-    return;
-  }
-
-  snprintf(mstat->cur, buf_size, "%s", status);
-  mstat->cur += status_len;
-}
-#endif  // ROCKSDB_JEMALLOC
-
-static void DumpMallocStats(std::string* stats) {
-#ifdef ROCKSDB_JEMALLOC
-  MallocStatus mstat;
-  const uint kMallocStatusLen = 1000000;
-  std::unique_ptr<char> buf{new char[kMallocStatusLen + 1]};
-  mstat.cur = buf.get();
-  mstat.end = buf.get() + kMallocStatusLen;
-  malloc_stats_print(GetJemallocStatus, &mstat, "");
-  stats->append(buf.get());
-#endif  // ROCKSDB_JEMALLOC
-}
-#endif  // !ROCKSDB_LITE
-
 void DBImpl::MaybeDumpStats() {
  if (db_options_.stats_dump_period_sec == 0) return;

@@ -601,9 +513,6 @@ void DBImpl::MaybeDumpStats() {
      default_cf_internal_stats_->GetStringProperty(
          *db_property_info, DB::Properties::kDBStats, &stats);
    }
-    if (db_options_.dump_malloc_stats) {
-      DumpMallocStats(&stats);
-    }
    Log(InfoLogLevel::WARN_LEVEL,
        db_options_.info_log, "------- DUMPING STATS -------");
    Log(InfoLogLevel::WARN_LEVEL,
@@ -920,8 +829,7 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state) {

  // Delete old info log files.
  size_t old_info_log_file_count = old_info_log_files.size();
-  if (old_info_log_file_count != 0 &&
-      old_info_log_file_count >= db_options_.keep_log_file_num) {
+  if (old_info_log_file_count >= db_options_.keep_log_file_num) {
    std::sort(old_info_log_files.begin(), old_info_log_files.end());
    size_t end = old_info_log_file_count - db_options_.keep_log_file_num;
    for (unsigned int i = 0; i <= end; i++) {
@@ -1026,7 +934,7 @@ Directory* DBImpl::Directories::GetDataDir(size_t path_id) {

 Status DBImpl::Recover(
    const std::vector<ColumnFamilyDescriptor>& column_families, bool read_only,
-    bool error_if_log_file_exist, bool error_if_data_exists_in_logs) {
+    bool error_if_log_file_exist) {
  mutex_.AssertHeld();

  bool is_new_db = false;
@@ -1121,25 +1029,10 @@ Status DBImpl::Recover(
      }
    }

-    if (logs.size() > 0) {
-      if (error_if_log_file_exist) {
-        return Status::Corruption(
-            "The db was opened in readonly mode with error_if_log_file_exist"
-            "flag but a log file already exists");
-      } else if (error_if_data_exists_in_logs) {
-        for (auto& log : logs) {
-          std::string fname = LogFileName(db_options_.wal_dir, log);
-          uint64_t bytes;
-          s = env_->GetFileSize(fname, &bytes);
-          if (s.ok()) {
-            if (bytes > 0) {
-              return Status::Corruption(
-                  "error_if_data_exists_in_logs is set but there are data "
-                  " in log files.");
-            }
-          }
-        }
-      }
+    if (logs.size() > 0 && error_if_log_file_exist) {
+      return Status::Corruption(""
+          "The db was opened in readonly mode with error_if_log_file_exist"
+          "flag but a log file already exists");
    }

    if (!logs.empty()) {
@@ -1209,23 +1102,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
    stream.EndArray();
  }

-#ifndef ROCKSDB_LITE
-  if (db_options_.wal_filter != nullptr) {
-    std::map<std::string, uint32_t> cf_name_id_map;
-    std::map<uint32_t, uint64_t> cf_lognumber_map;
-    for (auto cfd : *versions_->GetColumnFamilySet()) {
-      cf_name_id_map.insert(
-        std::make_pair(cfd->GetName(), cfd->GetID()));
-      cf_lognumber_map.insert(
-        std::make_pair(cfd->GetID(), cfd->GetLogNumber()));
-    }
-
-    db_options_.wal_filter->ColumnFamilyLogNumberMap(
-      cf_lognumber_map,
-      cf_name_id_map);
-  }
-#endif
-
  bool continue_replay_log = true;
  for (auto log_number : log_numbers) {
    // The previous incarnation may not have written any MANIFEST
@@ -1292,7 +1168,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
        continue_replay_log &&
        reader.ReadRecord(&record, &scratch, db_options_.wal_recovery_mode) &&
        status.ok()) {
-      if (record.size() < WriteBatchInternal::kHeader) {
+      if (record.size() < 12) {
        reporter.Corruption(record.size(),
                            Status::Corruption("log record too small"));
        continue;
@@ -1305,8 +1181,8 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
        bool batch_changed = false;

        WalFilter::WalProcessingOption wal_processing_option =
-            db_options_.wal_filter->LogRecordFound(log_number, fname, batch,
-                                              &new_batch, &batch_changed);
+            db_options_.wal_filter->LogRecord(batch, &new_batch,
+                                              &batch_changed);

        switch (wal_processing_option) {
          case WalFilter::WalProcessingOption::kContinueProcessing:
@@ -1534,6 +1410,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
        cfd->GetLatestMutableCFOptions()->paranoid_file_checks;
    {
      mutex_.Unlock();
+      TableFileCreationInfo info;

      SequenceNumber earliest_write_conflict_snapshot;
      std::vector<SequenceNumber> snapshot_seqs =
@@ -1542,18 +1419,30 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
      s = BuildTable(
          dbname_, env_, *cfd->ioptions(), env_options_, 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,
+          cfd->int_tbl_prop_collector_factories(), cfd->GetID(), snapshot_seqs,
+          earliest_write_conflict_snapshot,
          GetCompressionFlush(*cfd->ioptions()),
          cfd->ioptions()->compression_opts, paranoid_file_checks,
-          cfd->internal_stats(), TableFileCreationReason::kRecovery,
-          &event_logger_, job_id);
+          cfd->internal_stats(), Env::IO_HIGH, &info.table_properties);
      LogFlush(db_options_.info_log);
      Log(InfoLogLevel::DEBUG_LEVEL, db_options_.info_log,
          "[%s] [WriteLevel0TableForRecovery]"
          " Level-0 table #%" PRIu64 ": %" PRIu64 " bytes %s",
          cfd->GetName().c_str(), meta.fd.GetNumber(), meta.fd.GetFileSize(),
          s.ToString().c_str());
+
+      // output to event logger
+      if (s.ok()) {
+        info.db_name = dbname_;
+        info.cf_name = cfd->GetName();
+        info.file_path = TableFileName(db_options_.db_paths,
+                                       meta.fd.GetNumber(),
+                                       meta.fd.GetPathId());
+        info.file_size = meta.fd.GetFileSize();
+        info.job_id = job_id;
+        EventHelpers::LogAndNotifyTableFileCreation(
+            &event_logger_, db_options_.listeners, meta.fd, info);
+      }
      mutex_.Lock();
    }
  }
@@ -1591,13 +1480,12 @@ Status DBImpl::FlushMemTableToOutputFile(
  std::vector<SequenceNumber> snapshot_seqs =
      snapshots_.GetAll(&earliest_write_conflict_snapshot);

-  FlushJob flush_job(dbname_, cfd, db_options_, mutable_cf_options,
-                     env_options_, versions_.get(), &mutex_, &shutting_down_,
-                     snapshot_seqs, earliest_write_conflict_snapshot,
-                     job_context, log_buffer, directories_.GetDbDir(),
-                     directories_.GetDataDir(0U),
-                     GetCompressionFlush(*cfd->ioptions()), stats_,
-                     &event_logger_, mutable_cf_options.report_bg_io_stats);
+  FlushJob flush_job(
+      dbname_, cfd, db_options_, mutable_cf_options, env_options_,
+      versions_.get(), &mutex_, &shutting_down_, snapshot_seqs,
+      earliest_write_conflict_snapshot, job_context, log_buffer,
+      directories_.GetDbDir(), directories_.GetDataDir(0U),
+      GetCompressionFlush(*cfd->ioptions()), stats_, &event_logger_);

  FileMetaData file_meta;

@@ -1626,6 +1514,7 @@ Status DBImpl::FlushMemTableToOutputFile(
    // true, mark DB read-only
    bg_error_ = s;
  }
+  RecordFlushIOStats();
  if (s.ok()) {
 #ifndef ROCKSDB_LITE
    // may temporarily unlock and lock the mutex.
@@ -1945,7 +1834,7 @@ Status DBImpl::CompactFilesImpl(
      directories_.GetDataDir(c->output_path_id()), stats_, &mutex_, &bg_error_,
      snapshot_seqs, earliest_write_conflict_snapshot, table_cache_,
      &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
-      c->mutable_cf_options()->report_bg_io_stats, dbname_,
+      c->mutable_cf_options()->compaction_measure_io_stats, dbname_,
      nullptr);  // Here we pass a nullptr for CompactionJobStats because
                 // CompactFiles does not trigger OnCompactionCompleted(),
                 // which is the only place where CompactionJobStats is
@@ -2694,6 +2583,11 @@ void DBImpl::SchedulePendingCompaction(ColumnFamilyData* cfd) {
  }
 }

+void DBImpl::RecordFlushIOStats() {
+  RecordTick(stats_, FLUSH_WRITE_BYTES, IOSTATS(bytes_written));
+  IOSTATS_RESET(bytes_written);
+}
+
 void DBImpl::BGWorkFlush(void* db) {
  IOSTATS_SET_THREAD_POOL_ID(Env::Priority::HIGH);
  TEST_SYNC_POINT("DBImpl::BGWorkFlush");
@@ -2827,6 +2721,7 @@ void DBImpl::BackgroundCallFlush() {
    bg_flush_scheduled_--;
    // See if there's more work to be done
    MaybeScheduleFlushOrCompaction();
+    RecordFlushIOStats();
    bg_cv_.SignalAll();
    // IMPORTANT: there should be no code after calling SignalAll. This call may
    // signal the DB destructor that it's OK to proceed with destruction. In
@@ -3145,7 +3040,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        &bg_error_, snapshot_seqs, earliest_write_conflict_snapshot,
        table_cache_, &event_logger_,
        c->mutable_cf_options()->paranoid_file_checks,
-        c->mutable_cf_options()->report_bg_io_stats, dbname_,
+        c->mutable_cf_options()->compaction_measure_io_stats, dbname_,
        &compaction_job_stats);
    compaction_job.Prepare();

@@ -5460,9 +5355,27 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
    return s;
  }

-  s = ValidateOptions(db_options, column_families);
-  if (!s.ok()) {
-    return s;
+  for (auto& cfd : column_families) {
+    s = CheckCompressionSupported(cfd.options);
+    if (s.ok() && db_options.allow_concurrent_memtable_write) {
+      s = CheckConcurrentWritesSupported(cfd.options);
+    }
+    if (!s.ok()) {
+      return s;
+    }
+    if (db_options.db_paths.size() > 1) {
+      if ((cfd.options.compaction_style != kCompactionStyleUniversal) &&
+          (cfd.options.compaction_style != kCompactionStyleLevel)) {
+        return Status::NotSupported(
+            "More than one DB paths are only supported in "
+            "universal and level compaction styles. ");
+      }
+    }
+  }
+
+  if (db_options.db_paths.size() > 4) {
+    return Status::NotSupported(
+        "More than four DB paths are not supported yet. ");
  }

  *dbptr = nullptr;
@@ -232,7 +232,7 @@ class DBImpl : public DB {
  // SST files will also be checked.
  //
  // If a key is found, *found_record_for_key will be set to true and
-  // *seq will be set to the stored sequence number for the latest
+  // *seq will will be set to the stored sequence number for the latest
  // operation on this key or kMaxSequenceNumber if unknown.
  // If no key is found, *found_record_for_key will be set to false.
  //
@@ -483,8 +483,7 @@ class DBImpl : public DB {
  // amount of work to recover recently logged updates.  Any changes to
  // be made to the descriptor are added to *edit.
  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
-                 bool read_only = false, bool error_if_log_file_exist = false,
-                 bool error_if_data_exists_in_logs = false);
+                 bool read_only = false, bool error_if_log_file_exist = false);

  void MaybeIgnoreError(Status* s) const;

@@ -524,7 +523,7 @@ class DBImpl : public DB {
                         SequenceNumber* max_sequence, bool read_only);

  // The following two methods are used to flush a memtable to
-  // storage. The first one is used at database RecoveryTime (when the
+  // storage. The first one is used atdatabase RecoveryTime (when the
  // database is opened) and is heavyweight because it holds the mutex
  // for the entire period. The second method WriteLevel0Table supports
  // concurrent flush memtables to storage.
@@ -545,6 +544,9 @@ class DBImpl : public DB {
  // Wait for memtable flushed
  Status WaitForFlushMemTable(ColumnFamilyData* cfd);

+  void RecordFlushIOStats();
+  void RecordCompactionIOStats();
+
 #ifndef ROCKSDB_LITE
  Status CompactFilesImpl(
      const CompactionOptions& compact_options, ColumnFamilyData* cfd,
@@ -18,11 +18,12 @@ class DBTestInPlaceUpdate : public DBTestBase {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdate) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Update key with values of smaller size
@@ -40,11 +41,12 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdate) {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdateLargeNewValue) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;
    options.env = env_;
    options.write_buffer_size = 100000;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Update key with values of larger size
@@ -62,7 +64,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateLargeNewValue) {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerSize) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;

@@ -70,6 +72,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerSize) {
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTestInPlaceUpdate::updateInPlaceSmallerSize;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Update key with values of smaller size
@@ -89,7 +92,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerSize) {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerVarintSize) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;

@@ -97,6 +100,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerVarintSize) {
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTestInPlaceUpdate::updateInPlaceSmallerVarintSize;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Update key with values of smaller varint size
@@ -116,7 +120,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackSmallerVarintSize) {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackLargeNewValue) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;

@@ -124,6 +128,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackLargeNewValue) {
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTestInPlaceUpdate::updateInPlaceLargerSize;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Update key with values of larger size
@@ -141,7 +146,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackLargeNewValue) {

 TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackNoAction) {
  do {
-    Options options = CurrentOptions();
+    Options options;
    options.create_if_missing = true;
    options.inplace_update_support = true;

@@ -149,6 +154,7 @@ TEST_F(DBTestInPlaceUpdate, InPlaceUpdateCallbackNoAction) {
    options.write_buffer_size = 100000;
    options.inplace_callback =
      rocksdb::DBTestInPlaceUpdate::updateInPlaceNoAction;
+    options = CurrentOptions(options);
    CreateAndReopenWithCF({"pikachu"}, options);

    // Callback function requests no actions from db
@@ -15,8 +15,6 @@

 #include "db/dbformat.h"
 #include "db/filename.h"
-#include "db/merge_context.h"
-#include "db/pinned_iterators_manager.h"
 #include "port/port.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
@@ -104,7 +102,7 @@ class DBIter: public Iterator {
         InternalIterator* iter, SequenceNumber s, bool arena_mode,
         uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
         const Slice* iterate_upper_bound = nullptr,
-         bool prefix_same_as_start = false, bool pin_data = false)
+         bool prefix_same_as_start = false)
      : arena_mode_(arena_mode),
        env_(env),
        logger_(ioptions.info_log),
@@ -119,20 +117,12 @@ class DBIter: public Iterator {
        version_number_(version_number),
        iterate_upper_bound_(iterate_upper_bound),
        prefix_same_as_start_(prefix_same_as_start),
-        pin_thru_lifetime_(pin_data) {
+        iter_pinned_(false) {
    RecordTick(statistics_, NO_ITERATORS);
    prefix_extractor_ = ioptions.prefix_extractor;
    max_skip_ = max_sequential_skip_in_iterations;
-    if (pin_thru_lifetime_) {
-      pinned_iters_mgr_.StartPinning();
-    }
-    if (iter_) {
-      iter_->SetPinnedItersMgr(&pinned_iters_mgr_);
-    }
  }
  virtual ~DBIter() {
-    // Release pinned data if any
-    pinned_iters_mgr_.ReleasePinnedIterators();
    RecordTick(statistics_, NO_ITERATORS, -1);
    local_stats_.BumpGlobalStatistics(statistics_);
    if (!arena_mode_) {
@@ -144,7 +134,9 @@ class DBIter: public Iterator {
  virtual void SetIter(InternalIterator* iter) {
    assert(iter_ == nullptr);
    iter_ = iter;
-    iter_->SetPinnedItersMgr(&pinned_iters_mgr_);
+    if (iter_ && iter_pinned_) {
+      iter_->PinData();
+    }
  }
  virtual bool Valid() const override { return valid_; }
  virtual Slice key() const override {
@@ -153,13 +145,8 @@ class DBIter: public Iterator {
  }
  virtual Slice value() const override {
    assert(valid_);
-    if (current_entry_is_merged_) {
-      return saved_value_;
-    } else if (direction_ == kReverse) {
-      return pinned_value_;
-    } else {
-      return iter_->value();
-    }
+    return (direction_ == kForward && !current_entry_is_merged_) ?
+      iter_->value() : saved_value_;
  }
  virtual Status status() const override {
    if (status_.ok()) {
@@ -168,6 +155,28 @@ class DBIter: public Iterator {
      return status_;
    }
  }
+  virtual Status PinData() {
+    Status s;
+    if (iter_) {
+      s = iter_->PinData();
+    }
+    if (s.ok()) {
+      // Even if iter_ is nullptr, we set iter_pinned_ to true so that when
+      // iter_ is updated using SetIter, we Pin it.
+      iter_pinned_ = true;
+    }
+    return s;
+  }
+  virtual Status ReleasePinnedData() {
+    Status s;
+    if (iter_) {
+      s = iter_->ReleasePinnedData();
+    }
+    if (s.ok()) {
+      iter_pinned_ = false;
+    }
+    return s;
+  }

  virtual Status GetProperty(std::string prop_name,
                             std::string* prop) override {
@@ -182,7 +191,7 @@ class DBIter: public Iterator {
      return Status::OK();
    } else if (prop_name == "rocksdb.iterator.is-key-pinned") {
      if (valid_) {
-        *prop = (pin_thru_lifetime_ && saved_key_.IsKeyPinned()) ? "1" : "0";
+        *prop = (iter_pinned_ && saved_key_.IsKeyPinned()) ? "1" : "0";
      } else {
        *prop = "Iterator is not valid.";
      }
@@ -205,26 +214,11 @@ class DBIter: public Iterator {
  bool FindValueForCurrentKeyUsingSeek();
  void FindPrevUserKey();
  void FindNextUserKey();
-  inline void FindNextUserEntry(bool skipping, bool prefix_check);
-  void FindNextUserEntryInternal(bool skipping, bool prefix_check);
+  inline void FindNextUserEntry(bool skipping);
+  void FindNextUserEntryInternal(bool skipping);
  bool ParseKey(ParsedInternalKey* key);
  void MergeValuesNewToOld();

-  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
-  // is called
-  void TempPinData() {
-    if (!pin_thru_lifetime_) {
-      pinned_iters_mgr_.StartPinning();
-    }
-  }
-
-  // Release blocks pinned by TempPinData()
-  void ReleaseTempPinnedData() {
-    if (!pin_thru_lifetime_) {
-      pinned_iters_mgr_.ReleasePinnedIterators();
-    }
-  }
-
  inline void ClearSavedValue() {
    if (saved_value_.capacity() > 1048576) {
      std::string empty;
@@ -246,7 +240,6 @@ class DBIter: public Iterator {
  Status status_;
  IterKey saved_key_;
  std::string saved_value_;
-  Slice pinned_value_;
  Direction direction_;
  bool valid_;
  bool current_entry_is_merged_;
@@ -254,16 +247,12 @@ class DBIter: public Iterator {
  uint64_t max_skip_;
  uint64_t version_number_;
  const Slice* iterate_upper_bound_;
-  IterKey prefix_start_buf_;
-  Slice prefix_start_key_;
-  const bool prefix_same_as_start_;
-  // Means that we will pin all data blocks we read as long the Iterator
-  // is not deleted, will be true if ReadOptions::pin_data is true
-  const bool pin_thru_lifetime_;
+  IterKey prefix_start_;
+  bool prefix_same_as_start_;
+  bool iter_pinned_;
  // List of operands for merge operator.
-  MergeContext merge_context_;
+  std::deque<std::string> merge_operands_;
  LocalStatistics local_stats_;
-  PinnedIteratorsManager pinned_iters_mgr_;

  // No copying allowed
  DBIter(const DBIter&);
@@ -286,8 +275,6 @@ void DBIter::Next() {
  assert(valid_);

  if (direction_ == kReverse) {
-    // We only pin blocks when doing kReverse
-    ReleaseTempPinnedData();
    FindNextUserKey();
    direction_ = kForward;
    if (!iter_->Valid()) {
@@ -312,7 +299,12 @@ void DBIter::Next() {
    valid_ = false;
    return;
  }
-  FindNextUserEntry(true /* skipping the current user key */, prefix_same_as_start_);
+  FindNextUserEntry(true /* skipping the current user key */);
+  if (valid_ && prefix_extractor_ && prefix_same_as_start_ &&
+      prefix_extractor_->Transform(saved_key_.GetKey())
+              .compare(prefix_start_.GetKey()) != 0) {
+    valid_ = false;
+  }
  if (statistics_ != nullptr && valid_) {
    local_stats_.next_found_count_++;
    local_stats_.bytes_read_ += (key().size() + value().size());
@@ -327,18 +319,13 @@ void DBIter::Next() {
 //
 // NOTE: In between, saved_key_ can point to a user key that has
 //       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
-// performing a seek without a key (e.g. SeekToFirst). Set to
-// prefix_same_as_start_ for other iterations.
-inline void DBIter::FindNextUserEntry(bool skipping, bool prefix_check) {
+inline void DBIter::FindNextUserEntry(bool skipping) {
  PERF_TIMER_GUARD(find_next_user_entry_time);
-  FindNextUserEntryInternal(skipping, prefix_check);
+  FindNextUserEntryInternal(skipping);
 }

 // Actual implementation of DBIter::FindNextUserEntry()
-void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
+void DBIter::FindNextUserEntryInternal(bool skipping) {
  // Loop until we hit an acceptable entry to yield
  assert(iter_->Valid());
  assert(direction_ == kForward);
@@ -353,11 +340,6 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
        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) {
@@ -369,24 +351,21 @@ void DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
            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 */);
+              saved_key_.SetKey(ikey.user_key,
+                                !iter_->IsKeyPinned() /* copy */);
              skipping = true;
              num_skipped = 0;
              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
              break;
            case kTypeValue:
              valid_ = true;
-              saved_key_.SetKey(
-                  ikey.user_key,
-                  !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
+              saved_key_.SetKey(ikey.user_key,
+                                !iter_->IsKeyPinned() /* copy */);
              return;
            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 */);
+              saved_key_.SetKey(ikey.user_key,
+                                !iter_->IsKeyPinned() /* copy */);
              current_entry_is_merged_ = true;
              valid_ = true;
              MergeValuesNewToOld();  // Go to a different state machine
@@ -432,9 +411,9 @@ void DBIter::MergeValuesNewToOld() {
    return;
  }

-  merge_context_.Clear();
  // Start the merge process by pushing the first operand
-  merge_context_.PushOperand(iter_->value());
+  std::deque<std::string> operands;
+  operands.push_front(iter_->value().ToString());

  ParsedInternalKey ikey;
  for (iter_->Next(); iter_->Valid(); iter_->Next()) {
@@ -459,8 +438,7 @@ void DBIter::MergeValuesNewToOld() {
      {
        StopWatchNano timer(env_, statistics_ != nullptr);
        PERF_TIMER_GUARD(merge_operator_time_nanos);
-        user_merge_operator_->FullMerge(ikey.user_key, &val,
-                                        merge_context_.GetOperands(),
+        user_merge_operator_->FullMerge(ikey.user_key, &val, operands,
                                        &saved_value_, logger_);
        RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME,
                   timer.ElapsedNanos());
@@ -472,7 +450,7 @@ void DBIter::MergeValuesNewToOld() {
      // hit a merge, add the value as an operand and run associative merge.
      // when complete, add result to operands and continue.
      const Slice& val = iter_->value();
-      merge_context_.PushOperand(val);
+      operands.push_front(val.ToString());
    } else {
      assert(false);
    }
@@ -485,9 +463,8 @@ 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.
-    user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr,
-                                    merge_context_.GetOperands(), &saved_value_,
-                                    logger_);
+    user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr, operands,
+                                    &saved_value_, logger_);
    RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME, timer.ElapsedNanos());
  }
 }
@@ -497,7 +474,6 @@ void DBIter::Prev() {
  if (direction_ == kForward) {
    ReverseToBackward();
  }
-  ReleaseTempPinnedData();
  PrevInternal();
  if (statistics_ != nullptr) {
    local_stats_.prev_count_++;
@@ -508,7 +484,7 @@ void DBIter::Prev() {
  }
  if (valid_ && prefix_extractor_ && prefix_same_as_start_ &&
      prefix_extractor_->Transform(saved_key_.GetKey())
-              .compare(prefix_start_key_) != 0) {
+              .compare(prefix_start_.GetKey()) != 0) {
    valid_ = false;
  }
 }
@@ -550,7 +526,7 @@ void DBIter::PrevInternal() {

  while (iter_->Valid()) {
    saved_key_.SetKey(ExtractUserKey(iter_->key()),
-                      !iter_->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
+                      !iter_->IsKeyPinned() /* copy */);
    if (FindValueForCurrentKey()) {
      valid_ = true;
      if (!iter_->Valid()) {
@@ -580,8 +556,7 @@ void DBIter::PrevInternal() {
 // saved_value_
 bool DBIter::FindValueForCurrentKey() {
  assert(iter_->Valid());
-  merge_context_.Clear();
-  current_entry_is_merged_ = false;
+  merge_operands_.clear();
  // last entry before merge (could be kTypeDeletion, kTypeSingleDeletion or
  // kTypeValue)
  ValueType last_not_merge_type = kTypeDeletion;
@@ -601,21 +576,19 @@ bool DBIter::FindValueForCurrentKey() {
    last_key_entry_type = ikey.type;
    switch (last_key_entry_type) {
      case kTypeValue:
-        merge_context_.Clear();
-        ReleaseTempPinnedData();
-        TempPinData();
-        pinned_value_ = iter_->value();
+        merge_operands_.clear();
+        saved_value_ = iter_->value().ToString();
        last_not_merge_type = kTypeValue;
        break;
      case kTypeDeletion:
      case kTypeSingleDeletion:
-        merge_context_.Clear();
+        merge_operands_.clear();
        last_not_merge_type = last_key_entry_type;
        PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
        break;
      case kTypeMerge:
        assert(user_merge_operator_ != nullptr);
-        merge_context_.PushOperandBack(iter_->value());
+        merge_operands_.push_back(iter_->value().ToString());
        break;
      default:
        assert(false);
@@ -634,23 +607,24 @@ bool DBIter::FindValueForCurrentKey() {
      valid_ = false;
      return false;
    case kTypeMerge:
-      current_entry_is_merged_ = true;
      if (last_not_merge_type == kTypeDeletion) {
        StopWatchNano timer(env_, statistics_ != nullptr);
        PERF_TIMER_GUARD(merge_operator_time_nanos);
        user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr,
-                                        merge_context_.GetOperands(),
-                                        &saved_value_, logger_);
+                                        merge_operands_, &saved_value_,
+                                        logger_);
        RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME,
                   timer.ElapsedNanos());
      } else {
        assert(last_not_merge_type == kTypeValue);
+        std::string last_put_value = saved_value_;
+        Slice temp_slice(last_put_value);
        {
          StopWatchNano timer(env_, statistics_ != nullptr);
          PERF_TIMER_GUARD(merge_operator_time_nanos);
-          user_merge_operator_->FullMerge(saved_key_.GetKey(), &pinned_value_,
-                                          merge_context_.GetOperands(),
-                                          &saved_value_, logger_);
+          user_merge_operator_->FullMerge(saved_key_.GetKey(), &temp_slice,
+                                          merge_operands_, &saved_value_,
+                                          logger_);
          RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME,
                     timer.ElapsedNanos());
        }
@@ -683,9 +657,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
  if (ikey.type == kTypeValue || ikey.type == kTypeDeletion ||
      ikey.type == kTypeSingleDeletion) {
    if (ikey.type == kTypeValue) {
-      ReleaseTempPinnedData();
-      TempPinData();
-      pinned_value_ = iter_->value();
+      saved_value_ = iter_->value().ToString();
      valid_ = true;
      return true;
    }
@@ -695,12 +667,11 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {

  // kTypeMerge. We need to collect all kTypeMerge values and save them
  // in operands
-  current_entry_is_merged_ = true;
-  merge_context_.Clear();
+  std::deque<std::string> operands;
  while (iter_->Valid() &&
         user_comparator_->Equal(ikey.user_key, saved_key_.GetKey()) &&
         ikey.type == kTypeMerge) {
-    merge_context_.PushOperand(iter_->value());
+    operands.push_front(iter_->value().ToString());
    iter_->Next();
    FindParseableKey(&ikey, kForward);
  }
@@ -711,8 +682,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
    {
      StopWatchNano timer(env_, statistics_ != nullptr);
      PERF_TIMER_GUARD(merge_operator_time_nanos);
-      user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr,
-                                      merge_context_.GetOperands(),
+      user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr, operands,
                                      &saved_value_, logger_);
      RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME, timer.ElapsedNanos());
    }
@@ -730,9 +700,8 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
  {
    StopWatchNano timer(env_, statistics_ != nullptr);
    PERF_TIMER_GUARD(merge_operator_time_nanos);
-    user_merge_operator_->FullMerge(saved_key_.GetKey(), &val,
-                                    merge_context_.GetOperands(), &saved_value_,
-                                    logger_);
+    user_merge_operator_->FullMerge(saved_key_.GetKey(), &val, operands,
+                                    &saved_value_, logger_);
    RecordTick(statistics_, MERGE_OPERATION_TOTAL_TIME, timer.ElapsedNanos());
  }
  valid_ = true;
@@ -798,7 +767,6 @@ void DBIter::FindParseableKey(ParsedInternalKey* ikey, Direction direction) {

 void DBIter::Seek(const Slice& target) {
  StopWatch sw(env_, statistics_, DB_SEEK);
-  ReleaseTempPinnedData();
  saved_key_.Clear();
  // now savved_key is used to store internal key.
  saved_key_.SetInternalKey(target, sequence_);
@@ -810,15 +778,9 @@ void DBIter::Seek(const Slice& target) {

  RecordTick(statistics_, NUMBER_DB_SEEK);
  if (iter_->Valid()) {
-    if (prefix_extractor_ && prefix_same_as_start_) {
-      prefix_start_key_ = prefix_extractor_->Transform(target);
-    }
    direction_ = kForward;
    ClearSavedValue();
-    FindNextUserEntry(false /* not skipping */, prefix_same_as_start_);
-    if (!valid_) {
-      prefix_start_key_.clear();
-    }
+    FindNextUserEntry(false /* not skipping */);
    if (statistics_ != nullptr) {
      if (valid_) {
        RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
@@ -829,8 +791,7 @@ void DBIter::Seek(const Slice& target) {
    valid_ = false;
  }
  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
-    prefix_start_buf_.SetKey(prefix_start_key_);
-    prefix_start_key_ = prefix_start_buf_.GetKey();
+    prefix_start_.SetKey(prefix_extractor_->Transform(target));
  }
 }

@@ -841,7 +802,6 @@ void DBIter::SeekToFirst() {
    max_skip_ = std::numeric_limits<uint64_t>::max();
  }
  direction_ = kForward;
-  ReleaseTempPinnedData();
  ClearSavedValue();

  {
@@ -851,7 +811,7 @@ void DBIter::SeekToFirst() {

  RecordTick(statistics_, NUMBER_DB_SEEK);
  if (iter_->Valid()) {
-    FindNextUserEntry(false /* not skipping */, false /* no prefix check */);
+    FindNextUserEntry(false /* not skipping */);
    if (statistics_ != nullptr) {
      if (valid_) {
        RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
@@ -862,8 +822,7 @@ void DBIter::SeekToFirst() {
    valid_ = false;
  }
  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
-    prefix_start_buf_.SetKey(prefix_extractor_->Transform(saved_key_.GetKey()));
-    prefix_start_key_ = prefix_start_buf_.GetKey();
+    prefix_start_.SetKey(prefix_extractor_->Transform(saved_key_.GetKey()));
  }
 }

@@ -874,7 +833,6 @@ void DBIter::SeekToLast() {
    max_skip_ = std::numeric_limits<uint64_t>::max();
  }
  direction_ = kReverse;
-  ReleaseTempPinnedData();
  ClearSavedValue();

  {
@@ -912,8 +870,7 @@ void DBIter::SeekToLast() {
    }
  }
  if (valid_ && prefix_extractor_ && prefix_same_as_start_) {
-    prefix_start_buf_.SetKey(prefix_extractor_->Transform(saved_key_.GetKey()));
-    prefix_start_key_ = prefix_start_buf_.GetKey();
+    prefix_start_.SetKey(prefix_extractor_->Transform(saved_key_.GetKey()));
  }
 }

@@ -928,7 +885,10 @@ Iterator* NewDBIterator(Env* env, const ImmutableCFOptions& ioptions,
  DBIter* db_iter =
      new DBIter(env, ioptions, user_key_comparator, internal_iter, sequence,
                 false, max_sequential_skip_in_iterations, version_number,
-                 iterate_upper_bound, prefix_same_as_start, pin_data);
+                 iterate_upper_bound, prefix_same_as_start);
+  if (pin_data) {
+    db_iter->PinData();
+  }
  return db_iter;
 }

@@ -951,10 +911,14 @@ inline void ArenaWrappedDBIter::Prev() { db_iter_->Prev(); }
 inline Slice ArenaWrappedDBIter::key() const { return db_iter_->key(); }
 inline Slice ArenaWrappedDBIter::value() const { return db_iter_->value(); }
 inline Status ArenaWrappedDBIter::status() const { return db_iter_->status(); }
+inline Status ArenaWrappedDBIter::PinData() { return db_iter_->PinData(); }
 inline Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
                                              std::string* prop) {
  return db_iter_->GetProperty(prop_name, prop);
 }
+inline Status ArenaWrappedDBIter::ReleasePinnedData() {
+  return db_iter_->ReleasePinnedData();
+}
 void ArenaWrappedDBIter::RegisterCleanup(CleanupFunction function, void* arg1,
                                         void* arg2) {
  db_iter_->RegisterCleanup(function, arg1, arg2);
@@ -972,9 +936,12 @@ ArenaWrappedDBIter* NewArenaWrappedDbIterator(
  DBIter* db_iter =
      new (mem) DBIter(env, ioptions, user_key_comparator, nullptr, sequence,
                       true, max_sequential_skip_in_iterations, version_number,
-                       iterate_upper_bound, prefix_same_as_start, pin_data);
+                       iterate_upper_bound, prefix_same_as_start);

  iter->SetDBIter(db_iter);
+  if (pin_data) {
+    iter->PinData();
+  }

  return iter;
 }
@@ -63,6 +63,8 @@ class ArenaWrappedDBIter : public Iterator {
  virtual Status status() const override;

  void RegisterCleanup(CleanupFunction function, void* arg1, void* arg2);
+  virtual Status PinData();
+  virtual Status ReleasePinnedData();
  virtual Status GetProperty(std::string prop_name, std::string* prop) override;

 private:
@@ -19,7 +19,6 @@
 #include "rocksdb/perf_level.h"
 #include "rocksdb/table.h"
 #include "util/random.h"
-#include "util/string_util.h"

 namespace rocksdb {

@@ -224,7 +223,7 @@ void GetExpectedTableProperties(TableProperties* expected_tp,
                                const int kBloomBitsPerKey,
                                const size_t kBlockSize) {
  const int kKeyCount = kTableCount * kKeysPerTable;
-  const int kAvgSuccessorSize = kKeySize / 5;
+  const int kAvgSuccessorSize = kKeySize / 2;
  const int kEncodingSavePerKey = kKeySize / 4;
  expected_tp->raw_key_size = kKeyCount * (kKeySize + 8);
  expected_tp->raw_value_size = kKeyCount * kValueSize;
@@ -254,35 +253,6 @@ TEST_F(DBPropertiesTest, ValidatePropertyInfo) {
  }
 }

-TEST_F(DBPropertiesTest, ValidateSampleNumber) {
-  // When "max_open_files" is -1, we read all the files for
-  // "rocksdb.estimate-num-keys" computation, which is the ground truth.
-  // Otherwise, we sample 20 newest files to make an estimation.
-  // Formula: lastest_20_files_active_key_ratio * total_files
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.level0_stop_writes_trigger = 1000;
-  DestroyAndReopen(options);
-  int key = 0;
-  for (int files = 20; files >= 10; files -= 10) {
-    for (int i = 0; i < files; i++) {
-      int rows = files / 10;
-      for (int j = 0; j < rows; j++) {
-        db_->Put(WriteOptions(), std::to_string(++key), "foo");
-      }
-      db_->Flush(FlushOptions());
-    }
-  }
-  std::string num;
-  Reopen(options);
-  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
-  ASSERT_EQ("45", num);
-  options.max_open_files = -1;
-  Reopen(options);
-  ASSERT_TRUE(dbfull()->GetProperty("rocksdb.estimate-num-keys", &num));
-  ASSERT_EQ("50", num);
-}
-
 TEST_F(DBPropertiesTest, AggregatedTableProperties) {
  for (int kTableCount = 40; kTableCount <= 100; kTableCount += 30) {
    const int kKeysPerTable = 100;
@@ -899,48 +869,6 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
      "rocksdb.estimate-pending-compaction-bytes", &int_num));
  ASSERT_EQ(int_num, 0U);
 }
-
-TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-  const int kNumL0Files = 3;
-  const int kNumEntriesPerFile = 1000;
-
-  Options options = CurrentOptions();
-  options.compression_per_level = {kNoCompression, kSnappyCompression};
-  options.disable_auto_compactions = true;
-  options.max_background_flushes = 0;
-  options.num_levels = 2;
-  Reopen(options);
-
-  // compression ratio is -1.0 when no open files at level
-  ASSERT_EQ(CompressionRatioAtLevel(0), -1.0);
-
-  const std::string kVal(100, 'a');
-  for (int i = 0; i < kNumL0Files; ++i) {
-    for (int j = 0; j < kNumEntriesPerFile; ++j) {
-      // Put common data ("key") at end to prevent delta encoding from
-      // compressing the key effectively
-      std::string key = ToString(i) + ToString(j) + "key";
-      ASSERT_OK(dbfull()->Put(WriteOptions(), key, kVal));
-    }
-    Flush();
-  }
-
-  // no compression at L0, so ratio is less than one
-  ASSERT_LT(CompressionRatioAtLevel(0), 1.0);
-  ASSERT_GT(CompressionRatioAtLevel(0), 0.0);
-  ASSERT_EQ(CompressionRatioAtLevel(1), -1.0);
-
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
-
-  ASSERT_EQ(CompressionRatioAtLevel(0), -1.0);
-  // Data at L1 should be highly compressed thanks to Snappy and redundant data
-  // in values (ratio is 12.846 as of 4/19/2016).
-  ASSERT_GT(CompressionRatioAtLevel(1), 10.0);
-}
-
 #endif  // ROCKSDB_LITE

 class CountingUserTblPropCollector : public TablePropertiesCollector {
@@ -215,34 +215,6 @@ TEST_F(DBTablePropertiesTest, GetPropertiesOfTablesInRange) {
    TestGetPropertiesOfTablesInRange(std::move(ranges));
  }
 }
-
-TEST_F(DBTablePropertiesTest, GetColumnFamilyNameProperty) {
-  std::string kExtraCfName = "pikachu";
-  CreateAndReopenWithCF({kExtraCfName}, CurrentOptions());
-
-  // Create one table per CF, then verify it was created with the column family
-  // name property.
-  for (int cf = 0; cf < 2; ++cf) {
-    Put(cf, "key", "val");
-    Flush(cf);
-
-    TablePropertiesCollection fname_to_props;
-    ASSERT_OK(db_->GetPropertiesOfAllTables(handles_[cf], &fname_to_props));
-    ASSERT_EQ(1U, fname_to_props.size());
-
-    std::string expected_cf_name;
-    if (cf > 0) {
-      expected_cf_name = kExtraCfName;
-    } else {
-      expected_cf_name = kDefaultColumnFamilyName;
-    }
-    ASSERT_EQ(expected_cf_name,
-              fname_to_props.begin()->second->column_family_name);
-    ASSERT_EQ(cf, static_cast<uint32_t>(
-                      fname_to_props.begin()->second->column_family_id));
-  }
-}
-
 }  // namespace rocksdb

 #endif  // ROCKSDB_LITE
@@ -9,7 +9,6 @@
 #include <cstdlib>
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/wal_filter.h"

 namespace rocksdb {

@@ -18,68 +17,6 @@ class DBTest2 : public DBTestBase {
  DBTest2() : DBTestBase("/db_test2") {}
 };

-class PrefixFullBloomWithReverseComparator
-    : public DBTestBase,
-      public ::testing::WithParamInterface<bool> {
- public:
-  PrefixFullBloomWithReverseComparator()
-      : DBTestBase("/prefix_bloom_reverse") {}
-  virtual void SetUp() override { if_cache_filter_ = GetParam(); }
-  bool if_cache_filter_;
-};
-
-TEST_P(PrefixFullBloomWithReverseComparator,
-       PrefixFullBloomWithReverseComparator) {
-  Options options = last_options_;
-  options.comparator = ReverseBytewiseComparator();
-  options.prefix_extractor.reset(NewCappedPrefixTransform(3));
-  options.statistics = rocksdb::CreateDBStatistics();
-  BlockBasedTableOptions bbto;
-  if (if_cache_filter_) {
-    bbto.no_block_cache = false;
-    bbto.cache_index_and_filter_blocks = true;
-    bbto.block_cache = NewLRUCache(1);
-  }
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.whole_key_filtering = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  DestroyAndReopen(options);
-
-  ASSERT_OK(dbfull()->Put(WriteOptions(), "bar123", "foo"));
-  ASSERT_OK(dbfull()->Put(WriteOptions(), "bar234", "foo2"));
-  ASSERT_OK(dbfull()->Put(WriteOptions(), "foo123", "foo3"));
-
-  dbfull()->Flush(FlushOptions());
-
-  if (bbto.block_cache) {
-    bbto.block_cache->EraseUnRefEntries();
-  }
-
-  unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-  iter->Seek("bar345");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar234", iter->key().ToString());
-  ASSERT_EQ("foo2", iter->value().ToString());
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar123", iter->key().ToString());
-  ASSERT_EQ("foo", iter->value().ToString());
-
-  iter->Seek("foo234");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("foo123", iter->key().ToString());
-  ASSERT_EQ("foo3", iter->value().ToString());
-
-  iter->Seek("bar");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(!iter->Valid());
-}
-
-INSTANTIATE_TEST_CASE_P(PrefixFullBloomWithReverseComparator,
-                        PrefixFullBloomWithReverseComparator, testing::Bool());
-
 TEST_F(DBTest2, IteratorPropertyVersionNumber) {
  Put("", "");
  Iterator* iter1 = db_->NewIterator(ReadOptions());
@@ -121,815 +58,6 @@ TEST_F(DBTest2, IteratorPropertyVersionNumber) {
  delete iter2;
  delete iter3;
 }
-
-TEST_F(DBTest2, CacheIndexAndFilterWithDBRestart) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  Put(1, "a", "begin");
-  Put(1, "z", "end");
-  ASSERT_OK(Flush(1));
-  TryReopenWithColumnFamilies({"default", "pikachu"}, options);
-
-  std::string value;
-  value = Get(1, "a");
-}
-
-#ifndef ROCKSDB_LITE
-namespace {
-  void ValidateKeyExistence(DB* db, const std::vector<Slice>& keys_must_exist,
-    const std::vector<Slice>& keys_must_not_exist) {
-    // Ensure that expected keys exist
-    std::vector<std::string> values;
-    if (keys_must_exist.size() > 0) {
-      std::vector<Status> status_list =
-        db->MultiGet(ReadOptions(), keys_must_exist, &values);
-      for (size_t i = 0; i < keys_must_exist.size(); i++) {
-        ASSERT_OK(status_list[i]);
-      }
-    }
-
-    // Ensure that given keys don't exist
-    if (keys_must_not_exist.size() > 0) {
-      std::vector<Status> status_list =
-        db->MultiGet(ReadOptions(), keys_must_not_exist, &values);
-      for (size_t i = 0; i < keys_must_not_exist.size(); i++) {
-        ASSERT_TRUE(status_list[i].IsNotFound());
-      }
-    }
-  }
-
-}  // namespace
-
-TEST_F(DBTest2, WalFilterTest) {
-  class TestWalFilter : public WalFilter {
-  private:
-    // Processing option that is requested to be applied at the given index
-    WalFilter::WalProcessingOption wal_processing_option_;
-    // Index at which to apply wal_processing_option_
-    // At other indexes default wal_processing_option::kContinueProcessing is
-    // returned.
-    size_t apply_option_at_record_index_;
-    // Current record index, incremented with each record encountered.
-    size_t current_record_index_;
-
-  public:
-    TestWalFilter(WalFilter::WalProcessingOption wal_processing_option,
-      size_t apply_option_for_record_index)
-      : wal_processing_option_(wal_processing_option),
-      apply_option_at_record_index_(apply_option_for_record_index),
-      current_record_index_(0) {}
-
-    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
-      WriteBatch* new_batch,
-      bool* batch_changed) const override {
-      WalFilter::WalProcessingOption option_to_return;
-
-      if (current_record_index_ == apply_option_at_record_index_) {
-        option_to_return = wal_processing_option_;
-      }
-      else {
-        option_to_return = WalProcessingOption::kContinueProcessing;
-      }
-
-      // Filter is passed as a const object for RocksDB to not modify the
-      // object, however we modify it for our own purpose here and hence
-      // cast the constness away.
-      (const_cast<TestWalFilter*>(this)->current_record_index_)++;
-
-      return option_to_return;
-    }
-
-    virtual const char* Name() const override { return "TestWalFilter"; }
-  };
-
-  // Create 3 batches with two keys each
-  std::vector<std::vector<std::string>> batch_keys(3);
-
-  batch_keys[0].push_back("key1");
-  batch_keys[0].push_back("key2");
-  batch_keys[1].push_back("key3");
-  batch_keys[1].push_back("key4");
-  batch_keys[2].push_back("key5");
-  batch_keys[2].push_back("key6");
-
-  // Test with all WAL processing options
-  for (int option = 0;
-    option < static_cast<int>(
-    WalFilter::WalProcessingOption::kWalProcessingOptionMax);
-  option++) {
-    Options options = OptionsForLogIterTest();
-    DestroyAndReopen(options);
-    CreateAndReopenWithCF({ "pikachu" }, options);
-
-    // Write given keys in given batches
-    for (size_t i = 0; i < batch_keys.size(); i++) {
-      WriteBatch batch;
-      for (size_t j = 0; j < batch_keys[i].size(); j++) {
-        batch.Put(handles_[0], batch_keys[i][j], DummyString(1024));
-      }
-      dbfull()->Write(WriteOptions(), &batch);
-    }
-
-    WalFilter::WalProcessingOption wal_processing_option =
-      static_cast<WalFilter::WalProcessingOption>(option);
-
-    // Create a test filter that would apply wal_processing_option at the first
-    // record
-    size_t apply_option_for_record_index = 1;
-    TestWalFilter test_wal_filter(wal_processing_option,
-      apply_option_for_record_index);
-
-    // Reopen database with option to use WAL filter
-    options = OptionsForLogIterTest();
-    options.wal_filter = &test_wal_filter;
-    Status status =
-      TryReopenWithColumnFamilies({ "default", "pikachu" }, options);
-    if (wal_processing_option ==
-      WalFilter::WalProcessingOption::kCorruptedRecord) {
-      assert(!status.ok());
-      // In case of corruption we can turn off paranoid_checks to reopen
-      // databse
-      options.paranoid_checks = false;
-      ReopenWithColumnFamilies({ "default", "pikachu" }, options);
-    }
-    else {
-      assert(status.ok());
-    }
-
-    // Compute which keys we expect to be found
-    // and which we expect not to be found after recovery.
-    std::vector<Slice> keys_must_exist;
-    std::vector<Slice> keys_must_not_exist;
-    switch (wal_processing_option) {
-    case WalFilter::WalProcessingOption::kCorruptedRecord:
-    case WalFilter::WalProcessingOption::kContinueProcessing: {
-      fprintf(stderr, "Testing with complete WAL processing\n");
-      // we expect all records to be processed
-      for (size_t i = 0; i < batch_keys.size(); i++) {
-        for (size_t j = 0; j < batch_keys[i].size(); j++) {
-          keys_must_exist.push_back(Slice(batch_keys[i][j]));
-        }
-      }
-      break;
-    }
-    case WalFilter::WalProcessingOption::kIgnoreCurrentRecord: {
-      fprintf(stderr,
-        "Testing with ignoring record %" ROCKSDB_PRIszt " only\n",
-        apply_option_for_record_index);
-      // We expect the record with apply_option_for_record_index to be not
-      // found.
-      for (size_t i = 0; i < batch_keys.size(); i++) {
-        for (size_t j = 0; j < batch_keys[i].size(); j++) {
-          if (i == apply_option_for_record_index) {
-            keys_must_not_exist.push_back(Slice(batch_keys[i][j]));
-          }
-          else {
-            keys_must_exist.push_back(Slice(batch_keys[i][j]));
-          }
-        }
-      }
-      break;
-    }
-    case WalFilter::WalProcessingOption::kStopReplay: {
-      fprintf(stderr,
-        "Testing with stopping replay from record %" ROCKSDB_PRIszt
-        "\n",
-        apply_option_for_record_index);
-      // We expect records beyond apply_option_for_record_index to be not
-      // found.
-      for (size_t i = 0; i < batch_keys.size(); i++) {
-        for (size_t j = 0; j < batch_keys[i].size(); j++) {
-          if (i >= apply_option_for_record_index) {
-            keys_must_not_exist.push_back(Slice(batch_keys[i][j]));
-          }
-          else {
-            keys_must_exist.push_back(Slice(batch_keys[i][j]));
-          }
-        }
-      }
-      break;
-    }
-    default:
-      assert(false);  // unhandled case
-    }
-
-    bool checked_after_reopen = false;
-
-    while (true) {
-      // Ensure that expected keys exists
-      // and not expected keys don't exist after recovery
-      ValidateKeyExistence(db_, keys_must_exist, keys_must_not_exist);
-
-      if (checked_after_reopen) {
-        break;
-      }
-
-      // reopen database again to make sure previous log(s) are not used
-      //(even if they were skipped)
-      // reopn database with option to use WAL filter
-      options = OptionsForLogIterTest();
-      ReopenWithColumnFamilies({ "default", "pikachu" }, options);
-
-      checked_after_reopen = true;
-    }
-  }
-}
-
-TEST_F(DBTest2, WalFilterTestWithChangeBatch) {
-  class ChangeBatchHandler : public WriteBatch::Handler {
-  private:
-    // Batch to insert keys in
-    WriteBatch* new_write_batch_;
-    // Number of keys to add in the new batch
-    size_t num_keys_to_add_in_new_batch_;
-    // Number of keys added to new batch
-    size_t num_keys_added_;
-
-  public:
-    ChangeBatchHandler(WriteBatch* new_write_batch,
-      size_t num_keys_to_add_in_new_batch)
-      : new_write_batch_(new_write_batch),
-      num_keys_to_add_in_new_batch_(num_keys_to_add_in_new_batch),
-      num_keys_added_(0) {}
-    virtual void Put(const Slice& key, const Slice& value) override {
-      if (num_keys_added_ < num_keys_to_add_in_new_batch_) {
-        new_write_batch_->Put(key, value);
-        ++num_keys_added_;
-      }
-    }
-  };
-
-  class TestWalFilterWithChangeBatch : public WalFilter {
-  private:
-    // Index at which to start changing records
-    size_t change_records_from_index_;
-    // Number of keys to add in the new batch
-    size_t num_keys_to_add_in_new_batch_;
-    // Current record index, incremented with each record encountered.
-    size_t current_record_index_;
-
-  public:
-    TestWalFilterWithChangeBatch(size_t change_records_from_index,
-      size_t num_keys_to_add_in_new_batch)
-      : change_records_from_index_(change_records_from_index),
-      num_keys_to_add_in_new_batch_(num_keys_to_add_in_new_batch),
-      current_record_index_(0) {}
-
-    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
-      WriteBatch* new_batch,
-      bool* batch_changed) const override {
-      if (current_record_index_ >= change_records_from_index_) {
-        ChangeBatchHandler handler(new_batch, num_keys_to_add_in_new_batch_);
-        batch.Iterate(&handler);
-        *batch_changed = true;
-      }
-
-      // Filter is passed as a const object for RocksDB to not modify the
-      // object, however we modify it for our own purpose here and hence
-      // cast the constness away.
-      (const_cast<TestWalFilterWithChangeBatch*>(this)
-        ->current_record_index_)++;
-
-      return WalProcessingOption::kContinueProcessing;
-    }
-
-    virtual const char* Name() const override {
-      return "TestWalFilterWithChangeBatch";
-    }
-  };
-
-  std::vector<std::vector<std::string>> batch_keys(3);
-
-  batch_keys[0].push_back("key1");
-  batch_keys[0].push_back("key2");
-  batch_keys[1].push_back("key3");
-  batch_keys[1].push_back("key4");
-  batch_keys[2].push_back("key5");
-  batch_keys[2].push_back("key6");
-
-  Options options = OptionsForLogIterTest();
-  DestroyAndReopen(options);
-  CreateAndReopenWithCF({ "pikachu" }, options);
-
-  // Write given keys in given batches
-  for (size_t i = 0; i < batch_keys.size(); i++) {
-    WriteBatch batch;
-    for (size_t j = 0; j < batch_keys[i].size(); j++) {
-      batch.Put(handles_[0], batch_keys[i][j], DummyString(1024));
-    }
-    dbfull()->Write(WriteOptions(), &batch);
-  }
-
-  // Create a test filter that would apply wal_processing_option at the first
-  // record
-  size_t change_records_from_index = 1;
-  size_t num_keys_to_add_in_new_batch = 1;
-  TestWalFilterWithChangeBatch test_wal_filter_with_change_batch(
-    change_records_from_index, num_keys_to_add_in_new_batch);
-
-  // Reopen database with option to use WAL filter
-  options = OptionsForLogIterTest();
-  options.wal_filter = &test_wal_filter_with_change_batch;
-  ReopenWithColumnFamilies({ "default", "pikachu" }, options);
-
-  // Ensure that all keys exist before change_records_from_index_
-  // And after that index only single key exists
-  // as our filter adds only single key for each batch
-  std::vector<Slice> keys_must_exist;
-  std::vector<Slice> keys_must_not_exist;
-
-  for (size_t i = 0; i < batch_keys.size(); i++) {
-    for (size_t j = 0; j < batch_keys[i].size(); j++) {
-      if (i >= change_records_from_index && j >= num_keys_to_add_in_new_batch) {
-        keys_must_not_exist.push_back(Slice(batch_keys[i][j]));
-      }
-      else {
-        keys_must_exist.push_back(Slice(batch_keys[i][j]));
-      }
-    }
-  }
-
-  bool checked_after_reopen = false;
-
-  while (true) {
-    // Ensure that expected keys exists
-    // and not expected keys don't exist after recovery
-    ValidateKeyExistence(db_, keys_must_exist, keys_must_not_exist);
-
-    if (checked_after_reopen) {
-      break;
-    }
-
-    // reopen database again to make sure previous log(s) are not used
-    //(even if they were skipped)
-    // reopn database with option to use WAL filter
-    options = OptionsForLogIterTest();
-    ReopenWithColumnFamilies({ "default", "pikachu" }, options);
-
-    checked_after_reopen = true;
-  }
-}
-
-TEST_F(DBTest2, WalFilterTestWithChangeBatchExtraKeys) {
-  class TestWalFilterWithChangeBatchAddExtraKeys : public WalFilter {
-  public:
-    virtual WalProcessingOption LogRecord(const WriteBatch& batch,
-      WriteBatch* new_batch,
-      bool* batch_changed) const override {
-      *new_batch = batch;
-      new_batch->Put("key_extra", "value_extra");
-      *batch_changed = true;
-      return WalProcessingOption::kContinueProcessing;
-    }
-
-    virtual const char* Name() const override {
-      return "WalFilterTestWithChangeBatchExtraKeys";
-    }
-  };
-
-  std::vector<std::vector<std::string>> batch_keys(3);
-
-  batch_keys[0].push_back("key1");
-  batch_keys[0].push_back("key2");
-  batch_keys[1].push_back("key3");
-  batch_keys[1].push_back("key4");
-  batch_keys[2].push_back("key5");
-  batch_keys[2].push_back("key6");
-
-  Options options = OptionsForLogIterTest();
-  DestroyAndReopen(options);
-  CreateAndReopenWithCF({ "pikachu" }, options);
-
-  // Write given keys in given batches
-  for (size_t i = 0; i < batch_keys.size(); i++) {
-    WriteBatch batch;
-    for (size_t j = 0; j < batch_keys[i].size(); j++) {
-      batch.Put(handles_[0], batch_keys[i][j], DummyString(1024));
-    }
-    dbfull()->Write(WriteOptions(), &batch);
-  }
-
-  // Create a test filter that would add extra keys
-  TestWalFilterWithChangeBatchAddExtraKeys test_wal_filter_extra_keys;
-
-  // Reopen database with option to use WAL filter
-  options = OptionsForLogIterTest();
-  options.wal_filter = &test_wal_filter_extra_keys;
-  Status status = TryReopenWithColumnFamilies({"default", "pikachu"}, options);
-  ASSERT_TRUE(status.IsNotSupported());
-
-  // Reopen without filter, now reopen should succeed - previous
-  // attempt to open must not have altered the db.
-  options = OptionsForLogIterTest();
-  ReopenWithColumnFamilies({ "default", "pikachu" }, options);
-
-  std::vector<Slice> keys_must_exist;
-  std::vector<Slice> keys_must_not_exist;  // empty vector
-
-  for (size_t i = 0; i < batch_keys.size(); i++) {
-    for (size_t j = 0; j < batch_keys[i].size(); j++) {
-      keys_must_exist.push_back(Slice(batch_keys[i][j]));
-    }
-  }
-
-  ValidateKeyExistence(db_, keys_must_exist, keys_must_not_exist);
-}
-
-TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
-  class TestWalFilterWithColumnFamilies : public WalFilter {
-  private:
-    // column_family_id -> log_number map (provided to WALFilter)
-    std::map<uint32_t, uint64_t> cf_log_number_map_;
-    // column_family_name -> column_family_id map (provided to WALFilter)
-    std::map<std::string, uint32_t> cf_name_id_map_;
-    // column_family_name -> keys_found_in_wal map
-    // We store keys that are applicable to the column_family
-    // during recovery (i.e. aren't already flushed to SST file(s))
-    // for verification against the keys we expect.
-    std::map<uint32_t, std::vector<std::string>> cf_wal_keys_;
-  public:
-    virtual void ColumnFamilyLogNumberMap(
-      const std::map<uint32_t, uint64_t>& cf_lognumber_map,
-      const std::map<std::string, uint32_t>& cf_name_id_map) override {
-      cf_log_number_map_ = cf_lognumber_map;
-      cf_name_id_map_ = cf_name_id_map;
-    }
-
-    virtual WalProcessingOption LogRecordFound(unsigned long long log_number,
-      const std::string& log_file_name,
-      const WriteBatch& batch,
-      WriteBatch* new_batch,
-      bool* batch_changed) override {
-      class LogRecordBatchHandler : public WriteBatch::Handler {
-      private:
-        const std::map<uint32_t, uint64_t> & cf_log_number_map_;
-        std::map<uint32_t, std::vector<std::string>> & cf_wal_keys_;
-        unsigned long long log_number_;
-      public:
-        LogRecordBatchHandler(unsigned long long current_log_number,
-          const std::map<uint32_t, uint64_t> & cf_log_number_map,
-          std::map<uint32_t, std::vector<std::string>> & cf_wal_keys) :
-          cf_log_number_map_(cf_log_number_map),
-          cf_wal_keys_(cf_wal_keys),
-          log_number_(current_log_number){}
-
-        virtual Status PutCF(uint32_t column_family_id, const Slice& key,
-          const Slice& /*value*/) override {
-          auto it = cf_log_number_map_.find(column_family_id);
-          assert(it != cf_log_number_map_.end());
-          unsigned long long log_number_for_cf = it->second;
-          // If the current record is applicable for column_family_id
-          // (i.e. isn't flushed to SST file(s) for column_family_id)
-          // add it to the cf_wal_keys_ map for verification.
-          if (log_number_ >= log_number_for_cf) {
-            cf_wal_keys_[column_family_id].push_back(std::string(key.data(),
-              key.size()));
-          }
-          return Status::OK();
-        }
-      } handler(log_number, cf_log_number_map_, cf_wal_keys_);
-
-      batch.Iterate(&handler);
-
-      return WalProcessingOption::kContinueProcessing;
-    }
-
-    virtual const char* Name() const override {
-      return "WalFilterTestWithColumnFamilies";
-    }
-
-    const std::map<uint32_t, std::vector<std::string>>& GetColumnFamilyKeys() {
-      return cf_wal_keys_;
-    }
-
-    const std::map<std::string, uint32_t> & GetColumnFamilyNameIdMap() {
-      return cf_name_id_map_;
-    }
-  };
-
-  std::vector<std::vector<std::string>> batch_keys_pre_flush(3);
-
-  batch_keys_pre_flush[0].push_back("key1");
-  batch_keys_pre_flush[0].push_back("key2");
-  batch_keys_pre_flush[1].push_back("key3");
-  batch_keys_pre_flush[1].push_back("key4");
-  batch_keys_pre_flush[2].push_back("key5");
-  batch_keys_pre_flush[2].push_back("key6");
-
-  Options options = OptionsForLogIterTest();
-  DestroyAndReopen(options);
-  CreateAndReopenWithCF({ "pikachu" }, options);
-
-  // Write given keys in given batches
-  for (size_t i = 0; i < batch_keys_pre_flush.size(); i++) {
-    WriteBatch batch;
-    for (size_t j = 0; j < batch_keys_pre_flush[i].size(); j++) {
-      batch.Put(handles_[0], batch_keys_pre_flush[i][j], DummyString(1024));
-      batch.Put(handles_[1], batch_keys_pre_flush[i][j], DummyString(1024));
-    }
-    dbfull()->Write(WriteOptions(), &batch);
-  }
-
-  //Flush default column-family
-  db_->Flush(FlushOptions(), handles_[0]);
-
-  // Do some more writes
-  std::vector<std::vector<std::string>> batch_keys_post_flush(3);
-
-  batch_keys_post_flush[0].push_back("key7");
-  batch_keys_post_flush[0].push_back("key8");
-  batch_keys_post_flush[1].push_back("key9");
-  batch_keys_post_flush[1].push_back("key10");
-  batch_keys_post_flush[2].push_back("key11");
-  batch_keys_post_flush[2].push_back("key12");
-
-  // Write given keys in given batches
-  for (size_t i = 0; i < batch_keys_post_flush.size(); i++) {
-    WriteBatch batch;
-    for (size_t j = 0; j < batch_keys_post_flush[i].size(); j++) {
-      batch.Put(handles_[0], batch_keys_post_flush[i][j], DummyString(1024));
-      batch.Put(handles_[1], batch_keys_post_flush[i][j], DummyString(1024));
-    }
-    dbfull()->Write(WriteOptions(), &batch);
-  }
-
-  // On Recovery we should only find the second batch applicable to default CF
-  // But both batches applicable to pikachu CF
-
-  // Create a test filter that would add extra keys
-  TestWalFilterWithColumnFamilies test_wal_filter_column_families;
-
-  // Reopen database with option to use WAL filter
-  options = OptionsForLogIterTest();
-  options.wal_filter = &test_wal_filter_column_families;
-  Status status =
-    TryReopenWithColumnFamilies({ "default", "pikachu" }, options);
-  ASSERT_TRUE(status.ok());
-
-  // verify that handles_[0] only has post_flush keys
-  // while handles_[1] has pre and post flush keys
-  auto cf_wal_keys = test_wal_filter_column_families.GetColumnFamilyKeys();
-  auto name_id_map = test_wal_filter_column_families.GetColumnFamilyNameIdMap();
-  size_t index = 0;
-  auto keys_cf = cf_wal_keys[name_id_map[kDefaultColumnFamilyName]];
-  //default column-family, only post_flush keys are expected
-  for (size_t i = 0; i < batch_keys_post_flush.size(); i++) {
-    for (size_t j = 0; j < batch_keys_post_flush[i].size(); j++) {
-      Slice key_from_the_log(keys_cf[index++]);
-      Slice batch_key(batch_keys_post_flush[i][j]);
-      ASSERT_TRUE(key_from_the_log.compare(batch_key) == 0);
-    }
-  }
-  ASSERT_TRUE(index == keys_cf.size());
-
-  index = 0;
-  keys_cf = cf_wal_keys[name_id_map["pikachu"]];
-  //pikachu column-family, all keys are expected
-  for (size_t i = 0; i < batch_keys_pre_flush.size(); i++) {
-    for (size_t j = 0; j < batch_keys_pre_flush[i].size(); j++) {
-      Slice key_from_the_log(keys_cf[index++]);
-      Slice batch_key(batch_keys_pre_flush[i][j]);
-      ASSERT_TRUE(key_from_the_log.compare(batch_key) == 0);
-    }
-  }
-
-  for (size_t i = 0; i < batch_keys_post_flush.size(); i++) {
-    for (size_t j = 0; j < batch_keys_post_flush[i].size(); j++) {
-      Slice key_from_the_log(keys_cf[index++]);
-      Slice batch_key(batch_keys_post_flush[i][j]);
-      ASSERT_TRUE(key_from_the_log.compare(batch_key) == 0);
-    }
-  }
-  ASSERT_TRUE(index == keys_cf.size());
-}
-
-TEST_F(DBTest2, PresetCompressionDict) {
-  const size_t kBlockSizeBytes = 4 << 10;
-  const size_t kL0FileBytes = 128 << 10;
-  const size_t kApproxPerBlockOverheadBytes = 50;
-  const int kNumL0Files = 5;
-
-  Options options;
-  options.arena_block_size = kBlockSizeBytes;
-  options.compaction_style = kCompactionStyleUniversal;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  options.level0_file_num_compaction_trigger = kNumL0Files;
-  options.memtable_factory.reset(
-      new SpecialSkipListFactory(kL0FileBytes / kBlockSizeBytes));
-  options.num_levels = 2;
-  options.target_file_size_base = kL0FileBytes;
-  options.target_file_size_multiplier = 2;
-  options.write_buffer_size = kL0FileBytes;
-  BlockBasedTableOptions table_options;
-  table_options.block_size = kBlockSizeBytes;
-  std::vector<CompressionType> compression_types;
-  if (Zlib_Supported()) {
-    compression_types.push_back(kZlibCompression);
-  }
-#if LZ4_VERSION_NUMBER >= 10400  // r124+
-  compression_types.push_back(kLZ4Compression);
-  compression_types.push_back(kLZ4HCCompression);
-#endif                          // LZ4_VERSION_NUMBER >= 10400
-#if ZSTD_VERSION_NUMBER >= 500  // v0.5.0+
-  compression_types.push_back(kZSTDNotFinalCompression);
-#endif  // ZSTD_VERSION_NUMBER >= 500
-
-  for (auto compression_type : compression_types) {
-    options.compression = compression_type;
-    size_t prev_out_bytes;
-    for (int i = 0; i < 2; ++i) {
-      // First iteration: compress without preset dictionary
-      // Second iteration: compress with preset dictionary
-      // To make sure the compression dictionary was actually used, we verify
-      // the compressed size is smaller in the second iteration. Also in the
-      // second iteration, verify the data we get out is the same data we put
-      // in.
-      if (i) {
-        options.compression_opts.max_dict_bytes = kBlockSizeBytes;
-      } else {
-        options.compression_opts.max_dict_bytes = 0;
-      }
-
-      options.statistics = rocksdb::CreateDBStatistics();
-      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-      CreateAndReopenWithCF({"pikachu"}, options);
-      Random rnd(301);
-      std::string seq_data =
-          RandomString(&rnd, kBlockSizeBytes - kApproxPerBlockOverheadBytes);
-
-      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
-      for (int j = 0; j < kNumL0Files; ++j) {
-        for (size_t k = 0; k < kL0FileBytes / kBlockSizeBytes + 1; ++k) {
-          ASSERT_OK(Put(1, Key(static_cast<int>(
-                               j * (kL0FileBytes / kBlockSizeBytes) + k)),
-                        seq_data));
-        }
-        dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
-        ASSERT_EQ(j + 1, NumTableFilesAtLevel(0, 1));
-      }
-      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr);
-      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
-      ASSERT_GT(NumTableFilesAtLevel(1, 1), 0);
-
-      size_t out_bytes = 0;
-      std::vector<std::string> files;
-      GetSstFiles(dbname_, &files);
-      for (const auto& file : files) {
-        uint64_t curr_bytes;
-        env_->GetFileSize(dbname_ + "/" + file, &curr_bytes);
-        out_bytes += static_cast<size_t>(curr_bytes);
-      }
-
-      for (size_t j = 0; j < kNumL0Files * (kL0FileBytes / kBlockSizeBytes);
-           j++) {
-        ASSERT_EQ(seq_data, Get(1, Key(static_cast<int>(j))));
-      }
-      if (i) {
-        ASSERT_GT(prev_out_bytes, out_bytes);
-      }
-      prev_out_bytes = out_bytes;
-      DestroyAndReopen(options);
-    }
-  }
-}
-#endif  // ROCKSDB_LITE
-
-TEST_F(DBTest2, FirstSnapshotTest) {
-  Options options;
-  options.write_buffer_size = 100000;  // Small write buffer
-  options = CurrentOptions(options);
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  // This snapshot will have sequence number 0 what is expected behaviour.
-  const Snapshot* s1 = db_->GetSnapshot();
-
-  Put(1, "k1", std::string(100000, 'x'));  // Fill memtable
-  Put(1, "k2", std::string(100000, 'y'));  // Trigger flush
-
-  db_->ReleaseSnapshot(s1);
-}
-
-class PinL0IndexAndFilterBlocksTest : public DBTestBase,
-                                      public testing::WithParamInterface<bool> {
- public:
-  PinL0IndexAndFilterBlocksTest() : DBTestBase("/db_pin_l0_index_bloom_test") {}
-  virtual void SetUp() override { infinite_max_files_ = GetParam(); }
-
-  bool infinite_max_files_;
-};
-
-TEST_P(PinL0IndexAndFilterBlocksTest,
-       IndexAndFilterBlocksOfNewTableAddedToCacheWithPinning) {
-  Options options = CurrentOptions();
-  if (infinite_max_files_) {
-    options.max_open_files = -1;
-  }
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.pin_l0_filter_and_index_blocks_in_cache = true;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  ASSERT_OK(Put(1, "key", "val"));
-  // Create a new table.
-  ASSERT_OK(Flush(1));
-
-  // index/filter blocks added to block cache right after table creation.
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-
-  // only index/filter were added
-  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_ADD));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));
-
-  std::string value;
-  // Miss and hit count should remain the same, they're all pinned.
-  db_->KeyMayExist(ReadOptions(), handles_[1], "key", &value);
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-
-  // Miss and hit count should remain the same, they're all pinned.
-  value = Get(1, "key");
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-}
-
-TEST_P(PinL0IndexAndFilterBlocksTest,
-       MultiLevelIndexAndFilterBlocksCachedWithPinning) {
-  Options options = CurrentOptions();
-  if (infinite_max_files_) {
-    options.max_open_files = -1;
-  }
-  options.create_if_missing = true;
-  options.statistics = rocksdb::CreateDBStatistics();
-  BlockBasedTableOptions table_options;
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.pin_l0_filter_and_index_blocks_in_cache = true;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  Put(1, "a", "begin");
-  Put(1, "z", "end");
-  ASSERT_OK(Flush(1));
-  // move this table to L1
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]);
-
-  // reset block cache
-  table_options.block_cache = NewLRUCache(64 * 1024);
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  TryReopenWithColumnFamilies({"default", "pikachu"}, options);
-  // create new table at L0
-  Put(1, "a2", "begin2");
-  Put(1, "z2", "end2");
-  ASSERT_OK(Flush(1));
-
-  table_options.block_cache->EraseUnRefEntries();
-
-  // get base cache values
-  uint64_t fm = TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS);
-  uint64_t fh = TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT);
-  uint64_t im = TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS);
-  uint64_t ih = TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT);
-
-  std::string value;
-  // this should be read from L0
-  // so cache values don't change
-  value = Get(1, "a2");
-  ASSERT_EQ(fm, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(fh, TestGetTickerCount(options, BLOCK_CACHE_FILTER_HIT));
-  ASSERT_EQ(im, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-  ASSERT_EQ(ih, TestGetTickerCount(options, BLOCK_CACHE_INDEX_HIT));
-
-  // this should be read from L1
-  // the file is opened, prefetching results in a cache filter miss
-  // the block is loaded and added to the cache,
-  // then the get results in a cache hit for L1
-  value = Get(1, "a");
-  ASSERT_EQ(fm + 1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_MISS));
-  ASSERT_EQ(im + 1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_MISS));
-}
-
-INSTANTIATE_TEST_CASE_P(PinL0IndexAndFilterBlocksTest,
-                        PinL0IndexAndFilterBlocksTest, ::testing::Bool());
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -210,13 +210,6 @@ Options DBTestBase::CurrentOptions(
    const anon::OptionsOverride& options_override) {
  Options options;
  options.write_buffer_size = 4090 * 4096;
-  options.target_file_size_base = 2 * 1024 * 1024;
-  options.max_bytes_for_level_base = 10 * 1024 * 1024;
-  options.max_open_files = 5000;
-  options.base_background_compactions = -1;
-  options.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
-  options.compaction_pri = CompactionPri::kByCompensatedSize;
-
  return CurrentOptions(options, options_override);
 }

@@ -308,7 +301,6 @@ Options DBTestBase::CurrentOptions(
    case kPerfOptions:
      options.soft_rate_limit = 2.0;
      options.delayed_write_rate = 8 * 1024 * 1024;
-      options.report_bg_io_stats = true;
      // TODO(3.13) -- test more options
      break;
    case kDeletesFilterFirst:
@@ -719,22 +711,6 @@ int DBTestBase::NumTableFilesAtLevel(int level, int cf) {
  return atoi(property.c_str());
 }

-double DBTestBase::CompressionRatioAtLevel(int level, int cf) {
-  std::string property;
-  if (cf == 0) {
-    // default cfd
-    EXPECT_TRUE(db_->GetProperty(
-        "rocksdb.compression-ratio-at-level" + NumberToString(level),
-        &property));
-  } else {
-    EXPECT_TRUE(db_->GetProperty(
-        handles_[cf],
-        "rocksdb.compression-ratio-at-level" + NumberToString(level),
-        &property));
-  }
-  return std::stod(property);
-}
-
 int DBTestBase::TotalTableFiles(int cf, int levels) {
  if (levels == -1) {
    levels = CurrentOptions().num_levels;
@@ -1064,34 +1040,4 @@ std::unordered_map<std::string, uint64_t> DBTestBase::GetAllSSTFiles(
  return res;
 }

-std::vector<std::uint64_t> DBTestBase::ListTableFiles(Env* env,
-                                                      const std::string& path) {
-  std::vector<std::string> files;
-  std::vector<uint64_t> file_numbers;
-  env->GetChildren(path, &files);
-  uint64_t number;
-  FileType type;
-  for (size_t i = 0; i < files.size(); ++i) {
-    if (ParseFileName(files[i], &number, &type)) {
-      if (type == kTableFile) {
-        file_numbers.push_back(number);
-      }
-    }
-  }
-  return file_numbers;
-}
-
-#ifndef ROCKSDB_LITE
-uint64_t DBTestBase::GetNumberOfSstFilesForColumnFamily(
-    DB* db, std::string column_family_name) {
-  std::vector<LiveFileMetaData> metadata;
-  db->GetLiveFilesMetaData(&metadata);
-  uint64_t result = 0;
-  for (auto& fileMetadata : metadata) {
-    result += (fileMetadata.column_family_name == column_family_name);
-  }
-  return result;
-}
-#endif  // ROCKSDB_LITE
-
 }  // namespace rocksdb
@@ -39,7 +39,6 @@
 #include "rocksdb/filter_policy.h"
 #include "rocksdb/options.h"
 #include "rocksdb/slice.h"
-#include "rocksdb/statistics.h"
 #include "rocksdb/table.h"
 #include "rocksdb/utilities/checkpoint.h"
 #include "table/block_based_table_factory.h"
@@ -358,30 +357,23 @@ class SpecialEnv : public EnvWrapper {
    class CountingFile : public RandomAccessFile {
     public:
      CountingFile(unique_ptr<RandomAccessFile>&& target,
-                   anon::AtomicCounter* counter,
-                   std::atomic<size_t>* bytes_read)
-          : target_(std::move(target)),
-            counter_(counter),
-            bytes_read_(bytes_read) {}
+                   anon::AtomicCounter* counter)
+          : target_(std::move(target)), counter_(counter) {}
      virtual Status Read(uint64_t offset, size_t n, Slice* result,
                          char* scratch) const override {
        counter_->Increment();
-        Status s = target_->Read(offset, n, result, scratch);
-        *bytes_read_ += result->size();
-        return s;
+        return target_->Read(offset, n, result, scratch);
      }

     private:
      unique_ptr<RandomAccessFile> target_;
      anon::AtomicCounter* counter_;
-      std::atomic<size_t>* bytes_read_;
    };

    Status s = target()->NewRandomAccessFile(f, r, soptions);
    random_file_open_counter_++;
    if (s.ok() && count_random_reads_) {
-      r->reset(new CountingFile(std::move(*r), &random_read_counter_,
-                                &random_read_bytes_counter_));
+      r->reset(new CountingFile(std::move(*r), &random_read_counter_));
    }
    return s;
  }
@@ -471,7 +463,6 @@ class SpecialEnv : public EnvWrapper {

  bool count_random_reads_;
  anon::AtomicCounter random_read_counter_;
-  std::atomic<size_t> random_read_bytes_counter_;
  std::atomic<int> random_file_open_counter_;

  bool count_sequential_reads_;
@@ -500,33 +491,6 @@ class SpecialEnv : public EnvWrapper {
  std::atomic<bool> is_wal_sync_thread_safe_{true};
 };

-#ifndef ROCKSDB_LITE
-class OnFileDeletionListener : public EventListener {
- public:
-  OnFileDeletionListener() : matched_count_(0), expected_file_name_("") {}
-
-  void SetExpectedFileName(const std::string file_name) {
-    expected_file_name_ = file_name;
-  }
-
-  void VerifyMatchedCount(size_t expected_value) {
-    ASSERT_EQ(matched_count_, expected_value);
-  }
-
-  void OnTableFileDeleted(const TableFileDeletionInfo& info) override {
-    if (expected_file_name_ != "") {
-      ASSERT_EQ(expected_file_name_, info.file_path);
-      expected_file_name_ = "";
-      matched_count_++;
-    }
-  }
-
- private:
-  size_t matched_count_;
-  std::string expected_file_name_;
-};
-#endif
-
 class DBTestBase : public testing::Test {
 protected:
  // Sequence of option configurations to try
@@ -708,8 +672,6 @@ class DBTestBase : public testing::Test {

  int NumTableFilesAtLevel(int level, int cf = 0);

-  double CompressionRatioAtLevel(int level, int cf = 0);
-
  int TotalTableFiles(int cf = 0, int levels = -1);

  // Return spread of files per level
@@ -794,17 +756,6 @@ class DBTestBase : public testing::Test {

  std::unordered_map<std::string, uint64_t> GetAllSSTFiles(
      uint64_t* total_size = nullptr);
-
-  std::vector<std::uint64_t> ListTableFiles(Env* env, const std::string& path);
-
-#ifndef ROCKSDB_LITE
-  uint64_t GetNumberOfSstFilesForColumnFamily(DB* db,
-                                              std::string column_family_name);
-#endif  // ROCKSDB_LITE
-
-  uint64_t TestGetTickerCount(const Options& options, Tickers ticker_type) {
-    return options.statistics->getTickerCount(ticker_type);
-  }
 };

 }  // namespace rocksdb
@@ -14,6 +14,11 @@

 namespace rocksdb {

+static uint64_t TestGetTickerCount(const Options& options,
+                                   Tickers ticker_type) {
+  return options.statistics->getTickerCount(ticker_type);
+}
+
 static std::string CompressibleString(Random* rnd, int len) {
  std::string r;
  test::CompressibleString(rnd, 0.8, len, &r);
@@ -119,7 +124,8 @@ class DelayFilterFactory : public CompactionFilterFactory {
 // Make sure we don't trigger a problem if the trigger conditon is given
 // to be 0, which is invalid.
 TEST_P(DBTestUniversalCompaction, UniversalCompactionSingleSortedRun) {
-  Options options = CurrentOptions();
+  Options options;
+  options = CurrentOptions(options);

  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = num_levels_;
@@ -154,7 +160,8 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSingleSortedRun) {
 }

 TEST_P(DBTestUniversalCompaction, OptimizeFiltersForHits) {
-  Options options = CurrentOptions();
+  Options options;
+  options = CurrentOptions(options);
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.size_ratio = 5;
  options.num_levels = num_levels_;
@@ -330,12 +337,13 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrigger) {
 }

 TEST_P(DBTestUniversalCompaction, UniversalCompactionSizeAmplification) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = num_levels_;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
  options.level0_file_num_compaction_trigger = 3;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -380,12 +388,12 @@ TEST_P(DBTestUniversalCompaction, CompactFilesOnUniversalCompaction) {
  ChangeCompactOptions();
  Options options;
  options.create_if_missing = true;
+  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  options.compaction_style = kCompactionStyleLevel;
  options.num_levels = 1;
  options.target_file_size_base = options.write_buffer_size;
  options.compression = kNoCompression;
  options = CurrentOptions(options);
-  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
  CreateAndReopenWithCF({"pikachu"}, options);
  ASSERT_EQ(options.compaction_style, kCompactionStyleUniversal);
  Random rnd(301);
@@ -443,11 +451,12 @@ TEST_P(DBTestUniversalCompaction, CompactFilesOnUniversalCompaction) {
 }

 TEST_P(DBTestUniversalCompaction, UniversalCompactionTargetLevel) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.num_levels = 7;
  options.disable_auto_compactions = true;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  // Generate 3 overlapping files
@@ -487,13 +496,14 @@ class DBTestUniversalCompactionMultiLevels
 };

 TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionMultiLevels) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = num_levels_;
  options.write_buffer_size = 100 << 10;  // 100KB
  options.level0_file_num_compaction_trigger = 8;
  options.max_background_compactions = 3;
  options.target_file_size_base = 32 * 1024;
+  options = CurrentOptions(options);
  CreateAndReopenWithCF({"pikachu"}, options);

  // Trigger compaction if size amplification exceeds 110%
@@ -529,7 +539,7 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.allow_trivial_move = true;
  options.num_levels = 3;
@@ -537,6 +547,7 @@ TEST_P(DBTestUniversalCompactionMultiLevels, UniversalCompactionTrivialMove) {
  options.level0_file_num_compaction_trigger = 3;
  options.max_background_compactions = 2;
  options.target_file_size_base = 32 * 1024;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -575,7 +586,7 @@ class DBTestUniversalCompactionParallel :
 };

 TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.num_levels = num_levels_;
  options.write_buffer_size = 1 << 10;  // 1KB
@@ -584,6 +595,7 @@ TEST_P(DBTestUniversalCompactionParallel, UniversalCompactionParallel) {
  options.max_background_flushes = 3;
  options.target_file_size_base = 1 * 1024;
  options.compaction_options_universal.max_size_amplification_percent = 110;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -640,7 +652,7 @@ INSTANTIATE_TEST_CASE_P(DBTestUniversalCompactionParallel,
                                           ::testing::Bool()));

 TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 105 << 10;    // 105KB
  options.arena_block_size = 4 << 10;       // 4KB
@@ -648,6 +660,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
  options.level0_file_num_compaction_trigger = 4;
  options.num_levels = num_levels_;
  options.compaction_options_universal.compression_size_percent = -1;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -760,13 +773,14 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio1) {
    return;
  }

-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = num_levels_;
  options.compaction_options_universal.compression_size_percent = 70;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  Random rnd(301);
@@ -827,13 +841,14 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio2) {
  if (!Snappy_Supported()) {
    return;
  }
-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.write_buffer_size = 100 << 10;     // 100KB
  options.target_file_size_base = 32 << 10;  // 32KB
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = num_levels_;
  options.compaction_options_universal.compression_size_percent = 95;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);

  Random rnd(301);
@@ -869,7 +884,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) {
      });
  rocksdb::SyncPoint::GetInstance()->EnableProcessing();

-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.allow_trivial_move = true;
  options.num_levels = 2;
@@ -877,6 +892,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) {
  options.level0_file_num_compaction_trigger = 3;
  options.max_background_compactions = 1;
  options.target_file_size_base = 32 * 1024;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -913,7 +929,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {

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

-  Options options = CurrentOptions();
+  Options options;
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.allow_trivial_move = true;
  options.num_levels = 15;
@@ -921,6 +937,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
  options.level0_file_num_compaction_trigger = 8;
  options.max_background_compactions = 4;
  options.target_file_size_base = 64 * 1024;
+  options = CurrentOptions(options);
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

@@ -946,7 +963,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
 }

 TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) {
-  Options options = CurrentOptions();
+  Options options;
  options.db_paths.emplace_back(dbname_, 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 300 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 500 * 1024);
@@ -955,10 +972,11 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) {
      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.size_ratio = 5;
-  options.write_buffer_size = 111 << 10;  // 114KB
+  options.write_buffer_size = 110 << 10;  // 105KB
  options.arena_block_size = 4 << 10;
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
+  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
@@ -1086,7 +1104,6 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
-    dbfull()->TEST_WaitForCompact();
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
@@ -1104,7 +1121,6 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
-    dbfull()->TEST_WaitForCompact();
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
@@ -1136,7 +1152,6 @@ TEST_P(DBTestUniversalCompaction, IncreaseUniversalCompactionNumLevels) {
    // each value is 10K
    ASSERT_OK(Put(1, Key(i), RandomString(&rnd, 10000)));
    dbfull()->TEST_WaitForFlushMemTable(handles_[1]);
-    dbfull()->TEST_WaitForCompact();
  }
  ASSERT_OK(Flush(1));
  dbfull()->TEST_WaitForCompact();
@@ -1148,17 +1163,19 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionSecondPathRatio) {
  if (!Snappy_Supported()) {
    return;
  }
-  Options options = CurrentOptions();
+  Options options;
  options.db_paths.emplace_back(dbname_, 500 * 1024);
  options.db_paths.emplace_back(dbname_ + "_2", 1024 * 1024 * 1024);
  options.compaction_style = kCompactionStyleUniversal;
  options.compaction_options_universal.size_ratio = 5;
-  options.write_buffer_size = 111 << 10;  // 114KB
+  options.write_buffer_size = 110 << 10;  // 105KB
+  options.arena_block_size = 4 * 1024;
  options.arena_block_size = 4 << 10;
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 1;
  options.memtable_factory.reset(
      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+  options = CurrentOptions(options);

  std::vector<std::string> filenames;
  env_->GetChildren(options.db_paths[1].path, &filenames);
@@ -127,637 +127,6 @@ TEST_F(DBWALTest, SyncWALNotWaitWrite) {
  ASSERT_EQ(Get("foo2"), "bar2");
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
-
-TEST_F(DBWALTest, Recover) {
-  do {
-    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-    ASSERT_OK(Put(1, "foo", "v1"));
-    ASSERT_OK(Put(1, "baz", "v5"));
-
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    ASSERT_EQ("v1", Get(1, "foo"));
-
-    ASSERT_EQ("v1", Get(1, "foo"));
-    ASSERT_EQ("v5", Get(1, "baz"));
-    ASSERT_OK(Put(1, "bar", "v2"));
-    ASSERT_OK(Put(1, "foo", "v3"));
-
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    ASSERT_EQ("v3", Get(1, "foo"));
-    ASSERT_OK(Put(1, "foo", "v4"));
-    ASSERT_EQ("v4", Get(1, "foo"));
-    ASSERT_EQ("v2", Get(1, "bar"));
-    ASSERT_EQ("v5", Get(1, "baz"));
-  } while (ChangeOptions());
-}
-
-TEST_F(DBWALTest, RecoverWithTableHandle) {
-  do {
-    Options options = CurrentOptions();
-    options.create_if_missing = true;
-    options.disable_auto_compactions = true;
-    DestroyAndReopen(options);
-    CreateAndReopenWithCF({"pikachu"}, options);
-
-    ASSERT_OK(Put(1, "foo", "v1"));
-    ASSERT_OK(Put(1, "bar", "v2"));
-    ASSERT_OK(Flush(1));
-    ASSERT_OK(Put(1, "foo", "v3"));
-    ASSERT_OK(Put(1, "bar", "v4"));
-    ASSERT_OK(Flush(1));
-    ASSERT_OK(Put(1, "big", std::string(100, 'a')));
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-
-    std::vector<std::vector<FileMetaData>> files;
-    dbfull()->TEST_GetFilesMetaData(handles_[1], &files);
-    size_t total_files = 0;
-    for (const auto& level : files) {
-      total_files += level.size();
-    }
-    ASSERT_EQ(total_files, 3);
-    for (const auto& level : files) {
-      for (const auto& file : level) {
-        if (kInfiniteMaxOpenFiles == option_config_) {
-          ASSERT_TRUE(file.table_reader_handle != nullptr);
-        } else {
-          ASSERT_TRUE(file.table_reader_handle == nullptr);
-        }
-      }
-    }
-  } while (ChangeOptions());
-}
-
-TEST_F(DBWALTest, IgnoreRecoveredLog) {
-  std::string backup_logs = dbname_ + "/backup_logs";
-
-  // delete old files in backup_logs directory
-  env_->CreateDirIfMissing(backup_logs);
-  std::vector<std::string> old_files;
-  env_->GetChildren(backup_logs, &old_files);
-  for (auto& file : old_files) {
-    if (file != "." && file != "..") {
-      env_->DeleteFile(backup_logs + "/" + file);
-    }
-  }
-
-  do {
-    Options options = CurrentOptions();
-    options.create_if_missing = true;
-    options.merge_operator = MergeOperators::CreateUInt64AddOperator();
-    options.wal_dir = dbname_ + "/logs";
-    DestroyAndReopen(options);
-
-    // fill up the DB
-    std::string one, two;
-    PutFixed64(&one, 1);
-    PutFixed64(&two, 2);
-    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
-    ASSERT_OK(db_->Merge(WriteOptions(), Slice("foo"), Slice(one)));
-    ASSERT_OK(db_->Merge(WriteOptions(), Slice("bar"), Slice(one)));
-
-    // copy the logs to backup
-    std::vector<std::string> logs;
-    env_->GetChildren(options.wal_dir, &logs);
-    for (auto& log : logs) {
-      if (log != ".." && log != ".") {
-        CopyFile(options.wal_dir + "/" + log, backup_logs + "/" + log);
-      }
-    }
-
-    // recover the DB
-    Reopen(options);
-    ASSERT_EQ(two, Get("foo"));
-    ASSERT_EQ(one, Get("bar"));
-    Close();
-
-    // copy the logs from backup back to wal dir
-    for (auto& log : logs) {
-      if (log != ".." && log != ".") {
-        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
-      }
-    }
-    // this should ignore the log files, recovery should not happen again
-    // if the recovery happens, the same merge operator would be called twice,
-    // leading to incorrect results
-    Reopen(options);
-    ASSERT_EQ(two, Get("foo"));
-    ASSERT_EQ(one, Get("bar"));
-    Close();
-    Destroy(options);
-    Reopen(options);
-    Close();
-
-    // copy the logs from backup back to wal dir
-    env_->CreateDirIfMissing(options.wal_dir);
-    for (auto& log : logs) {
-      if (log != ".." && log != ".") {
-        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
-      }
-    }
-    // assert that we successfully recovered only from logs, even though we
-    // destroyed the DB
-    Reopen(options);
-    ASSERT_EQ(two, Get("foo"));
-    ASSERT_EQ(one, Get("bar"));
-
-    // Recovery will fail if DB directory doesn't exist.
-    Destroy(options);
-    // copy the logs from backup back to wal dir
-    env_->CreateDirIfMissing(options.wal_dir);
-    for (auto& log : logs) {
-      if (log != ".." && log != ".") {
-        CopyFile(backup_logs + "/" + log, options.wal_dir + "/" + log);
-        // we won't be needing this file no more
-        env_->DeleteFile(backup_logs + "/" + log);
-      }
-    }
-    Status s = TryReopen(options);
-    ASSERT_TRUE(!s.ok());
-  } while (ChangeOptions(kSkipHashCuckoo));
-}
-
-TEST_F(DBWALTest, RecoveryWithEmptyLog) {
-  do {
-    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-    ASSERT_OK(Put(1, "foo", "v1"));
-    ASSERT_OK(Put(1, "foo", "v2"));
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    ASSERT_OK(Put(1, "foo", "v3"));
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    ASSERT_EQ("v3", Get(1, "foo"));
-  } while (ChangeOptions());
-}
-
-#ifndef ROCKSDB_LITE
-TEST_F(DBWALTest, RecoverWithLargeLog) {
-  do {
-    {
-      Options options = CurrentOptions();
-      CreateAndReopenWithCF({"pikachu"}, options);
-      ASSERT_OK(Put(1, "big1", std::string(200000, '1')));
-      ASSERT_OK(Put(1, "big2", std::string(200000, '2')));
-      ASSERT_OK(Put(1, "small3", std::string(10, '3')));
-      ASSERT_OK(Put(1, "small4", std::string(10, '4')));
-      ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
-    }
-
-    // Make sure that if we re-open with a small write buffer size that
-    // we flush table files in the middle of a large log file.
-    Options options;
-    options.write_buffer_size = 100000;
-    options = CurrentOptions(options);
-    ReopenWithColumnFamilies({"default", "pikachu"}, options);
-    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 3);
-    ASSERT_EQ(std::string(200000, '1'), Get(1, "big1"));
-    ASSERT_EQ(std::string(200000, '2'), Get(1, "big2"));
-    ASSERT_EQ(std::string(10, '3'), Get(1, "small3"));
-    ASSERT_EQ(std::string(10, '4'), Get(1, "small4"));
-    ASSERT_GT(NumTableFilesAtLevel(0, 1), 1);
-  } while (ChangeCompactOptions());
-}
-
-// In https://reviews.facebook.net/D20661 we change
-// recovery behavior: previously for each log file each column family
-// memtable was flushed, even it was empty. Now it's changed:
-// we try to create the smallest number of table files by merging
-// updates from multiple logs
-TEST_F(DBWALTest, RecoverCheckFileAmountWithSmallWriteBuffer) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 5000000;
-  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
-
-  // Since we will reopen DB with smaller write_buffer_size,
-  // each key will go to new SST file
-  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
-  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
-  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
-  ASSERT_OK(Put(1, Key(10), DummyString(1000000)));
-
-  ASSERT_OK(Put(3, Key(10), DummyString(1)));
-  // Make 'dobrynia' to be flushed and new WAL file to be created
-  ASSERT_OK(Put(2, Key(10), DummyString(7500000)));
-  ASSERT_OK(Put(2, Key(1), DummyString(1)));
-  dbfull()->TEST_WaitForFlushMemTable(handles_[2]);
-  {
-    auto tables = ListTableFiles(env_, dbname_);
-    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
-    // Make sure 'dobrynia' was flushed: check sst files amount
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
-              static_cast<uint64_t>(1));
-  }
-  // New WAL file
-  ASSERT_OK(Put(1, Key(1), DummyString(1)));
-  ASSERT_OK(Put(1, Key(1), DummyString(1)));
-  ASSERT_OK(Put(3, Key(10), DummyString(1)));
-  ASSERT_OK(Put(3, Key(10), DummyString(1)));
-  ASSERT_OK(Put(3, Key(10), DummyString(1)));
-
-  options.write_buffer_size = 4096;
-  options.arena_block_size = 4096;
-  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
-                           options);
-  {
-    // No inserts => default is empty
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
-              static_cast<uint64_t>(0));
-    // First 4 keys goes to separate SSTs + 1 more SST for 2 smaller keys
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
-              static_cast<uint64_t>(5));
-    // 1 SST for big key + 1 SST for small one
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
-              static_cast<uint64_t>(2));
-    // 1 SST for all keys
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
-              static_cast<uint64_t>(1));
-  }
-}
-
-// In https://reviews.facebook.net/D20661 we change
-// recovery behavior: previously for each log file each column family
-// memtable was flushed, even it wasn't empty. Now it's changed:
-// we try to create the smallest number of table files by merging
-// updates from multiple logs
-TEST_F(DBWALTest, RecoverCheckFileAmount) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 100000;
-  options.arena_block_size = 4 * 1024;
-  CreateAndReopenWithCF({"pikachu", "dobrynia", "nikitich"}, options);
-
-  ASSERT_OK(Put(0, Key(1), DummyString(1)));
-  ASSERT_OK(Put(1, Key(1), DummyString(1)));
-  ASSERT_OK(Put(2, Key(1), DummyString(1)));
-
-  // Make 'nikitich' memtable to be flushed
-  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
-  ASSERT_OK(Put(3, Key(1), DummyString(1)));
-  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
-  // 4 memtable are not flushed, 1 sst file
-  {
-    auto tables = ListTableFiles(env_, dbname_);
-    ASSERT_EQ(tables.size(), static_cast<size_t>(1));
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
-              static_cast<uint64_t>(1));
-  }
-  // Memtable for 'nikitich' has flushed, new WAL file has opened
-  // 4 memtable still not flushed
-
-  // Write to new WAL file
-  ASSERT_OK(Put(0, Key(1), DummyString(1)));
-  ASSERT_OK(Put(1, Key(1), DummyString(1)));
-  ASSERT_OK(Put(2, Key(1), DummyString(1)));
-
-  // Fill up 'nikitich' one more time
-  ASSERT_OK(Put(3, Key(10), DummyString(1002400)));
-  // make it flush
-  ASSERT_OK(Put(3, Key(1), DummyString(1)));
-  dbfull()->TEST_WaitForFlushMemTable(handles_[3]);
-  // There are still 4 memtable not flushed, and 2 sst tables
-  ASSERT_OK(Put(0, Key(1), DummyString(1)));
-  ASSERT_OK(Put(1, Key(1), DummyString(1)));
-  ASSERT_OK(Put(2, Key(1), DummyString(1)));
-
-  {
-    auto tables = ListTableFiles(env_, dbname_);
-    ASSERT_EQ(tables.size(), static_cast<size_t>(2));
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
-              static_cast<uint64_t>(2));
-  }
-
-  ReopenWithColumnFamilies({"default", "pikachu", "dobrynia", "nikitich"},
-                           options);
-  {
-    std::vector<uint64_t> table_files = ListTableFiles(env_, dbname_);
-    // Check, that records for 'default', 'dobrynia' and 'pikachu' from
-    // first, second and third WALs  went to the same SST.
-    // So, there is 6 SSTs: three  for 'nikitich', one for 'default', one for
-    // 'dobrynia', one for 'pikachu'
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "default"),
-              static_cast<uint64_t>(1));
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "nikitich"),
-              static_cast<uint64_t>(3));
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "dobrynia"),
-              static_cast<uint64_t>(1));
-    ASSERT_EQ(GetNumberOfSstFilesForColumnFamily(db_, "pikachu"),
-              static_cast<uint64_t>(1));
-  }
-}
-
-TEST_F(DBWALTest, SyncMultipleLogs) {
-  const uint64_t kNumBatches = 2;
-  const int kBatchSize = 1000;
-
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.write_buffer_size = 4096;
-  Reopen(options);
-
-  WriteBatch batch;
-  WriteOptions wo;
-  wo.sync = true;
-
-  for (uint64_t b = 0; b < kNumBatches; b++) {
-    batch.Clear();
-    for (int i = 0; i < kBatchSize; i++) {
-      batch.Put(Key(i), DummyString(128));
-    }
-
-    dbfull()->Write(wo, &batch);
-  }
-
-  ASSERT_OK(dbfull()->SyncWAL());
-}
-
-//
-// Test WAL recovery for the various modes available
-//
-class RecoveryTestHelper {
- public:
-  // Number of WAL files to generate
-  static const int kWALFilesCount = 10;
-  // Starting number for the WAL file name like 00010.log
-  static const int kWALFileOffset = 10;
-  // Keys to be written per WAL file
-  static const int kKeysPerWALFile = 1024;
-  // Size of the value
-  static const int kValueSize = 10;
-
-  // Create WAL files with values filled in
-  static void FillData(DBWALTest* test, const Options& options,
-                       const size_t wal_count, size_t* count) {
-    const DBOptions& db_options = options;
-
-    *count = 0;
-
-    shared_ptr<Cache> table_cache = NewLRUCache(50000, 16);
-    EnvOptions env_options;
-    WriteBuffer write_buffer(db_options.db_write_buffer_size);
-
-    unique_ptr<VersionSet> versions;
-    unique_ptr<WalManager> wal_manager;
-    WriteController write_controller;
-
-    versions.reset(new VersionSet(test->dbname_, &db_options, env_options,
-                                  table_cache.get(), &write_buffer,
-                                  &write_controller));
-
-    wal_manager.reset(new WalManager(db_options, env_options));
-
-    std::unique_ptr<log::Writer> current_log_writer;
-
-    for (size_t j = kWALFileOffset; j < wal_count + kWALFileOffset; j++) {
-      uint64_t current_log_number = j;
-      std::string fname = LogFileName(test->dbname_, current_log_number);
-      unique_ptr<WritableFile> file;
-      ASSERT_OK(db_options.env->NewWritableFile(fname, &file, env_options));
-      unique_ptr<WritableFileWriter> file_writer(
-          new WritableFileWriter(std::move(file), env_options));
-      current_log_writer.reset(
-          new log::Writer(std::move(file_writer), current_log_number,
-                          db_options.recycle_log_file_num > 0));
-
-      for (int i = 0; i < kKeysPerWALFile; i++) {
-        std::string key = "key" + ToString((*count)++);
-        std::string value = test->DummyString(kValueSize);
-        assert(current_log_writer.get() != nullptr);
-        uint64_t seq = versions->LastSequence() + 1;
-        WriteBatch batch;
-        batch.Put(key, value);
-        WriteBatchInternal::SetSequence(&batch, seq);
-        current_log_writer->AddRecord(WriteBatchInternal::Contents(&batch));
-        versions->SetLastSequence(seq);
-      }
-    }
-  }
-
-  // Recreate and fill the store with some data
-  static size_t FillData(DBWALTest* test, Options* options) {
-    options->create_if_missing = true;
-    test->DestroyAndReopen(*options);
-    test->Close();
-
-    size_t count = 0;
-    FillData(test, *options, kWALFilesCount, &count);
-    return count;
-  }
-
-  // Read back all the keys we wrote and return the number of keys found
-  static size_t GetData(DBWALTest* test) {
-    size_t count = 0;
-    for (size_t i = 0; i < kWALFilesCount * kKeysPerWALFile; i++) {
-      if (test->Get("key" + ToString(i)) != "NOT_FOUND") {
-        ++count;
-      }
-    }
-    return count;
-  }
-
-  // Manuall corrupt the specified WAL
-  static void CorruptWAL(DBWALTest* test, const Options& options,
-                         const double off, const double len,
-                         const int wal_file_id, const bool trunc = false) {
-    Env* env = options.env;
-    std::string fname = LogFileName(test->dbname_, wal_file_id);
-    uint64_t size;
-    ASSERT_OK(env->GetFileSize(fname, &size));
-    ASSERT_GT(size, 0);
-#ifdef OS_WIN
-    // Windows disk cache behaves differently. When we truncate
-    // the original content is still in the cache due to the original
-    // handle is still open. Generally, in Windows, one prohibits
-    // shared access to files and it is not needed for WAL but we allow
-    // it to induce corruption at various tests.
-    test->Close();
-#endif
-    if (trunc) {
-      ASSERT_EQ(0, truncate(fname.c_str(), static_cast<int64_t>(size * off)));
-    } else {
-      InduceCorruption(fname, static_cast<size_t>(size * off),
-                       static_cast<size_t>(size * len));
-    }
-  }
-
-  // Overwrite data with 'a' from offset for length len
-  static void InduceCorruption(const std::string& filename, size_t offset,
-                               size_t len) {
-    ASSERT_GT(len, 0U);
-
-    int fd = open(filename.c_str(), O_RDWR);
-
-    // On windows long is 32-bit
-    ASSERT_LE(offset, std::numeric_limits<long>::max());
-
-    ASSERT_GT(fd, 0);
-    ASSERT_EQ(offset, lseek(fd, static_cast<long>(offset), SEEK_SET));
-
-    void* buf = alloca(len);
-    memset(buf, 'a', len);
-    ASSERT_EQ(len, write(fd, buf, static_cast<unsigned int>(len)));
-
-    close(fd);
-  }
-};
-
-// Test scope:
-// - We expect to open the data store when there is incomplete trailing writes
-// at the end of any of the logs
-// - We do not expect to open the data store for corruption
-TEST_F(DBWALTest, kTolerateCorruptedTailRecords) {
-  const int jstart = RecoveryTestHelper::kWALFileOffset;
-  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
-
-  for (auto trunc : {true, false}) {        /* Corruption style */
-    for (int i = 0; i < 4; i++) {           /* Corruption offset position */
-      for (int j = jstart; j < jend; j++) { /* WAL file */
-        // Fill data for testing
-        Options options = CurrentOptions();
-        const size_t row_count = RecoveryTestHelper::FillData(this, &options);
-        // test checksum failure or parsing
-        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
-                                       /*len%=*/.1, /*wal=*/j, trunc);
-
-        if (trunc) {
-          options.wal_recovery_mode =
-              WALRecoveryMode::kTolerateCorruptedTailRecords;
-          options.create_if_missing = false;
-          ASSERT_OK(TryReopen(options));
-          const size_t recovered_row_count = RecoveryTestHelper::GetData(this);
-          ASSERT_TRUE(i == 0 || recovered_row_count > 0);
-          ASSERT_LT(recovered_row_count, row_count);
-        } else {
-          options.wal_recovery_mode =
-              WALRecoveryMode::kTolerateCorruptedTailRecords;
-          ASSERT_NOK(TryReopen(options));
-        }
-      }
-    }
-  }
-}
-
-// Test scope:
-// We don't expect the data store to be opened if there is any corruption
-// (leading, middle or trailing -- incomplete writes or corruption)
-TEST_F(DBWALTest, kAbsoluteConsistency) {
-  const int jstart = RecoveryTestHelper::kWALFileOffset;
-  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
-
-  // Verify clean slate behavior
-  Options options = CurrentOptions();
-  const size_t row_count = RecoveryTestHelper::FillData(this, &options);
-  options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
-  options.create_if_missing = false;
-  ASSERT_OK(TryReopen(options));
-  ASSERT_EQ(RecoveryTestHelper::GetData(this), row_count);
-
-  for (auto trunc : {true, false}) { /* Corruption style */
-    for (int i = 0; i < 4; i++) {    /* Corruption offset position */
-      if (trunc && i == 0) {
-        continue;
-      }
-
-      for (int j = jstart; j < jend; j++) { /* wal files */
-        // fill with new date
-        RecoveryTestHelper::FillData(this, &options);
-        // corrupt the wal
-        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
-                                       /*len%=*/.1, j, trunc);
-        // verify
-        options.wal_recovery_mode = WALRecoveryMode::kAbsoluteConsistency;
-        options.create_if_missing = false;
-        ASSERT_NOK(TryReopen(options));
-      }
-    }
-  }
-}
-
-// Test scope:
-// - We expect to open data store under all circumstances
-// - We expect only data upto the point where the first error was encountered
-TEST_F(DBWALTest, kPointInTimeRecovery) {
-  const int jstart = RecoveryTestHelper::kWALFileOffset;
-  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
-  const int maxkeys =
-      RecoveryTestHelper::kWALFilesCount * RecoveryTestHelper::kKeysPerWALFile;
-
-  for (auto trunc : {true, false}) {        /* Corruption style */
-    for (int i = 0; i < 4; i++) {           /* Offset of corruption */
-      for (int j = jstart; j < jend; j++) { /* WAL file */
-        // Fill data for testing
-        Options options = CurrentOptions();
-        const size_t row_count = RecoveryTestHelper::FillData(this, &options);
-
-        // Corrupt the wal
-        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
-                                       /*len%=*/.1, j, trunc);
-
-        // Verify
-        options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
-        options.create_if_missing = false;
-        ASSERT_OK(TryReopen(options));
-
-        // Probe data for invariants
-        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
-        ASSERT_LT(recovered_row_count, row_count);
-
-        bool expect_data = true;
-        for (size_t k = 0; k < maxkeys; ++k) {
-          bool found = Get("key" + ToString(i)) != "NOT_FOUND";
-          if (expect_data && !found) {
-            expect_data = false;
-          }
-          ASSERT_EQ(found, expect_data);
-        }
-
-        const size_t min = RecoveryTestHelper::kKeysPerWALFile *
-                           (j - RecoveryTestHelper::kWALFileOffset);
-        ASSERT_GE(recovered_row_count, min);
-        if (!trunc && i != 0) {
-          const size_t max = RecoveryTestHelper::kKeysPerWALFile *
-                             (j - RecoveryTestHelper::kWALFileOffset + 1);
-          ASSERT_LE(recovered_row_count, max);
-        }
-      }
-    }
-  }
-}
-
-// Test scope:
-// - We expect to open the data store under all scenarios
-// - We expect to have recovered records past the corruption zone
-TEST_F(DBWALTest, kSkipAnyCorruptedRecords) {
-  const int jstart = RecoveryTestHelper::kWALFileOffset;
-  const int jend = jstart + RecoveryTestHelper::kWALFilesCount;
-
-  for (auto trunc : {true, false}) {        /* Corruption style */
-    for (int i = 0; i < 4; i++) {           /* Corruption offset */
-      for (int j = jstart; j < jend; j++) { /* wal files */
-        // Fill data for testing
-        Options options = CurrentOptions();
-        const size_t row_count = RecoveryTestHelper::FillData(this, &options);
-
-        // Corrupt the WAL
-        RecoveryTestHelper::CorruptWAL(this, options, /*off=*/i * .3,
-                                       /*len%=*/.1, j, trunc);
-
-        // Verify behavior
-        options.wal_recovery_mode = WALRecoveryMode::kSkipAnyCorruptedRecords;
-        options.create_if_missing = false;
-        ASSERT_OK(TryReopen(options));
-
-        // Probe data for invariants
-        size_t recovered_row_count = RecoveryTestHelper::GetData(this);
-        ASSERT_LT(recovered_row_count, row_count);
-
-        if (!trunc) {
-          ASSERT_TRUE(i != 0 || recovered_row_count > 0);
-        }
-      }
-    }
-  }
-}
-
-#endif  // ROCKSDB_LITE
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -465,12 +465,6 @@ class InternalKeySliceTransform : public SliceTransform {
  const SliceTransform* const transform_;
 };

-// Read the key of a record from a write batch.
-// if this record represent the default column family then cf_record
-// must be passed as false, otherwise it must be passed as true.
-extern bool ReadKeyFromWriteBatchEntry(Slice* input, Slice* key,
-                                       bool cf_record);
-
 // Read record from a write batch piece from input.
 // tag, column_family, key, value and blob are return values. Callers own the
 // Slice they point to.
@@ -92,30 +92,6 @@ TEST_F(FormatTest, InternalKeyShortSeparator) {
            Shorten(IKey("foo", 100, kTypeValue),
                    IKey("hello", 200, kTypeValue)));

-  ASSERT_EQ(IKey("ABC2", kMaxSequenceNumber, kValueTypeForSeek),
-            Shorten(IKey("ABC1AAAAA", 100, kTypeValue),
-                    IKey("ABC2ABB", 200, kTypeValue)));
-
-  ASSERT_EQ(IKey("AAA2", kMaxSequenceNumber, kValueTypeForSeek),
-            Shorten(IKey("AAA1AAA", 100, kTypeValue),
-                    IKey("AAA2AA", 200, kTypeValue)));
-
-  ASSERT_EQ(
-      IKey("AAA2", kMaxSequenceNumber, kValueTypeForSeek),
-      Shorten(IKey("AAA1AAA", 100, kTypeValue), IKey("AAA4", 200, kTypeValue)));
-
-  ASSERT_EQ(
-      IKey("AAA1B", kMaxSequenceNumber, kValueTypeForSeek),
-      Shorten(IKey("AAA1AAA", 100, kTypeValue), IKey("AAA2", 200, kTypeValue)));
-
-  ASSERT_EQ(IKey("AAA2", kMaxSequenceNumber, kValueTypeForSeek),
-            Shorten(IKey("AAA1AAA", 100, kTypeValue),
-                    IKey("AAA2A", 200, kTypeValue)));
-
-  ASSERT_EQ(
-      IKey("AAA1", 100, kTypeValue),
-      Shorten(IKey("AAA1", 100, kTypeValue), IKey("AAA2", 200, kTypeValue)));
-
  // When start user key is prefix of limit user key
  ASSERT_EQ(IKey("foo", 100, kTypeValue),
            Shorten(IKey("foo", 100, kTypeValue),
@@ -20,83 +20,57 @@ void EventHelpers::AppendCurrentTime(JSONWriter* jwriter) {
                  std::chrono::system_clock::now().time_since_epoch()).count();
 }

-#ifndef ROCKSDB_LITE
-void EventHelpers::NotifyTableFileCreationStarted(
-    const std::vector<std::shared_ptr<EventListener>>& listeners,
-    const std::string& db_name, const std::string& cf_name,
-    const std::string& file_path, int job_id, TableFileCreationReason reason) {
-  TableFileCreationBriefInfo info;
-  info.db_name = db_name;
-  info.cf_name = cf_name;
-  info.file_path = file_path;
-  info.job_id = job_id;
-  info.reason = reason;
-  for (auto& listener : listeners) {
-    listener->OnTableFileCreationStarted(info);
-  }
-}
-#endif  // !ROCKSDB_LITE
-
-void EventHelpers::LogAndNotifyTableFileCreationFinished(
+void EventHelpers::LogAndNotifyTableFileCreation(
    EventLogger* event_logger,
    const std::vector<std::shared_ptr<EventListener>>& listeners,
-    const std::string& db_name, const std::string& cf_name,
-    const std::string& file_path, int job_id, const FileDescriptor& fd,
-    const TableProperties& table_properties, TableFileCreationReason reason,
-    const Status& s) {
-  if (s.ok() && event_logger) {
-    JSONWriter jwriter;
-    AppendCurrentTime(&jwriter);
-    jwriter << "cf_name" << cf_name << "job" << job_id << "event"
-            << "table_file_creation"
-            << "file_number" << fd.GetNumber() << "file_size"
-            << fd.GetFileSize();
+    const FileDescriptor& fd, const TableFileCreationInfo& info) {
+  assert(event_logger);
+  JSONWriter jwriter;
+  AppendCurrentTime(&jwriter);
+  jwriter << "cf_name" << info.cf_name
+          << "job" << info.job_id
+          << "event" << "table_file_creation"
+          << "file_number" << fd.GetNumber()
+          << "file_size" << fd.GetFileSize();

-    // table_properties
-    {
-      jwriter << "table_properties";
-      jwriter.StartObject();
+  // table_properties
+  {
+    jwriter << "table_properties";
+    jwriter.StartObject();

-      // basic properties:
-      jwriter << "data_size" << table_properties.data_size << "index_size"
-              << table_properties.index_size << "filter_size"
-              << table_properties.filter_size << "raw_key_size"
-              << table_properties.raw_key_size << "raw_average_key_size"
-              << SafeDivide(table_properties.raw_key_size,
-                            table_properties.num_entries)
-              << "raw_value_size" << table_properties.raw_value_size
-              << "raw_average_value_size"
-              << SafeDivide(table_properties.raw_value_size,
-                            table_properties.num_entries)
-              << "num_data_blocks" << table_properties.num_data_blocks
-              << "num_entries" << table_properties.num_entries
-              << "filter_policy_name" << table_properties.filter_policy_name;
+    // basic properties:
+    jwriter << "data_size" << info.table_properties.data_size
+            << "index_size" << info.table_properties.index_size
+            << "filter_size" << info.table_properties.filter_size
+            << "raw_key_size" << info.table_properties.raw_key_size
+            << "raw_average_key_size" << SafeDivide(
+                info.table_properties.raw_key_size,
+                info.table_properties.num_entries)
+            << "raw_value_size" << info.table_properties.raw_value_size
+            << "raw_average_value_size" << SafeDivide(
+               info.table_properties.raw_value_size,
+               info.table_properties.num_entries)
+            << "num_data_blocks" << info.table_properties.num_data_blocks
+            << "num_entries" << info.table_properties.num_entries
+            << "filter_policy_name" <<
+                info.table_properties.filter_policy_name;

-      // user collected properties
-      for (const auto& prop : table_properties.readable_properties) {
-        jwriter << prop.first << prop.second;
-      }
-      jwriter.EndObject();
+    // user collected properties
+    for (const auto& prop : info.table_properties.readable_properties) {
+      jwriter << prop.first << prop.second;
    }
    jwriter.EndObject();
-
-    event_logger->Log(jwriter);
  }
+  jwriter.EndObject();
+
+  event_logger->Log(jwriter);

 #ifndef ROCKSDB_LITE
  if (listeners.size() == 0) {
    return;
  }
-  TableFileCreationInfo info;
-  info.db_name = db_name;
-  info.cf_name = cf_name;
-  info.file_path = file_path;
-  info.file_size = fd.file_size;
-  info.job_id = job_id;
-  info.table_properties = table_properties;
-  info.reason = reason;
-  info.status = s;
-  for (auto& listener : listeners) {
+
+  for (auto listener : listeners) {
    listener->OnTableFileCreated(info);
  }
 #endif  // !ROCKSDB_LITE
@@ -19,30 +19,15 @@ namespace rocksdb {
 class EventHelpers {
 public:
  static void AppendCurrentTime(JSONWriter* json_writer);
-#ifndef ROCKSDB_LITE
-  static void NotifyTableFileCreationStarted(
-      const std::vector<std::shared_ptr<EventListener>>& listeners,
-      const std::string& db_name, const std::string& cf_name,
-      const std::string& file_path, int job_id, TableFileCreationReason reason);
-#endif  // !ROCKSDB_LITE
-  static void LogAndNotifyTableFileCreationFinished(
+  static void LogAndNotifyTableFileCreation(
      EventLogger* event_logger,
      const std::vector<std::shared_ptr<EventListener>>& listeners,
-      const std::string& db_name, const std::string& cf_name,
-      const std::string& file_path, int job_id, const FileDescriptor& fd,
-      const TableProperties& table_properties, TableFileCreationReason reason,
-      const Status& s);
+      const FileDescriptor& fd, const TableFileCreationInfo& info);
  static void LogAndNotifyTableFileDeletion(
      EventLogger* event_logger, int job_id,
      uint64_t file_number, const std::string& file_path,
      const Status& status, const std::string& db_name,
      const std::vector<std::shared_ptr<EventListener>>& listeners);
-
- private:
-  static void LogAndNotifyTableFileCreation(
-      EventLogger* event_logger,
-      const std::vector<std::shared_ptr<EventListener>>& listeners,
-      const FileDescriptor& fd, const TableFileCreationInfo& info);
 };

 }  // namespace rocksdb
@@ -66,7 +66,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                   JobContext* job_context, LogBuffer* log_buffer,
                   Directory* db_directory, Directory* output_file_directory,
                   CompressionType output_compression, Statistics* stats,
-                   EventLogger* event_logger, bool measure_io_stats)
+                   EventLogger* event_logger)
    : dbname_(dbname),
      cfd_(cfd),
      db_options_(db_options),
@@ -83,8 +83,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
      output_file_directory_(output_file_directory),
      output_compression_(output_compression),
      stats_(stats),
-      event_logger_(event_logger),
-      measure_io_stats_(measure_io_stats) {
+      event_logger_(event_logger) {
  // Update the thread status to indicate flush.
  ReportStartedFlush();
  TEST_SYNC_POINT("FlushJob::FlushJob()");
@@ -115,30 +114,13 @@ void FlushJob::ReportFlushInputSize(const autovector<MemTable*>& mems) {
 }

 void FlushJob::RecordFlushIOStats() {
-  RecordTick(stats_, FLUSH_WRITE_BYTES, IOSTATS(bytes_written));
-  ThreadStatusUtil::IncreaseThreadOperationProperty(
+  ThreadStatusUtil::SetThreadOperationProperty(
      ThreadStatus::FLUSH_BYTES_WRITTEN, IOSTATS(bytes_written));
-  IOSTATS_RESET(bytes_written);
 }

 Status FlushJob::Run(FileMetaData* file_meta) {
  AutoThreadOperationStageUpdater stage_run(
      ThreadStatus::STAGE_FLUSH_RUN);
-  // I/O measurement variables
-  PerfLevel prev_perf_level = PerfLevel::kEnableTime;
-  uint64_t prev_write_nanos = 0;
-  uint64_t prev_fsync_nanos = 0;
-  uint64_t prev_range_sync_nanos = 0;
-  uint64_t prev_prepare_write_nanos = 0;
-  if (measure_io_stats_) {
-    prev_perf_level = GetPerfLevel();
-    SetPerfLevel(PerfLevel::kEnableTime);
-    prev_write_nanos = IOSTATS(write_nanos);
-    prev_fsync_nanos = IOSTATS(fsync_nanos);
-    prev_range_sync_nanos = IOSTATS(range_sync_nanos);
-    prev_prepare_write_nanos = IOSTATS(prepare_write_nanos);
-  }
-
  // Save the contents of the earliest memtable as a new Table
  FileMetaData meta;
  autovector<MemTable*> mems;
@@ -198,18 +180,6 @@ Status FlushJob::Run(FileMetaData* file_meta) {
  }
  stream.EndArray();

-  if (measure_io_stats_) {
-    if (prev_perf_level != PerfLevel::kEnableTime) {
-      SetPerfLevel(prev_perf_level);
-    }
-    stream << "file_write_nanos" << (IOSTATS(write_nanos) - prev_write_nanos);
-    stream << "file_range_sync_nanos"
-           << (IOSTATS(range_sync_nanos) - prev_range_sync_nanos);
-    stream << "file_fsync_nanos" << (IOSTATS(fsync_nanos) - prev_fsync_nanos);
-    stream << "file_prepare_write_nanos"
-           << (IOSTATS(prepare_write_nanos) - prev_prepare_write_nanos);
-  }
-
  return s;
 }

@@ -253,6 +223,7 @@ Status FlushJob::WriteLevel0Table(const autovector<MemTable*>& mems,
                         << total_num_deletes << "memory_usage"
                         << total_memory_usage;

+    TableFileCreationInfo info;
    {
      ScopedArenaIterator iter(
          NewMergingIterator(&cfd_->internal_comparator(), &memtables[0],
@@ -263,16 +234,15 @@ Status FlushJob::WriteLevel0Table(const autovector<MemTable*>& mems,

      TEST_SYNC_POINT_CALLBACK("FlushJob::WriteLevel0Table:output_compression",
                               &output_compression_);
-      s = BuildTable(
-          dbname_, db_options_.env, *cfd_->ioptions(), 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(),
-          TableFileCreationReason::kFlush, event_logger_, job_context_->job_id,
-          Env::IO_HIGH, &table_properties_, 0 /* level */);
+      s = BuildTable(dbname_, db_options_.env, *cfd_->ioptions(), env_options_,
+                     cfd_->table_cache(), iter.get(), meta,
+                     cfd_->internal_comparator(),
+                     cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
+                     existing_snapshots_, earliest_write_conflict_snapshot_,
+                     output_compression_, cfd_->ioptions()->compression_opts,
+                     mutable_cf_options_.paranoid_file_checks,
+                     cfd_->internal_stats(), Env::IO_HIGH, &table_properties_);
+      info.table_properties = table_properties_;
      LogFlush(db_options_.info_log);
    }
    Log(InfoLogLevel::INFO_LEVEL, db_options_.info_log,
@@ -283,6 +253,21 @@ Status FlushJob::WriteLevel0Table(const autovector<MemTable*>& mems,
        meta->fd.GetFileSize(), s.ToString().c_str(),
        meta->marked_for_compaction ? " (needs compaction)" : "");

+    // output to event logger
+    if (s.ok()) {
+      info.db_name = dbname_;
+      info.cf_name = cfd_->GetName();
+      info.file_path = TableFileName(db_options_.db_paths,
+                                     meta->fd.GetNumber(),
+                                     meta->fd.GetPathId());
+      info.file_size = meta->fd.GetFileSize();
+      info.job_id = job_context_->job_id;
+      EventHelpers::LogAndNotifyTableFileCreation(
+          event_logger_, db_options_.listeners,
+          meta->fd, info);
+      TEST_SYNC_POINT("FlushJob::LogAndNotifyTableFileCreation()");
+    }
+
    if (!db_options_.disableDataSync && output_file_directory_ != nullptr) {
      output_file_directory_->Fsync();
    }
@@ -308,14 +293,13 @@ Status FlushJob::WriteLevel0Table(const autovector<MemTable*>& mems,
                  meta->marked_for_compaction);
  }

-  // Note that here we treat flush as level 0 compaction in internal stats
  InternalStats::CompactionStats stats(1);
  stats.micros = db_options_.env->NowMicros() - start_micros;
  stats.bytes_written = meta->fd.GetFileSize();
  cfd_->internal_stats()->AddCompactionStats(0 /* level */, stats);
  cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
                                     meta->fd.GetFileSize());
-  RecordFlushIOStats();
+  RecordTick(stats_, COMPACT_WRITE_BYTES, meta->fd.GetFileSize());
  return s;
 }

@@ -62,7 +62,7 @@ class FlushJob {
           JobContext* job_context, LogBuffer* log_buffer,
           Directory* db_directory, Directory* output_file_directory,
           CompressionType output_compression, Statistics* stats,
-           EventLogger* event_logger, bool measure_io_stats);
+           EventLogger* event_logger);

  ~FlushJob();

@@ -93,7 +93,6 @@ class FlushJob {
  Statistics* stats_;
  EventLogger* event_logger_;
  TableProperties table_properties_;
-  bool measure_io_stats_;
 };

 }  // namespace rocksdb
@@ -93,7 +93,7 @@ TEST_F(FlushJobTest, Empty) {
                     db_options_, *cfd->GetLatestMutableCFOptions(),
                     env_options_, versions_.get(), &mutex_, &shutting_down_,
                     {}, kMaxSequenceNumber, &job_context, nullptr, nullptr,
-                     nullptr, kNoCompression, nullptr, &event_logger, false);
+                     nullptr, kNoCompression, nullptr, &event_logger);
  ASSERT_OK(flush_job.Run());
  job_context.Clean();
 }
@@ -132,7 +132,7 @@ TEST_F(FlushJobTest, NonEmpty) {
                     db_options_, *cfd->GetLatestMutableCFOptions(),
                     env_options_, versions_.get(), &mutex_, &shutting_down_,
                     {}, kMaxSequenceNumber, &job_context, nullptr, nullptr,
-                     nullptr, kNoCompression, nullptr, &event_logger, true);
+                     nullptr, kNoCompression, nullptr, &event_logger);
  FileMetaData fd;
  mutex_.Lock();
  ASSERT_OK(flush_job.Run(&fd));
@@ -192,11 +192,11 @@ TEST_F(FlushJobTest, Snapshots) {
  }

  EventLogger event_logger(db_options_.info_log.get());
-  FlushJob flush_job(
-      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
-      *cfd->GetLatestMutableCFOptions(), env_options_, versions_.get(), &mutex_,
-      &shutting_down_, snapshots, kMaxSequenceNumber, &job_context, nullptr,
-      nullptr, nullptr, kNoCompression, nullptr, &event_logger, true);
+  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
+                     db_options_, *cfd->GetLatestMutableCFOptions(),
+                     env_options_, versions_.get(), &mutex_, &shutting_down_,
+                     snapshots, kMaxSequenceNumber, &job_context, nullptr,
+                     nullptr, nullptr, kNoCompression, nullptr, &event_logger);
  mutex_.Lock();
  ASSERT_OK(flush_job.Run());
  mutex_.Unlock();
@@ -101,8 +101,6 @@ std::pair<Slice, Slice> GetPropertyNameAndArg(const Slice& property) {
 static const std::string rocksdb_prefix = "rocksdb.";

 static const std::string num_files_at_level_prefix = "num-files-at-level";
-static const std::string compression_ratio_at_level_prefix =
-    "compression-ratio-at-level";
 static const std::string allstats = "stats";
 static const std::string sstables = "sstables";
 static const std::string cfstats = "cfstats";
@@ -150,8 +148,6 @@ static const std::string num_running_flushes = "num-running-flushes";

 const std::string DB::Properties::kNumFilesAtLevelPrefix =
                      rocksdb_prefix + num_files_at_level_prefix;
-const std::string DB::Properties::kCompressionRatioAtLevelPrefix =
-                      rocksdb_prefix + compression_ratio_at_level_prefix;
 const std::string DB::Properties::kStats = rocksdb_prefix + allstats;
 const std::string DB::Properties::kSSTables = rocksdb_prefix + sstables;
 const std::string DB::Properties::kCFStats = rocksdb_prefix + cfstats;
@@ -215,8 +211,6 @@ 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}},
@@ -330,19 +324,6 @@ bool InternalStats::HandleNumFilesAtLevel(std::string* value, Slice suffix) {
  }
 }

-bool InternalStats::HandleCompressionRatioAtLevelPrefix(std::string* value,
-                                                        Slice suffix) {
-  uint64_t level;
-  const auto* vstorage = cfd_->current()->storage_info();
-  bool ok = ConsumeDecimalNumber(&suffix, &level) && suffix.empty();
-  if (!ok || level >= static_cast<uint64_t>(number_levels_)) {
-    return false;
-  }
-  *value = ToString(
-      vstorage->GetEstimatedCompressionRatioAtLevel(static_cast<int>(level)));
-  return true;
-}
-
 bool InternalStats::HandleLevelStats(std::string* value, Slice suffix) {
  char buf[1000];
  const auto* vstorage = cfd_->current()->storage_info();
@@ -608,6 +589,9 @@ void InternalStats::DumpDBStats(std::string* value) {
  uint64_t wal_synced = GetDBStats(InternalStats::WAL_FILE_SYNCED);
  uint64_t write_with_wal = GetDBStats(InternalStats::WRITE_WITH_WAL);
  uint64_t write_stall_micros = GetDBStats(InternalStats::WRITE_STALL_MICROS);
+  uint64_t compact_bytes_read = 0;
+  uint64_t compact_bytes_write = 0;
+  uint64_t compact_micros = 0;

  const int kHumanMicrosLen = 32;
  char human_micros[kHumanMicrosLen];
@@ -639,6 +623,20 @@ void InternalStats::DumpDBStats(std::string* value) {
           write_with_wal / static_cast<double>(wal_synced + 1),
           wal_bytes / kGB, wal_bytes / kMB / seconds_up);
  value->append(buf);
+  // Compact
+  for (int level = 0; level < number_levels_; level++) {
+    compact_bytes_read += comp_stats_[level].bytes_read_output_level +
+                          comp_stats_[level].bytes_read_non_output_levels;
+    compact_bytes_write += comp_stats_[level].bytes_written;
+    compact_micros += comp_stats_[level].micros;
+  }
+  snprintf(buf, sizeof(buf),
+           "Cumulative compaction: %.2f GB write, %.2f MB/s write, "
+           "%.2f GB read, %.2f MB/s read, %.1f seconds\n",
+           compact_bytes_write / kGB, compact_bytes_write / kMB / seconds_up,
+           compact_bytes_read / kGB, compact_bytes_read / kMB / seconds_up,
+           compact_micros / kMicrosInSec);
+  value->append(buf);
  // Stall
  AppendHumanMicros(write_stall_micros, human_micros, kHumanMicrosLen, true);
  snprintf(buf, sizeof(buf),
@@ -683,6 +681,25 @@ void InternalStats::DumpDBStats(std::string* value) {
           interval_wal_bytes / kMB / std::max(interval_seconds_up, 0.001));
  value->append(buf);

+  // Compaction
+  uint64_t interval_compact_bytes_write =
+      compact_bytes_write - db_stats_snapshot_.compact_bytes_write;
+  uint64_t interval_compact_bytes_read =
+      compact_bytes_read - db_stats_snapshot_.compact_bytes_read;
+  uint64_t interval_compact_micros =
+      compact_micros - db_stats_snapshot_.compact_micros;
+
+  snprintf(
+      buf, sizeof(buf),
+      "Interval compaction: %.2f GB write, %.2f MB/s write, "
+      "%.2f GB read, %.2f MB/s read, %.1f seconds\n",
+      interval_compact_bytes_write / kGB,
+      interval_compact_bytes_write / kMB / std::max(interval_seconds_up, 0.001),
+      interval_compact_bytes_read / kGB,
+      interval_compact_bytes_read / kMB / std::max(interval_seconds_up, 0.001),
+      interval_compact_micros / kMicrosInSec);
+  value->append(buf);
+
  // Stall
  AppendHumanMicros(
      write_stall_micros - db_stats_snapshot_.write_stall_micros,
@@ -714,6 +731,9 @@ void InternalStats::DumpDBStats(std::string* value) {
  db_stats_snapshot_.wal_synced = wal_synced;
  db_stats_snapshot_.write_with_wal = write_with_wal;
  db_stats_snapshot_.write_stall_micros = write_stall_micros;
+  db_stats_snapshot_.compact_bytes_write = compact_bytes_write;
+  db_stats_snapshot_.compact_bytes_read = compact_bytes_read;
+  db_stats_snapshot_.compact_micros = compact_micros;
 }

 void InternalStats::DumpCFStats(std::string* value) {
@@ -769,7 +789,6 @@ void InternalStats::DumpCFStats(std::string* value) {
      value->append(buf);
    }
  }
-
  uint64_t curr_ingest = cf_stats_value_[BYTES_FLUSHED];
  // Cumulative summary
  double w_amp = stats_sum.bytes_written / static_cast<double>(curr_ingest + 1);
@@ -793,58 +812,11 @@ void InternalStats::DumpCFStats(std::string* value) {
  PrintLevelStats(buf, sizeof(buf), "Int", 0, 0, 0, 0, w_amp, interval_stats);
  value->append(buf);

-  double seconds_up = (env_->NowMicros() - started_at_ + 1) / kMicrosInSec;
-  double interval_seconds_up = seconds_up - cf_stats_snapshot_.seconds_up;
-  snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",
-           seconds_up, interval_seconds_up);
-  value->append(buf);
-
  snprintf(buf, sizeof(buf),
           "Flush(GB): cumulative %.3f, interval %.3f\n",
           curr_ingest / kGB, interval_ingest / kGB);
  value->append(buf);

-  // Compact
-  uint64_t compact_bytes_read = 0;
-  uint64_t compact_bytes_write = 0;
-  uint64_t compact_micros = 0;
-  for (int level = 0; level < number_levels_; level++) {
-    compact_bytes_read += comp_stats_[level].bytes_read_output_level +
-                          comp_stats_[level].bytes_read_non_output_levels;
-    compact_bytes_write += comp_stats_[level].bytes_written;
-    compact_micros += comp_stats_[level].micros;
-  }
-
-  snprintf(buf, sizeof(buf),
-           "Cumulative compaction: %.2f GB write, %.2f MB/s write, "
-           "%.2f GB read, %.2f MB/s read, %.1f seconds\n",
-           compact_bytes_write / kGB, compact_bytes_write / kMB / seconds_up,
-           compact_bytes_read / kGB, compact_bytes_read / kMB / seconds_up,
-           compact_micros / kMicrosInSec);
-  value->append(buf);
-
-  // Compaction interval
-  uint64_t interval_compact_bytes_write =
-      compact_bytes_write - cf_stats_snapshot_.compact_bytes_write;
-  uint64_t interval_compact_bytes_read =
-      compact_bytes_read - cf_stats_snapshot_.compact_bytes_read;
-  uint64_t interval_compact_micros =
-      compact_micros - cf_stats_snapshot_.compact_micros;
-
-  snprintf(
-      buf, sizeof(buf),
-      "Interval compaction: %.2f GB write, %.2f MB/s write, "
-      "%.2f GB read, %.2f MB/s read, %.1f seconds\n",
-      interval_compact_bytes_write / kGB,
-      interval_compact_bytes_write / kMB / std::max(interval_seconds_up, 0.001),
-      interval_compact_bytes_read / kGB,
-      interval_compact_bytes_read / kMB / std::max(interval_seconds_up, 0.001),
-      interval_compact_micros / kMicrosInSec);
-  value->append(buf);
-  cf_stats_snapshot_.compact_bytes_write = compact_bytes_write;
-  cf_stats_snapshot_.compact_bytes_read = compact_bytes_read;
-  cf_stats_snapshot_.compact_micros = compact_micros;
-
  snprintf(buf, sizeof(buf), "Stalls(count): %" PRIu64
                             " level0_slowdown, "
                             "%" PRIu64
@@ -246,20 +246,11 @@ class InternalStats {
    CompactionStats comp_stats;
    uint64_t ingest_bytes;            // Bytes written to L0
    uint64_t stall_count;             // Stall count
-    // Stats from compaction jobs - bytes written, bytes read, duration.
-    uint64_t compact_bytes_write;
-    uint64_t compact_bytes_read;
-    uint64_t compact_micros;
-    double seconds_up;

    CFStatsSnapshot()
        : comp_stats(0),
          ingest_bytes(0),
-          stall_count(0),
-          compact_bytes_write(0),
-          compact_bytes_read(0),
-          compact_micros(0),
-          seconds_up(0) {}
+          stall_count(0) {}
  } cf_stats_snapshot_;

  struct DBStatsSnapshot {
@@ -272,6 +263,10 @@ class InternalStats {
    // another thread.
    uint64_t write_other;
    uint64_t write_self;
+    // Stats from compaction jobs - bytes written, bytes read, duration.
+    uint64_t compact_bytes_write;
+    uint64_t compact_bytes_read;
+    uint64_t compact_micros;
    // Total number of keys written. write_self and write_other measure number
    // of write requests written, Each of the write request can contain updates
    // to multiple keys. num_keys_written is total number of keys updated by all
@@ -288,6 +283,9 @@ class InternalStats {
          write_with_wal(0),
          write_other(0),
          write_self(0),
+          compact_bytes_write(0),
+          compact_bytes_read(0),
+          compact_micros(0),
          num_keys_written(0),
          write_stall_micros(0),
          seconds_up(0) {}
@@ -296,7 +294,6 @@ class InternalStats {
  // Handler functions for getting property values. They use "value" as a value-
  // result argument, and return true upon successfully setting "value".
  bool HandleNumFilesAtLevel(std::string* value, Slice suffix);
-  bool HandleCompressionRatioAtLevelPrefix(std::string* value, Slice suffix);
  bool HandleLevelStats(std::string* value, Slice suffix);
  bool HandleStats(std::string* value, Slice suffix);
  bool HandleCFStats(std::string* value, Slice suffix);
@@ -484,10 +484,7 @@ TEST_F(EventListenerTest, CompactionReasonLevel) {
  listener->compaction_reasons_.clear();
  Reopen(options);

-  Put("key", "value");
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
  ASSERT_GT(listener->compaction_reasons_.size(), 0);
  for (auto compaction_reason : listener->compaction_reasons_) {
    ASSERT_EQ(compaction_reason, CompactionReason::kManualCompaction);
@@ -582,147 +579,6 @@ TEST_F(EventListenerTest, CompactionReasonFIFO) {
    ASSERT_EQ(compaction_reason, CompactionReason::kFIFOMaxSize);
  }
 }
-
-class TableFileCreationListener : public EventListener {
- public:
-  class TestEnv : public EnvWrapper {
-   public:
-    TestEnv() : EnvWrapper(Env::Default()) {}
-
-    void SetStatus(Status s) { status_ = s; }
-
-    Status NewWritableFile(const std::string& fname,
-                           std::unique_ptr<WritableFile>* result,
-                           const EnvOptions& options) {
-      if (fname.size() > 4 && fname.substr(fname.size() - 4) == ".sst") {
-        if (!status_.ok()) {
-          return status_;
-        }
-      }
-      return Env::Default()->NewWritableFile(fname, result, options);
-    }
-
-   private:
-    Status status_;
-  };
-
-  TableFileCreationListener() {
-    for (int i = 0; i < 2; i++) {
-      started_[i] = finished_[i] = failure_[i] = 0;
-    }
-  }
-
-  int Index(TableFileCreationReason reason) {
-    int idx;
-    switch (reason) {
-      case TableFileCreationReason::kFlush:
-        idx = 0;
-        break;
-      case TableFileCreationReason::kCompaction:
-        idx = 1;
-        break;
-      default:
-        idx = -1;
-    }
-    return idx;
-  }
-
-  void CheckAndResetCounters(int flush_started, int flush_finished,
-                             int flush_failure, int compaction_started,
-                             int compaction_finished, int compaction_failure) {
-    ASSERT_EQ(started_[0], flush_started);
-    ASSERT_EQ(finished_[0], flush_finished);
-    ASSERT_EQ(failure_[0], flush_failure);
-    ASSERT_EQ(started_[1], compaction_started);
-    ASSERT_EQ(finished_[1], compaction_finished);
-    ASSERT_EQ(failure_[1], compaction_failure);
-    for (int i = 0; i < 2; i++) {
-      started_[i] = finished_[i] = failure_[i] = 0;
-    }
-  }
-
-  void OnTableFileCreationStarted(
-      const TableFileCreationBriefInfo& info) override {
-    int idx = Index(info.reason);
-    if (idx >= 0) {
-      started_[idx]++;
-    }
-    ASSERT_GT(info.db_name.size(), 0U);
-    ASSERT_GT(info.cf_name.size(), 0U);
-    ASSERT_GT(info.file_path.size(), 0U);
-    ASSERT_GT(info.job_id, 0);
-  }
-
-  void OnTableFileCreated(const TableFileCreationInfo& info) override {
-    int idx = Index(info.reason);
-    if (idx >= 0) {
-      finished_[idx]++;
-    }
-    ASSERT_GT(info.db_name.size(), 0U);
-    ASSERT_GT(info.cf_name.size(), 0U);
-    ASSERT_GT(info.file_path.size(), 0U);
-    ASSERT_GT(info.job_id, 0);
-    if (info.status.ok()) {
-      ASSERT_GT(info.table_properties.data_size, 0U);
-      ASSERT_GT(info.table_properties.raw_key_size, 0U);
-      ASSERT_GT(info.table_properties.raw_value_size, 0U);
-      ASSERT_GT(info.table_properties.num_data_blocks, 0U);
-      ASSERT_GT(info.table_properties.num_entries, 0U);
-    } else {
-      if (idx >= 0) {
-        failure_[idx]++;
-      }
-    }
-  }
-
-  TestEnv test_env;
-  int started_[2];
-  int finished_[2];
-  int failure_[2];
-};
-
-TEST_F(EventListenerTest, TableFileCreationListenersTest) {
-  auto listener = std::make_shared<TableFileCreationListener>();
-  Options options;
-  options.create_if_missing = true;
-  options.listeners.push_back(listener);
-  options.env = &listener->test_env;
-  DestroyAndReopen(options);
-
-  ASSERT_OK(Put("foo", "aaa"));
-  ASSERT_OK(Put("bar", "bbb"));
-  ASSERT_OK(Flush());
-  dbfull()->TEST_WaitForFlushMemTable();
-  listener->CheckAndResetCounters(1, 1, 0, 0, 0, 0);
-
-  ASSERT_OK(Put("foo", "aaa1"));
-  ASSERT_OK(Put("bar", "bbb1"));
-  listener->test_env.SetStatus(Status::NotSupported("not supported"));
-  ASSERT_NOK(Flush());
-  listener->CheckAndResetCounters(1, 1, 1, 0, 0, 0);
-  listener->test_env.SetStatus(Status::OK());
-
-  Reopen(options);
-  ASSERT_OK(Put("foo", "aaa2"));
-  ASSERT_OK(Put("bar", "bbb2"));
-  ASSERT_OK(Flush());
-  dbfull()->TEST_WaitForFlushMemTable();
-  listener->CheckAndResetCounters(1, 1, 0, 0, 0, 0);
-
-  const Slice kRangeStart = "a";
-  const Slice kRangeEnd = "z";
-  dbfull()->CompactRange(CompactRangeOptions(), &kRangeStart, &kRangeEnd);
-  dbfull()->TEST_WaitForCompact();
-  listener->CheckAndResetCounters(0, 0, 0, 1, 1, 0);
-
-  ASSERT_OK(Put("foo", "aaa3"));
-  ASSERT_OK(Put("bar", "bbb3"));
-  ASSERT_OK(Flush());
-  listener->test_env.SetStatus(Status::NotSupported("not supported"));
-  dbfull()->CompactRange(CompactRangeOptions(), &kRangeStart, &kRangeEnd);
-  dbfull()->TEST_WaitForCompact();
-  listener->CheckAndResetCounters(1, 1, 0, 1, 1, 1);
-}
 }  // namespace rocksdb

 #endif  // ROCKSDB_LITE
@@ -79,7 +79,7 @@ ManagedIterator::ManagedIterator(DBImpl* db, const ReadOptions& read_options,
      release_supported_(true) {
  read_options_.managed = false;
  if ((!read_options_.tailing) && (read_options_.snapshot == nullptr)) {
-    assert(nullptr != (read_options_.snapshot = db_->GetSnapshot()));
+    assert(read_options_.snapshot = db_->GetSnapshot());
    snapshot_created_ = true;
  }
  cfh_.SetCFD(cfd);
@@ -210,8 +210,7 @@ void ManagedIterator::RebuildIterator() {
 void ManagedIterator::UpdateCurrent() {
  assert(mutable_iter_ != nullptr);

-  valid_ = mutable_iter_->Valid();
-  if (!valid_) {
+  if (!(valid_ = mutable_iter_->Valid())) {
    status_ = mutable_iter_->status();
    return;
  }
@@ -15,7 +15,6 @@

 #include "db/dbformat.h"
 #include "db/merge_context.h"
-#include "db/pinned_iterators_manager.h"
 #include "db/writebuffer.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/env.h"
@@ -232,12 +231,6 @@ class MemTableIterator : public InternalIterator {
  }

  ~MemTableIterator() {
-#ifndef NDEBUG
-    // Assert that the MemTableIterator is never deleted while
-    // Pinning is Enabled.
-    assert(!pinned_iters_mgr_ ||
-           (pinned_iters_mgr_ && !pinned_iters_mgr_->PinningEnabled()));
-#endif
    if (arena_mode_) {
      iter_->~Iterator();
    } else {
@@ -245,14 +238,6 @@ class MemTableIterator : public InternalIterator {
    }
  }

-#ifndef NDEBUG
-  virtual void SetPinnedItersMgr(
-      PinnedIteratorsManager* pinned_iters_mgr) override {
-    pinned_iters_mgr_ = pinned_iters_mgr;
-  }
-  PinnedIteratorsManager* pinned_iters_mgr_ = nullptr;
-#endif
-
  virtual bool Valid() const override { return valid_; }
  virtual void Seek(const Slice& k) override {
    PERF_TIMER_GUARD(seek_on_memtable_time);
@@ -300,6 +285,16 @@ class MemTableIterator : public InternalIterator {

  virtual Status status() const override { return Status::OK(); }

+  virtual Status PinData() override {
+    // memtable data is always pinned
+    return Status::OK();
+  }
+
+  virtual Status ReleasePinnedData() override {
+    // memtable data is always pinned
+    return Status::OK();
+  }
+
  virtual bool IsKeyPinned() const override {
    // memtable data is always pinned
    return true;
@@ -345,8 +345,8 @@ Status MemTableList::InstallMemtableFlushResults(
        imm_flush_needed.store(true, std::memory_order_release);
      }
      ++mem_id;
-    } while (!current_->memlist_.empty() && (nullptr != (m = current_->memlist_.back())) &&
-             (m->file_number_ == file_number));
+    } while (!current_->memlist_.empty() && (m = current_->memlist_.back()) &&
+             m->file_number_ == file_number);
  }
  commit_in_progress_ = false;
  return s;
@@ -37,11 +37,6 @@ public:
    Initialize();
    operand_list->push_front(operand_slice.ToString());
  }
-  // Push back a merge operand
-  void PushOperandBack(const Slice& operand_slice) {
-    Initialize();
-    operand_list->push_back(operand_slice.ToString());
-  }
  // return total number of operands in the list
  size_t GetNumOperands() const {
    if (!operand_list) {
@@ -9,16 +9,16 @@
 #include <vector>

 #include "rocksdb/db.h"
-#include "rocksdb/memtablerep.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/slice_transform.h"
+#include "rocksdb/memtablerep.h"
 #include "util/histogram.h"
 #include "util/instrumented_mutex.h"
 #include "util/stop_watch.h"
-#include "util/string_util.h"
 #include "util/testharness.h"
 #include "util/thread_status_util.h"
-#include "utilities/merge_operators.h"
+#include "util/string_util.h"
+

 bool FLAGS_random_key = false;
 bool FLAGS_use_set_based_memetable = false;
@@ -37,7 +37,6 @@ std::shared_ptr<DB> OpenDb(bool read_only = false) {
    DB* db;
    Options options;
    options.create_if_missing = true;
-    options.max_open_files = -1;
    options.write_buffer_size = FLAGS_write_buffer_size;
    options.max_write_buffer_number = FLAGS_max_write_buffer_number;
    options.min_write_buffer_number_to_merge =
@@ -280,19 +279,14 @@ void ProfileQueries(bool enabled_time = false) {
 #endif

  for (const int i : keys) {
-    if (i == kFlushFlag) {
-      continue;
-    }
    std::string key = "k" + ToString(i);
-    std::string expected_value = "v" + ToString(i);
-    std::string value;
+    std::string value = "v" + ToString(i);

    std::vector<Slice> multiget_keys = {Slice(key)};
    std::vector<std::string> values;

    perf_context.Reset();
-    ASSERT_OK(db->Get(read_options, key, &value));
-    ASSERT_EQ(expected_value, value);
+    db->Get(read_options, key, &value);
    hist_get_snapshot.Add(perf_context.get_snapshot_time);
    hist_get_memtable.Add(perf_context.get_from_memtable_time);
    hist_get_files.Add(perf_context.get_from_output_files_time);
@@ -381,19 +375,14 @@ void ProfileQueries(bool enabled_time = false) {
  hist_mget_num_memtable_checked.Clear();

  for (const int i : keys) {
-    if (i == kFlushFlag) {
-      continue;
-    }
    std::string key = "k" + ToString(i);
-    std::string expected_value = "v" + ToString(i);
-    std::string value;
+    std::string value = "v" + ToString(i);

    std::vector<Slice> multiget_keys = {Slice(key)};
    std::vector<std::string> values;

    perf_context.Reset();
-    ASSERT_OK(db->Get(read_options, key, &value));
-    ASSERT_EQ(expected_value, value);
+    db->Get(read_options, key, &value);
    hist_get_snapshot.Add(perf_context.get_snapshot_time);
    hist_get_memtable.Add(perf_context.get_from_memtable_time);
    hist_get_files.Add(perf_context.get_from_output_files_time);
@@ -613,41 +602,6 @@ TEST_F(PerfContextTest, ToString) {
  ASSERT_EQ(std::string::npos, zero_excluded.find("= 0"));
  ASSERT_NE(std::string::npos, zero_excluded.find("= 12345"));
 }
-
-TEST_F(PerfContextTest, MergeOperatorTime) {
-  DestroyDB(kDbName, Options());
-  DB* db;
-  Options options;
-  options.create_if_missing = true;
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  Status s = DB::Open(options, kDbName, &db);
-  EXPECT_OK(s);
-
-  std::string val;
-  ASSERT_OK(db->Merge(WriteOptions(), "k1", "val1"));
-  ASSERT_OK(db->Merge(WriteOptions(), "k1", "val2"));
-  ASSERT_OK(db->Merge(WriteOptions(), "k1", "val3"));
-  ASSERT_OK(db->Merge(WriteOptions(), "k1", "val4"));
-
-  SetPerfLevel(kEnableTime);
-  perf_context.Reset();
-  ASSERT_OK(db->Get(ReadOptions(), "k1", &val));
-  EXPECT_GT(perf_context.merge_operator_time_nanos, 0);
-
-  ASSERT_OK(db->Flush(FlushOptions()));
-
-  perf_context.Reset();
-  ASSERT_OK(db->Get(ReadOptions(), "k1", &val));
-  EXPECT_GT(perf_context.merge_operator_time_nanos, 0);
-
-  ASSERT_OK(db->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  perf_context.Reset();
-  ASSERT_OK(db->Get(ReadOptions(), "k1", &val));
-  EXPECT_GT(perf_context.merge_operator_time_nanos, 0);
-
-  delete db;
-}
 }

 int main(int argc, char** argv) {
@@ -1,66 +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.
-//
-#pragma once
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include "table/internal_iterator.h"
-
-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:
-  PinnedIteratorsManager() : pinning_enabled(false), pinned_iters_(nullptr) {}
-  ~PinnedIteratorsManager() { assert(!pinning_enabled); }
-
-  // Enable Iterators pinning
-  void StartPinning() {
-    if (!pinning_enabled) {
-      pinning_enabled = true;
-      if (!pinned_iters_) {
-        pinned_iters_.reset(new std::vector<InternalIterator*>());
-      }
-    }
-  }
-
-  // Is pinning enabled ?
-  bool PinningEnabled() { return pinning_enabled; }
-
-  // Take ownership of iter if pinning is enabled and delete it when
-  // ReleasePinnedIterators() is called
-  void PinIteratorIfNeeded(InternalIterator* iter) {
-    if (!pinning_enabled || !iter) {
-      return;
-    }
-    pinned_iters_->push_back(iter);
-  }
-
-  // Release pinned Iterators
-  void ReleasePinnedIterators() {
-    if (pinning_enabled) {
-      pinning_enabled = false;
-
-      // Remove duplicate pointers
-      std::sort(pinned_iters_->begin(), pinned_iters_->end());
-      std::unique(pinned_iters_->begin(), pinned_iters_->end());
-
-      for (auto& iter : *pinned_iters_) {
-        delete iter;
-      }
-      pinned_iters_->clear();
-    }
-  }
-
- private:
-  bool pinning_enabled;
-  std::unique_ptr<std::vector<InternalIterator*>> pinned_iters_;
-};
-
-}  // namespace rocksdb
@@ -263,9 +263,7 @@ class TestPlainTableReader : public PlainTableReader {
                       const TableProperties* table_properties,
                       unique_ptr<RandomAccessFileReader>&& file,
                       const ImmutableCFOptions& ioptions,
-                       bool* expect_bloom_not_match, bool store_index_in_file,
-                       uint32_t column_family_id,
-                       const std::string& column_family_name)
+                       bool* expect_bloom_not_match, bool store_index_in_file)
      : PlainTableReader(ioptions, std::move(file), env_options, icomparator,
                         encoding_type, file_size, table_properties),
        expect_bloom_not_match_(expect_bloom_not_match) {
@@ -278,8 +276,6 @@ class TestPlainTableReader : public PlainTableReader {
    EXPECT_TRUE(s.ok());

    TableProperties* props = const_cast<TableProperties*>(table_properties);
-    EXPECT_EQ(column_family_id, static_cast<uint32_t>(props->column_family_id));
-    EXPECT_EQ(column_family_name, props->column_family_name);
    if (store_index_in_file) {
      auto bloom_version_ptr = props->user_collected_properties.find(
          PlainTablePropertyNames::kBloomVersion);
@@ -312,17 +308,13 @@ extern const uint64_t kPlainTableMagicNumber;
 class TestPlainTableFactory : public PlainTableFactory {
 public:
  explicit TestPlainTableFactory(bool* expect_bloom_not_match,
-                                 const PlainTableOptions& options,
-                                 uint32_t column_family_id,
-                                 std::string column_family_name)
+                                 const PlainTableOptions& options)
      : PlainTableFactory(options),
        bloom_bits_per_key_(options.bloom_bits_per_key),
        hash_table_ratio_(options.hash_table_ratio),
        index_sparseness_(options.index_sparseness),
        store_index_in_file_(options.store_index_in_file),
-        expect_bloom_not_match_(expect_bloom_not_match),
-        column_family_id_(column_family_id),
-        column_family_name_(std::move(column_family_name)) {}
+        expect_bloom_not_match_(expect_bloom_not_match) {}

  Status NewTableReader(const TableReaderOptions& table_reader_options,
                        unique_ptr<RandomAccessFileReader>&& file,
@@ -362,7 +354,7 @@ class TestPlainTableFactory : public PlainTableFactory {
        table_reader_options.internal_comparator, encoding_type, file_size,
        bloom_bits_per_key_, hash_table_ratio_, index_sparseness_, props,
        std::move(file), table_reader_options.ioptions, expect_bloom_not_match_,
-        store_index_in_file_, column_family_id_, column_family_name_));
+        store_index_in_file_));

    *table = std::move(new_reader);
    return s;
@@ -374,8 +366,6 @@ class TestPlainTableFactory : public PlainTableFactory {
  size_t index_sparseness_;
  bool store_index_in_file_;
  bool* expect_bloom_not_match_;
-  const uint32_t column_family_id_;
-  const std::string column_family_name_;
 };

 TEST_P(PlainTableDBTest, Flush) {
@@ -502,8 +492,7 @@ TEST_P(PlainTableDBTest, Flush2) {
        plain_table_options.encoding_type = encoding_type;
        plain_table_options.store_index_in_file = store_index_in_file;
        options.table_factory.reset(new TestPlainTableFactory(
-            &expect_bloom_not_match, plain_table_options,
-            0 /* column_family_id */, kDefaultColumnFamilyName));
+            &expect_bloom_not_match, plain_table_options));

        DestroyAndReopen(&options);
        ASSERT_OK(Put("0000000000000bar", "b"));
@@ -572,8 +561,7 @@ TEST_P(PlainTableDBTest, Iterator) {
          plain_table_options.encoding_type = encoding_type;

          options.table_factory.reset(new TestPlainTableFactory(
-              &expect_bloom_not_match, plain_table_options,
-              0 /* column_family_id */, kDefaultColumnFamilyName));
+              &expect_bloom_not_match, plain_table_options));
        } else {
          PlainTableOptions plain_table_options;
          plain_table_options.user_key_len = 16;
@@ -584,8 +572,7 @@ TEST_P(PlainTableDBTest, Iterator) {
          plain_table_options.encoding_type = encoding_type;

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

@@ -446,10 +446,6 @@ TEST_F(PrefixTest, PrefixValid) {
      iter->Next();
      ASSERT_FALSE(iter->Valid());
      ASSERT_EQ(kNotFoundResult, Get(db.get(), read_options, 12346, 8));
-
-      // Verify seeking past the prefix won't return a result.
-      SeekIterator(iter.get(), 12345, 10);
-      ASSERT_TRUE(!iter->Valid());
    }
  }
 }
@@ -265,7 +265,7 @@ class Repairer {
    mem->Ref();
    int counter = 0;
    while (reader.ReadRecord(&record, &scratch)) {
-      if (record.size() < WriteBatchInternal::kHeader) {
+      if (record.size() < 12) {
        reporter.Corruption(
            record.size(), Status::Corruption("log record too small"));
        continue;
@@ -294,10 +294,9 @@ class Repairer {
      status = BuildTable(
          dbname_, env_, ioptions_, env_options_, table_cache_, iter.get(),
          &meta, icmp_, &int_tbl_prop_collector_factories_,
-          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,
-          std::string() /* column_family_name */, {}, kMaxSequenceNumber,
-          kNoCompression, CompressionOptions(), false,
-          nullptr /* internal_stats */, TableFileCreationReason::kRecovery);
+          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily, {},
+          kMaxSequenceNumber, kNoCompression, CompressionOptions(), false,
+          nullptr);
    }
    delete mem->Unref();
    delete cf_mems_default;
@@ -1,177 +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 <string>
-#include <vector>
-
-#include "db/db_impl.h"
-#include "db/db_test_util.h"
-#include "rocksdb/db.h"
-#include "rocksdb/transaction_log.h"
-#include "util/file_util.h"
-
-namespace rocksdb {
-
-class RepairTest : public DBTestBase {
- public:
-  RepairTest() : DBTestBase("/repair_test") {}
-
-  std::string GetFirstSstPath() {
-    uint64_t manifest_size;
-    std::vector<std::string> files;
-    db_->GetLiveFiles(files, &manifest_size);
-    auto sst_iter =
-        std::find_if(files.begin(), files.end(), [](const std::string& file) {
-          uint64_t number;
-          FileType type;
-          bool ok = ParseFileName(file, &number, &type);
-          return ok && type == kTableFile;
-        });
-    return sst_iter == files.end() ? "" : dbname_ + *sst_iter;
-  }
-};
-
-TEST_F(RepairTest, LostManifest) {
-  // Add a couple SST files, delete the manifest, and verify RepairDB() saves
-  // the day.
-  Put("key", "val");
-  Flush();
-  Put("key2", "val2");
-  Flush();
-  // Need to get path before Close() deletes db_, but delete it after Close() to
-  // ensure Close() didn't change the manifest.
-  std::string manifest_path =
-      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
-
-  Close();
-  ASSERT_OK(env_->FileExists(manifest_path));
-  ASSERT_OK(env_->DeleteFile(manifest_path));
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  ASSERT_EQ(Get("key"), "val");
-  ASSERT_EQ(Get("key2"), "val2");
-}
-
-TEST_F(RepairTest, CorruptManifest) {
-  // Manifest is in an invalid format. Expect a full recovery.
-  Put("key", "val");
-  Flush();
-  Put("key2", "val2");
-  Flush();
-  // Need to get path before Close() deletes db_, but overwrite it after Close()
-  // to ensure Close() didn't change the manifest.
-  std::string manifest_path =
-      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
-
-  Close();
-  ASSERT_OK(env_->FileExists(manifest_path));
-  CreateFile(env_, manifest_path, "blah");
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  ASSERT_EQ(Get("key"), "val");
-  ASSERT_EQ(Get("key2"), "val2");
-}
-
-TEST_F(RepairTest, IncompleteManifest) {
-  // In this case, the manifest is valid but does not reference all of the SST
-  // files. Expect a full recovery.
-  Put("key", "val");
-  Flush();
-  std::string orig_manifest_path =
-      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
-  CopyFile(orig_manifest_path, orig_manifest_path + ".tmp");
-  Put("key2", "val2");
-  Flush();
-  // Need to get path before Close() deletes db_, but overwrite it after Close()
-  // to ensure Close() didn't change the manifest.
-  std::string new_manifest_path =
-      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
-
-  Close();
-  ASSERT_OK(env_->FileExists(new_manifest_path));
-  // Replace the manifest with one that is only aware of the first SST file.
-  CopyFile(orig_manifest_path + ".tmp", new_manifest_path);
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  ASSERT_EQ(Get("key"), "val");
-  ASSERT_EQ(Get("key2"), "val2");
-}
-
-TEST_F(RepairTest, LostSst) {
-  // Delete one of the SST files but preserve the manifest that refers to it,
-  // then verify the DB is still usable for the intact SST.
-  Put("key", "val");
-  Flush();
-  Put("key2", "val2");
-  Flush();
-  auto sst_path = GetFirstSstPath();
-  ASSERT_FALSE(sst_path.empty());
-  ASSERT_OK(env_->DeleteFile(sst_path));
-
-  Close();
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  // Exactly one of the key-value pairs should be in the DB now.
-  ASSERT_TRUE((Get("key") == "val") != (Get("key2") == "val2"));
-}
-
-TEST_F(RepairTest, CorruptSst) {
-  // Corrupt one of the SST files but preserve the manifest that refers to it,
-  // then verify the DB is still usable for the intact SST.
-  Put("key", "val");
-  Flush();
-  Put("key2", "val2");
-  Flush();
-  auto sst_path = GetFirstSstPath();
-  ASSERT_FALSE(sst_path.empty());
-  CreateFile(env_, sst_path, "blah");
-
-  Close();
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  // Exactly one of the key-value pairs should be in the DB now.
-  ASSERT_TRUE((Get("key") == "val") != (Get("key2") == "val2"));
-}
-
-TEST_F(RepairTest, UnflushedSst) {
-  // This test case invokes repair while some data is unflushed, then verifies
-  // that data is in the db.
-  Put("key", "val");
-  VectorLogPtr wal_files;
-  ASSERT_OK(dbfull()->GetSortedWalFiles(wal_files));
-  ASSERT_EQ(wal_files.size(), 1);
-  uint64_t total_ssts_size;
-  GetAllSSTFiles(&total_ssts_size);
-  ASSERT_EQ(total_ssts_size, 0);
-  // Need to get path before Close() deletes db_, but delete it after Close() to
-  // ensure Close() didn't change the manifest.
-  std::string manifest_path =
-      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
-
-  Close();
-  ASSERT_OK(env_->FileExists(manifest_path));
-  ASSERT_OK(env_->DeleteFile(manifest_path));
-  RepairDB(dbname_, CurrentOptions());
-  Reopen(CurrentOptions());
-
-  ASSERT_OK(dbfull()->GetSortedWalFiles(wal_files));
-  ASSERT_EQ(wal_files.size(), 0);
-  GetAllSSTFiles(&total_ssts_size);
-  ASSERT_GT(total_ssts_size, 0);
-  ASSERT_EQ(Get("key"), "val");
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -87,16 +87,15 @@ void TableCache::ReleaseHandle(Cache::Handle* handle) {
 Status TableCache::GetTableReader(
    const EnvOptions& env_options,
    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
-    bool sequential_mode, size_t readahead, bool record_read_stats,
-    HistogramImpl* file_read_hist, unique_ptr<TableReader>* table_reader,
-    bool skip_filters, int level) {
+    bool sequential_mode, bool record_read_stats, HistogramImpl* file_read_hist,
+    unique_ptr<TableReader>* table_reader, bool skip_filters) {
  std::string fname =
      TableFileName(ioptions_.db_paths, fd.GetNumber(), fd.GetPathId());
  unique_ptr<RandomAccessFile> file;
  Status s = ioptions_.env->NewRandomAccessFile(fname, &file, env_options);
-
-  if (readahead > 0) {
-    file = NewReadaheadRandomAccessFile(std::move(file), readahead);
+  if (sequential_mode && ioptions_.compaction_readahead_size > 0) {
+    file = NewReadaheadRandomAccessFile(std::move(file),
+                                        ioptions_.compaction_readahead_size);
  }
  RecordTick(ioptions_.statistics, NO_FILE_OPENS);
  if (s.ok()) {
@@ -110,26 +109,18 @@ Status TableCache::GetTableReader(
                                   file_read_hist));
    s = ioptions_.table_factory->NewTableReader(
        TableReaderOptions(ioptions_, env_options, internal_comparator,
-                           skip_filters, level),
+                           skip_filters),
        std::move(file_reader), fd.GetFileSize(), table_reader);
    TEST_SYNC_POINT("TableCache::GetTableReader:0");
  }
  return s;
 }

-void TableCache::EraseHandle(const FileDescriptor& fd, Cache::Handle* handle) {
-  ReleaseHandle(handle);
-  uint64_t number = fd.GetNumber();
-  Slice key = GetSliceForFileNumber(&number);
-  cache_->Erase(key);
-}
-
 Status TableCache::FindTable(const EnvOptions& env_options,
                             const InternalKeyComparator& internal_comparator,
                             const FileDescriptor& fd, Cache::Handle** handle,
                             const bool no_io, bool record_read_stats,
-                             HistogramImpl* file_read_hist, bool skip_filters,
-                             int level) {
+                             HistogramImpl* file_read_hist, bool skip_filters) {
  PERF_TIMER_GUARD(find_table_nanos);
  Status s;
  uint64_t number = fd.GetNumber();
@@ -144,9 +135,8 @@ Status TableCache::FindTable(const EnvOptions& env_options,
    }
    unique_ptr<TableReader> table_reader;
    s = GetTableReader(env_options, internal_comparator, fd,
-                       false /* sequential mode */, 0 /* readahead */,
-                       record_read_stats, file_read_hist, &table_reader,
-                       skip_filters, level);
+                       false /* sequential mode */, record_read_stats,
+                       file_read_hist, &table_reader, skip_filters);
    if (!s.ok()) {
      assert(table_reader == nullptr);
      RecordTick(ioptions_.statistics, NO_FILE_ERRORS);
@@ -168,7 +158,7 @@ InternalIterator* TableCache::NewIterator(
    const ReadOptions& options, const EnvOptions& env_options,
    const InternalKeyComparator& icomparator, const FileDescriptor& fd,
    TableReader** table_reader_ptr, HistogramImpl* file_read_hist,
-    bool for_compaction, Arena* arena, bool skip_filters, int level) {
+    bool for_compaction, Arena* arena, bool skip_filters) {
  PERF_TIMER_GUARD(new_table_iterator_nanos);

  if (table_reader_ptr != nullptr) {
@@ -177,25 +167,13 @@ InternalIterator* TableCache::NewIterator(

  TableReader* table_reader = nullptr;
  Cache::Handle* handle = nullptr;
-
-  size_t readahead = 0;
-  bool create_new_table_reader = false;
-  if (for_compaction) {
-    if (ioptions_.new_table_reader_for_compaction_inputs) {
-      readahead = ioptions_.compaction_readahead_size;
-      create_new_table_reader = true;
-    }
-  } else {
-    readahead = options.readahead_size;
-    create_new_table_reader = readahead > 0;
-  }
-
+  bool create_new_table_reader =
+      (for_compaction && ioptions_.new_table_reader_for_compaction_inputs);
  if (create_new_table_reader) {
    unique_ptr<TableReader> table_reader_unique_ptr;
    Status s = GetTableReader(
-        env_options, icomparator, fd, true /* sequential_mode */, readahead,
-        !for_compaction /* record stats */, nullptr, &table_reader_unique_ptr,
-        false /* skip_filters */, level);
+        env_options, icomparator, fd, /* sequential mode */ true,
+        /* record stats */ false, nullptr, &table_reader_unique_ptr);
    if (!s.ok()) {
      return NewErrorInternalIterator(s, arena);
    }
@@ -206,7 +184,7 @@ InternalIterator* TableCache::NewIterator(
      Status s = FindTable(env_options, icomparator, fd, &handle,
                           options.read_tier == kBlockCacheTier /* no_io */,
                           !for_compaction /* record read_stats */,
-                           file_read_hist, skip_filters, level);
+                           file_read_hist, skip_filters);
      if (!s.ok()) {
        return NewErrorInternalIterator(s, arena);
      }
@@ -238,7 +216,7 @@ Status TableCache::Get(const ReadOptions& options,
                       const InternalKeyComparator& internal_comparator,
                       const FileDescriptor& fd, const Slice& k,
                       GetContext* get_context, HistogramImpl* file_read_hist,
-                       bool skip_filters, int level) {
+                       bool skip_filters) {
  TableReader* t = fd.table_reader;
  Status s;
  Cache::Handle* handle = nullptr;
@@ -287,8 +265,7 @@ Status TableCache::Get(const ReadOptions& options,
  if (!t) {
    s = FindTable(env_options_, internal_comparator, fd, &handle,
                  options.read_tier == kBlockCacheTier /* no_io */,
-                  true /* record_read_stats */, file_read_hist, skip_filters,
-                  level);
+                  true /* record_read_stats */, file_read_hist, skip_filters);
    if (s.ok()) {
      t = GetTableReaderFromHandle(handle);
    }
@@ -45,41 +45,34 @@ class TableCache {
  // the cache and should not be deleted, and is valid for as long as the
  // returned iterator is live.
  // @param skip_filters Disables loading/accessing the filter block
-  // @param level The level this table is at, -1 for "not set / don't know"
  InternalIterator* NewIterator(
      const ReadOptions& options, const EnvOptions& toptions,
      const InternalKeyComparator& internal_comparator,
      const FileDescriptor& file_fd, TableReader** table_reader_ptr = nullptr,
      HistogramImpl* file_read_hist = nullptr, bool for_compaction = false,
-      Arena* arena = nullptr, bool skip_filters = false, int level = -1);
+      Arena* arena = nullptr, bool skip_filters = false);

  // If a seek to internal key "k" in specified file finds an entry,
  // call (*handle_result)(arg, found_key, found_value) repeatedly until
  // it returns false.
  // @param skip_filters Disables loading/accessing the filter block
-  // @param level The level this table is at, -1 for "not set / don't know"
  Status Get(const ReadOptions& options,
             const InternalKeyComparator& internal_comparator,
             const FileDescriptor& file_fd, const Slice& k,
             GetContext* get_context, HistogramImpl* file_read_hist = nullptr,
-             bool skip_filters = false, int level = -1);
+             bool skip_filters = false);

  // Evict any entry for the specified file number
  static void Evict(Cache* cache, uint64_t file_number);

-  // Clean table handle and erase it from the table cache
-  // Used in DB close, or the file is not live anymore.
-  void EraseHandle(const FileDescriptor& fd, Cache::Handle* handle);
-
  // Find table reader
  // @param skip_filters Disables loading/accessing the filter block
-  // @param level == -1 means not specified
  Status FindTable(const EnvOptions& toptions,
                   const InternalKeyComparator& internal_comparator,
                   const FileDescriptor& file_fd, Cache::Handle**,
                   const bool no_io = false, bool record_read_stats = true,
                   HistogramImpl* file_read_hist = nullptr,
-                   bool skip_filters = false, int level = -1);
+                   bool skip_filters = false);

  // Get TableReader from a cache handle.
  TableReader* GetTableReaderFromHandle(Cache::Handle* handle);
@@ -111,10 +104,9 @@ class TableCache {
  Status GetTableReader(const EnvOptions& env_options,
                        const InternalKeyComparator& internal_comparator,
                        const FileDescriptor& fd, bool sequential_mode,
-                        size_t readahead, bool record_read_stats,
-                        HistogramImpl* file_read_hist,
+                        bool record_read_stats, HistogramImpl* file_read_hist,
                        unique_ptr<TableReader>* table_reader,
-                        bool skip_filters = false, int level = -1);
+                        bool skip_filters = false);

  const ImmutableCFOptions& ioptions_;
  const EnvOptions& env_options_;
@@ -36,7 +36,6 @@ class TablePropertiesTest : public testing::Test,
 // Utilities test functions
 namespace {
 static const uint32_t kTestColumnFamilyId = 66;
-static const std::string kTestColumnFamilyName = "test_column_fam";

 void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions,
                 const InternalKeyComparator& internal_comparator,
@@ -49,8 +48,8 @@ void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions,

  builder->reset(NewTableBuilder(
      ioptions, internal_comparator, int_tbl_prop_collector_factories,
-      kTestColumnFamilyId, kTestColumnFamilyName,
-      writable->get(), options.compression, options.compression_opts));
+      kTestColumnFamilyId /* column_family_id */, writable->get(),
+      options.compression, options.compression_opts));
 }
 }  // namespace

@@ -107,7 +107,7 @@ void TransactionLogIteratorImpl::SeekToStartSequence(
    return;
  }
  while (RestrictedRead(&record, &scratch)) {
-    if (record.size() < WriteBatchInternal::kHeader) {
+    if (record.size() < 12) {
      reporter_.Corruption(
        record.size(), Status::Corruption("very small log record"));
      continue;
@@ -167,7 +167,7 @@ void TransactionLogIteratorImpl::NextImpl(bool internal) {
      currentLogReader_->UnmarkEOF();
    }
    while (RestrictedRead(&record, &scratch)) {
-      if (record.size() < WriteBatchInternal::kHeader) {
+      if (record.size() < 12) {
        reporter_.Corruption(
          record.size(), Status::Corruption("very small log record"));
        continue;
@@ -309,11 +309,11 @@ class VersionBuilder::Rep {

        auto* file_meta = files_meta[file_idx].first;
        int level = files_meta[file_idx].second;
-        table_cache_->FindTable(
-            env_options_, *(base_vstorage_->InternalComparator()),
-            file_meta->fd, &file_meta->table_reader_handle, false /*no_io */,
-            true /* record_read_stats */,
-            internal_stats->GetFileReadHist(level), false, level);
+        table_cache_->FindTable(env_options_,
+                                *(base_vstorage_->InternalComparator()),
+                                file_meta->fd, &file_meta->table_reader_handle,
+                                false /*no_io */, true /* record_read_stats */,
+                                internal_stats->GetFileReadHist(level));
        if (file_meta->table_reader_handle != nullptr) {
          // Load table_reader
          file_meta->fd.table_reader = table_cache_->GetTableReaderFromHandle(
@@ -23,7 +23,6 @@
 #include <vector>
 #include <string>

-#include "db/compaction.h"
 #include "db/filename.h"
 #include "db/internal_stats.h"
 #include "db/log_reader.h"
@@ -31,22 +30,22 @@
 #include "db/memtable.h"
 #include "db/merge_context.h"
 #include "db/table_cache.h"
+#include "db/compaction.h"
 #include "db/version_builder.h"
 #include "db/writebuffer.h"
 #include "rocksdb/env.h"
 #include "rocksdb/merge_operator.h"
-#include "table/format.h"
-#include "table/get_context.h"
 #include "table/internal_iterator.h"
-#include "table/merger.h"
-#include "table/meta_blocks.h"
-#include "table/plain_table_factory.h"
 #include "table/table_reader.h"
+#include "table/merger.h"
 #include "table/two_level_iterator.h"
+#include "table/format.h"
+#include "table/plain_table_factory.h"
+#include "table/meta_blocks.h"
+#include "table/get_context.h"
 #include "util/coding.h"
 #include "util/file_reader_writer.h"
 #include "util/logging.h"
-#include "util/perf_context_imp.h"
 #include "util/stop_watch.h"
 #include "util/sync_point.h"

@@ -91,9 +90,8 @@ class FilePicker {
             const Comparator* user_comparator,
             const InternalKeyComparator* internal_comparator)
      : num_levels_(num_levels),
-        curr_level_(static_cast<unsigned int>(-1)),
-        returned_file_level_(static_cast<unsigned int>(-1)),
-        hit_file_level_(static_cast<unsigned int>(-1)),
+        curr_level_(-1),
+        hit_file_level_(-1),
        search_left_bound_(0),
        search_right_bound_(FileIndexer::kLevelMaxIndex),
 #ifndef NDEBUG
@@ -119,8 +117,6 @@ class FilePicker {
    }
  }

-  int GetCurrentLevel() { return returned_file_level_; }
-
  FdWithKeyRange* GetNextFile() {
    while (!search_ended_) {  // Loops over different levels.
      while (curr_index_in_curr_level_ < curr_file_level_->num_files) {
@@ -193,7 +189,6 @@ class FilePicker {
        }
        prev_file_ = f;
 #endif
-        returned_file_level_ = curr_level_;
        if (curr_level_ > 0 && cmp_largest < 0) {
          // No more files to search in this level.
          search_ended_ = !PrepareNextLevel();
@@ -220,7 +215,6 @@ class FilePicker {
 private:
  unsigned int num_levels_;
  unsigned int curr_level_;
-  unsigned int returned_file_level_;
  unsigned int hit_file_level_;
  int32_t search_left_bound_;
  int32_t search_right_bound_;
@@ -327,7 +321,7 @@ Version::~Version() {
      f->refs--;
      if (f->refs <= 0) {
        if (f->table_reader_handle) {
-          cfd_->table_cache()->EraseHandle(f->fd, f->table_reader_handle);
+          cfd_->table_cache()->ReleaseHandle(f->table_reader_handle);
          f->table_reader_handle = nullptr;
        }
        vset_->obsolete_files_.push_back(f);
@@ -491,7 +485,7 @@ class LevelFileIteratorState : public TwoLevelIteratorState {
                         const EnvOptions& env_options,
                         const InternalKeyComparator& icomparator,
                         HistogramImpl* file_read_hist, bool for_compaction,
-                         bool prefix_enabled, bool skip_filters, int level)
+                         bool prefix_enabled, bool skip_filters)
      : TwoLevelIteratorState(prefix_enabled),
        table_cache_(table_cache),
        read_options_(read_options),
@@ -499,8 +493,7 @@ class LevelFileIteratorState : public TwoLevelIteratorState {
        icomparator_(icomparator),
        file_read_hist_(file_read_hist),
        for_compaction_(for_compaction),
-        skip_filters_(skip_filters),
-        level_(level) {}
+        skip_filters_(skip_filters) {}

  InternalIterator* NewSecondaryIterator(const Slice& meta_handle) override {
    if (meta_handle.size() != sizeof(FileDescriptor)) {
@@ -512,7 +505,7 @@ class LevelFileIteratorState : public TwoLevelIteratorState {
      return table_cache_->NewIterator(
          read_options_, env_options_, icomparator_, *fd,
          nullptr /* don't need reference to table*/, file_read_hist_,
-          for_compaction_, nullptr /* arena */, skip_filters_, level_);
+          for_compaction_, nullptr /* arena */, skip_filters_);
    }
  }

@@ -528,7 +521,6 @@ class LevelFileIteratorState : public TwoLevelIteratorState {
  HistogramImpl* file_read_hist_;
  bool for_compaction_;
  bool skip_filters_;
-  int level_;
 };

 // A wrapper of version builder which references the current version in
@@ -779,21 +771,6 @@ uint64_t VersionStorageInfo::GetEstimatedActiveKeys() const {
  }
 }

-double VersionStorageInfo::GetEstimatedCompressionRatioAtLevel(
-    int level) const {
-  assert(level < num_levels_);
-  uint64_t sum_file_size_bytes = 0;
-  uint64_t sum_data_size_bytes = 0;
-  for (auto* file_meta : files_[level]) {
-    sum_file_size_bytes += file_meta->fd.GetFileSize();
-    sum_data_size_bytes += file_meta->raw_key_size + file_meta->raw_value_size;
-  }
-  if (sum_file_size_bytes == 0) {
-    return -1.0;
-  }
-  return static_cast<double>(sum_data_size_bytes) / sum_file_size_bytes;
-}
-
 void Version::AddIterators(const ReadOptions& read_options,
                           const EnvOptions& soptions,
                           MergeIteratorBuilder* merge_iter_builder) {
@@ -811,8 +788,7 @@ void Version::AddIterators(const ReadOptions& read_options,
    const auto& file = storage_info_.LevelFilesBrief(0).files[i];
    merge_iter_builder->AddIterator(cfd_->table_cache()->NewIterator(
        read_options, soptions, cfd_->internal_comparator(), file.fd, nullptr,
-        cfd_->internal_stats()->GetFileReadHist(0), false, arena,
-        false /* skip_filters */, 0 /* level */));
+        cfd_->internal_stats()->GetFileReadHist(0), false, arena));
  }

  // For levels > 0, we can use a concatenating iterator that sequentially
@@ -827,7 +803,7 @@ void Version::AddIterators(const ReadOptions& read_options,
                                 cfd_->internal_stats()->GetFileReadHist(level),
                                 false /* for_compaction */,
                                 cfd_->ioptions()->prefix_extractor != nullptr,
-                                 IsFilterSkipped(level), level);
+                                 IsFilterSkipped(level));
      mem = arena->AllocateAligned(sizeof(LevelFileNumIterator));
      auto* first_level_iter = new (mem) LevelFileNumIterator(
          cfd_->internal_comparator(), &storage_info_.LevelFilesBrief(level));
@@ -932,8 +908,7 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
        read_options, *internal_comparator(), f->fd, ikey, &get_context,
        cfd_->internal_stats()->GetFileReadHist(fp.GetHitFileLevel()),
        IsFilterSkipped(static_cast<int>(fp.GetHitFileLevel()),
-                        fp.IsHitFileLastInLevel()),
-        fp.GetCurrentLevel());
+                        fp.IsHitFileLastInLevel()));
    // TODO: examine the behavior for corrupted key
    if (!status->ok()) {
      return;
@@ -973,16 +948,9 @@ void Version::Get(const ReadOptions& read_options, const LookupKey& k,
    }
    // merge_operands are in saver and we hit the beginning of the key history
    // do a final merge of nullptr and operands;
-    bool merge_success = false;
-    {
-      StopWatchNano timer(env_, db_statistics_ != nullptr);
-      PERF_TIMER_GUARD(merge_operator_time_nanos);
-      merge_success = merge_operator_->FullMerge(
-          user_key, nullptr, merge_context->GetOperands(), value, info_log_);
-      RecordTick(db_statistics_, MERGE_OPERATION_TOTAL_TIME,
-                 timer.ElapsedNanos());
-    }
-    if (merge_success) {
+    if (merge_operator_->FullMerge(user_key, nullptr,
+                                   merge_context->GetOperands(), value,
+                                   info_log_)) {
      *status = Status::OK();
    } else {
      RecordTick(db_statistics_, NUMBER_MERGE_FAILURES);
@@ -1094,12 +1062,6 @@ void Version::UpdateAccumulatedStats(bool update_stats) {
        if (MaybeInitializeFileMetaData(file_meta)) {
          // each FileMeta will be initialized only once.
          storage_info_.UpdateAccumulatedStats(file_meta);
-          // when option "max_open_files" is -1, all the file metadata has
-          // already been read, so MaybeInitializeFileMetaData() won't incur
-          // any I/O cost.
-          if (vset_->db_options_->max_open_files == -1) {
-            continue;
-          }
          if (++init_count >= kMaxInitCount) {
            break;
          }
@@ -2092,16 +2054,9 @@ VersionSet::VersionSet(const std::string& dbname, const DBOptions* db_options,
      env_options_(storage_options),
      env_options_compactions_(env_options_) {}

-void CloseTables(void* ptr, size_t) {
-  TableReader* table_reader = reinterpret_cast<TableReader*>(ptr);
-  table_reader->Close();
-}
-
 VersionSet::~VersionSet() {
  // we need to delete column_family_set_ because its destructor depends on
  // VersionSet
-  column_family_set_->get_table_cache()->ApplyToAllCacheEntries(&CloseTables,
-                                                                false);
  column_family_set_.reset();
  for (auto file : obsolete_files_) {
    delete file;
@@ -2351,14 +2306,11 @@ Status VersionSet::LogAndApply(ColumnFamilyData* column_family_data,
    manifest_file_size_ = new_manifest_file_size;
    prev_log_number_ = edit->prev_log_number_;
  } else {
-    std::string version_edits;
-    for (auto& e : batch_edits) {
-      version_edits = version_edits + "\n" + e->DebugString(true);
-    }
    Log(InfoLogLevel::ERROR_LEVEL, db_options_->info_log,
-        "[%s] Error in committing version edit to MANIFEST: %s",
-        column_family_data ? column_family_data->GetName().c_str() : "<null>",
-        version_edits.c_str());
+        "Error in committing version %lu to [%s]",
+        (unsigned long)v->GetVersionNumber(),
+        column_family_data ? column_family_data->GetName().c_str()
+                           : "<null>");
    delete v;
    if (new_descriptor_log) {
      Log(InfoLogLevel::INFO_LEVEL, db_options_->info_log,
@@ -3288,7 +3240,7 @@ void VersionSet::AddLiveFiles(std::vector<FileDescriptor>* live_list) {
  }
 }

-InternalIterator* VersionSet::MakeInputIterator(const Compaction* c) {
+InternalIterator* VersionSet::MakeInputIterator(Compaction* c) {
  auto cfd = c->column_family_data();
  ReadOptions read_options;
  read_options.verify_checksums =
@@ -3315,8 +3267,7 @@ InternalIterator* VersionSet::MakeInputIterator(const Compaction* c) {
              read_options, env_options_compactions_,
              cfd->internal_comparator(), flevel->files[i].fd, nullptr,
              nullptr, /* no per level latency histogram*/
-              true /* for_compaction */, nullptr /* arena */,
-              false /* skip_filters */, (int)which /* level */);
+              true /* for compaction */);
        }
      } else {
        // Create concatenating iterator for the files from this level
@@ -3326,7 +3277,7 @@ InternalIterator* VersionSet::MakeInputIterator(const Compaction* c) {
                cfd->internal_comparator(),
                nullptr /* no per level latency histogram */,
                true /* for_compaction */, false /* prefix enabled */,
-                false /* skip_filters */, (int)which /* level */),
+                false /* skip_filters */),
            new LevelFileNumIterator(cfd->internal_comparator(),
                                     c->input_levels(which)));
      }
@@ -301,8 +301,6 @@ class VersionStorageInfo {

  uint64_t GetEstimatedActiveKeys() const;

-  double GetEstimatedCompressionRatioAtLevel(int level) const;
-
  // re-initializes the index that is used to offset into
  // files_by_compaction_pri_
  // to find the next compaction candidate file.
@@ -673,7 +671,7 @@ class VersionSet {

  // Create an iterator that reads over the compaction inputs for "*c".
  // The caller should delete the iterator when no longer needed.
-  InternalIterator* MakeInputIterator(const Compaction* c);
+  InternalIterator* MakeInputIterator(Compaction* c);

  // Add all files listed in any live version to *live.
  void AddLiveFiles(std::vector<FileDescriptor>* live_list);
@@ -455,7 +455,7 @@ Status WalManager::ReadFirstLine(const std::string& fname,

  if (reader.ReadRecord(&record, &scratch) &&
      (status.ok() || !db_options_.paranoid_checks)) {
-    if (record.size() < WriteBatchInternal::kHeader) {
+    if (record.size() < 12) {
      reporter.Corruption(record.size(),
                          Status::Corruption("log record too small"));
      // TODO read record's till the first no corrupt entry?
@@ -81,6 +81,8 @@ struct BatchContentClassifier : public WriteBatch::Handler {

 }  // anon namespace

+// WriteBatch header has an 8-byte sequence number followed by a 4-byte count.
+static const size_t kHeader = 12;

 struct SavePoint {
  size_t size;  // size of rep_
@@ -94,9 +96,8 @@ struct SavePoints {

 WriteBatch::WriteBatch(size_t reserved_bytes)
    : save_points_(nullptr), content_flags_(0), rep_() {
-  rep_.reserve((reserved_bytes > WriteBatchInternal::kHeader) ?
-    reserved_bytes : WriteBatchInternal::kHeader);
-  rep_.resize(WriteBatchInternal::kHeader);
+  rep_.reserve((reserved_bytes > kHeader) ? reserved_bytes : kHeader);
+  rep_.resize(kHeader);
 }

 WriteBatch::WriteBatch(const std::string& rep)
@@ -145,7 +146,7 @@ bool WriteBatch::Handler::Continue() {

 void WriteBatch::Clear() {
  rep_.clear();
-  rep_.resize(WriteBatchInternal::kHeader);
+  rep_.resize(kHeader);

  content_flags_.store(0, std::memory_order_relaxed);

@@ -192,23 +193,6 @@ bool WriteBatch::HasMerge() const {
  return (ComputeContentFlags() & ContentFlags::HAS_MERGE) != 0;
 }

-bool ReadKeyFromWriteBatchEntry(Slice* input, Slice* key, bool cf_record) {
-  assert(input != nullptr && key != nullptr);
-  // Skip tag byte
-  input->remove_prefix(1);
-
-  if (cf_record) {
-    // Skip column_family bytes
-    uint32_t cf;
-    if (!GetVarint32(input, &cf)) {
-      return false;
-    }
-  }
-
-  // Extract key
-  return GetLengthPrefixedSlice(input, key);
-}
-
 Status ReadRecordFromWriteBatch(Slice* input, char* tag,
                                uint32_t* column_family, Slice* key,
                                Slice* value, Slice* blob) {
@@ -265,11 +249,11 @@ Status ReadRecordFromWriteBatch(Slice* input, char* tag,

 Status WriteBatch::Iterate(Handler* handler) const {
  Slice input(rep_);
-  if (input.size() < WriteBatchInternal::kHeader) {
+  if (input.size() < kHeader) {
    return Status::Corruption("malformed WriteBatch (too small)");
  }

-  input.remove_prefix(WriteBatchInternal::kHeader);
+  input.remove_prefix(kHeader);
  Slice key, value, blob;
  int found = 0;
  Status s;
@@ -345,9 +329,7 @@ void WriteBatchInternal::SetSequence(WriteBatch* b, SequenceNumber seq) {
  EncodeFixed64(&b->rep_[0], seq);
 }

-size_t WriteBatchInternal::GetFirstOffset(WriteBatch* b) {
-  return WriteBatchInternal::kHeader;
-}
+size_t WriteBatchInternal::GetFirstOffset(WriteBatch* b) { return kHeader; }

 void WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
                             const Slice& key, const Slice& value) {
@@ -850,16 +832,15 @@ Status WriteBatchInternal::InsertInto(const WriteBatch* batch,
 }

 void WriteBatchInternal::SetContents(WriteBatch* b, const Slice& contents) {
-  assert(contents.size() >= WriteBatchInternal::kHeader);
+  assert(contents.size() >= kHeader);
  b->rep_.assign(contents.data(), contents.size());
  b->content_flags_.store(ContentFlags::DEFERRED, std::memory_order_relaxed);
 }

 void WriteBatchInternal::Append(WriteBatch* dst, const WriteBatch* src) {
  SetCount(dst, Count(dst) + Count(src));
-  assert(src->rep_.size() >= WriteBatchInternal::kHeader);
-  dst->rep_.append(src->rep_.data() + WriteBatchInternal::kHeader,
-    src->rep_.size() - WriteBatchInternal::kHeader);
+  assert(src->rep_.size() >= kHeader);
+  dst->rep_.append(src->rep_.data() + kHeader, src->rep_.size() - kHeader);
  dst->content_flags_.store(
      dst->content_flags_.load(std::memory_order_relaxed) |
          src->content_flags_.load(std::memory_order_relaxed),
@@ -871,7 +852,7 @@ size_t WriteBatchInternal::AppendedByteSize(size_t leftByteSize,
  if (leftByteSize == 0 || rightByteSize == 0) {
    return leftByteSize + rightByteSize;
  } else {
-    return leftByteSize + rightByteSize - WriteBatchInternal::kHeader;
+    return leftByteSize + rightByteSize - kHeader;
  }
 }

@@ -63,10 +63,6 @@ class ColumnFamilyMemTablesDefault : public ColumnFamilyMemTables {
 // WriteBatch that we don't want in the public WriteBatch interface.
 class WriteBatchInternal {
 public:
-
-  // WriteBatch header has an 8-byte sequence number followed by a 4-byte count.
-  static const size_t kHeader = 12;
-
  // WriteBatch methods with column_family_id instead of ColumnFamilyHandle*
  static void Put(WriteBatch* batch, uint32_t column_family_id,
                  const Slice& key, const Slice& value);
@@ -123,7 +123,6 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
          DB* db;
          DBImpl* db_impl;

-          DestroyDB(dbname, options);
          ASSERT_OK(DB::Open(options, dbname, &db));

          db_impl = dynamic_cast<DBImpl*>(db);
@@ -283,8 +282,6 @@ TEST_F(WriteCallbackTest, WriteCallBackTest) {
  DB* db;
  DBImpl* db_impl;

-  DestroyDB(dbname, options);
-
  options.create_if_missing = true;
  Status s = DB::Open(options, dbname, &db);
  ASSERT_OK(s);
@@ -138,7 +138,6 @@
  block_size=8192
  block_restart_interval=16
  cache_index_and_filter_blocks=false
-  pin_l0_filter_and_index_blocks_in_cache=false
  index_type=kBinarySearch
  hash_index_allow_collision=true
  flush_block_policy_factory=FlushBlockBySizePolicyFactory
@@ -12,8 +12,8 @@ underlying filesystem.
 If you want to compile rocksdb with hdfs support, please set the following
 environment variables appropriately (also defined in setup.sh for convenience)
   USE_HDFS=1
-   JAVA_HOME=/usr/local/jdk-7u79-64
-   LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/jdk-7u79-64/jre/lib/amd64/server:/usr/local/jdk-7u79-64/jre/lib/amd64/:./snappy/libs
+   JAVA_HOME=/usr/local/jdk-6u22-64
+   LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/jdk-6u22-64/jre/lib/amd64/server:/usr/local/jdk-6u22-64/jre/lib/amd64/:./snappy/libs
   make clean all db_bench

 To run dbbench,
@@ -121,9 +121,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_t* rocksdb_backup_engine_open(
 extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_create_new_backup(
    rocksdb_backup_engine_t* be, rocksdb_t* db, char** errptr);

-extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_purge_old_backups(
-    rocksdb_backup_engine_t* be, uint32_t num_backups_to_keep, char** errptr);
-
 extern ROCKSDB_LIBRARY_API rocksdb_restore_options_t*
 rocksdb_restore_options_create();
 extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_destroy(
@@ -269,11 +266,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_create_iterator_cf(
    rocksdb_t* db, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family);

-extern ROCKSDB_LIBRARY_API void rocksdb_create_iterators(
-    rocksdb_t *db, rocksdb_readoptions_t* opts,
-    rocksdb_column_family_handle_t** column_families,
-    rocksdb_iterator_t** iterators, size_t size, char** errptr);
-
 extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t* rocksdb_create_snapshot(
    rocksdb_t* db);

@@ -459,9 +451,6 @@ extern ROCKSDB_LIBRARY_API void
 rocksdb_block_based_options_set_cache_index_and_filter_blocks(
    rocksdb_block_based_table_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void
-rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
-    rocksdb_block_based_table_options_t*, unsigned char);
-extern ROCKSDB_LIBRARY_API void
 rocksdb_block_based_options_set_skip_table_builder_flush(
    rocksdb_block_based_table_options_t* options, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_block_based_table_factory(
@@ -504,8 +493,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_filter(
    rocksdb_options_t*, rocksdb_compactionfilter_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_filter_factory(
    rocksdb_options_t*, rocksdb_compactionfilterfactory_t*);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_compaction_readahead_size(
-    rocksdb_options_t*, size_t);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_comparator(
    rocksdb_options_t*, rocksdb_comparator_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_merge_operator(
@@ -531,14 +518,12 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_info_log_level(
    rocksdb_options_t*, int);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_size(
    rocksdb_options_t*, size_t);
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_write_buffer_size(
-    rocksdb_options_t*, size_t);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_open_files(
    rocksdb_options_t*, int);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_total_wal_size(
    rocksdb_options_t* opt, uint64_t n);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compression_options(
-    rocksdb_options_t*, int, int, int, int);
+    rocksdb_options_t*, int, int, int);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_prefix_extractor(
    rocksdb_options_t*, rocksdb_slicetransform_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_num_levels(
@@ -847,7 +832,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_cache_destroy(rocksdb_cache_t* cache);
 /* Env */

 extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_default_env();
-extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_mem_env();
 extern ROCKSDB_LIBRARY_API void rocksdb_env_set_background_threads(
    rocksdb_env_t* env, int n);
 extern ROCKSDB_LIBRARY_API void
@@ -146,10 +146,6 @@ class Cache {
  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                      bool thread_safe) = 0;

-  // Remove all entries.
-  // Prerequisit: no entry is referenced.
-  virtual void EraseUnRefEntries() = 0;
-
 private:
  void LRU_Remove(Handle* e);
  void LRU_Append(Handle* e);
@@ -61,7 +61,7 @@ struct CompactionJobStats {
  uint64_t num_corrupt_keys;

  // Following counters are only populated if
-  // options.report_bg_io_stats = true;
+  // options.compaction_measure_io_stats = true;

  // Time spent on file's Append() call.
  uint64_t file_write_nanos;
@@ -18,7 +18,7 @@ namespace rocksdb {
 // base_options, and return the new options as a result.
 //
 // If input_strings_escaped is set to true, then each escaped characters
-// prefixed by '\' in the values of the opts_map will be further
+// prefixed by '\' in the the values of the opts_map will be further
 // converted back to the raw string before assigning to the associated
 // options.
 Status GetColumnFamilyOptionsFromMap(
@@ -30,7 +30,7 @@ Status GetColumnFamilyOptionsFromMap(
 // base_options, and return the new options as a result.
 //
 // If input_strings_escaped is set to true, then each escaped characters
-// prefixed by '\' in the values of the opts_map will be further
+// prefixed by '\' in the the values of the opts_map will be further
 // converted back to the raw string before assigning to the associated
 // options.
 Status GetDBOptionsFromMap(
@@ -338,13 +338,6 @@ class DB {
    //      level number (e.g., "0").
    static const std::string kNumFilesAtLevelPrefix;

-    //  "rocksdb.compression-ratio-at-level<N>" - returns string containing the
-    //      compression ratio of data at level <N>, where <N> is an ASCII
-    //      representation of a level number (e.g., "0"). Here, compression
-    //      ratio is defined as uncompressed data size / compressed file size.
-    //      Returns "-1.0" if no open files at level <N>.
-    static const std::string kCompressionRatioAtLevelPrefix;
-
    //  "rocksdb.stats" - returns a multi-line string containing the data
    //      described by kCFStats followed by the data described by kDBStats.
    static const std::string kStats;
@@ -561,7 +561,7 @@ class WritableFile {
   * underlying storage of a file (generally via fallocate) if the Env
   * instance supports it.
   */
-  virtual void SetPreallocationBlockSize(size_t size) {
+  void SetPreallocationBlockSize(size_t size) {
    preallocation_block_size_ = size;
  }

@@ -597,7 +597,7 @@ class WritableFile {
  // of space on devices where it can result in less file
  // fragmentation and/or less waste from over-zealous filesystem
  // pre-allocation.
-  virtual void PrepareWrite(size_t offset, size_t len) {
+  void PrepareWrite(size_t offset, size_t len) {
    if (preallocation_block_size_ == 0) {
      return;
    }
@@ -950,13 +950,6 @@ class WritableFileWrapper : public WritableFile {
    return target_->InvalidateCache(offset, length);
  }

-  virtual void SetPreallocationBlockSize(size_t size) override {
-    target_->SetPreallocationBlockSize(size);
-  }
-  virtual void PrepareWrite(size_t offset, size_t len) override {
-    target_->PrepareWrite(offset, len);
-  }
-
 protected:
  Status Allocate(uint64_t offset, uint64_t len) override {
    return target_->Allocate(offset, len);
@@ -98,11 +98,13 @@ class Iterator : public Cleanable {

  // Property "rocksdb.iterator.is-key-pinned":
  //   If returning "1", this means that the Slice returned by key() is valid
-  //   as long as the iterator is not deleted.
+  //   as long as the iterator is not deleted and ReleasePinnedData() is not
+  //   called.
  //   It is guaranteed to always return "1" if
  //      - Iterator created with ReadOptions::pin_data = true
  //      - DB tables were created with
-  //        BlockBasedTableOptions::use_delta_encoding = false.
+  //      BlockBasedTableOptions::use_delta_encoding
+  //        set to false.
  // Property "rocksdb.iterator.super-version-number":
  //   LSM version used by the iterator. The same format as DB Property
  //   kCurrentSuperVersionNumber. See its comment for more information.
@@ -21,36 +21,23 @@ class DB;
 class Status;
 struct CompactionJobStats;

-enum class TableFileCreationReason {
-  kFlush,
-  kCompaction,
-  kRecovery,
-};
-
-struct TableFileCreationBriefInfo {
+struct TableFileCreationInfo {
+  TableFileCreationInfo() = default;
+  explicit TableFileCreationInfo(TableProperties&& prop) :
+      table_properties(prop) {}
  // the name of the database where the file was created
  std::string db_name;
  // the name of the column family where the file was created.
  std::string cf_name;
  // the path to the created file.
  std::string file_path;
+  // the size of the file.
+  uint64_t file_size;
  // the id of the job (which could be flush or compaction) that
  // created the file.
  int job_id;
-  // reason of creating the table.
-  TableFileCreationReason reason;
-};
-
-struct TableFileCreationInfo : public TableFileCreationBriefInfo {
-  TableFileCreationInfo() = default;
-  explicit TableFileCreationInfo(TableProperties&& prop)
-      : table_properties(prop) {}
-  // the size of the file.
-  uint64_t file_size;
  // Detailed properties of the created file.
  TableProperties table_properties;
-  // The status indicating whether the creation was successful or not.
-  Status status;
 };

 enum class CompactionReason {
@@ -225,25 +212,11 @@ class EventListener {
  // on file creations and deletions is suggested to implement
  // OnFlushCompleted and OnCompactionCompleted.
  //
-  // Historically it will only be called if the file is successfully created.
-  // Now it will also be called on failure case. User can check info.status
-  // to see if it succeeded or not.
-  //
  // Note that if applications would like to use the passed reference
  // outside this function call, they should make copies from these
  // returned value.
  virtual void OnTableFileCreated(const TableFileCreationInfo& /*info*/) {}

-  // A call-back function for RocksDB which will be called before
-  // a SST file is being created. It will follow by OnTableFileCreated after
-  // the creation finishes.
-  //
-  // Note that if applications would like to use the passed reference
-  // outside this function call, they should make copies from these
-  // returned value.
-  virtual void OnTableFileCreationStarted(
-      const TableFileCreationBriefInfo& /*info*/) {}
-
  virtual ~EventListener() {}
 };

@@ -61,7 +61,6 @@ enum CompressionType : char {
  kBZip2Compression = 0x3,
  kLZ4Compression = 0x4,
  kLZ4HCCompression = 0x5,
-  kXpressCompression = 0x6,
  // zstd format is not finalized yet so it's subject to changes.
  kZSTDNotFinalCompression = 0x40,
 };
@@ -137,23 +136,9 @@ struct CompressionOptions {
  int window_bits;
  int level;
  int strategy;
-  // Maximum size of dictionary used to prime the compression library. Currently
-  // this dictionary will be constructed by sampling the first output file in a
-  // subcompaction when the target level is bottommost. This dictionary will be
-  // loaded into the compression library before compressing/uncompressing each
-  // data block of subsequent files in the subcompaction. Effectively, this
-  // improves compression ratios when there are repetitions across data blocks.
-  // A value of 0 indicates the feature is disabled.
-  // Default: 0.
-  uint32_t max_dict_bytes;
-
-  CompressionOptions()
-      : window_bits(-14), level(-1), strategy(0), max_dict_bytes(0) {}
-  CompressionOptions(int wbits, int _lev, int _strategy, int _max_dict_bytes)
-      : window_bits(wbits),
-        level(_lev),
-        strategy(_strategy),
-        max_dict_bytes(_max_dict_bytes) {}
+  CompressionOptions() : window_bits(-14), level(-1), strategy(0) {}
+  CompressionOptions(int wbits, int _lev, int _strategy)
+      : window_bits(wbits), level(_lev), strategy(_strategy) {}
 };

 enum UpdateStatus {    // Return status For inplace update callback
@@ -173,15 +158,7 @@ struct DbPath {
 struct Options;

 struct ColumnFamilyOptions {
-  // The function recovers options to a previous version. Only 4.6 or later
-  // versions are supported.
-  ColumnFamilyOptions* OldDefaults(int rocksdb_major_version = 4,
-                                   int rocksdb_minor_version = 6);
-
  // Some functions that make it easier to optimize RocksDB
-  // Use this if your DB is very small (like under 1GB) and you don't want to
-  // spend lots of memory for memtables.
-  ColumnFamilyOptions* OptimizeForSmallDb();

  // Use this if you don't need to keep the data sorted, i.e. you'll never use
  // an iterator, only Put() and Get() API calls
@@ -277,7 +254,7 @@ struct ColumnFamilyOptions {
  // Note that write_buffer_size is enforced per column family.
  // See db_write_buffer_size for sharing memory across column families.
  //
-  // Default: 64MB
+  // Default: 4MB
  //
  // Dynamically changeable through SetOptions() API
  size_t write_buffer_size;
@@ -297,7 +274,7 @@ struct ColumnFamilyOptions {

  // The minimum number of write buffers that will be merged together
  // before writing to storage.  If set to 1, then
-  // all write buffers are flushed to L0 as individual files and this increases
+  // all write buffers are fushed to L0 as individual files and this increases
  // read amplification because a get request has to check in all of these
  // files. Also, an in-memory merge may result in writing lesser
  // data to storage if there are duplicate records in each of these
@@ -423,7 +400,7 @@ struct ColumnFamilyOptions {
  // be 2MB, and each file on level 2 will be 20MB,
  // and each file on level-3 will be 200MB.
  //
-  // Default: 64MB.
+  // Default: 2MB.
  //
  // Dynamically changeable through SetOptions() API
  uint64_t target_file_size_base;
@@ -438,12 +415,12 @@ struct ColumnFamilyOptions {
  // max_bytes_for_level_base is the max total for level-1.
  // Maximum number of bytes for level L can be calculated as
  // (max_bytes_for_level_base) * (max_bytes_for_level_multiplier ^ (L-1))
-  // For example, if max_bytes_for_level_base is 200MB, and if
+  // For example, if max_bytes_for_level_base is 20MB, and if
  // max_bytes_for_level_multiplier is 10, total data size for level-1
-  // will be 2GB, total file size for level-2 will be 20GB,
-  // and total file size for level-3 will be 200GB.
+  // will be 20MB, total file size for level-2 will be 200MB,
+  // and total file size for level-3 will be 2GB.
  //
-  // Default: 256MB.
+  // Default: 10MB.
  //
  // Dynamically changeable through SetOptions() API
  uint64_t max_bytes_for_level_base;
@@ -561,13 +538,13 @@ struct ColumnFamilyOptions {
  // All writes will be slowed down to at least delayed_write_rate if estimated
  // bytes needed to be compaction exceed this threshold.
  //
-  // Default: 64GB
+  // Default: 0 (disabled)
  uint64_t soft_pending_compaction_bytes_limit;

  // All writes are stopped if estimated bytes needed to be compaction exceed
  // this threshold.
  //
-  // Default: 256GB
+  // Default: 0 (disabled)
  uint64_t hard_pending_compaction_bytes_limit;

  // DEPRECATED -- this options is no longer used
@@ -605,7 +582,7 @@ struct ColumnFamilyOptions {

  // If level compaction_style = kCompactionStyleLevel, for each level,
  // which files are prioritized to be picked to compact.
-  // Default: kByCompensatedSize
+  // Default: kCompactionPriByCompensatedSize
  CompactionPri compaction_pri;

  // If true, compaction will verify checksum on every read that happens
@@ -666,7 +643,7 @@ struct ColumnFamilyOptions {
  // If you'd like to customize some of these options, you will need to
  // use NewBlockBasedTableFactory() to construct a new table factory.

-  // This option allows user to collect their own interested statistics of
+  // This option allows user to to collect their own interested statistics of
  // the tables.
  // Default: empty vector -- no user-defined statistics collection will be
  // performed.
@@ -805,9 +782,9 @@ struct ColumnFamilyOptions {
  // Default: false
  bool paranoid_file_checks;

-  // Measure IO stats in compactions and flushes, if true.
+  // Measure IO stats in compactions, if true.
  // Default: false
-  bool report_bg_io_stats;
+  bool compaction_measure_io_stats;

  // Create ColumnFamilyOptions with default values for all fields
  ColumnFamilyOptions();
@@ -818,16 +795,8 @@ struct ColumnFamilyOptions {
 };

 struct DBOptions {
-  // The function recovers options to the option as in version 4.6.
-  DBOptions* OldDefaults(int rocksdb_major_version = 4,
-                         int rocksdb_minor_version = 6);
-
  // Some functions that make it easier to optimize RocksDB

-  // Use this if your DB is very small (like under 1GB) and you don't want to
-  // spend lots of memory for memtables.
-  DBOptions* OptimizeForSmallDb();
-
 #ifndef ROCKSDB_LITE
  // By default, RocksDB uses only one background thread for flush and
  // compaction. Calling this function will set it up such that total of
@@ -868,19 +837,10 @@ struct DBOptions {
  // Default: nullptr
  std::shared_ptr<RateLimiter> rate_limiter;

-  // Use to track SST files and control their file deletion rate.
-  //
-  // Features:
-  //  - Throttle the deletion rate of the SST files.
-  //  - Keep track the total size of all SST files.
-  //  - Set a maximum allowed space limit for SST files that when reached
-  //    the DB wont do any further flushes or compactions and will set the
-  //    background error.
-  //  - Can be shared between multiple dbs.
-  // Limitations:
-  //  - Only track and throttle deletes of SST files in
-  //    first db_path (db_name if db_paths is empty).
-  //
+  // Use to track SST files and control their file deletion rate, can be used
+  // among multiple RocksDB instances, sst_file_manager only track and throttle
+  // deletes of SST files in first db_path (db_name if db_paths is empty), other
+  // files and other db_paths wont be tracked or affected by sst_file_manager.
  // Default: nullptr
  std::shared_ptr<SstFileManager> sst_file_manager;

@@ -897,12 +857,12 @@ struct DBOptions {
  // files opened are always kept open. You can estimate number of files based
  // on target_file_size_base and target_file_size_multiplier for level-based
  // compaction. For universal-style compaction, you can usually set it to -1.
-  // Default: -1
+  // Default: 5000 or ulimit value of max open files (whichever is smaller)
  int max_open_files;

  // If max_open_files is -1, DB will open all files on DB::Open(). You can
  // use this option to increase the number of threads used to open the files.
-  // Default: 16
+  // Default: 1
  int max_file_opening_threads;

  // Once write-ahead logs exceed this size, we will start forcing the flush of
@@ -983,7 +943,7 @@ struct DBOptions {
  // Suggested number of concurrent background compaction jobs, submitted to
  // the default LOW priority thread pool.
  //
-  // Default: 1
+  // Default: max_background_compactions
  int base_background_compactions;

  // Maximum number of concurrent background compaction jobs, submitted to
@@ -1081,23 +1041,7 @@ struct DBOptions {
  // large amounts of data (such as xfs's allocsize option).
  size_t manifest_preallocation_size;

-  // Hint the OS that it should not buffer disk I/O. Enabling this
-  // parameter may improve performance but increases pressure on the
-  // system cache.
-  //
-  // The exact behavior of this parameter is platform dependent.
-  //
-  // On POSIX systems, after RocksDB reads data from disk it will
-  // mark the pages as "unneeded". The operating system may - or may not
-  // - evict these pages from memory, reducing pressure on the system
-  // cache. If the disk block is requested again this can result in
-  // additional disk I/O.
-  //
-  // On WINDOWS system, files will be opened in "unbuffered I/O" mode
-  // which means that data read from the disk will not be cached or
-  // bufferized. The hardware buffer of the devices may however still
-  // be used. Memory mapped files are not impacted by this parameter.
-  //
+  // Data being read from file storage may be buffered in the OS
  // Default: true
  bool allow_os_buffer;

@@ -1300,7 +1244,7 @@ struct DBOptions {
  bool skip_stats_update_on_db_open;

  // Recovery mode to control the consistency while replaying WAL
-  // Default: kPointInTimeRecovery
+  // Default: kTolerateCorruptedTailRecords
  WALRecoveryMode wal_recovery_mode;

  // A global cache for table-level rows.
@@ -1314,7 +1258,7 @@ struct DBOptions {
  // records, ignoring a particular record or skipping replay.
  // The filter is invoked at startup and is invoked from a single-thread
  // currently.
-  WalFilter* wal_filter;
+  const WalFilter* wal_filter;
 #endif  // ROCKSDB_LITE

  // If true, then DB::Open / CreateColumnFamily / DropColumnFamily
@@ -1323,11 +1267,6 @@ struct DBOptions {
  //
  // DEFAULT: false
  bool fail_if_options_file_error;
-
-  // If true, then print malloc stats together with rocksdb.stats
-  // when printing to LOG.
-  // DEFAULT: false
-  bool dump_malloc_stats;
 };

 // Options to control the behavior of a database (passed to DB::Open)
@@ -1339,16 +1278,10 @@ struct Options : public DBOptions, public ColumnFamilyOptions {
          const ColumnFamilyOptions& column_family_options)
      : DBOptions(db_options), ColumnFamilyOptions(column_family_options) {}

-  // The function recovers options to the option as in version 4.6.
-  Options* OldDefaults(int rocksdb_major_version = 4,
-                       int rocksdb_minor_version = 6);
-
  void Dump(Logger* log) const;

  void DumpCFOptions(Logger* log) const;

-  // Some functions that make it easier to optimize RocksDB
-
  // Set appropriate parameters for bulk loading.
  // The reason that this is a function that returns "this" instead of a
  // constructor is to enable chaining of multiple similar calls in the future.
@@ -1358,10 +1291,6 @@ struct Options : public DBOptions, public ColumnFamilyOptions {
  // It's recommended to manually call CompactRange(NULL, NULL) before reading
  // from the database, because otherwise the read can be very slow.
  Options* PrepareForBulkLoad();
-
-  // Use this if your DB is very small (like under 1GB) and you don't want to
-  // spend lots of memory for memtables.
-  Options* OptimizeForSmallDb();
 };

 //
@@ -1458,9 +1387,6 @@ struct ReadOptions {
  // Enable a total order seek regardless of index format (e.g. hash index)
  // used in the table. Some table format (e.g. plain table) may not support
  // this option.
-  // If true when calling Get(), we also skip prefix bloom when reading from
-  // block based table. It provides a way to read exisiting data after
-  // changing implementation of prefix extractor.
  bool total_order_seek;

  // Enforce that the iterator only iterates over the same prefix as the seek.
@@ -1479,12 +1405,6 @@ struct ReadOptions {
  // Default: false
  bool pin_data;

-  // If non-zero, NewIterator will create a new table reader which
-  // performs reads of the given size. Using a large size (> 2MB) can
-  // improve the performance of forward iteration on spinning disks.
-  // Default: 0
-  size_t readahead_size;
-
  ReadOptions();
  ReadOptions(bool cksum, bool cache);
 };
@@ -30,32 +30,10 @@ struct PerfContext {
  uint64_t block_read_time;           // total nanos spent on block reads
  uint64_t block_checksum_time;       // total nanos spent on block checksum
  uint64_t block_decompress_time;  // total nanos spent on block decompression
-  // total number of internal keys skipped over during iteration.
-  // There are several reasons for it:
-  // 1. when calling Next(), the iterator is in the position of the previous
-  //    key, so that we'll need to skip it. It means this counter will always
-  //    be incremented in Next().
-  // 2. when calling Next(), we need to skip internal entries for the previous
-  //    keys that are overwritten.
-  // 3. when calling Next(), Seek() or SeekToFirst(), after previous key
-  //    before calling Next(), the seek key in Seek() or the beginning for
-  //    SeekToFirst(), there may be one or more deleted keys before the next
-  //    valid key that the operation should place the iterator to. We need
-  //    to skip both of the tombstone and updates hidden by the tombstones. The
-  //    tombstones are not included in this counter, while previous updates
-  //    hidden by the tombstones will be included here.
-  // 4. symmetric cases for Prev() and SeekToLast()
-  // We sometimes also skip entries of more recent updates than the snapshot
-  // we read from, but they are not included in this counter.
-  //
+  // total number of internal keys skipped over during iteration (overwritten or
+  // deleted, to be more specific, hidden by a put or delete of the same key)
  uint64_t internal_key_skipped_count;
-  // Total number of deletes and single deletes skipped over during iteration
-  // When calling Next(), Seek() or SeekToFirst(), after previous position
-  // before calling Next(), the seek key in Seek() or the beginning for
-  // SeekToFirst(), there may be one or more deleted keys before the next valid
-  // key. Every deleted key is counted once. We don't recount here if there are
-  // still older updates invalidated by the tombstones.
-  //
+  // total number of deletes and single deletes skipped over during iteration
  uint64_t internal_delete_skipped_count;

  uint64_t get_snapshot_time;       // total nanos spent on getting snapshot
@@ -79,16 +79,8 @@ class Slice {
  }

  // Return a string that contains the copy of the referenced data.
-  // when hex is true, returns a string of twice the length hex encoded (0-9A-F)
  std::string ToString(bool hex = false) const;

-  // Decodes the current slice interpreted as an hexadecimal string into result,
-  // if successful returns true, if this isn't a valid hex string
-  // (e.g not coming from Slice::ToString(true)) DecodeHex returns false.
-  // This slice is expected to have an even number of 0-9A-F characters
-  // also accepts lowercase (a-f)
-  bool DecodeHex(std::string* result) const;
-
  // Three-way comparison.  Returns value:
  //   <  0 iff "*this" <  "b",
  //   == 0 iff "*this" == "b",
@@ -64,12 +64,6 @@ struct BlockBasedTableOptions {
  // block during table initialization.
  bool cache_index_and_filter_blocks = false;

-  // if cache_index_and_filter_blocks is true and the below is true, then
-  // filter and index blocks are stored in the cache, but a reference is
-  // held in the "table reader" object so the blocks are pinned and only
-  // evicted from cache when the table reader is freed.
-  bool pin_l0_filter_and_index_blocks_in_cache = false;
-
  // The index type that will be used for this table.
  enum IndexType : char {
    // A space efficient index block that is optimized for
@@ -130,7 +124,7 @@ struct BlockBasedTableOptions {
  int index_block_restart_interval = 1;

  // Use delta encoding to compress keys in blocks.
-  // ReadOptions::pin_data requires this option to be disabled.
+  // Iterator::PinData() requires this option to be disabled.
  //
  // Default: true
  bool use_delta_encoding = true;
Author	SHA1	Message	Date
sdong	b026bfdf4a	Disable error as warning	2019-11-05 11:03:42 -08:00
sdong	ce7b6bced6	Add one more #include<functional>	2019-11-05 11:03:40 -08:00
sdong	2f3fac5a1d	Add some include<functional>	2019-10-31 14:30:44 -07:00
sdong	b2ef1cb1ae	[FB Internal] Point to the latest tool chain.	2019-10-31 14:30:43 -07:00
sdong	05ab235fe7	[fb only] revert unintended change of USE_SSE The previuos change that use gcc-5 set USE_SSE to wrong flag by mistake. Fix it.	2017-07-17 22:21:57 -07:00
sdong	36a76d543e	[FB Only] use gcc-5	2017-07-17 21:48:14 -07:00
Islam AbdelRahman	21b393c7f3	backport fbcode gcc path fix	2016-06-08 13:06:52 -07:00
Andrew Kryczka	8d7926a766	Increment patch number for 4.6.1	2016-05-06 17:29:53 -07:00
Andrew Kryczka	9ed80413e0	Retrieve file size from proper Env Summary: When db_env_ != backup_env_, InsertPathnameToSizeBytes() would use the wrong Env during backup creation. This happened because this function used backup_env_ instead of db_env_ to get WAL/data file sizes. This diff adds an argument to InsertPathnameToSizeBytes() indicating which Env to use. Test Plan: ran @anirbanb's BackupTestTool Reviewers: sdong Reviewed By: sdong Subscribers: andrewkr, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D57159	2016-05-06 17:28:15 -07:00
Andrew Kryczka	15ec7d4f95	Update change log for 4.6 release Summary: as titled Test Plan: N/A Reviewers: sdong, kradhakrishnan, anthony, yhchiang, IslamAbdelRahman Reviewed By: IslamAbdelRahman Subscribers: leveldb, andrewkr, dhruba Differential Revision: https://reviews.facebook.net/D55323	2016-03-14 11:11:09 -07:00
Islam AbdelRahman	0612f472b2	Aggregate hot Iterator counters in LocalStatistics (DBIter::Next perf regression) Summary: This patch bump the counters in the frequent code path DBIter::Next() / DBIter::Prev() in a local data members and send them to Statistics when the iterator is destroyed A better solution will be to have thread_local implementation for Statistics New performance ``` readseq : 0.035 micros/op 28597881 ops/sec; 3163.7 MB/s 1,851,568,819 stalled-cycles-frontend # 31.29% frontend cycles idle [49.86%] 884,929,823 stalled-cycles-backend # 14.95% backend cycles idle [50.21%] readreverse : 0.071 micros/op 14077393 ops/sec; 1557.3 MB/s 3,239,575,993 stalled-cycles-frontend # 27.36% frontend cycles idle [49.96%] 1,558,253,983 stalled-cycles-backend # 13.16% backend cycles idle [50.14%] ``` Existing performance ``` readreverse : 0.174 micros/op 5732342 ops/sec; 634.1 MB/s 20,570,209,389 stalled-cycles-frontend # 70.71% frontend cycles idle [50.01%] 18,422,816,837 stalled-cycles-backend # 63.33% backend cycles idle [50.04%] readseq : 0.119 micros/op 8400537 ops/sec; 929.3 MB/s 15,634,225,844 stalled-cycles-frontend # 79.07% frontend cycles idle [49.96%] 14,227,427,453 stalled-cycles-backend # 71.95% backend cycles idle [50.09%] ``` Test Plan: unit tests Reviewers: yhchiang, sdong, igor Reviewed By: sdong Subscribers: andrewkr, dhruba Differential Revision: https://reviews.facebook.net/D55107	2016-03-14 11:11:09 -07:00
Andrew Kryczka	187cb23caa	Cleanup stale manifests outside of full purge Summary: - Keep track of obsolete manifests in VersionSet - Updated FindObsoleteFiles() to put obsolete manifests in the JobContext for later use by PurgeObsoleteFiles() - Added test case that verifies a stale manifest is deleted by a non-full purge Test Plan: $ ./backupable_db_test --gtest_filter=BackupableDBTest.ChangeManifestDuringBackupCreation Reviewers: IslamAbdelRahman, yoshinorim, sdong Reviewed By: sdong Subscribers: andrewkr, leveldb, dhruba Differential Revision: https://reviews.facebook.net/D55269	2016-03-14 11:11:09 -07:00
Yi Wu	848cf937d9	Cache to have an option to fail Cache::Insert() when full Summary: Cache to have an option to fail Cache::Insert() when full. Update call sites to check status and handle error. I totally have no idea what's correct behavior of all the call sites when they encounter error. Please let me know if you see something wrong or more unit test is needed. Test Plan: make check -j32, see tests pass. Reviewers: anthony, yhchiang, andrewkr, IslamAbdelRahman, kradhakrishnan, sdong Reviewed By: sdong Subscribers: andrewkr, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D54705	2016-03-14 11:11:09 -07:00
Yueh-Hsuan Chiang	c5cfed2e4a	Update compaction score right after CompactFiles forms a compaction Summary: This is a follow-up patch of https://reviews.facebook.net/D54891. As the information about files being compacted will also be used when making compaction decision, it is necessary to update the compaction score when a compaction plan has been made but not yet execute. This patch adds a missing call to update the compaction score in CompactFiles(). Test Plan: compact_files_test Reviewers: sdong, IslamAbdelRahman, kradhakrishnan, yiwu, andrewkr Reviewed By: andrewkr Subscribers: andrewkr, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D55227	2016-03-14 11:11:09 -07:00