leveldb 学习记录(一) skiplist

SkipList的定义：
1. 一个跳表应该有几个层（level）组成；
2. 跳表的第一层包含所有的元素；
3. 每一层都是一个有序的链表；
4. 如果元素x出现在第i层，则所有比i小的层都包含x；
5. 第i层的元素通过一个down指针指向下一层拥有相同值的元素；
6. 在每一层中，-1和1两个元素都出现(分别表示INT_MIN和INT_MAX)；
7. Top指针指向最高层的第一个元素。

图示:

find

查找方法为

1 起点为最高层第一个元素若元素小于查找值则查找该元素的后继值

2 若元素大于查找值则降低层级再次查找

3 若该元素的后继值为NULL或者大于该值，则降低层数再次查找

4 直到查找成功或者达到表的最底层且无元素可查找

图示中查找 17

起点为最高层第一个元素 6 6<17 6的下一个元素为null 则在元素6中降低层级

再次查找6的下一个元素是25 降低层级

再次查找6的下一个元素是9

再次查找9的下一个元素是25 降低层级

再次查找9的下一个元素是12

再次查找12的下一个元素是19 此处为最低层级则未查找到(进行插入)

insert

查找也可用于insert 注意insert 元素时候层级是随机的

leveldb 中skiplist 结构如下(内存池与原子指针等结构暂时不予理会)

 template<typename Key, class Comparator>

 struct SkipList<Key,Comparator>::Node {

   explicit Node(const Key& k) : key(k) { }

   Key const key;

   // Accessors/mutators for links.  Wrapped in methods so we can

   // add the appropriate barriers as necessary.

   Node* Next(int n) {

     assert(n >= );

     // Use an 'acquire load' so that we observe a fully initialized

     // version of the returned Node.

     return reinterpret_cast<Node*>(next_[n].Acquire_Load());

   }

   void SetNext(int n, Node* x) {

     assert(n >= );

     // Use a 'release store' so that anybody who reads through this

     // pointer observes a fully initialized version of the inserted node.

     next_[n].Release_Store(x);

   }

   // No-barrier variants that can be safely used in a few locations.

   Node* NoBarrier_Next(int n) {

     assert(n >= );

     return reinterpret_cast<Node*>(next_[n].NoBarrier_Load());

   }

   void NoBarrier_SetNext(int n, Node* x) {

     assert(n >= );

     next_[n].NoBarrier_Store(x);

   }

  private:

   // Array of length equal to the node height.  next_[0] is lowest level link.

   port::AtomicPointer next_[];

 };

 template<typename Key, class Comparator>

 typename SkipList<Key,Comparator>::Node*

 SkipList<Key,Comparator>::NewNode(const Key& key, int height) {

   char* mem = arena_->AllocateAligned(

       sizeof(Node) + sizeof(port::AtomicPointer) * (height - ));

   return new (mem) Node(key);

 }

抛开内存池和多线程情况下的原子操作定义很简单
分配获取下一个元素设置下一个元素
template<typename Key, class Comparator>中的 key是元素类型 Comparator是元素比较大小的策略

元素插入操作如下

 template<typename Key, class Comparator>

 void SkipList<Key,Comparator>::Insert(const Key& key) {

   // TODO(opt): We can use a barrier-free variant of FindGreaterOrEqual()

   // here since Insert() is externally synchronized.

   Node* prev[kMaxHeight];

   Node* x = FindGreaterOrEqual(key, prev);

   assert(x == NULL || !Equal(key, x->key));

   int height = RandomHeight();

   if (height > GetMaxHeight()) {

     for (int i = GetMaxHeight(); i < height; i++) {

       prev[i] = head_;

     }

     //fprintf(stderr, "Change height from %d to %d\n", max_height_, height);

     // It is ok to mutate max_height_ without any synchronization

     // with concurrent readers.  A concurrent reader that observes

     // the new value of max_height_ will see either the old value of

     // new level pointers from head_ (NULL), or a new value set in

     // the loop below.  In the former case the reader will

     // immediately drop to the next level since NULL sorts after all

     // keys.  In the latter case the reader will use the new node.

     max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));

   }

   x = NewNode(key, height);

   for (int i = ; i < height; i++) {

     // NoBarrier_SetNext() suffices since we will add a barrier when

     // we publish a pointer to "x" in prev[i].

     x->NoBarrier_SetNext(i, prev[i]->NoBarrier_Next(i));

     prev[i]->SetNext(i, x);

   }

 }

插入元素的层级是随机的并且获取当前最大层级数并未使用原子操作因为根据逻辑并无影响不使用原子操作也是性能上的一种考虑

元素读取操作如下

 template<typename Key, class Comparator>

 typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindGreaterOrEqual(const Key& key, Node** prev)

     const {

   Node* x = head_;

   int level = GetMaxHeight() - ;

   while (true) {

     Node* next = x->Next(level);

     if (KeyIsAfterNode(key, next)) {

       // Keep searching in this list

       x = next;

     } else {

       if (prev != NULL) prev[level] = x;

       if (level == ) {

         return next;

       } else {

         // Switch to next list

         level--;

       }

     }

   }

 }