redis代码结构之三类型库-list
redis代码结构之三类型库-list
1. REDIS_LIST(t_list.c)
该类型的命令包括：lpush,rpush,lpop,rpop等等。这里我们只介绍lpush命令，它相应的命令回调函数为void lpushCommand(redisClient *c) { pushGenericCommand(c,REDIS_HEAD);}我们直接看pushGenericCommandvoid pushGenericCommand(redisClient *c, int where) {
int j, addlen = 0, pushed = 0;
robj *lobj = lookupKeyWrite(c->db,c->argv[1]); //查找key是否存在,存在的话返回的是它的subobject
int may_have_waiting_clients = (lobj == NULL); //key不存在
if (lobj && lobj->type != REDIS_LIST) {//如果key存在,则它的type必定是REDIS_LIST
addReply(c,shared.wrongtypeerr);
return;
}
for (j = 2; j < c->argc; j++) {
c->argv[j] = tryObjectEncoding(c->argv[j]);
if (may_have_waiting_clients) {
if (handleClientsWaitingListPush(c,c->argv[1],c->argv[j])) { //判断是否有block的pop key,这种情况是由于blpop引起的
addlen++;
continue;
} else {
may_have_waiting_clients = 0;
}
}
if (!lobj) { //如果该key现在没有value,只调用一次
lobj = createZiplistObject(); //一开始总是使用ziplist,并赋值,跟进去可以看到其实ziplist是字符串数组
dbAdd(c->db,c->argv[1],lobj); //将key,robj value加入dict
}
listTypePush(lobj,c->argv[j],where); //将每个value加入到value list,并且该函数会判断是否需要转换存储类型
pushed++;
}
addReplyLongLong(c,addlen + (lobj ? listTypeLength(lobj) : 0));
if (pushed) signalModifiedKey(c->db,c->argv[1]);
server.dirty += pushed;
}上面的几个value有点别扭，其实通过key得到的都是一个robj value，而这个里面又包含了一个list或ziplist，这个list又是由多个robj value对象组成。下面我们看一下listTypePush函数：
void listTypePush(robj *subject, robj *value, int where) {
/* Check if we need to convert the ziplist */
listTypeTryConversion(subject,value); //查看是否需要将ziplist转换为普通的LINKEDLIST
//如果当前是ziplist类型,并且长度已经大于配置的list_max_ziplist_entries时，则将ziplist转换为LINKEDLIST
if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
if (subject->encoding == REDIS_ENCODING_ZIPLIST) {//仍然可以使用ziplist
int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
value = getDecodedObject(value); //获得string类型
subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);//ziplist的插入
decrRefCount(value);
} else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {//list类型,就是我们常见的双向链表插入,这里我们不再解释
if (where == REDIS_HEAD) {
listAddNodeHead(subject->ptr,value);
} else {
listAddNodeTail(subject->ptr,value);
}
incrRefCount(value);
} else {
redisPanic("Unknown list encoding");
}
}
//转换类型,如果要保存的value的长度大于配置的list_max_ziplist_value时也必须把原来的ziplist转换为list
void listTypeTryConversion(robj *subject, robj *value) {
if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
if (value->encoding == REDIS_ENCODING_RAW &&
sdslen(value->ptr) > server.list_max_ziplist_value)
listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
}通过上面的代码我们可以发现当要插入的value的长度（实际字节长度）大于配置的list_max_ziplist_value时或者ziplist的长度（元素大小）大于server.list_max_ziplist_entries时把ziplist转换为list类型。下面我们主要介绍一下ziplist的相关操作。
1.1 ziplist
/* Create a new empty ziplist. */
unsigned char *ziplistNew(void) {
unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
unsigned char *zl = zmalloc(bytes);
ZIPLIST_BYTES(zl) = bytes;
ZIPLIST_TAIL_OFFSET(zl) = ZIPLIST_HEADER_SIZE;
ZIPLIST_LENGTH(zl) = 0;
zl[bytes-1] = ZIP_END;
return zl;
}
//往ziplist中增加entry,zl就是ziplist字符串数组;s为要插入的value的实际内容;slen为value长度,where是首或尾
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
unsigned char *p;//p为实际把插入的位置head的话就是从header后开始,TAIL就是从最后的一个字节处开始
p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
return __ziplistInsert(zl,p,s,slen);
}
通过上面的new可以看到ziplist的结构：ziplist是一个字符串数组，它的格式为：
[header:<zlbytes><zltail><zllen>][body:<entry>…<entry>][end:<zlend>]，其中前面三个又称为ziplist header
zlbytes: uint32_t,保存该字符串数组的总长度，包括header,body,end；
zltail:uint32_t,用来保存最后一个entry的偏移,即最后一个节点的位置,允许pop操作，而不需要遍历
zllen:uint16_t,用来保存ziplist的entry个数，所以最多2^16-1个。
zlend:1byte结束标志[255]
下面我们再来看一下body:entry的结构：（每个body也是由三个部分组成）
prevrawlen:保存前一个节点的长度（这个len就是一个entry总长度），占用1或5个字节，当len少于254时占1个字节，否则前面一个字节保存254，后面4个字节保存实际的长度
lensize[curencode|curlen]:保存当前节点使用的encode类型,如果是字符串类型还必须包括长度；整型的话不需要长度，因为整型的长度是固定的。该字段可能占用：1，2，5，1，1，1个字节。当内容不能转换为long long的时候，必须使用字符串来encode，此时如果串的长度小于63（2^6-1），则可以使用ZIP_STR_06B来encode，这个字段就占用1个字节，其中前面两位表示ZIP_STR_06B(00)，后面6位表示实际的长度；如果串的长度小于16384（2^14-1），则可以使用ZIP_STR_14B来encode，这个字段就占用2个字节，其中前面两位表示ZIP_STR_14B(01)，后面14位表示实际的长度；如果串的长度大于等于16384，则使用ZIP_STR_32B来encode，这个字段就占用5个字节，其中前面一个字节表示ZIP_STR_32B(1000,0000)，后面4个字节（32位）表示实际的长度；
如果内容能够转换为long long的时候，则把它转换为相应的类型int16_t，int32_t，int64_t，这时该字段就只需要占用一个字节，它们的高4位用来表示encode类型，分别（1100,1101,1110），此时不再需要内容的长度，因为每个int，它的大小是可能通过类型来获得的。
value:保存实际的内容，它就根据前面的encode来存储的。占用的长度，如果是字符串，则由串的长度决定，如果的整形，则由每种类型自己决定（2，4，8）。如下图：
图1 ziplist结构
下面我们看一下ziplist是怎么进行插入：
static zlentry zipEntry(unsigned char *p) {
zlentry e;
e.prevrawlen = zipPrevDecodeLength(p,&e.prevrawlensize); //返回上一个节点的总共长度，并且把保存这个长度值所占用的字节数保存到e.prevrawlensize，即1或者5（见上面的解释）
e.len = zipDecodeLength(p+e.prevrawlensize,&e.lensize); //返回当前节点的内容的长度，并且把lensize占用的大小保存到e.lensize,即1,2,5,1,1,1
e.headersize = e.prevrawlensize+e.lensize; //即每个节点的前面两个字段的长度，这个值加上上面的e.len就是该节点的实际长度
e.encoding = zipEntryEncoding(p+e.prevrawlensize); //返回当前节点的encode
e.p = p;
return e;
}
//zl为要操作的ziplist，p为当前操作的位置，该值会根据head|tail而不同，如果是head则是ziplist: header之后的位置;如果是tail则在ziplist:end:<zlend>的位置，s为实际内容,slen为实际长度
static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
size_t curlen = ZIPLIST_BYTES(zl), reqlen, prevlen = 0;
size_t offset;
int nextdiff = 0;
unsigned char encoding = 0;
long long value;
zlentry entry, tail;
/* Find out prevlen for the entry that is inserted. */
if (p[0] != ZIP_END) {//这说明是从header insert
entry = zipEntry(p); //见上面的注释
prevlen = entry.prevrawlen; //返回上一个节点的长度,如果从head insert的话显然这个都是0
} else {//从tail insert
unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl); //获得最后一个节点的起始位置
if (ptail[0] != ZIP_END) { //如果当前list非空
prevlen = zipRawEntryLength(ptail); //获得最后一个节点的总共空间大小
}
}
/* See if the entry can be encoded 计算出存储该内容实际应该占用多少字节 reqlen为该节点总共要使用的空间*/
if (zipTryEncoding(s,slen,&value,&encoding)) { //整形2,4,8
/* 'encoding' is set to the appropriate integer encoding */
reqlen = zipIntSize(encoding);
} else { //字符串实际的长度
/* 'encoding' is untouched, however zipEncodeLength 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 += zipPrevEncodeLength(NULL,prevlen); //保存上一个节点长度这个值需要占用多少空间,即body第一个字段占有用的空间1或5
reqlen += zipEncodeLength(NULL,encoding,slen);//body第二个字段占用的空间1,2,5,1,1,1
/* 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. */
nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0; //如果是head insert的话,显然如果此时的头节点的prevrawlen就要改变，并且当要插入的节点的长度>245时，就需要增加4个字节，原来的头因为它的前一个是空所以只有一个字节保存0,而现在需要5个字节来保存这个新插入的节点的长度
/* Store offset because a realloc may change the address of zl. */
offset = p-zl;
zl = ziplistResize(zl,curlen+reqlen+nextdiff); //重新分配内存reqlen是当前插入节点的长度,nextdiff为需要增加的长度
p = zl+offset;
/* Apply memory move when necessary and update tail offset. */
if (p[0] != ZIP_END) { //header insert,显然之前的内容还在前面,所以需要把它们往后移
/* Subtract one because of the ZIP_END bytes */
memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff); //这里使用nextdiff是为了说明这nextdiff也是属于之前的节点的内容
/* Encode this entry's raw length in the next entry. */
zipPrevEncodeLength(p+reqlen,reqlen); //更新之前head node的prevlen
/* Update offset for tail */
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. */
tail = zipEntry(p+reqlen);
if (p[reqlen+tail.headersize+tail.len] != ZIP_END)
ZIPLIST_TAIL_OFFSET(zl) += nextdiff;
} else { //tail insert
/* This element will be the new tail. */
ZIPLIST_TAIL_OFFSET(zl) = 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) { //如果新插入的节点len大于254时，即前一个节点的prevlen需要扩展到5个节点来保存时，需要依次去遍历整个list去修改每个node的prevlen，当前这个遍历可能不会很长，因为从head开始也就是增加4个字节，当某一个prevlen+4小于254时，该遍历就结束了
offset = p-zl;
zl = __ziplistCascadeUpdate(zl,p+reqlen);
p = zl+offset;
}
/* Write the entry */
p += zipPrevEncodeLength(p,prevlen); //保存当前插入的新节点的prevlen
p += zipEncodeLength(p,encoding,slen); //保存当前插入新节点的lensize
if (ZIP_IS_STR(encoding)) { //保存实际的内容
memcpy(p,s,slen);
} else {
zipSaveInteger(p,value,encoding);
}
ZIPLIST_INCR_LENGTH(zl,1);
return zl;
}总而言之，ziplist其本质是一个字符串数组，它通过保存每个节点的上一个节点的大小，以及当前结节的encode及实际长度，来达到两个方面的遍历。另外，从上面的操作可以看出当从head插入的时候，整个insert需要更多的过程：memmove，计算扩展值nextdiff，从而导致遍历性的修改整个list的prevlen。但不管是从head还tail都需要一个realloc的过程，所以虽然ziplist可以节省内存，但是它是以cpu换mem。如果想减少使用，可以改小上面说的两个配置。并且尽量使用rpush的操作，来得到更好的性能。