【LevelDB源码阅读】Cache

2022-09-18 10:38:21

是什么

leveldb内部实现的缓存

为什么要用

性能高于内嵌哈希表

学到什么

与（&）操作进行模运算
减少cache锁操作，可以分为多组cache

源码分析

LRUHandle

缓存中代表键值对的数据结构

// An entry is a variable length heap-allocated structure.  Entries
// are kept in a circular doubly linked list ordered by access time.
struct LRUHandle {
  void *value;  // 存储键值对的值，可以为任意类型
  void (*deleter)(const Slice &, void *value);  // 函数指针当前结构体的清除函数
  LRUHandle *next_hash;                         // 用户hash冲突使用
  LRUHandle *next;                              // 当前节点下一个节点
  LRUHandle *prev;                              // 当前节点上一个节点
  size_t charge;                                // 当前节点占用内存
  size_t key_length;                            // 当前节点键的长度
  bool in_cache;     // Whether entry is in the cache.
  uint32_t refs;     // References, including cache reference, if present.
  uint32_t hash;     // Hash of key(); used for fast sharding and comparisons
  char key_data[1];  // Beginning of key

  Slice key() const {
    // next_ is only equal to this if the LRU handle is the list head of an
    // empty list. List heads never have meaningful keys.
    assert(next != this);

    return Slice(key_data, key_length);
  }
};

HandleTable

自定义的哈希表，首先看数据成员

  // The table consists of an array of buckets where each bucket is
  // a linked list of cache entries that hash into the bucket.
  uint32_t length_;  // hash表桶数组长度
  uint32_t elems_;   // 哈希表存储元素的数量
  LRUHandle **list_;  // 哈希数组指针，其中每个数组元素存储指针类型

构造函数和析构函数

  HandleTable() : length_(0), elems_(0), list_(nullptr) { Resize(); }
  ~HandleTable() { delete[] list_; }

主要接口函数

查询

  LRUHandle* Lookup(const Slice &key, uint32_t hash) {
    return *FindPointer(key, hash);
  }

其中FindPointer方法实现如下，首先确定在哈希数组的哪个哈希桶中，然后沿着哈希链表查找。
如果某个LRUHandle* 存在相同hash和key值，则返回LRUHandle*的二级指针，即上一个LRUHandle*的next_hash的二级指针。
如果不存在，则返回bucket中最后一个 LRUHandle*的next_hash，即为nullptr。

  // Return a pointer to slot that points to a cache entry that
  // matches key/hash.  If there is no such cache entry, return a
  // pointer to the trailing slot in the corresponding linked list.
  LRUHandle** FindPointer(const Slice &key, uint32_t hash) {
    LRUHandle **ptr = &list_[hash & (length_ - 1)];  // 下标结果是0到length-1
    while (*ptr != nullptr && ((*ptr)->hash != hash || key != (*ptr)->key())) {
      ptr = &(*ptr)->next_hash;  // 迭代哈希链找到键值相等节点，ptr为上一节点next_hash值
    }
    return ptr;
  }

插入（插入示意图参考：LevelDB之Cache之HandleTable）

  LRUHandle* Insert(LRUHandle *h) {
    LRUHandle **ptr = FindPointer(h->key(), h->hash);
    LRUHandle *old = *ptr;
    h->next_hash = (old == nullptr ? nullptr : old->next_hash);
    *ptr = h;  //将ptr值也就是对应上一个LRUHandle的next_hash值赋值为h来跳过old
    if (old == nullptr) {  // h是新节点
      ++elems_;
      // Since each cache entry is fairly large, we aim for a small
      // average linked list length (<= 1).
      if (elems_ > length_) {
        Resize();
      }
    }
    return old;
  }

其中Resize方法实现如下：

初始大小为4，每次以原有大小的2倍扩容
以新的长度创建哈希桶大小，并设置每个哈希桶为空
遍历原有每个哈希桶的每个元素，重新确定在新哈希桶的位置，采用头插法插入到新哈希桶的每个链表中
delete原有哈希链表，并赋值为新的哈希链表

  void Resize() {
    uint32_t new_length = 4;
    while (new_length < elems_) {
      new_length *= 2;  // 每次2倍扩容
    }
    LRUHandle **new_list = new LRUHandle *[new_length];
    memset(new_list, 0, sizeof(new_list[0]) * new_length);  //一级指针置空
    uint32_t count = 0;
    for (uint32_t i = 0; i < length_; ++i) {
      LRUHandle *h = list_[i];
      while (h != nullptr) {
        LRUHandle *next = h->next_hash;  // 一级指针上二级指针通过next_hash连接
        uint32_t hash = h->hash;
        LRUHandle **ptr = &new_list[hash & (new_length - 1)];  // 确定在新桶中位置
        h->next_hash = *ptr;  // 第一次*ptr为nullptr，其它为上个循环h的地址
        *ptr = h;
        h = next;
        ++count;
      }
    }
    assert(elems_ == count);
    delete[] list_;
    list_ = new_list;
    length_ = new_length;
  }

删除

  LRUHandle* Remove(const Slice &key, uint32_t hash) {
    LRUHandle **ptr = FindPointer(key, hash);
    LRUHandle *result = *ptr;
    if (result != nullptr) {  // 找到节点
      *ptr = result->next_hash;
      --elems_;
    }
    return result;
  }

LRUCache

数据成员如下包括：

cache总大小
cache已经使用大小
冷链表（lru_），即在cache中，但没有被外部引用，cache容量满时会被淘汰
热链表（in_use_），即在cache中，同时又被外部引用，cache容量满时也不会被淘汰
哈希表（table_），用于快速查找（链表结构则用于快速插入和删除）

  // Initialized before use.
  size_t capacity_;  // cache总容量

  // mutex_ protects the following state.
  mutable port::Mutex mutex_;
  size_t usage_ GUARDED_BY(mutex_);  // 已经使用的cache空间

  // Dummy head of LRU list.
  // lru.prev is newest entry, lru.next is oldest entry.
  // Entries have refs==1 and in_cache==true.
  LRUHandle lru_ GUARDED_BY(mutex_);  // 双向循环链表

  // Dummy head of in-use list.
  // Entries are in use by clients, and have refs >= 2 and in_cache==true.
  LRUHandle in_use_ GUARDED_BY(mutex_);

  HandleTable table_ GUARDED_BY(mutex_);  // 二级指针数组，用于缓存数据

构造函数和析构函数
构造函数，初始化所有数据成员，其中哈希执行默认初始化。

LRUCache::LRUCache() : capacity_(0), usage_(0) {
  // Make empty circular linked lists.
  lru_.next = &lru_;
  lru_.prev = &lru_;
  in_use_.next = &in_use_;
  in_use_.prev = &in_use_;
}

执行析构函数时，热链表中不应该有元素，函数体主要删除冷链表中元素。

LRUCache::~LRUCache() {
  assert(in_use_.next == &in_use_);  // Error if caller has an unreleased handle
  for (LRUHandle *e = lru_.next; e != &lru_;) {
    LRUHandle *next = e->next;
    assert(e->in_cache);
    e->in_cache = false;
    assert(e->refs == 1);  // Invariant of lru_ list.
    Unref(e);
    e = next;
  }
}

主要对外接口

查找

根据key和hash值在哈希表中进行查找，查找到后更新热链表。

Cache::Handle* LRUCache::Lookup(const Slice& key, uint32_t hash) {
  MutexLock l(&mutex_);
  LRUHandle* e = table_.Lookup(key, hash);
  if (e != nullptr) {
    Ref(e);
  }
  return reinterpret_cast<Cache::Handle*>(e);
}

插入

首先申请LRUHandle内存并且初始化，LRUHandle对象指针会返回给调用方，所以refs此时为1，然后添加到in_use_链表尾部，refs此时为2，同时更新in_cache=true和cache使用量。如果
插入到哈希表table_中已经存在，则会将原有节点从cache中删除。最后如果容量超限，从lru_进行淘汰并从哈希表中删除。

Cache::Handle* LRUCache::Insert(const Slice& key, uint32_t hash, void* value,
                                size_t charge,
                                void (*deleter)(const Slice& key,
                                                void* value)) {
  MutexLock l(&mutex_);

  LRUHandle* e =
      reinterpret_cast<LRUHandle*>(malloc(sizeof(LRUHandle) - 1 + key.size()));
  e->value = value;
  e->deleter = deleter;
  e->charge = charge;
  e->key_length = key.size();
  e->hash = hash;
  e->in_cache = false;
  e->refs = 1;  // for the returned handle.
  std::memcpy(e->key_data, key.data(), key.size());

  if (capacity_ > 0) {
    e->refs++;  // for the cache‘s reference.
    e->in_cache = true;
    LRU_Append(&in_use_, e);
    usage_ += charge;
    FinishErase(table_.Insert(e));  // 插入到哈希表中同时清理旧节点
  } else {  // don‘t cache. (capacity_==0 is supported and turns off caching.)
    // next is read by key() in an assert, so it must be initialized
    e->next = nullptr;
  }
  while (usage_ > capacity_ && lru_.next != &lru_) {
    LRUHandle* old = lru_.next;
    assert(old->refs == 1);
    bool erased = FinishErase(table_.Remove(old->key(), old->hash));
    if (!erased) {  // to avoid unused variable when compiled NDEBUG
      assert(erased);
    }
  }

  return reinterpret_cast<Cache::Handle*>(e);
}

删除

从哈希表中删除，然后从cache链表删除。

void LRUCache::Erase(const Slice& key, uint32_t hash) {
  MutexLock l(&mutex_);
  FinishErase(table_.Remove(key, hash));
}

其它辅助方法

Ref方法表示要使用该cache，如果元素位于冷链表中，需要移到热链表。

void LRUCache::Ref(LRUHandle* e) {
  if (e->refs == 1 && e->in_cache) {  // If on lru_ list, move to in_use_ list.
    LRU_Remove(e);
    LRU_Append(&in_use_, e);
  }
  e->refs++;
}

Unref正好相反，表示用户不再使用该元素，需要将引用计数--，如果彻底没有用户使用，即引用计数为0，则删除这个元素，如果引用计数为1，则从热链表移到冷链表中。

void LRUCache::Unref(LRUHandle* e) {
  assert(e->refs > 0);
  e->refs--;
  if (e->refs == 0) {  // Deallocate.
    assert(!e->in_cache);
    (*e->deleter)(e->key(), e->value);
    free(e);
  } else if (e->in_cache && e->refs == 1) {
    // No longer in use; move to lru_ list.
    LRU_Remove(e);
    LRU_Append(&lru_, e);
  }
}

其中从链表删除元素和将元素插入指定链表如下：

void LRUCache::LRU_Remove(LRUHandle* e) {
  e->next->prev = e->prev;
  e->prev->next = e->next;
}

void LRUCache::LRU_Append(LRUHandle* list, LRUHandle* e) {
  // Make "e" newest entry by inserting just before *list
  e->next = list;
  e->prev = list->prev;
  e->prev->next = e;
  e->next->prev = e;
}

SharedLRUCache

为什么有SharedLRUCache？
LRUCache的接口都会加锁，为了更少的锁持有时间以及更高的缓存命中率，可以定义多个LRUCache，分别处理不同hash取模后的缓存处理。SharedLRUCache是LRUCache上的一层封装，管理16个cache，对外提供服务，外部调用接口都委托内部某个LRUCache。

数据成员

  LRUCache shard_[kNumShards];  // 16个LRUCache

SharedLRUCache的主要作用就是计算Hash值，选择LRUCache，代码如下：

  static inline uint32_t HashSlice(const Slice &s) {
    return Hash(s.data(), s.size(), 0);
  }

  static uint32_t Shard(uint32_t hash) {  // 得到shard_数组下标
    return hash >> (32 - kNumShardBits);  // 取hash高4位得到shard_数组下标
  }

主要对外接口
这些接口都是先计算hash值，然后根据hash值选择LRUCache，最后通过调用LRUCache来实现。

插入

  Handle* Insert(const Slice &key, void *value, size_t charge,
                 void (*deleter)(const Slice &key, void *value)) override {
    const uint32_t hash = HashSlice(key);
    return shard_[Shard(hash)].Insert(key, hash, value, charge, deleter);
  }

查找

  Handle* Lookup(const Slice &key) override {
    const uint32_t hash = HashSlice(key);
    return shard_[Shard(hash)].Lookup(key, hash);
  }

删除

  void Erase(const Slice &key) override {
    const uint32_t hash = HashSlice(key);
    shard_[Shard(hash)].Erase(key, hash);
  }

查看缓存使用大小

  size_t TotalCharge() const override {
    size_t total = 0;
    for (int s = 0; s < kNumShards; s++) {
      total += shard_[s].TotalCharge();
    }
    return total;
  }