redis中的ziplist
1、结构
zlbytes:4字节，记录整个压缩列表占用的内存字节数
zltail:4字节，记录压缩列表表尾节点距离压缩列表的起始地址有多少字节。即entryN在ziplist中的偏移
zllen:2字节,记录了压缩列表包含的节点数,当这个属性的值小于UINT16_MAX时，这个属性的值就是压缩列表包含节点的数量 ，当这个值等于UINT16_MAX时，节点的真实数量需要遍历整个压缩列表才能计算得出。
zlend:1字节，特殊值0xff，用于标记压缩列表的末端。
压缩列表节点可以保存一个字节串或者一个整数。
每个压缩节点的组成
previous_entry_length以字节为单位，记录了压缩列表中前一个节点的长度。取值可以是1字节或者5字节。
如果前一节点的长度小于254字节，那么previous_entry_length长度为1字节，前一节点的长度就保存在这一个字节里。
如果前一节点的长度大于等于254字节，那么previous_entry_length长度为5字节，其中第一字节设置为0xFE，之后的四字节用于保存前一节点的长度。
一字节、两字节或者五字节长，值 的最高位为00,01或者10的是字节数组编码，这种编码表示节点的content属性保存着字节数组，数组的长度由编码除去最高两位之后的其他位记录。
一字节长，值的最高位以11开头的是整数编码，这种编码表示节点的content属性保存的是整数值，整数值的类型和长度由编码除去最高两位之后的其他位记录。
encoding记录节点的content属性所保存数据的类型以及长度
字符串支持的编码形式有
| 长度 | 编码 | 说明 |
| <=64 | |00pppppp| |
pppppp表示字符串长度 |
| <=16383 | |01pppppp|qqqqqqqq| |
p表示字符串长度，大端字符串存储 |
| >=16384 | |10000000|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt| |
|qqqqqqqq|rrrrrrrr|ssssssss|tttttttt|表示字符口中长度，大端字符序存储 |
整数支持的编码形式有
| 长度 | 编码 | 说明 |
| 2字节 | |11000000| |
总共占用3字节(encoding+content) |
| 4字节 | |11010000| |
总共占用5字节 |
| 8字节 | |11100000| |
总共占用9字节 |
| 3字节 | |11110000| |
总共占用4字节 |
| 1字节 | |11111110| |
总共占用2字节 |
| 0-12 | |1111xxxx| |
实际存储是的[1-13] |
content保存节点的值，节点值可以是一个字节数组或者整数，值的类型和长度由节点的encoding属性决定。
2、创建
createZiplistObject来创建ziplist
robj *createZiplistObject(void) {
unsigned char *zl = ziplistNew();
robj *o = createObject(OBJ_LIST,zl);
o->encoding = OBJ_ENCODING_ZIPLIST;
return o;
}3、添加entry
ziplistPush来添加entry，内部是调用__ziplistInsert，在位置p前插入entry(s, slen)，会更新p的prelen，ziplist的zltail,zlbytes, zllen
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
unsigned char *p;
p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
return __ziplistInsert(zl,p,s,slen);
}
unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
unsigned int prevlensize, prevlen = 0;
size_t offset;
int nextdiff = 0;
unsigned char encoding = 0;
long long value = 123456789; /* initialized to avoid warning. Using a value
that is easy to see if for some reason
we use it uninitialized. */
zlentry tail;
/* Find out prevlen for the entry that is inserted. */
if (p[0] != ZIP_END) {
ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
} else {
unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
if (ptail[0] != ZIP_END) {
prevlen = zipRawEntryLength(ptail);
}
}
/* See if the entry can be encoded */
if (zipTryEncoding(s,slen,&value,&encoding)) {
/* 'encoding' is set to the appropriate integer encoding */
reqlen = zipIntSize(encoding);
} else {
/* 'encoding' is untouched, however zipStoreEntryEncoding will use the
* string length to figure out how to encode it. */
reqlen = slen;
}
/* We need space for both the length of the previous entry and
* the length of the payload. */
reqlen += zipStorePrevEntryLength(NULL,prevlen);
reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
/* When the insert position is not equal to the tail, we need to
* make sure that the next entry can hold this entry's length in
* its prevlen field. */
int forcelarge = 0;
nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
if (nextdiff == -4 && reqlen < 4) {
nextdiff = 0;
forcelarge = 1;
}
/* Store offset because a realloc may change the address of zl. */
offset = p-zl;
zl = ziplistResize(zl,curlen+reqlen+nextdiff);
p = zl+offset;
/* Apply memory move when necessary and update tail offset. */
if (p[0] != ZIP_END) {
/* Subtract one because of the ZIP_END bytes */
memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
/* Encode this entry's raw length in the next entry. */
if (forcelarge)
zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
else
zipStorePrevEntryLength(p+reqlen,reqlen);
/* Update offset for tail */
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
/* When the tail contains more than one entry, we need to take
* "nextdiff" in account as well. Otherwise, a change in the
* size of prevlen doesn't have an effect on the *tail* offset. */
zipEntry(p+reqlen, &tail);
if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
ZIPLIST_TAIL_OFFSET(zl) =
intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
}
} else {
/* This element will be the new tail. */
ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
}
/* When nextdiff != 0, the raw length of the next entry has changed, so
* we need to cascade the update throughout the ziplist */
if (nextdiff != 0) {
offset = p-zl;
zl = __ziplistCascadeUpdate(zl,p+reqlen);
p = zl+offset;
}
/* Write the entry */
p += zipStorePrevEntryLength(p,prevlen);
p += zipStoreEntryEncoding(p,encoding,slen);
if (ZIP_IS_STR(encoding)) {
memcpy(p,s,slen);
} else {
zipSaveInteger(p,value,encoding);
}
ZIPLIST_INCR_LENGTH(zl,1);
return zl;
}redis中的hash当使用ziplist来存储key,value时，其内部entry列表顺序为key1,value1,..., keyn,valuen