redis之listpack

最新推荐文章于 2024-05-30 15:02:48 发布
最新推荐文章于 2024-05-30 15:02:48 发布
阅读量2.7k 收藏 5
点赞数 4
分类专栏： redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happytree001/article/details/119685207
版权

一、简介

对于ziplist，实现复杂，为了逆序遍历，每个entry中包含前一个entry的长度，这样导致在ziplist中间修改或者插入entry时可能产生级联更新。为了实现更紧凑、更快的解析，更简单的实现，重写实现了ziplist,listpack由此诞生。

二、结构图

2.1 整体结构

请添加图片描述

  • 头比ziplist少了4字节
  • 每个元素中只有自己的总长度来实现逆序遍历，更新时不会出现级联更新

2.2 数据编码

元素编码分为三部分，encoding，data, element-total-len, 对于数字类型字符串在int64_t范围内的都可以编码为数字型，将无data字段，元素值存储在encoding中。

2.2.1 encoding编码

  • 整数
    请添加图片描述
  • 字符串
    请添加图片描述

2.2.2 element-total-len编码

element-total-len表示当前元素的总长度，用于逆序遍历listpack时使用。
请添加图片描述

  • 使用大端序
  • 逆序读取，从右往左逐字节读取
  • 每个字节只是用7bit表示数字，最高位表示是否还有数据，1表示还需要读取下一字节，0表示结束了

三、实现

3. 1 位操作定义

#define LP_HDR_SIZE 6       /* 32 bit total len + 16 bit number of elements. */
#define LP_HDR_NUMELE_UNKNOWN UINT16_MAX
#define LP_MAX_INT_ENCODING_LEN 9
#define LP_MAX_BACKLEN_SIZE 5
#define LP_MAX_ENTRY_BACKLEN 34359738367ULL
#define LP_ENCODING_INT 0
#define LP_ENCODING_STRING 1

#define LP_ENCODING_7BIT_UINT 0
#define LP_ENCODING_7BIT_UINT_MASK 0x80
#define LP_ENCODING_IS_7BIT_UINT(byte) (((byte)&LP_ENCODING_7BIT_UINT_MASK)==LP_ENCODING_7BIT_UINT)

#define LP_ENCODING_6BIT_STR 0x80
#define LP_ENCODING_6BIT_STR_MASK 0xC0
#define LP_ENCODING_IS_6BIT_STR(byte) (((byte)&LP_ENCODING_6BIT_STR_MASK)==LP_ENCODING_6BIT_STR)

#define LP_ENCODING_13BIT_INT 0xC0
#define LP_ENCODING_13BIT_INT_MASK 0xE0
#define LP_ENCODING_IS_13BIT_INT(byte) (((byte)&LP_ENCODING_13BIT_INT_MASK)==LP_ENCODING_13BIT_INT)

#define LP_ENCODING_12BIT_STR 0xE0
#define LP_ENCODING_12BIT_STR_MASK 0xF0
#define LP_ENCODING_IS_12BIT_STR(byte) (((byte)&LP_ENCODING_12BIT_STR_MASK)==LP_ENCODING_12BIT_STR)

#define LP_ENCODING_16BIT_INT 0xF1
#define LP_ENCODING_16BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_16BIT_INT(byte) (((byte)&LP_ENCODING_16BIT_INT_MASK)==LP_ENCODING_16BIT_INT)

#define LP_ENCODING_24BIT_INT 0xF2
#define LP_ENCODING_24BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_24BIT_INT(byte) (((byte)&LP_ENCODING_24BIT_INT_MASK)==LP_ENCODING_24BIT_INT)

#define LP_ENCODING_32BIT_INT 0xF3
#define LP_ENCODING_32BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_32BIT_INT(byte) (((byte)&LP_ENCODING_32BIT_INT_MASK)==LP_ENCODING_32BIT_INT)

#define LP_ENCODING_64BIT_INT 0xF4
#define LP_ENCODING_64BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_64BIT_INT(byte) (((byte)&LP_ENCODING_64BIT_INT_MASK)==LP_ENCODING_64BIT_INT)

#define LP_ENCODING_32BIT_STR 0xF0
#define LP_ENCODING_32BIT_STR_MASK 0xFF
#define LP_ENCODING_IS_32BIT_STR(byte) (((byte)&LP_ENCODING_32BIT_STR_MASK)==LP_ENCODING_32BIT_STR)

#define LP_EOF 0xFF

#define LP_ENCODING_6BIT_STR_LEN(p) ((p)[0] & 0x3F)
#define LP_ENCODING_12BIT_STR_LEN(p) ((((p)[0] & 0xF) << 8) | (p)[1])
#define LP_ENCODING_32BIT_STR_LEN(p) (((uint32_t)(p)[1]<<0) | \
                                      ((uint32_t)(p)[2]<<8) | \
                                      ((uint32_t)(p)[3]<<16) | \
                                      ((uint32_t)(p)[4]<<24))

#define lpGetTotalBytes(p)           (((uint32_t)(p)[0]<<0) | \
                                      ((uint32_t)(p)[1]<<8) | \
                                      ((uint32_t)(p)[2]<<16) | \
                                      ((uint32_t)(p)[3]<<24))

#define lpGetNumElements(p)          (((uint32_t)(p)[4]<<0) | \
                                      ((uint32_t)(p)[5]<<8))
#define lpSetTotalBytes(p,v) do { \
    (p)[0] = (v)&0xff; \
    (p)[1] = ((v)>>8)&0xff; \
    (p)[2] = ((v)>>16)&0xff; \
    (p)[3] = ((v)>>24)&0xff; \
} while(0)

#define lpSetNumElements(p,v) do { \
    (p)[4] = (v)&0xff; \
    (p)[5] = ((v)>>8)&0xff; \
} while(0)

3.2 创建一个空的listpack

unsigned char *lpNew(void) {
    unsigned char *lp = lp_malloc(LP_HDR_SIZE+1);
    if (lp == NULL) return NULL;
    lpSetTotalBytes(lp,LP_HDR_SIZE+1);
    lpSetNumElements(lp,0);
    lp[LP_HDR_SIZE] = LP_EOF;
    return lp;
}

请添加图片描述

3.3 插入

  • 插入：p之前和p之后，实际插入时，都会转换为p’之前

3.3.1 例1.结尾插入“123”, len=3

1. 计算插入位置
unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size) {
    uint64_t listpack_bytes = lpGetTotalBytes(lp);
    unsigned char *eofptr = lp + listpack_bytes - 1;
    return lpInsert(lp,ele,size,eofptr,LP_BEFORE,NULL);
}

请添加图片描述

2. 转换插入方式

如果是插入p之后，将跳过当前节点，指向下一个节点p`，然后插入p`之前

  if (where == LP_AFTER) {
        p = lpSkip(p);
        where = LP_BEFORE;
    }

本例中是插入之前，所以不需要

3. 计算插入位置的偏移量

用于后续扩容后，重写定位到插入位置

 unsigned long poff = p-lp;

本例中poff = 6

4. 获取编码类型
  • 尝试将插入的值转换位int64_t的数值，如果成功，则使用整数进行编码
  • 否则使用字符串编码
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
    int64_t v;
    if (lpStringToInt64((const char*)ele, size, &v)) {
        if (v >= 0 && v <= 127) {
            /* Single byte 0-127 integer. */
            intenc[0] = v;
            *enclen = 1;
        } else if (v >= -4096 && v <= 4095) {
            /* 13 bit integer. */
            if (v < 0) v = ((int64_t)1<<13)+v;
            intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
            intenc[1] = v&0xff;
            *enclen = 2;
        } else if (v >= -32768 && v <= 32767) {
            /* 16 bit integer. */
            if (v < 0) v = ((int64_t)1<<16)+v;
            intenc[0] = LP_ENCODING_16BIT_INT;
            intenc[1] = v&0xff;
            intenc[2] = v>>8;
            *enclen = 3;
        } else if (v >= -8388608 && v <= 8388607) {
            /* 24 bit integer. */
            if (v < 0) v = ((int64_t)1<<24)+v;
            intenc[0] = LP_ENCODING_24BIT_INT;
            intenc[1] = v&0xff;
            intenc[2] = (v>>8)&0xff;
            intenc[3] = v>>16;
            *enclen = 4;
        } else if (v >= -2147483648 && v <= 2147483647) {
            /* 32 bit integer. */
            if (v < 0) v = ((int64_t)1<<32)+v;
            intenc[0] = LP_ENCODING_32BIT_INT;
            intenc[1] = v&0xff;
            intenc[2] = (v>>8)&0xff;
            intenc[3] = (v>>16)&0xff;
            intenc[4] = v>>24;
            *enclen = 5;
        } else {
            /* 64 bit integer. */
            uint64_t uv = v;
            intenc[0] = LP_ENCODING_64BIT_INT;
            intenc[1] = uv&0xff;
            intenc[2] = (uv>>8)&0xff;
            intenc[3] = (uv>>16)&0xff;
            intenc[4] = (uv>>24)&0xff;
            intenc[5] = (uv>>32)&0xff;
            intenc[6] = (uv>>40)&0xff;
            intenc[7] = (uv>>48)&0xff;
            intenc[8] = uv>>56;
            *enclen = 9;
        }
        return LP_ENCODING_INT;
    } else {
        if (size < 64) *enclen = 1+size;
        else if (size < 4096) *enclen = 2+size;
        else *enclen = 5+size;
        return LP_ENCODING_STRING;
    }
}

本例中“123”可以转换为123， 并且123 在[0,127]范围内，所以只需一字节表示
intenc[0] = 123(01111011);*enclen = 1;
请添加图片描述

5. 获取插入元素的总长度编码
unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
    if (l <= 127) {
        if (buf) buf[0] = l;
        return 1;
    } else if (l < 16383) {
        if (buf) {
            buf[0] = l>>7;
            buf[1] = (l&127)|128;
        }
        return 2;
    } else if (l < 2097151) {
        if (buf) {
            buf[0] = l>>14;
            buf[1] = ((l>>7)&127)|128;
            buf[2] = (l&127)|128;
        }
        return 3;
    } else if (l < 268435455) {
        if (buf) {
            buf[0] = l>>21;
            buf[1] = ((l>>14)&127)|128;
            buf[2] = ((l>>7)&127)|128;
            buf[3] = (l&127)|128;
        }
        return 4;
    } else {
        if (buf) {
            buf[0] = l>>28;
            buf[1] = ((l>>21)&127)|128;
            buf[2] = ((l>>14)&127)|128;
            buf[3] = ((l>>7)&127)|128;
            buf[4] = (l&127)|128;
        }
        return 5;
    }
}

因为上一步骤计算出来总长度为1字节，1<= 127满足，所以总长度编码也只需要1字节，backlen_size=1
请添加图片描述

6. 计算新的整个listpack总长度
uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
                                  - replaced_len;
if (new_listpack_bytes > UINT32_MAX) return NULL;

本例中是插入，所以replaced_len=0，old_listpack_bytes为原始的总长度7，new_listpack_bytes=7 + 1 + 1 - 0 = 9

7. 获取插入目标位置
 unsigned char *dst = lp + poff; /* May be updated after reallocation. */

请添加图片描述

8. 扩容
/* Realloc before: we need more room. */
if (new_listpack_bytes > old_listpack_bytes) {
   if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
   dst = lp + poff;
}

请添加图片描述

9. 移动数据，以腾出插入位置
if(where == LP_BEFORE) {
     memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
 }

mommove(dst+1+1,dst, 7 - 6) -> mommove(dst+2, dst, 1)
请添加图片描述

10. 写入encoding以及data
if (enctype == LP_ENCODING_INT) {
    memcpy(dst,intenc,enclen);
}
dst += enclen;

请添加图片描述

11. 写入插入节点totallen
memcpy(dst,backlen,backlen_size);
dst += backlen_size;

请添加图片描述

12. 更新元素个数
  • ele为空，则表示删除节点
 /* Update header. */
 if (where != LP_REPLACE || ele == NULL) {
     uint32_t num_elements = lpGetNumElements(lp);
     if (num_elements != LP_HDR_NUMELE_UNKNOWN) {
         if (ele)
             lpSetNumElements(lp,num_elements+1);
         else
             lpSetNumElements(lp,num_elements-1);
     }
 }

请添加图片描述

13. 更新整个listpakc总长度
lpSetTotalBytes(lp,new_listpack_bytes);

请添加图片描述

3.3.2 例2. 尾部插入“I love redis …”， len=200

1. 计算插入位置

请添加图片描述

2. 转换插入方式

如果是插入p之后，将跳过当前节点，指向下一个节点p`，然后插入p`之前
本例中是插入之前，所以不需要

3. 计算插入位置的偏移量

poff=8

4. 获取编码类型
  • 尝试将插入的值转换位int64_t的数值，如果成功，则使用整数进行编码
  • 否则使用字符串编码
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
    int64_t v;
    if (lpStringToInt64((const char*)ele, size, &v)) {
        ...
        return LP_ENCODING_INT;
    } else {
        if (size < 64) *enclen = 1+size;
        else if (size < 4096) *= 2+size;
        else *enclen = 5+size;
        return LP_ENCODING_STRING;
    }
}

本例中不能转为数值，长度200在[64, 4096), 所以需要2字节编码
*enclen = 2 + 200 = 202

5. 获取插入元素的总长度编码

202 在(127, 16383), 所以需要2字节，backlen_size=2

6. 计算新的整个listpack总长度

new_listpack_bytes = 9 + 202 + 2 - 0 = 213

7. 获取插入目标位置

请添加图片描述

8. 扩容

请添加图片描述

9. 移动数据，以腾出插入位置

memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
memmove(dst+202+2,dst, 9-8) -> mommove(dst+204, dst, 1)
请添加图片描述

10. 写入encoding以及data
void lpEncodeString(unsigned char *buf, unsigned char *s, uint32_t len) {
    if (len < 64) {
        buf[0] = len | LP_ENCODING_6BIT_STR;
        memcpy(buf+1,s,len);
    } else if (len < 4096) {
        buf[0] = (len >> 8) | LP_ENCODING_12BIT_STR;
        buf[1] = len & 0xff;
        memcpy(buf+2,s,len);
    } else {
        buf[0] = LP_ENCODING_32BIT_STR;
        buf[1] = len & 0xff;
        buf[2] = (len >> 8) & 0xff;
        buf[3] = (len >> 16) & 0xff;
        buf[4] = (len >> 24) & 0xff;
        memcpy(buf+5,s,len);
    }
}

if (enctype == LP_ENCODING_INT) {
    memcpy(dst,intenc,enclen);
} else {
    lpEncodeString(dst,ele,size);
}
dst += enclen;

字符串200在[64,4096)范围内，所以需要两个字节
请添加图片描述

11. 写入插入节点totallen

总长度202（11001010）-> 0000001, 1001010
请添加图片描述

12. 更新元素个数

请添加图片描述
lpSetNumElements(lp,num_elements+1);

13. 更新整个listpakc总长度

请添加图片描述

3.4 逆序遍历

unsigned char *ele = lpLast(lp);
while (ele) {
    ele = lpPrev(lp,ele);
}
  1. 定位到结尾
  2. 读取element-total-len，获取元素总长度elem-len
  3. 根据读取的elem-len，往前移elem-len，到元素开头
  4. 重复步骤2.和3.
unsigned char *lpPrev(unsigned char *lp, unsigned char *p) {
    if (p-lp == LP_HDR_SIZE) return NULL;
    p--; /* Seek the first backlen byte of the last element. */
    uint64_t prevlen = lpDecodeBacklen(p);
    prevlen += lpEncodeBacklen(NULL,prevlen);
    return p-prevlen+1; /* Seek the first byte of the previous entry. */
}

unsigned char *lpLast(unsigned char *lp) {
    unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
    return lpPrev(lp,p); /* Will return NULL if EOF is the only element. */
}
  • 定位到结尾
    请添加图片描述
unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
  • 判断是否有数据，必须大于头长度
if (p-lp == LP_HDR_SIZE) return NULL;
  • 定位到最后一个元素最后一个字节
p--; /* Seek the first backlen byte of the last element. */

请添加图片描述

  • 计算元素总长度
uint64_t prevlen = lpDecodeBacklen(p);

uint64_t lpDecodeBacklen(unsigned char *p) {
    uint64_t val = 0;
    uint64_t shift = 0;
    do {
        val |= (uint64_t)(p[0] & 127) << shift;
        if (!(p[0] & 128)) break; //判断最好位是否1，是1则表示还需要继续读取
        shift += 7;
        p--; //读取前一个字节
        if (shift > 28) return UINT64_MAX;
    } while(1);
    return val;
}

这里 1001010 | （1<<7） = 11001010 = 202
请添加图片描述

  • 根据计算到的元素总长度，进行计算长度编码字段
prevlen += lpEncodeBacklen(NULL,prevlen);

unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
    if (l <= 127) {
        if (buf) buf[0] = l;
        return 1;
    } else if (l < 16383) {
        if (buf) {
            buf[0] = l>>7;
            buf[1] = (l&127)|128;
        }
        return 2;
    } 
    ...
}

总长度202，长度编码2字节， 所以prevlen=202+2=204

  • 偏移到元素开始
return p-prevlen+1; /* Seek the first byte of the previous entry. */

请添加图片描述

  • 重复上述步骤
  • 判断是否还有元素
    if (p-lp == LP_HDR_SIZE) return NULL; 本例中还有数据
  • 往前移动一字节
    p--; /* Seek the first backlen byte of the last element. */
    请添加图片描述
  • 计算元素数据总长度
    00000001, 因此元素1字节
  • 计算长度编码字节数
    1字节长度只需要1字节表示，prevlen = 1+ 1 = 2
  • 偏移到元素开头
    请添加图片描述
  • 重复
  • 判断是否还有元素
if (p-lp == LP_HDR_SIZE) return NULL;

这里刚好等于头长度，所以没元素了

3.5 替换

3.5.1 例1. 将第一个元素替换成“-32767”

1. 计算偏移量
unsigned long poff = p-lp;

请添加图片描述
poff = p - lp = header = 6

2. 计算替换数据“-32767”的编码
if (ele) {
     enctype = lpEncodeGetType(ele,size,intenc,&enclen);
  • "-32767"可以转换为int64_t范围内，所以使用整数编码
  • -32767在范围 [-32768, 32767]中，所以需要3字节编码
  • 因为是负数，所以需要转换为正数数if (v < 0) v = ((int64_t)1<<16)+v;， v = 32769
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
  int64_t v;
   if (lpStringToInt64((const char*)ele, size, &v)) {
       if (v >= 0 && v <= 127) {
           /* Single byte 0-127 integer. */
           intenc[0] = v;
           *enclen = 1;
       } else if (v >= -4096 && v <= 4095) {
           /* 13 bit integer. */
           if (v < 0) v = ((int64_t)1<<13)+v;
           intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
           intenc[1] = v&0xff;
           *enclen = 2;
       } else if (v >= -32768 && v <= 32767) {
           /* 16 bit integer. */
           if (v < 0) v = ((int64_t)1<<16)+v;
           intenc[0] = LP_ENCODING_16BIT_INT;
           intenc[1] = v&0xff;
           intenc[2] = v>>8;
           *enclen = 3;
       } 
       ...
       return LP_ENCODING_INT;
   }
   ...
}

请添加图片描述

3. 计算元素长度需要的长度编码
unsigned long backlen_size = ele ? lpEncodeBacklen(backlen,enclen) : 0;

当前enclen=3，在[0,127] 范围内，所以只需要1字节， backlen_size=1
请添加图片描述

4. 计算需要替换元素的总长度
uint32_t replaced_len  = 0;
if (where == LP_REPLACE) {
    replaced_len = lpCurrentEncodedSize(p);
    replaced_len += lpEncodeBacklen(NULL,replaced_len);
}

本例中第一个元素2字节长度， 所以replaced_len=2

5. 计算新的总大小
 uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
                                  - replaced_len;

new_listpack_bytes = 0xD5 + 3 + 1 - 2 = 0xD5 + 2 = 0xD7

6. 计算目标位置
unsigned char *dst = lp + poff; /* May be updated after reallocation. */

dst = lp + poff = lp + 6

7. 扩容
/* Realloc before: we need more room. */
if (new_listpack_bytes > old_listpack_bytes) {
    if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
    dst = lp + poff;
}

替换后，长度增加了，所以需要扩容
请添加图片描述

8.数据移动
/* LP_REPLACE. */
long lendiff = (enclen+backlen_size)-replaced_len;
memmove(dst+replaced_len+lendiff,
        dst+replaced_len,
        old_listpack_bytes-poff-replaced_len);

lendiff=(3+1)-2=2
memmove(dst+2+2,dst+2,0xD5-6-2) -> memmove(dst+4, dst+2, 205)
请添加图片描述

9. 写入数据
if (enctype == LP_ENCODING_INT) {
    memcpy(dst,intenc,enclen);
} else {
    lpEncodeString(dst,ele,size);
}
dst += enclen;

这里是整数
请添加图片描述

10. 写入元素长度编码
 memcpy(dst,backlen,backlen_size);
dst += backlen_size;

请添加图片描述

11. 更新元素个数

不需要，未插入或者删除

12. 更新总长度
lpSetTotalBytes(lp,new_listpack_bytes);

请添加图片描述

3.6 删除

删除和替换以及插入差不多，只是elem参数为null,并且删除操作就是replace操作

unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp) {
    return lpInsert(lp,NULL,0,p,LP_REPLACE,newp);
}

3.6.1 例1. 删除第二个元素

首先通过p = lpSeek(lp, 1) ;获取删除元素首指针

1. 设置方式为replace

ele为空，则表示删除，删除方式只能是replace

 if (ele == NULL) where = LP_REPLACE;
2. 计算偏移量
unsigned long poff = p-lp;

poff = p - lp = 10
请添加图片描述

3. 设置数据编码长度
enctype = -1;
enclen = 0;
4. 设置长度编码
backlen_size = 0
5. 计算删除元素的总长度
if (where == LP_REPLACE) {
    replaced_len = lpCurrentEncodedSize(p);
    replaced_len += lpEncodeBacklen(NULL,replaced_len);
}

本例中，总长度replaced_len = 202+2 = 204

6. 计算删除后新的总长度
uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
                                  - replaced_len;

new_listpack_bytes = 0xD7 + 0 + 0 - 204 = 11

7. 计算目标地址
unsigned char *dst = lp + poff; /* May be updated after reallocation. */

请添加图片描述

8. 移动数据
long lendiff= (enclen+backlen_size)-replaced_len;
memmove(dst+replaced_len+lendiff,
        dst+replaced_len,
        old_listpack_bytes-poff-replaced_len);

lendiff = (0+0)-204=-204
memmove(dst+204+(-204), dst+204, 0xD7-10-204) -> memmove(dst, dst+204, 1)
请添加图片描述

9. 缩容
/* Realloc after: we need to free space. */
if (new_listpack_bytes < old_listpack_bytes) {
    if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
    dst = lp + poff;
}

请添加图片描述

10. 更新元素个数
lpSetNumElements(lp,num_elements-1);

请添加图片描述

11. 更新总长度
lpSetTotalBytes(lp,new_listpack_bytes);

请添加图片描述

3.7 定位到index的元素

  • index如果是负数，则逆序定位
  • 如果index
unsigned char *lpSeek(unsigned char *lp, long index) {
    int forward = 1; /* Seek forward by default. */

    /* We want to seek from left to right or the other way around
     * depending on the listpack length and the element position.
     * However if the listpack length cannot be obtained in constant time,
     * we always seek from left to right. */
    uint32_t numele = lpGetNumElements(lp);
    if (numele != LP_HDR_NUMELE_UNKNOWN) {
        if (index < 0) index = (long)numele+index;
        if (index < 0) return NULL; /* Index still < 0 means out of range. */
        if (index >= numele) return NULL; /* Out of range the other side. */
        /* We want to scan right-to-left if the element we are looking for
         * is past the half of the listpack. */
        if (index > numele/2) {
            forward = 0;
            /* Right to left scanning always expects a negative index. Convert
             * our index to negative form. */
            index -= numele;
        }
    } else {
        /* If the listpack length is unspecified, for negative indexes we
         * want to always scan right-to-left. */
        if (index < 0) forward = 0;
    }

    /* Forward and backward scanning is trivially based on lpNext()/lpPrev(). */
    if (forward) {
        unsigned char *ele = lpFirst(lp);
        while (index > 0 && ele) {
            ele = lpNext(lp,ele);
            index--;
        }
        return ele;
    } else {
        unsigned char *ele = lpLast(lp);
        while (index < -1 && ele) {
            ele = lpPrev(lp,ele);
            index++;
        }
        return ele;
    }
}

3.8 获取值

unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
    int64_t val;
    uint64_t uval, negstart, negmax;

    if (LP_ENCODING_IS_7BIT_UINT(p[0])) {
        negstart = UINT64_MAX; /* 7 bit ints are always positive. */
        negmax = 0;
        uval = p[0] & 0x7f;
    } else if (LP_ENCODING_IS_6BIT_STR(p[0])) {
        *count = LP_ENCODING_6BIT_STR_LEN(p);
        return p+1;
    } else if (LP_ENCODING_IS_13BIT_INT(p[0])) {
        uval = ((p[0]&0x1f)<<8) | p[1];
        negstart = (uint64_t)1<<12;
        negmax = 8191;
    } else if (LP_ENCODING_IS_16BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8;
        negstart = (uint64_t)1<<15;
        negmax = UINT16_MAX;
    } else if (LP_ENCODING_IS_24BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16;
        negstart = (uint64_t)1<<23;
        negmax = UINT32_MAX>>8;
    } else if (LP_ENCODING_IS_32BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16 |
               (uint64_t)p[4]<<24;
        negstart = (uint64_t)1<<31;
        negmax = UINT32_MAX;
    } else if (LP_ENCODING_IS_64BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16 |
               (uint64_t)p[4]<<24 |
               (uint64_t)p[5]<<32 |
               (uint64_t)p[6]<<40 |
               (uint64_t)p[7]<<48 |
               (uint64_t)p[8]<<56;
        negstart = (uint64_t)1<<63;
        negmax = UINT64_MAX;
    } else if (LP_ENCODING_IS_12BIT_STR(p[0])) {
        *count = LP_ENCODING_12BIT_STR_LEN(p);
        return p+2;
    } else if (LP_ENCODING_IS_32BIT_STR(p[0])) {
        *count = LP_ENCODING_32BIT_STR_LEN(p);
        return p+5;
    } else {
        uval = 12345678900000000ULL + p[0];
        negstart = UINT64_MAX;
        negmax = 0;
    }

    /* We reach this code path only for integer encodings.
     * Convert the unsigned value to the signed one using two's complement
     * rule. */
    if (uval >= negstart) {
        /* This three steps conversion should avoid undefined behaviors
         * in the unsigned -> signed conversion. */
        uval = negmax-uval;
        val = uval;
        val = -val-1;
    } else {
        val = uval;
    }

    /* Return the string representation of the integer or the value itself
     * depending on intbuf being NULL or not. */
    if (intbuf) {
        *count = snprintf((char*)intbuf,LP_INTBUF_SIZE,"%lld",(long long)val);
        return intbuf;
    } else {
        *count = val;
        return NULL;
    }
}

uval = (uint64_t)p[1] |(uint64_t)p[2]<<8 = (00000001) | (10000000)<<8 = 32769
negstart = (uint64_t)1<<15 = 32768
negmax = UINT16_MAX

uval > negstart 成立， 所以源数据为负数
uval = negmax-uval = 65535 - 32769 = 32766
val = uval = 32766
val = -val -1 = -32767， 和元素数据一致。

happytree001
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
redis 7.0.0 windows版
05-07
3. 在读取老的RDB文件格式的时候将ziplist转换为listpack，这种转换发生于两种情况之下：从磁盘读取文件或者从一个主节点进行复制文件的时候。 4. 在redis.conf配置文件中，protected-mode 默认更改为yes，只有当你...
Redis 7.0.2 for Windows
06-15
3. 在读取老的RDB文件格式的时候将ziplist转换为listpack，这种转换发生于两种情况之下：从磁盘读取文件或者从一个主节点进行复制文件的时候。 4. 在redis.conf配置文件中，protected-mode 默认更改为yes，只有当你...
redis底层数据结构---listpack
m0_58438555的博客
02-21 1808
listpack介绍 Redis 在 5.0 新设计一个数据结构叫 listpack，目的是替代压缩列表，它最大特点是 listpack 中每个节点不再包含前一个节点的长度，压缩列表每个节点正因为需要保存前一个节点的长度字段，就会有连锁更新的隐患。 listpack结构设计 listpack 采用了压缩列表的很多优秀的设计，比如还是用一块连续的内存空间来紧凑地保存数据，并且为了节省内存的开销，listpack 节点会采用不同的编码方式保存不同大小的数据。 listpack 有四个参数 总字节数 元素数量
【Redis】ziplist与listpack源码剖析：Redis数据存储的演进与优化
最新发布
白晨的博客
05-30 1135
ziplist是一种紧凑的字节数组数据结构，适用于存储小型列表。zlbytes：总字节数（4字节）。zltail：到列表尾节点的偏移量（4字节）。zllen：节点数量（2字节）。entry：实际存储的节点。zlend：结束标记（1字节，值为 0xFF）。每个节点包括prevlen（前一个节点的长度）、encoding（编码方式）和entry-data（实际存储内容）。
Redis7.0代码分析总结之：底层数据结构listpack实现原理
后端技术交流
03-21 1957
文章目录一、前言二、实现原理2.1 、内存结构2.2、 数据存储编码方案2.3、 backlen长度编码方案三、主要API介绍3.1、插入、更新、删除3.2、查找、遍历四、Redis内部应用五、总结 一、前言       listpack压缩列表。作为ziplist的替代品，从2017年引入Redis后，到redis7.0已经完全取代ziplist 作为redis底层存储数据结构之一。      &
listpack如何遍历？如何解决ziplist连锁更新问题？(五)
小派师兄
08-28 1388
listpack如何遍历？，如何解决ziplist连锁更新问题？(五)
【高阶篇】3.8 Redis之底层数据结构链表包(listpacks)详解
日拱一卒无有尽，功不唐捐终入海
06-16 1145
本文将Redis底层数据结构 listpacks（链表包）详解，它用于实现列表数据类型。listpacks是一种紧凑的连续内存块，其设计目标是减少内存的占用，通过紧凑的内存布局和多种数据类型的编码方式，提供了高效的插入和删除操作。| zlbytes | 4字节，列表总字节数| zltail | 4字节，列表尾节点偏移量| zllen | 2字节，列表节点数量。
Redis 7.0.4 for Windows
07-27
3. 在读取老的RDB文件格式的时候将ziplist转换为listpack，这种转换发生于两种情况之下：从磁盘读取文件或者从一个主节点进行复制文件的时候。 4. 在redis.conf配置文件中，protected-mode 默认更改为yes，只有当你...
Redis-x64-7.0.12-windows11
07-26
简言之，redis自己要去抢夺Lua脚本的饭碗； 7）RDB保存时间调整：将持久化文件RDB的保存规则发生了改变，尤其是时间记录频度变化； 8）命令新增和变动：Zset (有序集合)增加 ZMPOP、BZMPOP、ZINTERCARD 等命令Set ...
Redis 7.0.3 for Windows
07-12
3. 在读取老的RDB文件格式的时候将ziplist转换为listpack，这种转换发生于两种情况之下：从磁盘读取文件或者从一个主节点进行复制文件的时候。 4. 在redis.conf配置文件中，protected-mode 默认更改为yes，只有当你...
Redis哈希对象（listpack介绍）
weixin_57023347的博客
11-30 835
listpack(紧凑列表)时Redis5版本出现的，作用是为了代替ziplist。Redis7.0版本之后，listpack就完全替代了ziplist。ziplist的缺点是，在极端的情况下，可能会出现连锁更新的情况，时间复杂度是O(N^2)，会带来不小的性能消耗。Redis压缩列表-CSDN博客虽然Redis在3.0版本后使用quicklist，通过quicklistNode来控制ziplist的大小和元素的个数，减少连锁更新带来的性能问题，但是它并没有避免连锁更新，使用的还是ziplist。
【学习笔记】Redis数据结构梳理（一）：SDS、list、ziplist、quicklist、listpack
Left_Zzzz的博客
03-10 708
本文对Redis数据结构：SDS、list、ziplist、quicklist、listpack进行了知识梳理。
Redis - ziplist (压缩列表) 图文详解
热门推荐
一七令
05-30 1万+
List列表是简单的字符串列表，按照插入顺序排序，可以从头部或尾部向List列表添加元素。最大长度为2^32-1，也即每个列表支持超过40亿个元素。Redis的List类型有多种实现方式，由双向链表或压缩列表（v7.0由listpack替代）实现的。这篇文章就是介绍其中一种实现ziplist-压缩列表。ziplist为了节省内存，采用了紧凑的连续存储。所以在修改操作下并不能像一般的链表那么容易，需要从新分配新的内存，然后复制到新的空间。httpshttps。............
「Redis数据结构」压缩列表（ZipList）
frozenpenguin的博客
11-19 3847
压缩列表的最大特点，就是它被设计成一种内存紧凑型的数据结构，占用一块连续的内存空间，不仅可以利用 CPU 缓存，而且会针对不同长度的数据，进行相应编码，这种方法可以有效地节省内存开销。但是，压缩列表的缺陷不能保存过多的元素，否则查询效率就会降低；新增或修改某个元素时，压缩列表占用的内存空间需要重新分配，甚至可能引发连锁更新的问题。因此，Redis 对象（List 对象、Hash 对象、Zset 对象）包含的元素数量较少，或者元素值不大的情况才会使用压缩列表作为底层数据结构。
Redis 源码解析 - Redis listpack 源码解析
qq_33240556的博客
05-06 416
Redis Listpack（也称为LPACK）是一种紧凑的数据结构，用于高效存储序列化的数据，如列表（Lists）、集合（Sets）、有序集合（Sorted Sets）等。Listpack设计于Redis 5.0，作为一种更高效的替代方案，旨在解决压缩列表（ziplist）存在的问题，如内存效率和连锁更新问题。
【Redis核心原理和应用实践】源码 6：极度深寒 —— 探索「 紧凑列表」内部
通往神秘的道路的专栏
12-29 218
Redis 5.0 又引入了一个新的数据结构 listpack，它是对 ziplist 结构的改进，在存储空间上会更加节省，而且结构上也比 ziplist 要精简。它的整体形式和 ziplist 还是比较接近的，如果你认真阅读了 ziplist 的内部结构分析，那么 listpack 也是比较容易理解的。 struct listpack<T> { int32 total_...
Redis设计核心-1-Redis底层数据结构总结2
yqxz045000的博客
06-09 327
前言 最近看了相关的Redis设计核心相关的书籍，对Redis有了一些小的认识，然后自己也做一些产出加深映象，我会从几个方面去总结Redis设计的核心内容：Redis底层数据结构总结、Redis高性能由哪些基础支撑、Redis应用场景、那些有趣的功能。 概述 本篇主要内容是Redis底层数据结构总结。Redis供用户直接使用的数据结构有String、List、Set、Zset、Hash等结...
漫话Redis源码之五十三
认知 行动 坚持
01-09 295
/* Listpack -- A lists of strings serialization format * * This file implements the specification you can find at: * * https://github.com/antirez/listpack * * Copyright (c) 2017, Salvatore Sanfilippo <antirez at gmail dot com> * Copyrigh...
NoSQL 之Redis集群
06-09
Redis是一种基于内存的键值存储系统，它可以用作数据库、缓存和消息中间件。Redis支持多种数据结构，如字符串、哈希表、列表、集合、有序集合等。Redis集群是Redis提供的高可用性解决方案，它通过将数据分散到多个节点上来实现数据的可靠性和可扩展性。 Redis集群采用分片技术来实现数据的分散存储，每个节点存储部分数据，而客户端通过集群代理来访问数据。Redis集群的每个节点都是一个完整的Redis实例，每个节点都可以处理客户端请求和复制数据到其它节点。Redis集群还提供了自动故障转移和节点扩容功能，当一个节点失效时，集群会自动将其它节点上的数据迁移到新的节点上，从而保证数据的可靠性和可用性。 Redis集群的部署需要考虑多个因素，如节点数、数据分片、故障转移配置等。可以使用Redis官方提供的redis-trib工具来进行集群的创建和管理。同时，为了保证Redis集群的性能和可靠性，还需要进行监控和调优。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值