Redis源码剖析--压缩列表
压缩列表（ziplist）是列表键和哈希键的底层实现之一。
Redis的列表键，哈希键，有序集合的底层实现都用到了ziplist。
当列表键中包含比较少的元素，并且元素都是数字或者比较小的字符串的时候， redis会用压缩列表来作为列表键的底层实现。
当哈希键的键和值都是比较小的整数或者较短的字符的时候，也是用压缩列表来作为底层实现。 因为压缩列表也能够节省内存。
压缩列表结构
压缩列表的结构如下：
列表头包括三部分内容，分别是zlbytes，zltail，zllen
- zlbytes： 记录整个压缩列表占用的内存字节数：在对压缩列表进行内存重分配， 或者计算 zlend 的位置时使用。
- zltail：记录压缩列表表尾节点距离压缩列表的起始地址有多少字节： 通过这个偏移量，程序无须遍历整个压缩列表就可以确定表尾节点的地址。
- zllen：记录了压缩列表包含的节点数量： 当这个属性的值小于 UINT16_MAX （65535）时， 这个属性的值就是压缩列表包含节点的数量； 当这个值等于 UINT16_MAX 时， 节点的真实数量需要遍历整个压缩列表才能计算得出。
压缩列表中间一次保存着各个列表项entry。
压缩列表尾部的zlend则表示压缩列表结束，其值固定为0xFF。
压缩列表结点
先看结点的数据结构：
typedef struct zlentry {
unsigned int prevrawlensize, prevrawlen; // 前置节点长度和编码所需长度
unsigned int lensize, len; // 当前节点长度和编码所需长度
unsigned int headersize; // 头的大小
unsigned char encoding; // 编码类型
unsigned char *p; // 数据部分
} zlentry;每个压缩列表节点都由 previous_entry_length 、 encoding 、 content 三个部分组成。
previous_entry_length
节点的 previous_entry_length 记录了压缩列表中前一个节点的长度。
previous_entry_length 属性的长度可以是 1 字节或者 5 字节：
- 如果前一节点的长度小于 254 字节， 那么 previous_entry_length 属性的长度为 1 字节： 前一节点的长度就保存在这一个字节里面。
- 如果前一节点的长度大于等于 254 字节， 那么 previous_entry_length 属性的长度为 5 字节： 其中属性的第一字节会被设置为 0xFE （十进制值 254）， 而之后的四个字节则用于保存前一节点的长度。
压缩列表zltail和previous_entry_length的存在，我们能够轻松得到一个列表的尾部，然后从尾部实现向前遍历整个压缩列表。
encoding
压缩列表能够保存字节数组和整数，当读取压缩列表的时候，如何区分当前的结点存储的是字节数组还是整数呢，就需要靠encoding字段来判断。
1、字节数组
保存字节数组的时候，encoding字段可以是一字节、两字节或者五字节长， 值的最高位为 00 、 01 或者 10 ，数组的长度由编码除去最高两位之后的其他位记录。
| 编码 | 编码长度 | content 属性保存的值 |
|---|---|---|
| 00bbbbbb | 1 字节 | 长度小于等于 63 字节的字节数组。 |
| 01bbbbbb xxxxxxxx | 2 字节 | 长度小于等于 16383 字节的字节数组。 |
| 10______ aaaaaaaa bbbbbbbb cccccccc dddddddd | 5 字节 | 长度小于等于 4294967295 的字节数组。 |
如上表所示，三种长度的字节数组分别用不同长度的encoding字段来表示，用来节省空间。 而encoding的前两位用来标记encoding本身的类型。
2、整数
保存整数的时候，encoding字段为一字节长， 值的最高位以 11 开头。 整数值的类型和长度由编码除去最高两位之后的其他位记录。
| 编码 | 编码长度 | content 属性保存的值 |
|---|---|---|
| 11000000 | 1 字节 | int16_t 类型的整数。 |
| 11010000 | 1 字节 | int32_t 类型的整数。 |
| 11100000 | 1 字节 | int64_t 类型的整数。 |
| 11110000 | 1 字节 | 24 位有符号整数。 |
| 11111110 | 1 字节 | 8 位有符号整数。 |
| 1111xxxx | 1 字节 | 使用这一编码的节点没有相应的 content 属性， 因为编码本身的 xxxx 四个位已经保存了一个介于 0 和 12 之间的值， 所以它无须 content 属性。 |
当encoding最前两位字段为11的时候，表示当前结点为整数。 同时encoding的后几位用来表示不同的整数类型。可以看到后几位中用000000表示int16_t 类型的整数， 用010000表示int32_t 类型的整数， 用100000表示int64_t 类型的整数。
可以注意到，为了进一步节省内存，当编码为1111xxxx时，表示没有内容部分，xxxx已经存放了当前的整数值，包括整数0~12，即xxxx可以表示0000~1101。这样就节省了content的内存空间。这边编码为11111111代表ziplist的结尾。
连锁更新
由于每个压缩列表的结点保存了上一个结点的大小，所以当前结点的变化有可能引起下一个结点的变化。如果前一节点的长度小于 254 字节， 那么 previous_entry_length 属性需要用 1 字节长的空间来保存这个长度值； 如果超过了254字节，这个属性值就需要 5 个字节的长度来保存。
所以最坏的情况下，压缩列表中某一个结点的更新，会引起所有结点的一个更新操作，就是所谓的连锁更新。
此外，插入或者删除结点也有可能引起连锁更新的操作。不过虽然连锁更新带来的消耗很大，但是仍旧可以放心的使用压缩列表，因为连锁更新引起的条件比较苛刻，概率比较小。 首先， 压缩列表里要恰好有多个连续的、长度介于 250 字节至 253 字节之间的节点， 连锁更新才有可能被引发， 在实际中， 这种情况并不多见；
其次， 即使出现连锁更新， 但只要被更新的节点数量不多， 就不会对性能造成任何影响： 比如说， 对三五个节点进行连锁更新是绝对不会影响性能的。
压缩列表基本操作
创建新的压缩列表
/* Create a new empty ziplist. */
unsigned char *ziplistNew(void) {
// 空ziplist的大小为11个字节，头部10字节，尾部1字节
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);
// 压缩列表结点数为0
ZIPLIST_LENGTH(zl) = 0;
// 设定尾部一个字节位0xFF
zl[bytes-1] = ZIP_END;
return zl;
}插入结点
由于连锁更新的存在，插入结点的复杂度平均 O(N) ，最坏 O(N^2)
// ziplist插入节点只能往头或者尾部插入
// zl: 待插入的ziplist
// s，slen: 待插入节点和其长度
// where: 带插入的位置，0代表头部插入，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);
}
/* Insert item at "p". */
unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
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; /* 为了防止警告，进行初始化；用一个比较特殊的值以便能够方便的观察到不恰当的使用 */
zlentry tail;
/* Find out prevlen for the entry that is inserted. */
if (p[0] != ZIP_END) {
// 如果不是压缩列表的结束标志，说明p指向了一个已存在的结点
// 解码得到p的前置结点和长度
ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
} else {
// 如果p指向列表末端，表示列表为空
unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
if (ptail[0] != ZIP_END) {
prevlen = zipRawEntryLength(ptail);
}
}
/* See if the entry can be encoded */
// 判断是否能够编码为整数
if (zipTryEncoding(s,slen,&value,&encoding)) {
/* 'encoding' is set to the appropriate integer encoding */
reqlen = zipIntSize(encoding);
} else {
/* 'encoding' is untouched, however zipStoreEntryEncoding will use the
* string length to figure out how to encode it. */
// 编码为字节数组
reqlen = slen;
}
/* We need space for both the length of the previous entry and
* the length of the payload. */
// 加上前置结点的编码长度和当前结点的编码长度
reqlen += zipStorePrevEntryLength(NULL,prevlen);
reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
/* When the insert position is not equal to the tail, we need to
* make sure that the next entry can hold this entry's length in
* its prevlen field. */
// 如果不是插入到列表的末端，都需要判断下一个结点是否能存放新节点的长度编码
// nextdiff保存新旧编码之间的字节大小差，如果这个值大于0
// 那就说明当前p指向的节点的header进行扩展
int forcelarge = 0;
nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
if (nextdiff == -4 && reqlen < 4) {
nextdiff = 0;
forcelarge = 1;
}
/* Store offset because a realloc may change the address of zl. */
// 保存偏移量
offset = p-zl;
// 重新分配空间，curlen当前列表的长度
// reqlen 新节点的全部长度
// nextdiff 新节点的后继节点扩展header的长度
zl = ziplistResize(zl,curlen+reqlen+nextdiff);
// 根据新的压缩列表地址得到新的p的地址
p = zl+offset;
/* Apply memory move when necessary and update tail offset. */
if (p[0] != ZIP_END) {
// 如果不是表尾插入，需要更新表尾的偏移地址
/* Subtract one because of the ZIP_END bytes */
memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
/* Encode this entry's raw length in the next entry. */
// 编码新结点的长度到下一个结点中
if (forcelarge)
zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
else
zipStorePrevEntryLength(p+reqlen,reqlen);
/* Update offset for tail */
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
/* When the tail contains more than one entry, we need to take
* "nextdiff" in account as well. Otherwise, a change in the
* size of prevlen doesn't have an effect on the *tail* offset. */
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 {
/* This element will be the new tail. */
ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
}
// 如果nextdiff不等于0， 下一个结点的头部需要进行扩展
if (nextdiff != 0) {
offset = p-zl;
zl = __ziplistCascadeUpdate(zl,p+reqlen);
p = zl+offset;
}
/* Write the entry */
// 将新节点前置节点的长度写入新节点的header
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;
}查找结点
/* 寻找节点值和 vstr 相等的列表节点，并返回该节点的指针。
* 每次比对之前都跳过 skip 个节点。
* 如果找不到相应的节点，则返回 NULL 。 */
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;
// 循环直到碰到结束标志
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)) {
if (len == vlen && memcmp(q, vstr, vlen) == 0) {
return p;
}
} else {
/* 查看目标值是否能被编码，只会在第一次循环的时候检查；
* 检查一次之后vencoding会被置为非0 */
if (vencoding == 0) {
if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
/* 如果不能被编码，设置格式为UCHAR_MAX ， 下次不会再检查*/
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;
}删除结点
// 删除给定节点，输入压缩列表zl和指向删除节点的指针p
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
size_t offset = *p-zl;
// 调用底层函数__ziplistDelete进行删除操作
zl = __ziplistDelete(zl,*p,1);
// 删除操作可能会改变zl，因为会重新分配内存
*p = zl+offset;
return zl;
}
/* 从位置 p 开始，连续删除 num 个节点。
* 函数的返回值为处理删除操作之后的 ziplist */
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;
zipEntry(p, &first);
// 计算被删除节点的总个数
for (i = 0; p[0] != ZIP_END && i < num; i++) {
p += zipRawEntryLength(p);
deleted++;
}
// totlen 是所有被删除节点总共占用的内存字节数
totlen = p-first.p; /* Bytes taken by the element(s) to delete. */
if (totlen > 0) {
if (p[0] != ZIP_END) {
// 不是尾结点，表示被删除节点之后仍然有节点存在
// 因为位于被删除范围之后的第一个节点的 header 部分的大小
// 可能容纳不了新的前置节点，所以需要计算新旧前置节点之间的字节数差
nextdiff = zipPrevLenByteDiff(p,first.prevrawlen);
/* Note that there is always space when p jumps backward: if
* the new previous entry is large, one of the deleted elements
* had a 5 bytes prevlen header, so there is for sure at least
* 5 bytes free and we need just 4. */
// 如果有需要的话，将指针 p 后退 nextdiff 字节，为新 header 空出空间
// 由于会删除之前的结点，所以肯定会有足够的空间用来扩展
p -= nextdiff;
// 将 first 的前置节点的长度编码至 p 中
zipStorePrevEntryLength(p,first.prevrawlen);
/* Update offset for tail */
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))-totlen);
/* When the tail contains more than one entry, we need to take
* "nextdiff" in account as well. Otherwise, a change in the
* size of prevlen doesn't have an effect on the *tail* offset. */
// 如果被删除节点之后，有多于一个节点
// 那么程序需要将 nextdiff 记录的字节数也计算到表尾偏移量中
// 这样才能让表尾偏移量正确对齐表尾节点
zipEntry(p, &tail);
if (p[tail.headersize+tail.len] != ZIP_END) {
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
}
/* Move tail to the front of the ziplist */
// 从表尾向表头移动数据，覆盖被删除节点的数据
memmove(first.p,p,
intrev32ifbe(ZIPLIST_BYTES(zl))-(p-zl)-1);
} else {
/* The entire tail was deleted. No need to move memory. */
// 执行这里，表示被删除节点之后已经没有其他节点了， 不需要移动结点
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe((first.p-zl)-first.prevrawlen);
}
/* Resize and update length */
// 缩小并更新 ziplist 的长度
offset = first.p-zl;
zl = ziplistResize(zl, intrev32ifbe(ZIPLIST_BYTES(zl))-totlen+nextdiff);
ZIPLIST_INCR_LENGTH(zl,-deleted);
p = zl+offset;
/* When nextdiff != 0, the raw length of the next entry has changed, so
* we need to cascade the update throughout the ziplist */
// 如果 p 所指向的节点的大小已经变更，那么进行级联更新
// 检查 p 之后的所有节点是否符合 ziplist 的编码要求
if (nextdiff != 0)
zl = __ziplistCascadeUpdate(zl,p);
}
return zl;
}