Redis-压缩列表源码原理解析

struct ziplist<T> {

    int32 zlbytes; // 整个压缩列表占用字节数

    int32 zltail_offset; // 最后一个元素距离压缩列表起始位置的偏移量，用于快速定位到最后一个节点

    int16 zllength; // 元素个数

    T[] entries; // 元素内容列表，挨个挨个紧凑存储

    int8 zlend; // 标志压缩列表的结束，值恒为 0xFF

}

struct entry {

    int<var> prevlen; // 前一个 entry 的字节长度

    int<var> encoding; // 元素类型编码

    optional byte[] content; // 元素内容

}

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) {

        zipEntry(p, &cur);

        rawlen = cur.headersize + cur.len;

        rawlensize = zipStorePrevEntryLength(NULL,rawlen);

        /* Abort if there is no next entry. */

        if (p[rawlen] == ZIP_END) break;

        zipEntry(p+rawlen, &next);

        /* Abort when "prevlen" has not changed. */

        // prevlen 的长度没有变，中断级联更新

        if (next.prevrawlen == rawlen) break;

        if (next.prevrawlensize < rawlensize) {

            /* The "prevlen" field of "next" needs more bytes to hold

             * the raw length of "cur". */

            // 级联扩展

            offset = p-zl;

            extra = rawlensize-next.prevrawlensize;

            // 扩大内存

            zl = ziplistResize(zl,curlen+extra);

            p = zl+offset;

            /* Current pointer and offset for next element. */

            np = p+rawlen;

            noffset = np-zl;

            /* Update tail offset when next element is not the tail element. */

            // 更新 zltail_offset 指针

            if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) {

                ZIPLIST_TAIL_OFFSET(zl) =

                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);

            }

            /* Move the tail to the back. */

            // 移动内存

            memmove(np+rawlensize,

                np+next.prevrawlensize,

                curlen-noffset-next.prevrawlensize-1);

            zipStorePrevEntryLength(np,rawlen);

            /* Advance the cursor */

            p += rawlen;

            curlen += extra;

        } else {

            if (next.prevrawlensize > rawlensize) {

                /* This would result in shrinking, which we want to avoid.

                 * So, set "rawlen" in the available bytes. */

                // 级联收缩，不过这里可以不用收缩了，因为 5 个字节也是可以存储 1 个字节的内容的

                // 虽然有点浪费，但是级联更新实在是太可怕了，所以浪费就浪费吧

                zipStorePrevEntryLengthLarge(p+rawlen,rawlen);

            } else {

                // 大小没变，改个长度值就完事了

                zipStorePrevEntryLength(p+rawlen,rawlen);

            }

            /* Stop here, as the raw length of "next" has not changed. */

            break;

        }

    }

    return zl;

}

struct intset<T> {

    int32 encoding; // 决定整数位宽是 16 位、32 位还是 64 位

    int32 length; // 元素个数

    int<T> contents; // 整数数组，可以是 16 位、32 位和 64 位

}

> sadd codehole 1 2 3

(integer) 3

> debug object codehole

Value at:0x7fec2dc2bde0 refcount:1 encoding:intset serializedlength:15 lru:6065795 lru_seconds_idle:4

> sadd codehole go java python

(integer) 3

> debug object codehole

Value at:0x7fec2dc2bde0 refcount:1 encoding:hashtable serializedlength:22 lru:6065810 lru_seconds_idle:5