leveldb深度剖析-MemTable

上一篇介紹了SkipList數據結構，但leveldb插入數據並不是直接操作SkipList，而是直接操作MemTable。可以理解爲MemTable是對SkipList一層封裝。

一、數據結構

class MemTable {
 public:
  // MemTables are reference counted.  The initial reference count
  // is zero and the caller must call Ref() at least once.
  explicit MemTable(const InternalKeyComparator& comparator);

  // Increase reference count.
  void Ref() { ++refs_; }

  // Drop reference count.  Delete if no more references exist.
  void Unref() {//引用計數器爲0時表MemTable沒有用了 要刪除掉
    --refs_;
    assert(refs_ >= 0);
    if (refs_ <= 0) {
      delete this;
    }
  }

  // Returns an estimate of the number of bytes of data in use by this
  // data structure. It is safe to call when MemTable is being modified.
  size_t ApproximateMemoryUsage();

  // Return an iterator that yields the contents of the memtable.
  //
  // The caller must ensure that the underlying MemTable remains live
  // while the returned iterator is live.  The keys returned by this
  // iterator are internal keys encoded by AppendInternalKey in the
  // db/format.{h,cc} module.
  Iterator* NewIterator();

  // Add an entry into memtable that maps key to value at the
  // specified sequence number and with the specified type.
  // Typically value will be empty if type==kTypeDeletion.
  void Add(SequenceNumber seq, ValueType type,
           const Slice& key,
           const Slice& value);

  // If memtable contains a value for key, store it in *value and return true.
  // If memtable contains a deletion for key, store a NotFound() error
  // in *status and return true.
  // Else, return false.
  bool Get(const LookupKey& key, std::string* value, Status* s);

 private:
  ~MemTable();  // Private since only Unref() should be used to delete it

  struct KeyComparator {
    const InternalKeyComparator comparator;
    explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
    int operator()(const char* a, const char* b) const;
  };
  friend class MemTableIterator;
  friend class MemTableBackwardIterator;

  typedef SkipList<const char*, KeyComparator> Table;

  KeyComparator comparator_; // 比較器
  int refs_;
  Arena arena_;
  Table table_; /* 跳錶 Table類型重定義typedef */

  // No copying allowed
  MemTable(const MemTable&);
  void operator=(const MemTable&);
};

通過上面數據結構定義可知：

1) 真正常用接口只有插入Put和查詢Get

2)  封裝了SkipList\比較器\迭代器

3) 通過引用計數器來控制器MemTable對象是否需要釋放.以前的文章說明過，leveldb會現將輸入插入到MemTable中，當MemTable使用內存達到一定門限後會轉變成Immutable MemTable，然後將Immutable MemTable數據寫到磁盤中.最後將Immutable MemTable內存釋放掉,就是通過Ref進行控制的。

二、添加/刪除

添加和刪除操作對於MemTable來說都是Add操作，Add方法比較簡單，具體函數實現如下：

void MemTable::Add(SequenceNumber s, ValueType type,
                   const Slice& key,
                   const Slice& value) {
  size_t key_size = key.size();
  size_t val_size = value.size();
  size_t internal_key_size = key_size + 8;//這裏的8是SequenceNumber右移8位 或 操作ValueType
  const size_t encoded_len =
      VarintLength(internal_key_size) + internal_key_size +
      VarintLength(val_size) + val_size;
  char* buf = arena_.Allocate(encoded_len);
  //添加inernal_key長度及內容
  char* p = EncodeVarint32(buf, internal_key_size);
  memcpy(p, key.data(), key_size);
  p += key_size;
  EncodeFixed64(p, (s << 8) | type);//SequenceNumber最高8bit是預留給此處使用
  p += 8;
  //添加value長度及內容
  p = EncodeVarint32(p, val_size);
  memcpy(p, value.data(), val_size);
  assert((p + val_size) - buf == encoded_len);
  //插入到跳錶中 比較規則 比較internalkey 可參考InternalKeyComparator::Compare
  table_.Insert(buf);
}

說明：

1) 該方法構造一條Record，具體格式如下：

MemTable Record := 
    internal_key:  
    value:
internal_key :=
    internalkey-size:  varint32
    user-key :         uint8[key_size]
    SequenceNum|Type:  fixed64
value :=
    user-value_size:   varint32
    user-value:        uint8[value_size]

2) 調用insert接口插入到SkipList中 

三、查詢

插入邏輯比較簡單，接下來介紹查詢操作，方法實現如下：

/**
 * 查詢接口
 * @param key 查詢key封裝了InternalKey
 * @param value 輸出參數 用戶輸入value
 * @param s 保存狀態 當未找到key時 設置爲NotFound
 */
bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
  Slice memkey = key.memtable_key();
  Table::Iterator iter(&table_);
  iter.Seek(memkey.data());// memkey.data返回的是InternalKey 查找 ./db/skiplist.h
  if (iter.Valid()) {
    // entry format is:
    //    klength  varint32
    //    userkey  char[klength]
    //    tag      uint64
    //    vlength  varint32
    //    value    char[vlength]
    // Check that it belongs to same user key.  We do not check the
    // sequence number since the Seek() call above should have skipped
    // all entries with overly large sequence numbers.

    // 由於查詢過程中比較的key是按照InternalKey進行比較的, 這裏按照user-key再次進行比較
    const char* entry = iter.key();
    uint32_t key_length;
    const char* key_ptr = GetVarint32Ptr(entry, entry+5, &key_length);
    if (comparator_.comparator.user_comparator()->Compare(
            Slice(key_ptr, key_length - 8),
            key.user_key()) == 0) {// 比較用戶輸入的key是否相等  比較函數util/comparator.cc
      // Correct user key
      const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
      switch (static_cast<ValueType>(tag & 0xff)) {
        case kTypeValue: {
          Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
          value->assign(v.data(), v.size());
          return true;
        }
        case kTypeDeletion:
          *s = Status::NotFound(Slice());
          return true;
      }
    }
  }
  return false;
}

說明：

1) 爲了處理方便，leveldb在查詢的時候引入一個新的對象LookupKey，其內部構造就是InternalKey結構

2) 調用Seek按照InternalKey進行查找，如果沒有找到則返回false，否則需要再次進行比較.對InternalKey進行解析，解析出user-key，再次按照user-key進行比較

3) 如果user-key比較相同則認爲找到

四、比較器

在進行查找流程時，實際上遍歷SkipList，然後在SkipList中進行比較，但是SkipList並沒有提供比較器，比較器是由上層MemTable定義的，具體流程圖如下：

比較器實現比較簡單並且有很多註釋，這裏將相關代碼羅列一下：

template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::KeyIsAfterNode(const Key& key, Node* n) const {
  // NULL n is considered infinite
  // 這裏先調用重載()運算符 MemTable::KeyComparator::operator()
  return (n != NULL) && (compare_(n->key, key) < 0);  
}

/**
 * 重載()運算符
 * @param aptr InternalKey格式
 * @param bptr InternalKey格式
 */
int MemTable::KeyComparator::operator()(const char* aptr, const char* bptr)
    const {
  // Internal keys are encoded as length-prefixed strings.
  Slice a = GetLengthPrefixedSlice(aptr);
  Slice b = GetLengthPrefixedSlice(bptr); //返回值指向InternalKey對象中value部分
  return comparator.Compare(a, b);// InternalKeyComparator::Compare  db/dbformat.cc
}

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)
  // user key比較
  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
  if (r == 0) {//表示 user key 相同
    //這裏num應該是SequenceNumber|type  type = 0 表示刪除  type = 1表示查找或者插入
    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
    if (anum > bnum) {
      r = -1;
    } else if (anum < bnum) {
      r = +1;
    }
  }
  return r;
}

特別說明：Compare在比較的時候先按照User-Key進行比較，如果User-Key相等則按照Sequence Number|Type比較。這就保證在寫入ldb文件時候每一層文件key是有順序的不重疊的(除level0外)。

五、總結

由於篇幅原因不能把MemTable所有內容都介紹出來，這裏只把重點方法介紹了一下，其他方法需要自己閱讀源碼。