redis源码阅读—ziplist(压缩表)_intrev32ifbe

2401_87299614

于 2024-09-22 20:24:51 发布

阅读量602

点赞数 22

文章标签： redis 数据库缓存

本文链接：https://blog.csdn.net/2401_87299614/article/details/142442973

版权

* |11110000| - 4 bytes
* 编码为24 bit的有符号整数 (3 bytes).
* |11111110| - 2 bytes
* 编码为8 bit的有符号整数 (1 byte).
* |1111xxxx| - (xxxx 取值为 0000 到 1101) 表示4bit的整数
* 无符号整数的取值为0到12，由于无法使用0000(被|11110000|编码占用)和1111(被zlend占用)，因此取值
* 为1到13,因此需要从低4位的整数减去1获得entry的值.
* |11111111| - 表示ziplist的终止entry，即zlend
* /


**举例**


* 整数编码  
 如下ziplist包含2个元素，表示字符串"2"和"5"，长度为15字节，可以看到由于数值小于13，其编码和数值放在了一个字节中。

[0f 00 00 00] [0c 00 00 00] [02 00] [00 f3] [02 f6] [ff]
| | | | | |
zlbytes zltail entries “2” “5” end

 前4个字节(`zlbytes`)表示15，即整个ziplist包含的字节数；第2个4字节(`zltail`)最后一个entry的字节偏移，即字符串为"5"的entry的位置，偏移量为12字节；接下来的16bit(`entries`)表示ziplist中的entry的数目，为2；“00 f3"表示list中的第一个entry “2”，它包含了前一个entry的长度(`prevlen`)，为0，“f3"对应的编码为”|1111xxxx|”,"xxxx"的取值为0001到1101，去除前4个bit “1111”，并减去1，得到entry的值为2。下一个entry的prevlen为2，表示前一个entry占用了2字节."f6"的编码与前一个相同，去除前4个bit，并减去1，得到entry的值为5；最后的"ff"表示ziplist的结束(`zlend`)。
* 字符串编码  
 在上述ziplist中追加一个"Hello World"的entry的编码。第一个字节表示前面entry的长度，第二个字节表示encoding，二进制为"|00pppppp|"，因此"0b"表示一个11字节的字符串。从第3个字节(48)到最后一个字节(64)表示ASCII编码的字符串"Hello World"。  
 [02] [0b] [48 65 6c 6c 6f 20 57 6f 72 6c 64]


## 源码部分


### 新建ziplist


在阅读新建的源码之前，先看看一些公用的方法和定义  
 **编码类型的宏定义**

// ziplist 末端标识符，以及 5 字节长长度标识符
#define ZIP_END 255
#define ZIP_BIGLEN 254

// 字符串编码和整数编码的掩码
#define ZIP_STR_MASK 0xc0
#define ZIP_INT_MASK 0x30

// 字符串编码类型
#define ZIP_STR_06B (0 << 6)
#define ZIP_STR_14B (1 << 6)
#define ZIP_STR_32B (2 << 6)

// 整数编码类型
#define ZIP_INT_16B (0xc0 | 0<<4)
#define ZIP_INT_32B (0xc0 | 1<<4)
#define ZIP_INT_64B (0xc0 | 2<<4)
#define ZIP_INT_24B (0xc0 | 3<<4)
#define ZIP_INT_8B 0xfe


**提取previous\_entry\_length，encoding求压缩列表大小等信息的宏定义**

// 用于取出 bytes 属性的现有值，或者为 bytes 属性赋予新值
#define ZIPLIST_BYTES(zl) (*((uint32_t*)(zl)))
// 定位到 ziplist 的 offset 属性，该属性记录了到达表尾节点的偏移量
// 用于取出 offset 属性的现有值，或者为 offset 属性赋予新值
#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
// 定位到 ziplist 的 length 属性，该属性记录了 ziplist 包含的节点数量
// 用于取出 length 属性的现有值，或者为 length 属性赋予新值
#define ZIPLIST_LENGTH(zl) (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
// 返回 ziplist 表头的大小
#define ZIPLIST_HEADER_SIZE (sizeof(uint32_t)*2+sizeof(uint16_t))
// 返回指向 ziplist 第一个节点（的起始位置）的指针
#define ZIPLIST_ENTRY_HEAD(zl) ((zl)+ZIPLIST_HEADER_SIZE)
// 返回指向 ziplist 最后一个节点（的起始位置）的指针
#define ZIPLIST_ENTRY_TAIL(zl) ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)))
// 返回指向 ziplist 末端 ZIP_END （的起始位置）的指针
#define ZIPLIST_ENTRY_END(zl) ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)


**创建ziplist**

unsigned char *ziplistNew(void) {
// 表头加末端大小
unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
// 为表头和表末端分配空间
unsigned char *zl = zmalloc(bytes);
// 初始化表属性
// 压缩列表总字节长度
ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
// 尾部节点字节距离
ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
// 压缩列表节点个数
ZIPLIST_LENGTH(zl) = 0;
// 设置表末端
zl[bytes-1] = ZIP_END;
return zl;
}


压缩列表由总字节长度(4字节)，尾节点偏移量(4字节)，节点数量(2字节)，节点以及值为255的特殊结束符(1字节)组成,通过列表的开始地址向后偏移尾节点偏移量个字节，可以以O(1)时间复杂度获取尾节点信息。  
  
 压缩列表自身的信息只占用了11个字节，而链表光是头指针和尾指针存储就需要16个字节，所以针对数据量少的情况(节点少节点小)采用压缩列表会比较划算。



> 
> **intrev32ifbe函数为大小端转换，统一转换为小端存储。为什么要进行转换？**  
>  因为压缩列表的操作中涉及到的位运算很多，如果不统一的话会出现混乱。后续的所有位运算都是在小端存储的基础上进行的。  
>   
>  [大小端的介绍]( )
> 
> 
> 


### ziplist entry的组成


**entry组成结构体**

typedef struct zlentry {
// 前一节点长度信息的长度
unsigned int prevrawlensize;
// 前一节点长度
unsigned int prevrawlen;
// 当前节点长度信息长度
unsigned int lensize;
// 当前节点长度
unsigned int len;
// 当前节点头部信息长度
unsigned int headersize;
// 当前节点数据编码
unsigned char encoding;
unsigned char *p;
} zlentry;

void zipEntry(unsigned char *p, zlentry *e) {
// 前一节点长度信息解析
ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
// 当前节点数据长度与编码信息解析
ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
e->headersize = e->prevrawlensize + e->lensize;
e->p = p;
}


**前一节点长度信息**  
 前文已经介绍过原理，这里就不再赘述

#define ZIP_BIG_PREVLEN 254
#define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) do {
if ((ptr)[0] < ZIP_BIG_PREVLEN) {
(prevlensize) = 1;
} else {
(prevlensize) = 5;
}
} while(0);

#define ZIP_DECODE_PREVLEN(ptr, prevlensize, prevlen) do {
ZIP_DECODE_PREVLENSIZE(ptr, prevlensize);
if ((prevlensize) == 1) {
(prevlen) = (ptr)[0];
} else if ((prevlensize) == 5) {
assert(sizeof((prevlen)) == 4);
memcpy(&(prevlen), ((char*)(ptr)) + 1, 4);
memrev32ifbe(&prevlen);
}
} while(0);


**当前节点数据长度与编码信息**

/* Different encoding/length possibilities */
#define ZIP_STR_MASK 0xc0 /* 11000000 */
#define ZIP_STR_06B (0 << 6) /* 00000000 */
#define ZIP_STR_14B (1 << 6) /* 01000000 */
#define ZIP_STR_32B (2 << 6) /* 10000000 */
#define ZIP_INT_16B (0xc0 | 0<<4) /* 11000000 */
#define ZIP_INT_32B (0xc0 | 1<<4) /* 11010000 */
#define ZIP_INT_64B (0xc0 | 2<<4) /* 11100000 */
#define ZIP_INT_24B (0xc0 | 3<<4) /* 11110000 */
#define ZIP_INT_8B 0xfe /* 11111110 */

/* 4 bit integer immediate encoding |1111xxxx| with xxxx between
* 0001 and 1101. */
#define ZIP_INT_IMM_MASK 0x0f /* 00001111 */
#define ZIP_INT_IMM_MIN 0xf1 /* 11110001 */
#define ZIP_INT_IMM_MAX 0xfd /* 11111101 */

#define ZIP_ENTRY_ENCODING(ptr, encoding) do {
(encoding) = (ptr[0]);
if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK;
} while(0)

#define ZIP_DECODE_LENGTH(ptr, encoding, lensize, len) do {
ZIP_ENTRY_ENCODING((ptr), (encoding));
if ((encoding) < ZIP_STR_MASK) {
if ((encoding) == ZIP_STR_06B) {
(lensize) = 1;
(len) = (ptr)[0] & 0x3f;
} else if ((encoding) == ZIP_STR_14B) {
(lensize) = 2;
(len) = (((ptr)[0] & 0x3f) << 8) | (ptr)[1];
} else if ((encoding) == ZIP_STR_32B) {
(lensize) = 5;
(len) = ((ptr)[1] << 24) |
((ptr)[2] << 16) |
((ptr)[3] << 8) |
((ptr)[4]);
} else {
panic(“Invalid string encoding 0x%02X”, (encoding));
}
} else {
(lensize) = 1;
(len) = zipIntSize(encoding);
}
} while(0);

unsigned int zipIntSize(unsigned char encoding) {
switch(encoding) {
case ZIP_INT_8B: return 1;
case ZIP_INT_16B: return 2;
case ZIP_INT_24B: return 3;
case ZIP_INT_32B: return 4;
case ZIP_INT_64B: return 8;
}
if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX)
return 0; /* 4 bit immediate */
panic(“Invalid integer encoding 0x%02X”, encoding);
return 0;
}

int zipTryEncoding(unsigned char *entry, unsigned int entrylen, long long *v, unsigned char *encoding) {
long long value;
if (entrylen >= 32 || entrylen == 0) return 0;
if (string2ll((char*)entry,entrylen,&value)) {
if (value >= 0 && value <= 12) {
*encoding = ZIP_INT_IMM_MIN+value;
// …
return 1;
}
return 0;
}


### 更新

#define ZIPLIST_HEAD 0
#define ZIPLIST_TAIL 1
#define ZIPLIST_HEADER_SIZE (sizeof(uint32_t)*2+sizeof(uint16_t))
#define ZIPLIST_ENTRY_HEAD(zl) ((zl)+ZIPLIST_HEADER_SIZE)
#define ZIPLIST_ENTRY_END(zl) ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
unsigned char *p;
// 头部或尾部插入节点
p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
return __ziplistInsert(zl,p,s,slen);
}

unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
/// 插入节点至p指针指向元素前方
return __ziplistInsert(zl,p,s,slen);
}

unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
// 记录当前 ziplist 的长度
size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
unsigned int prevlensize, prevlen = 0;
size_t offset;
int nextdiff = 0;
unsigned char encoding = 0;
long long value = 123456789;

/\* Find out prevlen for the entry that is inserted. \*/
if (p[0] != ZIP_END) {
    // 插入位置不在尾部 
    /\*

如果 p[0] 不指向列表末端，说明列表非空，并且 p 正指向列表的其中一个节点
那么取出 p 所指向节点的信息，并将它保存到 entry 结构中
然后用 prevlen 变量记录前置节点的长度（当插入新节点之后 p 所指向的节点就成了新节点的前置节点）
*/
ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
} else {
// 插入位置在尾部
/*
如果 p 指向表尾末端，那么程序需要检查列表是否为：
1)如果 ptail 也指向 ZIP_END ，那么列表为空；
2)如果列表不为空，那么 ptail 将指向列表的最后一个节点。
*/
unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
// 尾节点存在取长度，不存在长度为0(列表为空时不存在)
if (ptail[0] != ZIP_END) {
// 表尾节点为新节点的前置节点取出表尾节点的长度
prevlen = zipRawEntryLength(ptail);
}
}
// s指针指向新增节点数据 slen为数据长度
// 确定数据编码。数据长度，为整数时返回对应固定长度，为字符串使用slen
if (zipTryEncoding(s,slen,&value,&encoding)) {
reqlen = zipIntSize(encoding);
} else {
reqlen = slen;
}
// 加上前一节点长度信息的长度
reqlen += zipStorePrevEntryLength(NULL,prevlen);
// 加上编码与长度信息的长度
// 此时reqlen为新加入节点的整体长度
reqlen += zipStoreEntryEncoding(NULL,encoding,slen);

int forcelarge = 0;
// 
nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
// 修复bug,详细分析见:https://segmentfault.com/a/1190000018878466?utm\_source=tag-newest
if (nextdiff == -4 && reqlen < 4) {
    nextdiff = 0;
    forcelarge = 1;
}

offset = p-zl;
// 调整内存大小
zl = ziplistResize(zl,curlen+reqlen+nextdiff);
p = zl+offset;

// 非空列表插入
if (p[0] != ZIP_END) {
    // 将p节点后移(没有移动p节点前一节点长度信息)，留出当前节点位置
    memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);

    // 写入p节点前一节点长度信息(要插入节点的长度)
    if (forcelarge)
        zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
    else
        zipStorePrevEntryLength(p+reqlen,reqlen);

    // 更新尾节点偏移量
    ZIPLIST\_TAIL\_OFFSET(zl) =
        intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))+reqlen);
    zipEntry(p+reqlen, &tail);
    if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
        ZIPLIST\_TAIL\_OFFSET(zl) =
            intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))+nextdiff);
    }
} else {
    // 空列表插入，只更新尾节点偏移量
    ZIPLIST\_TAIL\_OFFSET(zl) = intrev32ifbe(p-zl);
}

// 连锁更新
if (nextdiff != 0) {
    offset = p-zl;
    zl = \_\_ziplistCascadeUpdate(zl,p+reqlen);
    p = zl+offset;
}

// 写入前一节点长度信息
p += zipStorePrevEntryLength(p,prevlen);
// 写入节点编码与长度信息
p += zipStoreEntryEncoding(p,encoding,slen);
// 写入数据
if (ZIP\_IS\_STR(encoding)) {
    memcpy(p,s,slen);
} else {
    zipSaveInteger(p,value,encoding);
}
// 增加列表长度
ZIPLIST\_INCR\_LENGTH(zl,1);
return zl;

}



> 
> **\_\_ziplistInsert的步骤如下：**  
>  1.求新节点需要的编码长度，以及当前p所指节点的previous\_entry\_length能否装的下新节点长度，若装不下，则p所指节点头部需要扩展，要多分配内存  
>  2. 重分配内存  
>  3. 移动节点，中间预留出容纳新节点的空间  
>  4.更新之前p所指节点（即插入节点的后续节点）的头部  
>  5. 头部扩展后可能会导致连锁更新  
>  6. 最后写入节点，更新节点数量
> 
> 
> 


### 连锁更新


插入新节点后若新节点比较长，previous\_entry\_length需要5字节编码，而新节点后的节点X原来是1字节编码的，头部会扩展为5字节，整个X节点的长度恰好变大为需要5字节编码，而X的后续节点Y之前编码X的长度只需要1字节，装不下又会导致Y的头部扩展………往复下去


因为前置节点长度大于等于254，previous\_entry\_length才会采用5字节编码，所以当有连续的250-253字节长度的节点时才会导致连锁更新，概率不会很大，并不会因为连锁更新导致非常频繁的分配拷贝释放内存


插入也会导致连锁缩减，但是我们忽略这种情况。因为缩减并不是必须的，并且一个节点也只多占用了4字节内存。没有必要为了缩减几字节的内存而进行内存重分配

static unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p) {
size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), rawlen, rawlensize;
size_t offset, noffset, extra;
unsigned char *np;
zlentry cur, next;

while (p[0] != ZIP_END) {
    // 计算编码当前节点的长度所需的字节数
    // 将 p 所指向的节点的信息保存到 cur 结构中 
    cur = zipEntry(p);
    // 当前节点的长度
    rawlen = cur.headersize + cur.len;
    rawlensize = zipPrevEncodeLength(NULL,rawlen);

    // 如果已经没有后续空间需要更新了，跳出
    if (p[rawlen] == ZIP_END) break;

    // 取出后续节点的信息，保存到 next 结构中
    next = zipEntry(p+rawlen);

    // 后续节点编码当前节点的空间已经足够，无须再进行任何处理，跳出
    // 可以证明，只要遇到一个空间足够的节点，
    // 那么这个节点之后的所有节点的空间都是足够的
    if (next.prevrawlen == rawlen) break;

    if (next.prevrawlensize < rawlensize) {

        // 执行到这里，表示 next 空间的大小不足以编码 cur 的长度
        // 所以程序需要对 next 节点的（header 部分）空间进行扩展

        // 记录 p 的偏移量
        offset = p-zl;
        // 计算需要增加的节点数量
        extra = rawlensize-next.prevrawlensize;
        // 扩展 zl 的大小
        zl = ziplistResize(zl,curlen+extra);
        // 还原指针 p
        p = zl+offset;

        // 记录下一节点的偏移量
        np = p+rawlen;
        noffset = np-zl;

        // 当 next 节点不是表尾节点时，更新列表到表尾节点的偏移量
        if ((zl+intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))) != np) {
            ZIPLIST\_TAIL\_OFFSET(zl) =
                intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))+extra);
        }

        // 向后移动 cur 节点之后的数据，为 cur 的新 header 腾出空间
        memmove(np+rawlensize,
            np+next.prevrawlensize,
            curlen-noffset-next.prevrawlensize-1);
        // 将新的前一节点长度值编码进新的 next 节点的 header
        zipPrevEncodeLength(np,rawlen);

        // 移动指针，继续处理下个节点
        p += rawlen;
        curlen += extra;
    } else {
        if (next.prevrawlensize > rawlensize) {
            // 执行到这里，说明 next 节点编码前置节点的 header 空间有 5 字节
            // 而编码 rawlen 只需要 1 字节
            // 但是程序不会对 next 进行缩小，
            // 所以这里只将 rawlen 写入 5 字节的 header 中就算了。
            zipPrevEncodeLengthForceLarge(p+rawlen,rawlen);
        } else {
            // 运行到这里，
            // 说明 cur 节点的长度正好可以编码到 next 节点的 header 中
            zipPrevEncodeLength(p+rawlen,rawlen);
        }
        // 到这里此节点previous\_entry\_length长度不需要扩展
        // 连锁更新结束
        break;
    }
}

return zl;

}


### 获取节点索引

// 根据索引返回节点
unsigned char *ziplistIndex(unsigned char *zl, int index) {
unsigned char *p;
zlentry entry;
// 处理负数索引
if (index < 0) {
// 将索引转换为正数
index = (-index)-1;
// 定位到表尾节点
p = ZIPLIST_ENTRY_TAIL(zl);
// 如果列表不为空，那么。。。
if (p[0] != ZIP_END) {
// 从表尾向表头遍历
entry = zipEntry§;
while (entry.prevrawlen > 0 && index–) {
// 前移指针
p -= entry.prevrawlen;
entry = zipEntry§;
}
}
// 处理正数索引
} else {
// 定位到表头节点
p = ZIPLIST_ENTRY_HEAD(zl);
while (p[0] != ZIP_END && index–) {
// 后移指针
p += zipRawEntryLength§;
}
}

// 返回结果
return (p[0] == ZIP_END || index > 0) ? NULL : p;

}


### 查找

unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip) {
int skipcnt = 0;
unsigned char vencoding = 0;
long long vll = 0;
// 遍历压缩列表 skip为查找前跳过skip个节点
while (p[0] != ZIP_END) {
unsigned int prevlensize, encoding, lensize, len;
unsigned char *q;

    ZIP\_DECODE\_PREVLENSIZE(p, prevlensize);
    ZIP\_DECODE\_LENGTH(p + prevlensize, encoding, lensize, len);
    q = p + prevlensize + lensize;

    if (skipcnt == 0) {
        /\* Compare current entry with specified entry \*/
        if (ZIP\_IS\_STR(encoding)) {
            // 数据为字符串，判断字符串相等复杂度为O(n)
            if (len == vlen && memcmp(q, vstr, vlen) == 0) {
                return p;
            }
        } else {
            if (vencoding == 0) {
                // 首次比对时，对传入值进行解码
                if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
                    /\* If the entry can't be encoded we set it to

* UCHAR_MAX so that we don’t retry again the next
* time. */
vencoding = UCHAR_MAX;
}
/* Must be non-zero by now */
assert(vencoding);
}

            /\* Compare current entry with specified entry, do it only

* if vencoding != UCHAR_MAX because if there is no encoding
* possible for the field it can’t be a valid integer. */
if (vencoding != UCHAR_MAX) {
long long ll = zipLoadInteger(q, encoding);
if (ll == vll) {
return p;
}
}
}

        /\* Reset skip count \*/
        skipcnt = skip;
    } else {
        /\* Skip entry \*/
        skipcnt--;
    }

    /\* Move to next entry \*/
    p = q + len;
}

return NULL;

}


因为节点中存在字符串，且字符串相等比对的复杂度为O(n), 所以压缩列表查找节点的复杂度为O(n^2)。


### 删除

unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {

// 因为 \_\_ziplistDelete 时会对 zl 进行内存重分配
// 而内存充分配可能会改变 zl 的内存地址
// 所以这里需要记录到达 \*p 的偏移量
size_t offset = \*p-zl;
zl = \_\_ziplistDelete(zl,\*p,1);

\*p = zl+offset;

return zl;

}

static unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsigned int num) {
unsigned int i, totlen, deleted = 0;
size_t offset;
int nextdiff = 0;
zlentry first, tail;

// 计算被删除节点总共占用的内存字节数
// 以及被删除节点的总个数
first = zipEntry(p);
for (i = 0; p[0] != ZIP_END && i < num; i++) {
    p += zipRawEntryLength(p);
    deleted++;
}

// totlen 是所有被删除节点总共占用的内存字节数
totlen = p-first.p;
if (totlen > 0) {
    if (p[0] != ZIP_END) {
        // 执行这里，表示被删除节点之后仍然有节点存在

        // 因为位于被删除范围之后的第一个节点的 header 部分的大小
        // 可能容纳不了新的前置节点，所以需要计算新旧前置节点之间的字节数差
        nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
        // 如果有需要的话，将指针 p 后退 nextdiff 字节，为新 header 空出空间
        p -= nextdiff;
        // 将 first 的前置节点的长度编码至 p 中
        zipPrevEncodeLength(p,first.prevrawlen);

        // 更新到达表尾的偏移量
        ZIPLIST\_TAIL\_OFFSET(zl) =
            intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))-totlen);

        // 如果被删除节点之后，有多于一个节点
        // 那么程序需要将 nextdiff 记录的字节数也计算到表尾偏移量中
        // 这样才能让表尾偏移量正确对齐表尾节点
        tail = zipEntry(p);
        if (p[tail.headersize+tail.len] != ZIP_END) {
            ZIPLIST\_TAIL\_OFFSET(zl) =
               intrev32ifbe(intrev32ifbe(ZIPLIST\_TAIL\_OFFSET(zl))+nextdiff);
        }

        // 从表尾向表头移动数据，覆盖被删除节点的数据
        memmove(first.p,p,
            intrev32ifbe(ZIPLIST\_BYTES(zl))-(p-zl)-1);
    } else {
        // 执行这里，表示被删除节点之后已经没有其他节点了
        ZIPLIST\_TAIL\_OFFSET(zl) =
            intrev32ifbe((first.p-zl)-first.prevrawlen);
    }

    // 缩小并更新 ziplist 的长度
    offset = first.p-zl;
    zl = ziplistResize(zl, intrev32ifbe(ZIPLIST\_BYTES(zl))-totlen+nextdiff);
    ZIPLIST\_INCR\_LENGTH(zl,-deleted);
    p = zl+offset;

    // 如果 p 所指向的节点的大小已经变更，那么进行级联更新
    // 检查 p 之后的所有节点是否符合 ziplist 的编码要求
    if (nextdiff != 0)
        zl = \_\_ziplistCascadeUpdate(zl,p);
}

2401_87299614

关注

22
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫