levelDB源码笔记（3）-cache

levelDB实现的cache是LRU(Least Recently Used 近期最少使用)算法。其实现在ShardedLRUCache中，类成员主要有

class ShardedLRUCache : public Cache { private:  LRUCache shard_[kNumShards];  port::Mutex id_mutex_;  uint64_t last_id_;  static inline uint32_t HashSlice(const Slice& s) {    return Hash(s.data(), s.size(), 0);  }  static uint32_t Shard(uint32_t hash) {    return hash >> (32 - kNumShardBits);  } public:  explicit ShardedLRUCache(size_t capacity)      : last_id_(0) {    const size_t per_shard = (capacity + (kNumShards - 1)) / kNumShards;    for (int s = 0; s < kNumShards; s++) {      shard_[s].SetCapacity(per_shard);    }  }  virtual ~ShardedLRUCache() { }  virtual Handle* Insert(const Slice& key, void* value, size_t charge,                         void (*deleter)(const Slice& key, void* value)) {    const uint32_t hash = HashSlice(key);    return shard_[Shard(hash)].Insert(key, hash, value, charge, deleter);  }  virtual Handle* Lookup(const Slice& key) {    const uint32_t hash = HashSlice(key);    return shard_[Shard(hash)].Lookup(key, hash);  }  virtual void Release(Handle* handle);  virtual void Erase(const Slice& key);  virtual void* Value(Handle* handle);};

其主要的成员是LRUCache shard_[kNumShards];

每个SharedLRUCache包含多个LRUCache，查找Key时首先计算key属于哪一个分片hash=Shard(HashSlice(key))  ,然后在相应的shard_[hash]上进行查找。分片采用hash值的高位，这是一种常见的方法。使用多个LRUCache上，可以减少多线程的锁开销。对了，cache里都使用了mutex，ref等技术，保证了线程安全 

LRUCache用的是个比较标准的算法。

 class LRUCache { public:  void SetCapacity(size_t capacity) { capacity_ = capacity; }  // Like Cache methods, but with an extra "hash" parameter.  Cache::Handle* Insert(const Slice& key, uint32_t hash,                        void* value, size_t charge,                        void (*deleter)(const Slice& key, void* value));  Cache::Handle* Lookup(const Slice& key, uint32_t hash);  void Release(Cache::Handle* handle);  void Erase(const Slice& key, uint32_t hash); private: // Initialized before use.  size_t capacity_;  // mutex_ protects the following state.  port::Mutex mutex_;  size_t usage_;  // Dummy head of LRU list.  // lru.prev is newest entry, lru.next is oldest entry.  LRUHandle lru_;  HandleTable table_;} 

LRUCache需要通过key来获取对应的value（或null表示missing），每个数据对的指针保存在一个Handle节点里。

其主要成员包括一个按使用时间排列的双向链表lru。双向列表适合插入删除，特别是可以快速删除最老的块。其中lru.prev指向最新使用的块，lru.next指向最老的块。capacity_是cache最大长度，useage_则是当前已用，当useage_>capicity_，则删掉最老的一些块，释放内存。

另一个成员table_。这是一个自己实现的哈希表（内部实现采用二维链表），可以通过key找到对应的块。

双向链表和handletable的单个节点都是LRUHandle。所以LRUHandle包含了数据key/value，双向列表需要的前向，后向指针，以及handletable需要的指针next_hash

其成员函数定义如下：

struct LRUHandle {  void* value;  void (*deleter)(const Slice&, void* value);  LRUHandle* next_hash; //handletable需要的指针  LRUHandle* next;  //双向链表需要的next指针  LRUHandle* prev;   //双向链表需要的prev指针  size_t charge;      // 本块的数据大小（似乎是只有value的大小？不过这个不重要）  size_t key_length;  uint32_t refs;  uint32_t hash;      // Hash of key(); used for fast sharding and comparisons  char key_data[1];   // Beginning of key......};

这里用了几个技巧

1. key_data[1] .这个必须放在结构的最后一个成员。当申请一个LRUHandle变量时，申请的长度是sizeof(LRUHandle)-1 + key.size()

  LRUHandle* e = reinterpret_cast<LRUHandle*>(      malloc(sizeof(LRUHandle)-1 + key.size()));

用key_data可以索引到后面一些多出来的内存，等于实现了一个变长的buffer。

2. refs。

我们知道，cache随时可能被替换。当一个Handle块被从cache删除时，可能外部另一个线程正在使用它，这时候我们直接释放掉对应的内存，就会出错。

这里用ref配合delete函数来解决这个问题。当insert一个块时，ref=2。因为此时外部正在访问这个块，同时cache内部保留了这个块。另一个外部使用函数是lookup。每次外部从cache中获取一个handle，其ref++。当外部使用完毕后，必须调用unref函数，ref--。从cache中删除一个块，同样造成ref--。只有当ref<=0,才真正调用delete释放内存，同时修改对应cache的大小（useage）

3.将双向列表和hashtable使用同一个handle结构作为基本节点。

Handletable的主要成员变量是

 private:  // 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_;  uint32_t elems_;  LRUHandle** list_;

查找方式如下：

  LRUHandle** FindPointer(const Slice& key, uint32_t hash) {    LRUHandle** ptr = &list_[hash & (length_ - 1)];    while (*ptr != NULL &&           ((*ptr)->hash != hash || key != (*ptr)->key())) {      ptr = &(*ptr)->next_hash;    }    return ptr;  }

其实相当于采用链表法避免冲突的哈希表。