leveldb源码学习之MemTable

levedb的MemTable用于存储k-v数据

• memtable 用引用计数器管理，若计数为0则释放空间
• 用跳表实现内部有序（leveldb跳表实现见：leveldb源码学习之跳表skiplist）
• memtable 的key编码为以长度作为前缀的string，所以要先读取到实际长度，再获取key内容。
• key末尾存放64位的tag，标识key是value还是delete。查询时找到的key为value则返回值，为delete则返回notfound

memtable.h

#ifndef STORAGE_LEVELDB_DB_MEMTABLE_H_
#define STORAGE_LEVELDB_DB_MEMTABLE_H_

#include <string>

#include "db/dbformat.h"
#include "db/skiplist.h"
#include "leveldb/db.h"
#include "util/arena.h"

namespace leveldb {

class InternalKeyComparator;  // 用于key比较
class MemTableIterator;       // memtable 迭代器

class MemTable {
 public:
  // MemTables 使用引用计数，计数初始化为0.  
  // 使用者至少调用 Ref() 一次.
  explicit MemTable(const InternalKeyComparator& comparator); // 显式构造，指定比较器

  MemTable(const MemTable&) = delete;  // 禁止拷贝构造
  MemTable& operator=(const MemTable&) = delete;  // 禁止赋值

  // 引用计数加1.
  void Ref() { ++refs_; }  

  // 释放引用计数.  若没有引用则回收此memtable.
  void Unref() {
    --refs_;
    assert(refs_ >= 0);
    if (refs_ <= 0) {
      delete this;
    }
  }

  // 返回此结构使用的字节数的估计
  // 当MemTable 被修改时也可以安全调用 
  size_t ApproximateMemoryUsage();

  // 返回 memtable 迭代器.
  // 调用者必须保证 MemTable 是可用的（没有被回收）
  // 此迭代器返回的 keys 是AppendInternalKey 编码过的 keys 
  // 定义在 db/format.{h,cc}.
  Iterator* NewIterator();

  // 在指定的位置添加一个k-v，指定类型.
  // 若type==kTypeDeletion ，则value为空（已删除）.
  void Add(SequenceNumber seq, ValueType type, const Slice& key,
           const Slice& value);

  // 若memtable 包含key对应的value，在*value中存储并返回true.
  // 若 memtable包含key为deletion （删除）, 在status中保存NotFound() 错误，返回true
  // 其余返回false.
  bool Get(const LookupKey& key, std::string* value, Status* s);

 private:
  friend class MemTableIterator;
  friend class MemTableBackwardIterator;

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

  typedef SkipList<const char*, KeyComparator> Table; // 内部有序是以跳表实现

  ~MemTable();  // 私有，只有通过调用 Unref() 可以回收memtable

  KeyComparator comparator_;
  int refs_;
  Arena arena_; //内存分配器
  Table table_;
};

}  // namespace leveldb

#endif  // STORAGE_LEVELDB_DB_MEMTABLE_H_

 

 

memtable.cc

#include "db/memtable.h"
#include "db/dbformat.h"
#include "leveldb/comparator.h"
#include "leveldb/env.h"
#include "leveldb/iterator.h"
#include "util/coding.h"

namespace leveldb {

// 从data开头获取长度len，再根据len获得实际数据
static Slice GetLengthPrefixedSlice(const char* data) {
  uint32_t len;
  const char* p = data;
  p = GetVarint32Ptr(p, p + 5, &len);  // +5: we assume "p" is not corrupted
  return Slice(p, len);
}

MemTable::MemTable(const InternalKeyComparator& comparator)
    : comparator_(comparator), refs_(0), table_(comparator_, &arena_) {}

MemTable::~MemTable() { assert(refs_ == 0); }

// memtable 使用字节数的估计
size_t MemTable::ApproximateMemoryUsage() { return arena_.MemoryUsage(); }

int MemTable::KeyComparator::operator()(const char* aptr,
                                        const char* bptr) const {
  // 内部的key都编码为以长度作为前缀的string.
  Slice a = GetLengthPrefixedSlice(aptr);
  Slice b = GetLengthPrefixedSlice(bptr);
  return comparator.Compare(a, b);
}

// 给 "target" 编码为一个前缀为长度的key，并返回.
// 将 *scratch 作为缓存空间，返回指向该空间的指针.
static const char* EncodeKey(std::string* scratch, const Slice& target) {
  scratch->clear();
  PutVarint32(scratch, target.size()); // 将长度编码到开头
  scratch->append(target.data(), target.size());
  return scratch->data();
}

// 迭代器
class MemTableIterator : public Iterator {
 public:
  explicit MemTableIterator(MemTable::Table* table) : iter_(table) {}

  MemTableIterator(const MemTableIterator&) = delete; // 禁止拷贝构造
  MemTableIterator& operator=(const MemTableIterator&) = delete;  // 禁止赋值

  ~MemTableIterator() override = default;

  bool Valid() const override { return iter_.Valid(); }
  void Seek(const Slice& k) override { iter_.Seek(EncodeKey(&tmp_, k)); }
  void SeekToFirst() override { iter_.SeekToFirst(); }
  void SeekToLast() override { iter_.SeekToLast(); }
  void Next() override { iter_.Next(); }
  void Prev() override { iter_.Prev(); }
  Slice key() const override { return GetLengthPrefixedSlice(iter_.key()); }
  Slice value() const override {
    Slice key_slice = GetLengthPrefixedSlice(iter_.key());
    return GetLengthPrefixedSlice(key_slice.data() + key_slice.size());
  }

  Status status() const override { return Status::OK(); }

 private:
  MemTable::Table::Iterator iter_;
  std::string tmp_;  // 用于 EncodeKey 编码的缓存
};

// 返回指向table_ 的新迭代器
Iterator* MemTable::NewIterator() { return new MemTableIterator(&table_); }

void MemTable::Add(SequenceNumber s, ValueType type, const Slice& key,
                   const Slice& value) {
  // Format of an entry is concatenation of:
  //  key_size     : varint32 of internal_key.size()
  //  key bytes    : char[internal_key.size()]
  //  value_size   : varint32 of value.size()
  //  value bytes  : char[value.size()]
  size_t key_size = key.size();
  size_t val_size = value.size();
  size_t internal_key_size = key_size + 8; // key末尾有8个字节存放tag，标识value还是deleton
  const size_t encoded_len = VarintLength(internal_key_size) +
                             internal_key_size + VarintLength(val_size) +
                             val_size; //所以总内容是：key.size + key + value.size + value
  char* buf = arena_.Allocate(encoded_len);  // 分配空间
  char* p = EncodeVarint32(buf, internal_key_size);  // 先储存key.size
  memcpy(p, key.data(), key_size); // 储存key
  p += key_size;
  EncodeFixed64(p, (s << 8) | type); // 存放key对应的tag
  p += 8;
  p = EncodeVarint32(p, val_size);  // 存放value.size
  memcpy(p, value.data(), val_size);  // 存放value
  assert(p + val_size == buf + encoded_len); //校验空间
  table_.Insert(buf);
}

bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
  Slice memkey = key.memtable_key();
  Table::Iterator iter(&table_);
  iter.Seek(memkey.data());
  if (iter.Valid()) {
    // 格式:
    //    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.
    const char* entry = iter.key();
    uint32_t key_length;
    const char* key_ptr = GetVarint32Ptr(entry, entry + 5, &key_length); // key_ptr获得key起始地址，key_length得到key长度。
    if (comparator_.comparator.user_comparator()->Compare(
            Slice(key_ptr, key_length - 8), key.user_key()) == 0) {
      // Correct user key
      const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8); // 获取存放于key末尾的tag
      switch (static_cast<ValueType>(tag & 0xff)) {
        case kTypeValue: { // key存放的是value，则从key后面的地址读取value
          Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
          value->assign(v.data(), v.size());
          return true;
        }
        case kTypeDeletion: // key 已删除，则返回notfound
          *s = Status::NotFound(Slice());
          return true;
      }
    }
  }
  return false;
}

}  // namespace leveldb