/\*
\* |00pppppp| - 1 byte
\* 字符串的长度小于或等于63字节(6 bits).
\* "pppppp" 表示无符号6bit长度
\* |01pppppp|qqqqqqqq| - 2 bytes
\* 字符串的长度小于或等于16383字节(14 bits).
\* IMPORTANT: 14 bit的数字使用大端序保存.
\* |10000000|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt| - 5 bytes
\* 字符串的长度大于或等于16384字节,只使用第1个字节之后的4个字节表示长度,最大为2^32-1,第一个
\* 字节的低6位没有使用,设置为0。因此entry的最大长度为32
\* IMPORTANT: 32 bit的数字使用大端序保存.
\* |11000000| - 3 bytes
\* 整数编码为int16\_t (2 bytes).
\* |11010000| - 5 bytes
\* 整数编码为int32\_t (4 bytes).
\* |11100000| - 9 bytes
\* I整数编码为int64\_t (8 bytes).
\* |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;
}
}
![img](https://img-blog.csdnimg.cn/img_convert/d63ee92f12e225298d7f83be0134f463.png)
![img](https://img-blog.csdnimg.cn/img_convert/504a3504c07d829a6f318defcb807c68.png)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
n 写入 5 字节的 header 中就算了。
zipPrevEncodeLengthForceLarge(p+rawlen,rawlen);
} else {
// 运行到这里,
// 说明 cur 节点的长度正好可以编码到 next 节点的 header 中
zipPrevEncodeLength(p+rawlen,rawlen);
}
// 到这里此节点previous\_entry\_length长度不需要扩展
// 连锁更新结束
break;
}
}
[外链图片转存中...(img-KRmgJjBz-1726094532309)]
[外链图片转存中...(img-WwDSlqsV-1726094532309)]
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**