Provide mechanism to configure when to flush the block

Summary: Allow block based table to configure the way flushing the blocks. This feature will allow us to add support for prefix-aligned block.

Test Plan: make check

Reviewers: dhruba, haobo, sdong, igor

Reviewed By: sdong

CC: leveldb

Differential Revision: https://reviews.facebook.net/D13875

include/rocksdb/flush_block_policy.h

@@ -0,0 +1,64 @@
+//  Copyright (c) 2013, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under the BSD-style license found in the
+//  LICENSE file in the root directory of this source tree. An additional grant
+//  of patent rights can be found in the PATENTS file in the same directory.
+
+#pragma once
+
+#include <string>
+
+namespace rocksdb {
+
+class Slice;
+class BlockBuilder;
+
+// FlushBlockPolicy provides a configurable way to determine when to flush a
+// block in the block based tables,
+class FlushBlockPolicy {
+ public:
+  // Keep track of the key/value sequences and return the boolean value to
+  // determine if table builder should flush current data block.
+  virtual bool Update(const Slice& key,
+                      const Slice& value) = 0;
+
+  virtual ~FlushBlockPolicy() { }
+};
+
+class FlushBlockPolicyFactory {
+ public:
+  // Return the name of the flush block policy.
+  virtual const char* Name() const = 0;
+
+  // Return a new block flush policy that flushes data blocks by data size.
+  // FlushBlockPolicy may need to access the metadata of the data block
+  // builder to determine when to flush the blocks.
+  //
+  // Callers must delete the result after any database that is using the
+  // result has been closed.
+  virtual FlushBlockPolicy* NewFlushBlockPolicy(
+      const BlockBuilder& data_block_builder) const = 0;
+
+  virtual ~FlushBlockPolicyFactory() { }
+};
+
+class FlushBlockBySizePolicyFactory : public FlushBlockPolicyFactory {
+ public:
+  FlushBlockBySizePolicyFactory(const uint64_t block_size,
+                                const uint64_t block_size_deviation) :
+      block_size_(block_size),
+      block_size_deviation_(block_size_deviation) {
+  }
+
+  virtual const char* Name() const override {
+    return "FlushBlockBySizePolicyFactory";
+  }
+
+  virtual FlushBlockPolicy* NewFlushBlockPolicy(
+      const BlockBuilder& data_block_builder) const override;
+
+ private:
+  const uint64_t block_size_;
+  const uint64_t block_size_deviation_;
+};
+
+}  // rocksdb

include/rocksdb/options.h

@@ -11,26 +11,27 @@
 #include <vector>
 #include <stdint.h>
 
+#include "rocksdb/memtablerep.h"
 #include "rocksdb/memtablerep.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/slice_transform.h"
+#include "rocksdb/slice_transform.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/table_stats.h"
 #include "rocksdb/universal_compaction.h"
-#include "rocksdb/memtablerep.h"
-#include "rocksdb/slice_transform.h"
 
 namespace rocksdb {
 
 class Cache;
+class CompactionFilter;
+class CompactionFilterFactory;
 class Comparator;
 class Env;
 class FilterPolicy;
+class FlushBlockPolicyFactory;
 class Logger;
 class MergeOperator;
 class Snapshot;
-class CompactionFilter;
-class CompactionFilterFactory;
 class TableFactory;
 
 using std::shared_ptr;
@@ -485,6 +486,13 @@ struct Options {
   // from the database, because otherwise the read can be very slow.
   Options* PrepareForBulkLoad();
 
+  // Set up the default flush-block policy factory. By default, we'll use
+  // `FlushBlockBySizePolicyFactory` as the policy factory.
+  // Note: Please call this method after block_size and block_size_deviation
+  //       is set.
+  // REQUIRES: flush_block_policy_factory is not set.
+  Options* SetUpDefaultFlushBlockPolicyFactory();
+
   // Disable automatic compactions. Manual compactions can still
   // be issued on this database.
   bool disable_auto_compactions;
@@ -623,6 +631,13 @@ struct Options {
   // Number of locks used for inplace update
   // Default: 10000, if inplace_update_support = true, else 0.
   size_t inplace_update_num_locks;
+
+  // Creates the instances of flush block policy.
+  // A flush-block policy provides a configurable way to determine when to
+  // flush a block in the block based tables,
+  // Default: nullptr. User can call FlushBlockBySizePolicyFactory() to set
+  // up default policy factory (`FlushBlockBySizePolicyFactory`).
+  std::shared_ptr<FlushBlockPolicyFactory> flush_block_policy_factory;
 };
 
 //