argumentoutofrangeexception:长度不能小于0_Redis5.0源码解析4 - 列表

最新推荐文章于 2021-12-29 10:28:17 发布

思一缘

最新推荐文章于 2021-12-29 10:28:17 发布

阅读量165

点赞数

文章标签： argumentoutofrangeexception:长度不能小于0

本文链接：https://blog.csdn.net/weixin_34961316/article/details/112128873

版权

Redis为列表结构提供了多种不同的实现，分为AdList、ZipList和QuickList三种。主要的代码在adlist.h、adlist.c、ziplist.h、ziplist.c、quicklist.h、quicklist.c和t_list.c这几个文件中。其中用户使用的lpush、rpush、llen、lrange、ltrim等list相关的命令都是用QuickList数据结构实现的。

1. AdList 双向链表

adlist是Redis中最简单的列表结构，采用了典型的双向链表实现。我们来看一下其中数据结构的定义，代码在adlist.h文件中。

/* adlist.h */
// 双向链表节点
typedef struct listNode {
    // 前驱节点
    struct listNode *prev;
    // 后继节点
    struct listNode *next;
    // 储存的数据
    void *value;
} listNode;

// 链表迭代器
typedef struct listIter {
    // 下一个节点
    listNode *next;
    // 迭代方向，0或1
    int direction;
} listIter;

// 链表数据结构， 包含dup，free，match三个函数指针
typedef struct list {
    listNode *head;  // 头部节点
    listNode *tail;  // 尾部节点
    void *(*dup)(void *ptr);  // 复制元素
    void (*free)(void *ptr);  // 析构元素
    int (*match)(void *ptr, void *key);  // 匹配元素
    unsigned long len;  // 链表中元素个数
} list;

adlist数据结构

接下来是一组函数接口和常量的定义：

/* adlist.h */
// 函数定义
list *listCreate(void);
void listRelease(list *list);
void listEmpty(list *list);
list *listAddNodeHead(list *list, void *value);
list *listAddNodeTail(list *list, void *value);
list *listInsertNode(list *list, listNode *old_node, void *value, int after);
void listDelNode(list *list, listNode *node);
listIter *listGetIterator(list *list, int direction);
listNode *listNext(listIter *iter);
void listReleaseIterator(listIter *iter);
list *listDup(list *orig);
listNode *listSearchKey(list *list, void *key);
listNode *listIndex(list *list, long index);
void listRewind(list *list, listIter *li);
void listRewindTail(list *list, listIter *li);
void listRotate(list *list);
void listJoin(list *l, list *o);
// 迭代方向
#define AL_START_HEAD 0  // 0表示迭代器从链表头部向尾部移动
#define AL_START_TAIL 1 //  1表示迭代器从链表尾部向头部移动

因为adlist的实现逻辑比较简单，传统功夫讲究点到为止，在这里不过多解释，我们就选其中几个函数作为例子：

/* adlist.c */
// 新建一个链表
list *listCreate(void)
{
    struct list *list;
    //分配内存失败
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;
    //所有成员初始化0值
    list->head = list->tail = NULL;
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;
    return list;
}

// 向链表头部添加一个元素
list *listAddNodeHead(list *list, void *value)
{
    listNode *node;
    // 分配内存失败
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    // node存储value
    node->value = value;
    // 当前链表为空，添加链表中的唯一节点，同时作为头和尾
    if (list->len == 0) {
        list->head = list->tail = node;
        node->prev = node->next = NULL;
    } else { //当前链表非空
        node->prev = NULL;
        node->next = list->head;
        list->head->prev = node;
        list->head = node;
    }
    // 长度+1
    list->len++;
    return list;
}

// 新建链表迭代器
listIter *listGetIterator(list *list, int direction)
{
    listIter *iter;
    if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;
    if (direction == AL_START_HEAD)
        iter->next = list->head;
    else
        iter->next = list->tail;
    iter->direction = direction;
    return iter;
}

// 删除迭代器
void listReleaseIterator(listIter *iter) {
    zfree(iter);
}

// 重置迭代器,从链表头部开始迭代
void listRewind(list *list, listIter *li) {
    li->next = list->head;
    li->direction = AL_START_HEAD;
}

// 重置迭代器,从链表尾部开始迭代
void listRewindTail(list *list, listIter *li) {
    li->next = list->tail;
    li->direction = AL_START_TAIL;
}

// 根据key查找链表中的节点
listNode *listSearchKey(list *list, void *key)
{
    listIter iter;
    listNode *node;
    listRewind(list, &iter);
    while((node = listNext(&iter)) != NULL) {
        // 当match函数不为空时，用match函数比较元素和key，否则直接用==比较
        if (list->match) {
            if (list->match(node->value, key)) {
                return node;
            }
        } else {
            if (key == node->value) {
                return node;
            }
        }
    }
    return NULL;
}

2. ZipList 压缩列表

在前一节中我们看到，每次向adlist中添加一个元素都需要创建一个listNode结构体，需要额外的3个指针。而Redis是一个内存数据库，必须要使内存的利用率最大化，所以为了节省内存，Redis的开发者设计了ziplist数据结构。

ziplist的类型是unsigned char*，表示堆内存上一段连续的空间，数据都是经过编码后储存在其中的，所以并不需要一个特别的结构体来定义，编码格式如下图所示：

ziplist数据结构

zlbytes：ziplist总共占用的字节数，包括zlbytes本身的4字节，最大可用字节数为
zltail：ziplist中最后一个entry的偏移量
zllen：ziplist中entry的数量
entry：ziplist中储存的元素
- prevlen：前一个元素的长度。第一个字节小于254时，prevlen只占1字节，它本身表示前一个元素的长度；当第一个字节是254时，prevlen占5字节，除了第一个字节之外的4个字节表示前一个元素的长度。
- encoding：记录了当前元素的数据类型和长度。如下表所示，encoding字段至少需要1字节，可以根据第一个字节中最高的2位判断encoding本身需要多少字节。
- entry-data：实际储存的数据，可能为空
zlend：固定值255，表示ziplist结尾

encoding	含义	entry-data字节长度
\| 00pppppp \|	entry-data为6位长度的字符串	小于等于63字节
\| 01pppppp \| qqqqqqqq \|	entry-data的长度用大端序储存在p和q中，表示14位长度的字符串	小于等于16383字节
\| 10000000 \| qqqqqqqq \| rrrrrrrr \| ssssssss \| tttttttt \|	entry-data的长度用大端序储存在q、r、s、t中，表示32位长度的字符串	小于等于2^32-1字节
\| 11000000 \|	entry-data为int16	2字节
\| 11010000 \|	entry-data为int32	4字节
\| 11100000 \|	entry-data为int64	8字节
\| 11110000 \|	entry-data为24位整数	3字节
\| 11111110 \|	entry-data为8位整数	1字节
\| 1111xxxx \|	不需要entry-data，直接表示4位整数，xxxx只能为1~13，所表示的值为0~12	0字节

11开头的encoding表示整数，00、01、10开头的表示字符串。

举个几个例子：最短的ziplist如下图所示，不含entry ，长度为0，占用字节数为4+4+2+1=11字节。

长度为0的ziplist

以下是ziplist提供的函数接口：

/* ziplist.h */
#define ZIPLIST_HEAD 0
#define ZIPLIST_TAIL 1
unsigned char *ziplistNew(void);
unsigned char *ziplistMerge(unsigned char **first, unsigned char **second);
unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where);
unsigned char *ziplistIndex(unsigned char *zl, int index);
unsigned char *ziplistNext(unsigned char *zl, unsigned char *p);
unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p);
unsigned int ziplistGet(unsigned char *p, unsigned char **sval, unsigned int *slen, long long *lval);
unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p);
unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num);
unsigned int ziplistCompare(unsigned char *p, unsigned char *s, unsigned int slen);
unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip);
unsigned int ziplistLen(unsigned char *zl);
size_t ziplistBlobLen(unsigned char *zl);
void ziplistRepr(unsigned char *zl);

来看一下ziplist相关的类型定义：

typedef struct zlentry {
    unsigned int prevrawlensize;  /* prevlen编码占用的字节数*/
    unsigned int prevrawlen;     /* 前一个entry占用的字节数 */
    unsigned int lensize;          /* len编码占用的字节数*/
    unsigned int len;           	   /* 数据占用的字节数 */
    unsigned int headersize;  /* prevrawlensize + lensize. */
    unsigned char encoding;  /* 编码格式 */
    unsigned char *p;            	  /* 指向entry首地址的指针 */
} zlentry;

需要注意的是zlentry类型只用来获取entry的信息，并不是数据的实际储存方式。下面我们来看如何向ziplist中添加一个元素：

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) {
    // curlen：当前字节数，reqlen：需要的字节数
    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
    // prevlensize：prevlen本身的字节数，prevlen：前一个元素的字节数
    unsigned int prevlensize, prevlen = 0;
    size_t offset;
    int nextdiff = 0;
    unsigned char encoding = 0;
    long long value = 123456789;
    zlentry tail;

    if (p[0] != ZIP_END) {
        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
    } else {
        // p是末尾0xff
        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
        if (ptail[0] != ZIP_END) {
            prevlen = zipRawEntryLength(ptail);
        }
    }
    
    if (zipTryEncoding(s,slen,&value,&encoding)) {
        reqlen = zipIntSize(encoding);
    } else {
        reqlen = slen;
    }
    // prevlen需要的字节数
    reqlen += zipStorePrevEntryLength(NULL,prevlen);
    // encoding需要的字节数
    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);
    // reqlen现在等于entry需要的总长度
    int forcelarge = 0;
    // 新的reqlen和老的prevlen所需字节数之差
    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
    if (nextdiff == -4 && reqlen < 4) {
        // 如果新元素占用字符比较少，会导致内存需要缩小
        // prevlen的字节数需要缩小4字节时，强制prevlen占用5字节
        nextdiff = 0;
        forcelarge = 1;
    }
    offset = p-zl;
    // 重新分配内存，当前字节数+新元素的字节数+调整的字节数
    zl = ziplistResize(zl,curlen+reqlen+nextdiff);
    // 重新分配后的p指针
    p = zl+offset;
    if (p[0] != ZIP_END) {
        // 当不是在末尾插入时要移动内存里原来的数据
        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
        if (forcelarge)
            zipStorePrevEntryLengthLarge(p+reqlen,reqlen);
        else
            zipStorePrevEntryLength(p+reqlen,reqlen);
        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
        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 {
        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
    }
    if (nextdiff != 0) {
        offset = p-zl;
        zl = __ziplistCascadeUpdate(zl,p+reqlen);
        p = zl+offset;
    }
    // 写入新元素
    p += zipStorePrevEntryLength(p,prevlen);
    p += zipStoreEntryEncoding(p,encoding,slen);
    if (ZIP_IS_STR(encoding)) {
        // 直接copy字符串
        memcpy(p,s,slen);
    } else {
        zipSaveInteger(p,value,encoding);
    }
    ZIPLIST_INCR_LENGTH(zl,1);
    return zl;
}

添加元素时，ziplist的zlbytes、zltail、zllen字段都的值会增大，另外还需要计算新增元素的prevlen字段。在列表尾部添加元素比较方便，只需计算旧的尾部元素的字节数，再进行编码后存入新元素的prevlen字段，如下图所示：

在列表头部添加元素则比较复杂，因为会导致后续元素的prevlen字段发生改变，称为cascade update层叠更新，最坏情况下需要更新列表中所有元素的prevlen，__ziplistCascadeUpdate函数会遍历所有需要更新的元素。

/* ziplist.c */
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);
        if (p[rawlen] == ZIP_END) break;
        zipEntry(p+rawlen, &next);
        if (next.prevrawlen == rawlen) break;
        if (next.prevrawlensize < rawlensize) {
            offset = p-zl;
            // 需要更多内存空间
            extra = rawlensize-next.prevrawlensize;
            // 重新分配内存，zl可能和原来不一样
            zl = ziplistResize(zl,curlen+extra);
            // 新的p地址
            p = zl+offset;
            np = p+rawlen;
            noffset = np-zl;
            // 更新tail_offset
            if ((zl+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) != np) {
                ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+extra);
            }
            // 移动内存
            memmove(np+rawlensize,
                np+next.prevrawlensize,
                curlen-noffset-next.prevrawlensize-1);
            // 写入rawlen
            zipStorePrevEntryLength(np,rawlen);
            // 前进
            p += rawlen;
            curlen += extra;
        } else {
            if (next.prevrawlensize > rawlensize) {
                // 强制存5字节prevlen
                zipStorePrevEntryLengthLarge(p+rawlen,rawlen);
            } else {
                // 原地更新
                zipStorePrevEntryLength(p+rawlen,rawlen);
            }
            break;
        }
    }
    return zl;
}

思一缘

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
argumentoutofrangeexception:长度不能小于0_Redis5.0源码解析4 - 列表

Redis为列表结构提供了多种不同的实现，分为AdList、ZipList和QuickList三种。主要的代码在adlist.h、adlist.c、ziplist.h、ziplist.c、quicklist.h、quicklist.c和t_list.c这几个文件中。其中用户使用的lpush、rpush、llen、lrange、ltrim等list相关的命令都是用QuickList数据结构实现的。1...
复制链接

扫一扫