Release 1.5.8.fb.

Summary: Test Plan: Reviewers: CC: Task ID: # Blame Rev:
2026-11-07 03:22:34 -05:00 · 2013-03-13 15:38:02 -07:00
164 changed files with 3027 additions and 16896 deletions
@@ -1,16 +1,13 @@
 build_config.mk
 *.a
-*.arc
-*.d
-*.dylib*
-*.gcda
-*.gcno
 *.o
+*.dylib*
 *.so
 *.so.*
 *_test
+*.arc
+*.d
 db_bench
-db_repl_stress
 db_stress
 ldb
 leveldb_server
@@ -18,6 +15,4 @@ leveldb_shell
 manifest_dump
 sst_dump
 util/build_version.cc
-build_tools/VALGRIND_LOGS/
-coverage/COVERAGE_REPORT
-util/build_version.cc.tmp
+db_repl_stress
@@ -14,13 +14,13 @@ OPT += -O2 -fno-omit-frame-pointer -momit-leaf-frame-pointer
 #-----------------------------------------------

 # detect what platform we're building on
-$(shell (cd build_tools/; ROCKSDB_ROOT=.. ./build_detect_platform ../build_config.mk))
+$(shell ./build_detect_platform build_config.mk)
 # this file is generated by the previous line to set build flags and sources
 include build_config.mk

-WARNING_FLAGS = -Wall -Werror
+WARNING_FLAGS = -Wall -Werror -Wno-unused-parameter -Wno-sign-compare
 CFLAGS += -g $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CCFLAGS) $(OPT)
-CXXFLAGS += -g $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT) -std=gnu++0x -Woverloaded-virtual
+CXXFLAGS += -g $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT) -std=gnu++0x

 LDFLAGS += $(PLATFORM_LDFLAGS)

@@ -31,54 +31,48 @@ MEMENVOBJECTS = $(MEMENV_SOURCES:.cc=.o)
 TESTUTIL = ./util/testutil.o
 TESTHARNESS = ./util/testharness.o $(TESTUTIL)
 VALGRIND_ERROR = 2
-VALGRIND_DIR = build_tools/VALGRIND_LOGS
+VALGRIND_DIR = VALGRIND_LOGS
 VALGRIND_VER := $(join $(VALGRIND_VER),valgrind)
 VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full

 TESTS = \
 	arena_test \
-	auto_roll_logger_test \
-	block_test \
 	bloom_test \
 	c_test \
 	cache_test \
 	coding_test \
+	histogram_test \
 	corruption_test \
 	crc32c_test \
 	db_test \
 	dbformat_test \
 	env_test \
-	filelock_test \
 	filename_test \
 	filter_block_test \
-	histogram_test \
 	log_test \
-	manual_compaction_test \
 	memenv_test \
-	merge_test \
-	redis_test \
-	reduce_levels_test \
 	skiplist_test \
-	stringappend_test \
 	table_test \
-	ttl_test \
+	block_test \
 	version_edit_test \
 	version_set_test \
-	write_batch_test
+	reduce_levels_test \
+	write_batch_test \
+	auto_roll_logger_test \
+	filelock_test
+

 TOOLS = \
+	manifest_dump \
        sst_dump \
        db_stress \
        ldb \
 	db_repl_stress

-PROGRAMS = db_bench signal_test $(TESTS) $(TOOLS)
+PROGRAMS = db_bench $(TESTS) $(TOOLS)
 BENCHMARKS = db_bench_sqlite3 db_bench_tree_db

-# The library name is configurable since we are maintaining libraries of both
-# debug/release mode.
-LIBNAME = librocksdb
-LIBRARY = ${LIBNAME}.a
+LIBRARY = libleveldb.a
 MEMENVLIBRARY = libmemenv.a

 default: all
@@ -87,15 +81,15 @@ default: all
 ifneq ($(PLATFORM_SHARED_EXT),)

 ifneq ($(PLATFORM_SHARED_VERSIONED),true)
-SHARED1 = ${LIBNAME}.$(PLATFORM_SHARED_EXT)
+SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
 SHARED2 = $(SHARED1)
 SHARED3 = $(SHARED1)
 SHARED = $(SHARED1)
 else
 # Update db.h if you change these.
-SHARED_MAJOR = 2
-SHARED_MINOR = 0
-SHARED1 = ${LIBNAME}.$(PLATFORM_SHARED_EXT)
+SHARED_MAJOR = 1
+SHARED_MINOR = 5
+SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
 SHARED2 = $(SHARED1).$(SHARED_MAJOR)
 SHARED3 = $(SHARED1).$(SHARED_MAJOR).$(SHARED_MINOR)
 SHARED = $(SHARED1) $(SHARED2) $(SHARED3)
@@ -106,25 +100,15 @@ $(SHARED2): $(SHARED3)
 endif

 $(SHARED3):
-	$(CXX) $(LDFLAGS) $(PLATFORM_SHARED_LDFLAGS)$(SHARED2) $(CXXFLAGS) $(COVERAGEFLAGS) $(PLATFORM_SHARED_CFLAGS) $(SOURCES) -o $(SHARED3)
+	$(CXX) $(LDFLAGS) $(PLATFORM_SHARED_LDFLAGS)$(SHARED2) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(SOURCES) -o $(SHARED3)

 endif  # PLATFORM_SHARED_EXT

 all: $(SHARED) $(LIBRARY) $(PROGRAMS)

-.PHONY: blackbox_crash_test check clean coverage crash_test ldb_tests \
-	release tags valgrind_check whitebox_crash_test
-
 release:
-	$(MAKE) clean
-	OPT=-DNDEBUG $(MAKE) -j32
-
-coverage:
-	$(MAKE) clean
-	COVERAGEFLAGS="-fprofile-arcs -ftest-coverage" $(MAKE) all check
-	(cd coverage; ./coverage_test.sh)
-	# Delete intermediate files
-	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" | xargs --no-run-if-empty rm
+	make clean
+	OPT=-DNDEBUG make -j32

 check: all $(PROGRAMS) $(TESTS) $(TOOLS) ldb_tests
 	for t in $(TESTS); do echo "***** Running $$t"; ./$$t || exit 1; done
@@ -132,16 +116,7 @@ check: all $(PROGRAMS) $(TESTS) $(TOOLS) ldb_tests
 ldb_tests: all $(PROGRAMS) $(TOOLS)
 	python tools/ldb_test.py

-crash_test: blackbox_crash_test whitebox_crash_test
-
-blackbox_crash_test: db_stress
-	python -u tools/db_crashtest.py
-
-whitebox_crash_test: db_stress
-	python -u tools/db_crashtest2.py
-
 valgrind_check: all $(PROGRAMS) $(TESTS)
-	mkdir -p $(VALGRIND_DIR)
 	echo TESTS THAT HAVE VALGRIND ERRORS > $(VALGRIND_DIR)/valgrind_failed_tests; \
 	echo TIMES in seconds TAKEN BY TESTS ON VALGRIND > $(VALGRIND_DIR)/valgrind_tests_times; \
 	for t in $(filter-out skiplist_test,$(TESTS)); do \
@@ -155,148 +130,119 @@ valgrind_check: all $(PROGRAMS) $(TESTS)
 	done

 clean:
-	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) $(THRIFTSERVER) build_config.mk
+	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) $(THRIFTSERVER) */*.o */*/*.o ios-x86/*/*.o ios-arm/*/*.o build_config.mk
 	-rm -rf ios-x86/* ios-arm/*
-	-find . -name "*.[od]" | xargs --no-run-if-empty rm
-	-find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" | xargs --no-run-if-empty rm
-tags:
-	ctags * -R
-	cscope -b `find . -name '*.cc'` `find . -name '*.h'`

-# ---------------------------------------------------------------------------
-# 	Unit tests and tools
-# ---------------------------------------------------------------------------
 $(LIBRARY): $(LIBOBJECTS)
 	rm -f $@
 	$(AR) -rs $@ $(LIBOBJECTS)

+
 db_bench: db/db_bench.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS)

 db_stress: tools/db_stress.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) tools/db_stress.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) tools/db_stress.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS)

 db_repl_stress: tools/db_repl_stress.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) tools/db_repl_stress.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) tools/db_repl_stress.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS)

 db_bench_sqlite3: doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) -lsqlite3 $(COVERAGEFLAGS)
+	$(CXX) doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) -lsqlite3

 db_bench_tree_db: doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) -lkyotocabinet $(COVERAGEFLAGS)
-
-signal_test: util/signal_test.o $(LIBOBJECTS)
-	$(CXX) util/signal_test.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) -lkyotocabinet

 arena_test: util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 bloom_test: util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 c_test: db/c_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/c_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/c_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 cache_test: util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 coding_test: util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-stringappend_test: utilities/merge_operators/string_append/stringappend_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) utilities/merge_operators/string_append/stringappend_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-redis_test: utilities/redis/redis_lists_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) utilities/redis/redis_lists_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 histogram_test: util/histogram_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/histogram_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o$@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/histogram_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o$@ $(LDFLAGS)

 corruption_test: db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 db_test: db/db_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-perf_context_test: db/perf_context_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/perf_context_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
-
-ttl_test: utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 env_test: util/env_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 filename_test: db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 filter_block_test: table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 log_test: db/log_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/log_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/log_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 table_test: table/table_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) table/table_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) table/table_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 block_test: table/block_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) table/block_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) table/block_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 skiplist_test: db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 version_edit_test: db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 version_set_test: db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 reduce_levels_test: tools/reduce_levels_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) tools/reduce_levels_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) tools/reduce_levels_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 write_batch_test: db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-merge_test: db/merge_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/merge_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 $(MEMENVLIBRARY) : $(MEMENVOBJECTS)
 	rm -f $@
 	$(AR) -rs $@ $(MEMENVOBJECTS)

 memenv_test : helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS)
-	$(CXX) helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

-manual_compaction_test: util/manual_compaction_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/manual_compaction_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+leveldb_shell: tools/shell/ShellContext.o tools/shell/ShellState.o tools/shell/LeveldbShell.o tools/shell/DBClientProxy.o tools/shell/ShellContext.h tools/shell/ShellState.h tools/shell/DBClientProxy.h $(LIBOBJECTS)
+	$(CXX) tools/shell/ShellContext.o tools/shell/ShellState.o tools/shell/LeveldbShell.o tools/shell/DBClientProxy.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

-rocksdb_shell: tools/shell/ShellContext.o tools/shell/ShellState.o tools/shell/LeveldbShell.o tools/shell/DBClientProxy.o tools/shell/ShellContext.h tools/shell/ShellState.h tools/shell/DBClientProxy.h $(LIBOBJECTS)
-	$(CXX) tools/shell/ShellContext.o tools/shell/ShellState.o tools/shell/LeveldbShell.o tools/shell/DBClientProxy.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+DBClientProxy_test: tools/shell/test/DBClientProxyTest.o tools/shell/DBClientProxy.o $(LIBRARY) 
+	$(CXX) tools/shell/test/DBClientProxyTest.o tools/shell/DBClientProxy.o $(LIBRARY) $(EXEC_LDFLAGS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS)

-DBClientProxy_test: tools/shell/test/DBClientProxyTest.o tools/shell/DBClientProxy.o $(LIBRARY)
-	$(CXX) tools/shell/test/DBClientProxyTest.o tools/shell/DBClientProxy.o $(LIBRARY) $(EXEC_LDFLAGS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
+manifest_dump: tools/manifest_dump.o $(LIBOBJECTS)
+	$(CXX) tools/manifest_dump.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 filelock_test: util/filelock_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/filelock_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/filelock_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 auto_roll_logger_test: util/auto_roll_logger_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/auto_roll_logger_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) util/auto_roll_logger_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 sst_dump: tools/sst_dump.o $(LIBOBJECTS)
-	$(CXX) tools/sst_dump.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
+	$(CXX) tools/sst_dump.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 ldb: tools/ldb.o $(LIBOBJECTS)
-	$(CXX) tools/ldb.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-# ---------------------------------------------------------------------------
-#  	Platform-specific compilation
-# ---------------------------------------------------------------------------
+	$(CXX) tools/ldb.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)

 ifeq ($(PLATFORM), IOS)
 # For iOS, create universal object files to be used on both the simulator and
@@ -308,9 +254,9 @@ IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/versionCFBun

 .cc.o:
 	mkdir -p ios-x86/$(dir $@)
-	$(SIMULATORROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@ $(COVERAGEFLAGS)
+	$(SIMULATORROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@
 	mkdir -p ios-arm/$(dir $@)
-	$(DEVICEROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@ $(COVERAGEFLAGS)
+	$(DEVICEROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@
 	lipo ios-x86/$@ ios-arm/$@ -create -output $@

 .c.o:
@@ -322,26 +268,17 @@ IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/versionCFBun

 else
 .cc.o:
-	$(CXX) $(CXXFLAGS) -c $< -o $@ $(COVERAGEFLAGS)
+	$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) -c $< -o $@

 .c.o:
-	$(CC) $(CFLAGS) -c $< -o $@
+	$(CC) $(CFLAGS) $(PLATFORM_SHARED_CFLAGS) -c $< -o $@
 endif

-# ---------------------------------------------------------------------------
-#  	Source files dependencies detection
-# ---------------------------------------------------------------------------
-
-# Add proper dependency support so changing a .h file forces a .cc file to
-# rebuild.
-
-# The .d file indicates .cc file's dependencies on .h files. We generate such
-# dependency by g++'s -MM option, whose output is a make dependency rule.
-# The sed command makes sure the "target" file in the generated .d file has
-# the correct path prefix.
 %.d: %.cc
-	$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) -MM $< -o $@
-	@sed -i -e 's|.*:|$*.o:|' $@
+	$(CXX) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) -MM $< -o $*.d
+	@cp -f $*.d $*.d.tmp
+	@sed -e 's|.*:|$*.o:|' < $*.d.tmp > $*.d
+	@rm -f $*.d.tmp

 DEPFILES = $(filter-out util/build_version.d,$(SOURCES:.cc=.d))

@@ -350,3 +287,4 @@ depend: $(DEPFILES)
 ifneq ($(MAKECMDGOALS),clean)
 -include $(DEPFILES)
 endif
+
@@ -1,7 +1,5 @@
 rocksdb: A persistent key-value store for flash storage
-Authors: * The Facebook Database Engineering Team
-         * Build on earlier work on leveldb by Sanjay Ghemawat 
-           (sanjay@google.com) and Jeff Dean (jeff@google.com)
+Authors: The Facebook Database Engineering Team

 This code is a library that forms the core building block for a fast
 key value server, especially suited for storing data on flash drives.
@@ -58,25 +56,6 @@ include/env.h
    Abstraction of the OS environment.  A posix implementation of
    this interface is in util/env_posix.cc

+include/table.h
 include/table_builder.h
    Lower-level modules that most clients probably won't use directly
-
-include/cache.h
-    An API for the block cache.
-
-include/compaction_filter.h
-    An API for a application filter invoked on every compaction.
-
-include/filter_policy.h
-    An API for configuring a bloom filter.
-
-include/memtablerep.h
-    An API for implementing a memtable.
-
-include/statistics.h
-    An API to retrieve various database statistics.
-
-include/transaction_log_iterator.h
-    An API to retrieve transaction logs from a database.
-
-
@@ -1,3 +1,3 @@
 * Detailed instructions on how to compile using fbcode and jemalloc

-* Latest release is 2.1.fb
+* Latest release is 1.5.8.fb
@@ -0,0 +1,4 @@
+This directory stores the tests that failed valgrind and the times associated
+with the failed runs.
+"make valgrind_check" can be invoked to call valgrind on the rocksdb tests and
+generate files in this directory
@@ -31,9 +31,9 @@ fi
 # Default to fbcode gcc on internal fb machines
 if [ -d /mnt/gvfs/third-party -a -z "$CXX" ]; then
    if [ -z "$USE_CLANG" ]; then
-        source ./fbcode.gcc471.sh
+        source fbcode.gcc471.sh
    else
-        source ./fbcode.clang31.sh
+        source fbcode.clang31.sh
    fi
 fi

@@ -64,9 +64,6 @@ PLATFORM_SHARED_LDFLAGS="${EXEC_LDFLAGS_SHARED} -shared -Wl,-soname -Wl,"
 PLATFORM_SHARED_CFLAGS="-fPIC"
 PLATFORM_SHARED_VERSIONED=true

-# generic port files (working on all platform by #ifdef) go directly in /port
-GENERIC_PORT_FILES=`cd $ROCKSDB_ROOT; find port -name '*.cc' | tr "\n" " "`
-
 # On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp
 case "$TARGET_OS" in
    Darwin)
@@ -74,52 +71,52 @@ case "$TARGET_OS" in
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -DOS_MACOSX"
        PLATFORM_SHARED_EXT=dylib
        PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
-        # PORT_FILES=port/darwin/darwin_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    Linux)
        PLATFORM=OS_LINUX
-        COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX"
+        COMMON_FLAGS="$COMMON_FLAGS -DOS_LINUX -fPIC"
        if [ -z "$USE_CLANG" ]; then
            COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
        fi
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        # PORT_FILES=port/linux/linux_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    SunOS)
        PLATFORM=OS_SOLARIS
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
-        # PORT_FILES=port/sunos/sunos_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    FreeBSD)
        PLATFORM=OS_FREEBSD
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        # PORT_FILES=port/freebsd/freebsd_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    NetBSD)
        PLATFORM=OS_NETBSD
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lgcc_s"
-        # PORT_FILES=port/netbsd/netbsd_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    OpenBSD)
        PLATFORM=OS_OPENBSD
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread"
-        # PORT_FILES=port/openbsd/openbsd_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    DragonFly)
        PLATFORM=OS_DRAGONFLYBSD
        COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        # PORT_FILES=port/dragonfly/dragonfly_specific.cc
+        PORT_FILE=port/port_posix.cc
        ;;
    OS_ANDROID_CROSSCOMPILE)
        PLATFORM=OS_ANDROID
 	COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_ANDROID -DLEVELDB_PLATFORM_POSIX"
 	PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS "  # All pthread features are in the Android C library
-        # PORT_FILES=port/android/android.cc
+        PORT_FILE=port/port_posix.cc
        CROSS_COMPILE=true
        ;;
    *)
@@ -133,7 +130,7 @@ esac
 # except for the test and benchmark files. By default, find will output a list
 # of all files matching either rule, so we need to append -print to make the
 # prune take effect.
-DIRS="util db table utilities"
+DIRS="util db table"
 if test "$USE_THRIFT"; then
  DIRS="$DIRS thrift/server_utils.cpp thrift/gen-cpp "
  THRIFTSERVER=leveldb_server
@@ -146,13 +143,13 @@ fi
 set -f # temporarily disable globbing so that our patterns arent expanded
 PRUNE_TEST="-name *test*.cc -prune"
 PRUNE_BENCH="-name *_bench.cc -prune"
-PORTABLE_FILES=`cd $ROCKSDB_ROOT; find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cc' -print | sort | tr "\n" " "`
-PORTABLE_CPP=`cd $ROCKSDB_ROOT; find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cpp' -print | sort | tr "\n" " "`
+PORTABLE_FILES=`find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cc' -print | sort | tr "\n" " "`
+PORTABLE_CPP=`find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cpp' -print | sort | tr "\n" " "`
 set +f # re-enable globbing

 # The sources consist of the portable files, plus the platform-specific port
 # file.
-echo "SOURCES=$PORTABLE_FILES $GENERIC_PORT_FILES $PORT_FILES" >> $OUTPUT
+echo "SOURCES=$PORTABLE_FILES $PORT_FILE" >> $OUTPUT
 echo "SOURCESCPP=$PORTABLE_CPP" >> $OUTPUT
 echo "MEMENV_SOURCES=helpers/memenv/memenv.cc" >> $OUTPUT

@@ -0,0 +1,30 @@
+#!/bin/sh
+#
+# Record the version of the source that we are compiling.
+# We keep a record of the git revision in util/version.cc. This source file
+# is then built as a regular source file as part of the compilation process.
+# One can run "strings executable_filename | grep _build_" to find the version of
+# the source that we used to build the executable file.
+#
+
+# create git version file
+VFILE=$(mktemp)
+trap "rm $VFILE" EXIT
+
+# check to see if git is in the path
+which git > /dev/null
+
+if [ "$?" = 0 ]; then
+  env -i git rev-parse HEAD | awk ' BEGIN {print "#include \"build_version.h\""} {print "const char * leveldb_build_git_sha = \"leveldb_build_git_sha:" $0"\";"} END {}' >  ${VFILE}
+else
+  echo "git not found"| awk ' BEGIN {print "#include \"build_version.h\""} {print "const char * leveldb_build_git_sha = \"leveldb_build_git_sha:git not found\";"} END {}' > ${VFILE}
+fi
+
+date | awk 'BEGIN {} {print "const char * leveldb_build_git_datetime = \"leveldb_build_git_datetime:"$0"\";"} END {} ' >> ${VFILE}
+echo "const char * leveldb_build_compile_date = __DATE__;" >> ${VFILE}
+echo "const char * leveldb_build_compile_time = __TIME__;" >> ${VFILE}
+
+OUTFILE=util/build_version.cc
+if [ ! -e $OUTFILE ] || ! cmp -s $VFILE $OUTFILE; then
+    cp $VFILE $OUTFILE
+fi
@@ -1,42 +0,0 @@
-#!/bin/sh
-#
-# Record the version of the source that we are compiling.
-# We keep a record of the git revision in util/version.cc. This source file
-# is then built as a regular source file as part of the compilation process.
-# One can run "strings executable_filename | grep _build_" to find the version of
-# the source that we used to build the executable file.
-#
-
-# create git version file
-VFILE=$ROCKSDB_ROOT/util/build_version.cc.tmp
-trap "rm $VFILE" EXIT
-
-# check to see if git is in the path
-which git > /dev/null
-
-if [ "$?" = 0 ]; then
-  env -i git rev-parse HEAD |
-  awk '
-  BEGIN {
-    print "#include \"build_version.h\"\n"
-  } 
-  { print "const char* leveldb_build_git_sha = \"leveldb_build_git_sha:" $0"\";" }
-  ' >  ${VFILE}
-else
-  echo "git not found" |
-  awk '
-    BEGIN {
-      print "#include \"build_version.h\"" 
-    } 
-    { print "const char* leveldb_build_git_sha = \"leveldb_build_git_sha:git not found\";" }
-    ' > ${VFILE}
-fi
-
-echo "const char* leveldb_build_git_datetime = \"leveldb_build_git_datetime:$(date)\";" >> ${VFILE}
-echo "const char* leveldb_build_compile_date = __DATE__;" >> ${VFILE}
-echo "const char* leveldb_build_compile_time = __TIME__;" >> ${VFILE}
-
-OUTFILE=$ROCKSDB_ROOT/util/build_version.cc
-if [ ! -e $OUTFILE ] || ! cmp -s $VFILE $OUTFILE; then
-    cp $VFILE $OUTFILE
-fi
@@ -1,66 +0,0 @@
-#!/bin/bash
-
-# Exit on error.
-set -e
-
-if [ -n "$USE_CLANG" ]; then
-  echo "Error: Coverage test is supported only for gcc."
-  exit 1
-fi
-
-ROOT=".."
-# Fetch right version of gcov
-if [ -d /mnt/gvfs/third-party -a -z "$CXX" ]; then
-  source $ROOT/build_tools/fbcode.gcc471.sh
-  GCOV=$TOOLCHAIN_EXECUTABLES/gcc/gcc-4.7.1/cc6c9dc/bin/gcov
-else
-  GCOV=$(which gcov)
-fi
-
-COVERAGE_DIR="$PWD/COVERAGE_REPORT"
-mkdir -p $COVERAGE_DIR
-
-# Find all gcno files to generate the coverage report
-
-GCNO_FILES=`find $ROOT -name "*.gcno"`
-$GCOV --preserve-paths --relative-only --no-output $GCNO_FILES 2>/dev/null |
-  # Parse the raw gcov report to more human readable form.
-  python $ROOT/coverage/parse_gcov_output.py |
-  # Write the output to both stdout and report file.
-  tee $COVERAGE_DIR/coverage_report_all.txt &&
-echo -e "Generated coverage report for all files: $COVERAGE_DIR/coverage_report_all.txt\n"
-
-# TODO: we also need to get the files of the latest commits.
-# Get the most recently committed files.
-LATEST_FILES=`
-  git show --pretty="format:" --name-only HEAD |
-  grep -v "^$" |
-  paste -s -d,`
-RECENT_REPORT=$COVERAGE_DIR/coverage_report_recent.txt
-
-echo -e "Recently updated files: $LATEST_FILES\n" > $RECENT_REPORT
-$GCOV --preserve-paths --relative-only --no-output $GCNO_FILES 2>/dev/null |
-  python $ROOT/coverage/parse_gcov_output.py -interested-files $LATEST_FILES |
-  tee -a $RECENT_REPORT &&
-echo -e "Generated coverage report for recently updated files: $RECENT_REPORT\n"
-
-# Generate the html report. If we cannot find lcov in this machine, we'll simply
-# skip this step.
-echo "Generating the html coverage report..."
-
-LCOV=$(which lcov || true 2>/dev/null)
-if [ -z $LCOV ]
-then
-  echo "Skip: Cannot find lcov to generate the html report."
-  exit 0
-fi
-
-(cd $ROOT; lcov --no-external \
-     --capture  \
-     --directory $PWD \
-     --gcov-tool $GCOV \
-     --output-file $COVERAGE_DIR/coverage.info &>/dev/null)
-
-genhtml $COVERAGE_DIR/coverage.info -o $COVERAGE_DIR &>/dev/null
-
-echo "HTML Coverage report is generated in $COVERAGE_DIR"
@@ -1,118 +0,0 @@
-import optparse
-import re
-import sys
-
-from optparse import OptionParser
-
-# the gcov report follows certain pattern. Each file will have two lines
-# of report, from which we can extract the file name, total lines and coverage
-# percentage.
-def parse_gcov_report(gcov_input):
-    per_file_coverage = {}
-    total_coverage = None
-
-    for line in sys.stdin:
-        line = line.strip()
-
-        # --First line of the coverage report (with file name in it)?
-        match_obj = re.match("^File '(.*)'$", line)
-        if match_obj:
-            # fetch the file name from the first line of the report.
-            current_file = match_obj.group(1)
-            continue
-
-        # -- Second line of the file report (with coverage percentage)
-        match_obj = re.match("^Lines executed:(.*)% of (.*)", line)
-
-        if match_obj:
-            coverage = float(match_obj.group(1))
-            lines = int(match_obj.group(2))
-
-            if current_file is not None:
-                per_file_coverage[current_file] = (coverage, lines)
-                current_file = None
-            else:
-                # If current_file is not set, we reach the last line of report,
-                # which contains the summarized coverage percentage.
-                total_coverage = (coverage, lines)
-            continue
-
-        # If the line's pattern doesn't fall into the above categories. We
-        # can simply ignore them since they're either empty line or doesn't
-        # find executable lines of the given file.
-        current_file = None
-
-    return per_file_coverage, total_coverage
-
-def get_option_parser():
-    usage = "Parse the gcov output and generate more human-readable code " +\
-            "coverage report."
-    parser = OptionParser(usage)
-
-    parser.add_option(
-        "--interested-files", "-i",
-        dest="filenames",
-        help="Comma separated files names. if specified, we will display " +
-             "the coverage report only for interested source files. " +
-             "Otherwise we will display the coverage report for all " +
-             "source files."
-    )
-    return parser
-
-def display_file_coverage(per_file_coverage, total_coverage):
-    # To print out auto-adjustable column, we need to know the longest
-    # length of file names.
-    max_file_name_length = max(
-        len(fname) for fname in per_file_coverage.keys()
-    )
-
-    # -- Print header
-    # size of separator is determined by 3 column sizes:
-    # file name, coverage percentage and lines.
-    header_template = \
-        "%" + str(max_file_name_length) + "s\t%s\t%s"
-    separator = "-" * (max_file_name_length + 10 + 20)
-    print header_template % ("Filename", "Coverage", "Lines")
-    print separator
-
-    # -- Print body
-    # template for printing coverage report for each file.
-    record_template = "%" + str(max_file_name_length) + "s\t%5.2f%%\t%10d"
-
-    for fname, coverage_info in per_file_coverage.items():
-        coverage, lines = coverage_info
-        print record_template % (fname, coverage, lines)
-
-    # -- Print footer
-    if total_coverage:
-        print separator
-        print record_template % ("Total", total_coverage[0], total_coverage[1])
-
-def report_coverage():
-    parser = get_option_parser()
-    (options, args) = parser.parse_args()
-
-    interested_files = set()
-    if options.filenames is not None:
-        interested_files = set(f.strip() for f in options.filenames.split(','))
-
-    # To make things simple, right now we only read gcov report from the input
-    per_file_coverage, total_coverage = parse_gcov_report(sys.stdin)
-
-    # Check if we need to display coverage info for interested files.
-    if len(interested_files):
-        per_file_coverage = dict(
-            (fname, per_file_coverage[fname]) for fname in interested_files
-            if fname in per_file_coverage
-        )
-        # If we only interested in several files, it makes no sense to report
-        # the total_coverage
-        total_coverage = None
-
-    if not len(per_file_coverage):
-        print >> sys.stderr, "Cannot find coverage info for the given files."
-        return
-    display_file_coverage(per_file_coverage, total_coverage)
-
-if __name__ == "__main__":
-    report_coverage()
@@ -6,20 +6,17 @@

 #include "db/filename.h"
 #include "db/dbformat.h"
-#include "db/merge_helper.h"
 #include "db/table_cache.h"
 #include "db/version_edit.h"
 #include "leveldb/db.h"
 #include "leveldb/env.h"
 #include "leveldb/iterator.h"
-#include "util/stop_watch.h"

 namespace leveldb {

 Status BuildTable(const std::string& dbname,
                  Env* env,
                  const Options& options,
-                  const EnvOptions& soptions,
                  TableCache* table_cache,
                  Iterator* iter,
                  FileMetaData* meta,
@@ -28,7 +25,6 @@ Status BuildTable(const std::string& dbname,
                  const SequenceNumber earliest_seqno_in_memtable) {
  Status s;
  meta->file_size = 0;
-  meta->smallest_seqno = meta->largest_seqno = 0;
  iter->SeekToFirst();

  // If the sequence number of the smallest entry in the memtable is
@@ -42,7 +38,7 @@ Status BuildTable(const std::string& dbname,
  std::string fname = TableFileName(dbname, meta->number);
  if (iter->Valid()) {
    unique_ptr<WritableFile> file;
-    s = env->NewWritableFile(fname, &file, soptions);
+    s = env->NewWritableFile(fname, &file);
    if (!s.ok()) {
      return s;
    }
@@ -51,106 +47,47 @@ Status BuildTable(const std::string& dbname,
    // the first key is the smallest key
    Slice key = iter->key();
    meta->smallest.DecodeFrom(key);
-    meta->smallest_seqno = GetInternalKeySeqno(key);
-    meta->largest_seqno = meta->smallest_seqno;
-
-    MergeHelper merge(user_comparator, options.merge_operator.get(),
-                      options.info_log.get(),
-                      true /* internal key corruption is not ok */);

    if (purge) {
-      // Ugly walkaround to avoid compiler error for release build
-      bool ok __attribute__((unused)) = true;
-
-      // Will write to builder if current key != prev key
      ParsedInternalKey prev_ikey;
+      std::string prev_value;
      std::string prev_key;
-      bool is_first_key = true;    // Also write if this is the very first key

-      while (iter->Valid()) {
-        bool iterator_at_next = false;
+      // store first key-value
+      prev_key.assign(key.data(), key.size());
+      prev_value.assign(iter->value().data(), iter->value().size());
+      ParseInternalKey(Slice(prev_key), &prev_ikey);
+      assert(prev_ikey.sequence >= earliest_seqno_in_memtable);

-        // Get current key
+      for (iter->Next(); iter->Valid(); iter->Next()) {
        ParsedInternalKey this_ikey;
        Slice key = iter->key();
-        Slice value = iter->value();
-
-        // In-memory key corruption is not ok;
-        // TODO: find a clean way to treat in memory key corruption
-        ok = ParseInternalKey(key, &this_ikey);
-        assert(ok);
+        ParseInternalKey(key, &this_ikey);
        assert(this_ikey.sequence >= earliest_seqno_in_memtable);

-        // If the key is the same as the previous key (and it is not the
-        // first key), then we skip it, since it is an older version.
-        // Otherwise we output the key and mark it as the "new" previous key.
-        if (!is_first_key && !user_comparator->Compare(prev_ikey.user_key,
-                                                       this_ikey.user_key)) {
+        if (user_comparator->Compare(prev_ikey.user_key, this_ikey.user_key)) {
+          // This key is different from previous key.
+          // Output prev key and remember current key
+          builder->Add(Slice(prev_key), Slice(prev_value));
+          prev_key.assign(key.data(), key.size());
+          prev_value.assign(iter->value().data(), iter->value().size());
+          ParseInternalKey(Slice(prev_key), &prev_ikey);
+        } else {
          // seqno within the same key are in decreasing order
          assert(this_ikey.sequence < prev_ikey.sequence);
-        } else {
-          is_first_key = false;
-
-          if (this_ikey.type == kTypeMerge) {
-            // Handle merge-type keys using the MergeHelper
-            merge.MergeUntil(iter, 0 /* don't worry about snapshot */);
-            iterator_at_next = true;
-            if (merge.IsSuccess()) {
-              // Merge completed correctly.
-              // Add the resulting merge key/value and continue to next
-              builder->Add(merge.key(), merge.value());
-              prev_key.assign(merge.key().data(), merge.key().size());
-              ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
-              assert(ok);
-            } else {
-              // Merge did not find a Put/Delete.
-              // Can not compact these merges into a kValueType.
-              // Write them out one-by-one. (Proceed back() to front())
-              const std::deque<std::string>& keys = merge.keys();
-              const std::deque<std::string>& values = merge.values();
-              assert(keys.size() == values.size() && keys.size() >= 1);
-              std::deque<std::string>::const_reverse_iterator key_iter;
-              std::deque<std::string>::const_reverse_iterator value_iter;
-              for (key_iter=keys.rbegin(), value_iter = values.rbegin();
-                   key_iter != keys.rend() && value_iter != values.rend();
-                   ++key_iter, ++value_iter) {
-
-                builder->Add(Slice(*key_iter), Slice(*value_iter));
-              }
-
-              // Sanity check. Both iterators should end at the same time
-              assert(key_iter == keys.rend() && value_iter == values.rend());
-
-              prev_key.assign(keys.front());
-              ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
-              assert(ok);
-            }
-          } else {
-            // Handle Put/Delete-type keys by simply writing them
-            builder->Add(key, value);
-            prev_key.assign(key.data(), key.size());
-            ok = ParseInternalKey(Slice(prev_key), &prev_ikey);
-            assert(ok);
-          }
+          // This key is an earlier version of the same key in prev_key.
+          // Skip current key.
        }
-
-        if (!iterator_at_next) iter->Next();
      }
-
-      // The last key is the largest key
+      // output last key
+      builder->Add(Slice(prev_key), Slice(prev_value));
      meta->largest.DecodeFrom(Slice(prev_key));
-      SequenceNumber seqno = GetInternalKeySeqno(Slice(prev_key));
-      meta->smallest_seqno = std::min(meta->smallest_seqno, seqno);
-      meta->largest_seqno = std::max(meta->largest_seqno, seqno);

    } else {
      for (; iter->Valid(); iter->Next()) {
        Slice key = iter->key();
        meta->largest.DecodeFrom(key);
        builder->Add(key, iter->value());
-        SequenceNumber seqno = GetInternalKeySeqno(key);
-        meta->smallest_seqno = std::min(meta->smallest_seqno, seqno);
-        meta->largest_seqno = std::max(meta->largest_seqno, seqno);
      }
    }

@@ -169,10 +106,8 @@ Status BuildTable(const std::string& dbname,
    // Finish and check for file errors
    if (s.ok() && !options.disableDataSync) {
      if (options.use_fsync) {
-        StopWatch sw(env, options.statistics, TABLE_SYNC_MICROS);
        s = file->Fsync();
      } else {
-        StopWatch sw(env, options.statistics, TABLE_SYNC_MICROS);
        s = file->Sync();
      }
    }
@@ -183,7 +118,6 @@ Status BuildTable(const std::string& dbname,
    if (s.ok()) {
      // Verify that the table is usable
      Iterator* it = table_cache->NewIterator(ReadOptions(),
-                                              soptions,
                                              meta->number,
                                              meta->file_size);
      s = it->status();
@@ -15,7 +15,6 @@ struct Options;
 struct FileMetaData;

 class Env;
-class EnvOptions;
 class Iterator;
 class TableCache;
 class VersionEdit;
@@ -28,7 +27,6 @@ class VersionEdit;
 extern Status BuildTable(const std::string& dbname,
                         Env* env,
                         const Options& options,
-                         const EnvOptions& soptions,
                         TableCache* table_cache,
                         Iterator* iter,
                         FileMetaData* meta,
@@ -10,12 +10,12 @@
 #include <sys/types.h>
 #include "leveldb/cache.h"
 #include "leveldb/env.h"
+#include "leveldb/table.h"
 #include "leveldb/write_batch.h"
 #include "db/db_impl.h"
 #include "db/filename.h"
 #include "db/log_format.h"
 #include "db/version_set.h"
-#include "table/table.h"
 #include "util/logging.h"
 #include "util/testharness.h"
 #include "util/testutil.h"
@@ -40,7 +40,6 @@ class CorruptionTest {

    db_ = nullptr;
    options_.create_if_missing = true;
-    options_.block_size_deviation = 0; // make unit test pass for now
    Reopen();
    options_.create_if_missing = false;
  }
@@ -56,8 +55,6 @@ class CorruptionTest {
    Options opt = (options ? *options : options_);
    opt.env = &env_;
    opt.block_cache = tiny_cache_;
-    opt.block_size_deviation = 0;
-    opt.arena_block_size = 4096;
    return DB::Open(opt, dbname_, &db_);
  }

@@ -2,11 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

-#include <algorithm>
-#include <string>
-#include <stdint.h>
 #include "db/db_impl.h"
 #include "db/filename.h"
+#include <string>
+#include <stdint.h>
 #include "db/version_set.h"
 #include "leveldb/db.h"
 #include "leveldb/env.h"
@@ -18,14 +17,12 @@ namespace leveldb {
 Status DBImpl::DisableFileDeletions() {
  MutexLock l(&mutex_);
  disable_delete_obsolete_files_ = true;
-  Log(options_.info_log, "File Deletions Disabled");
  return Status::OK();
 }

 Status DBImpl::EnableFileDeletions() {
  MutexLock l(&mutex_);
  disable_delete_obsolete_files_ = false;
-  Log(options_.info_log, "File Deletions Enabled");
  return Status::OK();
 }

@@ -67,47 +64,4 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
  return Status::OK();
 }

-Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
-  // First get sorted files in archive dir, then append sorted files from main
-  // dir to maintain sorted order
-
-  //  list wal files in archive dir.
-  Status s;
-  std::string archivedir = ArchivalDirectory(dbname_);
-  if (env_->FileExists(archivedir)) {
-    s = AppendSortedWalsOfType(archivedir, files, kArchivedLogFile);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-  // list wal files in main db dir.
-  s = AppendSortedWalsOfType(dbname_, files, kAliveLogFile);
-  if (!s.ok()) {
-    return s;
-  }
-  return s;
-}
-
-Status DBImpl::DeleteWalFiles(const VectorLogPtr& files) {
-  Status s;
-  std::string archivedir = ArchivalDirectory(dbname_);
-  std::string files_not_deleted;
-  for (const auto& wal : files) {
-    /* Try deleting in archive dir. If fails, try deleting in main db dir.
-     * This is efficient because all except for very few wal files will be in
-     * archive. Checking for WalType is not much helpful because alive wal could
-       be archived now.
-     */
-    if (!env_->DeleteFile(archivedir + "/" + wal->Filename()).ok() &&
-        !env_->DeleteFile(dbname_ + "/" + wal->Filename()).ok()) {
-      files_not_deleted.append(wal->Filename());
-    }
-  }
-  if (!files_not_deleted.empty()) {
-    return Status::IOError("Deleted all requested files except: " +
-                           files_not_deleted);
-  }
-  return Status::OK();
-}
-
 }
@@ -5,17 +5,14 @@
 #ifndef STORAGE_LEVELDB_DB_DB_IMPL_H_
 #define STORAGE_LEVELDB_DB_DB_IMPL_H_

-#include <atomic>
 #include <deque>
 #include <set>
-#include <vector>
 #include "db/dbformat.h"
+#include "db/log_file.h"
 #include "db/log_writer.h"
 #include "db/snapshot.h"
 #include "leveldb/db.h"
 #include "leveldb/env.h"
-#include "leveldb/memtablerep.h"
-#include "leveldb/transaction_log.h"
 #include "port/port.h"
 #include "util/stats_logger.h"
 #include "memtablelist.h"
@@ -39,32 +36,17 @@ class DBImpl : public DB {

  // Implementations of the DB interface
  virtual Status Put(const WriteOptions&, const Slice& key, const Slice& value);
-  virtual Status Merge(const WriteOptions&, const Slice& key,
-                       const Slice& value);
  virtual Status Delete(const WriteOptions&, const Slice& key);
  virtual Status Write(const WriteOptions& options, WriteBatch* updates);
  virtual Status Get(const ReadOptions& options,
                     const Slice& key,
                     std::string* value);
-  virtual std::vector<Status> MultiGet(const ReadOptions& options,
-                                       const std::vector<Slice>& keys,
-                                       std::vector<std::string>* values);
-
-  // Returns false if key doesn't exist in the database and true if it may.
-  // If value_found is not passed in as null, then return the value if found in
-  // memory. On return, if value was found, then value_found will be set to true
-  // , otherwise false.
-  virtual bool KeyMayExist(const ReadOptions& options,
-                           const Slice& key,
-                           std::string* value,
-                           bool* value_found = nullptr);
  virtual Iterator* NewIterator(const ReadOptions&);
  virtual const Snapshot* GetSnapshot();
  virtual void ReleaseSnapshot(const Snapshot* snapshot);
  virtual bool GetProperty(const Slice& property, std::string* value);
  virtual void GetApproximateSizes(const Range* range, int n, uint64_t* sizes);
-  virtual void CompactRange(const Slice* begin, const Slice* end,
-                            bool reduce_level = false);
+  virtual void CompactRange(const Slice* begin, const Slice* end);
  virtual int NumberLevels();
  virtual int MaxMemCompactionLevel();
  virtual int Level0StopWriteTrigger();
@@ -73,15 +55,13 @@ class DBImpl : public DB {
  virtual Status EnableFileDeletions();
  virtual Status GetLiveFiles(std::vector<std::string>&,
                              uint64_t* manifest_file_size);
-  virtual Status GetSortedWalFiles(VectorLogPtr& files);
-  virtual Status DeleteWalFiles(const VectorLogPtr& files);
  virtual SequenceNumber GetLatestSequenceNumber();
  virtual Status GetUpdatesSince(SequenceNumber seq_number,
                                 unique_ptr<TransactionLogIterator>* iter);

  // Extra methods (for testing) that are not in the public DB interface

-  // Compact any files in the named level that overlap [*begin, *end]
+  // Compact any files in the named level that overlap [*begin,*end]
  void TEST_CompactRange(int level, const Slice* begin, const Slice* end);

  // Force current memtable contents to be compacted.
@@ -107,10 +87,6 @@ class DBImpl : public DB {

  // Return the current manifest file no.
  uint64_t TEST_Current_Manifest_FileNo();
-
-  // Trigger's a background call for testing.
-  void TEST_PurgeObsoleteteWAL();
-
 protected:
  Env* const env_;
  const std::string dbname_;
@@ -165,10 +141,9 @@ class DBImpl : public DB {
  // for the entire period. The second method WriteLevel0Table supports
  // concurrent flush memtables to storage.
  Status WriteLevel0TableForRecovery(MemTable* mem, VersionEdit* edit);
-  Status WriteLevel0Table(std::vector<MemTable*> &mems, VersionEdit* edit,
+  Status WriteLevel0Table(MemTable* mem, VersionEdit* edit,
                                uint64_t* filenumber);

-  uint64_t SlowdownAmount(int n, int top, int bottom);
  Status MakeRoomForWrite(bool force /* compact even if there is room? */);
  WriteBatch* BuildBatchGroup(Writer** last_writer);

@@ -185,7 +160,7 @@ class DBImpl : public DB {
  void MaybeScheduleCompaction();
  static void BGWork(void* db);
  void BackgroundCall();
-  Status BackgroundCompaction(bool* madeProgress,DeletionState& deletion_state);
+  Status BackgroundCompaction(bool* madeProgress, DeletionState& deletion_state);
  void CleanupCompaction(CompactionState* compact);
  Status DoCompactionWork(CompactionState* compact);

@@ -210,37 +185,21 @@ class DBImpl : public DB {

  void PurgeObsoleteWALFiles();

-  Status AppendSortedWalsOfType(const std::string& path,
-                                VectorLogPtr& log_files,
-                                WalFileType type);
+  Status ListAllWALFiles(const std::string& path,
+                         std::vector<LogFile>* logFiles,
+                         WalFileType type);

-  // Requires: all_logs should be sorted with earliest log file first
-  // Retains all log files in all_logs which contain updates with seq no.
-  // Greater Than or Equal to the requested SequenceNumber.
-  Status RetainProbableWalFiles(VectorLogPtr& all_logs,
-                                const SequenceNumber target);
-  //  return true if
-  bool CheckWalFileExistsAndEmpty(const WalFileType type,
-                                  const uint64_t number);
+  //  Find's all the log files which contain updates with seq no.
+  //  Greater Than or Equal to the requested SequenceNumber
+  Status FindProbableWALFiles(std::vector<LogFile>* const allLogs,
+                              std::vector<LogFile>* const result,
+                              const SequenceNumber target);
+
+
+  Status ReadFirstRecord(const LogFile& file, WriteBatch* const result);

-  Status ReadFirstRecord(const WalFileType type, const uint64_t number,
-                         WriteBatch* const result);

  Status ReadFirstLine(const std::string& fname, WriteBatch* const batch);
-
-  void PrintStatistics();
-
-  // dump leveldb.stats to LOG
-  void MaybeDumpStats();
-
-  // Return the minimum empty level that could hold the total data in the
-  // input level. Return the input level, if such level could not be found.
-  int FindMinimumEmptyLevelFitting(int level);
-
-  // Move the files in the input level to the minimum level that could hold
-  // the data set.
-  void ReFitLevel(int level);
-
  // Constant after construction
  const InternalFilterPolicy internal_filter_policy_;
  bool owns_info_log_;
@@ -255,7 +214,6 @@ class DBImpl : public DB {
  port::Mutex mutex_;
  port::AtomicPointer shutting_down_;
  port::CondVar bg_cv_;          // Signalled when background work finishes
-  std::shared_ptr<MemTableRepFactory> mem_rep_factory_;
  MemTable* mem_;
  MemTableList imm_;             // Memtable that are not changing
  uint64_t logfile_number_;
@@ -265,7 +223,7 @@ class DBImpl : public DB {

  // Queue of writers.
  std::deque<Writer*> writers_;
-  WriteBatch tmp_batch_;
+  WriteBatch* tmp_batch_;

  SnapshotList snapshots_;

@@ -293,7 +251,7 @@ class DBImpl : public DB {
  // Have we encountered a background error in paranoid mode?
  Status bg_error_;

-  std::unique_ptr<StatsLogger> logger_;
+  StatsLogger* logger_;

  int64_t volatile last_log_ts;

@@ -303,21 +261,11 @@ class DBImpl : public DB {
  // last time when DeleteObsoleteFiles was invoked
  uint64_t delete_obsolete_files_last_run_;

-  // last time when PurgeObsoleteWALFiles ran.
-  uint64_t purge_wal_files_last_run_;
-
-  // last time stats were dumped to LOG
-  std::atomic<uint64_t> last_stats_dump_time_microsec_;
-
  // These count the number of microseconds for which MakeRoomForWrite stalls.
  uint64_t stall_level0_slowdown_;
  uint64_t stall_memtable_compaction_;
  uint64_t stall_level0_num_files_;
  std::vector<uint64_t> stall_leveln_slowdown_;
-  uint64_t stall_level0_slowdown_count_;
-  uint64_t stall_memtable_compaction_count_;
-  uint64_t stall_level0_num_files_count_;
-  std::vector<uint64_t> stall_leveln_slowdown_count_;

  // Time at which this instance was started.
  const uint64_t started_at_;
@@ -367,20 +315,7 @@ class DBImpl : public DB {
    }
  };

-  std::vector<CompactionStats> stats_;
-
-  // Used to compute per-interval statistics
-  struct StatsSnapshot {
-    uint64_t bytes_read_;
-    uint64_t bytes_written_;
-    uint64_t bytes_new_;
-    double   seconds_up_;
-
-    StatsSnapshot() : bytes_read_(0), bytes_written_(0),
-                      bytes_new_(0), seconds_up_(0) {}
-  };
-
-  StatsSnapshot last_stats_;
+  CompactionStats* stats_;

  static const int KEEP_LOG_FILE_NUM = 1000;
  std::string db_absolute_path_;
@@ -392,15 +327,6 @@ class DBImpl : public DB {
  // Used by transaction log iterator.
  SequenceNumber last_flushed_sequence_;

-  // The options to access storage files
-  const EnvOptions storage_options_;
-
-  // A value of true temporarily disables scheduling of background work
-  bool bg_work_gate_closed_;
-
-  // Guard against multiple concurrent refitting
-  bool refitting_level_;
-
  // No copying allowed
  DBImpl(const DBImpl&);
  void operator=(const DBImpl&);
@@ -408,20 +334,9 @@ class DBImpl : public DB {
  // dump the delayed_writes_ to the log file and reset counter.
  void DelayLoggingAndReset();

-  // Return the earliest snapshot where seqno is visible.
-  // Store the snapshot right before that, if any, in prev_snapshot
-  inline SequenceNumber findEarliestVisibleSnapshot(
-    SequenceNumber in,
-    std::vector<SequenceNumber>& snapshots,
-    SequenceNumber* prev_snapshot);
-
-  // Function that Get and KeyMayExist call with no_io true or false
-  // Note: 'value_found' from KeyMayExist propagates here
-  Status GetImpl(const ReadOptions& options,
-                 const Slice& key,
-                 std::string* value,
-                 const bool no_io = false,
-                 bool* value_found = nullptr);
+  // find the earliest snapshot where seqno is visible
+  inline SequenceNumber findEarliestVisibleSnapshot(SequenceNumber in,
+    std::vector<SequenceNumber>& snapshots);
 };

 // Sanitize db options.  The caller should delete result.info_log if
@@ -24,11 +24,11 @@
 #include "leveldb/db.h"
 #include "leveldb/env.h"
 #include "leveldb/status.h"
+#include "leveldb/table.h"
 #include "leveldb/table_builder.h"
 #include "port/port.h"
 #include "table/block.h"
 #include "table/merger.h"
-#include "table/table.h"
 #include "table/two_level_iterator.h"
 #include "util/coding.h"
 #include "util/logging.h"
@@ -53,12 +53,11 @@ Status DBImplReadOnly::Get(const ReadOptions& options,
  MemTable* mem = GetMemTable();
  Version* current = versions_->current();
  SequenceNumber snapshot = versions_->LastSequence();
-  std::deque<std::string> merge_operands;
  LookupKey lkey(key, snapshot);
-  if (mem->Get(lkey, value, &s, &merge_operands, options_)) {
+  if (mem->Get(lkey, value, &s)) {
  } else {
    Version::GetStats stats;
-    current->Get(options, lkey, value, &s, &merge_operands, &stats, options_);
+    s = current->Get(options, lkey, value, &stats);
  }
  return s;
 }
@@ -67,7 +66,7 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& options) {
  SequenceNumber latest_snapshot;
  Iterator* internal_iter = NewInternalIterator(options, &latest_snapshot);
  return NewDBIterator(
-    &dbname_, env_, options_,  user_comparator(),internal_iter,
+      &dbname_, env_, user_comparator(), internal_iter,
      (options.snapshot != nullptr
      ? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_
      : latest_snapshot));
@@ -32,26 +32,18 @@ public:
 virtual Status Get(const ReadOptions& options,
                    const Slice& key,
                    std::string* value);
-
- // TODO: Implement ReadOnly MultiGet?
-
 virtual Iterator* NewIterator(const ReadOptions&);

 virtual Status Put(const WriteOptions&, const Slice& key, const Slice& value) {
   return Status::NotSupported("Not supported operation in read only mode.");
 }
- virtual Status Merge(const WriteOptions&, const Slice& key,
-                      const Slice& value) {
-   return Status::NotSupported("Not supported operation in read only mode.");
- }
 virtual Status Delete(const WriteOptions&, const Slice& key) {
   return Status::NotSupported("Not supported operation in read only mode.");
 }
 virtual Status Write(const WriteOptions& options, WriteBatch* updates) {
   return Status::NotSupported("Not supported operation in read only mode.");
 }
- virtual void CompactRange(const Slice* begin, const Slice* end,
-                           bool reduce_level = false) {
+ virtual void CompactRange(const Slice* begin, const Slice* end) {
 }
 virtual Status DisableFileDeletions() {
   return Status::NotSupported("Not supported operation in read only mode.");
@@ -3,15 +3,11 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/db_iter.h"
-#include <stdexcept>
-#include <deque>

 #include "db/filename.h"
 #include "db/dbformat.h"
 #include "leveldb/env.h"
-#include "leveldb/options.h"
 #include "leveldb/iterator.h"
-#include "leveldb/merge_operator.h"
 #include "port/port.h"
 #include "util/logging.h"
 #include "util/mutexlock.h"
@@ -40,7 +36,6 @@ namespace {
 // numbers, deletion markers, overwrites, etc.
 class DBIter: public Iterator {
 public:
-  // The following is grossly complicated. TODO: clean it up
  // Which direction is the iterator currently moving?
  // (1) When moving forward, the internal iterator is positioned at
  //     the exact entry that yields this->key(), this->value()
@@ -51,34 +46,27 @@ class DBIter: public Iterator {
    kReverse
  };

-  DBIter(const std::string* dbname, Env* env, const Options& options,
+  DBIter(const std::string* dbname, Env* env,
         const Comparator* cmp, Iterator* iter, SequenceNumber s)
      : dbname_(dbname),
        env_(env),
-        logger_(options.info_log),
        user_comparator_(cmp),
-        user_merge_operator_(options.merge_operator.get()),
        iter_(iter),
        sequence_(s),
        direction_(kForward),
-        valid_(false),
-        current_entry_is_merged_(false),
-        statistics_(options.statistics) {
-    RecordTick(statistics_, NO_ITERATORS, 1);
+        valid_(false) {
  }
  virtual ~DBIter() {
-    RecordTick(statistics_, NO_ITERATORS, -1);
    delete iter_;
  }
  virtual bool Valid() const { return valid_; }
  virtual Slice key() const {
    assert(valid_);
-    return saved_key_;
+    return (direction_ == kForward) ? ExtractUserKey(iter_->key()) : saved_key_;
  }
  virtual Slice value() const {
    assert(valid_);
-    return (direction_ == kForward && !current_entry_is_merged_) ?
-      iter_->value() : saved_value_;
+    return (direction_ == kForward) ? iter_->value() : saved_value_;
  }
  virtual Status status() const {
    if (status_.ok()) {
@@ -95,10 +83,9 @@ class DBIter: public Iterator {
  virtual void SeekToLast();

 private:
-  void FindNextUserEntry(bool skipping);
+  void FindNextUserEntry(bool skipping, std::string* skip);
  void FindPrevUserEntry();
  bool ParseKey(ParsedInternalKey* key);
-  void MergeValuesNewToOld();

  inline void SaveKey(const Slice& k, std::string* dst) {
    dst->assign(k.data(), k.size());
@@ -115,20 +102,15 @@ class DBIter: public Iterator {

  const std::string* const dbname_;
  Env* const env_;
-  shared_ptr<Logger> logger_;
  const Comparator* const user_comparator_;
-  const MergeOperator* const user_merge_operator_;
  Iterator* const iter_;
  SequenceNumber const sequence_;

  Status status_;
  std::string saved_key_;     // == current key when direction_==kReverse
  std::string saved_value_;   // == current raw value when direction_==kReverse
-  std::string skip_key_;
  Direction direction_;
  bool valid_;
-  bool current_entry_is_merged_;
-  std::shared_ptr<Statistics> statistics_;

  // No copying allowed
  DBIter(const DBIter&);
@@ -138,8 +120,6 @@ class DBIter: public Iterator {
 inline bool DBIter::ParseKey(ParsedInternalKey* ikey) {
  if (!ParseInternalKey(iter_->key(), ikey)) {
    status_ = Status::Corruption("corrupted internal key in DBIter");
-    Log(logger_, "corrupted internal key in DBIter: %s",
-        iter_->key().ToString(true).c_str());
    return false;
  } else {
    return true;
@@ -166,156 +146,47 @@ void DBIter::Next() {
    }
  }

-  // If the current value is merged, we might already hit end of iter_
-  if (!iter_->Valid()) {
-    valid_ = false;
-    return;
-  }
-  FindNextUserEntry(true /* skipping the current user key */);
+  // Temporarily use saved_key_ as storage for key to skip.
+  std::string* skip = &saved_key_;
+  SaveKey(ExtractUserKey(iter_->key()), skip);
+  FindNextUserEntry(true, skip);
 }

-
-// PRE: saved_key_ has the current user key if skipping
-// POST: saved_key_ should have the next user key if valid_,
-//       if the current entry is a result of merge
-//           current_entry_is_merged_ => true
-//           saved_value_             => the merged value
-//
-// NOTE: In between, saved_key_ can point to a user key that has
-//       a delete marker
-void DBIter::FindNextUserEntry(bool skipping) {
+void DBIter::FindNextUserEntry(bool skipping, std::string* skip) {
  // Loop until we hit an acceptable entry to yield
  assert(iter_->Valid());
  assert(direction_ == kForward);
-  current_entry_is_merged_ = false;
  do {
    ParsedInternalKey ikey;
    if (ParseKey(&ikey) && ikey.sequence <= sequence_) {
-      if (skipping &&
-          user_comparator_->Compare(ikey.user_key, saved_key_) <= 0) {
-        // skip this entry
-      } else {
-        skipping = false;
-        switch (ikey.type) {
-          case kTypeDeletion:
-            // Arrange to skip all upcoming entries for this key since
-            // they are hidden by this deletion.
-            SaveKey(ikey.user_key, &saved_key_);
-            skipping = true;
-            break;
-          case kTypeValue:
+      switch (ikey.type) {
+        case kTypeDeletion:
+          // Arrange to skip all upcoming entries for this key since
+          // they are hidden by this deletion.
+          SaveKey(ikey.user_key, skip);
+          skipping = true;
+          break;
+        case kTypeValue:
+          if (skipping &&
+              user_comparator_->Compare(ikey.user_key, *skip) <= 0) {
+            // Entry hidden
+          } else {
            valid_ = true;
-            SaveKey(ikey.user_key, &saved_key_);
+            saved_key_.clear();
            return;
-          case kTypeMerge:
-            // By now, we are sure the current ikey is going to yield a value
-            SaveKey(ikey.user_key, &saved_key_);
-            current_entry_is_merged_ = true;
-            valid_ = true;
-            MergeValuesNewToOld();  // Go to a different state machine
-            return;
-          case kTypeLogData:
-            assert(false);
-            break;
-        }
+          }
+          break;
      }
    }
    iter_->Next();
  } while (iter_->Valid());
+  saved_key_.clear();
  valid_ = false;
 }

-// Merge values of the same user key starting from the current iter_ position
-// Scan from the newer entries to older entries.
-// PRE: iter_->key() points to the first merge type entry
-//      saved_key_ stores the user key
-// POST: saved_value_ has the merged value for the user key
-//       iter_ points to the next entry (or invalid)
-void DBIter::MergeValuesNewToOld() {
-  if (!user_merge_operator_) {
-    Log(logger_, "Options::merge_operator is null.");
-    throw std::logic_error("DBIter::MergeValuesNewToOld() with"
-                           " Options::merge_operator null");
-  }
-
-  // Start the merge process by pushing the first operand
-  std::deque<std::string> operands;
-  operands.push_front(iter_->value().ToString());
-
-  std::string merge_result;   // Temporary string to hold merge result later
-  ParsedInternalKey ikey;
-  for (iter_->Next(); iter_->Valid(); iter_->Next()) {
-    if (!ParseKey(&ikey)) {
-      // skip corrupted key
-      continue;
-    }
-
-    if (user_comparator_->Compare(ikey.user_key, saved_key_) != 0) {
-      // hit the next user key, stop right here
-      break;
-    }
-
-    if (kTypeDeletion == ikey.type) {
-      // hit a delete with the same user key, stop right here
-      // iter_ is positioned after delete
-      iter_->Next();
-      break;
-    }
-
-    if (kTypeValue == ikey.type) {
-      // hit a put, merge the put value with operands and store the
-      // final result in saved_value_. We are done!
-      // ignore corruption if there is any.
-      const Slice value = iter_->value();
-      user_merge_operator_->FullMerge(ikey.user_key, &value, operands,
-                                      &saved_value_, logger_.get());
-      // iter_ is positioned after put
-      iter_->Next();
-      return;
-    }
-
-    if (kTypeMerge == ikey.type) {
-      // hit a merge, add the value as an operand and run associative merge.
-      // when complete, add result to operands and continue.
-      const Slice& value = iter_->value();
-      operands.push_front(value.ToString());
-      while(operands.size() >= 2) {
-        // Call user associative-merge until it returns false
-        if (user_merge_operator_->PartialMerge(ikey.user_key,
-                                               Slice(operands[0]),
-                                               Slice(operands[1]),
-                                               &merge_result,
-                                               logger_.get())) {
-          operands.pop_front();
-          swap(operands.front(), merge_result);
-        } else {
-          // Associative merge returns false ==> stack the operands
-          break;
-        }
-      }
-
-    }
-  }
-
-  // we either exhausted all internal keys under this user key, or hit
-  // 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_, nullptr, operands,
-                                  &saved_value_, logger_.get());
-}
-
 void DBIter::Prev() {
  assert(valid_);

-  // Throw an exception now if merge_operator is provided
-  // TODO: support backward iteration
-  if (user_merge_operator_) {
-    Log(logger_, "Prev not supported yet if merge_operator is provided");
-    throw std::logic_error("DBIter::Prev backward iteration not supported"
-                           " if merge_operator is provided");
-  }
-
  if (direction_ == kForward) {  // Switch directions?
    // iter_ is pointing at the current entry.  Scan backwards until
    // the key changes so we can use the normal reverse scanning code.
@@ -390,7 +261,7 @@ void DBIter::Seek(const Slice& target) {
      &saved_key_, ParsedInternalKey(target, sequence_, kValueTypeForSeek));
  iter_->Seek(saved_key_);
  if (iter_->Valid()) {
-    FindNextUserEntry(false /*not skipping */);
+    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
  } else {
    valid_ = false;
  }
@@ -401,21 +272,13 @@ void DBIter::SeekToFirst() {
  ClearSavedValue();
  iter_->SeekToFirst();
  if (iter_->Valid()) {
-    FindNextUserEntry(false /* not skipping */);
+    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
  } else {
    valid_ = false;
  }
 }

 void DBIter::SeekToLast() {
-  // Throw an exception for now if merge_operator is provided
-  // TODO: support backward iteration
-  if (user_merge_operator_) {
-    Log(logger_, "SeekToLast not supported yet if merge_operator is provided");
-    throw std::logic_error("DBIter::SeekToLast: backward iteration not"
-                           " supported if merge_operator is provided");
-  }
-
  direction_ = kReverse;
  ClearSavedValue();
  iter_->SeekToLast();
@@ -427,12 +290,10 @@ void DBIter::SeekToLast() {
 Iterator* NewDBIterator(
    const std::string* dbname,
    Env* env,
-    const Options& options,
-    const Comparator *user_key_comparator,
+    const Comparator* user_key_comparator,
    Iterator* internal_iter,
    const SequenceNumber& sequence) {
-  return new DBIter(dbname, env, options, user_key_comparator,
-                    internal_iter, sequence);
+  return new DBIter(dbname, env, user_key_comparator, internal_iter, sequence);
 }

 }  // namespace leveldb
@@ -17,8 +17,7 @@ namespace leveldb {
 extern Iterator* NewDBIterator(
    const std::string* dbname,
    Env* env,
-    const Options& options,
-    const Comparator *user_key_comparator,
+    const Comparator* user_key_comparator,
    Iterator* internal_iter,
    const SequenceNumber& sequence);

@@ -8,7 +8,6 @@
 #include <cassert>
 #include <stdlib.h>
 #include <vector>
-#include <memory>

 #include "leveldb/statistics.h"
 #include "util/histogram.h"
@@ -30,11 +29,6 @@ class DBStatistics: public Statistics {
    return allTickers_[tickerType].getCount();
  }

-  virtual void setTickerCount(Tickers tickerType, uint64_t count) {
-    assert(tickerType < TICKER_ENUM_MAX);
-    allTickers_[tickerType].setTickerCount(count);
-  }
-
  virtual void recordTick(Tickers tickerType, uint64_t count) {
    assert(tickerType < TICKER_ENUM_MAX);
    allTickers_[tickerType].recordTick(count);
@@ -45,6 +39,11 @@ class DBStatistics: public Statistics {
    allHistograms_[histogramType].Add(value);
  }

+  virtual void measureTime(Histograms histogramType, double value) {
+    assert(histogramType < HISTOGRAM_ENUM_MAX);
+    allHistograms_[histogramType].Add(value);
+  }
+
  virtual void histogramData(Histograms histogramType,
                             HistogramData * const data) {
    assert(histogramType < HISTOGRAM_ENUM_MAX);
@@ -54,11 +53,6 @@ class DBStatistics: public Statistics {
  std::vector<Ticker> allTickers_;
  std::vector<HistogramImpl> allHistograms_;
 };
-
-std::shared_ptr<Statistics> CreateDBStatistics() {
-  return std::make_shared<DBStatistics>();
-}
-
 } // namespace leveldb

 #endif // LEVELDB_STORAGE_DB_DB_STATISTICS_H_
@@ -6,7 +6,6 @@
 #include "db/dbformat.h"
 #include "port/port.h"
 #include "util/coding.h"
-#include "include/leveldb/perf_context.h"

 namespace leveldb {

@@ -45,7 +44,7 @@ std::string InternalKey::DebugString(bool hex) const {
 }

 const char* InternalKeyComparator::Name() const {
-  return name_.c_str();
+  return "leveldb.InternalKeyComparator";
 }

 int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
@@ -54,7 +53,6 @@ int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
  //    decreasing sequence number
  //    decreasing type (though sequence# should be enough to disambiguate)
  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
-  perf_context.user_key_comparison_count++;
  if (r == 0) {
    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
@@ -24,9 +24,7 @@ class InternalKey;
 // data structures.
 enum ValueType {
  kTypeDeletion = 0x0,
-  kTypeValue = 0x1,
-  kTypeMerge = 0x2,
-  kTypeLogData = 0x3
+  kTypeValue = 0x1
 };
 // kValueTypeForSeek defines the ValueType that should be passed when
 // constructing a ParsedInternalKey object for seeking to a particular
@@ -34,7 +32,7 @@ enum ValueType {
 // and the value type is embedded as the low 8 bits in the sequence
 // number in internal keys, we need to use the highest-numbered
 // ValueType, not the lowest).
-static const ValueType kValueTypeForSeek = kTypeMerge;
+static const ValueType kValueTypeForSeek = kTypeValue;

 // We leave eight bits empty at the bottom so a type and sequence#
 // can be packed together into 64-bits.
@@ -87,13 +85,8 @@ inline ValueType ExtractValueType(const Slice& internal_key) {
 class InternalKeyComparator : public Comparator {
 private:
  const Comparator* user_comparator_;
-  std::string name_;
 public:
-  explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
-    name_("leveldb.InternalKeyComparator:" +
-          std::string(user_comparator_->Name())) {
-  }
-
+  explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c) { }
  virtual const char* Name() const;
  virtual int Compare(const Slice& a, const Slice& b) const;
  virtual void FindShortestSeparator(
@@ -161,7 +154,7 @@ inline bool ParseInternalKey(const Slice& internal_key,
  result->sequence = num >> 8;
  result->type = static_cast<ValueType>(c);
  result->user_key = Slice(internal_key.data(), n - 8);
-  return (c <= static_cast<unsigned char>(kValueTypeForSeek));
+  return (c <= static_cast<unsigned char>(kTypeValue));
 }

 // Update the sequence number in the internal key
@@ -174,15 +167,6 @@ inline void UpdateInternalKey(char* internal_key,
  EncodeFixed64(seqtype, newval);
 }

-// Get the sequence number from the internal key
-inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
-  const size_t n = internal_key.size();
-  assert(n >= 8);
-  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
-  return num >> 8;
-}
-
-
 // A helper class useful for DBImpl::Get()
 class LookupKey {
 public:
@@ -46,13 +46,10 @@ extern Status WriteStringToFileSync(Env* env, const Slice& data,
 static std::string MakeFileName(const std::string& name, uint64_t number,
                                const char* suffix) {
  char buf[100];
-  snprintf(buf, sizeof(buf), "%06llu.%s",
+  snprintf(buf, sizeof(buf), "/%06llu.%s",
           static_cast<unsigned long long>(number),
           suffix);
-  if (name.empty()) {
-    return buf;
-  }
-  return name + "/" + buf;
+  return name + buf;
 }

 std::string LogFileName(const std::string& name, uint64_t number) {
@@ -0,0 +1,48 @@
+// Copyright 2008-present Facebook. All Rights Reserved.
+
+#ifndef STORAGE_LEVELDB_DB_LOG_FILE_H_
+#define STORAGE_LEVELDB_DB_LOG_FILE_H_
+
+namespace leveldb {
+
+enum  WalFileType {
+  kArchivedLogFile = 0,
+  kAliveLogFile = 1
+} ;
+
+class LogFile {
+
+ public:
+  uint64_t logNumber;
+  WalFileType type;
+
+  LogFile(uint64_t logNum,WalFileType logType) :
+    logNumber(logNum),
+    type(logType) {}
+
+  LogFile(const LogFile& that) {
+   logNumber = that.logNumber;
+   type = that.type;
+  }
+
+  bool operator < (const LogFile& that) const {
+    return logNumber < that.logNumber;
+  }
+
+  std::string ToString() const {
+    char response[100];
+    const char* typeOfLog;
+    if (type == kAliveLogFile) {
+      typeOfLog = "Alive Log";
+    } else {
+      typeOfLog = "Archived Log";
+    }
+    sprintf(response,
+            "LogNumber  : %ld LogType : %s",
+            logNumber,
+            typeOfLog);
+    return std::string(response);
+  }
+};
+}  //  namespace leveldb
+#endif  // STORAGE_LEVELDB_DB_LOG_FILE_H_
@@ -24,7 +24,7 @@ enum RecordType {
 };
 static const int kMaxRecordType = kLastType;

-static const unsigned int kBlockSize = 32768;
+static const int kBlockSize = 32768;

 // Header is checksum (4 bytes), type (1 byte), length (2 bytes).
 static const int kHeaderSize = 4 + 1 + 2;
@@ -59,17 +59,6 @@ class Reader {
  // Undefined before the first call to ReadRecord.
  uint64_t LastRecordOffset();

-  // returns true if the reader has encountered an eof condition.
-  bool IsEOF() {
-    return eof_;
-  }
-
-  // when we know more data has been written to the file. we can use this
-  // function to force the reader to look again in the file.
-  void UnmarkEOF() {
-    eof_ = false;
-  }
-
  SequentialFile* file() { return file_.get(); }

 private:
@@ -450,13 +450,13 @@ TEST(LogTest, ErrorJoinsRecords) {
  Write("correct");

  // Wipe the middle block
-  for (unsigned int offset = kBlockSize; offset < 2*kBlockSize; offset++) {
+  for (int offset = kBlockSize; offset < 2*kBlockSize; offset++) {
    SetByte(offset, 'x');
  }

  ASSERT_EQ("correct", Read());
  ASSERT_EQ("EOF", Read());
-  const unsigned int dropped = DroppedBytes();
+  const int dropped = DroppedBytes();
  ASSERT_LE(dropped, 2*kBlockSize + 100);
  ASSERT_GE(dropped, 2*kBlockSize);
 }
@@ -3,14 +3,10 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/memtable.h"
-
-#include <memory>
-
 #include "db/dbformat.h"
 #include "leveldb/comparator.h"
 #include "leveldb/env.h"
 #include "leveldb/iterator.h"
-#include "leveldb/merge_operator.h"
 #include "util/coding.h"

 namespace leveldb {
@@ -22,28 +18,22 @@ static Slice GetLengthPrefixedSlice(const char* data) {
  return Slice(p, len);
 }

-MemTable::MemTable(const InternalKeyComparator& cmp,
-                   std::shared_ptr<MemTableRepFactory> table_factory,
-                   int numlevel,
-                   const Options& options)
+MemTable::MemTable(const InternalKeyComparator& cmp, int numlevel)
    : comparator_(cmp),
      refs_(0),
-      arena_impl_(options.arena_block_size),
-      table_(table_factory->CreateMemTableRep(comparator_, &arena_impl_)),
+      table_(comparator_, &arena_),
      flush_in_progress_(false),
      flush_completed_(false),
      file_number_(0),
      edit_(numlevel),
-      first_seqno_(0),
-      mem_logfile_number_(0) { }
+      first_seqno_(0) {
+}

 MemTable::~MemTable() {
  assert(refs_ == 0);
 }

-size_t MemTable::ApproximateMemoryUsage() {
-  return arena_impl_.ApproximateMemoryUsage();
-}
+size_t MemTable::ApproximateMemoryUsage() { return arena_.MemoryUsage(); }

 int MemTable::KeyComparator::operator()(const char* aptr, const char* bptr)
    const {
@@ -65,27 +55,24 @@ static const char* EncodeKey(std::string* scratch, const Slice& target) {

 class MemTableIterator: public Iterator {
 public:
-  explicit MemTableIterator(MemTableRep* table)
-    : iter_(table->GetIterator()) { }
+  explicit MemTableIterator(MemTable::Table* table) : iter_(table) { }

-  virtual bool Valid() const { return iter_->Valid(); }
-  virtual void Seek(const Slice& k) { iter_->Seek(EncodeKey(&tmp_, k)); }
-  virtual void SeekToFirst() { iter_->SeekToFirst(); }
-  virtual void SeekToLast() { iter_->SeekToLast(); }
-  virtual void Next() { iter_->Next(); }
-  virtual void Prev() { iter_->Prev(); }
-  virtual Slice key() const {
-    return GetLengthPrefixedSlice(iter_->key());
-  }
+  virtual bool Valid() const { return iter_.Valid(); }
+  virtual void Seek(const Slice& k) { iter_.Seek(EncodeKey(&tmp_, k)); }
+  virtual void SeekToFirst() { iter_.SeekToFirst(); }
+  virtual void SeekToLast() { iter_.SeekToLast(); }
+  virtual void Next() { iter_.Next(); }
+  virtual void Prev() { iter_.Prev(); }
+  virtual Slice key() const { return GetLengthPrefixedSlice(iter_.key()); }
  virtual Slice value() const {
-    Slice key_slice = GetLengthPrefixedSlice(iter_->key());
+    Slice key_slice = GetLengthPrefixedSlice(iter_.key());
    return GetLengthPrefixedSlice(key_slice.data() + key_slice.size());
  }

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

 private:
-  std::shared_ptr<MemTableRep::Iterator> iter_;
+  MemTable::Table::Iterator iter_;
  std::string tmp_;       // For passing to EncodeKey

  // No copying allowed
@@ -94,7 +81,7 @@ class MemTableIterator: public Iterator {
 };

 Iterator* MemTable::NewIterator() {
-  return new MemTableIterator(table_.get());
+  return new MemTableIterator(&table_);
 }

 void MemTable::Add(SequenceNumber s, ValueType type,
@@ -111,7 +98,7 @@ void MemTable::Add(SequenceNumber s, ValueType type,
  const size_t encoded_len =
      VarintLength(internal_key_size) + internal_key_size +
      VarintLength(val_size) + val_size;
-  char* buf = arena_impl_.Allocate(encoded_len);
+  char* buf = arena_.Allocate(encoded_len);
  char* p = EncodeVarint32(buf, internal_key_size);
  memcpy(p, key.data(), key_size);
  p += key_size;
@@ -120,7 +107,7 @@ void MemTable::Add(SequenceNumber s, ValueType type,
  p = EncodeVarint32(p, val_size);
  memcpy(p, value.data(), val_size);
  assert((p + val_size) - buf == (unsigned)encoded_len);
-  table_->Insert(buf);
+  table_.Insert(buf);

  // The first sequence number inserted into the memtable
  assert(first_seqno_ == 0 || s > first_seqno_);
@@ -129,21 +116,11 @@ void MemTable::Add(SequenceNumber s, ValueType type,
  }
 }

-bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
-                   std::deque<std::string>* operands, const Options& options) {
+bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
  Slice memkey = key.memtable_key();
-  std::shared_ptr<MemTableRep::Iterator> iter(table_.get()->GetIterator());
-  iter->Seek(memkey.data());
-
-  // It is the caller's responsibility to allocate/delete operands list
-  assert(operands != nullptr);
-
-  bool merge_in_progress = s->IsMergeInProgress();
-  auto merge_operator = options.merge_operator.get();
-  auto logger = options.info_log;
-  std::string merge_result;
-
-  for (; iter->Valid(); iter->Next()) {
+  Table::Iterator iter(&table_);
+  iter.Seek(memkey.data());
+  if (iter.Valid()) {
    // entry format is:
    //    klength  varint32
    //    userkey  char[klength-8]
@@ -153,7 +130,7 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
    // Check that it belongs to same user key.  We do not check the
    // sequence number since the Seek() call above should have skipped
    // all entries with overly large sequence numbers.
-    const char* entry = iter->key();
+    const char* entry = iter.key();
    uint32_t key_length;
    const char* key_ptr = GetVarint32Ptr(entry, entry+5, &key_length);
    if (comparator_.comparator.user_comparator()->Compare(
@@ -164,68 +141,15 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
      switch (static_cast<ValueType>(tag & 0xff)) {
        case kTypeValue: {
          Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
-          *s = Status::OK();
-          if (merge_in_progress) {
-            assert(merge_operator);
-            if (!merge_operator->FullMerge(key.user_key(), &v, *operands,
-                                           value, logger.get())) {
-              RecordTick(options.statistics, NUMBER_MERGE_FAILURES);
-              *s = Status::Corruption("Error: Could not perform merge.");
-            }
-          } else {
-            value->assign(v.data(), v.size());
-          }
+          value->assign(v.data(), v.size());
          return true;
        }
-        case kTypeDeletion: {
-          if (merge_in_progress) {
-            assert(merge_operator);
-            *s = Status::OK();
-            if (!merge_operator->FullMerge(key.user_key(), nullptr, *operands,
-                                           value, logger.get())) {
-              RecordTick(options.statistics, NUMBER_MERGE_FAILURES);
-              *s = Status::Corruption("Error: Could not perform merge.");
-            }
-          } else {
-            *s = Status::NotFound(Slice());
-          }
+        case kTypeDeletion:
+          *s = Status::NotFound(Slice());
          return true;
-        }
-        case kTypeMerge: {
-          Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
-          merge_in_progress = true;
-          operands->push_front(v.ToString());
-          while(operands->size() >= 2) {
-            // Attempt to associative merge. (Returns true if successful)
-            if (merge_operator->PartialMerge(key.user_key(),
-                                             Slice((*operands)[0]),
-                                             Slice((*operands)[1]),
-                                             &merge_result,
-                                             logger.get())) {
-              operands->pop_front();
-              swap(operands->front(), merge_result);
-            } else {
-              // Stack them because user can't associative merge
-              break;
-            }
-          }
-          break;
-        }
-        case kTypeLogData:
-          assert(false);
-          break;
      }
-    } else {
-      // exit loop if user key does not match
-      break;
    }
  }
-
-  // No change to value, since we have not yet found a Put/Delete
-
-  if (merge_in_progress) {
-    *s = Status::MergeInProgress("");
-  }
  return false;
 }

@@ -6,35 +6,24 @@
 #define STORAGE_LEVELDB_DB_MEMTABLE_H_

 #include <string>
-#include <memory>
-#include <deque>
+#include "leveldb/db.h"
 #include "db/dbformat.h"
 #include "db/skiplist.h"
 #include "db/version_set.h"
-#include "leveldb/db.h"
-#include "leveldb/memtablerep.h"
-#include "util/arena_impl.h"
+#include "util/arena.h"

 namespace leveldb {

+class InternalKeyComparator;
 class Mutex;
 class MemTableIterator;

 class MemTable {
 public:
-  struct KeyComparator : public MemTableRep::KeyComparator {
-    const InternalKeyComparator comparator;
-    explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
-    virtual int operator()(const char* a, const char* b) const;
-  };
-
  // MemTables are reference counted.  The initial reference count
  // is zero and the caller must call Ref() at least once.
-  explicit MemTable(
-    const InternalKeyComparator& comparator,
-    std::shared_ptr<MemTableRepFactory> table_factory,
-    int numlevel = 7,
-    const Options& options = Options());
+  explicit MemTable(const InternalKeyComparator& comparator,
+                    int numlevel = 7);

  // Increase reference count.
  void Ref() { ++refs_; }
@@ -73,13 +62,8 @@ class MemTable {
  // If memtable contains a value for key, store it in *value and return true.
  // If memtable contains a deletion for key, store a NotFound() error
  // in *status and return true.
-  // If memtable contains Merge operation as the most recent entry for a key,
-  //   and the merge process does not stop (not reaching a value or delete),
-  //   prepend the current merge operand to *operands.
-  //   store MergeInProgress in s, and return false.
  // Else, return false.
-  bool Get(const LookupKey& key, std::string* value, Status* s,
-           std::deque<std::string>* operands, const Options& options);
+  bool Get(const LookupKey& key, std::string* value, Status* s);

  // Returns the edits area that is needed for flushing the memtable
  VersionEdit* GetEdits() { return &edit_; }
@@ -88,24 +72,24 @@ class MemTable {
  // into the memtable
  SequenceNumber GetFirstSequenceNumber() { return first_seqno_; }

-  // Returns the logfile number that can be safely deleted when this
-  // memstore is flushed to storage
-  uint64_t GetLogNumber() { return mem_logfile_number_; }
-
-  // Sets the logfile number that can be safely deleted when this
-  // memstore is flushed to storage
-  void SetLogNumber(uint64_t num) { mem_logfile_number_ = num; }
-
 private:
  ~MemTable();  // Private since only Unref() should be used to delete it
+
+  struct KeyComparator {
+    const InternalKeyComparator comparator;
+    explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
+    int operator()(const char* a, const char* b) const;
+  };
  friend class MemTableIterator;
  friend class MemTableBackwardIterator;
  friend class MemTableList;

+  typedef SkipList<const char*, KeyComparator> Table;
+
  KeyComparator comparator_;
  int refs_;
-  ArenaImpl arena_impl_;
-  shared_ptr<MemTableRep> table_;
+  Arena arena_;
+  Table table_;

  // These are used to manage memtable flushes to storage
  bool flush_in_progress_; // started the flush
@@ -119,9 +103,6 @@ class MemTable {
  // The sequence number of the kv that was inserted first
  SequenceNumber first_seqno_;

-  // The log files earlier than this number can be deleted.
-  uint64_t mem_logfile_number_;
-
  // No copying allowed
  MemTable(const MemTable&);
  void operator=(const MemTable&);
@@ -21,15 +21,17 @@ using std::list;

 // Increase reference count on all underling memtables
 void MemTableList::RefAll() {
-  for (auto &memtable : memlist_) {
-    memtable->Ref();
+  for (list<MemTable*>::iterator it = memlist_.begin();
+       it != memlist_.end() ; ++it) {
+    (*it)->Ref();
  }
 }

 // Drop reference count on all underling memtables
 void MemTableList::UnrefAll() {
-  for (auto &memtable : memlist_) {
-    memtable->Unref();
+  for (list<MemTable*>::iterator it = memlist_.begin();
+       it != memlist_.end() ; ++it) {
+    (*it)->Unref();
  }
 }

@@ -41,17 +43,19 @@ int MemTableList::size() {

 // Returns true if there is at least one memtable on which flush has
 // not yet started.
-bool MemTableList::IsFlushPending(int min_write_buffer_number_to_merge) {
-  if (num_flush_not_started_ >= min_write_buffer_number_to_merge) {
+bool MemTableList::IsFlushPending() {
+  if (num_flush_not_started_ > 0) {
    assert(imm_flush_needed.NoBarrier_Load() != nullptr);
    return true;
  }
  return false;
 }

-// Returns the memtables that need to be flushed.
-void MemTableList::PickMemtablesToFlush(std::vector<MemTable*>* ret) {
-  for (auto it = memlist_.rbegin(); it != memlist_.rend(); it++) {
+// Returns the earliest memtable that needs to be flushed.
+// Returns null, if no such memtable exist.
+MemTable* MemTableList::PickMemtableToFlush() {
+  for (list<MemTable*>::reverse_iterator it = memlist_.rbegin();
+       it != memlist_.rend(); it++) {
    MemTable* m = *it;
    if (!m->flush_in_progress_) {
      assert(!m->flush_completed_);
@@ -60,48 +64,37 @@ void MemTableList::PickMemtablesToFlush(std::vector<MemTable*>* ret) {
        imm_flush_needed.Release_Store(nullptr);
      }
      m->flush_in_progress_ = true; // flushing will start very soon
-      ret->push_back(m);
+      return m;
    }
  }
+  return nullptr;
 }

 // Record a successful flush in the manifest file
-Status MemTableList::InstallMemtableFlushResults(
-                      const std::vector<MemTable*> &mems,
+Status MemTableList::InstallMemtableFlushResults(MemTable* m,
                      VersionSet* vset, Status flushStatus,
                      port::Mutex* mu, Logger* info_log,
                      uint64_t file_number,
                      std::set<uint64_t>& pending_outputs) {
  mu->AssertHeld();
+  assert(m->flush_in_progress_);
+  assert(m->file_number_ == 0);

  // If the flush was not successful, then just reset state.
  // Maybe a suceeding attempt to flush will be successful.
  if (!flushStatus.ok()) {
-    for (MemTable* m : mems) {
-      assert(m->flush_in_progress_);
-      assert(m->file_number_ == 0);
-
-      m->flush_in_progress_ = false;
-      m->flush_completed_ = false;
-      m->edit_.Clear();
-      num_flush_not_started_++;
-      imm_flush_needed.Release_Store((void *)1);
-      pending_outputs.erase(file_number);
-    }
+    m->flush_in_progress_ = false;
+    m->flush_completed_ = false;
+    m->edit_.Clear();
+    num_flush_not_started_++;
+    imm_flush_needed.Release_Store((void *)1);
+    pending_outputs.erase(file_number);
    return flushStatus;
  }

  // flush was sucessful
-  bool first = true;
-  for (MemTable* m : mems) {
-
-    // All the edits are associated with the first memtable of this batch.
-    assert(first || m->GetEdits()->NumEntries() == 0);
-    first = false;
-
-    m->flush_completed_ = true;
-    m->file_number_ = file_number;
-  }
+  m->flush_completed_ = true;
+  m->file_number_ = file_number;

  // if some other thread is already commiting, then return
  Status s;
@@ -113,15 +106,12 @@ Status MemTableList::InstallMemtableFlushResults(
  commit_in_progress_ = true;

  // scan all memtables from the earliest, and commit those
-  // (in that order) that have finished flushing. Memetables
-  // are always committed in the order that they were created.
-  while (!memlist_.empty() && s.ok()) {
-    MemTable* m = memlist_.back(); // get the last element
+  // (in that order) that have finished flushing.
+  while (!memlist_.empty()) {
+    m = memlist_.back(); // get the last element
    if (!m->flush_completed_) {
      break;
    }
-    first = true;
-
    Log(info_log,
        "Level-0 commit table #%llu: started",
        (unsigned long long)m->file_number_);
@@ -129,39 +119,33 @@ Status MemTableList::InstallMemtableFlushResults(
    // this can release and reacquire the mutex.
    s = vset->LogAndApply(&m->edit_, mu);

-    // All the later memtables that have the same filenum
-    // are part of the same batch. They can be committed now.
-    do {
-      if (s.ok()) { // commit new state
-        Log(info_log, "Level-0 commit table #%llu: done %s",
-                       (unsigned long long)m->file_number_,
-                       first ? "": "bulk");
-        memlist_.remove(m);
-        assert(m->file_number_ > 0);
+    if (s.ok()) { // commit new state
+      Log(info_log, "Level-0 commit table #%llu: done",
+                     (unsigned long long)m->file_number_);
+      memlist_.remove(m);
+      assert(m->file_number_ > 0);

-        // pending_outputs can be cleared only after the newly created file
-        // has been written to a committed version so that other concurrently
-        // executing compaction threads do not mistakenly assume that this
-        // file is not live.
-        pending_outputs.erase(m->file_number_);
-        m->Unref();
-        size_--;
-      } else {
-        //commit failed. setup state so that we can flush again.
-        Log(info_log, "Level-0 commit table #%llu: failed",
-                       (unsigned long long)m->file_number_);
-        m->flush_completed_ = false;
-        m->flush_in_progress_ = false;
-        m->edit_.Clear();
-        num_flush_not_started_++;
-        pending_outputs.erase(m->file_number_);
-        m->file_number_ = 0;
-        imm_flush_needed.Release_Store((void *)1);
-        s = Status::IOError("Unable to commit flushed memtable");
-      }
-      first = false;
-    } while (!memlist_.empty() && (m = memlist_.back()) &&
-             m->file_number_ == file_number);
+      // pending_outputs can be cleared only after the newly created file
+      // has been written to a committed version so that other concurrently
+      // executing compaction threads do not mistakenly assume that this
+      // file is not live.
+      pending_outputs.erase(m->file_number_);
+      m->Unref();
+      size_--;
+    } else {
+      //commit failed. setup state so that we can flush again.
+      Log(info_log, "Level-0 commit table #%llu: failed",
+                     (unsigned long long)m->file_number_);
+      m->flush_completed_ = false;
+      m->flush_in_progress_ = false;
+      m->edit_.Clear();
+      num_flush_not_started_++;
+      pending_outputs.erase(m->file_number_);
+      m->file_number_ = 0;
+      imm_flush_needed.Release_Store((void *)1);
+      s = Status::IOError("Unable to commit flushed memtable");
+      break;
+    }
  }
  commit_in_progress_ = false;
  return s;
@@ -181,20 +165,19 @@ void MemTableList::Add(MemTable* m) {
 // Returns an estimate of the number of bytes of data in use.
 size_t MemTableList::ApproximateMemoryUsage() {
  size_t size = 0;
-  for (auto &memtable : memlist_) {
-    size += memtable->ApproximateMemoryUsage();
+  for (list<MemTable*>::iterator it = memlist_.begin();
+       it != memlist_.end(); ++it) {
+    size += (*it)->ApproximateMemoryUsage();
  }
  return size;
 }

 // Search all the memtables starting from the most recent one.
 // Return the most recent value found, if any.
-// Operands stores the list of merge operations to apply, so far.
-bool MemTableList::Get(const LookupKey& key, std::string* value, Status* s,
-                       std::deque<std::string>* operands,
-                       const Options& options) {
-  for (auto &memtable : memlist_) {
-    if (memtable->Get(key, value, s, operands, options)) {
+bool MemTableList::Get(const LookupKey& key, std::string* value, Status* s) {
+  for (list<MemTable*>::iterator it = memlist_.begin();
+       it != memlist_.end(); ++it) {
+    if ((*it)->Get(key, value, s)) {
      return true;
    }
  }
@@ -202,8 +185,9 @@ bool MemTableList::Get(const LookupKey& key, std::string* value, Status* s,
 }

 void MemTableList::GetMemTables(std::vector<MemTable*>* output) {
-  for (auto &memtable : memlist_) {
-    output->push_back(memtable);
+  for (list<MemTable*>::iterator it = memlist_.begin();
+       it != memlist_.end(); ++it) {
+    output->push_back(*it);
  }
 }

@@ -5,10 +5,10 @@

 #include <string>
 #include <list>
-#include <deque>
 #include "leveldb/db.h"
 #include "db/dbformat.h"
 #include "db/skiplist.h"
+#include "util/arena.h"
 #include "memtable.h"

 namespace leveldb {
@@ -18,7 +18,7 @@ class Mutex;
 class MemTableListIterator;

 //
-// This class stores references to all the immutable memtables.
+// This class stores refeernces to all the immutable memtables.
 // The memtables are flushed to L0 as soon as possible and in
 // any order. If there are more than one immutable memtable, their
 // flushes can occur concurrently.  However, they are 'committed'
@@ -49,13 +49,14 @@ class MemTableList {

  // Returns true if there is at least one memtable on which flush has
  // not yet started.
-  bool IsFlushPending(int min_write_buffer_number_to_merge);
+  bool IsFlushPending();

-  // Returns the earliest memtables that needs to be flushed.
-  void PickMemtablesToFlush(std::vector<MemTable*>* mems);
+  // Returns the earliest memtable that needs to be flushed.
+  // Returns null, if no such memtable exist.
+  MemTable* PickMemtableToFlush();

  // Commit a successful flush in the manifest file
-  Status InstallMemtableFlushResults(const std::vector<MemTable*> &m,
+  Status InstallMemtableFlushResults(MemTable* m,
                      VersionSet* vset, Status flushStatus,
                      port::Mutex* mu, Logger* info_log,
                      uint64_t file_number,
@@ -70,8 +71,7 @@ class MemTableList {

  // Search all the memtables starting from the most recent one.
  // Return the most recent value found, if any.
-  bool Get(const LookupKey& key, std::string* value, Status* s,
-           std::deque<std::string>* operands, const Options& options);
+  bool Get(const LookupKey& key, std::string* value, Status* s);

  // Returns the list of underlying memtables.
  void GetMemTables(std::vector<MemTable*>* list);
@@ -1,192 +0,0 @@
-#include "merge_helper.h"
-#include "db/dbformat.h"
-#include "leveldb/comparator.h"
-#include "leveldb/db.h"
-#include "leveldb/merge_operator.h"
-#include <string>
-#include <stdio.h>
-
-namespace leveldb {
-
-// PRE:  iter points to the first merge type entry
-// POST: iter points to the first entry beyond the merge process (or the end)
-//       keys_, operands_ are updated to reflect the merge result.
-//       keys_ stores the list of keys encountered while merging.
-//       operands_ stores the list of merge operands encountered while merging.
-//       keys_[i] corresponds to operands_[i] for each i.
-void MergeHelper::MergeUntil(Iterator* iter, SequenceNumber stop_before,
-                             bool at_bottom, shared_ptr<Statistics> stats) {
-  // Get a copy of the internal key, before it's invalidated by iter->Next()
-  // Also maintain the list of merge operands seen.
-  keys_.clear();
-  operands_.clear();
-  keys_.push_front(iter->key().ToString());
-  operands_.push_front(iter->value().ToString());
-
-  success_ = false;   // Will become true if we hit Put/Delete or bottom
-
-  // We need to parse the internal key again as the parsed key is
-  // backed by the internal key!
-  // Assume no internal key corruption as it has been successfully parsed
-  // by the caller.
-  // Invariant: keys_.back() will not change. Hence, orig_ikey is always valid.
-  ParsedInternalKey orig_ikey;
-  ParseInternalKey(keys_.back(), &orig_ikey);
-
-  bool hit_the_next_user_key = false;
-  ParsedInternalKey ikey;
-  std::string merge_result;  // Temporary value for merge results
-  for (iter->Next(); iter->Valid(); iter->Next()) {
-    assert(operands_.size() >= 1);        // Should be invariants!
-    assert(keys_.size() == operands_.size());
-
-    if (!ParseInternalKey(iter->key(), &ikey)) {
-      // stop at corrupted key
-      if (assert_valid_internal_key_) {
-        assert(!"corrupted internal key is not expected");
-      }
-      break;
-    }
-
-    if (user_comparator_->Compare(ikey.user_key, orig_ikey.user_key) != 0) {
-      // hit a different user key, stop right here
-      hit_the_next_user_key = true;
-      break;
-    }
-
-    if (stop_before && ikey.sequence <= stop_before) {
-      // hit an entry that's visible by the previous snapshot, can't touch that
-      break;
-    }
-
-    // At this point we are guaranteed that we need to process this key.
-
-    if (kTypeDeletion == ikey.type) {
-      // hit a delete
-      //   => merge nullptr with operands_
-      //   => store result in operands_.back() (and update keys_.back())
-      //   => change the entry type to kTypeValue for keys_.back()
-      // We are done! Return a success if the merge passes.
-      success_ = user_merge_operator_->FullMerge(ikey.user_key, nullptr,
-                                                 operands_, &merge_result,
-                                                 logger_);
-
-      // We store the result in keys_.back() and operands_.back()
-      // if nothing went wrong (i.e.: no operand corruption on disk)
-      if (success_) {
-        std::string& key = keys_.back();  // The original key encountered
-        orig_ikey.type = kTypeValue;
-        UpdateInternalKey(&key[0], key.size(),
-                          orig_ikey.sequence, orig_ikey.type);
-        swap(operands_.back(), merge_result);
-      } else {
-        RecordTick(stats, NUMBER_MERGE_FAILURES);
-      }
-
-      // move iter to the next entry (before doing anything else)
-      iter->Next();
-      return;
-    }
-
-    if (kTypeValue == ikey.type) {
-      // hit a put
-      //   => merge the put value with operands_
-      //   => store result in operands_.back() (and update keys_.back())
-      //   => change the entry type to kTypeValue for keys_.back()
-      // We are done! Success!
-      const Slice value = iter->value();
-      success_ = user_merge_operator_->FullMerge(ikey.user_key, &value,
-                                                 operands_, &merge_result,
-                                                 logger_);
-
-      // We store the result in keys_.back() and operands_.back()
-      // if nothing went wrong (i.e.: no operand corruption on disk)
-      if (success_) {
-        std::string& key = keys_.back();  // The original key encountered
-        orig_ikey.type = kTypeValue;
-        UpdateInternalKey(&key[0], key.size(),
-                          orig_ikey.sequence, orig_ikey.type);
-        swap(operands_.back(), merge_result);
-      } else {
-        RecordTick(stats, NUMBER_MERGE_FAILURES);
-      }
-
-      // move iter to the next entry
-      iter->Next();
-      return;
-    }
-
-    if (kTypeMerge == ikey.type) {
-      // hit a merge
-      //   => merge the operand into the front of the operands_ list
-      //   => use the user's associative merge function to determine how.
-      //   => then continue because we haven't yet seen a Put/Delete.
-      assert(!operands_.empty()); // Should have at least one element in it
-
-      keys_.push_front(iter->key().ToString());
-      operands_.push_front(iter->value().ToString());
-      while (operands_.size() >= 2) {
-        // Returns false when the merge_operator can no longer process it
-        if (user_merge_operator_->PartialMerge(ikey.user_key,
-                                               Slice(operands_[0]),
-                                               Slice(operands_[1]),
-                                               &merge_result,
-                                               logger_)) {
-          // Merging of operands (associative merge) was successful.
-          // Replace these frontmost two operands with the merge result
-          keys_.pop_front();
-          operands_.pop_front();
-          swap(operands_.front(), merge_result);
-        } else {
-          // Merging of operands (associative merge) returned false.
-          // The user merge_operator does not know how to merge these operands.
-          // So we just stack them up until we find a Put/Delete or end of key.
-          break;
-        }
-      }
-      continue;
-    }
-  }
-
-  // We are sure we have seen this key's entire history if we are at the
-  // last level and exhausted all internal keys of this user key.
-  // NOTE: !iter->Valid() does not necessarily mean we hit the
-  // beginning of a user key, as versions of a user key might be
-  // split into multiple files (even files on the same level)
-  // and some files might not be included in the compaction/merge.
-  //
-  // There are also cases where we have seen the root of history of this
-  // key without being sure of it. Then, we simply miss the opportunity
-  // to combine the keys. Since VersionSet::SetupOtherInputs() always makes
-  // sure that all merge-operands on the same level get compacted together,
-  // this will simply lead to these merge operands moving to the next level.
-  //
-  // So, we only perform the following logic (to merge all operands together
-  // without a Put/Delete) if we are certain that we have seen the end of key.
-  bool surely_seen_the_beginning = hit_the_next_user_key && at_bottom;
-  if (surely_seen_the_beginning) {
-    // do a final merge with nullptr as the existing value and say
-    // bye to the merge type (it's now converted to a Put)
-    assert(kTypeMerge == orig_ikey.type);
-    assert(operands_.size() >= 1);
-    assert(operands_.size() == keys_.size());
-    success_ = user_merge_operator_->FullMerge(ikey.user_key, nullptr,
-                                               operands_, &merge_result,
-                                               logger_);
-
-    if (success_) {
-      std::string& key = keys_.back();  // The original key encountered
-      orig_ikey.type = kTypeValue;
-      UpdateInternalKey(&key[0], key.size(),
-                        orig_ikey.sequence, orig_ikey.type);
-
-      // The final value() is always stored in operands_.back()
-      swap(operands_.back(),merge_result);
-    } else {
-      RecordTick(stats, NUMBER_MERGE_FAILURES);
-      // Do nothing if not success_. Leave keys() and operands() as they are.
-    }
-  }
-}
-
-} // namespace leveldb
@@ -1,98 +0,0 @@
-#ifndef MERGE_HELPER_H
-#define MERGE_HELPER_H
-
-#include "db/dbformat.h"
-#include "leveldb/slice.h"
-#include "leveldb/statistics.h"
-#include <string>
-#include <deque>
-
-namespace leveldb {
-
-class Comparator;
-class Iterator;
-class Logger;
-class MergeOperator;
-
-class MergeHelper {
- public:
-  MergeHelper(const Comparator* user_comparator,
-              const MergeOperator* user_merge_operator,
-              Logger* logger,
-              bool assert_valid_internal_key)
-      : user_comparator_(user_comparator),
-        user_merge_operator_(user_merge_operator),
-        logger_(logger),
-        assert_valid_internal_key_(assert_valid_internal_key),
-        keys_(),
-        operands_(),
-        success_(false) {}
-
-  // Merge entries until we hit
-  //     - a corrupted key
-  //     - a Put/Delete,
-  //     - a different user key,
-  //     - a specific sequence number (snapshot boundary),
-  //  or - the end of iteration
-  // iter: (IN)  points to the first merge type entry
-  //       (OUT) points to the first entry not included in the merge process
-  // stop_before: (IN) a sequence number that merge should not cross.
-  //                   0 means no restriction
-  // at_bottom:   (IN) true if the iterator covers the bottem level, which means
-  //                   we could reach the start of the history of this user key.
-  void MergeUntil(Iterator* iter, SequenceNumber stop_before = 0,
-                  bool at_bottom = false, shared_ptr<Statistics> stats=nullptr);
-
-  // Query the merge result
-  // These are valid until the next MergeUntil call
-  // If the merging was successful:
-  //   - IsSuccess() will be true
-  //   - key() will have the latest sequence number of the merges.
-  //           The type will be Put or Merge. See IMPORTANT 1 note, below.
-  //   - value() will be the result of merging all the operands together
-  //   - The user should ignore keys() and values().
-  //
-  //   IMPORTANT 1: the key type could change after the MergeUntil call.
-  //        Put/Delete + Merge + ... + Merge => Put
-  //        Merge + ... + Merge => Merge
-  //
-  // If the merge operator is not associative, and if a Put/Delete is not found
-  // then the merging will be unsuccessful. In this case:
-  //   - IsSuccess() will be false
-  //   - keys() contains the list of internal keys seen in order of iteration.
-  //   - values() contains the list of values (merges) seen in the same order.
-  //              values() is parallel to keys() so that the first entry in
-  //              keys() is the key associated with the first entry in values()
-  //              and so on. These lists will be the same length.
-  //              All of these pairs will be merges over the same user key.
-  //              See IMPORTANT 2 note below.
-  //   - The user should ignore key() and value().
-  //
-  //   IMPORTANT 2: The entries were traversed in order from BACK to FRONT.
-  //                So keys().back() was the first key seen by iterator.
-  // TODO: Re-style this comment to be like the first one
-  bool IsSuccess() { return success_; }
-  Slice key() { assert(success_); return Slice(keys_.back()); }
-  Slice value() { assert(success_); return Slice(operands_.back()); }
-  const std::deque<std::string>& keys() { assert(!success_); return keys_; }
-  const std::deque<std::string>& values() {
-    assert(!success_); return operands_;
-  }
-
- private:
-  const Comparator* user_comparator_;
-  const MergeOperator* user_merge_operator_;
-  Logger* logger_;
-  Iterator* iter_; // in: the internal iterator, positioned at the first merge entry
-  bool assert_valid_internal_key_; // enforce no internal key corruption?
-
-  // the scratch area that holds the result of MergeUntil
-  // valid up to the next MergeUntil call
-  std::deque<std::string> keys_;    // Keeps track of the sequence of keys seen
-  std::deque<std::string> operands_;  // Parallel with keys_; stores the values
-  bool success_;
-};
-
-} // namespace leveldb
-
-#endif
@@ -1,51 +0,0 @@
-/**
- * Back-end implementation details specific to the Merge Operator.
- *
- * @author Deon Nicholas (dnicholas@fb.com)
- * Copyright 2013 Facebook
- */
-
-#include "leveldb/merge_operator.h"
-
-namespace leveldb {
-
-// Given a "real" merge from the library, call the user's
-// associative merge function one-by-one on each of the operands.
-// NOTE: It is assumed that the client's merge-operator will handle any errors.
-bool AssociativeMergeOperator::FullMerge(
-    const Slice& key,
-    const Slice* existing_value,
-    const std::deque<std::string>& operand_list,
-    std::string* new_value,
-    Logger* logger) const {
-
-  // Simply loop through the operands
-  Slice temp_existing;
-  std::string temp_value;
-  for (const auto& operand : operand_list) {
-    Slice value(operand);
-    if (!Merge(key, existing_value, value, &temp_value, logger)) {
-      return false;
-    }
-    swap(temp_value, *new_value);
-    temp_existing = Slice(*new_value);
-    existing_value = &temp_existing;
-  }
-
-  // The result will be in *new_value. All merges succeeded.
-  return true;
-}
-
-// Call the user defined simple merge on the operands;
-// NOTE: It is assumed that the client's merge-operator will handle any errors.
-bool AssociativeMergeOperator::PartialMerge(
-    const Slice& key,
-    const Slice& left_operand,
-    const Slice& right_operand,
-    std::string* new_value,
-    Logger* logger) const {
-
-  return Merge(key, &left_operand, right_operand, new_value, logger);
-}
-
-} // namespace leveldb
@@ -1,270 +0,0 @@
-#include <assert.h>
-#include <memory>
-#include <iostream>
-
-#include "leveldb/cache.h"
-#include "leveldb/comparator.h"
-#include "leveldb/db.h"
-#include "leveldb/env.h"
-#include "leveldb/merge_operator.h"
-#include "db/dbformat.h"
-#include "db/db_impl.h"
-#include "utilities/merge_operators.h"
-#include "util/testharness.h"
-#include "utilities/utility_db.h"
-
-using namespace std;
-using namespace leveldb;
-
-
-std::shared_ptr<DB> OpenDb(const string& dbname, const bool ttl = false) {
-  DB* db;
-  StackableDB* sdb;
-  Options options;
-  options.create_if_missing = true;
-  options.merge_operator = MergeOperators::CreateUInt64AddOperator();
-  Status s;
-  DestroyDB(dbname, Options());
-  if (ttl) {
-    cout << "Opening database with TTL\n";
-    s = UtilityDB::OpenTtlDB(options, dbname, &sdb);
-    db = sdb;
-  } else {
-    s = DB::Open(options, dbname, &db);
-  }
-  if (!s.ok()) {
-    cerr << s.ToString() << endl;
-    assert(false);
-  }
-  return std::shared_ptr<DB>(db);
-}
-
-// Imagine we are maintaining a set of uint64 counters.
-// Each counter has a distinct name. And we would like
-// to support four high level operations:
-// set, add, get and remove
-// This is a quick implementation without a Merge operation.
-class Counters {
-
- protected:
-  std::shared_ptr<DB> db_;
-
-  WriteOptions put_option_;
-  ReadOptions get_option_;
-  WriteOptions delete_option_;
-
-  uint64_t default_;
-
- public:
-  explicit Counters(std::shared_ptr<DB> db, uint64_t defaultCount = 0)
-      : db_(db),
-        put_option_(),
-        get_option_(),
-        delete_option_(),
-        default_(defaultCount) {
-    assert(db_);
-  }
-
-  virtual ~Counters() {}
-
-  // public interface of Counters.
-  // All four functions return false
-  // if the underlying level db operation failed.
-
-  // mapped to a levedb Put
-  bool set(const string& key, uint64_t value) {
-    // just treat the internal rep of int64 as the string
-    Slice slice((char *)&value, sizeof(value));
-    auto s = db_->Put(put_option_, key, slice);
-
-    if (s.ok()) {
-      return true;
-    } else {
-      cerr << s.ToString() << endl;
-      return false;
-    }
-  }
-
-  // mapped to a leveldb Delete
-  bool remove(const string& key) {
-    auto s = db_->Delete(delete_option_, key);
-
-    if (s.ok()) {
-      return true;
-    } else {
-      cerr << s.ToString() << std::endl;
-      return false;
-    }
-  }
-
-  // mapped to a leveldb Get
-  bool get(const string& key, uint64_t *value) {
-    string str;
-    auto s = db_->Get(get_option_, key, &str);
-
-    if (s.IsNotFound()) {
-      // return default value if not found;
-      *value = default_;
-      return true;
-    } else if (s.ok()) {
-      // deserialization
-      if (str.size() != sizeof(uint64_t)) {
-        cerr << "value corruption\n";
-        return false;
-      }
-      *value = DecodeFixed64(&str[0]);
-      return true;
-    } else {
-      cerr << s.ToString() << std::endl;
-      return false;
-    }
-  }
-
-  // 'add' is implemented as get -> modify -> set
-  // An alternative is a single merge operation, see MergeBasedCounters
-  virtual bool add(const string& key, uint64_t value) {
-    uint64_t base = default_;
-    return get(key, &base) && set(key, base + value);
-  }
-
-
-  // convenience functions for testing
-  void assert_set(const string& key, uint64_t value) {
-    assert(set(key, value));
-  }
-
-  void assert_remove(const string& key) {
-    assert(remove(key));
-  }
-
-  uint64_t assert_get(const string& key) {
-    uint64_t value = default_;
-    assert(get(key, &value));
-    return value;
-  }
-
-  void assert_add(const string& key, uint64_t value) {
-    assert(add(key, value));
-  }
-};
-
-// Implement 'add' directly with the new Merge operation
-class MergeBasedCounters : public Counters {
- private:
-  WriteOptions merge_option_; // for merge
-
- public:
-  explicit MergeBasedCounters(std::shared_ptr<DB> db, uint64_t defaultCount = 0)
-      : Counters(db, defaultCount),
-        merge_option_() {
-  }
-
-  // mapped to a leveldb Merge operation
-  virtual bool add(const string& key, uint64_t value) override {
-    char encoded[sizeof(uint64_t)];
-    EncodeFixed64(encoded, value);
-    Slice slice(encoded, sizeof(uint64_t));
-    auto s = db_->Merge(merge_option_, key, slice);
-
-    if (s.ok()) {
-      return true;
-    } else {
-      cerr << s.ToString() << endl;
-      return false;
-    }
-  }
-};
-
-void dumpDb(DB* db) {
-  auto it = unique_ptr<Iterator>(db->NewIterator(ReadOptions()));
-  for (it->SeekToFirst(); it->Valid(); it->Next()) {
-    uint64_t value = DecodeFixed64(it->value().data());
-    cout << it->key().ToString() << ": "  << value << endl;
-  }
-  assert(it->status().ok());  // Check for any errors found during the scan
-}
-
-void testCounters(Counters& counters, DB* db, bool test_compaction) {
-
-  FlushOptions o;
-  o.wait = true;
-
-  counters.assert_set("a", 1);
-
-  if (test_compaction) db->Flush(o);
-
-  assert(counters.assert_get("a") == 1);
-
-  counters.assert_remove("b");
-
-  // defaut value is 0 if non-existent
-  assert(counters.assert_get("b") == 0);
-
-  counters.assert_add("a", 2);
-
-  if (test_compaction) db->Flush(o);
-
-  // 1+2 = 3
-  assert(counters.assert_get("a")== 3);
-
-  dumpDb(db);
-
-  std::cout << "1\n";
-
-  // 1+...+49 = ?
-  uint64_t sum = 0;
-  for (int i = 1; i < 50; i++) {
-    counters.assert_add("b", i);
-    sum += i;
-  }
-  assert(counters.assert_get("b") == sum);
-
-  std::cout << "2\n";
-  dumpDb(db);
-
-  std::cout << "3\n";
-
-  if (test_compaction) {
-    db->Flush(o);
-
-    cout << "Compaction started ...\n";
-    db->CompactRange(nullptr, nullptr);
-    cout << "Compaction ended\n";
-
-    dumpDb(db);
-
-    assert(counters.assert_get("a")== 3);
-    assert(counters.assert_get("b") == sum);
-  }
-}
-
-void runTest(int argc, const string& dbname, const bool use_ttl = false) {
-  auto db = OpenDb(dbname, use_ttl);
-
-  {
-    cout << "Test read-modify-write counters... \n";
-    Counters counters(db, 0);
-    testCounters(counters, db.get(), true);
-  }
-
-  bool compact = false;
-  if (argc > 1) {
-    compact = true;
-    cout << "Turn on Compaction\n";
-  }
-
-  {
-    cout << "Test merge-based counters... \n";
-    MergeBasedCounters counters(db, 0);
-    testCounters(counters, db.get(), compact);
-  }
-
-  DestroyDB(dbname, Options());
-}
-
-int main(int argc, char *argv[]) {
-  //TODO: Make this test like a general rocksdb unit-test
-  runTest(argc, test::TmpDir() + "/merge_testdb");
-  runTest(argc, test::TmpDir() + "/merge_testdbttl", true); // Run test on TTL database
-  return 0;
-}
@@ -1,12 +0,0 @@
-#include "include/leveldb/perf_context.h"
-
-
-namespace leveldb {
-
-void PerfContext::Reset() {
-  user_key_comparison_count = 0;
-}
-
-__thread PerfContext perf_context;
-
-}
@@ -1,81 +0,0 @@
-#include <iostream>
-
-#include "leveldb/db.h"
-#include "leveldb/perf_context.h"
-#include "util/testharness.h"
-
-
-namespace leveldb {
-
-// Path to the database on file system
-const std::string kDbName = test::TmpDir() + "/perf_context_test";
-
-std::shared_ptr<DB> OpenDb() {
-    DB* db;
-    Options options;
-    options.create_if_missing = true;
-    options.write_buffer_size = 1000000000;     // give it a big memtable
-    Status s = DB::Open(options, kDbName,  &db);
-    ASSERT_OK(s);
-    return std::shared_ptr<DB>(db);
-}
-
-class PerfContextTest { };
-
-int kTotalKeys = 100;
-
-TEST(PerfContextTest, KeyComparisonCount) {
-
-  DestroyDB(kDbName, Options());    // Start this test with a fresh DB
-
-  auto db = OpenDb();
-
-  WriteOptions write_options;
-  ReadOptions read_options;
-
-  uint64_t total_user_key_comparison_get = 0;
-  uint64_t total_user_key_comparison_put = 0;
-  uint64_t max_user_key_comparison_get = 0;
-
-  std::cout << "Inserting " << kTotalKeys << " key/value pairs\n...\n";
-
-  for (int i = 0; i < kTotalKeys; ++i) {
-    std::string key = "k" + std::to_string(i);
-    std::string value = "v" + std::to_string(i);
-
-    perf_context.Reset();
-    db->Put(write_options, key, value);
-    total_user_key_comparison_put += perf_context.user_key_comparison_count;
-
-    perf_context.Reset();
-    db->Get(read_options, key, &value);
-    total_user_key_comparison_get += perf_context.user_key_comparison_count;
-    max_user_key_comparison_get =
-      std::max(max_user_key_comparison_get,
-               perf_context.user_key_comparison_count);
-  }
-
-  std::cout << "total user key comparison get: "
-            << total_user_key_comparison_get << "\n"
-            << "total user key comparison put: "
-            << total_user_key_comparison_put << "\n"
-            << "max user key comparison get: "
-            << max_user_key_comparison_get << "\n"
-            << "avg user key comparison get:"
-            << total_user_key_comparison_get/kTotalKeys << "\n";
-
-}
-
-
-}
-
-
-int main(int argc, char** argv) {
-
-  if (argc > 1) {
-    leveldb::kTotalKeys = std::stoi(argv[1]);
-  }
-
-  leveldb::test::RunAllTests();
-  return 0;
-}
@@ -1,76 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// Wrap an underlying iterator, but exclude any results not starting
-// with a given prefix.  Seeking to keys not beginning with the prefix
-// is invalid, and SeekToLast is not implemented (that would be
-// non-trivial), but otherwise this iterator will behave just like the
-// underlying iterator would if there happened to be no non-matching
-// keys in the dataset.
-
-#ifndef STORAGE_LEVELDB_DB_PREFIX_FILTER_ITERATOR_H_
-#define STORAGE_LEVELDB_DB_PREFIX_FILTER_ITERATOR_H_
-
-#include "leveldb/iterator.h"
-
-namespace leveldb {
-
-class PrefixFilterIterator : public Iterator {
- private:
-  Iterator* iter_;
-  const Slice &prefix_;
-  const SliceTransform *prefix_extractor_;
-  Status status_;
-
- public:
-  PrefixFilterIterator(Iterator* iter,
-                       const Slice &prefix,
-                       const SliceTransform* prefix_extractor)
-                             : iter_(iter), prefix_(prefix),
-                               prefix_extractor_(prefix_extractor),
-                               status_(Status::OK()) {
-    if (prefix_extractor == nullptr) {
-      status_ = Status::InvalidArgument("A prefix filter may not be used "
-                                        "unless a function is also defined "
-                                        "for extracting prefixes");
-    } else if (!prefix_extractor_->InRange(prefix)) {
-      status_ = Status::InvalidArgument("Must provide a slice for prefix which"
-                                        "is a prefix for some key");
-    }
-  }
-  ~PrefixFilterIterator() {
-    delete iter_;
-  }
-  Slice key() const { return iter_->key(); }
-  Slice value() const { return iter_->value(); }
-  Status status() const {
-    if (!status_.ok()) {
-      return status_;
-    }
-    return iter_->status();
-  }
-  void Next() { iter_->Next(); }
-  void Prev() { iter_->Prev(); }
-  void Seek(const Slice& k) {
-    if (prefix_extractor_->Transform(k) == prefix_) {
-      iter_->Seek(k);
-    } else {
-      status_ = Status::InvalidArgument("Seek must begin with target prefix");
-    }
-  }
-  void SeekToFirst() {
-    Seek(prefix_);
-  }
-  void SeekToLast() {
-    status_ = Status::NotSupported("SeekToLast is incompatible with prefixes");
-  }
-  bool Valid() const {
-    return (status_.ok() && iter_->Valid() &&
-            prefix_extractor_->Transform(iter_->key()) == prefix_);
-  }
-};
-
-}  // namespace leveldb
-
-#endif
@@ -52,7 +52,7 @@ class Repairer {
        options_(SanitizeOptions(dbname, &icmp_, &ipolicy_, options)),
        next_file_number_(1) {
    // TableCache can be small since we expect each table to be opened once.
-    table_cache_ = new TableCache(dbname_, &options_, storage_options_, 10);
+    table_cache_ = new TableCache(dbname_, &options_, 10);
    edit_ = new VersionEdit(options.num_levels);
  }

@@ -88,7 +88,6 @@ class Repairer {
 private:
  struct TableInfo {
    FileMetaData meta;
-    SequenceNumber min_sequence;
    SequenceNumber max_sequence;
  };

@@ -106,7 +105,6 @@ class Repairer {
  std::vector<uint64_t> logs_;
  std::vector<TableInfo> tables_;
  uint64_t next_file_number_;
-  const EnvOptions storage_options_;

  Status FindFiles() {
    std::vector<std::string> filenames;
@@ -171,7 +169,7 @@ class Repairer {
    // Open the log file
    std::string logname = LogFileName(dbname_, log);
    unique_ptr<SequentialFile> lfile;
-    Status status = env_->NewSequentialFile(logname, &lfile, storage_options_);
+    Status status = env_->NewSequentialFile(logname, &lfile);
    if (!status.ok()) {
      return status;
    }
@@ -192,8 +190,7 @@ class Repairer {
    std::string scratch;
    Slice record;
    WriteBatch batch;
-    MemTable* mem = new MemTable(icmp_, options_.memtable_factory,
-      options_.num_levels);
+    MemTable* mem = new MemTable(icmp_, options_.num_levels);
    mem->Ref();
    int counter = 0;
    while (reader.ReadRecord(&record, &scratch)) {
@@ -219,8 +216,7 @@ class Repairer {
    FileMetaData meta;
    meta.number = next_file_number_++;
    Iterator* iter = mem->NewIterator();
-    status = BuildTable(dbname_, env_, options_, storage_options_,
-                        table_cache_, iter, &meta,
+    status = BuildTable(dbname_, env_, options_, table_cache_, iter, &meta,
                        icmp_.user_comparator(), 0, 0);
    delete iter;
    mem->Unref();
@@ -262,10 +258,9 @@ class Repairer {
    Status status = env_->GetFileSize(fname, &t->meta.file_size);
    if (status.ok()) {
      Iterator* iter = table_cache_->NewIterator(
-          ReadOptions(), storage_options_, t->meta.number, t->meta.file_size);
+          ReadOptions(), t->meta.number, t->meta.file_size);
      bool empty = true;
      ParsedInternalKey parsed;
-      t->min_sequence = 0;
      t->max_sequence = 0;
      for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
        Slice key = iter->key();
@@ -282,9 +277,6 @@ class Repairer {
          t->meta.smallest.DecodeFrom(key);
        }
        t->meta.largest.DecodeFrom(key);
-        if (parsed.sequence < t->min_sequence) {
-          t->min_sequence = parsed.sequence;
-        }
        if (parsed.sequence > t->max_sequence) {
          t->max_sequence = parsed.sequence;
        }
@@ -304,7 +296,7 @@ class Repairer {
  Status WriteDescriptor() {
    std::string tmp = TempFileName(dbname_, 1);
    unique_ptr<WritableFile> file;
-    Status status = env_->NewWritableFile(tmp, &file, storage_options_);
+    Status status = env_->NewWritableFile(tmp, &file);
    if (!status.ok()) {
      return status;
    }
@@ -325,8 +317,7 @@ class Repairer {
      // TODO(opt): separate out into multiple levels
      const TableInfo& t = tables_[i];
      edit_->AddFile(0, t.meta.number, t.meta.file_size,
-                    t.meta.smallest, t.meta.largest,
-                    t.min_sequence, t.max_sequence);
+                    t.meta.smallest, t.meta.largest);
    }

    //fprintf(stderr, "NewDescriptor:\n%s\n", edit_.DebugString().c_str());
@@ -31,10 +31,13 @@
 #include <assert.h>
 #include <stdlib.h>
 #include "port/port.h"
+#include "util/arena.h"
 #include "util/random.h"

 namespace leveldb {

+class Arena;
+
 template<typename Key, class Comparator>
 class SkipList {
 private:
@@ -5,7 +5,7 @@
 #include "db/skiplist.h"
 #include <set>
 #include "leveldb/env.h"
-#include "util/arena_impl.h"
+#include "util/arena.h"
 #include "util/hash.h"
 #include "util/random.h"
 #include "util/testharness.h"
@@ -29,9 +29,9 @@ struct TestComparator {
 class SkipTest { };

 TEST(SkipTest, Empty) {
-  ArenaImpl arena_impl;
+  Arena arena;
  TestComparator cmp;
-  SkipList<Key, TestComparator> list(cmp, &arena_impl);
+  SkipList<Key, TestComparator> list(cmp, &arena);
  ASSERT_TRUE(!list.Contains(10));

  SkipList<Key, TestComparator>::Iterator iter(&list);
@@ -49,9 +49,9 @@ TEST(SkipTest, InsertAndLookup) {
  const int R = 5000;
  Random rnd(1000);
  std::set<Key> keys;
-  ArenaImpl arena_impl;
+  Arena arena;
  TestComparator cmp;
-  SkipList<Key, TestComparator> list(cmp, &arena_impl);
+  SkipList<Key, TestComparator> list(cmp, &arena);
  for (int i = 0; i < N; i++) {
    Key key = rnd.Next() % R;
    if (keys.insert(key).second) {
@@ -204,14 +204,14 @@ class ConcurrentTest {
  // Current state of the test
  State current_;

-  ArenaImpl arena_impl_;
+  Arena arena_;

  // SkipList is not protected by mu_.  We just use a single writer
  // thread to modify it.
  SkipList<Key, TestComparator> list_;

 public:
-  ConcurrentTest() : list_(TestComparator(), &arena_impl_) { }
+  ConcurrentTest() : list_(TestComparator(), &arena_) { }

  // REQUIRES: External synchronization
  void WriteStep(Random* rnd) {
@@ -1,102 +0,0 @@
-#ifndef STORAGE_LEVELDB_DB_SKIPLISTREP_H_
-#define STORAGE_LEVELDB_DB_SKIPLISTREP_H_
-
-#include "leveldb/memtablerep.h"
-#include "db/memtable.h"
-#include "db/skiplist.h"
-
-namespace leveldb {
-
-class Arena;
-
-class SkipListRep : public MemTableRep {
-  SkipList<const char*, MemTableRep::KeyComparator&> skip_list_;
-public:
-  explicit SkipListRep(MemTableRep::KeyComparator& compare, Arena* arena)
-    : skip_list_(compare, arena) {
-}
-
-  // Insert key into the list.
-  // REQUIRES: nothing that compares equal to key is currently in the list.
-  virtual void Insert(const char* key) {
-    skip_list_.Insert(key);
-  }
-
-  // Returns true iff an entry that compares equal to key is in the list.
-  virtual bool Contains(const char* key) const {
-    return skip_list_.Contains(key);
-  }
-
-  virtual ~SkipListRep() { }
-
-  // Iteration over the contents of a skip list
-  class Iterator : public MemTableRep::Iterator {
-    SkipList<const char*, MemTableRep::KeyComparator&>::Iterator iter_;
-   public:
-    // Initialize an iterator over the specified list.
-    // The returned iterator is not valid.
-    explicit Iterator(
-      const SkipList<const char*, MemTableRep::KeyComparator&>* list
-    ) : iter_(list) { }
-
-    virtual ~Iterator() { }
-
-    // Returns true iff the iterator is positioned at a valid node.
-    virtual bool Valid() const {
-      return iter_.Valid();
-    }
-
-    // Returns the key at the current position.
-    // REQUIRES: Valid()
-    virtual const char* key() const {
-      return iter_.key();
-    }
-
-    // Advances to the next position.
-    // REQUIRES: Valid()
-    virtual void Next() {
-      iter_.Next();
-    }
-
-    // Advances to the previous position.
-    // REQUIRES: Valid()
-    virtual void Prev() {
-      iter_.Prev();
-    }
-
-    // Advance to the first entry with a key >= target
-    virtual void Seek(const char* target) {
-      iter_.Seek(target);
-    }
-
-    // Position at the first entry in list.
-    // Final state of iterator is Valid() iff list is not empty.
-    virtual void SeekToFirst() {
-      iter_.SeekToFirst();
-    }
-
-    // Position at the last entry in list.
-    // Final state of iterator is Valid() iff list is not empty.
-    virtual void SeekToLast() {
-      iter_.SeekToLast();
-    }
-  };
-
-  virtual std::shared_ptr<MemTableRep::Iterator> GetIterator() {
-    return std::shared_ptr<MemTableRep::Iterator>(
-      new SkipListRep::Iterator(&skip_list_)
-    );
-  }
-};
-
-class SkipListFactory : public MemTableRepFactory {
-public:
-  virtual std::shared_ptr<MemTableRep> CreateMemTableRep (
-    MemTableRep::KeyComparator& compare, Arena* arena) {
-      return std::shared_ptr<MemTableRep>(new SkipListRep(compare, arena));
-  }
-};
-
-}
-
-#endif // STORAGE_LEVELDB_DB_SKIPLISTREP_H_
@@ -59,9 +59,12 @@ class SnapshotList {

  // retrieve all snapshot numbers. They are sorted in ascending order.
  void getAll(std::vector<SequenceNumber>& ret) {
-    if (empty()) return;
    SnapshotImpl* s = &list_;
+    if (empty()) return;
+    SequenceNumber prev __attribute__((unused)) = 0;
    while (s->next_ != &list_) {
+      assert(prev <= s->next_->number_);
+      assert(prev = s->next_->number_); // assignment
      ret.push_back(s->next_->number_);
      s = s ->next_;
    }
@@ -6,16 +6,23 @@

 #include "db/filename.h"

+#include "leveldb/env.h"
+#include "leveldb/table.h"
 #include "leveldb/statistics.h"
-#include "table/table.h"
 #include "util/coding.h"
-#include "util/stop_watch.h"

 namespace leveldb {

+struct TableAndFile {
+  unique_ptr<Table> table;
+};
+
+static class Statistics* dbstatistics;
+
 static void DeleteEntry(const Slice& key, void* value) {
-  Table* table = reinterpret_cast<Table*>(value);
-  delete table;
+  TableAndFile* tf = reinterpret_cast<TableAndFile*>(value);
+  RecordTick(dbstatistics, NO_FILE_CLOSES);
+  delete tf;
 }

 static void UnrefEntry(void* arg1, void* arg2) {
@@ -26,44 +33,35 @@ static void UnrefEntry(void* arg1, void* arg2) {

 TableCache::TableCache(const std::string& dbname,
                       const Options* options,
-                       const EnvOptions& storage_options,
                       int entries)
    : env_(options->env),
      dbname_(dbname),
      options_(options),
-      storage_options_(storage_options),
-      cache_(NewLRUCache(entries, options->table_cache_numshardbits)) {}
+      cache_(NewLRUCache(entries, options->table_cache_numshardbits)) {
+  dbstatistics = options->statistics;
+}

 TableCache::~TableCache() {
 }

-Status TableCache::FindTable(const EnvOptions& toptions,
-                             uint64_t file_number, uint64_t file_size,
-                             Cache::Handle** handle, bool* table_io,
-                             const bool no_io) {
+Status TableCache::FindTable(uint64_t file_number, uint64_t file_size,
+                             Cache::Handle** handle, bool* tableIO) {
  Status s;
  char buf[sizeof(file_number)];
  EncodeFixed64(buf, file_number);
  Slice key(buf, sizeof(buf));
  *handle = cache_->Lookup(key);
  if (*handle == nullptr) {
-    if (no_io) { // Dont do IO and return a not-found status
-      return Status::NotFound("Table not found in table_cache, no_io is set");
-    }
-    if (table_io != nullptr) {
-      *table_io = true;    // we had to do IO from storage
+    if (tableIO != nullptr) {
+      *tableIO = true;    // we had to do IO from storage
    }
    std::string fname = TableFileName(dbname_, file_number);
    unique_ptr<RandomAccessFile> file;
    unique_ptr<Table> table;
-    s = env_->NewRandomAccessFile(fname, &file, toptions);
+    s = env_->NewRandomAccessFile(fname, &file);
    RecordTick(options_->statistics, NO_FILE_OPENS);
    if (s.ok()) {
-      if (options_->advise_random_on_open) {
-        file->Hint(RandomAccessFile::RANDOM);
-      }
-      StopWatch sw(env_, options_->statistics, TABLE_OPEN_IO_MICROS);
-      s = Table::Open(*options_, toptions, std::move(file), file_size, &table);
+      s = Table::Open(*options_, std::move(file), file_size, &table);
    }

    if (!s.ok()) {
@@ -72,41 +70,36 @@ Status TableCache::FindTable(const EnvOptions& toptions,
      // We do not cache error results so that if the error is transient,
      // or somebody repairs the file, we recover automatically.
    } else {
+      TableAndFile* tf = new TableAndFile;
+      tf->table = std::move(table);
      assert(file.get() == nullptr);
-      *handle = cache_->Insert(key, table.release(), 1, &DeleteEntry);
+      *handle = cache_->Insert(key, tf, 1, &DeleteEntry);
    }
  }
  return s;
 }

 Iterator* TableCache::NewIterator(const ReadOptions& options,
-                                  const EnvOptions& toptions,
                                  uint64_t file_number,
                                  uint64_t file_size,
-                                  Table** tableptr,
-                                  bool for_compaction) {
+                                  Table** tableptr) {
  if (tableptr != nullptr) {
    *tableptr = nullptr;
  }

  Cache::Handle* handle = nullptr;
-  Status s = FindTable(toptions, file_number, file_size, &handle);
+  Status s = FindTable(file_number, file_size, &handle);
  if (!s.ok()) {
    return NewErrorIterator(s);
  }

  Table* table =
-    reinterpret_cast<Table*>(cache_->Value(handle));
+    reinterpret_cast<TableAndFile*>(cache_->Value(handle))->table.get();
  Iterator* result = table->NewIterator(options);
  result->RegisterCleanup(&UnrefEntry, cache_.get(), handle);
  if (tableptr != nullptr) {
    *tableptr = table;
  }
-
-  if (for_compaction) {
-    table->SetupForCompaction();
-  }
-
  return result;
 }

@@ -115,22 +108,15 @@ Status TableCache::Get(const ReadOptions& options,
                       uint64_t file_size,
                       const Slice& k,
                       void* arg,
-                       bool (*saver)(void*, const Slice&, const Slice&, bool),
-                       bool* table_io,
-                       void (*mark_key_may_exist)(void*),
-                       const bool no_io) {
+                       void (*saver)(void*, const Slice&, const Slice&, bool),
+                       bool* tableIO) {
  Cache::Handle* handle = nullptr;
-  Status s = FindTable(storage_options_, file_number, file_size,
-                       &handle, table_io, no_io);
+  Status s = FindTable(file_number, file_size, &handle, tableIO);
  if (s.ok()) {
    Table* t =
-      reinterpret_cast<Table*>(cache_->Value(handle));
-    s = t->InternalGet(options, k, arg, saver, mark_key_may_exist, no_io);
+      reinterpret_cast<TableAndFile*>(cache_->Value(handle))->table.get();
+    s = t->InternalGet(options, k, arg, saver);
    cache_->Release(handle);
-  } else if (no_io && s.IsNotFound()) {
-    // Couldnt find Table in cache but treat as kFound if no_io set
-    (*mark_key_may_exist)(arg);
-    return Status::OK();
  }
  return s;
 }
@@ -10,10 +10,9 @@
 #include <string>
 #include <stdint.h>
 #include "db/dbformat.h"
-#include "leveldb/env.h"
 #include "leveldb/cache.h"
+#include "leveldb/table.h"
 #include "port/port.h"
-#include "table/table.h"

 namespace leveldb {

@@ -21,8 +20,7 @@ class Env;

 class TableCache {
 public:
-  TableCache(const std::string& dbname, const Options* options,
-             const EnvOptions& storage_options, int entries);
+  TableCache(const std::string& dbname, const Options* options, int entries);
  ~TableCache();

  // Return an iterator for the specified file number (the corresponding
@@ -33,24 +31,19 @@ class TableCache {
  // the cache and should not be deleted, and is valid for as long as the
  // returned iterator is live.
  Iterator* NewIterator(const ReadOptions& options,
-                        const EnvOptions& toptions,
                        uint64_t file_number,
                        uint64_t file_size,
-                        Table** tableptr = nullptr,
-                        bool for_compaction = false);
+                        Table** tableptr = nullptr);

  // 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.
+  // call (*handle_result)(arg, found_key, found_value).
  Status Get(const ReadOptions& options,
             uint64_t file_number,
             uint64_t file_size,
             const Slice& k,
             void* arg,
-             bool (*handle_result)(void*, const Slice&, const Slice&, bool),
-             bool* table_io,
-             void (*mark_key_may_exist)(void*) = nullptr,
-             const bool no_io = false);
+             void (*handle_result)(void*, const Slice&, const Slice&, bool),
+             bool* tableIO);

  // Evict any entry for the specified file number
  void Evict(uint64_t file_number);
@@ -59,12 +52,10 @@ class TableCache {
  Env* const env_;
  const std::string dbname_;
  const Options* options_;
-  const EnvOptions& storage_options_;
  std::shared_ptr<Cache> cache_;

-  Status FindTable(const EnvOptions& toptions, uint64_t file_number,
-                   uint64_t file_size, Cache::Handle**, bool* table_io=nullptr,
-                   const bool no_io = false);
+  Status FindTable(uint64_t file_number, uint64_t file_size, Cache::Handle**,
+                   bool* tableIO = nullptr);
 };

 }  // namespace leveldb
@@ -1,171 +0,0 @@
-#include "db/transaction_log_impl.h"
-#include "db/write_batch_internal.h"
-
-namespace leveldb {
-
-TransactionLogIteratorImpl::TransactionLogIteratorImpl(
-                           const std::string& dbname,
-                           const Options* options,
-                           const EnvOptions& soptions,
-                           const SequenceNumber seq,
-                           std::unique_ptr<VectorLogPtr> files,
-                           SequenceNumber const * const lastFlushedSequence) :
-    dbname_(dbname),
-    options_(options),
-    soptions_(soptions),
-    startingSequenceNumber_(seq),
-    files_(std::move(files)),
-    started_(false),
-    isValid_(false),
-    currentFileIndex_(0),
-    lastFlushedSequence_(lastFlushedSequence) {
-  assert(startingSequenceNumber_ <= *lastFlushedSequence_);
-  assert(files_.get() != nullptr);
-
-  reporter_.env = options_->env;
-  reporter_.info_log = options_->info_log.get();
-}
-
-Status TransactionLogIteratorImpl::OpenLogFile(
-  const LogFile* logFile,
-  unique_ptr<SequentialFile>* file) {
-  Env* env = options_->env;
-  if (logFile->Type() == kArchivedLogFile) {
-    std::string fname = ArchivedLogFileName(dbname_, logFile->LogNumber());
-    return env->NewSequentialFile(fname, file, soptions_);
-  } else {
-    std::string fname = LogFileName(dbname_, logFile->LogNumber());
-    Status status = env->NewSequentialFile(fname, file, soptions_);
-    if (!status.ok()) {
-      //  If cannot open file in DB directory.
-      //  Try the archive dir, as it could have moved in the meanwhile.
-      fname = ArchivedLogFileName(dbname_, logFile->LogNumber());
-      status = env->NewSequentialFile(fname, file, soptions_);
-      if (!status.ok()) {
-        return Status::IOError(" Requested file not present in the dir");
-      }
-    }
-    return status;
-  }
-}
-
-BatchResult TransactionLogIteratorImpl::GetBatch()  {
-  assert(isValid_);  //  cannot call in a non valid state.
-  BatchResult result;
-  result.sequence = currentSequence_;
-  result.writeBatchPtr = std::move(currentBatch_);
-  return result;
-}
-
-Status TransactionLogIteratorImpl::status() {
-  return currentStatus_;
-}
-
-bool TransactionLogIteratorImpl::Valid() {
-  return started_ && isValid_;
-}
-
-void TransactionLogIteratorImpl::Next() {
-  LogFile* currentLogFile = files_.get()->at(currentFileIndex_).get();
-
-//  First seek to the given seqNo. in the current file.
-  std::string scratch;
-  Slice record;
-  if (!started_) {
-    started_ = true;  // this piece only runs onced.
-    isValid_ = false;
-    if (startingSequenceNumber_ > *lastFlushedSequence_) {
-      currentStatus_ = Status::IOError("Looking for a sequence, "
-                                        "which is not flushed yet.");
-      return;
-    }
-    Status s = OpenLogReader(currentLogFile);
-    if (!s.ok()) {
-      currentStatus_ = s;
-      isValid_ = false;
-      return;
-    }
-    while (currentLogReader_->ReadRecord(&record, &scratch)) {
-      if (record.size() < 12) {
-        reporter_.Corruption(
-          record.size(), Status::Corruption("log record too small"));
-        continue;
-      }
-      UpdateCurrentWriteBatch(record);
-      if (currentSequence_ >= startingSequenceNumber_) {
-        assert(currentSequence_ <= *lastFlushedSequence_);
-        isValid_ = true;
-        break;
-      } else {
-        isValid_ = false;
-      }
-    }
-    if (isValid_) {
-      // Done for this iteration
-      return;
-    }
-  }
-  bool openNextFile = true;
-  while(openNextFile) {
-    assert(currentLogReader_);
-    if (currentSequence_ < *lastFlushedSequence_) {
-      if (currentLogReader_->IsEOF()) {
-        currentLogReader_->UnmarkEOF();
-      }
-      while (currentLogReader_->ReadRecord(&record, &scratch)) {
-        if (record.size() < 12) {
-          reporter_.Corruption(
-            record.size(), Status::Corruption("log record too small"));
-          continue;
-        } else {
-          UpdateCurrentWriteBatch(record);
-          openNextFile = false;
-          break;
-        }
-      }
-    }
-
-    if (openNextFile) {
-      if (currentFileIndex_ < files_.get()->size() - 1) {
-        ++currentFileIndex_;
-        Status status =OpenLogReader(files_.get()->at(currentFileIndex_).get());
-        if (!status.ok()) {
-          isValid_ = false;
-          currentStatus_ = status;
-          return;
-        }
-      } else {
-        isValid_ = false;
-        openNextFile = false;
-        if (currentSequence_ == *lastFlushedSequence_) {
-          currentStatus_ = Status::OK();
-        } else {
-          currentStatus_ = Status::IOError(" NO MORE DATA LEFT");
-        }
-      }
-    }
-  }
-}
-
-void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
-  WriteBatch* batch = new WriteBatch();
-  WriteBatchInternal::SetContents(batch, record);
-  currentSequence_ = WriteBatchInternal::Sequence(batch);
-  currentBatch_.reset(batch);
-  isValid_ = true;
-  currentStatus_ = Status::OK();
-}
-
-Status TransactionLogIteratorImpl::OpenLogReader(const LogFile* logFile) {
-  unique_ptr<SequentialFile> file;
-  Status status = OpenLogFile(logFile, &file);
-  if (!status.ok()) {
-    return status;
-  }
-  assert(file);
-  currentLogReader_.reset(
-    new log::Reader(std::move(file), &reporter_, true, 0)
-  );
-  return Status::OK();
-}
-}  //  namespace leveldb
@@ -0,0 +1,172 @@
+#include "db/transaction_log_iterator_impl.h"
+#include "db/write_batch_internal.h"
+#include "db/filename.h"
+namespace leveldb {
+
+TransactionLogIteratorImpl::TransactionLogIteratorImpl(
+                           const std::string& dbname,
+                           const Options* options,
+                           SequenceNumber& seq,
+                           std::vector<LogFile>* files,
+                           SequenceNumber const * const lastFlushedSequence) :
+  dbname_(dbname),
+  options_(options),
+  sequenceNumber_(seq),
+  files_(files),
+  started_(false),
+  isValid_(true),
+  currentFileIndex_(0),
+  lastFlushedSequence_(lastFlushedSequence) {
+  assert(files_ != nullptr);
+  assert(lastFlushedSequence_);
+}
+
+LogReporter
+TransactionLogIteratorImpl::NewLogReporter(const uint64_t logNumber) {
+  LogReporter reporter;
+  reporter.env = options_->env;
+  reporter.info_log = options_->info_log.get();
+  reporter.log_number = logNumber;
+  return reporter;
+}
+
+Status TransactionLogIteratorImpl::OpenLogFile(
+  const LogFile& logFile,
+  unique_ptr<SequentialFile>* file) {
+  Env* env = options_->env;
+  if (logFile.type == kArchivedLogFile) {
+    std::string fname = ArchivedLogFileName(dbname_, logFile.logNumber);
+    return env->NewSequentialFile(fname, file);
+  } else {
+    std::string fname = LogFileName(dbname_, logFile.logNumber);
+    Status status = env->NewSequentialFile(fname, file);
+    if (!status.ok()) {
+      //  If cannot open file in DB directory.
+      //  Try the archive dir, as it could have moved in the meanwhile.
+      fname = ArchivedLogFileName(dbname_, logFile.logNumber);
+      status = env->NewSequentialFile(fname, file);
+      if (!status.ok()) {
+        return Status::IOError(" Requested file not present in the dir");
+      }
+    }
+    return status;
+  }
+}
+
+BatchResult TransactionLogIteratorImpl::GetBatch()  {
+  assert(isValid_);  //  cannot call in a non valid state.
+  BatchResult result;
+  result.sequence = currentSequence_;
+  result.writeBatchPtr = std::move(currentBatch_);
+  return result;
+}
+
+Status TransactionLogIteratorImpl::status() {
+  return currentStatus_;
+}
+
+bool TransactionLogIteratorImpl::Valid() {
+  return started_ && isValid_;
+}
+
+void TransactionLogIteratorImpl::Next() {
+//  First seek to the given seqNo. in the current file.
+  LogFile currentLogFile = files_->at(currentFileIndex_);
+  LogReporter reporter = NewLogReporter(currentLogFile.logNumber);
+  std::string scratch;
+  Slice record;
+
+  if (!started_) {
+    isValid_ = false;
+    if (sequenceNumber_ > *lastFlushedSequence_) {
+      currentStatus_ = Status::IOError("Looking for a sequence, "
+                                        "which is not flushed yet.");
+      return;
+    }
+    unique_ptr<SequentialFile> file;
+    Status status = OpenLogFile(currentLogFile, &file);
+    if (!status.ok()) {
+      currentStatus_ = status;
+      return;
+    }
+    assert(file);
+    unique_ptr<log::Reader> reader(
+      new log::Reader(std::move(file), &reporter, true, 0));
+    assert(reader);
+    while (reader->ReadRecord(&record, &scratch)) {
+      if (record.size() < 12) {
+        reporter.Corruption(
+          record.size(), Status::Corruption("log record too small"));
+        continue;
+      }
+      UpdateCurrentWriteBatch(record);
+      if (currentSequence_ >= sequenceNumber_) {
+        assert(currentSequence_ < *lastFlushedSequence_);
+        isValid_ = true;
+        currentLogReader_ = std::move(reader);
+        break;
+      }
+    }
+    if (!isValid_) {
+      //  TODO read the entire first file. and did not find the seq number.
+      //  Error out.
+      currentStatus_ =
+        Status::NotFound("Did not find the Seq no. in first file");
+    }
+    started_ = true;
+  } else {
+LOOK_NEXT_FILE:
+    assert(currentLogReader_);
+    bool openNextFile = true;
+
+    if (currentSequence_ == *lastFlushedSequence_) {
+      // The last update has been read. and next is being called.
+      isValid_ = false;
+      currentStatus_ = Status::OK();
+    }
+
+    while (currentLogReader_->ReadRecord(&record, &scratch) &&
+           currentSequence_ < *lastFlushedSequence_) {
+      if (record.size() < 12) {
+        reporter.Corruption(
+          record.size(), Status::Corruption("log record too small"));
+        continue;
+      } else {
+        UpdateCurrentWriteBatch(record);
+        openNextFile = false;
+        break;
+      }
+    }
+
+    if (openNextFile) {
+      if (currentFileIndex_ < files_->size() - 1) {
+        ++currentFileIndex_;
+        currentLogReader_.reset();
+        unique_ptr<SequentialFile> file;
+        Status status = OpenLogFile(files_->at(currentFileIndex_), &file);
+        if (!status.ok()) {
+          isValid_ = false;
+          currentStatus_ = status;
+          return;
+        }
+        currentLogReader_.reset(
+          new log::Reader(std::move(file), &reporter, true, 0));
+        goto LOOK_NEXT_FILE;
+      } else {
+        //  LOOKED AT FILES. WE ARE DONE HERE.
+        isValid_ = false;
+        currentStatus_ = Status::IOError(" NO MORE DATA LEFT");
+      }
+    }
+
+  }
+}
+
+void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
+  WriteBatch* batch = new WriteBatch();
+  WriteBatchInternal::SetContents(batch, record);
+  currentSequence_ = WriteBatchInternal::Sequence(batch);
+  currentBatch_.reset(batch);
+}
+
+}  //  namespace leveldb
@@ -7,61 +7,35 @@
 #include "leveldb/env.h"
 #include "leveldb/options.h"
 #include "leveldb/types.h"
-#include "leveldb/transaction_log.h"
+#include "leveldb/transaction_log_iterator.h"
+#include "db/log_file.h"
 #include "db/log_reader.h"
-#include "db/filename.h"

 namespace leveldb {

 struct LogReporter : public log::Reader::Reporter {
  Env* env;
  Logger* info_log;
+  uint64_t log_number;
  virtual void Corruption(size_t bytes, const Status& s) {
-    Log(info_log, "dropping %zu bytes; %s", bytes, s.ToString().c_str());
+    Log(info_log, "%ld: dropping %d bytes; %s",
+        log_number, static_cast<int>(bytes), s.ToString().c_str());
  }
 };

-class LogFileImpl : public LogFile {
- public:
-  LogFileImpl(uint64_t logNum, WalFileType logType, SequenceNumber startSeq,
-              uint64_t sizeBytes) :
-    logNumber_(logNum),
-    type_(logType),
-    startSequence_(startSeq),
-    sizeFileBytes_(sizeBytes) {
-  }
-
-  std::string Filename() const { return LogFileName("", logNumber_); }
-
-  uint64_t LogNumber() const { return logNumber_; }
-
-  WalFileType Type() const { return type_; }
-
-  SequenceNumber StartSequence() const { return startSequence_; }
-
-  uint64_t SizeFileBytes() const { return sizeFileBytes_; }
-
-  bool operator < (const LogFile& that) const {
-    return LogNumber() < that.LogNumber();
-  }
-
- private:
-  uint64_t logNumber_;
-  WalFileType type_;
-  SequenceNumber startSequence_;
-  uint64_t sizeFileBytes_;
-
-};
-
 class TransactionLogIteratorImpl : public TransactionLogIterator {
 public:
  TransactionLogIteratorImpl(const std::string& dbname,
                             const Options* options,
-                             const EnvOptions& soptions,
-                             const SequenceNumber seqNum,
-                             std::unique_ptr<VectorLogPtr> files,
+                             SequenceNumber& seqNum,
+                             std::vector<LogFile>* files,
                             SequenceNumber const * const lastFlushedSequence);

+  virtual ~TransactionLogIteratorImpl() {
+    //  TODO move to cc file.
+    delete files_;
+  }
+
  virtual bool Valid();

  virtual void Next();
@@ -73,23 +47,21 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
 private:
  const std::string& dbname_;
  const Options* options_;
-  const EnvOptions& soptions_;
-  const SequenceNumber startingSequenceNumber_;
-  std::unique_ptr<VectorLogPtr> files_;
+  const uint64_t sequenceNumber_;
+  const std::vector<LogFile>* files_;
  bool started_;
  bool isValid_;  // not valid when it starts of.
  Status currentStatus_;
  size_t currentFileIndex_;
  std::unique_ptr<WriteBatch> currentBatch_;
  unique_ptr<log::Reader> currentLogReader_;
-  Status OpenLogFile(const LogFile* logFile, unique_ptr<SequentialFile>* file);
-  LogReporter reporter_;
+  Status OpenLogFile(const LogFile& logFile, unique_ptr<SequentialFile>* file);
+  LogReporter NewLogReporter(uint64_t logNumber);
  SequenceNumber const * const lastFlushedSequence_;
  // represents the sequence number being read currently.
  SequenceNumber currentSequence_;

  void UpdateCurrentWriteBatch(const Slice& record);
-  Status OpenLogReader(const LogFile* file);
 };


@@ -20,10 +20,7 @@ enum Tag {
  kDeletedFile          = 6,
  kNewFile              = 7,
  // 8 was used for large value refs
-  kPrevLogNumber        = 9,
-
-  // these are new formats divergent from open source leveldb
-  kNewFile2             = 100  // store smallest & largest seqno
+  kPrevLogNumber        = 9
 };

 void VersionEdit::Clear() {
@@ -79,14 +76,12 @@ void VersionEdit::EncodeTo(std::string* dst) const {

  for (size_t i = 0; i < new_files_.size(); i++) {
    const FileMetaData& f = new_files_[i].second;
-    PutVarint32(dst, kNewFile2);
+    PutVarint32(dst, kNewFile);
    PutVarint32(dst, new_files_[i].first);  // level
    PutVarint64(dst, f.number);
    PutVarint64(dst, f.file_size);
    PutLengthPrefixedSlice(dst, f.smallest.Encode());
    PutLengthPrefixedSlice(dst, f.largest.Encode());
-    PutVarint64(dst, f.smallest_seqno);
-    PutVarint64(dst, f.largest_seqno);
  }
 }

@@ -206,22 +201,6 @@ Status VersionEdit::DecodeFrom(const Slice& src) {
        }
        break;

-      case kNewFile2:
-        if (GetLevel(&input, &level, &msg) &&
-            GetVarint64(&input, &f.number) &&
-            GetVarint64(&input, &f.file_size) &&
-            GetInternalKey(&input, &f.smallest) &&
-            GetInternalKey(&input, &f.largest) &&
-            GetVarint64(&input, &f.smallest_seqno) &&
-            GetVarint64(&input, &f.largest_seqno) ) {
-          new_files_.push_back(std::make_pair(level, f));
-        } else {
-          if (!msg) {
-            msg = "new-file2 entry";
-          }
-        }
-        break;
-
      default:
        msg = "unknown tag";
        break;
@@ -239,7 +218,7 @@ Status VersionEdit::DecodeFrom(const Slice& src) {
  return result;
 }

-std::string VersionEdit::DebugString(bool hex_key) const {
+std::string VersionEdit::DebugString() const {
  std::string r;
  r.append("VersionEdit {");
  if (has_comparator_) {
@@ -266,7 +245,7 @@ std::string VersionEdit::DebugString(bool hex_key) const {
    r.append("\n  CompactPointer: ");
    AppendNumberTo(&r, compact_pointers_[i].first);
    r.append(" ");
-    r.append(compact_pointers_[i].second.DebugString(hex_key));
+    r.append(compact_pointers_[i].second.DebugString());
  }
  for (DeletedFileSet::const_iterator iter = deleted_files_.begin();
       iter != deleted_files_.end();
@@ -285,9 +264,9 @@ std::string VersionEdit::DebugString(bool hex_key) const {
    r.append(" ");
    AppendNumberTo(&r, f.file_size);
    r.append(" ");
-    r.append(f.smallest.DebugString(hex_key));
+    r.append(f.smallest.DebugString());
    r.append(" .. ");
-    r.append(f.largest.DebugString(hex_key));
+    r.append(f.largest.DebugString());
  }
  r.append("\n}\n");
  return r;
@@ -22,8 +22,6 @@ struct FileMetaData {
  InternalKey smallest;       // Smallest internal key served by table
  InternalKey largest;        // Largest internal key served by table
  bool being_compacted;       // Is this file undergoing compaction?
-  SequenceNumber smallest_seqno;// The smallest seqno in this file
-  SequenceNumber largest_seqno; // The largest seqno in this file

  FileMetaData() : refs(0), allowed_seeks(1 << 30), file_size(0),
                   being_compacted(false) { }
@@ -69,17 +67,12 @@ class VersionEdit {
  void AddFile(int level, uint64_t file,
               uint64_t file_size,
               const InternalKey& smallest,
-               const InternalKey& largest,
-               const SequenceNumber& smallest_seqno,
-               const SequenceNumber& largest_seqno) {
+               const InternalKey& largest) {
    FileMetaData f;
    f.number = file;
    f.file_size = file_size;
    f.smallest = smallest;
    f.largest = largest;
-    f.smallest_seqno = smallest_seqno;
-    f.largest_seqno = largest_seqno;
-    assert(smallest_seqno <= largest_seqno);
    new_files_.push_back(std::make_pair(level, f));
  }

@@ -88,15 +81,10 @@ class VersionEdit {
    deleted_files_.insert(std::make_pair(level, file));
  }

-  // Number of edits
-  int NumEntries() {
-    return new_files_.size() + deleted_files_.size();
-  }
-
  void EncodeTo(std::string* dst) const;
  Status DecodeFrom(const Slice& src);

-  std::string DebugString(bool hex_key = false) const;
+  std::string DebugString() const;

 private:
  friend class VersionSet;
@@ -27,9 +27,7 @@ TEST(VersionEditTest, EncodeDecode) {
    TestEncodeDecode(edit);
    edit.AddFile(3, kBig + 300 + i, kBig + 400 + i,
                 InternalKey("foo", kBig + 500 + i, kTypeValue),
-                 InternalKey("zoo", kBig + 600 + i, kTypeDeletion),
-                 kBig + 500 + i,
-                 kBig + 600 + i);
+                 InternalKey("zoo", kBig + 600 + i, kTypeDeletion));
    edit.DeleteFile(4, kBig + 700 + i);
    edit.SetCompactPointer(i, InternalKey("x", kBig + 900 + i, kTypeValue));
  }
@@ -63,21 +63,17 @@ class Version {
  // Append to *iters a sequence of iterators that will
  // yield the contents of this Version when merged together.
  // REQUIRES: This version has been saved (see VersionSet::SaveTo)
-  void AddIterators(const ReadOptions&, const EnvOptions& soptions,
-                    std::vector<Iterator*>* iters);
+  void AddIterators(const ReadOptions&, std::vector<Iterator*>* iters);

  // Lookup the value for key.  If found, store it in *val and
  // return OK.  Else return a non-OK status.  Fills *stats.
-  // Uses *operands to store merge_operator operations to apply later
  // REQUIRES: lock is not held
  struct GetStats {
    FileMetaData* seek_file;
    int seek_file_level;
  };
-  void Get(const ReadOptions&, const LookupKey& key, std::string* val,
-           Status* status, std::deque<std::string>* operands, GetStats* stats,
-           const Options& db_option, const bool no_io = false,
-           bool* value_found = nullptr);
+  Status Get(const ReadOptions&, const LookupKey& key, std::string* val,
+             GetStats* stats);

  // Adds "stats" into the current state.  Returns true if a new
  // compaction may need to be triggered, false otherwise.
@@ -110,7 +106,7 @@ class Version {
      const Slice& begin,         // nullptr means before all keys
      const Slice& end,           // nullptr means after all keys
      std::vector<FileMetaData*>* inputs,
-      unsigned int index);                 // start extending from this index
+      int index);                 // start extending from this index

  // Returns true iff some file in the specified level overlaps
  // some part of [*smallest_user_key,*largest_user_key].
@@ -120,14 +116,6 @@ class Version {
                      const Slice* smallest_user_key,
                      const Slice* largest_user_key);

-  // Returns true iff the first or last file in inputs contains
-  // an overlapping user key to the file "just outside" of it (i.e.
-  // just after the last file, or just before the first file)
-  // REQUIRES: "*inputs" is a sorted list of non-overlapping files
-  bool HasOverlappingUserKey(const std::vector<FileMetaData*>* inputs,
-                             int level);
-
-
  // Return the level at which we should place a new memtable compaction
  // result that covers the range [smallest_user_key,largest_user_key].
  int PickLevelForMemTableOutput(const Slice& smallest_user_key,
@@ -146,12 +134,9 @@ class Version {
 private:
  friend class Compaction;
  friend class VersionSet;
-  friend class DBImpl;

  class LevelFileNumIterator;
-  Iterator* NewConcatenatingIterator(const ReadOptions&,
-                                     const EnvOptions& soptions,
-                                     int level) const;
+  Iterator* NewConcatenatingIterator(const ReadOptions&, int level) const;

  VersionSet* vset_;            // VersionSet to which this Version belongs
  Version* next_;               // Next version in linked list
@@ -219,7 +204,6 @@ class VersionSet {
 public:
  VersionSet(const std::string& dbname,
             const Options* options,
-             const EnvOptions& storage_options,
             TableCache* table_cache,
             const InternalKeyComparator*);
  ~VersionSet();
@@ -338,7 +322,8 @@ class VersionSet {
  }

  // Add all files listed in any live version to *live.
-  void AddLiveFiles(std::vector<uint64_t>* live_list);
+  // May also mutate some internal state.
+  void AddLiveFiles(std::set<uint64_t>* live);

  // Add all files listed in the current version to *live.
  void AddLiveFilesCurrentVersion(std::set<uint64_t>* live);
@@ -352,9 +337,6 @@ class VersionSet {
  struct LevelSummaryStorage {
    char buffer[100];
  };
-  struct FileSummaryStorage {
-    char buffer[1000];
-  };
  const char* LevelSummary(LevelSummaryStorage* scratch) const;

  // printf contents (for debugging)
@@ -365,10 +347,6 @@ class VersionSet {
  // of files per level.  Uses *scratch as backing store.
  const char* LevelDataSizeSummary(LevelSummaryStorage* scratch) const;

-  // Return a human-readable short (single-line) summary of files
-  // in a specified level.  Uses *scratch as backing store.
-  const char* LevelFileSummary(FileSummaryStorage* scratch, int level) const;
-
  // Return the size of the current manifest file
  const uint64_t ManifestFileSize() { return current_->offset_manifest_file_; }

@@ -378,9 +356,6 @@ class VersionSet {
  // function will return nullptr.
  Compaction* PickCompactionBySize(int level, double score);

-  // Pick files to compact in Universal mode
-  Compaction* PickCompactionUniversal(int level, double score);
-
  // Free up the files that were participated in a compaction
  void ReleaseCompactionFiles(Compaction* c, Status status);

@@ -403,8 +378,6 @@ class VersionSet {
  // Get the max file size in a given level.
  uint64_t MaxFileSizeForLevel(int level);

-  double MaxBytesForLevel(int level);
-
 private:
  class Builder;
  struct ManifestWriter;
@@ -425,8 +398,6 @@ class VersionSet {
                 InternalKey* smallest,
                 InternalKey* largest);

-  void ExpandWhileOverlapping(Compaction* c);
-
  void SetupOtherInputs(Compaction* c);

  // Save current contents to *log
@@ -436,9 +407,11 @@ class VersionSet {

  bool ManifestContains(const std::string& record) const;

-  uint64_t ExpandedCompactionByteSizeLimit(int level);
+  double MaxBytesForLevel(int level);

-  uint64_t MaxGrandParentOverlapBytes(int level);
+  int64_t ExpandedCompactionByteSizeLimit(int level);
+
+  int64_t MaxGrandParentOverlapBytes(int level);

  Env* const env_;
  const std::string dbname_;
@@ -481,13 +454,6 @@ class VersionSet {
  // Save us the cost of checking file size twice in LogAndApply
  uint64_t last_observed_manifest_size_;

-  // storage options for all reads and writes except compactions
-  const EnvOptions& storage_options_;
-
-  // storage options used for compactions. This is a copy of
-  // storage_options_ but with readaheads set to readahead_compactions_.
-  const EnvOptions storage_options_compactions_;
-
  // No copying allowed
  VersionSet(const VersionSet&);
  void operator=(const VersionSet&);
@@ -513,12 +479,9 @@ class Compaction {
  ~Compaction();

  // Return the level that is being compacted.  Inputs from "level"
-  // will be merged.
+  // and "level+1" will be merged to produce a set of "level+1" files.
  int level() const { return level_; }

-  // Outputs will go to this level
-  int output_level() const { return out_level_; }
-
  // Return the object that holds the edits to the descriptor done
  // by this compaction.
  VersionEdit* edit() { return edit_; }
@@ -557,21 +520,17 @@ class Compaction {
  // Return the score that was used to pick this compaction run.
  double score() const { return score_; }

-  // Is this compaction creating a file in the bottom most level?
-  bool BottomMostLevel() { return bottommost_level_; }
-
 private:
  friend class Version;
  friend class VersionSet;

-  explicit Compaction(int level, int out_level, uint64_t target_file_size,
+  explicit Compaction(int level, uint64_t target_file_size,
    uint64_t max_grandparent_overlap_bytes, int number_levels,
    bool seek_compaction = false);

  int level_;
-  int out_level_; // levels to which output files are stored
  uint64_t max_output_file_size_;
-  uint64_t maxGrandParentOverlapBytes_;
+  int64_t maxGrandParentOverlapBytes_;
  Version* input_version_;
  VersionEdit* edit_;
  int number_levels_;
@@ -586,27 +545,23 @@ class Compaction {
  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
+  int64_t overlapped_bytes_;  // Bytes of overlap between current output
                              // and grandparent files
  int base_index_;   // index of the file in files_[level_]
  int parent_index_; // index of some file with same range in files_[level_+1]
  double score_;     // score that was used to pick this compaction.

-  // Is this compaction creating a file in the bottom most level?
-  bool bottommost_level_;
+  // State for implementing IsBaseLevelForKey

  // level_ptrs_ holds indices into input_version_->levels_: our state
  // is that we are positioned at one of the file ranges for each
  // higher level than the ones involved in this compaction (i.e. for
  // all L >= level_ + 2).
-  std::vector<size_t> level_ptrs_;
+  size_t* level_ptrs_;

  // mark (or clear) all files that are being compacted
  void MarkFilesBeingCompacted(bool);

-  // Initialize whether compaction producing files at the bottommost level
-  void SetupBottomMostLevel(bool isManual);
-
  // In case of compaction error, reset the nextIndex that is used
  // to pick up the next file to be compacted from files_by_size_
  void ResetNextCompactionIndex();
@@ -7,8 +7,7 @@
 //    count: fixed32
 //    data: record[count]
 // record :=
-//    kTypeValue varstring varstring
-//    kTypeMerge varstring varstring
+//    kTypeValue varstring varstring         |
 //    kTypeDeletion varstring
 // varstring :=
 //    len: varint32
@@ -16,15 +15,11 @@

 #include "leveldb/write_batch.h"

-#include "leveldb/options.h"
-#include "leveldb/statistics.h"
+#include "leveldb/db.h"
 #include "db/dbformat.h"
-#include "db/db_impl.h"
 #include "db/memtable.h"
-#include "db/snapshot.h"
 #include "db/write_batch_internal.h"
 #include "util/coding.h"
-#include <stdexcept>

 namespace leveldb {

@@ -39,24 +34,11 @@ WriteBatch::~WriteBatch() { }

 WriteBatch::Handler::~Handler() { }

-void WriteBatch::Handler::Merge(const Slice& key, const Slice& value) {
-  throw std::runtime_error("Handler::Merge not implemented!");
-}
-
-void WriteBatch::Handler::LogData(const Slice& blob) {
-  // If the user has not specified something to do with blobs, then we ignore
-  // them.
-}
-
 void WriteBatch::Clear() {
  rep_.clear();
  rep_.resize(kHeader);
 }

-int WriteBatch::Count() const {
-  return WriteBatchInternal::Count(this);
-}
-
 Status WriteBatch::Iterate(Handler* handler) const {
  Slice input(rep_);
  if (input.size() < kHeader) {
@@ -64,9 +46,10 @@ Status WriteBatch::Iterate(Handler* handler) const {
  }

  input.remove_prefix(kHeader);
-  Slice key, value, blob;
+  Slice key, value;
  int found = 0;
  while (!input.empty()) {
+    found++;
    char tag = input[0];
    input.remove_prefix(1);
    switch (tag) {
@@ -74,7 +57,6 @@ Status WriteBatch::Iterate(Handler* handler) const {
        if (GetLengthPrefixedSlice(&input, &key) &&
            GetLengthPrefixedSlice(&input, &value)) {
          handler->Put(key, value);
-          found++;
        } else {
          return Status::Corruption("bad WriteBatch Put");
        }
@@ -82,27 +64,10 @@ Status WriteBatch::Iterate(Handler* handler) const {
      case kTypeDeletion:
        if (GetLengthPrefixedSlice(&input, &key)) {
          handler->Delete(key);
-          found++;
        } else {
          return Status::Corruption("bad WriteBatch Delete");
        }
        break;
-      case kTypeMerge:
-        if (GetLengthPrefixedSlice(&input, &key) &&
-            GetLengthPrefixedSlice(&input, &value)) {
-          handler->Merge(key, value);
-          found++;
-        } else {
-          return Status::Corruption("bad WriteBatch Merge");
-        }
-        break;
-      case kTypeLogData:
-        if (GetLengthPrefixedSlice(&input, &blob)) {
-          handler->LogData(blob);
-        } else {
-          return Status::Corruption("bad WriteBatch Blob");
-        }
-        break;
      default:
        return Status::Corruption("unknown WriteBatch tag");
    }
@@ -143,72 +108,28 @@ void WriteBatch::Delete(const Slice& key) {
  PutLengthPrefixedSlice(&rep_, key);
 }

-void WriteBatch::Merge(const Slice& key, const Slice& value) {
-  WriteBatchInternal::SetCount(this, WriteBatchInternal::Count(this) + 1);
-  rep_.push_back(static_cast<char>(kTypeMerge));
-  PutLengthPrefixedSlice(&rep_, key);
-  PutLengthPrefixedSlice(&rep_, value);
-}
-
-void WriteBatch::PutLogData(const Slice& blob) {
-  rep_.push_back(static_cast<char>(kTypeLogData));
-  PutLengthPrefixedSlice(&rep_, blob);
-}
-
 namespace {
 class MemTableInserter : public WriteBatch::Handler {
 public:
  SequenceNumber sequence_;
  MemTable* mem_;
-  const Options* options_;
-  DBImpl* db_;
-  const bool filter_deletes_;
-
-  MemTableInserter(SequenceNumber sequence, MemTable* mem, const Options* opts,
-                   DB* db, const bool filter_deletes)
-    : sequence_(sequence),
-      mem_(mem),
-      options_(opts),
-      db_(reinterpret_cast<DBImpl*>(db)),
-      filter_deletes_(filter_deletes) {
-    assert(mem_);
-    if (filter_deletes_) {
-      assert(options_);
-      assert(db_);
-    }
-  }

  virtual void Put(const Slice& key, const Slice& value) {
    mem_->Add(sequence_, kTypeValue, key, value);
    sequence_++;
  }
-  virtual void Merge(const Slice& key, const Slice& value) {
-    mem_->Add(sequence_, kTypeMerge, key, value);
-    sequence_++;
-  }
  virtual void Delete(const Slice& key) {
-    if (filter_deletes_) {
-      SnapshotImpl read_from_snapshot;
-      read_from_snapshot.number_ = sequence_;
-      ReadOptions ropts;
-      ropts.snapshot = &read_from_snapshot;
-      std::string value;
-      if (!db_->KeyMayExist(ropts, key, &value)) {
-        RecordTick(options_->statistics, NUMBER_FILTERED_DELETES);
-        return;
-      }
-    }
    mem_->Add(sequence_, kTypeDeletion, key, Slice());
    sequence_++;
  }
 };
 }  // namespace

-Status WriteBatchInternal::InsertInto(const WriteBatch* b, MemTable* mem,
-                                      const Options* opts, DB* db,
-                                      const bool filter_deletes) {
-  MemTableInserter inserter(WriteBatchInternal::Sequence(b), mem, opts, db,
-                            filter_deletes);
+Status WriteBatchInternal::InsertInto(const WriteBatch* b,
+                                      MemTable* memtable) {
+  MemTableInserter inserter;
+  inserter.sequence_ = WriteBatchInternal::Sequence(b);
+  inserter.mem_ = memtable;
  return b->Iterate(&inserter);
 }

@@ -7,8 +7,6 @@

 #include "leveldb/types.h"
 #include "leveldb/write_batch.h"
-#include "leveldb/db.h"
-#include "leveldb/options.h"

 namespace leveldb {

@@ -41,12 +39,7 @@ class WriteBatchInternal {

  static void SetContents(WriteBatch* batch, const Slice& contents);

-  // Inserts batch entries into memtable
-  // Drops deletes in batch if filter_del is set to true and
-  // db->KeyMayExist returns false
-  static Status InsertInto(const WriteBatch* batch, MemTable* memtable,
-                           const Options* opts = nullptr, DB* db = nullptr,
-                           const bool filter_del = false);
+  static Status InsertInto(const WriteBatch* batch, MemTable* memtable);

  static void Append(WriteBatch* dst, const WriteBatch* src);
 };
@@ -4,8 +4,6 @@

 #include "leveldb/db.h"

-#include <memory>
-#include "db/skiplistrep.h"
 #include "db/memtable.h"
 #include "db/write_batch_internal.h"
 #include "leveldb/env.h"
@@ -16,8 +14,7 @@ namespace leveldb {

 static std::string PrintContents(WriteBatch* b) {
  InternalKeyComparator cmp(BytewiseComparator());
-  auto factory = std::make_shared<SkipListFactory>();
-  MemTable* mem = new MemTable(cmp, factory);
+  MemTable* mem = new MemTable(cmp);
  mem->Ref();
  std::string state;
  Status s = WriteBatchInternal::InsertInto(b, mem);
@@ -36,30 +33,19 @@ static std::string PrintContents(WriteBatch* b) {
        state.append(")");
        count++;
        break;
-      case kTypeMerge:
-        state.append("Merge(");
-        state.append(ikey.user_key.ToString());
-        state.append(", ");
-        state.append(iter->value().ToString());
-        state.append(")");
-        count++;
-        break;
      case kTypeDeletion:
        state.append("Delete(");
        state.append(ikey.user_key.ToString());
        state.append(")");
        count++;
        break;
-      case kTypeLogData:
-        assert(false);
-        break;
    }
    state.append("@");
    state.append(NumberToString(ikey.sequence));
  }
  delete iter;
  if (!s.ok()) {
-    state.append(s.ToString());
+    state.append("ParseError()");
  } else if (count != WriteBatchInternal::Count(b)) {
    state.append("CountMismatch()");
  }
@@ -73,7 +59,6 @@ TEST(WriteBatchTest, Empty) {
  WriteBatch batch;
  ASSERT_EQ("", PrintContents(&batch));
  ASSERT_EQ(0, WriteBatchInternal::Count(&batch));
-  ASSERT_EQ(0, batch.Count());
 }

 TEST(WriteBatchTest, Multiple) {
@@ -88,7 +73,6 @@ TEST(WriteBatchTest, Multiple) {
            "Delete(box)@101"
            "Put(foo, bar)@100",
            PrintContents(&batch));
-  ASSERT_EQ(3, batch.Count());
 }

 TEST(WriteBatchTest, Corruption) {
@@ -100,7 +84,7 @@ TEST(WriteBatchTest, Corruption) {
  WriteBatchInternal::SetContents(&batch,
                                  Slice(contents.data(),contents.size()-1));
  ASSERT_EQ("Put(foo, bar)@200"
-            "Corruption: bad WriteBatch Delete",
+            "ParseError()",
            PrintContents(&batch));
 }

@@ -111,19 +95,16 @@ TEST(WriteBatchTest, Append) {
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("",
            PrintContents(&b1));
-  ASSERT_EQ(0, b1.Count());
  b2.Put("a", "va");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200",
            PrintContents(&b1));
-  ASSERT_EQ(1, b1.Count());
  b2.Clear();
  b2.Put("b", "vb");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200"
            "Put(b, vb)@201",
            PrintContents(&b1));
-  ASSERT_EQ(2, b1.Count());
  b2.Delete("foo");
  WriteBatchInternal::Append(&b1, &b2);
  ASSERT_EQ("Put(a, va)@200"
@@ -131,51 +112,6 @@ TEST(WriteBatchTest, Append) {
            "Put(b, vb)@201"
            "Delete(foo)@203",
            PrintContents(&b1));
-  ASSERT_EQ(4, b1.Count());
-}
-
-TEST(WriteBatchTest, Blob) {
-  WriteBatch batch;
-  batch.Put(Slice("k1"), Slice("v1"));
-  batch.Put(Slice("k2"), Slice("v2"));
-  batch.Put(Slice("k3"), Slice("v3"));
-  batch.PutLogData(Slice("blob1"));
-  batch.Delete(Slice("k2"));
-  batch.PutLogData(Slice("blob2"));
-  batch.Merge(Slice("foo"), Slice("bar"));
-  ASSERT_EQ(5, batch.Count());
-  ASSERT_EQ("Merge(foo, bar)@4"
-            "Put(k1, v1)@0"
-            "Delete(k2)@3"
-            "Put(k2, v2)@1"
-            "Put(k3, v3)@2",
-            PrintContents(&batch));
-
-  struct Handler : public WriteBatch::Handler {
-    std::string seen;
-    virtual void Put(const Slice& key, const Slice& value) {
-      seen += "Put(" + key.ToString() + ", " + value.ToString() + ")";
-    }
-    virtual void Merge(const Slice& key, const Slice& value) {
-      seen += "Merge(" + key.ToString() + ", " + value.ToString() + ")";
-    }
-    virtual void LogData(const Slice& blob) {
-      seen += "LogData(" + blob.ToString() + ")";
-    }
-    virtual void Delete(const Slice& key) {
-      seen += "Delete(" + key.ToString() + ")";
-    }
-  } handler;
-  batch.Iterate(&handler);
-  ASSERT_EQ(
-            "Put(k1, v1)"
-            "Put(k2, v2)"
-            "Put(k3, v3)"
-            "LogData(blob1)"
-            "Delete(k2)"
-            "LogData(blob2)"
-            "Merge(foo, bar)",
-            handler.seen);
 }

 }  // namespace leveldb
@@ -4,10 +4,10 @@
 # fbcode settings.  It uses the latest g++ compiler and also
 # uses jemalloc

-TOOLCHAIN_REV=83eb773e262fa705eaebbf3de40db71d53fabf2e
+TOOLCHAIN_REV=3748fabb2c5e033009597bae1f9ef8bf4b218581
 TOOLCHAIN_EXECUTABLES="/mnt/gvfs/third-party/$TOOLCHAIN_REV/centos5.2-native"
 TOOLCHAIN_LIB_BASE="/mnt/gvfs/third-party/$TOOLCHAIN_REV/gcc-4.7.1-glibc-2.14.1"
-TOOL_JEMALLOC=jemalloc-3.3.1/2f45f3a
+TOOL_JEMALLOC=jemalloc-3.0.0/2f45f3a

 # location of libhdfs libraries
 if test "$USE_HDFS"; then
@@ -235,18 +235,15 @@ class HdfsEnv : public Env {
  }

  virtual Status NewSequentialFile(const std::string& fname,
-                                   unique_ptr<SequentialFile>* result,
-                                   const EnvOptions& options);
+                                   unique_ptr<SequentialFile>* result);

  virtual Status NewRandomAccessFile(const std::string& fname,
-                                     unique_ptr<RandomAccessFile>* result,
-                                     const EnvOptions& options) {
+                                     unique_ptr<RandomAccessFile>* result) {
    return notsup;
  }

  virtual Status NewWritableFile(const std::string& fname,
-                                 unique_ptr<WritableFile>* result,
-                                 const EnvOptions& options) {
+                                 unique_ptr<WritableFile>* result) {
    return notsup;
  }

@@ -233,8 +233,7 @@ class InMemoryEnv : public EnvWrapper {

  // Partial implementation of the Env interface.
  virtual Status NewSequentialFile(const std::string& fname,
-                                   unique_ptr<SequentialFile>* result,
-                                   const EnvOptions& soptions) {
+                                   unique_ptr<SequentialFile>* result) {
    MutexLock lock(&mutex_);
    if (file_map_.find(fname) == file_map_.end()) {
      *result = NULL;
@@ -246,8 +245,7 @@ class InMemoryEnv : public EnvWrapper {
  }

  virtual Status NewRandomAccessFile(const std::string& fname,
-                                     unique_ptr<RandomAccessFile>* result,
-                                     const EnvOptions& soptions) {
+                                     unique_ptr<RandomAccessFile>* result) {
    MutexLock lock(&mutex_);
    if (file_map_.find(fname) == file_map_.end()) {
      *result = NULL;
@@ -259,8 +257,7 @@ class InMemoryEnv : public EnvWrapper {
  }

  virtual Status NewWritableFile(const std::string& fname,
-                                 unique_ptr<WritableFile>* result,
-                                 const EnvOptions& soptions) {
+                                 unique_ptr<WritableFile>* result) {
    MutexLock lock(&mutex_);
    if (file_map_.find(fname) != file_map_.end()) {
      DeleteFileInternal(fname);
@@ -17,7 +17,6 @@ namespace leveldb {
 class MemEnvTest {
 public:
  Env* env_;
-  const EnvOptions soptions_;

  MemEnvTest()
      : env_(NewMemEnv(Env::Default())) {
@@ -41,7 +40,7 @@ TEST(MemEnvTest, Basics) {
  ASSERT_EQ(0U, children.size());

  // Create a file.
-  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
+  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
  writable_file.reset();

  // Check that the file exists.
@@ -53,7 +52,7 @@ TEST(MemEnvTest, Basics) {
  ASSERT_EQ("f", children[0]);

  // Write to the file.
-  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
+  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
  ASSERT_OK(writable_file->Append("abc"));
  writable_file.reset();

@@ -72,11 +71,9 @@ TEST(MemEnvTest, Basics) {
  // Check that opening non-existent file fails.
  unique_ptr<SequentialFile> seq_file;
  unique_ptr<RandomAccessFile> rand_file;
-  ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file,
-                                       soptions_).ok());
+  ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file).ok());
  ASSERT_TRUE(!seq_file);
-  ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file,
-                                         soptions_).ok());
+  ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file).ok());
  ASSERT_TRUE(!rand_file);

  // Check that deleting works.
@@ -97,13 +94,13 @@ TEST(MemEnvTest, ReadWrite) {

  ASSERT_OK(env_->CreateDir("/dir"));

-  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
+  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
  ASSERT_OK(writable_file->Append("hello "));
  ASSERT_OK(writable_file->Append("world"));
  writable_file.reset();

  // Read sequentially.
-  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
+  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
  ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
  ASSERT_EQ(0, result.compare("hello"));
  ASSERT_OK(seq_file->Skip(1));
@@ -116,7 +113,7 @@ TEST(MemEnvTest, ReadWrite) {
  ASSERT_EQ(0U, result.size());

  // Random reads.
-  ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file, soptions_));
+  ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file));
  ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
  ASSERT_EQ(0, result.compare("world"));
  ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
@@ -142,7 +139,7 @@ TEST(MemEnvTest, Misc) {
  ASSERT_TRUE(!test_dir.empty());

  unique_ptr<WritableFile> writable_file;
-  ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file, soptions_));
+  ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file));

  // These are no-ops, but we test they return success.
  ASSERT_OK(writable_file->Sync());
@@ -161,14 +158,14 @@ TEST(MemEnvTest, LargeWrite) {
  }

  unique_ptr<WritableFile> writable_file;
-  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
+  ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
  ASSERT_OK(writable_file->Append("foo"));
  ASSERT_OK(writable_file->Append(write_data));
  writable_file.reset();

  unique_ptr<SequentialFile> seq_file;
  Slice result;
-  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
+  ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
  ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
  ASSERT_EQ(0, result.compare("foo"));

@@ -1,38 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// Arena class defines memory allocation methods. It's used by memtable and
-// skiplist.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_ARENA_H_
-#define STORAGE_LEVELDB_INCLUDE_ARENA_H_
-
-namespace leveldb {
-
-class Arena {
- public:
-  Arena() {};
-  virtual ~Arena() {};
-
-  // Return a pointer to a newly allocated memory block of "bytes" bytes.
-  virtual char* Allocate(size_t bytes) = 0;
-
-  // Allocate memory with the normal alignment guarantees provided by malloc.
-  virtual char* AllocateAligned(size_t bytes) = 0;
-
-  // Returns an estimate of the total memory used by arena.
-  virtual const size_t ApproximateMemoryUsage() = 0;
-
-  // Returns the total number of bytes in all blocks allocated so far.
-  virtual const size_t MemoryAllocatedBytes() = 0;
-
- private:
-  // No copying allowed
-  Arena(const Arena&);
-  void operator=(const Arena&);
-};
-
-}  // namespace leveldb
-
-#endif  // STORAGE_LEVELDB_INCLUDE_ARENA_H_
@@ -1,71 +0,0 @@
-// Copyright (c) 2013 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_COMPACTION_FILTER_H_
-#define STORAGE_LEVELDB_INCLUDE_COMPACTION_FILTER_H_
-
-#include <string>
-
-namespace leveldb {
-
-class Slice;
-
-// CompactionFilter allows an application to modify/delete a key-value at
-// the time of compaction.
-
-class CompactionFilter {
- public:
-  virtual ~CompactionFilter() {}
-
-
-  // The compaction process invokes this
-  // method for kv that is being compacted. A return value
-  // of false indicates that the kv should be preserved in the
-  // output of this compaction run and a return value of true
-  // indicates that this key-value should be removed from the
-  // output of the compaction.  The application can inspect
-  // the existing value of the key and make decision based on it.
-  //
-  // When the value is to be preserved, the application has the option
-  // to modify the existing_value and pass it back through new_value.
-  // value_changed needs to be set to true in this case.
-  virtual bool Filter(int level,
-                      const Slice& key,
-                      const Slice& existing_value,
-                      std::string* new_value,
-                      bool* value_changed) const = 0;
-
-  // Returns a name that identifies this compaction filter.
-  // The name will be printed to LOG file on start up for diagnosis.
-  virtual const char* Name() const = 0;
-};
-
-// Each compaction will create a new CompactionFilter allowing the
-// application to know about different campactions
-class CompactionFilterFactory {
-  public:
-    virtual ~CompactionFilterFactory() { };
-    virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter() = 0;
-
-    // Returns a name that identifies this compaction filter factory.
-    virtual const char* Name() const = 0;
-};
-
-// Default implementaion of CompactionFilterFactory which does not
-// return any filter
-class DefaultCompactionFilterFactory : public CompactionFilterFactory {
-  public:
-    virtual std::unique_ptr<CompactionFilter>
-    CreateCompactionFilter() override {
-      return std::unique_ptr<CompactionFilter>(nullptr);
-    }
-
-    virtual const char* Name() const override {
-      return "DefaultCompactionFilterFactory";
-    }
-};
-
-}  // namespace leveldb
-
-#endif  // STORAGE_LEVELDB_INCLUDE_COMPACTION_FILTER_H_
@@ -12,15 +12,15 @@
 #include "leveldb/iterator.h"
 #include "leveldb/options.h"
 #include "leveldb/types.h"
-#include "leveldb/transaction_log.h"
+#include "leveldb/transaction_log_iterator.h"

 namespace leveldb {

 using std::unique_ptr;

 // Update Makefile if you change these
-static const int kMajorVersion = 2;
-static const int kMinorVersion = 0;
+static const int kMajorVersion = 1;
+static const int kMinorVersion = 5;

 struct Options;
 struct ReadOptions;
@@ -83,14 +83,6 @@ class DB {
  // Note: consider setting options.sync = true.
  virtual Status Delete(const WriteOptions& options, const Slice& key) = 0;

-  // Merge the database entry for "key" with "value".  Returns OK on success,
-  // and a non-OK status on error. The semantics of this operation is
-  // determined by the user provided merge_operator when opening DB.
-  // Note: consider setting options.sync = true.
-  virtual Status Merge(const WriteOptions& options,
-                       const Slice& key,
-                       const Slice& value) = 0;
-
  // Apply the specified updates to the database.
  // Returns OK on success, non-OK on failure.
  // Note: consider setting options.sync = true.
@@ -104,39 +96,7 @@ class DB {
  //
  // May return some other Status on an error.
  virtual Status Get(const ReadOptions& options,
-                     const Slice& key,
-                     std::string* value) = 0;
-
-  // If keys[i] does not exist in the database, then the i'th returned
-  // status will be one for which Status::IsNotFound() is true, and
-  // (*values)[i] will be set to some arbitrary value (often ""). Otherwise,
-  // the i'th returned status will have Status::ok() true, and (*values)[i]
-  // will store the value associated with keys[i].
-  //
-  // (*values) will always be resized to be the same size as (keys).
-  // Similarly, the number of returned statuses will be the number of keys.
-  // Note: keys will not be "de-duplicated". Duplicate keys will return
-  // duplicate values in order.
-  virtual std::vector<Status> MultiGet(const ReadOptions& options,
-                                       const std::vector<Slice>& keys,
-                                       std::vector<std::string>* values) = 0;
-
-  // If the key definitely does not exist in the database, then this method
-  // returns false, else true. If the caller wants to obtain value when the key
-  // is found in memory, a bool for 'value_found' must be passed. 'value_found'
-  // will be true on return if value has been set properly.
-  // This check is potentially lighter-weight than invoking DB::Get(). One way
-  // to make this lighter weight is to avoid doing any IOs.
-  // Default implementation here returns true and sets 'value_found' to false
-  virtual bool KeyMayExist(const ReadOptions& options,
-                           const Slice& key,
-                           std::string* value,
-                           bool* value_found = nullptr) {
-    if (value_found != nullptr) {
-      *value_found = false;
-    }
-    return true;
-  }
+                     const Slice& key, std::string* value) = 0;

  // Return a heap-allocated iterator over the contents of the database.
  // The result of NewIterator() is initially invalid (caller must
@@ -193,14 +153,7 @@ class DB {
  // end==nullptr is treated as a key after all keys in the database.
  // Therefore the following call will compact the entire database:
  //    db->CompactRange(nullptr, nullptr);
-  // Note that after the entire database is compacted, all data are pushed
-  // down to the last level containing any data. If the total data size
-  // after compaction is reduced, that level might not be appropriate for
-  // hosting all the files. In this case, client could set reduce_level
-  // to true, to move the files back to the minimum level capable of holding
-  // the data set.
-  virtual void CompactRange(const Slice* begin, const Slice* end,
-                            bool reduce_level = false) = 0;
+  virtual void CompactRange(const Slice* begin, const Slice* end) = 0;

  // Number of levels used for this DB.
  virtual int NumberLevels() = 0;
@@ -232,15 +185,7 @@ class DB {
  virtual Status GetLiveFiles(std::vector<std::string>&,
                              uint64_t* manifest_file_size) = 0;

-  // Retrieve the sorted list of all wal files with earliest file first
-  virtual Status GetSortedWalFiles(VectorLogPtr& files) = 0;
-
-  // Delete wal files in files. These can be either live or archived.
-  // Returns Status::OK if all files could be deleted, otherwise Status::IOError
-  // which contains information about files that could not be deleted.
-  virtual Status DeleteWalFiles(const VectorLogPtr& files) = 0;
-
-  // The sequence number of the most recent transaction.
+  // The sequence number of the most recent transaction. 
  virtual SequenceNumber GetLatestSequenceNumber() = 0;

  // Return's an iterator for all writes since the sequence number
@@ -28,41 +28,10 @@ class RandomAccessFile;
 class SequentialFile;
 class Slice;
 class WritableFile;
-class Options;

 using std::unique_ptr;
 using std::shared_ptr;

-
-// Options while opening a file to read/write
-struct EnvOptions {
-
-  // construct with default Options
-  EnvOptions();
-
-  // construct from Options
-  EnvOptions(const Options& options);
-
-  // If true, then allow caching of data in environment buffers
-  bool use_os_buffer;
-
-   // If true, then use mmap to read data
-  bool use_mmap_reads;
-
-   // If true, then use mmap to write data
-  bool use_mmap_writes;
-
-  // If true, set the FD_CLOEXEC on open fd.
-  bool set_fd_cloexec;
-
-  // Allows OS to incrementally sync files to disk while they are being
-  // written, in the background. Issue one request for every bytes_per_sync
-  // written. 0 turns it off.
-  // Default: 0
-  uint64_t bytes_per_sync;
-
-};
-
 class Env {
 public:
  Env() { }
@@ -82,9 +51,7 @@ class Env {
  //
  // The returned file will only be accessed by one thread at a time.
  virtual Status NewSequentialFile(const std::string& fname,
-                                   unique_ptr<SequentialFile>* result,
-                                   const EnvOptions& options)
-                                   = 0;
+                                   unique_ptr<SequentialFile>* result) = 0;

  // Create a brand new random access read-only file with the
  // specified name.  On success, stores a pointer to the new file in
@@ -94,9 +61,7 @@ class Env {
  //
  // The returned file may be concurrently accessed by multiple threads.
  virtual Status NewRandomAccessFile(const std::string& fname,
-                                     unique_ptr<RandomAccessFile>* result,
-                                     const EnvOptions& options)
-                                     = 0;
+                                     unique_ptr<RandomAccessFile>* result) = 0;

  // Create an object that writes to a new file with the specified
  // name.  Deletes any existing file with the same name and creates a
@@ -106,8 +71,7 @@ class Env {
  //
  // The returned file will only be accessed by one thread at a time.
  virtual Status NewWritableFile(const std::string& fname,
-                                 unique_ptr<WritableFile>* result,
-                                 const EnvOptions& options) = 0;
+                                 unique_ptr<WritableFile>* result) = 0;

  // Returns true iff the named file exists.
  virtual bool FileExists(const std::string& fname) = 0;
@@ -264,7 +228,7 @@ class RandomAccessFile {
  // the file is opened (and will stay the same while the file is open).
  // Furthermore, it tries to make this ID at most "max_size" bytes. If such an
  // ID can be created this function returns the length of the ID and places it
-  // in "id"; otherwise, this function returns 0, in which case "id"
+  // in "id"; otherwise, this function returns 0, in which case "id" may more
  // may not have been modified.
  //
  // This function guarantees, for IDs from a given environment, two unique ids
@@ -279,12 +243,6 @@ class RandomAccessFile {
    return 0; // Default implementation to prevent issues with backwards
              // compatibility.
  };
-
-
-  enum AccessPattern { NORMAL, RANDOM, SEQUENTIAL, WILLNEED, DONTNEED };
-
-  virtual void Hint(AccessPattern pattern) {}
-
 };

 // A file abstraction for sequential writing.  The implementation
@@ -366,16 +324,6 @@ class WritableFile {
    return Status::OK();
  }

-  // Sync a file range with disk.
-  // offset is the starting byte of the file range to be synchronized.
-  // nbytes specifies the length of the range to be synchronized.
-  // This asks the OS to initiate flushing the cached data to disk,
-  // without waiting for completion.
-  // Default implementation does nothing.
-  virtual Status RangeSync(off64_t offset, off64_t nbytes) {
-    return Status::OK();
-  }
-
 private:
  size_t last_preallocated_block_;
  size_t preallocation_block_size_;
@@ -450,18 +398,15 @@ class EnvWrapper : public Env {

  // The following text is boilerplate that forwards all methods to target()
  Status NewSequentialFile(const std::string& f,
-                           unique_ptr<SequentialFile>* r,
-                           const EnvOptions& options) {
-    return target_->NewSequentialFile(f, r, options);
+                           unique_ptr<SequentialFile>* r) {
+    return target_->NewSequentialFile(f, r);
  }
  Status NewRandomAccessFile(const std::string& f,
-                             unique_ptr<RandomAccessFile>* r,
-                             const EnvOptions& options) {
-    return target_->NewRandomAccessFile(f, r, options);
+                             unique_ptr<RandomAccessFile>* r) {
+    return target_->NewRandomAccessFile(f, r);
  }
-  Status NewWritableFile(const std::string& f, unique_ptr<WritableFile>* r,
-                         const EnvOptions& options) {
-    return target_->NewWritableFile(f, r, options);
+  Status NewWritableFile(const std::string& f, unique_ptr<WritableFile>* r) {
+    return target_->NewWritableFile(f, r);
  }
  bool FileExists(const std::string& f) { return target_->FileExists(f); }
  Status GetChildren(const std::string& dir, std::vector<std::string>* r) {
@@ -1,14 +0,0 @@
-// Copyright 2008-present Facebook. All Rights Reserved.
-#ifndef STORAGE_LEVELDB_INCLUDE_LDB_TOOL_H
-#define STORAGE_LEVELDB_INCLUDE_LDB_TOOL_H
-#include "leveldb/options.h"
-
-namespace leveldb {
-
-class LDBTool {
- public:
-  void Run(int argc, char** argv, Options = Options());
-};
-
-} // namespace leveldb
-#endif // STORAGE_LEVELDB_INCLUDE_LDB_TOOL_H
@@ -1,88 +0,0 @@
-// This file contains the interface that must be implemented by any collection
-// to be used as the backing store for a MemTable. Such a collection must
-// satisfy the following properties:
-//  (1) It does not store duplicate items.
-//  (2) It uses MemTableRep::KeyComparator to compare items for iteration and
-//     equality.
-//  (3) It can be accessed concurrently by multiple readers but need not support
-//      concurrent writes.
-//  (4) Items are never deleted.
-// The liberal use of assertions is encouraged to enforce (1).
-
-#ifndef STORAGE_LEVELDB_DB_TABLE_H_
-#define STORAGE_LEVELDB_DB_TABLE_H_
-
-#include <memory>
-#include "leveldb/arena.h"
-
-namespace leveldb {
-
-class MemTableRep {
- public:
-  // KeyComparator(a, b) returns a negative value if a is less than b, 0 if they
-  // are equal, and a positive value if b is greater than a
-  class KeyComparator {
-  public:
-    virtual int operator()(const char* a, const char* b) const = 0;
-    virtual ~KeyComparator() { }
-  };
-
-  // Insert key into the collection. (The caller will pack key and value into a
-  // single buffer and pass that in as the parameter to Insert)
-  // REQUIRES: nothing that compares equal to key is currently in the
-  // collection.
-  virtual void Insert(const char* key) = 0;
-
-  // Returns true iff an entry that compares equal to key is in the collection.
-  virtual bool Contains(const char* key) const = 0;
-
-  virtual ~MemTableRep() { }
-
-  // Iteration over the contents of a skip collection
-  class Iterator {
-   public:
-    // Initialize an iterator over the specified collection.
-    // The returned iterator is not valid.
-    // explicit Iterator(const MemTableRep* collection);
-    virtual ~Iterator() { };
-
-    // Returns true iff the iterator is positioned at a valid node.
-    virtual bool Valid() const = 0;
-
-    // Returns the key at the current position.
-    // REQUIRES: Valid()
-    virtual const char* key() const = 0;
-
-    // Advances to the next position.
-    // REQUIRES: Valid()
-    virtual void Next() = 0;
-
-    // Advances to the previous position.
-    // REQUIRES: Valid()
-    virtual void Prev() = 0;
-
-    // Advance to the first entry with a key >= target
-    virtual void Seek(const char* target) = 0;
-
-    // Position at the first entry in collection.
-    // Final state of iterator is Valid() iff collection is not empty.
-    virtual void SeekToFirst() = 0;
-
-    // Position at the last entry in collection.
-    // Final state of iterator is Valid() iff collection is not empty.
-    virtual void SeekToLast() = 0;
-  };
-
-  virtual std::shared_ptr<Iterator> GetIterator() = 0;
-};
-
-class MemTableRepFactory {
- public:
-  virtual ~MemTableRepFactory() { };
-  virtual std::shared_ptr<MemTableRep> CreateMemTableRep(
-    MemTableRep::KeyComparator&, Arena* arena) = 0;
-};
-
-}
-
-#endif // STORAGE_LEVELDB_DB_TABLE_H_
@@ -1,147 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_MERGE_OPERATOR_H_
-#define STORAGE_LEVELDB_INCLUDE_MERGE_OPERATOR_H_
-
-#include <string>
-#include <deque>
-#include "leveldb/slice.h"  // TODO: Remove this when migration is done;
-
-namespace leveldb {
-
-class Slice;
-class Logger;
-
-// The Merge Operator
-//
-// Essentially, a MergeOperator specifies the SEMANTICS of a merge, which only
-// client knows. It could be numeric addition, list append, string
-// concatenation, edit data structure, ... , anything.
-// The library, on the other hand, is concerned with the exercise of this
-// interface, at the right time (during get, iteration, compaction...)
-//
-// To use merge, the client needs to provide an object implementing one of
-// the following interfaces:
-//  a) AssociativeMergeOperator - for most simple semantics (always take
-//    two values, and merge them into one value, which is then put back
-//    into rocksdb); numeric addition and string concatenation are examples;
-//
-//  b) MergeOperator - the generic class for all the more abstract / complex
-//    operations; one method (FullMerge) to merge a Put/Delete value with a
-//    merge operand; and another method (PartialMerge) that merges two
-//    operands together. this is especially useful if your key values have a
-//    complex structure but you would still like to support client-specific
-//    incremental updates.
-//
-// AssociativeMergeOperator is simpler to implement. MergeOperator is simply
-// more powerful.
-//
-// Refer to rocksdb-merge wiki for more details and example implementations.
-//
-class MergeOperator {
- public:
-  virtual ~MergeOperator() {}
-
-  // Gives the client a way to express the read -> modify -> write semantics
-  // key:      (IN)    The key that's associated with this merge operation.
-  //                   Client could multiplex the merge operator based on it
-  //                   if the key space is partitioned and different subspaces
-  //                   refer to different types of data which have different
-  //                   merge operation semantics
-  // existing: (IN)    null indicates that the key does not exist before this op
-  // operand_list:(IN) the sequence of merge operations to apply, front() first.
-  // new_value:(OUT)   Client is responsible for filling the merge result here
-  // logger:   (IN)    Client could use this to log errors during merge.
-  //
-  // Return true on success.
-  // All values passed in will be client-specific values. So if this method
-  // returns false, it is because client specified bad data or there was
-  // internal corruption. This will be treated as an error by the library.
-  //
-  // Also make use of the *logger for error messages.
-  virtual bool FullMerge(const Slice& key,
-                         const Slice* existing_value,
-                         const std::deque<std::string>& operand_list,
-                         std::string* new_value,
-                         Logger* logger) const = 0;
-
-  // This function performs merge(left_op, right_op)
-  // when both the operands are themselves merge operation types
-  // that you would have passed to a DB::Merge() call in the same order
-  // (i.e.: DB::Merge(key,left_op), followed by DB::Merge(key,right_op)).
-  //
-  // PartialMerge should combine them into a single merge operation that is
-  // saved into *new_value, and then it should return true.
-  // *new_value should be constructed such that a call to
-  // DB::Merge(key, *new_value) would yield the same result as a call
-  // to DB::Merge(key, left_op) followed by DB::Merge(key, right_op).
-  //
-  // If it is impossible or infeasible to combine the two operations,
-  // leave new_value unchanged and return false. The library will
-  // internally keep track of the operations, and apply them in the
-  // correct order once a base-value (a Put/Delete/End-of-Database) is seen.
-  //
-  // TODO: Presently there is no way to differentiate between error/corruption
-  // and simply "return false". For now, the client should simply return
-  // false in any case it cannot perform partial-merge, regardless of reason.
-  // If there is corruption in the data, handle it in the FullMerge() function,
-  // and return false there.
-  virtual bool PartialMerge(const Slice& key,
-                            const Slice& left_operand,
-                            const Slice& right_operand,
-                            std::string* new_value,
-                            Logger* logger) const = 0;
-
-  // The name of the MergeOperator. Used to check for MergeOperator
-  // mismatches (i.e., a DB created with one MergeOperator is
-  // accessed using a different MergeOperator)
-  // TODO: the name is currently not stored persistently and thus
-  //       no checking is enforced. Client is responsible for providing
-  //       consistent MergeOperator between DB opens.
-  virtual const char* Name() const = 0;
-};
-
-// The simpler, associative merge operator.
-class AssociativeMergeOperator : public MergeOperator {
- public:
-  virtual ~AssociativeMergeOperator() {}
-
-  // Gives the client a way to express the read -> modify -> write semantics
-  // key:           (IN) The key that's associated with this merge operation.
-  // existing_value:(IN) null indicates the key does not exist before this op
-  // value:         (IN) the value to update/merge the existing_value with
-  // new_value:    (OUT) Client is responsible for filling the merge result here
-  // logger:        (IN) Client could use this to log errors during merge.
-  //
-  // Return true on success.
-  // All values passed in will be client-specific values. So if this method
-  // returns false, it is because client specified bad data or there was
-  // internal corruption. The client should assume that this will be treated
-  // as an error by the library.
-  virtual bool Merge(const Slice& key,
-                     const Slice* existing_value,
-                     const Slice& value,
-                     std::string* new_value,
-                     Logger* logger) const = 0;
-
-
- private:
-  // Default implementations of the MergeOperator functions
-  virtual bool FullMerge(const Slice& key,
-                         const Slice* existing_value,
-                         const std::deque<std::string>& operand_list,
-                         std::string* new_value,
-                         Logger* logger) const override;
-
-  virtual bool PartialMerge(const Slice& key,
-                            const Slice& left_operand,
-                            const Slice& right_operand,
-                            std::string* new_value,
-                            Logger* logger) const override;
-};
-
-}  // namespace leveldb
-
-#endif  // STORAGE_LEVELDB_INCLUDE_MERGE_OPERATOR_H_
@@ -11,11 +11,6 @@
 #include <vector>
 #include <stdint.h>
 #include "leveldb/slice.h"
-#include "leveldb/statistics.h"
-#include "leveldb/universal_compaction.h"
-#include "leveldb/memtablerep.h"
-
-#include "leveldb/slice_transform.h"

 namespace leveldb {

@@ -24,10 +19,8 @@ class Comparator;
 class Env;
 class FilterPolicy;
 class Logger;
-class MergeOperator;
 class Snapshot;
-class CompactionFilter;
-class CompactionFilterFactory;
+class Statistics;

 using std::shared_ptr;

@@ -44,11 +37,6 @@ enum CompressionType {
  kBZip2Compression = 0x3
 };

-enum CompactionStyle {
-  kCompactionStyleLevel       = 0x0, // level based compaction style
-  kCompactionStyleUniversal   = 0x1  // Universal compaction style
-};
-
 // Compression options for different compression algorithms like Zlib
 struct CompressionOptions {
  int window_bits;
@@ -75,28 +63,6 @@ struct Options {
  // comparator provided to previous open calls on the same DB.
  const Comparator* comparator;

-  // REQUIRES: The client must provide a merge operator if Merge operation
-  // needs to be accessed. Calling Merge on a DB without a merge operator
-  // would result in Status::NotSupported. The client must ensure that the
-  // merge operator supplied here has the same name and *exactly* the same
-  // semantics as the merge operator provided to previous open calls on
-  // the same DB. The only exception is reserved for upgrade, where a DB
-  // previously without a merge operator is introduced to Merge operation
-  // for the first time. It's necessary to specify a merge operator when
-  // openning the DB in this case.
-  // Default: nullptr
-  shared_ptr<MergeOperator> merge_operator;
-
-  // The client must provide compaction_filter_factory if it requires a new
-  // compaction filter to be used for different compaction processes
-  // Allows an application to modify/delete a key-value during background
-  // compaction.
-  // Ideally, client should specify only one of filter or factory.
-  // compaction_filter takes precedence over compaction_filter_factory if
-  // client specifies both.
-  // Default: nullptr
-  const CompactionFilter* compaction_filter;
-
  // If true, the database will be created if it is missing.
  // Default: false
  bool create_if_missing;
@@ -146,15 +112,6 @@ struct Options {
  // Default: 2
  int max_write_buffer_number;

-  // The minimum number of write buffers that will be merged together
-  // before writing to storage.  If set to 1, then
-  // 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
-  // individual write buffers.  Default: 1
-  int min_write_buffer_number_to_merge;
-
  // Number of open files that can be used by the DB.  You may need to
  // increase this if your database has a large working set (budget
  // one open file per 2MB of working set).
@@ -226,28 +183,6 @@ struct Options {
  // Default: nullptr
  const FilterPolicy* filter_policy;

-  // If non-nullptr, use the specified function to determine the
-  // prefixes for keys.  These prefixes will be placed in the filter.
-  // Depending on the workload, this can reduce the number of read-IOP
-  // cost for scans when a prefix is passed via ReadOptions to
-  // db.NewIterator().  For prefix filtering to work properly,
-  // "prefix_extractor" and "comparator" must be such that the following
-  // properties hold:
-  //
-  // 1) key.starts_with(prefix(key))
-  // 2) Compare(prefix(key), key) <= 0.
-  // 3) If Compare(k1, k2) <= 0, then Compare(prefix(k1), prefix(k2)) <= 0
-  // 4) prefix(prefix(key)) == prefix(key)
-  //
-  // Default: nullptr
-  const SliceTransform* prefix_extractor;
-
-  // If true, place whole keys in the filter (not just prefixes).
-  // This must generally be true for gets to be efficient.
-  //
-  // Default: true
-  bool whole_key_filtering;
-
  // Number of levels for this database
  int num_levels;

@@ -255,9 +190,9 @@ struct Options {
  // level-0 compaction will not be triggered by number of files at all.
  int level0_file_num_compaction_trigger;

-  // Soft limit on number of level-0 files. We start slowing down writes at this
-  // point. A value <0 means that no writing slow down will be triggered by
-  // number of files in level-0.
+  // Soft limit on number of level-0 files. We slow down writes at this point.
+  // A value <0 means that no writing slow down will be triggered by number
+  // of files in level-0.
  int level0_slowdown_writes_trigger;

  // Maximum number of level-0 files.  We stop writes at this point.
@@ -301,12 +236,6 @@ struct Options {
  // by default 'max_bytes_for_level_base' is 10.
  int max_bytes_for_level_multiplier;

-  // Different max-size multipliers for different levels.
-  // These are multiplied by max_bytes_for_level_multiplier to arrive
-  // at the max-size of each level.
-  // Default: 1
-  std::vector<int> max_bytes_for_level_multiplier_additional;
-
  // Maximum number of bytes in all compacted files.  We avoid expanding
  // the lower level file set of a compaction if it would make the
  // total compaction cover more than
@@ -329,7 +258,7 @@ struct Options {
  // If non-null, then we should collect metrics about database operations
  // Statistics objects should not be shared between DB instances as
  // it does not use any locks to prevent concurrent updates.
-  shared_ptr<Statistics> statistics;
+  Statistics* statistics;

  // If true, then the contents of data files are not synced
  // to stable storage. Their contents remain in the OS buffers till the
@@ -391,44 +320,26 @@ struct Options {
  // Default: 1000
  size_t keep_log_file_num;

-  // Puts are delayed 0-1 ms when any level has a compaction score that exceeds
-  // soft_rate_limit. This is ignored when == 0.0.
-  // CONSTRAINT: soft_rate_limit <= hard_rate_limit. If this constraint does not
-  // hold, RocksDB will set soft_rate_limit = hard_rate_limit
-  // Default: 0 (disabled)
-  double soft_rate_limit;
+  // Puts are delayed when any level has a compaction score that
+  // exceeds rate_limit. This is ignored when <= 1.0.
+  double rate_limit;

-  // Puts are delayed 1ms at a time when any level has a compaction score that
-  // exceeds hard_rate_limit. This is ignored when <= 1.0.
-  // Default: 0 (disabled)
-  double hard_rate_limit;
-
-  // Max time a put will be stalled when hard_rate_limit is enforced. If 0, then
-  // there is no limit.
-  // Default: 1000
-  unsigned int rate_limit_delay_max_milliseconds;
+  // Max time a put will be stalled when rate_limit is enforced
+  int rate_limit_delay_milliseconds;

  // manifest file is rolled over on reaching this limit.
  // The older manifest file be deleted.
  // The default value is MAX_INT so that roll-over does not take place.
  uint64_t max_manifest_file_size;

-  // Disable block cache. If this is set to true,
+  // Disable block cache. If this is set to false,
  // then no block cache should be used, and the block_cache should
  // point to a nullptr object.
-  // Default: false
  bool no_block_cache;

  // Number of shards used for table cache.
  int table_cache_numshardbits;

-  // size of one block in arena memory allocation.
-  // If <= 0, a proper value is automatically calculated (usually 1/10 of
-  // writer_buffer_size).
-  //
-  // Default: 0
-  size_t arena_block_size;
-
  // Create an Options object with default values for all fields.
  Options();

@@ -443,6 +354,25 @@ struct Options {
  // from the database, because otherwise the read can be very slow.
  Options* PrepareForBulkLoad();

+  // This method allows an application to modify/delete a key-value at
+  // the time of compaction. The compaction process invokes this
+  // method for every kv that is being compacted. A return value
+  // of false indicates that the kv should be preserved in the
+  // output of this compaction run and a return value of true
+  // indicates that this key-value should be removed from the
+  // output of the compaction.  The application can inspect
+  // the existing value of the key, modify it if needed and
+  // return back the new value for this key. The application
+  // should allocate memory for the Slice object that is used to
+  // return the new value and the leveldb framework will
+  // free up that memory.
+  // The compaction_filter_args, if specified here, are passed
+  // back to the invocation of the CompactionFilter.
+  void* compaction_filter_args;
+  bool (*CompactionFilter)(void* compaction_filter_args,
+         int level, const Slice& key,
+         const Slice& existing_value, Slice** new_value);
+
  // Disable automatic compactions. Manual compactions can still
  // be issued on this database.
  bool disable_auto_compactions;
@@ -466,82 +396,6 @@ struct Options {
  // Purge duplicate/deleted keys when a memtable is flushed to storage.
  // Default: true
  bool purge_redundant_kvs_while_flush;
-
-  // Data being read from file storage may be buffered in the OS
-  // Default: true
-  bool allow_os_buffer;
-
-  // Allow the OS to mmap file for reading sst tables. Default: false
-  bool allow_mmap_reads;
-
-  // Allow the OS to mmap file for writing. Default: true
-  bool allow_mmap_writes;
-
-  // Disable child process inherit open files. Default: true
-  bool is_fd_close_on_exec;
-
-  // Skip log corruption error on recovery (If client is ok with
-  // losing most recent changes)
-  // Default: false
-  bool skip_log_error_on_recovery;
-
-  // if not zero, dump leveldb.stats to LOG every stats_dump_period_sec
-  // Default: 3600 (1 hour)
-  unsigned int stats_dump_period_sec;
-
-  // This is used to close a block before it reaches the configured
-  // 'block_size'. If the percentage of free space in the current block is less
-  // than this specified number and adding a new record to the block will
-  // exceed the configured block size, then this block will be closed and the
-  // new record will be written to the next block.
-  // Default is 10.
-  int block_size_deviation;
-
-  // If set true, will hint the underlying file system that the file
-  // access pattern is random, when a sst file is opened.
-  // Default: true
-  bool advise_random_on_open;
-
-  // Specify the file access pattern once a compaction is started.
-  // It will be applied to all input files of a compaction.
-  // Default: NORMAL
-  enum { NONE, NORMAL, SEQUENTIAL, WILLNEED } access_hint_on_compaction_start;
-
-  // Use adaptive mutex, which spins in the user space before resorting
-  // to kernel. This could reduce context switch when the mutex is not
-  // heavily contended. However, if the mutex is hot, we could end up
-  // wasting spin time.
-  // Default: false
-  bool use_adaptive_mutex;
-
-  // Allows OS to incrementally sync files to disk while they are being
-  // written, asynchronously, in the background.
-  // Issue one request for every bytes_per_sync written. 0 turns it off.
-  // Default: 0
-  uint64_t bytes_per_sync;
-
-  // The compaction style. Default: kCompactionStyleLevel
-  CompactionStyle compaction_style;
-
-  // The options needed to support Universal Style compactions
-  CompactionOptionsUniversal compaction_options_universal;
-
-  // Use KeyMayExist API to filter deletes when this is true.
-  // If KeyMayExist returns false, i.e. the key definitely does not exist, then
-  // the delete is a noop. KeyMayExist only incurs in-memory look up.
-  // This optimization avoids writing the delete to storage when appropriate.
-  // Default: false
-  bool filter_deletes;
-
-  // This is a factory that provides MemTableRep objects.
-  // Default: a factory that provides a skip-list-based implementation of
-  // MemTableRep.
-  std::shared_ptr<MemTableRepFactory> memtable_factory;
-
-  // This is a factory that provides compaction filter objects which allow
-  // an application to modify/delete a key-value during background compaction.
-  // Default: a factory that doesn't provide any object
-  std::shared_ptr<CompactionFilterFactory> compaction_filter_factory;
 };

 // Options that control read operations
@@ -563,28 +417,14 @@ struct ReadOptions {
  // Default: nullptr
  const Snapshot* snapshot;

-  // If "prefix" is non-nullptr, and ReadOptions is being passed to
-  // db.NewIterator, only return results when the key begins with this
-  // prefix.  This field is ignored by other calls (e.g., Get).
-  // Options.prefix_extractor must also be set, and
-  // prefix_extractor.InRange(prefix) must be true.  The iterator
-  // returned by NewIterator when this option is set will behave just
-  // as if the underlying store did not contain any non-matching keys,
-  // with two exceptions.  Seek() only accepts keys starting with the
-  // prefix, and SeekToLast() is not supported.  prefix filter with this
-  // option will sometimes reduce the number of read IOPs.
-  // Default: nullptr
-  const Slice* prefix;
-
  ReadOptions()
      : verify_checksums(false),
        fill_cache(true),
-        snapshot(nullptr),
-        prefix(nullptr) {
+        snapshot(nullptr) {
  }
  ReadOptions(bool cksum, bool cache) :
              verify_checksums(cksum), fill_cache(cache),
-              snapshot(nullptr), prefix(nullptr) {
+              snapshot(nullptr) {
  }
 };

@@ -1,24 +0,0 @@
-#ifndef STORAGE_LEVELDB_INCLUDE_PERF_CONTEXT_H
-#define STORAGE_LEVELDB_INCLUDE_PERF_CONTEXT_H
-
-#include <stdint.h>
-
-namespace leveldb {
-
-// A thread local context for gathering performance counter efficiently
-// and transparently.
-
-struct PerfContext {
-
-  void Reset(); // reset all performance counters to zero
-
-
-  uint64_t user_key_comparison_count; // total number of user key comparisons
-};
-
-extern __thread PerfContext perf_context;
-
-}
-
-
-#endif
@@ -1,41 +0,0 @@
-// Copyright (c) 2012 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// Class for specifying user-defined functions which perform a
-// transformation on a slice.  It is not required that every slice
-// belong to the domain and/or range of a function.  Subclasses should
-// define InDomain and InRange to determine which slices are in either
-// of these sets respectively.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_SLICE_TRANSFORM_H_
-#define STORAGE_LEVELDB_INCLUDE_SLICE_TRANSFORM_H_
-
-#include <string>
-
-namespace leveldb {
-
-class Slice;
-
-class SliceTransform {
- public:
-  virtual ~SliceTransform() {};
-
-  // Return the name of this transformation.
-  virtual const char* Name() const = 0;
-
-  // transform a src in domain to a dst in the range
-  virtual Slice Transform(const Slice& src) const = 0;
-
-  // determine whether this is a valid src upon the function applies
-  virtual bool InDomain(const Slice& src) const = 0;
-
-  // determine whether dst=Transform(src) for some src
-  virtual bool InRange(const Slice& dst) const = 0;
-};
-
-extern const SliceTransform* NewFixedPrefixTransform(size_t prefix_len);
-
-}
-
-#endif  // STORAGE_LEVELDB_INCLUDE_SLICE_TRANSFORM_H_
@@ -5,13 +5,10 @@
 #ifndef STORAGE_LEVELDB_INCLUDE_STATISTICS_H_
 #define STORAGE_LEVELDB_INCLUDE_STATISTICS_H_

-#include <atomic>
-#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <string>
 #include <memory>
-#include <vector>

 namespace leveldb {

@@ -19,7 +16,6 @@ namespace leveldb {
 * Keep adding ticker's here.
 * Any ticker should have a value less than TICKER_ENUM_MAX.
 * Add a new ticker by assigning it the current value of TICKER_ENUM_MAX
- * Add a string representation in TickersNameMap below.
 * And incrementing TICKER_ENUM_MAX.
 */
 enum Tickers {
@@ -43,105 +39,21 @@ enum Tickers {
  NO_FILE_CLOSES = 10,
  NO_FILE_OPENS = 11,
  NO_FILE_ERRORS = 12,
-  // Time system had to wait to do LO-L1 compactions
-  STALL_L0_SLOWDOWN_MICROS = 13,
-  // Time system had to wait to move memtable to L1.
-  STALL_MEMTABLE_COMPACTION_MICROS = 14,
-  // write throttle because of too many files in L0
-  STALL_L0_NUM_FILES_MICROS = 15,
-  RATE_LIMIT_DELAY_MILLIS = 16,
-
-  NO_ITERATORS = 17, // number of iterators currently open
-
-  // Number of MultiGet calls, keys read, and bytes read
-  NUMBER_MULTIGET_CALLS = 18,
-  NUMBER_MULTIGET_KEYS_READ = 19,
-  NUMBER_MULTIGET_BYTES_READ = 20,
-
-  NUMBER_FILTERED_DELETES = 21,
-  NUMBER_MERGE_FAILURES = 22,
-  SEQUENCE_NUMBER = 23,
-
-  TICKER_ENUM_MAX = 24
+  TICKER_ENUM_MAX = 13,
 };

-const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
-  { BLOCK_CACHE_MISS, "rocksdb.block.cache.miss" },
-  { BLOCK_CACHE_HIT, "rocksdb.block.cache.hit" },
-  { BLOOM_FILTER_USEFUL, "rocksdb.bloom.filter.useful" },
-  { COMPACTION_KEY_DROP_NEWER_ENTRY, "rocksdb.compaction.key.drop.new" },
-  { COMPACTION_KEY_DROP_OBSOLETE, "rocksdb.compaction.key.drop.obsolete" },
-  { COMPACTION_KEY_DROP_USER, "rocksdb.compaction.key.drop.user" },
-  { NUMBER_KEYS_WRITTEN, "rocksdb.number.keys.written" },
-  { NUMBER_KEYS_READ, "rocksdb.number.keys.read" },
-  { BYTES_WRITTEN, "rocksdb.bytes.written" },
-  { BYTES_READ, "rocksdb.bytes.read" },
-  { NO_FILE_CLOSES, "rocksdb.no.file.closes" },
-  { NO_FILE_OPENS, "rocksdb.no.file.opens" },
-  { NO_FILE_ERRORS, "rocksdb.no.file.errors" },
-  { STALL_L0_SLOWDOWN_MICROS, "rocksdb.l0.slowdown.micros" },
-  { STALL_MEMTABLE_COMPACTION_MICROS, "rocksdb.memtable.compaction.micros" },
-  { STALL_L0_NUM_FILES_MICROS, "rocksdb.l0.num.files.stall.micros" },
-  { RATE_LIMIT_DELAY_MILLIS, "rocksdb.rate.limit.delay.millis" },
-  { NO_ITERATORS, "rocksdb.num.iterators" },
-  { NUMBER_MULTIGET_CALLS, "rocksdb.number.multiget.get" },
-  { NUMBER_MULTIGET_KEYS_READ, "rocksdb.number.multiget.keys.read" },
-  { NUMBER_MULTIGET_BYTES_READ, "rocksdb.number.multiget.bytes.read" },
-  { NUMBER_FILTERED_DELETES, "rocksdb.number.deletes.filtered" },
-  { NUMBER_MERGE_FAILURES, "rocksdb.number.merge.failures" },
-  { SEQUENCE_NUMBER, "rocksdb.sequence.number" }
-};

 /**
 * Keep adding histogram's here.
 * Any histogram whould have value less than HISTOGRAM_ENUM_MAX
 * Add a new Histogram by assigning it the current value of HISTOGRAM_ENUM_MAX
- * Add a string representation in HistogramsNameMap below
 * And increment HISTOGRAM_ENUM_MAX
 */
 enum Histograms {
  DB_GET = 0,
  DB_WRITE = 1,
  COMPACTION_TIME = 2,
-  TABLE_SYNC_MICROS = 3,
-  COMPACTION_OUTFILE_SYNC_MICROS = 4,
-  WAL_FILE_SYNC_MICROS = 5,
-  MANIFEST_FILE_SYNC_MICROS = 6,
-  // TIME SPENT IN IO DURING TABLE OPEN
-  TABLE_OPEN_IO_MICROS = 7,
-  DB_MULTIGET = 8,
-  READ_BLOCK_COMPACTION_MICROS = 9,
-  READ_BLOCK_GET_MICROS = 10,
-  WRITE_RAW_BLOCK_MICROS = 11,
-
-  STALL_L0_SLOWDOWN_COUNT = 12,
-  STALL_MEMTABLE_COMPACTION_COUNT = 13,
-  STALL_L0_NUM_FILES_COUNT = 14,
-  HARD_RATE_LIMIT_DELAY_COUNT = 15,
-  SOFT_RATE_LIMIT_DELAY_COUNT = 16,
-  NUM_FILES_IN_SINGLE_COMPACTION = 17,
-  HISTOGRAM_ENUM_MAX = 18
-};
-
-const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
-  { DB_GET, "rocksdb.db.get.micros" },
-  { DB_WRITE, "rocksdb.db.write.micros" },
-  { COMPACTION_TIME, "rocksdb.compaction.times.micros" },
-  { TABLE_SYNC_MICROS, "rocksdb.table.sync.micros" },
-  { COMPACTION_OUTFILE_SYNC_MICROS, "rocksdb.compaction.outfile.sync.micros" },
-  { WAL_FILE_SYNC_MICROS, "rocksdb.wal.file.sync.micros" },
-  { MANIFEST_FILE_SYNC_MICROS, "rocksdb.manifest.file.sync.micros" },
-  { TABLE_OPEN_IO_MICROS, "rocksdb.table.open.io.micros" },
-  { DB_MULTIGET, "rocksdb.db.multiget.micros" },
-  { READ_BLOCK_COMPACTION_MICROS, "rocksdb.read.block.compaction.micros" },
-  { READ_BLOCK_GET_MICROS, "rocksdb.read.block.get.micros" },
-  { WRITE_RAW_BLOCK_MICROS, "rocksdb.write.raw.block.micros" },
-  { STALL_L0_SLOWDOWN_COUNT, "rocksdb.l0.slowdown.count"},
-  { STALL_MEMTABLE_COMPACTION_COUNT, "rocksdb.memtable.compaction.count"},
-  { STALL_L0_NUM_FILES_COUNT, "rocksdb.num.files.stall.count"},
-  { HARD_RATE_LIMIT_DELAY_COUNT, "rocksdb.hard.rate.limit.delay.count"},
-  { SOFT_RATE_LIMIT_DELAY_COUNT, "rocksdb.soft.rate.limit.delay.count"},
-  { NUM_FILES_IN_SINGLE_COMPACTION, "rocksdb.numfiles.in.singlecompaction" }
+  HISTOGRAM_ENUM_MAX = 3,
 };

 struct HistogramData {
@@ -160,6 +72,7 @@ class Histogram {
  virtual ~Histogram();
  // Add a value to be recorded in the histogram.
  virtual void Add(uint64_t value) = 0;
+  virtual void Add(double value) = 0;

  virtual std::string ToString() const = 0;

@@ -180,11 +93,11 @@ class Ticker {
 public:
  Ticker() : count_(0) { }

-  inline void setTickerCount(uint64_t count) {
-    count_ = count;
+  inline void recordTick() {
+    count_++;
  }

-  inline void recordTick(int count = 1) {
+  inline void recordTick(int count) {
    count_ += count;
  }

@@ -193,7 +106,8 @@ class Ticker {
  }

 private:
-  std::atomic_uint_fast64_t count_;
+  uint64_t count_;
+
 };

 // Analyze the performance of a db
@@ -202,38 +116,21 @@ class Statistics {

  virtual long getTickerCount(Tickers tickerType) = 0;
  virtual void recordTick(Tickers tickerType, uint64_t count = 0) = 0;
-  virtual void setTickerCount(Tickers tickerType, uint64_t count) = 0;
-  virtual void measureTime(Histograms histogramType, uint64_t time) = 0;
+  virtual void measureTime(Histograms histogramType, uint64_t count) = 0;
+  virtual void measureTime(Histograms histogramType, double count) = 0;

  virtual void histogramData(Histograms type, HistogramData * const data) = 0;
-  // String representation of the statistic object.
-  std::string ToString();
+
 };

-// Create a concrete DBStatistics object
-std::shared_ptr<Statistics> CreateDBStatistics();
-
 // Ease of Use functions
-inline void RecordTick(std::shared_ptr<Statistics> statistics,
+inline void RecordTick(Statistics* const statistics,
                       Tickers ticker,
                       uint64_t count = 1) {
-  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
-  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
-  if (statistics) {
+  if (statistics != nullptr) {
    statistics->recordTick(ticker, count);
  }
 }
-
-inline void SetTickerCount(std::shared_ptr<Statistics> statistics,
-                           Tickers ticker,
-                           uint64_t count) {
-  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
-  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
-  if (statistics) {
-    statistics->setTickerCount(ticker, count);
-  }
-}
-
 }  // namespace leveldb

 #endif  // STORAGE_LEVELDB_INCLUDE_STATISTICS_H_
@@ -47,9 +47,6 @@ class Status {
  static Status IOError(const Slice& msg, const Slice& msg2 = Slice()) {
    return Status(kIOError, msg, msg2);
  }
-  static Status MergeInProgress(const Slice& msg, const Slice& msg2 = Slice()) {
-    return Status(kMergeInProgress, msg, msg2);
-  }

  // Returns true iff the status indicates success.
  bool ok() const { return (state_ == nullptr); }
@@ -69,9 +66,6 @@ class Status {
  // Returns true iff the status indicates an IOError.
  bool IsIOError() const { return code() == kIOError; }

-  // Returns true iff the status indicates an MergeInProgress.
-  bool IsMergeInProgress() const { return code() == kMergeInProgress; }
-
  // Return a string representation of this status suitable for printing.
  // Returns the string "OK" for success.
  std::string ToString() const;
@@ -90,8 +84,7 @@ class Status {
    kCorruption = 2,
    kNotSupported = 3,
    kInvalidArgument = 4,
-    kIOError = 5,
-    kMergeInProgress = 6
+    kIOError = 5
  };

  Code code() const {
@@ -8,7 +8,6 @@
 #include <memory>
 #include <stdint.h>
 #include "leveldb/iterator.h"
-#include "leveldb/env.h"

 namespace leveldb {

@@ -40,15 +39,12 @@ class Table {
  //
  // *file must remain live while this Table is in use.
  static Status Open(const Options& options,
-                     const EnvOptions& soptions,
                     unique_ptr<RandomAccessFile>&& file,
                     uint64_t file_size,
                     unique_ptr<Table>* table);

  ~Table();

-  bool PrefixMayMatch(const Slice& prefix) const;
-
  // Returns a new iterator over the table contents.
  // The result of NewIterator() is initially invalid (caller must
  // call one of the Seek methods on the iterator before using it).
@@ -66,32 +62,23 @@ class Table {
  // REQUIRES: key is in this table.
  bool TEST_KeyInCache(const ReadOptions& options, const Slice& key);

-  // Set up the table for Compaction. Might change some parameters with
-  // posix_fadvise
-  void SetupForCompaction();
-
 private:
  struct Rep;
  Rep* rep_;
-  bool compaction_optimized_;
-  explicit Table(Rep* rep) : compaction_optimized_(false) { rep_ = rep; }
-  static Iterator* BlockReader(void*, const ReadOptions&,
-                               const EnvOptions& soptions, const Slice&,
-                               bool for_compaction);
-  static Iterator* BlockReader(void*, const ReadOptions&, const Slice&,
-                               bool* didIO, bool for_compaction = false,
-                               const bool no_io = false);

-  // Calls (*handle_result)(arg, ...) repeatedly, starting with the entry found
-  // after a call to Seek(key), until handle_result returns false.
-  // May not make such a call if filter policy says that key is not present.
+  explicit Table(Rep* rep) { rep_ = rep; }
+  static Iterator* BlockReader(void*, const ReadOptions&, const Slice&);
+  static Iterator* BlockReader(void*, const ReadOptions&, const Slice&,
+                               bool* didIO);
+
+  // Calls (*handle_result)(arg, ...) with the entry found after a call
+  // to Seek(key).  May not make such a call if filter policy says
+  // that key is not present.
  friend class TableCache;
  Status InternalGet(
      const ReadOptions&, const Slice& key,
      void* arg,
-      bool (*handle_result)(void* arg, const Slice& k, const Slice& v, bool),
-      void (*mark_key_may_exist)(void*) = nullptr,
-      const bool no_io = false);
+      void (*handle_result)(void* arg, const Slice& k, const Slice& v, bool));


  void ReadMeta(const Footer& footer);
@@ -3,46 +3,10 @@
 #define STORAGE_LEVELDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_

 #include "leveldb/status.h"
-#include "leveldb/types.h"
 #include "leveldb/write_batch.h"

 namespace leveldb {

-class LogFile;
-typedef std::vector<std::unique_ptr<LogFile>> VectorLogPtr;
-
-enum  WalFileType {
-  /* Indicates that WAL file is in archive directory. WAL files are moved from
-   * the main db directory to archive directory once they are not live and stay
-   * there for a duration of WAL_ttl_seconds which can be set in Options
-   */
-  kArchivedLogFile = 0,
-
-  /* Indicates that WAL file is live and resides in the main db directory */
-  kAliveLogFile = 1
-} ;
-
-class LogFile {
- public:
-  LogFile() {}
-  virtual ~LogFile() {}
-
-  // Returns log file's name excluding the db path
-  virtual std::string Filename() const = 0;
-
-  // Primary identifier for log file.
-  // This is directly proportional to creation time of the log file
-  virtual uint64_t LogNumber() const = 0;
-
-  // Log file can be either alive or archived
-  virtual WalFileType Type() const = 0;
-
-  // Starting sequence number of writebatch written in this log file
-  virtual SequenceNumber StartSequence() const = 0;
-
-  // Size of log file on disk in Bytes
-  virtual uint64_t SizeFileBytes() const = 0;
-};

 struct BatchResult {
  SequenceNumber sequence;
@@ -7,7 +7,7 @@ namespace leveldb {

 // Define all public custom types here.

-// Represents a sequence number in a WAL file.
+//  Represents a sequence number in a WAL file.
 typedef uint64_t SequenceNumber;

 }  //  namespace leveldb
@@ -1,57 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_ROCKSDB_UNIVERSAL_COMPACTION_OPTIONS_H
-#define STORAGE_ROCKSDB_UNIVERSAL_COMPACTION_OPTIONS_H
-
-#include <stddef.h>
-#include <string>
-#include <memory>
-#include <vector>
-#include <stdint.h>
-#include <climits>
-#include "leveldb/slice.h"
-#include "leveldb/statistics.h"
-
-namespace leveldb {
-
-//
-// Algorithm used to make a compaction request stop picking new files
-// into a single compaction run
-//
-enum CompactionStopStyle {
-  kCompactionStopStyleSimilarSize, // pick files of similar size
-  kCompactionStopStyleTotalSize    // total size of picked files > next file
-};
-
-class CompactionOptionsUniversal {
- public:
-
-  // Percentage flexibilty while comparing file size. If the candidate file(s)
-  // size is 1% smaller than the next file's size, then include next file into
-  // this candidate set. // Default: 1
-  unsigned int size_ratio;
-
-  // The minimum number of files in a single compaction run. Default: 2
-  unsigned int min_merge_width;
-
-  // The maximum number of files in a single compaction run. Default: INT_MAX
-  unsigned int max_merge_width;
-
-  // The algorithm used to stop picking files into a single compaction run
-  // Default: kCompactionStopStyleTotalSize
-  CompactionStopStyle stop_style;
-
-  // Default set of parameters
-  CompactionOptionsUniversal() :
-    size_ratio(1),
-    min_merge_width(2),
-    max_merge_width(UINT_MAX),
-    stop_style(kCompactionStopStyleTotalSize) {
-  }
-};
-
-}  // namespace leveldb
-
-#endif  // STORAGE_ROCKSDB_UNIVERSAL_COMPACTION_OPTIONS_H
@@ -36,24 +36,9 @@ class WriteBatch {
  // Store the mapping "key->value" in the database.
  void Put(const Slice& key, const Slice& value);

-  // Merge "value" with the existing value of "key" in the database.
-  // "key->merge(existing, value)"
-  void Merge(const Slice& key, const Slice& value);
-
  // If the database contains a mapping for "key", erase it.  Else do nothing.
  void Delete(const Slice& key);

-  // Append a blob of arbitrary to the records in this batch. The blob will be
-  // stored in the transaction log but not in any other file. In particular, it
-  // will not be persisted to the SST files. When iterating over this
-  // WriteBatch, WriteBatch::Handler::LogData will be called with the contents
-  // of the blob as it is encountered. Blobs, puts, deletes, and merges will be
-  // encountered in the same order in thich they were inserted.
-  //
-  // Example application: add timestamps to the transaction log for use in
-  // replication.
-  void PutLogData(const Slice& blob);
-
  // Clear all updates buffered in this batch.
  void Clear();

@@ -62,24 +47,15 @@ class WriteBatch {
   public:
    virtual ~Handler();
    virtual void Put(const Slice& key, const Slice& value) = 0;
-    // Merge and LogData are not pure virtual. Otherwise, we would break
-    // existing clients of Handler on a source code level. The default
-    // implementation of Merge simply throws a runtime exception.
-    virtual void Merge(const Slice& key, const Slice& value);
-    // The default implementation of LogData does nothing.
-    virtual void LogData(const Slice& blob);
    virtual void Delete(const Slice& key) = 0;
  };
  Status Iterate(Handler* handler) const;

-  // Retrieve the serialized version of this batch.
+  // Retrive the serialized version of this batch.
  std::string Data() { return rep_; }

-  // Returns the number of updates in the batch
-  int Count() const;
-
  // Constructor with a serialized string object
-  explicit WriteBatch(std::string rep): rep_(rep) {}
+  WriteBatch(std::string rep): rep_(rep) {}

 private:
  friend class WriteBatchInternal;
@@ -1,163 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef LEVELDB_INCLUDE_UTILITIES_STACKABLE_DB_H_
-#define LEVELDB_INCLUDE_UTILITIES_STACKABLE_DB_H_
-
-#include "leveldb/db.h"
-
-namespace leveldb {
-
-// This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
-class StackableDB : public DB {
- public:
-  explicit StackableDB(StackableDB* sdb) : sdb_(sdb) {}
-
-  // Returns the DB object that is the lowermost component in the stack of DBs
-  virtual DB* GetRawDB() {
-    return sdb_->GetRawDB();
-  }
-
-  // convert a DB to StackableDB
-  static StackableDB* DBToStackableDB(DB* db) {
-    class NewStackableDB : public StackableDB {
-     public:
-      NewStackableDB(DB* db)
-        : StackableDB(nullptr),
-          db_(db) {}
-
-      DB* GetRawDB() {
-        return db_;
-      }
-
-     private:
-      DB* db_;
-    };
-    return new NewStackableDB(db);
-  }
-
-  virtual Status Put(const WriteOptions& options,
-                     const Slice& key,
-                     const Slice& val) override {
-    return sdb_->Put(options, key, val);
-  }
-
-  virtual Status Get(const ReadOptions& options,
-                     const Slice& key,
-                     std::string* value) override {
-    return sdb_->Get(options, key, value);
-  }
-
-  virtual std::vector<Status> MultiGet(const ReadOptions& options,
-                                       const std::vector<Slice>& keys,
-                                       std::vector<std::string>* values)
-    override {
-      return sdb_->MultiGet(options, keys, values);
-  }
-
-  virtual bool KeyMayExist(const ReadOptions& options,
-                           const Slice& key,
-                           std::string* value,
-                           bool* value_found = nullptr) override {
-    return sdb_->KeyMayExist(options, key, value, value_found);
-  }
-
-  virtual Status Delete(const WriteOptions& wopts, const Slice& key) override {
-    return sdb_->Delete(wopts, key);
-  }
-
-  virtual Status Merge(const WriteOptions& options,
-                       const Slice& key,
-                       const Slice& value) override {
-    return sdb_->Merge(options, key, value);
-  }
-
-
-  virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
-    override {
-      return sdb_->Write(opts, updates);
-  }
-
-  virtual Iterator* NewIterator(const ReadOptions& opts) override {
-    return sdb_->NewIterator(opts);
-  }
-
-  virtual const Snapshot* GetSnapshot() override {
-    return sdb_->GetSnapshot();
-  }
-
-  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
-    return sdb_->ReleaseSnapshot(snapshot);
-  }
-
-  virtual bool GetProperty(const Slice& property, std::string* value)
-    override {
-      return sdb_->GetProperty(property, value);
-  }
-
-  virtual void GetApproximateSizes(const Range* r, int n, uint64_t* sizes)
-    override {
-      return sdb_->GetApproximateSizes(r, n, sizes);
-  }
-
-  virtual void CompactRange(const Slice* begin, const Slice* end,
-                            bool reduce_level = false) override {
-    return sdb_->CompactRange(begin, end, reduce_level);
-  }
-
-  virtual int NumberLevels() override {
-    return sdb_->NumberLevels();
-  }
-
-  virtual int MaxMemCompactionLevel() override {
-    return sdb_->MaxMemCompactionLevel();
-  }
-
-  virtual int Level0StopWriteTrigger() override {
-    return sdb_->Level0StopWriteTrigger();
-  }
-
-  virtual Status Flush(const FlushOptions& fopts) override {
-    return sdb_->Flush(fopts);
-  }
-
-  virtual Status DisableFileDeletions() override {
-    return sdb_->DisableFileDeletions();
-  }
-
-  virtual Status EnableFileDeletions() override {
-    return sdb_->EnableFileDeletions();
-  }
-
-  virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs)
-    override {
-      return sdb_->GetLiveFiles(vec, mfs);
-  }
-
-  virtual SequenceNumber GetLatestSequenceNumber() override {
-    return sdb_->GetLatestSequenceNumber();
-  }
-
-  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
-    return sdb_->GetSortedWalFiles(files);
-  }
-
-  virtual Status DeleteWalFiles(const VectorLogPtr& files)
-    override{
-      return sdb_->DeleteWalFiles(files);
-  }
-
-  virtual Status GetUpdatesSince(SequenceNumber seq_number,
-                                 unique_ptr<TransactionLogIterator>* iter)
-    override {
-      return sdb_->GetUpdatesSince(seq_number, iter);
-  }
-
- protected:
-  StackableDB* sdb_;
-};
-
-} //  namespace leveldb
-
-#endif  //  LEVELDB_INCLUDE_UTILITIES_STACKABLE_DB_H_
@@ -1,54 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef LEVELDB_INCLUDE_UTILITIES_UTILITY_DB_H_
-#define LEVELDB_INCLUDE_UTILITIES_UTILITY_DB_H_
-
-#include "stackable_db.h"
-
-namespace leveldb {
-
-// This class contains APIs to open leveldb with specific support eg. TTL
-class UtilityDB {
-
-  public:
-    // Open the database with TTL support.
-    //
-    // USE-CASES:
-    // This API should be used to open the db when key-values inserted are
-    //  meant to be removed from the db in a non-strict 'ttl' amount of time
-    //  Therefore, this guarantees that key-values inserted will remain in the
-    //  db for >= ttl amount of time and the db will make efforts to remove the
-    //  key-values as soon as possible after ttl seconds of their insertion.
-    //
-    // BEHAVIOUR:
-    // TTL is accepted in seconds
-    // (int32_t)Timestamp(creation) is suffixed to values in Put internally
-    // Expired TTL values deleted in compaction only:(Timestamp+ttl<time_now)
-    // Get/Iterator may return expired entries(compaction not run on them yet)
-    // Different TTL may be used during different Opens
-    // Example: Open1 at t=0 with ttl=4 and insert k1,k2, close at t=2
-    //          Open2 at t=3 with ttl=5. Now k1,k2 should be deleted at t>=5
-    // read_only=true opens in the usual read-only mode. Compactions will not be
-    //  triggered(neither manual nor automatic), so no expired entries removed
-    //
-    // CONSTRAINTS:
-    // Not specifying/passing or non-positive TTL behaves like TTL = infinity
-    //
-    // !!!WARNING!!!:
-    // Calling DB::Open directly to re-open a db created by this API will get
-    //  corrupt values(timestamp suffixed) and no ttl effect will be there
-    //  during the second Open, so use this API consistently to open the db
-    // Be careful when passing ttl with a small positive value because the
-    //  whole database may be deleted in a small amount of time
-    static Status OpenTtlDB(const Options& options,
-                            const std::string& name,
-                            StackableDB** dbptr,
-                            int32_t ttl = 0,
-                            bool read_only = false);
-};
-
-} //  namespace leveldb
-
-#endif  //  LEVELDB_INCLUDE_UTILITIES_UTILITY_DB_H_
@@ -19,24 +19,7 @@ static void PthreadCall(const char* label, int result) {
  }
 }

-Mutex::Mutex(bool adaptive) {
-#ifdef OS_LINUX
-  if (!adaptive) {
-    PthreadCall("init mutex", pthread_mutex_init(&mu_, NULL));
-  } else {
-    pthread_mutexattr_t mutex_attr;
-    PthreadCall("init mutex attr", pthread_mutexattr_init(&mutex_attr));
-    PthreadCall("set mutex attr",
-                pthread_mutexattr_settype(&mutex_attr,
-                                          PTHREAD_MUTEX_ADAPTIVE_NP));
-    PthreadCall("init mutex", pthread_mutex_init(&mu_, &mutex_attr));
-    PthreadCall("destroy mutex attr",
-                pthread_mutexattr_destroy(&mutex_attr));
-  }
-#else // ignore adaptive for non-linux platform
-  PthreadCall("init mutex", pthread_mutex_init(&mu_, NULL));
-#endif // OS_LINUX
-}
+Mutex::Mutex() { PthreadCall("init mutex", pthread_mutex_init(&mu_, NULL)); }

 Mutex::~Mutex() { PthreadCall("destroy mutex", pthread_mutex_destroy(&mu_)); }

@@ -82,7 +82,7 @@ class CondVar;

 class Mutex {
 public:
-  /* implicit */ Mutex(bool adaptive = false);
+  Mutex();
  ~Mutex();

  void Lock();
@@ -192,20 +192,17 @@ inline bool Zlib_Compress(const CompressionOptions& opts, const char* input,
  _stream.avail_out = length;
  _stream.next_out = (Bytef *)&(*output)[0];

-  int old_sz =0, new_sz =0, new_sz_delta =0;
-  bool done = false;
-  while (!done) {
+  int old_sz =0, new_sz =0;
+  while(_stream.next_in != NULL && _stream.avail_in != 0) {
    int st = deflate(&_stream, Z_FINISH);
    switch (st) {
      case Z_STREAM_END:
-        done = true;
        break;
      case Z_OK:
        // No output space. Increase the output space by 20%.
        // (Should we fail the compression since it expands the size?)
        old_sz = output->size();
-        new_sz_delta = (int)(output->size() * 0.2);
-        new_sz = output->size() + (new_sz_delta < 10 ? 10 : new_sz_delta);
+        new_sz = (int)(output->size() * 1.2);
        output->resize(new_sz);
        // Set more output.
        _stream.next_out = (Bytef *)&(*output)[old_sz];
@@ -231,13 +228,13 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
  z_stream _stream;
  memset(&_stream, 0, sizeof(z_stream));

-  // For raw inflate, the windowBits should be -8..-15.
+  // For raw inflate, the windowBits should be Ð8..Ð15.
  // If windowBits is bigger than zero, it will use either zlib
  // header or gzip header. Adding 32 to it will do automatic detection.
  int st = inflateInit2(&_stream,
      windowBits > 0 ? windowBits + 32 : windowBits);
  if (st != Z_OK) {
-    return nullptr;
+    return NULL;
  }

  _stream.next_in = (Bytef *)input_data;
@@ -251,22 +248,17 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
  _stream.next_out = (Bytef *)output;
  _stream.avail_out = output_len;

-  char* tmp = nullptr;
-  int output_len_delta;
-  bool done = false;
+  char* tmp = NULL;

-  //while(_stream.next_in != nullptr && _stream.avail_in != 0) {
-  while (!done) {
+  while(_stream.next_in != NULL && _stream.avail_in != 0) {
    int st = inflate(&_stream, Z_SYNC_FLUSH);
    switch (st) {
      case Z_STREAM_END:
-        done = true;
        break;
      case Z_OK:
        // No output space. Increase the output space by 20%.
        old_sz = output_len;
-        output_len_delta = (int)(output_len * 0.2);
-        output_len += output_len_delta < 10 ? 10 : output_len_delta;
+        output_len = (int)(output_len * 1.2);
        tmp = new char[output_len];
        memcpy(tmp, output, old_sz);
        delete[] output;
@@ -280,7 +272,7 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
      default:
        delete[] output;
        inflateEnd(&_stream);
-        return nullptr;
+        return NULL;
    }
  }

@@ -289,7 +281,7 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
  return output;
 #endif

-  return nullptr;
+  return NULL;
 }

 inline bool BZip2_Compress(const CompressionOptions& opts, const char* input,
@@ -319,7 +311,7 @@ inline bool BZip2_Compress(const CompressionOptions& opts, const char* input,
  _stream.avail_out = length;

  int old_sz =0, new_sz =0;
-  while(_stream.next_in != nullptr && _stream.avail_in != 0) {
+  while(_stream.next_in != NULL && _stream.avail_in != 0) {
    int st = BZ2_bzCompress(&_stream, BZ_FINISH);
    switch (st) {
      case BZ_STREAM_END:
@@ -357,7 +349,7 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,

  int st = BZ2_bzDecompressInit(&_stream, 0, 0);
  if (st != BZ_OK) {
-    return nullptr;
+    return NULL;
  }

  _stream.next_in = (char *)input_data;
@@ -371,9 +363,9 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,
  _stream.next_out = (char *)output;
  _stream.avail_out = output_len;

-  char* tmp = nullptr;
+  char* tmp = NULL;

-  while(_stream.next_in != nullptr && _stream.avail_in != 0) {
+  while(_stream.next_in != NULL && _stream.avail_in != 0) {
    int st = BZ2_bzDecompress(&_stream);
    switch (st) {
      case BZ_STREAM_END:
@@ -395,7 +387,7 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,
      default:
        delete[] output;
        BZ2_bzDecompressEnd(&_stream);
-        return nullptr;
+        return NULL;
    }
  }

@@ -403,7 +395,7 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,
  BZ2_bzDecompressEnd(&_stream);
  return output;
 #endif
-  return nullptr;
+  return NULL;
 }

 inline bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg) {
@@ -1,97 +0,0 @@
-#include "util/stack_trace.h"
-
-#ifdef OS_LINUX
-
-#include <execinfo.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-namespace leveldb {
-
-static const char* GetExecutableName()
-{
-  static char name[1024];
-
-  char link[1024];
-  snprintf(link, sizeof(link), "/proc/%d/exe", getpid());
-  auto read = readlink(link, name, sizeof(name));
-  if (-1 == read) {
-    return nullptr;
-  } else {
-    name[read] = 0;
-    return name;
-  }
-}
-
-static void StackTraceHandler(int sig) {
-  // reset to default handler
-  signal(sig, SIG_DFL);
-
-  fprintf(stderr, "Received signal %d (%s)\n", sig, strsignal(sig));
-
-  const int kMaxFrames = 100;
-  void *frames[kMaxFrames];
-
-  auto num_frames = backtrace(frames, kMaxFrames);
-  auto symbols = backtrace_symbols(frames, num_frames);
-
-  auto executable = GetExecutableName();
-
-  const int kSkip = 2; // skip the top two signal handler related frames
-
-  for (int i = kSkip; i < num_frames; ++i)
-  {
-    fprintf(stderr, "#%-2d %p ", i - kSkip, frames[i]);
-    if (symbols) {
-      fprintf(stderr, "%s ", symbols[i]);
-    }
-    if (executable) {
-      // out source to addr2line, for the address translation
-      const int kLineMax = 256;
-      char cmd[kLineMax];
-      sprintf(cmd,"addr2line %p -e %s 2>&1", frames[i] , executable);
-      auto f = popen(cmd, "r");
-      if (f) {
-        char line[kLineMax];
-        while (fgets(line, sizeof(line), f)) {
-          fprintf(stderr, "%s", line);
-        }
-        pclose(f);
-      } else {
-        fprintf(stderr, "\n");
-      }
-    } else {
-      fprintf(stderr, "\n");
-    }
-  }
-
-  // re-signal to default handler (so we still get core dump if needed...)
-  raise(sig);
-}
-
-void InstallStackTraceHandler() {
-  // just use the plain old signal as it's simple and sufficient
-  // for this use case
-  signal(SIGILL, StackTraceHandler);
-  signal(SIGSEGV, StackTraceHandler);
-  signal(SIGBUS, StackTraceHandler);
-  signal(SIGABRT, StackTraceHandler);
-
-  printf("Installed stack trace handler for SIGILL SIGSEGV SIGBUS SIGABRT\n");
-
-}
-
-}   // namespace leveldb
-
-#else // no-op for non-linux system for now
-
-namespace leveldb {
-
-void InstallStackTraceHandler() {}
-
-}
-
-#endif // OS_LINUX
@@ -14,8 +14,8 @@ fi
 # On the production build servers, set data and stat
 # files/directories not in /tmp or else the tempdir cleaning
 # scripts will make you very unhappy.
-DATA_DIR=${DATA_DIR:-$(mktemp -t -d rocksdb_XXXX)}
-STAT_FILE=${STAT_FILE:-$(mktemp -t -u rocksdb_test_stats_XXXX)}
+DATA_DIR=${DATA_DIR:-$(mktemp --tmpdir -d leveldb_XXXX)}
+STAT_FILE=${STAT_FILE:-$(mktemp --tmpdir -u leveldb_test_stats_XXXX)}

 function cleanup {
  rm -rf $DATA_DIR
@@ -34,8 +34,7 @@ function send_to_ods {
    echo >&2 "ERROR: Key $key doesn't have a value."
    return
  fi
-  curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=$key&value=$value" \
-    --connect-timeout 60
+  curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=$key&value=$value"
 }

 make clean
@@ -23,8 +23,7 @@ inline uint32_t Block::NumRestarts() const {
 Block::Block(const BlockContents& contents)
    : data_(contents.data.data()),
      size_(contents.data.size()),
-      owned_(contents.heap_allocated),
-      cachable_(contents.cachable) {
+      owned_(contents.heap_allocated) {
  if (size_ < sizeof(uint32_t)) {
    size_ = 0;  // Error marker
  } else {
@@ -22,7 +22,6 @@ class Block {
  ~Block();

  size_t size() const { return size_; }
-  bool   isCachable() const { return cachable_; }
  Iterator* NewIterator(const Comparator* comparator);

 private:
@@ -32,7 +31,6 @@ class Block {
  size_t size_;
  uint32_t restart_offset_;     // Offset in data_ of restart array
  bool owned_;                  // Block owns data_[]
-  bool cachable_;

  // No copying allowed
  Block(const Block&);
@@ -60,21 +60,6 @@ size_t BlockBuilder::CurrentSizeEstimate() const {
          sizeof(uint32_t));                      // Restart array length
 }

-size_t BlockBuilder::EstimateSizeAfterKV(const Slice& key, const Slice& value)
-  const {
-  size_t estimate = CurrentSizeEstimate();
-  estimate += key.size() + value.size();
-  if (counter_ >= options_->block_restart_interval) {
-    estimate += sizeof(uint32_t); // a new restart entry.
-  }
-
-  estimate += sizeof(int32_t); // varint for shared prefix length.
-  estimate += VarintLength(key.size()); // varint for key length.
-  estimate += VarintLength(value.size()); // varint for value length.
-
-  return estimate;
-}
-
 Slice BlockBuilder::Finish() {
  // Append restart array
  for (size_t i = 0; i < restarts_.size(); i++) {
@@ -34,9 +34,6 @@ class BlockBuilder {
  // we are building.
  size_t CurrentSizeEstimate() const;

-  // Returns an estimated block size after appending key and value.
-  size_t EstimateSizeAfterKV(const Slice& key, const Slice& value) const;
-
  // Return true iff no entries have been added since the last Reset()
  bool empty() const {
    return buffer_.empty();
@@ -1,6 +1,9 @@
 // Copyright (c) 2012 Facebook.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+#include "leveldb/table.h"
+
 #include <string>
 #include "db/dbformat.h"
 #include "db/memtable.h"
@@ -11,7 +14,6 @@
 #include "leveldb/table_builder.h"
 #include "table/block.h"
 #include "table/block_builder.h"
-#include "table/table.h"
 #include "table/format.h"
 #include "util/random.h"
 #include "util/testharness.h"
@@ -58,7 +60,7 @@ TEST(BlockTest, SimpleTest) {
  // read serialized contents of the block
  Slice rawblock = builder.Finish();

-  // create block reader
+  // create block reader 
  BlockContents contents;
  contents.data = rawblock;
  contents.cachable = false;
@@ -69,7 +71,7 @@ TEST(BlockTest, SimpleTest) {
  int count = 0;
  Iterator* iter = reader.NewIterator(options.comparator);
  for (iter->SeekToFirst();iter->Valid(); count++, iter->Next()) {
-
+    
    // read kv from block
    Slice k = iter->key();
    Slice v = iter->value();
@@ -79,8 +81,8 @@ TEST(BlockTest, SimpleTest) {
    ASSERT_EQ(v.ToString().compare(values[count]), 0);
  }
  delete iter;
-
-  // read block contents randomly
+  
+  // read block contents randomly 
  iter = reader.NewIterator(options.comparator);
  for (int i = 0; i < num_records; i++) {

@@ -4,7 +4,6 @@

 #include "table/filter_block.h"

-#include "db/dbformat.h"
 #include "leveldb/filter_policy.h"
 #include "util/coding.h"

@@ -16,11 +15,9 @@ namespace leveldb {
 static const size_t kFilterBaseLg = 11;
 static const size_t kFilterBase = 1 << kFilterBaseLg;

-FilterBlockBuilder::FilterBlockBuilder(const Options& opt)
-                 : policy_(opt.filter_policy),
-                   prefix_extractor_(opt.prefix_extractor),
-                   whole_key_filtering_(opt.whole_key_filtering),
-                   comparator_(opt.comparator){}
+FilterBlockBuilder::FilterBlockBuilder(const FilterPolicy* policy)
+    : policy_(policy) {
+}

 void FilterBlockBuilder::StartBlock(uint64_t block_offset) {
  uint64_t filter_index = (block_offset / kFilterBase);
@@ -30,47 +27,10 @@ void FilterBlockBuilder::StartBlock(uint64_t block_offset) {
  }
 }

-bool FilterBlockBuilder::SamePrefix(const Slice &key1,
-                                    const Slice &key2) const {
-  if (!prefix_extractor_->InDomain(key1) &&
-      !prefix_extractor_->InDomain(key2)) {
-    return true;
-  } else if (!prefix_extractor_->InDomain(key1) ||
-             !prefix_extractor_->InDomain(key2)) {
-    return false;
-  } else {
-    return (prefix_extractor_->Transform(key1) ==
-            prefix_extractor_->Transform(key2));
-  }
-}
-
 void FilterBlockBuilder::AddKey(const Slice& key) {
-  Slice prev;
-  if (start_.size() > 0) {
-    size_t prev_start = start_[start_.size() - 1];
-    const char* base = entries_.data() + prev_start;
-    size_t length = entries_.size() - prev_start;
-    prev = Slice(base, length);
-  }
-
-  if (whole_key_filtering_) {
-    start_.push_back(entries_.size());
-    entries_.append(key.data(), key.size());
-  }
-
-  if (prefix_extractor_ && prefix_extractor_->InDomain(key)) {
-    // this assumes prefix(prefix(key)) == prefix(key), as the last
-    // entry in entries_ may be either a key or prefix, and we use
-    // prefix(last entry) to get the prefix of the last key.
-    if (prev.size() == 0 || ! SamePrefix(key, prev)) {
-      Slice prefix = prefix_extractor_->Transform(key);
-      InternalKey internal_prefix_tmp(prefix, 0, kTypeValue);
-      Slice internal_prefix = internal_prefix_tmp.Encode();
-      assert(comparator_->Compare(internal_prefix, key) <= 0);
-      start_.push_back(entries_.size());
-      entries_.append(internal_prefix.data(), internal_prefix.size());
-    }
-  }
+  Slice k = key;
+  start_.push_back(keys_.size());
+  keys_.append(k.data(), k.size());
 }

 Slice FilterBlockBuilder::Finish() {
@@ -90,35 +50,34 @@ Slice FilterBlockBuilder::Finish() {
 }

 void FilterBlockBuilder::GenerateFilter() {
-  const size_t num_entries = start_.size();
-  if (num_entries == 0) {
+  const size_t num_keys = start_.size();
+  if (num_keys == 0) {
    // Fast path if there are no keys for this filter
    filter_offsets_.push_back(result_.size());
    return;
  }

  // Make list of keys from flattened key structure
-  start_.push_back(entries_.size());  // Simplify length computation
-  tmp_entries_.resize(num_entries);
-  for (size_t i = 0; i < num_entries; i++) {
-    const char* base = entries_.data() + start_[i];
+  start_.push_back(keys_.size());  // Simplify length computation
+  tmp_keys_.resize(num_keys);
+  for (size_t i = 0; i < num_keys; i++) {
+    const char* base = keys_.data() + start_[i];
    size_t length = start_[i+1] - start_[i];
-    tmp_entries_[i] = Slice(base, length);
+    tmp_keys_[i] = Slice(base, length);
  }

  // Generate filter for current set of keys and append to result_.
  filter_offsets_.push_back(result_.size());
-  policy_->CreateFilter(&tmp_entries_[0], num_entries, &result_);
+  policy_->CreateFilter(&tmp_keys_[0], num_keys, &result_);

-  tmp_entries_.clear();
-  entries_.clear();
+  tmp_keys_.clear();
+  keys_.clear();
  start_.clear();
 }

-FilterBlockReader::FilterBlockReader(const Options& opt, const Slice& contents)
-    : policy_(opt.filter_policy),
-      prefix_extractor_(opt.prefix_extractor),
-      whole_key_filtering_(opt.whole_key_filtering),
+FilterBlockReader::FilterBlockReader(const FilterPolicy* policy,
+                                     const Slice& contents)
+    : policy_(policy),
      data_(nullptr),
      offset_(nullptr),
      num_(0),
@@ -133,32 +92,16 @@ FilterBlockReader::FilterBlockReader(const Options& opt, const Slice& contents)
  num_ = (n - 5 - last_word) / 4;
 }

-bool FilterBlockReader::KeyMayMatch(uint64_t block_offset,
-                                    const Slice& key) {
-  if (!whole_key_filtering_) {
-    return true;
-  }
-  return MayMatch(block_offset, key);
-}
-
-bool FilterBlockReader::PrefixMayMatch(uint64_t block_offset,
-                                       const Slice& prefix) {
-  if (!prefix_extractor_) {
-    return true;
-  }
-  return MayMatch(block_offset, prefix);
-}
-
-bool FilterBlockReader::MayMatch(uint64_t block_offset, const Slice& entry) {
+bool FilterBlockReader::KeyMayMatch(uint64_t block_offset, const Slice& key) {
  uint64_t index = block_offset >> base_lg_;
  if (index < num_) {
    uint32_t start = DecodeFixed32(offset_ + index*4);
    uint32_t limit = DecodeFixed32(offset_ + index*4 + 4);
    if (start <= limit && limit <= (offset_ - data_)) {
      Slice filter = Slice(data_ + start, limit - start);
-      return policy_->KeyMayMatch(entry, filter);
+      return policy_->KeyMayMatch(key, filter);
    } else if (start == limit) {
-      // Empty filters do not match any entries
+      // Empty filters do not match any keys
      return false;
    }
  }
@@ -13,9 +13,7 @@
 #include <stdint.h>
 #include <string>
 #include <vector>
-#include "leveldb/options.h"
 #include "leveldb/slice.h"
-#include "leveldb/slice_transform.h"
 #include "util/hash.h"

 namespace leveldb {
@@ -30,25 +28,20 @@ class FilterPolicy;
 //      (StartBlock AddKey*)* Finish
 class FilterBlockBuilder {
 public:
-  explicit FilterBlockBuilder(const Options& opt);
+  explicit FilterBlockBuilder(const FilterPolicy*);

  void StartBlock(uint64_t block_offset);
  void AddKey(const Slice& key);
  Slice Finish();

 private:
-  bool SamePrefix(const Slice &key1, const Slice &key2) const;
  void GenerateFilter();

  const FilterPolicy* policy_;
-  const SliceTransform* prefix_extractor_;
-  bool whole_key_filtering_;
-  const Comparator* comparator_;
-
-  std::string entries_;         // Flattened entry contents
-  std::vector<size_t> start_;   // Starting index in entries_ of each entry
-  std::string result_;          // Filter data computed so far
-  std::vector<Slice> tmp_entries_; // policy_->CreateFilter() argument
+  std::string keys_;              // Flattened key contents
+  std::vector<size_t> start_;     // Starting index in keys_ of each key
+  std::string result_;            // Filter data computed so far
+  std::vector<Slice> tmp_keys_;   // policy_->CreateFilter() argument
  std::vector<uint32_t> filter_offsets_;

  // No copying allowed
@@ -59,20 +52,15 @@ class FilterBlockBuilder {
 class FilterBlockReader {
 public:
 // REQUIRES: "contents" and *policy must stay live while *this is live.
-  FilterBlockReader(const Options& opt, const Slice& contents);
+  FilterBlockReader(const FilterPolicy* policy, const Slice& contents);
  bool KeyMayMatch(uint64_t block_offset, const Slice& key);
-  bool PrefixMayMatch(uint64_t block_offset, const Slice& prefix);

 private:
  const FilterPolicy* policy_;
-  const SliceTransform* prefix_extractor_;
-  bool whole_key_filtering_;
  const char* data_;    // Pointer to filter data (at block-start)
  const char* offset_;  // Pointer to beginning of offset array (at block-end)
  size_t num_;          // Number of entries in offset array
  size_t base_lg_;      // Encoding parameter (see kFilterBaseLg in .cc file)
-
-  bool MayMatch(uint64_t block_offset, const Slice& entry);
 };

 }
@@ -41,25 +41,19 @@ class TestHashFilter : public FilterPolicy {
 class FilterBlockTest {
 public:
  TestHashFilter policy_;
-  Options options_;
-
-  FilterBlockTest() {
-    options_ = Options();
-    options_.filter_policy = &policy_;
-  }
 };

 TEST(FilterBlockTest, EmptyBuilder) {
-  FilterBlockBuilder builder(options_);
+  FilterBlockBuilder builder(&policy_);
  Slice block = builder.Finish();
  ASSERT_EQ("\\x00\\x00\\x00\\x00\\x0b", EscapeString(block));
-  FilterBlockReader reader(options_, block);
+  FilterBlockReader reader(&policy_, block);
  ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
  ASSERT_TRUE(reader.KeyMayMatch(100000, "foo"));
 }

 TEST(FilterBlockTest, SingleChunk) {
-  FilterBlockBuilder builder(options_);
+  FilterBlockBuilder builder(&policy_);
  builder.StartBlock(100);
  builder.AddKey("foo");
  builder.AddKey("bar");
@@ -69,7 +63,7 @@ TEST(FilterBlockTest, SingleChunk) {
  builder.StartBlock(300);
  builder.AddKey("hello");
  Slice block = builder.Finish();
-  FilterBlockReader reader(options_, block);
+  FilterBlockReader reader(&policy_, block);
  ASSERT_TRUE(reader.KeyMayMatch(100, "foo"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "bar"));
  ASSERT_TRUE(reader.KeyMayMatch(100, "box"));
@@ -80,7 +74,7 @@ TEST(FilterBlockTest, SingleChunk) {
 }

 TEST(FilterBlockTest, MultiChunk) {
-  FilterBlockBuilder builder(options_);
+  FilterBlockBuilder builder(&policy_);

  // First filter
  builder.StartBlock(0);
@@ -100,7 +94,7 @@ TEST(FilterBlockTest, MultiChunk) {
  builder.AddKey("hello");

  Slice block = builder.Finish();
-  FilterBlockReader reader(options_, block);
+  FilterBlockReader reader(&policy_, block);

  // Check first filter
  ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
@@ -66,10 +66,10 @@ Status Footer::DecodeFrom(Slice* input) {
  return result;
 }

-Status ReadBlockContents(RandomAccessFile* file,
-                         const ReadOptions& options,
-                         const BlockHandle& handle,
-                         BlockContents* result) {
+Status ReadBlock(RandomAccessFile* file,
+                 const ReadOptions& options,
+                 const BlockHandle& handle,
+                 BlockContents* result) {
  result->data = Slice();
  result->cachable = false;
  result->heap_allocated = false;
@@ -91,10 +91,10 @@ struct BlockContents {

 // Read the block identified by "handle" from "file".  On failure
 // return non-OK.  On success fill *result and return OK.
-extern Status ReadBlockContents(RandomAccessFile* file,
-                                const ReadOptions& options,
-                                const BlockHandle& handle,
-                                BlockContents* result);
+extern Status ReadBlock(RandomAccessFile* file,
+                        const ReadOptions& options,
+                        const BlockHandle& handle,
+                        BlockContents* result);

 // Implementation details follow.  Clients should ignore,

@@ -2,9 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

-#include "table/table.h"
-
-#include "db/dbformat.h"
+#include "leveldb/table.h"

 #include "leveldb/cache.h"
 #include "leveldb/comparator.h"
@@ -12,14 +10,11 @@
 #include "leveldb/filter_policy.h"
 #include "leveldb/options.h"
 #include "leveldb/statistics.h"
-
 #include "table/block.h"
 #include "table/filter_block.h"
 #include "table/format.h"
 #include "table/two_level_iterator.h"
-
 #include "util/coding.h"
-#include "util/stop_watch.h"

 namespace leveldb {

@@ -34,12 +29,8 @@ struct Table::Rep {
    delete [] filter_data;
    delete index_block;
  }
-  Rep(const EnvOptions& storage_options) :
-    soptions(storage_options) {
-  }

  Options options;
-  const EnvOptions& soptions;
  Status status;
  unique_ptr<RandomAccessFile> file;
  char cache_key_prefix[kMaxCacheKeyPrefixSize];
@@ -70,34 +61,7 @@ void Table::SetupCacheKeyPrefix(Rep* rep) {
  }
 }

-namespace {  // anonymous namespace, not visible externally
-
-// Read the block identified by "handle" from "file".
-// The only relevant option is options.verify_checksums for now.
-// Set *didIO to true if didIO is not null.
-// On failure return non-OK.
-// On success fill *result and return OK - caller owns *result
-Status ReadBlock(RandomAccessFile* file,
-                 const ReadOptions& options,
-                 const BlockHandle& handle,
-                 Block** result,
-                 bool* didIO = nullptr) {
-  BlockContents contents;
-  Status s = ReadBlockContents(file, options, handle, &contents);
-  if (s.ok()) {
-    *result = new Block(contents);
-  }
-
-  if (didIO) {
-    *didIO = true;
-  }
-  return s;
-}
-
-} // end of anonymous namespace
-
 Status Table::Open(const Options& options,
-                   const EnvOptions& soptions,
                   unique_ptr<RandomAccessFile>&& file,
                   uint64_t size,
                   unique_ptr<Table>* table) {
@@ -123,14 +87,20 @@ Status Table::Open(const Options& options,
  s = footer.DecodeFrom(&footer_input);
  if (!s.ok()) return s;

+  // Read the index block
+  BlockContents contents;
  Block* index_block = nullptr;
-  // TODO: we never really verify check sum for index block
-  s = ReadBlock(file.get(), ReadOptions(), footer.index_handle(), &index_block);
+  if (s.ok()) {
+    s = ReadBlock(file.get(), ReadOptions(), footer.index_handle(), &contents);
+    if (s.ok()) {
+      index_block = new Block(contents);
+    }
+  }

  if (s.ok()) {
    // We've successfully read the footer and the index block: we're
    // ready to serve requests.
-    Rep* rep = new Table::Rep(soptions);
+    Rep* rep = new Table::Rep;
    rep->options = options;
    rep->file = std::move(file);
    rep->metaindex_handle = footer.metaindex_handle();
@@ -147,25 +117,6 @@ Status Table::Open(const Options& options,
  return s;
 }

-void Table::SetupForCompaction() {
-  switch (rep_->options.access_hint_on_compaction_start) {
-    case Options::NONE:
-      break;
-    case Options::NORMAL:
-      rep_->file->Hint(RandomAccessFile::NORMAL);
-      break;
-    case Options::SEQUENTIAL:
-      rep_->file->Hint(RandomAccessFile::SEQUENTIAL);
-      break;
-    case Options::WILLNEED:
-      rep_->file->Hint(RandomAccessFile::WILLNEED);
-      break;
-    default:
-      assert(false);
-  }
-  compaction_optimized_ = true;
-}
-
 void Table::ReadMeta(const Footer& footer) {
  if (rep_->options.filter_policy == nullptr) {
    return;  // Do not need any metadata
@@ -173,13 +124,14 @@ void Table::ReadMeta(const Footer& footer) {

  // TODO(sanjay): Skip this if footer.metaindex_handle() size indicates
  // it is an empty block.
-  //  TODO: we never really verify check sum for meta index block
-  Block* meta = nullptr;
-  if (!ReadBlock(rep_->file.get(), ReadOptions(), footer.metaindex_handle(),
-                 &meta).ok()) {
+  ReadOptions opt;
+  BlockContents contents;
+  if (!ReadBlock(rep_->file.get(), opt, footer.metaindex_handle(),
+                 &contents).ok()) {
    // Do not propagate errors since meta info is not needed for operation
    return;
  }
+  Block* meta = new Block(contents);

  Iterator* iter = meta->NewIterator(BytewiseComparator());
  std::string key = "filter.";
@@ -199,17 +151,17 @@ void Table::ReadFilter(const Slice& filter_handle_value) {
    return;
  }

-  // TODO: We might want to unify with ReadBlock() if we start
+  // We might want to unify with ReadBlock() if we start
  // requiring checksum verification in Table::Open.
  ReadOptions opt;
  BlockContents block;
-  if (!ReadBlockContents(rep_->file.get(), opt, filter_handle, &block).ok()) {
+  if (!ReadBlock(rep_->file.get(), opt, filter_handle, &block).ok()) {
    return;
  }
  if (block.heap_allocated) {
    rep_->filter_data = block.data.data();     // Will need to delete later
  }
-  rep_->filter = new FilterBlockReader(rep_->options, block.data);
+  rep_->filter = new FilterBlockReader(rep_->options.filter_policy, block.data);
 }

 Table::~Table() {
@@ -236,12 +188,10 @@ static void ReleaseBlock(void* arg, void* h) {
 Iterator* Table::BlockReader(void* arg,
                             const ReadOptions& options,
                             const Slice& index_value,
-                             bool* didIO,
-                             bool for_compaction,
-                             const bool no_io) {
+                             bool* didIO) {
  Table* table = reinterpret_cast<Table*>(arg);
  Cache* block_cache = table->rep_->options.block_cache.get();
-  std::shared_ptr<Statistics> statistics = table->rep_->options.statistics;
+  Statistics* const statistics = table->rep_->options.statistics;
  Block* block = nullptr;
  Cache::Handle* cache_handle = nullptr;

@@ -252,6 +202,7 @@ Iterator* Table::BlockReader(void* arg,
  // can add more features in the future.

  if (s.ok()) {
+    BlockContents contents;
    if (block_cache != nullptr) {
      char cache_key[kMaxCacheKeyPrefixSize + kMaxVarint64Length];
      const size_t cache_key_prefix_size = table->rep_->cache_key_prefix_size;
@@ -267,34 +218,29 @@ Iterator* Table::BlockReader(void* arg,
        block = reinterpret_cast<Block*>(block_cache->Value(cache_handle));

        RecordTick(statistics, BLOCK_CACHE_HIT);
-      } else if (no_io) {
-        return nullptr; // Did not find in block_cache and can't do IO
      } else {
-        Histograms histogram = for_compaction ?
-          READ_BLOCK_COMPACTION_MICROS : READ_BLOCK_GET_MICROS;
-        {  // block for stop watch
-          StopWatch sw(table->rep_->options.env, statistics, histogram);
-          s = ReadBlock(
-                table->rep_->file.get(),
-                options,
-                handle,
-                &block,
-                didIO
-              );
-        }
+        s = ReadBlock(table->rep_->file.get(), options, handle, &contents);
        if (s.ok()) {
-          if (block->isCachable() && options.fill_cache) {
+          block = new Block(contents);
+          if (contents.cachable && options.fill_cache) {
            cache_handle = block_cache->Insert(
-              key, block, block->size(), &DeleteCachedBlock);
+                key, block, block->size(), &DeleteCachedBlock);
          }
        }
+        if (didIO != nullptr) {
+          *didIO = true; // we did some io from storage
+        }

        RecordTick(statistics, BLOCK_CACHE_MISS);
      }
-    } else if (no_io) {
-      return nullptr; // Could not read from block_cache and can't do IO
-    }else {
-      s = ReadBlock(table->rep_->file.get(), options, handle, &block, didIO);
+    } else {
+      s = ReadBlock(table->rep_->file.get(), options, handle, &contents);
+      if (s.ok()) {
+        block = new Block(contents);
+      }
+      if (didIO != nullptr) {
+        *didIO = true; // we did some io from storage
+      }
    }
  }

@@ -314,87 +260,23 @@ Iterator* Table::BlockReader(void* arg,

 Iterator* Table::BlockReader(void* arg,
                             const ReadOptions& options,
-                             const EnvOptions& soptions,
-                             const Slice& index_value,
-                             bool for_compaction) {
-  return BlockReader(arg, options, index_value, nullptr, for_compaction);
-}
-
-// This will be broken if the user specifies an unusual implementation
-// of Options.comparator, or if the user specifies an unusual
-// definition of prefixes in Options.filter_policy.  In particular, we
-// require the following three properties:
-//
-// 1) key.starts_with(prefix(key))
-// 2) Compare(prefix(key), key) <= 0.
-// 3) If Compare(key1, key2) <= 0, then Compare(prefix(key1), prefix(key2)) <= 0
-bool Table::PrefixMayMatch(const Slice& internal_prefix) const {
-  FilterBlockReader* filter = rep_->filter;
-  bool may_match = true;
-  Status s;
-
-  if (filter == nullptr) {
-    return true;
-  }
-
-  Iterator* iiter = rep_->index_block->NewIterator(rep_->options.comparator);
-  iiter->Seek(internal_prefix);
-  if (! iiter->Valid()) {
-    // we're past end of file
-    may_match = false;
-  } else if (iiter->key().starts_with(internal_prefix)) {
-    // we need to check for this subtle case because our only
-    // guarantee is that "the key is a string >= last key in that data
-    // block" according to the doc/table_format.txt spec.
-    //
-    // Suppose iiter->key() starts with the desired prefix; it is not
-    // necessarily the case that the corresponding data block will
-    // contain the prefix, since iiter->key() need not be in the
-    // block.  However, the next data block may contain the prefix, so
-    // we return true to play it safe.
-    may_match = true;
-  } else {
-    // iiter->key() does NOT start with the desired prefix.  Because
-    // Seek() finds the first key that is >= the seek target, this
-    // means that iiter->key() > prefix.  Thus, any data blocks coming
-    // after the data block corresponding to iiter->key() cannot
-    // possibly contain the key.  Thus, the corresponding data block
-    // is the only one which could potentially contain the prefix.
-    Slice handle_value = iiter->value();
-    BlockHandle handle;
-    s = handle.DecodeFrom(&handle_value);
-    assert(s.ok());
-    may_match = filter->PrefixMayMatch(handle.offset(), internal_prefix);
-  }
-  delete iiter;
-  return may_match;
+                             const Slice& index_value) {
+  return BlockReader(arg, options, index_value, nullptr);
 }

 Iterator* Table::NewIterator(const ReadOptions& options) const {
-  if (options.prefix) {
-    InternalKey internal_prefix(*options.prefix, 0, kTypeValue);
-    if (!PrefixMayMatch(internal_prefix.Encode())) {
-      // nothing in this file can match the prefix, so we should not
-      // bother doing I/O to this file when iterating.
-      return NewEmptyIterator();
-    }
-  }
-
  return NewTwoLevelIterator(
      rep_->index_block->NewIterator(rep_->options.comparator),
-      &Table::BlockReader, const_cast<Table*>(this), options, rep_->soptions);
+      &Table::BlockReader, const_cast<Table*>(this), options);
 }

 Status Table::InternalGet(const ReadOptions& options, const Slice& k,
                          void* arg,
-                          bool (*saver)(void*, const Slice&, const Slice&,
-                                        bool),
-                          void (*mark_key_may_exist)(void*),
-                          const bool no_io) {
+                          void (*saver)(void*, const Slice&, const Slice&, bool)) {
  Status s;
  Iterator* iiter = rep_->index_block->NewIterator(rep_->options.comparator);
-  bool done = false;
-  for (iiter->Seek(k); iiter->Valid() && !done; iiter->Next()) {
+  iiter->Seek(k);
+  if (iiter->Valid()) {
    Slice handle_value = iiter->value();
    FilterBlockReader* filter = rep_->filter;
    BlockHandle handle;
@@ -402,28 +284,14 @@ Status Table::InternalGet(const ReadOptions& options, const Slice& k,
        handle.DecodeFrom(&handle_value).ok() &&
        !filter->KeyMayMatch(handle.offset(), k)) {
      // Not found
-      // TODO: think about interaction with Merge. If a user key cannot
-      // cross one data block, we should be fine.
      RecordTick(rep_->options.statistics, BLOOM_FILTER_USEFUL);
-      break;
    } else {
      bool didIO = false;
      Iterator* block_iter = BlockReader(this, options, iiter->value(),
-                                         &didIO, no_io);
-
-      if (no_io && !block_iter) { // couldn't get block from block_cache
-        // Update Saver.state to Found because we are only looking for whether
-        // we can guarantee the key is not there when "no_io" is set
-        (*mark_key_may_exist)(arg);
-        break;
-      }
-
-      // Call the *saver function on each entry/block until it returns false
-      for (block_iter->Seek(k); block_iter->Valid(); block_iter->Next()) {
-        if (!(*saver)(arg, block_iter->key(), block_iter->value(), didIO)) {
-          done = true;
-          break;
-        }
+                                         &didIO);
+      block_iter->Seek(k);
+      if (block_iter->Valid()) {
+        (*saver)(arg, block_iter->key(), block_iter->value(), didIO);
      }
      s = block_iter->status();
      delete block_iter;
@@ -436,9 +304,8 @@ Status Table::InternalGet(const ReadOptions& options, const Slice& k,
  return s;
 }

-bool SaveDidIO(void* arg, const Slice& key, const Slice& value, bool didIO) {
+void SaveDidIO(void* arg, const Slice& key, const Slice& value, bool didIO) {
  *reinterpret_cast<bool*>(arg) = didIO;
-  return false;
 }
 bool Table::TEST_KeyInCache(const ReadOptions& options, const Slice& key) {
  // We use InternalGet() as it has logic that checks whether we read the