Adaptive Radix Tree: high-performance memtable

.gitignore

@@ -7,6 +7,7 @@ make_config.mk
 *.gcda
 *.gcno
 *.o
+*.o.tmp
 *.so
 *.so.*
 *_test

CMakeLists.txt

@@ -576,6 +576,8 @@ set(SOURCES
         memtable/hash_linklist_rep.cc
         memtable/hash_skiplist_rep.cc
         memtable/skiplistrep.cc
+        memtable/artrep.cc
+        memtable/art.cc
         memtable/vectorrep.cc
         memtable/write_buffer_manager.cc
         monitoring/histogram.cc
@@ -973,6 +975,7 @@ if(WITH_TESTS)
         memory/arena_test.cc
         memtable/inlineskiplist_test.cc
         memtable/skiplist_test.cc
+        memtable/art_test.cc
         memtable/write_buffer_manager_test.cc
         monitoring/histogram_test.cc
         monitoring/iostats_context_test.cc

Makefile

@@ -430,6 +430,7 @@ TESTS = \
 	crc32c_test \
 	coding_test \
 	inlineskiplist_test \
+	art_test \
 	encryption_test \
 	env_basic_test \
 	env_test \
@@ -1423,6 +1424,9 @@ data_block_hash_index_test: table/block_based/data_block_hash_index_test.o $(LIB
 inlineskiplist_test: memtable/inlineskiplist_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 
+art_test: memtable/art_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(AM_LINK)
+
 skiplist_test: memtable/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)
 

TARGETS

@@ -186,6 +186,8 @@ cpp_library(
         "memory/concurrent_arena.cc",
         "memory/jemalloc_nodump_allocator.cc",
         "memtable/alloc_tracker.cc",
+        "memtable/art.cc",
+        "memtable/artrep.cc",
         "memtable/hash_linklist_rep.cc",
         "memtable/hash_skiplist_rep.cc",
         "memtable/skiplistrep.cc",
@@ -1255,6 +1257,13 @@ ROCKS_TESTS = [
         [],
         [],
     ],
+    [
+        "art_test",
+        "memtable/art_test.cc",
+        "serial",
+        [],
+        [],
+    ],
     [
         "slice_transform_test",
         "util/slice_transform_test.cc",

db/db_test.cc

@@ -1021,18 +1021,15 @@ TEST_F(DBTest, FailMoreDbPaths) {
 
 void CheckColumnFamilyMeta(const ColumnFamilyMetaData& cf_meta) {
   uint64_t cf_size = 0;
-  uint64_t cf_csize = 0;
   size_t file_count = 0;
   for (auto level_meta : cf_meta.levels) {
     uint64_t level_size = 0;
-    uint64_t level_csize = 0;
     file_count += level_meta.files.size();
     for (auto file_meta : level_meta.files) {
       level_size += file_meta.size;
     }
     ASSERT_EQ(level_meta.size, level_size);
     cf_size += level_size;
-    cf_csize += level_csize;
   }
   ASSERT_EQ(cf_meta.file_count, file_count);
   ASSERT_EQ(cf_meta.size, cf_size);

db/perf_context_test.cc

@@ -944,10 +944,8 @@ TEST_F(PerfContextTest, BitMapControl) {
   auto db = OpenDb();
   WriteOptions write_options;
   SetPerfLevel(PerfLevel::kDisable);
-  SetPerfFlags(NewPerfFlags({
-      PerfFlag::user_key_comparison_count, 
-      PerfFlag::write_wal_time
-  }));
+  SetPerfFlags(NewPerfFlags(
+      {PerfFlag::user_key_comparison_count, PerfFlag::write_wal_time}));
 
   for (int i = 0; i < FLAGS_total_keys; ++i) {
     std::string i_str = ToString(i);

include/rocksdb/memtablerep.h

@@ -323,6 +323,24 @@ class DoublySkipListFactory : public MemTableRepFactory {
   const size_t lookahead_;
 };
 
+// This uses an adaptive radix tree to store keys, which is similar to trie,
+// but optimize for memory use.
+class AdaptiveRadixTreeFactory : public MemTableRepFactory {
+ public:
+  explicit AdaptiveRadixTreeFactory() {}
+  virtual ~AdaptiveRadixTreeFactory() {}
+
+  using MemTableRepFactory::CreateMemTableRep;
+  MemTableRep* CreateMemTableRep(const MemTableRep::KeyComparator&, Allocator*,
+                                 const SliceTransform*,
+                                 Logger* logger) override;
+  const char* Name() const override { return "AdaptiveRadixTreeFactory"; }
+
+  bool IsInsertConcurrentlySupported() const override { return false; }
+
+  bool CanHandleDuplicatedKey() const override { return false; }
+};
+
 #ifndef ROCKSDB_LITE
 // This creates MemTableReps that are backed by an std::vector. On iteration,
 // the vector is sorted. This is useful for workloads where iteration is very