leveldb memtable

memtable常驻于内存，需要按照key进行排序，通常意义上的话，可以使用二叉查找树来实现，跟进一步可以使用红黑树保证树的平衡，但是leveldb中使用了另外的一种数据结构：跳表Skip List。

memtable声明在db/memtable.h中，定义如下：

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()
    {
        --refs_;
        assert(refs_ >= 0);
        if (refs_ <= 0)     // 如果引用数为0,删除该对象
        {
            delete this;
        }
    }

    // Returns an estimate of the number of bytes of data in use by this
    // data structure.
    //
    // REQUIRES: external synchronization to prevent simultaneous
    // operations on the same MemTable.
    // 返回使用的内存量
    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.
    // 返回迭代器，遍历该memtable
    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.
    // 由于采用了LSM结构，所以没有数据删除，只有数据的添加，如果type=
    // kTypeDeletion，这时value为空
    // sequence number：递增的序列，用于数据的恢复
    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.
    // 查询该memtable
    bool Get(const LookupKey& key, std::string* value, Status* s);

private:
    // 私有化析构函数，这样保证只有Unref()方法能够删除该对象
    ~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;

    // key比较器
    KeyComparator comparator_;
    // 对象被引用的数量，如果该值为0，则删除该对象
    int refs_;

    // 内存区域的封装
    Arena arena_;
    // 使用跳表数据结构保证内存数据按照key排序
    Table table_;

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

这里面有几个注意点，首先Arena对象实现了一套leveldb的内存管理策略，将在下面的文章中进行分析，这里仅仅将其想象成一个内存分配器即可；另外就是Table类型（实际上就是SkipList类型）也将在下面的文章中进行分析。下面主要关注memtable初始化、插入key、查询key，由于LSM模型中memtable中没有数据的“实际”删除，这里并没有实现删除方法。

初始化函数定义如下：

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

就是简单的完成refs_和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()]
    // 首先格式化kv数据，之后分别写入,格式如下:
    // key_size, key_bytes, sequence_number|type(固定64位),
    // value_size,value
    size_t key_size = key.size();
    size_t val_size = value.size();
    size_t internal_key_size = key_size + 8;
    const size_t encoded_len =
        VarintLength(internal_key_size) + internal_key_size +
        VarintLength(val_size) + val_size;
    char* buf = arena_.Allocate(encoded_len);
    char* p = EncodeVarint32(buf, internal_key_size);
    memcpy(p, key.data(), key_size);
    p += key_size;
    EncodeFixed64(p, (s << 8) | type);  // (sequencenum << 8) | type
    p += 8;
    p = EncodeVarint32(p, val_size);
    memcpy(p, value.data(), val_size);
    assert((p + val_size) - buf == encoded_len);

    // 插入数据
    table_.Insert(buf);
}

思路上相对比较简单，首先对用户传递进来的kv进行格式化，之后调用table_的Insert方法插入到数据库中，需要注意：1. 新出现了Slice类型，基本上和std::string类型向类似，代码比较简单，这里略过；2. 用户传递进来的kv最终被封装到了一个char数组中，格式为key_size, key_bytes, (sequence_number << 8)|type,value_size, value_bytes（其中并没有,这里仅仅是为了区分）。

查询的操作代码如下：

bool MemTable::Get(const LookupKey& key, std::string* value, Status* s)
{
    Slice memkey = key.memtable_key();
    Table::Iterator iter(&table_);
    // 查找key
    iter.Seek(memkey.data());
    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.
        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)   // memtable找到的key和用户查找的key相同
        {
            // Correct user key
            const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
            switch (static_cast<ValueType>(tag & 0xff)) // 屏蔽低8位
            {
            case kTypeValue:    // 如果是kTypeValue类型，表明找到
            {
                Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
                value->assign(v.data(), v.size());
                return true;
            }
            case kTypeDeletion: // 如果是kTypeDeletion删除的数据
                *s = Status::NotFound(Slice());
                return true;
            }
        }
    }
    return false;
}

Get函数内首先通过Table查找key，如果找到该key，解析key的内容，如果是kTypeValue类型的，返回给客户端查找到的value，如果是kTypeDeletion类型的（参考leveldb源代码分析：理论基础），返回给客户端表明没有找到。这里需要注意的是Get的参数中使用了LookupKey，该类型实际上就是在用户输入的key/value和leveldb内部使用key的起到桥梁的作用，定义如下：

// A helper class useful for DBImpl::Get()
class LookupKey{
 public:
  // Initialize *this for looking up user_key at a snapshot with
  // the specified sequence number.
  LookupKey(const Slice& user_key, SequenceNumber sequence);

  ~LookupKey();

  // Return a key suitable for lookup in a MemTable.
  Slice memtable_key() const { return Slice(start_, end_ - start_); }

  // Return an internal key (suitable for passing to an internal iterator)
  Slice internal_key() const { return Slice(kstart_, end_ - kstart_); }

  // Return the user key
  Slice user_key() const { return Slice(kstart_, end_ - kstart_ - 8); }

 private:
  // We construct a char array of the form:
  //    klength  varint32               <-- start_
  //    userkey  char[klength]          <-- kstart_
  //    tag      uint64
  //                                    <-- end_
  // The array is a suitable MemTable key.
  // The suffix starting with "userkey" can be used as an InternalKey.
  const char* start_;
  const char* kstart_;
  const char* end_;
  char space_[200];      // Avoid allocation for short keys

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

至此基本上memtable的初始化、读取、插入的操作分析完了，未解决问题如下：

1. SkipList数据结构

2. Arena内存分配策略