Redis源码解析-基础数据-ziplist(压缩列表)

太长不看版

• 压缩列表是一种为节约空间而实现的线性数据结构，本质是字节数组。
• 压缩列表元素可以为整数或字符串。
• 压缩列表在快速列表、列表对象和哈希对象中都有使用。
• 压缩列表添加(平均复杂度O(n))与删除节点(平均复杂度O(n))，可能会触发连锁更新(平均复杂度O(n^2))，因为触发机率不高所以不影响性能。
• 因为节点存在字符串，字符串匹配为O(n)复杂度，所以压缩列表查找节点平均复杂度为O(n^2)。

本篇解析基于redis 5.0.0版本，本篇涉及源码文件为ziplist.c, ziplist.h。

什么是压缩列表

/* Create a new empty ziplist. */
unsigned char *ziplistNew(void) {
    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
    unsigned char *zl = zmalloc(bytes);
    // ...
    return zl;
}

从上述创建代码中可以看出，压缩列表本质上就是一个字节数组，其是redis使用字节数组实现的线性数据结构，其元素可以是整数或者字符串。在快速列表、列表对象和哈希对象中都有使用，一般用在元素较少且元素字节数较小的情况下。

为什么要实现压缩列表？

因为为了尽可能的节约内存。设想下现在有两个元素: 整数1和字符串’123’，两个节点 数据本身只有占8个字节(64位机器中)。
使用单向链表的话需要多加两个向后指针，占用24个字节，其中链表节点数据占用16个字节是数据本身大小的两倍。
而此例中压缩列表存储只需要每个节点记录前一节点长度(1字节)、节点本身编码信息(1字节)(具体规则后边解释)，总共占用10个字节。

压缩列表的构成

#define ZIP_END 255         /* Special "end of ziplist" entry. */
#define ZIPLIST_BYTES(zl)       (*((uint32_t*)(zl)))
#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
#define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
#define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t))
#define ZIPLIST_END_SIZE        (sizeof(uint8_t))
/* Create a new empty 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;
    // 255特殊结尾值
    zl[bytes-1] = ZIP_END;
    return zl;
}

压缩列表由总字节长度(4字节)，尾节点偏移量(4字节)，节点数量(2字节)，节点以及值为255的特殊结束符(1字节)组成,通过列表的开始地址向后偏移尾节点偏移量个字节，可以以O(1)时间复杂度获取尾节点信息。

压缩列表自身的信息只占用了11个字节，而链表光是头指针和尾指针存储就需要16个字节，所以针对数据量少的情况(节点少节点小)采用压缩列表会比较划算。

intrev32ifbe函数为大小端转换，统一转换为小端存储。为什么要进行转换？

因为压缩列表的操作中涉及到的位运算很多，如果不统一的话会出现混乱。后续的所有位运算都是在小端存储的基础上进行的。大小端知识点戳此了解

压缩列表节点的构成

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;
}

如前所述，压缩列表本质上是字节数组，redis为了操作计算方便定义了zlentry结构体。进行操作计算时，将字节数组中包含的信息按照规则解析到zlentry结构体中，方便后续的计算。从存储角度来看，压缩列表节点分为三部分：

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

下图为压缩列表节点各部分组成与zlentry结构体长度字段示意图：

前一节点长度信息

#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);

前一节点长度小于254时，使用1个字节保存前一节点的长度信息。

前一节点长度大于254时，使用5个字节保存前一节点的长度信息。首个字节固定为254，后续的4个字节用来存储长度信息。

宏定义为什么要写成do {} while(0);

写成do {} while(0); 是为了保证不管在调用代码中怎么使用分号和大括号，该宏总是能确保其行为是一致的。错误示例如下：

#define TEST() test1(); test2();
// 此时test2必然被执行，不符合预期
if (a > 0)
    TEST();
#define TEST() { test1(); test2(); }
// 此时就会出现语法错误
if (a > 0)
    TEST();

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

/* 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;