redis之zipmap

类型介绍

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