Introduction to skiplist and skip list of Redis source code analysis

<div class="iteye-blog-content-contain" style="font-size: 14px"><div id="Article"> 
 ;<a href="https://www.2cto.com/ym/" target="_blank" class="keylink">Source code</a>Version: redis-4.0.1 ;
 Source location: server.h : Data structure definition of zskiplistNode and zskiplist. t_zset.c: The functions starting with zsl are the operation functions related to SkipList. 
 <h1 id="Introduction to a jump table">I. Introduction to the jump table</h1> 
 Jump The table (SkipList) is actually a data structure to solve the search problem, but it is neither a balanced tree structure nor a Hash structure. Its characteristic is that the elements are ordered. For more explanations about the jump table, you can refer to Teacher Zhang Tielei - Detailed Explanation of Redis Internal Data Structure (6)&

 a) this implementation allows for repeated scores. // allows for repeated scores b) the comparison is not just by key (our ‘score’) but by satellite data . //When comparing, compare not only the score but also the value of the object c) there is a back pointer, so it’sa doubly linked list with the back pointers being only at “level 1”./ /There is a back pointer, that is, a doubly linked list is implemented at the first level, allowing back traversal 
 </blockquote> 
 Next, let's take a look at the data structure definition of SkipList. 
 <h1 id="Second data structure definition">Second, data structure definition</h1> 
 

typedef struct zskiplistNode { 
 sds ele; //数据域
 double score; //分值 
 struct zskiplistNode *backward; //后向指针，使得跳表第一层组织为双向链表
 struct zskiplistLevel { //每一个结点的层级 unsigned int span; //Span of a layer from the next node
 struct zskiplistNode *forward; //forward node of a layer

 } level[]; The value is 32, defined by ZSKIPLIST_MAXLEVEL
} zskiplistNode;
</pre> 
 That is, use the above zskiplistNode to organize a SkipList: 
 <pre class="brush:sql;">
typedef struct zskiplist { 
 struct zskiplistNode *header; //header
 struct zskiplistNode *tail; //tail
 unsigned long length;
 int level;
} zskiplist;</pre> 
 The core data structures are the above two. 
 <h1 id="three create, insert, search, delete, release">three, create, insert, find, delete, release</h1> 
 We use the following example to track the code of SkipList, which involves operations such as creation, insertion, search, deletion, release, etc. (ps: Replace the code of the main function in Redis with the following code to test) 
 <pre class="brush:sql;">
// The zslGetElementByRank() function needs to be declared, which is used in the main function

 unsigned long ret;
 zskiplistNode *node;
 zskiplist *zsl = zslCreate();
 
 zslInsert(zsl, 65.5, sdsnew("tom")); //level = 1
 zslInsert(zsl, 87.5, sdsnew("jack")); //level = 4
 zslInsert(zsl, 70.0, sdsnew("alice")); //level = 3
 zslInsert(zsl, 95.0, sdsnew("tony")); //level = 2
 
 zrangespec spec = { //定义一个区间， 70.0 <= x <= 90.0
 .min = 70.0,
 .max = 90.0,
 .minex = 0,
 .maxex = 0};
 
 printf("zslFirstInRange 70.0 <= x <= 90.0, x is:"); // 找到符合区间的最小值
 node = zslFirstInRange(zsl, &spec);
 printf("%s->%f\n", node->ele, node->score);
 
 printf("zslLastInRange 70.0 <= x <= 90.0, x is:"); // 找到符合区间的最大值
 node = zslLastInRange(zsl, &spec);
 printf("%s->%f\n", node->ele, node->score);
 
 printf("tony's Ranking is :"); // 根据分数获取排名
 ret = zslGetRank(zsl, 95.0, sdsnew("tony"));
 printf("%lu\n", ret);
 
 printf("The Rank equal 4 is :"); // 根据排名获取分数
 node = zslGetElementByRank(zsl, 4);
 printf("%s->%f\n", node->ele, node->score);
 
 ret = zslDelete(zsl, 70.0, sdsnew("alice"), &node); // 删除元素
 if (ret == 1) {
 printf("Delete node:%s->%f success!\n", node->ele, node->score);
 }
 
 zslFree(zsl); // 释放zsl
 
 return 0;
}
 
Out > 
zslFirstInRange 70.0 <= x <= 90.0, x is:alice->70.000000
zslLastInRange 70.0 <= x <= 90.0, x is:jack->87.500000
tony's Ranking is :4
The Rank equal 4 is :tony->95.000000
Delete node:alice->70.000000 success!</pre> Next, we analyze the code line by line. First, zskiplist *zsl = zslCreate(); creates a SkipList. The key point to be concerned about is to initialize zsl ->header is the maximum level of 32, because ZSKIPLIST_MAXLEVEL is defined as 32, this reason is related to the random function of getting Level in SkipList, please refer to the blog link given at the beginning of the article for details. Let's look at the code of zslCreate: 
 <pre class="brush:sql;">
zskiplist *zslCreate(void) {
 int j;
 zskiplist *zsl;
 
 zsl = zmalloc(sizeof( *zsl));
 zsl->level = 1; // 初始层级定义为1
 zsl->length = 0;
 zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL); // 初始化header为32层
 for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
 zsl->header->level[j].forward = NULL;
 zsl->header->level[j].span = 0;
 }
 zsl->header->backward = NULL; 
 zsl->tail = NULL; // tail目前为NULL
 return zsl; 
}
 
// zslCreateNode根据传入的level和score以及ele创建一个level层的zskiplistNode
zskiplistNode *zslCreateNode(int level, double score, sds ele) { 
 zskiplistNode *zn =
 zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
 zn->score = score;
 zn->ele = ele;
 return zn;
}</pre> 
nbsp; * Just like when we insert a node into an ordered singly linked list, we must first find a node with a smaller number than the current number and save it. * 2: Obtain the level according to the random function and generate a new node * The new node is inserted. 

 */ 
 
 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
 unsigned int rank[ZSKIPLIST_MAXLEVEL];
 int i, level;
 
 /* 第一步: 根据目前传入的score找到插入位置x，并且将各层的前置节点保存至rank[]中 */
 serverAssert(!isnan(score));
 x = zsl->header;
 for (i = zsl->level-1; i >= 0; i--) {
 /* store rank that is crossed to reach the insert position */
 rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
 while (x->level[i].forward &&
 (x->level[i].forward->score < score ||
 (x->level[i].forward->score == score &&
 sdscmp(x->level[i].forward->ele,ele) < 0)))
 {
 rank[i] += x->level[i].span;
 x = x->level[i].forward;
 }
 update[i] = x;
 }
 /* we assume the element is not already inside, since we allow duplicated
 * scores, reinserting the same element should never happen since the
 * caller of zslInsert() should test in the hash table if the element is
 * already inside or not. */
 
 /* 第二步：获取level，生成新的节点 */
 level = zslRandomLevel(); 
 if (level > zsl->level) {
 for (i = zsl->level; i < level; i++) {
 rank[i] = 0;
 update[i] = zsl->header;
 update[i]->level[i].span = zsl->length;
 }
 zsl->level = level;
 }
 x = zslCreateNode(level,score,ele); for (i = 0; i < level; i++) { /* Step 3: Modify the pointing of each pointer and insert the new node created*/
 

 x->level[i].forward = update[i]->level[i].forward;
 update[i]->level[i].forward = x;
 
 /* update span covered by update[i] as x is inserted here */
 x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
 update[i]->level[i].span = (rank[0] - rank[i]) + 1;
 }
 
 /* increment span for untouched levels */
 for (i = level; i < zsl->level; i++) {
 update[i]->level[i].span++;
 }
 
 /* 更新backword的指向 */
 x->backward = (update[0] == zsl->header) ? NULL : update[0];
 if (x->level[0].forward)
 x->level[0].forward->backward = x;
 else
 zsl->tail = x;
 zsl->length++;
 return x;
}</pre> 
 It should be noted that the meaning of span is the span of the current node from the next node. The reason why elements can be obtained according to the rank ranking is determined according to the span. update[i] saves the previous node that the i-th layer should insert into the node, which is used when updating the pointer in the third step. The zsl with an element inserted is shown below (level=1): 
 <img alt="Write image description here" src=" /uploadfile/Collfiles/20171114/20171114090518124.jpg" /> Then we continue to insert the next three pieces of data, their levels are jack->4, alice->3, tony ->2, the zsl at this time is as shown in the figure below, pay attention to the update of the span: 
 <img alt="Write the picture description here" src=" /uploadfile/Collfiles/20171114/20171114090519125.jpg" /> Well, the insertion is finally over! Next, let's look at the related operations of search. The above code gives four examples of search, which are: 
 1) Find the smallest element within the specified range
<

 We analyze (1) and (4), (2), (3) are the same. First look at (1), use the zrangespec structure to define a range of 70.0 <= x <= 90.0, the zrangespec structure is as follows: 
 <pre class="brush:sql;">
typedef struct {
 double min, max; // definition Min range and max range
 int minex, maxex; // Whether to include the min and max itself, 0 means inclusive, 1 means not inclusive
 } zrangespec;
 
/* The code to define the range is as follows*/
zrangespec spec = { ;

 .max = 90.0,
 .minex = 0,
 .maxex = 0}; //为结构体元素赋值</pre> 
 下面调用zslFirstInRange()函数遍历得到了满足70.0 <= x <= 90.0的最小节点，代码如下： 
 <pre class="brush:sql;">
/* Find the first node that is contained in the specified range.
 * Returns NULL when no element is contained in the range. */
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
 zskiplistNode *x;
 int i;
 
 /* If everything is out of range, return early. */
 if (!zslIsInRange(zsl,range)) return NULL; // 判断给定的范围是否合法
 
 x = zsl->header; 
 for (i = zsl->level-1; i >= 0; i--) { // 从最高的Level开始 
 /* Go forward while *OUT* of range. */ 
 while (x->level[i].forward && //只要没结束 && 目前结点的score小于目标score
 !zslValueGteMin(x->level[i].forward->score,range))
 // 将结点走到当前的节点
 x = x->level[i].forward;
 }
 
 /* This is an inner range, so the next node cannot be NULL. */
 x = x->level[0].forward; // 找到了符合的点
 serverAssert(x != NULL); 
 
 /* Check if score <= max. */
 if (!zslValueLteMax(x->score,range)) return NULL; // 判断返回的值是否小于max值
 return x;
}</pre> 
 It can be seen that the core idea of traversal is: (1) High Level -> Low Level (2) Small score -> Large score That is, in the process of traversing and comparing from a high level, if the score at this time is less than the value of a certain high level, the node before this node is lowered by a level and continues to traverse forward. We find the one with 70.0. The route is shown in the figure below (red line in the figure): 
 <img alt="Write image description here" src="/uploadfile/Collfiles/20171114/20171114090519126.jpg" /> The function zslGetElementByRank() is mainly completed according to the span domain. The code is as follows: 
 <pre class="brush:sql;">
zskiplistNode * zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
 zskiplistNode *x;
 unsigned long traversed = 0;
 int i;
 
 x = zsl->header;
 for (i = zsl-> level-1; i >= 0; i--) {
 while (x->level[i].forward && (traversed + x->level[i].span) <= rank)
 {
 traversed += x->level[i].span;
 x = x->level[i].forward;
 }
 if (traversed == rank) {
 return x;
 }
 }
 return NULL;
}</pre> 
 The idea of traversal is no different from the previous one. This traversal route is shown in the figure below: 
 <img alt="Write picture description here" src="/uploadfile/Collfiles/20171114/20171114090520128.jpg" /> Next, let's look at the Delete() function , ret = zslDelete(zsl, 70.0, sdsnew("alice"), &node); means to delete the element whose score is 70.0 and the data is alice in zsl, which is also the second element of Redis SkipList Features, comparing an element not only compares the score, but also compares the data, look at the code of zslDelete below: 
 <pre class="brush:sql;">
int zslDelete(zskiplist *zsl, double score, sds ele, zskiplistNode **node) {
 zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
 int i;
 
 x = zsl-& gt;header;
 for (i = zsl->level-1; i >= 0; i--) {
 while (x->level[i].forward &&
 (x->level[i].forward->score < score ||
 (x->level[i].forward->score == score &&
 sdscmp(x->level[i].forward->ele,ele) < 0)))
 {
 x = x->level[i].forward;
 }
 update[i] = x;
 }
 /* We may have multiple elements with the same score, what we need
 * is to find the element with both the right score and object. */
 x = x->level[0].forward;
 if (x && score == x->score && sdscmp(x->ele,ele) == 0) {
 zslDeleteNode(zsl, x, update);
 if (!node)
 zslFreeNode(x);
 else
 *node = x;
 return 1;
 }
 return 0; /* not found */
}</pre> It should be noted that the fourth parameter of zslDelete() is a zskipListNode ** type. If it is not NULL, then the code will not release it directly after traversing to find the node, but hand over the address to it, and the subsequent release of this space must be handled manually by us. The idea of traversal and comparison is the same as before, in update[], record the node before each layer deletes the node. The while loop compares the conditions, sdscmp(x->level[i].forward->ele,ele) < 0 because the insertion function zslInsert() is also inserted according to this logic. Finally need to compare again if (x && score == x->score && sdscmp(x->ele,ele) == 0) is Because Redis SkipList allows elements of the same score to exist. 
 Finally, look at the release function zslFree(zsl), the idea is very simple, because level[0] must be continuous (and a doubly linked list), so from level[ 0] It is enough to traverse and release in turn. 
 <pre class="brush:sql;">


 <table> 
 <thead> 
 <tr> 
 <th> 操作</th> 
 <th> 一般性能</th> 
 <th> 最坏性能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>插入</td> 
 <td>O(log n)</td> 
 <td>O(n)</td> 
 </tr> 
 <tr> /tr> <tr> /tr> <tr>

Introduction to skiplist and skip list of Redis source code analysis

Guess you like