redis 源码阅读 - 内存编码篇 - 压缩列表 ziplist

最新推荐文章于 2024-09-28 17:17:42 发布
最新推荐文章于 2024-09-28 17:17:42 发布
阅读量144 收藏
点赞数
分类专栏： 源码略读 文章标签： redis 数据库 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40058501/article/details/118771601
版权
本文深入解析了Redis中ziplist数据结构的实现，包括节点的编码方式（字符串和整数）、长度编码、节点布局以及辅助函数。内容涵盖ziplist的内存管理、节点插入、删除、查找和更新等操作，展示了ziplist如何高效地存储和操作小数据列表。
摘要由CSDN通过智能技术生成

2.压缩列表 ziplist.h 和 ziplist.c

数据结构定义

  • 有序整数集合

    typedef struct zlentry {
    // prevrawlen ：前置节点的长度
    // prevrawlensize ：编码 prevrawlen 所需的字节大小
    unsigned int prevrawlensize, prevrawlen;
    // len ：当前节点值的长度
    // lensize ：编码 len 所需的字节大小
    unsigned int lensize, len;
    // 当前节点 header 的大小
    // 等于 prevrawlensize + lensize
    unsigned int headersize;
    // 当前节点值所使用的编码类型
    unsigned char encoding;
    // 指向当前节点的指针
    unsigned char *p;
} zlentry;

  • 布局
    在这里插入图片描述

    // <zlbytes> 是一个uint32_t，保存着 ziplist 使用的内存数量
#define ZIPLIST_BYTES(zl)       (*((uint32_t*)(zl)))

// <zltail> 是一个uint32_t，保存着到达列表中最后一个节点的偏移量
#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
// 最后一个节点
#define ZIPLIST_ENTRY_TAIL(zl)  ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)))

// <zllen> 是一个uint16_t, 保存着列表中的节点数量
#define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))

// <zlend> 的长度为 1 字节，值为 255 ，标识列表的末尾
#define ZIP_END 255
#define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)

// 返回 ziplist 表头的大小
#define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t))
// 第一个节点
#define ZIPLIST_ENTRY_HEAD(zl)  ((zl)+ZIPLIST_HEADER_SIZE)

  • 编码

    // 节点 带有一个 header，包含 2 部分：
// 前置节点 长度
// 当前节点 长度 & type

// 长度
// 1) 小于254, 1个字节
// 2) 大于等于254, 5个字节，第一个字节 = 254, 后四个字节保存长度
#define ZIP_BIGLEN 254

// type
// string: 2位编码 + 长度
// |00pppppp|: 0 - 63 
// |01pppppp|qqqqqqqq|: 64 - 16383
// |10pppppp|qqqqqqqq|mmmmmmmm|nnnnnnnn|oooooooo|: 16383 - 
//
// 整数 ：1个字节编码
// |11000000|:int16_t,2字节
// |11010000|:int32_t,4字节
// |11100000|:int64_t,8字节
// |11110000|:int24_t,3字节
// |11111110|:int8_t,1字节
// |1111xxxx|:[0,12],0字节，xxxx - 1

// string编码掩码
#define ZIP_STR_MASK 0xc0
#define ZIP_STR_06B (0 << 6)
#define ZIP_STR_14B (1 << 6)
#define ZIP_STR_32B (2 << 6)
#define ZIP_IS_STR(enc) (((enc) & ZIP_STR_MASK) < ZIP_STR_MASK)
// 整数编码掩码
#define ZIP_INT_MASK 0x30
#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
#define ZIP_INT_IMM_MASK 0x0f
#define ZIP_INT_IMM_MIN 0xf1    /* 11110001 */
#define ZIP_INT_IMM_MAX 0xfd    /* 11111101 */
#define ZIP_INT_IMM_VAL(v) (v & ZIP_INT_IMM_MASK)
#define INT24_MAX 0x7fffff
#define INT24_MIN (-INT24_MAX - 1)
Helper函数（可跳过，需要时阅读）

  • 一些宏

    #define ZIPLIST_INCR_LENGTH(zl,incr) { \
    if (ZIPLIST_LENGTH(zl) < UINT16_MAX) \
        ZIPLIST_LENGTH(zl) = intrev16ifbe(intrev16ifbe(ZIPLIST_LENGTH(zl))+incr); \
}
#define ZIP_ENTRY_ENCODING(ptr, encoding) do {  \
    (encoding) = (ptr[0]); \
    if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \
} while(0)

  • Get int size

    static 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;
    default: return 0; /* 4 bit immediate */
    }
    assert(NULL);
    return 0;
}

  • encode type & length

    static unsigned int zipEncodeLength(unsigned char *p, unsigned char encoding, unsigned int rawlen) {
    unsigned char len = 1, buf[5];
    // 编码字符串
    if (ZIP_IS_STR(encoding)) {
        if (rawlen <= 0x3f) {
            if (!p) return len;
            buf[0] = ZIP_STR_06B | rawlen;
        } else if (rawlen <= 0x3fff) {
            len += 1;
            if (!p) return len;
            buf[0] = ZIP_STR_14B | ((rawlen >> 8) & 0x3f);
            buf[1] = rawlen & 0xff;
        } else {
            len += 4;
            if (!p) return len;
            buf[0] = ZIP_STR_32B;
            buf[1] = (rawlen >> 24) & 0xff;
            buf[2] = (rawlen >> 16) & 0xff;
            buf[3] = (rawlen >> 8) & 0xff;
            buf[4] = rawlen & 0xff;
        }
    // 编码整数
    } else {
        if (!p) return len;
        buf[0] = encoding;
    }
    // 将编码后的长度写入 p 
    memcpy(p,buf,len);
    // 返回编码所需的字节数
    return len;
}

  • decode type & length

    #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 {                                                               
            assert(NULL);                                                      
        }                                                                      
    /* 整数编码 */                                                             
    } else {                                                                   
        (lensize) = 1;                                                         
        (len) = zipIntSize(encoding);                                          
    }                                                                          
} while(0);

  • 编码前置节点长度

    static unsigned int zipPrevEncodeLength(unsigned char *p, unsigned int len) {
    // 仅返回编码 len 所需的字节数量
    if (p == NULL) {
        return (len < ZIP_BIGLEN) ? 1 : sizeof(len)+1;
    // 写入并返回编码 len 所需的字节数量
    } else {
        // 1 字节
        if (len < ZIP_BIGLEN) {
            p[0] = len;
            return 1;
        // 5 字节
        } else {
            // 添加 5 字节长度标识
            p[0] = ZIP_BIGLEN;
            // 写入编码
            memcpy(p+1,&len,sizeof(len));
            // 如果有必要的话，进行大小端转换
            memrev32ifbe(p+1);
            // 返回编码长度
            return 1+sizeof(len);
        }
    }
}
static void zipPrevEncodeLengthForceLarge(unsigned char *p, unsigned int len) {
    if (p == NULL) return;
    // 设置 5 字节长度标识
    p[0] = ZIP_BIGLEN;
    // 写入 len
    memcpy(p+1,&len,sizeof(len));
    memrev32ifbe(p+1);
}
static int zipPrevLenByteDiff(unsigned char *p, unsigned int len) {
    unsigned int prevlensize;
    // 取出编码原来的前置节点长度所需的字节数
    // T = O(1)
    ZIP_DECODE_PREVLENSIZE(p, prevlensize);
    // 计算编码 len 所需的字节数，然后进行减法运算
    // T = O(1)
    return zipPrevEncodeLength(NULL, len) - prevlensize;
}

  • 解码前置节点长度

    #define ZIP_DECODE_PREVLENSIZE(ptr, prevlensize) do {                          
    if ((ptr)[0] < ZIP_BIGLEN) {                                               
        (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((prevlensize)) == 4);                                    
        memcpy(&(prevlen), ((char*)(ptr)) + 1, 4);                             
        memrev32ifbe(&prevlen);                                                
    }                                                                          
} while(0);

  • Resize

    static unsigned char *ziplistResize(unsigned char *zl, unsigned int len) {
    // 用 zrealloc ，扩展时不改变现有元素
    zl = zrealloc(zl,len);
    // 更新 bytes 属性
    ZIPLIST_BYTES(zl) = intrev32ifbe(len);
    // 重新设置表末端
    zl[len-1] = ZIP_END;
    return zl;
}

  • 更新前置节点长度

    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 节点的空间进行扩展
            // 记录 p 的偏移量
            offset = p-zl;
            // 计算需要增加的节点数量
            extra = rawlensize-next.prevrawlensize;
            // 扩展 zl 的大小
            zl = ziplistResize(zl,curlen+extra);
            // 还原指针 p
            p = zl+offset;
            // 记录下一节点的偏移量
            np = p+rawlen;
            noffset = np-zl;
            if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) {
                ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
            }
            // | header | value |  ==>  | header |    | value |  ==>  | header      | value |
            //                                   |<-->|
            //                            为新 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) {
                // 需要进行缩小，但不进行缩小操作
                zipPrevEncodeLengthForceLarge(p+rawlen,rawlen);
            } else {
                // 说明 cur 节点的长度正好可以编码到 next 节点的 header 中
                zipPrevEncodeLength(p+rawlen,rawlen);
            }
            break;
        }
    }
    return zl;
}

  • Get entry number

    unsigned int ziplistLen(unsigned char *zl) {
    unsigned int len = 0;
    // 节点数小于 UINT16_MAX
    if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) {
        len = intrev16ifbe(ZIPLIST_LENGTH(zl));
    // 节点数大于 UINT16_MAX 时，需要遍历整个列表才能计算出节点数
    } else {
        unsigned char *p = zl+ZIPLIST_HEADER_SIZE;
        while (*p != ZIP_END) {
            p += zipRawEntryLength(p);
            len++;
        }
        if (len < UINT16_MAX) ZIPLIST_LENGTH(zl) = intrev16ifbe(len);
    }
    return len;
}
size_t ziplistBlobLen(unsigned char *zl) {
    return intrev32ifbe(ZIPLIST_BYTES(zl));
}
构造函数
unsigned char *ziplistNew(void) {
    // 1 字节是表末端 ZIP_END 的大小
    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;
}
解码entry
static unsigned int zipRawEntryLength(unsigned char *p) {
    unsigned int prevlensize, encoding, lensize, len;
    // 取出编码前置节点的长度所需的字节数
    ZIP_DECODE_PREVLENSIZE(p, prevlensize);
    // 取出当前节点值的编码类型，编码节点值长度所需的字节数，以及节点值的长度
    ZIP_DECODE_LENGTH(p + prevlensize, encoding, lensize, len);
    // 计算节点占用的字节数总和
    return prevlensize + lensize + len;
}
static 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)) {
        // 转换成功，以从小到大的顺序检查适合值 value 的编码方式
        if (value >= 0 && value <= 12) {
            *encoding = ZIP_INT_IMM_MIN+value;
        } else if (value >= INT8_MIN && value <= INT8_MAX) {
            *encoding = ZIP_INT_8B;
        } else if (value >= INT16_MIN && value <= INT16_MAX) {
            *encoding = ZIP_INT_16B;
        } else if (value >= INT24_MIN && value <= INT24_MAX) {
            *encoding = ZIP_INT_24B;
        } else if (value >= INT32_MIN && value <= INT32_MAX) {
            *encoding = ZIP_INT_32B;
        } else {
            *encoding = ZIP_INT_64B;
        }
        // 记录值到指针
        *v = value;
        // 返回转换成功标识
        return 1;
    }
    // 转换失败
    return 0;
}
static int64_t zipLoadInteger(unsigned char *p, unsigned char encoding) {
    int16_t i16;
    int32_t i32;
    int64_t i64, ret = 0;
    if (encoding == ZIP_INT_8B) {
        ret = ((int8_t*)p)[0];
    } else if (encoding == ZIP_INT_16B) {
        memcpy(&i16,p,sizeof(i16));
        memrev16ifbe(&i16);
        ret = i16;
    } else if (encoding == ZIP_INT_32B) {
        memcpy(&i32,p,sizeof(i32));
        memrev32ifbe(&i32);
        ret = i32;
    } else if (encoding == ZIP_INT_24B) {
        i32 = 0;
        memcpy(((uint8_t*)&i32)+1,p,sizeof(i32)-sizeof(uint8_t));
        memrev32ifbe(&i32);
        ret = i32>>8;
    } else if (encoding == ZIP_INT_64B) {
        memcpy(&i64,p,sizeof(i64));
        memrev64ifbe(&i64);
        ret = i64;
    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
        ret = (encoding & ZIP_INT_IMM_MASK)-1;
    } else {
        assert(NULL);
    }

    return ret;
}
static zlentry zipEntry(unsigned char *p) {
    zlentry e;
    // e.prevrawlensize 保存着编码前一个节点的长度所需的字节数
    // e.prevrawlen 保存着前一个节点的长度
    ZIP_DECODE_PREVLEN(p, e.prevrawlensize, e.prevrawlen);
    // p + e.prevrawlensize 将指针移动到列表节点本身
    // e.encoding 保存着节点值的编码类型
    // e.lensize 保存着编码节点值长度所需的字节数
    // e.len 保存着节点值的长度
    ZIP_DECODE_LENGTH(p + e.prevrawlensize, e.encoding, e.lensize, e.len);
    // 计算头结点的字节数
    e.headersize = e.prevrawlensize + e.lensize;
    // 记录指针
    e.p = p;
    return e;
}
编码entry
static void zipSaveInteger(unsigned char *p, int64_t value, unsigned char encoding) {
    int16_t i16;
    int32_t i32;
    int64_t i64;
    if (encoding == ZIP_INT_8B) {
        ((int8_t*)p)[0] = (int8_t)value;
    } else if (encoding == ZIP_INT_16B) {
        i16 = value;
        memcpy(p,&i16,sizeof(i16));
        memrev16ifbe(p);
    } else if (encoding == ZIP_INT_24B) {
        i32 = value<<8;
        memrev32ifbe(&i32);
        memcpy(p,((uint8_t*)&i32)+1,sizeof(i32)-sizeof(uint8_t));
    } else if (encoding == ZIP_INT_32B) {
        i32 = value;
        memcpy(p,&i32,sizeof(i32));
        memrev32ifbe(p);
    } else if (encoding == ZIP_INT_64B) {
        i64 = value;
        memcpy(p,&i64,sizeof(i64));
        memrev64ifbe(p);
    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
        /* Nothing to do, the value is stored in the encoding itself. */
    } else {
        assert(NULL);
    }
}
删除entry
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) {
            // 执行删除
            // 可能容纳不了新的前置节点，所以需要计算新旧前置节点之间的字节数差
            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);
    }
    return zl;
}
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
    // 因为 __ziplistDelete 时会对 zl 进行内存重分配
    // 而内存充分配可能会改变 zl 的内存地址
    // 所以这里需要记录到达 *p 的偏移量
    // 这样在删除节点之后就可以通过偏移量来将 *p 还原到正确的位置
    size_t offset = *p-zl;
    zl = __ziplistDelete(zl,*p,1);
    *p = zl+offset;
    return zl;
}
unsigned char *ziplistDeleteRange(unsigned char *zl, unsigned int index, unsigned int num) {
    // 根据索引定位到节点
    unsigned char *p = ziplistIndex(zl,index);
    // 连续删除 num 个节点
    return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
}
插入entry
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
    // 根据 where 参数的值，决定将值推入到表头还是表尾
    unsigned char *p;
    p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
    // 返回添加新值后的 ziplist
    return __ziplistInsert(zl,p,s,slen);
}

static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
    // 记录当前 ziplist 的长度
    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen, prevlen = 0;
    size_t offset;
    int nextdiff = 0;
    unsigned char encoding = 0;
    long long value = 123456789; 
    zlentry entry, tail;
    if (p[0] != ZIP_END) {
        // 非空，记录前置节点长度
        entry = zipEntry(p);
        prevlen = entry.prevrawlen;
    } else {
        // 检查非空
        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
        if (ptail[0] != ZIP_END) {
            // 表尾节点为新节点的前置节点
            prevlen = zipRawEntryLength(ptail);
        }
    }

    // 优先编码整数
    // 1)value 将保存转换后的整数值
    // 2)encoding 则保存适用于 value 的编码方式
    // 无论使用什么编码， reqlen 都保存节点值的长度
    if (zipTryEncoding(s,slen,&value,&encoding)) {
        reqlen = zipIntSize(encoding);
    } else {
        reqlen = slen;
    }
    // 计算编码前置节点的长度所需的大小
    reqlen += zipPrevEncodeLength(NULL,prevlen);
    // 计算编码当前节点值所需的大小
    reqlen += zipEncodeLength(NULL,encoding,slen);

    // 更改p的前置节点长度编码
    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;

    // 记录旧偏移
    offset = p-zl;
    // curlen 是 ziplist 原来的长度
    // reqlen 是整个新节点的长度
    // nextdiff 是新节点的后继节点扩展 header 的长度（要么 0 字节，要么 4 个字节）
    zl = ziplistResize(zl,curlen+reqlen+nextdiff);
    p = zl+offset;

    if (p[0] != ZIP_END) {
        // 移动现有元素，为新元素的插入空间腾出位置
        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);

        // 后置节点 编码 前置节点长度
        zipPrevEncodeLength(p+reqlen,reqlen);

        // 更新到达表尾的偏移量，将新节点的长度也算上
        ZIPLIST_TAIL_OFFSET(zl) =
            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);

        // 如果新节点的后面有多于一个节点
        // 那么程序需要将 nextdiff 记录的字节数也计算到表尾偏移量中
        // 这样才能让表尾偏移量正确对齐表尾节点
        tail = zipEntry(p+reqlen);
        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;
    }

    // 写入三个值，分别是前置节点长度，自身长度和value
    p += zipPrevEncodeLength(p,prevlen);
    p += zipEncodeLength(p,encoding,slen);
    if (ZIP_IS_STR(encoding)) {
        memcpy(p,s,slen);
    } else {
        zipSaveInteger(p,value,encoding);
    }

    // 更新列表的节点数量计数器
    ZIPLIST_INCR_LENGTH(zl,1);

    return zl;
}
get entry by index
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(p);
            while (entry.prevrawlen > 0 && index--) {
                // 前移指针
                p -= entry.prevrawlen;
                entry = zipEntry(p);
            }
        }
    // 处理正数索引
    } else {
        // 定位到表头节点
        p = ZIPLIST_ENTRY_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            // 后移指针
            p += zipRawEntryLength(p);
        }
    }
    // 返回结果
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}
next entry
unsigned char *ziplistNext(unsigned char *zl, unsigned char *p) {
    ((void) zl);
    // p 已经指向列表末端
    if (p[0] == ZIP_END) {
        return NULL;
    }
    // 指向后一节点
    p += zipRawEntryLength(p);
    if (p[0] == ZIP_END) {
        // p 已经是表尾节点，没有后置节点
        return NULL;
    }
    return p;
}
prev entry
unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
    zlentry entry;
    // 表尾需要单独处理
    if (p[0] == ZIP_END) {
        p = ZIPLIST_ENTRY_TAIL(zl);
        // 尾端节点也指向列表末端，那么列表为空
        return (p[0] == ZIP_END) ? NULL : p;
    // 如果 p 指向列表头，那么说明迭代已经完成
    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
        return NULL;
    // 既不是表头也不是表尾，从表尾向表头移动指针
    } else {
        // 计算前一个节点的节点数
        entry = zipEntry(p);
        assert(entry.prevrawlen > 0);
        // 移动指针，指向前一个节点
        return p-entry.prevrawlen;
    }
}
get value in entry
unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
    zlentry entry;
    if (p == NULL || p[0] == ZIP_END) return 0;
    if (sstr) *sstr = NULL;
    // 取出 p 所指向的节点的各项信息，并保存到结构 entry 中
    entry = zipEntry(p);
    // 节点的值为字符串，将字符串长度保存到 *slen ，字符串保存到 *sstr
    if (ZIP_IS_STR(entry.encoding)) {
        if (sstr) {
            *slen = entry.len;
            *sstr = p+entry.headersize;
        }
    // 节点的值为整数，解码值，并将值保存到 *sval
    } else {
        if (sval) {
            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
        }
    }
    return 1;
}
compare entry
unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) {
    zlentry entry;
    unsigned char sencoding;
    long long zval, sval;
    if (p[0] == ZIP_END) return 0;
    // 取出节点
    entry = zipEntry(p);
    if (ZIP_IS_STR(entry.encoding)) {
        // 节点值为字符串，进行字符串对比
        if (entry.len == slen) {
            return memcmp(p+entry.headersize,sstr,slen) == 0;
        } else {
            return 0;
        }
    } else {
        // 节点值为整数，进行整数对比
        if (zipTryEncoding(sstr,slen,&sval,&sencoding)) {
          zval = zipLoadInteger(p+entry.headersize,entry.encoding);
          return zval == sval;
        }
    }
    return 0;
}
get entry by value
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) {
            // 对比字符串值
            if (ZIP_IS_STR(encoding)) {
                if (len == vlen && memcmp(q, vstr, vlen) == 0) {
                    return p;
                }
            } else {
                // 因为传入值有可能被编码了，
                // 所以当第一次进行值对比时，程序会对传入值进行解码
                // 这个解码操作只会进行一次
                if (vencoding == 0) {
                    if (!zipTryEncoding(vstr, vlen, &vll, &vencoding)) {
                        vencoding = UCHAR_MAX;
                    }
                    assert(vencoding);
                }
                // 对比整数值
                if (vencoding != UCHAR_MAX) {
                    long long ll = zipLoadInteger(q, encoding);
                    if (ll == vll) {
                        return p;
                    }
                }
            }
            skipcnt = skip;
        } else {
            skipcnt--;
        }
        // 后移指针，指向后置节点
        p = q + len;
    }
    // 没有找到指定的节点
    return NULL;
}
Jamgun zhang
关注
专栏目录
redis源码分析（八）、redis数据结构之压缩ziplist--------ziplist.c ziplist.h学习笔记
chen
12-20 731
一、介绍ziplist /* The ziplist is a specially encoded dually linked list that is designed * to be very memory efficient. * Ziplist 是为了尽可能节约内存而设计相当特许的双端队列 *It stores both strings and integer values,
ziplist--redis源码研究笔记-压缩列表ziplist
chen
12-30 417
ziplsit的特点简单介绍： ziplist其实就是分配一块连续的内存，用指针和位操作来操作内存的一种高效的数据结构。 Ziplist 能存储strings和integer值，整型值被存储为实际的整型值而不是字符数组 Ziplist 是为了尽可能节约内存而设计相当特殊的双端队列 Ziplist 在头部和尾部的操作时间0（1），ziplist的操作都需要重新分配内存，所以实际的复杂度和zipli...
redis源码解析之ziplist.h
小羽毛的博客
09-10 142
#ifndef _ZIPLIST_H #define _ZIPLIST_H #define ZIPLIST_HEAD 0 #define ZIPLIST_TAIL 1 unsigned char *ziplistNew(void);//新建ziplist unsigned char *ziplistMerge(unsigned char **first, unsigned char **sec...
Redis源码阅读(五)ziplist
Orange_pa的博客
10-17 304
压缩链表
Redis - ziplist (压缩列表) 图文详解
热门推荐
一七令
05-30 1万+
List列表是简单的字符串列表，按照插入顺序排序，可以从头部或尾部向List列表添加元素。最大长度为2^32-1，也即每个列表支持超过40亿个元素。Redis的List类型有多种实现方式，由双向链表或压缩列表（v7.0由listpack替代）实现的。这篇文章就是介绍其中一种实现ziplist-压缩列表。ziplist为了节省内存，采用了紧凑的连续存储。所以在修改操作下并不能像一般的链表那么容易，需要从新分配新的内存，然后复制到新的空间。httpshttps。............
Redis源码解析-基础数据-ziplist(压缩列表)
Knight0xffff的博客
12-03 462
太长不看版 压缩列表是一种为节约空间而实现的线性数据结构，本质是字节数组。 压缩列表元素可以为整数或字符串。 压缩列表在快速列表、列表对象和哈希对象中都有使用。 压缩列表添加(平均复杂度O(n))与删除节点(平均复杂度O(n))，可能会触发连锁更新(平均复杂度O(n^2))，因为触发机率不高所以不影响性能。 因为节点存在字符串，字符串匹配为O(n)复杂度，所以压缩列表查找节点平均复杂度为O(n...
[redis 源码走读] - 压缩列表(ziplist)
smart_an的专栏
06-03 1032
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！压缩列表ziplist是一个双向链表，设计主要是为了节省内存。保存字符串，数值两种类型（ It stores both strings and integer values），列表内部实现主要是对一块连续内存进行管理，列表支持列表头尾的插入或弹出结点操作。
Redis 源码解析 - Redis 压缩列表(ziplist)
qq_33240556的博客
04-29 322
Redis 的压缩列表（ziplist）是一种为了节省内存而设计的高效数据结构，它被用作列表（list）、哈希（hash）和有序集合（zset）等数据类型的底层实现之一，尤其是在元素数量较少且元素值较小时。学习ziplist的源码对于理解Redis如何在内存效率和数据结构灵活性之间做出权衡至关重要，同时也提供了优化内存使用和设计高效数据结构的实战案例。随着Redis版本的更新，从Redis 7.0开始，ziplist已被新的数据结构。所取代，它提供了更好的内存效率和性能。
Redis数据结构-ZipList（压缩列表）
qq_59776041的博客
09-01 610
ZipList在redis的集合和hash中被经常作为基层存储结构使用。ZipList是一种特殊的“双向链表”，被设计为一系列连续内存经过特殊编码组成的数据结构。而抛弃了记录内存的指针的方法。即有效节省了内存开销，也可以在任意一端进行压入/弹出操作。且时间复杂度均为O(1)。ziplist 为了节省内存，采用了紧凑的连续存储。所以在修改操作下并不能像一般的链表那么容易，需要从新分配新的内存，然后复制到新的空间。
ziplist--redis源码研究笔记-压缩列表ziplist1
08-04
Redis中的压缩列表`ziplist`是一种特殊的内存优化数据结构，主要设计用于存储简化的序列数据，如哈希表和有序集合。它通过紧凑的内存布局和指针位操作来节省内存，尤其适用于小数据量的场景。以下是关于`ziplist`的...
redis源码分析教程之压缩链表ziplist详解
09-09
压缩链表（ziplist）是Redis中用于存储小型数据序列的一种高效内存结构，它被广泛应用于列表、字典等数据类型的底层实现。ziplist的主要优点是节省内存，通过压缩和特殊编码的方式，减少了不必要的内存开销。 在...
【Redis 源码】6AOF持久化
qq_17821591的博客
09-27 814
RDB (快照)定期保存内存中的数据到磁盘。文件紧凑，适合备份和灾难恢复。恢复速度快，但可能丢失最后一次快照之后的数据。AOF (日志)记录每个写操作，并追加到文件中。可以设置不同的 fsync 策略来平衡性能和数据安全性。数据更完整，但文件较大，恢复速度较慢。
Redis-持久化
最新发布
qq_74812898的博客
09-28 653
redis持久化
Redis系列补充：聊聊布隆过滤器（go语言实践篇）
sdgfafg_25的博客
09-24 802
本篇介绍了布隆过滤器的几种实现场景。并以火车票订单信息查询为案例进行说明，如何使用布隆过滤器避免缓存穿透，避免被恶意攻击。引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构。
[Redis][主从复制][中]详细讲解
SnowK博客
09-26 3211
[Redis][主从复制][中]详细讲解
微服务Redis解析部署使用全流程
m0_71240584的博客
09-26 1126
/判断是否有key所对应的值，有则返回true，没有则返回false//有则取出key值所对应的值//删除单个key值//其中keys:Collection keys//将当前传入的key值序列化为byte[]类型//设置过期时间//设置过期时间//查找匹配的key值，返回一个Set集合类型//返回传入key所存储的值的类型//如果旧值存在时，将旧值改为新值//从redis中随机取出一个key//返回当前key所对应的剩余过期时间。
推荐一款开源的Redis桌面客户端
xiangzhihong8的专栏
09-23 741
TinyRDM 是一个现代化的、轻量级的跨平台 Redis 桌面客户端，能在 Mac、Windows 和 Linux 系统上使用。它有着现代化的设计风格，界面既简洁又清晰，操作起来方便又高效。不管是刚开始接触的新手，还是经验丰富的开发者，都能很容易地学会使用，能够迅速地管理和操作 Redis 数据库。
Redis 介绍
2401_84881237的博客
09-24 651
Redis 中每个存储区域除了存储 key-value 值，还会开辟额外的存储空间 expires 记录每个 key-value 的存储地址以及过期时间。但层次太多会导致数据延迟，慎用。set 类型中，key 值对应的存储空间内可以保存多个字符串数据，采用哈希存储实现。Redis 将数据存储分为多个相互独立的区域，将 Redis 操作局限在自己的存储区域内。对于 16 个存储区域的 expires 进行轮询，对选中的 expires 随机选择 W 个 key 进行检查，如果 key 过期就进行删除。
Redis源码分析：压缩链表ziplist深度解析
"Redis压缩链表ziplist是其节省内存的一种高效数据结构，常用于列表、字典等。ziplist通过特殊编码的内存块组织数据，包含zlbytes、zltail、zllen和zlend等关键字段，以及entry字段，用于存储元素。entry由prevlen、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值