Updating readme to 2.1

Summary:

Test Plan:

Reviewers:

CC:

Task ID: #

Blame Rev:

Makefile

@@ -53,14 +53,18 @@ TESTS = \
 	memenv_test \
 	skiplist_test \
 	table_test \
+	ttl_test \
 	block_test \
 	version_edit_test \
 	version_set_test \
 	reduce_levels_test \
 	write_batch_test \
 	auto_roll_logger_test \
-	filelock_test
-
+	filelock_test \
+	merge_test \
+	redis_test \
+	manual_compaction_test \
+	stringappend_test
 
 TOOLS = \
         sst_dump \
@@ -68,7 +72,7 @@ TOOLS = \
         ldb \
 	db_repl_stress
 
-PROGRAMS = db_bench $(TESTS) $(TOOLS)
+PROGRAMS = db_bench signal_test $(TESTS) $(TOOLS)
 BENCHMARKS = db_bench_sqlite3 db_bench_tree_db
 
 LIBRARY = librocksdb.a
@@ -86,8 +90,8 @@ SHARED3 = $(SHARED1)
 SHARED = $(SHARED1)
 else
 # Update db.h if you change these.
-SHARED_MAJOR = 1
-SHARED_MINOR = 5
+SHARED_MAJOR = 2
+SHARED_MINOR = 0
 SHARED1 = librocksdb.$(PLATFORM_SHARED_EXT)
 SHARED2 = $(SHARED1).$(SHARED_MAJOR)
 SHARED3 = $(SHARED1).$(SHARED_MAJOR).$(SHARED_MINOR)
@@ -115,9 +119,14 @@ check: all $(PROGRAMS) $(TESTS) $(TOOLS) ldb_tests
 ldb_tests: all $(PROGRAMS) $(TOOLS)
 	python tools/ldb_test.py
 
-crash_test: db_stress
+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)
 	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; \
@@ -132,8 +141,9 @@ valgrind_check: all $(PROGRAMS) $(TESTS)
 	done
 
 clean:
-	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) $(THRIFTSERVER) */*.o */*/*.o ios-x86/*/*.o ios-arm/*/*.o build_config.mk
+	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) $(THRIFTSERVER) build_config.mk
 	-rm -rf ios-x86/* ios-arm/*
+	-for x in `find . -name "*.[od]"`; do rm $$x; done
 
 $(LIBRARY): $(LIBOBJECTS)
 	rm -f $@
@@ -155,6 +165,9 @@ db_bench_sqlite3: doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL)
 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
 
+signal_test: util/signal_test.o $(LIBOBJECTS)
+	$(CXX) util/signal_test.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
+
 arena_test: util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
 
@@ -170,6 +183,12 @@ cache_test: util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
 coding_test: util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
 
+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)
+
+redis_test: utilities/redis/redis_lists_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(CXX) utilities/redis/redis_lists_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)
 
@@ -182,6 +201,9 @@ crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
 db_test: db/db_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) db/db_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)
+
 dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
 
@@ -218,6 +240,9 @@ reduce_levels_test: tools/reduce_levels_test.o $(LIBOBJECTS) $(TESTHARNESS)
 write_batch_test: db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
 
+merge_test: db/merge_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(CXX) db/merge_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
+
 $(MEMENVLIBRARY) : $(MEMENVOBJECTS)
 	rm -f $@
 	$(AR) -rs $@ $(MEMENVOBJECTS)
@@ -225,10 +250,13 @@ $(MEMENVLIBRARY) : $(MEMENVOBJECTS)
 memenv_test : helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS)
 	$(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)
+
 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)
 
-DBClientProxy_test: tools/shell/test/DBClientProxyTest.o tools/shell/DBClientProxy.o $(LIBRARY) 
+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)
 
 filelock_test: util/filelock_test.o $(LIBOBJECTS) $(TESTHARNESS)
@@ -243,6 +271,11 @@ sst_dump: tools/sst_dump.o $(LIBOBJECTS)
 ldb: tools/ldb.o $(LIBOBJECTS)
 	$(CXX) tools/ldb.o $(LIBOBJECTS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS)
 
+.PHONY: tags
+tags:
+	ctags `find . -name '*.cc'` `find . -name '*.h'`
+	cscope -b `find . -name '*.cc'` `find . -name '*.h'`
+
 ifeq ($(PLATFORM), IOS)
 # For iOS, create universal object files to be used on both the simulator and
 # a device.

README

@@ -1,5 +1,7 @@
 rocksdb: A persistent key-value store for flash storage
-Authors: The Facebook Database Engineering Team
+Authors: * The Facebook Database Engineering Team
+         * Build on earlier work on leveldb by Sanjay Ghemawat 
+           (sanjay@google.com) and Jeff Dean (jeff@google.com)
 
 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.
@@ -56,6 +58,25 @@ 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.
+
+

README.fb

@@ -1,3 +1,3 @@
 * Detailed instructions on how to compile using fbcode and jemalloc
 
-* Latest release is 1.5.9.fb
+* Latest release is 2.1.fb

build_detect_platform

@@ -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,6 +64,9 @@ 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=`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)
@@ -71,7 +74,7 @@ case "$TARGET_OS" in
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -DOS_MACOSX"
         PLATFORM_SHARED_EXT=dylib
         PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/darwin/darwin_specific.cc
         ;;
     Linux)
         PLATFORM=OS_LINUX
@@ -80,43 +83,43 @@ case "$TARGET_OS" in
             COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp"
         fi
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/linux/linux_specific.cc
         ;;
     SunOS)
         PLATFORM=OS_SOLARIS
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_SOLARIS"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/sunos/sunos_specific.cc
         ;;
     FreeBSD)
         PLATFORM=OS_FREEBSD
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_FREEBSD"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/freebsd/freebsd_specific.cc
         ;;
     NetBSD)
         PLATFORM=OS_NETBSD
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_NETBSD"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lgcc_s"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/netbsd/netbsd_specific.cc
         ;;
     OpenBSD)
         PLATFORM=OS_OPENBSD
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/openbsd/openbsd_specific.cc
         ;;
     DragonFly)
         PLATFORM=OS_DRAGONFLYBSD
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_DRAGONFLYBSD"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread"
-        PORT_FILE=port/port_posix.cc
+        # PORT_FILES=port/dragonfly/dragonfly_specific.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_FILE=port/port_posix.cc
+        # PORT_FILES=port/android/android.cc
         CROSS_COMPILE=true
         ;;
     *)
@@ -130,7 +133,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"
+DIRS="util db table utilities"
 if test "$USE_THRIFT"; then
   DIRS="$DIRS thrift/server_utils.cpp thrift/gen-cpp "
   THRIFTSERVER=leveldb_server
@@ -149,7 +152,7 @@ set +f # re-enable globbing
 
 # The sources consist of the portable files, plus the platform-specific port
 # file.
-echo "SOURCES=$PORTABLE_FILES $PORT_FILE" >> $OUTPUT
+echo "SOURCES=$PORTABLE_FILES $GENERIC_PORT_FILES $PORT_FILES" >> $OUTPUT
 echo "SOURCESCPP=$PORTABLE_CPP" >> $OUTPUT
 echo "MEMENV_SOURCES=helpers/memenv/memenv.cc" >> $OUTPUT
 

db/builder.cc

@@ -6,18 +6,20 @@
 
 #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 StorageOptions& soptions,
+                  const EnvOptions& soptions,
                   TableCache* table_cache,
                   Iterator* iter,
                   FileMetaData* meta,
@@ -46,42 +48,92 @@ Status BuildTable(const std::string& dbname,
     TableBuilder* builder = new TableBuilder(options, file.get(), 0);
 
     // the first key is the smallest key
-    Slice key = iter->key();
-    meta->smallest.DecodeFrom(key);
+    meta->smallest.DecodeFrom(iter->key());
+
+    MergeHelper merge(user_comparator, options.merge_operator,
+                      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
 
-      // 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);
+      while (iter->Valid()) {
+        bool iterator_at_next = false;
 
-      for (iter->Next(); iter->Valid(); iter->Next()) {
+        // Get current key
         ParsedInternalKey this_ikey;
         Slice key = iter->key();
-        ParseInternalKey(key, &this_ikey);
+        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);
         assert(this_ikey.sequence >= earliest_seqno_in_memtable);
 
-        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 {
+        // 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)) {
           // seqno within the same key are in decreasing order
           assert(this_ikey.sequence < prev_ikey.sequence);
-          // This key is an earlier version of the same key in prev_key.
-          // Skip current key.
+        } 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);
+          }
         }
+
+        if (!iterator_at_next) iter->Next();
       }
-      // output last key
-      builder->Add(Slice(prev_key), Slice(prev_value));
+
+      // The last key is the largest key
       meta->largest.DecodeFrom(Slice(prev_key));
 
     } else {
@@ -107,8 +159,10 @@ 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();
       }
     }

db/builder.h

@@ -8,7 +8,6 @@
 #include "leveldb/comparator.h"
 #include "leveldb/status.h"
 #include "leveldb/types.h"
-#include "util/storage_options.h"
 
 namespace leveldb {
 
@@ -16,6 +15,7 @@ struct Options;
 struct FileMetaData;
 
 class Env;
+class EnvOptions;
 class Iterator;
 class TableCache;
 class VersionEdit;
@@ -28,7 +28,7 @@ class VersionEdit;
 extern Status BuildTable(const std::string& dbname,
                          Env* env,
                          const Options& options,
-                         const StorageOptions& soptions,
+                         const EnvOptions& soptions,
                          TableCache* table_cache,
                          Iterator* iter,
                          FileMetaData* meta,

db/corruption_test.cc

@@ -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,6 +40,7 @@ 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;
   }
@@ -55,6 +56,8 @@ 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_);
   }
 

db/db_bench.cc

@@ -15,10 +15,13 @@
 #include "leveldb/write_batch.h"
 #include "leveldb/statistics.h"
 #include "port/port.h"
+#include "util/bit_set.h"
 #include "util/crc32c.h"
 #include "util/histogram.h"
 #include "util/mutexlock.h"
 #include "util/random.h"
+#include "util/stack_trace.h"
+#include "util/string_util.h"
 #include "util/testutil.h"
 #include "hdfs/env_hdfs.h"
 
@@ -119,6 +122,16 @@ static int FLAGS_write_buffer_size = 0;
 // This is initialized to default value of 2 in "main" function.
 static int FLAGS_max_write_buffer_number = 0;
 
+// The minimum number of write buffers that will be merged together
+// before writing to storage. This is cheap because it is an
+// in-memory merge. If this feature is not enabled, then all these
+// write buffers are fushed to L0 as seperate 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.
+static int FLAGS_min_write_buffer_number_to_merge = 0;
+
 // The maximum number of concurrent background compactions
 // that can occur in parallel.
 // This is initialized to default value of 1 in "main" function.
@@ -161,6 +174,10 @@ static class std::shared_ptr<leveldb::Statistics> dbstats;
 // Number of write operations to do.  If negative, do FLAGS_num reads.
 static long FLAGS_writes = -1;
 
+// Per-thread rate limit on writes per second. No limit when <= 0.
+// Only for the readwhilewriting test.
+static int FLAGS_writes_per_second = 0;
+
 // These default values might change if the hardcoded
 
 // Sync all writes to disk
@@ -197,6 +214,9 @@ static uint64_t FLAGS_max_bytes_for_level_base = 10 * 1048576;
 // A multiplier to compute max bytes for level-N
 static int FLAGS_max_bytes_for_level_multiplier = 10;
 
+// A vector that specifies additional fanout per level
+static std::vector<int> FLAGS_max_bytes_for_level_multiplier_additional;
+
 // Number of files in level-0 that will trigger put stop.
 static int FLAGS_level0_stop_writes_trigger = 12;
 
@@ -244,13 +264,16 @@ static int FLAGS_stats_interval = 0;
 // than 0.
 static int FLAGS_stats_per_interval = 0;
 
+static double FLAGS_soft_rate_limit = 0;
+
 // When not equal to 0 this make threads sleep at each stats
 // reporting interval until the compaction score for all levels is
 // less than or equal to this value.
-static double FLAGS_rate_limit = 0;
+static double FLAGS_hard_rate_limit = 0;
 
-// When FLAGS_rate_limit is set then this is the max time a put will be stalled.
-static int FLAGS_rate_limit_delay_milliseconds = 1000;
+// When FLAGS_hard_rate_limit is set then this is the max time a put will be
+// stalled.
+static int FLAGS_rate_limit_delay_max_milliseconds = 1000;
 
 // Control maximum bytes of overlaps in grandparent (i.e., level+2) before we
 // stop building a single file in a level->level+1 compaction.
@@ -272,17 +295,43 @@ static uint64_t FLAGS_WAL_ttl_seconds = 0;
 // Allow buffered io using OS buffers
 static bool FLAGS_use_os_buffer;
 
-// Allow filesystem to do read-aheads
-static bool FLAGS_use_fsreadahead;
-
 // Allow reads to occur via mmap-ing files
 static bool FLAGS_use_mmap_reads;
 
 // Allow writes to occur via mmap-ing files
 static bool FLAGS_use_mmap_writes;
 
-// Allow readaheads to occur for compactions
-static bool FLAGS_use_readahead_compactions;
+// Advise random access on table file open
+static bool FLAGS_advise_random_on_open =
+  leveldb::Options().advise_random_on_open;
+
+// Access pattern advice when a file is compacted
+static auto FLAGS_compaction_fadvice =
+  leveldb::Options().access_hint_on_compaction_start;
+
+// Use multiget to access a series of keys instead of get
+static bool FLAGS_use_multiget = false;
+
+// If FLAGS_use_multiget is true, determines number of keys to group per call
+// Arbitrary default. 90 is good because it agrees with FLAGS_readwritepercent
+static long FLAGS_keys_per_multiget = 90;
+
+// Print a message to user when a key is missing in a Get/MultiGet call
+// TODO: Apply this flag to generic Get calls too. Currently only with Multiget
+static bool FLAGS_warn_missing_keys = true;
+
+// Use adaptive mutex
+static auto FLAGS_use_adaptive_mutex =
+  leveldb::Options().use_adaptive_mutex;
+
+// 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.
+static auto FLAGS_bytes_per_sync =
+  leveldb::Options().bytes_per_sync;
+
+// On true, deletes use bloom-filter and drop the delete if key not present
+static bool FLAGS_filter_deletes = false;
 
 namespace leveldb {
 
@@ -476,7 +525,7 @@ class Stats {
 
     fprintf(stdout, "%-12s : %11.3f micros/op %ld ops/sec;%s%s\n",
             name.ToString().c_str(),
-            seconds_ * 1e6 / done_,
+            elapsed * 1e6 / done_,
             (long)throughput,
             (extra.empty() ? "" : " "),
             extra.c_str());
@@ -529,10 +578,12 @@ class Duration {
   }
 
   bool Done(int increment) {
+    if (increment <= 0) increment = 1;    // avoid Done(0) and infinite loops
     ops_ += increment;
 
     if (max_seconds_) {
-      if (!(ops_ % 1000)) {
+      // Recheck every appx 1000 ops (exact iff increment is factor of 1000)
+      if ((ops_/1000) != ((ops_-increment)/1000)) {
         double now = FLAGS_env->NowMicros();
         return ((now - start_at_) / 1000000.0) >= max_seconds_;
       } else {
@@ -578,6 +629,7 @@ class Benchmark {
     fprintf(stdout, "FileSize:   %.1f MB (estimated)\n",
             (((FLAGS_key_size + FLAGS_value_size * FLAGS_compression_ratio) * num_)
              / 1048576.0));
+    fprintf(stdout, "Write rate limit: %d\n", FLAGS_writes_per_second);
 
     switch (FLAGS_compression_type) {
       case leveldb::kNoCompression:
@@ -686,35 +738,6 @@ class Benchmark {
 #endif
   }
 
-  void PrintHistogram(Histograms histogram_type, std::string name) {
-    HistogramData histogramData;
-    dbstats->histogramData(histogram_type, &histogramData);
-    fprintf(stdout, "%s statistics : \n", name.c_str());
-    fprintf(stdout, "Median : %f\n",histogramData.median);
-    fprintf(stdout, "99ile : %f\n", histogramData.percentile99);
-  }
-
-  void PrintStatistics() {
-    if (FLAGS_statistics) {
-      fprintf(stdout, "File opened:%ld closed:%ld errors:%ld\n"
-          "Block Cache Hit Count:%ld Block Cache Miss Count:%ld\n"
-          "Bloom Filter Useful: %ld \n"
-          "Compaction key_drop_newer_entry: %ld key_drop_obsolete: %ld "
-          "Compaction key_drop_user: %ld\n",
-          dbstats->getTickerCount(NO_FILE_OPENS),
-          dbstats->getTickerCount(NO_FILE_CLOSES),
-          dbstats->getTickerCount(NO_FILE_ERRORS),
-          dbstats->getTickerCount(BLOCK_CACHE_HIT),
-          dbstats->getTickerCount(BLOCK_CACHE_MISS),
-          dbstats->getTickerCount(BLOOM_FILTER_USEFUL),
-          dbstats->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-          dbstats->getTickerCount(COMPACTION_KEY_DROP_OBSOLETE),
-          dbstats->getTickerCount(COMPACTION_KEY_DROP_USER));
-      PrintHistogram(DB_GET, "DB_GET");
-      PrintHistogram(DB_WRITE, "DB_WRITE");
-    }
-  }
-
  public:
   Benchmark()
   : cache_(FLAGS_cache_size >= 0 ?
@@ -756,13 +779,13 @@ void ConstructStrFormatForKey(char* str, int keySize)
 {
   str[0] = '%';
   str[1] = '0';
-  sprintf(str+2, "%dd", keySize);
+  sprintf(str+2, "%dd%s", keySize, "%s");
 }
 
-unique_ptr<char []> GenerateKeyFromInt(int v)
+unique_ptr<char []> GenerateKeyFromInt(int v, const char* suffix = "")
 {
   unique_ptr<char []> keyInStr(new char[MAX_KEY_SIZE]);
-  snprintf(keyInStr.get(), MAX_KEY_SIZE, keyFormat_, v);
+  snprintf(keyInStr.get(), MAX_KEY_SIZE, keyFormat_, v, suffix);
   return keyInStr;
 }
   void Run() {
@@ -809,6 +832,14 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
       } else if (name == Slice("fillrandom")) {
         fresh_db = true;
         method = &Benchmark::WriteRandom;
+      } else if (name == Slice("filluniquerandom")) {
+        fresh_db = true;
+        if (num_threads > 1) {
+          fprintf(stderr, "filluniquerandom multithreaded not supported"
+                           " set --threads=1");
+          exit(1);
+        }
+        method = &Benchmark::WriteUniqueRandom;
       } else if (name == Slice("overwrite")) {
         fresh_db = false;
         method = &Benchmark::WriteRandom;
@@ -888,10 +919,13 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
       }
 
       if (method != nullptr) {
+        fprintf(stdout, "DB path: [%s]\n", FLAGS_db);
         RunBenchmark(num_threads, name, method);
       }
     }
-    PrintStatistics();
+    if (FLAGS_statistics) {
+     fprintf(stdout, "STATISTICS:\n%s\n", dbstats->ToString().c_str());
+    }
   }
 
  private:
@@ -1067,6 +1101,8 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     }
     options.write_buffer_size = FLAGS_write_buffer_size;
     options.max_write_buffer_number = FLAGS_max_write_buffer_number;
+    options.min_write_buffer_number_to_merge =
+      FLAGS_min_write_buffer_number_to_merge;
     options.max_background_compactions = FLAGS_max_background_compactions;
     options.block_size = FLAGS_block_size;
     options.filter_policy = filter_policy_;
@@ -1081,6 +1117,17 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     options.max_bytes_for_level_base = FLAGS_max_bytes_for_level_base;
     options.max_bytes_for_level_multiplier =
         FLAGS_max_bytes_for_level_multiplier;
+    options.filter_deletes = FLAGS_filter_deletes;
+    if (FLAGS_max_bytes_for_level_multiplier_additional.size() > 0) {
+      if (FLAGS_max_bytes_for_level_multiplier_additional.size() !=
+          (unsigned int)FLAGS_num_levels) {
+        fprintf(stderr, "Insufficient number of fanouts specified %d\n",
+                (int)FLAGS_max_bytes_for_level_multiplier_additional.size());
+        exit(1);
+      }
+      options.max_bytes_for_level_multiplier_additional =
+        FLAGS_max_bytes_for_level_multiplier_additional;
+    }
     options.level0_stop_writes_trigger = FLAGS_level0_stop_writes_trigger;
     options.level0_file_num_compaction_trigger =
         FLAGS_level0_file_num_compaction_trigger;
@@ -1102,8 +1149,10 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     options.disable_seek_compaction = FLAGS_disable_seek_compaction;
     options.delete_obsolete_files_period_micros =
       FLAGS_delete_obsolete_files_period_micros;
-    options.rate_limit = FLAGS_rate_limit;
-    options.rate_limit_delay_milliseconds = FLAGS_rate_limit_delay_milliseconds;
+    options.soft_rate_limit = FLAGS_soft_rate_limit;
+    options.hard_rate_limit = FLAGS_hard_rate_limit;
+    options.rate_limit_delay_max_milliseconds =
+      FLAGS_rate_limit_delay_max_milliseconds;
     options.table_cache_numshardbits = FLAGS_table_cache_numshardbits;
     options.max_grandparent_overlap_factor =
       FLAGS_max_grandparent_overlap_factor;
@@ -1112,10 +1161,14 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
 
     // fill storage options
     options.allow_os_buffer = FLAGS_use_os_buffer;
-    options.allow_readahead = FLAGS_use_fsreadahead;
     options.allow_mmap_reads = FLAGS_use_mmap_reads;
     options.allow_mmap_writes = FLAGS_use_mmap_writes;
-    options.allow_readahead_compactions = FLAGS_use_readahead_compactions;
+    options.advise_random_on_open = FLAGS_advise_random_on_open;
+    options.access_hint_on_compaction_start = FLAGS_compaction_fadvice;
+
+    options.use_adaptive_mutex = FLAGS_use_adaptive_mutex;
+    options.bytes_per_sync = FLAGS_bytes_per_sync;
+
     Status s;
     if(FLAGS_read_only) {
       s = DB::OpenForReadOnly(options, FLAGS_db, &db_);
@@ -1131,16 +1184,31 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     }
   }
 
+  enum WriteMode {
+    RANDOM, SEQUENTIAL, UNIQUE_RANDOM
+  };
+
   void WriteSeq(ThreadState* thread) {
-    DoWrite(thread, true);
+    DoWrite(thread, SEQUENTIAL);
   }
 
   void WriteRandom(ThreadState* thread) {
-    DoWrite(thread, false);
+    DoWrite(thread, RANDOM);
   }
 
-  void DoWrite(ThreadState* thread, bool seq) {
-    Duration duration(seq ? 0 : FLAGS_duration, writes_);
+  void WriteUniqueRandom(ThreadState* thread) {
+    DoWrite(thread, UNIQUE_RANDOM);
+  }
+
+  void DoWrite(ThreadState* thread, WriteMode write_mode) {
+    const int test_duration = write_mode == RANDOM ? FLAGS_duration : 0;
+    const int num_ops = writes_ == 0 ? num_ : writes_ ;
+    Duration duration(test_duration, num_ops);
+    unique_ptr<BitSet> bit_set;
+
+    if (write_mode == UNIQUE_RANDOM) {
+      bit_set.reset(new BitSet(num_ops));
+    }
 
     if (num_ != FLAGS_num) {
       char msg[100];
@@ -1156,7 +1224,44 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     while (!duration.Done(entries_per_batch_)) {
       batch.Clear();
       for (int j = 0; j < entries_per_batch_; j++) {
-        const int k = seq ? i+j : (thread->rand.Next() % FLAGS_num);
+        int k = 0;
+        switch(write_mode) {
+          case SEQUENTIAL:
+            k = i +j;
+            break;
+          case RANDOM:
+            k = thread->rand.Next() % FLAGS_num;
+            break;
+          case UNIQUE_RANDOM:
+            {
+              int t = thread->rand.Next() % FLAGS_num;
+              if (!bit_set->test(t)) {
+                // best case
+                k = t;
+              } else {
+                bool found = false;
+                // look forward
+                for (size_t i = t + 1; i < bit_set->size(); ++i) {
+                  if (!bit_set->test(i)) {
+                    found = true;
+                    k = i;
+                    break;
+                  }
+                }
+                if (!found) {
+                  for (size_t i = t; i-- > 0;) {
+                    if (!bit_set->test(i)) {
+                      found = true;
+                      k = i;
+                      break;
+                    }
+                  }
+                }
+              }
+              bit_set->set(k);
+              break;
+            }
+        };
         unique_ptr<char []> key = GenerateKeyFromInt(k);
         batch.Put(key.get(), gen.Generate(value_size_));
         bytes += value_size_ + strlen(key.get());
@@ -1198,81 +1303,187 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     thread->stats.AddBytes(bytes);
   }
 
+  // Calls MultiGet over a list of keys from a random distribution.
+  // Returns the total number of keys found.
+  long MultiGetRandom(ReadOptions& options, int num_keys,
+                     Random& rand, int range, const char* suffix) {
+    assert(num_keys > 0);
+    std::vector<Slice> keys(num_keys);
+    std::vector<std::string> values(num_keys);
+    std::vector<unique_ptr<char []> > gen_keys(num_keys);
+
+    int i;
+    long k;
+
+    // Fill the keys vector
+    for(i=0; i<num_keys; ++i) {
+      k = rand.Next() % range;
+      gen_keys[i] = GenerateKeyFromInt(k,suffix);
+      keys[i] = gen_keys[i].get();
+    }
+
+    if (FLAGS_use_snapshot) {
+      options.snapshot = db_->GetSnapshot();
+    }
+
+    // Apply the operation
+    std::vector<Status> statuses = db_->MultiGet(options, keys, &values);
+    assert((long)statuses.size() == num_keys);
+    assert((long)keys.size() == num_keys);  // Should always be the case.
+    assert((long)values.size() == num_keys);
+
+    if (FLAGS_use_snapshot) {
+      db_->ReleaseSnapshot(options.snapshot);
+      options.snapshot = nullptr;
+    }
+
+    // Count number found
+    long found = 0;
+    for(i=0; i<num_keys; ++i) {
+      if (statuses[i].ok()){
+        ++found;
+      } else if (FLAGS_warn_missing_keys == true) {
+        // Key not found, or error.
+        fprintf(stderr, "get error: %s\n", statuses[i].ToString().c_str());
+      }
+    }
+
+    return found;
+  }
+
   void ReadRandom(ThreadState* thread) {
     ReadOptions options(FLAGS_verify_checksum, true);
-    Iterator* iter = db_->NewIterator(options);
     Duration duration(FLAGS_duration, reads_);
 
-    std::string value;
     long found = 0;
-    while (!duration.Done(1)) {
-      const int k = thread->rand.Next() % FLAGS_num;
-      unique_ptr<char []> key = GenerateKeyFromInt(k);
 
-      if (FLAGS_use_snapshot) {
-        options.snapshot = db_->GetSnapshot();
+    if (FLAGS_use_multiget) {   // MultiGet
+      const long& kpg = FLAGS_keys_per_multiget;  // keys per multiget group
+      long keys_left = reads_;
+
+      // Recalculate number of keys per group, and call MultiGet until done
+      long num_keys;
+      while(num_keys = std::min(keys_left, kpg), !duration.Done(num_keys)) {
+        found += MultiGetRandom(options, num_keys, thread->rand, FLAGS_num,"");
+        thread->stats.FinishedSingleOp(db_);
+        keys_left -= num_keys;
       }
-
-      if (FLAGS_read_range < 2) {
-        if (db_->Get(options, key.get(), &value).ok()) {
-          found++;
-        }
-      } else {
-        Slice skey(key.get());
-        int count = 1;
-
-        if (FLAGS_get_approx) {
-          unique_ptr<char []> key2 =
-              GenerateKeyFromInt(k + (int) FLAGS_read_range);
-          Slice skey2(key2.get());
-          Range range(skey, skey2);
-          uint64_t sizes;
-          db_->GetApproximateSizes(&range, 1, &sizes);
+    } else {    // Regular case. Do one "get" at a time Get
+      Iterator* iter = db_->NewIterator(options);
+      std::string value;
+      while (!duration.Done(1)) {
+        const int k = thread->rand.Next() % FLAGS_num;
+        unique_ptr<char []> key = GenerateKeyFromInt(k);
+        if (FLAGS_use_snapshot) {
+          options.snapshot = db_->GetSnapshot();
         }
 
-        for (iter->Seek(skey);
-             iter->Valid() && count <= FLAGS_read_range;
-             ++count, iter->Next()) {
-          found++;
+        if (FLAGS_read_range < 2) {
+          if (db_->Get(options, key.get(), &value).ok()) {
+            found++;
+          }
+        } else {
+          Slice skey(key.get());
+          int count = 1;
+
+          if (FLAGS_get_approx) {
+            unique_ptr<char []> key2 =
+                GenerateKeyFromInt(k + (int) FLAGS_read_range);
+            Slice skey2(key2.get());
+            Range range(skey, skey2);
+            uint64_t sizes;
+            db_->GetApproximateSizes(&range, 1, &sizes);
+          }
+
+          for (iter->Seek(skey);
+               iter->Valid() && count <= FLAGS_read_range;
+               ++count, iter->Next()) {
+            found++;
+          }
         }
+
+        if (FLAGS_use_snapshot) {
+          db_->ReleaseSnapshot(options.snapshot);
+          options.snapshot = nullptr;
+        }
+
+        thread->stats.FinishedSingleOp(db_);
       }
 
-      if (FLAGS_use_snapshot) {
-        db_->ReleaseSnapshot(options.snapshot);
-        options.snapshot = nullptr;
-      }
-
-      thread->stats.FinishedSingleOp(db_);
+      delete iter;
     }
-    delete iter;
+
     char msg[100];
-    snprintf(msg, sizeof(msg), "(%ld of %ld found)", found, num_);
+    snprintf(msg, sizeof(msg), "(%ld of %ld found)", found, reads_);
     thread->stats.AddMessage(msg);
   }
 
-  void ReadMissing(ThreadState* thread) {
+void ReadMissing(ThreadState* thread) {
+    FLAGS_warn_missing_keys = false;    // Never warn about missing keys
+
     Duration duration(FLAGS_duration, reads_);
     ReadOptions options(FLAGS_verify_checksum, true);
-    std::string value;
-    while (!duration.Done(1)) {
-      const int k = thread->rand.Next() % FLAGS_num;
-      unique_ptr<char []> key = GenerateKeyFromInt(k);
-      db_->Get(options, key.get(), &value);
-      thread->stats.FinishedSingleOp(db_);
+
+    if (FLAGS_use_multiget) {
+      const long& kpg = FLAGS_keys_per_multiget;  // keys per multiget group
+      long keys_left = reads_;
+
+      // Recalculate number of keys per group, and call MultiGet until done
+      long num_keys;
+      long found;
+      while(num_keys = std::min(keys_left, kpg), !duration.Done(num_keys)) {
+        found = MultiGetRandom(options, num_keys, thread->rand, FLAGS_num,".");
+        if (!found) {
+          assert(false);
+        }
+        thread->stats.FinishedSingleOp(db_);
+        keys_left -= num_keys;
+      }
+    } else {  // Regular case (not MultiGet)
+      std::string value;
+      Status s;
+      while (!duration.Done(1)) {
+        const int k = thread->rand.Next() % FLAGS_num;
+        unique_ptr<char []> key = GenerateKeyFromInt(k, ".");
+        s = db_->Get(options, key.get(), &value);
+        assert(!s.ok() && s.IsNotFound());
+        thread->stats.FinishedSingleOp(db_);
+      }
     }
   }
 
   void ReadHot(ThreadState* thread) {
     Duration duration(FLAGS_duration, reads_);
     ReadOptions options(FLAGS_verify_checksum, true);
-    std::string value;
     const long range = (FLAGS_num + 99) / 100;
-    while (!duration.Done(1)) {
-      const int k = thread->rand.Next() % range;
-      unique_ptr<char []> key = GenerateKeyFromInt(k);
-      db_->Get(options, key.get(), &value);
-      thread->stats.FinishedSingleOp(db_);
+    long found = 0;
+
+    if (FLAGS_use_multiget) {
+      const long& kpg = FLAGS_keys_per_multiget;  // keys per multiget group
+      long keys_left = reads_;
+
+      // Recalculate number of keys per group, and call MultiGet until done
+      long num_keys;
+      while(num_keys = std::min(keys_left, kpg), !duration.Done(num_keys)) {
+        found += MultiGetRandom(options, num_keys, thread->rand, range, "");
+        thread->stats.FinishedSingleOp(db_);
+        keys_left -= num_keys;
+      }
+    } else {
+      std::string value;
+      while (!duration.Done(1)) {
+        const int k = thread->rand.Next() % range;
+        unique_ptr<char []> key = GenerateKeyFromInt(k);
+        if (db_->Get(options, key.get(), &value).ok()){
+          ++found;
+        }
+        thread->stats.FinishedSingleOp(db_);
+      }
     }
+
+    char msg[100];
+    snprintf(msg, sizeof(msg), "(%ld of %ld found)", found, reads_);
+    thread->stats.AddMessage(msg);
   }
 
   void SeekRandom(ThreadState* thread) {
@@ -1295,7 +1506,6 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
   }
 
   void DoDelete(ThreadState* thread, bool seq) {
-    RandomGenerator gen;
     WriteBatch batch;
     Status s;
     Duration duration(seq ? 0 : FLAGS_duration, num_);
@@ -1331,6 +1541,15 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     } else {
       // Special thread that keeps writing until other threads are done.
       RandomGenerator gen;
+      double last = FLAGS_env->NowMicros();
+      int writes_per_second_by_10 = 0;
+      int num_writes = 0;
+
+      // --writes_per_second rate limit is enforced per 100 milliseconds
+      // intervals to avoid a burst of writes at the start of each second.
+
+      if (FLAGS_writes_per_second > 0)
+        writes_per_second_by_10 = FLAGS_writes_per_second / 10;
 
       // Don't merge stats from this thread with the readers.
       thread->stats.SetExcludeFromMerge();
@@ -1352,13 +1571,27 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
           exit(1);
         }
         thread->stats.FinishedSingleOp(db_);
+
+        ++num_writes;
+        if (writes_per_second_by_10 && num_writes >= writes_per_second_by_10) {
+          double now = FLAGS_env->NowMicros();
+          double usecs_since_last = now - last;
+
+          num_writes = 0;
+          last = now;
+
+          if (usecs_since_last < 100000.0) {
+            FLAGS_env->SleepForMicroseconds(100000.0 - usecs_since_last);
+            last = FLAGS_env->NowMicros();
+          }
+        }
       }
     }
   }
 
   // Given a key K and value V, this puts (K+"0", V), (K+"1", V), (K+"2", V)
-  // in DB atomically i.e in a single batch. Also refer MultiGet.
-  Status MultiPut(const WriteOptions& writeoptions,
+  // in DB atomically i.e in a single batch. Also refer GetMany.
+  Status PutMany(const WriteOptions& writeoptions,
                   const Slice& key, const Slice& value) {
     std::string suffixes[3] = {"2", "1", "0"};
     std::string keys[3];
@@ -1376,8 +1609,8 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
 
 
   // Given a key K, this deletes (K+"0", V), (K+"1", V), (K+"2", V)
-  // in DB atomically i.e in a single batch. Also refer MultiGet.
-  Status MultiDelete(const WriteOptions& writeoptions,
+  // in DB atomically i.e in a single batch. Also refer GetMany.
+  Status DeleteMany(const WriteOptions& writeoptions,
                   const Slice& key) {
     std::string suffixes[3] = {"1", "2", "0"};
     std::string keys[3];
@@ -1395,8 +1628,8 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
 
   // Given a key K and value V, this gets values for K+"0", K+"1" and K+"2"
   // in the same snapshot, and verifies that all the values are identical.
-  // ASSUMES that MultiPut was used to put (K, V) into the DB.
-  Status MultiGet(const ReadOptions& readoptions,
+  // ASSUMES that PutMany was used to put (K, V) into the DB.
+  Status GetMany(const ReadOptions& readoptions,
                   const Slice& key, std::string* value) {
     std::string suffixes[3] = {"0", "1", "2"};
     std::string keys[3];
@@ -1434,11 +1667,12 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
   }
 
   // Differs from readrandomwriterandom in the following ways:
-  // (a) Uses MultiGet/MultiPut to read/write key values. Refer to those funcs.
+  // (a) Uses GetMany/PutMany to read/write key values. Refer to those funcs.
   // (b) Does deletes as well (per FLAGS_deletepercent)
   // (c) In order to achieve high % of 'found' during lookups, and to do
   //     multiple writes (including puts and deletes) it uses upto
   //     FLAGS_numdistinct distinct keys instead of FLAGS_num distinct keys.
+  // (d) Does not have a MultiGet option.
   void RandomWithVerify(ThreadState* thread) {
     ReadOptions options(FLAGS_verify_checksum, true);
     RandomGenerator gen;
@@ -1450,21 +1684,22 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     long gets_done = 0;
     long puts_done = 0;
     long deletes_done = 0;
+
     // the number of iterations is the larger of read_ or write_
     for (long i = 0; i < readwrites_; i++) {
       const int k = thread->rand.Next() % (FLAGS_numdistinct);
       unique_ptr<char []> key = GenerateKeyFromInt(k);
       if (get_weight == 0 && put_weight == 0 && delete_weight == 0) {
-        // one batch complated, reinitialize for next batch
+        // one batch completed, reinitialize for next batch
         get_weight = FLAGS_readwritepercent;
         delete_weight = FLAGS_deletepercent;
         put_weight = 100 - get_weight - delete_weight;
       }
       if (get_weight > 0) {
         // do all the gets first
-        Status s = MultiGet(options, key.get(), &value);
+        Status s = GetMany(options, key.get(), &value);
         if (!s.ok() && !s.IsNotFound()) {
-          fprintf(stderr, "get error: %s\n", s.ToString().c_str());
+          fprintf(stderr, "getmany error: %s\n", s.ToString().c_str());
           // we continue after error rather than exiting so that we can
           // find more errors if any
         } else if (!s.IsNotFound()) {
@@ -1475,17 +1710,17 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
       } else if (put_weight > 0) {
         // then do all the corresponding number of puts
         // for all the gets we have done earlier
-        Status s = MultiPut(write_options_, key.get(), gen.Generate(value_size_));
+        Status s = PutMany(write_options_, key.get(), gen.Generate(value_size_));
         if (!s.ok()) {
-          fprintf(stderr, "multiput error: %s\n", s.ToString().c_str());
+          fprintf(stderr, "putmany error: %s\n", s.ToString().c_str());
           exit(1);
         }
         put_weight--;
         puts_done++;
       } else if (delete_weight > 0) {
-        Status s = MultiDelete(write_options_, key.get());
+        Status s = DeleteMany(write_options_, key.get());
         if (!s.ok()) {
-          fprintf(stderr, "multidelete error: %s\n", s.ToString().c_str());
+          fprintf(stderr, "deletemany error: %s\n", s.ToString().c_str());
           exit(1);
         }
         delete_weight--;
@@ -1505,6 +1740,12 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
   // an extra thread.
   //
   void ReadRandomWriteRandom(ThreadState* thread) {
+    if (FLAGS_use_multiget){
+      // Separate function for multiget (for ease of reading)
+      ReadRandomWriteRandomMultiGet(thread);
+      return;
+    }
+
     ReadOptions options(FLAGS_verify_checksum, true);
     RandomGenerator gen;
     std::string value;
@@ -1550,9 +1791,6 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
           found++;
         }
 
-        if (db_->Get(options, key.get(), &value).ok()) {
-          found++;
-        }
         get_weight--;
         reads_done++;
 
@@ -1579,9 +1817,85 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
     thread->stats.AddMessage(msg);
   }
 
+  // ReadRandomWriteRandom (with multiget)
+  // Does FLAGS_keys_per_multiget reads (per multiget), followed by some puts.
+  // FLAGS_readwritepercent will specify the ratio of gets to puts.
+  // e.g.: If FLAGS_keys_per_multiget == 100 and FLAGS_readwritepercent == 75
+  // Then each block will do 100 multigets and 33 puts
+  // So there are 133 operations in-total: 100 of them (75%) are gets, and 33
+  // of them (25%) are puts.
+  void ReadRandomWriteRandomMultiGet(ThreadState* thread) {
+    ReadOptions options(FLAGS_verify_checksum, true);
+    RandomGenerator gen;
+
+    // For multiget
+    const long& kpg = FLAGS_keys_per_multiget;  // keys per multiget group
+
+    long keys_left = readwrites_;  // number of keys still left to read
+    long num_keys;                  // number of keys to read in current group
+    long num_put_keys;              // number of keys to put in current group
+
+    long found = 0;
+    long reads_done = 0;
+    long writes_done = 0;
+    long multigets_done = 0;
+
+    // the number of iterations is the larger of read_ or write_
+    Duration duration(FLAGS_duration, readwrites_);
+    while(true) {
+      // Read num_keys keys, then write num_put_keys keys.
+      // The ratio of num_keys to num_put_keys is always FLAGS_readwritepercent
+      // And num_keys is set to be FLAGS_keys_per_multiget (kpg)
+      // num_put_keys is calculated accordingly (to maintain the ratio)
+      // Note: On the final iteration, num_keys and num_put_keys will be smaller
+      num_keys = std::min(keys_left*(FLAGS_readwritepercent + 99)/100, kpg);
+      num_put_keys = num_keys * (100-FLAGS_readwritepercent)
+                     / FLAGS_readwritepercent;
+
+      // This will break the loop when duration is complete
+      if (duration.Done(num_keys + num_put_keys)) {
+        break;
+      }
+
+      // A quick check to make sure our formula doesn't break on edge cases
+      assert(num_keys >= 1);
+      assert(num_keys + num_put_keys <= keys_left);
+
+      // Apply the MultiGet operations
+      found += MultiGetRandom(options, num_keys, thread->rand, FLAGS_num,"");
+      ++multigets_done;
+      reads_done+=num_keys;
+      thread->stats.FinishedSingleOp(db_);
+
+      // Now do the puts
+      int i;
+      long k;
+      for(i=0; i<num_put_keys; ++i) {
+        k = thread->rand.Next() % FLAGS_num;
+        unique_ptr<char []> key = GenerateKeyFromInt(k);
+        Status s = db_->Put(write_options_, key.get(),
+                            gen.Generate(value_size_));
+        if (!s.ok()) {
+          fprintf(stderr, "put error: %s\n", s.ToString().c_str());
+          exit(1);
+        }
+        writes_done++;
+        thread->stats.FinishedSingleOp(db_);
+      }
+
+      keys_left -= (num_keys + num_put_keys);
+    }
+    char msg[100];
+    snprintf(msg, sizeof(msg),
+             "( reads:%ld writes:%ld total:%ld multiget_ops:%ld found:%ld)",
+             reads_done, writes_done, readwrites_, multigets_done, found);
+    thread->stats.AddMessage(msg);
+  }
+
   //
   // Read-modify-write for random keys
   //
+  // TODO: Implement MergeOperator tests here (Read-modify-write)
   void UpdateRandom(ThreadState* thread) {
     ReadOptions options(FLAGS_verify_checksum, true);
     RandomGenerator gen;
@@ -1646,7 +1960,7 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
 
   void HeapProfile() {
     char fname[100];
-    StorageOptions soptions;
+    EnvOptions soptions;
     snprintf(fname, sizeof(fname), "%s/heap-%04d", FLAGS_db, ++heap_counter_);
     unique_ptr<WritableFile> file;
     Status s = FLAGS_env->NewWritableFile(fname, &file, soptions);
@@ -1665,19 +1979,20 @@ unique_ptr<char []> GenerateKeyFromInt(int v)
 }  // namespace leveldb
 
 int main(int argc, char** argv) {
+  leveldb::InstallStackTraceHandler();
+
   FLAGS_write_buffer_size = leveldb::Options().write_buffer_size;
   FLAGS_max_write_buffer_number = leveldb::Options().max_write_buffer_number;
+  FLAGS_min_write_buffer_number_to_merge =
+    leveldb::Options().min_write_buffer_number_to_merge;
   FLAGS_open_files = leveldb::Options().max_open_files;
   FLAGS_max_background_compactions =
     leveldb::Options().max_background_compactions;
   // Compression test code above refers to FLAGS_block_size
   FLAGS_block_size = leveldb::Options().block_size;
-  FLAGS_use_os_buffer = leveldb::StorageOptions().UseOsBuffer();
-  FLAGS_use_fsreadahead = leveldb::StorageOptions().UseReadahead();
-  FLAGS_use_mmap_reads = leveldb::StorageOptions().UseMmapReads();
-  FLAGS_use_mmap_writes = leveldb::StorageOptions().UseMmapWrites();
-  FLAGS_use_readahead_compactions =
-    leveldb::StorageOptions().UseReadaheadCompactions();
+  FLAGS_use_os_buffer = leveldb::EnvOptions().use_os_buffer;
+  FLAGS_use_mmap_reads = leveldb::EnvOptions().use_mmap_reads;
+  FLAGS_use_mmap_writes = leveldb::EnvOptions().use_mmap_writes;
 
   std::string default_db_path;
 
@@ -1686,7 +2001,9 @@ int main(int argc, char** argv) {
     int n;
     long l;
     char junk;
-    char hdfsname[2048];
+    char buf[2048];
+    char str[512];
+
     if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
       FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
     } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
@@ -1724,7 +2041,11 @@ int main(int argc, char** argv) {
       FLAGS_write_buffer_size = n;
     } else if (sscanf(argv[i], "--max_write_buffer_number=%d%c", &n, &junk) == 1) {
       FLAGS_max_write_buffer_number = n;
-    } else if (sscanf(argv[i], "--max_background_compactions=%d%c", &n, &junk) == 1) {
+    } else if (sscanf(argv[i], "--min_write_buffer_number_to_merge=%d%c",
+               &n, &junk) == 1) {
+      FLAGS_min_write_buffer_number_to_merge = n;
+    } else if (sscanf(argv[i], "--max_background_compactions=%d%c", &n, &junk)
+               == 1) {
       FLAGS_max_background_compactions = n;
     } else if (sscanf(argv[i], "--cache_size=%ld%c", &l, &junk) == 1) {
       FLAGS_cache_size = l;
@@ -1762,20 +2083,16 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--mmap_write=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
       FLAGS_use_mmap_writes = n;
-    } else if (sscanf(argv[i], "--readahead=%d%c", &n, &junk) == 1 &&
-               (n == 0 || n == 1)) {
-      FLAGS_use_fsreadahead = n;
-    } else if (sscanf(argv[i], "--readahead_compactions=%d%c", &n, &junk) == 1&&
-               (n == 0 || n == 1)) {
-      FLAGS_use_readahead_compactions = n;
     } else if (sscanf(argv[i], "--statistics=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
       if (n == 1) {
-        dbstats.reset(new leveldb::DBStatistics());
+        dbstats = leveldb::CreateDBStatistics();
         FLAGS_statistics = true;
       }
     } else if (sscanf(argv[i], "--writes=%d%c", &n, &junk) == 1) {
       FLAGS_writes = n;
+    } else if (sscanf(argv[i], "--writes_per_second=%d%c", &n, &junk) == 1) {
+      FLAGS_writes_per_second = n;
     } else if (sscanf(argv[i], "--sync=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
       FLAGS_sync = n;
@@ -1800,8 +2117,8 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--get_approx=%d%c", &n, &junk) == 1 &&
         (n == 0 || n == 1)) {
       FLAGS_get_approx = n;
-    } else if (sscanf(argv[i], "--hdfs=%s", hdfsname) == 1) {
-      FLAGS_env  = new leveldb::HdfsEnv(hdfsname);
+    } else if (sscanf(argv[i], "--hdfs=%s", buf) == 1) {
+      FLAGS_env  = new leveldb::HdfsEnv(buf);
     } else if (sscanf(argv[i], "--num_levels=%d%c",
         &n, &junk) == 1) {
       FLAGS_num_levels = n;
@@ -1820,6 +2137,14 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i],"--level0_stop_writes_trigger=%d%c",
         &n, &junk) == 1) {
       FLAGS_level0_stop_writes_trigger = n;
+    } else if (sscanf(argv[i],
+                "--max_bytes_for_level_multiplier_additional=%s%c",
+                str, &junk) == 1) {
+      std::vector<std::string> fanout = leveldb::stringSplit(str, ',');
+      for (unsigned int j= 0; j < fanout.size(); j++) {
+        FLAGS_max_bytes_for_level_multiplier_additional.push_back(
+          std::stoi(fanout[j]));
+      }
     } else if (sscanf(argv[i],"--level0_slowdown_writes_trigger=%d%c",
         &n, &junk) == 1) {
       FLAGS_level0_slowdown_writes_trigger = n;
@@ -1854,13 +2179,16 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--stats_per_interval=%d%c", &n, &junk) == 1
         && (n == 0 || n == 1)) {
       FLAGS_stats_per_interval = n;
-    } else if (sscanf(argv[i], "--rate_limit=%lf%c", &d, &junk) == 1 &&
+    } else if (sscanf(argv[i], "--soft_rate_limit=%lf%c", &d, &junk) == 1 &&
+               d > 0.0) {
+      FLAGS_soft_rate_limit = d;
+    } else if (sscanf(argv[i], "--hard_rate_limit=%lf%c", &d, &junk) == 1 &&
                d > 1.0) {
-      FLAGS_rate_limit = d;
+      FLAGS_hard_rate_limit = d;
     } else if (sscanf(argv[i],
-               "--rate_limit_delay_milliseconds=%d%c", &n, &junk) == 1
-        && n > 0) {
-      FLAGS_rate_limit_delay_milliseconds = n;
+               "--rate_limit_delay_max_milliseconds=%d%c", &n, &junk) == 1
+        && n >= 0) {
+      FLAGS_rate_limit_delay_max_milliseconds = n;
     } else if (sscanf(argv[i], "--readonly=%d%c", &n, &junk) == 1 &&
         (n == 0 || n ==1 )) {
       FLAGS_read_only = n;
@@ -1875,6 +2203,35 @@ int main(int argc, char** argv) {
       FLAGS_source_compaction_factor = n;
     } else if (sscanf(argv[i], "--wal_ttl=%d%c", &n, &junk) == 1) {
       FLAGS_WAL_ttl_seconds = static_cast<uint64_t>(n);
+    } else if (sscanf(argv[i], "--advise_random_on_open=%d%c", &n, &junk) == 1
+               && (n == 0 || n ==1 )) {
+      FLAGS_advise_random_on_open = n;
+    } else if (sscanf(argv[i], "--compaction_fadvice=%s", buf) == 1) {
+      if (!strcasecmp(buf, "NONE"))
+        FLAGS_compaction_fadvice = leveldb::Options::NONE;
+      else if (!strcasecmp(buf, "NORMAL"))
+        FLAGS_compaction_fadvice = leveldb::Options::NORMAL;
+      else if (!strcasecmp(buf, "SEQUENTIAL"))
+        FLAGS_compaction_fadvice = leveldb::Options::SEQUENTIAL;
+      else if (!strcasecmp(buf, "WILLNEED"))
+        FLAGS_compaction_fadvice = leveldb::Options::WILLNEED;
+      else {
+        fprintf(stdout, "Unknown compaction fadvice:%s\n", buf);
+      }
+    } else if (sscanf(argv[i], "--use_adaptive_mutex=%d%c", &n, &junk) == 1
+               && (n == 0 || n ==1 )) {
+      FLAGS_use_adaptive_mutex = n;
+    } else if (sscanf(argv[i], "--use_multiget=%d%c", &n, &junk) == 1 &&
+               (n == 0 || n == 1)) {
+      FLAGS_use_multiget = n;
+    } else if (sscanf(argv[i], "--keys_per_multiget=%d%c",
+               &n, &junk) == 1) {
+      FLAGS_keys_per_multiget = n;
+    }  else if (sscanf(argv[i], "--bytes_per_sync=%ld%c", &l, &junk) == 1) {
+      FLAGS_bytes_per_sync = l;
+    } else if (sscanf(argv[i], "--filter_deletes=%d%c", &n, &junk)
+               == 1 && (n == 0 || n ==1 )) {
+      FLAGS_filter_deletes = n;
     } else {
       fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
       exit(1);

db/db_filesnapshot.cc

@@ -17,12 +17,14 @@ 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();
 }
 

db/db_impl.h

@@ -5,8 +5,10 @@
 #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"
@@ -16,6 +18,7 @@
 #include "port/port.h"
 #include "util/stats_logger.h"
 #include "memtablelist.h"
+#include "leveldb/memtablerep.h"
 
 #ifdef USE_SCRIBE
 #include "scribe/scribe_logger.h"
@@ -36,17 +39,32 @@ 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);
+  virtual void CompactRange(const Slice* begin, const Slice* end,
+                            bool reduce_level = false);
   virtual int NumberLevels();
   virtual int MaxMemCompactionLevel();
   virtual int Level0StopWriteTrigger();
@@ -61,7 +79,7 @@ class DBImpl : public DB {
 
   // 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.
@@ -87,6 +105,10 @@ 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_;
@@ -141,9 +163,10 @@ 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(MemTable* mem, VersionEdit* edit,
+  Status WriteLevel0Table(std::vector<MemTable*> &mems, 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);
 
@@ -197,11 +220,23 @@ class DBImpl : public DB {
   //  return true if
   bool CheckFileExistsAndEmpty(const LogFile& file);
 
-
   Status ReadFirstRecord(const LogFile& file, 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_;
@@ -216,6 +251,7 @@ 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_;
@@ -263,11 +299,21 @@ 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_;
@@ -319,6 +365,19 @@ 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_;
+
   static const int KEEP_LOG_FILE_NUM = 1000;
   std::string db_absolute_path_;
 
@@ -330,7 +389,13 @@ class DBImpl : public DB {
   SequenceNumber last_flushed_sequence_;
 
   // The options to access storage files
-  const StorageOptions storage_options_;
+  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&);
@@ -339,9 +404,20 @@ class DBImpl : public DB {
   // dump the delayed_writes_ to the log file and reset counter.
   void DelayLoggingAndReset();
 
-  // find the earliest snapshot where seqno is visible
-  inline SequenceNumber findEarliestVisibleSnapshot(SequenceNumber in,
-    std::vector<SequenceNumber>& snapshots);
+  // 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);
 };
 
 // Sanitize db options.  The caller should delete result.info_log if

db/db_impl_readonly.cc

@@ -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,11 +53,12 @@ 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)) {
+  if (mem->Get(lkey, value, &s, &merge_operands, options_)) {
   } else {
     Version::GetStats stats;
-    s = current->Get(options, lkey, value, &stats);
+    current->Get(options, lkey, value, &s, &merge_operands, &stats, options_);
   }
   return s;
 }
@@ -66,7 +67,7 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& options) {
   SequenceNumber latest_snapshot;
   Iterator* internal_iter = NewInternalIterator(options, &latest_snapshot);
   return NewDBIterator(
-      &dbname_, env_, user_comparator(), internal_iter,
+    &dbname_, env_, options_,  user_comparator(),internal_iter,
       (options.snapshot != nullptr
       ? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_
       : latest_snapshot));

db/db_impl_readonly.h

@@ -32,18 +32,26 @@ 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) {
+ virtual void CompactRange(const Slice* begin, const Slice* end,
+                           bool reduce_level = false) {
  }
  virtual Status DisableFileDeletions() {
    return Status::NotSupported("Not supported operation in read only mode.");

db/db_iter.cc

@@ -3,11 +3,15 @@
 // 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"
@@ -36,6 +40,7 @@ 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()
@@ -46,27 +51,34 @@ class DBIter: public Iterator {
     kReverse
   };
 
-  DBIter(const std::string* dbname, Env* env,
+  DBIter(const std::string* dbname, Env* env, const Options& options,
          const Comparator* cmp, Iterator* iter, SequenceNumber s)
       : dbname_(dbname),
         env_(env),
+        logger_(options.info_log),
         user_comparator_(cmp),
+        user_merge_operator_(options.merge_operator),
         iter_(iter),
         sequence_(s),
         direction_(kForward),
-        valid_(false) {
+        valid_(false),
+        current_entry_is_merged_(false),
+        statistics_(options.statistics) {
+    RecordTick(statistics_, NO_ITERATORS, 1);
   }
   virtual ~DBIter() {
+    RecordTick(statistics_, NO_ITERATORS, -1);
     delete iter_;
   }
   virtual bool Valid() const { return valid_; }
   virtual Slice key() const {
     assert(valid_);
-    return (direction_ == kForward) ? ExtractUserKey(iter_->key()) : saved_key_;
+    return saved_key_;
   }
   virtual Slice value() const {
     assert(valid_);
-    return (direction_ == kForward) ? iter_->value() : saved_value_;
+    return (direction_ == kForward && !current_entry_is_merged_) ?
+      iter_->value() : saved_value_;
   }
   virtual Status status() const {
     if (status_.ok()) {
@@ -83,9 +95,10 @@ class DBIter: public Iterator {
   virtual void SeekToLast();
 
  private:
-  void FindNextUserEntry(bool skipping, std::string* skip);
+  void FindNextUserEntry(bool skipping);
   void FindPrevUserEntry();
   bool ParseKey(ParsedInternalKey* key);
+  void MergeValuesNewToOld();
 
   inline void SaveKey(const Slice& k, std::string* dst) {
     dst->assign(k.data(), k.size());
@@ -102,15 +115,20 @@ 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&);
@@ -120,6 +138,8 @@ 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;
@@ -146,47 +166,152 @@ void DBIter::Next() {
     }
   }
 
-  // Temporarily use saved_key_ as storage for key to skip.
-  std::string* skip = &saved_key_;
-  SaveKey(ExtractUserKey(iter_->key()), skip);
-  FindNextUserEntry(true, skip);
+  // 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 */);
 }
 
-void DBIter::FindNextUserEntry(bool skipping, std::string* 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) {
   // 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_) {
-      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 {
+      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:
             valid_ = true;
-            saved_key_.clear();
+            SaveKey(ikey.user_key, &saved_key_);
             return;
-          }
-          break;
+          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;
+            // Go to a different state machine
+            MergeValuesNewToOld();
+            // TODO: what if !iter_->Valid()
+            return;
+            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() {
+  // TODO: Is there a way to unite with MergeHelper or other similar code?
+
+  // 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_->Merge(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_->Merge(ikey.user_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.
@@ -261,7 +386,7 @@ void DBIter::Seek(const Slice& target) {
       &saved_key_, ParsedInternalKey(target, sequence_, kValueTypeForSeek));
   iter_->Seek(saved_key_);
   if (iter_->Valid()) {
-    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
+    FindNextUserEntry(false /*not skipping */);
   } else {
     valid_ = false;
   }
@@ -272,13 +397,21 @@ void DBIter::SeekToFirst() {
   ClearSavedValue();
   iter_->SeekToFirst();
   if (iter_->Valid()) {
-    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
+    FindNextUserEntry(false /* not skipping */);
   } 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();
@@ -290,10 +423,12 @@ void DBIter::SeekToLast() {
 Iterator* NewDBIterator(
     const std::string* dbname,
     Env* env,
-    const Comparator* user_key_comparator,
+    const Options& options,
+    const Comparator *user_key_comparator,
     Iterator* internal_iter,
     const SequenceNumber& sequence) {
-  return new DBIter(dbname, env, user_key_comparator, internal_iter, sequence);
+  return new DBIter(dbname, env, options, user_key_comparator,
+                    internal_iter, sequence);
 }
 
 }  // namespace leveldb

db/db_iter.h

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

db/db_statistics.h

@@ -8,6 +8,7 @@
 #include <cassert>
 #include <stdlib.h>
 #include <vector>
+#include <memory>
 
 #include "leveldb/statistics.h"
 #include "util/histogram.h"
@@ -39,11 +40,6 @@ 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);
@@ -53,6 +49,11 @@ 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_

db/db_test.cc

@@ -12,14 +12,15 @@
 #include "db/version_set.h"
 #include "db/write_batch_internal.h"
 #include "leveldb/cache.h"
+#include "leveldb/compaction_filter.h"
 #include "leveldb/env.h"
-#include "leveldb/table.h"
+#include "table/table.h"
 #include "util/hash.h"
 #include "util/logging.h"
 #include "util/mutexlock.h"
 #include "util/testharness.h"
 #include "util/testutil.h"
-#include "util/storage_options.h"
+#include "utilities/merge_operators.h"
 
 namespace leveldb {
 
@@ -209,6 +210,7 @@ class DBTest {
   // Sequence of option configurations to try
   enum OptionConfig {
     kDefault,
+    kMergePut,
     kFilter,
     kUncompressed,
     kNumLevel_3,
@@ -216,10 +218,13 @@ class DBTest {
     kManifestFileSize,
     kCompactOnFlush,
     kPerfOptions,
+    kDeletesFilterFirst,
     kEnd
   };
   int option_config_;
 
+  std::shared_ptr<MergeOperator> merge_operator_;
+
  public:
   std::string dbname_;
   SpecialEnv* env_;
@@ -228,6 +233,7 @@ class DBTest {
   Options last_options_;
 
   DBTest() : option_config_(kDefault),
+             merge_operator_(MergeOperators::CreatePutOperator()),
              env_(new SpecialEnv(Env::Default())) {
     filter_policy_ = NewBloomFilterPolicy(10);
     dbname_ = test::TmpDir() + "/db_test";
@@ -259,6 +265,9 @@ class DBTest {
   Options CurrentOptions() {
     Options options;
     switch (option_config_) {
+      case kMergePut:
+        options.merge_operator = merge_operator_.get();
+        break;
       case kFilter:
         options.filter_policy = filter_policy_;
         break;
@@ -277,10 +286,13 @@ class DBTest {
         options.purge_redundant_kvs_while_flush = !options.purge_redundant_kvs_while_flush;
         break;
       case kPerfOptions:
-        options.rate_limit = 2.0;
-        options.rate_limit_delay_milliseconds = 2;
+        options.hard_rate_limit = 2.0;
+        options.rate_limit_delay_max_milliseconds = 2;
         // TODO -- test more options
         break;
+      case kDeletesFilterFirst:
+        options.filter_deletes = true;
+        break;
       default:
         break;
     }
@@ -326,8 +338,12 @@ class DBTest {
     return DB::Open(opts, dbname_, &db_);
   }
 
-  Status Put(const std::string& k, const std::string& v) {
-    return db_->Put(WriteOptions(), k, v);
+  Status Put(const Slice& k, const Slice& v) {
+    if (kMergePut == option_config_ ) {
+      return db_->Merge(WriteOptions(), k, v);
+    } else {
+      return db_->Put(WriteOptions(), k, v);
+    }
   }
 
   Status Delete(const std::string& k) {
@@ -400,6 +416,10 @@ class DBTest {
             case kTypeValue:
               result += iter->value().ToString();
               break;
+            case kTypeMerge:
+              // keep it the same as kTypeValue for testing kMergePut
+              result += iter->value().ToString();
+              break;
             case kTypeDeletion:
               result += "DEL";
               break;
@@ -574,6 +594,7 @@ TEST(DBTest, LevelLimitReopen) {
   }
 
   options.num_levels = 1;
+  options.max_bytes_for_level_multiplier_additional.resize(1, 1);
   Status s = TryReopen(&options);
   ASSERT_EQ(s.IsCorruption(), true);
   ASSERT_EQ(s.ToString(),
@@ -581,13 +602,14 @@ TEST(DBTest, LevelLimitReopen) {
             "more levels than options.num_levels");
 
   options.num_levels = 10;
+  options.max_bytes_for_level_multiplier_additional.resize(10, 1);
   ASSERT_OK(TryReopen(&options));
 }
 
 TEST(DBTest, Preallocation) {
   const std::string src = dbname_ + "/alloc_test";
   unique_ptr<WritableFile> srcfile;
-  const StorageOptions soptions;
+  const EnvOptions soptions;
   ASSERT_OK(env_->NewWritableFile(src, &srcfile, soptions));
   srcfile->SetPreallocationBlockSize(1024 * 1024);
 
@@ -750,6 +772,84 @@ TEST(DBTest, GetEncountersEmptyLevel) {
   } while (ChangeOptions());
 }
 
+// KeyMayExist can lead to a few false positives, but not false negatives.
+// To make test deterministic, use a much larger number of bits per key-20 than
+// bits in the key, so that false positives are eliminated
+TEST(DBTest, KeyMayExist) {
+  do {
+    ReadOptions ropts;
+    std::string value;
+    Options options = CurrentOptions();
+    options.filter_policy = NewBloomFilterPolicy(20);
+    Reopen(&options);
+
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));
+
+    ASSERT_OK(db_->Put(WriteOptions(), "a", "b"));
+    bool value_found = false;
+    ASSERT_TRUE(db_->KeyMayExist(ropts, "a", &value, &value_found));
+    ASSERT_TRUE(value_found);
+    ASSERT_EQ("b", value);
+
+    dbfull()->Flush(FlushOptions());
+    value.clear();
+    value_found = false;
+    ASSERT_TRUE(db_->KeyMayExist(ropts, "a", &value, &value_found));
+    ASSERT_TRUE(value_found);
+    ASSERT_EQ("b", value);
+
+    ASSERT_OK(db_->Delete(WriteOptions(), "a"));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));
+
+    dbfull()->Flush(FlushOptions());
+    dbfull()->CompactRange(nullptr, nullptr);
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, "a", &value));
+
+    ASSERT_OK(db_->Delete(WriteOptions(), "c"));
+    ASSERT_TRUE(!db_->KeyMayExist(ropts, "c", &value));
+
+    delete options.filter_policy;
+  } while (ChangeOptions());
+}
+
+// A delete is skipped for key if KeyMayExist(key) returns False
+// Tests Writebatch consistency and proper delete behaviour
+TEST(DBTest, FilterDeletes) {
+  Options options = CurrentOptions();
+  options.filter_policy = NewBloomFilterPolicy(20);
+  options.filter_deletes = true;
+  Reopen(&options);
+  WriteBatch batch;
+
+  batch.Delete("a");
+  dbfull()->Write(WriteOptions(), &batch);
+  ASSERT_EQ(AllEntriesFor("a"), "[ ]"); // Delete skipped
+  batch.Clear();
+
+  batch.Put("a", "b");
+  batch.Delete("a");
+  dbfull()->Write(WriteOptions(), &batch);
+  ASSERT_EQ(Get("a"), "NOT_FOUND");
+  ASSERT_EQ(AllEntriesFor("a"), "[ DEL, b ]"); // Delete issued
+  batch.Clear();
+
+  batch.Delete("c");
+  batch.Put("c", "d");
+  dbfull()->Write(WriteOptions(), &batch);
+  ASSERT_EQ(Get("c"), "d");
+  ASSERT_EQ(AllEntriesFor("c"), "[ d ]"); // Delete skipped
+  batch.Clear();
+
+  dbfull()->Flush(FlushOptions()); // A stray Flush
+
+  batch.Delete("c");
+  dbfull()->Write(WriteOptions(), &batch);
+  ASSERT_EQ(AllEntriesFor("c"), "[ DEL, d ]"); // Delete issued
+  batch.Clear();
+
+  delete options.filter_policy;
+}
+
 TEST(DBTest, IterEmpty) {
   Iterator* iter = db_->NewIterator(ReadOptions());
 
@@ -935,8 +1035,11 @@ TEST(DBTest, IterMultiWithDelete) {
     Iterator* iter = db_->NewIterator(ReadOptions());
     iter->Seek("c");
     ASSERT_EQ(IterStatus(iter), "c->vc");
-    iter->Prev();
-    ASSERT_EQ(IterStatus(iter), "a->va");
+    if (!CurrentOptions().merge_operator) {
+      // TODO: merge operator does not support backward iteration yet
+      iter->Prev();
+      ASSERT_EQ(IterStatus(iter), "a->va");
+    }
     delete iter;
   } while (ChangeOptions());
 }
@@ -1350,40 +1453,69 @@ TEST(DBTest, RepeatedWritesToSameKey) {
 // kvs during the compaction process.
 static int cfilter_count;
 static std::string NEW_VALUE = "NewValue";
-static bool keep_filter(void* arg, int level, const Slice& key,
-  const Slice& value, Slice** new_value) {
-  assert(arg == nullptr);
-  cfilter_count++;
-  return false;
-}
-static bool delete_filter(void*argv, int level, const Slice& key,
-  const Slice& value, Slice** new_value) {
-  assert(argv == nullptr);
-  cfilter_count++;
-  return true;
-}
-static bool change_filter(void*argv, int level, const Slice& key,
-  const Slice& value, Slice** new_value) {
-  assert(argv == (void*)100);
-  assert(new_value != nullptr);
-  *new_value = new Slice(NEW_VALUE);
-  return false;
-}
+
+class KeepFilter : public CompactionFilter {
+ public:
+  virtual bool Filter(int level, const Slice& key,
+                      const Slice& value, std::string* new_value,
+                      bool* value_changed) const override {
+    cfilter_count++;
+    return false;
+  }
+
+  virtual const char* Name() const override {
+    return "KeepFilter";
+  }
+
+};
+
+class DeleteFilter : public CompactionFilter {
+ public:
+  virtual bool Filter(int level, const Slice& key,
+                      const Slice& value, std::string* new_value,
+                      bool* value_changed) const override {
+    cfilter_count++;
+    return true;
+  }
+
+  virtual const char* Name() const override {
+    return "DeleteFilter";
+  }
+};
+
+class ChangeFilter : public CompactionFilter {
+ public:
+  explicit ChangeFilter(int argv) : argv_(argv) {}
+
+  virtual bool Filter(int level, const Slice& key,
+                      const Slice& value, std::string* new_value,
+                      bool* value_changed) const override {
+    assert(argv_ == 100);
+    assert(new_value != nullptr);
+    *new_value = NEW_VALUE;
+    *value_changed = true;
+    return false;
+  }
+
+  virtual const char* Name() const override {
+    return "ChangeFilter";
+  }
+
+ private:
+  const int argv_;
+};
 
 TEST(DBTest, CompactionFilter) {
   Options options = CurrentOptions();
   options.num_levels = 3;
   options.max_mem_compaction_level = 0;
-  options.CompactionFilter = keep_filter;
+  auto keep_filter = std::make_shared<KeepFilter>();
+  options.compaction_filter = keep_filter.get();
   Reopen(&options);
 
-  // Write 100K+1 keys, these are written to a few files
-  // in L0. We do this so that the current snapshot points
-  // to the 100001 key.The compaction filter is  not invoked
-  // on keys that are visible via a snapshot because we
-  // anyways cannot delete it.
+  // Write 100K keys, these are written to a few files in L0.
   const std::string value(10, 'x');
-  for (int i = 0; i < 100001; i++) {
+  for (int i = 0; i < 100000; i++) {
     char key[100];
     snprintf(key, sizeof(key), "B%010d", i);
     Put(key, value);
@@ -1410,6 +1542,7 @@ TEST(DBTest, CompactionFilter) {
   // has sequence number zero. The 100001st record
   // is at the tip of this snapshot and cannot
   // be zeroed out.
+  // TODO: figure out sequence number squashtoo
   int count = 0;
   int total = 0;
   Iterator* iter = dbfull()->TEST_NewInternalIterator();
@@ -1425,12 +1558,12 @@ TEST(DBTest, CompactionFilter) {
     }
     iter->Next();
   }
-  ASSERT_EQ(total, 100001);
+  ASSERT_EQ(total, 100000);
   ASSERT_EQ(count, 1);
   delete iter;
 
-  // overwrite all the 100K+1 keys once again.
-  for (int i = 0; i < 100001; i++) {
+  // overwrite all the 100K keys once again.
+  for (int i = 0; i < 100000; i++) {
     char key[100];
     snprintf(key, sizeof(key), "B%010d", i);
     Put(key, value);
@@ -1452,12 +1585,13 @@ TEST(DBTest, CompactionFilter) {
 
   // create a new database with the compaction
   // filter in such a way that it deletes all keys
-  options.CompactionFilter = delete_filter;
+  auto delete_filter = std::make_shared<DeleteFilter>();
+  options.compaction_filter = delete_filter.get();
   options.create_if_missing = true;
   DestroyAndReopen(&options);
 
   // write all the keys once again.
-  for (int i = 0; i < 100001; i++) {
+  for (int i = 0; i < 100000; i++) {
     char key[100];
     snprintf(key, sizeof(key), "B%010d", i);
     Put(key, value);
@@ -1480,10 +1614,7 @@ TEST(DBTest, CompactionFilter) {
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   ASSERT_EQ(NumTableFilesAtLevel(1), 0);
 
-  // Scan the entire database to ensure that only the
-  // 100001th key is left in the db. The 100001th key
-  // is part of the default-most-current snapshot and
-  // cannot be deleted.
+  // Scan the entire database to ensure that nothing is left
   iter = db_->NewIterator(ReadOptions());
   iter->SeekToFirst();
   count = 0;
@@ -1491,12 +1622,14 @@ TEST(DBTest, CompactionFilter) {
     count++;
     iter->Next();
   }
-  ASSERT_EQ(count, 1);
+  ASSERT_EQ(count, 0);
   delete iter;
 
   // The sequence number of the remaining record
   // is not zeroed out even though it is at the
   // level Lmax because this record is at the tip
+  // TODO: remove the following or design a different
+  // test
   count = 0;
   iter = dbfull()->TEST_NewInternalIterator();
   iter->SeekToFirst();
@@ -1508,7 +1641,7 @@ TEST(DBTest, CompactionFilter) {
     count++;
     iter->Next();
   }
-  ASSERT_EQ(count, 1);
+  ASSERT_EQ(count, 0);
   delete iter;
 }
 
@@ -1516,8 +1649,8 @@ TEST(DBTest, CompactionFilterWithValueChange) {
   Options options = CurrentOptions();
   options.num_levels = 3;
   options.max_mem_compaction_level = 0;
-  options.compaction_filter_args = (void *)100;
-  options.CompactionFilter = change_filter;
+  auto change_filter = std::make_shared<ChangeFilter>(100);
+  options.compaction_filter = change_filter.get();
   Reopen(&options);
 
   // Write 100K+1 keys, these are written to a few files
@@ -2331,7 +2464,7 @@ TEST(DBTest, BloomFilter) {
 
 TEST(DBTest, SnapshotFiles) {
   Options options = CurrentOptions();
-  const StorageOptions soptions;
+  const EnvOptions soptions;
   options.write_buffer_size = 100000000;        // Large write buffer
   Reopen(&options);
 
@@ -2543,20 +2676,20 @@ TEST(DBTest, CompactOnFlush) {
   db_->ReleaseSnapshot(snapshot1);
 }
 
-void ListLogFiles(Env* env,
-                  const std::string& path,
-                  std::vector<uint64_t>* logFiles) {
+std::vector<std::uint64_t> ListLogFiles(Env* env, const std::string& path) {
   std::vector<std::string> files;
+  std::vector<uint64_t> log_files;
   env->GetChildren(path, &files);
   uint64_t number;
   FileType type;
   for (size_t i = 0; i < files.size(); ++i) {
     if (ParseFileName(files[i], &number, &type)) {
       if (type == kLogFile) {
-        logFiles->push_back(number);
+        log_files.push_back(number);
       }
     }
   }
+  return std::move(log_files);
 }
 
 TEST(DBTest, WALArchival) {
@@ -2575,42 +2708,52 @@ TEST(DBTest, WALArchival) {
   std::string archiveDir = ArchivalDirectory(dbname_);
 
   for (int i = 0; i < 10; ++i) {
-
     for (int j = 0; j < 10; ++j) {
       ASSERT_OK(Put(Key(10*i+j), value));
     }
 
-    std::vector<uint64_t> logFiles;
-    ListLogFiles(env_, dbname_, &logFiles);
+    std::vector<uint64_t> logFiles = ListLogFiles(env_, dbname_);
 
     options.create_if_missing = false;
     Reopen(&options);
 
-    std::vector<uint64_t> logs;
-    ListLogFiles(env_, archiveDir, &logs);
+    std::vector<uint64_t> logs = ListLogFiles(env_, archiveDir);
     std::set<uint64_t> archivedFiles(logs.begin(), logs.end());
 
-    for (std::vector<uint64_t>::iterator it = logFiles.begin();
-         it != logFiles.end();
-         ++it) {
-      ASSERT_TRUE(archivedFiles.find(*it) != archivedFiles.end());
+    for (auto& log : logFiles) {
+      ASSERT_TRUE(archivedFiles.find(log) != archivedFiles.end());
     }
   }
 
-  // REOPEN database with 0 TTL. all files should have been deleted.
-  std::vector<uint64_t> logFiles;
-  ListLogFiles(env_, archiveDir, &logFiles);
+  std::vector<uint64_t> logFiles = ListLogFiles(env_, archiveDir);
   ASSERT_TRUE(logFiles.size() > 0);
   options.WAL_ttl_seconds = 1;
   env_->SleepForMicroseconds(2*1000*1000);
   Reopen(&options);
 
-  logFiles.clear();
-  ListLogFiles(env_, archiveDir, &logFiles);
+  logFiles = ListLogFiles(env_, archiveDir);
   ASSERT_TRUE(logFiles.size() == 0);
 
 }
 
+TEST(DBTest, WALClear) {
+  Options options = CurrentOptions();
+  options.create_if_missing = true;
+  options.WAL_ttl_seconds = 1;
+
+  for (int j = 0; j < 10; ++j)
+  for (int i = 0; i < 10; ++i)
+    ASSERT_OK(Put(Key(10*i+j), DummyString(1024)));
+  Reopen(&options);
+  std::string archive_dir = ArchivalDirectory(dbname_);
+  std::vector<std::uint64_t> log_files = ListLogFiles(env_, archive_dir);
+  ASSERT_TRUE(!log_files.empty());
+  env_->SleepForMicroseconds(2 * 1000 * 1000);
+  dbfull()->TEST_PurgeObsoleteteWAL();
+  log_files = ListLogFiles(env_, archive_dir);
+  ASSERT_TRUE(log_files.empty());
+}
+
 void ExpectRecords(
   const int expected_no_records,
   std::unique_ptr<TransactionLogIterator>& iter) {
@@ -2639,7 +2782,7 @@ TEST(DBTest, TransactionLogIterator) {
     ExpectRecords(3, iter);
   }
   Reopen(&options);
-  {
+    env_->SleepForMicroseconds(2 * 1000 * 1000);{
     Put("key4", DummyString(1024));
     Put("key5", DummyString(1024));
     Put("key6", DummyString(1024));
@@ -2818,7 +2961,7 @@ static void MTThreadBody(void* arg) {
       // We add some padding for force compactions.
       snprintf(valbuf, sizeof(valbuf), "%d.%d.%-1000d",
                key, id, static_cast<int>(counter));
-      ASSERT_OK(db->Put(WriteOptions(), Slice(keybuf), Slice(valbuf)));
+      ASSERT_OK(t->state->test->Put(Slice(keybuf), Slice(valbuf)));
     } else {
       // Read a value and verify that it matches the pattern written above.
       Status s = db->Get(ReadOptions(), Slice(keybuf), &value);
@@ -2891,13 +3034,32 @@ class ModelDB: public DB {
   virtual Status Put(const WriteOptions& o, const Slice& k, const Slice& v) {
     return DB::Put(o, k, v);
   }
+  virtual Status Merge(const WriteOptions& o, const Slice& k, const Slice& v) {
+    return DB::Merge(o, k, v);
+  }
   virtual Status Delete(const WriteOptions& o, const Slice& key) {
     return DB::Delete(o, key);
   }
   virtual Status Get(const ReadOptions& options,
                      const Slice& key, std::string* value) {
-    assert(false);      // Not implemented
-    return Status::NotFound(key);
+    return Status::NotSupported(key);
+  }
+
+  virtual std::vector<Status> MultiGet(const ReadOptions& options,
+                                       const std::vector<Slice>& keys,
+                                       std::vector<std::string>* values) {
+    std::vector<Status> s(keys.size(),
+                          Status::NotSupported("Not implemented."));
+    return s;
+  }
+  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; // Not Supported directly
   }
   virtual Iterator* NewIterator(const ReadOptions& options) {
     if (options.snapshot == nullptr) {
@@ -2926,6 +3088,10 @@ class ModelDB: public DB {
       virtual void Put(const Slice& key, const Slice& value) {
         (*map_)[key.ToString()] = value.ToString();
       }
+      virtual void Merge(const Slice& key, const Slice& value) {
+        // ignore merge for now
+        //(*map_)[key.ToString()] = value.ToString();
+      }
       virtual void Delete(const Slice& key) {
         map_->erase(key.ToString());
       }
@@ -2943,7 +3109,8 @@ class ModelDB: public DB {
       sizes[i] = 0;
     }
   }
-  virtual void CompactRange(const Slice* start, const Slice* end) {
+  virtual void CompactRange(const Slice* start, const Slice* end,
+                            bool reduce_level ) {
   }
 
   virtual int NumberLevels()
@@ -3076,6 +3243,9 @@ static bool CompareIterators(int step,
 TEST(DBTest, Randomized) {
   Random rnd(test::RandomSeed());
   do {
+    if (CurrentOptions().filter_deletes) {
+      ChangeOptions(); // DBTest.Randomized not suited for filter_deletes
+    }
     ModelDB model(CurrentOptions());
     const int N = 10000;
     const Snapshot* model_snap = nullptr;
@@ -3141,6 +3311,61 @@ TEST(DBTest, Randomized) {
   } while (ChangeOptions());
 }
 
+TEST(DBTest, MultiGetSimple) {
+  ASSERT_OK(db_->Put(WriteOptions(),"k1","v1"));
+  ASSERT_OK(db_->Put(WriteOptions(),"k2","v2"));
+  ASSERT_OK(db_->Put(WriteOptions(),"k3","v3"));
+  ASSERT_OK(db_->Put(WriteOptions(),"k4","v4"));
+  ASSERT_OK(db_->Delete(WriteOptions(),"k4"));
+  ASSERT_OK(db_->Put(WriteOptions(),"k5","v5"));
+  ASSERT_OK(db_->Delete(WriteOptions(),"no_key"));
+
+  std::vector<Slice> keys(6);
+  keys[0] = "k1";
+  keys[1] = "k2";
+  keys[2] = "k3";
+  keys[3] = "k4";
+  keys[4] = "k5";
+  keys[5] = "no_key";
+
+  std::vector<std::string> values(20,"Temporary data to be overwritten");
+
+  std::vector<Status> s =  db_->MultiGet(ReadOptions(),keys,&values);
+  ASSERT_EQ(values.size(),keys.size());
+  ASSERT_EQ(values[0], "v1");
+  ASSERT_EQ(values[1], "v2");
+  ASSERT_EQ(values[2], "v3");
+  ASSERT_EQ(values[4], "v5");
+
+  ASSERT_OK(s[0]);
+  ASSERT_OK(s[1]);
+  ASSERT_OK(s[2]);
+  ASSERT_TRUE(s[3].IsNotFound());
+  ASSERT_OK(s[4]);
+  ASSERT_TRUE(s[5].IsNotFound());
+}
+
+TEST(DBTest, MultiGetEmpty) {
+  // Empty Key Set
+  std::vector<Slice> keys;
+  std::vector<std::string> values;
+  std::vector<Status> s = db_->MultiGet(ReadOptions(),keys,&values);
+  ASSERT_EQ((int)s.size(),0);
+
+  // Empty Database, Empty Key Set
+  DestroyAndReopen();
+  s = db_->MultiGet(ReadOptions(), keys, &values);
+  ASSERT_EQ((int)s.size(),0);
+
+  // Empty Database, Search for Keys
+  keys.resize(2);
+  keys[0] = "a";
+  keys[1] = "b";
+  s = db_->MultiGet(ReadOptions(),keys,&values);
+  ASSERT_EQ((int)s.size(), 2);
+  ASSERT_TRUE(s[0].IsNotFound() && s[1].IsNotFound());
+}
+
 std::string MakeKey(unsigned int num) {
   char buf[30];
   snprintf(buf, sizeof(buf), "%016u", num);
@@ -3168,7 +3393,7 @@ void BM_LogAndApply(int iters, int num_base_files) {
 
   InternalKeyComparator cmp(BytewiseComparator());
   Options options;
-  StorageOptions sopt;
+  EnvOptions sopt;
   VersionSet vset(dbname, &options, sopt, nullptr, &cmp);
   ASSERT_OK(vset.Recover());
   VersionEdit vbase(vset.NumberLevels());

db/dbformat.cc

@@ -44,7 +44,7 @@ std::string InternalKey::DebugString(bool hex) const {
 }
 
 const char* InternalKeyComparator::Name() const {
-  return "leveldb.InternalKeyComparator";
+  return name_.c_str();
 }
 
 int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {

db/dbformat.h

@@ -24,7 +24,8 @@ class InternalKey;
 // data structures.
 enum ValueType {
   kTypeDeletion = 0x0,
-  kTypeValue = 0x1
+  kTypeValue = 0x1,
+  kTypeMerge = 0x2
 };
 // kValueTypeForSeek defines the ValueType that should be passed when
 // constructing a ParsedInternalKey object for seeking to a particular
@@ -32,7 +33,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 = kTypeValue;
+static const ValueType kValueTypeForSeek = kTypeMerge;
 
 // We leave eight bits empty at the bottom so a type and sequence#
 // can be packed together into 64-bits.
@@ -85,8 +86,13 @@ 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) { }
+  explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
+    name_("leveldb.InternalKeyComparator:" +
+          std::string(user_comparator_->Name())) {
+  }
+
   virtual const char* Name() const;
   virtual int Compare(const Slice& a, const Slice& b) const;
   virtual void FindShortestSeparator(
@@ -154,7 +160,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>(kTypeValue));
+  return (c <= static_cast<unsigned char>(kValueTypeForSeek));
 }
 
 // Update the sequence number in the internal key

db/memtable.cc

@@ -3,10 +3,14 @@
 // 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 {
@@ -18,22 +22,28 @@ static Slice GetLengthPrefixedSlice(const char* data) {
   return Slice(p, len);
 }
 
-MemTable::MemTable(const InternalKeyComparator& cmp, int numlevel)
+MemTable::MemTable(const InternalKeyComparator& cmp,
+                   std::shared_ptr<MemTableRepFactory> table_factory,
+                   int numlevel,
+                   const Options& options)
     : comparator_(cmp),
       refs_(0),
-      table_(comparator_, &arena_),
+      arena_impl_(options.arena_block_size),
+      table_(table_factory->CreateMemTableRep(comparator_, &arena_impl_)),
       flush_in_progress_(false),
       flush_completed_(false),
       file_number_(0),
       edit_(numlevel),
-      first_seqno_(0) {
-}
+      first_seqno_(0),
+      mem_logfile_number_(0) { }
 
 MemTable::~MemTable() {
   assert(refs_ == 0);
 }
 
-size_t MemTable::ApproximateMemoryUsage() { return arena_.MemoryUsage(); }
+size_t MemTable::ApproximateMemoryUsage() {
+  return arena_impl_.ApproximateMemoryUsage();
+}
 
 int MemTable::KeyComparator::operator()(const char* aptr, const char* bptr)
     const {
@@ -55,24 +65,27 @@ static const char* EncodeKey(std::string* scratch, const Slice& target) {
 
 class MemTableIterator: public Iterator {
  public:
-  explicit MemTableIterator(MemTable::Table* table) : iter_(table) { }
+  explicit MemTableIterator(MemTableRep* table)
+    : iter_(table->GetIterator()) { }
 
-  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:
-  MemTable::Table::Iterator iter_;
+  std::shared_ptr<MemTableRep::Iterator> iter_;
   std::string tmp_;       // For passing to EncodeKey
 
   // No copying allowed
@@ -81,7 +94,7 @@ class MemTableIterator: public Iterator {
 };
 
 Iterator* MemTable::NewIterator() {
-  return new MemTableIterator(&table_);
+  return new MemTableIterator(table_.get());
 }
 
 void MemTable::Add(SequenceNumber s, ValueType type,
@@ -98,7 +111,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_.Allocate(encoded_len);
+  char* buf = arena_impl_.Allocate(encoded_len);
   char* p = EncodeVarint32(buf, internal_key_size);
   memcpy(p, key.data(), key_size);
   p += key_size;
@@ -107,7 +120,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_);
@@ -116,11 +129,21 @@ void MemTable::Add(SequenceNumber s, ValueType type,
   }
 }
 
-bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
+bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
+                   std::deque<std::string>* operands, const Options& options) {
   Slice memkey = key.memtable_key();
-  Table::Iterator iter(&table_);
-  iter.Seek(memkey.data());
-  if (iter.Valid()) {
+  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;
+  auto logger = options.info_log;
+  std::string merge_result;
+
+  for (; iter->Valid(); iter->Next()) {
     // entry format is:
     //    klength  varint32
     //    userkey  char[klength-8]
@@ -130,7 +153,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(
@@ -141,15 +164,63 @@ 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);
-          value->assign(v.data(), v.size());
+          *s = Status::OK();
+          if (merge_in_progress) {
+            assert(merge_operator);
+            if (!merge_operator->Merge(key.user_key(), &v, *operands,
+                                       value, logger.get())) {
+              *s = Status::Corruption("Error: Could not perform merge.");
+            }
+          } else {
+            value->assign(v.data(), v.size());
+          }
           return true;
         }
-        case kTypeDeletion:
-          *s = Status::NotFound(Slice());
+        case kTypeDeletion: {
+          if (merge_in_progress) {
+            assert(merge_operator);
+            *s = Status::OK();
+            if (!merge_operator->Merge(key.user_key(), nullptr, *operands,
+                                       value, logger.get())) {
+              *s = Status::Corruption("Error: Could not perform merge.");
+            }
+          } else {
+            *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;
+        }
       }
+    } 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;
 }
 

db/memtable.h

@@ -6,24 +6,35 @@
 #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 "util/arena.h"
+#include "leveldb/memtablerep.h"
+#include "util/arena_impl.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,
-                    int numlevel = 7);
+  explicit MemTable(
+    const InternalKeyComparator& comparator,
+    std::shared_ptr<MemTableRepFactory> table_factory,
+    int numlevel = 7,
+    const Options& options = Options());
 
   // Increase reference count.
   void Ref() { ++refs_; }
@@ -62,8 +73,13 @@ 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);
+  bool Get(const LookupKey& key, std::string* value, Status* s,
+           std::deque<std::string>* operands, const Options& options);
 
   // Returns the edits area that is needed for flushing the memtable
   VersionEdit* GetEdits() { return &edit_; }
@@ -72,24 +88,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_;
-  Arena arena_;
-  Table table_;
+  ArenaImpl arena_impl_;
+  shared_ptr<MemTableRep> table_;
 
   // These are used to manage memtable flushes to storage
   bool flush_in_progress_; // started the flush
@@ -103,6 +119,9 @@ 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&);

db/memtablelist.cc

@@ -43,17 +43,16 @@ int MemTableList::size() {
 
 // Returns true if there is at least one memtable on which flush has
 // not yet started.
-bool MemTableList::IsFlushPending() {
-  if (num_flush_not_started_ > 0) {
+bool MemTableList::IsFlushPending(int min_write_buffer_number_to_merge) {
+  if (num_flush_not_started_ >= min_write_buffer_number_to_merge) {
     assert(imm_flush_needed.NoBarrier_Load() != nullptr);
     return true;
   }
   return false;
 }
 
-// Returns the earliest memtable that needs to be flushed.
-// Returns null, if no such memtable exist.
-MemTable* MemTableList::PickMemtableToFlush() {
+// Returns the memtables that need to be flushed.
+void MemTableList::PickMemtablesToFlush(std::vector<MemTable*>* ret) {
   for (list<MemTable*>::reverse_iterator it = memlist_.rbegin();
        it != memlist_.rend(); it++) {
     MemTable* m = *it;
@@ -64,37 +63,48 @@ MemTable* MemTableList::PickMemtableToFlush() {
         imm_flush_needed.Release_Store(nullptr);
       }
       m->flush_in_progress_ = true; // flushing will start very soon
-      return m;
+      ret->push_back(m);
     }
   }
-  return nullptr;
 }
 
 // Record a successful flush in the manifest file
-Status MemTableList::InstallMemtableFlushResults(MemTable* m,
+Status MemTableList::InstallMemtableFlushResults(
+                      const std::vector<MemTable*> &mems,
                       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()) {
-    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);
+    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);
+    }
     return flushStatus;
   }
 
   // flush was sucessful
-  m->flush_completed_ = true;
-  m->file_number_ = file_number;
+  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;
+  }
 
   // if some other thread is already commiting, then return
   Status s;
@@ -106,12 +116,15 @@ Status MemTableList::InstallMemtableFlushResults(MemTable* m,
   commit_in_progress_ = true;
 
   // scan all memtables from the earliest, and commit those
-  // (in that order) that have finished flushing.
-  while (!memlist_.empty()) {
-    m = memlist_.back(); // get the last element
+  // (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
     if (!m->flush_completed_) {
       break;
     }
+    first = true;
+
     Log(info_log,
         "Level-0 commit table #%llu: started",
         (unsigned long long)m->file_number_);
@@ -119,33 +132,39 @@ Status MemTableList::InstallMemtableFlushResults(MemTable* m,
     // this can release and reacquire the mutex.
     s = vset->LogAndApply(&m->edit_, mu);
 
-    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);
+    // 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);
 
-      // 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;
-    }
+        // 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);
   }
   commit_in_progress_ = false;
   return s;
@@ -174,10 +193,13 @@ size_t MemTableList::ApproximateMemoryUsage() {
 
 // Search all the memtables starting from the most recent one.
 // Return the most recent value found, if any.
-bool MemTableList::Get(const LookupKey& key, std::string* value, Status* s) {
+// 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 (list<MemTable*>::iterator it = memlist_.begin();
        it != memlist_.end(); ++it) {
-    if ((*it)->Get(key, value, s)) {
+    if ((*it)->Get(key, value, s, operands, options)) {
       return true;
     }
   }

db/memtablelist.h

@@ -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 refeernces to all the immutable memtables.
+// This class stores references 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,14 +49,13 @@ class MemTableList {
 
   // Returns true if there is at least one memtable on which flush has
   // not yet started.
-  bool IsFlushPending();
+  bool IsFlushPending(int min_write_buffer_number_to_merge);
 
-  // Returns the earliest memtable that needs to be flushed.
-  // Returns null, if no such memtable exist.
-  MemTable* PickMemtableToFlush();
+  // Returns the earliest memtables that needs to be flushed.
+  void PickMemtablesToFlush(std::vector<MemTable*>* mems);
 
   // Commit a successful flush in the manifest file
-  Status InstallMemtableFlushResults(MemTable* m,
+  Status InstallMemtableFlushResults(const std::vector<MemTable*> &m,
                       VersionSet* vset, Status flushStatus,
                       port::Mutex* mu, Logger* info_log,
                       uint64_t file_number,
@@ -71,7 +70,8 @@ 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);
+  bool Get(const LookupKey& key, std::string* value, Status* s,
+           std::deque<std::string>* operands, const Options& options);
 
   // Returns the list of underlying memtables.
   void GetMemTables(std::vector<MemTable*>* list);

db/merge_helper.cc

@@ -0,0 +1,187 @@
+#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) {
+  // 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_->Merge(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);
+      }
+
+      // 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_->Merge(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);
+      }
+
+      // 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_->Merge(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 {
+      // Do nothing if not success_. Leave keys() and operands() as they are.
+    }
+  }
+}
+
+} // namespace leveldb

db/merge_helper.h

@@ -0,0 +1,97 @@
+#ifndef MERGE_HELPER_H
+#define MERGE_HELPER_H
+
+#include "db/dbformat.h"
+#include "leveldb/slice.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);
+
+  // 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

db/merge_operator.cc

@@ -0,0 +1,51 @@
+/**
+ * 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::Merge(
+    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

db/merge_test.cc

@@ -0,0 +1,271 @@
+#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;
+
+auto mergeOperator = MergeOperators::CreateUInt64AddOperator();
+
+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 = mergeOperator.get();
+  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;
+}

db/repair.cc

@@ -105,7 +105,7 @@ class Repairer {
   std::vector<uint64_t> logs_;
   std::vector<TableInfo> tables_;
   uint64_t next_file_number_;
-  const StorageOptions storage_options_;
+  const EnvOptions storage_options_;
 
   Status FindFiles() {
     std::vector<std::string> filenames;
@@ -191,7 +191,8 @@ class Repairer {
     std::string scratch;
     Slice record;
     WriteBatch batch;
-    MemTable* mem = new MemTable(icmp_, options_.num_levels);
+    MemTable* mem = new MemTable(icmp_, options_.memtable_factory,
+      options_.num_levels);
     mem->Ref();
     int counter = 0;
     while (reader.ReadRecord(&record, &scratch)) {

db/skiplist.h

@@ -31,13 +31,10 @@
 #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:

db/skiplist_test.cc

@@ -5,7 +5,7 @@
 #include "db/skiplist.h"
 #include <set>
 #include "leveldb/env.h"
-#include "util/arena.h"
+#include "util/arena_impl.h"
 #include "util/hash.h"
 #include "util/random.h"
 #include "util/testharness.h"
@@ -29,9 +29,9 @@ struct TestComparator {
 class SkipTest { };
 
 TEST(SkipTest, Empty) {
-  Arena arena;
+  ArenaImpl arena_impl;
   TestComparator cmp;
-  SkipList<Key, TestComparator> list(cmp, &arena);
+  SkipList<Key, TestComparator> list(cmp, &arena_impl);
   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;
-  Arena arena;
+  ArenaImpl arena_impl;
   TestComparator cmp;
-  SkipList<Key, TestComparator> list(cmp, &arena);
+  SkipList<Key, TestComparator> list(cmp, &arena_impl);
   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_;
 
-  Arena arena_;
+  ArenaImpl arena_impl_;
 
   // 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_) { }
+  ConcurrentTest() : list_(TestComparator(), &arena_impl_) { }
 
   // REQUIRES: External synchronization
   void WriteStep(Random* rnd) {

db/skiplistrep.h

@@ -0,0 +1,102 @@
+#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_

db/snapshot.h

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

db/table_cache.cc

@@ -6,9 +6,10 @@
 
 #include "db/filename.h"
 
-#include "leveldb/table.h"
 #include "leveldb/statistics.h"
+#include "table/table.h"
 #include "util/coding.h"
+#include "util/stop_watch.h"
 
 namespace leveldb {
 
@@ -25,7 +26,7 @@ static void UnrefEntry(void* arg1, void* arg2) {
 
 TableCache::TableCache(const std::string& dbname,
                        const Options* options,
-                       const StorageOptions& storage_options,
+                       const EnvOptions& storage_options,
                        int entries)
     : env_(options->env),
       dbname_(dbname),
@@ -38,15 +39,19 @@ TableCache::~TableCache() {
 
 Status TableCache::FindTable(const EnvOptions& toptions,
                              uint64_t file_number, uint64_t file_size,
-                             Cache::Handle** handle, bool* tableIO) {
+                             Cache::Handle** handle, bool* table_io,
+                             const bool no_io) {
   Status s;
   char buf[sizeof(file_number)];
   EncodeFixed64(buf, file_number);
   Slice key(buf, sizeof(buf));
   *handle = cache_->Lookup(key);
   if (*handle == nullptr) {
-    if (tableIO != nullptr) {
-      *tableIO = true;    // we had to do IO from storage
+    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
     }
     std::string fname = TableFileName(dbname_, file_number);
     unique_ptr<RandomAccessFile> file;
@@ -54,6 +59,10 @@ Status TableCache::FindTable(const EnvOptions& toptions,
     s = env_->NewRandomAccessFile(fname, &file, toptions);
     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);
     }
 
@@ -74,7 +83,8 @@ Iterator* TableCache::NewIterator(const ReadOptions& options,
                                   const EnvOptions& toptions,
                                   uint64_t file_number,
                                   uint64_t file_size,
-                                  Table** tableptr) {
+                                  Table** tableptr,
+                                  bool for_compaction) {
   if (tableptr != nullptr) {
     *tableptr = nullptr;
   }
@@ -92,6 +102,11 @@ Iterator* TableCache::NewIterator(const ReadOptions& options,
   if (tableptr != nullptr) {
     *tableptr = table;
   }
+
+  if (for_compaction) {
+    table->SetupForCompaction();
+  }
+
   return result;
 }
 
@@ -100,16 +115,22 @@ Status TableCache::Get(const ReadOptions& options,
                        uint64_t file_size,
                        const Slice& k,
                        void* arg,
-                       void (*saver)(void*, const Slice&, const Slice&, bool),
-                       bool* tableIO) {
+                       bool (*saver)(void*, const Slice&, const Slice&, bool),
+                       bool* table_io,
+                       void (*mark_key_may_exist)(void*),
+                       const bool no_io) {
   Cache::Handle* handle = nullptr;
   Status s = FindTable(storage_options_, file_number, file_size,
-                       &handle, tableIO);
+                       &handle, table_io, no_io);
   if (s.ok()) {
     Table* t =
       reinterpret_cast<Table*>(cache_->Value(handle));
-    s = t->InternalGet(options, k, arg, saver);
+    s = t->InternalGet(options, k, arg, saver, mark_key_may_exist, no_io);
     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;
 }

db/table_cache.h

@@ -12,9 +12,8 @@
 #include "db/dbformat.h"
 #include "leveldb/env.h"
 #include "leveldb/cache.h"
-#include "leveldb/table.h"
 #include "port/port.h"
-#include "util/storage_options.h"
+#include "table/table.h"
 
 namespace leveldb {
 
@@ -23,7 +22,7 @@ class Env;
 class TableCache {
  public:
   TableCache(const std::string& dbname, const Options* options,
-             const StorageOptions& storage_options, int entries);
+             const EnvOptions& storage_options, int entries);
   ~TableCache();
 
   // Return an iterator for the specified file number (the corresponding
@@ -37,17 +36,21 @@ class TableCache {
                         const EnvOptions& toptions,
                         uint64_t file_number,
                         uint64_t file_size,
-                        Table** tableptr = nullptr);
+                        Table** tableptr = nullptr,
+                        bool for_compaction = false);
 
   // If a seek to internal key "k" in specified file finds an entry,
-  // call (*handle_result)(arg, found_key, found_value).
+  // call (*handle_result)(arg, found_key, found_value) repeatedly until
+  // it returns false.
   Status Get(const ReadOptions& options,
              uint64_t file_number,
              uint64_t file_size,
              const Slice& k,
              void* arg,
-             void (*handle_result)(void*, const Slice&, const Slice&, bool),
-             bool* tableIO);
+             bool (*handle_result)(void*, const Slice&, const Slice&, bool),
+             bool* table_io,
+             void (*mark_key_may_exist)(void*) = nullptr,
+             const bool no_io = false);
 
   // Evict any entry for the specified file number
   void Evict(uint64_t file_number);
@@ -56,12 +59,12 @@ class TableCache {
   Env* const env_;
   const std::string dbname_;
   const Options* options_;
-  const StorageOptions& storage_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* tableIO = nullptr);
+  Status FindTable(const EnvOptions& toptions, uint64_t file_number,
+                   uint64_t file_size, Cache::Handle**, bool* table_io=nullptr,
+                   const bool no_io = false);
 };
 
 }  // namespace leveldb

db/transaction_log_iterator_impl.cc

@@ -7,30 +7,24 @@ namespace leveldb {
 TransactionLogIteratorImpl::TransactionLogIteratorImpl(
                            const std::string& dbname,
                            const Options* options,
-                           const StorageOptions& soptions,
+                           const EnvOptions& soptions,
                            SequenceNumber& seq,
-                           std::vector<LogFile>* files,
+                           std::unique_ptr<std::vector<LogFile>> files,
                            SequenceNumber const * const lastFlushedSequence) :
   dbname_(dbname),
   options_(options),
   soptions_(soptions),
   startingSequenceNumber_(seq),
-  files_(files),
+  files_(std::move(files)),
   started_(false),
   isValid_(false),
   currentFileIndex_(0),
   lastFlushedSequence_(lastFlushedSequence) {
-  assert(files_ != nullptr);
+  assert(files_.get() != 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;
+  reporter_.env = options_->env;
+  reporter_.info_log = options_->info_log.get();
 }
 
 Status TransactionLogIteratorImpl::OpenLogFile(
@@ -73,8 +67,7 @@ bool TransactionLogIteratorImpl::Valid() {
 }
 
 void TransactionLogIteratorImpl::Next() {
-  LogFile currentLogFile = files_->at(currentFileIndex_);
-  LogReporter reporter = NewLogReporter(currentLogFile.logNumber);
+  LogFile currentLogFile = files_.get()->at(currentFileIndex_);
 
 //  First seek to the given seqNo. in the current file.
   std::string scratch;
@@ -95,7 +88,7 @@ void TransactionLogIteratorImpl::Next() {
     }
     while (currentLogReader_->ReadRecord(&record, &scratch)) {
       if (record.size() < 12) {
-        reporter.Corruption(
+        reporter_.Corruption(
           record.size(), Status::Corruption("log record too small"));
         continue;
       }
@@ -122,7 +115,7 @@ void TransactionLogIteratorImpl::Next() {
       }
       while (currentLogReader_->ReadRecord(&record, &scratch)) {
         if (record.size() < 12) {
-          reporter.Corruption(
+          reporter_.Corruption(
             record.size(), Status::Corruption("log record too small"));
           continue;
         } else {
@@ -134,9 +127,9 @@ void TransactionLogIteratorImpl::Next() {
     }
 
     if (openNextFile) {
-      if (currentFileIndex_ < files_->size() - 1) {
+      if (currentFileIndex_ < files_.get()->size() - 1) {
         ++currentFileIndex_;
-        Status status = OpenLogReader(files_->at(currentFileIndex_));
+        Status status = OpenLogReader(files_.get()->at(currentFileIndex_));
         if (!status.ok()) {
           isValid_ = false;
           currentStatus_ = status;
@@ -165,7 +158,6 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
 }
 
 Status TransactionLogIteratorImpl::OpenLogReader(const LogFile& logFile) {
-  LogReporter reporter = NewLogReporter(logFile.logNumber);
   unique_ptr<SequentialFile> file;
   Status status = OpenLogFile(logFile, &file);
   if (!status.ok()) {
@@ -173,7 +165,7 @@ Status TransactionLogIteratorImpl::OpenLogReader(const LogFile& logFile) {
   }
   assert(file);
   currentLogReader_.reset(
-    new log::Reader(std::move(file), &reporter, true, 0)
+    new log::Reader(std::move(file), &reporter_, true, 0)
   );
   return Status::OK();
 }

db/transaction_log_iterator_impl.h

@@ -10,17 +10,14 @@
 #include "leveldb/transaction_log_iterator.h"
 #include "db/log_file.h"
 #include "db/log_reader.h"
-#include "util/storage_options.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, "%ld: dropping %d bytes; %s",
-        log_number, static_cast<int>(bytes), s.ToString().c_str());
+    Log(info_log, "dropping %zu bytes; %s", bytes, s.ToString().c_str());
   }
 };
 
@@ -28,16 +25,11 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
  public:
   TransactionLogIteratorImpl(const std::string& dbname,
                              const Options* options,
-                             const StorageOptions& soptions,
+                             const EnvOptions& soptions,
                              SequenceNumber& seqNum,
-                             std::vector<LogFile>* files,
+                             std::unique_ptr<std::vector<LogFile>> files,
                              SequenceNumber const * const lastFlushedSequence);
 
-  virtual ~TransactionLogIteratorImpl() {
-    //  TODO move to cc file.
-    delete files_;
-  }
-
   virtual bool Valid();
 
   virtual void Next();
@@ -49,9 +41,9 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
  private:
   const std::string& dbname_;
   const Options* options_;
-  const StorageOptions& soptions_;
+  const EnvOptions& soptions_;
   const uint64_t startingSequenceNumber_;
-  const std::vector<LogFile>* files_;
+  std::unique_ptr<std::vector<LogFile>> files_;
   bool started_;
   bool isValid_;  // not valid when it starts of.
   Status currentStatus_;
@@ -59,7 +51,7 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
   std::unique_ptr<WriteBatch> currentBatch_;
   unique_ptr<log::Reader> currentLogReader_;
   Status OpenLogFile(const LogFile& logFile, unique_ptr<SequentialFile>* file);
-  LogReporter NewLogReporter(uint64_t logNumber);
+  LogReporter reporter_;
   SequenceNumber const * const lastFlushedSequence_;
   // represents the sequence number being read currently.
   SequenceNumber currentSequence_;

db/version_edit.h

@@ -81,6 +81,11 @@ 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);
 

db/version_set.cc

@@ -12,11 +12,13 @@
 #include "db/memtable.h"
 #include "db/table_cache.h"
 #include "leveldb/env.h"
+#include "leveldb/merge_operator.h"
 #include "leveldb/table_builder.h"
 #include "table/merger.h"
 #include "table/two_level_iterator.h"
 #include "util/coding.h"
 #include "util/logging.h"
+#include "util/stop_watch.h"
 
 namespace leveldb {
 
@@ -179,7 +181,8 @@ class Version::LevelFileNumIterator : public Iterator {
 static Iterator* GetFileIterator(void* arg,
                                  const ReadOptions& options,
                                  const EnvOptions& soptions,
-                                 const Slice& file_value) {
+                                 const Slice& file_value,
+                                 bool for_compaction) {
   TableCache* cache = reinterpret_cast<TableCache*>(arg);
   if (file_value.size() != 16) {
     return NewErrorIterator(
@@ -188,12 +191,14 @@ static Iterator* GetFileIterator(void* arg,
     return cache->NewIterator(options,
                               soptions,
                               DecodeFixed64(file_value.data()),
-                              DecodeFixed64(file_value.data() + 8));
+                              DecodeFixed64(file_value.data() + 8),
+                              nullptr /* don't need reference to table*/,
+                              for_compaction);
   }
 }
 
 Iterator* Version::NewConcatenatingIterator(const ReadOptions& options,
-                                            const StorageOptions& soptions,
+                                            const EnvOptions& soptions,
                                             int level) const {
   return NewTwoLevelIterator(
       new LevelFileNumIterator(vset_->icmp_, &files_[level]),
@@ -201,7 +206,7 @@ Iterator* Version::NewConcatenatingIterator(const ReadOptions& options,
 }
 
 void Version::AddIterators(const ReadOptions& options,
-                           const StorageOptions& soptions,
+                           const EnvOptions& soptions,
                            std::vector<Iterator*>* iters) {
   // Merge all level zero files together since they may overlap
   for (size_t i = 0; i < files_[0].size(); i++) {
@@ -227,29 +232,107 @@ enum SaverState {
   kFound,
   kDeleted,
   kCorrupt,
+  kMerge // saver contains the current merge result (the operands)
 };
 struct Saver {
   SaverState state;
   const Comparator* ucmp;
   Slice user_key;
+  bool* value_found; // Is value set correctly? Used by KeyMayExist
   std::string* value;
+  const MergeOperator* merge_operator;
+  std::deque<std::string>* merge_operands;  // the merge operations encountered
+  Logger* logger;
   bool didIO;    // did we do any disk io?
 };
 }
-static void SaveValue(void* arg, const Slice& ikey, const Slice& v, bool didIO){
+
+// Called from TableCache::Get and InternalGet when file/block in which key may
+// exist are not there in TableCache/BlockCache respectively. In this case we
+// can't guarantee that key does not exist and are not permitted to do IO to be
+// certain.Set the status=kFound and value_found=false to let the caller know
+// that key may exist but is not there in memory
+static void MarkKeyMayExist(void* arg) {
   Saver* s = reinterpret_cast<Saver*>(arg);
+  s->state = kFound;
+  if (s->value_found != nullptr) {
+    *(s->value_found) = false;
+  }
+}
+
+static bool SaveValue(void* arg, const Slice& ikey, const Slice& v, bool didIO){
+  Saver* s = reinterpret_cast<Saver*>(arg);
+  std::deque<std::string>* const ops = s->merge_operands; // shorter alias
+  std::string merge_result;  // temporary area for merge results later
+
+  assert(s != nullptr && ops != nullptr);
+
   ParsedInternalKey parsed_key;
+  // TODO: didIO and Merge?
   s->didIO = didIO;
   if (!ParseInternalKey(ikey, &parsed_key)) {
+    // TODO: what about corrupt during Merge?
     s->state = kCorrupt;
   } else {
     if (s->ucmp->Compare(parsed_key.user_key, s->user_key) == 0) {
-      s->state = (parsed_key.type == kTypeValue) ? kFound : kDeleted;
-      if (s->state == kFound) {
-        s->value->assign(v.data(), v.size());
+      // Key matches. Process it
+      switch (parsed_key.type) {
+        case kTypeValue:
+          if (kNotFound == s->state) {
+            s->state = kFound;
+            s->value->assign(v.data(), v.size());
+          } else if (kMerge == s->state) {
+            assert(s->merge_operator != nullptr);
+            s->state = kFound;
+            if (!s->merge_operator->Merge(s->user_key, &v, *ops,
+                                          s->value, s->logger)) {
+              s->state = kCorrupt;
+            }
+          } else {
+            assert(false);
+          }
+          return false;
+
+        case kTypeDeletion:
+          if (kNotFound == s->state) {
+            s->state = kDeleted;
+          } else if (kMerge == s->state) {
+            s->state = kFound;
+            if (!s->merge_operator->Merge(s->user_key, nullptr, *ops,
+                                          s->value, s->logger)) {
+              s->state = kCorrupt;
+            }
+          } else {
+            assert(false);
+          }
+          return false;
+
+        case kTypeMerge:
+          assert(s->state == kNotFound || s->state == kMerge);
+          s->state = kMerge;
+          ops->push_front(v.ToString());
+          while (ops->size() >= 2) {
+            // Attempt to merge operands together via user associateive merge
+            if (s->merge_operator->PartialMerge(s->user_key,
+                                                Slice((*ops)[0]),
+                                                Slice((*ops)[1]),
+                                                &merge_result,
+                                                s->logger)) {
+              ops->pop_front();
+              swap(ops->front(), merge_result);
+            } else {
+              // Associative merge returns false ==> stack the operands
+              break;
+            }
+          }
+          return true;
       }
     }
   }
+
+  // s->state could be Corrupt, merge or notfound
+
+  return false;
 }
 
 static bool NewestFirst(FileMetaData* a, FileMetaData* b) {
@@ -269,14 +352,36 @@ Version::Version(VersionSet* vset, uint64_t version_number)
   files_ = new std::vector<FileMetaData*>[vset->NumberLevels()];
 }
 
-Status Version::Get(const ReadOptions& options,
-                    const LookupKey& k,
-                    std::string* value,
-                    GetStats* stats) {
+void Version::Get(const ReadOptions& options,
+                  const LookupKey& k,
+                  std::string* value,
+                  Status* status,
+                  std::deque<std::string>* operands,
+                  GetStats* stats,
+                  const Options& db_options,
+                  const bool no_io,
+                  bool* value_found) {
   Slice ikey = k.internal_key();
   Slice user_key = k.user_key();
   const Comparator* ucmp = vset_->icmp_.user_comparator();
-  Status s;
+
+  auto merge_operator = db_options.merge_operator;
+  auto logger = db_options.info_log;
+
+  assert(status->ok() || status->IsMergeInProgress());
+  if (no_io) {
+    assert(status->ok());
+  }
+  Saver saver;
+  saver.state = status->ok()? kNotFound : kMerge;
+  saver.ucmp = ucmp;
+  saver.user_key = user_key;
+  saver.value_found = value_found;
+  saver.value = value;
+  saver.merge_operator = merge_operator;
+  saver.merge_operands = operands;
+  saver.logger = logger.get();
+  saver.didIO = false;
 
   stats->seek_file = nullptr;
   stats->seek_file_level = -1;
@@ -285,64 +390,75 @@ Status Version::Get(const ReadOptions& options,
 
   // We can search level-by-level since entries never hop across
   // levels.  Therefore we are guaranteed that if we find data
-  // in an smaller level, later levels are irrelevant.
-  std::vector<FileMetaData*> tmp;
-  FileMetaData* tmp2;
+  // in an smaller level, later levels are irrelevant (unless we
+  // are MergeInProgress).
+  std::vector<FileMetaData*> important_files;
   for (int level = 0; level < vset_->NumberLevels(); level++) {
     size_t num_files = files_[level].size();
     if (num_files == 0) continue;
 
     // Get the list of files to search in this level
     FileMetaData* const* files = &files_[level][0];
-    if (level == 0) {
-      // Level-0 files may overlap each other.  Find all files that
-      // overlap user_key and process them in order from newest to oldest.
-      tmp.reserve(num_files);
-      for (uint32_t i = 0; i < num_files; i++) {
-        FileMetaData* f = files[i];
-        if (ucmp->Compare(user_key, f->smallest.user_key()) >= 0 &&
-            ucmp->Compare(user_key, f->largest.user_key()) <= 0) {
-          tmp.push_back(f);
-        }
-      }
-      if (tmp.empty()) continue;
+    important_files.clear();
+    important_files.reserve(num_files);
 
-      std::sort(tmp.begin(), tmp.end(), NewestFirst);
-      files = &tmp[0];
-      num_files = tmp.size();
+    // Some files may overlap each other. We find
+    // all files that overlap user_key and process them in order from
+    // newest to oldest. In the context of merge-operator,
+    // this can occur at any level. Otherwise, it only occurs
+    // at Level-0 (since Put/Deletes are always compacted into a single entry).
+    uint32_t start_index;
+    if (level == 0) {
+      // On Level-0, we read through all files to check for overlap.
+      start_index = 0;
     } else {
+      // On Level-n (n>=1), files are sorted.
       // Binary search to find earliest index whose largest key >= ikey.
-      uint32_t index = FindFile(vset_->icmp_, files_[level], ikey);
-      if (index >= num_files) {
-        files = nullptr;
-        num_files = 0;
-      } else {
-        tmp2 = files[index];
-        if (ucmp->Compare(user_key, tmp2->smallest.user_key()) < 0) {
-          // All of "tmp2" is past any data for user_key
-          files = nullptr;
-          num_files = 0;
-        } else {
-          files = &tmp2;
-          num_files = 1;
-        }
+      // We will also stop when the file no longer overlaps ikey
+      start_index = FindFile(vset_->icmp_, files_[level], ikey);
+    }
+
+    // Traverse the list, finding all overlapping files.
+    for (uint32_t i = start_index; i < num_files; i++) {
+      FileMetaData* f = files[i];
+      if (ucmp->Compare(user_key, f->smallest.user_key()) >= 0 &&
+          ucmp->Compare(user_key, f->largest.user_key()) <= 0) {
+        important_files.push_back(f);
+      } else if (level > 0) {
+        // If on Level-n (n>=1) then the files are sorted.
+        // So we can stop looking when we are past the ikey.
+        break;
       }
     }
 
-    for (uint32_t i = 0; i < num_files; ++i) {
+    if (important_files.empty()) continue;
 
-      FileMetaData* f = files[i];
-      Saver saver;
-      saver.state = kNotFound;
-      saver.ucmp = ucmp;
-      saver.user_key = user_key;
-      saver.value = value;
-      saver.didIO = false;
+    if (level == 0) {
+      std::sort(important_files.begin(), important_files.end(), NewestFirst);
+    } else {
+      // Sanity check to make sure that the files are correctly sorted
+#ifndef NDEBUG
+      num_files = important_files.size();
+      for (uint32_t i = 1; i < num_files; ++i) {
+        FileMetaData* a = important_files[i-1];
+        FileMetaData* b = important_files[i];
+        int comp_sign = vset_->icmp_.Compare(a->largest, b->smallest);
+        assert(comp_sign < 0);
+      }
+#endif
+    }
+
+    // Traverse each relevant file to find the desired key
+    num_files = important_files.size();
+    for (uint32_t i = 0; i < num_files; ++i) {
+      FileMetaData* f = important_files[i];
       bool tableIO = false;
-      s = vset_->table_cache_->Get(options, f->number, f->file_size,
-                                   ikey, &saver, SaveValue, &tableIO);
-      if (!s.ok()) {
-        return s;
+      *status = vset_->table_cache_->Get(options, f->number, f->file_size,
+                                         ikey, &saver, SaveValue, &tableIO,
+                                         MarkKeyMayExist, no_io);
+      // TODO: examine the behavior for corrupted key
+      if (!status->ok()) {
+        return;
       }
 
       if (last_file_read != nullptr && stats->seek_file == nullptr) {
@@ -367,18 +483,33 @@ Status Version::Get(const ReadOptions& options,
         case kNotFound:
           break;      // Keep searching in other files
         case kFound:
-          return s;
+          return;
         case kDeleted:
-          s = Status::NotFound(Slice());  // Use empty error message for speed
-          return s;
+          *status = Status::NotFound(Slice());  // Use empty error message for speed
+          return;
         case kCorrupt:
-          s = Status::Corruption("corrupted key for ", user_key);
-          return s;
+          *status = Status::Corruption("corrupted key for ", user_key);
+          return;
+        case kMerge:
+          break;
       }
     }
   }
 
-  return Status::NotFound(Slice());  // Use an empty error message for speed
+
+  if (kMerge == saver.state) {
+    // merge_operands are in saver and we hit the beginning of the key history
+    // do a final merge of nullptr and operands;
+    if (merge_operator->Merge(user_key, nullptr, *saver.merge_operands,
+                              value, logger.get())) {
+      *status = Status::OK();
+    } else {
+      *status = Status::Corruption("could not perform end-of-key merge for ",
+                                   user_key);
+    }
+  } else {
+    *status = Status::NotFound(Slice()); // Use an empty error message for speed
+  }
 }
 
 bool Version::UpdateStats(const GetStats& stats) {
@@ -615,6 +746,53 @@ void Version::ExtendOverlappingInputs(
   }
 }
 
+// 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 Version::HasOverlappingUserKey(
+    const std::vector<FileMetaData*>* inputs,
+    int level) {
+
+  // If inputs empty, there is no overlap.
+  // If level == 0, it is assumed that all needed files were already included.
+  if (inputs->empty() || level == 0){
+    return false;
+  }
+
+  const Comparator* user_cmp = vset_->icmp_.user_comparator();
+  const std::vector<FileMetaData*>& files = files_[level];
+  const size_t kNumFiles = files.size();
+
+  // Check the last file in inputs against the file after it
+  size_t last_file = FindFile(vset_->icmp_, files,
+                              inputs->back()->largest.Encode());
+  assert(0 <= last_file && last_file < kNumFiles);  // File should exist!
+  if (last_file < kNumFiles-1) {                    // If not the last file
+    const Slice last_key_in_input = files[last_file]->largest.user_key();
+    const Slice first_key_after = files[last_file+1]->smallest.user_key();
+    if (user_cmp->Compare(last_key_in_input, first_key_after) == 0) {
+      // The last user key in input overlaps with the next file's first key
+      return true;
+    }
+  }
+
+  // Check the first file in inputs against the file just before it
+  size_t first_file = FindFile(vset_->icmp_, files,
+                               inputs->front()->smallest.Encode());
+  assert(0 <= first_file && first_file <= last_file);   // File should exist!
+  if (first_file > 0) {                                 // If not first file
+    const Slice& first_key_in_input = files[first_file]->smallest.user_key();
+    const Slice& last_key_before = files[first_file-1]->largest.user_key();
+    if (user_cmp->Compare(first_key_in_input, last_key_before) == 0) {
+      // The first user key in input overlaps with the previous file's last key
+      return true;
+    }
+  }
+
+  return false;
+}
+
 std::string Version::DebugString(bool hex) const {
   std::string r;
   for (int level = 0; level < vset_->NumberLevels(); level++) {
@@ -891,7 +1069,7 @@ class VersionSet::Builder {
 
 VersionSet::VersionSet(const std::string& dbname,
                        const Options* options,
-                       const StorageOptions& storage_options,
+                       const EnvOptions& storage_options,
                        TableCache* table_cache,
                        const InternalKeyComparator* cmp)
     : env_(options->env),
@@ -933,7 +1111,8 @@ void VersionSet::Init(int num_levels) {
   for (int i = 0; i < num_levels; i++) {
     if (i > 1) {
       max_file_size_[i] = max_file_size_[i-1] * target_file_size_multiplier;
-      level_max_bytes_[i] = level_max_bytes_[i-1] * max_bytes_multiplier;
+      level_max_bytes_[i] = level_max_bytes_[i-1] * max_bytes_multiplier *
+        options_->max_bytes_for_level_multiplier_additional[i-1];
     } else {
       max_file_size_[i] = options_->target_file_size_base;
       level_max_bytes_[i] = options_->max_bytes_for_level_base;
@@ -1043,8 +1222,10 @@ Status VersionSet::LogAndApply(VersionEdit* edit, port::Mutex* mu,
       }
       if (s.ok()) {
         if (options_->use_fsync) {
+          StopWatch sw(env_, options_->statistics, MANIFEST_FILE_SYNC_MICROS);
           s = descriptor_log_->file()->Fsync();
         } else {
+          StopWatch sw(env_, options_->statistics, MANIFEST_FILE_SYNC_MICROS);
           s = descriptor_log_->file()->Sync();
         }
       }
@@ -1461,7 +1642,7 @@ void VersionSet::Finalize(Version* v,
 
   // sort all the levels based on their score. Higher scores get listed
   // first. Use bubble sort because the number of entries are small.
-  for(int i = 0; i <  NumberLevels()-2; i++) {
+  for (int i = 0; i <  NumberLevels()-2; i++) {
     for (int j = i+1; j < NumberLevels()-1; j++) {
       if (v->compaction_score_[i] < v->compaction_score_[j]) {
         double score = v->compaction_score_[i];
@@ -1643,14 +1824,26 @@ uint64_t VersionSet::ApproximateOffsetOf(Version* v, const InternalKey& ikey) {
   return result;
 }
 
-void VersionSet::AddLiveFiles(std::set<uint64_t>* live) {
+void VersionSet::AddLiveFiles(std::vector<uint64_t>* live_list) {
+  // pre-calculate space requirement
+  int64_t total_files = 0;
   for (Version* v = dummy_versions_.next_;
        v != &dummy_versions_;
        v = v->next_) {
     for (int level = 0; level < NumberLevels(); level++) {
-      const std::vector<FileMetaData*>& files = v->files_[level];
-      for (size_t i = 0; i < files.size(); i++) {
-        live->insert(files[i]->number);
+      total_files += v->files_[level].size();
+    }
+  }
+
+  // just one time extension to the right size
+  live_list->reserve(live_list->size() + total_files);
+
+  for (Version* v = dummy_versions_.next_;
+       v != &dummy_versions_;
+       v = v->next_) {
+    for (int level = 0; level < NumberLevels(); level++) {
+      for (const auto& f : v->files_[level]) {
+        live_list->push_back(f->number);
       }
     }
   }
@@ -1745,13 +1938,15 @@ Iterator* VersionSet::MakeInputIterator(Compaction* c) {
         for (size_t i = 0; i < files.size(); i++) {
           list[num++] = table_cache_->NewIterator(
               options, storage_options_compactions_,
-              files[i]->number, files[i]->file_size);
+              files[i]->number, files[i]->file_size, nullptr,
+              true /* for compaction */);
         }
       } else {
         // Create concatenating iterator for the files from this level
         list[num++] = NewTwoLevelIterator(
             new Version::LevelFileNumIterator(icmp_, &c->inputs_[which]),
-            &GetFileIterator, table_cache_, options, storage_options_);
+            &GetFileIterator, table_cache_, options, storage_options_,
+            true /* for compaction */);
       }
     }
   }
@@ -1877,7 +2072,7 @@ Compaction* VersionSet::PickCompactionBySize(int level, double score) {
 
   assert(level >= 0);
   assert(level+1 < NumberLevels());
-  c = new Compaction(level, MaxFileSizeForLevel(level),
+  c = new Compaction(level, MaxFileSizeForLevel(level+1),
       MaxGrandParentOverlapBytes(level), NumberLevels());
   c->score_ = score;
 
@@ -1941,7 +2136,7 @@ Compaction* VersionSet::PickCompaction() {
   Compaction* c = nullptr;
   int level = -1;
 
-  // compute the compactions needed. It is better to do it here
+  // Compute the compactions needed. It is better to do it here
   // and also in LogAndApply(), otherwise the values could be stale.
   std::vector<uint64_t> size_being_compacted(NumberLevels()-1);
   current_->vset_->SizeBeingCompacted(size_being_compacted);
@@ -1957,6 +2152,7 @@ Compaction* VersionSet::PickCompaction() {
     level = current_->compaction_level_[i];
     if ((current_->compaction_score_[i] >= 1)) {
       c = PickCompactionBySize(level, current_->compaction_score_[i]);
+      ExpandWhileOverlapping(c);
       if (c != nullptr) {
         break;
       }
@@ -1964,14 +2160,24 @@ Compaction* VersionSet::PickCompaction() {
   }
 
   // Find compactions needed by seeks
-  if (c == nullptr && (current_->file_to_compact_ != nullptr)) {
+  FileMetaData* f = current_->file_to_compact_;
+  if (c == nullptr && f != nullptr && !f->being_compacted) {
+
     level = current_->file_to_compact_level_;
+    int parent_index = -1;
 
     // Only allow one level 0 compaction at a time.
+    // Do not pick this file if its parents at level+1 are being compacted.
     if (level != 0 || compactions_in_progress_[0].empty()) {
-      c = new Compaction(level, MaxFileSizeForLevel(level),
-      MaxGrandParentOverlapBytes(level), NumberLevels(), true);
-      c->inputs_[0].push_back(current_->file_to_compact_);
+      if (!ParentRangeInCompaction(&f->smallest, &f->largest, level,
+                                   &parent_index)) {
+        c = new Compaction(level, MaxFileSizeForLevel(level+1),
+                MaxGrandParentOverlapBytes(level), NumberLevels(), true);
+        c->inputs_[0].push_back(f);
+        c->parent_index_ = parent_index;
+        current_->file_to_compact_ = nullptr;
+        ExpandWhileOverlapping(c);
+      }
     }
   }
 
@@ -1982,7 +2188,6 @@ Compaction* VersionSet::PickCompaction() {
   c->input_version_ = current_;
   c->input_version_->Ref();
 
-  // Files in level 0 may overlap each other, so pick up all overlapping ones
   // Two level 0 compaction won't run at the same time, so don't need to worry
   // about files on level 0 being compacted.
   if (level == 0) {
@@ -1994,6 +2199,11 @@ Compaction* VersionSet::PickCompaction() {
     // which will include the picked file.
     c->inputs_[0].clear();
     current_->GetOverlappingInputs(0, &smallest, &largest, &c->inputs_[0]);
+
+    // If we include more L0 files in the same compaction run it can
+    // cause the 'smallest' and 'largest' key to get extended to a
+    // larger range. So, re-invoke GetRange to get the new key range
+    GetRange(c->inputs_[0], &smallest, &largest);
     if (ParentRangeInCompaction(&smallest, &largest,
                                 level, &c->parent_index_)) {
       delete c;
@@ -2002,6 +2212,8 @@ Compaction* VersionSet::PickCompaction() {
     assert(!c->inputs_[0].empty());
   }
 
+
+  // Setup "level+1" files (inputs_[1])
   SetupOtherInputs(c);
 
   // mark all the files that are being compacted
@@ -2033,11 +2245,76 @@ bool VersionSet::FilesInCompaction(std::vector<FileMetaData*>& files) {
   return false;
 }
 
-void VersionSet::SetupOtherInputs(Compaction* c) {
+// Add more files to the inputs on "level" to make sure that
+// no newer version of a key is compacted to "level+1" while leaving an older
+// version in a "level". Otherwise, any Get() will search "level" first,
+// and will likely return an old/stale value for the key, since it always
+// searches in increasing order of level to find the value. This could
+// also scramble the order of merge operands. This function should be
+// called any time a new Compaction is created, and its inputs_[0] are
+// populated.
+//
+// Will set c to nullptr if it is impossible to apply this compaction.
+void VersionSet::ExpandWhileOverlapping(Compaction* c) {
+  // If inputs are empty then there is nothing to expand.
+  if (!c || c->inputs_[0].empty()) {
+    return;
+  }
+
+  // GetOverlappingInputs will always do the right thing for level-0.
+  // So we don't need to do any expansion if level == 0.
+  if (c->level() == 0) {
+    return;
+  }
+
   const int level = c->level();
   InternalKey smallest, largest;
+
+  // Keep expanding c->inputs_[0] until we are sure that there is a
+  // "clean cut" boundary between the files in input and the surrounding files.
+  // This will ensure that no parts of a key are lost during compaction.
+  int hint_index = -1;
+  size_t old_size;
+  do {
+    old_size = c->inputs_[0].size();
+    GetRange(c->inputs_[0], &smallest, &largest);
+    c->inputs_[0].clear();
+    current_->GetOverlappingInputs(level, &smallest, &largest, &c->inputs_[0],
+                                   hint_index, &hint_index);
+  } while(c->inputs_[0].size() > old_size);
+
+  // Get the new range
   GetRange(c->inputs_[0], &smallest, &largest);
 
+  // If, after the expansion, there are files that are already under
+  // compaction, then we must drop/cancel this compaction.
+  int parent_index = -1;
+  if (FilesInCompaction(c->inputs_[0]) ||
+      ParentRangeInCompaction(&smallest, &largest, level, &parent_index)) {
+    c->inputs_[0].clear();
+    c->inputs_[1].clear();
+    delete c;
+    c = nullptr;
+  }
+}
+
+// Populates the set of inputs from "level+1" that overlap with "level".
+// Will also attempt to expand "level" if that doesn't expand "level+1"
+// or cause "level" to include a file for compaction that has an overlapping
+// user-key with another file.
+void VersionSet::SetupOtherInputs(Compaction* c) {
+  // If inputs are empty, then there is nothing to expand.
+  if (c->inputs_[0].empty()) {
+    return;
+  }
+
+  const int level = c->level();
+  InternalKey smallest, largest;
+
+  // Get the range one last time.
+  GetRange(c->inputs_[0], &smallest, &largest);
+
+  // Populate the set of next-level files (inputs_[1]) to include in compaction
   current_->GetOverlappingInputs(level+1, &smallest, &largest, &c->inputs_[1],
                                  c->parent_index_, &c->parent_index_);
 
@@ -2045,8 +2322,11 @@ void VersionSet::SetupOtherInputs(Compaction* c) {
   InternalKey all_start, all_limit;
   GetRange2(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);
 
-  // See if we can grow the number of inputs in "level" without
-  // changing the number of "level+1" files we pick up.
+  // See if we can further grow the number of inputs in "level" without
+  // changing the number of "level+1" files we pick up. We also choose NOT
+  // to expand if this would cause "level" to include some entries for some
+  // user key, while excluding other entries for the same user key. This
+  // can happen when one user key spans multiple files.
   if (!c->inputs_[1].empty()) {
     std::vector<FileMetaData*> expanded0;
     current_->GetOverlappingInputs(level, &all_start, &all_limit, &expanded0,
@@ -2057,7 +2337,8 @@ void VersionSet::SetupOtherInputs(Compaction* c) {
     int64_t limit = ExpandedCompactionByteSizeLimit(level);
     if (expanded0.size() > c->inputs_[0].size() &&
         inputs1_size + expanded0_size < limit &&
-        !FilesInCompaction(expanded0)) {
+        !FilesInCompaction(expanded0) &&
+        !current_->HasOverlappingUserKey(&expanded0, level)) {
       InternalKey new_start, new_limit;
       GetRange(expanded0, &new_start, &new_limit);
       std::vector<FileMetaData*> expanded1;
@@ -2117,23 +2398,34 @@ Compaction* VersionSet::CompactRange(
   }
 
   // Avoid compacting too much in one shot in case the range is large.
-  const uint64_t limit = MaxFileSizeForLevel(level) *
+  // But we cannot do this for level-0 since level-0 files can overlap
+  // and we must not pick one file and drop another older file if the
+  // two files overlap.
+  if (level > 0) {
+    const uint64_t limit = MaxFileSizeForLevel(level) *
                          options_->source_compaction_factor;
-  uint64_t total = 0;
-  for (size_t i = 0; i < inputs.size(); i++) {
-    uint64_t s = inputs[i]->file_size;
-    total += s;
-    if (total >= limit) {
-      inputs.resize(i + 1);
-      break;
+    uint64_t total = 0;
+    for (size_t i = 0; i < inputs.size(); ++i) {
+      uint64_t s = inputs[i]->file_size;
+      total += s;
+      if (total >= limit) {
+        inputs.resize(i + 1);
+        break;
+      }
     }
   }
-
-  Compaction* c = new Compaction(level, MaxFileSizeForLevel(level),
+  Compaction* c = new Compaction(level, MaxFileSizeForLevel(level+1),
     MaxGrandParentOverlapBytes(level), NumberLevels());
+
+  c->inputs_[0] = inputs;
+  ExpandWhileOverlapping(c);
+  if (c == nullptr) {
+    Log(options_->info_log, "Could not compact due to expansion failure.\n");
+    return nullptr;
+  }
+
   c->input_version_ = current_;
   c->input_version_->Ref();
-  c->inputs_[0] = inputs;
   SetupOtherInputs(c);
 
   // These files that are to be manaully compacted do not trample
@@ -2157,16 +2449,15 @@ Compaction::Compaction(int level, uint64_t target_file_size,
       overlapped_bytes_(0),
       base_index_(-1),
       parent_index_(-1),
-      score_(0) {
+      score_(0),
+      level_ptrs_(std::vector<size_t>(number_levels)) {
   edit_ = new VersionEdit(number_levels_);
-  level_ptrs_ = new size_t[number_levels_];
   for (int i = 0; i < number_levels_; i++) {
     level_ptrs_[i] = 0;
   }
 }
 
 Compaction::~Compaction() {
-  delete[] level_ptrs_;
   delete edit_;
   if (input_version_ != nullptr) {
     input_version_->Unref();
@@ -2279,8 +2570,9 @@ void Compaction::Summary(char* output, int len) {
   int write = snprintf(output, len,
       "Base version %ld Base level %d, seek compaction:%d, inputs:",
       input_version_->GetVersionNumber(), level_, seek_compaction_);
-  if(write < 0 || write > len)
+  if (write < 0 || write > len) {
     return;
+  }
 
   char level_low_summary[100];
   InputSummary(inputs_[0], level_low_summary, sizeof(level_low_summary));

db/version_set.h

@@ -63,18 +63,21 @@ 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 StorageOptions& soptions,
+  void AddIterators(const ReadOptions&, const EnvOptions& soptions,
                     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;
   };
-  Status Get(const ReadOptions&, const LookupKey& key, std::string* val,
-             GetStats* stats);
+  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);
 
   // Adds "stats" into the current state.  Returns true if a new
   // compaction may need to be triggered, false otherwise.
@@ -117,6 +120,14 @@ 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,
@@ -135,10 +146,11 @@ class Version {
  private:
   friend class Compaction;
   friend class VersionSet;
+  friend class DBImpl;
 
   class LevelFileNumIterator;
   Iterator* NewConcatenatingIterator(const ReadOptions&,
-                                     const StorageOptions& soptions,
+                                     const EnvOptions& soptions,
                                      int level) const;
 
   VersionSet* vset_;            // VersionSet to which this Version belongs
@@ -207,7 +219,7 @@ class VersionSet {
  public:
   VersionSet(const std::string& dbname,
              const Options* options,
-             const StorageOptions& storage_options,
+             const EnvOptions& storage_options,
              TableCache* table_cache,
              const InternalKeyComparator*);
   ~VersionSet();
@@ -326,8 +338,7 @@ class VersionSet {
   }
 
   // Add all files listed in any live version to *live.
-  // May also mutate some internal state.
-  void AddLiveFiles(std::set<uint64_t>* live);
+  void AddLiveFiles(std::vector<uint64_t>* live_list);
 
   // Add all files listed in the current version to *live.
   void AddLiveFilesCurrentVersion(std::set<uint64_t>* live);
@@ -382,6 +393,8 @@ 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;
@@ -402,6 +415,8 @@ class VersionSet {
                  InternalKey* smallest,
                  InternalKey* largest);
 
+  void ExpandWhileOverlapping(Compaction* c);
+
   void SetupOtherInputs(Compaction* c);
 
   // Save current contents to *log
@@ -411,8 +426,6 @@ class VersionSet {
 
   bool ManifestContains(const std::string& record) const;
 
-  double MaxBytesForLevel(int level);
-
   int64_t ExpandedCompactionByteSizeLimit(int level);
 
   int64_t MaxGrandParentOverlapBytes(int level);
@@ -459,11 +472,11 @@ class VersionSet {
   uint64_t last_observed_manifest_size_;
 
   // storage options for all reads and writes except compactions
-  const StorageOptions& storage_options_;
+  const EnvOptions& storage_options_;
 
   // storage options used for compactions. This is a copy of
   // storage_options_ but with readaheads set to readahead_compactions_.
-  const StorageOptions storage_options_compactions_;
+  const EnvOptions storage_options_compactions_;
 
   // No copying allowed
   VersionSet(const VersionSet&);
@@ -568,7 +581,7 @@ class Compaction {
   // 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).
-  size_t* level_ptrs_;
+  std::vector<size_t> level_ptrs_;
 
   // mark (or clear) all files that are being compacted
   void MarkFilesBeingCompacted(bool);

db/write_batch.cc

@@ -7,7 +7,8 @@
 //    count: fixed32
 //    data: record[count]
 // record :=
-//    kTypeValue varstring varstring         |
+//    kTypeValue varstring varstring
+//    kTypeMerge varstring varstring
 //    kTypeDeletion varstring
 // varstring :=
 //    len: varint32
@@ -15,11 +16,15 @@
 
 #include "leveldb/write_batch.h"
 
-#include "leveldb/db.h"
+#include "leveldb/options.h"
+#include "leveldb/statistics.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 {
 
@@ -34,11 +39,19 @@ 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::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) {
@@ -68,6 +81,14 @@ Status WriteBatch::Iterate(Handler* handler) const {
           return Status::Corruption("bad WriteBatch Delete");
         }
         break;
+      case kTypeMerge:
+        if (GetLengthPrefixedSlice(&input, &key) &&
+            GetLengthPrefixedSlice(&input, &value)) {
+          handler->Merge(key, value);
+        } else {
+          return Status::Corruption("bad WriteBatch Merge");
+        }
+        break;
       default:
         return Status::Corruption("unknown WriteBatch tag");
     }
@@ -108,28 +129,68 @@ 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);
+}
+
+
 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* memtable) {
-  MemTableInserter inserter;
-  inserter.sequence_ = WriteBatchInternal::Sequence(b);
-  inserter.mem_ = memtable;
+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);
   return b->Iterate(&inserter);
 }
 

db/write_batch_internal.h

@@ -7,6 +7,8 @@
 
 #include "leveldb/types.h"
 #include "leveldb/write_batch.h"
+#include "leveldb/db.h"
+#include "leveldb/options.h"
 
 namespace leveldb {
 
@@ -39,7 +41,12 @@ class WriteBatchInternal {
 
   static void SetContents(WriteBatch* batch, const Slice& contents);
 
-  static Status InsertInto(const WriteBatch* batch, MemTable* memtable);
+  // 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 void Append(WriteBatch* dst, const WriteBatch* src);
 };

db/write_batch_test.cc

@@ -4,6 +4,8 @@
 
 #include "leveldb/db.h"
 
+#include <memory>
+#include "db/skiplistrep.h"
 #include "db/memtable.h"
 #include "db/write_batch_internal.h"
 #include "leveldb/env.h"
@@ -14,7 +16,8 @@ namespace leveldb {
 
 static std::string PrintContents(WriteBatch* b) {
   InternalKeyComparator cmp(BytewiseComparator());
-  MemTable* mem = new MemTable(cmp);
+  auto factory = std::make_shared<SkipListFactory>();
+  MemTable* mem = new MemTable(cmp, factory);
   mem->Ref();
   std::string state;
   Status s = WriteBatchInternal::InsertInto(b, mem);
@@ -33,6 +36,14 @@ 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());
@@ -59,6 +70,7 @@ TEST(WriteBatchTest, Empty) {
   WriteBatch batch;
   ASSERT_EQ("", PrintContents(&batch));
   ASSERT_EQ(0, WriteBatchInternal::Count(&batch));
+  ASSERT_EQ(0, batch.Count());
 }
 
 TEST(WriteBatchTest, Multiple) {
@@ -73,6 +85,7 @@ TEST(WriteBatchTest, Multiple) {
             "Delete(box)@101"
             "Put(foo, bar)@100",
             PrintContents(&batch));
+  ASSERT_EQ(3, batch.Count());
 }
 
 TEST(WriteBatchTest, Corruption) {
@@ -95,16 +108,19 @@ 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"
@@ -112,6 +128,7 @@ TEST(WriteBatchTest, Append) {
             "Put(b, vb)@201"
             "Delete(foo)@203",
             PrintContents(&b1));
+  ASSERT_EQ(4, b1.Count());
 }
 
 }  // namespace leveldb

helpers/memenv/memenv_test.cc

@@ -8,7 +8,6 @@
 #include "leveldb/db.h"
 #include "leveldb/env.h"
 #include "util/testharness.h"
-#include "util/storage_options.h"
 #include <memory>
 #include <string>
 #include <vector>
@@ -18,7 +17,7 @@ namespace leveldb {
 class MemEnvTest {
  public:
   Env* env_;
-  const StorageOptions soptions_;
+  const EnvOptions soptions_;
 
   MemEnvTest()
       : env_(NewMemEnv(Env::Default())) {

include/leveldb/arena.h

@@ -0,0 +1,38 @@
+// 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_

include/leveldb/compaction_filter.h

@@ -0,0 +1,46 @@
+// 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;
+};
+
+}  // namespace leveldb
+
+#endif  // STORAGE_LEVELDB_INCLUDE_COMPACTION_FILTER_H_

include/leveldb/db.h

@@ -19,8 +19,8 @@ namespace leveldb {
 using std::unique_ptr;
 
 // Update Makefile if you change these
-static const int kMajorVersion = 1;
-static const int kMinorVersion = 5;
+static const int kMajorVersion = 2;
+static const int kMinorVersion = 0;
 
 struct Options;
 struct ReadOptions;
@@ -83,6 +83,14 @@ 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.
@@ -96,7 +104,39 @@ class DB {
   //
   // May return some other Status on an error.
   virtual Status Get(const ReadOptions& options,
-                     const Slice& key, std::string* value) = 0;
+                     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;
+  }
 
   // Return a heap-allocated iterator over the contents of the database.
   // The result of NewIterator() is initially invalid (caller must
@@ -153,7 +193,14 @@ 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);
-  virtual void CompactRange(const Slice* begin, const Slice* end) = 0;
+  // 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;
 
   // Number of levels used for this DB.
   virtual int NumberLevels() = 0;
@@ -185,7 +232,7 @@ class DB {
   virtual Status GetLiveFiles(std::vector<std::string>&,
                               uint64_t* manifest_file_size) = 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

include/leveldb/env.h

@@ -23,16 +23,46 @@
 namespace leveldb {
 
 class FileLock;
-class EnvOptions;
 class Logger;
 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() { }
@@ -249,6 +279,12 @@ 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
@@ -330,6 +366,16 @@ 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_;
@@ -369,27 +415,6 @@ class FileLock {
   void operator=(const FileLock&);
 };
 
-// Options while opening a file to read/write
-class EnvOptions {
-  public:
-   virtual ~EnvOptions() {}
-
-   // If true, then allow caching of data in environment buffers
-   virtual bool UseOsBuffer() const = 0;
-
-   // If true, then allow the environment to readahead data
-   virtual bool UseReadahead() const = 0;
-
-   // If true, then use mmap to read data
-   virtual bool UseMmapReads() const = 0;
-
-   // If true, then use mmap to write data
-   virtual bool UseMmapWrites() const = 0;
-
-   // If true, set the FD_CLOEXEC on open fd.
-   virtual bool IsFDCloseOnExec() const = 0;
-};
-
 // Log the specified data to *info_log if info_log is non-nullptr.
 extern void Log(const shared_ptr<Logger>& info_log, const char* format, ...)
 #   if defined(__GNUC__) || defined(__clang__)

include/leveldb/ldb_tool.h

@@ -0,0 +1,14 @@
+// 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

include/leveldb/memtablerep.h

@@ -0,0 +1,88 @@
+// 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_

include/leveldb/merge_operator.h

@@ -0,0 +1,146 @@
+// 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 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 Merge(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 above Merge() 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 Merge(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_

include/leveldb/options.h

@@ -12,6 +12,7 @@
 #include <stdint.h>
 #include "leveldb/slice.h"
 #include "leveldb/statistics.h"
+#include "leveldb/memtablerep.h"
 
 namespace leveldb {
 
@@ -20,7 +21,9 @@ class Comparator;
 class Env;
 class FilterPolicy;
 class Logger;
+class MergeOperator;
 class Snapshot;
+class CompactionFilter;
 
 using std::shared_ptr;
 
@@ -63,6 +66,23 @@ 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
+  const MergeOperator* merge_operator;
+
+  // Allows an application to modify/delete a key-value during background
+  // compaction.
+  // Default: nullptr
+  const CompactionFilter* compaction_filter;
+
   // If true, the database will be created if it is missing.
   // Default: false
   bool create_if_missing;
@@ -112,6 +132,15 @@ 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).
@@ -190,9 +219,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 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.
+  // 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.
   int level0_slowdown_writes_trigger;
 
   // Maximum number of level-0 files.  We stop writes at this point.
@@ -236,6 +265,12 @@ 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
@@ -320,12 +355,22 @@ struct Options {
   // Default: 1000
   size_t keep_log_file_num;
 
-  // 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 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;
 
-  // Max time a put will be stalled when rate_limit is enforced
-  unsigned int rate_limit_delay_milliseconds;
+  // 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;
 
   // manifest file is rolled over on reaching this limit.
   // The older manifest file be deleted.
@@ -340,6 +385,13 @@ struct Options {
   // 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();
 
@@ -354,25 +406,6 @@ 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;
@@ -401,16 +434,7 @@ struct Options {
   // Default: true
   bool allow_os_buffer;
 
-  // Reading a single block from a file can cause the OS/FS to start
-  // readaheads of other blocks from the file. Default: true
-  bool allow_readahead;
-
-  // The reads triggered by compaction allows data to be readahead
-  // by the OS/FS. This overrides the setting of 'allow_readahead'
-  // for compaction-reads. Default: true
-  bool allow_readahead_compactions;
-
-  // Allow the OS to mmap file for reading. Default: false
+  // 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
@@ -418,6 +442,59 @@ struct Options {
 
   // 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;
+
+  // 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;
+
 };
 
 // Options that control read operations

include/leveldb/statistics.h

@@ -5,10 +5,13 @@
 #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 {
 
@@ -16,6 +19,7 @@ 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 {
@@ -39,21 +43,99 @@ enum Tickers {
   NO_FILE_CLOSES = 10,
   NO_FILE_OPENS = 11,
   NO_FILE_ERRORS = 12,
-  TICKER_ENUM_MAX = 13,
+  // 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,
+
+  TICKER_ENUM_MAX = 22
 };
 
+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" }
+};
 
 /**
  * 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,
-  HISTOGRAM_ENUM_MAX = 3,
+  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,
+  HISTOGRAM_ENUM_MAX = 17
+};
+
+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"}
 };
 
 struct HistogramData {
@@ -72,7 +154,6 @@ 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;
 
@@ -93,7 +174,7 @@ class Ticker {
  public:
   Ticker() : count_(0) { }
 
-  inline void recordTick() {
+ inline void recordTick() {
     count_++;
   }
 
@@ -106,8 +187,7 @@ class Ticker {
   }
 
  private:
-  uint64_t count_;
-
+  std::atomic_uint_fast64_t count_;
 };
 
 // Analyze the performance of a db
@@ -116,17 +196,22 @@ class Statistics {
 
   virtual long getTickerCount(Tickers tickerType) = 0;
   virtual void recordTick(Tickers tickerType, uint64_t count = 0) = 0;
-  virtual void measureTime(Histograms histogramType, uint64_t count) = 0;
-  virtual void measureTime(Histograms histogramType, double count) = 0;
+  virtual void measureTime(Histograms histogramType, uint64_t time) = 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,
                        Tickers ticker,
                        uint64_t count = 1) {
+  assert(HistogramsNameMap.size() == HISTOGRAM_ENUM_MAX);
+  assert(TickersNameMap.size() == TICKER_ENUM_MAX);
   if (statistics) {
     statistics->recordTick(ticker, count);
   }

include/leveldb/status.h

@@ -47,6 +47,9 @@ 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); }
@@ -66,6 +69,9 @@ 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;
@@ -84,7 +90,8 @@ class Status {
     kCorruption = 2,
     kNotSupported = 3,
     kInvalidArgument = 4,
-    kIOError = 5
+    kIOError = 5,
+    kMergeInProgress = 6
   };
 
   Code code() const {

include/leveldb/write_batch.h

@@ -36,6 +36,10 @@ 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);
 
@@ -47,13 +51,20 @@ class WriteBatch {
    public:
     virtual ~Handler();
     virtual void Put(const Slice& key, const Slice& value) = 0;
+    // Merge is not pure virtual. Otherwise, we would break existing
+    // clients of Handler on a source code level.
+    // The default implementation simply throws a runtime exception.
+    virtual void Merge(const Slice& key, const Slice& value);
     virtual void Delete(const Slice& key) = 0;
   };
   Status Iterate(Handler* handler) const;
 
-  // Retrive the serialized version of this batch.
+  // Retrieve 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
   WriteBatch(std::string rep): rep_(rep) {}
 

include/utilities/stackable_db.h

@@ -0,0 +1,154 @@
+// 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 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 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_

include/utilities/utility_db.h

@@ -0,0 +1,54 @@
+// 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_

port/port_posix.cc

@@ -19,7 +19,24 @@ static void PthreadCall(const char* label, int result) {
   }
 }
 
-Mutex::Mutex() { PthreadCall("init mutex", pthread_mutex_init(&mu_, NULL)); }
+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("destroy mutex", pthread_mutex_destroy(&mu_)); }
 

port/port_posix.h

@@ -82,7 +82,7 @@ class CondVar;
 
 class Mutex {
  public:
-  Mutex();
+  /* implicit */ Mutex(bool adaptive = false);
   ~Mutex();
 
   void Lock();
@@ -192,17 +192,20 @@ 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;
-  while(_stream.next_in != NULL && _stream.avail_in != 0) {
+  int old_sz =0, new_sz =0, new_sz_delta =0;
+  bool done = false;
+  while (!done) {
     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 = (int)(output->size() * 1.2);
+        new_sz_delta = (int)(output->size() * 0.2);
+        new_sz = output->size() + (new_sz_delta < 10 ? 10 : new_sz_delta);
         output->resize(new_sz);
         // Set more output.
         _stream.next_out = (Bytef *)&(*output)[old_sz];
@@ -228,13 +231,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 NULL;
+    return nullptr;
   }
 
   _stream.next_in = (Bytef *)input_data;
@@ -248,17 +251,22 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
   _stream.next_out = (Bytef *)output;
   _stream.avail_out = output_len;
 
-  char* tmp = NULL;
+  char* tmp = nullptr;
+  int output_len_delta;
+  bool done = false;
 
-  while(_stream.next_in != NULL && _stream.avail_in != 0) {
+  //while(_stream.next_in != nullptr && _stream.avail_in != 0) {
+  while (!done) {
     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 = (int)(output_len * 1.2);
+        output_len_delta = (int)(output_len * 0.2);
+        output_len += output_len_delta < 10 ? 10 : output_len_delta;
         tmp = new char[output_len];
         memcpy(tmp, output, old_sz);
         delete[] output;
@@ -272,7 +280,7 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
       default:
         delete[] output;
         inflateEnd(&_stream);
-        return NULL;
+        return nullptr;
     }
   }
 
@@ -281,7 +289,7 @@ inline char* Zlib_Uncompress(const char* input_data, size_t input_length,
   return output;
 #endif
 
-  return NULL;
+  return nullptr;
 }
 
 inline bool BZip2_Compress(const CompressionOptions& opts, const char* input,
@@ -311,7 +319,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 != NULL && _stream.avail_in != 0) {
+  while(_stream.next_in != nullptr && _stream.avail_in != 0) {
     int st = BZ2_bzCompress(&_stream, BZ_FINISH);
     switch (st) {
       case BZ_STREAM_END:
@@ -349,7 +357,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 NULL;
+    return nullptr;
   }
 
   _stream.next_in = (char *)input_data;
@@ -363,9 +371,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 = NULL;
+  char* tmp = nullptr;
 
-  while(_stream.next_in != NULL && _stream.avail_in != 0) {
+  while(_stream.next_in != nullptr && _stream.avail_in != 0) {
     int st = BZ2_bzDecompress(&_stream);
     switch (st) {
       case BZ_STREAM_END:
@@ -387,7 +395,7 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,
       default:
         delete[] output;
         BZ2_bzDecompressEnd(&_stream);
-        return NULL;
+        return nullptr;
     }
   }
 
@@ -395,7 +403,7 @@ inline char*  BZip2_Uncompress(const char* input_data, size_t input_length,
   BZ2_bzDecompressEnd(&_stream);
   return output;
 #endif
-  return NULL;
+  return nullptr;
 }
 
 inline bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg) {

port/stack_trace.cc

@@ -0,0 +1,97 @@
+#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

table/block.cc

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

table/block.h

@@ -22,6 +22,7 @@ class Block {
   ~Block();
 
   size_t size() const { return size_; }
+  bool   isCachable() const { return cachable_; }
   Iterator* NewIterator(const Comparator* comparator);
 
  private:
@@ -31,6 +32,7 @@ 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&);

table/block_builder.cc

@@ -60,6 +60,21 @@ 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++) {

table/block_builder.h

@@ -34,6 +34,9 @@ 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();

table/block_test.cc

@@ -1,9 +1,6 @@
 // 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"
@@ -14,6 +11,7 @@
 #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"
@@ -60,7 +58,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;
@@ -71,7 +69,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();
@@ -81,8 +79,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++) {
 

table/format.cc

@@ -66,10 +66,10 @@ Status Footer::DecodeFrom(Slice* input) {
   return result;
 }
 
-Status ReadBlock(RandomAccessFile* file,
-                 const ReadOptions& options,
-                 const BlockHandle& handle,
-                 BlockContents* result) {
+Status ReadBlockContents(RandomAccessFile* file,
+                         const ReadOptions& options,
+                         const BlockHandle& handle,
+                         BlockContents* result) {
   result->data = Slice();
   result->cachable = false;
   result->heap_allocated = false;

table/format.h

@@ -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 ReadBlock(RandomAccessFile* file,
-                        const ReadOptions& options,
-                        const BlockHandle& handle,
-                        BlockContents* result);
+extern Status ReadBlockContents(RandomAccessFile* file,
+                                const ReadOptions& options,
+                                const BlockHandle& handle,
+                                BlockContents* result);
 
 // Implementation details follow.  Clients should ignore,
 

table/table.cc

@@ -2,7 +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 "leveldb/table.h"
+#include "table/table.h"
 
 #include "leveldb/cache.h"
 #include "leveldb/comparator.h"
@@ -10,11 +10,14 @@
 #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 {
 
@@ -65,6 +68,32 @@ 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,
@@ -92,15 +121,9 @@ 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;
-  if (s.ok()) {
-    s = ReadBlock(file.get(), ReadOptions(), footer.index_handle(), &contents);
-    if (s.ok()) {
-      index_block = new Block(contents);
-    }
-  }
+  // TODO: we never really verify check sum for index block
+  s = ReadBlock(file.get(), ReadOptions(), footer.index_handle(), &index_block);
 
   if (s.ok()) {
     // We've successfully read the footer and the index block: we're
@@ -122,6 +145,25 @@ 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
@@ -129,14 +171,13 @@ void Table::ReadMeta(const Footer& footer) {
 
   // TODO(sanjay): Skip this if footer.metaindex_handle() size indicates
   // it is an empty block.
-  ReadOptions opt;
-  BlockContents contents;
-  if (!ReadBlock(rep_->file.get(), opt, footer.metaindex_handle(),
-                 &contents).ok()) {
+  //  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()) {
     // 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.";
@@ -156,11 +197,11 @@ void Table::ReadFilter(const Slice& filter_handle_value) {
     return;
   }
 
-  // We might want to unify with ReadBlock() if we start
+  // TODO: We might want to unify with ReadBlock() if we start
   // requiring checksum verification in Table::Open.
   ReadOptions opt;
   BlockContents block;
-  if (!ReadBlock(rep_->file.get(), opt, filter_handle, &block).ok()) {
+  if (!ReadBlockContents(rep_->file.get(), opt, filter_handle, &block).ok()) {
     return;
   }
   if (block.heap_allocated) {
@@ -193,7 +234,9 @@ static void ReleaseBlock(void* arg, void* h) {
 Iterator* Table::BlockReader(void* arg,
                              const ReadOptions& options,
                              const Slice& index_value,
-                             bool* didIO) {
+                             bool* didIO,
+                             bool for_compaction,
+                             const bool no_io) {
   Table* table = reinterpret_cast<Table*>(arg);
   Cache* block_cache = table->rep_->options.block_cache.get();
   std::shared_ptr<Statistics> statistics = table->rep_->options.statistics;
@@ -207,7 +250,6 @@ 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;
@@ -223,29 +265,34 @@ 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 {
-        s = ReadBlock(table->rep_->file.get(), options, handle, &contents);
-        if (s.ok()) {
-          block = new Block(contents);
-          if (contents.cachable && options.fill_cache) {
-            cache_handle = block_cache->Insert(
-                key, block, block->size(), &DeleteCachedBlock);
-          }
+        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
+              );
         }
-        if (didIO != nullptr) {
-          *didIO = true; // we did some io from storage
+        if (s.ok()) {
+          if (block->isCachable() && options.fill_cache) {
+            cache_handle = block_cache->Insert(
+              key, block, block->size(), &DeleteCachedBlock);
+          }
         }
 
         RecordTick(statistics, BLOCK_CACHE_MISS);
       }
-    } 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
-      }
+    } 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);
     }
   }
 
@@ -266,8 +313,9 @@ Iterator* Table::BlockReader(void* arg,
 Iterator* Table::BlockReader(void* arg,
                              const ReadOptions& options,
                              const EnvOptions& soptions,
-                             const Slice& index_value) {
-  return BlockReader(arg, options, index_value, nullptr);
+                             const Slice& index_value,
+                             bool for_compaction) {
+  return BlockReader(arg, options, index_value, nullptr, for_compaction);
 }
 
 Iterator* Table::NewIterator(const ReadOptions& options) const {
@@ -278,11 +326,14 @@ Iterator* Table::NewIterator(const ReadOptions& options) const {
 
 Status Table::InternalGet(const ReadOptions& options, const Slice& k,
                           void* arg,
-                          void (*saver)(void*, const Slice&, const Slice&, bool)) {
+                          bool (*saver)(void*, const Slice&, const Slice&,
+                                        bool),
+                          void (*mark_key_may_exist)(void*),
+                          const bool no_io) {
   Status s;
   Iterator* iiter = rep_->index_block->NewIterator(rep_->options.comparator);
-  iiter->Seek(k);
-  if (iiter->Valid()) {
+  bool done = false;
+  for (iiter->Seek(k); iiter->Valid() && !done; iiter->Next()) {
     Slice handle_value = iiter->value();
     FilterBlockReader* filter = rep_->filter;
     BlockHandle handle;
@@ -290,14 +341,28 @@ 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);
-      block_iter->Seek(k);
-      if (block_iter->Valid()) {
-        (*saver)(arg, block_iter->key(), block_iter->value(), didIO);
+                                         &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;
+        }
       }
       s = block_iter->status();
       delete block_iter;
@@ -310,8 +375,9 @@ Status Table::InternalGet(const ReadOptions& options, const Slice& k,
   return s;
 }
 
-void SaveDidIO(void* arg, const Slice& key, const Slice& value, bool didIO) {
+bool 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

table/table.h

@@ -64,24 +64,32 @@ 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_;
-
-  explicit Table(Rep* 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&);
+                               const EnvOptions& soptions, const Slice&,
+                               bool for_compaction);
   static Iterator* BlockReader(void*, const ReadOptions&, const Slice&,
-                               bool* didIO);
+                               bool* didIO, bool for_compaction = false,
+                               const bool no_io = false);
 
-  // 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.
+  // 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.
   friend class TableCache;
   Status InternalGet(
       const ReadOptions&, const Slice& key,
       void* arg,
-      void (*handle_result)(void* arg, const Slice& k, const Slice& v, bool));
+      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 ReadMeta(const Footer& footer);

table/table_builder.cc

@@ -14,6 +14,7 @@
 #include "table/format.h"
 #include "util/coding.h"
 #include "util/crc32c.h"
+#include "util/stop_watch.h"
 
 namespace leveldb {
 
@@ -98,6 +99,22 @@ void TableBuilder::Add(const Slice& key, const Slice& value) {
     assert(r->options.comparator->Compare(key, Slice(r->last_key)) > 0);
   }
 
+  const size_t curr_size = r->data_block.CurrentSizeEstimate();
+  const size_t estimated_size_after = r->data_block.EstimateSizeAfterKV(key,
+      value);
+  // Do flush if one of the below two conditions is true:
+  // 1) if the current estimated size already exceeds the block size,
+  // 2) block_size_deviation is set and the estimated size after appending
+  // the kv will exceed the block size and the current size is under the
+  // the deviation.
+  if (curr_size >= r->options.block_size ||
+      (estimated_size_after > r->options.block_size &&
+      r->options.block_size_deviation > 0 &&
+      (curr_size * 100) >
+        r->options.block_size * (100 - r->options.block_size_deviation))) {
+    Flush();
+  }
+
   if (r->pending_index_entry) {
     assert(r->data_block.empty());
     r->options.comparator->FindShortestSeparator(&r->last_key, key);
@@ -114,11 +131,6 @@ void TableBuilder::Add(const Slice& key, const Slice& value) {
   r->last_key.assign(key.data(), key.size());
   r->num_entries++;
   r->data_block.Add(key, value);
-
-  const size_t estimated_block_size = r->data_block.CurrentSizeEstimate();
-  if (estimated_block_size >= r->options.block_size) {
-    Flush();
-  }
 }
 
 void TableBuilder::Flush() {
@@ -220,6 +232,7 @@ void TableBuilder::WriteRawBlock(const Slice& block_contents,
                                  CompressionType type,
                                  BlockHandle* handle) {
   Rep* r = rep_;
+  StopWatch sw(r->options.env, r->options.statistics, WRITE_RAW_BLOCK_MICROS);
   handle->set_offset(r->offset);
   handle->set_size(block_contents.size());
   r->status = r->file->Append(block_contents);

table/table_test.cc

@@ -1,13 +1,12 @@
 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "leveldb/table.h"
-
 #include <map>
 #include <string>
+#include <memory>
 #include "db/dbformat.h"
 #include "db/memtable.h"
+#include "db/skiplistrep.h"
 #include "db/write_batch_internal.h"
 #include "leveldb/db.h"
 #include "leveldb/env.h"
@@ -16,6 +15,7 @@
 #include "table/block.h"
 #include "table/block_builder.h"
 #include "table/format.h"
+#include "table/table.h"
 #include "util/random.h"
 #include "util/testharness.h"
 #include "util/testutil.h"
@@ -295,7 +295,7 @@ class TableConstructor: public Constructor {
   TableConstructor();
 
   static uint64_t cur_uniq_id_;
-  const StorageOptions soptions;
+  const EnvOptions soptions;
 };
 uint64_t TableConstructor::cur_uniq_id_ = 1;
 
@@ -344,8 +344,9 @@ class MemTableConstructor: public Constructor {
  public:
   explicit MemTableConstructor(const Comparator* cmp)
       : Constructor(cmp),
-        internal_comparator_(cmp) {
-    memtable_ = new MemTable(internal_comparator_);
+        internal_comparator_(cmp),
+        table_factory_(new SkipListFactory) {
+    memtable_ = new MemTable(internal_comparator_, table_factory_);
     memtable_->Ref();
   }
   ~MemTableConstructor() {
@@ -353,7 +354,7 @@ class MemTableConstructor: public Constructor {
   }
   virtual Status FinishImpl(const Options& options, const KVMap& data) {
     memtable_->Unref();
-    memtable_ = new MemTable(internal_comparator_);
+    memtable_ = new MemTable(internal_comparator_, table_factory_);
     memtable_->Ref();
     int seq = 1;
     for (KVMap::const_iterator it = data.begin();
@@ -371,6 +372,7 @@ class MemTableConstructor: public Constructor {
  private:
   InternalKeyComparator internal_comparator_;
   MemTable* memtable_;
+  std::shared_ptr<SkipListFactory> table_factory_;
 };
 
 class DBConstructor: public Constructor {
@@ -807,7 +809,8 @@ class MemTableTest { };
 
 TEST(MemTableTest, Simple) {
   InternalKeyComparator cmp(BytewiseComparator());
-  MemTable* memtable = new MemTable(cmp);
+  auto table_factory = std::make_shared<SkipListFactory>();
+  MemTable* memtable = new MemTable(cmp, table_factory);
   memtable->Ref();
   WriteBatch batch;
   WriteBatchInternal::SetSequence(&batch, 100);

table/two_level_iterator.cc

@@ -4,9 +4,9 @@
 
 #include "table/two_level_iterator.h"
 
-#include "leveldb/table.h"
 #include "table/block.h"
 #include "table/format.h"
+#include "table/table.h"
 #include "table/iterator_wrapper.h"
 
 namespace leveldb {
@@ -14,7 +14,8 @@ namespace leveldb {
 namespace {
 
 typedef Iterator* (*BlockFunction)(void*, const ReadOptions&,
-                                   const EnvOptions& soptions, const Slice&);
+                                   const EnvOptions& soptions, const Slice&,
+                                   bool for_compaction);
 
 class TwoLevelIterator: public Iterator {
  public:
@@ -23,7 +24,8 @@ class TwoLevelIterator: public Iterator {
     BlockFunction block_function,
     void* arg,
     const ReadOptions& options,
-    const EnvOptions& soptions);
+    const EnvOptions& soptions,
+    bool for_compaction);
 
   virtual ~TwoLevelIterator();
 
@@ -74,6 +76,7 @@ class TwoLevelIterator: public Iterator {
   // If data_iter_ is non-nullptr, then "data_block_handle_" holds the
   // "index_value" passed to block_function_ to create the data_iter_.
   std::string data_block_handle_;
+  bool for_compaction_;
 };
 
 TwoLevelIterator::TwoLevelIterator(
@@ -81,13 +84,15 @@ TwoLevelIterator::TwoLevelIterator(
     BlockFunction block_function,
     void* arg,
     const ReadOptions& options,
-    const EnvOptions& soptions)
+    const EnvOptions& soptions,
+    bool for_compaction)
     : block_function_(block_function),
       arg_(arg),
       options_(options),
       soptions_(soptions),
       index_iter_(index_iter),
-      data_iter_(nullptr) {
+      data_iter_(nullptr),
+      for_compaction_(for_compaction) {
 }
 
 TwoLevelIterator::~TwoLevelIterator() {
@@ -168,7 +173,8 @@ void TwoLevelIterator::InitDataBlock() {
       // data_iter_ is already constructed with this iterator, so
       // no need to change anything
     } else {
-      Iterator* iter = (*block_function_)(arg_, options_, soptions_, handle);
+      Iterator* iter = (*block_function_)(arg_, options_, soptions_, handle,
+                                          for_compaction_);
       data_block_handle_.assign(handle.data(), handle.size());
       SetDataIterator(iter);
     }
@@ -182,9 +188,10 @@ Iterator* NewTwoLevelIterator(
     BlockFunction block_function,
     void* arg,
     const ReadOptions& options,
-    const EnvOptions& soptions) {
+    const EnvOptions& soptions,
+    bool for_compaction) {
   return new TwoLevelIterator(index_iter, block_function, arg,
-                              options, soptions);
+                              options, soptions, for_compaction);
 }
 
 }  // namespace leveldb

table/two_level_iterator.h

@@ -27,10 +27,12 @@ extern Iterator* NewTwoLevelIterator(
         void* arg,
         const ReadOptions& options,
         const EnvOptions& soptions,
-        const Slice& index_value),
+        const Slice& index_value,
+        bool for_compaction),
     void* arg,
     const ReadOptions& options,
-    const EnvOptions& soptions);
+    const EnvOptions& soptions,
+    bool for_compaction = false);
 
 }  // namespace leveldb
 

tools/db_crashtest.py

@@ -2,7 +2,7 @@
 import os
 import sys
 import time
-import shlex
+import random
 import getopt
 import logging
 import tempfile
@@ -27,7 +27,7 @@ def main(argv):
     duration = 6000  # total time for this script to test db_stress
     threads = 32
     # since we will be killing anyway, use large value for ops_per_thread
-    ops_per_thread = 10000000
+    ops_per_thread = 100000000
     write_buf_size = 4 * 1024 * 1024
 
     for opt, arg in opts:
@@ -56,7 +56,7 @@ def main(argv):
 
     dirpath = tempfile.mkdtemp()
 
-    print("Running crash-test with \ninterval_between_crash="
+    print("Running blackbox-crash-test with \ninterval_between_crash="
           + str(interval) + "\ntotal-duration=" + str(duration)
           + "\nthreads=" + str(threads) + "\nops_per_thread="
           + str(ops_per_thread) + "\nwrite_buffer_size="
@@ -64,6 +64,23 @@ def main(argv):
 
     while time.time() < exit_time:
         run_had_errors = False
+        additional_opts = ' --disable_seek_compaction=' + \
+                          str(random.randint(0, 1)) + \
+                          ' --mmap_read=' + str(random.randint(0, 1)) + \
+                          ' --block_size=16384 ' + \
+                          ' --cache_size=1048576 ' + \
+                          ' --open_files=500000 ' + \
+                          ' --verify_checksum=1 ' + \
+                          ' --sync=' + str(random.randint(0, 1)) + \
+                          ' --disable_wal=0 ' + \
+                          ' --disable_data_sync=' + \
+                          str(random.randint(0, 1)) + \
+                          ' --target_file_size_base=2097152 ' + \
+                          ' --target_file_size_multiplier=2 ' + \
+                          ' --max_write_buffer_number=3 ' + \
+                          ' --max_background_compactions=20 ' + \
+                          ' --max_bytes_for_level_base=10485760 ' + \
+                          ' --filter_deletes=' + str(random.randint(0, 1))
         killtime = time.time() + interval
         child = subprocess.Popen(['./db_stress \
                         --test_batches_snapshots=1 \
@@ -74,8 +91,10 @@ def main(argv):
                         --reopen=0 \
                         --readpercent=50 \
                         --db=' + dirpath + '\
-                        --max_key=1000'], stderr=subprocess.PIPE, shell=True)
-        print("Running db_stress with pid=%d\n" % child.pid)
+                        --max_key=100000000 ' + additional_opts],
+                                 stderr=subprocess.PIPE, shell=True)
+        print("Running db_stress with pid=%d and additional options=\n"
+              % child.pid + additional_opts + "\n")
         time.sleep(interval)
         while True:
             if time.time() > killtime:

tools/db_crashtest2.py

@@ -0,0 +1,149 @@
+#! /usr/bin/env python
+import os
+import sys
+import time
+import random
+import getopt
+import logging
+import tempfile
+import subprocess
+
+# This python script runs db_stress multiple times with kill_random_test
+# that causes leveldb to crash at various points in code.
+# It also has test-batches-snapshot ON so that basic atomic/consistency
+# checks can be performed.
+#
+def main(argv):
+    try:
+        opts, args = getopt.getopt(argv, "hd:t:k:o:b:")
+    except getopt.GetoptError:
+        print str(getopt.GetoptError)
+        print "db_crashtest2.py -d <duration_test> -t <#threads> " \
+            "-k <kills with prob 1/k> -o <ops_per_thread> "\
+            "-b <write_buffer_size>\n"
+        sys.exit(2)
+
+    # default values, will be overridden by cmdline args
+    kill_random_test = 97  # kill with probability 1/97 by default
+    duration = 6000  # total time for this script to test db_stress
+    threads = 32
+    ops_per_thread = 200000
+    write_buf_size = 4 * 1024 * 1024
+
+    for opt, arg in opts:
+        if opt == '-h':
+            print "db_crashtest2.py -d <duration_test> -t <#threads> " \
+                "-k <kills with prob 1/k> -o <ops_per_thread> "\
+                "-b <write_buffer_size>\n"
+            sys.exit()
+        elif opt == ("-d"):
+            duration = int(arg)
+        elif opt == ("-t"):
+            threads = int(arg)
+        elif opt == ("-k"):
+            kill_random_test = int(arg)
+        elif opt == ("-i"):
+            interval = int(arg)
+        elif opt == ("-o"):
+            ops_per_thread = int(arg)
+        elif opt == ("-b"):
+            write_buf_size = int(arg)
+        else:
+            print "unrecognized option " + str(opt) + "\n"
+            print "db_crashtest2.py -d <duration_test> -t <#threads> " \
+                "-k <kills with prob 1/k> -o <ops_per_thread> " \
+                "-b <write_buffer_size>\n"
+            sys.exit(2)
+
+    exit_time = time.time() + duration
+
+    dirpath = tempfile.mkdtemp()
+
+    print("Running whitebox-crash-test with \ntotal-duration=" + str(duration)
+          + "\nthreads=" + str(threads) + "\nops_per_thread="
+          + str(ops_per_thread) + "\nwrite_buffer_size="
+          + str(write_buf_size) + "\n")
+
+    # kill in every alternate run. toggle tracks which run we are doing.
+    toggle = True
+
+    while time.time() < exit_time:
+        run_had_errors = False
+        additional_opts = ' --disable_seek_compaction=' + \
+                          str(random.randint(0, 1)) + \
+                          ' --mmap_read=' + str(random.randint(0, 1)) + \
+                          ' --block_size=16384 ' + \
+                          ' --cache_size=1048576 ' + \
+                          ' --open_files=500000 ' + \
+                          ' --verify_checksum=1 ' + \
+                          ' --sync=' + str(random.randint(0, 1)) + \
+                          ' --disable_wal=0 ' + \
+                          ' --disable_data_sync=' + \
+                          str(random.randint(0, 1)) + \
+                          ' --target_file_size_base=2097152 ' + \
+                          ' --target_file_size_multiplier=2 ' + \
+                          ' --max_write_buffer_number=3 ' + \
+                          ' --max_background_compactions=20 ' + \
+                          ' --max_bytes_for_level_base=10485760 ' + \
+                          ' --filter_deletes=' + str(random.randint(0, 1))
+        print ("Running db_stress with additional options=\n"
+               + additional_opts + "\n")
+
+        if toggle:
+            # since we are going to kill anyway, use more ops per thread
+            new_ops_per_thread = 100 * ops_per_thread
+            killoption = '--kill_random_test=' + str(kill_random_test)
+        else:
+            new_ops_per_thread = ops_per_thread
+            killoption = ''
+
+        toggle = not toggle
+
+        cmd = ['./db_stress \
+                --test_batches_snapshots=1 \
+                --ops_per_thread=0' + str(new_ops_per_thread) + ' \
+                --threads=0' + str(threads) + ' \
+                --write_buffer_size=' + str(write_buf_size) + ' \
+                --destroy_db_initially=0 ' + killoption + ' \
+                --reopen=0 \
+                --readpercent=50 \
+                --db=' + dirpath + ' \
+                --max_key=100000000 ' + additional_opts]
+
+        popen = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                 stderr=subprocess.STDOUT,
+                                 shell=True)
+        stdoutdata, stderrdata = popen.communicate()
+        retncode = popen.returncode
+        msg = ("kill option = {0}, exitcode = {1}".format(
+               killoption, retncode))
+        print msg
+        print stdoutdata
+
+        expected = False
+        if (killoption == '') and (retncode == 0):
+            # we expect zero retncode if no kill option
+            expected = True
+        elif killoption != '' and retncode < 0:
+            # we expect negative retncode if kill option was given
+            expected = True
+
+        if not expected:
+            print "TEST FAILED. See kill option and exit code above!!!\n"
+            sys.exit(1)
+
+        stdoutdata = stdoutdata.lower()
+        errorcount = (stdoutdata.count('error') -
+                      stdoutdata.count('got errors 0 times'))
+        print "#times error occured in output is " + str(errorcount) + "\n"
+
+        if (errorcount > 0):
+            print "TEST FAILED. Output has 'error'!!!\n"
+            sys.exit(2)
+        if (stdoutdata.find('fail') >= 0):
+            print "TEST FAILED. Output has 'fail'!!!\n"
+            sys.exit(2)
+        time.sleep(1)  # time to stabilize after a kill
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

tools/db_stress.cc

@@ -21,7 +21,7 @@
 #include "db/version_set.h"
 #include "db/db_statistics.h"
 #include "leveldb/cache.h"
-#include "leveldb/db.h"
+#include "utilities/utility_db.h"
 #include "leveldb/env.h"
 #include "leveldb/write_batch.h"
 #include "leveldb/statistics.h"
@@ -31,6 +31,8 @@
 #include "util/mutexlock.h"
 #include "util/random.h"
 #include "util/testutil.h"
+#include "util/logging.h"
+#include "utilities/ttl/db_ttl.h"
 #include "hdfs/env_hdfs.h"
 
 static const long KB = 1024;
@@ -54,6 +56,11 @@ static bool FLAGS_test_batches_snapshots = false;
 // Number of concurrent threads to run.
 static int FLAGS_threads = 32;
 
+// Opens the db with this ttl value if this is not -1
+// Carefully specify a large value such that verifications on deleted
+//  values don't fail
+static int FLAGS_ttl = -1;
+
 // Size of each value will be this number times rand_int(1,3) bytes
 static int FLAGS_value_size_mult = 8;
 
@@ -103,6 +110,9 @@ static const char* FLAGS_db = nullptr;
 // Verify checksum for every block read from storage
 static bool FLAGS_verify_checksum = false;
 
+// Allow reads to occur via mmap-ing files
+static bool FLAGS_use_mmap_reads = leveldb::EnvOptions().use_mmap_reads;
+
 // Database statistics
 static std::shared_ptr<leveldb::Statistics> dbstats;
 
@@ -115,6 +125,10 @@ static bool FLAGS_disable_data_sync = false;
 // If true, issue fsync instead of fdatasync
 static bool FLAGS_use_fsync = false;
 
+// If non-zero, kill at various points in source code with probability 1/this
+static int FLAGS_kill_random_test = 0;
+extern int leveldb_kill_odds;
+
 // If true, do not write WAL for write.
 static bool FLAGS_disable_wal = false;
 
@@ -166,9 +180,11 @@ static uint32_t FLAGS_log2_keys_per_lock = 2; // implies 2^2 keys per lock
 // Percentage of times we want to purge redundant keys in memory before flushing
 static uint32_t FLAGS_purge_redundant_percent = 50;
 
-extern bool useOsBuffer;
-extern bool useFsReadAhead;
-extern bool useMmapRead;
+// On true, deletes use KeyMayExist to drop the delete if key not present
+static bool FLAGS_filter_deletes = false;
+
+// Level0 compaction start trigger
+static int FLAGS_level0_file_num_compaction_trigger = 0;
 
 namespace leveldb {
 
@@ -691,7 +707,7 @@ class StressTest {
         char expected_prefix = (keys[i])[0];
         char actual_prefix = (values[i])[0];
         if (actual_prefix != expected_prefix) {
-          fprintf(stderr, "expected prefix = %c actual = %c\n",
+          fprintf(stderr, "error expected prefix = %c actual = %c\n",
                   expected_prefix, actual_prefix);
         }
         (values[i])[0] = ' '; // blank out the differing character
@@ -703,7 +719,7 @@ class StressTest {
     // Now that we retrieved all values, check that they all match
     for (int i = 1; i < 10; i++) {
       if (values[i] != values[0]) {
-        fprintf(stderr, "inconsistent values for key %s: %s, %s\n",
+        fprintf(stderr, "error : inconsistent values for key %s: %s, %s\n",
                 key.ToString().c_str(), values[0].c_str(),
                 values[i].c_str());
       // we continue after error rather than exiting so that we can
@@ -862,6 +878,7 @@ class StressTest {
     for (size_t i=sizeof(uint32_t); i < value_sz; i++) {
       v[i] = (char)(rand ^ i);
     }
+    v[value_sz] = '\0';
     return value_sz; // the size of the value set.
   }
 
@@ -870,6 +887,11 @@ class StressTest {
             kMajorVersion, kMinorVersion);
     fprintf(stdout, "Number of threads   : %d\n", FLAGS_threads);
     fprintf(stdout, "Ops per thread      : %d\n", FLAGS_ops_per_thread);
+    std::string ttl_state("unused");
+    if (FLAGS_ttl > 0) {
+      ttl_state = NumberToString(FLAGS_ttl);
+    }
+    fprintf(stdout, "Time to live(sec)   : %s\n", ttl_state.c_str());
     fprintf(stdout, "Read percentage     : %d\n", FLAGS_readpercent);
     fprintf(stdout, "Write-buffer-size   : %d\n", FLAGS_write_buffer_size);
     fprintf(stdout, "Delete percentage   : %d\n", FLAGS_delpercent);
@@ -879,8 +901,10 @@ class StressTest {
     fprintf(stdout, "Num times DB reopens: %d\n", FLAGS_reopen);
     fprintf(stdout, "Batches/snapshots   : %d\n",
             FLAGS_test_batches_snapshots);
-    fprintf(stdout, "Purge redundant %%   : %d\n",
+    fprintf(stdout, "Purge redundant %%  : %d\n",
             FLAGS_purge_redundant_percent);
+    fprintf(stdout, "Deletes use filter  : %d\n",
+            FLAGS_filter_deletes);
     fprintf(stdout, "Num keys per lock   : %d\n",
             1 << FLAGS_log2_keys_per_lock);
 
@@ -918,6 +942,8 @@ class StressTest {
     options.env = FLAGS_env;
     options.disableDataSync = FLAGS_disable_data_sync;
     options.use_fsync = FLAGS_use_fsync;
+    options.allow_mmap_reads = FLAGS_use_mmap_reads;
+    leveldb_kill_odds = FLAGS_kill_random_test;
     options.target_file_size_base = FLAGS_target_file_size_base;
     options.target_file_size_multiplier = FLAGS_target_file_size_multiplier;
     options.max_bytes_for_level_base = FLAGS_max_bytes_for_level_base;
@@ -926,17 +952,29 @@ class StressTest {
     options.level0_stop_writes_trigger = FLAGS_level0_stop_writes_trigger;
     options.level0_slowdown_writes_trigger =
       FLAGS_level0_slowdown_writes_trigger;
+    options.level0_file_num_compaction_trigger =
+      FLAGS_level0_file_num_compaction_trigger;
     options.compression = FLAGS_compression_type;
     options.create_if_missing = true;
     options.disable_seek_compaction = FLAGS_disable_seek_compaction;
     options.delete_obsolete_files_period_micros =
       FLAGS_delete_obsolete_files_period_micros;
     options.max_manifest_file_size = 1024;
+    options.filter_deletes = FLAGS_filter_deletes;
     static Random purge_percent(1000); // no benefit from non-determinism here
     if (purge_percent.Uniform(100) < FLAGS_purge_redundant_percent - 1) {
       options.purge_redundant_kvs_while_flush = false;
     }
-    Status s = DB::Open(options, FLAGS_db, &db_);
+
+    fprintf(stdout, "DB path: [%s]\n", FLAGS_db);
+
+    Status s;
+    if (FLAGS_ttl == -1) {
+      s = DB::Open(options, FLAGS_db, &db_);
+    } else {
+      s = UtilityDB::OpenTtlDB(options, FLAGS_db, &sdb_, FLAGS_ttl);
+      db_ = sdb_;
+    }
     if (!s.ok()) {
       fprintf(stderr, "open error: %s\n", s.ToString().c_str());
       exit(1);
@@ -946,7 +984,11 @@ class StressTest {
   void Reopen() {
     // do not close the db. Just delete the lock file. This
     // simulates a crash-recovery kind of situation.
-    ((DBImpl*) db_)->TEST_Destroy_DBImpl();
+    if (FLAGS_ttl != -1) {
+      ((DBWithTTL*) db_)->TEST_Destroy_DBWithTtl();
+    } else {
+      ((DBImpl*) db_)->TEST_Destroy_DBImpl();
+    }
     db_ = nullptr;
 
     num_times_reopened_++;
@@ -959,10 +1001,7 @@ class StressTest {
 
   void PrintStatistics() {
     if (dbstats) {
-      fprintf(stdout, "File opened:%ld closed:%ld errors:%ld\n",
-              dbstats->getTickerCount(NO_FILE_OPENS),
-              dbstats->getTickerCount(NO_FILE_CLOSES),
-              dbstats->getTickerCount(NO_FILE_ERRORS));
+      fprintf(stdout, "STATISTICS:\n%s\n", dbstats->ToString().c_str());
     }
   }
 
@@ -970,6 +1009,7 @@ class StressTest {
   shared_ptr<Cache> cache_;
   const FilterPolicy* filter_policy_;
   DB* db_;
+  StackableDB* sdb_;
   int num_times_reopened_;
 };
 
@@ -981,6 +1021,12 @@ int main(int argc, char** argv) {
   FLAGS_open_files = leveldb::Options().max_open_files;
   FLAGS_max_background_compactions =
     leveldb::Options().max_background_compactions;
+  FLAGS_level0_file_num_compaction_trigger =
+    leveldb::Options().level0_file_num_compaction_trigger;
+  FLAGS_level0_slowdown_writes_trigger =
+    leveldb::Options().level0_slowdown_writes_trigger;
+  FLAGS_level0_stop_writes_trigger =
+    leveldb::Options().level0_stop_writes_trigger;
   // Compression test code above refers to FLAGS_block_size
   FLAGS_block_size = leveldb::Options().block_size;
   std::string default_db_path;
@@ -1017,6 +1063,8 @@ int main(int argc, char** argv) {
       FLAGS_test_batches_snapshots = n;
     } else if (sscanf(argv[i], "--threads=%d%c", &n, &junk) == 1) {
       FLAGS_threads = n;
+    } else if (sscanf(argv[i], "--ttl=%d%c", &n, &junk) == 1) {
+      FLAGS_ttl = n;
     } else if (sscanf(argv[i], "--value_size_mult=%d%c", &n, &junk) == 1) {
       FLAGS_value_size_mult = n;
     } else if (sscanf(argv[i], "--write_buffer_size=%d%c", &n, &junk) == 1) {
@@ -1040,19 +1088,13 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--verify_checksum=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
       FLAGS_verify_checksum = n;
-    } else if (sscanf(argv[i], "--bufferedio=%d%c", &n, &junk) == 1 &&
-               (n == 0 || n == 1)) {
-      useOsBuffer = n;
     } else if (sscanf(argv[i], "--mmap_read=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
-      useMmapRead = n;
-    } else if (sscanf(argv[i], "--readhead=%d%c", &n, &junk) == 1 &&
-               (n == 0 || n == 1)) {
-      useFsReadAhead = n;
+      FLAGS_use_mmap_reads = n;
     } else if (sscanf(argv[i], "--statistics=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
       if (n == 1) {
-        dbstats.reset(new leveldb::DBStatistics());
+        dbstats = leveldb::CreateDBStatistics();
       }
     } else if (sscanf(argv[i], "--sync=%d%c", &n, &junk) == 1 &&
                (n == 0 || n == 1)) {
@@ -1069,6 +1111,9 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--use_fsync=%d%c", &n, &junk) == 1 &&
         (n == 0 || n == 1)) {
       FLAGS_use_fsync = n;
+    } else if (sscanf(argv[i], "--kill_random_test=%d%c", &n, &junk) == 1 &&
+               (n >= 0)) {
+      FLAGS_kill_random_test = n;
     } else if (sscanf(argv[i], "--disable_wal=%d%c", &n, &junk) == 1 &&
         (n == 0 || n == 1)) {
       FLAGS_disable_wal = n;
@@ -1092,6 +1137,9 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i],"--level0_slowdown_writes_trigger=%d%c",
         &n, &junk) == 1) {
       FLAGS_level0_slowdown_writes_trigger = n;
+    } else if (sscanf(argv[i],"--level0_file_num_compaction_trigger=%d%c",
+        &n, &junk) == 1) {
+      FLAGS_level0_file_num_compaction_trigger = n;
     } else if (strncmp(argv[i], "--compression_type=", 19) == 0) {
       const char* ctype = argv[i] + 19;
       if (!strcasecmp(ctype, "none"))
@@ -1114,6 +1162,9 @@ int main(int argc, char** argv) {
     } else if (sscanf(argv[i], "--purge_redundant_percent=%d%c", &n, &junk) == 1
         && (n >= 0 && n <= 100)) {
       FLAGS_purge_redundant_percent = n;
+    } else if (sscanf(argv[i], "--filter_deletes=%d%c", &n, &junk)
+        == 1 && (n == 0 || n == 1)) {
+      FLAGS_filter_deletes = n;
     } else {
       fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
       exit(1);
@@ -1128,7 +1179,10 @@ int main(int argc, char** argv) {
       fprintf(stderr, "Error: Read + Delete percents > 100!\n");
       exit(1);
   }
-
+  if (FLAGS_disable_wal == 1 && FLAGS_reopen > 0) {
+      fprintf(stderr, "Error: Db cannot reopen safely with disable_wal set!\n");
+      exit(1);
+  }
   if ((unsigned)FLAGS_reopen >= FLAGS_ops_per_thread) {
       fprintf(stderr, "Error: #DB-reopens should be < ops_per_thread\n"
         "Provided reopens = %d and ops_per_thread = %u\n", FLAGS_reopen,

tools/ldb.cc

@@ -2,94 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "util/ldb_cmd.h"
-
-namespace leveldb {
-
-class LDBCommandRunner {
-public:
-
-  static void PrintHelp(const char* exec_name) {
-    string ret;
-
-    ret.append("ldb - LevelDB Tool");
-    ret.append("\n\n");
-    ret.append("All commands MUST specify --" + LDBCommand::ARG_DB +
-        "=<full_path_to_db_directory>\n");
-    ret.append("\n");
-    ret.append("The following optional parameters control if keys/values are "
-        "input/output as hex or as plain strings:\n");
-    ret.append("  --" + LDBCommand::ARG_KEY_HEX +
-        " : Keys are input/output as hex\n");
-    ret.append("  --" + LDBCommand::ARG_VALUE_HEX +
-        " : Values are input/output as hex\n");
-    ret.append("  --" + LDBCommand::ARG_HEX +
-        " : Both keys and values are input/output as hex\n");
-    ret.append("\n");
-
-    ret.append("The following optional parameters control the database "
-        "internals:\n");
-    ret.append("  --" + LDBCommand::ARG_BLOOM_BITS + "=<int,e.g.:14>\n");
-    ret.append("  --" + LDBCommand::ARG_COMPRESSION_TYPE +
-        "=<no|snappy|zlib|bzip2>\n");
-    ret.append("  --" + LDBCommand::ARG_BLOCK_SIZE +
-        "=<block_size_in_bytes>\n");
-    ret.append("  --" + LDBCommand::ARG_AUTO_COMPACTION + "=<true|false>\n");
-    ret.append("  --" + LDBCommand::ARG_WRITE_BUFFER_SIZE +
-        "=<int,e.g.:4194304>\n");
-    ret.append("  --" + LDBCommand::ARG_FILE_SIZE + "=<int,e.g.:2097152>\n");
-
-    ret.append("\n\n");
-    ret.append("Data Access Commands:\n");
-    PutCommand::Help(ret);
-    GetCommand::Help(ret);
-    BatchPutCommand::Help(ret);
-    ScanCommand::Help(ret);
-    DeleteCommand::Help(ret);
-    DBQuerierCommand::Help(ret);
-    ApproxSizeCommand::Help(ret);
-
-    ret.append("\n\n");
-    ret.append("Admin Commands:\n");
-    WALDumperCommand::Help(ret);
-    CompactorCommand::Help(ret);
-    ReduceDBLevelsCommand::Help(ret);
-    DBDumperCommand::Help(ret);
-    DBLoaderCommand::Help(ret);
-    ManifestDumpCommand::Help(ret);
-
-    fprintf(stderr, "%s\n", ret.c_str());
-  }
-
-  static void RunCommand(int argc, char** argv) {
-    if (argc <= 2) {
-      PrintHelp(argv[0]);
-      exit(1);
-    }
-
-    LDBCommand* cmdObj = LDBCommand::InitFromCmdLineArgs(argc, argv);
-    if (cmdObj == nullptr) {
-      fprintf(stderr, "Unknown command\n");
-      PrintHelp(argv[0]);
-      exit(1);
-    }
-
-    if (!cmdObj->ValidateCmdLineOptions()) {
-      exit(1);
-    }
-
-    cmdObj->Run();
-    LDBCommandExecuteResult ret = cmdObj->GetExecuteState();
-    fprintf(stderr, "%s\n", ret.ToString().c_str());
-    delete cmdObj;
-
-    exit(ret.IsFailed());
-  }
-
-};
-
-}
+#include "leveldb/ldb_tool.h"
 
 int main(int argc, char** argv) {
-  leveldb::LDBCommandRunner::RunCommand(argc, argv);
+  leveldb::LDBTool tool;
+  tool.Run(argc, argv);
+  return 0;
 }

tools/ldb_test.py

@@ -43,7 +43,7 @@ class LDBTestCase(unittest.TestCase):
     def dbParam(self, dbName):
         return "--db=%s" % os.path.join(self.TMP_DIR, dbName)
 
-    def assertRunOKFull(self, params, expectedOutput):
+    def assertRunOKFull(self, params, expectedOutput, unexpected=False):
         """
         All command-line params must be specified.
         Allows full flexibility in testing; for example: missing db param.
@@ -52,7 +52,10 @@ class LDBTestCase(unittest.TestCase):
 
         output = my_check_output("./ldb %s |grep -v \"Created bg thread\"" %
                             params, shell=True)
-        self.assertEquals(output.strip(), expectedOutput.strip());
+        if not unexpected:
+            self.assertEqual(output.strip(), expectedOutput.strip())
+        else:
+            self.assertNotEqual(output.strip(), expectedOutput.strip())
 
     def assertRunFAILFull(self, params):
         """
@@ -70,13 +73,13 @@ class LDBTestCase(unittest.TestCase):
             "Exception should have been raised for command with params: %s" %
             params)
 
-    def assertRunOK(self, params, expectedOutput):
+    def assertRunOK(self, params, expectedOutput, unexpected=False):
         """
         Uses the default test db.
 
         """
         self.assertRunOKFull("%s %s" % (self.dbParam(self.DB_NAME), params),
-                expectedOutput)
+                             expectedOutput, unexpected)
 
     def assertRunFAIL(self, params):
         """
@@ -123,7 +126,7 @@ class LDBTestCase(unittest.TestCase):
         self.assertRunOK("scan", "x2 : y2\nx3 : y3")
 
         self.assertRunOK("delete NonExistentKey", "OK")
-        # It is wierd that GET and SCAN raise exception for
+        # It is weird that GET and SCAN raise exception for
         # non-existent key, while delete does not
 
     def dumpDb(self, params, dumpFile):
@@ -142,6 +145,16 @@ class LDBTestCase(unittest.TestCase):
         self.assertRunFAIL("batchput k1")
         self.assertRunFAIL("batchput k1 v1 k2")
 
+    def testInvalidCmdLines(self):
+        print "Running testInvalidCmdLines..."
+        # db not specified
+        self.assertRunFAILFull("put 0x6133 0x6233 --hex --create_if_missing")
+        # No param called he
+        self.assertRunFAIL("put 0x6133 0x6233 --he --create_if_missing")
+        # max_keys is not applicable for put
+        self.assertRunFAIL("put 0x6133 0x6233 --max_keys=1 --create_if_missing")
+        # hex has invalid boolean value
+
     def testHexPutGet(self):
         print "Running testHexPutGet..."
         self.assertRunOK("put a1 b1 --create_if_missing", "OK")
@@ -171,6 +184,18 @@ class LDBTestCase(unittest.TestCase):
         self.assertRunOK("delete --hex 0x6133", "OK")
         self.assertRunOK("scan", "a1 : b1\na2 : b2\na4 : b4")
 
+    def testTtlPutGet(self):
+        print "Running testTtlPutGet..."
+        self.assertRunOK("put a1 b1 --ttl --create_if_missing", "OK")
+        self.assertRunOK("scan ", "a1 : b1", True)
+        self.assertRunOK("dump --ttl ", "a1 ==> b1", True)
+        self.assertRunOK("scan --hex --ttl", "0x6131 : 0x6231")
+        self.assertRunOK("get a1", "b1", True)
+        self.assertRunOK("get --ttl a1", "b1")
+        self.assertRunOK("put a3 b3 --create_if_missing", "OK")
+        # fails because timstamp's length is greater than value's
+        self.assertRunFAIL("get --ttl a3")
+
     def testInvalidCmdLines(self):
         print "Running testInvalidCmdLines..."
         # db not specified

tools/sst_dump.cc

@@ -1,4 +1,4 @@
-#include "leveldb/table.h"
+#include "table/table.h"
 
 #include <map>
 #include <string>
@@ -34,7 +34,7 @@ private:
   uint64_t read_num_;
   bool verify_checksum_;
   bool output_hex_;
-  StorageOptions soptions_;
+  EnvOptions soptions_;
 };
 
 SstFileReader::SstFileReader(std::string file_path,

util/arena_impl.cc

@@ -2,27 +2,32 @@
 // 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 "util/arena.h"
-#include <assert.h>
+#include "util/arena_impl.h"
 
 namespace leveldb {
 
-static const int kBlockSize = 4096;
+ArenaImpl::ArenaImpl(size_t block_size) {
+  if (block_size < kMinBlockSize) {
+    block_size_ = kMinBlockSize;
+  } else if (block_size > kMaxBlockSize) {
+    block_size_ = kMaxBlockSize;
+  } else {
+    block_size_ = block_size;
+  }
 
-Arena::Arena() {
   blocks_memory_ = 0;
   alloc_ptr_ = nullptr;  // First allocation will allocate a block
   alloc_bytes_remaining_ = 0;
 }
 
-Arena::~Arena() {
+ArenaImpl::~ArenaImpl() {
   for (size_t i = 0; i < blocks_.size(); i++) {
     delete[] blocks_[i];
   }
 }
 
-char* Arena::AllocateFallback(size_t bytes) {
-  if (bytes > kBlockSize / 4) {
+char* ArenaImpl::AllocateFallback(size_t bytes) {
+  if (bytes > block_size_ / 4) {
     // Object is more than a quarter of our block size.  Allocate it separately
     // to avoid wasting too much space in leftover bytes.
     char* result = AllocateNewBlock(bytes);
@@ -30,8 +35,8 @@ char* Arena::AllocateFallback(size_t bytes) {
   }
 
   // We waste the remaining space in the current block.
-  alloc_ptr_ = AllocateNewBlock(kBlockSize);
-  alloc_bytes_remaining_ = kBlockSize;
+  alloc_ptr_ = AllocateNewBlock(block_size_);
+  alloc_bytes_remaining_ = block_size_;
 
   char* result = alloc_ptr_;
   alloc_ptr_ += bytes;
@@ -39,7 +44,7 @@ char* Arena::AllocateFallback(size_t bytes) {
   return result;
 }
 
-char* Arena::AllocateAligned(size_t bytes) {
+char* ArenaImpl::AllocateAligned(size_t bytes) {
   const int align = sizeof(void*);    // We'll align to pointer size
   assert((align & (align-1)) == 0);   // Pointer size should be a power of 2
   size_t current_mod = reinterpret_cast<uintptr_t>(alloc_ptr_) & (align-1);
@@ -58,7 +63,7 @@ char* Arena::AllocateAligned(size_t bytes) {
   return result;
 }
 
-char* Arena::AllocateNewBlock(size_t block_bytes) {
+char* ArenaImpl::AllocateNewBlock(size_t block_bytes) {
   char* result = new char[block_bytes];
   blocks_memory_ += block_bytes;
   blocks_.push_back(result);

util/arena_impl.h

@@ -2,38 +2,53 @@
 // 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_UTIL_ARENA_H_
-#define STORAGE_LEVELDB_UTIL_ARENA_H_
+// ArenaImpl is an implementation of Arena class. For a request of small size,
+// it allocates a block with pre-defined block size. For a request of big
+// size, it uses malloc to directly get the requested size.
+
+#ifndef STORAGE_LEVELDB_UTIL_ARENA_IMPL_H_
+#define STORAGE_LEVELDB_UTIL_ARENA_IMPL_H_
 
 #include <cstddef>
 #include <vector>
 #include <assert.h>
 #include <stdint.h>
+#include "leveldb/arena.h"
 
 namespace leveldb {
 
-class Arena {
+class ArenaImpl : public Arena {
  public:
-  Arena();
-  ~Arena();
+  explicit ArenaImpl(size_t block_size = kMinBlockSize);
+  virtual ~ArenaImpl();
 
-  // Return a pointer to a newly allocated memory block of "bytes" bytes.
-  char* Allocate(size_t bytes);
+  virtual char* Allocate(size_t bytes);
 
-  // Allocate memory with the normal alignment guarantees provided by malloc
-  char* AllocateAligned(size_t bytes);
+  virtual char* AllocateAligned(size_t bytes);
 
   // Returns an estimate of the total memory usage of data allocated
   // by the arena (including space allocated but not yet used for user
   // allocations).
-  size_t MemoryUsage() const {
+  //
+  // TODO: Do we need to exclude space allocated but not used?
+  virtual const size_t ApproximateMemoryUsage() {
     return blocks_memory_ + blocks_.capacity() * sizeof(char*);
   }
 
+  virtual const size_t MemoryAllocatedBytes() {
+    return blocks_memory_;
+  }
+
  private:
   char* AllocateFallback(size_t bytes);
   char* AllocateNewBlock(size_t block_bytes);
 
+  static const size_t kMinBlockSize = 4096;
+  static const size_t kMaxBlockSize = 2 << 30;
+
+  // Number of bytes allocated in one block
+  size_t block_size_;
+
   // Allocation state
   char* alloc_ptr_;
   size_t alloc_bytes_remaining_;
@@ -45,11 +60,11 @@ class Arena {
   size_t blocks_memory_;
 
   // No copying allowed
-  Arena(const Arena&);
-  void operator=(const Arena&);
+  ArenaImpl(const ArenaImpl&);
+  void operator=(const ArenaImpl&);
 };
 
-inline char* Arena::Allocate(size_t bytes) {
+inline char* ArenaImpl::Allocate(size_t bytes) {
   // The semantics of what to return are a bit messy if we allow
   // 0-byte allocations, so we disallow them here (we don't need
   // them for our internal use).
@@ -65,4 +80,4 @@ inline char* Arena::Allocate(size_t bytes) {
 
 }  // namespace leveldb
 
-#endif  // STORAGE_LEVELDB_UTIL_ARENA_H_
+#endif  // STORAGE_LEVELDB_UTIL_ARENA_IMPL_H_

util/arena_test.cc

@@ -2,22 +2,59 @@
 // 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 "util/arena.h"
-
+#include "util/arena_impl.h"
 #include "util/random.h"
 #include "util/testharness.h"
 
 namespace leveldb {
 
-class ArenaTest { };
+class ArenaImplTest { };
 
-TEST(ArenaTest, Empty) {
-  Arena arena;
+TEST(ArenaImplTest, Empty) {
+  ArenaImpl arena0;
 }
 
-TEST(ArenaTest, Simple) {
+TEST(ArenaImplTest, MemoryAllocatedBytes) {
+  const int N = 17;
+  size_t req_sz;  //requested size
+  size_t bsz = 8192;  // block size
+  size_t expected_memory_allocated;
+
+  ArenaImpl arena_impl(bsz);
+
+  // requested size > quarter of a block:
+  //   allocate requested size separately
+  req_sz = 3001;
+  for (int i = 0; i < N; i++) {
+    arena_impl.Allocate(req_sz);
+  }
+  expected_memory_allocated = req_sz * N;
+  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);
+
+  // requested size < quarter of a block:
+  //   allocate a block with the default size, then try to use unused part
+  //   of the block. So one new block will be allocated for the first
+  //   Allocate(99) call. All the remaining calls won't lead to new allocation.
+  req_sz = 99;
+  for (int i = 0; i < N; i++) {
+    arena_impl.Allocate(req_sz);
+  }
+  expected_memory_allocated += bsz;
+  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);
+
+  // requested size > quarter of a block:
+  //   allocate requested size separately
+  req_sz = 99999999;
+  for (int i = 0; i < N; i++) {
+    arena_impl.Allocate(req_sz);
+  }
+  expected_memory_allocated += req_sz * N;
+  ASSERT_EQ(arena_impl.MemoryAllocatedBytes(), expected_memory_allocated);
+}
+
+TEST(ArenaImplTest, Simple) {
   std::vector<std::pair<size_t, char*> > allocated;
-  Arena arena;
+  ArenaImpl arena_impl;
   const int N = 100000;
   size_t bytes = 0;
   Random rnd(301);
@@ -35,9 +72,9 @@ TEST(ArenaTest, Simple) {
     }
     char* r;
     if (rnd.OneIn(10)) {
-      r = arena.AllocateAligned(s);
+      r = arena_impl.AllocateAligned(s);
     } else {
-      r = arena.Allocate(s);
+      r = arena_impl.Allocate(s);
     }
 
     for (unsigned int b = 0; b < s; b++) {
@@ -46,9 +83,9 @@ TEST(ArenaTest, Simple) {
     }
     bytes += s;
     allocated.push_back(std::make_pair(s, r));
-    ASSERT_GE(arena.MemoryUsage(), bytes);
+    ASSERT_GE(arena_impl.ApproximateMemoryUsage(), bytes);
     if (i > N/10) {
-      ASSERT_LE(arena.MemoryUsage(), bytes * 1.10);
+      ASSERT_LE(arena_impl.ApproximateMemoryUsage(), bytes * 1.10);
     }
   }
   for (unsigned int i = 0; i < allocated.size(); i++) {

util/auto_roll_logger.cc

@@ -1,4 +1,5 @@
 #include "util/auto_roll_logger.h"
+#include "util/mutexlock.h"
 
 using namespace std;
 
@@ -35,17 +36,26 @@ void AutoRollLogger::RollLogFile() {
 void AutoRollLogger::Logv(const char* format, va_list ap) {
   assert(GetStatus().ok());
 
-  if (kLogFileTimeToRoll > 0 && LogExpired()) {
-    RollLogFile();
-    ResetLogger();
+  std::shared_ptr<Logger> logger;
+  {
+    MutexLock l(&mutex_);
+    if ((kLogFileTimeToRoll > 0 && LogExpired()) ||
+        (kMaxLogFileSize > 0 && logger_->GetLogFileSize() >= kMaxLogFileSize)) {
+      RollLogFile();
+      ResetLogger();
+    }
+
+    // pin down the current logger_ instance before releasing the mutex.
+    logger = logger_;
   }
 
-  logger_->Logv(format, ap);
-
-  if (kMaxLogFileSize > 0 && logger_->GetLogFileSize() > kMaxLogFileSize) {
-    RollLogFile();
-    ResetLogger();
-  }
+  // Another thread could have put a new Logger instance into logger_ by now.
+  // However, since logger is still hanging on to the previous instance
+  // (reference count is not zero), we don't have to worry about it being
+  // deleted while we are accessing it.
+  // Note that logv itself is not mutex protected to allow maximum concurrency,
+  // as thread safety should have been handled by the underlying logger.
+  logger->Logv(format, ap);
 }
 
 bool AutoRollLogger::LogExpired() {

util/auto_roll_logger.h

@@ -8,8 +8,9 @@
 #ifndef STORAGE_LEVELDB_UTIL_AUTO_ROLL_LOGGER_H
 #define STORAGE_LEVELDB_UTIL_AUTO_ROLL_LOGGER_H
 
-#include "util/posix_logger.h"
 #include "db/filename.h"
+#include "port/port.h"
+#include "util/posix_logger.h"
 
 namespace leveldb {
 
@@ -29,7 +30,8 @@ class AutoRollLogger : public Logger {
      cached_now(static_cast<uint64_t>(env_->NowMicros() * 1e-6)),
      ctime_(cached_now),
      cached_now_access_count(0),
-     call_NowMicros_every_N_records_(100) {
+     call_NowMicros_every_N_records_(100),
+     mutex_() {
     env->GetAbsolutePath(dbname, &db_absolute_path_);
     log_fname_ = InfoLogFileName(dbname_, db_absolute_path_, db_log_dir_);
     RollLogFile();
@@ -75,6 +77,7 @@ class AutoRollLogger : public Logger {
   uint64_t ctime_;
   uint64_t cached_now_access_count;
   uint64_t call_NowMicros_every_N_records_;
+  port::Mutex mutex_;
 };
 
 // Facade to craete logger automatically

util/auto_roll_logger_test.cc

@@ -78,7 +78,11 @@ void AutoRollLoggerTest::RollLogFileBySizeTest(AutoRollLogger* logger,
 
   // Now the log file will be rolled
   LogMessage(logger, log_message.c_str());
-  ASSERT_TRUE(0 == logger->GetLogFileSize());
+  // Since rotation is checked before actual logging, we need to
+  // trigger the rotation by logging another message.
+  LogMessage(logger, log_message.c_str());
+
+  ASSERT_TRUE(message_size == logger->GetLogFileSize());
 }
 
 uint64_t AutoRollLoggerTest::RollLogFileByTimeTest(

util/bit_set.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright 2009 Facebook
+ * @author Tudor Bosman (tudorb@facebook.com)
+ */
+
+#ifndef STORAGE_LEVELDB_UTIL_BIT_SET_H_
+#define STORAGE_LEVELDB_UTIL_BIT_SET_H_
+
+#include <cassert>
+
+namespace leveldb {
+
+class BitSet {
+ public:
+  /**
+   * Create a bit set of numBits, with the bits set to either true or false.
+   */
+  explicit BitSet(size_t numBits, bool initial=false)
+    : numBits_(numBits),
+      data_(numWords(), initial ? ~0UL : 0UL) {
+  }
+
+  /**
+   * Set bit b to 1.
+   */
+  void set(size_t b) {
+    assert(b >= 0 && b < numBits_);
+    data_[word(b)] |= wordOffsetMask(b);
+  }
+
+  /**
+   * Set bit b to 0;
+   */
+  void reset(size_t b) {
+    assert(b >= 0 && b < numBits_);
+    data_[word(b)] &= ~wordOffsetMask(b);
+  }
+
+  /**
+   * Get a bit.
+   */
+  bool test(int b) const {
+    return data_[word(b)] & wordOffsetMask(b);
+  }
+
+ /**
+   * Return the size of the BitSet, in bits.
+   */
+  size_t size() const {
+    return numBits_;
+  }
+
+ private:
+
+ inline size_t numWords() const {
+    if (numBits_ == 0) return 0;
+    return 1 + (numBits_-1) / (8*sizeof(unsigned long));
+  }
+  inline static size_t word(int b) {
+    return b / (8*sizeof(unsigned long));
+  }
+  inline static int wordOffset(int b) {
+    return b % (8*sizeof(unsigned long));
+  }
+  inline static unsigned long wordOffsetMask(int b) {
+    return 1UL << wordOffset(b);
+  }
+
+  size_t numBits_;
+  std::vector<unsigned long> data_;
+};
+
+}  // namespace facebook
+
+#endif // STORAGE_LEVELDB_UTIL_BIT_SET_H_

util/env.cc

@@ -3,7 +3,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "leveldb/env.h"
-#include "util/storage_options.h"
+#include "leveldb/options.h"
 
 namespace leveldb {
 
@@ -47,7 +47,7 @@ static Status DoWriteStringToFile(Env* env, const Slice& data,
                                   const std::string& fname,
                                   bool should_sync) {
   unique_ptr<WritableFile> file;
-  StorageOptions soptions;
+  EnvOptions soptions;
   Status s = env->NewWritableFile(fname, &file, soptions);
   if (!s.ok()) {
     return s;
@@ -73,7 +73,7 @@ Status WriteStringToFileSync(Env* env, const Slice& data,
 }
 
 Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
-  StorageOptions soptions;
+  EnvOptions soptions;
   data->clear();
   unique_ptr<SequentialFile> file;
   Status s = env->NewSequentialFile(fname, &file, soptions);
@@ -100,4 +100,26 @@ Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
 EnvWrapper::~EnvWrapper() {
 }
 
+namespace {  // anonymous namespace
+
+void AssignEnvOptions(EnvOptions* env_options, const Options& options) {
+  env_options->use_os_buffer = options.allow_os_buffer;
+  env_options->use_mmap_reads = options.allow_mmap_reads;
+  env_options->use_mmap_writes = options.allow_mmap_writes;
+  env_options->set_fd_cloexec = options.is_fd_close_on_exec;
+  env_options->bytes_per_sync = options.bytes_per_sync;
+}
+
+}
+
+EnvOptions::EnvOptions(const Options& options) {
+  AssignEnvOptions(this, options);
+}
+
+EnvOptions::EnvOptions() {
+  Options options;
+  AssignEnvOptions(this, options);
+}
+
+
 }  // namespace leveldb

util/env_posix.cc

@@ -22,6 +22,7 @@
 #include <unistd.h>
 #if defined(OS_LINUX)
 #include <linux/fs.h>
+#include <fcntl.h>
 #endif
 #if defined(LEVELDB_PLATFORM_ANDROID)
 #include <sys/stat.h>
@@ -32,6 +33,8 @@
 #include "util/coding.h"
 #include "util/logging.h"
 #include "util/posix_logger.h"
+#include "util/random.h"
+#include <signal.h>
 
 #if !defined(TMPFS_MAGIC)
 #define TMPFS_MAGIC 0x01021994
@@ -43,13 +46,13 @@
 #define EXT4_SUPER_MAGIC 0xEF53
 #endif
 
-bool useOsBuffer = 1;     // cache data in OS buffers
-bool useFsReadAhead = 1;  // allow filesystem to do readaheads
-bool useMmapRead = 0;     // do not use mmaps for reading files
-bool useMmapWrite = 1;    // use mmaps for appending to files
+// This is only set from db_stress.cc and for testing only.
+// If non-zero, kill at various points in source code with probability 1/this
+int leveldb_kill_odds = 0;
 
 namespace leveldb {
 
+
 namespace {
 
 // list of pathnames that are locked
@@ -60,20 +63,51 @@ static Status IOError(const std::string& context, int err_number) {
   return Status::IOError(context, strerror(err_number));
 }
 
+#ifdef NDEBUG
+// empty in release build
+#define TEST_KILL_RANDOM(leveldb_kill_odds)
+#else
+
+// Kill the process with probablity 1/odds for testing.
+static void TestKillRandom(int odds, const std::string& srcfile,
+                           int srcline) {
+  time_t curtime = time(nullptr);
+  Random r((uint32_t)curtime);
+
+  assert(odds > 0);
+  bool crash = r.OneIn(odds);
+  if (crash) {
+    fprintf(stdout, "Crashing at %s:%d\n", srcfile.c_str(), srcline);
+    fflush(stdout);
+    kill(getpid(), SIGTERM);
+  }
+}
+
+// To avoid crashing always at some frequently executed codepaths (during
+// kill random test), use this factor to reduce odds
+#define REDUCE_ODDS 2
+#define REDUCE_ODDS2 4
+
+#define TEST_KILL_RANDOM(leveldb_kill_odds) {   \
+  if (leveldb_kill_odds > 0) { \
+    TestKillRandom(leveldb_kill_odds, __FILE__, __LINE__);     \
+  } \
+}
+
+#endif
+
 class PosixSequentialFile: public SequentialFile {
  private:
   std::string filename_;
   FILE* file_;
   int fd_;
-  bool use_os_buffer = true;
+  bool use_os_buffer_;
 
  public:
   PosixSequentialFile(const std::string& fname, FILE* f,
       const EnvOptions& options)
-      : filename_(fname), file_(f) {
-    fd_ = fileno(f);
-    assert(!options.UseMmapReads());
-    use_os_buffer = options.UseOsBuffer();
+      : filename_(fname), file_(f), fd_(fileno(f)),
+        use_os_buffer_(options.use_os_buffer) {
   }
   virtual ~PosixSequentialFile() { fclose(file_); }
 
@@ -89,7 +123,7 @@ class PosixSequentialFile: public SequentialFile {
         s = IOError(filename_, errno);
       }
     }
-    if (!use_os_buffer) {
+    if (!use_os_buffer_) {
       // we need to fadvise away the entire range of pages because
       // we do not want readahead pages to be cached.
       posix_fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED); // free OS pages
@@ -110,17 +144,13 @@ class PosixRandomAccessFile: public RandomAccessFile {
  private:
   std::string filename_;
   int fd_;
-  bool use_os_buffer = true;
+  bool use_os_buffer_;
 
  public:
   PosixRandomAccessFile(const std::string& fname, int fd,
                         const EnvOptions& options)
-      : filename_(fname), fd_(fd) {
-    assert(!options.UseMmapReads());
-    if (!options.UseReadahead()) { // disable read-aheads
-      posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
-    }
-    use_os_buffer = options.UseOsBuffer();
+      : filename_(fname), fd_(fd), use_os_buffer_(options.use_os_buffer) {
+    assert(!options.use_mmap_reads);
   }
   virtual ~PosixRandomAccessFile() { close(fd_); }
 
@@ -133,7 +163,7 @@ class PosixRandomAccessFile: public RandomAccessFile {
       // An error: return a non-ok status
       s = IOError(filename_, errno);
     }
-    if (!use_os_buffer) {
+    if (!use_os_buffer_) {
       // we need to fadvise away the entire range of pages because
       // we do not want readahead pages to be cached.
       posix_fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED); // free OS pages
@@ -169,6 +199,30 @@ class PosixRandomAccessFile: public RandomAccessFile {
     return static_cast<size_t>(rid-id);
   }
 #endif
+
+  virtual void Hint(AccessPattern pattern) {
+    switch(pattern) {
+      case NORMAL:
+        posix_fadvise(fd_, 0, 0, POSIX_FADV_NORMAL);
+        break;
+      case RANDOM:
+        posix_fadvise(fd_, 0, 0, POSIX_FADV_RANDOM);
+        break;
+      case SEQUENTIAL:
+        posix_fadvise(fd_, 0, 0, POSIX_FADV_SEQUENTIAL);
+        break;
+      case WILLNEED:
+        posix_fadvise(fd_, 0, 0, POSIX_FADV_WILLNEED);
+        break;
+      case DONTNEED:
+        posix_fadvise(fd_, 0, 0, POSIX_FADV_DONTNEED);
+        break;
+      default:
+        assert(false);
+        break;
+    }
+  }
+
 };
 
 // mmap() based random-access
@@ -183,9 +237,8 @@ class PosixMmapReadableFile: public RandomAccessFile {
   PosixMmapReadableFile(const std::string& fname, void* base, size_t length,
                         const EnvOptions& options)
       : filename_(fname), mmapped_region_(base), length_(length) {
-    assert(options.UseMmapReads());
-    assert(options.UseOsBuffer());
-    assert(options.UseReadahead());
+    assert(options.use_mmap_reads);
+    assert(options.use_os_buffer);
   }
   virtual ~PosixMmapReadableFile() { munmap(mmapped_region_, length_); }
 
@@ -234,6 +287,7 @@ class PosixMmapFile : public WritableFile {
 
   bool UnmapCurrentRegion() {
     bool result = true;
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     if (base_ != nullptr) {
       if (last_sync_ < limit_) {
         // Defer syncing this data until next Sync() call, if any
@@ -259,18 +313,22 @@ class PosixMmapFile : public WritableFile {
   Status MapNewRegion() {
     assert(base_ == nullptr);
 
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     int alloc_status = posix_fallocate(fd_, file_offset_, map_size_);
     if (alloc_status != 0) {
       return Status::IOError("Error allocating space to file : " + filename_ +
         "Error : " + strerror(alloc_status));
     }
 
-
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     void* ptr = mmap(nullptr, map_size_, PROT_READ | PROT_WRITE, MAP_SHARED,
                      fd_, file_offset_);
     if (ptr == MAP_FAILED) {
       return Status::IOError("MMap failed on " + filename_);
     }
+
+    TEST_KILL_RANDOM(leveldb_kill_odds);
+
     base_ = reinterpret_cast<char*>(ptr);
     limit_ = base_ + map_size_;
     dst_ = base_;
@@ -292,7 +350,7 @@ class PosixMmapFile : public WritableFile {
         file_offset_(0),
         pending_sync_(false) {
     assert((page_size & (page_size - 1)) == 0);
-    assert(options.UseMmapWrites());
+    assert(options.use_mmap_writes);
   }
 
 
@@ -305,6 +363,7 @@ class PosixMmapFile : public WritableFile {
   virtual Status Append(const Slice& data) {
     const char* src = data.data();
     size_t left = data.size();
+    TEST_KILL_RANDOM(leveldb_kill_odds * REDUCE_ODDS);
     PrepareWrite(GetFileSize(), left);
     while (left > 0) {
       assert(base_ <= dst_);
@@ -316,6 +375,7 @@ class PosixMmapFile : public WritableFile {
           if (!s.ok()) {
             return s;
           }
+          TEST_KILL_RANDOM(leveldb_kill_odds);
         }
       }
 
@@ -325,12 +385,16 @@ class PosixMmapFile : public WritableFile {
       src += n;
       left -= n;
     }
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     return Status::OK();
   }
 
   virtual Status Close() {
     Status s;
     size_t unused = limit_ - dst_;
+
+    TEST_KILL_RANDOM(leveldb_kill_odds);
+
     if (!UnmapCurrentRegion()) {
       s = IOError(filename_, errno);
     } else if (unused > 0) {
@@ -340,6 +404,8 @@ class PosixMmapFile : public WritableFile {
       }
     }
 
+    TEST_KILL_RANDOM(leveldb_kill_odds);
+
     if (close(fd_) < 0) {
       if (s.ok()) {
         s = IOError(filename_, errno);
@@ -353,6 +419,7 @@ class PosixMmapFile : public WritableFile {
   }
 
   virtual Status Flush() {
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     return Status::OK();
   }
 
@@ -361,10 +428,12 @@ class PosixMmapFile : public WritableFile {
 
     if (pending_sync_) {
       // Some unmapped data was not synced
+      TEST_KILL_RANDOM(leveldb_kill_odds);
       pending_sync_ = false;
       if (fdatasync(fd_) < 0) {
         s = IOError(filename_, errno);
       }
+      TEST_KILL_RANDOM(leveldb_kill_odds * REDUCE_ODDS);
     }
 
     if (dst_ > last_sync_) {
@@ -373,9 +442,11 @@ class PosixMmapFile : public WritableFile {
       size_t p1 = TruncateToPageBoundary(last_sync_ - base_);
       size_t p2 = TruncateToPageBoundary(dst_ - base_ - 1);
       last_sync_ = dst_;
+      TEST_KILL_RANDOM(leveldb_kill_odds);
       if (msync(base_ + p1, p2 - p1 + page_size_, MS_SYNC) < 0) {
         s = IOError(filename_, errno);
       }
+      TEST_KILL_RANDOM(leveldb_kill_odds);
     }
 
     return s;
@@ -387,10 +458,12 @@ class PosixMmapFile : public WritableFile {
   virtual Status Fsync() {
     if (pending_sync_) {
       // Some unmapped data was not synced
+      TEST_KILL_RANDOM(leveldb_kill_odds);
       pending_sync_ = false;
       if (fsync(fd_) < 0) {
         return IOError(filename_, errno);
       }
+      TEST_KILL_RANDOM(leveldb_kill_odds);
     }
     // This invocation to Sync will not issue the call to
     // fdatasync because pending_sync_ has already been cleared.
@@ -409,6 +482,7 @@ class PosixMmapFile : public WritableFile {
 
 #ifdef OS_LINUX
   virtual Status Allocate(off_t offset, off_t len) {
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     if (!fallocate(fd_, FALLOC_FL_KEEP_SIZE, offset, len)) {
       return Status::OK();
     } else {
@@ -429,6 +503,8 @@ class PosixWritableFile : public WritableFile {
   uint64_t filesize_;
   bool pending_sync_;
   bool pending_fsync_;
+  uint64_t last_sync_size_;
+  uint64_t bytes_per_sync_;
 
  public:
   PosixWritableFile(const std::string& fname, int fd, size_t capacity,
@@ -440,8 +516,10 @@ class PosixWritableFile : public WritableFile {
     buf_(new char[capacity]),
     filesize_(0),
     pending_sync_(false),
-    pending_fsync_(false) {
-    assert(!options.UseMmapWrites());
+    pending_fsync_(false),
+    last_sync_size_(0),
+    bytes_per_sync_(options.bytes_per_sync) {
+    assert(!options.use_mmap_writes);
   }
 
   ~PosixWritableFile() {
@@ -457,6 +535,8 @@ class PosixWritableFile : public WritableFile {
     pending_sync_ = true;
     pending_fsync_ = true;
 
+    TEST_KILL_RANDOM(leveldb_kill_odds * REDUCE_ODDS2);
+
     PrepareWrite(GetFileSize(), left);
     // if there is no space in the cache, then flush
     if (cursize_ + left > capacity_) {
@@ -483,6 +563,8 @@ class PosixWritableFile : public WritableFile {
         if (done < 0) {
           return IOError(filename_, errno);
         }
+        TEST_KILL_RANDOM(leveldb_kill_odds);
+
         left -= done;
         src += done;
       }
@@ -496,6 +578,9 @@ class PosixWritableFile : public WritableFile {
     s = Flush(); // flush cache to OS
     if (!s.ok()) {
     }
+
+    TEST_KILL_RANDOM(leveldb_kill_odds);
+
     if (close(fd_) < 0) {
       if (s.ok()) {
         s = IOError(filename_, errno);
@@ -507,6 +592,7 @@ class PosixWritableFile : public WritableFile {
 
   // write out the cached data to the OS cache
   virtual Status Flush() {
+    TEST_KILL_RANDOM(leveldb_kill_odds * REDUCE_ODDS2);
     size_t left = cursize_;
     char* src = buf_.get();
     while (left != 0) {
@@ -514,25 +600,41 @@ class PosixWritableFile : public WritableFile {
       if (done < 0) {
         return IOError(filename_, errno);
       }
+      TEST_KILL_RANDOM(leveldb_kill_odds * REDUCE_ODDS2);
       left -= done;
       src += done;
     }
     cursize_ = 0;
+
+    // sync OS cache to disk for every bytes_per_sync_
+    // TODO: give log file and sst file different options (log
+    // files could be potentially cached in OS for their whole
+    // life time, thus we might not want to flush at all).
+    if (bytes_per_sync_ &&
+        filesize_ - last_sync_size_ >= bytes_per_sync_) {
+      RangeSync(last_sync_size_, filesize_ - last_sync_size_);
+      last_sync_size_ = filesize_;
+    }
+
     return Status::OK();
   }
 
   virtual Status Sync() {
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     if (pending_sync_ && fdatasync(fd_) < 0) {
       return IOError(filename_, errno);
     }
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     pending_sync_ = false;
     return Status::OK();
   }
 
   virtual Status Fsync() {
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     if (pending_fsync_ && fsync(fd_) < 0) {
       return IOError(filename_, errno);
     }
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     pending_fsync_ = false;
     pending_sync_ = false;
     return Status::OK();
@@ -544,12 +646,21 @@ class PosixWritableFile : public WritableFile {
 
 #ifdef OS_LINUX
   virtual Status Allocate(off_t offset, off_t len) {
+    TEST_KILL_RANDOM(leveldb_kill_odds);
     if (!fallocate(fd_, FALLOC_FL_KEEP_SIZE, offset, len)) {
       return Status::OK();
     } else {
       return IOError(filename_, errno);
     }
   }
+
+  virtual Status RangeSync(off64_t offset, off64_t nbytes) {
+    if (sync_file_range(fd_, offset, nbytes, SYNC_FILE_RANGE_WRITE) == 0) {
+      return Status::OK();
+    } else {
+      return IOError(filename_, errno);
+    }
+  }
 #endif
 };
 
@@ -606,7 +717,7 @@ class PosixEnv : public Env {
   }
 
   void SetFD_CLOEXEC(int fd, const EnvOptions* options) {
-    if ((options == nullptr || options->IsFDCloseOnExec()) && fd > 0) {
+    if ((options == nullptr || options->set_fd_cloexec) && fd > 0) {
       fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
     }
   }
@@ -636,7 +747,7 @@ class PosixEnv : public Env {
     SetFD_CLOEXEC(fd, &options);
     if (fd < 0) {
       s = IOError(fname, errno);
-    } else if (options.UseMmapReads() && sizeof(void*) >= 8) {
+    } else if (options.use_mmap_reads && sizeof(void*) >= 8) {
       // Use of mmap for random reads has been removed because it
       // kills performance when storage is fast.
       // Use mmap when virtual address-space is plentiful.
@@ -667,7 +778,7 @@ class PosixEnv : public Env {
       s = IOError(fname, errno);
     } else {
       SetFD_CLOEXEC(fd, &options);
-      if (options.UseMmapWrites()) {
+      if (options.use_mmap_writes) {
         if (!checkedDiskForMmap_) {
           // this will be executed once in the program's lifetime.
           // do not use mmapWrite on non ext-3/xfs/tmpfs systems.
@@ -677,7 +788,7 @@ class PosixEnv : public Env {
           checkedDiskForMmap_ = true;
         }
       }
-      if (options.UseMmapWrites() && !forceMmapOff) {
+      if (options.use_mmap_writes && !forceMmapOff) {
         result->reset(new PosixMmapFile(fname, fd, page_size_, options));
       } else {
         result->reset(new PosixWritableFile(fname, fd, 65536, options));
@@ -1080,9 +1191,8 @@ void PosixEnv::StartThread(void (*function)(void* arg), void* arg) {
 
 }  // namespace
 
-static PosixEnv default_env;
-
 Env* Env::Default() {
+  static PosixEnv default_env;
   return &default_env;
 }
 

util/env_test.cc

@@ -8,7 +8,6 @@
 #include "port/port.h"
 #include "util/coding.h"
 #include "util/testharness.h"
-#include "util/storage_options.h"
 
 namespace leveldb {
 
@@ -120,7 +119,7 @@ char temp_id[MAX_ID_SIZE];
 
 TEST(EnvPosixTest, RandomAccessUniqueID) {
   // Create file.
-  const StorageOptions soptions;
+  const EnvOptions soptions;
   std::string fname = test::TmpDir() + "/" + "testfile";
   unique_ptr<WritableFile> wfile;
   ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions));
@@ -174,7 +173,7 @@ bool HasPrefix(const std::unordered_set<std::string>& ss) {
 
 TEST(EnvPosixTest, RandomAccessUniqueIDConcurrent) {
   // Check whether a bunch of concurrently existing files have unique IDs.
-  const StorageOptions soptions;
+  const EnvOptions soptions;
 
   // Create the files
   std::vector<std::string> fnames;
@@ -210,7 +209,7 @@ TEST(EnvPosixTest, RandomAccessUniqueIDConcurrent) {
 }
 
 TEST(EnvPosixTest, RandomAccessUniqueIDDeletes) {
-  const StorageOptions soptions;
+  const EnvOptions soptions;
   std::string fname = test::TmpDir() + "/" + "testfile";
 
   // Check that after file is deleted we don't get same ID again in a new file.

util/histogram.cc

@@ -85,10 +85,6 @@ void HistogramImpl::Add(uint64_t value) {
   sum_squares_ += (value * value);
 }
 
-void HistogramImpl::Add(double value) {
-  Add(static_cast<uint64_t>(value));
-}
-
 void HistogramImpl::Merge(const HistogramImpl& other) {
   if (other.min_ < min_) min_ = other.min_;
   if (other.max_ > max_) max_ = other.max_;
@@ -152,8 +148,10 @@ std::string HistogramImpl::ToString() const {
            (num_ == 0.0 ? 0.0 : min_), Median(), max_);
   r.append(buf);
   snprintf(buf, sizeof(buf),
-           "Percentiles: P50: %.2f P75: %.2f P99: %.2f P99.9: %.2f\n",
-           Percentile(50), Percentile(75), Percentile(99), Percentile(99.9));
+           "Percentiles: "
+           "P50: %.2f P75: %.2f P99: %.2f P99.9: %.2f P99.99: %.2f\n",
+           Percentile(50), Percentile(75), Percentile(99), Percentile(99.9),
+           Percentile(99.99));
   r.append(buf);
   r.append("------------------------------------------------------\n");
   const double mult = 100.0 / num_;

util/histogram.h

@@ -53,7 +53,6 @@ class HistogramImpl {
   virtual ~HistogramImpl() {}
   virtual void Clear();
   virtual void Add(uint64_t value);
-  virtual void Add(double value);
   void Merge(const HistogramImpl& other);
 
   virtual std::string ToString() const;

util/ldb_cmd.cc

@@ -3,36 +3,33 @@
 // found in the LICENSE file.
 
 #include "util/ldb_cmd.h"
-#include <dirent.h>
 
-#include <sstream>
-#include <string>
-#include <stdexcept>
-
-#include "leveldb/write_batch.h"
 #include "db/dbformat.h"
+#include "db/db_impl.h"
 #include "db/log_reader.h"
 #include "db/filename.h"
 #include "db/write_batch_internal.h"
+#include "leveldb/write_batch.h"
+#include "util/coding.h"
+
+#include <ctime>
+#include <dirent.h>
+#include <sstream>
+#include <string>
+#include <stdexcept>
 
 namespace leveldb {
 
 using namespace std;
 
-vector<string> stringSplit(string arg, char delim) {
-  vector<string> splits;
-  stringstream ss(arg);
-  string item;
-  while(getline(ss, item, delim)) {
-    splits.push_back(item);
-  }
-  return splits;
-}
-
 const string LDBCommand::ARG_DB = "db";
 const string LDBCommand::ARG_HEX = "hex";
 const string LDBCommand::ARG_KEY_HEX = "key_hex";
 const string LDBCommand::ARG_VALUE_HEX = "value_hex";
+const string LDBCommand::ARG_TTL = "ttl";
+const string LDBCommand::ARG_TTL_START = "start_time";
+const string LDBCommand::ARG_TTL_END = "end_time";
+const string LDBCommand::ARG_TIMESTAMP = "timestamp";
 const string LDBCommand::ARG_FROM = "from";
 const string LDBCommand::ARG_TO = "to";
 const string LDBCommand::ARG_MAX_KEYS = "max_keys";
@@ -46,12 +43,16 @@ const string LDBCommand::ARG_CREATE_IF_MISSING = "create_if_missing";
 
 const char* LDBCommand::DELIM = " ==> ";
 
-LDBCommand* LDBCommand::InitFromCmdLineArgs(int argc, char** argv) {
+LDBCommand* LDBCommand::InitFromCmdLineArgs(
+  int argc,
+  char** argv,
+  const Options& options
+) {
   vector<string> args;
   for (int i = 1; i < argc; i++) {
     args.push_back(argv[i]);
   }
-  return InitFromCmdLineArgs(args);
+  return InitFromCmdLineArgs(args, options);
 }
 
 /**
@@ -64,33 +65,34 @@ LDBCommand* LDBCommand::InitFromCmdLineArgs(int argc, char** argv) {
  * Command name is not included in args.
  * Returns nullptr if the command-line cannot be parsed.
  */
-LDBCommand* LDBCommand::InitFromCmdLineArgs(const vector<string>& args) {
+LDBCommand* LDBCommand::InitFromCmdLineArgs(
+  const vector<string>& args,
+  const Options& options
+) {
   // --x=y command line arguments are added as x->y map entries.
-  map<string, string> options;
+  map<string, string> option_map;
 
   // Command-line arguments of the form --hex end up in this array as hex
   vector<string> flags;
 
-  // Everything other than options and flags. Represents commands
+  // Everything other than option_map and flags. Represents commands
   // and their parameters.  For eg: put key1 value1 go into this vector.
   vector<string> cmdTokens;
 
   const string OPTION_PREFIX = "--";
 
-  for (vector<string>::const_iterator itr = args.begin();
-      itr != args.end(); itr++) {
-    string arg = *itr;
+  for (const auto& arg : args) {
     if (arg[0] == '-' && arg[1] == '-'){
       vector<string> splits = stringSplit(arg, '=');
       if (splits.size() == 2) {
         string optionKey = splits[0].substr(OPTION_PREFIX.size());
-        options[optionKey] = splits[1];
+        option_map[optionKey] = splits[1];
       } else {
         string optionKey = splits[0].substr(OPTION_PREFIX.size());
         flags.push_back(optionKey);
       }
     } else {
-      cmdTokens.push_back(string(arg));
+      cmdTokens.push_back(arg);
     }
   }
 
@@ -101,38 +103,59 @@ LDBCommand* LDBCommand::InitFromCmdLineArgs(const vector<string>& args) {
 
   string cmd = cmdTokens[0];
   vector<string> cmdParams(cmdTokens.begin()+1, cmdTokens.end());
+  LDBCommand* command = LDBCommand::SelectCommand(
+    cmd,
+    cmdParams,
+    option_map,
+    flags
+  );
+
+  if (command) {
+    command->SetOptions(options);
+  }
+  return command;
+}
+
+LDBCommand* LDBCommand::SelectCommand(
+    const std::string& cmd,
+    const vector<string>& cmdParams,
+    const map<string, string>& option_map,
+    const vector<string>& flags
+  ) {
 
   if (cmd == GetCommand::Name()) {
-    return new GetCommand(cmdParams, options, flags);
+    return new GetCommand(cmdParams, option_map, flags);
   } else if (cmd == PutCommand::Name()) {
-    return new PutCommand(cmdParams, options, flags);
+    return new PutCommand(cmdParams, option_map, flags);
   } else if (cmd == BatchPutCommand::Name()) {
-    return new BatchPutCommand(cmdParams, options, flags);
+    return new BatchPutCommand(cmdParams, option_map, flags);
   } else if (cmd == ScanCommand::Name()) {
-    return new ScanCommand(cmdParams, options, flags);
+    return new ScanCommand(cmdParams, option_map, flags);
   } else if (cmd == DeleteCommand::Name()) {
-    return new DeleteCommand(cmdParams, options, flags);
+    return new DeleteCommand(cmdParams, option_map, flags);
   } else if (cmd == ApproxSizeCommand::Name()) {
-    return new ApproxSizeCommand(cmdParams, options, flags);
+    return new ApproxSizeCommand(cmdParams, option_map, flags);
   } else if (cmd == DBQuerierCommand::Name()) {
-    return new DBQuerierCommand(cmdParams, options, flags);
+    return new DBQuerierCommand(cmdParams, option_map, flags);
   } else if (cmd == CompactorCommand::Name()) {
-    return new CompactorCommand(cmdParams, options, flags);
+    return new CompactorCommand(cmdParams, option_map, flags);
   } else if (cmd == WALDumperCommand::Name()) {
-    return new WALDumperCommand(cmdParams, options, flags);
+    return new WALDumperCommand(cmdParams, option_map, flags);
   } else if (cmd == ReduceDBLevelsCommand::Name()) {
-    return new ReduceDBLevelsCommand(cmdParams, options, flags);
+    return new ReduceDBLevelsCommand(cmdParams, option_map, flags);
   } else if (cmd == DBDumperCommand::Name()) {
-    return new DBDumperCommand(cmdParams, options, flags);
+    return new DBDumperCommand(cmdParams, option_map, flags);
   } else if (cmd == DBLoaderCommand::Name()) {
-    return new DBLoaderCommand(cmdParams, options, flags);
+    return new DBLoaderCommand(cmdParams, option_map, flags);
   } else if (cmd == ManifestDumpCommand::Name()) {
-    return new ManifestDumpCommand(cmdParams, options, flags);
+    return new ManifestDumpCommand(cmdParams, option_map, flags);
+  } else if (cmd == InternalDumpCommand::Name()) {
+    return new InternalDumpCommand(cmdParams, option_map, flags);
   }
-
   return nullptr;
 }
 
+
 /**
  * Parses the specific integer option and fills in the value.
  * Returns true if the option is found.
@@ -141,10 +164,11 @@ LDBCommand* LDBCommand::InitFromCmdLineArgs(const vector<string>& args) {
  * updated.
  */
 bool LDBCommand::ParseIntOption(const map<string, string>& options,
-    string option, int& value, LDBCommandExecuteResult& exec_state) {
+                                const string& option, int& value,
+                                LDBCommandExecuteResult& exec_state) {
 
-  map<string, string>::const_iterator itr = options_.find(option);
-  if (itr != options_.end()) {
+  map<string, string>::const_iterator itr = option_map_.find(option);
+  if (itr != option_map_.end()) {
     try {
       value = stoi(itr->second);
       return true;
@@ -159,17 +183,32 @@ bool LDBCommand::ParseIntOption(const map<string, string>& options,
   return false;
 }
 
-leveldb::Options LDBCommand::PrepareOptionsForOpenDB() {
+/**
+ * Parses the specified option and fills in the value.
+ * Returns true if the option is found.
+ * Returns false otherwise.
+ */
+bool LDBCommand::ParseStringOption(const map<string, string>& options,
+                                   const string& option, string* value) {
+  auto itr = option_map_.find(option);
+  if (itr != option_map_.end()) {
+    *value = itr->second;
+    return true;
+  }
+  return false;
+}
 
-  leveldb::Options opt;
+Options LDBCommand::PrepareOptionsForOpenDB() {
+
+  Options opt = options_;
   opt.create_if_missing = false;
 
   map<string, string>::const_iterator itr;
 
   int bits;
-  if (ParseIntOption(options_, ARG_BLOOM_BITS, bits, exec_state_)) {
+  if (ParseIntOption(option_map_, ARG_BLOOM_BITS, bits, exec_state_)) {
     if (bits > 0) {
-      opt.filter_policy = leveldb::NewBloomFilterPolicy(bits);
+      opt.filter_policy = NewBloomFilterPolicy(bits);
     } else {
       exec_state_ = LDBCommandExecuteResult::FAILED(ARG_BLOOM_BITS +
                       " must be > 0.");
@@ -177,7 +216,7 @@ leveldb::Options LDBCommand::PrepareOptionsForOpenDB() {
   }
 
   int block_size;
-  if (ParseIntOption(options_, ARG_BLOCK_SIZE, block_size, exec_state_)) {
+  if (ParseIntOption(option_map_, ARG_BLOCK_SIZE, block_size, exec_state_)) {
     if (block_size > 0) {
       opt.block_size = block_size;
     } else {
@@ -186,22 +225,22 @@ leveldb::Options LDBCommand::PrepareOptionsForOpenDB() {
     }
   }
 
-  itr = options_.find(ARG_AUTO_COMPACTION);
-  if (itr != options_.end()) {
+  itr = option_map_.find(ARG_AUTO_COMPACTION);
+  if (itr != option_map_.end()) {
     opt.disable_auto_compactions = ! StringToBool(itr->second);
   }
 
-  itr = options_.find(ARG_COMPRESSION_TYPE);
-  if (itr != options_.end()) {
+  itr = option_map_.find(ARG_COMPRESSION_TYPE);
+  if (itr != option_map_.end()) {
     string comp = itr->second;
     if (comp == "no") {
-      opt.compression = leveldb::kNoCompression;
+      opt.compression = kNoCompression;
     } else if (comp == "snappy") {
-      opt.compression = leveldb::kSnappyCompression;
+      opt.compression = kSnappyCompression;
     } else if (comp == "zlib") {
-      opt.compression = leveldb::kZlibCompression;
+      opt.compression = kZlibCompression;
     } else if (comp == "bzip2") {
-      opt.compression = leveldb::kBZip2Compression;
+      opt.compression = kBZip2Compression;
     } else {
       // Unknown compression.
       exec_state_ = LDBCommandExecuteResult::FAILED(
@@ -210,7 +249,7 @@ leveldb::Options LDBCommand::PrepareOptionsForOpenDB() {
   }
 
   int write_buffer_size;
-  if (ParseIntOption(options_, ARG_WRITE_BUFFER_SIZE, write_buffer_size,
+  if (ParseIntOption(option_map_, ARG_WRITE_BUFFER_SIZE, write_buffer_size,
         exec_state_)) {
     if (write_buffer_size > 0) {
       opt.write_buffer_size = write_buffer_size;
@@ -221,7 +260,7 @@ leveldb::Options LDBCommand::PrepareOptionsForOpenDB() {
   }
 
   int file_size;
-  if (ParseIntOption(options_, ARG_FILE_SIZE, file_size, exec_state_)) {
+  if (ParseIntOption(option_map_, ARG_FILE_SIZE, file_size, exec_state_)) {
     if (file_size > 0) {
       opt.target_file_size_base = file_size;
     } else {
@@ -260,8 +299,8 @@ bool LDBCommand::ParseKeyValue(const string& line, string* key, string* value,
  */
 bool LDBCommand::ValidateCmdLineOptions() {
 
-  for (map<string, string>::const_iterator itr = options_.begin();
-        itr != options_.end(); itr++) {
+  for (map<string, string>::const_iterator itr = option_map_.begin();
+        itr != option_map_.end(); itr++) {
     if (find(valid_cmd_line_options_.begin(),
           valid_cmd_line_options_.end(), itr->first) ==
           valid_cmd_line_options_.end()) {
@@ -280,7 +319,7 @@ bool LDBCommand::ValidateCmdLineOptions() {
     }
   }
 
-  if (options_.find(ARG_DB) == options_.end()) {
+  if (!NoDBOpen() && option_map_.find(ARG_DB) == option_map_.end()) {
     fprintf(stderr, "%s must be specified\n", ARG_DB.c_str());
     return false;
   }
@@ -326,13 +365,13 @@ void CompactorCommand::Help(string& ret) {
 
 void CompactorCommand::DoCommand() {
 
-  leveldb::Slice* begin = nullptr;
-  leveldb::Slice* end = nullptr;
+  Slice* begin = nullptr;
+  Slice* end = nullptr;
   if (!null_from_) {
-    begin = new leveldb::Slice(from_);
+    begin = new Slice(from_);
   }
   if (!null_to_) {
-    end = new leveldb::Slice(to_);
+    end = new Slice(to_);
   }
 
   db_->CompactRange(begin, end);
@@ -372,8 +411,8 @@ void DBLoaderCommand::Help(string& ret) {
   ret.append("\n");
 }
 
-leveldb::Options DBLoaderCommand::PrepareOptionsForOpenDB() {
-  leveldb::Options opt = LDBCommand::PrepareOptionsForOpenDB();
+Options DBLoaderCommand::PrepareOptionsForOpenDB() {
+  Options opt = LDBCommand::PrepareOptionsForOpenDB();
   opt.create_if_missing = create_if_missing_;
   if (bulk_load_) {
     opt.PrepareForBulkLoad();
@@ -431,7 +470,7 @@ void ManifestDumpCommand::Help(string& ret) {
 ManifestDumpCommand::ManifestDumpCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
     LDBCommand(options, flags, false,
-               BuildCmdLineOptions({ARG_VERBOSE,ARG_PATH})),
+               BuildCmdLineOptions({ARG_VERBOSE, ARG_PATH, ARG_HEX})),
     verbose_(false),
     path_("")
 {
@@ -486,7 +525,7 @@ void ManifestDumpCommand::DoCommand() {
   }
 
   Options options;
-  StorageOptions sopt;
+  EnvOptions sopt;
   std::string file(manifestfile);
   std::string dbname("dummy");
   TableCache* tc = new TableCache(dbname, &options, sopt, 10);
@@ -506,15 +545,158 @@ void ManifestDumpCommand::DoCommand() {
 
 // ----------------------------------------------------------------------------
 
+string ReadableTime(int unixtime) {
+  char time_buffer [80];
+  time_t rawtime = unixtime;
+  struct tm * timeinfo = localtime(&rawtime);
+  strftime(time_buffer, 80, "%c", timeinfo);
+  return string(time_buffer);
+}
+
+// This function only called when it's the sane case of >1 buckets in time-range
+// Also called only when timekv falls between ttl_start and ttl_end provided
+void IncBucketCounts(vector<uint64_t>& bucket_counts, int ttl_start,
+      int time_range, int bucket_size, int timekv, int num_buckets) {
+  assert(time_range > 0 && timekv >= ttl_start && bucket_size > 0 &&
+    timekv < (ttl_start + time_range) && num_buckets > 1);
+  int bucket = (timekv - ttl_start) / bucket_size;
+  bucket_counts[bucket]++;
+}
+
+void PrintBucketCounts(const vector<uint64_t>& bucket_counts, int ttl_start,
+      int ttl_end, int bucket_size, int num_buckets) {
+  int time_point = ttl_start;
+  for(int i = 0; i < num_buckets - 1; i++, time_point += bucket_size) {
+    fprintf(stdout, "Keys in range %s to %s : %lu\n",
+            ReadableTime(time_point).c_str(),
+            ReadableTime(time_point + bucket_size).c_str(), bucket_counts[i]);
+  }
+  fprintf(stdout, "Keys in range %s to %s : %lu\n",
+          ReadableTime(time_point).c_str(),
+          ReadableTime(ttl_end).c_str(), bucket_counts[num_buckets - 1]);
+}
+
+const string InternalDumpCommand::ARG_COUNT_ONLY = "count_only";
+const string InternalDumpCommand::ARG_STATS = "stats";
+
+InternalDumpCommand::InternalDumpCommand(const vector<string>& params,
+                                         const map<string, string>& options,
+                                         const vector<string>& flags) :
+    LDBCommand(options, flags, true,
+               BuildCmdLineOptions({ ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
+                                     ARG_FROM, ARG_TO, ARG_MAX_KEYS,
+                                     ARG_COUNT_ONLY, ARG_STATS})),
+    has_from_(false),
+    has_to_(false),
+    max_keys_(-1),
+    count_only_(false),
+    print_stats_(false) {
+
+  has_from_ = ParseStringOption(options, ARG_FROM, &from_);
+  has_to_ = ParseStringOption(options, ARG_TO, &to_);
+
+  ParseIntOption(options, ARG_MAX_KEYS, max_keys_, exec_state_);
+
+  print_stats_ = IsFlagPresent(flags, ARG_STATS);
+  count_only_ = IsFlagPresent(flags, ARG_COUNT_ONLY);
+
+  if (is_key_hex_) {
+    if (has_from_) {
+      from_ = HexToString(from_);
+    }
+    if (has_to_) {
+      to_ = HexToString(to_);
+    }
+  }
+}
+
+void InternalDumpCommand::Help(string& ret) {
+  ret.append("  ");
+  ret.append(InternalDumpCommand::Name());
+  ret.append(HelpRangeCmdArgs());
+  ret.append(" [--" + ARG_MAX_KEYS + "=<N>]");
+  ret.append(" [--" + ARG_COUNT_ONLY + "]");
+  ret.append(" [--" + ARG_STATS + "]");
+  ret.append("\n");
+}
+
+void InternalDumpCommand::DoCommand() {
+  if (!db_) {
+    return;
+  }
+
+  if (print_stats_) {
+    string stats;
+    if (db_->GetProperty("leveldb.stats", &stats)) {
+      fprintf(stdout, "%s\n", stats.c_str());
+    }
+  }
+
+  // Cast as DBImpl to get internal iterator
+  DBImpl* idb = dynamic_cast<DBImpl*>(db_);
+  if (!idb) {
+    exec_state_ = LDBCommandExecuteResult::FAILED("DB is not DBImpl");
+    return;
+  }
+
+  // Setup internal key iterator
+  auto iter = unique_ptr<Iterator>(idb->TEST_NewInternalIterator());
+  Status st = iter->status();
+  if (!st.ok()) {
+    exec_state_ = LDBCommandExecuteResult::FAILED("Iterator error:"
+                                                  + st.ToString());
+  }
+
+  if (has_from_) {
+    InternalKey ikey(from_, kMaxSequenceNumber, kValueTypeForSeek);
+    iter->Seek(ikey.Encode());
+  } else {
+    iter->SeekToFirst();
+  }
+
+  long long count = 0;
+  for (; iter->Valid(); iter->Next()) {
+    ParsedInternalKey ikey;
+    if (!ParseInternalKey(iter->key(), &ikey)) {
+      fprintf(stderr, "Internal Key [%s] parse error!\n",
+              iter->key().ToString(true /* in hex*/).data());
+      // TODO: add error counter
+      continue;
+    }
+
+    // If end marker was specified, we stop before it
+    if (has_to_ && options_.comparator->Compare(ikey.user_key, to_) >= 0) {
+      break;
+    }
+
+    ++count;
+
+    if (!count_only_) {
+      string key = ikey.DebugString(is_key_hex_);
+      string value = iter->value().ToString(is_value_hex_);
+      fprintf(stdout, "%s => %s\n", key.data(), value.data());
+    }
+
+    // Terminate if maximum number of keys have been dumped
+    if (max_keys_ > 0 && count >= max_keys_) break;
+  }
+
+  fprintf(stdout, "Internal keys in range: %lld\n", (long long) count);
+}
+
+
 const string DBDumperCommand::ARG_COUNT_ONLY = "count_only";
 const string DBDumperCommand::ARG_STATS = "stats";
+const string DBDumperCommand::ARG_TTL_BUCKET = "bucket";
 
 DBDumperCommand::DBDumperCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
     LDBCommand(options, flags, true,
-               BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
-                                    ARG_FROM, ARG_TO, ARG_MAX_KEYS,
-                                    ARG_COUNT_ONLY, ARG_STATS})),
+               BuildCmdLineOptions({ARG_TTL, ARG_HEX, ARG_KEY_HEX,
+                                    ARG_VALUE_HEX, ARG_FROM, ARG_TO,
+                                    ARG_MAX_KEYS, ARG_COUNT_ONLY, ARG_STATS,
+                                    ARG_TTL_START, ARG_TTL_END,
+                                    ARG_TTL_BUCKET, ARG_TIMESTAMP})),
     null_from_(true),
     null_to_(true),
     max_keys_(-1),
@@ -542,7 +724,7 @@ DBDumperCommand::DBDumperCommand(const vector<string>& params,
                         " has an invalid value");
     } catch(const out_of_range&) {
       exec_state_ = LDBCommandExecuteResult::FAILED(ARG_MAX_KEYS +
-                        " has a valuei out-of-range");
+                        " has a value out-of-range");
     }
   }
 
@@ -563,9 +745,14 @@ void DBDumperCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(DBDumperCommand::Name());
   ret.append(HelpRangeCmdArgs());
+  ret.append(" [--" + ARG_TTL + "]");
   ret.append(" [--" + ARG_MAX_KEYS + "=<N>]");
+  ret.append(" [--" + ARG_TIMESTAMP + "]");
   ret.append(" [--" + ARG_COUNT_ONLY + "]");
   ret.append(" [--" + ARG_STATS + "]");
+  ret.append(" [--" + ARG_TTL_BUCKET + "=<N>]");
+  ret.append(" [--" + ARG_TTL_START + "=<N>:- is inclusive]");
+  ret.append(" [--" + ARG_TTL_END + "=<N>:- is exclusive]");
   ret.append("\n");
 }
 
@@ -583,8 +770,8 @@ void DBDumperCommand::DoCommand() {
   }
 
   // Setup key iterator
-  leveldb::Iterator* iter = db_->NewIterator(leveldb::ReadOptions());
-  leveldb::Status st = iter->status();
+  Iterator* iter = db_->NewIterator(ReadOptions());
+  Status st = iter->status();
   if (!st.ok()) {
     exec_state_ = LDBCommandExecuteResult::FAILED("Iterator error."
         + st.ToString());
@@ -597,25 +784,74 @@ void DBDumperCommand::DoCommand() {
   }
 
   int max_keys = max_keys_;
+  int ttl_start;
+  if (!ParseIntOption(option_map_, ARG_TTL_START, ttl_start, exec_state_)) {
+    ttl_start = DBWithTTL::kMinTimestamp; // TTL introduction time
+  }
+  int ttl_end;
+  if (!ParseIntOption(option_map_, ARG_TTL_END, ttl_end, exec_state_)) {
+    ttl_end = DBWithTTL::kMaxTimestamp; // Max time allowed by TTL feature
+  }
+  if (ttl_end < ttl_start) {
+    fprintf(stderr, "Error: End time can't be less than start time\n");
+    delete iter;
+    return;
+  }
+  int time_range = ttl_end - ttl_start;
+  int bucket_size;
+  if (!ParseIntOption(option_map_, ARG_TTL_BUCKET, bucket_size, exec_state_) ||
+      bucket_size <= 0) {
+    bucket_size = time_range; // Will have just 1 bucket by default
+  }
+  // At this point, bucket_size=0 => time_range=0
+  uint64_t num_buckets = (bucket_size >= time_range) ? 1 :
+    ((time_range + bucket_size - 1) / bucket_size);
+  vector<uint64_t> bucket_counts(num_buckets, 0);
+  if (is_db_ttl_ && !count_only_ && timestamp_) {
+    fprintf(stdout, "Dumping key-values from %s to %s\n",
+            ReadableTime(ttl_start).c_str(), ReadableTime(ttl_end).c_str());
+  }
+
   for (; iter->Valid(); iter->Next()) {
+    int rawtime = 0;
     // If end marker was specified, we stop before it
     if (!null_to_ && (iter->key().ToString() >= to_))
       break;
     // Terminate if maximum number of keys have been dumped
     if (max_keys == 0)
       break;
+    if (is_db_ttl_) {
+      TtlIterator* it_ttl = dynamic_cast<TtlIterator*>(iter);
+      assert(it_ttl);
+      rawtime = it_ttl->timestamp();
+      if (rawtime < ttl_start || rawtime >= ttl_end) {
+        continue;
+      }
+    }
     if (max_keys > 0) {
       --max_keys;
     }
+    if (is_db_ttl_ && num_buckets > 1) {
+      IncBucketCounts(bucket_counts, ttl_start, time_range, bucket_size,
+                      rawtime, num_buckets);
+    }
     ++count;
     if (!count_only_) {
+      if (is_db_ttl_ && timestamp_) {
+        fprintf(stdout, "%s ", ReadableTime(rawtime).c_str());
+      }
       string str = PrintKeyValue(iter->key().ToString(),
-                                      iter->value().ToString(),
-                                      is_key_hex_, is_value_hex_);
+                                 iter->value().ToString(), is_key_hex_,
+                                 is_value_hex_);
       fprintf(stdout, "%s\n", str.c_str());
     }
   }
-  fprintf(stdout, "Keys in range: %lld\n", (long long) count);
+  if (num_buckets > 1 && is_db_ttl_) {
+    PrintBucketCounts(bucket_counts, ttl_start, ttl_end, bucket_size,
+                      num_buckets);
+  } else {
+    fprintf(stdout, "Keys in range: %lld\n", (long long) count);
+  }
   // Clean up
   delete iter;
 }
@@ -632,7 +868,7 @@ ReduceDBLevelsCommand::ReduceDBLevelsCommand(const vector<string>& params,
     print_old_levels_(false) {
 
 
-  ParseIntOption(options_, ARG_NEW_LEVELS, new_levels_, exec_state_);
+  ParseIntOption(option_map_, ARG_NEW_LEVELS, new_levels_, exec_state_);
   print_old_levels_ = IsFlagPresent(flags, ARG_PRINT_OLD_LEVELS);
 
   if(new_levels_ <= 0) {
@@ -661,9 +897,10 @@ void ReduceDBLevelsCommand::Help(string& ret) {
   ret.append("\n");
 }
 
-leveldb::Options ReduceDBLevelsCommand::PrepareOptionsForOpenDB() {
-  leveldb::Options opt = LDBCommand::PrepareOptionsForOpenDB();
+Options ReduceDBLevelsCommand::PrepareOptionsForOpenDB() {
+  Options opt = LDBCommand::PrepareOptionsForOpenDB();
   opt.num_levels = old_levels_;
+  opt.max_bytes_for_level_multiplier_additional.resize(opt.num_levels, 1);
   // Disable size compaction
   opt.max_bytes_for_level_base = 1UL << 50;
   opt.max_bytes_for_level_multiplier = 1;
@@ -671,9 +908,9 @@ leveldb::Options ReduceDBLevelsCommand::PrepareOptionsForOpenDB() {
   return opt;
 }
 
-Status ReduceDBLevelsCommand::GetOldNumOfLevels(leveldb::Options& opt,
+Status ReduceDBLevelsCommand::GetOldNumOfLevels(Options& opt,
     int* levels) {
-  StorageOptions soptions;
+  EnvOptions soptions;
   TableCache tc(db_path_, &opt, soptions, 10);
   const InternalKeyComparator cmp(opt.comparator);
   VersionSet versions(db_path_, &opt, soptions, &tc, &cmp);
@@ -702,8 +939,8 @@ void ReduceDBLevelsCommand::DoCommand() {
     return;
   }
 
-  leveldb::Status st;
-  leveldb::Options opt = PrepareOptionsForOpenDB();
+  Status st;
+  Options opt = PrepareOptionsForOpenDB();
   int old_level_num = -1;
   st = GetOldNumOfLevels(opt, &old_level_num);
   if (!st.ok()) {
@@ -730,7 +967,7 @@ void ReduceDBLevelsCommand::DoCommand() {
   db_->CompactRange(nullptr, nullptr);
   CloseDB();
 
-  StorageOptions soptions;
+  EnvOptions soptions;
   TableCache tc(db_path_, &opt, soptions, 10);
   const InternalKeyComparator cmp(opt.comparator);
   VersionSet versions(db_path_, &opt, soptions, &tc, &cmp);
@@ -822,7 +1059,7 @@ void WALDumperCommand::DoCommand() {
 
   unique_ptr<SequentialFile> file;
   Env* env_ = Env::Default();
-  StorageOptions soptions;
+  EnvOptions soptions;
   Status status = env_->NewSequentialFile(wal_file_, &file, soptions);
   if (!status.ok()) {
     exec_state_ = LDBCommandExecuteResult::FAILED("Failed to open WAL file " +
@@ -882,8 +1119,9 @@ void WALDumperCommand::DoCommand() {
 
 GetCommand::GetCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
-  LDBCommand(options, flags, true,
-             BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX})) {
+  LDBCommand(options, flags, true, BuildCmdLineOptions({ARG_TTL, ARG_HEX,
+                                                        ARG_KEY_HEX,
+                                                        ARG_VALUE_HEX})) {
 
   if (params.size() != 1) {
     exec_state_ = LDBCommandExecuteResult::FAILED(
@@ -901,12 +1139,13 @@ void GetCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(GetCommand::Name());
   ret.append(" <key>");
+  ret.append(" [--" + ARG_TTL + "]");
   ret.append("\n");
 }
 
 void GetCommand::DoCommand() {
   string value;
-  leveldb::Status st = db_->Get(leveldb::ReadOptions(), key_, &value);
+  Status st = db_->Get(ReadOptions(), key_, &value);
   if (st.ok()) {
     fprintf(stdout, "%s\n",
               (is_value_hex_ ? StringToHex(value) : value).c_str());
@@ -953,8 +1192,8 @@ void ApproxSizeCommand::Help(string& ret) {
 
 void ApproxSizeCommand::DoCommand() {
 
-  leveldb::Range ranges[1];
-  ranges[0] = leveldb::Range(start_key_, end_key_);
+  Range ranges[1];
+  ranges[0] = Range(start_key_, end_key_);
   uint64_t sizes[1];
   db_->GetApproximateSizes(ranges, 1, sizes);
   fprintf(stdout, "%ld\n", sizes[0]);
@@ -970,7 +1209,7 @@ void ApproxSizeCommand::DoCommand() {
 BatchPutCommand::BatchPutCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
   LDBCommand(options, flags, false,
-             BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
+             BuildCmdLineOptions({ARG_TTL, ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
                                   ARG_CREATE_IF_MISSING})) {
 
   if (params.size() < 2) {
@@ -994,17 +1233,18 @@ void BatchPutCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(BatchPutCommand::Name());
   ret.append(" <key> <value> [<key> <value>] [..]");
+  ret.append(" [--" + ARG_TTL + "]");
   ret.append("\n");
 }
 
 void BatchPutCommand::DoCommand() {
-  leveldb::WriteBatch batch;
+  WriteBatch batch;
 
   for (vector<pair<string, string>>::const_iterator itr
         = key_values_.begin(); itr != key_values_.end(); itr++) {
       batch.Put(itr->first, itr->second);
   }
-  leveldb::Status st = db_->Write(leveldb::WriteOptions(), &batch);
+  Status st = db_->Write(WriteOptions(), &batch);
   if (st.ok()) {
     fprintf(stdout, "OK\n");
   } else {
@@ -1012,8 +1252,8 @@ void BatchPutCommand::DoCommand() {
   }
 }
 
-leveldb::Options BatchPutCommand::PrepareOptionsForOpenDB() {
-  leveldb::Options opt = LDBCommand::PrepareOptionsForOpenDB();
+Options BatchPutCommand::PrepareOptionsForOpenDB() {
+  Options opt = LDBCommand::PrepareOptionsForOpenDB();
   opt.create_if_missing = IsFlagPresent(flags_, ARG_CREATE_IF_MISSING);
   return opt;
 }
@@ -1022,8 +1262,9 @@ leveldb::Options BatchPutCommand::PrepareOptionsForOpenDB() {
 ScanCommand::ScanCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
     LDBCommand(options, flags, true,
-               BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
-                                    ARG_FROM, ARG_TO, ARG_MAX_KEYS})),
+               BuildCmdLineOptions({ARG_TTL, ARG_HEX, ARG_KEY_HEX, ARG_TO,
+                                    ARG_VALUE_HEX, ARG_FROM, ARG_TIMESTAMP,
+                                    ARG_MAX_KEYS, ARG_TTL_START, ARG_TTL_END})),
     start_key_specified_(false),
     end_key_specified_(false),
     max_keys_scanned_(-1) {
@@ -1063,23 +1304,55 @@ void ScanCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(ScanCommand::Name());
   ret.append(HelpRangeCmdArgs());
-  ret.append("--" + ARG_MAX_KEYS + "=N] ");
+  ret.append(" [--" + ARG_TTL + "]");
+  ret.append(" [--" + ARG_TIMESTAMP + "]");
+  ret.append(" [--" + ARG_MAX_KEYS + "=<N>q] ");
+  ret.append(" [--" + ARG_TTL_START + "=<N>:- is inclusive]");
+  ret.append(" [--" + ARG_TTL_END + "=<N>:- is exclusive]");
   ret.append("\n");
 }
 
 void ScanCommand::DoCommand() {
 
   int num_keys_scanned = 0;
-  Iterator* it = db_->NewIterator(leveldb::ReadOptions());
+  Iterator* it = db_->NewIterator(ReadOptions());
   if (start_key_specified_) {
     it->Seek(start_key_);
   } else {
     it->SeekToFirst();
   }
+  int ttl_start;
+  if (!ParseIntOption(option_map_, ARG_TTL_START, ttl_start, exec_state_)) {
+    ttl_start = DBWithTTL::kMinTimestamp; // TTL introduction time
+  }
+  int ttl_end;
+  if (!ParseIntOption(option_map_, ARG_TTL_END, ttl_end, exec_state_)) {
+    ttl_end = DBWithTTL::kMaxTimestamp; // Max time allowed by TTL feature
+  }
+  if (ttl_end < ttl_start) {
+    fprintf(stderr, "Error: End time can't be less than start time\n");
+    delete it;
+    return;
+  }
+  if (is_db_ttl_ && timestamp_) {
+    fprintf(stdout, "Scanning key-values from %s to %s\n",
+            ReadableTime(ttl_start).c_str(), ReadableTime(ttl_end).c_str());
+  }
   for ( ;
         it->Valid() && (!end_key_specified_ || it->key().ToString() < end_key_);
         it->Next()) {
     string key = it->key().ToString();
+    if (is_db_ttl_) {
+      TtlIterator* it_ttl = dynamic_cast<TtlIterator*>(it);
+      assert(it_ttl);
+      int rawtime = it_ttl->timestamp();
+      if (rawtime < ttl_start || rawtime >= ttl_end) {
+        continue;
+      }
+      if (timestamp_) {
+        fprintf(stdout, "%s ", ReadableTime(rawtime).c_str());
+      }
+    }
     string value = it->value().ToString();
     fprintf(stdout, "%s : %s\n",
           (is_key_hex_ ? StringToHex(key) : key).c_str(),
@@ -1120,7 +1393,7 @@ void DeleteCommand::Help(string& ret) {
 }
 
 void DeleteCommand::DoCommand() {
-  leveldb::Status st = db_->Delete(leveldb::WriteOptions(), key_);
+  Status st = db_->Delete(WriteOptions(), key_);
   if (st.ok()) {
     fprintf(stdout, "OK\n");
   } else {
@@ -1132,7 +1405,7 @@ void DeleteCommand::DoCommand() {
 PutCommand::PutCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags) :
   LDBCommand(options, flags, false,
-             BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
+             BuildCmdLineOptions({ARG_TTL, ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX,
                                   ARG_CREATE_IF_MISSING})) {
 
   if (params.size() != 2) {
@@ -1156,11 +1429,12 @@ void PutCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(PutCommand::Name());
   ret.append(" <key> <value> ");
+  ret.append(" [--" + ARG_TTL + "]");
   ret.append("\n");
 }
 
 void PutCommand::DoCommand() {
-  leveldb::Status st = db_->Put(leveldb::WriteOptions(), key_, value_);
+  Status st = db_->Put(WriteOptions(), key_, value_);
   if (st.ok()) {
     fprintf(stdout, "OK\n");
   } else {
@@ -1168,8 +1442,8 @@ void PutCommand::DoCommand() {
   }
 }
 
-leveldb::Options PutCommand::PrepareOptionsForOpenDB() {
-  leveldb::Options opt = LDBCommand::PrepareOptionsForOpenDB();
+Options PutCommand::PrepareOptionsForOpenDB() {
+  Options opt = LDBCommand::PrepareOptionsForOpenDB();
   opt.create_if_missing = IsFlagPresent(flags_, ARG_CREATE_IF_MISSING);
   return opt;
 }
@@ -1183,13 +1457,15 @@ const char* DBQuerierCommand::DELETE_CMD = "delete";
 DBQuerierCommand::DBQuerierCommand(const vector<string>& params,
     const map<string, string>& options, const vector<string>& flags) :
   LDBCommand(options, flags, false,
-             BuildCmdLineOptions({ARG_HEX, ARG_KEY_HEX, ARG_VALUE_HEX})) {
+             BuildCmdLineOptions({ARG_TTL, ARG_HEX, ARG_KEY_HEX,
+                                  ARG_VALUE_HEX})) {
 
 }
 
 void DBQuerierCommand::Help(string& ret) {
   ret.append("  ");
   ret.append(DBQuerierCommand::Name());
+  ret.append(" [--" + ARG_TTL + "]");
   ret.append("\n");
   ret.append("    Starts a REPL shell.  Type help for list of available "
              "commands.");
@@ -1201,8 +1477,8 @@ void DBQuerierCommand::DoCommand() {
     return;
   }
 
-  leveldb::ReadOptions read_options;
-  leveldb::WriteOptions write_options;
+  ReadOptions read_options;
+  WriteOptions write_options;
 
   string line;
   string key;

util/ldb_cmd.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef LEVELDB_UTIL_LDB_CMD_H_
-#define LEVELDB_UTIL_LDB_CMD_H_
+#ifndef STORAGE_LEVELDB_UTIL_LDB_CMD_H_
+#define STORAGE_LEVELDB_UTIL_LDB_CMD_H_
 
 #include <string>
 #include <iostream>
@@ -12,14 +12,16 @@
 #include <algorithm>
 #include <stdio.h>
 
-#include "leveldb/db.h"
+#include "db/version_set.h"
 #include "leveldb/env.h"
 #include "leveldb/options.h"
 #include "leveldb/iterator.h"
 #include "leveldb/slice.h"
-#include "db/version_set.h"
 #include "util/logging.h"
 #include "util/ldb_cmd_execute_result.h"
+#include "util/string_util.h"
+#include "utilities/utility_db.h"
+#include "utilities/ttl/db_ttl.h"
 
 using std::string;
 using std::map;
@@ -36,6 +38,10 @@ public:
   static const string ARG_HEX;
   static const string ARG_KEY_HEX;
   static const string ARG_VALUE_HEX;
+  static const string ARG_TTL;
+  static const string ARG_TTL_START;
+  static const string ARG_TTL_END;
+  static const string ARG_TIMESTAMP;
   static const string ARG_FROM;
   static const string ARG_TO;
   static const string ARG_MAX_KEYS;
@@ -47,11 +53,24 @@ public:
   static const string ARG_FILE_SIZE;
   static const string ARG_CREATE_IF_MISSING;
 
-  static LDBCommand* InitFromCmdLineArgs(const vector<string>& args);
-  static LDBCommand* InitFromCmdLineArgs(int argc, char** argv);
+  static LDBCommand* InitFromCmdLineArgs(
+    const vector<string>& args,
+    const Options& options = Options()
+  );
+
+  static LDBCommand* InitFromCmdLineArgs(
+    int argc,
+    char** argv,
+    const Options& options = Options()
+  );
+
   bool ValidateCmdLineOptions();
 
-  virtual leveldb::Options PrepareOptionsForOpenDB();
+  virtual Options PrepareOptionsForOpenDB();
+
+  virtual void SetOptions(Options options) {
+    options_ = options;
+  }
 
   virtual bool NoDBOpen() {
     return false;
@@ -129,8 +148,9 @@ public:
 protected:
 
   LDBCommandExecuteResult exec_state_;
-  std::string db_path_;
-  leveldb::DB* db_;
+  string db_path_;
+  DB* db_;
+  StackableDB* sdb_;
 
   /**
    * true implies that this command can work if the db is opened in read-only
@@ -144,10 +164,16 @@ protected:
   /** If true, the value is input/output as hex in get/put/scan/delete etc. */
   bool is_value_hex_;
 
+  /** If true, the value is treated as timestamp suffixed */
+  bool is_db_ttl_;
+
+  // If true, the kvs are output with their insert/modify timestamp in a ttl db
+  bool timestamp_;
+
   /**
    * Map of options passed on the command-line.
    */
-  const map<string, string> options_;
+  const map<string, string> option_map_;
 
   /**
    * Flags passed on the command-line.
@@ -166,7 +192,9 @@ protected:
       is_read_only_(is_read_only),
       is_key_hex_(false),
       is_value_hex_(false),
-      options_(options),
+      is_db_ttl_(false),
+      timestamp_(false),
+      option_map_(options),
       flags_(flags),
       valid_cmd_line_options_(valid_cmd_line_options) {
 
@@ -177,24 +205,35 @@ protected:
 
     is_key_hex_ = IsKeyHex(options, flags);
     is_value_hex_ = IsValueHex(options, flags);
+    is_db_ttl_ = IsFlagPresent(flags, ARG_TTL);
+    timestamp_ = IsFlagPresent(flags, ARG_TIMESTAMP);
   }
 
   void OpenDB() {
-    leveldb::Options opt = PrepareOptionsForOpenDB();
+    Options opt = PrepareOptionsForOpenDB();
     if (!exec_state_.IsNotStarted()) {
       return;
     }
     // Open the DB.
-    leveldb::Status st;
-    if (is_read_only_) {
-      st = leveldb::DB::OpenForReadOnly(opt, db_path_, &db_);
+    Status st;
+    if (is_db_ttl_) {
+      if (is_read_only_) {
+        st = UtilityDB::OpenTtlDB(opt, db_path_, &sdb_, 0, true);
+      } else {
+        st = UtilityDB::OpenTtlDB(opt, db_path_, &sdb_);
+      }
+      db_ = sdb_;
+    } else if (is_read_only_) {
+      st = DB::OpenForReadOnly(opt, db_path_, &db_);
     } else {
-      st = leveldb::DB::Open(opt, db_path_, &db_);
+      st = DB::Open(opt, db_path_, &db_);
     }
     if (!st.ok()) {
-      std::string msg = st.ToString();
+      string msg = st.ToString();
       exec_state_ = LDBCommandExecuteResult::FAILED(msg);
     }
+
+    options_ = opt;
   }
 
   void CloseDB () {
@@ -246,8 +285,13 @@ protected:
     return ret;
   }
 
-  bool ParseIntOption(const map<string, string>& options, string option,
-      int& value, LDBCommandExecuteResult& exec_state);
+  bool ParseIntOption(const map<string, string>& options, const string& option,
+                      int& value, LDBCommandExecuteResult& exec_state);
+
+  bool ParseStringOption(const map<string, string>& options,
+                         const string& option, string* value);
+
+  Options options_;
 
 private:
 
@@ -308,6 +352,13 @@ private:
     }
   }
 
+  static LDBCommand* SelectCommand(
+    const string& cmd,
+    const vector<string>& cmdParams,
+    const map<string, string>& option_map,
+    const vector<string>& flags
+  );
+
 };
 
 class CompactorCommand: public LDBCommand {
@@ -348,6 +399,32 @@ private:
   bool count_only_;
   bool print_stats_;
 
+  static const string ARG_COUNT_ONLY;
+  static const string ARG_STATS;
+  static const string ARG_TTL_BUCKET;
+};
+
+class InternalDumpCommand: public LDBCommand {
+public:
+  static string Name() { return "idump"; }
+
+  InternalDumpCommand(const vector<string>& params,
+                      const map<string, string>& options,
+                      const vector<string>& flags);
+
+  static void Help(string& ret);
+
+  virtual void DoCommand();
+
+private:
+  bool has_from_;
+  string from_;
+  bool has_to_;
+  string to_;
+  int max_keys_;
+  bool count_only_;
+  bool print_stats_;
+
   static const string ARG_COUNT_ONLY;
   static const string ARG_STATS;
 };
@@ -364,7 +441,7 @@ public:
   static void Help(string& ret);
   virtual void DoCommand();
 
-  virtual leveldb::Options PrepareOptionsForOpenDB();
+  virtual Options PrepareOptionsForOpenDB();
 
 private:
   bool create_if_missing_;
@@ -406,7 +483,7 @@ public:
   ReduceDBLevelsCommand(const vector<string>& params,
       const map<string, string>& options, const vector<string>& flags);
 
-  virtual leveldb::Options PrepareOptionsForOpenDB();
+  virtual Options PrepareOptionsForOpenDB();
 
   virtual void DoCommand();
 
@@ -427,7 +504,7 @@ private:
   static const string ARG_NEW_LEVELS;
   static const string ARG_PRINT_OLD_LEVELS;
 
-  Status GetOldNumOfLevels(leveldb::Options& opt, int* levels);
+  Status GetOldNumOfLevels(Options& opt, int* levels);
 };
 
 class WALDumperCommand : public LDBCommand {
@@ -497,7 +574,7 @@ public:
 
   static void Help(string& ret);
 
-  virtual leveldb::Options PrepareOptionsForOpenDB();
+  virtual Options PrepareOptionsForOpenDB();
 
 private:
   /**
@@ -551,7 +628,7 @@ public:
 
   static void Help(string& ret);
 
-  virtual leveldb::Options PrepareOptionsForOpenDB();
+  virtual Options PrepareOptionsForOpenDB();
 
 private:
   string key_;
@@ -580,5 +657,5 @@ private:
   static const char* DELETE_CMD;
 };
 
-}
-#endif
+} // namespace leveldb
+#endif // STORAGE_LEVELDB_UTIL_LDB_CMD_H_

util/ldb_tool.cc

@@ -0,0 +1,99 @@
+// Copyright 2008-present Facebook. All Rights Reserved.
+
+#include "leveldb/ldb_tool.h"
+#include "util/ldb_cmd.h"
+
+namespace leveldb {
+
+class LDBCommandRunner {
+public:
+
+  static void PrintHelp(const char* exec_name) {
+    string ret;
+
+    ret.append("ldb - LevelDB Tool");
+    ret.append("\n\n");
+    ret.append("commands MUST specify --" + LDBCommand::ARG_DB +
+        "=<full_path_to_db_directory> when necessary\n");
+    ret.append("\n");
+    ret.append("The following optional parameters control if keys/values are "
+        "input/output as hex or as plain strings:\n");
+    ret.append("  --" + LDBCommand::ARG_KEY_HEX +
+        " : Keys are input/output as hex\n");
+    ret.append("  --" + LDBCommand::ARG_VALUE_HEX +
+        " : Values are input/output as hex\n");
+    ret.append("  --" + LDBCommand::ARG_HEX +
+        " : Both keys and values are input/output as hex\n");
+    ret.append("\n");
+
+    ret.append("The following optional parameters control the database "
+        "internals:\n");
+    ret.append("  --" + LDBCommand::ARG_TTL +
+        " with 'put','get','scan','dump','query','batchput'"
+        " : DB supports ttl and value is internally timestamp-suffixed\n");
+    ret.append("  --" + LDBCommand::ARG_BLOOM_BITS + "=<int,e.g.:14>\n");
+    ret.append("  --" + LDBCommand::ARG_COMPRESSION_TYPE +
+        "=<no|snappy|zlib|bzip2>\n");
+    ret.append("  --" + LDBCommand::ARG_BLOCK_SIZE +
+        "=<block_size_in_bytes>\n");
+    ret.append("  --" + LDBCommand::ARG_AUTO_COMPACTION + "=<true|false>\n");
+    ret.append("  --" + LDBCommand::ARG_WRITE_BUFFER_SIZE +
+        "=<int,e.g.:4194304>\n");
+    ret.append("  --" + LDBCommand::ARG_FILE_SIZE + "=<int,e.g.:2097152>\n");
+
+    ret.append("\n\n");
+    ret.append("Data Access Commands:\n");
+    PutCommand::Help(ret);
+    GetCommand::Help(ret);
+    BatchPutCommand::Help(ret);
+    ScanCommand::Help(ret);
+    DeleteCommand::Help(ret);
+    DBQuerierCommand::Help(ret);
+    ApproxSizeCommand::Help(ret);
+
+    ret.append("\n\n");
+    ret.append("Admin Commands:\n");
+    WALDumperCommand::Help(ret);
+    CompactorCommand::Help(ret);
+    ReduceDBLevelsCommand::Help(ret);
+    DBDumperCommand::Help(ret);
+    DBLoaderCommand::Help(ret);
+    ManifestDumpCommand::Help(ret);
+    InternalDumpCommand::Help(ret);
+
+    fprintf(stderr, "%s\n", ret.c_str());
+  }
+
+  static void RunCommand(int argc, char** argv, Options options) {
+    if (argc <= 2) {
+      PrintHelp(argv[0]);
+      exit(1);
+    }
+
+    LDBCommand* cmdObj = LDBCommand::InitFromCmdLineArgs(argc, argv, options);
+    if (cmdObj == nullptr) {
+      fprintf(stderr, "Unknown command\n");
+      PrintHelp(argv[0]);
+      exit(1);
+    }
+
+    if (!cmdObj->ValidateCmdLineOptions()) {
+      exit(1);
+    }
+
+    cmdObj->Run();
+    LDBCommandExecuteResult ret = cmdObj->GetExecuteState();
+    fprintf(stderr, "%s\n", ret.ToString().c_str());
+    delete cmdObj;
+
+    exit(ret.IsFailed());
+  }
+
+};
+
+
+void LDBTool::Run(int argc, char** argv, Options options) {
+  LDBCommandRunner::RunCommand(argc, argv, options);
+}
+} // namespace leveldb
+

util/manual_compaction_test.cc

@@ -0,0 +1,88 @@
+// Test for issue 178: a manual compaction causes deleted data to reappear.
+#include <iostream>
+#include <sstream>
+#include <cstdlib>
+
+#include "leveldb/db.h"
+#include "leveldb/write_batch.h"
+#include "util/testharness.h"
+
+namespace {
+
+const int kNumKeys = 1100000;
+
+std::string Key1(int i) {
+  char buf[100];
+  snprintf(buf, sizeof(buf), "my_key_%d", i);
+  return buf;
+}
+
+std::string Key2(int i) {
+  return Key1(i) + "_xxx";
+}
+
+class ManualCompactionTest { };
+
+TEST(ManualCompactionTest, Test) {
+  // Get rid of any state from an old run.
+  std::string dbpath = leveldb::test::TmpDir() + "/leveldb_cbug_test";
+  DestroyDB(dbpath, leveldb::Options());
+
+  // Open database.  Disable compression since it affects the creation
+  // of layers and the code below is trying to test against a very
+  // specific scenario.
+  leveldb::DB* db;
+  leveldb::Options db_options;
+  db_options.create_if_missing = true;
+  db_options.compression = leveldb::kNoCompression;
+  ASSERT_OK(leveldb::DB::Open(db_options, dbpath, &db));
+
+  // create first key range
+  leveldb::WriteBatch batch;
+  for (int i = 0; i < kNumKeys; i++) {
+    batch.Put(Key1(i), "value for range 1 key");
+  }
+  ASSERT_OK(db->Write(leveldb::WriteOptions(), &batch));
+
+  // create second key range
+  batch.Clear();
+  for (int i = 0; i < kNumKeys; i++) {
+    batch.Put(Key2(i), "value for range 2 key");
+  }
+  ASSERT_OK(db->Write(leveldb::WriteOptions(), &batch));
+
+  // delete second key range
+  batch.Clear();
+  for (int i = 0; i < kNumKeys; i++) {
+    batch.Delete(Key2(i));
+  }
+  ASSERT_OK(db->Write(leveldb::WriteOptions(), &batch));
+
+  // compact database
+  std::string start_key = Key1(0);
+  std::string end_key = Key1(kNumKeys - 1);
+  leveldb::Slice least(start_key.data(), start_key.size());
+  leveldb::Slice greatest(end_key.data(), end_key.size());
+
+  // commenting out the line below causes the example to work correctly
+  db->CompactRange(&least, &greatest);
+
+  // count the keys
+  leveldb::Iterator* iter = db->NewIterator(leveldb::ReadOptions());
+  int num_keys = 0;
+  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+    num_keys++;
+  }
+  delete iter;
+  ASSERT_EQ(kNumKeys, num_keys) << "Bad number of keys";
+
+  // close database
+  delete db;
+  DestroyDB(dbpath, leveldb::Options());
+}
+
+}  // anonymous namespace
+
+int main(int argc, char** argv) {
+  return leveldb::test::RunAllTests();
+}

util/options.cc

@@ -6,15 +6,20 @@
 
 #include <limits>
 
+#include "leveldb/cache.h"
+#include "leveldb/compaction_filter.h"
 #include "leveldb/comparator.h"
 #include "leveldb/env.h"
 #include "leveldb/filter_policy.h"
-#include "leveldb/cache.h"
+#include "leveldb/merge_operator.h"
+#include "db/skiplistrep.h"
 
 namespace leveldb {
 
 Options::Options()
     : comparator(BytewiseComparator()),
+      merge_operator(nullptr),
+      compaction_filter(nullptr),
       create_if_missing(false),
       error_if_exists(false),
       paranoid_checks(false),
@@ -22,6 +27,7 @@ Options::Options()
       info_log(nullptr),
       write_buffer_size(4<<20),
       max_write_buffer_number(2),
+      min_write_buffer_number_to_merge(1),
       max_open_files(1000),
       block_size(4096),
       block_restart_interval(16),
@@ -36,6 +42,7 @@ Options::Options()
       target_file_size_multiplier(1),
       max_bytes_for_level_base(10 * 1048576),
       max_bytes_for_level_multiplier(10),
+      max_bytes_for_level_multiplier_additional(num_levels, 1),
       expanded_compaction_factor(25),
       source_compaction_factor(1),
       max_grandparent_overlap_factor(10),
@@ -49,30 +56,45 @@ Options::Options()
       max_log_file_size(0),
       log_file_time_to_roll(0),
       keep_log_file_num(1000),
-      rate_limit(0.0),
-      rate_limit_delay_milliseconds(1000),
+      soft_rate_limit(0.0),
+      hard_rate_limit(0.0),
+      rate_limit_delay_max_milliseconds(1000),
       max_manifest_file_size(std::numeric_limits<uint64_t>::max()),
       no_block_cache(false),
       table_cache_numshardbits(4),
-      compaction_filter_args(nullptr),
-      CompactionFilter(nullptr),
+      arena_block_size(0),
       disable_auto_compactions(false),
       WAL_ttl_seconds(0),
       manifest_preallocation_size(4 * 1024 * 1024),
       purge_redundant_kvs_while_flush(true),
       allow_os_buffer(true),
-      allow_readahead(true),
-      allow_readahead_compactions(true),
       allow_mmap_reads(false),
       allow_mmap_writes(true),
-      is_fd_close_on_exec(true) {
+      is_fd_close_on_exec(true),
+      skip_log_error_on_recovery(false),
+      stats_dump_period_sec(3600),
+      block_size_deviation (10),
+      advise_random_on_open(true),
+      access_hint_on_compaction_start(NORMAL),
+      use_adaptive_mutex(false),
+      bytes_per_sync(0),
+      filter_deletes(false),
+      memtable_factory(std::shared_ptr<SkipListFactory>(new SkipListFactory)) {
+  assert(memtable_factory.get() != nullptr);
 }
 
+static const char* const access_hints[] = {
+  "NONE", "NORMAL", "SEQUENTIAL", "WILLNEED"
+};
+
 void
 Options::Dump(Logger* log) const
 {
     Log(log,"              Options.comparator: %s", comparator->Name());
-    Log(log,"       Options.create_if_missing: %d", create_if_missing);
+    Log(log,"          Options.merge_operator: %s",
+        merge_operator? merge_operator->Name() : "None");
+    Log(log,"       Options.compaction_filter: %s",
+        compaction_filter? compaction_filter->Name() : "None");
     Log(log,"         Options.error_if_exists: %d", error_if_exists);
     Log(log,"         Options.paranoid_checks: %d", paranoid_checks);
     Log(log,"                     Options.env: %p", env);
@@ -108,11 +130,10 @@ Options::Dump(Logger* log) const
     Log(log," Options.db_stats_log_interval: %d",
         db_stats_log_interval);
     Log(log,"       Options.allow_os_buffer: %d", allow_os_buffer);
-    Log(log,"       Options.allow_readahead: %d", allow_readahead);
     Log(log,"      Options.allow_mmap_reads: %d", allow_mmap_reads);
     Log(log,"     Options.allow_mmap_writes: %d", allow_mmap_writes);
-    Log(log,"            Options.allow_readahead_compactions: %d",
-        allow_readahead_compactions);
+    Log(log,"       Options.min_write_buffer_number_to_merge: %d",
+        min_write_buffer_number_to_merge);
     Log(log,"        Options.purge_redundant_kvs_while_flush: %d",
          purge_redundant_kvs_while_flush);
     Log(log,"           Options.compression_opts.window_bits: %d",
@@ -137,6 +158,10 @@ Options::Dump(Logger* log) const
         max_bytes_for_level_base);
     Log(log,"         Options.max_bytes_for_level_multiplier: %d",
         max_bytes_for_level_multiplier);
+    for (int i = 0; i < num_levels; i++) {
+      Log(log,"Options.max_bytes_for_level_multiplier_addtl[%d]: %d",
+          i, max_bytes_for_level_multiplier_additional[i]);
+    }
     Log(log,"             Options.expanded_compaction_factor: %d",
         expanded_compaction_factor);
     Log(log,"               Options.source_compaction_factor: %d",
@@ -150,19 +175,17 @@ Options::Dump(Logger* log) const
     Log(log,"                         Options.no_block_cache: %d",
         no_block_cache);
     Log(log,"               Options.table_cache_numshardbits: %d",
-  table_cache_numshardbits);
+        table_cache_numshardbits);
+    Log(log,"                       Options.arena_block_size: %ld",
+        arena_block_size);
     Log(log,"    Options.delete_obsolete_files_period_micros: %ld",
         delete_obsolete_files_period_micros);
     Log(log,"             Options.max_background_compactions: %d",
         max_background_compactions);
-    Log(log,"                             Options.rate_limit: %.2f",
-        rate_limit);
-    Log(log,"          Options.rate_limit_delay_milliseconds: %d",
-        rate_limit_delay_milliseconds);
-    Log(log,"                 Options.compaction_filter_args: %p",
-        compaction_filter_args);
-    Log(log,"                       Options.CompactionFilter: %p",
-        CompactionFilter);
+    Log(log,"                      Options.hard_rate_limit: %.2f",
+        hard_rate_limit);
+    Log(log,"      Options.rate_limit_delay_max_milliseconds: %d",
+        rate_limit_delay_max_milliseconds);
     Log(log,"               Options.disable_auto_compactions: %d",
         disable_auto_compactions);
     Log(log,"                        Options.WAL_ttl_seconds: %ld",
@@ -173,16 +196,28 @@ Options::Dump(Logger* log) const
         purge_redundant_kvs_while_flush);
     Log(log,"                         Options.allow_os_buffer: %d",
         allow_os_buffer);
-    Log(log,"                         Options.allow_readahead: %d",
-        allow_readahead);
-    Log(log,"             Options.allow_readahead_compactions: %d",
-        allow_readahead_compactions);
     Log(log,"                        Options.allow_mmap_reads: %d",
         allow_mmap_reads);
     Log(log,"                       Options.allow_mmap_writes: %d",
         allow_mmap_writes);
     Log(log,"                     Options.is_fd_close_on_exec: %d",
         is_fd_close_on_exec);
+    Log(log,"              Options.skip_log_error_on_recovery: %d",
+        skip_log_error_on_recovery);
+    Log(log,"                   Options.stats_dump_period_sec: %d",
+        stats_dump_period_sec);
+    Log(log,"                    Options.block_size_deviation: %d",
+        block_size_deviation);
+    Log(log,"                   Options.advise_random_on_open: %d",
+        advise_random_on_open);
+    Log(log,"         Options.access_hint_on_compaction_start: %s",
+        access_hints[access_hint_on_compaction_start]);
+    Log(log,"                      Options.use_adaptive_mutex: %d",
+        use_adaptive_mutex);
+    Log(log,"                          Options.bytes_per_sync: %ld",
+        bytes_per_sync);
+    Log(log,"                          Options.filter_deletes: %d",
+        filter_deletes);
 }   // Options::Dump
 
 //

util/posix_logger.h

@@ -18,6 +18,7 @@
 #include <linux/falloc.h>
 #endif
 #include "leveldb/env.h"
+#include <atomic>
 
 namespace leveldb {
 
@@ -27,8 +28,7 @@ class PosixLogger : public Logger {
  private:
   FILE* file_;
   uint64_t (*gettid_)();  // Return the thread id for the current thread
-
-  size_t log_size_;
+  std::atomic_size_t log_size_;
   int fd_;
  public:
   PosixLogger(FILE* f, uint64_t (*gettid)()) :
@@ -94,16 +94,17 @@ class PosixLogger : public Logger {
       }
 
       assert(p <= limit);
+      const size_t write_size = p - base;
 
 #ifdef OS_LINUX
       // If this write would cross a boundary of kDebugLogChunkSize
       // space, pre-allocate more space to avoid overly large
       // allocations from filesystem allocsize options.
-      const size_t write_size = p - base;
+      const size_t log_size = log_size_;
       const int last_allocation_chunk =
-        ((kDebugLogChunkSize - 1 + log_size_) / kDebugLogChunkSize);
+        ((kDebugLogChunkSize - 1 + log_size) / kDebugLogChunkSize);
       const int desired_allocation_chunk =
-        ((kDebugLogChunkSize - 1 + log_size_ + write_size) /
+        ((kDebugLogChunkSize - 1 + log_size + write_size) /
            kDebugLogChunkSize);
       if (last_allocation_chunk != desired_allocation_chunk) {
         fallocate(fd_, FALLOC_FL_KEEP_SIZE, 0,

util/random.h

@@ -5,6 +5,7 @@
 #ifndef STORAGE_LEVELDB_UTIL_RANDOM_H_
 #define STORAGE_LEVELDB_UTIL_RANDOM_H_
 
+#include <random>
 #include <stdint.h>
 
 namespace leveldb {
@@ -54,6 +55,35 @@ class Random {
   }
 };
 
+// A simple 64bit random number generator based on std::mt19937_64
+class Random64 {
+ private:
+  std::mt19937_64 generator_;
+
+ public:
+  explicit Random64(uint64_t s) : generator_(s) { }
+
+  // Generates the next random number
+  uint64_t Next() { return generator_(); }
+
+  // Returns a uniformly distributed value in the range [0..n-1]
+  // REQUIRES: n > 0
+  uint64_t Uniform(uint64_t n) {
+    return std::uniform_int_distribution<uint64_t>(0, n - 1)(generator_);
+  }
+
+  // Randomly returns true ~"1/n" of the time, and false otherwise.
+  // REQUIRES: n > 0
+  bool OneIn(uint64_t n) { return Uniform(n) == 0; }
+
+  // Skewed: pick "base" uniformly from range [0,max_log] and then
+  // return "base" random bits.  The effect is to pick a number in the
+  // range [0,2^max_log-1] with exponential bias towards smaller numbers.
+  uint64_t Skewed(int max_log) {
+    return Uniform(1 << Uniform(max_log + 1));
+  }
+};
+
 }  // namespace leveldb
 
 #endif  // STORAGE_LEVELDB_UTIL_RANDOM_H_

util/signal_test.cc

@@ -0,0 +1,27 @@
+#include "util/stack_trace.h"
+#include <assert.h>
+
+void f0() {
+  char *p = nullptr;
+  *p = 10;  /* SIGSEGV here!! */
+}
+
+void f1() {
+  f0();
+}
+
+void f2() {
+  f1();
+}
+
+void f3() {
+  f2();
+}
+
+int main() {
+  leveldb::InstallStackTraceHandler();
+
+  f3();
+
+  return 0;
+}

util/stack_trace.h

@@ -0,0 +1,13 @@
+#ifndef STACK_TRACE_H
+#define STACK_TRACE_H
+
+namespace leveldb {
+
+// Install a signal handler to print callstack on the following signals:
+// SIGILL SIGSEGV SIGBUS SIGABRT
+// Currently supports linux only. No-op otherwise.
+void InstallStackTraceHandler();
+
+}   // namespace leveldb
+
+#endif

util/statistics.cc

@@ -0,0 +1,55 @@
+#include "leveldb/statistics.h"
+#include <cstdio>
+
+namespace leveldb {
+
+namespace {
+// a buffer size used for temp string buffers
+const int kBufferSize = 200;
+
+std::string HistogramToString (
+    Statistics* dbstats,
+    const Histograms& histogram_type,
+    const std::string& name) {
+
+  char buffer[kBufferSize];
+  HistogramData histogramData;
+  dbstats->histogramData(histogram_type, &histogramData);
+  snprintf(
+      buffer,
+      kBufferSize,
+      "%s statistics Percentiles :=> 50 : %f 95 : %f 99 : %f\n",
+      name.c_str(),
+      histogramData.median,
+      histogramData.percentile95,
+      histogramData.percentile99
+  );
+  return std::string(buffer);
+};
+
+std::string TickerToString (
+    Statistics* dbstats,
+    const Tickers& ticker,
+    const std::string& name) {
+
+  char buffer[kBufferSize];
+  snprintf(buffer, kBufferSize, "%s COUNT : %ld\n",
+            name.c_str(), dbstats->getTickerCount(ticker));
+  return std::string(buffer);
+};
+} // namespace
+
+std::string Statistics::ToString() {
+  std::string res;
+  res.reserve(20000);
+  for (const auto& t : TickersNameMap) {
+    res.append(TickerToString(this, t.first, t.second));
+  }
+  for (const auto& h : HistogramsNameMap) {
+    res.append(HistogramToString(this, h.first, h.second));
+  }
+  res.shrink_to_fit();
+  return res;
+}
+
+} // namespace leveldb