History and version updated to 6.0.2 for Java compilation fixes.

Summary:
I needed this change to be able to build the v6.0.1 release on Windows.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5227

Differential Revision: D15033815

Pulled By: sagar0

fbshipit-source-id: 579f3b8e694c34c0d43527eb2fa37175e37f5911

CMakeLists.txt

@@ -416,7 +416,7 @@ if(WITH_FALLOCATE)
 #include <linux/falloc.h>
 int main() {
  int fd = open(\"/dev/null\", 0);
- fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
+ fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, 1024);
 }
 " HAVE_FALLOCATE)
   if(HAVE_FALLOCATE)
@@ -489,7 +489,6 @@ set(SOURCES
         db/db_impl_debug.cc
         db/db_impl_experimental.cc
         db/db_impl_readonly.cc
-        db/db_impl_secondary.cc
         db/db_info_dumper.cc
         db/db_iter.cc
         db/dbformat.cc
@@ -874,7 +873,6 @@ if(WITH_TESTS)
         db/db_options_test.cc
         db/db_properties_test.cc
         db/db_range_del_test.cc
-        db/db_secondary_test.cc
         db/db_sst_test.cc
         db/db_statistics_test.cc
         db/db_table_properties_test.cc

HISTORY.md

@@ -1,33 +1,22 @@
 # Rocksdb Change Log
-## 6.1.2 (6/4/2019)
-### Bug Fixes
-* Fix flush's/compaction's merge processing logic which allowed `Put`s covered by range tombstones to reappear. Note `Put`s may exist even if the user only ever called `Merge()` due to an internal conversion during compaction to the bottommost level.
 
-## 6.1.1 (4/9/2019)
+## 6.0.2 (4/23/2019)
+## Bug Fixes
+* Fix build failures due to missing JEMALLOC_CXX_THROW macro (#5053)
+* Fix compilation on db_bench_tool.cc on Windows (#5227)
+
+## 6.0.1 (3/26/2019)
 ### New Features
-* When reading from option file/string/map, customized comparators and/or merge operators can be filled according to object registry.
 ### Public API Change
+* Added many new features to the Java API to bring it closer to the C++ API.
+
 ### Bug Fixes
-* Fix a bug in 2PC where a sequence of txn prepare, memtable flush, and crash could result in losing the prepared transaction.
-* Fix a bug in Encryption Env which could cause encrypted files to be read beyond file boundaries.
-
-## 6.1.0 (3/27/2019)
-### New Features
-* Introduce two more stats levels, kExceptHistogramOrTimers and kExceptTimers.
-* Added a feature to perform data-block sampling for compressibility, and report stats to user.
-* Add support for trace filtering.
-* Add DBOptions.avoid_unnecessary_blocking_io. If true, we avoid file deletion when destorying ColumnFamilyHandle and Iterator. Instead, a job is scheduled to delete the files in background.
-
-### Public API Change
-* Remove bundled fbson library.
-* statistics.stats_level_ becomes atomic. It is preferred to use statistics.set_stats_level() and statistics.get_stats_level() to access it.
-* Introduce a new IOError subcode, PathNotFound, to indicate trying to open a nonexistent file or directory for read.
-* Add initial support for multiple db instances sharing the same data in single-writer, multi-reader mode.
-* Removed some "using std::xxx" from public headers.
+* Make BlobDB wait for all background tasks on shutdown.
+* Fixed a BlobDB issue where some trash files are not tracked causing them to remain forever.
 
 ### Bug Fixes
 * Fix JEMALLOC_CXX_THROW macro missing from older Jemalloc versions, causing build failures on some platforms.
-* Fix SstFileReader not able to open file ingested with write_glbal_seqno=true.
+
 
 ## 6.0.0 (2/19/2019)
 ### New Features

LANGUAGE-BINDINGS.md

@@ -1,9 +1,7 @@
 This is the list of all known third-party language bindings for RocksDB. If something is missing, please open a pull request to add it.
 
 * Java - https://github.com/facebook/rocksdb/tree/master/java
-* Python
-    * http://python-rocksdb.readthedocs.io/en/latest/
-    * http://pyrocksdb.readthedocs.org/en/latest/ (unmaintained)
+* Python - http://pyrocksdb.readthedocs.org/en/latest/
 * Perl - https://metacpan.org/pod/RocksDB
 * Node.js - https://npmjs.org/package/rocksdb
 * Go - https://github.com/tecbot/gorocksdb

Makefile

@@ -443,7 +443,6 @@ TESTS = \
 	db_merge_operator_test \
 	db_options_test \
 	db_range_del_test \
-	db_secondary_test \
 	db_sst_test \
 	db_tailing_iter_test \
 	db_io_failure_test \
@@ -548,7 +547,6 @@ TESTS = \
 	range_tombstone_fragmenter_test \
 	range_del_aggregator_test \
 	sst_file_reader_test \
-	db_secondary_test \
 
 PARALLEL_TEST = \
 	backupable_db_test \
@@ -1573,9 +1571,6 @@ range_tombstone_fragmenter_test: db/range_tombstone_fragmenter_test.o db/db_test
 sst_file_reader_test: table/sst_file_reader_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
-db_secondary_test: db/db_secondary_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 #-------------------------------------------------
 # make install related stuff
 INSTALL_PATH ?= /usr/local

README.md

@@ -5,7 +5,7 @@
 [![PPC64le Build Status](http://140.211.168.68:8080/buildStatus/icon?job=Rocksdb)](http://140.211.168.68:8080/job/Rocksdb)
 
 RocksDB is developed and maintained by Facebook Database Engineering Team.
-It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
+It is built 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

TARGETS

@@ -98,7 +98,6 @@ cpp_library(
         "db/db_impl_files.cc",
         "db/db_impl_open.cc",
         "db/db_impl_readonly.cc",
-        "db/db_impl_secondary.cc",
         "db/db_impl_write.cc",
         "db/db_info_dumper.cc",
         "db/db_iter.cc",
@@ -606,11 +605,6 @@ ROCKS_TESTS = [
         "db/db_range_del_test.cc",
         "serial",
     ],
-    [
-        "db_secondary_test",
-        "db/db_secondary_test.cc",
-        "serial",
-    ],
     [
         "db_sst_test",
         "db/db_sst_test.cc",

WINDOWS_PORT.md

@@ -43,7 +43,7 @@ We plan to use this port for our business purposes here at Bing and this provide
 
 * Certain headers that are not present and not necessary on Windows were simply `#ifndef OS_WIN` in a few places (`unistd.h`)
 * All posix specific headers were replaced to port/port.h which worked well
-* Replaced `dirent.h` for `port/port_dirent.h` (very few places) with the implementation of the relevant interfaces within `rocksdb::port` namespace
+* Replaced `dirent.h` for `port/dirent.h` (very few places) with the implementation of the relevant interfaces within `rocksdb::port` namespace
 * Replaced `sys/time.h` to `port/sys_time.h` (few places) implemented equivalents within `rocksdb::port`
 * `printf %z` specification is not supported on Windows. To imitate existing standards we came up with a string macro `ROCKSDB_PRIszt` which expands to `zu` on posix systems and to `Iu` on windows.
 * in class member initialization were moved to a __ctors in some cases

build_tools/build_detect_platform

@@ -56,10 +56,10 @@ if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
     if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
       # we need this to build with MySQL. Don't use for other purposes.
       source "$PWD/build_tools/fbcode_config4.8.1.sh"
-    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
-      source "$PWD/build_tools/fbcode_config.sh"
-    else
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007" ]; then
       source "$PWD/build_tools/fbcode_config_platform007.sh"
+    else
+      source "$PWD/build_tools/fbcode_config.sh"
     fi
 fi
 
@@ -234,7 +234,7 @@ else
           #include <linux/falloc.h>
           int main() {
       int fd = open("/dev/null", 0);
-      fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, 1024);
+      fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, 1024);
           }
 EOF
         if [ "$?" = 0 ]; then
@@ -518,8 +518,8 @@ if test "$USE_HDFS"; then
     echo "JAVA_HOME has to be set for HDFS usage."
     exit 1
   fi
-  HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include"
-  HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native"
+  HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS"
+  HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64"
   HDFS_LDFLAGS="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib"
   HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm"
   COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS"

cache/cache_test.cc

@@ -98,7 +98,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
     return nullptr;
   }
 
-  int Lookup(std::shared_ptr<Cache> cache, int key) {
+  int Lookup(shared_ptr<Cache> cache, int key) {
     Cache::Handle* handle = cache->Lookup(EncodeKey(key));
     const int r = (handle == nullptr) ? -1 : DecodeValue(cache->Value(handle));
     if (handle != nullptr) {
@@ -107,16 +107,16 @@ class CacheTest : public testing::TestWithParam<std::string> {
     return r;
   }
 
-  void Insert(std::shared_ptr<Cache> cache, int key, int value,
-              int charge = 1) {
+  void Insert(shared_ptr<Cache> cache, int key, int value, int charge = 1) {
     cache->Insert(EncodeKey(key), EncodeValue(value), charge,
                   &CacheTest::Deleter);
   }
 
-  void Erase(std::shared_ptr<Cache> cache, int key) {
+  void Erase(shared_ptr<Cache> cache, int key) {
     cache->Erase(EncodeKey(key));
   }
 
+
   int Lookup(int key) {
     return Lookup(cache_, key);
   }
@@ -306,7 +306,7 @@ TEST_P(CacheTest, EvictionPolicy) {
   Insert(200, 201);
 
   // Frequently used entry must be kept around
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize + 100; i++) {
     Insert(1000+i, 2000+i);
     ASSERT_EQ(101, Lookup(100));
   }
@@ -359,7 +359,7 @@ TEST_P(CacheTest, EvictionPolicyRef) {
   Insert(303, 104);
 
   // Insert entries much more than Cache capacity
-  for (int i = 0; i < kCacheSize + 200; i++) {
+  for (int i = 0; i < kCacheSize + 100; i++) {
     Insert(1000 + i, 2000 + i);
   }
 
@@ -687,8 +687,7 @@ TEST_P(CacheTest, DefaultShardBits) {
 }
 
 #ifdef SUPPORT_CLOCK_CACHE
-std::shared_ptr<Cache> (*new_clock_cache_func)(size_t, int,
-                                               bool) = NewClockCache;
+shared_ptr<Cache> (*new_clock_cache_func)(size_t, int, bool) = NewClockCache;
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
                         testing::Values(kLRU, kClock));
 #else

cache/clock_cache.cc

@@ -234,7 +234,7 @@ struct CleanupContext {
 };
 
 // A cache shard which maintains its own CLOCK cache.
-class ClockCacheShard final : public CacheShard {
+class ClockCacheShard : public CacheShard {
  public:
   // Hash map type.
   typedef tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey> HashTable;
@@ -672,7 +672,7 @@ void ClockCacheShard::EraseUnRefEntries() {
   Cleanup(context);
 }
 
-class ClockCache final : public ShardedCache {
+class ClockCache : public ShardedCache {
  public:
   ClockCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit)
       : ShardedCache(capacity, num_shard_bits, strict_capacity_limit) {

cache/lru_cache.cc

@@ -100,16 +100,14 @@ void LRUHandleTable::Resize() {
 }
 
 LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                             double high_pri_pool_ratio,
-                             bool use_adaptive_mutex)
+                             double high_pri_pool_ratio)
     : capacity_(0),
       high_pri_pool_usage_(0),
       strict_capacity_limit_(strict_capacity_limit),
       high_pri_pool_ratio_(high_pri_pool_ratio),
       high_pri_pool_capacity_(0),
       usage_(0),
-      lru_usage_(0),
-      mutex_(use_adaptive_mutex) {
+      lru_usage_(0) {
   // Make empty circular linked list
   lru_.next = &lru_;
   lru_.prev = &lru_;
@@ -464,8 +462,7 @@ std::string LRUCacheShard::GetPrintableOptions() const {
 
 LRUCache::LRUCache(size_t capacity, int num_shard_bits,
                    bool strict_capacity_limit, double high_pri_pool_ratio,
-                   std::shared_ptr<MemoryAllocator> allocator,
-                   bool use_adaptive_mutex)
+                   std::shared_ptr<MemoryAllocator> allocator)
     : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
                    std::move(allocator)) {
   num_shards_ = 1 << num_shard_bits;
@@ -474,8 +471,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
   size_t per_shard = (capacity + (num_shards_ - 1)) / num_shards_;
   for (int i = 0; i < num_shards_; i++) {
     new (&shards_[i])
-        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio,
-            use_adaptive_mutex);
+        LRUCacheShard(per_shard, strict_capacity_limit, high_pri_pool_ratio);
   }
 }
 
@@ -544,15 +540,13 @@ std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
   return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
                      cache_opts.strict_capacity_limit,
                      cache_opts.high_pri_pool_ratio,
-                     cache_opts.memory_allocator,
-                     cache_opts.use_adaptive_mutex);
+                     cache_opts.memory_allocator);
 }
 
 std::shared_ptr<Cache> NewLRUCache(
     size_t capacity, int num_shard_bits, bool strict_capacity_limit,
     double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator,
-    bool use_adaptive_mutex) {
+    std::shared_ptr<MemoryAllocator> memory_allocator) {
   if (num_shard_bits >= 20) {
     return nullptr;  // the cache cannot be sharded into too many fine pieces
   }
@@ -565,8 +559,7 @@ std::shared_ptr<Cache> NewLRUCache(
   }
   return std::make_shared<LRUCache>(capacity, num_shard_bits,
                                     strict_capacity_limit, high_pri_pool_ratio,
-                                    std::move(memory_allocator),
-                                    use_adaptive_mutex);
+                                    std::move(memory_allocator));
 }
 
 }  // namespace rocksdb

cache/lru_cache.h

@@ -55,18 +55,10 @@ struct LRUHandle {
                      // cache itself is counted as 1
 
   // Include the following flags:
-  //   IN_CACHE:         whether this entry is referenced by the hash table.
-  //   IS_HIGH_PRI:      whether this entry is high priority entry.
-  //   IN_HIGH_PRI_POOL: whether this entry is in high-pri pool.
-  //   HAS_HIT:          whether this entry has had any lookups (hits).
-  enum Flags : uint8_t {
-    IN_CACHE = (1 << 0),
-    IS_HIGH_PRI = (1 << 1),
-    IN_HIGH_PRI_POOL = (1 << 2),
-    HAS_HIT = (1 << 3),
-  };
-
-  uint8_t flags;
+  //   in_cache:    whether this entry is referenced by the hash table.
+  //   is_high_pri: whether this entry is high priority entry.
+  //   in_high_pri_pool: whether this entry is in high-pri pool.
+  char flags;
 
   uint32_t hash;     // Hash of key(); used for fast sharding and comparisons
 
@@ -82,36 +74,36 @@ struct LRUHandle {
     }
   }
 
-  bool InCache() const { return flags & IN_CACHE; }
-  bool IsHighPri() const { return flags & IS_HIGH_PRI; }
-  bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
-  bool HasHit() const { return flags & HAS_HIT; }
+  bool InCache() { return flags & 1; }
+  bool IsHighPri() { return flags & 2; }
+  bool InHighPriPool() { return flags & 4; }
+  bool HasHit() { return flags & 8; }
 
   void SetInCache(bool in_cache) {
     if (in_cache) {
-      flags |= IN_CACHE;
+      flags |= 1;
     } else {
-      flags &= ~IN_CACHE;
+      flags &= ~1;
     }
   }
 
   void SetPriority(Cache::Priority priority) {
     if (priority == Cache::Priority::HIGH) {
-      flags |= IS_HIGH_PRI;
+      flags |= 2;
     } else {
-      flags &= ~IS_HIGH_PRI;
+      flags &= ~2;
     }
   }
 
   void SetInHighPriPool(bool in_high_pri_pool) {
     if (in_high_pri_pool) {
-      flags |= IN_HIGH_PRI_POOL;
+      flags |= 4;
     } else {
-      flags &= ~IN_HIGH_PRI_POOL;
+      flags &= ~4;
     }
   }
 
-  void SetHit() { flags |= HAS_HIT; }
+  void SetHit() { flags |= 8; }
 
   void Free() {
     assert((refs == 1 && InCache()) || (refs == 0 && !InCache()));
@@ -165,10 +157,10 @@ class LRUHandleTable {
 };
 
 // A single shard of sharded cache.
-class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
+class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard : public CacheShard {
  public:
   LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                double high_pri_pool_ratio, bool use_adaptive_mutex);
+                double high_pri_pool_ratio);
   virtual ~LRUCacheShard();
 
   // Separate from constructor so caller can easily make an array of LRUCache
@@ -284,16 +276,11 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   mutable port::Mutex mutex_;
 };
 
-class LRUCache
-#ifdef NDEBUG
-    final
-#endif
-    : public ShardedCache {
+class LRUCache : public ShardedCache {
  public:
   LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
            double high_pri_pool_ratio,
-           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-           bool use_adaptive_mutex = kDefaultToAdaptiveMutex);
+           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr);
   virtual ~LRUCache();
   virtual const char* Name() const override { return "LRUCache"; }
   virtual CacheShard* GetShard(int shard) override;

cache/lru_cache_test.cc

@@ -25,13 +25,12 @@ class LRUCacheTest : public testing::Test {
     }
   }
 
-  void NewCache(size_t capacity, double high_pri_pool_ratio = 0.0,
-                bool use_adaptive_mutex = kDefaultToAdaptiveMutex) {
+  void NewCache(size_t capacity, double high_pri_pool_ratio = 0.0) {
     DeleteCache();
     cache_ = reinterpret_cast<LRUCacheShard*>(
         port::cacheline_aligned_alloc(sizeof(LRUCacheShard)));
     new (cache_) LRUCacheShard(capacity, false /*strict_capcity_limit*/,
-                               high_pri_pool_ratio, use_adaptive_mutex);
+                               high_pri_pool_ratio);
   }
 
   void Insert(const std::string& key,

cache/sharded_cache.h

@@ -83,7 +83,7 @@ class ShardedCache : public Cache {
 
  private:
   static inline uint32_t HashSlice(const Slice& s) {
-    return static_cast<uint32_t>(GetSliceNPHash64(s));
+    return Hash(s.data(), s.size(), 0);
   }
 
   uint32_t Shard(uint32_t hash) {

db/builder.cc

@@ -47,8 +47,8 @@ TableBuilder* NewTableBuilder(
         int_tbl_prop_collector_factories,
     uint32_t column_family_id, const std::string& column_family_name,
     WritableFileWriter* file, const CompressionType compression_type,
-    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
-    int level, const bool skip_filters, const uint64_t creation_time,
+    const CompressionOptions& compression_opts, int level,
+    const bool skip_filters, const uint64_t creation_time,
     const uint64_t oldest_key_time, const uint64_t target_file_size) {
   assert((column_family_id ==
           TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
@@ -56,9 +56,9 @@ TableBuilder* NewTableBuilder(
   return ioptions.table_factory->NewTableBuilder(
       TableBuilderOptions(ioptions, moptions, internal_comparator,
                           int_tbl_prop_collector_factories, compression_type,
-                          sample_for_compression, compression_opts,
-                          skip_filters, column_family_name, level,
-                          creation_time, oldest_key_time, target_file_size),
+                          compression_opts, skip_filters, column_family_name,
+                          level, creation_time, oldest_key_time,
+                          target_file_size),
       column_family_id, file);
 }
 
@@ -75,12 +75,11 @@ Status BuildTable(
     std::vector<SequenceNumber> snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
     SnapshotChecker* snapshot_checker, const CompressionType compression,
-    uint64_t sample_for_compression, const CompressionOptions& compression_opts,
-    bool paranoid_file_checks, InternalStats* internal_stats,
-    TableFileCreationReason reason, EventLogger* event_logger, int job_id,
-    const Env::IOPriority io_priority, TableProperties* table_properties,
-    int level, const uint64_t creation_time, const uint64_t oldest_key_time,
-    Env::WriteLifeTimeHint write_hint) {
+    const CompressionOptions& compression_opts, bool paranoid_file_checks,
+    InternalStats* internal_stats, TableFileCreationReason reason,
+    EventLogger* event_logger, int job_id, const Env::IOPriority io_priority,
+    TableProperties* table_properties, int level, const uint64_t creation_time,
+    const uint64_t oldest_key_time, Env::WriteLifeTimeHint write_hint) {
   assert((column_family_id ==
           TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
          column_family_name.empty());
@@ -134,8 +133,8 @@ Status BuildTable(
           ioptions, mutable_cf_options, internal_comparator,
           int_tbl_prop_collector_factories, column_family_id,
           column_family_name, file_writer.get(), compression,
-          sample_for_compression, compression_opts_for_flush, level,
-          false /* skip_filters */, creation_time, oldest_key_time);
+          compression_opts_for_flush, level, false /* skip_filters */,
+          creation_time, oldest_key_time);
     }
 
     MergeHelper merge(env, internal_comparator.user_comparator(),

db/builder.h

@@ -47,7 +47,6 @@ TableBuilder* NewTableBuilder(
         int_tbl_prop_collector_factories,
     uint32_t column_family_id, const std::string& column_family_name,
     WritableFileWriter* file, const CompressionType compression_type,
-    const uint64_t sample_for_compression,
     const CompressionOptions& compression_opts, int level,
     const bool skip_filters = false, const uint64_t creation_time = 0,
     const uint64_t oldest_key_time = 0, const uint64_t target_file_size = 0);
@@ -73,7 +72,6 @@ extern Status BuildTable(
     std::vector<SequenceNumber> snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
     SnapshotChecker* snapshot_checker, const CompressionType compression,
-    const uint64_t sample_for_compression,
     const CompressionOptions& compression_opts, bool paranoid_file_checks,
     InternalStats* internal_stats, TableFileCreationReason reason,
     EventLogger* event_logger = nullptr, int job_id = 0,

db/c.cc

@@ -3702,38 +3702,6 @@ rocksdb_transactiondb_t* rocksdb_transactiondb_open(
   return result;
 }
 
-rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
-    const rocksdb_options_t* options,
-    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
-    int num_column_families, const char** column_family_names,
-    const rocksdb_options_t** column_family_options,
-    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
-  std::vector<ColumnFamilyDescriptor> column_families;
-  for (int i = 0; i < num_column_families; i++) {
-    column_families.push_back(ColumnFamilyDescriptor(
-        std::string(column_family_names[i]),
-        ColumnFamilyOptions(column_family_options[i]->rep)));
-  }
-
-  TransactionDB* txn_db;
-  std::vector<ColumnFamilyHandle*> handles;
-  if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
-                                            std::string(name), column_families,
-                                            &handles, &txn_db))) {
-    return nullptr;
-  }
-
-  for (size_t i = 0; i < handles.size(); i++) {
-    rocksdb_column_family_handle_t* c_handle =
-        new rocksdb_column_family_handle_t;
-    c_handle->rep = handles[i];
-    column_family_handles[i] = c_handle;
-  }
-  rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
-  result->rep = txn_db;
-  return result;
-}
-
 const rocksdb_snapshot_t* rocksdb_transactiondb_create_snapshot(
     rocksdb_transactiondb_t* txn_db) {
   rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
@@ -3854,26 +3822,6 @@ char* rocksdb_transaction_get_for_update(rocksdb_transaction_t* txn,
   return result;
 }
 
-char* rocksdb_transaction_get_for_update_cf(
-    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    size_t* vlen, unsigned char exclusive, char** errptr) {
-  char* result = nullptr;
-  std::string tmp;
-  Status s = txn->rep->GetForUpdate(options->rep, column_family->rep,
-                                    Slice(key, klen), &tmp, exclusive);
-  if (s.ok()) {
-    *vlen = tmp.size();
-    result = CopyString(tmp);
-  } else {
-    *vlen = 0;
-    if (!s.IsNotFound()) {
-      SaveError(errptr, s);
-    }
-  }
-  return result;
-}
-
 // Read a key outside a transaction
 char* rocksdb_transactiondb_get(
     rocksdb_transactiondb_t* txn_db,
@@ -3966,14 +3914,6 @@ void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
   SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
 }
 
-void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t klen, const char* val,
-                                  size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
-                                    Slice(val, vlen)));
-}
-
 // Merge a key outside a transaction
 void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
                                  const rocksdb_writeoptions_t* options,
@@ -3983,14 +3923,6 @@ void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
                                        Slice(val, vlen)));
 }
 
-void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
-                                       Slice(key, klen), Slice(val, vlen)));
-}
-
 // Delete a key inside a transaction
 void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
                                 size_t klen, char** errptr) {
@@ -4043,14 +3975,6 @@ rocksdb_iterator_t* rocksdb_transactiondb_create_iterator(
   return result;
 }
 
-rocksdb_iterator_t* rocksdb_transactiondb_create_iterator_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family) {
-  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep = txn_db->rep->NewIterator(options->rep, column_family->rep);
-  return result;
-}
-
 void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) {
   delete txn_db->rep;
   delete txn_db;

db/column_family.cc

@@ -68,14 +68,7 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
     db_->FindObsoleteFiles(&job_context, false, true);
     mutex_->Unlock();
     if (job_context.HaveSomethingToDelete()) {
-      bool defer_purge =
-          db_->immutable_db_options().avoid_unnecessary_blocking_io;
-      db_->PurgeObsoleteFiles(job_context, defer_purge);
-      if (defer_purge) {
-        mutex_->Lock();
-        db_->SchedulePurge();
-        mutex_->Unlock();
-      }
+      db_->PurgeObsoleteFiles(job_context);
     }
     job_context.Clean();
   }

db/compaction_job.cc

@@ -312,8 +312,7 @@ CompactionJob::CompactionJob(
     SequenceNumber earliest_write_conflict_snapshot,
     const SnapshotChecker* snapshot_checker, std::shared_ptr<Cache> table_cache,
     EventLogger* event_logger, bool paranoid_file_checks, bool measure_io_stats,
-    const std::string& dbname, CompactionJobStats* compaction_job_stats,
-    Env::Priority thread_pri)
+    const std::string& dbname, CompactionJobStats* compaction_job_stats)
     : job_id_(job_id),
       compact_(new CompactionState(compaction)),
       compaction_job_stats_(compaction_job_stats),
@@ -341,8 +340,7 @@ CompactionJob::CompactionJob(
       bottommost_level_(false),
       paranoid_file_checks_(paranoid_file_checks),
       measure_io_stats_(measure_io_stats),
-      write_hint_(Env::WLTH_NOT_SET),
-      thread_pri_(thread_pri) {
+      write_hint_(Env::WLTH_NOT_SET) {
   assert(log_buffer_ != nullptr);
   const auto* cfd = compact_->compaction->column_family_data();
   ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
@@ -416,10 +414,11 @@ void CompactionJob::Prepare() {
   bottommost_level_ = c->bottommost_level();
 
   if (c->ShouldFormSubcompactions()) {
-    {
-      StopWatch sw(env_, stats_, SUBCOMPACTION_SETUP_TIME);
-      GenSubcompactionBoundaries();
-    }
+    const uint64_t start_micros = env_->NowMicros();
+    GenSubcompactionBoundaries();
+    MeasureTime(stats_, SUBCOMPACTION_SETUP_TIME,
+                env_->NowMicros() - start_micros);
+
     assert(sizes_.size() == boundaries_.size() + 1);
 
     for (size_t i = 0; i <= boundaries_.size(); i++) {
@@ -427,8 +426,8 @@ void CompactionJob::Prepare() {
       Slice* end = i == boundaries_.size() ? nullptr : &boundaries_[i];
       compact_->sub_compact_states.emplace_back(c, start, end, sizes_[i]);
     }
-    RecordInHistogram(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
-                      compact_->sub_compact_states.size());
+    MeasureTime(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
+                compact_->sub_compact_states.size());
   } else {
     compact_->sub_compact_states.emplace_back(c, nullptr, nullptr);
   }
@@ -608,9 +607,8 @@ Status CompactionJob::Run() {
         compact_->sub_compact_states[i].compaction_job_stats.cpu_micros;
   }
 
-  RecordTimeToHistogram(stats_, COMPACTION_TIME, compaction_stats_.micros);
-  RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
-                        compaction_stats_.cpu_micros);
+  MeasureTime(stats_, COMPACTION_TIME, compaction_stats_.micros);
+  MeasureTime(stats_, COMPACTION_CPU_TIME, compaction_stats_.cpu_micros);
 
   TEST_SYNC_POINT("CompactionJob::Run:BeforeVerify");
 
@@ -719,7 +717,7 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
   Status status = compact_->status;
   ColumnFamilyData* cfd = compact_->compaction->column_family_data();
   cfd->internal_stats()->AddCompactionStats(
-      compact_->compaction->output_level(), thread_pri_, compaction_stats_);
+      compact_->compaction->output_level(), compaction_stats_);
 
   if (status.ok()) {
     status = InstallCompactionResults(mutable_cf_options);
@@ -1501,7 +1499,6 @@ Status CompactionJob::OpenCompactionOutputFile(
       cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
       cfd->GetID(), cfd->GetName(), sub_compact->outfile.get(),
       sub_compact->compaction->output_compression(),
-      0 /*sample_for_compression */,
       sub_compact->compaction->output_compression_opts(),
       sub_compact->compaction->output_level(), skip_filters,
       output_file_creation_time, 0 /* oldest_key_time */,

db/compaction_job.h

@@ -62,17 +62,17 @@ class CompactionJob {
                 const EnvOptions env_options, VersionSet* versions,
                 const std::atomic<bool>* shutting_down,
                 const SequenceNumber preserve_deletes_seqnum,
-                LogBuffer* log_buffer, Directory* db_directory,
-                Directory* output_directory, Statistics* stats,
-                InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
+                LogBuffer* log_buffer,
+                Directory* db_directory, Directory* output_directory,
+                Statistics* stats, InstrumentedMutex* db_mutex,
+                ErrorHandler* db_error_handler,
                 std::vector<SequenceNumber> existing_snapshots,
                 SequenceNumber earliest_write_conflict_snapshot,
                 const SnapshotChecker* snapshot_checker,
                 std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
                 bool paranoid_file_checks, bool measure_io_stats,
                 const std::string& dbname,
-                CompactionJobStats* compaction_job_stats,
-                Env::Priority thread_pri);
+                CompactionJobStats* compaction_job_stats);
 
   ~CompactionJob();
 
@@ -172,7 +172,6 @@ class CompactionJob {
   // Stores the approx size of keys covered in the range of each subcompaction
   std::vector<uint64_t> sizes_;
   Env::WriteLifeTimeHint write_hint_;
-  Env::Priority thread_pri_;
 };
 
 }  // namespace rocksdb

db/compaction_job_test.cc

@@ -262,8 +262,7 @@ class CompactionJobTest : public testing::Test {
         &shutting_down_, preserve_deletes_seqnum_, &log_buffer, nullptr,
         nullptr, nullptr, &mutex_, &error_handler_, snapshots,
         earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
-        &event_logger, false, false, dbname_, &compaction_job_stats_,
-        Env::Priority::USER);
+        &event_logger, false, false, dbname_, &compaction_job_stats_);
     VerifyInitializationOfCompactionJobStats(compaction_job_stats_);
 
     compaction_job.Prepare();

db/compaction_picker_universal.cc

@@ -395,8 +395,8 @@ Compaction* UniversalCompactionPicker::PickCompaction(
   }
 #endif
   // update statistics
-  RecordInHistogram(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION,
-                    c->inputs(0)->size());
+  MeasureTime(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION,
+              c->inputs(0)->size());
 
   RegisterCompaction(c);
   vstorage->ComputeCompactionScore(ioptions_, mutable_cf_options);

db/db_compaction_test.cc

@@ -3348,7 +3348,7 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
   options.level0_file_num_compaction_trigger = kNumLevelFiles;
   // inflate it a bit to account for key/metadata overhead
   options.target_file_size_base = 120 * kNumKeysPerFile * kValueSize / 100;
-  CreateAndReopenWithCF({"one"}, options);
+  Reopen(options);
 
   Random rnd(301);
   const Snapshot* snapshot = nullptr;
@@ -3379,12 +3379,10 @@ TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
   // just need to bump seqnum so ReleaseSnapshot knows the newest key in the SST
   // files does not need to be preserved in case of a future snapshot.
   ASSERT_OK(Put(Key(0), "val"));
-  ASSERT_NE(kMaxSequenceNumber, dbfull()->bottommost_files_mark_threshold_);
   // release snapshot and wait for compactions to finish. Single-file
   // compactions should be triggered, which reduce the size of each bottom-level
   // file without changing file count.
   db_->ReleaseSnapshot(snapshot);
-  ASSERT_EQ(kMaxSequenceNumber, dbfull()->bottommost_files_mark_threshold_);
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
         Compaction* compaction = reinterpret_cast<Compaction*>(arg);

db/db_impl.cc

@@ -148,21 +148,18 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       immutable_db_options_(initial_db_options_),
       mutable_db_options_(initial_db_options_),
       stats_(immutable_db_options_.statistics.get()),
+      db_lock_(nullptr),
       mutex_(stats_, env_, DB_MUTEX_WAIT_MICROS,
              immutable_db_options_.use_adaptive_mutex),
-      default_cf_handle_(nullptr),
-      max_total_in_memory_state_(0),
-      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
-      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
-          env_options_, immutable_db_options_)),
-      db_lock_(nullptr),
       shutting_down_(false),
       bg_cv_(&mutex_),
       logfile_number_(0),
       log_dir_synced_(false),
       log_empty_(true),
+      default_cf_handle_(nullptr),
       log_sync_cv_(&mutex_),
       total_log_size_(0),
+      max_total_in_memory_state_(0),
       is_snapshot_supported_(true),
       write_buffer_manager_(immutable_db_options_.write_buffer_manager.get()),
       write_thread_(immutable_db_options_),
@@ -189,6 +186,9 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       next_job_id_(1),
       has_unpersisted_data_(false),
       unable_to_release_oldest_log_(false),
+      env_options_(BuildDBOptions(immutable_db_options_, mutable_db_options_)),
+      env_options_for_compaction_(env_->OptimizeForCompactionTableWrite(
+          env_options_, immutable_db_options_)),
       num_running_ingest_file_(0),
 #ifndef ROCKSDB_LITE
       wal_manager_(immutable_db_options_, env_options_, seq_per_batch),
@@ -299,8 +299,7 @@ Status DBImpl::ResumeImpl() {
     s = Status::ShutdownInProgress();
   }
   if (s.ok() && bg_error.severity() > Status::Severity::kHardError) {
-    ROCKS_LOG_INFO(
-        immutable_db_options_.info_log,
+    ROCKS_LOG_INFO(immutable_db_options_.info_log,
         "DB resume requested but failed due to Fatal/Unrecoverable error");
     s = bg_error;
   }
@@ -371,8 +370,8 @@ Status DBImpl::ResumeImpl() {
   // Wake up any waiters - in this case, it could be the shutdown thread
   bg_cv_.SignalAll();
 
-  // No need to check BGError again. If something happened, event listener would
-  // be notified and the operation causing it would have failed
+  // No need to check BGError again. If something happened, event listener would be
+  // notified and the operation causing it would have failed
   return s;
 }
 
@@ -386,6 +385,7 @@ void DBImpl::WaitForBackgroundWork() {
 
 // Will lock the mutex_,  will wait for completion if wait is true
 void DBImpl::CancelAllBackgroundWork(bool wait) {
+
   ROCKS_LOG_INFO(immutable_db_options_.info_log,
                  "Shutdown: canceling all background work");
 
@@ -572,7 +572,7 @@ Status DBImpl::CloseHelper() {
         immutable_db_options_.sst_file_manager.get());
     sfm->Close();
   }
-#endif  // ROCKSDB_LITE
+#endif // ROCKSDB_LITE
 
   if (immutable_db_options_.info_log && own_info_log_) {
     Status s = immutable_db_options_.info_log->Close();
@@ -730,8 +730,7 @@ bool DBImpl::FindStatsByTime(uint64_t start_time, uint64_t end_time,
   }
 }
 
-Status DBImpl::GetStatsHistory(
-    uint64_t start_time, uint64_t end_time,
+Status DBImpl::GetStatsHistory(uint64_t start_time, uint64_t end_time,
     std::unique_ptr<StatsHistoryIterator>* stats_iterator) {
   if (!stats_iterator) {
     return Status::InvalidArgument("stats_iterator not preallocated.");
@@ -913,18 +912,19 @@ Status DBImpl::SetDBOptions(
       }
       if (new_options.stats_dump_period_sec !=
           mutable_db_options_.stats_dump_period_sec) {
-        if (thread_dump_stats_) {
-          mutex_.Unlock();
-          thread_dump_stats_->cancel();
-          mutex_.Lock();
-        }
-        if (new_options.stats_dump_period_sec > 0) {
-          thread_dump_stats_.reset(new rocksdb::RepeatableThread(
-              [this]() { DBImpl::DumpStats(); }, "dump_st", env_,
-              new_options.stats_dump_period_sec * 1000000));
-        } else {
-          thread_dump_stats_.reset();
-        }
+          if (thread_dump_stats_) {
+            mutex_.Unlock();
+            thread_dump_stats_->cancel();
+            mutex_.Lock();
+          }
+          if (new_options.stats_dump_period_sec > 0) {
+            thread_dump_stats_.reset(new rocksdb::RepeatableThread(
+                [this]() { DBImpl::DumpStats(); }, "dump_st", env_,
+                new_options.stats_dump_period_sec * 1000000));
+          }
+          else {
+            thread_dump_stats_.reset();
+          }
       }
       if (new_options.stats_persist_period_sec !=
           mutable_db_options_.stats_persist_period_sec) {
@@ -1112,25 +1112,6 @@ Status DBImpl::SyncWAL() {
   return status;
 }
 
-Status DBImpl::LockWAL() {
-  log_write_mutex_.Lock();
-  auto cur_log_writer = logs_.back().writer;
-  auto status = cur_log_writer->WriteBuffer();
-  if (!status.ok()) {
-    ROCKS_LOG_ERROR(immutable_db_options_.info_log, "WAL flush error %s",
-                    status.ToString().c_str());
-    // In case there is a fs error we should set it globally to prevent the
-    // future writes
-    WriteStatusCheck(status);
-  }
-  return status;
-}
-
-Status DBImpl::UnlockWAL() {
-  log_write_mutex_.Unlock();
-  return Status::OK();
-}
-
 void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
                             const Status& status) {
   mutex_.AssertHeld();
@@ -1332,8 +1313,7 @@ InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
     internal_iter = merge_iter_builder.Finish();
     IterState* cleanup =
         new IterState(this, &mutex_, super_version,
-                      read_options.background_purge_on_iterator_cleanup ||
-                      immutable_db_options_.avoid_unnecessary_blocking_io);
+                      read_options.background_purge_on_iterator_cleanup);
     internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);
 
     return internal_iter;
@@ -1393,7 +1373,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
     snapshot =
         reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
     if (callback) {
-      snapshot = std::max(snapshot, callback->max_visible_seq());
+      snapshot = std::max(snapshot, callback->MaxUnpreparedSequenceNumber());
     }
   } else {
     // Since we get and reference the super version before getting
@@ -1467,7 +1447,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
       RecordTick(stats_, BYTES_READ, size);
       PERF_COUNTER_ADD(get_read_bytes, size);
     }
-    RecordInHistogram(stats_, BYTES_PER_READ, size);
+    MeasureTime(stats_, BYTES_PER_READ, size);
   }
   return s;
 }
@@ -1652,7 +1632,7 @@ std::vector<Status> DBImpl::MultiGet(
   RecordTick(stats_, NUMBER_MULTIGET_KEYS_READ, num_keys);
   RecordTick(stats_, NUMBER_MULTIGET_KEYS_FOUND, num_found);
   RecordTick(stats_, NUMBER_MULTIGET_BYTES_READ, bytes_read);
-  RecordInHistogram(stats_, BYTES_PER_MULTIGET, bytes_read);
+  MeasureTime(stats_, BYTES_PER_MULTIGET, bytes_read);
   PERF_COUNTER_ADD(multiget_read_bytes, bytes_read);
   PERF_TIMER_STOP(get_post_process_time);
 
@@ -1959,7 +1939,7 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
   auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
   auto cfd = cfh->cfd();
   ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (read_options.tailing) {
+if (read_options.tailing) {
 #ifdef ROCKSDB_LITE
     // not supported in lite version
     result = nullptr;
@@ -2133,18 +2113,6 @@ SnapshotImpl* DBImpl::GetSnapshotImpl(bool is_write_conflict_boundary,
   return snapshot;
 }
 
-namespace {
-typedef autovector<ColumnFamilyData*, 2> CfdList;
-bool CfdListContains(const CfdList& list, ColumnFamilyData* cfd) {
-  for (const ColumnFamilyData* t : list) {
-    if (t == cfd) {
-      return true;
-    }
-  }
-  return false;
-}
-}  //  namespace
-
 void DBImpl::ReleaseSnapshot(const Snapshot* s) {
   const SnapshotImpl* casted_s = reinterpret_cast<const SnapshotImpl*>(s);
   {
@@ -2158,35 +2126,15 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
     } else {
       oldest_snapshot = snapshots_.oldest()->number_;
     }
-    // Avoid to go through every column family by checking a global threshold
-    // first.
-    if (oldest_snapshot > bottommost_files_mark_threshold_) {
-      CfdList cf_scheduled;
-      for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
-        if (!cfd->current()
-                 ->storage_info()
-                 ->BottommostFilesMarkedForCompaction()
-                 .empty()) {
-          SchedulePendingCompaction(cfd);
-          MaybeScheduleFlushOrCompaction();
-          cf_scheduled.push_back(cfd);
-        }
+    for (auto* cfd : *versions_->GetColumnFamilySet()) {
+      cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
+      if (!cfd->current()
+               ->storage_info()
+               ->BottommostFilesMarkedForCompaction()
+               .empty()) {
+        SchedulePendingCompaction(cfd);
+        MaybeScheduleFlushOrCompaction();
       }
-
-      // Calculate a new threshold, skipping those CFs where compactions are
-      // scheduled. We do not do the same pass as the previous loop because
-      // mutex might be unlocked during the loop, making the result inaccurate.
-      SequenceNumber new_bottommost_files_mark_threshold = kMaxSequenceNumber;
-      for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        if (CfdListContains(cf_scheduled, cfd)) {
-          continue;
-        }
-        new_bottommost_files_mark_threshold = std::min(
-            new_bottommost_files_mark_threshold,
-            cfd->current()->storage_info()->bottommost_files_mark_threshold());
-      }
-      bottommost_files_mark_threshold_ = new_bottommost_files_mark_threshold;
     }
   }
   delete casted_s;
@@ -2805,8 +2753,7 @@ Status DBImpl::GetDbIdentity(std::string& identity) const {
   if (!s.ok()) {
     return s;
   }
-  char* buffer =
-      reinterpret_cast<char*>(alloca(static_cast<size_t>(file_size)));
+  char* buffer = reinterpret_cast<char*>(alloca(static_cast<size_t>(file_size)));
   Slice id;
   s = id_file_reader->Read(static_cast<size_t>(file_size), &id, buffer);
   if (!s.ok()) {
@@ -2893,13 +2840,13 @@ Status DestroyDB(const std::string& dbname, const Options& options,
     InfoLogPrefix info_log_prefix(!soptions.db_log_dir.empty(), dbname);
     for (const auto& fname : filenames) {
       if (ParseFileName(fname, &number, info_log_prefix.prefix, &type) &&
-          type != kDBLockFile) {  // Lock file will be deleted at end
+        type != kDBLockFile) {  // Lock file will be deleted at end
         Status del;
         std::string path_to_delete = dbname + "/" + fname;
         if (type == kMetaDatabase) {
           del = DestroyDB(path_to_delete, options);
-        } else if (type == kTableFile || type == kLogFile) {
-          del = DeleteDBFile(&soptions, path_to_delete, dbname);
+        } else if (type == kTableFile) {
+          del = DeleteSSTFile(&soptions, path_to_delete, dbname);
         } else {
           del = env->DeleteFile(path_to_delete);
         }
@@ -2931,9 +2878,9 @@ Status DestroyDB(const std::string& dbname, const Options& options,
       if (env->GetChildren(path, &filenames).ok()) {
         for (const auto& fname : filenames) {
           if (ParseFileName(fname, &number, &type) &&
-              type == kTableFile) {  // Lock file will be deleted at end
+            type == kTableFile) {  // Lock file will be deleted at end
             std::string table_path = path + "/" + fname;
-            Status del = DeleteDBFile(&soptions, table_path, dbname);
+            Status del = DeleteSSTFile(&soptions, table_path, dbname);
             if (result.ok() && !del.ok()) {
               result = del;
             }
@@ -2958,9 +2905,9 @@ Status DestroyDB(const std::string& dbname, const Options& options,
     if (env->GetChildren(archivedir, &archiveFiles).ok()) {
       // Delete archival files.
       for (const auto& file : archiveFiles) {
-        if (ParseFileName(file, &number, &type) && type == kLogFile) {
-          Status del =
-              DeleteDBFile(&soptions, archivedir + "/" + file, archivedir);
+        if (ParseFileName(file, &number, &type) &&
+          type == kLogFile) {
+          Status del = env->DeleteFile(archivedir + "/" + file);
           if (result.ok() && !del.ok()) {
             result = del;
           }
@@ -2973,9 +2920,7 @@ Status DestroyDB(const std::string& dbname, const Options& options,
     if (wal_dir_exists) {
       for (const auto& file : walDirFiles) {
         if (ParseFileName(file, &number, &type) && type == kLogFile) {
-          Status del =
-              DeleteDBFile(&soptions, LogFileName(soptions.wal_dir, number),
-                           soptions.wal_dir);
+          Status del = env->DeleteFile(LogFileName(soptions.wal_dir, number));
           if (result.ok() && !del.ok()) {
             result = del;
           }
@@ -3170,7 +3115,7 @@ void DumpRocksDBBuildVersion(Logger* log) {
   ROCKS_LOG_HEADER(log, "Git sha %s", rocksdb_build_git_sha);
   ROCKS_LOG_HEADER(log, "Compile date %s", rocksdb_build_compile_date);
 #else
-  (void)log;  // ignore "-Wunused-parameter"
+    (void)log;  // ignore "-Wunused-parameter"
 #endif
 }
 
@@ -3608,8 +3553,8 @@ Status DBImpl::VerifyChecksum() {
     Options opts;
     {
       InstrumentedMutexLock l(&mutex_);
-      opts = Options(BuildDBOptions(immutable_db_options_, mutable_db_options_),
-                     cfd->GetLatestCFOptions());
+      opts = Options(BuildDBOptions(immutable_db_options_,
+         mutable_db_options_), cfd->GetLatestCFOptions());
     }
     for (int i = 0; i < vstorage->num_non_empty_levels() && s.ok(); i++) {
       for (size_t j = 0; j < vstorage->LevelFilesBrief(i).num_files && s.ok();
@@ -3674,13 +3619,8 @@ Status DBImpl::StartTrace(const TraceOptions& trace_options,
 
 Status DBImpl::EndTrace() {
   InstrumentedMutexLock lock(&trace_mutex_);
-  Status s;
-  if (tracer_ != nullptr) {
-    s = tracer_->Close();
-    tracer_.reset();
-  } else {
-    return Status::IOError("No trace file to close");
-  }
+  Status s = tracer_->Close();
+  tracer_.reset();
   return s;
 }
 

db/db_impl.h

@@ -178,9 +178,10 @@ class DBImpl : public DB {
   virtual bool GetAggregatedIntProperty(const Slice& property,
                                         uint64_t* aggregated_value) override;
   using DB::GetApproximateSizes;
-  virtual void GetApproximateSizes(
-      ColumnFamilyHandle* column_family, const Range* range, int n,
-      uint64_t* sizes, uint8_t include_flags = INCLUDE_FILES) override;
+  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
+                                   const Range* range, int n, uint64_t* sizes,
+                                   uint8_t include_flags
+                                   = INCLUDE_FILES) override;
   using DB::GetApproximateMemTableStats;
   virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
                                            const Range& range,
@@ -234,10 +235,8 @@ class DBImpl : public DB {
       const FlushOptions& options,
       const std::vector<ColumnFamilyHandle*>& column_families) override;
   virtual Status FlushWAL(bool sync) override;
-  bool TEST_WALBufferIsEmpty(bool lock = true);
+  bool TEST_WALBufferIsEmpty();
   virtual Status SyncWAL() override;
-  virtual Status LockWAL() override;
-  virtual Status UnlockWAL() override;
 
   virtual SequenceNumber GetLatestSequenceNumber() const override;
   virtual SequenceNumber GetLastPublishedSequence() const {
@@ -285,8 +284,9 @@ class DBImpl : public DB {
   // Status::NotFound() will be returned if the current DB does not have
   // any column family match the specified name.
   // TODO(yhchiang): output parameter is placed in the end in this codebase.
-  virtual void GetColumnFamilyMetaData(ColumnFamilyHandle* column_family,
-                                       ColumnFamilyMetaData* metadata) override;
+  virtual void GetColumnFamilyMetaData(
+      ColumnFamilyHandle* column_family,
+      ColumnFamilyMetaData* metadata) override;
 
   Status SuggestCompactRange(ColumnFamilyHandle* column_family,
                              const Slice* begin, const Slice* end) override;
@@ -378,8 +378,9 @@ class DBImpl : public DB {
 
   Status RunManualCompaction(ColumnFamilyData* cfd, int input_level,
                              int output_level, uint32_t output_path_id,
-                             uint32_t max_subcompactions, const Slice* begin,
-                             const Slice* end, bool exclusive,
+                             uint32_t max_subcompactions,
+                             const Slice* begin, const Slice* end,
+                             bool exclusive,
                              bool disallow_trivial_move = false);
 
   // Return an internal iterator over the current state of the database.
@@ -426,8 +427,8 @@ class DBImpl : public DB {
 
   // Return the maximum overlapping data (in bytes) at next level for any
   // file at a level >= 1.
-  int64_t TEST_MaxNextLevelOverlappingBytes(
-      ColumnFamilyHandle* column_family = nullptr);
+  int64_t TEST_MaxNextLevelOverlappingBytes(ColumnFamilyHandle* column_family =
+                                                nullptr);
 
   // Return the current manifest file no.
   uint64_t TEST_Current_Manifest_FileNo();
@@ -757,29 +758,6 @@ class DBImpl : public DB {
   std::unique_ptr<Tracer> tracer_;
   InstrumentedMutex trace_mutex_;
 
-  // State below is protected by mutex_
-  // With two_write_queues enabled, some of the variables that accessed during
-  // WriteToWAL need different synchronization: log_empty_, alive_log_files_,
-  // logs_, logfile_number_. Refer to the definition of each variable below for
-  // more description.
-  mutable InstrumentedMutex mutex_;
-
-  ColumnFamilyHandleImpl* default_cf_handle_;
-  InternalStats* default_cf_internal_stats_;
-
-  // only used for dynamically adjusting max_total_wal_size. it is a sum of
-  // [write_buffer_size * max_write_buffer_number] over all column families
-  uint64_t max_total_in_memory_state_;
-  // If true, we have only one (default) column family. We use this to optimize
-  // some code-paths
-  bool single_column_family_mode_;
-
-  // The options to access storage files
-  const EnvOptions env_options_;
-
-  // Additonal options for compaction and flush
-  EnvOptions env_options_for_compaction_;
-
   // Except in DB::Open(), WriteOptionsFile can only be called when:
   // Persist options to options file.
   // If need_mutex_lock = false, the method will lock DB mutex.
@@ -800,12 +778,13 @@ class DBImpl : public DB {
                               const MutableCFOptions& mutable_cf_options,
                               int job_id, TableProperties prop);
 
-  void NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
-                               const Status& st,
-                               const CompactionJobStats& job_stats, int job_id);
+  void NotifyOnCompactionBegin(ColumnFamilyData* cfd,
+                               Compaction *c, const Status &st,
+                               const CompactionJobStats& job_stats,
+                               int job_id);
 
-  void NotifyOnCompactionCompleted(ColumnFamilyData* cfd, Compaction* c,
-                                   const Status& st,
+  void NotifyOnCompactionCompleted(ColumnFamilyData* cfd,
+                                   Compaction *c, const Status &st,
                                    const CompactionJobStats& job_stats,
                                    int job_id);
   void NotifyOnMemTableSealed(ColumnFamilyData* cfd,
@@ -866,14 +845,6 @@ class DBImpl : public DB {
   // Actual implementation of Close()
   Status CloseImpl();
 
-  // Recover the descriptor from persistent storage.  May do a significant
-  // amount of work to recover recently logged updates.  Any changes to
-  // be made to the descriptor are added to *edit.
-  virtual Status Recover(
-      const std::vector<ColumnFamilyDescriptor>& column_families,
-      bool read_only = false, bool error_if_log_file_exist = false,
-      bool error_if_data_exists_in_logs = false);
-
  private:
   friend class DB;
   friend class ErrorHandler;
@@ -894,7 +865,6 @@ class DBImpl : public DB {
   friend class CompactedDBImpl;
   friend class DBTest_ConcurrentFlushWAL_Test;
   friend class DBTest_MixedSlowdownOptionsStop_Test;
-  friend class DBCompactionTest_CompactBottomLevelFilesWithDeletions_Test;
 #ifndef NDEBUG
   friend class DBTest2_ReadCallbackTest_Test;
   friend class WriteCallbackTest_WriteWithCallbackTest_Test;
@@ -922,6 +892,13 @@ class DBImpl : public DB {
   struct PrepickedCompaction;
   struct PurgeFileInfo;
 
+  // Recover the descriptor from persistent storage.  May do a significant
+  // amount of work to recover recently logged updates.  Any changes to
+  // be made to the descriptor are added to *edit.
+  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
+                 bool read_only = false, bool error_if_log_file_exist = false,
+                 bool error_if_data_exists_in_logs = false);
+
   Status ResumeImpl();
 
   void MaybeIgnoreError(Status* s) const;
@@ -971,8 +948,7 @@ class DBImpl : public DB {
       SuperVersionContext* superversion_context,
       std::vector<SequenceNumber>& snapshot_seqs,
       SequenceNumber earliest_write_conflict_snapshot,
-      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-      Env::Priority thread_pri);
+      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer);
 
   // Argument required by background flush thread.
   struct BGFlushArg {
@@ -995,22 +971,15 @@ class DBImpl : public DB {
     SuperVersionContext* superversion_context_;
   };
 
-  // Argument passed to flush thread.
-  struct FlushThreadArg {
-    DBImpl* db_;
-
-    Env::Priority thread_pri_;
-  };
-
   // Flush the memtables of (multiple) column families to multiple files on
   // persistent storage.
   Status FlushMemTablesToOutputFiles(
       const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-      JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri);
+      JobContext* job_context, LogBuffer* log_buffer);
 
   Status AtomicFlushMemTablesToOutputFiles(
       const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-      JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri);
+      JobContext* job_context, LogBuffer* log_buffer);
 
   // REQUIRES: log_numbers are sorted in ascending order
   Status RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
@@ -1153,21 +1122,18 @@ class DBImpl : public DB {
   // Runs a pre-chosen universal compaction involving bottom level in a
   // separate, bottom-pri thread pool.
   static void BGWorkBottomCompaction(void* arg);
-  static void BGWorkFlush(void* arg);
+  static void BGWorkFlush(void* db);
   static void BGWorkPurge(void* arg);
-  static void UnscheduleCompactionCallback(void* arg);
-  static void UnscheduleFlushCallback(void* arg);
+  static void UnscheduleCallback(void* arg);
   void BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
-                                Env::Priority thread_pri);
-  void BackgroundCallFlush(Env::Priority thread_pri);
+                                Env::Priority bg_thread_pri);
+  void BackgroundCallFlush();
   void BackgroundCallPurge();
   Status BackgroundCompaction(bool* madeProgress, JobContext* job_context,
                               LogBuffer* log_buffer,
-                              PrepickedCompaction* prepicked_compaction,
-                              Env::Priority thread_pri);
+                              PrepickedCompaction* prepicked_compaction);
   Status BackgroundFlush(bool* madeProgress, JobContext* job_context,
-                         LogBuffer* log_buffer, FlushReason* reason,
-                         Env::Priority thread_pri);
+                         LogBuffer* log_buffer, FlushReason* reason);
 
   bool EnoughRoomForCompaction(ColumnFamilyData* cfd,
                                const std::vector<CompactionInputFiles>& inputs,
@@ -1195,8 +1161,7 @@ class DBImpl : public DB {
   // 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(ColumnFamilyData* cfd,
-                                   const MutableCFOptions& mutable_cf_options,
-                                   int level);
+      const MutableCFOptions& mutable_cf_options, int level);
 
   // Move the files in the input level to the target level.
   // If target_level < 0, automatically calculate the minimum level that could
@@ -1239,6 +1204,12 @@ class DBImpl : public DB {
   // and log_empty_. Refer to the definition of each variable below for more
   // details.
   InstrumentedMutex log_write_mutex_;
+  // State below is protected by mutex_
+  // With two_write_queues enabled, some of the variables that accessed during
+  // WriteToWAL need different synchronization: log_empty_, alive_log_files_,
+  // logs_, logfile_number_. Refer to the definition of each variable below for
+  // more description.
+  mutable InstrumentedMutex mutex_;
 
   std::atomic<bool> shutting_down_;
   // This condition variable is signaled on these conditions:
@@ -1270,10 +1241,12 @@ class DBImpl : public DB {
   // read and writes are protected by log_write_mutex_ instead. This is to avoid
   // expesnive mutex_ lock during WAL write, which update log_empty_.
   bool log_empty_;
-
+  ColumnFamilyHandleImpl* default_cf_handle_;
+  InternalStats* default_cf_internal_stats_;
   std::unique_ptr<ColumnFamilyMemTablesImpl> column_family_memtables_;
   struct LogFileNumberSize {
-    explicit LogFileNumberSize(uint64_t _number) : number(_number) {}
+    explicit LogFileNumberSize(uint64_t _number)
+        : number(_number) {}
     void AddSize(uint64_t new_size) { size += new_size; }
     uint64_t number;
     uint64_t size = 0;
@@ -1336,7 +1309,12 @@ class DBImpl : public DB {
   WriteBatch cached_recoverable_state_;
   std::atomic<bool> cached_recoverable_state_empty_ = {true};
   std::atomic<uint64_t> total_log_size_;
-
+  // only used for dynamically adjusting max_total_wal_size. it is a sum of
+  // [write_buffer_size * max_write_buffer_number] over all column families
+  uint64_t max_total_in_memory_state_;
+  // If true, we have only one (default) column family. We use this to optimize
+  // some code-paths
+  bool single_column_family_mode_;
   // If this is non-empty, we need to delete these log files in background
   // threads. Protected by db mutex.
   autovector<log::Writer*> logs_to_free_;
@@ -1485,15 +1463,15 @@ class DBImpl : public DB {
     uint32_t output_path_id;
     Status status;
     bool done;
-    bool in_progress;            // compaction request being processed?
-    bool incomplete;             // only part of requested range compacted
-    bool exclusive;              // current behavior of only one manual
-    bool disallow_trivial_move;  // Force actual compaction to run
-    const InternalKey* begin;    // nullptr means beginning of key range
-    const InternalKey* end;      // nullptr means end of key range
-    InternalKey* manual_end;     // how far we are compacting
-    InternalKey tmp_storage;     // Used to keep track of compaction progress
-    InternalKey tmp_storage1;    // Used to keep track of compaction progress
+    bool in_progress;             // compaction request being processed?
+    bool incomplete;              // only part of requested range compacted
+    bool exclusive;               // current behavior of only one manual
+    bool disallow_trivial_move;   // Force actual compaction to run
+    const InternalKey* begin;     // nullptr means beginning of key range
+    const InternalKey* end;       // nullptr means end of key range
+    InternalKey* manual_end;      // how far we are compacting
+    InternalKey tmp_storage;      // Used to keep track of compaction progress
+    InternalKey tmp_storage1;     // Used to keep track of compaction progress
   };
   struct PrepickedCompaction {
     // background compaction takes ownership of `compaction`.
@@ -1555,6 +1533,12 @@ class DBImpl : public DB {
 
   std::string db_absolute_path_;
 
+  // The options to access storage files
+  const EnvOptions env_options_;
+
+  // Additonal options for compaction and flush
+  EnvOptions env_options_for_compaction_;
+
   // Number of running IngestExternalFile() calls.
   // REQUIRES: mutex held
   int num_running_ingest_file_;
@@ -1578,10 +1562,6 @@ class DBImpl : public DB {
   // Indicate DB was opened successfully
   bool opened_successfully_;
 
-  // The min threshold to triggere bottommost compaction for removing
-  // garbages, among all column families.
-  SequenceNumber bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-
   LogsWithPrepTracker logs_with_prep_tracker_;
 
   // Callback for compaction to check if a key is visible to a snapshot.
@@ -1617,9 +1597,9 @@ class DBImpl : public DB {
 
 #ifndef ROCKSDB_LITE
   using DB::GetPropertiesOfAllTables;
-  virtual Status GetPropertiesOfAllTables(
-      ColumnFamilyHandle* column_family,
-      TablePropertiesCollection* props) override;
+  virtual Status GetPropertiesOfAllTables(ColumnFamilyHandle* column_family,
+                                          TablePropertiesCollection* props)
+      override;
   virtual Status GetPropertiesOfTablesInRange(
       ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
       TablePropertiesCollection* props) override;
@@ -1657,7 +1637,9 @@ class DBImpl : public DB {
   void MarkAsGrabbedForPurge(uint64_t file_number);
 
   size_t GetWalPreallocateBlockSize(uint64_t write_buffer_size) const;
-  Env::WriteLifeTimeHint CalculateWALWriteHint() { return Env::WLTH_SHORT; }
+  Env::WriteLifeTimeHint CalculateWALWriteHint() {
+    return Env::WLTH_SHORT;
+  }
 
   // When set, we use a separate queue for writes that dont write to memtable.
   // In 2PC these are the writes at Prepare phase.
@@ -1719,7 +1701,8 @@ class DBImpl : public DB {
   InstrumentedCondVar atomic_flush_install_cv_;
 };
 
-extern Options SanitizeOptions(const std::string& db, const Options& src);
+extern Options SanitizeOptions(const std::string& db,
+                               const Options& src);
 
 extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src);
 

db/db_impl_compaction_flush.cc

@@ -135,12 +135,12 @@ Status DBImpl::FlushMemTableToOutputFile(
     SuperVersionContext* superversion_context,
     std::vector<SequenceNumber>& snapshot_seqs,
     SequenceNumber earliest_write_conflict_snapshot,
-    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-    Env::Priority thread_pri) {
+    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer) {
   mutex_.AssertHeld();
   assert(cfd->imm()->NumNotFlushed() != 0);
   assert(cfd->imm()->IsFlushPending());
 
+
   FlushJob flush_job(
       dbname_, cfd, immutable_db_options_, mutable_cf_options,
       nullptr /* memtable_id */, env_options_for_compaction_, versions_.get(),
@@ -149,7 +149,7 @@ Status DBImpl::FlushMemTableToOutputFile(
       GetDataDir(cfd, 0U),
       GetCompressionFlush(*cfd->ioptions(), mutable_cf_options), stats_,
       &event_logger_, mutable_cf_options.report_bg_io_stats,
-      true /* sync_output_directory */, true /* write_manifest */, thread_pri);
+      true /* sync_output_directory */, true /* write_manifest */);
 
   FileMetaData file_meta;
 
@@ -218,8 +218,7 @@ Status DBImpl::FlushMemTableToOutputFile(
           cfd->ioptions()->cf_paths[0].path, file_meta.fd.GetNumber());
       sfm->OnAddFile(file_path);
       if (sfm->IsMaxAllowedSpaceReached()) {
-        Status new_bg_error =
-            Status::SpaceLimit("Max allowed space was reached");
+        Status new_bg_error = Status::SpaceLimit("Max allowed space was reached");
         TEST_SYNC_POINT_CALLBACK(
             "DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached",
             &new_bg_error);
@@ -233,10 +232,10 @@ Status DBImpl::FlushMemTableToOutputFile(
 
 Status DBImpl::FlushMemTablesToOutputFiles(
     const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-    JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri) {
+    JobContext* job_context, LogBuffer* log_buffer) {
   if (immutable_db_options_.atomic_flush) {
-    return AtomicFlushMemTablesToOutputFiles(
-        bg_flush_args, made_progress, job_context, log_buffer, thread_pri);
+    return AtomicFlushMemTablesToOutputFiles(bg_flush_args, made_progress,
+                                             job_context, log_buffer);
   }
   std::vector<SequenceNumber> snapshot_seqs;
   SequenceNumber earliest_write_conflict_snapshot;
@@ -251,7 +250,7 @@ Status DBImpl::FlushMemTablesToOutputFiles(
     Status s = FlushMemTableToOutputFile(
         cfd, mutable_cf_options, made_progress, job_context,
         superversion_context, snapshot_seqs, earliest_write_conflict_snapshot,
-        snapshot_checker, log_buffer, thread_pri);
+        snapshot_checker, log_buffer);
     if (!s.ok()) {
       status = s;
       if (!s.IsShutdownInProgress()) {
@@ -275,7 +274,7 @@ Status DBImpl::FlushMemTablesToOutputFiles(
  */
 Status DBImpl::AtomicFlushMemTablesToOutputFiles(
     const autovector<BGFlushArg>& bg_flush_args, bool* made_progress,
-    JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri) {
+    JobContext* job_context, LogBuffer* log_buffer) {
   mutex_.AssertHeld();
 
   autovector<ColumnFamilyData*> cfds;
@@ -332,8 +331,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
         snapshot_checker, job_context, log_buffer, directories_.GetDbDir(),
         data_dir, GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
         stats_, &event_logger_, mutable_cf_options.report_bg_io_stats,
-        false /* sync_output_directory */, false /* write_manifest */,
-        thread_pri);
+        false /* sync_output_directory */, false /* write_manifest */);
     jobs.back().PickMemTable();
   }
 
@@ -740,8 +738,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,
         }
       }
       s = RunManualCompaction(cfd, level, output_level, options.target_path_id,
-                              options.max_subcompactions, begin, end,
-                              exclusive);
+                              options.max_subcompactions, begin, end, exclusive);
       if (!s.ok()) {
         break;
       }
@@ -960,7 +957,7 @@ Status DBImpl::CompactFilesImpl(
       snapshot_checker, table_cache_, &event_logger_,
       c->mutable_cf_options()->paranoid_file_checks,
       c->mutable_cf_options()->report_bg_io_stats, dbname_,
-      &compaction_job_stats, Env::Priority::USER);
+      &compaction_job_stats);
 
   // Creating a compaction influences the compaction score because the score
   // takes running compactions into account (by skipping files that are already
@@ -1064,8 +1061,8 @@ Status DBImpl::ContinueBackgroundWork() {
   return Status::OK();
 }
 
-void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
-                                     const Status& st,
+void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd,
+                                     Compaction *c, const Status &st,
                                      const CompactionJobStats& job_stats,
                                      int job_id) {
 #ifndef ROCKSDB_LITE
@@ -1310,9 +1307,8 @@ Status DBImpl::Flush(const FlushOptions& flush_options,
                   });
     s = AtomicFlushMemTables(cfds, flush_options, FlushReason::kManualFlush);
     ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Manual atomic flush finished, status: %s\n"
-                   "=====Column families:=====",
-                   s.ToString().c_str());
+                   "Manual atomic flush finished, status: %s\n",
+                   "=====Column families:=====", s.ToString().c_str());
     for (auto cfh : column_families) {
       auto cfhi = static_cast<ColumnFamilyHandleImpl*>(cfh);
       ROCKS_LOG_INFO(immutable_db_options_.info_log, "%s",
@@ -1449,7 +1445,7 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
       manual.incomplete = false;
       bg_compaction_scheduled_++;
       env_->Schedule(&DBImpl::BGWorkCompaction, ca, Env::Priority::LOW, this,
-                     &DBImpl::UnscheduleCompactionCallback);
+                     &DBImpl::UnscheduleCallback);
       scheduled = true;
     }
   }
@@ -1626,7 +1622,7 @@ Status DBImpl::AtomicFlushMemTables(
 // it against various constrains and delays flush if it'd cause write stall.
 // Called should check status and flush_needed to see if flush already happened.
 Status DBImpl::WaitUntilFlushWouldNotStallWrites(ColumnFamilyData* cfd,
-                                                 bool* flush_needed) {
+    bool* flush_needed) {
   {
     *flush_needed = true;
     InstrumentedMutexLock l(&mutex_);
@@ -1774,7 +1770,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
     // we paused the background work
     return;
   } else if (error_handler_.IsBGWorkStopped() &&
-             !error_handler_.IsRecoveryInProgress()) {
+      !error_handler_.IsRecoveryInProgress()) {
     // There has been a hard error and this call is not part of the recovery
     // sequence. Bail out here so we don't get into an endless loop of
     // scheduling BG work which will again call this function
@@ -1789,11 +1785,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
   while (!is_flush_pool_empty && unscheduled_flushes_ > 0 &&
          bg_flush_scheduled_ < bg_job_limits.max_flushes) {
     bg_flush_scheduled_++;
-    FlushThreadArg* fta = new FlushThreadArg;
-    fta->db_ = this;
-    fta->thread_pri_ = Env::Priority::HIGH;
-    env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::HIGH, this,
-                   &DBImpl::UnscheduleFlushCallback);
+    env_->Schedule(&DBImpl::BGWorkFlush, this, Env::Priority::HIGH, this);
   }
 
   // special case -- if high-pri (flush) thread pool is empty, then schedule
@@ -1803,11 +1795,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
            bg_flush_scheduled_ + bg_compaction_scheduled_ <
                bg_job_limits.max_flushes) {
       bg_flush_scheduled_++;
-      FlushThreadArg* fta = new FlushThreadArg;
-      fta->db_ = this;
-      fta->thread_pri_ = Env::Priority::LOW;
-      env_->Schedule(&DBImpl::BGWorkFlush, fta, Env::Priority::LOW, this,
-                     &DBImpl::UnscheduleFlushCallback);
+      env_->Schedule(&DBImpl::BGWorkFlush, this, Env::Priority::LOW, this);
     }
   }
 
@@ -1837,7 +1825,7 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
     bg_compaction_scheduled_++;
     unscheduled_compactions_--;
     env_->Schedule(&DBImpl::BGWorkCompaction, ca, Env::Priority::LOW, this,
-                   &DBImpl::UnscheduleCompactionCallback);
+                   &DBImpl::UnscheduleCallback);
   }
 }
 
@@ -1952,13 +1940,10 @@ void DBImpl::SchedulePendingPurge(std::string fname, std::string dir_to_sync,
   purge_queue_.push_back(std::move(file_info));
 }
 
-void DBImpl::BGWorkFlush(void* arg) {
-  FlushThreadArg fta = *(reinterpret_cast<FlushThreadArg*>(arg));
-  delete reinterpret_cast<FlushThreadArg*>(arg);
-
-  IOSTATS_SET_THREAD_POOL_ID(fta.thread_pri_);
+void DBImpl::BGWorkFlush(void* db) {
+  IOSTATS_SET_THREAD_POOL_ID(Env::Priority::HIGH);
   TEST_SYNC_POINT("DBImpl::BGWorkFlush");
-  reinterpret_cast<DBImpl*>(fta.db_)->BackgroundCallFlush(fta.thread_pri_);
+  reinterpret_cast<DBImpl*>(db)->BackgroundCallFlush();
   TEST_SYNC_POINT("DBImpl::BGWorkFlush:done");
 }
 
@@ -1993,7 +1978,7 @@ void DBImpl::BGWorkPurge(void* db) {
   TEST_SYNC_POINT("DBImpl::BGWorkPurge:end");
 }
 
-void DBImpl::UnscheduleCompactionCallback(void* arg) {
+void DBImpl::UnscheduleCallback(void* arg) {
   CompactionArg ca = *(reinterpret_cast<CompactionArg*>(arg));
   delete reinterpret_cast<CompactionArg*>(arg);
   if (ca.prepicked_compaction != nullptr) {
@@ -2002,17 +1987,11 @@ void DBImpl::UnscheduleCompactionCallback(void* arg) {
     }
     delete ca.prepicked_compaction;
   }
-  TEST_SYNC_POINT("DBImpl::UnscheduleCompactionCallback");
-}
-
-void DBImpl::UnscheduleFlushCallback(void* arg) {
-  delete reinterpret_cast<FlushThreadArg*>(arg);
-  TEST_SYNC_POINT("DBImpl::UnscheduleFlushCallback");
+  TEST_SYNC_POINT("DBImpl::UnscheduleCallback");
 }
 
 Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
-                               LogBuffer* log_buffer, FlushReason* reason,
-                               Env::Priority thread_pri) {
+                               LogBuffer* log_buffer, FlushReason* reason) {
   mutex_.AssertHeld();
 
   Status status;
@@ -2073,7 +2052,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
           bg_compaction_scheduled_);
     }
     status = FlushMemTablesToOutputFiles(bg_flush_args, made_progress,
-                                         job_context, log_buffer, thread_pri);
+                                         job_context, log_buffer);
     // All the CFDs in the FlushReq must have the same flush reason, so just
     // grab the first one
     *reason = bg_flush_args[0].cfd_->GetFlushReason();
@@ -2088,7 +2067,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
   return status;
 }
 
-void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
+void DBImpl::BackgroundCallFlush() {
   bool made_progress = false;
   JobContext job_context(next_job_id_.fetch_add(1), true);
 
@@ -2105,8 +2084,8 @@ void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
         CaptureCurrentFileNumberInPendingOutputs();
     FlushReason reason;
 
-    Status s = BackgroundFlush(&made_progress, &job_context, &log_buffer,
-                               &reason, thread_pri);
+    Status s =
+        BackgroundFlush(&made_progress, &job_context, &log_buffer, &reason);
     if (!s.ok() && !s.IsShutdownInProgress() &&
         reason != FlushReason::kErrorRecovery) {
       // Wait a little bit before retrying background flush in
@@ -2189,12 +2168,12 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
             bg_bottom_compaction_scheduled_) ||
            (bg_thread_pri == Env::Priority::LOW && bg_compaction_scheduled_));
     Status s = BackgroundCompaction(&made_progress, &job_context, &log_buffer,
-                                    prepicked_compaction, bg_thread_pri);
+                                    prepicked_compaction);
     TEST_SYNC_POINT("BackgroundCallCompaction:1");
     if (s.IsBusy()) {
       bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
       mutex_.Unlock();
-      env_->SleepForMicroseconds(10000);  // prevent hot loop
+      env_->SleepForMicroseconds(10000); // prevent hot loop
       mutex_.Lock();
     } else if (!s.ok() && !s.IsShutdownInProgress()) {
       // Wait a little bit before retrying background compaction in
@@ -2276,8 +2255,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
 Status DBImpl::BackgroundCompaction(bool* made_progress,
                                     JobContext* job_context,
                                     LogBuffer* log_buffer,
-                                    PrepickedCompaction* prepicked_compaction,
-                                    Env::Priority thread_pri) {
+                                    PrepickedCompaction* prepicked_compaction) {
   ManualCompactionState* manual_compaction =
       prepicked_compaction == nullptr
           ? nullptr
@@ -2440,8 +2418,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
           status = Status::CompactionTooLarge();
         } else {
           // update statistics
-          RecordInHistogram(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
-                            c->inputs(0)->size());
+          MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
+                      c->inputs(0)->size());
           // There are three things that can change compaction score:
           // 1) When flush or compaction finish. This case is covered by
           // InstallSuperVersionAndScheduleWork
@@ -2590,7 +2568,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     ca->prepicked_compaction->task_token = std::move(task_token);
     ++bg_bottom_compaction_scheduled_;
     env_->Schedule(&DBImpl::BGWorkBottomCompaction, ca, Env::Priority::BOTTOM,
-                   this, &DBImpl::UnscheduleCompactionCallback);
+                   this, &DBImpl::UnscheduleCallback);
   } else {
     TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
                              c->column_family_data());
@@ -2609,11 +2587,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
         env_options_for_compaction_, versions_.get(), &shutting_down_,
         preserve_deletes_seqnum_.load(), log_buffer, directories_.GetDbDir(),
         GetDataDir(c->column_family_data(), c->output_path_id()), stats_,
-        &mutex_, &error_handler_, snapshot_seqs,
-        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
-        &event_logger_, c->mutable_cf_options()->paranoid_file_checks,
+        &mutex_, &error_handler_, snapshot_seqs, earliest_write_conflict_snapshot,
+        snapshot_checker, table_cache_, &event_logger_,
+        c->mutable_cf_options()->paranoid_file_checks,
         c->mutable_cf_options()->report_bg_io_stats, dbname_,
-        &compaction_job_stats, thread_pri);
+        &compaction_job_stats);
     compaction_job.Prepare();
 
     NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
@@ -2836,7 +2814,7 @@ void DBImpl::BuildCompactionJobInfo(
                               fmd->fd.GetNumber(), fmd->fd.GetPathId());
       compaction_job_info->input_files.push_back(fn);
       if (compaction_job_info->table_properties.count(fn) == 0) {
-        std::shared_ptr<const TableProperties> tp;
+        shared_ptr<const TableProperties> tp;
         auto s = current->GetTableProperties(&tp, fmd, &fn);
         if (s.ok()) {
           compaction_job_info->table_properties[fn] = tp;
@@ -2883,17 +2861,6 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
   }
   cfd->InstallSuperVersion(sv_context, &mutex_, mutable_cf_options);
 
-  // There may be a small data race here. The snapshot tricking bottommost
-  // compaction may already be released here. But assuming there will always be
-  // newer snapshot created and released frequently, the compaction will be
-  // triggered soon anyway.
-  bottommost_files_mark_threshold_ = kMaxSequenceNumber;
-  for (auto* my_cfd : *versions_->GetColumnFamilySet()) {
-    bottommost_files_mark_threshold_ = std::min(
-        bottommost_files_mark_threshold_,
-        my_cfd->current()->storage_info()->bottommost_files_mark_threshold());
-  }
-
   // Whenever we install new SuperVersion, we might need to issue new flushes or
   // compactions.
   SchedulePendingCompaction(cfd);

db/db_impl_debug.cc

@@ -26,16 +26,10 @@ void DBImpl::TEST_SwitchWAL() {
   SwitchWAL(&write_context);
 }
 
-bool DBImpl::TEST_WALBufferIsEmpty(bool lock) {
-  if (lock) {
-    log_write_mutex_.Lock();
-  }
+bool DBImpl::TEST_WALBufferIsEmpty() {
+  InstrumentedMutexLock wl(&log_write_mutex_);
   log::Writer* cur_log_writer = logs_.back().writer;
-  auto res = cur_log_writer->TEST_BufferIsEmpty();
-  if (lock) {
-    log_write_mutex_.Unlock();
-  }
-  return res;
+  return cur_log_writer->TEST_BufferIsEmpty();
 }
 
 int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes(
@@ -107,7 +101,7 @@ Status DBImpl::TEST_SwitchMemtable(ColumnFamilyData* cfd) {
 }
 
 Status DBImpl::TEST_FlushMemTable(bool wait, bool allow_write_stall,
-                                  ColumnFamilyHandle* cfh) {
+    ColumnFamilyHandle* cfh) {
   FlushOptions fo;
   fo.wait = wait;
   fo.allow_write_stall = allow_write_stall;
@@ -149,9 +143,13 @@ Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {
   return error_handler_.GetBGError();
 }
 
-void DBImpl::TEST_LockMutex() { mutex_.Lock(); }
+void DBImpl::TEST_LockMutex() {
+  mutex_.Lock();
+}
 
-void DBImpl::TEST_UnlockMutex() { mutex_.Unlock(); }
+void DBImpl::TEST_UnlockMutex() {
+  mutex_.Unlock();
+}
 
 void* DBImpl::TEST_BeginWrite() {
   auto w = new WriteThread::Writer();

db/db_impl_files.cc

@@ -108,7 +108,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
   versions_->AddLiveFiles(&job_context->sst_live);
   if (doing_the_full_scan) {
     InfoLogPrefix info_log_prefix(!immutable_db_options_.db_log_dir.empty(),
-                                  dbname_);
+        dbname_);
     std::set<std::string> paths;
     for (size_t path_id = 0; path_id < immutable_db_options_.db_paths.size();
          path_id++) {
@@ -152,7 +152,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
         }
 
         // TODO(icanadi) clean up this mess to avoid having one-off "/" prefixes
-        job_context->full_scan_candidate_files.emplace_back("/" + file, path);
+        job_context->full_scan_candidate_files.emplace_back(
+            "/" + file, path);
       }
     }
 
@@ -162,8 +163,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
       env_->GetChildren(immutable_db_options_.wal_dir,
                         &log_files);  // Ignore errors
       for (const std::string& log_file : log_files) {
-        job_context->full_scan_candidate_files.emplace_back(
-            log_file, immutable_db_options_.wal_dir);
+        job_context->full_scan_candidate_files.emplace_back(log_file,
+            immutable_db_options_.wal_dir);
       }
     }
     // Add info log files in db_log_dir
@@ -173,8 +174,8 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
       // Ignore errors
       env_->GetChildren(immutable_db_options_.db_log_dir, &info_log_files);
       for (std::string& log_file : info_log_files) {
-        job_context->full_scan_candidate_files.emplace_back(
-            log_file, immutable_db_options_.db_log_dir);
+        job_context->full_scan_candidate_files.emplace_back(log_file,
+            immutable_db_options_.db_log_dir);
       }
     }
   }
@@ -259,14 +260,14 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
                                     const std::string& path_to_sync,
                                     FileType type, uint64_t number) {
   Status file_deletion_status;
-  if (type == kTableFile || type == kLogFile) {
+  if (type == kTableFile) {
     file_deletion_status =
-        DeleteDBFile(&immutable_db_options_, fname, path_to_sync);
+        DeleteSSTFile(&immutable_db_options_, fname, path_to_sync);
   } else {
     file_deletion_status = env_->DeleteFile(fname);
   }
   TEST_SYNC_POINT_CALLBACK("DBImpl::DeleteObsoleteFileImpl:AfterDeletion",
-                           &file_deletion_status);
+      &file_deletion_status);
   if (file_deletion_status.ok()) {
     ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
                     "[JOB %d] Delete %s type=%d #%" PRIu64 " -- %s\n", job_id,
@@ -321,8 +322,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
   const char* kDumbDbName = "";
   for (auto& file : state.sst_delete_files) {
     candidate_files.emplace_back(
-        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()),
-        file.path);
+        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()), file.path);
     if (file.metadata->table_reader_handle) {
       table_cache_->Release(file.metadata->table_reader_handle);
     }
@@ -332,7 +332,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
   for (auto file_num : state.log_delete_files) {
     if (file_num > 0) {
       candidate_files.emplace_back(LogFileName(kDumbDbName, file_num),
-                                   immutable_db_options_.wal_dir);
+          immutable_db_options_.wal_dir);
     }
   }
   for (const auto& filename : state.manifest_delete_files) {
@@ -465,12 +465,13 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
     } else {
       dir_to_sync =
           (type == kLogFile) ? immutable_db_options_.wal_dir : dbname_;
-      fname = dir_to_sync +
-              ((!dir_to_sync.empty() && dir_to_sync.back() == '/') ||
-                       (!to_delete.empty() && to_delete.front() == '/')
-                   ? ""
-                   : "/") +
-              to_delete;
+      fname = dir_to_sync
+            + (
+                (!dir_to_sync.empty() && dir_to_sync.back() == '/') ||
+                (!to_delete.empty() && to_delete.front() == '/')
+                ? "" : "/"
+              )
+            + to_delete;
     }
 
 #ifndef ROCKSDB_LITE

db/db_impl_open.cc

@@ -580,7 +580,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
 
     ROCKS_LOG_INFO(immutable_db_options_.info_log,
                    "Recovering log #%" PRIu64 " mode %d", log_number,
-                   static_cast<int>(immutable_db_options_.wal_recovery_mode));
+                   immutable_db_options_.wal_recovery_mode);
     auto logFileDropped = [this, &fname]() {
       uint64_t bytes;
       if (env_->GetFileSize(fname, &bytes).ok()) {
@@ -629,7 +629,8 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
     // to be skipped instead of propagating bad information (like overly
     // large sequence numbers).
     log::Reader reader(immutable_db_options_.info_log, std::move(file_reader),
-                       &reporter, true /*checksum*/, log_number);
+                       &reporter, true /*checksum*/, log_number,
+                       false /* retry_after_eof */);
 
     // Determine if we should tolerate incomplete records at the tail end of the
     // Read all the records and add to a memtable
@@ -723,8 +724,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
                 " mode %d log filter %s returned "
                 "more records (%d) than original (%d) which is not allowed. "
                 "Aborting recovery.",
-                log_number,
-                static_cast<int>(immutable_db_options_.wal_recovery_mode),
+                log_number, immutable_db_options_.wal_recovery_mode,
                 immutable_db_options_.wal_filter->Name(), new_count,
                 original_count);
             status = Status::NotSupported(
@@ -1029,7 +1029,6 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
           cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
           snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
           GetCompressionFlush(*cfd->ioptions(), mutable_cf_options),
-          mutable_cf_options.sample_for_compression,
           cfd->ioptions()->compression_opts, paranoid_file_checks,
           cfd->internal_stats(), TableFileCreationReason::kRecovery,
           &event_logger_, job_id, Env::IO_HIGH, nullptr /* table_properties */,
@@ -1059,7 +1058,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
   stats.micros = env_->NowMicros() - start_micros;
   stats.bytes_written = meta.fd.GetFileSize();
   stats.num_output_files = 1;
-  cfd->internal_stats()->AddCompactionStats(level, Env::Priority::USER, stats);
+  cfd->internal_stats()->AddCompactionStats(level, stats);
   cfd->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
                                     meta.fd.GetFileSize());
   RecordTick(stats_, COMPACT_WRITE_BYTES, meta.fd.GetFileSize());

db/db_impl_readonly.cc

@@ -60,7 +60,7 @@ Status DBImplReadOnly::Get(const ReadOptions& read_options,
   RecordTick(stats_, NUMBER_KEYS_READ);
   size_t size = pinnable_val->size();
   RecordTick(stats_, BYTES_READ, size);
-  RecordInHistogram(stats_, BYTES_PER_READ, size);
+  MeasureTime(stats_, BYTES_PER_READ, size);
   PERF_COUNTER_ADD(get_read_bytes, size);
   return s;
 }

db/db_impl_readonly.h

@@ -7,9 +7,9 @@
 
 #ifndef ROCKSDB_LITE
 
-#include <string>
-#include <vector>
 #include "db/db_impl.h"
+#include <vector>
+#include <string>
 
 namespace rocksdb {
 
@@ -122,6 +122,6 @@ class DBImplReadOnly : public DBImpl {
   DBImplReadOnly(const DBImplReadOnly&);
   void operator=(const DBImplReadOnly&);
 };
-}  // namespace rocksdb
+}
 
 #endif  // !ROCKSDB_LITE

db/db_impl_secondary.cc

@@ -1,356 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/db_impl_secondary.h"
-#include "db/db_iter.h"
-#include "db/merge_context.h"
-#include "monitoring/perf_context_imp.h"
-#include "util/auto_roll_logger.h"
-
-namespace rocksdb {
-
-#ifndef ROCKSDB_LITE
-
-DBImplSecondary::DBImplSecondary(const DBOptions& db_options,
-                                 const std::string& dbname)
-    : DBImpl(db_options, dbname) {
-  ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                 "Opening the db in secondary mode");
-  LogFlush(immutable_db_options_.info_log);
-}
-
-DBImplSecondary::~DBImplSecondary() {}
-
-Status DBImplSecondary::Recover(
-    const std::vector<ColumnFamilyDescriptor>& column_families,
-    bool /*readonly*/, bool /*error_if_log_file_exist*/,
-    bool /*error_if_data_exists_in_logs*/) {
-  mutex_.AssertHeld();
-
-  Status s;
-  s = static_cast<ReactiveVersionSet*>(versions_.get())
-          ->Recover(column_families, &manifest_reader_, &manifest_reporter_,
-                    &manifest_reader_status_);
-  if (!s.ok()) {
-    return s;
-  }
-  if (immutable_db_options_.paranoid_checks && s.ok()) {
-    s = CheckConsistency();
-  }
-  // Initial max_total_in_memory_state_ before recovery logs.
-  max_total_in_memory_state_ = 0;
-  for (auto cfd : *versions_->GetColumnFamilySet()) {
-    auto* mutable_cf_options = cfd->GetLatestMutableCFOptions();
-    max_total_in_memory_state_ += mutable_cf_options->write_buffer_size *
-                                  mutable_cf_options->max_write_buffer_number;
-  }
-  if (s.ok()) {
-    default_cf_handle_ = new ColumnFamilyHandleImpl(
-        versions_->GetColumnFamilySet()->GetDefault(), this, &mutex_);
-    default_cf_internal_stats_ = default_cf_handle_->cfd()->internal_stats();
-    single_column_family_mode_ =
-        versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1;
-  }
-
-  // TODO: attempt to recover from WAL files.
-  return s;
-}
-
-// Implementation of the DB interface
-Status DBImplSecondary::Get(const ReadOptions& read_options,
-                            ColumnFamilyHandle* column_family, const Slice& key,
-                            PinnableSlice* value) {
-  return GetImpl(read_options, column_family, key, value);
-}
-
-Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
-                                ColumnFamilyHandle* column_family,
-                                const Slice& key, PinnableSlice* pinnable_val) {
-  assert(pinnable_val != nullptr);
-  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
-  StopWatch sw(env_, stats_, DB_GET);
-  PERF_TIMER_GUARD(get_snapshot_time);
-
-  auto cfh = static_cast<ColumnFamilyHandleImpl*>(column_family);
-  ColumnFamilyData* cfd = cfh->cfd();
-  if (tracer_) {
-    InstrumentedMutexLock lock(&trace_mutex_);
-    if (tracer_) {
-      tracer_->Get(column_family, key);
-    }
-  }
-  // Acquire SuperVersion
-  SuperVersion* super_version = GetAndRefSuperVersion(cfd);
-  SequenceNumber snapshot = versions_->LastSequence();
-  MergeContext merge_context;
-  SequenceNumber max_covering_tombstone_seq = 0;
-  Status s;
-  LookupKey lkey(key, snapshot);
-  PERF_TIMER_STOP(get_snapshot_time);
-
-  bool done = false;
-  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                              &max_covering_tombstone_seq, read_options)) {
-    done = true;
-    pinnable_val->PinSelf();
-    RecordTick(stats_, MEMTABLE_HIT);
-  } else if ((s.ok() || s.IsMergeInProgress()) &&
-             super_version->imm->Get(
-                 lkey, pinnable_val->GetSelf(), &s, &merge_context,
-                 &max_covering_tombstone_seq, read_options)) {
-    done = true;
-    pinnable_val->PinSelf();
-    RecordTick(stats_, MEMTABLE_HIT);
-  }
-  if (!done && !s.ok() && !s.IsMergeInProgress()) {
-    ReturnAndCleanupSuperVersion(cfd, super_version);
-    return s;
-  }
-  if (!done) {
-    PERF_TIMER_GUARD(get_from_output_files_time);
-    super_version->current->Get(read_options, lkey, pinnable_val, &s,
-                                &merge_context, &max_covering_tombstone_seq);
-    RecordTick(stats_, MEMTABLE_MISS);
-  }
-  {
-    PERF_TIMER_GUARD(get_post_process_time);
-    ReturnAndCleanupSuperVersion(cfd, super_version);
-    RecordTick(stats_, NUMBER_KEYS_READ);
-    size_t size = pinnable_val->size();
-    RecordTick(stats_, BYTES_READ, size);
-    RecordTimeToHistogram(stats_, BYTES_PER_READ, size);
-    PERF_COUNTER_ADD(get_read_bytes, size);
-  }
-  return s;
-}
-
-Iterator* DBImplSecondary::NewIterator(const ReadOptions& read_options,
-                                       ColumnFamilyHandle* column_family) {
-  if (read_options.managed) {
-    return NewErrorIterator(
-        Status::NotSupported("Managed iterator is not supported anymore."));
-  }
-  if (read_options.read_tier == kPersistedTier) {
-    return NewErrorIterator(Status::NotSupported(
-        "ReadTier::kPersistedData is not yet supported in iterators."));
-  }
-  Iterator* result = nullptr;
-  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
-  auto cfd = cfh->cfd();
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (read_options.tailing) {
-    return NewErrorIterator(Status::NotSupported(
-        "tailing iterator not supported in secondary mode"));
-  } else if (read_options.snapshot != nullptr) {
-    // TODO (yanqin) support snapshot.
-    return NewErrorIterator(
-        Status::NotSupported("snapshot not supported in secondary mode"));
-  } else {
-    auto snapshot = versions_->LastSequence();
-    result = NewIteratorImpl(read_options, cfd, snapshot, read_callback);
-  }
-  return result;
-}
-
-ArenaWrappedDBIter* DBImplSecondary::NewIteratorImpl(
-    const ReadOptions& read_options, ColumnFamilyData* cfd,
-    SequenceNumber snapshot, ReadCallback* read_callback) {
-  assert(nullptr != cfd);
-  SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-  auto db_iter = NewArenaWrappedDbIterator(
-      env_, read_options, *cfd->ioptions(), super_version->mutable_cf_options,
-      snapshot,
-      super_version->mutable_cf_options.max_sequential_skip_in_iterations,
-      super_version->version_number, read_callback);
-  auto internal_iter =
-      NewInternalIterator(read_options, cfd, super_version, db_iter->GetArena(),
-                          db_iter->GetRangeDelAggregator(), snapshot);
-  db_iter->SetIterUnderDBIter(internal_iter);
-  return db_iter;
-}
-
-Status DBImplSecondary::NewIterators(
-    const ReadOptions& read_options,
-    const std::vector<ColumnFamilyHandle*>& column_families,
-    std::vector<Iterator*>* iterators) {
-  if (read_options.managed) {
-    return Status::NotSupported("Managed iterator is not supported anymore.");
-  }
-  if (read_options.read_tier == kPersistedTier) {
-    return Status::NotSupported(
-        "ReadTier::kPersistedData is not yet supported in iterators.");
-  }
-  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  if (iterators == nullptr) {
-    return Status::InvalidArgument("iterators not allowed to be nullptr");
-  }
-  iterators->clear();
-  iterators->reserve(column_families.size());
-  if (read_options.tailing) {
-    return Status::NotSupported(
-        "tailing iterator not supported in secondary mode");
-  } else if (read_options.snapshot != nullptr) {
-    // TODO (yanqin) support snapshot.
-    return Status::NotSupported("snapshot not supported in secondary mode");
-  } else {
-    SequenceNumber read_seq = versions_->LastSequence();
-    for (auto cfh : column_families) {
-      ColumnFamilyData* cfd = static_cast<ColumnFamilyHandleImpl*>(cfh)->cfd();
-      iterators->push_back(
-          NewIteratorImpl(read_options, cfd, read_seq, read_callback));
-    }
-  }
-  return Status::OK();
-}
-
-Status DBImplSecondary::TryCatchUpWithPrimary() {
-  assert(versions_.get() != nullptr);
-  assert(manifest_reader_.get() != nullptr);
-  Status s;
-  std::unordered_set<ColumnFamilyData*> cfds_changed;
-  InstrumentedMutexLock lock_guard(&mutex_);
-  s = static_cast<ReactiveVersionSet*>(versions_.get())
-          ->ReadAndApply(&mutex_, &manifest_reader_, &cfds_changed);
-  if (s.ok()) {
-    SuperVersionContext sv_context(true /* create_superversion */);
-    for (auto cfd : cfds_changed) {
-      sv_context.NewSuperVersion();
-      cfd->InstallSuperVersion(&sv_context, &mutex_);
-    }
-    sv_context.Clean();
-  }
-  return s;
-}
-
-Status DB::OpenAsSecondary(const Options& options, const std::string& dbname,
-                           const std::string& secondary_path, DB** dbptr) {
-  *dbptr = nullptr;
-
-  DBOptions db_options(options);
-  ColumnFamilyOptions cf_options(options);
-  std::vector<ColumnFamilyDescriptor> column_families;
-  column_families.emplace_back(kDefaultColumnFamilyName, cf_options);
-  std::vector<ColumnFamilyHandle*> handles;
-
-  Status s = DB::OpenAsSecondary(db_options, dbname, secondary_path,
-                                 column_families, &handles, dbptr);
-  if (s.ok()) {
-    assert(handles.size() == 1);
-    delete handles[0];
-  }
-  return s;
-}
-
-Status DB::OpenAsSecondary(
-    const DBOptions& db_options, const std::string& dbname,
-    const std::string& secondary_path,
-    const std::vector<ColumnFamilyDescriptor>& column_families,
-    std::vector<ColumnFamilyHandle*>* handles, DB** dbptr) {
-  *dbptr = nullptr;
-  if (db_options.max_open_files != -1) {
-    // TODO (yanqin) maybe support max_open_files != -1 by creating hard links
-    // on SST files so that db secondary can still have access to old SSTs
-    // while primary instance may delete original.
-    return Status::InvalidArgument("require max_open_files to be -1");
-  }
-
-  DBOptions tmp_opts(db_options);
-  if (nullptr == tmp_opts.info_log) {
-    Env* env = tmp_opts.env;
-    assert(env != nullptr);
-    std::string secondary_abs_path;
-    env->GetAbsolutePath(secondary_path, &secondary_abs_path);
-    std::string fname = InfoLogFileName(secondary_path, secondary_abs_path,
-                                        tmp_opts.db_log_dir);
-
-    env->CreateDirIfMissing(secondary_path);
-    if (tmp_opts.log_file_time_to_roll > 0 || tmp_opts.max_log_file_size > 0) {
-      AutoRollLogger* result = new AutoRollLogger(
-          env, secondary_path, tmp_opts.db_log_dir, tmp_opts.max_log_file_size,
-          tmp_opts.log_file_time_to_roll, tmp_opts.info_log_level);
-      Status s = result->GetStatus();
-      if (!s.ok()) {
-        delete result;
-      } else {
-        tmp_opts.info_log.reset(result);
-      }
-    }
-    if (nullptr == tmp_opts.info_log) {
-      env->RenameFile(
-          fname, OldInfoLogFileName(secondary_path, env->NowMicros(),
-                                    secondary_abs_path, tmp_opts.db_log_dir));
-      Status s = env->NewLogger(fname, &(tmp_opts.info_log));
-      if (tmp_opts.info_log != nullptr) {
-        tmp_opts.info_log->SetInfoLogLevel(tmp_opts.info_log_level);
-      }
-    }
-  }
-
-  assert(tmp_opts.info_log != nullptr);
-
-  handles->clear();
-  DBImplSecondary* impl = new DBImplSecondary(tmp_opts, dbname);
-  impl->versions_.reset(new ReactiveVersionSet(
-      dbname, &impl->immutable_db_options_, impl->env_options_,
-      impl->table_cache_.get(), impl->write_buffer_manager_,
-      &impl->write_controller_));
-  impl->column_family_memtables_.reset(
-      new ColumnFamilyMemTablesImpl(impl->versions_->GetColumnFamilySet()));
-  impl->mutex_.Lock();
-  Status s = impl->Recover(column_families, true, false, false);
-  if (s.ok()) {
-    for (auto cf : column_families) {
-      auto cfd =
-          impl->versions_->GetColumnFamilySet()->GetColumnFamily(cf.name);
-      if (nullptr == cfd) {
-        s = Status::InvalidArgument("Column family not found: ", cf.name);
-        break;
-      }
-      handles->push_back(new ColumnFamilyHandleImpl(cfd, impl, &impl->mutex_));
-    }
-  }
-  SuperVersionContext sv_context(true /* create_superversion */);
-  if (s.ok()) {
-    for (auto cfd : *impl->versions_->GetColumnFamilySet()) {
-      sv_context.NewSuperVersion();
-      cfd->InstallSuperVersion(&sv_context, &impl->mutex_);
-    }
-  }
-  impl->mutex_.Unlock();
-  sv_context.Clean();
-  if (s.ok()) {
-    *dbptr = impl;
-    for (auto h : *handles) {
-      impl->NewThreadStatusCfInfo(
-          reinterpret_cast<ColumnFamilyHandleImpl*>(h)->cfd());
-    }
-  } else {
-    for (auto h : *handles) {
-      delete h;
-    }
-    handles->clear();
-    delete impl;
-  }
-  return s;
-}
-#else   // !ROCKSDB_LITE
-
-Status DB::OpenAsSecondary(const Options& /*options*/,
-                           const std::string& /*name*/,
-                           const std::string& /*secondary_path*/,
-                           DB** /*dbptr*/) {
-  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
-}
-
-Status DB::OpenAsSecondary(
-    const DBOptions& /*db_options*/, const std::string& /*dbname*/,
-    const std::string& /*secondary_path*/,
-    const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
-    std::vector<ColumnFamilyHandle*>* /*handles*/, DB** /*dbptr*/) {
-  return Status::NotSupported("Not supported in ROCKSDB_LITE.");
-}
-#endif  // !ROCKSDB_LITE
-
-}  // namespace rocksdb

db/db_impl_secondary.h

@@ -1,151 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <vector>
-#include "db/db_impl.h"
-
-namespace rocksdb {
-
-class DBImplSecondary : public DBImpl {
- public:
-  DBImplSecondary(const DBOptions& options, const std::string& dbname);
-  ~DBImplSecondary() override;
-
-  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
-                 bool read_only, bool error_if_log_file_exist,
-                 bool error_if_data_exists_in_logs) override;
-
-  // Implementations of the DB interface
-  using DB::Get;
-  Status Get(const ReadOptions& options, ColumnFamilyHandle* column_family,
-             const Slice& key, PinnableSlice* value) override;
-
-  Status GetImpl(const ReadOptions& options, ColumnFamilyHandle* column_family,
-                 const Slice& key, PinnableSlice* value);
-
-  using DBImpl::NewIterator;
-  Iterator* NewIterator(const ReadOptions&,
-                        ColumnFamilyHandle* column_family) override;
-
-  ArenaWrappedDBIter* NewIteratorImpl(const ReadOptions& read_options,
-                                      ColumnFamilyData* cfd,
-                                      SequenceNumber snapshot,
-                                      ReadCallback* read_callback);
-
-  Status NewIterators(const ReadOptions& options,
-                      const std::vector<ColumnFamilyHandle*>& column_families,
-                      std::vector<Iterator*>* iterators) override;
-
-  using DBImpl::Put;
-  Status Put(const WriteOptions& /*options*/,
-             ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
-             const Slice& /*value*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Merge;
-  Status Merge(const WriteOptions& /*options*/,
-               ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
-               const Slice& /*value*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Delete;
-  Status Delete(const WriteOptions& /*options*/,
-                ColumnFamilyHandle* /*column_family*/,
-                const Slice& /*key*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::SingleDelete;
-  Status SingleDelete(const WriteOptions& /*options*/,
-                      ColumnFamilyHandle* /*column_family*/,
-                      const Slice& /*key*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status Write(const WriteOptions& /*options*/,
-               WriteBatch* /*updates*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::CompactRange;
-  Status CompactRange(const CompactRangeOptions& /*options*/,
-                      ColumnFamilyHandle* /*column_family*/,
-                      const Slice* /*begin*/, const Slice* /*end*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::CompactFiles;
-  Status CompactFiles(
-      const CompactionOptions& /*compact_options*/,
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr,
-      CompactionJobInfo* /*compaction_job_info*/ = nullptr) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status DisableFileDeletions() override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status EnableFileDeletions(bool /*force*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status GetLiveFiles(std::vector<std::string>&,
-                      uint64_t* /*manifest_file_size*/,
-                      bool /*flush_memtable*/ = true) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::Flush;
-  Status Flush(const FlushOptions& /*options*/,
-               ColumnFamilyHandle* /*column_family*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DBImpl::SyncWAL;
-  Status SyncWAL() override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DB::IngestExternalFile;
-  Status IngestExternalFile(
-      ColumnFamilyHandle* /*column_family*/,
-      const std::vector<std::string>& /*external_files*/,
-      const IngestExternalFileOptions& /*ingestion_options*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  // Try to catch up with the primary by reading as much as possible from the
-  // log files until there is nothing more to read or encounters an error. If
-  // the amount of information in the log files to process is huge, this
-  // method can take long time due to all the I/O and CPU costs.
-  Status TryCatchUpWithPrimary() override;
-
- private:
-  friend class DB;
-
-  // No copying allowed
-  DBImplSecondary(const DBImplSecondary&);
-  void operator=(const DBImplSecondary&);
-
-  using DBImpl::Recover;
-
-  std::unique_ptr<log::FragmentBufferedReader> manifest_reader_;
-  std::unique_ptr<log::Reader::Reporter> manifest_reporter_;
-  std::unique_ptr<Status> manifest_reader_status_;
-};
-}  // namespace rocksdb
-
-#endif  // !ROCKSDB_LITE

db/db_impl_write.cc

@@ -146,6 +146,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
     if (write_thread_.CompleteParallelMemTableWriter(&w)) {
       // we're responsible for exit batch group
+      for (auto* writer : *(w.write_group)) {
+        if (!writer->CallbackFailed() && writer->pre_release_callback) {
+          assert(writer->sequence != kMaxSequenceNumber);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence,
+                                                             disable_memtable);
+          if (!ws.ok()) {
+            status = ws;
+            break;
+          }
+        }
+      }
       // TODO(myabandeh): propagate status to write_group
       auto last_sequence = w.write_group->last_sequence;
       versions_->SetLastSequence(last_sequence);
@@ -268,7 +279,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                         concurrent_update);
       RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
     }
-    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);
 
     if (write_options.disableWAL) {
       has_unpersisted_data_.store(true, std::memory_order_relaxed);
@@ -298,35 +309,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     const SequenceNumber current_sequence = last_sequence + 1;
     last_sequence += seq_inc;
 
-    // PreReleaseCallback is called after WAL write and before memtable write
-    if (status.ok()) {
-      SequenceNumber next_sequence = current_sequence;
-      // Note: the logic for advancing seq here must be consistent with the
-      // logic in WriteBatchInternal::InsertInto(write_group...) as well as
-      // with WriteBatchInternal::InsertInto(write_batch...) that is called on
-      // the merged batch during recovery from the WAL.
-      for (auto* writer : write_group) {
-        if (writer->CallbackFailed()) {
-          continue;
-        }
-        writer->sequence = next_sequence;
-        if (writer->pre_release_callback) {
-          Status ws = writer->pre_release_callback->Callback(
-              writer->sequence, disable_memtable, writer->log_used);
-          if (!ws.ok()) {
-            status = ws;
-            break;
-          }
-        }
-        if (seq_per_batch_) {
-          assert(writer->batch_cnt);
-          next_sequence += writer->batch_cnt;
-        } else if (writer->ShouldWriteToMemtable()) {
-          next_sequence += WriteBatchInternal::Count(writer->batch);
-        }
-      }
-    }
-
     if (status.ok()) {
       PERF_TIMER_GUARD(write_memtable_time);
 
@@ -338,6 +320,23 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
             0 /*recovery_log_number*/, this, parallel, seq_per_batch_,
             batch_per_txn_);
       } else {
+        SequenceNumber next_sequence = current_sequence;
+        // Note: the logic for advancing seq here must be consistent with the
+        // logic in WriteBatchInternal::InsertInto(write_group...) as well as
+        // with WriteBatchInternal::InsertInto(write_batch...) that is called on
+        // the merged batch during recovery from the WAL.
+        for (auto* writer : write_group) {
+          if (writer->CallbackFailed()) {
+            continue;
+          }
+          writer->sequence = next_sequence;
+          if (seq_per_batch_) {
+            assert(writer->batch_cnt);
+            next_sequence += writer->batch_cnt;
+          } else if (writer->ShouldWriteToMemtable()) {
+            next_sequence += WriteBatchInternal::Count(writer->batch);
+          }
+        }
         write_group.last_sequence = last_sequence;
         write_thread_.LaunchParallelMemTableWriters(&write_group);
         in_parallel_group = true;
@@ -389,8 +388,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   }
   if (should_exit_batch_group) {
     if (status.ok()) {
-      // Note: if we are to resume after non-OK statuses we need to revisit how
-      // we reacts to non-OK statuses here.
+      for (auto* writer : write_group) {
+        if (!writer->CallbackFailed() && writer->pre_release_callback) {
+          assert(writer->sequence != kMaxSequenceNumber);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence,
+                                                             disable_memtable);
+          if (!ws.ok()) {
+            status = ws;
+            break;
+          }
+        }
+      }
       versions_->SetLastSequence(last_sequence);
     }
     MemTableInsertStatusCheck(w.status);
@@ -463,7 +471,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
     RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
     stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size);
     RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+    MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);
 
     PERF_TIMER_STOP(write_pre_and_post_process_time);
 
@@ -594,7 +602,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
                       concurrent_update);
     RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
   }
-  RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
+  MeasureTime(stats_, BYTES_PER_WRITE, total_byte_size);
 
   PERF_TIMER_STOP(write_pre_and_post_process_time);
 
@@ -649,8 +657,8 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
       if (!writer->CallbackFailed() && writer->pre_release_callback) {
         assert(writer->sequence != kMaxSequenceNumber);
         const bool DISABLE_MEMTABLE = true;
-        Status ws = writer->pre_release_callback->Callback(
-            writer->sequence, DISABLE_MEMTABLE, writer->log_used);
+        Status ws = writer->pre_release_callback->Callback(writer->sequence,
+                                                           DISABLE_MEMTABLE);
         if (!ws.ok()) {
           status = ws;
           break;
@@ -868,7 +876,7 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
   status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
   if (to_be_cached_state) {
     cached_recoverable_state_ = *to_be_cached_state;
-    cached_recoverable_state_empty_ = false;
+      cached_recoverable_state_empty_ = false;
   }
 
   if (status.ok() && need_log_sync) {
@@ -944,7 +952,7 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
   status = WriteToWAL(*merged_batch, log_writer, log_used, &log_size);
   if (to_be_cached_state) {
     cached_recoverable_state_ = *to_be_cached_state;
-    cached_recoverable_state_empty_ = false;
+      cached_recoverable_state_empty_ = false;
   }
   log_write_mutex_.Unlock();
 
@@ -993,9 +1001,8 @@ Status DBImpl::WriteRecoverableState() {
       const bool DISABLE_MEMTABLE = true;
       for (uint64_t sub_batch_seq = seq + 1;
            sub_batch_seq < next_seq && status.ok(); sub_batch_seq++) {
-        uint64_t const no_log_num = 0;
         status = recoverable_state_pre_release_callback_->Callback(
-            sub_batch_seq, !DISABLE_MEMTABLE, no_log_num);
+            sub_batch_seq, !DISABLE_MEMTABLE);
       }
     }
     if (status.ok()) {
@@ -1065,17 +1072,16 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
   if (!flush_wont_release_oldest_log) {
     // we only mark this log as getting flushed if we have successfully
     // flushed all data in this log. If this log contains outstanding prepared
-    // transactions then we cannot flush this log until those transactions are
-    // commited.
+    // transactions then we cannot flush this log until those transactions are commited.
     unable_to_release_oldest_log_ = false;
     alive_log_files_.begin()->getting_flushed = true;
   }
 
-  ROCKS_LOG_INFO(
-      immutable_db_options_.info_log,
-      "Flushing all column families with data in WAL number %" PRIu64
-      ". Total log size is %" PRIu64 " while max_total_wal_size is %" PRIu64,
-      oldest_alive_log, total_log_size_.load(), GetMaxTotalWalSize());
+  ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                 "Flushing all column families with data in WAL number %" PRIu64
+                 ". Total log size is %" PRIu64
+                 " while max_total_wal_size is %" PRIu64,
+                 oldest_alive_log, total_log_size_.load(), GetMaxTotalWalSize());
   // no need to refcount because drop is happening in write thread, so can't
   // happen while we're in the write thread
   autovector<ColumnFamilyData*> cfds;
@@ -1127,7 +1133,7 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
   ROCKS_LOG_INFO(
       immutable_db_options_.info_log,
       "Flushing column family with largest mem table size. Write buffer is "
-      "using %" ROCKSDB_PRIszt " bytes out of a total of %" ROCKSDB_PRIszt ".",
+      "using %" PRIu64 " bytes out of a total of %" PRIu64 ".",
       write_buffer_manager_->memory_usage(),
       write_buffer_manager_->buffer_size());
   // no need to refcount because drop is happening in write thread, so can't
@@ -1421,7 +1427,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   DBOptions db_options =
       BuildDBOptions(immutable_db_options_, mutable_db_options_);
   const auto preallocate_block_size =
-      GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
+    GetWalPreallocateBlockSize(mutable_cf_options.write_buffer_size);
   auto write_hint = CalculateWALWriteHint();
   mutex_.Unlock();
   {
@@ -1463,6 +1469,13 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
       new_mem = cfd->ConstructNewMemtable(mutable_cf_options, seq);
       context->superversion_context.NewSuperVersion();
     }
+
+#ifndef ROCKSDB_LITE
+    // PLEASE NOTE: We assume that there are no failable operations
+    // after lock is acquired below since we are already notifying
+    // client about mem table becoming immutable.
+    NotifyOnMemTableSealed(cfd, memtable_info);
+#endif //ROCKSDB_LITE
   }
   ROCKS_LOG_INFO(immutable_db_options_.info_log,
                  "[%s] New memtable created with log file: #%" PRIu64
@@ -1471,7 +1484,10 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   mutex_.Lock();
   if (s.ok() && creating_new_log) {
     log_write_mutex_.Lock();
+    logfile_number_ = new_log_number;
     assert(new_log != nullptr);
+    log_empty_ = true;
+    log_dir_synced_ = false;
     if (!logs_.empty()) {
       // Alway flush the buffer of the last log before switching to a new one
       log::Writer* cur_log_writer = logs_.back().writer;
@@ -1479,41 +1495,21 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
       if (!s.ok()) {
         ROCKS_LOG_WARN(immutable_db_options_.info_log,
                        "[%s] Failed to switch from #%" PRIu64 " to #%" PRIu64
-                       "  WAL file\n",
+                       "  WAL file -- %s\n",
                        cfd->GetName().c_str(), cur_log_writer->get_log_number(),
                        new_log_number);
       }
     }
-    if (s.ok()) {
-      logfile_number_ = new_log_number;
-      log_empty_ = true;
-      log_dir_synced_ = false;
-      logs_.emplace_back(logfile_number_, new_log);
-      alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
-    }
+    logs_.emplace_back(logfile_number_, new_log);
+    alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
     log_write_mutex_.Unlock();
   }
 
   if (!s.ok()) {
     // how do we fail if we're not creating new log?
     assert(creating_new_log);
-    if (new_mem) {
-      delete new_mem;
-    }
-    if (new_log) {
-      delete new_log;
-    }
-    SuperVersion* new_superversion =
-        context->superversion_context.new_superversion.release();
-    if (new_superversion != nullptr) {
-      delete new_superversion;
-    }
-    // We may have lost data from the WritableFileBuffer in-memory buffer for
-    // the current log, so treat it as a fatal error and set bg_error
-    error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
-    // Read back bg_error in order to get the right severity
-    s = error_handler_.GetBGError();
-
+    assert(!new_mem);
+    assert(!new_log);
     if (two_write_queues_) {
       nonmem_write_thread_.ExitUnbatched(&nonmem_w);
     }
@@ -1540,13 +1536,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   cfd->SetMemtable(new_mem);
   InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
                                      mutable_cf_options);
-#ifndef ROCKSDB_LITE
-  mutex_.Unlock();
-  // Notify client that memtable is sealed, now that we have successfully
-  // installed a new memtable
-  NotifyOnMemTableSealed(cfd, memtable_info);
-  mutex_.Lock();
-#endif  // ROCKSDB_LITE
   if (two_write_queues_) {
     nonmem_write_thread_.ExitUnbatched(&nonmem_w);
   }
@@ -1555,13 +1544,13 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
 
 size_t DBImpl::GetWalPreallocateBlockSize(uint64_t write_buffer_size) const {
   mutex_.AssertHeld();
-  size_t bsize =
-      static_cast<size_t>(write_buffer_size / 10 + write_buffer_size);
+  size_t bsize = static_cast<size_t>(
+    write_buffer_size / 10 + write_buffer_size);
   // Some users might set very high write_buffer_size and rely on
   // max_total_wal_size or other parameters to control the WAL size.
   if (mutable_db_options_.max_total_wal_size > 0) {
-    bsize = std::min<size_t>(
-        bsize, static_cast<size_t>(mutable_db_options_.max_total_wal_size));
+    bsize = std::min<size_t>(bsize, static_cast<size_t>(
+      mutable_db_options_.max_total_wal_size));
   }
   if (immutable_db_options_.db_write_buffer_size > 0) {
     bsize = std::min<size_t>(bsize, immutable_db_options_.db_write_buffer_size);

db/db_iter.cc

@@ -28,7 +28,6 @@
 #include "util/mutexlock.h"
 #include "util/string_util.h"
 #include "util/trace_replay.h"
-#include "util/user_comparator_wrapper.h"
 
 namespace rocksdb {
 
@@ -118,29 +117,29 @@ class DBIter final: public Iterator {
          uint64_t max_sequential_skip_in_iterations,
          ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd,
          bool allow_blob)
-      : env_(_env),
+      : arena_mode_(arena_mode),
+        env_(_env),
         logger_(cf_options.info_log),
         user_comparator_(cmp),
         merge_operator_(cf_options.merge_operator),
         iter_(iter),
-        read_callback_(read_callback),
         sequence_(s),
+        direction_(kForward),
+        valid_(false),
+        current_entry_is_merged_(false),
         statistics_(cf_options.statistics),
         num_internal_keys_skipped_(0),
         iterate_lower_bound_(read_options.iterate_lower_bound),
         iterate_upper_bound_(read_options.iterate_upper_bound),
-        direction_(kForward),
-        valid_(false),
-        current_entry_is_merged_(false),
         prefix_same_as_start_(read_options.prefix_same_as_start),
         pin_thru_lifetime_(read_options.pin_data),
         total_order_seek_(read_options.total_order_seek),
-        allow_blob_(allow_blob),
-        is_blob_(false),
-        arena_mode_(arena_mode),
         range_del_agg_(&cf_options.internal_comparator, s),
+        read_callback_(read_callback),
         db_impl_(db_impl),
         cfd_(cfd),
+        allow_blob_(allow_blob),
+        is_blob_(false),
         start_seqnum_(read_options.iter_start_seqnum) {
     RecordTick(statistics_, NO_ITERATOR_CREATED);
     prefix_extractor_ = mutable_cf_options.prefix_extractor.get();
@@ -238,12 +237,7 @@ class DBIter final: public Iterator {
   void SeekToFirst() override;
   void SeekToLast() override;
   Env* env() { return env_; }
-  void set_sequence(uint64_t s) {
-    sequence_ = s;
-    if (read_callback_) {
-      read_callback_->Refresh(s);
-    }
-  }
+  void set_sequence(uint64_t s) { sequence_ = s; }
   void set_valid(bool v) { valid_ = v; }
 
  private:
@@ -263,7 +257,7 @@ class DBIter final: public Iterator {
 
   void PrevInternal();
   bool TooManyInternalKeysSkipped(bool increment = true);
-  inline bool IsVisible(SequenceNumber sequence);
+  bool IsVisible(SequenceNumber sequence);
 
   // CanReseekToSkip() returns whether the iterator can use the optimization
   // where it reseek by sequence number to get the next key when there are too
@@ -271,6 +265,12 @@ class DBIter final: public Iterator {
   // sequence number does not guarantee that it is visible.
   inline bool CanReseekToSkip();
 
+  // MaxVisibleSequenceNumber() returns the maximum visible sequence number
+  // for this snapshot. This sequence number may be greater than snapshot
+  // seqno because uncommitted data written to DB for write unprepared will
+  // have a higher sequence number.
+  inline SequenceNumber MaxVisibleSequenceNumber();
+
   // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
   // is called
   void TempPinData() {
@@ -304,16 +304,15 @@ class DBIter final: public Iterator {
   }
 
   const SliceTransform* prefix_extractor_;
+  bool arena_mode_;
   Env* const env_;
   Logger* logger_;
-  UserComparatorWrapper user_comparator_;
+  const Comparator* const user_comparator_;
   const MergeOperator* const merge_operator_;
   InternalIterator* iter_;
-  ReadCallback* read_callback_;
-  // Max visible sequence number. It is normally the snapshot seq unless we have
-  // uncommitted data in db as in WriteUnCommitted.
   SequenceNumber sequence_;
 
+  Status status_;
   IterKey saved_key_;
   // Reusable internal key data structure. This is only used inside one function
   // and should not be used across functions. Reusing this object can reduce
@@ -321,6 +320,9 @@ class DBIter final: public Iterator {
   ParsedInternalKey ikey_;
   std::string saved_value_;
   Slice pinned_value_;
+  Direction direction_;
+  bool valid_;
+  bool current_entry_is_merged_;
   // for prefix seek mode to support prev()
   Statistics* statistics_;
   uint64_t max_skip_;
@@ -328,29 +330,23 @@ class DBIter final: public Iterator {
   uint64_t num_internal_keys_skipped_;
   const Slice* iterate_lower_bound_;
   const Slice* iterate_upper_bound_;
-
   IterKey prefix_start_buf_;
-
-  Status status_;
   Slice prefix_start_key_;
-  Direction direction_;
-  bool valid_;
-  bool current_entry_is_merged_;
   const bool prefix_same_as_start_;
   // Means that we will pin all data blocks we read as long the Iterator
   // is not deleted, will be true if ReadOptions::pin_data is true
   const bool pin_thru_lifetime_;
   const bool total_order_seek_;
-  bool allow_blob_;
-  bool is_blob_;
-  bool arena_mode_;
   // List of operands for merge operator.
   MergeContext merge_context_;
   ReadRangeDelAggregator range_del_agg_;
   LocalStatistics local_stats_;
   PinnedIteratorsManager pinned_iters_mgr_;
+  ReadCallback* read_callback_;
   DBImpl* db_impl_;
   ColumnFamilyData* cfd_;
+  bool allow_blob_;
+  bool is_blob_;
   // for diff snapshots we want the lower bound on the seqnum;
   // if this value > 0 iterator will return internal keys
   SequenceNumber start_seqnum_;
@@ -376,7 +372,6 @@ void DBIter::Next() {
   assert(valid_);
   assert(status_.ok());
 
-  PERF_CPU_TIMER_GUARD(iter_next_cpu_nanos, env_);
   // Release temporarily pinned blocks from last operation
   ReleaseTempPinnedData();
   ResetInternalKeysSkippedCounter();
@@ -457,7 +452,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
     }
 
     if (iterate_upper_bound_ != nullptr &&
-        user_comparator_.Compare(ikey_.user_key, *iterate_upper_bound_) >= 0) {
+        user_comparator_->Compare(ikey_.user_key, *iterate_upper_bound_) >= 0) {
       break;
     }
 
@@ -472,8 +467,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
     }
 
     if (IsVisible(ikey_.sequence)) {
-      if (skipping && user_comparator_.Compare(ikey_.user_key,
-                                               saved_key_.GetUserKey()) <= 0) {
+      if (skipping && user_comparator_->Compare(ikey_.user_key,
+                                                saved_key_.GetUserKey()) <= 0) {
         num_skipped++;  // skip this entry
         PERF_COUNTER_ADD(internal_key_skipped_count, 1);
       } else {
@@ -580,7 +575,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check) {
       // If this happens too many times in a row for the same user key, we want
       // to seek to the target sequence number.
       int cmp =
-          user_comparator_.Compare(ikey_.user_key, saved_key_.GetUserKey());
+          user_comparator_->Compare(ikey_.user_key, saved_key_.GetUserKey());
       if (cmp == 0 || (skipping && cmp <= 0)) {
         num_skipped++;
       } else {
@@ -656,7 +651,7 @@ bool DBIter::MergeValuesNewToOld() {
       return false;
     }
 
-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
       // hit the next user key, stop right here
       break;
     } else if (kTypeDeletion == ikey.type || kTypeSingleDeletion == ikey.type ||
@@ -734,8 +729,6 @@ bool DBIter::MergeValuesNewToOld() {
 void DBIter::Prev() {
   assert(valid_);
   assert(status_.ok());
-
-  PERF_CPU_TIMER_GUARD(iter_prev_cpu_nanos, env_);
   ReleaseTempPinnedData();
   ResetInternalKeysSkippedCounter();
   bool ok = true;
@@ -776,7 +769,8 @@ bool DBIter::ReverseToForward() {
     if (!ParseKey(&ikey)) {
       return false;
     }
-    if (user_comparator_.Compare(ikey.user_key, saved_key_.GetUserKey()) >= 0) {
+    if (user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) >=
+        0) {
       return true;
     }
     iter_->Next();
@@ -839,8 +833,8 @@ void DBIter::PrevInternal() {
     }
 
     if (iterate_lower_bound_ != nullptr &&
-        user_comparator_.Compare(saved_key_.GetUserKey(),
-                                 *iterate_lower_bound_) < 0) {
+        user_comparator_->Compare(saved_key_.GetUserKey(),
+                                  *iterate_lower_bound_) < 0) {
       // We've iterated earlier than the user-specified lower bound.
       valid_ = false;
       return;
@@ -901,7 +895,7 @@ bool DBIter::FindValueForCurrentKey() {
     }
 
     if (!IsVisible(ikey.sequence) ||
-        !user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+        !user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
       break;
     }
     if (TooManyInternalKeysSkipped()) {
@@ -1054,7 +1048,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
     if (!ParseKey(&ikey)) {
       return false;
     }
-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
       // No visible values for this key, even though FindValueForCurrentKey()
       // has seen some. This is possible if we're using a tailing iterator, and
       // the entries were discarded in a compaction.
@@ -1110,7 +1104,7 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {
     if (!ParseKey(&ikey)) {
       return false;
     }
-    if (!user_comparator_.Equal(ikey.user_key, saved_key_.GetUserKey())) {
+    if (!user_comparator_->Equal(ikey.user_key, saved_key_.GetUserKey())) {
       break;
     }
 
@@ -1192,7 +1186,7 @@ bool DBIter::FindUserKeyBeforeSavedKey() {
       return false;
     }
 
-    if (user_comparator_.Compare(ikey.user_key, saved_key_.GetUserKey()) < 0) {
+    if (user_comparator_->Compare(ikey.user_key, saved_key_.GetUserKey()) < 0) {
       return true;
     }
 
@@ -1247,25 +1241,30 @@ bool DBIter::TooManyInternalKeysSkipped(bool increment) {
 }
 
 bool DBIter::IsVisible(SequenceNumber sequence) {
-  if (read_callback_ == nullptr) {
-    return sequence <= sequence_;
-  } else {
-    return read_callback_->IsVisible(sequence);
-  }
+  return sequence <= MaxVisibleSequenceNumber() &&
+         (read_callback_ == nullptr || read_callback_->IsVisible(sequence));
 }
 
 bool DBIter::CanReseekToSkip() {
-  return read_callback_ == nullptr || read_callback_->CanReseekToSkip();
+  return read_callback_ == nullptr ||
+         read_callback_->MaxUnpreparedSequenceNumber() == 0;
+}
+
+SequenceNumber DBIter::MaxVisibleSequenceNumber() {
+  if (read_callback_ == nullptr) {
+    return sequence_;
+  }
+
+  return std::max(sequence_, read_callback_->MaxUnpreparedSequenceNumber());
 }
 
 void DBIter::Seek(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   StopWatch sw(env_, statistics_, DB_SEEK);
   status_ = Status::OK();
   ReleaseTempPinnedData();
   ResetInternalKeysSkippedCounter();
 
-  SequenceNumber seq = sequence_;
+  SequenceNumber seq = MaxVisibleSequenceNumber();
   saved_key_.Clear();
   saved_key_.SetInternalKey(target, seq);
 
@@ -1276,8 +1275,8 @@ void DBIter::Seek(const Slice& target) {
 #endif  // ROCKSDB_LITE
 
   if (iterate_lower_bound_ != nullptr &&
-      user_comparator_.Compare(saved_key_.GetUserKey(), *iterate_lower_bound_) <
-          0) {
+      user_comparator_->Compare(saved_key_.GetUserKey(),
+                                *iterate_lower_bound_) < 0) {
     saved_key_.Clear();
     saved_key_.SetInternalKey(*iterate_lower_bound_, seq);
   }
@@ -1317,7 +1316,6 @@ void DBIter::Seek(const Slice& target) {
 }
 
 void DBIter::SeekForPrev(const Slice& target) {
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   StopWatch sw(env_, statistics_, DB_SEEK);
   status_ = Status::OK();
   ReleaseTempPinnedData();
@@ -1328,8 +1326,8 @@ void DBIter::SeekForPrev(const Slice& target) {
                             kValueTypeForSeekForPrev);
 
   if (iterate_upper_bound_ != nullptr &&
-      user_comparator_.Compare(saved_key_.GetUserKey(),
-                               *iterate_upper_bound_) >= 0) {
+      user_comparator_->Compare(saved_key_.GetUserKey(),
+                                *iterate_upper_bound_) >= 0) {
     saved_key_.Clear();
     saved_key_.SetInternalKey(*iterate_upper_bound_, kMaxSequenceNumber);
   }
@@ -1378,7 +1376,6 @@ void DBIter::SeekToFirst() {
     Seek(*iterate_lower_bound_);
     return;
   }
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   // Don't use iter_::Seek() if we set a prefix extractor
   // because prefix seek will be used.
   if (prefix_extractor_ != nullptr && !total_order_seek_) {
@@ -1423,14 +1420,13 @@ void DBIter::SeekToLast() {
   if (iterate_upper_bound_ != nullptr) {
     // Seek to last key strictly less than ReadOptions.iterate_upper_bound.
     SeekForPrev(*iterate_upper_bound_);
-    if (Valid() && user_comparator_.Equal(*iterate_upper_bound_, key())) {
+    if (Valid() && user_comparator_->Equal(*iterate_upper_bound_, key())) {
       ReleaseTempPinnedData();
       PrevInternal();
     }
     return;
   }
 
-  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
   // Don't use iter_::Seek() if we set a prefix extractor
   // because prefix seek will be used.
   if (prefix_extractor_ != nullptr && !total_order_seek_) {
@@ -1551,9 +1547,6 @@ Status ArenaWrappedDBIter::Refresh() {
     new (&arena_) Arena();
 
     SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_->mutex());
-    if (read_callback_) {
-      read_callback_->Refresh(latest_seq);
-    }
     Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
          latest_seq, sv->mutable_cf_options.max_sequential_skip_in_iterations,
          cur_sv_number, read_callback_, db_impl_, cfd_, allow_blob_,

db/db_iterator_test.cc

@@ -20,10 +20,7 @@ namespace rocksdb {
 
 // A dumb ReadCallback which saying every key is committed.
 class DummyReadCallback : public ReadCallback {
- public:
-  DummyReadCallback() : ReadCallback(kMaxSequenceNumber) {}
-  bool IsVisibleFullCheck(SequenceNumber /*seq*/) override { return true; }
-  void SetSnapshot(SequenceNumber seq) { max_visible_seq_ = seq; }
+  bool IsVisible(SequenceNumber /*seq*/) override { return true; }
 };
 
 // Test param:
@@ -43,20 +40,12 @@ class DBIteratorTest : public DBTestBase,
                              ? read_options.snapshot->GetSequenceNumber()
                              : db_->GetLatestSequenceNumber();
     bool use_read_callback = GetParam();
-    DummyReadCallback* read_callback = nullptr;
-    if (use_read_callback) {
-      read_callback = new DummyReadCallback();
-      read_callback->SetSnapshot(seq);
-      InstrumentedMutexLock lock(&mutex_);
-      read_callbacks_.push_back(
-          std::unique_ptr<DummyReadCallback>(read_callback));
-    }
+    ReadCallback* read_callback = use_read_callback ? &read_callback_ : nullptr;
     return dbfull()->NewIteratorImpl(read_options, cfd, seq, read_callback);
   }
 
  private:
-  InstrumentedMutex mutex_;
-  std::vector<std::unique_ptr<DummyReadCallback>> read_callbacks_;
+  DummyReadCallback read_callback_;
 };
 
 class FlushBlockEveryKeyPolicy : public FlushBlockPolicy {
@@ -2487,12 +2476,15 @@ class DBIteratorWithReadCallbackTest : public DBIteratorTest {};
 TEST_F(DBIteratorWithReadCallbackTest, ReadCallback) {
   class TestReadCallback : public ReadCallback {
    public:
-    explicit TestReadCallback(SequenceNumber _max_visible_seq)
-        : ReadCallback(_max_visible_seq) {}
+    explicit TestReadCallback(SequenceNumber last_visible_seq)
+        : last_visible_seq_(last_visible_seq) {}
 
-    bool IsVisibleFullCheck(SequenceNumber seq) override {
-      return seq <= max_visible_seq_;
+    bool IsVisible(SequenceNumber seq) override {
+      return seq <= last_visible_seq_;
     }
+
+   private:
+    SequenceNumber last_visible_seq_;
   };
 
   ASSERT_OK(Put("foo", "v1"));

db/db_merge_operator_test.cc

@@ -18,11 +18,9 @@ class TestReadCallback : public ReadCallback {
  public:
   TestReadCallback(SnapshotChecker* snapshot_checker,
                    SequenceNumber snapshot_seq)
-      : ReadCallback(snapshot_seq),
-        snapshot_checker_(snapshot_checker),
-        snapshot_seq_(snapshot_seq) {}
+      : snapshot_checker_(snapshot_checker), snapshot_seq_(snapshot_seq) {}
 
-  bool IsVisibleFullCheck(SequenceNumber seq) override {
+  bool IsVisible(SequenceNumber seq) override {
     return snapshot_checker_->CheckInSnapshot(seq, snapshot_seq_) ==
            SnapshotCheckerResult::kInSnapshot;
   }

db/db_options_test.cc

@@ -527,17 +527,6 @@ TEST_F(DBOptionsTest, RunStatsDumpPeriodSec) {
   mock_env->set_current_time(0); // in seconds
   options.env = mock_env.get();
   int counter = 0;
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::DumpStats:1", [&](void* /*arg*/) {
         counter++;
@@ -567,17 +556,6 @@ TEST_F(DBOptionsTest, StatsPersistScheduling) {
   mock_env.reset(new rocksdb::MockTimeEnv(env_));
   mock_env->set_current_time(0);  // in seconds
   options.env = mock_env.get();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
   int counter = 0;
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::PersistStats:Entry", [&](void* /*arg*/) { counter++; });
@@ -603,17 +581,6 @@ TEST_F(DBOptionsTest, PersistentStatsFreshInstall) {
   mock_env.reset(new rocksdb::MockTimeEnv(env_));
   mock_env->set_current_time(0);  // in seconds
   options.env = mock_env.get();
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX && !NDEBUG
   int counter = 0;
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::PersistStats:Entry", [&](void* /*arg*/) { counter++; });
@@ -649,19 +616,6 @@ TEST_F(DBOptionsTest, GetStatsHistory) {
   mock_env.reset(new rocksdb::MockTimeEnv(env_));
   mock_env->set_current_time(0);  // in seconds
   options.env = mock_env.get();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-#endif  // OS_MACOSX && !NDEBUG
-
   CreateColumnFamilies({"pikachu"}, options);
   ASSERT_OK(Put("foo", "bar"));
   ReopenWithColumnFamilies({"default", "pikachu"}, options);
@@ -704,19 +658,6 @@ TEST_F(DBOptionsTest, InMemoryStatsHistoryPurging) {
   mock_env.reset(new rocksdb::MockTimeEnv(env_));
   mock_env->set_current_time(0);  // in seconds
   options.env = mock_env.get();
-#if defined(OS_MACOSX) && !defined(NDEBUG)
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *reinterpret_cast<uint64_t*>(arg);
-        if (time_us < mock_env->RealNowMicros()) {
-          *reinterpret_cast<uint64_t*>(arg) = mock_env->RealNowMicros() + 1000;
-        }
-      });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-#endif  // OS_MACOSX && !NDEBUG
-
   CreateColumnFamilies({"pikachu"}, options);
   ASSERT_OK(Put("foo", "bar"));
   ReopenWithColumnFamilies({"default", "pikachu"}, options);

db/db_range_del_test.cc

@@ -490,30 +490,6 @@ TEST_F(DBRangeDelTest, CompactionRemovesCoveredMergeOperands) {
   ASSERT_EQ(expected, actual);
 }
 
-TEST_F(DBRangeDelTest, PutDeleteRangeMergeFlush) {
-  // Test the sequence of operations: (1) Put, (2) DeleteRange, (3) Merge, (4)
-  // Flush. The `CompactionIterator` previously had a bug where we forgot to
-  // check for covering range tombstones when processing the (1) Put, causing
-  // it to reappear after the flush.
-  Options opts = CurrentOptions();
-  opts.merge_operator = MergeOperators::CreateUInt64AddOperator();
-  Reopen(opts);
-
-  std::string val;
-  PutFixed64(&val, 1);
-  ASSERT_OK(db_->Put(WriteOptions(), "key", val));
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                             "key", "key_"));
-  ASSERT_OK(db_->Merge(WriteOptions(), "key", val));
-  ASSERT_OK(db_->Flush(FlushOptions()));
-
-  ReadOptions read_opts;
-  std::string expected, actual;
-  ASSERT_OK(db_->Get(read_opts, "key", &actual));
-  PutFixed64(&expected, 1);
-  ASSERT_EQ(expected, actual);
-}
-
 // NumTableFilesAtLevel() is not supported in ROCKSDB_LITE
 #ifndef ROCKSDB_LITE
 TEST_F(DBRangeDelTest, ObsoleteTombstoneCleanup) {

db/db_secondary_test.cc

@@ -1,480 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// 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 "db/db_impl_secondary.h"
-#include "db/db_test_util.h"
-#include "port/stack_trace.h"
-#include "util/fault_injection_test_env.h"
-#include "util/sync_point.h"
-
-namespace rocksdb {
-
-#ifndef ROCKSDB_LITE
-class DBSecondaryTest : public DBTestBase {
- public:
-  DBSecondaryTest()
-      : DBTestBase("/db_secondary_test"),
-        secondary_path_(),
-        handles_secondary_(),
-        db_secondary_(nullptr) {
-    secondary_path_ =
-        test::PerThreadDBPath(env_, "/db_secondary_test_secondary");
-  }
-
-  ~DBSecondaryTest() override {
-    CloseSecondary();
-    if (getenv("KEEP_DB") != nullptr) {
-      fprintf(stdout, "Secondary DB is still at %s\n", secondary_path_.c_str());
-    } else {
-      Options options;
-      options.env = env_;
-      EXPECT_OK(DestroyDB(secondary_path_, options));
-    }
-  }
-
- protected:
-  Status ReopenAsSecondary(const Options& options) {
-    return DB::OpenAsSecondary(options, dbname_, secondary_path_, &db_);
-  }
-
-  void OpenSecondary(const Options& options);
-
-  void OpenSecondaryWithColumnFamilies(
-      const std::vector<std::string>& column_families, const Options& options);
-
-  void CloseSecondary() {
-    for (auto h : handles_secondary_) {
-      db_secondary_->DestroyColumnFamilyHandle(h);
-    }
-    handles_secondary_.clear();
-    delete db_secondary_;
-    db_secondary_ = nullptr;
-  }
-
-  DBImplSecondary* db_secondary_full() {
-    return static_cast<DBImplSecondary*>(db_secondary_);
-  }
-
-  void CheckFileTypeCounts(const std::string& dir, int expected_log,
-                           int expected_sst, int expected_manifest) const;
-
-  std::string secondary_path_;
-  std::vector<ColumnFamilyHandle*> handles_secondary_;
-  DB* db_secondary_;
-};
-
-void DBSecondaryTest::OpenSecondary(const Options& options) {
-  Status s =
-      DB::OpenAsSecondary(options, dbname_, secondary_path_, &db_secondary_);
-  ASSERT_OK(s);
-}
-
-void DBSecondaryTest::OpenSecondaryWithColumnFamilies(
-    const std::vector<std::string>& column_families, const Options& options) {
-  std::vector<ColumnFamilyDescriptor> cf_descs;
-  cf_descs.emplace_back(kDefaultColumnFamilyName, options);
-  for (const auto& cf_name : column_families) {
-    cf_descs.emplace_back(cf_name, options);
-  }
-  Status s = DB::OpenAsSecondary(options, dbname_, secondary_path_, cf_descs,
-                                 &handles_secondary_, &db_secondary_);
-  ASSERT_OK(s);
-}
-
-void DBSecondaryTest::CheckFileTypeCounts(const std::string& dir,
-                                          int expected_log, int expected_sst,
-                                          int expected_manifest) const {
-  std::vector<std::string> filenames;
-  env_->GetChildren(dir, &filenames);
-
-  int log_cnt = 0, sst_cnt = 0, manifest_cnt = 0;
-  for (auto file : filenames) {
-    uint64_t number;
-    FileType type;
-    if (ParseFileName(file, &number, &type)) {
-      log_cnt += (type == kLogFile);
-      sst_cnt += (type == kTableFile);
-      manifest_cnt += (type == kDescriptorFile);
-    }
-  }
-  ASSERT_EQ(expected_log, log_cnt);
-  ASSERT_EQ(expected_sst, sst_cnt);
-  ASSERT_EQ(expected_manifest, manifest_cnt);
-}
-
-TEST_F(DBSecondaryTest, ReopenAsSecondary) {
-  Options options;
-  options.env = env_;
-  Reopen(options);
-  ASSERT_OK(Put("foo", "foo_value"));
-  ASSERT_OK(Put("bar", "bar_value"));
-  ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  Close();
-
-  ASSERT_OK(ReopenAsSecondary(options));
-  ASSERT_EQ("foo_value", Get("foo"));
-  ASSERT_EQ("bar_value", Get("bar"));
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  auto db1 = static_cast<DBImplSecondary*>(db_);
-  ASSERT_NE(nullptr, db1);
-  Iterator* iter = db1->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    if (0 == count) {
-      ASSERT_EQ("bar", iter->key().ToString());
-      ASSERT_EQ("bar_value", iter->value().ToString());
-    } else if (1 == count) {
-      ASSERT_EQ("foo", iter->key().ToString());
-      ASSERT_EQ("foo_value", iter->value().ToString());
-    }
-    ++count;
-  }
-  delete iter;
-  ASSERT_EQ(2, count);
-}
-
-TEST_F(DBSecondaryTest, OpenAsSecondary) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  const auto verify_db_func = [&](const std::string& foo_val,
-                                  const std::string& bar_val) {
-    std::string value;
-    ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-    ASSERT_EQ(foo_val, value);
-    ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-    ASSERT_EQ(bar_val, value);
-    Iterator* iter = db_secondary_->NewIterator(ropts);
-    ASSERT_NE(nullptr, iter);
-    iter->Seek("foo");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("foo", iter->key().ToString());
-    ASSERT_EQ(foo_val, iter->value().ToString());
-    iter->Seek("bar");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("bar", iter->key().ToString());
-    ASSERT_EQ(bar_val, iter->value().ToString());
-    size_t count = 0;
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-      ++count;
-    }
-    ASSERT_EQ(2, count);
-    delete iter;
-  };
-
-  verify_db_func("foo_value2", "bar_value2");
-
-  ASSERT_OK(Put("foo", "new_foo_value"));
-  ASSERT_OK(Put("bar", "new_bar_value"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  verify_db_func("new_foo_value", "new_bar_value");
-}
-
-TEST_F(DBSecondaryTest, OpenWithNonExistColumnFamily) {
-  Options options;
-  options.env = env_;
-  CreateAndReopenWithCF({"pikachu"}, options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  std::vector<ColumnFamilyDescriptor> cf_descs;
-  cf_descs.emplace_back(kDefaultColumnFamilyName, options1);
-  cf_descs.emplace_back("pikachu", options1);
-  cf_descs.emplace_back("eevee", options1);
-  Status s = DB::OpenAsSecondary(options1, dbname_, secondary_path_, cf_descs,
-                                 &handles_secondary_, &db_secondary_);
-  ASSERT_NOK(s);
-}
-
-TEST_F(DBSecondaryTest, OpenWithSubsetOfColumnFamilies) {
-  Options options;
-  options.env = env_;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ASSERT_EQ(0, handles_secondary_.size());
-  ASSERT_NE(nullptr, db_secondary_);
-
-  ASSERT_OK(Put(0 /*cf*/, "foo", "foo_value"));
-  ASSERT_OK(Put(1 /*cf*/, "foo", "foo_value"));
-  ASSERT_OK(Flush(0 /*cf*/));
-  ASSERT_OK(Flush(1 /*cf*/));
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value", value);
-}
-
-TEST_F(DBSecondaryTest, SwitchToNewManifestDuringOpen) {
-  Options options;
-  options.env = env_;
-  Reopen(options);
-  Close();
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"ReactiveVersionSet::MaybeSwitchManifest:AfterGetCurrentManifestPath:0",
-        "VersionSet::ProcessManifestWrites:BeforeNewManifest"},
-       {"VersionSet::ProcessManifestWrites:AfterNewManifest",
-        "ReactiveVersionSet::MaybeSwitchManifest:AfterGetCurrentManifestPath:"
-        "1"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Make sure db calls RecoverLogFiles so as to trigger a manifest write,
-  // which causes the db to switch to a new MANIFEST upon start.
-  port::Thread ro_db_thread([&]() {
-    Options options1;
-    options1.env = env_;
-    options1.max_open_files = -1;
-    OpenSecondary(options1);
-    CloseSecondary();
-  });
-  Reopen(options);
-  ro_db_thread.join();
-}
-
-TEST_F(DBSecondaryTest, MissingTableFileDuringOpen) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-  for (int i = 0; i != options.level0_file_num_compaction_trigger; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  Iterator* iter = db_secondary_->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  iter->Seek("bar");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar", iter->key().ToString());
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  iter->Seek("foo");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("foo", iter->key().ToString());
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ++count;
-  }
-  ASSERT_EQ(2, count);
-  delete iter;
-}
-
-TEST_F(DBSecondaryTest, MissingTableFile) {
-  int table_files_not_exist = 0;
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "ReactiveVersionSet::ReadAndApply:AfterLoadTableHandlers",
-      [&](void* arg) {
-        Status s = *reinterpret_cast<Status*>(arg);
-        if (s.IsPathNotFound()) {
-          ++table_files_not_exist;
-        } else if (!s.ok()) {
-          assert(false);  // Should not reach here
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-
-  for (int i = 0; i != options.level0_file_num_compaction_trigger; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(dbfull()->Flush(FlushOptions()));
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ASSERT_NE(nullptr, db_secondary_full());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_NOK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_NOK(db_secondary_->Get(ropts, "bar", &value));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ASSERT_EQ(options.level0_file_num_compaction_trigger, table_files_not_exist);
-  ASSERT_OK(db_secondary_->Get(ropts, "foo", &value));
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  ASSERT_OK(db_secondary_->Get(ropts, "bar", &value));
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            value);
-  Iterator* iter = db_secondary_->NewIterator(ropts);
-  ASSERT_NE(nullptr, iter);
-  iter->Seek("bar");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("bar", iter->key().ToString());
-  ASSERT_EQ("bar_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  iter->Seek("foo");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("foo", iter->key().ToString());
-  ASSERT_EQ("foo_value" +
-                std::to_string(options.level0_file_num_compaction_trigger - 1),
-            iter->value().ToString());
-  size_t count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ++count;
-  }
-  ASSERT_EQ(2, count);
-  delete iter;
-}
-
-TEST_F(DBSecondaryTest, PrimaryDropColumnFamily) {
-  Options options;
-  options.env = env_;
-  const std::string kCfName1 = "pikachu";
-  CreateAndReopenWithCF({kCfName1}, options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondaryWithColumnFamilies({kCfName1}, options1);
-  ASSERT_EQ(2, handles_secondary_.size());
-
-  ASSERT_OK(Put(1 /*cf*/, "foo", "foo_val_1"));
-  ASSERT_OK(Flush(1 /*cf*/));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  std::string value;
-  ASSERT_OK(db_secondary_->Get(ropts, handles_secondary_[1], "foo", &value));
-  ASSERT_EQ("foo_val_1", value);
-
-  ASSERT_OK(dbfull()->DropColumnFamily(handles_[1]));
-  Close();
-  CheckFileTypeCounts(dbname_, 1, 0, 1);
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  value.clear();
-  ASSERT_OK(db_secondary_->Get(ropts, handles_secondary_[1], "foo", &value));
-  ASSERT_EQ("foo_val_1", value);
-}
-
-TEST_F(DBSecondaryTest, SwitchManifest) {
-  Options options;
-  options.env = env_;
-  options.level0_file_num_compaction_trigger = 4;
-  Reopen(options);
-
-  Options options1;
-  options1.env = env_;
-  options1.max_open_files = -1;
-  OpenSecondary(options1);
-
-  const int kNumFiles = options.level0_file_num_compaction_trigger - 1;
-  // Keep it smaller than 10 so that key0, key1, ..., key9 are sorted as 0, 1,
-  // ..., 9.
-  const int kNumKeys = 10;
-  // Create two sst
-  for (int i = 0; i != kNumFiles; ++i) {
-    for (int j = 0; j != kNumKeys; ++j) {
-      ASSERT_OK(Put("key" + std::to_string(j), "value_" + std::to_string(i)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  const auto& range_scan_db = [&]() {
-    ReadOptions tmp_ropts;
-    tmp_ropts.total_order_seek = true;
-    tmp_ropts.verify_checksums = true;
-    std::unique_ptr<Iterator> iter(db_secondary_->NewIterator(tmp_ropts));
-    int cnt = 0;
-    for (iter->SeekToFirst(); iter->Valid(); iter->Next(), ++cnt) {
-      ASSERT_EQ("key" + std::to_string(cnt), iter->key().ToString());
-      ASSERT_EQ("value_" + std::to_string(kNumFiles - 1),
-                iter->value().ToString());
-    }
-  };
-
-  range_scan_db();
-
-  // While secondary instance still keeps old MANIFEST open, we close primary,
-  // restart primary, performs full compaction, close again, restart again so
-  // that next time secondary tries to catch up with primary, the secondary
-  // will skip the MANIFEST in middle.
-  Reopen(options);
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  Reopen(options);
-  ASSERT_OK(dbfull()->SetOptions({{"disable_auto_compactions", "false"}}));
-
-  ASSERT_OK(db_secondary_->TryCatchUpWithPrimary());
-  range_scan_db();
-}
-#endif  //! ROCKSDB_LITE
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

db/db_sst_test.cc

@@ -356,14 +356,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
   env_->time_elapse_only_sleep_ = true;
   Options options = CurrentOptions();
   options.disable_auto_compactions = true;
-  // Need to disable stats dumping and persisting which also use
-  // RepeatableThread, one of whose member variables is of type
-  // InstrumentedCondVar. The callback for
-  // InstrumentedCondVar::TimedWaitInternal can be triggered by stats dumping
-  // and persisting threads and cause time_spent_deleting measurement to become
-  // incorrect.
-  options.stats_dump_period_sec = 0;
-  options.stats_persist_period_sec = 0;
   options.env = env_;
 
   int64_t rate_bytes_per_sec = 1024 * 10;  // 10 Kbs / Sec
@@ -375,16 +367,14 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
   auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
   sfm->delete_scheduler()->SetMaxTrashDBRatio(1.1);
 
-  WriteOptions wo;
-  wo.disableWAL = true;
   ASSERT_OK(TryReopen(options));
   // Create 4 files in L0
   for (char v = 'a'; v <= 'd'; v++) {
-    ASSERT_OK(Put("Key2", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key3", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key4", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key1", DummyString(1024, v), wo));
-    ASSERT_OK(Put("Key4", DummyString(1024, v), wo));
+    ASSERT_OK(Put("Key2", DummyString(1024, v)));
+    ASSERT_OK(Put("Key3", DummyString(1024, v)));
+    ASSERT_OK(Put("Key4", DummyString(1024, v)));
+    ASSERT_OK(Put("Key1", DummyString(1024, v)));
+    ASSERT_OK(Put("Key4", DummyString(1024, v)));
     ASSERT_OK(Flush());
   }
   // We created 4 sst files in L0
@@ -418,55 +408,6 @@ TEST_F(DBSSTTest, RateLimitedDelete) {
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
 
-TEST_F(DBSSTTest, RateLimitedWALDelete) {
-  Destroy(last_options_);
-
-  std::vector<uint64_t> penalties;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::BackgroundEmptyTrash:Wait",
-      [&](void* arg) { penalties.push_back(*(static_cast<uint64_t*>(arg))); });
-
-  env_->no_slowdown_ = true;
-  env_->time_elapse_only_sleep_ = true;
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  options.env = env_;
-
-  int64_t rate_bytes_per_sec = 1024 * 10;  // 10 Kbs / Sec
-  Status s;
-  options.sst_file_manager.reset(
-      NewSstFileManager(env_, nullptr, "", 0, false, &s, 0));
-  ASSERT_OK(s);
-  options.sst_file_manager->SetDeleteRateBytesPerSecond(rate_bytes_per_sec);
-  auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
-  sfm->delete_scheduler()->SetMaxTrashDBRatio(2.1);
-
-  ASSERT_OK(TryReopen(options));
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  // Create 4 files in L0
-  for (char v = 'a'; v <= 'd'; v++) {
-    ASSERT_OK(Put("Key2", DummyString(1024, v)));
-    ASSERT_OK(Put("Key3", DummyString(1024, v)));
-    ASSERT_OK(Put("Key4", DummyString(1024, v)));
-    ASSERT_OK(Put("Key1", DummyString(1024, v)));
-    ASSERT_OK(Put("Key4", DummyString(1024, v)));
-    ASSERT_OK(Flush());
-  }
-  // We created 4 sst files in L0
-  ASSERT_EQ("4", FilesPerLevel(0));
-
-  // Compaction will move the 4 files in L0 to trash and create 1 L1 file
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact(true));
-  ASSERT_EQ("0,1", FilesPerLevel(0));
-
-  sfm->WaitForEmptyTrash();
-  ASSERT_EQ(penalties.size(), 8);
-
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBSSTTest, OpenDBWithExistingTrash) {
   Options options = CurrentOptions();
 
@@ -505,6 +446,7 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DeleteScheduler::DeleteFile",
       [&](void* /*arg*/) { bg_delete_file++; });
+  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
 
   Options options = CurrentOptions();
   options.disable_auto_compactions = true;
@@ -522,14 +464,10 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
   auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
 
   DestroyAndReopen(options);
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  WriteOptions wo;
-  wo.disableWAL = true;
 
   // Create 4 files in L0
   for (int i = 0; i < 4; i++) {
-    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'A'), wo));
+    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'A')));
     ASSERT_OK(Flush());
   }
   // We created 4 sst files in L0
@@ -545,7 +483,7 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
 
   // Create 4 files in L0
   for (int i = 4; i < 8; i++) {
-    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'B'), wo));
+    ASSERT_OK(Put("Key" + ToString(i), DummyString(1024, 'B')));
     ASSERT_OK(Flush());
   }
   ASSERT_EQ("4,1", FilesPerLevel(0));
@@ -600,27 +538,14 @@ TEST_F(DBSSTTest, DestroyDBWithRateLimitedDelete) {
   // Close DB and destroy it using DeleteScheduler
   Close();
 
-  int num_sst_files = 0;
-  int num_wal_files = 0;
-  std::vector<std::string> db_files;
-  env_->GetChildren(dbname_, &db_files);
-  for (std::string f : db_files) {
-    if (f.substr(f.find_last_of(".") + 1) == "sst") {
-      num_sst_files++;
-    } else if (f.substr(f.find_last_of(".") + 1) == "log") {
-      num_wal_files++;
-    }
-  }
-  ASSERT_GT(num_sst_files, 0);
-  ASSERT_GT(num_wal_files, 0);
-
   auto sfm = static_cast<SstFileManagerImpl*>(options.sst_file_manager.get());
 
   sfm->SetDeleteRateBytesPerSecond(1024 * 1024);
   sfm->delete_scheduler()->SetMaxTrashDBRatio(1.1);
   ASSERT_OK(DestroyDB(dbname_, options));
   sfm->WaitForEmptyTrash();
-  ASSERT_EQ(bg_delete_file, num_sst_files + num_wal_files);
+  // We have deleted the 4 sst files in the delete_scheduler
+  ASSERT_EQ(bg_delete_file, 4);
 }
 
 TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {

db/db_statistics_test.cc

@@ -46,7 +46,7 @@ TEST_F(DBStatisticsTest, CompressionStatsTest) {
   Options options = CurrentOptions();
   options.compression = type;
   options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(StatsLevel::kExceptTimeForMutex);
+  options.statistics->stats_level_ = StatsLevel::kExceptTimeForMutex;
   DestroyAndReopen(options);
 
   int kNumKeysWritten = 100000;
@@ -105,7 +105,7 @@ TEST_F(DBStatisticsTest, MutexWaitStats) {
   Options options = CurrentOptions();
   options.create_if_missing = true;
   options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(StatsLevel::kAll);
+  options.statistics->stats_level_ = StatsLevel::kAll;
   CreateAndReopenWithCF({"pikachu"}, options);
   const uint64_t kMutexWaitDelay = 100;
   ThreadStatusUtil::TEST_SetStateDelay(ThreadStatus::STATE_MUTEX_WAIT,

db/db_test.cc

@@ -5102,7 +5102,7 @@ TEST_P(DBTestWithParam, FilterCompactionTimeTest) {
   options.disable_auto_compactions = true;
   options.create_if_missing = true;
   options.statistics = rocksdb::CreateDBStatistics();
-  options.statistics->set_stats_level(kExceptTimeForMutex);
+  options.statistics->stats_level_ = kExceptTimeForMutex;
   options.max_subcompactions = max_subcompactions_;
   DestroyAndReopen(options);
 

db/db_test2.cc

@@ -1805,7 +1805,7 @@ class MockPersistentCache : public PersistentCache {
 #ifdef OS_LINUX
 // Make sure that in CPU time perf context counters, Env::NowCPUNanos()
 // is used, rather than Env::CPUNanos();
-TEST_F(DBTest2, TestPerfContextGetCpuTime) {
+TEST_F(DBTest2, TestPerfContextCpuTime) {
   // force resizing table cache so table handle is not preloaded so that
   // we can measure find_table_nanos during Get().
   dbfull()->TEST_table_cache()->SetCapacity(0);
@@ -1836,91 +1836,6 @@ TEST_F(DBTest2, TestPerfContextGetCpuTime) {
   SetPerfLevel(PerfLevel::kDisable);
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
-
-TEST_F(DBTest2, TestPerfContextIterCpuTime) {
-  DestroyAndReopen(CurrentOptions());
-  // force resizing table cache so table handle is not preloaded so that
-  // we can measure find_table_nanos during iteration
-  dbfull()->TEST_table_cache()->SetCapacity(0);
-
-  const size_t kNumEntries = 10;
-  for (size_t i = 0; i < kNumEntries; ++i) {
-    ASSERT_OK(Put("k" + ToString(i), "v" + ToString(i)));
-  }
-  ASSERT_OK(Flush());
-  for (size_t i = 0; i < kNumEntries; ++i) {
-    ASSERT_EQ("v" + ToString(i), Get("k" + ToString(i)));
-  }
-  std::string last_key = "k" + ToString(kNumEntries - 1);
-  std::string last_value = "v" + ToString(kNumEntries - 1);
-  env_->now_cpu_count_.store(0);
-
-  // CPU timing is not enabled with kEnableTimeExceptForMutex
-  SetPerfLevel(PerfLevel::kEnableTimeExceptForMutex);
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  iter->Seek("k0");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  iter->SeekForPrev(last_key);
-  ASSERT_TRUE(iter->Valid());
-  iter->SeekToLast();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(last_value, iter->value().ToString());
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_seek_cpu_nanos);
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v1", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_next_cpu_nanos);
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_EQ(0, get_perf_context()->iter_prev_cpu_nanos);
-  ASSERT_EQ(0, env_->now_cpu_count_.load());
-  delete iter;
-
-  uint64_t kDummyAddonTime = uint64_t{1000000000000};
-
-  // Add time to NowNanos() reading.
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "TableCache::FindTable:0",
-      [&](void* /*arg*/) { env_->addon_time_.fetch_add(kDummyAddonTime); });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  SetPerfLevel(PerfLevel::kEnableTimeAndCPUTimeExceptForMutex);
-  iter = db_->NewIterator(ReadOptions());
-  iter->Seek("k0");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  iter->SeekForPrev(last_key);
-  ASSERT_TRUE(iter->Valid());
-  iter->SeekToLast();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(last_value, iter->value().ToString());
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_seek_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_seek_cpu_nanos, kDummyAddonTime);
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v1", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_next_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_next_cpu_nanos, kDummyAddonTime);
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ("v0", iter->value().ToString());
-  ASSERT_GT(get_perf_context()->iter_prev_cpu_nanos, 0);
-  ASSERT_LT(get_perf_context()->iter_prev_cpu_nanos, kDummyAddonTime);
-  ASSERT_GE(env_->now_cpu_count_.load(), 12);
-  ASSERT_GT(get_perf_context()->find_table_nanos, kDummyAddonTime);
-
-  SetPerfLevel(PerfLevel::kDisable);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-  delete iter;
-}
 #endif  // OS_LINUX
 
 #ifndef OS_SOLARIS // GetUniqueIdFromFile is not implemented
@@ -2729,11 +2644,8 @@ TEST_F(DBTest2, ReadCallbackTest) {
 
   class TestReadCallback : public ReadCallback {
    public:
-    explicit TestReadCallback(SequenceNumber snapshot)
-        : ReadCallback(snapshot), snapshot_(snapshot) {}
-    bool IsVisibleFullCheck(SequenceNumber seq) override {
-      return seq <= snapshot_;
-    }
+    explicit TestReadCallback(SequenceNumber snapshot) : snapshot_(snapshot) {}
+    bool IsVisible(SequenceNumber seq) override { return seq <= snapshot_; }
 
    private:
     SequenceNumber snapshot_;
@@ -2875,8 +2787,6 @@ TEST_F(DBTest2, TraceAndReplay) {
   Random rnd(301);
   Iterator* single_iter = nullptr;
 
-  ASSERT_TRUE(db_->EndTrace().IsIOError());
-
   std::string trace_filename = dbname_ + "/rocksdb.trace";
   std::unique_ptr<TraceWriter> trace_writer;
   ASSERT_OK(NewFileTraceWriter(env_, env_opts, trace_filename, &trace_writer));
@@ -3107,177 +3017,6 @@ TEST_F(DBTest2, TraceWithSampling) {
   ASSERT_OK(DestroyDB(dbname2, options));
 }
 
-TEST_F(DBTest2, TraceWithFilter) {
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreatePutOperator();
-  ReadOptions ro;
-  WriteOptions wo;
-  TraceOptions trace_opts;
-  EnvOptions env_opts;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  Random rnd(301);
-  Iterator* single_iter = nullptr;
-
-  trace_opts.filter = TraceFilterType::kTraceFilterWrite;
-
-  std::string trace_filename = dbname_ + "/rocksdb.trace";
-  std::unique_ptr<TraceWriter> trace_writer;
-  ASSERT_OK(NewFileTraceWriter(env_, env_opts, trace_filename, &trace_writer));
-  ASSERT_OK(db_->StartTrace(trace_opts, std::move(trace_writer)));
-
-  ASSERT_OK(Put(0, "a", "1"));
-  ASSERT_OK(Merge(0, "b", "2"));
-  ASSERT_OK(Delete(0, "c"));
-  ASSERT_OK(SingleDelete(0, "d"));
-  ASSERT_OK(db_->DeleteRange(wo, dbfull()->DefaultColumnFamily(), "e", "f"));
-
-  WriteBatch batch;
-  ASSERT_OK(batch.Put("f", "11"));
-  ASSERT_OK(batch.Merge("g", "12"));
-  ASSERT_OK(batch.Delete("h"));
-  ASSERT_OK(batch.SingleDelete("i"));
-  ASSERT_OK(batch.DeleteRange("j", "k"));
-  ASSERT_OK(db_->Write(wo, &batch));
-
-  single_iter = db_->NewIterator(ro);
-  single_iter->Seek("f");
-  single_iter->SeekForPrev("g");
-  delete single_iter;
-
-  ASSERT_EQ("1", Get(0, "a"));
-  ASSERT_EQ("12", Get(0, "g"));
-
-  ASSERT_OK(Put(1, "foo", "bar"));
-  ASSERT_OK(Put(1, "rocksdb", "rocks"));
-  ASSERT_EQ("NOT_FOUND", Get(1, "leveldb"));
-
-  ASSERT_OK(db_->EndTrace());
-  // These should not get into the trace file as it is after EndTrace.
-  Put("hello", "world");
-  Merge("foo", "bar");
-
-  // Open another db, replay, and verify the data
-  std::string value;
-  std::string dbname2 = test::TmpDir(env_) + "/db_replay";
-  ASSERT_OK(DestroyDB(dbname2, options));
-
-  // Using a different name than db2, to pacify infer's use-after-lifetime
-  // warnings (http://fbinfer.com).
-  DB* db2_init = nullptr;
-  options.create_if_missing = true;
-  ASSERT_OK(DB::Open(options, dbname2, &db2_init));
-  ColumnFamilyHandle* cf;
-  ASSERT_OK(
-      db2_init->CreateColumnFamily(ColumnFamilyOptions(), "pikachu", &cf));
-  delete cf;
-  delete db2_init;
-
-  DB* db2 = nullptr;
-  std::vector<ColumnFamilyDescriptor> column_families;
-  ColumnFamilyOptions cf_options;
-  cf_options.merge_operator = MergeOperators::CreatePutOperator();
-  column_families.push_back(ColumnFamilyDescriptor("default", cf_options));
-  column_families.push_back(
-      ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
-  std::vector<ColumnFamilyHandle*> handles;
-  ASSERT_OK(DB::Open(DBOptions(), dbname2, column_families, &handles, &db2));
-
-  env_->SleepForMicroseconds(100);
-  // Verify that the keys don't already exist
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "g", &value).IsNotFound());
-
-  std::unique_ptr<TraceReader> trace_reader;
-  ASSERT_OK(NewFileTraceReader(env_, env_opts, trace_filename, &trace_reader));
-  Replayer replayer(db2, handles_, std::move(trace_reader));
-  ASSERT_OK(replayer.Replay());
-
-  // All the key-values should not present since we filter out the WRITE ops.
-  ASSERT_TRUE(db2->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "g", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "hello", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "world", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "foo", &value).IsNotFound());
-  ASSERT_TRUE(db2->Get(ro, handles[0], "rocksdb", &value).IsNotFound());
-
-  for (auto handle : handles) {
-    delete handle;
-  }
-  delete db2;
-  ASSERT_OK(DestroyDB(dbname2, options));
-
-  // Set up a new db.
-  std::string dbname3 = test::TmpDir(env_) + "/db_not_trace_read";
-  ASSERT_OK(DestroyDB(dbname3, options));
-
-  DB* db3_init = nullptr;
-  options.create_if_missing = true;
-  ColumnFamilyHandle* cf3;
-  ASSERT_OK(DB::Open(options, dbname3, &db3_init));
-  ASSERT_OK(
-      db3_init->CreateColumnFamily(ColumnFamilyOptions(), "pikachu", &cf3));
-  delete cf3;
-  delete db3_init;
-
-  column_families.clear();
-  column_families.push_back(ColumnFamilyDescriptor("default", cf_options));
-  column_families.push_back(
-      ColumnFamilyDescriptor("pikachu", ColumnFamilyOptions()));
-  handles.clear();
-
-  DB* db3 =  nullptr;
-  ASSERT_OK(DB::Open(DBOptions(), dbname3, column_families, &handles, &db3));
-
-  env_->SleepForMicroseconds(100);
-  // Verify that the keys don't already exist
-  ASSERT_TRUE(db3->Get(ro, handles[0], "a", &value).IsNotFound());
-  ASSERT_TRUE(db3->Get(ro, handles[0], "g", &value).IsNotFound());
-
-  //The tracer will not record the READ ops.
-  trace_opts.filter = TraceFilterType::kTraceFilterGet;
-  std::string trace_filename3 = dbname_ + "/rocksdb.trace_3";
-  std::unique_ptr<TraceWriter> trace_writer3;
-  ASSERT_OK(
-    NewFileTraceWriter(env_, env_opts, trace_filename3, &trace_writer3));
-  ASSERT_OK(db3->StartTrace(trace_opts, std::move(trace_writer3)));
-
-  ASSERT_OK(db3->Put(wo, handles[0], "a", "1"));
-  ASSERT_OK(db3->Merge(wo, handles[0], "b", "2"));
-  ASSERT_OK(db3->Delete(wo, handles[0], "c"));
-  ASSERT_OK(db3->SingleDelete(wo, handles[0], "d"));
-
-  ASSERT_OK(db3->Get(ro, handles[0], "a", &value));
-  ASSERT_EQ(value, "1");
-  ASSERT_TRUE(db3->Get(ro, handles[0], "c", &value).IsNotFound());
-
-  ASSERT_OK(db3->EndTrace());
-
-  for (auto handle : handles) {
-    delete handle;
-  }
-  delete db3;
-  ASSERT_OK(DestroyDB(dbname3, options));
-
-  std::unique_ptr<TraceReader> trace_reader3;
-  ASSERT_OK(
-    NewFileTraceReader(env_, env_opts, trace_filename3, &trace_reader3));
-
-  // Count the number of records in the trace file;
-  int count = 0;
-  std::string data;
-  Status s;
-  while (true) {
-    s = trace_reader3->Read(&data);
-    if (!s.ok()) {
-      break;
-    }
-    count += 1;
-  }
-  // We also need to count the header and footer
-  // 4 WRITE + HEADER + FOOTER = 6
-  ASSERT_EQ(count, 6);
-}
-
 #endif  // ROCKSDB_LITE
 
 TEST_F(DBTest2, PinnableSliceAndMmapReads) {
@@ -3661,48 +3400,6 @@ TEST_F(DBTest2, MultiDBParallelOpenTest) {
 }
 #endif  // OS_WIN
 
-namespace {
-class DummyOldStats : public Statistics {
- public:
-  uint64_t getTickerCount(uint32_t /*ticker_type*/) const override { return 0; }
-  void recordTick(uint32_t /* ticker_type */, uint64_t /* count */) override {
-    num_rt++;
-  }
-  void setTickerCount(uint32_t /*ticker_type*/, uint64_t /*count*/) override {}
-  uint64_t getAndResetTickerCount(uint32_t /*ticker_type*/) override {
-    return 0;
-  }
-  void measureTime(uint32_t /*histogram_type*/, uint64_t /*count*/) override {
-    num_mt++;
-  }
-  void histogramData(uint32_t /*histogram_type*/,
-                     rocksdb::HistogramData* const /*data*/) const override {}
-  std::string getHistogramString(uint32_t /*type*/) const override {
-    return "";
-  }
-  bool HistEnabledForType(uint32_t /*type*/) const override { return false; }
-  std::string ToString() const override { return ""; }
-  int num_rt = 0;
-  int num_mt = 0;
-};
-}  // namespace
-
-TEST_F(DBTest2, OldStatsInterface) {
-  DummyOldStats* dos = new DummyOldStats();
-  std::shared_ptr<Statistics> stats(dos);
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = stats;
-  Reopen(options);
-
-  Put("foo", "bar");
-  ASSERT_EQ("bar", Get("foo"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ("bar", Get("foo"));
-
-  ASSERT_GT(dos->num_rt, 0);
-  ASSERT_GT(dos->num_mt, 0);
-}
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/db_write_test.cc

@@ -140,51 +140,6 @@ TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
   Close();
 }
 
-TEST_P(DBWriteTest, IOErrorOnSwitchMemtable) {
-  Random rnd(301);
-  std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options = GetOptions();
-  options.env = mock_env.get();
-  options.writable_file_max_buffer_size = 4 * 1024 * 1024;
-  options.write_buffer_size = 3 * 512 * 1024;
-  options.wal_bytes_per_sync = 256 * 1024;
-  options.manual_wal_flush = true;
-  Reopen(options);
-  mock_env->SetFilesystemActive(false, Status::IOError("Not active"));
-  Status s;
-  for (int i = 0; i < 4 * 512; ++i) {
-    s = Put(Key(i), RandomString(&rnd, 1024));
-    if (!s.ok()) {
-      break;
-    }
-  }
-  ASSERT_EQ(s.severity(), Status::Severity::kFatalError);
-
-  mock_env->SetFilesystemActive(true);
-  // Close before mock_env destruct.
-  Close();
-}
-
-// Test that db->LockWAL() flushes the WAL after locking.
-TEST_P(DBWriteTest, LockWalInEffect) {
-  Options options = GetOptions();
-  Reopen(options);
-  // try the 1st WAL created during open
-  ASSERT_OK(Put("key" + ToString(0), "value"));
-  ASSERT_TRUE(options.manual_wal_flush != dbfull()->TEST_WALBufferIsEmpty());
-  ASSERT_OK(dbfull()->LockWAL());
-  ASSERT_TRUE(dbfull()->TEST_WALBufferIsEmpty(false));
-  ASSERT_OK(dbfull()->UnlockWAL());
-  // try the 2nd wal created during SwitchWAL
-  dbfull()->TEST_SwitchWAL();
-  ASSERT_OK(Put("key" + ToString(0), "value"));
-  ASSERT_TRUE(options.manual_wal_flush != dbfull()->TEST_WALBufferIsEmpty());
-  ASSERT_OK(dbfull()->LockWAL());
-  ASSERT_TRUE(dbfull()->TEST_WALBufferIsEmpty(false));
-  ASSERT_OK(dbfull()->UnlockWAL());
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                         testing::Values(DBTestBase::kDefault,
                                         DBTestBase::kConcurrentWALWrites,

db/dbformat.cc

@@ -106,7 +106,9 @@ std::string InternalKey::DebugString(bool hex) const {
   return result;
 }
 
-const char* InternalKeyComparator::Name() const { return name_.c_str(); }
+const char* InternalKeyComparator::Name() const {
+  return name_.c_str();
+}
 
 int InternalKeyComparator::Compare(const ParsedInternalKey& a,
                                    const ParsedInternalKey& b) const {
@@ -114,7 +116,8 @@ int InternalKeyComparator::Compare(const ParsedInternalKey& a,
   //    increasing user key (according to user-supplied comparator)
   //    decreasing sequence number
   //    decreasing type (though sequence# should be enough to disambiguate)
-  int r = user_comparator_.Compare(a.user_key, b.user_key);
+  int r = user_comparator_->Compare(a.user_key, b.user_key);
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
   if (r == 0) {
     if (a.sequence > b.sequence) {
       r = -1;
@@ -129,19 +132,19 @@ int InternalKeyComparator::Compare(const ParsedInternalKey& a,
   return r;
 }
 
-void InternalKeyComparator::FindShortestSeparator(std::string* start,
-                                                  const Slice& limit) const {
+void InternalKeyComparator::FindShortestSeparator(
+      std::string* start,
+      const Slice& limit) const {
   // Attempt to shorten the user portion of the key
   Slice user_start = ExtractUserKey(*start);
   Slice user_limit = ExtractUserKey(limit);
   std::string tmp(user_start.data(), user_start.size());
-  user_comparator_.FindShortestSeparator(&tmp, user_limit);
+  user_comparator_->FindShortestSeparator(&tmp, user_limit);
   if (tmp.size() <= user_start.size() &&
-      user_comparator_.Compare(user_start, tmp) < 0) {
+      user_comparator_->Compare(user_start, tmp) < 0) {
     // User key has become shorter physically, but larger logically.
     // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
-               PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
+    PutFixed64(&tmp, PackSequenceAndType(kMaxSequenceNumber,kValueTypeForSeek));
     assert(this->Compare(*start, tmp) < 0);
     assert(this->Compare(tmp, limit) < 0);
     start->swap(tmp);
@@ -151,13 +154,12 @@ void InternalKeyComparator::FindShortestSeparator(std::string* start,
 void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
   Slice user_key = ExtractUserKey(*key);
   std::string tmp(user_key.data(), user_key.size());
-  user_comparator_.FindShortSuccessor(&tmp);
+  user_comparator_->FindShortSuccessor(&tmp);
   if (tmp.size() <= user_key.size() &&
-      user_comparator_.Compare(user_key, tmp) < 0) {
+      user_comparator_->Compare(user_key, tmp) < 0) {
     // User key has become shorter physically, but larger logically.
     // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
-               PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
+    PutFixed64(&tmp, PackSequenceAndType(kMaxSequenceNumber,kValueTypeForSeek));
     assert(this->Compare(*key, tmp) < 0);
     key->swap(tmp);
   }

db/dbformat.h

@@ -21,7 +21,6 @@
 #include "rocksdb/types.h"
 #include "util/coding.h"
 #include "util/logging.h"
-#include "util/user_comparator_wrapper.h"
 
 namespace rocksdb {
 
@@ -81,7 +80,8 @@ inline bool IsExtendedValueType(ValueType t) {
 
 // We leave eight bits empty at the bottom so a type and sequence#
 // can be packed together into 64-bits.
-static const SequenceNumber kMaxSequenceNumber = ((0x1ull << 56) - 1);
+static const SequenceNumber kMaxSequenceNumber =
+    ((0x1ull << 56) - 1);
 
 static const SequenceNumber kDisableGlobalSequenceNumber = port::kMaxUint64;
 
@@ -92,9 +92,9 @@ struct ParsedInternalKey {
 
   ParsedInternalKey()
       : sequence(kMaxSequenceNumber)  // Make code analyzer happy
-  {}  // Intentionally left uninitialized (for speed)
+        {} // Intentionally left uninitialized (for speed)
   ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
-      : user_key(u), sequence(seq), type(t) {}
+      : user_key(u), sequence(seq), type(t) { }
   std::string DebugString(bool hex = false) const;
 
   void clear() {
@@ -160,14 +160,13 @@ class InternalKeyComparator
 #endif
     : public Comparator {
  private:
-  UserComparatorWrapper user_comparator_;
+  const Comparator* user_comparator_;
   std::string name_;
-
  public:
-  explicit InternalKeyComparator(const Comparator* c)
-      : user_comparator_(c),
-        name_("rocksdb.InternalKeyComparator:" +
-              std::string(user_comparator_.Name())) {}
+  explicit InternalKeyComparator(const Comparator* c) : user_comparator_(c),
+    name_("rocksdb.InternalKeyComparator:" +
+          std::string(user_comparator_->Name())) {
+  }
   virtual ~InternalKeyComparator() {}
 
   virtual const char* Name() const override;
@@ -178,14 +177,12 @@ class InternalKeyComparator
                                      const Slice& limit) const override;
   virtual void FindShortSuccessor(std::string* key) const override;
 
-  const Comparator* user_comparator() const {
-    return user_comparator_.user_comparator();
-  }
+  const Comparator* user_comparator() const { return user_comparator_; }
 
   int Compare(const InternalKey& a, const InternalKey& b) const;
   int Compare(const ParsedInternalKey& a, const ParsedInternalKey& b) const;
   virtual const Comparator* GetRootComparator() const override {
-    return user_comparator_.GetRootComparator();
+    return user_comparator_->GetRootComparator();
   }
 };
 
@@ -195,9 +192,8 @@ class InternalKeyComparator
 class InternalKey {
  private:
   std::string rep_;
-
  public:
-  InternalKey() {}  // Leave rep_ as empty to indicate it is invalid
+  InternalKey() { }   // Leave rep_ as empty to indicate it is invalid
   InternalKey(const Slice& _user_key, SequenceNumber s, ValueType t) {
     AppendInternalKey(&rep_, ParsedInternalKey(_user_key, s, t));
   }
@@ -254,8 +250,8 @@ class InternalKey {
   std::string DebugString(bool hex = false) const;
 };
 
-inline int InternalKeyComparator::Compare(const InternalKey& a,
-                                          const InternalKey& b) const {
+inline int InternalKeyComparator::Compare(
+    const InternalKey& a, const InternalKey& b) const {
   return Compare(a.Encode(), b.Encode());
 }
 
@@ -292,6 +288,7 @@ inline uint64_t GetInternalKeySeqno(const Slice& internal_key) {
   return num >> 8;
 }
 
+
 // A helper class useful for DBImpl::Get()
 class LookupKey {
  public:
@@ -327,7 +324,7 @@ class LookupKey {
   const char* start_;
   const char* kstart_;
   const char* end_;
-  char space_[200];  // Avoid allocation for short keys
+  char space_[200];      // Avoid allocation for short keys
 
   // No copying allowed
   LookupKey(const LookupKey&);
@@ -342,9 +339,9 @@ class IterKey {
  public:
   IterKey()
       : buf_(space_),
+        buf_size_(sizeof(space_)),
         key_(buf_),
         key_size_(0),
-        buf_size_(sizeof(space_)),
         is_user_key_(true) {}
 
   ~IterKey() { ResetBuffer(); }
@@ -499,9 +496,9 @@ class IterKey {
 
  private:
   char* buf_;
+  size_t buf_size_;
   const char* key_;
   size_t key_size_;
-  size_t buf_size_;
   char space_[32];  // Avoid allocation for short keys
   bool is_user_key_;
 
@@ -636,13 +633,14 @@ struct RangeTombstone {
   }
 };
 
-inline int InternalKeyComparator::Compare(const Slice& akey,
-                                          const Slice& bkey) const {
+inline
+int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
   // Order by:
   //    increasing user key (according to user-supplied comparator)
   //    decreasing sequence number
   //    decreasing type (though sequence# should be enough to disambiguate)
-  int r = user_comparator_.Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
   if (r == 0) {
     const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
     const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
@@ -655,12 +653,14 @@ inline int InternalKeyComparator::Compare(const Slice& akey,
   return r;
 }
 
-inline int InternalKeyComparator::CompareKeySeq(const Slice& akey,
-                                                const Slice& bkey) const {
+inline
+int InternalKeyComparator::CompareKeySeq(const Slice& akey,
+                                         const Slice& bkey) const {
   // Order by:
   //    increasing user key (according to user-supplied comparator)
   //    decreasing sequence number
-  int r = user_comparator_.Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
   if (r == 0) {
     // Shift the number to exclude the last byte which contains the value type
     const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8) >> 8;

db/deletefile_test.cc

@@ -71,9 +71,7 @@ class DeleteFileTest : public testing::Test {
     }
     db_ = nullptr;
     options_.create_if_missing = create;
-    Status s = DB::Open(options_, dbname_, &db_);
-    assert(db_);
-    return s;
+    return DB::Open(options_, dbname_, &db_);
   }
 
   void CloseDB() {
@@ -243,7 +241,7 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
   CloseDB();
 }
 
-TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
+TEST_F(DeleteFileTest, BackgroundPurgeTest) {
   std::string first("0"), last("999999");
   CompactRangeOptions compact_options;
   compact_options.change_level = true;
@@ -281,53 +279,6 @@ TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
   CloseDB();
 }
 
-TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
-  auto do_test = [&](bool bg_purge) {
-    ColumnFamilyOptions co;
-    WriteOptions wo;
-    FlushOptions fo;
-    ColumnFamilyHandle* cfh = nullptr;
-
-    ASSERT_OK(db_->CreateColumnFamily(co, "dropme", &cfh));
-
-    ASSERT_OK(db_->Put(wo, cfh, "pika", "chu"));
-    ASSERT_OK(db_->Flush(fo, cfh));
-    // Expect 1 sst file.
-    CheckFileTypeCounts(dbname_, 0, 1, 1);
-
-    ASSERT_OK(db_->DropColumnFamily(cfh));
-    // Still 1 file, it won't be deleted while ColumnFamilyHandle is alive.
-    CheckFileTypeCounts(dbname_, 0, 1, 1);
-
-    delete cfh;
-    test::SleepingBackgroundTask sleeping_task_after;
-    env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   &sleeping_task_after, Env::Priority::HIGH);
-    // If background purge is enabled, the file should still be there.
-    CheckFileTypeCounts(dbname_, 0, bg_purge ? 1 : 0, 1);
-
-    // Execute background purges.
-    sleeping_task_after.WakeUp();
-    sleeping_task_after.WaitUntilDone();
-    // The file should have been deleted.
-    CheckFileTypeCounts(dbname_, 0, 0, 1);
-  };
-
-  {
-    SCOPED_TRACE("avoid_unnecessary_blocking_io = false");
-    do_test(false);
-  }
-
-  options_.avoid_unnecessary_blocking_io = true;
-  ASSERT_OK(ReopenDB(false));
-  {
-    SCOPED_TRACE("avoid_unnecessary_blocking_io = true");
-    do_test(true);
-  }
-
-  CloseDB();
-}
-
 // This test is to reproduce a bug that read invalid ReadOption in iterator
 // cleanup function
 TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {

db/external_sst_file_ingestion_job.cc

@@ -227,8 +227,7 @@ void ExternalSstFileIngestionJob::UpdateStats() {
       stats.bytes_moved = f.fd.GetFileSize();
     }
     stats.num_output_files = 1;
-    cfd_->internal_stats()->AddCompactionStats(f.picked_level,
-                                               Env::Priority::USER, stats);
+    cfd_->internal_stats()->AddCompactionStats(f.picked_level, stats);
     cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_INGESTED_ADD_FILE,
                                        f.fd.GetFileSize());
     total_keys += f.num_entries;

db/external_sst_file_test.cc

@@ -83,8 +83,7 @@ class ExternalSSTFileTest
       const Options options,
       std::vector<std::pair<std::string, std::string>> data, int file_id = -1,
       bool allow_global_seqno = false, bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
       std::map<std::string, std::string>* true_data = nullptr,
       ColumnFamilyHandle* cfh = nullptr) {
     // Generate a file id if not provided
@@ -129,7 +128,66 @@ class ExternalSSTFileTest
       ifo.allow_global_seqno = allow_global_seqno;
       ifo.write_global_seqno = allow_global_seqno ? write_global_seqno : false;
       ifo.verify_checksums_before_ingest = verify_checksums_before_ingest;
-      ifo.ingest_behind = ingest_behind;
+      if (cfh) {
+        s = db_->IngestExternalFile(cfh, {file_path}, ifo);
+      } else {
+        s = db_->IngestExternalFile({file_path}, ifo);
+      }
+    }
+
+    if (s.ok() && true_data) {
+      for (auto& entry : data) {
+        (*true_data)[entry.first] = entry.second;
+      }
+    }
+
+    return s;
+  }
+
+  Status GenerateAndAddExternalFileIngestBehind(
+      const Options options, const IngestExternalFileOptions ifo,
+      std::vector<std::pair<std::string, std::string>> data, int file_id = -1,
+      bool sort_data = false,
+      std::map<std::string, std::string>* true_data = nullptr,
+      ColumnFamilyHandle* cfh = nullptr) {
+    // Generate a file id if not provided
+    if (file_id == -1) {
+      file_id = last_file_id_ + 1;
+      last_file_id_++;
+    }
+
+    // Sort data if asked to do so
+    if (sort_data) {
+      std::sort(data.begin(), data.end(),
+                [&](const std::pair<std::string, std::string>& e1,
+                    const std::pair<std::string, std::string>& e2) {
+                  return options.comparator->Compare(e1.first, e2.first) < 0;
+                });
+      auto uniq_iter = std::unique(
+          data.begin(), data.end(),
+          [&](const std::pair<std::string, std::string>& e1,
+              const std::pair<std::string, std::string>& e2) {
+            return options.comparator->Compare(e1.first, e2.first) == 0;
+          });
+      data.resize(uniq_iter - data.begin());
+    }
+    std::string file_path = sst_files_dir_ + ToString(file_id);
+    SstFileWriter sst_file_writer(EnvOptions(), options, cfh);
+
+    Status s = sst_file_writer.Open(file_path);
+    if (!s.ok()) {
+      return s;
+    }
+    for (auto& entry : data) {
+      s = sst_file_writer.Put(entry.first, entry.second);
+      if (!s.ok()) {
+        sst_file_writer.Finish();
+        return s;
+      }
+    }
+    s = sst_file_writer.Finish();
+
+    if (s.ok()) {
       if (cfh) {
         s = db_->IngestExternalFile(cfh, {file_path}, ifo);
       } else {
@@ -185,35 +243,31 @@ class ExternalSSTFileTest
       const Options options, std::vector<std::pair<int, std::string>> data,
       int file_id = -1, bool allow_global_seqno = false,
       bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
       std::map<std::string, std::string>* true_data = nullptr,
       ColumnFamilyHandle* cfh = nullptr) {
     std::vector<std::pair<std::string, std::string>> file_data;
     for (auto& entry : data) {
       file_data.emplace_back(Key(entry.first), entry.second);
     }
-    return GenerateAndAddExternalFile(options, file_data, file_id,
-                                      allow_global_seqno, write_global_seqno,
-                                      verify_checksums_before_ingest,
-                                      ingest_behind, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(
+        options, file_data, file_id, allow_global_seqno, write_global_seqno,
+        verify_checksums_before_ingest, sort_data, true_data, cfh);
   }
 
   Status GenerateAndAddExternalFile(
       const Options options, std::vector<int> keys, int file_id = -1,
       bool allow_global_seqno = false, bool write_global_seqno = false,
-      bool verify_checksums_before_ingest = true, bool ingest_behind = false,
-      bool sort_data = false,
+      bool verify_checksums_before_ingest = true, bool sort_data = false,
       std::map<std::string, std::string>* true_data = nullptr,
       ColumnFamilyHandle* cfh = nullptr) {
     std::vector<std::pair<std::string, std::string>> file_data;
     for (auto& k : keys) {
       file_data.emplace_back(Key(k), Key(k) + ToString(file_id));
     }
-    return GenerateAndAddExternalFile(options, file_data, file_id,
-                                      allow_global_seqno, write_global_seqno,
-                                      verify_checksums_before_ingest,
-                                      ingest_behind, sort_data, true_data, cfh);
+    return GenerateAndAddExternalFile(
+        options, file_data, file_id, allow_global_seqno, write_global_seqno,
+        verify_checksums_before_ingest, sort_data, true_data, cfh);
   }
 
   Status DeprecatedAddFile(const std::vector<std::string>& files,
@@ -1192,12 +1246,12 @@ TEST_P(ExternalSSTFileTest, PickedLevel) {
 
   // File 0 will go to last level (L3)
   ASSERT_OK(GenerateAndAddExternalFile(options, {1, 10}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "0,0,0,1");
 
   // File 1 will go to level L2 (since it overlap with file 0 in L3)
   ASSERT_OK(GenerateAndAddExternalFile(options, {2, 9}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "0,0,1,1");
 
   rocksdb::SyncPoint::GetInstance()->LoadDependency({
@@ -1227,12 +1281,12 @@ TEST_P(ExternalSSTFileTest, PickedLevel) {
   // This file overlaps with file 0 (L3), file 1 (L2) and the
   // output of compaction going to L1
   ASSERT_OK(GenerateAndAddExternalFile(options, {4, 7}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "5,0,1,1");
 
   // This file does not overlap with any file or with the running compaction
   ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
-                                       false, false, false, &true_data));
+                                       true, false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "5,0,1,2");
 
   // Hold compaction from finishing
@@ -1463,12 +1517,12 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
   // This file overlaps with the output of the compaction (going to L3)
   // so the file will be added to L0 since L3 is the base level
   ASSERT_OK(GenerateAndAddExternalFile(options, {31, 32, 33, 34}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "5");
 
   // This file does not overlap with the current running compactiong
   ASSERT_OK(GenerateAndAddExternalFile(options, {9000, 9001}, -1, false, false,
-                                       true, false, false, &true_data));
+                                       true, false, &true_data));
   EXPECT_EQ(FilesPerLevel(), "5,0,0,1");
 
   // Hold compaction from finishing
@@ -1483,25 +1537,25 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
   Reopen(options);
 
   ASSERT_OK(GenerateAndAddExternalFile(options, {1, 15, 19}, -1, false, false,
-                                       true, false, false, &true_data));
+                                       true, false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "1,0,0,3");
 
   ASSERT_OK(GenerateAndAddExternalFile(options, {1000, 1001, 1002}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "1,0,0,4");
 
   ASSERT_OK(GenerateAndAddExternalFile(options, {500, 600, 700}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "1,0,0,5");
 
   // File 5 overlaps with file 2 (L3 / base level)
   ASSERT_OK(GenerateAndAddExternalFile(options, {2, 10}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "2,0,0,5");
 
   // File 6 overlaps with file 2 (L3 / base level) and file 5 (L0)
   ASSERT_OK(GenerateAndAddExternalFile(options, {3, 9}, -1, false, false, true,
-                                       false, false, &true_data));
+                                       false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "3,0,0,5");
 
   // Verify data in files
@@ -1520,7 +1574,7 @@ TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
 
   // File 7 overlaps with file 4 (L3)
   ASSERT_OK(GenerateAndAddExternalFile(options, {650, 651, 652}, -1, false,
-                                       false, true, false, false, &true_data));
+                                       false, true, false, &true_data));
   ASSERT_EQ(FilesPerLevel(), "5,0,0,5");
 
   VerifyDBFromMap(true_data, &kcnt, false);
@@ -1687,7 +1741,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
       } else {
         ASSERT_OK(GenerateAndAddExternalFile(
             options, random_data, -1, true, write_global_seqno,
-            verify_checksums_before_ingest, false, true, &true_data));
+            verify_checksums_before_ingest, true, &true_data));
       }
     }
     size_t kcnt = 0;
@@ -1720,7 +1774,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
   bool verify_checksums_before_ingest = std::get<1>(GetParam());
   ASSERT_OK(GenerateAndAddExternalFile(
       options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
 
   // This file dont overlap with anything in the DB, will go to L4
   ASSERT_EQ("0,0,0,0,1", FilesPerLevel());
@@ -1732,7 +1786,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
   }
   ASSERT_OK(GenerateAndAddExternalFile(
       options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
 
   // This file overlap with the memtable, so it will flush it and add
   // it self to L0
@@ -1745,7 +1799,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
   }
   ASSERT_OK(GenerateAndAddExternalFile(
       options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
 
   // This file dont overlap with anything in the DB and fit in L4 as well
   ASSERT_EQ("2,0,0,0,2", FilesPerLevel());
@@ -1757,7 +1811,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
   }
   ASSERT_OK(GenerateAndAddExternalFile(
       options, file_data, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
 
   // This file overlap with files in L4, we will ingest it in L3
   ASSERT_EQ("2,0,0,1,2", FilesPerLevel());
@@ -1785,7 +1839,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
   // No need for flush
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {90, 100, 110}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
   db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                       &entries_in_memtable);
   ASSERT_GE(entries_in_memtable, 1);
@@ -1793,7 +1847,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
   // This file will flush the memtable
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {19, 20, 21}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
   db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                       &entries_in_memtable);
   ASSERT_EQ(entries_in_memtable, 0);
@@ -1809,15 +1863,15 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoMemtableFlush) {
   // No need for flush, this file keys fit between the memtable keys
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {202, 203, 204}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      verify_checksums_before_ingest, false, &true_data));
   db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                       &entries_in_memtable);
   ASSERT_GE(entries_in_memtable, 1);
 
   // This file will flush the memtable
   ASSERT_OK(GenerateAndAddExternalFile(
-      options, {206, 207}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, false, &true_data));
+      options, {206, 207}, -1, true, false, write_global_seqno,
+      verify_checksums_before_ingest, &true_data));
   db_->GetIntProperty(DB::Properties::kNumEntriesActiveMemTable,
                       &entries_in_memtable);
   ASSERT_EQ(entries_in_memtable, 0);
@@ -1838,13 +1892,13 @@ TEST_P(ExternalSSTFileTest, L0SortingIssue) {
   bool write_global_seqno = std::get<0>(GetParam());
   bool verify_checksums_before_ingest = std::get<1>(GetParam());
   // No Flush needed, No global seqno needed, Ingest in L1
-  ASSERT_OK(
-      GenerateAndAddExternalFile(options, {7, 8}, -1, true, write_global_seqno,
-                                 verify_checksums_before_ingest, false, false));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
+                                       write_global_seqno,
+                                       verify_checksums_before_ingest, false));
   // No Flush needed, but need a global seqno, Ingest in L0
-  ASSERT_OK(
-      GenerateAndAddExternalFile(options, {7, 8}, -1, true, write_global_seqno,
-                                 verify_checksums_before_ingest, false, false));
+  ASSERT_OK(GenerateAndAddExternalFile(options, {7, 8}, -1, true,
+                                       write_global_seqno,
+                                       verify_checksums_before_ingest, false));
   printf("%s\n", FilesPerLevel().c_str());
 
   // Overwrite what we added using external files
@@ -2085,7 +2139,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
   // Ingest into default cf
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[0]));
+      verify_checksums_before_ingest, true, nullptr, handles_[0]));
   ASSERT_EQ(listener->ingested_files.size(), 1);
   ASSERT_EQ(listener->ingested_files.back().cf_name, "default");
   ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2097,7 +2151,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
   // Ingest into cf1
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[1]));
+      verify_checksums_before_ingest, true, nullptr, handles_[1]));
   ASSERT_EQ(listener->ingested_files.size(), 2);
   ASSERT_EQ(listener->ingested_files.back().cf_name, "koko");
   ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2109,7 +2163,7 @@ TEST_P(ExternalSSTFileTest, IngestionListener) {
   // Ingest into cf2
   ASSERT_OK(GenerateAndAddExternalFile(
       options, {1, 2}, -1, true, write_global_seqno,
-      verify_checksums_before_ingest, false, true, nullptr, handles_[2]));
+      verify_checksums_before_ingest, true, nullptr, handles_[2]));
   ASSERT_EQ(listener->ingested_files.size(), 3);
   ASSERT_EQ(listener->ingested_files.back().cf_name, "toto");
   ASSERT_EQ(listener->ingested_files.back().global_seqno, 0);
@@ -2172,16 +2226,16 @@ TEST_P(ExternalSSTFileTest, IngestBehind) {
     file_data.emplace_back(Key(i), "ingest_behind");
   }
 
-  bool allow_global_seqno = true;
-  bool ingest_behind = true;
-  bool write_global_seqno = std::get<0>(GetParam());
-  bool verify_checksums_before_ingest = std::get<1>(GetParam());
+  IngestExternalFileOptions ifo;
+  ifo.allow_global_seqno = true;
+  ifo.ingest_behind = true;
+  ifo.write_global_seqno = std::get<0>(GetParam());
+  ifo.verify_checksums_before_ingest = std::get<1>(GetParam());
 
   // Can't ingest behind since allow_ingest_behind isn't set to true
-  ASSERT_NOK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, ingest_behind, false /*sort_data*/,
-      &true_data));
+  ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));
 
   options.allow_ingest_behind = true;
   // check that we still can open the DB, as num_levels should be
@@ -2199,16 +2253,14 @@ TEST_P(ExternalSSTFileTest, IngestBehind) {
   db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   // Universal picker should go at second from the bottom level
   ASSERT_EQ("0,1", FilesPerLevel());
-  ASSERT_OK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, true /*ingest_behind*/,
-      false /*sort_data*/, &true_data));
+  ASSERT_OK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));
   ASSERT_EQ("0,1,1", FilesPerLevel());
   // this time ingest should fail as the file doesn't fit to the bottom level
-  ASSERT_NOK(GenerateAndAddExternalFile(
-      options, file_data, -1, allow_global_seqno, write_global_seqno,
-      verify_checksums_before_ingest, true /*ingest_behind*/,
-      false /*sort_data*/, &true_data));
+  ASSERT_NOK(GenerateAndAddExternalFileIngestBehind(options, ifo,
+                                                   file_data, -1, false,
+                                                   &true_data));
   ASSERT_EQ("0,1,1", FilesPerLevel());
   db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   // bottom level should be empty

db/flush_job.cc

@@ -100,8 +100,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
                    Directory* output_file_directory,
                    CompressionType output_compression, Statistics* stats,
                    EventLogger* event_logger, bool measure_io_stats,
-                   const bool sync_output_directory, const bool write_manifest,
-                   Env::Priority thread_pri)
+                   const bool sync_output_directory, const bool write_manifest)
     : dbname_(dbname),
       cfd_(cfd),
       db_options_(db_options),
@@ -126,8 +125,7 @@ FlushJob::FlushJob(const std::string& dbname, ColumnFamilyData* cfd,
       write_manifest_(write_manifest),
       edit_(nullptr),
       base_(nullptr),
-      pick_memtable_called(false),
-      thread_pri_(thread_pri) {
+      pick_memtable_called(false) {
   // Update the thread status to indicate flush.
   ReportStartedFlush();
   TEST_SYNC_POINT("FlushJob::FlushJob()");
@@ -374,8 +372,7 @@ Status FlushJob::WriteLevel0Table() {
           cfd_->int_tbl_prop_collector_factories(), cfd_->GetID(),
           cfd_->GetName(), existing_snapshots_,
           earliest_write_conflict_snapshot_, snapshot_checker_,
-          output_compression_, mutable_cf_options_.sample_for_compression,
-          cfd_->ioptions()->compression_opts,
+          output_compression_, cfd_->ioptions()->compression_opts,
           mutable_cf_options_.paranoid_file_checks, cfd_->internal_stats(),
           TableFileCreationReason::kFlush, event_logger_, job_context_->job_id,
           Env::IO_HIGH, &table_properties_, 0 /* level */, current_time,
@@ -418,8 +415,8 @@ Status FlushJob::WriteLevel0Table() {
   stats.micros = db_options_.env->NowMicros() - start_micros;
   stats.cpu_micros = db_options_.env->NowCPUNanos() / 1000 - start_cpu_micros;
   stats.bytes_written = meta_.fd.GetFileSize();
-  RecordTimeToHistogram(stats_, FLUSH_TIME, stats.micros);
-  cfd_->internal_stats()->AddCompactionStats(0 /* level */, thread_pri_, stats);
+  MeasureTime(stats_, FLUSH_TIME, stats.micros);
+  cfd_->internal_stats()->AddCompactionStats(0 /* level */, stats);
   cfd_->internal_stats()->AddCFStats(InternalStats::BYTES_FLUSHED,
                                      meta_.fd.GetFileSize());
   RecordFlushIOStats();

db/flush_job.h

@@ -68,8 +68,7 @@ class FlushJob {
            LogBuffer* log_buffer, Directory* db_directory,
            Directory* output_file_directory, CompressionType output_compression,
            Statistics* stats, EventLogger* event_logger, bool measure_io_stats,
-           const bool sync_output_directory, const bool write_manifest,
-           Env::Priority thread_pri);
+           const bool sync_output_directory, const bool write_manifest);
 
   ~FlushJob();
 
@@ -138,7 +137,6 @@ class FlushJob {
   VersionEdit* edit_;
   Version* base_;
   bool pick_memtable_called;
-  Env::Priority thread_pri_;
 };
 
 }  // namespace rocksdb

db/flush_job_test.cc

@@ -118,14 +118,13 @@ TEST_F(FlushJobTest, Empty) {
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
   EventLogger event_logger(db_options_.info_log.get());
   SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, nullptr, &event_logger, false,
-                     true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, {},
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, nullptr, &event_logger, false,
+      true /* sync_output_directory */, true /* write_manifest */);
   {
     InstrumentedMutexLock l(&mutex_);
     flush_job.PickMemTable();
@@ -166,14 +165,13 @@ TEST_F(FlushJobTest, NonEmpty) {
 
   EventLogger event_logger(db_options_.info_log.get());
   SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, db_options_.statistics.get(),
-                     &event_logger, true, true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, {},
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, db_options_.statistics.get(), &event_logger,
+      true, true /* sync_output_directory */, true /* write_manifest */);
 
   HistogramData hist;
   FileMetaData file_meta;
@@ -230,14 +228,13 @@ TEST_F(FlushJobTest, FlushMemTablesSingleColumnFamily) {
   uint64_t smallest_memtable_id = memtable_ids.front();
   uint64_t flush_memtable_id = smallest_memtable_id + num_mems_to_flush - 1;
 
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     &flush_memtable_id, env_options_, versions_.get(), &mutex_,
-                     &shutting_down_, {}, kMaxSequenceNumber, snapshot_checker,
-                     &job_context, nullptr, nullptr, nullptr, kNoCompression,
-                     db_options_.statistics.get(), &event_logger, true,
-                     true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), &flush_memtable_id, env_options_,
+      versions_.get(), &mutex_, &shutting_down_, {}, kMaxSequenceNumber,
+      snapshot_checker, &job_context, nullptr, nullptr, nullptr, kNoCompression,
+      db_options_.statistics.get(), &event_logger, true,
+      true /* sync_output_directory */, true /* write_manifest */);
   HistogramData hist;
   FileMetaData file_meta;
   mutex_.Lock();
@@ -307,8 +304,7 @@ TEST_F(FlushJobTest, FlushMemtablesMultipleColumnFamilies) {
         &shutting_down_, snapshot_seqs, kMaxSequenceNumber, snapshot_checker,
         &job_context, nullptr, nullptr, nullptr, kNoCompression,
         db_options_.statistics.get(), &event_logger, true,
-        false /* sync_output_directory */, false /* write_manifest */,
-        Env::Priority::USER);
+        false /* sync_output_directory */, false /* write_manifest */);
     k++;
   }
   HistogramData hist;
@@ -417,14 +413,13 @@ TEST_F(FlushJobTest, Snapshots) {
 
   EventLogger event_logger(db_options_.info_log.get());
   SnapshotChecker* snapshot_checker = nullptr;  // not relavant
-  FlushJob flush_job(dbname_, versions_->GetColumnFamilySet()->GetDefault(),
-                     db_options_, *cfd->GetLatestMutableCFOptions(),
-                     nullptr /* memtable_id */, env_options_, versions_.get(),
-                     &mutex_, &shutting_down_, snapshots, kMaxSequenceNumber,
-                     snapshot_checker, &job_context, nullptr, nullptr, nullptr,
-                     kNoCompression, db_options_.statistics.get(),
-                     &event_logger, true, true /* sync_output_directory */,
-                     true /* write_manifest */, Env::Priority::USER);
+  FlushJob flush_job(
+      dbname_, versions_->GetColumnFamilySet()->GetDefault(), db_options_,
+      *cfd->GetLatestMutableCFOptions(), nullptr /* memtable_id */,
+      env_options_, versions_.get(), &mutex_, &shutting_down_, snapshots,
+      kMaxSequenceNumber, snapshot_checker, &job_context, nullptr, nullptr,
+      nullptr, kNoCompression, db_options_.statistics.get(), &event_logger,
+      true, true /* sync_output_directory */, true /* write_manifest */);
   mutex_.Lock();
   flush_job.PickMemTable();
   ASSERT_OK(flush_job.Run());

db/forward_iterator.cc

@@ -265,18 +265,16 @@ void ForwardIterator::SVCleanup() {
   if (sv_ == nullptr) {
     return;
   }
-  bool background_purge =
-      read_options_.background_purge_on_iterator_cleanup ||
-      db_->immutable_db_options().avoid_unnecessary_blocking_io;
   if (pinned_iters_mgr_ && pinned_iters_mgr_->PinningEnabled()) {
     // pinned_iters_mgr_ tells us to make sure that all visited key-value slices
     // are alive until pinned_iters_mgr_->ReleasePinnedData() is called.
     // The slices may point into some memtables owned by sv_, so we need to keep
     // sv_ referenced until pinned_iters_mgr_ unpins everything.
-    auto p = new SVCleanupParams{db_, sv_, background_purge};
+    auto p = new SVCleanupParams{
+      db_, sv_, read_options_.background_purge_on_iterator_cleanup};
     pinned_iters_mgr_->PinPtr(p, &ForwardIterator::DeferredSVCleanup);
   } else {
-    SVCleanup(db_, sv_, background_purge);
+    SVCleanup(db_, sv_, read_options_.background_purge_on_iterator_cleanup);
   }
 }
 

db/internal_stats.cc

@@ -58,8 +58,7 @@ const double kMB = 1048576.0;
 const double kGB = kMB * 1024;
 const double kMicrosInSec = 1000000.0;
 
-void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name,
-                           const std::string& group_by) {
+void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
   int written_size =
       snprintf(buf, len, "\n** Compaction Stats [%s] **\n", cf_name.c_str());
   auto hdr = [](LevelStatType t) {
@@ -67,18 +66,17 @@ void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name,
   };
   int line_size = snprintf(
       buf + written_size, len - written_size,
-      "%s    %s   %s     %s %s  %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
+      "Level    %s   %s     %s %s  %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
       // Note that we skip COMPACTED_FILES and merge it with Files column
-      group_by.c_str(), hdr(LevelStatType::NUM_FILES),
-      hdr(LevelStatType::SIZE_BYTES), hdr(LevelStatType::SCORE),
-      hdr(LevelStatType::READ_GB), hdr(LevelStatType::RN_GB),
-      hdr(LevelStatType::RNP1_GB), hdr(LevelStatType::WRITE_GB),
-      hdr(LevelStatType::W_NEW_GB), hdr(LevelStatType::MOVED_GB),
-      hdr(LevelStatType::WRITE_AMP), hdr(LevelStatType::READ_MBPS),
-      hdr(LevelStatType::WRITE_MBPS), hdr(LevelStatType::COMP_SEC),
-      hdr(LevelStatType::COMP_CPU_SEC), hdr(LevelStatType::COMP_COUNT),
-      hdr(LevelStatType::AVG_SEC), hdr(LevelStatType::KEY_IN),
-      hdr(LevelStatType::KEY_DROP));
+      hdr(LevelStatType::NUM_FILES), hdr(LevelStatType::SIZE_BYTES),
+      hdr(LevelStatType::SCORE), hdr(LevelStatType::READ_GB),
+      hdr(LevelStatType::RN_GB), hdr(LevelStatType::RNP1_GB),
+      hdr(LevelStatType::WRITE_GB), hdr(LevelStatType::W_NEW_GB),
+      hdr(LevelStatType::MOVED_GB), hdr(LevelStatType::WRITE_AMP),
+      hdr(LevelStatType::READ_MBPS), hdr(LevelStatType::WRITE_MBPS),
+      hdr(LevelStatType::COMP_SEC), hdr(LevelStatType::COMP_CPU_SEC),
+      hdr(LevelStatType::COMP_COUNT), hdr(LevelStatType::AVG_SEC),
+      hdr(LevelStatType::KEY_IN), hdr(LevelStatType::KEY_DROP));
 
   written_size += line_size;
   snprintf(buf + written_size, len - written_size, "%s\n",
@@ -1154,20 +1152,6 @@ void InternalStats::DumpCFMapStats(
   (*levels_stats)[-1] = sum_stats;  //  -1 is for the Sum level
 }
 
-void InternalStats::DumpCFMapStatsByPriority(
-    std::map<int, std::map<LevelStatType, double>>* priorities_stats) {
-  for (size_t priority = 0; priority < comp_stats_by_pri_.size(); priority++) {
-    if (comp_stats_by_pri_[priority].micros > 0) {
-      std::map<LevelStatType, double> priority_stats;
-      PrepareLevelStats(&priority_stats, 0 /* num_files */,
-                        0 /* being_compacted */, 0 /* total_file_size */,
-                        0 /* compaction_score */, 0 /* w_amp */,
-                        comp_stats_by_pri_[priority]);
-      (*priorities_stats)[static_cast<int>(priority)] = priority_stats;
-    }
-  }
-}
-
 void InternalStats::DumpCFMapStatsIOStalls(
     std::map<std::string, std::string>* cf_stats) {
   (*cf_stats)["io_stalls.level0_slowdown"] =
@@ -1208,7 +1192,7 @@ void InternalStats::DumpCFStats(std::string* value) {
 void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
   char buf[2000];
   // Per-ColumnFamily stats
-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName(), "Level");
+  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
   value->append(buf);
 
   // Print stats for each level
@@ -1254,21 +1238,6 @@ void InternalStats::DumpCFStatsNoFileHistogram(std::string* value) {
   PrintLevelStats(buf, sizeof(buf), "Int", 0, 0, 0, 0, w_amp, interval_stats);
   value->append(buf);
 
-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName(), "Priority");
-  value->append(buf);
-  std::map<int, std::map<LevelStatType, double>> priorities_stats;
-  DumpCFMapStatsByPriority(&priorities_stats);
-  for (size_t priority = 0; priority < comp_stats_by_pri_.size(); ++priority) {
-    if (priorities_stats.find(static_cast<int>(priority)) !=
-        priorities_stats.end()) {
-      PrintLevelStats(
-          buf, sizeof(buf),
-          Env::PriorityToString(static_cast<Env::Priority>(priority)),
-          priorities_stats[static_cast<int>(priority)]);
-      value->append(buf);
-    }
-  }
-
   double seconds_up = (env_->NowMicros() - started_at_ + 1) / kMicrosInSec;
   double interval_seconds_up = seconds_up - cf_stats_snapshot_.seconds_up;
   snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",

db/internal_stats.h

@@ -125,7 +125,6 @@ class InternalStats {
         cf_stats_value_{},
         cf_stats_count_{},
         comp_stats_(num_levels),
-        comp_stats_by_pri_(Env::Priority::TOTAL),
         file_read_latency_(num_levels),
         bg_error_count_(0),
         number_levels_(num_levels),
@@ -319,10 +318,8 @@ class InternalStats {
     started_at_ = env_->NowMicros();
   }
 
-  void AddCompactionStats(int level, Env::Priority thread_pri,
-                          const CompactionStats& stats) {
+  void AddCompactionStats(int level, const CompactionStats& stats) {
     comp_stats_[level].Add(stats);
-    comp_stats_by_pri_[thread_pri].Add(stats);
   }
 
   void IncBytesMoved(int level, uint64_t amount) {
@@ -384,8 +381,6 @@ class InternalStats {
   void DumpCFMapStats(
       std::map<int, std::map<LevelStatType, double>>* level_stats,
       CompactionStats* compaction_stats_sum);
-  void DumpCFMapStatsByPriority(
-      std::map<int, std::map<LevelStatType, double>>* priorities_stats);
   void DumpCFMapStatsIOStalls(std::map<std::string, std::string>* cf_stats);
   void DumpCFStats(std::string* value);
   void DumpCFStatsNoFileHistogram(std::string* value);
@@ -400,7 +395,6 @@ class InternalStats {
   uint64_t cf_stats_count_[INTERNAL_CF_STATS_ENUM_MAX];
   // Per-ColumnFamily/level compaction stats
   std::vector<CompactionStats> comp_stats_;
-  std::vector<CompactionStats> comp_stats_by_pri_;
   std::vector<HistogramImpl> file_read_latency_;
 
   // Used to compute per-interval statistics
@@ -631,8 +625,7 @@ class InternalStats {
     void Subtract(const CompactionStats& /*c*/) {}
   };
 
-  void AddCompactionStats(int /*level*/, Env::Priority /*thread_pri*/,
-                          const CompactionStats& /*stats*/) {}
+  void AddCompactionStats(int /*level*/, const CompactionStats& /*stats*/) {}
 
   void IncBytesMoved(int /*level*/, uint64_t /*amount*/) {}
 

db/log_reader.cc

@@ -24,7 +24,8 @@ Reader::Reporter::~Reporter() {
 
 Reader::Reader(std::shared_ptr<Logger> info_log,
                std::unique_ptr<SequentialFileReader>&& _file,
-               Reporter* reporter, bool checksum, uint64_t log_num)
+               Reporter* reporter, bool checksum, uint64_t log_num,
+               bool retry_after_eof)
     : info_log_(info_log),
       file_(std::move(_file)),
       reporter_(reporter),
@@ -37,7 +38,8 @@ Reader::Reader(std::shared_ptr<Logger> info_log,
       last_record_offset_(0),
       end_of_buffer_offset_(0),
       log_number_(log_num),
-      recycled_(false) {}
+      recycled_(false),
+      retry_after_eof_(retry_after_eof) {}
 
 Reader::~Reader() {
   delete[] backing_store_;
@@ -205,14 +207,14 @@ void Reader::UnmarkEOF() {
   if (read_error_) {
     return;
   }
+
   eof_ = false;
-  if (eof_offset_ == 0) {
+
+  // If retry_after_eof_ is true, we have to proceed to read anyway.
+  if (!retry_after_eof_ && eof_offset_ == 0) {
     return;
   }
-  UnmarkEOFInternal();
-}
 
-void Reader::UnmarkEOFInternal() {
   // If the EOF was in the middle of a block (a partial block was read) we have
   // to read the rest of the block as ReadPhysicalRecord can only read full
   // blocks and expects the file position indicator to be aligned to the start
@@ -290,8 +292,12 @@ bool Reader::ReadMore(size_t* drop_size, int *error) {
     } else if (buffer_.size() < static_cast<size_t>(kBlockSize)) {
       eof_ = true;
       eof_offset_ = buffer_.size();
+      TEST_SYNC_POINT("LogReader::ReadMore:FirstEOF");
     }
     return true;
+  } else if (retry_after_eof_ && !read_error_) {
+    UnmarkEOF();
+    return !read_error_;
   } else {
     // Note that if buffer_ is non-empty, we have a truncated header at the
     //  end of the file, which can be caused by the writer crashing in the
@@ -349,16 +355,24 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size) {
       }
     }
     if (header_size + length > buffer_.size()) {
-      *drop_size = buffer_.size();
-      buffer_.clear();
-      if (!eof_) {
-        return kBadRecordLen;
-      }
-      // If the end of the file has been reached without reading |length|
-      // bytes of payload, assume the writer died in the middle of writing the
-      // record. Don't report a corruption unless requested.
-      if (*drop_size) {
-        return kBadHeader;
+      if (!retry_after_eof_) {
+        *drop_size = buffer_.size();
+        buffer_.clear();
+        if (!eof_) {
+          return kBadRecordLen;
+        }
+        // If the end of the file has been reached without reading |length|
+        // bytes of payload, assume the writer died in the middle of writing the
+        // record. Don't report a corruption unless requested.
+        if (*drop_size) {
+          return kBadHeader;
+        }
+      } else {
+        int r = kEof;
+        if (!ReadMore(drop_size, &r)) {
+          return r;
+        }
+        continue;
       }
       return kEof;
     }
@@ -395,229 +409,5 @@ unsigned int Reader::ReadPhysicalRecord(Slice* result, size_t* drop_size) {
   }
 }
 
-bool FragmentBufferedReader::ReadRecord(Slice* record, std::string* scratch,
-                                        WALRecoveryMode /*unused*/) {
-  assert(record != nullptr);
-  assert(scratch != nullptr);
-  record->clear();
-  scratch->clear();
-
-  uint64_t prospective_record_offset = 0;
-  uint64_t physical_record_offset = end_of_buffer_offset_ - buffer_.size();
-  size_t drop_size = 0;
-  unsigned int fragment_type_or_err = 0;  // Initialize to make compiler happy
-  Slice fragment;
-  while (TryReadFragment(&fragment, &drop_size, &fragment_type_or_err)) {
-    switch (fragment_type_or_err) {
-      case kFullType:
-      case kRecyclableFullType:
-        if (in_fragmented_record_ && !fragments_.empty()) {
-          ReportCorruption(fragments_.size(), "partial record without end(1)");
-        }
-        fragments_.clear();
-        *record = fragment;
-        prospective_record_offset = physical_record_offset;
-        last_record_offset_ = prospective_record_offset;
-        in_fragmented_record_ = false;
-        return true;
-
-      case kFirstType:
-      case kRecyclableFirstType:
-        if (in_fragmented_record_ || !fragments_.empty()) {
-          ReportCorruption(fragments_.size(), "partial record without end(2)");
-        }
-        prospective_record_offset = physical_record_offset;
-        fragments_.assign(fragment.data(), fragment.size());
-        in_fragmented_record_ = true;
-        break;
-
-      case kMiddleType:
-      case kRecyclableMiddleType:
-        if (!in_fragmented_record_) {
-          ReportCorruption(fragment.size(),
-                           "missing start of fragmented record(1)");
-        } else {
-          fragments_.append(fragment.data(), fragment.size());
-        }
-        break;
-
-      case kLastType:
-      case kRecyclableLastType:
-        if (!in_fragmented_record_) {
-          ReportCorruption(fragment.size(),
-                           "missing start of fragmented record(2)");
-        } else {
-          fragments_.append(fragment.data(), fragment.size());
-          scratch->assign(fragments_.data(), fragments_.size());
-          fragments_.clear();
-          *record = Slice(*scratch);
-          last_record_offset_ = prospective_record_offset;
-          in_fragmented_record_ = false;
-          return true;
-        }
-        break;
-
-      case kBadHeader:
-      case kBadRecord:
-      case kEof:
-      case kOldRecord:
-        if (in_fragmented_record_) {
-          ReportCorruption(fragments_.size(), "error in middle of record");
-          in_fragmented_record_ = false;
-          fragments_.clear();
-        }
-        break;
-
-      case kBadRecordChecksum:
-        if (recycled_) {
-          fragments_.clear();
-          return false;
-        }
-        ReportCorruption(drop_size, "checksum mismatch");
-        if (in_fragmented_record_) {
-          ReportCorruption(fragments_.size(), "error in middle of record");
-          in_fragmented_record_ = false;
-          fragments_.clear();
-        }
-        break;
-
-      default: {
-        char buf[40];
-        snprintf(buf, sizeof(buf), "unknown record type %u",
-                 fragment_type_or_err);
-        ReportCorruption(
-            fragment.size() + (in_fragmented_record_ ? fragments_.size() : 0),
-            buf);
-        in_fragmented_record_ = false;
-        fragments_.clear();
-        break;
-      }
-    }
-  }
-  return false;
-}
-
-void FragmentBufferedReader::UnmarkEOF() {
-  if (read_error_) {
-    return;
-  }
-  eof_ = false;
-  UnmarkEOFInternal();
-}
-
-bool FragmentBufferedReader::TryReadMore(size_t* drop_size, int* error) {
-  if (!eof_ && !read_error_) {
-    // Last read was a full read, so this is a trailer to skip
-    buffer_.clear();
-    Status status = file_->Read(kBlockSize, &buffer_, backing_store_);
-    end_of_buffer_offset_ += buffer_.size();
-    if (!status.ok()) {
-      buffer_.clear();
-      ReportDrop(kBlockSize, status);
-      read_error_ = true;
-      *error = kEof;
-      return false;
-    } else if (buffer_.size() < static_cast<size_t>(kBlockSize)) {
-      eof_ = true;
-      eof_offset_ = buffer_.size();
-      TEST_SYNC_POINT_CALLBACK(
-          "FragmentBufferedLogReader::TryReadMore:FirstEOF", nullptr);
-    }
-    return true;
-  } else if (!read_error_) {
-    UnmarkEOF();
-  }
-  if (!read_error_) {
-    return true;
-  }
-  *error = kEof;
-  *drop_size = buffer_.size();
-  if (buffer_.size() > 0) {
-    *error = kBadHeader;
-  }
-  buffer_.clear();
-  return false;
-}
-
-// return true if the caller should process the fragment_type_or_err.
-bool FragmentBufferedReader::TryReadFragment(
-    Slice* fragment, size_t* drop_size, unsigned int* fragment_type_or_err) {
-  assert(fragment != nullptr);
-  assert(drop_size != nullptr);
-  assert(fragment_type_or_err != nullptr);
-
-  while (buffer_.size() < static_cast<size_t>(kHeaderSize)) {
-    size_t old_size = buffer_.size();
-    int error = kEof;
-    if (!TryReadMore(drop_size, &error)) {
-      *fragment_type_or_err = error;
-      return false;
-    } else if (old_size == buffer_.size()) {
-      return false;
-    }
-  }
-  const char* header = buffer_.data();
-  const uint32_t a = static_cast<uint32_t>(header[4]) & 0xff;
-  const uint32_t b = static_cast<uint32_t>(header[5]) & 0xff;
-  const unsigned int type = header[6];
-  const uint32_t length = a | (b << 8);
-  int header_size = kHeaderSize;
-  if (type >= kRecyclableFullType && type <= kRecyclableLastType) {
-    if (end_of_buffer_offset_ - buffer_.size() == 0) {
-      recycled_ = true;
-    }
-    header_size = kRecyclableHeaderSize;
-    while (buffer_.size() < static_cast<size_t>(kRecyclableHeaderSize)) {
-      size_t old_size = buffer_.size();
-      int error = kEof;
-      if (!TryReadMore(drop_size, &error)) {
-        *fragment_type_or_err = error;
-        return false;
-      } else if (old_size == buffer_.size()) {
-        return false;
-      }
-    }
-    const uint32_t log_num = DecodeFixed32(header + 7);
-    if (log_num != log_number_) {
-      *fragment_type_or_err = kOldRecord;
-      return true;
-    }
-  }
-
-  while (header_size + length > buffer_.size()) {
-    size_t old_size = buffer_.size();
-    int error = kEof;
-    if (!TryReadMore(drop_size, &error)) {
-      *fragment_type_or_err = error;
-      return false;
-    } else if (old_size == buffer_.size()) {
-      return false;
-    }
-  }
-
-  if (type == kZeroType && length == 0) {
-    buffer_.clear();
-    *fragment_type_or_err = kBadRecord;
-    return true;
-  }
-
-  if (checksum_) {
-    uint32_t expected_crc = crc32c::Unmask(DecodeFixed32(header));
-    uint32_t actual_crc = crc32c::Value(header + 6, length + header_size - 6);
-    if (actual_crc != expected_crc) {
-      *drop_size = buffer_.size();
-      buffer_.clear();
-      *fragment_type_or_err = kBadRecordChecksum;
-      return true;
-    }
-  }
-
-  buffer_.remove_prefix(header_size + length);
-
-  *fragment = Slice(header + header_size, length);
-  *fragment_type_or_err = type;
-  return true;
-}
-
 }  // namespace log
 }  // namespace rocksdb

db/log_reader.h

@@ -20,6 +20,7 @@ namespace rocksdb {
 
 class SequentialFileReader;
 class Logger;
+using std::unique_ptr;
 
 namespace log {
 
@@ -52,18 +53,18 @@ class Reader {
   Reader(std::shared_ptr<Logger> info_log,
          // @lint-ignore TXT2 T25377293 Grandfathered in
          std::unique_ptr<SequentialFileReader>&& file, Reporter* reporter,
-         bool checksum, uint64_t log_num);
+         bool checksum, uint64_t log_num, bool retry_after_eof);
 
-  virtual ~Reader();
+  ~Reader();
 
   // Read the next record into *record.  Returns true if read
   // successfully, false if we hit end of the input.  May use
   // "*scratch" as temporary storage.  The contents filled in *record
   // will only be valid until the next mutating operation on this
   // reader or the next mutation to *scratch.
-  virtual bool ReadRecord(Slice* record, std::string* scratch,
-                          WALRecoveryMode wal_recovery_mode =
-                              WALRecoveryMode::kTolerateCorruptedTailRecords);
+  bool ReadRecord(Slice* record, std::string* scratch,
+                  WALRecoveryMode wal_recovery_mode =
+                      WALRecoveryMode::kTolerateCorruptedTailRecords);
 
   // Returns the physical offset of the last record returned by ReadRecord.
   //
@@ -75,28 +76,21 @@ class Reader {
     return eof_;
   }
 
-  // returns true if the reader has encountered read error.
-  bool hasReadError() const { return read_error_; }
-
   // when we know more data has been written to the file. we can use this
   // function to force the reader to look again in the file.
   // Also aligns the file position indicator to the start of the next block
   // by reading the rest of the data from the EOF position to the end of the
   // block that was partially read.
-  virtual void UnmarkEOF();
+  void UnmarkEOF();
 
   SequentialFileReader* file() { return file_.get(); }
 
-  Reporter* GetReporter() const { return reporter_; }
-
- protected:
+ private:
   std::shared_ptr<Logger> info_log_;
   const std::unique_ptr<SequentialFileReader> file_;
   Reporter* const reporter_;
   bool const checksum_;
   char* const backing_store_;
-
-  // Internal state variables used for reading records
   Slice buffer_;
   bool eof_;   // Last Read() indicated EOF by returning < kBlockSize
   bool read_error_;   // Error occurred while reading from file
@@ -116,6 +110,11 @@ class Reader {
   // Whether this is a recycled log file
   bool recycled_;
 
+  // Whether retry after encountering EOF
+  // TODO (yanqin) add support for retry policy, e.g. sleep, max retry limit,
+  // etc.
+  const bool retry_after_eof_;
+
   // Extend record types with the following special values
   enum {
     kEof = kMaxRecordType + 1,
@@ -140,47 +139,15 @@ class Reader {
   // Read some more
   bool ReadMore(size_t* drop_size, int *error);
 
-  void UnmarkEOFInternal();
-
   // Reports dropped bytes to the reporter.
   // buffer_ must be updated to remove the dropped bytes prior to invocation.
   void ReportCorruption(size_t bytes, const char* reason);
   void ReportDrop(size_t bytes, const Status& reason);
 
- private:
   // No copying allowed
   Reader(const Reader&);
   void operator=(const Reader&);
 };
 
-class FragmentBufferedReader : public Reader {
- public:
-  FragmentBufferedReader(std::shared_ptr<Logger> info_log,
-                         // @lint-ignore TXT2 T25377293 Grandfathered in
-                         std::unique_ptr<SequentialFileReader>&& _file,
-                         Reporter* reporter, bool checksum, uint64_t log_num)
-      : Reader(info_log, std::move(_file), reporter, checksum, log_num),
-        fragments_(),
-        in_fragmented_record_(false) {}
-  ~FragmentBufferedReader() override {}
-  bool ReadRecord(Slice* record, std::string* scratch,
-                  WALRecoveryMode wal_recovery_mode =
-                      WALRecoveryMode::kTolerateCorruptedTailRecords) override;
-  void UnmarkEOF() override;
-
- private:
-  std::string fragments_;
-  bool in_fragmented_record_;
-
-  bool TryReadFragment(Slice* result, size_t* drop_size,
-                       unsigned int* fragment_type_or_err);
-
-  bool TryReadMore(size_t* drop_size, int* error);
-
-  // No copy allowed
-  FragmentBufferedReader(const FragmentBufferedReader&);
-  void operator=(const FragmentBufferedReader&);
-};
-
 }  // namespace log
 }  // namespace rocksdb

db/log_test.cc

@@ -43,10 +43,7 @@ static std::string RandomSkewedString(int i, Random* rnd) {
   return BigString(NumberString(i), rnd->Skewed(17));
 }
 
-// Param type is tuple<int, bool>
-// get<0>(tuple): non-zero if recycling log, zero if regular log
-// get<1>(tuple): true if allow retry after read EOF, false otherwise
-class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
+class LogTest : public ::testing::TestWithParam<int> {
  private:
   class StringSource : public SequentialFile {
    public:
@@ -56,20 +53,16 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
     bool force_eof_;
     size_t force_eof_position_;
     bool returned_partial_;
-    bool fail_after_read_partial_;
-    explicit StringSource(Slice& contents, bool fail_after_read_partial)
-        : contents_(contents),
-          force_error_(false),
-          force_error_position_(0),
-          force_eof_(false),
-          force_eof_position_(0),
-          returned_partial_(false),
-          fail_after_read_partial_(fail_after_read_partial) {}
+    explicit StringSource(Slice& contents) :
+      contents_(contents),
+      force_error_(false),
+      force_error_position_(0),
+      force_eof_(false),
+      force_eof_position_(0),
+      returned_partial_(false) { }
 
     Status Read(size_t n, Slice* result, char* scratch) override {
-      if (fail_after_read_partial_) {
-        EXPECT_TRUE(!returned_partial_) << "must not Read() after eof/error";
-      }
+      EXPECT_TRUE(!returned_partial_) << "must not Read() after eof/error";
 
       if (force_error_) {
         if (force_error_position_ >= n) {
@@ -146,7 +139,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
   }
 
   void reset_source_contents() {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
     assert(src);
     src->contents_ = dest_contents();
   }
@@ -156,10 +149,11 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
   std::unique_ptr<SequentialFileReader> source_holder_;
   ReportCollector report_;
   Writer writer_;
-  std::unique_ptr<Reader> reader_;
+  Reader reader_;
 
- protected:
-  bool allow_retry_read_;
+  // Record metadata for testing initial offset functionality
+  static size_t initial_offset_record_sizes_[];
+  uint64_t initial_offset_last_record_offsets_[4];
 
  public:
   LogTest()
@@ -167,18 +161,18 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
         dest_holder_(test::GetWritableFileWriter(
             new test::StringSink(&reader_contents_), "" /* don't care */)),
         source_holder_(test::GetSequentialFileReader(
-            new StringSource(reader_contents_, !std::get<1>(GetParam())),
-            "" /* file name */)),
-        writer_(std::move(dest_holder_), 123, std::get<0>(GetParam())),
-        allow_retry_read_(std::get<1>(GetParam())) {
-    if (allow_retry_read_) {
-      reader_.reset(new FragmentBufferedReader(
-          nullptr, std::move(source_holder_), &report_, true /* checksum */,
-          123 /* log_number */));
-    } else {
-      reader_.reset(new Reader(nullptr, std::move(source_holder_), &report_,
-                               true /* checksum */, 123 /* log_number */));
-    }
+            new StringSource(reader_contents_), "" /* file name */)),
+        writer_(std::move(dest_holder_), 123, GetParam()),
+        reader_(nullptr, std::move(source_holder_), &report_,
+                true /* checksum */, 123 /* log_number */,
+                false /* retry_after_eof */) {
+    int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
+    initial_offset_last_record_offsets_[0] = 0;
+    initial_offset_last_record_offsets_[1] = header_size + 10000;
+    initial_offset_last_record_offsets_[2] = 2 * (header_size + 10000);
+    initial_offset_last_record_offsets_[3] = 2 * (header_size + 10000) +
+                                             (2 * log::kBlockSize - 1000) +
+                                             3 * header_size;
   }
 
   Slice* get_reader_contents() { return &reader_contents_; }
@@ -195,9 +189,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
                        WALRecoveryMode::kTolerateCorruptedTailRecords) {
     std::string scratch;
     Slice record;
-    bool ret = false;
-    ret = reader_->ReadRecord(&record, &scratch, wal_recovery_mode);
-    if (ret) {
+    if (reader_.ReadRecord(&record, &scratch, wal_recovery_mode)) {
       return record.ToString();
     } else {
       return "EOF";
@@ -229,7 +221,7 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
   }
 
   void ForceError(size_t position = 0) {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
     src->force_error_ = true;
     src->force_error_position_ = position;
   }
@@ -243,18 +235,20 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
   }
 
   void ForceEOF(size_t position = 0) {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
     src->force_eof_ = true;
     src->force_eof_position_ = position;
   }
 
   void UnmarkEOF() {
-    auto src = dynamic_cast<StringSource*>(reader_->file()->file());
+    auto src = dynamic_cast<StringSource*>(reader_.file()->file());
     src->returned_partial_ = false;
-    reader_->UnmarkEOF();
+    reader_.UnmarkEOF();
   }
 
-  bool IsEOF() { return reader_->IsEOF(); }
+  bool IsEOF() {
+    return reader_.IsEOF();
+  }
 
   // Returns OK iff recorded error message contains "msg"
   std::string MatchError(const std::string& msg) const {
@@ -264,8 +258,23 @@ class LogTest : public ::testing::TestWithParam<std::tuple<int, bool>> {
       return "OK";
     }
   }
+
+  void WriteInitialOffsetLog() {
+    for (int i = 0; i < 4; i++) {
+      std::string record(initial_offset_record_sizes_[i],
+                         static_cast<char>('a' + i));
+      Write(record);
+    }
+  }
+
 };
 
+size_t LogTest::initial_offset_record_sizes_[] =
+    {10000,  // Two sizable records in first block
+     10000,
+     2 * log::kBlockSize - 1000,  // Span three blocks
+     1};
+
 TEST_P(LogTest, Empty) { ASSERT_EQ("EOF", Read()); }
 
 TEST_P(LogTest, ReadWrite) {
@@ -303,8 +312,7 @@ TEST_P(LogTest, Fragmentation) {
 
 TEST_P(LogTest, MarginalTrailer) {
   // Make a trailer that is exactly the same length as an empty record.
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   const int n = kBlockSize - 2 * header_size;
   Write(BigString("foo", n));
   ASSERT_EQ((unsigned int)(kBlockSize - header_size), WrittenBytes());
@@ -318,8 +326,7 @@ TEST_P(LogTest, MarginalTrailer) {
 
 TEST_P(LogTest, MarginalTrailer2) {
   // Make a trailer that is exactly the same length as an empty record.
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   const int n = kBlockSize - 2 * header_size;
   Write(BigString("foo", n));
   ASSERT_EQ((unsigned int)(kBlockSize - header_size), WrittenBytes());
@@ -332,8 +339,7 @@ TEST_P(LogTest, MarginalTrailer2) {
 }
 
 TEST_P(LogTest, ShortTrailer) {
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   const int n = kBlockSize - 2 * header_size + 4;
   Write(BigString("foo", n));
   ASSERT_EQ((unsigned int)(kBlockSize - header_size + 4), WrittenBytes());
@@ -346,8 +352,7 @@ TEST_P(LogTest, ShortTrailer) {
 }
 
 TEST_P(LogTest, AlignedEof) {
-  int header_size =
-      std::get<0>(GetParam()) ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   const int n = kBlockSize - 2 * header_size + 4;
   Write(BigString("foo", n));
   ASSERT_EQ((unsigned int)(kBlockSize - header_size + 4), WrittenBytes());
@@ -398,11 +403,6 @@ TEST_P(LogTest, TruncatedTrailingRecordIsIgnored) {
 }
 
 TEST_P(LogTest, TruncatedTrailingRecordIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
   Write("foo");
   ShrinkSize(4);  // Drop all payload as well as a header byte
   ASSERT_EQ("EOF", Read(WALRecoveryMode::kAbsoluteConsistency));
@@ -412,20 +412,13 @@ TEST_P(LogTest, TruncatedTrailingRecordIsNotIgnored) {
 }
 
 TEST_P(LogTest, BadLength) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   const int kPayloadSize = kBlockSize - header_size;
   Write(BigString("bar", kPayloadSize));
   Write("foo");
   // Least significant size byte is stored in header[4].
   IncrementByte(4, 1);
-  if (!recyclable_log) {
+  if (!GetParam()) {
     ASSERT_EQ("foo", Read());
     ASSERT_EQ(kBlockSize, DroppedBytes());
     ASSERT_EQ("OK", MatchError("bad record length"));
@@ -435,12 +428,6 @@ TEST_P(LogTest, BadLength) {
 }
 
 TEST_P(LogTest, BadLengthAtEndIsIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
   Write("foo");
   ShrinkSize(1);
   ASSERT_EQ("EOF", Read());
@@ -449,12 +436,6 @@ TEST_P(LogTest, BadLengthAtEndIsIgnored) {
 }
 
 TEST_P(LogTest, BadLengthAtEndIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then we should not raise an error when the
-    // record length specified in header is longer than data currently
-    // available. It's possible that the body of the record is not written yet.
-    return;
-  }
   Write("foo");
   ShrinkSize(1);
   ASSERT_EQ("EOF", Read(WALRecoveryMode::kAbsoluteConsistency));
@@ -466,8 +447,7 @@ TEST_P(LogTest, ChecksumMismatch) {
   Write("foooooo");
   IncrementByte(0, 14);
   ASSERT_EQ("EOF", Read());
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
     ASSERT_EQ(14U, DroppedBytes());
     ASSERT_EQ("OK", MatchError("checksum mismatch"));
   } else {
@@ -478,10 +458,8 @@ TEST_P(LogTest, ChecksumMismatch) {
 
 TEST_P(LogTest, UnexpectedMiddleType) {
   Write("foo");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(6, static_cast<char>(recyclable_log ? kRecyclableMiddleType
-                                              : kMiddleType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableMiddleType : kMiddleType));
+  FixChecksum(0, 3, !!GetParam());
   ASSERT_EQ("EOF", Read());
   ASSERT_EQ(3U, DroppedBytes());
   ASSERT_EQ("OK", MatchError("missing start"));
@@ -489,10 +467,8 @@ TEST_P(LogTest, UnexpectedMiddleType) {
 
 TEST_P(LogTest, UnexpectedLastType) {
   Write("foo");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(6,
-          static_cast<char>(recyclable_log ? kRecyclableLastType : kLastType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableLastType : kLastType));
+  FixChecksum(0, 3, !!GetParam());
   ASSERT_EQ("EOF", Read());
   ASSERT_EQ(3U, DroppedBytes());
   ASSERT_EQ("OK", MatchError("missing start"));
@@ -501,10 +477,8 @@ TEST_P(LogTest, UnexpectedLastType) {
 TEST_P(LogTest, UnexpectedFullType) {
   Write("foo");
   Write("bar");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(
-      6, static_cast<char>(recyclable_log ? kRecyclableFirstType : kFirstType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  FixChecksum(0, 3, !!GetParam());
   ASSERT_EQ("bar", Read());
   ASSERT_EQ("EOF", Read());
   ASSERT_EQ(3U, DroppedBytes());
@@ -514,10 +488,8 @@ TEST_P(LogTest, UnexpectedFullType) {
 TEST_P(LogTest, UnexpectedFirstType) {
   Write("foo");
   Write(BigString("bar", 100000));
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  SetByte(
-      6, static_cast<char>(recyclable_log ? kRecyclableFirstType : kFirstType));
-  FixChecksum(0, 3, !!recyclable_log);
+  SetByte(6, static_cast<char>(GetParam() ? kRecyclableFirstType : kFirstType));
+  FixChecksum(0, 3, !!GetParam());
   ASSERT_EQ(BigString("bar", 100000), Read());
   ASSERT_EQ("EOF", Read());
   ASSERT_EQ(3U, DroppedBytes());
@@ -534,11 +506,6 @@ TEST_P(LogTest, MissingLastIsIgnored) {
 }
 
 TEST_P(LogTest, MissingLastIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
   Write(BigString("bar", kBlockSize));
   // Remove the LAST block, including header.
   ShrinkSize(14);
@@ -557,11 +524,6 @@ TEST_P(LogTest, PartialLastIsIgnored) {
 }
 
 TEST_P(LogTest, PartialLastIsNotIgnored) {
-  if (allow_retry_read_) {
-    // If read retry is allowed, then truncated trailing record should not
-    // raise an error.
-    return;
-  }
   Write(BigString("bar", kBlockSize));
   // Cause a bad record length in the LAST block.
   ShrinkSize(1);
@@ -588,8 +550,7 @@ TEST_P(LogTest, ErrorJoinsRecords) {
     SetByte(offset, 'x');
   }
 
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
     ASSERT_EQ("correct", Read());
     ASSERT_EQ("EOF", Read());
     size_t dropped = DroppedBytes();
@@ -603,8 +564,7 @@ TEST_P(LogTest, ErrorJoinsRecords) {
 TEST_P(LogTest, ClearEofSingleBlock) {
   Write("foo");
   Write("bar");
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   ForceEOF(3 + header_size + 2);
   ASSERT_EQ("foo", Read());
   UnmarkEOF();
@@ -619,8 +579,7 @@ TEST_P(LogTest, ClearEofSingleBlock) {
 
 TEST_P(LogTest, ClearEofMultiBlock) {
   size_t num_full_blocks = 5;
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  int header_size = recyclable_log ? kRecyclableHeaderSize : kHeaderSize;
+  int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
   size_t n = (kBlockSize - header_size) * num_full_blocks + 25;
   Write(BigString("foo", n));
   Write(BigString("bar", n));
@@ -669,8 +628,7 @@ TEST_P(LogTest, ClearEofError2) {
 }
 
 TEST_P(LogTest, Recycle) {
-  bool recyclable_log = (std::get<0>(GetParam()) != 0);
-  if (!recyclable_log) {
+  if (!GetParam()) {
     return;  // test is only valid for recycled logs
   }
   Write("foo");
@@ -693,11 +651,7 @@ TEST_P(LogTest, Recycle) {
   ASSERT_EQ("EOF", Read());
 }
 
-INSTANTIATE_TEST_CASE_P(bool, LogTest,
-                        ::testing::Values(std::make_tuple(0, false),
-                                          std::make_tuple(0, true),
-                                          std::make_tuple(1, false),
-                                          std::make_tuple(1, true)));
+INSTANTIATE_TEST_CASE_P(bool, LogTest, ::testing::Values(0, 2));
 
 class RetriableLogTest : public ::testing::TestWithParam<int> {
  private:
@@ -723,7 +677,7 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
   std::unique_ptr<WritableFileWriter> writer_;
   std::unique_ptr<SequentialFileReader> reader_;
   ReportCollector report_;
-  std::unique_ptr<FragmentBufferedReader> log_reader_;
+  std::unique_ptr<Reader> log_reader_;
 
  public:
   RetriableLogTest()
@@ -762,9 +716,9 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
     if (s.ok()) {
       reader_.reset(new SequentialFileReader(std::move(seq_file), log_file_));
       assert(reader_ != nullptr);
-      log_reader_.reset(new FragmentBufferedReader(
-          nullptr, std::move(reader_), &report_, true /* checksum */,
-          123 /* log_number */));
+      log_reader_.reset(new Reader(nullptr, std::move(reader_), &report_,
+                                   true /* checksum */, 123 /* log_number */,
+                                   true /* retry_after_eof */));
       assert(log_reader_ != nullptr);
     }
     return s;
@@ -784,17 +738,14 @@ class RetriableLogTest : public ::testing::TestWithParam<int> {
     writer_->Sync(true);
   }
 
-  bool TryRead(std::string* result) {
-    assert(result != nullptr);
-    result->clear();
+  std::string Read() {
+    auto wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
     std::string scratch;
     Slice record;
-    bool r = log_reader_->ReadRecord(&record, &scratch);
-    if (r) {
-      result->assign(record.data(), record.size());
-      return true;
+    if (log_reader_->ReadRecord(&record, &scratch, wal_recovery_mode)) {
+      return record.ToString();
     } else {
-      return false;
+      return "Read error";
     }
   }
 };
@@ -803,17 +754,12 @@ TEST_P(RetriableLogTest, TailLog_PartialHeader) {
   ASSERT_OK(SetupTestEnv());
   std::vector<int> remaining_bytes_in_last_record;
   size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  bool eof = false;
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->LoadDependency(
       {{"RetriableLogTest::TailLog:AfterPart1",
         "RetriableLogTest::TailLog:BeforeReadRecord"},
-       {"FragmentBufferedLogReader::TryReadMore:FirstEOF",
+       {"LogReader::ReadMore:FirstEOF",
         "RetriableLogTest::TailLog:BeforePart2"}});
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "FragmentBufferedLogReader::TryReadMore:FirstEOF",
-      [&](void* /*arg*/) { eof = true; });
   SyncPoint::GetInstance()->EnableProcessing();
 
   size_t delta = header_size - 1;
@@ -833,30 +779,23 @@ TEST_P(RetriableLogTest, TailLog_PartialHeader) {
   std::string record;
   port::Thread log_reader_thread([&]() {
     TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforeReadRecord");
-    while (!TryRead(&record)) {
-    }
+    record = Read();
   });
   log_reader_thread.join();
   log_writer_thread.join();
   ASSERT_EQ("foo", record);
-  ASSERT_TRUE(eof);
 }
 
 TEST_P(RetriableLogTest, TailLog_FullHeader) {
   ASSERT_OK(SetupTestEnv());
   std::vector<int> remaining_bytes_in_last_record;
   size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  bool eof = false;
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->LoadDependency(
       {{"RetriableLogTest::TailLog:AfterPart1",
         "RetriableLogTest::TailLog:BeforeReadRecord"},
-       {"FragmentBufferedLogReader::TryReadMore:FirstEOF",
+       {"LogReader::ReadMore:FirstEOF",
         "RetriableLogTest::TailLog:BeforePart2"}});
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "FragmentBufferedLogReader::TryReadMore:FirstEOF",
-      [&](void* /*arg*/) { eof = true; });
   SyncPoint::GetInstance()->EnableProcessing();
 
   size_t delta = header_size + 1;
@@ -871,45 +810,18 @@ TEST_P(RetriableLogTest, TailLog_FullHeader) {
     TEST_SYNC_POINT("RetriableLogTest::TailLog:AfterPart1");
     TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforePart2");
     Write(Slice(part2));
-    ASSERT_TRUE(eof);
   });
 
   std::string record;
   port::Thread log_reader_thread([&]() {
     TEST_SYNC_POINT("RetriableLogTest::TailLog:BeforeReadRecord");
-    while (!TryRead(&record)) {
-    }
+    record = Read();
   });
   log_reader_thread.join();
   log_writer_thread.join();
   ASSERT_EQ("foo", record);
 }
 
-TEST_P(RetriableLogTest, NonBlockingReadFullRecord) {
-  // Clear all sync point callbacks even if this test does not use sync point.
-  // It is necessary, otherwise the execute of this test may hit a sync point
-  // with which a callback is registered. The registered callback may access
-  // some dead variable, causing segfault.
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  ASSERT_OK(SetupTestEnv());
-  size_t header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
-  size_t delta = header_size - 1;
-  size_t old_sz = contents().size();
-  Encode("foo-bar");
-  size_t new_sz = contents().size();
-  std::string part1 = contents().substr(old_sz, delta);
-  std::string part2 =
-      contents().substr(old_sz + delta, new_sz - old_sz - delta);
-  Write(Slice(part1));
-  std::string record;
-  ASSERT_FALSE(TryRead(&record));
-  ASSERT_TRUE(record.empty());
-  Write(Slice(part2));
-  ASSERT_TRUE(TryRead(&record));
-  ASSERT_EQ("foo-bar", record);
-}
-
 INSTANTIATE_TEST_CASE_P(bool, RetriableLogTest, ::testing::Values(0, 2));
 
 }  // namespace log

db/log_writer.cc

@@ -18,7 +18,7 @@
 namespace rocksdb {
 namespace log {
 
-Writer::Writer(std::unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
+Writer::Writer(unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
                bool recycle_log_files, bool manual_flush)
     : dest_(std::move(dest)),
       block_offset_(0),

db/log_writer.h

@@ -20,6 +20,8 @@ namespace rocksdb {
 
 class WritableFileWriter;
 
+using std::unique_ptr;
+
 namespace log {
 
 /**
@@ -70,9 +72,8 @@ class Writer {
   // Create a writer that will append data to "*dest".
   // "*dest" must be initially empty.
   // "*dest" must remain live while this Writer is in use.
-  explicit Writer(std::unique_ptr<WritableFileWriter>&& dest,
-                  uint64_t log_number, bool recycle_log_files,
-                  bool manual_flush = false);
+  explicit Writer(unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
+                  bool recycle_log_files, bool manual_flush = false);
   ~Writer();
 
   Status AddRecord(const Slice& slice);

db/memtable.cc

@@ -35,6 +35,7 @@
 #include "util/autovector.h"
 #include "util/coding.h"
 #include "util/memory_usage.h"
+#include "util/murmurhash.h"
 #include "util/mutexlock.h"
 #include "util/util.h"
 
@@ -437,7 +438,8 @@ FragmentedRangeTombstoneIterator* MemTable::NewRangeTombstoneIterator(
 }
 
 port::RWMutex* MemTable::GetLock(const Slice& key) {
-  return &locks_[static_cast<size_t>(GetSliceNPHash64(key)) % locks_.size()];
+  static murmur_hash hash;
+  return &locks_[hash(key) % locks_.size()];
 }
 
 MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,

db/merge_helper.cc

@@ -64,8 +64,8 @@ Status MergeHelper::TimedFullMerge(const MergeOperator* merge_operator,
   }
 
   if (update_num_ops_stats) {
-    RecordInHistogram(statistics, READ_NUM_MERGE_OPERANDS,
-                      static_cast<uint64_t>(operands.size()));
+    MeasureTime(statistics, READ_NUM_MERGE_OPERANDS,
+                static_cast<uint64_t>(operands.size()));
   }
 
   bool success;
@@ -201,15 +201,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       // want. Also if we're in compaction and it's a put, it would be nice to
       // run compaction filter on it.
       const Slice val = iter->value();
-      const Slice* val_ptr;
-      if (kTypeValue == ikey.type &&
-          (range_del_agg == nullptr ||
-           !range_del_agg->ShouldDelete(
-               ikey, RangeDelPositioningMode::kForwardTraversal))) {
-        val_ptr = &val;
-      } else {
-        val_ptr = nullptr;
-      }
+      const Slice* val_ptr = (kTypeValue == ikey.type) ? &val : nullptr;
       std::string merge_result;
       s = TimedFullMerge(user_merge_operator_, ikey.user_key, val_ptr,
                          merge_context_.GetOperands(), &merge_result, logger_,

db/obsolete_files_test.cc

@@ -158,6 +158,9 @@ class ObsoleteFilesTest : public testing::Test {
 };
 
 TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
+  createLevel0Files(2, 50000);
+  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
+
   SyncPoint::GetInstance()->LoadDependency({
       {"DBImpl::BackgroundCallCompaction:FoundObsoleteFiles",
        "ObsoleteFilesTest::RaceForObsoleteFileDeletion:1"},
@@ -167,7 +170,7 @@ TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::DeleteObsoleteFileImpl:AfterDeletion", [&](void* arg) {
         Status* p_status = reinterpret_cast<Status*>(arg);
-        ASSERT_OK(*p_status);
+        ASSERT_TRUE(p_status->ok());
       });
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::CloseHelper:PendingPurgeFinished", [&](void* arg) {
@@ -177,9 +180,6 @@ TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
       });
   SyncPoint::GetInstance()->EnableProcessing();
 
-  createLevel0Files(2, 50000);
-  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
-
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   port::Thread user_thread([&]() {
     JobContext jobCxt(0);
@@ -196,10 +196,12 @@ TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
   user_thread.join();
 
   CloseDB();
-  SyncPoint::GetInstance()->DisableProcessing();
 }
 
 TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
+  createLevel0Files(2, 50000);
+  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
+
   std::vector<uint64_t> optsfiles_nums;
   std::vector<bool> optsfiles_keep;
   SyncPoint::GetInstance()->SetCallBack(
@@ -212,9 +214,6 @@ TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
       });
   SyncPoint::GetInstance()->EnableProcessing();
 
-  createLevel0Files(2, 50000);
-  CheckFileTypeCounts(options_.wal_dir, 1, 0, 0);
-
   DBImpl* dbi = static_cast<DBImpl*>(db_);
   ASSERT_OK(dbi->DisableFileDeletions());
   for (int i = 0; i != 4; ++i) {
@@ -246,7 +245,6 @@ TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
     }
   }
   ASSERT_EQ(2, opts_file_count);
-  SyncPoint::GetInstance()->DisableProcessing();
 }
 
 } //namespace rocksdb

db/perf_context_test.cc

@@ -813,131 +813,6 @@ TEST_F(PerfContextTest, PerfContextByLevelGetSet) {
   ASSERT_NE(std::string::npos,
             zero_excluded.find("block_cache_miss_count = 4@level1, 2@level3"));
 }
-
-TEST_F(PerfContextTest, CPUTimer) {
-  DestroyDB(kDbName, Options());
-  auto db = OpenDb();
-  WriteOptions write_options;
-  ReadOptions read_options;
-  SetPerfLevel(PerfLevel::kEnableTimeAndCPUTimeExceptForMutex);
-
-  std::string max_str = "0";
-  for (int i = 0; i < FLAGS_total_keys; ++i) {
-    std::string i_str = ToString(i);
-    std::string key = "k" + i_str;
-    std::string value = "v" + i_str;
-    max_str = max_str > i_str ? max_str : i_str;
-
-    db->Put(write_options, key, value);
-  }
-  std::string last_key = "k" + max_str;
-  std::string last_value = "v" + max_str;
-
-  {
-    // Get
-    get_perf_context()->Reset();
-    std::string value;
-    ASSERT_OK(db->Get(read_options, "k0", &value));
-    ASSERT_EQ(value, "v0");
-
-    if (FLAGS_verbose) {
-      std::cout << "Get CPU time nanos: " << get_perf_context()->get_cpu_nanos
-                << "ns\n";
-    }
-
-    // Iter
-    std::unique_ptr<Iterator> iter(db->NewIterator(read_options));
-
-    // Seek
-    get_perf_context()->Reset();
-    iter->Seek(last_key);
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ(last_value, iter->value().ToString());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter Seek CPU time nanos: "
-                << get_perf_context()->iter_seek_cpu_nanos << "ns\n";
-    }
-
-    // SeekForPrev
-    get_perf_context()->Reset();
-    iter->SeekForPrev(last_key);
-    ASSERT_TRUE(iter->Valid());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter SeekForPrev CPU time nanos: "
-                << get_perf_context()->iter_seek_cpu_nanos << "ns\n";
-    }
-
-    // SeekToLast
-    get_perf_context()->Reset();
-    iter->SeekToLast();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ(last_value, iter->value().ToString());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter SeekToLast CPU time nanos: "
-                << get_perf_context()->iter_seek_cpu_nanos << "ns\n";
-    }
-
-    // SeekToFirst
-    get_perf_context()->Reset();
-    iter->SeekToFirst();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("v0", iter->value().ToString());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter SeekToFirst CPU time nanos: "
-                << get_perf_context()->iter_seek_cpu_nanos << "ns\n";
-    }
-
-    // Next
-    get_perf_context()->Reset();
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("v1", iter->value().ToString());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter Next CPU time nanos: "
-                << get_perf_context()->iter_next_cpu_nanos << "ns\n";
-    }
-
-    // Prev
-    get_perf_context()->Reset();
-    iter->Prev();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_EQ("v0", iter->value().ToString());
-
-    if (FLAGS_verbose) {
-      std::cout << "Iter Prev CPU time nanos: "
-                << get_perf_context()->iter_prev_cpu_nanos << "ns\n";
-    }
-
-    // monotonically increasing
-    get_perf_context()->Reset();
-    auto count = get_perf_context()->iter_seek_cpu_nanos;
-    for (int i = 0; i < FLAGS_total_keys; ++i) {
-      iter->Seek("k" + ToString(i));
-      ASSERT_TRUE(iter->Valid());
-      ASSERT_EQ("v" + ToString(i), iter->value().ToString());
-      auto next_count = get_perf_context()->iter_seek_cpu_nanos;
-      ASSERT_GT(next_count, count);
-      count = next_count;
-    }
-
-    // iterator creation/destruction; multiple iterators
-    {
-      std::unique_ptr<Iterator> iter2(db->NewIterator(read_options));
-      ASSERT_EQ(count, get_perf_context()->iter_seek_cpu_nanos);
-      iter2->Seek(last_key);
-      ASSERT_TRUE(iter2->Valid());
-      ASSERT_EQ(last_value, iter2->value().ToString());
-      ASSERT_GT(get_perf_context()->iter_seek_cpu_nanos, count);
-      count = get_perf_context()->iter_seek_cpu_nanos;
-    }
-    ASSERT_EQ(count, get_perf_context()->iter_seek_cpu_nanos);
-  }
-}
 }  // namespace rocksdb
 
 int main(int argc, char** argv) {

db/pre_release_callback.h

@@ -15,8 +15,8 @@ class PreReleaseCallback {
  public:
   virtual ~PreReleaseCallback() {}
 
-  // Will be called while on the write thread after the write to the WAL and
-  // before the write to memtable. This is useful if any operation needs to be
+  // Will be called while on the write thread after the write and before the
+  // release of the sequence number. This is useful if any operation needs to be
   // done before the write gets visible to the readers, or if we want to reduce
   // the overhead of locking by updating something sequentially while we are on
   // the write thread. If the callback fails, this function returns a non-OK
@@ -26,9 +26,7 @@ class PreReleaseCallback {
   // released.
   // is_mem_disabled is currently used for debugging purposes to assert that
   // the callback is done from the right write queue.
-  // If non-zero, log_number indicates the WAL log to which we wrote.
-  virtual Status Callback(SequenceNumber seq, bool is_mem_disabled,
-                          uint64_t log_number) = 0;
+  virtual Status Callback(SequenceNumber seq, bool is_mem_disabled) = 0;
 };
 
 }  //  namespace rocksdb

db/read_callback.h

@@ -11,45 +11,20 @@ namespace rocksdb {
 
 class ReadCallback {
  public:
-  ReadCallback(SequenceNumber last_visible_seq)
-      : max_visible_seq_(last_visible_seq) {}
-  ReadCallback(SequenceNumber last_visible_seq, SequenceNumber min_uncommitted)
-      : max_visible_seq_(last_visible_seq), min_uncommitted_(min_uncommitted) {}
-
   virtual ~ReadCallback() {}
 
   // Will be called to see if the seq number visible; if not it moves on to
   // the next seq number.
-  virtual bool IsVisibleFullCheck(SequenceNumber seq) = 0;
+  virtual bool IsVisible(SequenceNumber seq) = 0;
 
-  inline bool IsVisible(SequenceNumber seq) {
-    assert(min_uncommitted_ > 0);
-    assert(min_uncommitted_ >= kMinUnCommittedSeq);
-    if (seq < min_uncommitted_) {  // handles seq == 0 as well
-      assert(seq <= max_visible_seq_);
-      return true;
-    } else if (max_visible_seq_ < seq) {
-      assert(seq != 0);
-      return false;
-    } else {
-      assert(seq != 0);  // already handled in the first if-then clause
-      return IsVisibleFullCheck(seq);
-    }
-  }
-
-  inline SequenceNumber max_visible_seq() { return max_visible_seq_; }
-
-  virtual void Refresh(SequenceNumber seq) { max_visible_seq_ = seq; }
-
-  // Refer to DBIter::CanReseekToSkip
-  virtual bool CanReseekToSkip() { return true; }
-
- protected:
-  // The max visible seq, it is usually the snapshot but could be larger if
-  // transaction has its own writes written to db.
-  SequenceNumber max_visible_seq_ = kMaxSequenceNumber;
-  // Any seq less than min_uncommitted_ is committed.
-  const SequenceNumber min_uncommitted_ = kMinUnCommittedSeq;
+  // This is called to determine the maximum visible sequence number for the
+  // current transaction for read-your-own-write semantics. This is so that
+  // for write unprepared, we will not skip keys that are written by the
+  // current transaction with the seek to snapshot optimization.
+  //
+  // For other uses, this returns zero, meaning that the current snapshot
+  // sequence number is the maximum visible sequence number.
+  inline virtual SequenceNumber MaxUnpreparedSequenceNumber() { return 0; };
 };
 
 }  //  namespace rocksdb

db/repair.cc

@@ -364,7 +364,8 @@ class Repairer {
     // propagating bad information (like overly large sequence
     // numbers).
     log::Reader reader(db_options_.info_log, std::move(lfile_reader), &reporter,
-                       true /*enable checksum*/, log);
+                       true /*enable checksum*/, log,
+                       false /* retry_after_eof */);
 
     // Initialize per-column family memtables
     for (auto* cfd : *vset_.GetColumnFamilySet()) {
@@ -429,11 +430,10 @@ class Repairer {
           &meta, cfd->internal_comparator(),
           cfd->int_tbl_prop_collector_factories(), cfd->GetID(), cfd->GetName(),
           {}, kMaxSequenceNumber, snapshot_checker, kNoCompression,
-          0 /* sample_for_compression */, CompressionOptions(), false,
-          nullptr /* internal_stats */, TableFileCreationReason::kRecovery,
-          nullptr /* event_logger */, 0 /* job_id */, Env::IO_HIGH,
-          nullptr /* table_properties */, -1 /* level */, current_time,
-          write_hint);
+          CompressionOptions(), false, nullptr /* internal_stats */,
+          TableFileCreationReason::kRecovery, nullptr /* event_logger */,
+          0 /* job_id */, Env::IO_HIGH, nullptr /* table_properties */,
+          -1 /* level */, current_time, write_hint);
       ROCKS_LOG_INFO(db_options_.info_log,
                      "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s",
                      log, counter, meta.fd.GetNumber(),

db/snapshot_impl.h

@@ -24,7 +24,7 @@ class SnapshotImpl : public Snapshot {
   // It indicates the smallest uncommitted data at the time the snapshot was
   // taken. This is currently used by WritePrepared transactions to limit the
   // scope of queries to IsInSnpashot.
-  SequenceNumber min_uncommitted_ = kMinUnCommittedSeq;
+  SequenceNumber min_uncommitted_ = 0;
 
   virtual SequenceNumber GetSequenceNumber() const override { return number_; }
 

db/table_properties_collector.cc

@@ -41,13 +41,6 @@ Status UserKeyTablePropertiesCollector::InternalAdd(const Slice& key,
                                 ikey.sequence, file_size);
 }
 
-void UserKeyTablePropertiesCollector::BlockAdd(
-    uint64_t bLockRawBytes, uint64_t blockCompressedBytesFast,
-    uint64_t blockCompressedBytesSlow) {
-  return collector_->BlockAdd(bLockRawBytes, blockCompressedBytesFast,
-                              blockCompressedBytesSlow);
-}
-
 Status UserKeyTablePropertiesCollector::Finish(
     UserCollectedProperties* properties) {
   return collector_->Finish(properties);

db/table_properties_collector.h

@@ -27,10 +27,6 @@ class IntTblPropCollector {
   virtual Status InternalAdd(const Slice& key, const Slice& value,
                              uint64_t file_size) = 0;
 
-  virtual void BlockAdd(uint64_t blockRawBytes,
-                        uint64_t blockCompressedBytesFast,
-                        uint64_t blockCompressedBytesSlow) = 0;
-
   virtual UserCollectedProperties GetReadableProperties() const = 0;
 
   virtual bool NeedCompact() const { return false; }
@@ -64,10 +60,6 @@ class UserKeyTablePropertiesCollector : public IntTblPropCollector {
   virtual Status InternalAdd(const Slice& key, const Slice& value,
                              uint64_t file_size) override;
 
-  virtual void BlockAdd(uint64_t blockRawBytes,
-                        uint64_t blockCompressedBytesFast,
-                        uint64_t blockCompressedBytesSlow) override;
-
   virtual Status Finish(UserCollectedProperties* properties) override;
 
   virtual const char* Name() const override { return collector_->Name(); }

db/table_properties_collector_test.cc

@@ -52,8 +52,7 @@ void MakeBuilder(const Options& options, const ImmutableCFOptions& ioptions,
   builder->reset(NewTableBuilder(
       ioptions, moptions, internal_comparator, int_tbl_prop_collector_factories,
       kTestColumnFamilyId, kTestColumnFamilyName, writable->get(),
-      options.compression, options.sample_for_compression,
-      options.compression_opts, unknown_level));
+      options.compression, options.compression_opts, unknown_level));
 }
 }  // namespace
 
@@ -173,13 +172,6 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector {
     return Status::OK();
   }
 
-  void BlockAdd(uint64_t /* blockRawBytes */,
-                uint64_t /* blockCompressedBytesFast */,
-                uint64_t /* blockCompressedBytesSlow */) override {
-    // Nothing to do.
-    return;
-  }
-
   UserCollectedProperties GetReadableProperties() const override {
     return UserCollectedProperties{};
   }

db/transaction_log_impl.cc

@@ -25,13 +25,13 @@ TransactionLogIteratorImpl::TransactionLogIteratorImpl(
       options_(options),
       read_options_(read_options),
       soptions_(soptions),
-      starting_sequence_number_(seq),
+      startingSequenceNumber_(seq),
       files_(std::move(files)),
       started_(false),
-      is_valid_(false),
-      current_file_index_(0),
-      current_batch_seq_(0),
-      current_last_seq_(0),
+      isValid_(false),
+      currentFileIndex_(0),
+      currentBatchSeq_(0),
+      currentLastSeq_(0),
       versions_(versions),
       seq_per_batch_(seq_per_batch) {
   assert(files_ != nullptr);
@@ -43,23 +43,23 @@ TransactionLogIteratorImpl::TransactionLogIteratorImpl(
 }
 
 Status TransactionLogIteratorImpl::OpenLogFile(
-    const LogFile* log_file,
+    const LogFile* logFile,
     std::unique_ptr<SequentialFileReader>* file_reader) {
   Env* env = options_->env;
   std::unique_ptr<SequentialFile> file;
   std::string fname;
   Status s;
   EnvOptions optimized_env_options = env->OptimizeForLogRead(soptions_);
-  if (log_file->Type() == kArchivedLogFile) {
-    fname = ArchivedLogFileName(dir_, log_file->LogNumber());
+  if (logFile->Type() == kArchivedLogFile) {
+    fname = ArchivedLogFileName(dir_, logFile->LogNumber());
     s = env->NewSequentialFile(fname, &file, optimized_env_options);
   } else {
-    fname = LogFileName(dir_, log_file->LogNumber());
+    fname = LogFileName(dir_, logFile->LogNumber());
     s = env->NewSequentialFile(fname, &file, optimized_env_options);
     if (!s.ok()) {
       //  If cannot open file in DB directory.
       //  Try the archive dir, as it could have moved in the meanwhile.
-      fname = ArchivedLogFileName(dir_, log_file->LogNumber());
+      fname = ArchivedLogFileName(dir_, logFile->LogNumber());
       s = env->NewSequentialFile(fname, &file, optimized_env_options);
     }
   }
@@ -70,41 +70,45 @@ Status TransactionLogIteratorImpl::OpenLogFile(
 }
 
 BatchResult TransactionLogIteratorImpl::GetBatch()  {
-  assert(is_valid_);  //  cannot call in a non valid state.
+  assert(isValid_);  //  cannot call in a non valid state.
   BatchResult result;
-  result.sequence = current_batch_seq_;
-  result.writeBatchPtr = std::move(current_batch_);
+  result.sequence = currentBatchSeq_;
+  result.writeBatchPtr = std::move(currentBatch_);
   return result;
 }
 
-Status TransactionLogIteratorImpl::status() { return current_status_; }
+Status TransactionLogIteratorImpl::status() {
+  return currentStatus_;
+}
 
-bool TransactionLogIteratorImpl::Valid() { return started_ && is_valid_; }
+bool TransactionLogIteratorImpl::Valid() {
+  return started_ && isValid_;
+}
 
 bool TransactionLogIteratorImpl::RestrictedRead(
     Slice* record,
     std::string* scratch) {
   // Don't read if no more complete entries to read from logs
-  if (current_last_seq_ >= versions_->LastSequence()) {
+  if (currentLastSeq_ >= versions_->LastSequence()) {
     return false;
   }
-  return current_log_reader_->ReadRecord(record, scratch);
+  return currentLogReader_->ReadRecord(record, scratch);
 }
 
-void TransactionLogIteratorImpl::SeekToStartSequence(uint64_t start_file_index,
-                                                     bool strict) {
+void TransactionLogIteratorImpl::SeekToStartSequence(
+    uint64_t startFileIndex,
+    bool strict) {
   std::string scratch;
   Slice record;
   started_ = false;
-  is_valid_ = false;
-  if (files_->size() <= start_file_index) {
+  isValid_ = false;
+  if (files_->size() <= startFileIndex) {
     return;
   }
-  Status s =
-      OpenLogReader(files_->at(static_cast<size_t>(start_file_index)).get());
+  Status s = OpenLogReader(files_->at(static_cast<size_t>(startFileIndex)).get());
   if (!s.ok()) {
-    current_status_ = s;
-    reporter_.Info(current_status_.ToString().c_str());
+    currentStatus_ = s;
+    reporter_.Info(currentStatus_.ToString().c_str());
     return;
   }
   while (RestrictedRead(&record, &scratch)) {
@@ -114,22 +118,21 @@ void TransactionLogIteratorImpl::SeekToStartSequence(uint64_t start_file_index,
       continue;
     }
     UpdateCurrentWriteBatch(record);
-    if (current_last_seq_ >= starting_sequence_number_) {
-      if (strict && current_batch_seq_ != starting_sequence_number_) {
-        current_status_ = Status::Corruption(
-            "Gap in sequence number. Could not "
-            "seek to required sequence number");
-        reporter_.Info(current_status_.ToString().c_str());
+    if (currentLastSeq_ >= startingSequenceNumber_) {
+      if (strict && currentBatchSeq_ != startingSequenceNumber_) {
+        currentStatus_ = Status::Corruption("Gap in sequence number. Could not "
+                                            "seek to required sequence number");
+        reporter_.Info(currentStatus_.ToString().c_str());
         return;
       } else if (strict) {
         reporter_.Info("Could seek required sequence number. Iterator will "
                        "continue.");
       }
-      is_valid_ = true;
+      isValid_ = true;
       started_ = true; // set started_ as we could seek till starting sequence
       return;
     } else {
-      is_valid_ = false;
+      isValid_ = false;
     }
   }
 
@@ -138,15 +141,13 @@ void TransactionLogIteratorImpl::SeekToStartSequence(uint64_t start_file_index,
   // If strict is set, we want to seek exactly till the start sequence and it
   // should have been present in the file we scanned above
   if (strict) {
-    current_status_ = Status::Corruption(
-        "Gap in sequence number. Could not "
-        "seek to required sequence number");
-    reporter_.Info(current_status_.ToString().c_str());
+    currentStatus_ = Status::Corruption("Gap in sequence number. Could not "
+                                        "seek to required sequence number");
+    reporter_.Info(currentStatus_.ToString().c_str());
   } else if (files_->size() != 1) {
-    current_status_ = Status::Corruption(
-        "Start sequence was not found, "
-        "skipping to the next available");
-    reporter_.Info(current_status_.ToString().c_str());
+    currentStatus_ = Status::Corruption("Start sequence was not found, "
+                                        "skipping to the next available");
+    reporter_.Info(currentStatus_.ToString().c_str());
     // Let NextImpl find the next available entry. started_ remains false
     // because we don't want to check for gaps while moving to start sequence
     NextImpl(true);
@@ -160,15 +161,15 @@ void TransactionLogIteratorImpl::Next() {
 void TransactionLogIteratorImpl::NextImpl(bool internal) {
   std::string scratch;
   Slice record;
-  is_valid_ = false;
+  isValid_ = false;
   if (!internal && !started_) {
     // Runs every time until we can seek to the start sequence
     return SeekToStartSequence();
   }
   while(true) {
-    assert(current_log_reader_);
-    if (current_log_reader_->IsEOF()) {
-      current_log_reader_->UnmarkEOF();
+    assert(currentLogReader_);
+    if (currentLogReader_->IsEOF()) {
+      currentLogReader_->UnmarkEOF();
     }
     while (RestrictedRead(&record, &scratch)) {
       if (record.size() < WriteBatchInternal::kHeader) {
@@ -189,20 +190,20 @@ void TransactionLogIteratorImpl::NextImpl(bool internal) {
     }
 
     // Open the next file
-    if (current_file_index_ < files_->size() - 1) {
-      ++current_file_index_;
-      Status s = OpenLogReader(files_->at(current_file_index_).get());
+    if (currentFileIndex_ < files_->size() - 1) {
+      ++currentFileIndex_;
+      Status s = OpenLogReader(files_->at(currentFileIndex_).get());
       if (!s.ok()) {
-        is_valid_ = false;
-        current_status_ = s;
+        isValid_ = false;
+        currentStatus_ = s;
         return;
       }
     } else {
-      is_valid_ = false;
-      if (current_last_seq_ == versions_->LastSequence()) {
-        current_status_ = Status::OK();
+      isValid_ = false;
+      if (currentLastSeq_ == versions_->LastSequence()) {
+        currentStatus_ = Status::OK();
       } else {
-        current_status_ = Status::Corruption("NO MORE DATA LEFT");
+        currentStatus_ = Status::Corruption("NO MORE DATA LEFT");
       }
       return;
     }
@@ -210,16 +211,17 @@ void TransactionLogIteratorImpl::NextImpl(bool internal) {
 }
 
 bool TransactionLogIteratorImpl::IsBatchExpected(
-    const WriteBatch* batch, const SequenceNumber expected_seq) {
+    const WriteBatch* batch,
+    const SequenceNumber expectedSeq) {
   assert(batch);
   SequenceNumber batchSeq = WriteBatchInternal::Sequence(batch);
-  if (batchSeq != expected_seq) {
+  if (batchSeq != expectedSeq) {
     char buf[200];
     snprintf(buf, sizeof(buf),
              "Discontinuity in log records. Got seq=%" PRIu64
              ", Expected seq=%" PRIu64 ", Last flushed seq=%" PRIu64
              ".Log iterator will reseek the correct batch.",
-             batchSeq, expected_seq, versions_->LastSequence());
+             batchSeq, expectedSeq, versions_->LastSequence());
     reporter_.Info(buf);
     return false;
   }
@@ -230,25 +232,25 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
   std::unique_ptr<WriteBatch> batch(new WriteBatch());
   WriteBatchInternal::SetContents(batch.get(), record);
 
-  SequenceNumber expected_seq = current_last_seq_ + 1;
+  SequenceNumber expectedSeq = currentLastSeq_ + 1;
   // If the iterator has started, then confirm that we get continuous batches
-  if (started_ && !IsBatchExpected(batch.get(), expected_seq)) {
+  if (started_ && !IsBatchExpected(batch.get(), expectedSeq)) {
     // Seek to the batch having expected sequence number
-    if (expected_seq < files_->at(current_file_index_)->StartSequence()) {
+    if (expectedSeq < files_->at(currentFileIndex_)->StartSequence()) {
       // Expected batch must lie in the previous log file
       // Avoid underflow.
-      if (current_file_index_ != 0) {
-        current_file_index_--;
+      if (currentFileIndex_ != 0) {
+        currentFileIndex_--;
       }
     }
-    starting_sequence_number_ = expected_seq;
+    startingSequenceNumber_ = expectedSeq;
     // currentStatus_ will be set to Ok if reseek succeeds
     // Note: this is still ok in seq_pre_batch_ && two_write_queuesp_ mode
     // that allows gaps in the WAL since it will still skip over the gap.
-    current_status_ = Status::NotFound("Gap in sequence numbers");
+    currentStatus_ = Status::NotFound("Gap in sequence numbers");
     // In seq_per_batch_ mode, gaps in the seq are possible so the strict mode
     // should be disabled
-    return SeekToStartSequence(current_file_index_, !seq_per_batch_);
+    return SeekToStartSequence(currentFileIndex_, !seq_per_batch_);
   }
 
   struct BatchCounter : public WriteBatch::Handler {
@@ -287,33 +289,34 @@ void TransactionLogIteratorImpl::UpdateCurrentWriteBatch(const Slice& record) {
     Status MarkRollback(const Slice&) override { return Status::OK(); }
   };
 
-  current_batch_seq_ = WriteBatchInternal::Sequence(batch.get());
+  currentBatchSeq_ = WriteBatchInternal::Sequence(batch.get());
   if (seq_per_batch_) {
-    BatchCounter counter(current_batch_seq_);
+    BatchCounter counter(currentBatchSeq_);
     batch->Iterate(&counter);
-    current_last_seq_ = counter.sequence_;
+    currentLastSeq_ = counter.sequence_;
   } else {
-    current_last_seq_ =
-        current_batch_seq_ + WriteBatchInternal::Count(batch.get()) - 1;
+    currentLastSeq_ =
+        currentBatchSeq_ + WriteBatchInternal::Count(batch.get()) - 1;
   }
   // currentBatchSeq_ can only change here
-  assert(current_last_seq_ <= versions_->LastSequence());
+  assert(currentLastSeq_ <= versions_->LastSequence());
 
-  current_batch_ = std::move(batch);
-  is_valid_ = true;
-  current_status_ = Status::OK();
+  currentBatch_ = std::move(batch);
+  isValid_ = true;
+  currentStatus_ = Status::OK();
 }
 
-Status TransactionLogIteratorImpl::OpenLogReader(const LogFile* log_file) {
+Status TransactionLogIteratorImpl::OpenLogReader(const LogFile* logFile) {
   std::unique_ptr<SequentialFileReader> file;
-  Status s = OpenLogFile(log_file, &file);
+  Status s = OpenLogFile(logFile, &file);
   if (!s.ok()) {
     return s;
   }
   assert(file);
-  current_log_reader_.reset(
+  currentLogReader_.reset(
       new log::Reader(options_->info_log, std::move(file), &reporter_,
-                      read_options_.verify_checksums_, log_file->LogNumber()));
+                      read_options_.verify_checksums_, logFile->LogNumber(),
+                      false /* retry_after_eof */));
   return Status::OK();
 }
 }  //  namespace rocksdb

db/transaction_log_impl.h

@@ -78,15 +78,15 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
   const ImmutableDBOptions* options_;
   const TransactionLogIterator::ReadOptions read_options_;
   const EnvOptions& soptions_;
-  SequenceNumber starting_sequence_number_;
+  SequenceNumber startingSequenceNumber_;
   std::unique_ptr<VectorLogPtr> files_;
   bool started_;
-  bool is_valid_;  // not valid when it starts of.
-  Status current_status_;
-  size_t current_file_index_;
-  std::unique_ptr<WriteBatch> current_batch_;
-  std::unique_ptr<log::Reader> current_log_reader_;
-  Status OpenLogFile(const LogFile* log_file,
+  bool isValid_;  // not valid when it starts of.
+  Status currentStatus_;
+  size_t currentFileIndex_;
+  std::unique_ptr<WriteBatch> currentBatch_;
+  std::unique_ptr<log::Reader> currentLogReader_;
+  Status OpenLogFile(const LogFile* logFile,
                      std::unique_ptr<SequentialFileReader>* file);
 
   struct LogReporter : public log::Reader::Reporter {
@@ -99,9 +99,8 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
     virtual void Info(const char* s) { ROCKS_LOG_INFO(info_log, "%s", s); }
   } reporter_;
 
-  SequenceNumber
-      current_batch_seq_;  // sequence number at start of current batch
-  SequenceNumber current_last_seq_;  // last sequence in the current batch
+  SequenceNumber currentBatchSeq_; // sequence number at start of current batch
+  SequenceNumber currentLastSeq_; // last sequence in the current batch
   // Used only to get latest seq. num
   // TODO(icanadi) can this be just a callback?
   VersionSet const* const versions_;
@@ -110,14 +109,14 @@ class TransactionLogIteratorImpl : public TransactionLogIterator {
   bool RestrictedRead(Slice* record, std::string* scratch);
   // Seeks to startingSequenceNumber reading from startFileIndex in files_.
   // If strict is set,then must get a batch starting with startingSequenceNumber
-  void SeekToStartSequence(uint64_t start_file_index = 0, bool strict = false);
+  void SeekToStartSequence(uint64_t startFileIndex = 0, bool strict = false);
   // Implementation of Next. SeekToStartSequence calls it internally with
   // internal=true to let it find next entry even if it has to jump gaps because
   // the iterator may start off from the first available entry but promises to
   // be continuous after that
   void NextImpl(bool internal = false);
   // Check if batch is expected, else return false
-  bool IsBatchExpected(const WriteBatch* batch, SequenceNumber expected_seq);
+  bool IsBatchExpected(const WriteBatch* batch, SequenceNumber expectedSeq);
   // Update current batch if a continuous batch is found, else return false
   void UpdateCurrentWriteBatch(const Slice& record);
   Status OpenLogReader(const LogFile* file);

db/version_builder.cc

@@ -364,10 +364,10 @@ class VersionBuilder::Rep {
     CheckConsistency(vstorage);
   }
 
-  Status LoadTableHandlers(InternalStats* internal_stats, int max_threads,
-                           bool prefetch_index_and_filter_in_cache,
-                           bool is_initial_load,
-                           const SliceTransform* prefix_extractor) {
+  void LoadTableHandlers(InternalStats* internal_stats, int max_threads,
+                         bool prefetch_index_and_filter_in_cache,
+                         bool is_initial_load,
+                         const SliceTransform* prefix_extractor) {
     assert(table_cache_ != nullptr);
 
     size_t table_cache_capacity = table_cache_->get_cache()->GetCapacity();
@@ -394,8 +394,7 @@ class VersionBuilder::Rep {
 
       size_t table_cache_usage = table_cache_->get_cache()->GetUsage();
       if (table_cache_usage >= load_limit) {
-        // TODO (yanqin) find a suitable status code.
-        return Status::OK();
+        return;
       } else {
         max_load = load_limit - table_cache_usage;
       }
@@ -403,15 +402,11 @@ class VersionBuilder::Rep {
 
     // <file metadata, level>
     std::vector<std::pair<FileMetaData*, int>> files_meta;
-    std::vector<Status> statuses;
     for (int level = 0; level < num_levels_; level++) {
       for (auto& file_meta_pair : levels_[level].added_files) {
         auto* file_meta = file_meta_pair.second;
-        // If the file has been opened before, just skip it.
-        if (!file_meta->table_reader_handle) {
-          files_meta.emplace_back(file_meta, level);
-          statuses.emplace_back(Status::OK());
-        }
+        assert(!file_meta->table_reader_handle);
+        files_meta.emplace_back(file_meta, level);
         if (files_meta.size() >= max_load) {
           break;
         }
@@ -431,7 +426,7 @@ class VersionBuilder::Rep {
 
         auto* file_meta = files_meta[file_idx].first;
         int level = files_meta[file_idx].second;
-        statuses[file_idx] = table_cache_->FindTable(
+        table_cache_->FindTable(
             env_options_, *(base_vstorage_->InternalComparator()),
             file_meta->fd, &file_meta->table_reader_handle, prefix_extractor,
             false /*no_io */, true /* record_read_stats */,
@@ -453,12 +448,6 @@ class VersionBuilder::Rep {
     for (auto& t : threads) {
       t.join();
     }
-    for (const auto& s : statuses) {
-      if (!s.ok()) {
-        return s;
-      }
-    }
-    return Status::OK();
   }
 
   void MaybeAddFile(VersionStorageInfo* vstorage, int level, FileMetaData* f) {
@@ -498,13 +487,14 @@ void VersionBuilder::SaveTo(VersionStorageInfo* vstorage) {
   rep_->SaveTo(vstorage);
 }
 
-Status VersionBuilder::LoadTableHandlers(
-    InternalStats* internal_stats, int max_threads,
-    bool prefetch_index_and_filter_in_cache, bool is_initial_load,
-    const SliceTransform* prefix_extractor) {
-  return rep_->LoadTableHandlers(internal_stats, max_threads,
-                                 prefetch_index_and_filter_in_cache,
-                                 is_initial_load, prefix_extractor);
+void VersionBuilder::LoadTableHandlers(InternalStats* internal_stats,
+                                       int max_threads,
+                                       bool prefetch_index_and_filter_in_cache,
+                                       bool is_initial_load,
+                                       const SliceTransform* prefix_extractor) {
+  rep_->LoadTableHandlers(internal_stats, max_threads,
+                          prefetch_index_and_filter_in_cache, is_initial_load,
+                          prefix_extractor);
 }
 
 void VersionBuilder::MaybeAddFile(VersionStorageInfo* vstorage, int level,

db/version_builder.h

@@ -33,10 +33,10 @@ class VersionBuilder {
   bool CheckConsistencyForNumLevels();
   void Apply(VersionEdit* edit);
   void SaveTo(VersionStorageInfo* vstorage);
-  Status LoadTableHandlers(InternalStats* internal_stats, int max_threads,
-                           bool prefetch_index_and_filter_in_cache,
-                           bool is_initial_load,
-                           const SliceTransform* prefix_extractor);
+  void LoadTableHandlers(InternalStats* internal_stats, int max_threads,
+                         bool prefetch_index_and_filter_in_cache,
+                         bool is_initial_load,
+                         const SliceTransform* prefix_extractor);
   void MaybeAddFile(VersionStorageInfo* vstorage, int level, FileMetaData* f);
 
  private:

db/version_edit.h

@@ -313,7 +313,6 @@ class VersionEdit {
   std::string DebugJSON(int edit_num, bool hex_key = false) const;
 
  private:
-  friend class ReactiveVersionSet;
   friend class VersionSet;
   friend class Version;
 

db/version_set.cc

@@ -51,7 +51,6 @@
 #include "util/stop_watch.h"
 #include "util/string_util.h"
 #include "util/sync_point.h"
-#include "util/user_comparator_wrapper.h"
 
 namespace rocksdb {
 
@@ -478,7 +477,6 @@ class LevelIterator final : public InternalIterator {
         read_options_(read_options),
         env_options_(env_options),
         icomparator_(icomparator),
-        user_comparator_(icomparator.user_comparator()),
         flevel_(flevel),
         prefix_extractor_(prefix_extractor),
         file_read_hist_(file_read_hist),
@@ -543,8 +541,9 @@ class LevelIterator final : public InternalIterator {
 
   bool KeyReachedUpperBound(const Slice& internal_key) {
     return read_options_.iterate_upper_bound != nullptr &&
-           user_comparator_.Compare(ExtractUserKey(internal_key),
-                                    *read_options_.iterate_upper_bound) >= 0;
+           icomparator_.user_comparator()->Compare(
+               ExtractUserKey(internal_key),
+               *read_options_.iterate_upper_bound) >= 0;
   }
 
   InternalIterator* NewFileIterator() {
@@ -572,7 +571,6 @@ class LevelIterator final : public InternalIterator {
   const ReadOptions read_options_;
   const EnvOptions& env_options_;
   const InternalKeyComparator& icomparator_;
-  const UserComparatorWrapper user_comparator_;
   const LevelFilesBrief* flevel_;
   mutable FileDescriptor current_value_;
   const SliceTransform* prefix_extractor_;
@@ -714,7 +712,6 @@ void LevelIterator::InitFileIterator(size_t new_file_index) {
     }
   }
 }
-}  // anonymous namespace
 
 // A wrapper of version builder which references the current version in
 // constructor and unref it in the destructor.
@@ -729,14 +726,16 @@ class BaseReferencedVersionBuilder {
     version_->Ref();
   }
   ~BaseReferencedVersionBuilder() {
+    delete version_builder_;
     version_->Unref();
   }
-  VersionBuilder* version_builder() { return version_builder_.get(); }
+  VersionBuilder* version_builder() { return version_builder_; }
 
  private:
-  std::unique_ptr<VersionBuilder> version_builder_;
+  VersionBuilder* version_builder_;
   Version* version_;
 };
+}  // anonymous namespace
 
 Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
                                    const FileMetaData* file_meta,
@@ -2235,7 +2234,7 @@ void VersionStorageInfo::GetOverlappingInputsRangeBinarySearch(
   // If there were no overlapping files, return immediately.
   if (!foundOverlap) {
     if (next_smallest) {
-      *next_smallest = nullptr;
+      next_smallest = nullptr;
     }
     return;
   }
@@ -2937,7 +2936,7 @@ Status VersionSet::ProcessManifestWrites(
         } else if (group_start != std::numeric_limits<size_t>::max()) {
           group_start = std::numeric_limits<size_t>::max();
         }
-        LogAndApplyHelper(last_writer->cfd, builder, e, mu);
+        LogAndApplyHelper(last_writer->cfd, builder, version, e, mu);
         batch_edits.push_back(e);
       }
     }
@@ -2991,7 +2990,6 @@ Status VersionSet::ProcessManifestWrites(
   assert(pending_manifest_file_number_ == 0);
   if (!descriptor_log_ ||
       manifest_file_size_ > db_options_->max_manifest_file_size) {
-    TEST_SYNC_POINT("VersionSet::ProcessManifestWrites:BeforeNewManifest");
     pending_manifest_file_number_ = NewFileNumber();
     batch_edits.back()->SetNextFile(next_file_number_.load());
     new_descriptor_log = true;
@@ -3100,7 +3098,6 @@ Status VersionSet::ProcessManifestWrites(
     if (s.ok() && new_descriptor_log) {
       s = SetCurrentFile(env_, dbname_, pending_manifest_file_number_,
                          db_directory);
-      TEST_SYNC_POINT("VersionSet::ProcessManifestWrites:AfterNewManifest");
     }
 
     if (s.ok()) {
@@ -3228,7 +3225,7 @@ Status VersionSet::ProcessManifestWrites(
   return s;
 }
 
-// 'datas' is gramatically incorrect. We still use this notation to indicate
+// 'datas' is gramatically incorrect. We still use this notation is to indicate
 // that this variable represents a collection of column_family_data.
 Status VersionSet::LogAndApply(
     const autovector<ColumnFamilyData*>& column_family_datas,
@@ -3328,8 +3325,8 @@ void VersionSet::LogAndApplyCFHelper(VersionEdit* edit) {
 }
 
 void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
-                                   VersionBuilder* builder, VersionEdit* edit,
-                                   InstrumentedMutex* mu) {
+                                   VersionBuilder* builder, Version* /*v*/,
+                                   VersionEdit* edit, InstrumentedMutex* mu) {
 #ifdef NDEBUG
   (void)cfd;
 #endif
@@ -3356,16 +3353,16 @@ void VersionSet::LogAndApplyHelper(ColumnFamilyData* cfd,
   builder->Apply(edit);
 }
 
-Status VersionSet::ApplyOneVersionEditToBuilder(
+Status VersionSet::ApplyOneVersionEdit(
     VersionEdit& edit,
     const std::unordered_map<std::string, ColumnFamilyOptions>& name_to_options,
     std::unordered_map<int, std::string>& column_families_not_found,
-    std::unordered_map<uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>&
-        builders,
-    bool* have_log_number, uint64_t* log_number, bool* have_prev_log_number,
-    uint64_t* previous_log_number, bool* have_next_file, uint64_t* next_file,
-    bool* have_last_sequence, SequenceNumber* last_sequence,
-    uint64_t* min_log_number_to_keep, uint32_t* max_column_family) {
+    std::unordered_map<uint32_t, BaseReferencedVersionBuilder*>& builders,
+    bool* have_log_number, uint64_t* /* log_number */,
+    bool* have_prev_log_number, uint64_t* previous_log_number,
+    bool* have_next_file, uint64_t* next_file, bool* have_last_sequence,
+    SequenceNumber* last_sequence, uint64_t* min_log_number_to_keep,
+    uint32_t* max_column_family) {
   // Not found means that user didn't supply that column
   // family option AND we encountered column family add
   // record. Once we encounter column family drop record,
@@ -3395,14 +3392,14 @@ Status VersionSet::ApplyOneVersionEditToBuilder(
     } else {
       cfd = CreateColumnFamily(cf_options->second, &edit);
       cfd->set_initialized();
-      builders.insert(std::make_pair(
-          edit.column_family_, std::unique_ptr<BaseReferencedVersionBuilder>(
-                                   new BaseReferencedVersionBuilder(cfd))));
+      builders.insert(
+          {edit.column_family_, new BaseReferencedVersionBuilder(cfd)});
     }
   } else if (edit.is_column_family_drop_) {
     if (cf_in_builders) {
       auto builder = builders.find(edit.column_family_);
       assert(builder != builders.end());
+      delete builder->second;
       builders.erase(builder);
       cfd = column_family_set_->GetColumnFamily(edit.column_family_);
       assert(cfd != nullptr);
@@ -3436,18 +3433,7 @@ Status VersionSet::ApplyOneVersionEditToBuilder(
     assert(builder != builders.end());
     builder->second->version_builder()->Apply(&edit);
   }
-  return ExtractInfoFromVersionEdit(
-      cfd, edit, have_log_number, log_number, have_prev_log_number,
-      previous_log_number, have_next_file, next_file, have_last_sequence,
-      last_sequence, min_log_number_to_keep, max_column_family);
-}
 
-Status VersionSet::ExtractInfoFromVersionEdit(
-    ColumnFamilyData* cfd, const VersionEdit& edit, bool* have_log_number,
-    uint64_t* log_number, bool* have_prev_log_number,
-    uint64_t* previous_log_number, bool* have_next_file, uint64_t* next_file,
-    bool* have_last_sequence, SequenceNumber* last_sequence,
-    uint64_t* min_log_number_to_keep, uint32_t* max_column_family) {
   if (cfd != nullptr) {
     if (edit.has_log_number_) {
       if (cfd->GetLogNumber() > edit.log_number_) {
@@ -3458,7 +3444,6 @@ Status VersionSet::ExtractInfoFromVersionEdit(
       } else {
         cfd->SetLogNumber(edit.log_number_);
         *have_log_number = true;
-        *log_number = edit.log_number_;
       }
     }
     if (edit.has_comparator_ &&
@@ -3495,31 +3480,6 @@ Status VersionSet::ExtractInfoFromVersionEdit(
   return Status::OK();
 }
 
-Status VersionSet::GetCurrentManifestPath(std::string* manifest_path) {
-  assert(manifest_path != nullptr);
-  std::string fname;
-  Status s = ReadFileToString(env_, CurrentFileName(dbname_), &fname);
-  if (!s.ok()) {
-    return s;
-  }
-  if (fname.empty() || fname.back() != '\n') {
-    return Status::Corruption("CURRENT file does not end with newline");
-  }
-  // remove the trailing '\n'
-  fname.resize(fname.size() - 1);
-  FileType type;
-  bool parse_ok = ParseFileName(fname, &manifest_file_number_, &type);
-  if (!parse_ok || type != kDescriptorFile) {
-    return Status::Corruption("CURRENT file corrupted");
-  }
-  *manifest_path = dbname_;
-  if (dbname_.back() != '/') {
-    manifest_path->push_back('/');
-  }
-  *manifest_path += fname;
-  return Status::OK();
-}
-
 Status VersionSet::Recover(
     const std::vector<ColumnFamilyDescriptor>& column_families,
     bool read_only) {
@@ -3533,28 +3493,43 @@ Status VersionSet::Recover(
   std::unordered_map<int, std::string> column_families_not_found;
 
   // Read "CURRENT" file, which contains a pointer to the current manifest file
-  std::string manifest_path;
-  Status s = GetCurrentManifestPath(&manifest_path);
+  std::string manifest_filename;
+  Status s = ReadFileToString(
+      env_, CurrentFileName(dbname_), &manifest_filename
+  );
   if (!s.ok()) {
     return s;
   }
+  if (manifest_filename.empty() ||
+      manifest_filename.back() != '\n') {
+    return Status::Corruption("CURRENT file does not end with newline");
+  }
+  // remove the trailing '\n'
+  manifest_filename.resize(manifest_filename.size() - 1);
+  FileType type;
+  bool parse_ok =
+      ParseFileName(manifest_filename, &manifest_file_number_, &type);
+  if (!parse_ok || type != kDescriptorFile) {
+    return Status::Corruption("CURRENT file corrupted");
+  }
 
   ROCKS_LOG_INFO(db_options_->info_log, "Recovering from manifest file: %s\n",
-                 manifest_path.c_str());
+                 manifest_filename.c_str());
 
+  manifest_filename = dbname_ + "/" + manifest_filename;
   std::unique_ptr<SequentialFileReader> manifest_file_reader;
   {
     std::unique_ptr<SequentialFile> manifest_file;
-    s = env_->NewSequentialFile(manifest_path, &manifest_file,
+    s = env_->NewSequentialFile(manifest_filename, &manifest_file,
                                 env_->OptimizeForManifestRead(env_options_));
     if (!s.ok()) {
       return s;
     }
     manifest_file_reader.reset(
-        new SequentialFileReader(std::move(manifest_file), manifest_path));
+        new SequentialFileReader(std::move(manifest_file), manifest_filename));
   }
   uint64_t current_manifest_file_size;
-  s = env_->GetFileSize(manifest_path, &current_manifest_file_size);
+  s = env_->GetFileSize(manifest_filename, &current_manifest_file_size);
   if (!s.ok()) {
     return s;
   }
@@ -3569,8 +3544,7 @@ Status VersionSet::Recover(
   uint64_t previous_log_number = 0;
   uint32_t max_column_family = 0;
   uint64_t min_log_number_to_keep = 0;
-  std::unordered_map<uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>
-      builders;
+  std::unordered_map<uint32_t, BaseReferencedVersionBuilder*> builders;
 
   // add default column family
   auto default_cf_iter = cf_name_to_options.find(kDefaultColumnFamilyName);
@@ -3585,15 +3559,14 @@ Status VersionSet::Recover(
   // In recovery, nobody else can access it, so it's fine to set it to be
   // initialized earlier.
   default_cfd->set_initialized();
-  builders.insert(
-      std::make_pair(0, std::unique_ptr<BaseReferencedVersionBuilder>(
-                            new BaseReferencedVersionBuilder(default_cfd))));
+  builders.insert({0, new BaseReferencedVersionBuilder(default_cfd)});
 
   {
     VersionSet::LogReporter reporter;
     reporter.status = &s;
     log::Reader reader(nullptr, std::move(manifest_file_reader), &reporter,
-                       true /* checksum */, 0 /* log_number */);
+                       true /* checksum */, 0 /* log_number */,
+                       false /* retry_after_eof */);
     Slice record;
     std::string scratch;
     std::vector<VersionEdit> replay_buffer;
@@ -3624,7 +3597,7 @@ Status VersionSet::Recover(
           TEST_SYNC_POINT_CALLBACK("VersionSet::Recover:LastInAtomicGroup",
                                    &edit);
           for (auto& e : replay_buffer) {
-            s = ApplyOneVersionEditToBuilder(
+            s = ApplyOneVersionEdit(
                 e, cf_name_to_options, column_families_not_found, builders,
                 &have_log_number, &log_number, &have_prev_log_number,
                 &previous_log_number, &have_next_file, &next_file,
@@ -3645,7 +3618,7 @@ Status VersionSet::Recover(
           s = Status::Corruption("corrupted atomic group");
           break;
         }
-        s = ApplyOneVersionEditToBuilder(
+        s = ApplyOneVersionEdit(
             edit, cf_name_to_options, column_families_not_found, builders,
             &have_log_number, &log_number, &have_prev_log_number,
             &previous_log_number, &have_next_file, &next_file,
@@ -3716,7 +3689,7 @@ Status VersionSet::Recover(
       assert(cfd->initialized());
       auto builders_iter = builders.find(cfd->GetID());
       assert(builders_iter != builders.end());
-      auto builder = builders_iter->second->version_builder();
+      auto* builder = builders_iter->second->version_builder();
 
       // unlimited table cache. Pre-load table handle now.
       // Need to do it out of the mutex.
@@ -3747,26 +3720,30 @@ Status VersionSet::Recover(
     ROCKS_LOG_INFO(
         db_options_->info_log,
         "Recovered from manifest file:%s succeeded,"
-        "manifest_file_number is %" PRIu64 ", next_file_number is %" PRIu64
-        ", last_sequence is %" PRIu64 ", log_number is %" PRIu64
-        ",prev_log_number is %" PRIu64 ",max_column_family is %" PRIu32
-        ",min_log_number_to_keep is %" PRIu64 "\n",
-        manifest_path.c_str(), manifest_file_number_,
-        next_file_number_.load(), last_sequence_.load(), log_number,
-        prev_log_number_, column_family_set_->GetMaxColumnFamily(),
-        min_log_number_to_keep_2pc());
+        "manifest_file_number is %lu, next_file_number is %lu, "
+        "last_sequence is %lu, log_number is %lu,"
+        "prev_log_number is %lu,"
+        "max_column_family is %u,"
+        "min_log_number_to_keep is %lu\n",
+        manifest_filename.c_str(), (unsigned long)manifest_file_number_,
+        (unsigned long)next_file_number_.load(), (unsigned long)last_sequence_,
+        (unsigned long)log_number, (unsigned long)prev_log_number_,
+        column_family_set_->GetMaxColumnFamily(), min_log_number_to_keep_2pc());
 
     for (auto cfd : *column_family_set_) {
       if (cfd->IsDropped()) {
         continue;
       }
       ROCKS_LOG_INFO(db_options_->info_log,
-                     "Column family [%s] (ID %" PRIu32
-                     "), log number is %" PRIu64 "\n",
+                     "Column family [%s] (ID %u), log number is %" PRIu64 "\n",
                      cfd->GetName().c_str(), cfd->GetID(), cfd->GetLogNumber());
     }
   }
 
+  for (auto& builder : builders) {
+    delete builder.second;
+  }
+
   return s;
 }
 
@@ -3804,7 +3781,8 @@ Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
   VersionSet::LogReporter reporter;
   reporter.status = &s;
   log::Reader reader(nullptr, std::move(file_reader), &reporter,
-                     true /* checksum */, 0 /* log_number */);
+                     true /* checksum */, 0 /* log_number */,
+                     false /* retry_after_eof */);
   Slice record;
   std::string scratch;
   while (reader.ReadRecord(&record, &scratch) && s.ok()) {
@@ -3950,8 +3928,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
   uint64_t previous_log_number = 0;
   int count = 0;
   std::unordered_map<uint32_t, std::string> comparators;
-  std::unordered_map<uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>
-      builders;
+  std::unordered_map<uint32_t, BaseReferencedVersionBuilder*> builders;
 
   // add default column family
   VersionEdit default_cf_edit;
@@ -3959,15 +3936,14 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
   default_cf_edit.SetColumnFamily(0);
   ColumnFamilyData* default_cfd =
       CreateColumnFamily(ColumnFamilyOptions(options), &default_cf_edit);
-  builders.insert(
-      std::make_pair(0, std::unique_ptr<BaseReferencedVersionBuilder>(
-                            new BaseReferencedVersionBuilder(default_cfd))));
+  builders.insert({0, new BaseReferencedVersionBuilder(default_cfd)});
 
   {
     VersionSet::LogReporter reporter;
     reporter.status = &s;
     log::Reader reader(nullptr, std::move(file_reader), &reporter,
-                       true /* checksum */, 0 /* log_number */);
+                       true /* checksum */, 0 /* log_number */,
+                       false /* retry_after_eof */);
     Slice record;
     std::string scratch;
     while (reader.ReadRecord(&record, &scratch) && s.ok()) {
@@ -4002,9 +3978,8 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
         }
         cfd = CreateColumnFamily(ColumnFamilyOptions(options), &edit);
         cfd->set_initialized();
-        builders.insert(std::make_pair(
-            edit.column_family_, std::unique_ptr<BaseReferencedVersionBuilder>(
-                                     new BaseReferencedVersionBuilder(cfd))));
+        builders.insert(
+            {edit.column_family_, new BaseReferencedVersionBuilder(cfd)});
       } else if (edit.is_column_family_drop_) {
         if (!cf_in_builders) {
           s = Status::Corruption(
@@ -4012,6 +3987,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
           break;
         }
         auto builder_iter = builders.find(edit.column_family_);
+        delete builder_iter->second;
         builders.erase(builder_iter);
         comparators.erase(edit.column_family_);
         cfd = column_family_set_->GetColumnFamily(edit.column_family_);
@@ -4098,10 +4074,9 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
       builder->SaveTo(v->storage_info());
       v->PrepareApply(*cfd->GetLatestMutableCFOptions(), false);
 
-      printf("--------------- Column family \"%s\"  (ID %" PRIu32
-             ") --------------\n",
-             cfd->GetName().c_str(), cfd->GetID());
-      printf("log number: %" PRIu64 "\n", cfd->GetLogNumber());
+      printf("--------------- Column family \"%s\"  (ID %u) --------------\n",
+             cfd->GetName().c_str(), (unsigned int)cfd->GetID());
+      printf("log number: %lu\n", (unsigned long)cfd->GetLogNumber());
       auto comparator = comparators.find(cfd->GetID());
       if (comparator != comparators.end()) {
         printf("comparator: %s\n", comparator->second.c_str());
@@ -4112,19 +4087,24 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
       delete v;
     }
 
+    // Free builders
+    for (auto& builder : builders) {
+      delete builder.second;
+    }
+
     next_file_number_.store(next_file + 1);
     last_allocated_sequence_ = last_sequence;
     last_published_sequence_ = last_sequence;
     last_sequence_ = last_sequence;
     prev_log_number_ = previous_log_number;
 
-    printf("next_file_number %" PRIu64 " last_sequence %" PRIu64
-           "  prev_log_number %" PRIu64 " max_column_family %" PRIu32
-           " min_log_number_to_keep "
-           "%" PRIu64 "\n",
-           next_file_number_.load(), last_sequence, previous_log_number,
-           column_family_set_->GetMaxColumnFamily(),
-           min_log_number_to_keep_2pc());
+    printf(
+        "next_file_number %lu last_sequence "
+        "%lu  prev_log_number %lu max_column_family %u min_log_number_to_keep "
+        "%" PRIu64 "\n",
+        (unsigned long)next_file_number_.load(), (unsigned long)last_sequence,
+        (unsigned long)previous_log_number,
+        column_family_set_->GetMaxColumnFamily(), min_log_number_to_keep_2pc());
   }
 
   return s;
@@ -4603,405 +4583,4 @@ uint64_t VersionSet::GetTotalSstFilesSize(Version* dummy_versions) {
   return total_files_size;
 }
 
-ReactiveVersionSet::ReactiveVersionSet(const std::string& dbname,
-                                       const ImmutableDBOptions* _db_options,
-                                       const EnvOptions& _env_options,
-                                       Cache* table_cache,
-                                       WriteBufferManager* write_buffer_manager,
-                                       WriteController* write_controller)
-    : VersionSet(dbname, _db_options, _env_options, table_cache,
-                 write_buffer_manager, write_controller) {}
-
-ReactiveVersionSet::~ReactiveVersionSet() {}
-
-Status ReactiveVersionSet::Recover(
-    const std::vector<ColumnFamilyDescriptor>& column_families,
-    std::unique_ptr<log::FragmentBufferedReader>* manifest_reader,
-    std::unique_ptr<log::Reader::Reporter>* manifest_reporter,
-    std::unique_ptr<Status>* manifest_reader_status) {
-  assert(manifest_reader != nullptr);
-  assert(manifest_reporter != nullptr);
-  assert(manifest_reader_status != nullptr);
-
-  std::unordered_map<std::string, ColumnFamilyOptions> cf_name_to_options;
-  for (const auto& cf : column_families) {
-    cf_name_to_options.insert({cf.name, cf.options});
-  }
-
-  // add default column family
-  auto default_cf_iter = cf_name_to_options.find(kDefaultColumnFamilyName);
-  if (default_cf_iter == cf_name_to_options.end()) {
-    return Status::InvalidArgument("Default column family not specified");
-  }
-  VersionEdit default_cf_edit;
-  default_cf_edit.AddColumnFamily(kDefaultColumnFamilyName);
-  default_cf_edit.SetColumnFamily(0);
-  ColumnFamilyData* default_cfd =
-      CreateColumnFamily(default_cf_iter->second, &default_cf_edit);
-  // In recovery, nobody else can access it, so it's fine to set it to be
-  // initialized earlier.
-  default_cfd->set_initialized();
-
-  bool have_log_number = false;
-  bool have_prev_log_number = false;
-  bool have_next_file = false;
-  bool have_last_sequence = false;
-  uint64_t next_file = 0;
-  uint64_t last_sequence = 0;
-  uint64_t log_number = 0;
-  uint64_t previous_log_number = 0;
-  uint32_t max_column_family = 0;
-  uint64_t min_log_number_to_keep = 0;
-  std::unordered_map<uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>
-      builders;
-  std::unordered_map<int, std::string> column_families_not_found;
-  builders.insert(
-      std::make_pair(0, std::unique_ptr<BaseReferencedVersionBuilder>(
-                            new BaseReferencedVersionBuilder(default_cfd))));
-
-  manifest_reader_status->reset(new Status());
-  manifest_reporter->reset(new LogReporter());
-  static_cast<LogReporter*>(manifest_reporter->get())->status =
-      manifest_reader_status->get();
-  Status s = MaybeSwitchManifest(manifest_reporter->get(), manifest_reader);
-  log::Reader* reader = manifest_reader->get();
-
-  int retry = 0;
-  while (s.ok() && retry < 1) {
-    assert(reader != nullptr);
-    Slice record;
-    std::string scratch;
-    while (s.ok() && reader->ReadRecord(&record, &scratch)) {
-      VersionEdit edit;
-      s = edit.DecodeFrom(record);
-      if (!s.ok()) {
-        break;
-      }
-      s = ApplyOneVersionEditToBuilder(
-          edit, cf_name_to_options, column_families_not_found, builders,
-          &have_log_number, &log_number, &have_prev_log_number,
-          &previous_log_number, &have_next_file, &next_file,
-          &have_last_sequence, &last_sequence, &min_log_number_to_keep,
-          &max_column_family);
-    }
-    if (s.ok()) {
-      bool enough = have_next_file && have_log_number && have_last_sequence;
-      if (enough) {
-        for (const auto& cf : column_families) {
-          auto cfd = column_family_set_->GetColumnFamily(cf.name);
-          if (cfd == nullptr) {
-            enough = false;
-            break;
-          }
-        }
-      }
-      if (enough) {
-        for (const auto& cf : column_families) {
-          auto cfd = column_family_set_->GetColumnFamily(cf.name);
-          assert(cfd != nullptr);
-          if (!cfd->IsDropped()) {
-            auto builder_iter = builders.find(cfd->GetID());
-            assert(builder_iter != builders.end());
-            auto builder = builder_iter->second->version_builder();
-            assert(builder != nullptr);
-            s = builder->LoadTableHandlers(
-                cfd->internal_stats(), db_options_->max_file_opening_threads,
-                false /* prefetch_index_and_filter_in_cache */,
-                true /* is_initial_load */,
-                cfd->GetLatestMutableCFOptions()->prefix_extractor.get());
-            if (!s.ok()) {
-              enough = false;
-              if (s.IsPathNotFound()) {
-                s = Status::OK();
-              }
-              break;
-            }
-          }
-        }
-      }
-      if (enough) {
-        break;
-      }
-    }
-    ++retry;
-  }
-
-  if (s.ok()) {
-    if (!have_prev_log_number) {
-      previous_log_number = 0;
-    }
-    column_family_set_->UpdateMaxColumnFamily(max_column_family);
-
-    MarkMinLogNumberToKeep2PC(min_log_number_to_keep);
-    MarkFileNumberUsed(previous_log_number);
-    MarkFileNumberUsed(log_number);
-
-    for (auto cfd : *column_family_set_) {
-      assert(builders.count(cfd->GetID()) > 0);
-      auto builder = builders[cfd->GetID()]->version_builder();
-      if (!builder->CheckConsistencyForNumLevels()) {
-        s = Status::InvalidArgument(
-            "db has more levels than options.num_levels");
-        break;
-      }
-    }
-  }
-
-  if (s.ok()) {
-    for (auto cfd : *column_family_set_) {
-      if (cfd->IsDropped()) {
-        continue;
-      }
-      assert(cfd->initialized());
-      auto builders_iter = builders.find(cfd->GetID());
-      assert(builders_iter != builders.end());
-      auto* builder = builders_iter->second->version_builder();
-
-      Version* v = new Version(cfd, this, env_options_,
-                               *cfd->GetLatestMutableCFOptions(),
-                               current_version_number_++);
-      builder->SaveTo(v->storage_info());
-
-      // Install recovered version
-      v->PrepareApply(*cfd->GetLatestMutableCFOptions(),
-                      !(db_options_->skip_stats_update_on_db_open));
-      AppendVersion(cfd, v);
-    }
-    next_file_number_.store(next_file + 1);
-    last_allocated_sequence_ = last_sequence;
-    last_published_sequence_ = last_sequence;
-    last_sequence_ = last_sequence;
-    prev_log_number_ = previous_log_number;
-    for (auto cfd : *column_family_set_) {
-      if (cfd->IsDropped()) {
-        continue;
-      }
-      ROCKS_LOG_INFO(db_options_->info_log,
-                     "Column family [%s] (ID %u), log number is %" PRIu64 "\n",
-                     cfd->GetName().c_str(), cfd->GetID(), cfd->GetLogNumber());
-    }
-  }
-  return s;
-}
-
-Status ReactiveVersionSet::ReadAndApply(
-    InstrumentedMutex* mu,
-    std::unique_ptr<log::FragmentBufferedReader>* manifest_reader,
-    std::unordered_set<ColumnFamilyData*>* cfds_changed) {
-  assert(manifest_reader != nullptr);
-  assert(cfds_changed != nullptr);
-  mu->AssertHeld();
-
-  Status s;
-  bool have_log_number = false;
-  bool have_prev_log_number = false;
-  bool have_next_file = false;
-  bool have_last_sequence = false;
-  uint64_t next_file = 0;
-  uint64_t last_sequence = 0;
-  uint64_t log_number = 0;
-  uint64_t previous_log_number = 0;
-  uint32_t max_column_family = 0;
-  uint64_t min_log_number_to_keep = 0;
-
-  while (s.ok()) {
-    Slice record;
-    std::string scratch;
-    log::Reader* reader = manifest_reader->get();
-    std::string old_manifest_path = reader->file()->file_name();
-    while (reader->ReadRecord(&record, &scratch)) {
-      VersionEdit edit;
-      s = edit.DecodeFrom(record);
-      if (!s.ok()) {
-        break;
-      }
-      ColumnFamilyData* cfd =
-          column_family_set_->GetColumnFamily(edit.column_family_);
-      // If we cannot find this column family in our column family set, then it
-      // may be a new column family created by the primary after the secondary
-      // starts. Ignore it for now.
-      if (nullptr == cfd) {
-        continue;
-      }
-      if (active_version_builders_.find(edit.column_family_) ==
-          active_version_builders_.end()) {
-        std::unique_ptr<BaseReferencedVersionBuilder> builder_guard(
-            new BaseReferencedVersionBuilder(cfd));
-        active_version_builders_.insert(
-            std::make_pair(edit.column_family_, std::move(builder_guard)));
-      }
-      s = ApplyOneVersionEditToBuilder(
-          edit, &have_log_number, &log_number, &have_prev_log_number,
-          &previous_log_number, &have_next_file, &next_file,
-          &have_last_sequence, &last_sequence, &min_log_number_to_keep,
-          &max_column_family);
-      if (!s.ok()) {
-        break;
-      }
-      auto builder_iter = active_version_builders_.find(edit.column_family_);
-      assert(builder_iter != active_version_builders_.end());
-      auto builder = builder_iter->second->version_builder();
-      assert(builder != nullptr);
-      s = builder->LoadTableHandlers(
-          cfd->internal_stats(), db_options_->max_file_opening_threads,
-          false /* prefetch_index_and_filter_in_cache */,
-          false /* is_initial_load */,
-          cfd->GetLatestMutableCFOptions()->prefix_extractor.get());
-      TEST_SYNC_POINT_CALLBACK(
-          "ReactiveVersionSet::ReadAndApply:AfterLoadTableHandlers", &s);
-      if (!s.ok() && !s.IsPathNotFound()) {
-        break;
-      } else if (s.IsPathNotFound()) {
-        s = Status::OK();
-      } else {  // s.ok() == true
-        auto version = new Version(cfd, this, env_options_,
-                                   *cfd->GetLatestMutableCFOptions(),
-                                   current_version_number_++);
-        builder->SaveTo(version->storage_info());
-        version->PrepareApply(*cfd->GetLatestMutableCFOptions(), true);
-        AppendVersion(cfd, version);
-        active_version_builders_.erase(builder_iter);
-        if (cfds_changed->count(cfd) == 0) {
-          cfds_changed->insert(cfd);
-        }
-      }
-      if (have_next_file) {
-        next_file_number_.store(next_file + 1);
-      }
-      if (have_last_sequence) {
-        last_allocated_sequence_ = last_sequence;
-        last_published_sequence_ = last_sequence;
-        last_sequence_ = last_sequence;
-      }
-      if (have_prev_log_number) {
-        prev_log_number_ = previous_log_number;
-        MarkFileNumberUsed(previous_log_number);
-      }
-      if (have_log_number) {
-        MarkFileNumberUsed(log_number);
-      }
-      column_family_set_->UpdateMaxColumnFamily(max_column_family);
-      MarkMinLogNumberToKeep2PC(min_log_number_to_keep);
-    }
-    // It's possible that:
-    // 1) s.IsCorruption(), indicating the current MANIFEST is corrupted.
-    // 2) we have finished reading the current MANIFEST.
-    // 3) we have encountered an IOError reading the current MANIFEST.
-    // We need to look for the next MANIFEST and start from there. If we cannot
-    // find the next MANIFEST, we should exit the loop.
-    s = MaybeSwitchManifest(reader->GetReporter(), manifest_reader);
-    reader = manifest_reader->get();
-    if (s.ok() && reader->file()->file_name() == old_manifest_path) {
-      break;
-    }
-  }
-
-  if (s.ok()) {
-    for (auto cfd : *column_family_set_) {
-      auto builder_iter = active_version_builders_.find(cfd->GetID());
-      if (builder_iter == active_version_builders_.end()) {
-        continue;
-      }
-      auto builder = builder_iter->second->version_builder();
-      if (!builder->CheckConsistencyForNumLevels()) {
-        s = Status::InvalidArgument(
-            "db has more levels than options.num_levels");
-        break;
-      }
-    }
-  }
-  return s;
-}
-
-Status ReactiveVersionSet::ApplyOneVersionEditToBuilder(
-    VersionEdit& edit, bool* have_log_number, uint64_t* log_number,
-    bool* have_prev_log_number, uint64_t* previous_log_number,
-    bool* have_next_file, uint64_t* next_file, bool* have_last_sequence,
-    SequenceNumber* last_sequence, uint64_t* min_log_number_to_keep,
-    uint32_t* max_column_family) {
-  ColumnFamilyData* cfd = nullptr;
-  Status status;
-  if (edit.is_column_family_add_) {
-    // TODO (yanqin) for now the secondary ignores column families created
-    // after Open. This also simplifies handling of switching to a new MANIFEST
-    // and processing the snapshot of the system at the beginning of the
-    // MANIFEST.
-    return Status::OK();
-  } else if (edit.is_column_family_drop_) {
-    cfd = column_family_set_->GetColumnFamily(edit.column_family_);
-    // Drop a CF created by primary after secondary starts? Then ignore
-    if (cfd == nullptr) {
-      return Status::OK();
-    }
-    // Drop the column family by setting it to be 'dropped' without destroying
-    // the column family handle.
-    cfd->SetDropped();
-    if (cfd->Unref()) {
-      delete cfd;
-      cfd = nullptr;
-    }
-  } else {
-    cfd = column_family_set_->GetColumnFamily(edit.column_family_);
-    // Operation on a CF created after Open? Then ignore
-    if (cfd == nullptr) {
-      return Status::OK();
-    }
-    auto builder_iter = active_version_builders_.find(edit.column_family_);
-    assert(builder_iter != active_version_builders_.end());
-    auto builder = builder_iter->second->version_builder();
-    assert(builder != nullptr);
-    builder->Apply(&edit);
-  }
-  return ExtractInfoFromVersionEdit(
-      cfd, edit, have_log_number, log_number, have_prev_log_number,
-      previous_log_number, have_next_file, next_file, have_last_sequence,
-      last_sequence, min_log_number_to_keep, max_column_family);
-}
-
-Status ReactiveVersionSet::MaybeSwitchManifest(
-    log::Reader::Reporter* reporter,
-    std::unique_ptr<log::FragmentBufferedReader>* manifest_reader) {
-  assert(manifest_reader != nullptr);
-  Status s;
-  do {
-    std::string manifest_path;
-    s = GetCurrentManifestPath(&manifest_path);
-    std::unique_ptr<SequentialFile> manifest_file;
-    if (s.ok()) {
-      if (nullptr == manifest_reader->get() ||
-          manifest_reader->get()->file()->file_name() != manifest_path) {
-        TEST_SYNC_POINT(
-            "ReactiveVersionSet::MaybeSwitchManifest:"
-            "AfterGetCurrentManifestPath:0");
-        TEST_SYNC_POINT(
-            "ReactiveVersionSet::MaybeSwitchManifest:"
-            "AfterGetCurrentManifestPath:1");
-        s = env_->NewSequentialFile(
-            manifest_path, &manifest_file,
-            env_->OptimizeForManifestRead(env_options_));
-      } else {
-        // No need to switch manifest.
-        break;
-      }
-    }
-    std::unique_ptr<SequentialFileReader> manifest_file_reader;
-    if (s.ok()) {
-      manifest_file_reader.reset(
-          new SequentialFileReader(std::move(manifest_file), manifest_path));
-      manifest_reader->reset(new log::FragmentBufferedReader(
-          nullptr, std::move(manifest_file_reader), reporter,
-          true /* checksum */, 0 /* log_number */));
-      ROCKS_LOG_INFO(db_options_->info_log, "Switched to new manifest: %s\n",
-                     manifest_path.c_str());
-      // TODO (yanqin) every time we switch to a new MANIFEST, we clear the
-      // active_version_builders_ map because we choose to construct the
-      // versions from scratch, thanks to the first part of each MANIFEST
-      // written by VersionSet::WriteSnapshot. This is not necessary, but we
-      // choose this at present for the sake of simplicity.
-      active_version_builders_.clear();
-    }
-  } while (s.IsPathNotFound());
-  return s;
-}
-
 }  // namespace rocksdb

db/version_set.h

@@ -402,10 +402,6 @@ class VersionStorageInfo {
 
   bool force_consistency_checks() const { return force_consistency_checks_; }
 
-  SequenceNumber bottommost_files_mark_threshold() const {
-    return bottommost_files_mark_threshold_;
-  }
-
   // Returns whether any key in [`smallest_key`, `largest_key`] could appear in
   // an older L0 file than `last_l0_idx` or in a greater level than `last_level`
   //
@@ -648,7 +644,6 @@ class Version {
 
  private:
   Env* env_;
-  friend class ReactiveVersionSet;
   friend class VersionSet;
 
   const InternalKeyComparator* internal_comparator() const {
@@ -740,7 +735,9 @@ struct ObsoleteFileInfo {
   }
 };
 
+namespace {
 class BaseReferencedVersionBuilder;
+}
 
 class VersionSet {
  public:
@@ -748,7 +745,7 @@ class VersionSet {
              const EnvOptions& env_options, Cache* table_cache,
              WriteBufferManager* write_buffer_manager,
              WriteController* write_controller);
-  virtual ~VersionSet();
+  ~VersionSet();
 
   // Apply *edit to the current version to form a new descriptor that
   // is both saved to persistent state and installed as the new
@@ -794,7 +791,7 @@ class VersionSet {
   // The across-multi-cf batch version. If edit_lists contain more than
   // 1 version edits, caller must ensure that no edit in the []list is column
   // family manipulation.
-  virtual Status LogAndApply(
+  Status LogAndApply(
       const autovector<ColumnFamilyData*>& cfds,
       const autovector<const MutableCFOptions*>& mutable_cf_options_list,
       const autovector<autovector<VersionEdit*>>& edit_lists,
@@ -802,8 +799,6 @@ class VersionSet {
       bool new_descriptor_log = false,
       const ColumnFamilyOptions* new_cf_options = nullptr);
 
-  Status GetCurrentManifestPath(std::string* manifest_filename);
-
   // Recover the last saved descriptor from persistent storage.
   // If read_only == true, Recover() will not complain if some column families
   // are not opened
@@ -984,12 +979,11 @@ class VersionSet {
 
   static uint64_t GetTotalSstFilesSize(Version* dummy_versions);
 
- protected:
+ private:
   struct ManifestWriter;
 
   friend class Version;
   friend class DBImpl;
-  friend class DBImplReadOnly;
 
   struct LogReporter : public log::Reader::Reporter {
     Status* status;
@@ -1013,24 +1007,20 @@ class VersionSet {
   ColumnFamilyData* CreateColumnFamily(const ColumnFamilyOptions& cf_options,
                                        VersionEdit* edit);
 
-  // REQUIRES db mutex
-  Status ApplyOneVersionEditToBuilder(
+  Status ApplyOneVersionEdit(
       VersionEdit& edit,
       const std::unordered_map<std::string, ColumnFamilyOptions>& name_to_opts,
       std::unordered_map<int, std::string>& column_families_not_found,
-      std::unordered_map<
-          uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>& builders,
+      std::unordered_map<uint32_t, BaseReferencedVersionBuilder*>& builders,
       bool* have_log_number, uint64_t* log_number, bool* have_prev_log_number,
       uint64_t* previous_log_number, bool* have_next_file, uint64_t* next_file,
       bool* have_last_sequence, SequenceNumber* last_sequence,
       uint64_t* min_log_number_to_keep, uint32_t* max_column_family);
 
-  Status ExtractInfoFromVersionEdit(
-      ColumnFamilyData* cfd, const VersionEdit& edit, bool* have_log_number,
-      uint64_t* log_number, bool* have_prev_log_number,
-      uint64_t* previous_log_number, bool* have_next_file, uint64_t* next_file,
-      bool* have_last_sequence, SequenceNumber* last_sequence,
-      uint64_t* min_log_number_to_keep, uint32_t* max_column_family);
+  Status ProcessManifestWrites(std::deque<ManifestWriter>& writers,
+                               InstrumentedMutex* mu, Directory* db_directory,
+                               bool new_descriptor_log,
+                               const ColumnFamilyOptions* new_cf_options);
 
   std::unique_ptr<ColumnFamilySet> column_family_set_;
 
@@ -1080,77 +1070,13 @@ class VersionSet {
   // env options for all reads and writes except compactions
   EnvOptions env_options_;
 
- private:
   // No copying allowed
   VersionSet(const VersionSet&);
   void operator=(const VersionSet&);
 
-  // REQUIRES db mutex at beginning. may release and re-acquire db mutex
-  Status ProcessManifestWrites(std::deque<ManifestWriter>& writers,
-                               InstrumentedMutex* mu, Directory* db_directory,
-                               bool new_descriptor_log,
-                               const ColumnFamilyOptions* new_cf_options);
-
   void LogAndApplyCFHelper(VersionEdit* edit);
-  void LogAndApplyHelper(ColumnFamilyData* cfd, VersionBuilder* b,
+  void LogAndApplyHelper(ColumnFamilyData* cfd, VersionBuilder* b, Version* v,
                          VersionEdit* edit, InstrumentedMutex* mu);
 };
 
-class ReactiveVersionSet : public VersionSet {
- public:
-  ReactiveVersionSet(const std::string& dbname,
-                     const ImmutableDBOptions* _db_options,
-                     const EnvOptions& _env_options, Cache* table_cache,
-                     WriteBufferManager* write_buffer_manager,
-                     WriteController* write_controller);
-
-  ~ReactiveVersionSet() override;
-
-  Status ReadAndApply(
-      InstrumentedMutex* mu,
-      std::unique_ptr<log::FragmentBufferedReader>* manifest_reader,
-      std::unordered_set<ColumnFamilyData*>* cfds_changed);
-
-  Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
-                 std::unique_ptr<log::FragmentBufferedReader>* manifest_reader,
-                 std::unique_ptr<log::Reader::Reporter>* manifest_reporter,
-                 std::unique_ptr<Status>* manifest_reader_status);
-
- protected:
-  using VersionSet::ApplyOneVersionEditToBuilder;
-
-  // REQUIRES db mutex
-  Status ApplyOneVersionEditToBuilder(
-      VersionEdit& edit, bool* have_log_number, uint64_t* log_number,
-      bool* have_prev_log_number, uint64_t* previous_log_number,
-      bool* have_next_file, uint64_t* next_file, bool* have_last_sequence,
-      SequenceNumber* last_sequence, uint64_t* min_log_number_to_keep,
-      uint32_t* max_column_family);
-
-  Status MaybeSwitchManifest(
-      log::Reader::Reporter* reporter,
-      std::unique_ptr<log::FragmentBufferedReader>* manifest_reader);
-
- private:
-  std::unordered_map<uint32_t, std::unique_ptr<BaseReferencedVersionBuilder>>
-      active_version_builders_;
-
-  using VersionSet::LogAndApply;
-  using VersionSet::Recover;
-
-  Status LogAndApply(
-      const autovector<ColumnFamilyData*>& /*cfds*/,
-      const autovector<const MutableCFOptions*>& /*mutable_cf_options_list*/,
-      const autovector<autovector<VersionEdit*>>& /*edit_lists*/,
-      InstrumentedMutex* /*mu*/, Directory* /*db_directory*/,
-      bool /*new_descriptor_log*/,
-      const ColumnFamilyOptions* /*new_cf_option*/) override {
-    return Status::NotSupported("not supported in reactive mode");
-  }
-
-  // No copy allowed
-  ReactiveVersionSet(const ReactiveVersionSet&);
-  ReactiveVersionSet& operator=(const ReactiveVersionSet&);
-};
-
 }  // namespace rocksdb

db/wal_manager.cc

@@ -29,7 +29,6 @@
 #include "util/cast_util.h"
 #include "util/coding.h"
 #include "util/file_reader_writer.h"
-#include "util/file_util.h"
 #include "util/filename.h"
 #include "util/logging.h"
 #include "util/mutexlock.h"
@@ -191,7 +190,7 @@ void WalManager::PurgeObsoleteWALFiles() {
           continue;
         }
         if (now_seconds - file_m_time > db_options_.wal_ttl_seconds) {
-          s = DeleteDBFile(&db_options_, file_path, archival_dir, false);
+          s = env_->DeleteFile(file_path);
           if (!s.ok()) {
             ROCKS_LOG_WARN(db_options_.info_log, "Can't delete file: %s: %s",
                            file_path.c_str(), s.ToString().c_str());
@@ -217,7 +216,7 @@ void WalManager::PurgeObsoleteWALFiles() {
             log_file_size = std::max(log_file_size, file_size);
             ++log_files_num;
           } else {
-            s = DeleteDBFile(&db_options_, file_path, archival_dir, false);
+            s = env_->DeleteFile(file_path);
             if (!s.ok()) {
               ROCKS_LOG_WARN(db_options_.info_log,
                              "Unable to delete file: %s: %s", file_path.c_str(),
@@ -256,8 +255,7 @@ void WalManager::PurgeObsoleteWALFiles() {
 
   for (size_t i = 0; i < files_del_num; ++i) {
     std::string const file_path = archived_logs[i]->PathName();
-    s = DeleteDBFile(&db_options_, db_options_.wal_dir + "/" + file_path,
-                     db_options_.wal_dir, false);
+    s = env_->DeleteFile(db_options_.wal_dir + "/" + file_path);
     if (!s.ok()) {
       ROCKS_LOG_WARN(db_options_.info_log, "Unable to delete file: %s: %s",
                      file_path.c_str(), s.ToString().c_str());
@@ -459,7 +457,7 @@ Status WalManager::ReadFirstLine(const std::string& fname,
   reporter.status = &status;
   reporter.ignore_error = !db_options_.paranoid_checks;
   log::Reader reader(db_options_.info_log, std::move(file_reader), &reporter,
-                     true /*checksum*/, number);
+                     true /*checksum*/, number, false /* retry_after_eof */);
   std::string scratch;
   Slice record;
 

db/write_callback_test.cc

@@ -295,8 +295,8 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
                    public:
                     PublishSeqCallback(DBImpl* db_impl_in)
                         : db_impl_(db_impl_in) {}
-                    Status Callback(SequenceNumber last_seq, bool /*not used*/,
-                                    uint64_t) override {
+                    Status Callback(SequenceNumber last_seq,
+                                    bool /*not used*/) override {
                       db_impl_->SetLastPublishedSequence(last_seq);
                       return Status::OK();
                     }

docs/_posts/2019-03-08-format-version-4.markdown

@@ -1,36 +0,0 @@
----
-title: format_version 4
-layout: post
-author: maysamyabandeh
-category: blog
----
-
-The data blocks in RocksDB consist of a sequence of key/values pairs sorted by key, where the pairs are grouped into _restart intervals_ specified by `block_restart_interval`. Up to RocksDB version 5.14, where the latest and default value of `BlockBasedTableOptions::format_version` is 2, the format of index and data blocks are the same: index blocks use the same key format of <`user_key`,`seq`> and encode pointers to data blocks, <`offset`,`size`>, to a byte string and use them as values. The only difference is that the index blocks use `index_block_restart_interval` for the size of _restart intervals_. `format_version=`3,4 offer more optimized, backward-compatible, yet forward-incompatible format for index blocks. 
-
-### Pros
-
-Using `format_version`=4 significantly reduces the index block size, in some cases around 4-5x. This frees more space in block cache, which would result in higher hit rate for data and filter blocks, or offer the same performance with a smaller block cache size.
-
-### Cons
-
-Being _forward-incompatible_ means that if you enable `format_version=`4 you cannot downgrade to a RocksDB version lower than 5.16.
-
-### How to use it?
-
-- `BlockBasedTableOptions::format_version` = 4
-- `BlockBasedTableOptions::index_block_restart_interval` = 16
-
-### What is format_version 3?
-(Since RocksDB 5.15) In most cases, the sequence number `seq` is not necessary for keys in the index blocks. In such cases, `format_version`=3 skips encoding the sequence number and sets `index_key_is_user_key` in TableProperties, which is used by the reader to know how to decode the index block.
-
-### What is format_version 4?
-(Since RocksDB 5.16) Changes the format of index blocks by delta encoding the index values, which are the block handles. This saves the encoding of `BlockHandle::offset` of the non-head index entries in each restart interval. If used, `TableProperties::index_value_is_delta_encoded` is set, which is used by the reader to know how to decode the index block.  The format of each key is (shared_size, non_shared_size, shared, non_shared). The format of each value, i.e., block handle, is (offset, size) whenever the shared_size is 0, which included the first entry in each restart point. Otherwise the format is delta-size = block handle size - size of last block handle.
-
-The index format in `format_version=4` would be as follows:
-
-    restart_point   0: k, v (off, sz), k, v (delta-sz), ..., k, v (delta-sz)
-    restart_point   1: k, v (off, sz), k, v (delta-sz), ..., k, v (delta-sz)
-    ...
-    restart_point n-1: k, v (off, sz), k, v (delta-sz), ..., k, v (delta-sz)
-    where, k is key, v is value, and its encoding is in parenthesis.
-

env/env.cc

@@ -30,8 +30,6 @@ std::string Env::PriorityToString(Env::Priority priority) {
       return "Low";
     case Env::Priority::HIGH:
       return "High";
-    case Env::Priority::USER:
-      return "User";
     case Env::Priority::TOTAL:
       assert(false);
   }

env/env_encryption.cc

@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <cctype>
 #include <iostream>
-#include <cassert>
 
 #include "rocksdb/env_encryption.h"
 #include "util/aligned_buffer.h"
@@ -734,8 +733,6 @@ Status BlockAccessCipherStream::Decrypt(uint64_t fileOffset, char *data, size_t
   std::string scratch;
   AllocateScratch(scratch);
 
-  assert(fileOffset < dataSize);
-
   // Decrypt individual blocks.
   while (1) {
     char *block = data;
@@ -759,14 +756,6 @@ Status BlockAccessCipherStream::Decrypt(uint64_t fileOffset, char *data, size_t
       // Copy decrypted data back to `data`.
       memmove(data, block + blockOffset, n);
     }
-
-    // Simply decrementing dataSize by n could cause it to underflow,
-    // which will very likely make it read over the original bounds later
-    assert(dataSize >= n);
-    if (dataSize < n) {
-      return Status::Corruption("Cannot decrypt data at given offset");
-    }
-
     dataSize -= n;
     if (dataSize == 0) {
       return Status::OK();
@@ -893,13 +882,6 @@ Status CTREncryptionProvider::CreateCipherStream(
   Slice iv;
   decodeCTRParameters(prefix.data(), blockSize, initialCounter, iv);
 
-  // If the prefix is smaller than twice the block size, we would below read a
-  // very large chunk of the file (and very likely read over the bounds)
-  assert(prefix.size() >= 2 * blockSize);
-  if (prefix.size() < 2 * blockSize) {
-    return Status::Corruption("Unable to read from file " + fname + ": read attempt would read beyond file bounds");
-  }
-
   // Decrypt the encrypted part of the prefix, starting from block 2 (block 0, 1 with initial counter & IV are unencrypted)
   CTRCipherStream cipherStream(cipher_, iv.data(), initialCounter);
   auto status = cipherStream.Decrypt(0, (char*)prefix.data() + (2 * blockSize), prefix.size() - (2 * blockSize));

env/env_hdfs.cc

@@ -11,14 +11,13 @@
 #ifndef ROCKSDB_HDFS_FILE_C
 #define ROCKSDB_HDFS_FILE_C
 
+#include <algorithm>
 #include <stdio.h>
 #include <sys/time.h>
 #include <time.h>
-#include <algorithm>
 #include <iostream>
 #include <sstream>
 #include "rocksdb/status.h"
-#include "util/logging.h"
 #include "util/string_util.h"
 
 #define HDFS_EXISTS 0
@@ -37,11 +36,9 @@ namespace {
 
 // Log error message
 static Status IOError(const std::string& context, int err_number) {
-  return (err_number == ENOSPC)
-             ? Status::NoSpace(context, strerror(err_number))
-             : (err_number == ENOENT)
-                   ? Status::PathNotFound(context, strerror(err_number))
-                   : Status::IOError(context, strerror(err_number));
+  return (err_number == ENOSPC) ?
+      Status::NoSpace(context, strerror(err_number)) :
+      Status::IOError(context, strerror(err_number));
 }
 
 // assume that there is one global logger for now. It is not thread-safe,
@@ -225,7 +222,7 @@ class HdfsWritableFile: public WritableFile {
                     filename_.c_str());
     const char* src = data.data();
     size_t left = data.size();
-    size_t ret = hdfsWrite(fileSys_, hfile_, src, static_cast<tSize>(left));
+    size_t ret = hdfsWrite(fileSys_, hfile_, src, left);
     ROCKS_LOG_DEBUG(mylog, "[hdfs] HdfsWritableFile Appended %s\n",
                     filename_.c_str());
     if (ret != left) {
@@ -255,8 +252,7 @@ class HdfsWritableFile: public WritableFile {
 
   // This is used by HdfsLogger to write data to the debug log file
   virtual Status Append(const char* src, size_t size) {
-    if (hdfsWrite(fileSys_, hfile_, src, static_cast<tSize>(size)) !=
-        static_cast<tSize>(size)) {
+    if (hdfsWrite(fileSys_, hfile_, src, size) != (tSize)size) {
       return IOError(filename_, errno);
     }
     return Status::OK();
@@ -284,10 +280,11 @@ class HdfsLogger : public Logger {
   Status HdfsCloseHelper() {
     ROCKS_LOG_DEBUG(mylog, "[hdfs] HdfsLogger closed %s\n",
                     file_->getName().c_str());
+    Status s = file_->Close();
     if (mylog != nullptr && mylog == this) {
       mylog = nullptr;
     }
-    return Status::OK();
+    return s;
   }
 
  protected:
@@ -300,15 +297,14 @@ class HdfsLogger : public Logger {
                     file_->getName().c_str());
   }
 
-  ~HdfsLogger() override {
+  virtual ~HdfsLogger() {
     if (!closed_) {
       closed_ = true;
       HdfsCloseHelper();
     }
   }
 
-  using Logger::Logv;
-  void Logv(const char* format, va_list ap) override {
+  virtual void Logv(const char* format, va_list ap) {
     const uint64_t thread_id = (*gettid_)();
 
     // We try twice: the first time with a fixed-size stack allocated buffer,
@@ -386,7 +382,7 @@ const std::string HdfsEnv::pathsep = "/";
 // open a file for sequential reading
 Status HdfsEnv::NewSequentialFile(const std::string& fname,
                                   std::unique_ptr<SequentialFile>* result,
-                                  const EnvOptions& /*options*/) {
+                                  const EnvOptions& options) {
   result->reset();
   HdfsReadableFile* f = new HdfsReadableFile(fileSys_, fname);
   if (f == nullptr || !f->isValid()) {
@@ -401,7 +397,7 @@ Status HdfsEnv::NewSequentialFile(const std::string& fname,
 // open a file for random reading
 Status HdfsEnv::NewRandomAccessFile(const std::string& fname,
                                     std::unique_ptr<RandomAccessFile>* result,
-                                    const EnvOptions& /*options*/) {
+                                    const EnvOptions& options) {
   result->reset();
   HdfsReadableFile* f = new HdfsReadableFile(fileSys_, fname);
   if (f == nullptr || !f->isValid()) {
@@ -416,7 +412,7 @@ Status HdfsEnv::NewRandomAccessFile(const std::string& fname,
 // create a new file for writing
 Status HdfsEnv::NewWritableFile(const std::string& fname,
                                 std::unique_ptr<WritableFile>* result,
-                                const EnvOptions& /*options*/) {
+                                const EnvOptions& options) {
   result->reset();
   Status s;
   HdfsWritableFile* f = new HdfsWritableFile(fileSys_, fname);
@@ -434,9 +430,7 @@ class HdfsDirectory : public Directory {
   explicit HdfsDirectory(int fd) : fd_(fd) {}
   ~HdfsDirectory() {}
 
-  Status Fsync() override { return Status::OK(); }
-
-  int GetFd() const { return fd_; }
+  virtual Status Fsync() { return Status::OK(); }
 
  private:
   int fd_;
@@ -481,10 +475,10 @@ Status HdfsEnv::GetChildren(const std::string& path,
     pHdfsFileInfo = hdfsListDirectory(fileSys_, path.c_str(), &numEntries);
     if (numEntries >= 0) {
       for(int i = 0; i < numEntries; i++) {
-        std::string pathname(pHdfsFileInfo[i].mName);
-        size_t pos = pathname.rfind("/");
-        if (std::string::npos != pos) {
-          result->push_back(pathname.substr(pos + 1));
+        char* pathname = pHdfsFileInfo[i].mName;
+        char* filename = std::rindex(pathname, '/');
+        if (filename != nullptr) {
+          result->push_back(filename+1);
         }
       }
       if (pHdfsFileInfo != nullptr) {
@@ -575,14 +569,16 @@ Status HdfsEnv::RenameFile(const std::string& src, const std::string& target) {
   return IOError(src, errno);
 }
 
-Status HdfsEnv::LockFile(const std::string& /*fname*/, FileLock** lock) {
+Status HdfsEnv::LockFile(const std::string& fname, FileLock** lock) {
   // there isn's a very good way to atomically check and create
   // a file via libhdfs
   *lock = nullptr;
   return Status::OK();
 }
 
-Status HdfsEnv::UnlockFile(FileLock* /*lock*/) { return Status::OK(); }
+Status HdfsEnv::UnlockFile(FileLock* lock) {
+  return Status::OK();
+}
 
 Status HdfsEnv::NewLogger(const std::string& fname,
                           std::shared_ptr<Logger>* result) {

env/io_posix.cc

@@ -265,6 +265,7 @@ size_t PosixHelper::GetUniqueIdFromFile(int fd, char* id, size_t max_size) {
 
   struct stat buf;
   int result = fstat(fd, &buf);
+  assert(result != -1);
   if (result == -1) {
     return 0;
   }
@@ -824,8 +825,7 @@ Status PosixWritableFile::Close() {
     // but it will be nice to log these errors.
     int dummy __attribute__((__unused__));
     dummy = ftruncate(fd_, filesize_);
-#if defined(ROCKSDB_FALLOCATE_PRESENT) && defined(FALLOC_FL_PUNCH_HOLE) && \
-    !defined(TRAVIS)
+#if defined(ROCKSDB_FALLOCATE_PRESENT) && !defined(TRAVIS)
     // in some file systems, ftruncate only trims trailing space if the
     // new file size is smaller than the current size. Calling fallocate
     // with FALLOC_FL_PUNCH_HOLE flag to explicitly release these unused

env/io_posix.h

@@ -41,9 +41,6 @@ static Status IOError(const std::string& context, const std::string& file_name,
                            strerror(err_number));
   case ESTALE:
     return Status::IOError(Status::kStaleFile);
-  case ENOENT:
-    return Status::PathNotFound(IOErrorMsg(context, file_name),
-                                strerror(err_number));
   default:
     return Status::IOError(IOErrorMsg(context, file_name),
                            strerror(err_number));

examples/.gitignore

@@ -2,7 +2,6 @@ c_simple_example
 column_families_example
 compact_files_example
 compaction_filter_example
-multi_processes_example
 optimistic_transaction_example
 options_file_example
 simple_example

examples/Makefile

@@ -43,11 +43,8 @@ transaction_example: librocksdb transaction_example.cc
 options_file_example: librocksdb options_file_example.cc
 	$(CXX) $(CXXFLAGS) $@.cc -o$@ ../librocksdb.a -I../include -O2 -std=c++11 $(PLATFORM_LDFLAGS) $(PLATFORM_CXXFLAGS) $(EXEC_LDFLAGS)
 
-multi_processes_example: librocksdb multi_processes_example.cc
-	$(CXX) $(CXXFLAGS) $@.cc -o$@ ../librocksdb.a -I../include -O2 -std=c++11 $(PLATFORM_LDFLAGS) $(PLATFORM_CXXFLAGS) $(EXEC_LDFLAGS)
-
 clean:
-	rm -rf ./simple_example ./column_families_example ./compact_files_example ./compaction_filter_example ./c_simple_example c_simple_example.o ./optimistic_transaction_example ./transaction_example ./options_file_example ./multi_processes_example
+	rm -rf ./simple_example ./column_families_example ./compact_files_example ./compaction_filter_example ./c_simple_example c_simple_example.o ./optimistic_transaction_example ./transaction_example ./options_file_example
 
 librocksdb:
 	cd .. && $(MAKE) static_lib

examples/multi_processes_example.cc

@@ -1,395 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-// This source code is licensed under both the GPLv2 (found in the
-// COPYING file in the root directory) and Apache 2.0 License
-// (found in the LICENSE.Apache file in the root directory).
-
-// How to use this example
-// Open two terminals, in one of them, run `./multi_processes_example 0` to
-// start a process running the primary instance. This will create a new DB in
-// kDBPath. The process will run for a while inserting keys to the normal
-// RocksDB database.
-// Next, go to the other terminal and run `./multi_processes_example 1` to
-// start a process running the secondary instance. This will create a secondary
-// instance following the aforementioned primary instance. This process will
-// run for a while, tailing the logs of the primary. After process with primary
-// instance exits, this process will keep running until you hit 'CTRL+C'.
-
-#include <inttypes.h>
-#include <chrono>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <string>
-#include <thread>
-#include <vector>
-
-#if defined(OS_LINUX)
-#include <dirent.h>
-#include <signal.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#endif  // !OS_LINUX
-
-#include "rocksdb/db.h"
-#include "rocksdb/options.h"
-#include "rocksdb/slice.h"
-
-using rocksdb::ColumnFamilyDescriptor;
-using rocksdb::ColumnFamilyHandle;
-using rocksdb::ColumnFamilyOptions;
-using rocksdb::DB;
-using rocksdb::FlushOptions;
-using rocksdb::Iterator;
-using rocksdb::Options;
-using rocksdb::ReadOptions;
-using rocksdb::Slice;
-using rocksdb::Status;
-using rocksdb::WriteOptions;
-
-const std::string kDBPath = "/tmp/rocksdb_multi_processes_example";
-const std::string kPrimaryStatusFile =
-    "/tmp/rocksdb_multi_processes_example_primary_status";
-const uint64_t kMaxKey = 600000;
-const size_t kMaxValueLength = 256;
-const size_t kNumKeysPerFlush = 1000;
-
-const std::vector<std::string>& GetColumnFamilyNames() {
-  static std::vector<std::string> column_family_names = {
-      rocksdb::kDefaultColumnFamilyName, "pikachu"};
-  return column_family_names;
-}
-
-inline bool IsLittleEndian() {
-  uint32_t x = 1;
-  return *reinterpret_cast<char*>(&x) != 0;
-}
-
-static std::atomic<int>& ShouldSecondaryWait() {
-  static std::atomic<int> should_secondary_wait{1};
-  return should_secondary_wait;
-}
-
-static std::string Key(uint64_t k) {
-  std::string ret;
-  if (IsLittleEndian()) {
-    ret.append(reinterpret_cast<char*>(&k), sizeof(k));
-  } else {
-    char buf[sizeof(k)];
-    buf[0] = k & 0xff;
-    buf[1] = (k >> 8) & 0xff;
-    buf[2] = (k >> 16) & 0xff;
-    buf[3] = (k >> 24) & 0xff;
-    buf[4] = (k >> 32) & 0xff;
-    buf[5] = (k >> 40) & 0xff;
-    buf[6] = (k >> 48) & 0xff;
-    buf[7] = (k >> 56) & 0xff;
-    ret.append(buf, sizeof(k));
-  }
-  size_t i = 0, j = ret.size() - 1;
-  while (i < j) {
-    char tmp = ret[i];
-    ret[i] = ret[j];
-    ret[j] = tmp;
-    ++i;
-    --j;
-  }
-  return ret;
-}
-
-static uint64_t Key(std::string key) {
-  assert(key.size() == sizeof(uint64_t));
-  size_t i = 0, j = key.size() - 1;
-  while (i < j) {
-    char tmp = key[i];
-    key[i] = key[j];
-    key[j] = tmp;
-    ++i;
-    --j;
-  }
-  uint64_t ret = 0;
-  if (IsLittleEndian()) {
-    memcpy(&ret, key.c_str(), sizeof(uint64_t));
-  } else {
-    const char* buf = key.c_str();
-    ret |= static_cast<uint64_t>(buf[0]);
-    ret |= (static_cast<uint64_t>(buf[1]) << 8);
-    ret |= (static_cast<uint64_t>(buf[2]) << 16);
-    ret |= (static_cast<uint64_t>(buf[3]) << 24);
-    ret |= (static_cast<uint64_t>(buf[4]) << 32);
-    ret |= (static_cast<uint64_t>(buf[5]) << 40);
-    ret |= (static_cast<uint64_t>(buf[6]) << 48);
-    ret |= (static_cast<uint64_t>(buf[7]) << 56);
-  }
-  return ret;
-}
-
-static Slice GenerateRandomValue(const size_t max_length, char scratch[]) {
-  size_t sz = 1 + (std::rand() % max_length);
-  int rnd = std::rand();
-  for (size_t i = 0; i != sz; ++i) {
-    scratch[i] = static_cast<char>(rnd ^ i);
-  }
-  return Slice(scratch, sz);
-}
-
-static bool ShouldCloseDB() { return true; }
-
-// TODO: port this example to other systems. It should be straightforward for
-// POSIX-compliant systems.
-#if defined(OS_LINUX)
-void CreateDB() {
-  long my_pid = static_cast<long>(getpid());
-  Options options;
-  Status s = rocksdb::DestroyDB(kDBPath, options);
-  if (!s.ok()) {
-    fprintf(stderr, "[process %ld] Failed to destroy DB: %s\n", my_pid,
-            s.ToString().c_str());
-    assert(false);
-  }
-  options.create_if_missing = true;
-  DB* db = nullptr;
-  s = DB::Open(options, kDBPath, &db);
-  if (!s.ok()) {
-    fprintf(stderr, "[process %ld] Failed to open DB: %s\n", my_pid,
-            s.ToString().c_str());
-    assert(false);
-  }
-  std::vector<ColumnFamilyHandle*> handles;
-  ColumnFamilyOptions cf_opts(options);
-  for (const auto& cf_name : GetColumnFamilyNames()) {
-    if (rocksdb::kDefaultColumnFamilyName != cf_name) {
-      ColumnFamilyHandle* handle = nullptr;
-      s = db->CreateColumnFamily(cf_opts, cf_name, &handle);
-      if (!s.ok()) {
-        fprintf(stderr, "[process %ld] Failed to create CF %s: %s\n", my_pid,
-                cf_name.c_str(), s.ToString().c_str());
-        assert(false);
-      }
-      handles.push_back(handle);
-    }
-  }
-  fprintf(stdout, "[process %ld] Column families created\n", my_pid);
-  for (auto h : handles) {
-    delete h;
-  }
-  handles.clear();
-  delete db;
-}
-
-void RunPrimary() {
-  long my_pid = static_cast<long>(getpid());
-  fprintf(stdout, "[process %ld] Primary instance starts\n", my_pid);
-  CreateDB();
-  std::srand(time(nullptr));
-  DB* db = nullptr;
-  Options options;
-  options.create_if_missing = false;
-  std::vector<ColumnFamilyDescriptor> column_families;
-  for (const auto& cf_name : GetColumnFamilyNames()) {
-    column_families.push_back(ColumnFamilyDescriptor(cf_name, options));
-  }
-  std::vector<ColumnFamilyHandle*> handles;
-  WriteOptions write_opts;
-  char val_buf[kMaxValueLength] = {0};
-  uint64_t curr_key = 0;
-  while (curr_key < kMaxKey) {
-    Status s;
-    if (nullptr == db) {
-      s = DB::Open(options, kDBPath, column_families, &handles, &db);
-      if (!s.ok()) {
-        fprintf(stderr, "[process %ld] Failed to open DB: %s\n", my_pid,
-                s.ToString().c_str());
-        assert(false);
-      }
-    }
-    assert(nullptr != db);
-    assert(handles.size() == GetColumnFamilyNames().size());
-    for (auto h : handles) {
-      assert(nullptr != h);
-      for (size_t i = 0; i != kNumKeysPerFlush; ++i) {
-        Slice key = Key(curr_key + static_cast<uint64_t>(i));
-        Slice value = GenerateRandomValue(kMaxValueLength, val_buf);
-        s = db->Put(write_opts, h, key, value);
-        if (!s.ok()) {
-          fprintf(stderr, "[process %ld] Failed to insert\n", my_pid);
-          assert(false);
-        }
-      }
-      s = db->Flush(FlushOptions(), h);
-      if (!s.ok()) {
-        fprintf(stderr, "[process %ld] Failed to flush\n", my_pid);
-        assert(false);
-      }
-    }
-    curr_key += static_cast<uint64_t>(kNumKeysPerFlush);
-    if (ShouldCloseDB()) {
-      for (auto h : handles) {
-        delete h;
-      }
-      handles.clear();
-      delete db;
-      db = nullptr;
-    }
-  }
-  if (nullptr != db) {
-    for (auto h : handles) {
-      delete h;
-    }
-    handles.clear();
-    delete db;
-    db = nullptr;
-  }
-  fprintf(stdout, "[process %ld] Finished adding keys\n", my_pid);
-}
-
-void secondary_instance_sigint_handler(int signal) {
-  ShouldSecondaryWait().store(0, std::memory_order_relaxed);
-  fprintf(stdout, "\n");
-  fflush(stdout);
-};
-
-void RunSecondary() {
-  ::signal(SIGINT, secondary_instance_sigint_handler);
-  long my_pid = static_cast<long>(getpid());
-  const std::string kSecondaryPath =
-      "/tmp/rocksdb_multi_processes_example_secondary";
-  // Create directory if necessary
-  if (nullptr == opendir(kSecondaryPath.c_str())) {
-    int ret =
-        mkdir(kSecondaryPath.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-    if (ret < 0) {
-      perror("failed to create directory for secondary instance");
-      exit(0);
-    }
-  }
-  DB* db = nullptr;
-  Options options;
-  options.create_if_missing = false;
-  options.max_open_files = -1;
-  Status s = DB::OpenAsSecondary(options, kDBPath, kSecondaryPath, &db);
-  if (!s.ok()) {
-    fprintf(stderr, "[process %ld] Failed to open in secondary mode: %s\n",
-            my_pid, s.ToString().c_str());
-    assert(false);
-  } else {
-    fprintf(stdout, "[process %ld] Secondary instance starts\n", my_pid);
-  }
-
-  ReadOptions ropts;
-  ropts.verify_checksums = true;
-  ropts.total_order_seek = true;
-
-  std::vector<std::thread> test_threads;
-  test_threads.emplace_back([&]() {
-    while (1 == ShouldSecondaryWait().load(std::memory_order_relaxed)) {
-      std::unique_ptr<Iterator> iter(db->NewIterator(ropts));
-      iter->SeekToFirst();
-      size_t count = 0;
-      for (; iter->Valid(); iter->Next()) {
-        ++count;
-      }
-    }
-    fprintf(stdout, "[process %ld] Range_scan thread finished\n", my_pid);
-  });
-
-  test_threads.emplace_back([&]() {
-    std::srand(time(nullptr));
-    while (1 == ShouldSecondaryWait().load(std::memory_order_relaxed)) {
-      Slice key = Key(std::rand() % kMaxKey);
-      std::string value;
-      db->Get(ropts, key, &value);
-    }
-    fprintf(stdout, "[process %ld] Point lookup thread finished\n");
-  });
-
-  uint64_t curr_key = 0;
-  while (1 == ShouldSecondaryWait().load(std::memory_order_relaxed)) {
-    s = db->TryCatchUpWithPrimary();
-    if (!s.ok()) {
-      fprintf(stderr,
-              "[process %ld] error while trying to catch up with "
-              "primary %s\n",
-              my_pid, s.ToString().c_str());
-      assert(false);
-    }
-    {
-      std::unique_ptr<Iterator> iter(db->NewIterator(ropts));
-      if (!iter) {
-        fprintf(stderr, "[process %ld] Failed to create iterator\n", my_pid);
-        assert(false);
-      }
-      iter->SeekToLast();
-      if (iter->Valid()) {
-        uint64_t curr_max_key = Key(iter->key().ToString());
-        if (curr_max_key != curr_key) {
-          fprintf(stdout, "[process %ld] Observed key %" PRIu64 "\n", my_pid,
-                  curr_key);
-          curr_key = curr_max_key;
-        }
-      }
-    }
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-  }
-  s = db->TryCatchUpWithPrimary();
-  if (!s.ok()) {
-    fprintf(stderr,
-            "[process %ld] error while trying to catch up with "
-            "primary %s\n",
-            my_pid, s.ToString().c_str());
-    assert(false);
-  }
-
-  std::vector<ColumnFamilyDescriptor> column_families;
-  for (const auto& cf_name : GetColumnFamilyNames()) {
-    column_families.push_back(ColumnFamilyDescriptor(cf_name, options));
-  }
-  std::vector<ColumnFamilyHandle*> handles;
-  DB* verification_db = nullptr;
-  s = DB::OpenForReadOnly(options, kDBPath, column_families, &handles,
-                          &verification_db);
-  assert(s.ok());
-  Iterator* iter1 = verification_db->NewIterator(ropts);
-  iter1->SeekToFirst();
-
-  Iterator* iter = db->NewIterator(ropts);
-  iter->SeekToFirst();
-  for (; iter->Valid() && iter1->Valid(); iter->Next(), iter1->Next()) {
-    if (iter->key().ToString() != iter1->key().ToString()) {
-      fprintf(stderr, "%" PRIu64 "!= %" PRIu64 "\n",
-              Key(iter->key().ToString()), Key(iter1->key().ToString()));
-      assert(false);
-    } else if (iter->value().ToString() != iter1->value().ToString()) {
-      fprintf(stderr, "Value mismatch\n");
-      assert(false);
-    }
-  }
-  fprintf(stdout, "[process %ld] Verification succeeded\n", my_pid);
-  for (auto& thr : test_threads) {
-    thr.join();
-  }
-  delete iter;
-  delete iter1;
-  delete db;
-  delete verification_db;
-}
-
-int main(int argc, char** argv) {
-  if (argc < 2) {
-    fprintf(stderr, "%s <0 for primary, 1 for secondary>\n", argv[0]);
-    return 0;
-  }
-  if (atoi(argv[1]) == 0) {
-    RunPrimary();
-  } else {
-    RunSecondary();
-  }
-  return 0;
-}
-#else   // OS_LINUX
-int main() {
-  fpritnf(stderr, "Not implemented.\n");
-  return 0;
-}
-#endif  // !OS_LINUX

hdfs/env_hdfs.h

@@ -54,109 +54,110 @@ class HdfsEnv : public Env {
     hdfsDisconnect(fileSys_);
   }
 
-  Status NewSequentialFile(const std::string& fname,
-                           std::unique_ptr<SequentialFile>* result,
-                           const EnvOptions& options) override;
+  virtual Status NewSequentialFile(const std::string& fname,
+                                   std::unique_ptr<SequentialFile>* result,
+                                   const EnvOptions& options);
 
-  Status NewRandomAccessFile(const std::string& fname,
-                             std::unique_ptr<RandomAccessFile>* result,
-                             const EnvOptions& options) override;
+  virtual Status NewRandomAccessFile(const std::string& fname,
+                                     std::unique_ptr<RandomAccessFile>* result,
+                                     const EnvOptions& options);
 
-  Status NewWritableFile(const std::string& fname,
-                         std::unique_ptr<WritableFile>* result,
-                         const EnvOptions& options) override;
+  virtual Status NewWritableFile(const std::string& fname,
+                                 std::unique_ptr<WritableFile>* result,
+                                 const EnvOptions& options);
 
-  Status NewDirectory(const std::string& name,
-                      std::unique_ptr<Directory>* result) override;
+  virtual Status NewDirectory(const std::string& name,
+                              std::unique_ptr<Directory>* result);
 
-  Status FileExists(const std::string& fname) override;
+  virtual Status FileExists(const std::string& fname);
 
-  Status GetChildren(const std::string& path,
-                     std::vector<std::string>* result) override;
+  virtual Status GetChildren(const std::string& path,
+                             std::vector<std::string>* result);
 
-  Status DeleteFile(const std::string& fname) override;
+  virtual Status DeleteFile(const std::string& fname);
 
-  Status CreateDir(const std::string& name) override;
+  virtual Status CreateDir(const std::string& name);
 
-  Status CreateDirIfMissing(const std::string& name) override;
+  virtual Status CreateDirIfMissing(const std::string& name);
 
-  Status DeleteDir(const std::string& name) override;
+  virtual Status DeleteDir(const std::string& name);
 
-  Status GetFileSize(const std::string& fname, uint64_t* size) override;
+  virtual Status GetFileSize(const std::string& fname, uint64_t* size);
 
-  Status GetFileModificationTime(const std::string& fname,
-                                 uint64_t* file_mtime) override;
+  virtual Status GetFileModificationTime(const std::string& fname,
+                                         uint64_t* file_mtime);
 
-  Status RenameFile(const std::string& src, const std::string& target) override;
+  virtual Status RenameFile(const std::string& src, const std::string& target);
 
-  Status LinkFile(const std::string& /*src*/,
-                  const std::string& /*target*/) override {
+  virtual Status LinkFile(const std::string& src, const std::string& target) {
     return Status::NotSupported(); // not supported
   }
 
-  Status LockFile(const std::string& fname, FileLock** lock) override;
+  virtual Status LockFile(const std::string& fname, FileLock** lock);
 
-  Status UnlockFile(FileLock* lock) override;
+  virtual Status UnlockFile(FileLock* lock);
 
-  Status NewLogger(const std::string& fname,
-                   std::shared_ptr<Logger>* result) override;
+  virtual Status NewLogger(const std::string& fname,
+                           std::shared_ptr<Logger>* result);
 
-  void Schedule(void (*function)(void* arg), void* arg, Priority pri = LOW,
-                void* tag = nullptr,
-                void (*unschedFunction)(void* arg) = 0) override {
+  virtual void Schedule(void (*function)(void* arg), void* arg,
+                        Priority pri = LOW, void* tag = nullptr, void (*unschedFunction)(void* arg) = 0) {
     posixEnv->Schedule(function, arg, pri, tag, unschedFunction);
   }
 
-  int UnSchedule(void* tag, Priority pri) override {
+  virtual int UnSchedule(void* tag, Priority pri) {
     return posixEnv->UnSchedule(tag, pri);
   }
 
-  void StartThread(void (*function)(void* arg), void* arg) override {
+  virtual void StartThread(void (*function)(void* arg), void* arg) {
     posixEnv->StartThread(function, arg);
   }
 
-  void WaitForJoin() override { posixEnv->WaitForJoin(); }
+  virtual void WaitForJoin() { posixEnv->WaitForJoin(); }
 
-  unsigned int GetThreadPoolQueueLen(Priority pri = LOW) const override {
+  virtual unsigned int GetThreadPoolQueueLen(Priority pri = LOW) const
+      override {
     return posixEnv->GetThreadPoolQueueLen(pri);
   }
 
-  Status GetTestDirectory(std::string* path) override {
+  virtual Status GetTestDirectory(std::string* path) {
     return posixEnv->GetTestDirectory(path);
   }
 
-  uint64_t NowMicros() override { return posixEnv->NowMicros(); }
+  virtual uint64_t NowMicros() {
+    return posixEnv->NowMicros();
+  }
 
-  void SleepForMicroseconds(int micros) override {
+  virtual void SleepForMicroseconds(int micros) {
     posixEnv->SleepForMicroseconds(micros);
   }
 
-  Status GetHostName(char* name, uint64_t len) override {
+  virtual Status GetHostName(char* name, uint64_t len) {
     return posixEnv->GetHostName(name, len);
   }
 
-  Status GetCurrentTime(int64_t* unix_time) override {
+  virtual Status GetCurrentTime(int64_t* unix_time) {
     return posixEnv->GetCurrentTime(unix_time);
   }
 
-  Status GetAbsolutePath(const std::string& db_path,
-                         std::string* output_path) override {
+  virtual Status GetAbsolutePath(const std::string& db_path,
+      std::string* output_path) {
     return posixEnv->GetAbsolutePath(db_path, output_path);
   }
 
-  void SetBackgroundThreads(int number, Priority pri = LOW) override {
+  virtual void SetBackgroundThreads(int number, Priority pri = LOW) {
     posixEnv->SetBackgroundThreads(number, pri);
   }
 
-  int GetBackgroundThreads(Priority pri = LOW) override {
+  virtual int GetBackgroundThreads(Priority pri = LOW) {
     return posixEnv->GetBackgroundThreads(pri);
   }
 
-  void IncBackgroundThreadsIfNeeded(int number, Priority pri) override {
+  virtual void IncBackgroundThreadsIfNeeded(int number, Priority pri) override {
     posixEnv->IncBackgroundThreadsIfNeeded(number, pri);
   }
 
-  std::string TimeToString(uint64_t number) override {
+  virtual std::string TimeToString(uint64_t number) {
     return posixEnv->TimeToString(number);
   }
 
@@ -165,7 +166,9 @@ class HdfsEnv : public Env {
     return (uint64_t)pthread_self();
   }
 
-  uint64_t GetThreadID() const override { return HdfsEnv::gettid(); }
+  virtual uint64_t GetThreadID() const override {
+    return HdfsEnv::gettid();
+  }
 
  private:
   std::string fsname_;  // string of the form "hdfs://hostname:port/"
@@ -203,7 +206,7 @@ class HdfsEnv : public Env {
     std::string host(parts[0]);
     std::string remaining(parts[1]);
 
-    int rem = static_cast<int>(remaining.find(pathsep));
+    int rem = remaining.find(pathsep);
     std::string portStr = (rem == 0 ? remaining :
                            remaining.substr(0, rem));
 

hdfs/setup.sh

@@ -1,8 +1,8 @@
 # shellcheck disable=SC2148
 export USE_HDFS=1
-export LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/amd64/server:$JAVA_HOME/jre/lib/amd64:$HADOOP_HOME/lib/native
+export LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/amd64/server:$JAVA_HOME/jre/lib/amd64:/usr/lib/hadoop/lib/native
 
-export CLASSPATH=`$HADOOP_HOME/bin/hadoop classpath --glob`
+export CLASSPATH=
 for f in `find /usr/lib/hadoop-hdfs | grep jar`; do export CLASSPATH=$CLASSPATH:$f; done
 for f in `find /usr/lib/hadoop | grep jar`; do export CLASSPATH=$CLASSPATH:$f; done
 for f in `find /usr/lib/hadoop/client | grep jar`; do export CLASSPATH=$CLASSPATH:$f; done

include/rocksdb/advanced_options.h

@@ -644,12 +644,6 @@ struct AdvancedColumnFamilyOptions {
   // Dynamically changeable through SetOptions() API
   uint64_t ttl = 0;
 
-  // If this option is set then 1 in N blocks are compressed
-  // using a fast (lz4) and slow (zstd) compression algorithm.
-  // The compressibility is reported as stats and the stored
-  // data is left uncompressed (unless compression is also requested).
-  uint64_t sample_for_compression = 0;
-
   // Create ColumnFamilyOptions with default values for all fields
   AdvancedColumnFamilyOptions();
   // Create ColumnFamilyOptions from Options

include/rocksdb/c.h

@@ -1459,13 +1459,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_t* rocksdb_transactiondb_open(
     const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
     char** errptr);
 
-rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
-    const rocksdb_options_t* options,
-    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
-    int num_column_families, const char** column_family_names,
-    const rocksdb_options_t** column_family_options,
-    rocksdb_column_family_handle_t** column_family_handles, char** errptr);
-
 extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t*
 rocksdb_transactiondb_create_snapshot(rocksdb_transactiondb_t* txn_db);
 
@@ -1511,11 +1504,6 @@ extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_for_update(
     const char* key, size_t klen, size_t* vlen, unsigned char exclusive,
     char** errptr);
 
-char* rocksdb_transaction_get_for_update_cf(
-    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    size_t* vlen, unsigned char exclusive, char** errptr);
-
 extern ROCKSDB_LIBRARY_API char* rocksdb_transactiondb_get(
     rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
     const char* key, size_t klen, size_t* vlen, char** errptr);
@@ -1550,19 +1538,10 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge(
     rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val,
     size_t vlen, char** errptr);
 
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
 extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge(
     rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
     const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
 
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr);
-
 extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete(
     rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr);
 
@@ -1592,11 +1571,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_iterator_t*
 rocksdb_transactiondb_create_iterator(rocksdb_transactiondb_t* txn_db,
                                       const rocksdb_readoptions_t* options);
 
-extern ROCKSDB_LIBRARY_API rocksdb_iterator_t*
-rocksdb_transactiondb_create_iterator_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family);
-
 extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_close(
     rocksdb_transactiondb_t* txn_db);
 

include/rocksdb/cache.h

@@ -34,8 +34,6 @@ namespace rocksdb {
 
 class Cache;
 
-extern const bool kDefaultToAdaptiveMutex;
-
 struct LRUCacheOptions {
   // Capacity of the cache.
   size_t capacity = 0;
@@ -70,23 +68,15 @@ struct LRUCacheOptions {
   // internally (currently only XPRESS).
   std::shared_ptr<MemoryAllocator> memory_allocator;
 
-  // Whether to use adaptive mutexes for cache shards. Note that adaptive
-  // mutexes need to be supported by the platform in order for this to have any
-  // effect. The default value is true if RocksDB is compiled with
-  // -DROCKSDB_DEFAULT_TO_ADAPTIVE_MUTEX, false otherwise.
-  bool use_adaptive_mutex = kDefaultToAdaptiveMutex;
-
   LRUCacheOptions() {}
   LRUCacheOptions(size_t _capacity, int _num_shard_bits,
                   bool _strict_capacity_limit, double _high_pri_pool_ratio,
-                  std::shared_ptr<MemoryAllocator> _memory_allocator = nullptr,
-                  bool _use_adaptive_mutex = kDefaultToAdaptiveMutex)
+                  std::shared_ptr<MemoryAllocator> _memory_allocator = nullptr)
       : capacity(_capacity),
         num_shard_bits(_num_shard_bits),
         strict_capacity_limit(_strict_capacity_limit),
         high_pri_pool_ratio(_high_pri_pool_ratio),
-        memory_allocator(std::move(_memory_allocator)),
-        use_adaptive_mutex(_use_adaptive_mutex) {}
+        memory_allocator(std::move(_memory_allocator)) {}
 };
 
 // Create a new cache with a fixed size capacity. The cache is sharded
@@ -100,8 +90,7 @@ struct LRUCacheOptions {
 extern std::shared_ptr<Cache> NewLRUCache(
     size_t capacity, int num_shard_bits = -1,
     bool strict_capacity_limit = false, double high_pri_pool_ratio = 0.0,
-    std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-    bool use_adaptive_mutex = kDefaultToAdaptiveMutex);
+    std::shared_ptr<MemoryAllocator> memory_allocator = nullptr);
 
 extern std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts);
 

include/rocksdb/compaction_filter.h

@@ -189,7 +189,7 @@ class CompactionFilter {
 // application to know about different compactions
 class CompactionFilterFactory {
  public:
-  virtual ~CompactionFilterFactory() {}
+  virtual ~CompactionFilterFactory() { }
 
   virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
       const CompactionFilter::Context& context) = 0;

include/rocksdb/comparator.h

@@ -55,8 +55,9 @@ class Comparator {
   // If *start < limit, changes *start to a short string in [start,limit).
   // Simple comparator implementations may return with *start unchanged,
   // i.e., an implementation of this method that does nothing is correct.
-  virtual void FindShortestSeparator(std::string* start,
-                                     const Slice& limit) const = 0;
+  virtual void FindShortestSeparator(
+      std::string* start,
+      const Slice& limit) const = 0;
 
   // Changes *key to a short string >= *key.
   // Simple comparator implementations may return with *key unchanged,

include/rocksdb/concurrent_task_limiter.h

@@ -16,6 +16,7 @@ namespace rocksdb {
 
 class ConcurrentTaskLimiter {
  public:
+
   virtual ~ConcurrentTaskLimiter() {}
 
   // Returns a name that identifies this concurrent task limiter.
@@ -40,7 +41,7 @@ class ConcurrentTaskLimiter {
 // @param limit: max concurrent tasks.
 //        limit = 0 means no new task allowed.
 //        limit < 0 means no limitation.
-extern ConcurrentTaskLimiter* NewConcurrentTaskLimiter(const std::string& name,
-                                                       int32_t limit);
+extern ConcurrentTaskLimiter* NewConcurrentTaskLimiter(
+    const std::string& name, int32_t limit);
 
 }  // namespace rocksdb

include/rocksdb/convenience.h

@@ -277,13 +277,15 @@ Status GetPlainTableOptionsFromMap(
 // BlockBasedTableOptions as part of the string for block-based table factory:
 //   "write_buffer_size=1024;block_based_table_factory={block_size=4k};"
 //   "max_write_buffer_num=2"
-Status GetColumnFamilyOptionsFromString(const ColumnFamilyOptions& base_options,
-                                        const std::string& opts_str,
-                                        ColumnFamilyOptions* new_options);
+Status GetColumnFamilyOptionsFromString(
+    const ColumnFamilyOptions& base_options,
+    const std::string& opts_str,
+    ColumnFamilyOptions* new_options);
 
-Status GetDBOptionsFromString(const DBOptions& base_options,
-                              const std::string& opts_str,
-                              DBOptions* new_options);
+Status GetDBOptionsFromString(
+    const DBOptions& base_options,
+    const std::string& opts_str,
+    DBOptions* new_options);
 
 Status GetStringFromDBOptions(std::string* opts_str,
                               const DBOptions& db_options,
@@ -299,12 +301,14 @@ Status GetStringFromCompressionType(std::string* compression_str,
 std::vector<CompressionType> GetSupportedCompressions();
 
 Status GetBlockBasedTableOptionsFromString(
-    const BlockBasedTableOptions& table_options, const std::string& opts_str,
+    const BlockBasedTableOptions& table_options,
+    const std::string& opts_str,
     BlockBasedTableOptions* new_table_options);
 
-Status GetPlainTableOptionsFromString(const PlainTableOptions& table_options,
-                                      const std::string& opts_str,
-                                      PlainTableOptions* new_table_options);
+Status GetPlainTableOptionsFromString(
+    const PlainTableOptions& table_options,
+    const std::string& opts_str,
+    PlainTableOptions* new_table_options);
 
 Status GetMemTableRepFactoryFromString(
     const std::string& opts_str,

include/rocksdb/db.h

@@ -58,6 +58,8 @@ class TraceWriter;
 class CompactionJobInfo;
 #endif
 
+using std::unique_ptr;
+
 extern const std::string kDefaultColumnFamilyName;
 struct ColumnFamilyDescriptor {
   std::string name;
@@ -97,16 +99,16 @@ struct Range {
   Slice start;
   Slice limit;
 
-  Range() {}
-  Range(const Slice& s, const Slice& l) : start(s), limit(l) {}
+  Range() { }
+  Range(const Slice& s, const Slice& l) : start(s), limit(l) { }
 };
 
 struct RangePtr {
   const Slice* start;
   const Slice* limit;
 
-  RangePtr() : start(nullptr), limit(nullptr) {}
-  RangePtr(const Slice* s, const Slice* l) : start(s), limit(l) {}
+  RangePtr() : start(nullptr), limit(nullptr) { }
+  RangePtr(const Slice* s, const Slice* l) : start(s), limit(l) { }
 };
 
 struct IngestExternalFileArg {
@@ -131,7 +133,8 @@ class DB {
   // OK on success.
   // Stores nullptr in *dbptr and returns a non-OK status on error.
   // Caller should delete *dbptr when it is no longer needed.
-  static Status Open(const Options& options, const std::string& name,
+  static Status Open(const Options& options,
+                     const std::string& name,
                      DB** dbptr);
 
   // Open the database for read only. All DB interfaces
@@ -141,9 +144,9 @@ class DB {
   //
   // Not supported in ROCKSDB_LITE, in which case the function will
   // return Status::NotSupported.
-  static Status OpenForReadOnly(const Options& options, const std::string& name,
-                                DB** dbptr,
-                                bool error_if_log_file_exist = false);
+  static Status OpenForReadOnly(const Options& options,
+      const std::string& name, DB** dbptr,
+      bool error_if_log_file_exist = false);
 
   // Open the database for read only with column families. When opening DB with
   // read only, you can specify only a subset of column families in the
@@ -159,54 +162,6 @@ class DB {
       std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
       bool error_if_log_file_exist = false);
 
-  // The following OpenAsSecondary functions create a secondary instance that
-  // can dynamically tail the MANIFEST of a primary that must have already been
-  // created. User can call TryCatchUpWithPrimary to make the secondary
-  // instance catch up with primary (WAL tailing is NOT supported now) whenever
-  // the user feels necessary. Column families created by the primary after the
-  // secondary instance starts are currently ignored by the secondary instance.
-  // Column families opened by secondary and dropped by the primary will be
-  // dropped by secondary as well. However the user of the secondary instance
-  // can still access the data of such dropped column family as long as they
-  // do not destroy the corresponding column family handle.
-  // WAL tailing is not supported at present, but will arrive soon.
-  //
-  // The options argument specifies the options to open the secondary instance.
-  // The name argument specifies the name of the primary db that you have used
-  // to open the primary instance.
-  // The secondary_path argument points to a directory where the secondary
-  // instance stores its info log.
-  // The dbptr is an out-arg corresponding to the opened secondary instance.
-  // The pointer points to a heap-allocated database, and the user should
-  // delete it after use.
-  // Open DB as secondary instance with only the default column family.
-  // Return OK on success, non-OK on failures.
-  static Status OpenAsSecondary(const Options& options, const std::string& name,
-                                const std::string& secondary_path, DB** dbptr);
-
-  // Open DB as secondary instance with column families. You can open a subset
-  // of column families in secondary mode.
-  // The db_options specify the database specific options.
-  // The name argument specifies the name of the primary db that you have used
-  // to open the primary instance.
-  // The secondary_path argument points to a directory where the secondary
-  // instance stores its info log.
-  // The column_families argument specifieds a list of column families to open.
-  // If any of the column families does not exist, the function returns non-OK
-  // status.
-  // The handles is an out-arg corresponding to the opened database column
-  // familiy handles.
-  // The dbptr is an out-arg corresponding to the opened secondary instance.
-  // The pointer points to a heap-allocated database, and the caller should
-  // delete it after use. Before deleting the dbptr, the user should also
-  // delete the pointers stored in handles vector.
-  // Return OK on success, on-OK on failures.
-  static Status OpenAsSecondary(
-      const DBOptions& db_options, const std::string& name,
-      const std::string& secondary_path,
-      const std::vector<ColumnFamilyDescriptor>& column_families,
-      std::vector<ColumnFamilyHandle*>* handles, DB** dbptr);
-
   // Open DB with column families.
   // db_options specify database specific options
   // column_families is the vector of all column families in the database,
@@ -245,7 +200,7 @@ class DB {
                                    const std::string& name,
                                    std::vector<std::string>* column_families);
 
-  DB() {}
+  DB() { }
   virtual ~DB();
 
   // Create a column_family and return the handle of column family
@@ -393,8 +348,7 @@ class DB {
   virtual Status Get(const ReadOptions& options,
                      ColumnFamilyHandle* column_family, const Slice& key,
                      PinnableSlice* value) = 0;
-  virtual Status Get(const ReadOptions& options, const Slice& key,
-                     std::string* value) {
+  virtual Status Get(const ReadOptions& options, const Slice& key, std::string* value) {
     return Get(options, DefaultColumnFamily(), key, value);
   }
 
@@ -415,10 +369,9 @@ class DB {
   virtual std::vector<Status> MultiGet(const ReadOptions& options,
                                        const std::vector<Slice>& keys,
                                        std::vector<std::string>* values) {
-    return MultiGet(
-        options,
-        std::vector<ColumnFamilyHandle*>(keys.size(), DefaultColumnFamily()),
-        keys, values);
+    return MultiGet(options, std::vector<ColumnFamilyHandle*>(
+                                 keys.size(), DefaultColumnFamily()),
+                    keys, values);
   }
 
   // If the key definitely does not exist in the database, then this method
@@ -780,10 +733,13 @@ class DB {
   // include_flags should be of type DB::SizeApproximationFlags
   virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
                                    const Range* range, int n, uint64_t* sizes,
-                                   uint8_t include_flags = INCLUDE_FILES) = 0;
+                                   uint8_t include_flags
+                                   = INCLUDE_FILES) = 0;
   virtual void GetApproximateSizes(const Range* range, int n, uint64_t* sizes,
-                                   uint8_t include_flags = INCLUDE_FILES) {
-    GetApproximateSizes(DefaultColumnFamily(), range, n, sizes, include_flags);
+                                   uint8_t include_flags
+                                   = INCLUDE_FILES) {
+    GetApproximateSizes(DefaultColumnFamily(), range, n, sizes,
+                        include_flags);
   }
 
   // The method is similar to GetApproximateSizes, except it
@@ -800,7 +756,8 @@ class DB {
 
   // Deprecated versions of GetApproximateSizes
   ROCKSDB_DEPRECATED_FUNC virtual void GetApproximateSizes(
-      const Range* range, int n, uint64_t* sizes, bool include_memtable) {
+      const Range* range, int n, uint64_t* sizes,
+      bool include_memtable) {
     uint8_t include_flags = SizeApproximationFlags::INCLUDE_FILES;
     if (include_memtable) {
       include_flags |= SizeApproximationFlags::INCLUDE_MEMTABLES;
@@ -808,8 +765,9 @@ class DB {
     GetApproximateSizes(DefaultColumnFamily(), range, n, sizes, include_flags);
   }
   ROCKSDB_DEPRECATED_FUNC virtual void GetApproximateSizes(
-      ColumnFamilyHandle* column_family, const Range* range, int n,
-      uint64_t* sizes, bool include_memtable) {
+      ColumnFamilyHandle* column_family,
+      const Range* range, int n, uint64_t* sizes,
+      bool include_memtable) {
     uint8_t include_flags = SizeApproximationFlags::INCLUDE_FILES;
     if (include_memtable) {
       include_flags |= SizeApproximationFlags::INCLUDE_MEMTABLES;
@@ -986,16 +944,6 @@ class DB {
   // Currently only works if allow_mmap_writes = false in Options.
   virtual Status SyncWAL() = 0;
 
-  // Lock the WAL. Also flushes the WAL after locking.
-  virtual Status LockWAL() {
-    return Status::NotSupported("LockWAL not implemented");
-  }
-
-  // Unlock the WAL.
-  virtual Status UnlockWAL() {
-    return Status::NotSupported("UnlockWAL not implemented");
-  }
-
   // The sequence number of the most recent transaction.
   virtual SequenceNumber GetLatestSequenceNumber() const = 0;
 
@@ -1079,7 +1027,8 @@ class DB {
                                        ColumnFamilyMetaData* /*metadata*/) {}
 
   // Get the metadata of the default column family.
-  void GetColumnFamilyMetaData(ColumnFamilyMetaData* metadata) {
+  void GetColumnFamilyMetaData(
+      ColumnFamilyMetaData* metadata) {
     GetColumnFamilyMetaData(DefaultColumnFamily(), metadata);
   }
 
@@ -1280,29 +1229,12 @@ class DB {
 
   // Given a time window, return an iterator for accessing stats history
   // User is responsible for deleting StatsHistoryIterator after use
-  virtual Status GetStatsHistory(
-      uint64_t /*start_time*/, uint64_t /*end_time*/,
+  virtual Status GetStatsHistory(uint64_t /*start_time*/,
+      uint64_t /*end_time*/,
       std::unique_ptr<StatsHistoryIterator>* /*stats_iterator*/) {
     return Status::NotSupported("GetStatsHistory() is not implemented.");
   }
 
-#ifndef ROCKSDB_LITE
-  // Make the secondary instance catch up with the primary by tailing and
-  // replaying the MANIFEST and WAL of the primary.
-  // Column families created by the primary after the secondary instance starts
-  // will be ignored unless the secondary instance closes and restarts with the
-  // newly created column families.
-  // Column families that exist before secondary instance starts and dropped by
-  // the primary afterwards will be marked as dropped. However, as long as the
-  // secondary instance does not delete the corresponding column family
-  // handles, the data of the column family is still accessible to the
-  // secondary.
-  // TODO: we will support WAL tailing soon.
-  virtual Status TryCatchUpWithPrimary() {
-    return Status::NotSupported("Supported only by secondary instance");
-  }
-#endif  // !ROCKSDB_LITE
-
  private:
   // No copying allowed
   DB(const DB&);
@@ -1313,7 +1245,7 @@ class DB {
 // Be very careful using this method.
 Status DestroyDB(const std::string& name, const Options& options,
                  const std::vector<ColumnFamilyDescriptor>& column_families =
-                     std::vector<ColumnFamilyDescriptor>());
+                   std::vector<ColumnFamilyDescriptor>());
 
 #ifndef ROCKSDB_LITE
 // If a DB cannot be opened, you may attempt to call this method to