redis基本数据结构之动态字符串(SDS)

 SDS (Simple Dynamic Strings) 是redis 用于存储字符串的数据结构,有以下几个特性:

  • 二进制安全
  • 兼容C语言标准字符串处理函数
  • 节省空间

二进制安全

C语言中用'\0'表示字符串结尾,如果字符串内容含有'\0',就会提前截断(非二进制安全),redis 使用一个变量存放字符串长度,另一个字符柔性数组存放字符串实际内容,读取时根据len变量确定长度,不会出现截断:

redis基本数据结构之动态字符串(SDS)_第1张图片

 

兼容C语言标准

SDS 对外暴露buf的指针,而不是结构体的起始地址,上层可以类似处理C语言字符串一样处理SDS字符串。

结构体使用了柔性数组,这种数组是可伸缩的,之所以使用柔性数组是因为数组地址和结构体地址是连续的,如图:

redis基本数据结构之动态字符串(SDS)_第2张图片

 这样就可以通过数组的地址定位到结构体地址,从而获取到其他变量的值(参考用于获取字符串长度的sdslen 函数)

节省空间

不是所有长度的字符串都用相同的结构存放,redis中SDS 根据长度分为5种类型:

  • sdshdr5:长度 < 2^5 - 1
  • sdshdr8:长度 < 2^8 - 1
  • sdshdr16:长度 < 2^16 - 1
  • sdshdr32:长度 < 2^32  - 1
  • sdshdr64 : 长度 < 2^64 - 1

实际结构如下:

struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {                      
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

len表示buf中已占字节数,alloc表示buf中分配字节数,flags 表示字符串类型,buf存放实际字符串内容,当字符串长度小于32字节时,甚至用一个int变量flags同时表示了字符串类型和长度,存储空间节省到了极致。

flags中只有低3位存放类型,高5位对于sdshdr5 用作存放长度,其余类型作为预留字段。

当获取一个sds变量长度时,需要先找到flags变量,然后判断sds是5中类型中哪一种,再进一步获取len变量的值:

#define SDS_TYPE_5  0    
#define SDS_TYPE_8  1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4
#define SDS_TYPE_MASK 7
#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
static inline size_t sdslen(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8:
            return SDS_HDR(8,s)->len;        
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->len;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->len;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->len;
    }
    return 0;
}

sdslen的入参s指向柔性数组buf的地址,因为buf和结构体地址连续,所以可以通过s[-1] 获得flags变量,判断类型时,只取flags的低3位,进而获取到sds头部结构的大小,然后用buf - 头部大小获取到sds的起始地址,再读取len变量。

每个字符串结构都用 __attribute__ ((__packed__)) 修改对齐方式,加上修饰后,结构体会按1字节对齐,这样才能通过buf变量的地址 -1 获取到flags地址,效果如图:

redis基本数据结构之动态字符串(SDS)_第3张图片

字符串基本操作

sds字符串基本操作有创建、释放、拼接等

字符串创建

代码位于sds.c 文件 _sdsnewlen 函数

sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {          
    void *sh;
    sds s;
    char type = sdsReqType(initlen);  // 根据长度判断用哪种类型
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;  // 如果是空串,为了应对可能的扩容,直接用sdshdr8类型
    int hdrlen = sdsHdrSize(type);  // 头部长度
    unsigned char *fp; /* flags pointer. */
    size_t usable;

    assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
    sh = trymalloc?
        s_trymalloc_usable(hdrlen+initlen+1, &usable) :
        s_malloc_usable(hdrlen+initlen+1, &usable);
    if (sh == NULL) return NULL;
    if (init==SDS_NOINIT)
        init = NULL;
    else if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    s = (char*)sh+hdrlen;  // buf 数组地址
    fp = ((unsigned char*)s)-1;  // flags变量地址
    usable = usable-hdrlen-1;
    if (usable > sdsTypeMaxSize(type))
        usable = sdsTypeMaxSize(type);
    switch(type) {  // 根据不同类型初始化结构体
        case SDS_TYPE_5: {
            *fp = type | (initlen << SDS_TYPE_BITS);
            break;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        }
        case SDS_TYPE_16: {
            SDS_HDR_VAR(16,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        case SDS_TYPE_32: {
            SDS_HDR_VAR(32,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        case SDS_TYPE_64: {
            SDS_HDR_VAR(64,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
    }
    if (initlen && init)
        memcpy(s, init, initlen);  // 将字符串写入buf
    s[initlen] = '\0';  // 末尾添加\0
    return s;  // 对外返回buf地址                         
}

主要操作是根据长度判断用那种类型sds结构,然后初始化结构体,最后对外返回buf数组的地址。

字符串释放

void sdsfree(sds s) {                      
    if (s == NULL) return;
    s_free((char*)s-sdsHdrSize(s[-1]));
}

sds 还提供字符串置空函数,仅将字符串内容清空,避免重复内存释放/申请的操作

void sdsclear(sds s) { 
    sdssetlen(s, 0);
    s[0] = '\0';
}

字符串拼接

sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);
    sdssetlen(s, curlen+len);
    s[curlen+len] = '\0';
    return s;
}

主要通过sdsMakeRoomFor 函数为buf数据分配好足以放下len个字节的空间,如果已有空间不够则需要重新申请内存并迁移原sds内容到新的空间,然后再做拼接。

sds sdsMakeRoomFor(sds s, size_t addlen) {
    void *sh, *newsh;
    size_t avail = sdsavail(s);  // 当前字符串可用空间,一般是alloc - len
    size_t len, newlen, reqlen;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;
    size_t usable;

    /* Return ASAP if there is enough space left. */
    if (avail >= addlen) return s;

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);  // 原sds结构体起始地址
    reqlen = newlen = (len+addlen);
    assert(newlen > len);   /* Catch size_t overflow */
    if (newlen < SDS_MAX_PREALLOC)  //  小于1M时翻倍扩容,大于1M时每次新增1M
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;
        newlen += SDS_MAX_PREALLOC;                                           

    type = sdsReqType(newlen);

    /* Don't use type 5: the user is appending to the string and type 5 is
     * not able to remember empty space, so sdsMakeRoomFor() must be called
     * at every appending operation. */
    if (type == SDS_TYPE_5) type = SDS_TYPE_8;  // 为避免频繁扩容,直接用type8

    hdrlen = sdsHdrSize(type);
    assert(hdrlen + newlen + 1 > reqlen);  /* Catch size_t overflow */
    if (oldtype==type) {  // 新的字符串类型没变,直接在原地址空间上分配空间
        newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {  // 新的字符串需要用不同类型,则重新分配空间并拷贝
        /* Since the header size changes, need to move the string forward,
         * and can't use realloc */
        newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    usable = usable-hdrlen-1;
    if (usable > sdsTypeMaxSize(type))
        usable = sdsTypeMaxSize(type);
    sdssetalloc(s, usable);
    return s;
}

这里扩容规则是,如果字符串长度还小于1M,则翻倍扩容,否则每次扩容1M。

参考:

《redis5设计与源码分析》

你可能感兴趣的:(redis,缓存,分布式,redis,数据库,缓存)