类型介绍

zipmap也是redis的存储类型之一，这里面是sting->string的map结构，之所以出现这种形式的类型，主要是为了节省内存空间，采用的序列内存的方式，这种方式的一个问题就是查找的时候不是O(1)的复杂度，而是O(N)的时间复杂度，因此，它的目的是为了应付小规模的数据的，大规模的数据会过渡到hash表结构，这样应该是为了实现效率与空间的一种平衡；
内存格式为：
zmlen–len–“foo”–len–free–“bar”–len–“hello”–len–free–“world”
zmlen，是指zipmap中包含的entry数目，大于254的话，就不起作用了，当做标记开头；
len，是指key的长度，小于254的话占据一个字节，超过的话，后面跟着4个字节来表示长度；
free，空位，一般不会超过4个

代码分析

变量

ZIPMAP_BIGLEN, zipmap的最大长度
ZIPMAP_END, zipmap的结束符
ZIPMAP_VALUE_MAX_FREE, zipmap的free部分最大长度

函数

zipmapNew，新建一个zipmap;

unsigned char *zipmapNew(void) {
    unsigned char *zm = zmalloc(2);

    zm[0] = 0; /* Length */  
    zm[1] = ZIPMAP_END;  //结尾标志，0XFF
    return zm;
}

zipmapDecodeLength，zipmap解码长度信息；

static unsigned int zipmapDecodeLength(unsigned char *p) {
    unsigned int len = *p;

    if (len < ZIPMAP_BIGLEN) return len;  //如果长度小于254，无需编码
    memcpy(&len,p+1,sizeof(unsigned int)); //长度超过255，获取p指针的后面的4个字节的数据
    memrev32ifbe(&len);  //获取该4个自己对应的数据，需要根据大小端判断，来解析长度信息
    return len;
}

zipmapEncodeLength，zipmap编码长度信息；

static unsigned int zipmapEncodeLength(unsigned char *p, unsigned int len) {
    if (p == NULL) {
        return ZIPMAP_LEN_BYTES(len);  //如果p为NULL，则单纯返回该长度需要的内存字节数目
    } else {
        if (len < ZIPMAP_BIGLEN) {
            p[0] = len;  //如果小于254，那么无需编码，直接复制给当前字节
            return 1;  //主需要一个字节来保存长度信息
        } else {
            p[0] = ZIPMAP_BIGLEN;
            memcpy(p+1,&len,sizeof(len));  
            memrev32ifbe(p+1);  //需要硬编码到内存
            return 1+sizeof(len);  //需要5个字节来保存长度信息
        }
    }
}

zipmapLookupRaw，zipmap的查找过程；

static unsigned char *zipmapLookupRaw(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned int *totlen) {
    unsigned char *p = zm+1, *k = NULL;  //zm+1是因为第一位是长度信息
    unsigned int l,llen;

    while(*p != ZIPMAP_END) {  //还没到结尾
        unsigned char free;

        /* Match or skip the key */
        l = zipmapDecodeLength(p);  //获取当前地址对应的key长度
        llen = zipmapEncodeLength(NULL,l);  //获取该长度占用的字节数
        if (key != NULL && k == NULL && l == klen && !memcmp(p+llen,key,l)) {
        //查看是否能够匹配key信息，如果匹配了
            /* Only return when the user doesn't care
             * for the total length of the zipmap. */
            if (totlen != NULL) {  //这里表示是否需要返回zipmap的整体长度
                k = p;  
            } else {
                return p;  //返回k/v当前地址
            }
        }
        //下面是跳过当前kv，进入下一个kv
        p += llen+l;
        /* Skip the value as well */
        l = zipmapDecodeLength(p);
        p += zipmapEncodeLength(NULL,l);
        free = p[0]; //free的长度
        p += l+1+free; /* +1 to skip the free byte */
    }
    if (totlen != NULL) *totlen = (unsigned int)(p-zm)+1;  //如果需要返回zipmap占据的长度信息，计算
    return k;
}

zipmapRequiredLength，计算当前kv所需要的内存大小；

static unsigned long zipmapRequiredLength(unsigned int klen, unsigned int vlen) {
    unsigned int l;

    l = klen+vlen+3; //这三个是必有的，
    if (klen >= ZIPMAP_BIGLEN) l += 4;  //如果超出254，还需要额外4个字节
    if (vlen >= ZIPMAP_BIGLEN) l += 4;
    return l;
}

zipmapRawKeyLength，计算当前key占用的内存大小，包括key的长度以及存储该长度使用的数目；

static unsigned int zipmapRawKeyLength(unsigned char *p) {
    unsigned int l = zipmapDecodeLength(p);  //获取当前key的长度
    return zipmapEncodeLength(NULL,l) + l;  //返回当前key的长度l和该长度所需要的存储字节数之和
}

zipmapRawValueLength，计算存储当前value占用的所有内存数，包括value的长度以及free字段长度和存储value长度占用的字节数；

static unsigned int zipmapRawValueLength(unsigned char *p) {
    unsigned int l = zipmapDecodeLength(p);  //获取当前value的长度
    unsigned int used;

    used = zipmapEncodeLength(NULL,l);  //获取存储value长度使用的内存数
    used += p[used] + 1 + l;  //加上一个free字段长度+1
    return used;
}

zipmapRawEntryLength，获取当前指针指向的一个kv占用的内存字节数；

static unsigned int zipmapRawEntryLength(unsigned char *p) {
    unsigned int l = zipmapRawKeyLength(p);  //先计算当前key占用的字节数
    return l + zipmapRawValueLength(p+l);  //再计算当前value占用的字节数
}

zipmapResize，调整当前 zipmap的大小；

static inline unsigned char *zipmapResize(unsigned char *zm, unsigned int len) {
    zm = zrealloc(zm, len);
    zm[len-1] = ZIPMAP_END;  //尾部置位
    return zm;
}

zipmapSet，设置kv，如果当前zipmap已存在该key，则更新对应的value值，这部分主要是涉及内存移动；

unsigned char *zipmapSet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char *val, unsigned int vlen, int *update) {
    unsigned int zmlen, offset;
    unsigned int freelen, reqlen = zipmapRequiredLength(klen,vlen);  //计算该kv所需要的字节数
    unsigned int empty, vempty;
    unsigned char *p;

    freelen = reqlen;
    if (update) *update = 0;  //这个是用来表示该key是否之前已经存在，现在是更新操作
    p = zipmapLookupRaw(zm,key,klen,&zmlen);  //查找该key
    if (p == NULL) {
        /* Key not found: enlarge */ //未找到，扩大zipmap
        zm = zipmapResize(zm, zmlen+reqlen);
        p = zm+zmlen-1; //设置指针跳到zm+zmlen-1
        zmlen = zmlen+reqlen;  //当前的长度，zipmap占用的字节数

        /* Increase zipmap length (this is an insert) */
        if (zm[0] < ZIPMAP_BIGLEN) zm[0]++;  //这里面是当zipmap的entry数目小于254才计数，多的话就不计数了，通过其他方式获取
    } else {
        /* Key found. Is there enough space for the new value? */
        /* Compute the total length: */
        if (update) *update = 1;  //更新操作
        freelen = zipmapRawEntryLength(p);  //获取该kv之前占据的内存字节数
        if (freelen < reqlen) { //如果之前占据的内存数小于现在需要的
            /* Store the offset of this key within the current zipmap, so
             * it can be resized. Then, move the tail backwards so this
             * pair fits at the current position. */
            offset = p-zm;  //偏移量
            zm = zipmapResize(zm, zmlen-freelen+reqlen); //调整大小
            p = zm+offset;  //跳转到现在zipmap之前entry的起始地址

            /* The +1 in the number of bytes to be moved is caused by the
             * end-of-zipmap byte. Note: the *original* zmlen is used. */
            memmove(p+reqlen, p+freelen, zmlen-(offset+freelen+1));  //将此前entry的后一个entry往后移动，空出来保存该entry的内存空间
            zmlen = zmlen-freelen+reqlen;  //获取新的zipmap的带下
            freelen = reqlen;  //设置新的该key占用的内存空间
        }
    }

    /* We now have a suitable block where the key/value entry can
     * be written. If there is too much free space, move the tail
     * of the zipmap a few bytes to the front and shrink the zipmap,
     * as we want zipmaps to be very space efficient. */
    empty = freelen-reqlen;  //这个是更新操作时，现在的v的长度比以前的小
    if (empty >= ZIPMAP_VALUE_MAX_FREE) {  //free的长度超过现在
        /* First, move the tail <empty> bytes to the front, then resize
         * the zipmap to be <empty> bytes smaller. */
        offset = p-zm;
        memmove(p+reqlen, p+freelen, zmlen-(offset+freelen+1));//移动内存空间，将现在的节省下来
        zmlen -= empty;
        zm = zipmapResize(zm, zmlen);
        p = zm+offset;
        vempty = 0;
    } else {
        vempty = empty;  //新的free值
    }

    /* Just write the key + value and we are done. */
    /* Key: */
    //上面是指无论哪种情况，都是留出该kv需要的空间，并赋给p可以存储该信息的内存起始地址，下面就是依次将数据写入到内存中
    p += zipmapEncodeLength(p,klen);
    memcpy(p,key,klen);  
    p += klen;
    /* Value: */
    p += zipmapEncodeLength(p,vlen);
    *p++ = vempty;
    memcpy(p,val,vlen);
    return zm;
}

zipmapDel，删除指定key以及对应的内容；

unsigned char *zipmapDel(unsigned char *zm, unsigned char *key, unsigned int klen, int *deleted) {
    unsigned int zmlen, freelen;
    unsigned char *p = zipmapLookupRaw(zm,key,klen,&zmlen);  //查找该key
    if (p) {  //找到
        freelen = zipmapRawEntryLength(p);  //获取该key占用内存大小
        memmove(p, p+freelen, zmlen-((p-zm)+freelen+1));  //将该kv后面的内容往前移动，覆盖待删除的kv
        zm = zipmapResize(zm, zmlen-freelen);  //调整大小

        /* Decrease zipmap length */
        if (zm[0] < ZIPMAP_BIGLEN) zm[0]--;  //如果zipmap的entry数目小于254，正常计数

        if (deleted) *deleted = 1;  //设置删除标记位
    } else {
        if (deleted) *deleted = 0;
    }
    return zm;  //返回现在的zipmap的首地址
}

zipmapNext，获取当前kv的值，并返回下一个entry的地址；

unsigned char *zipmapNext(unsigned char *zm, unsigned char **key, unsigned int *klen, unsigned char **value, unsigned int *vlen) {
    if (zm[0] == ZIPMAP_END) return NULL;  直接到末尾了，返回NULL 
    if (key) {  //用于存放当前key的地址
        *key = zm;
        *klen = zipmapDecodeLength(zm);  //获取当前key的长度
        *key += ZIPMAP_LEN_BYTES(*klen);  //当前key的地址
    }
    zm += zipmapRawKeyLength(zm);  //移动到存储value的地址
    if (value) {  //用来保存当前value的地址
        *value = zm+1; //跳过长度信息位
        *vlen = zipmapDecodeLength(zm);  //获取该value的长度 
        *value += ZIPMAP_LEN_BYTES(*vlen);  //移动到value的地址
    }
    zm += zipmapRawValueLength(zm);  //移动到value之后，也就是下一个kv的开始地址
    return zm;
}

zipmapGet，获取某个key的value，如果没找到，返回0；

int zipmapGet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char **value, unsigned int *vlen) {
    unsigned char *p;

    if ((p = zipmapLookupRaw(zm,key,klen,NULL)) == NULL) return 0;  //查找该key，没找到返回0
    p += zipmapRawKeyLength(p);  //找到跳过key的长度，移动到value部分
    *vlen = zipmapDecodeLength(p);  //获取该value的长度信息
    *value = p + ZIPMAP_LEN_BYTES(*vlen) + 1; //跳到value内容的起始地址
    return 1;
}

zipmapLen，获取该zipmap的entry的长度；

unsigned int zipmapLen(unsigned char *zm) {
    unsigned int len = 0;
    if (zm[0] < ZIPMAP_BIGLEN) {
        len = zm[0];  //如果长度信息未超过254，则可以直接读取首位获取数目
    } else {
        unsigned char *p = zipmapRewind(zm);  //这个函数前面没列出，是用来跳过zipmap第一个字节的，直接是第一个key的首地址，和zipmapNext配合来遍历zipmap
        while((p = zipmapNext(p,NULL,NULL,NULL,NULL)) != NULL) len++;  //一直到zipmap的结尾，获取长度

        /* Re-store length if small enough */
        if (len < ZIPMAP_BIGLEN) zm[0] = len; //如果发现长度信息比254小，则可以重置zipmap的第一个位，之所以可能出现这种情况是因为可能删除之前zipmap长度超了，删除过程没有恢复。
    }
    return len;
}