解构redis sds源码实现

最新推荐文章于 2023-07-01 23:07:54 发布

TPCloud

最新推荐文章于 2023-07-01 23:07:54 发布

阅读量164

点赞数

分类专栏： redis 文章标签： redis 源码 sds

本文链接：https://blog.csdn.net/tpc4289/article/details/110876528

版权

redis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

希望是附丽于存在的，有存在，便有希望，有希望，便是光明！

redis作为现今使用最火的开源内存数据库，强大的效率和功能是其成功的根本原因。源代码开源是这个信息时代送给程序员最好的东西，程序员从中学习并不断强大自己。redis作为开源数据库，让我们能够静下心来慢慢细品其中的核心代码的高效之美。

今日我们首先从redis的基础结构sds源码开始，慢慢熟悉了解其内部实现原理，了解其内部为了实现高效率而采取的实现方法。

一，sds结构定义

typedef char *sds;

/* Note: sdshdr5 is never used, we just access the flags byte directly.
 * However is here to document the layout of type 5 SDS strings. */
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[];
};

在sds.h头文件中，一开始通过typedef char *sds语句类型别名定义sds，这个sds指针后续指向具体的用户输入的字符串头地址。

后续接着定义了sds的头，这里定义了sdshdr5，sdshdr8，sdshdr16，sdshdr32，sdshdr64多个结构体类型。这里定义多个结构体类型是因为redis为了根据实际的用户存入数据自动来识别使用哪一个结构体类型，以便节省空间。举个例子，用户要存入9个字符数据，那么计算机就给它分配16个字符空间就够了，这样不仅满足需求，还有7个字符够后期使用；如果分配32个字符，就大大浪费内存空间了。

结构体中__attribute__ ((__packed__))关键字是说明使用节凑型排列方式，而不是使用对齐方式排序。该声明也是为了节省空间，避免空间浪费：

struct student
{
    char[] name;
    int    age;
    char   sex;
};

该结构体中，在对齐排列方式下，char类型占用4个字节，int占用4个字节；但在紧凑型模式下，char只占用一个字节，int占用4个字节，节省了空间。

sdshdr结构体中，有4个变量（我们以sdshdr8为例）：

uint8_t len; //代表字符串使用
uint8_t alloc; //代表字符串的最大容量
unsigned char flags; //标志位，通过该标志为可以知道具体使用哪个长度结构体
char buf[]; //字符串数组，用来存放实际数据

flags在文件中通过宏定义了多个类型

#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

通过上述分析我们可以知道字符串“abcdef"在内存中存放格式如下：

可以看到，指针s执向字符串开始地址，那么通过s[-1]我们可以获得flag的信息。

二、宏定义

#define SDS_TYPE_MASK 7
#define SDS_TYPE_BITS 3
#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)

宏定义中，函数宏定义SDS_HDR_VAR(T,S)获得指向结构体的指针：s是指向字符串的地址，通过(s)-(sizeof(struct sdshdr##T))前移指针，使得指针指向sdshdr结构体开始位置。

三、函数分析

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;
}

该函数获取字符串长度：sds通过获取len变量获取字符串长度，时间复杂度为O(1)，这比通过遍历字符串获取长度（时间复杂度为O(n))效率高很多。

static inline size_t sdsavail(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5: {
            return 0;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);
            return sh->alloc - sh->len;
        }
        case SDS_TYPE_16: {
            SDS_HDR_VAR(16,s);
            return sh->alloc - sh->len;
        }
        case SDS_TYPE_32: {
            SDS_HDR_VAR(32,s);
            return sh->alloc - sh->len;
        }
        case SDS_TYPE_64: {
            SDS_HDR_VAR(64,s);
            return sh->alloc - sh->len;
        }
    }
    return 0;
}

该函数获取sds中字符串可用空间

static inline void sdssetlen(sds s, size_t newlen) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->len = newlen;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->len = newlen;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->len = newlen;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->len = newlen;
            break;
    }
}

该函数重设sds字符串长度；

static inline void sdsinclen(sds s, size_t inc) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            {
                unsigned char *fp = ((unsigned char*)s)-1;
                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
            }
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->len += inc;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->len += inc;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->len += inc;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->len += inc;
            break;
    }
}

该函数用来修改sds字符串的长度。

static inline size_t sdsalloc(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)->alloc;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->alloc;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->alloc;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->alloc;
    }
    return 0;
}

该函数用来获取sds分配的空间。

static inline void sdssetalloc(sds s, size_t newlen) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            /* Nothing to do, this type has no total allocation info. */
            break;
        case SDS_TYPE_8:
            SDS_HDR(8,s)->alloc = newlen;
            break;
        case SDS_TYPE_16:
            SDS_HDR(16,s)->alloc = newlen;
            break;
        case SDS_TYPE_32:
            SDS_HDR(32,s)->alloc = newlen;
            break;
        case SDS_TYPE_64:
            SDS_HDR(64,s)->alloc = newlen;
            break;
    }
}

该函数用来重新设置sds的最大容量。

四、sds中的其他函数声明

sds sdsnewlen(const void *init, size_t initlen);
sds sdsnew(const char *init);
sds sdsempty(void);
sds sdsdup(const sds s);
void sdsfree(sds s);
sds sdsgrowzero(sds s, size_t len);
sds sdscatlen(sds s, const void *t, size_t len);
sds sdscat(sds s, const char *t);
sds sdscatsds(sds s, const sds t);
sds sdscpylen(sds s, const char *t, size_t len);
sds sdscpy(sds s, const char *t);

sds sdscatvprintf(sds s, const char *fmt, va_list ap);
#ifdef __GNUC__
sds sdscatprintf(sds s, const char *fmt, ...)
    __attribute__((format(printf, 2, 3)));
#else
sds sdscatprintf(sds s, const char *fmt, ...);
#endif

sds sdscatfmt(sds s, char const *fmt, ...);
sds sdstrim(sds s, const char *cset);
void sdsrange(sds s, ssize_t start, ssize_t end);
void sdsupdatelen(sds s);
void sdsclear(sds s);
int sdscmp(const sds s1, const sds s2);
sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
void sdsfreesplitres(sds *tokens, int count);
void sdstolower(sds s);
void sdstoupper(sds s);
sds sdsfromlonglong(long long value);
sds sdscatrepr(sds s, const char *p, size_t len);
sds *sdssplitargs(const char *line, int *argc);
sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
sds sdsjoin(char **argv, int argc, char *sep);
sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);

/* Low level functions exposed to the user API */
sds sdsMakeRoomFor(sds s, size_t addlen);
void sdsIncrLen(sds s, ssize_t incr);
sds sdsRemoveFreeSpace(sds s);
size_t sdsAllocSize(sds s);
void *sdsAllocPtr(sds s);

/* Export the allocator used by SDS to the program using SDS.
 * Sometimes the program SDS is linked to, may use a different set of
 * allocators, but may want to allocate or free things that SDS will
 * respectively free or allocate. */
void *sds_malloc(size_t size);
void *sds_realloc(void *ptr, size_t size);
void sds_free(void *ptr);

#ifdef REDIS_TEST
int sdsTest(int argc, char *argv[]);
#endif

#endif

其他函数的定义实现在sds.c中有源码具体实现，这里就不再详细贴述了，其中源码中比较重要的几点是：

1，sds中，对字符串进行加长和扩容操作，如果每次新增字符串后的字符串长度容量小于1M，如果sdshdr中格式不变（flag未进行变化），那么字符串仅仅只会在原有基础上调整len的值，并把新加字符串加入原有字符串后面。如果容量超过1M，那么每次扩容将新增1M空间：

void *sh, *newsh;
    size_t avail = sdsavail(s);
    size_t len, newlen;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;

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

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);
    newlen = (len+addlen);
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;

2，sds进行字符串缩短时，并不会把原有的空间释放，它只是会调整len的值，并把buf后续空间至为'\0'，这种惰性方法，大大减少了内存的申请和释放操作，提高效率，减少内存碎片化：

sds sdstrim(sds s, const char *cset) {
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (s != sp) memmove(s, sp, len);
    s[len] = '\0';
    sdssetlen(s,len);
    return s;
}

总的来说，redis为了提高读写速度，使用了内存来存储和访问数据。但它快不仅仅只是利用内存这一方面原因，它通过优化存储结构，优化算法，最终才使得整个数据库读写效率非常高。

欢迎大家关注以下公众号进行数据库方面知识探讨：

TPCloud

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
解构redis sds源码实现

希望是附丽于存在的，有存在，便有希望，有希望，便是光明！ redis作为现今使用最火的开源内存数据库，强大的效率和功能是其成功的根本原因。源代码开源是这个信息时代送给程序员最好的东西，程序员从中学习并不断强大自己。redis作为开源数据库，让我们能够静下心来慢慢细品其中的核心代码的高效之美。今日我们首先从...
复制链接

扫一扫