Redis学习之SDS源码分析

时间:2021-12-27 18:42:11

一.SDS的简单介绍

SDS:简单动态字符串(simple dynamic string)

1)SDS是Redis默认的字符表示,比如包含字符串值的键值对都是在底层由SDS实现的

2)SDS用来保存数据库中的字符串值

3)SDS被用作缓冲区:比如AOF模块的AOF缓冲区,以及客户端状态中的输入缓冲区

二.SDS的结构

struct sdshdr {

    // buf 中已占用空间的长度
int len; // buf 中剩余可用空间的长度
int free; // 字节数组
char buf[];
};

Redis学习之SDS源码分析

分析:

1)free=5:代表空闲空间长度为5

2)len=5:代表已经使用的空间长度为5

三.Redis使用SDS的原因

1)常数复杂度获取字符串长度:O(1)

C字符串获取字符串长度时间复杂度为O(N),使用SDS可以确保获取字符串长度的操作不会成为Redis的性能瓶颈

2)杜绝缓冲区溢出

C字符串不记录自身长度和空闲空间,容易造成缓冲区溢出,使用SDS则不会,SDS拼接字符串之前会先通过free字段检测剩余空间能否满足需求,不能满足需求的就会扩容

3)减少修改字符串时带来的内存重分配次数

使用C字符串的话:

每次对一个C字符串进行增长或缩短操作,长度都需要对这个C字符串数组进行一次内存重分配,比如C字符串的拼接,程序要先进行内存重分配来扩展字符串数组的大小,避免缓冲区溢出,又比如C字符串的缩短操作,程序需要通过内存重分配来释放不再使用的那部分空间,避免内存泄漏

使用SDS的话:

通过SDS的len属性和free属性可以实现两种内存分配的优化策略:空间预分配和惰性空间释放

1.针对内存分配的策略:空间预分配

在对SDS的空间进行扩展的时候,程序不仅会为SDS分配修改所必须的空间,还会为SDS分配额外的未使用的空间

这样可以减少连续执行字符串增长操作所需的内存重分配次数,通过这种预分配的策略,SDS将连续增长N次字符串所需的内存重分配次数从必定N次降低为最多N次,这是个很大的性能提升!

2.针对内存释放的策略:惰性空间释放

在对SDS的字符串进行缩短操作的时候,程序并不会立刻使用内存重分配来回收缩短之后多出来的字节,而是使用free属性将这些字节的数量记录下来等待将来使用,通过惰性空间释放策略,SDS避免了缩短字符串时所需的内存重分配次数,并且为将来可能有的增长操作提供了优化!

4)二进制安全

为了确保数据库可以二进制数据(图片,视频等),SDS的API都是二进制安全的,所有的API都会以处理二进制的方式来处理存放在SDS的buf数组里面的数据,程序不会对其中的数据做任何的限制,过滤,数据存进去是什么样子,读出来就是什么样子,这也是buf数组叫做字节数组而不是叫字符数组的原因,以为它是用来保存一系列二进制数据的

通过二进制安全的SDS,Redis不仅可以保存文本数据,还可以保存任意格式是二进制数

四.SDS的主要API及其源码解析

1)sdsnew函数:创建一个包含给定字符串的SDS

sds sdsnew(const char *init)

/*
* 根据给定字符串 init ,创建一个包含同样字符串的 sds
*
* 参数
* init :如果输入为 NULL ,那么创建一个空白 sds
* 否则,新创建的 sds 中包含和 init 内容相同字符串
*
* 返回值
* sds :创建成功返回 sdshdr 相对应的 sds
* 创建失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdsnew(const char *init) {
size_t initlen = (init == NULL) ? : strlen(init);
return sdsnewlen(init, initlen);
} /*
* 根据给定的初始化字符串 init 和字符串长度 initlen
* 创建一个新的 sds
*
* 参数
* init :初始化字符串指针
* initlen :初始化字符串的长度
*
* 返回值
* sds :创建成功返回 sdshdr 相对应的 sds
* 创建失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdsnewlen(const void *init, size_t initlen) { struct sdshdr *sh; // 根据是否有初始化内容,选择适当的内存分配方式
// T = O(N)
if (init) {
// zmalloc 不初始化所分配的内存
sh = zmalloc(sizeof(struct sdshdr) + initlen + );
}
else {
// zcalloc 将分配的内存全部初始化为 0
sh = zcalloc(sizeof(struct sdshdr) + initlen + );
} // 内存分配失败,返回
if (sh == NULL) return NULL; // 设置初始化长度
sh->len = initlen;
// 新 sds 不预留任何空间
sh->free = ;
// 如果有指定初始化内容,将它们复制到 sdshdr 的 buf 中
// T = O(N)
if (initlen && init)
memcpy(sh->buf, init, initlen);
// 以 \0 结尾
sh->buf[initlen] = '\0'; // 返回 buf 部分,而不是整个 sdshdr,因为sds是char指针类型的别名
return (char*)sh->buf;
}

2)sdsempty函数:创建一个不包含任何内容的SDS

sds sdsempty(void)

/*
* 创建并返回一个只保存了空字符串 "" 的 sds
*
* 返回值
* sds :创建成功返回 sdshdr 相对应的 sds
* 创建失败返回 NULL
*
* 复杂度
* T = O(1)
*/
sds sdsempty(void) {
return sdsnewlen("", );
}

3)sdsfree函数:释放给定的SDS

/*
* 释放给定的 sds
*
* 复杂度
* T = O(N)
*/
void sdsfree(sds s) {
if (s == NULL) return;
zfree(s - sizeof(struct sdshdr));
}

ps:zfree函数为内存管理模块中的函数,我们在这里先不探究,只需要知道它可以释放指定的空间就可以了

分析:s - sizeof(struct sdshdr)到底返回的是什么呢?

首先我们知道SDS的buf数组是柔性数组,也就是这个数组是不占据内存大小的,所以sizeof(struct sdshdr)为8

还有SDS数据类型为char *类型,所以假如存在这样一条语句:

struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)))

其结构的内存结构图为:

Redis学习之SDS源码分析

所以s-(sizeof(struct sdshdr))就是指向sds的头部的!!

4)sdslen函数:返回SDS的已使用的空间字节数

/*
* 返回 sds 已经使用的空间字节数
*
* T = O(1)
*/
static inline size_t sdslen(const sds s)
{
struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr)));
return sh->len;
}

static inline修饰的函数是内联函数,目的是解决函数在多次调用时候的效率问题!

size_t是无符号整数,是sizeof操作符返回的结构类型

const代表变量只能读,不能被修改

5)sdsavail函数:返回SDS的未使用的空间字节数

/*
* 返回 sds 为使用的空间字节数
*
* T = O(1)
*/
static inline size_t sdsavail(const sds s)
{
struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr)));
return sh->free;
}

跟sdslen函数的区别就在于返回的属性不同

6)sdsup函数:创建一个给定SDS的副本(copy)

/*
* 复制给定 sds 的副本
*
* 返回值
* sds :创建成功返回输入 sds 的副本
* 创建失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdsdup(const sds s) {
return sdsnewlen(s, sdslen(s));
}

调用了sdsnewlen函数和sdslen函数,这两个函数在上面都有介绍

7)sdsclear函数:清空SDS保存的字符串内容

/*
* 在不释放 SDS 的字符串空间的情况下,
* 重置 SDS 所保存的字符串为空字符串。
*
* 复杂度
* T = O(1)
*/
void sdsclear(sds s) { // 取出 sdshdr
struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr))); // 重新计算属性
sh->free += sh->len;
sh->len = ; // 将结束符放到最前面(相当于惰性地删除 buf 中的内容)
sh->buf[] = '\0';
}

以上采用了惰性空间释放的策略,其实buf中的内容并没有被“真正的删除”,只是len属性和free属性变了,结束符移动到buf数组最前面了而已

8)sdscat函数:将给定的C字符串拼接到SDS字符串的末尾

/*
* 将给定字符串 t 追加到 sds 的末尾
*
* 返回值
* sds :追加成功返回新 sds ,失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdscat(sds s, const char *t) {
return sdscatlen(s, t, strlen(t));
}
/*
* 将长度为 len 的字符串 t 追加到 sds 的字符串末尾
*
* 返回值
* sds :追加成功返回新 sds ,失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdscatlen(sds s, const void *t, size_t len) { struct sdshdr *sh; // 原有字符串长度
size_t curlen = sdslen(s); // 扩展 sds 空间
// T = O(N)
s = sdsMakeRoomFor(s, len); // 内存不足?直接返回
if (s == NULL) return NULL; // 复制 t 中的内容到字符串后部
// T = O(N)
sh = (void*)(s - (sizeof(struct sdshdr)));
memcpy(s + curlen, t, len); // 更新属性
sh->len = curlen + len;
sh->free = sh->free - len; // 添加新结尾符号
s[curlen + len] = '\0'; // 返回新 sds
return s;
}
/*
* 对 sds 中 buf 的长度进行扩展,确保在函数执行之后,
* buf 至少会有 addlen + 1 长度的空余空间
* (额外的 1 字节是为 \0 准备的)
*
* 返回值
* sds :扩展成功返回扩展后的 sds
* 扩展失败返回 NULL
*
* 复杂度
* T = O(N)
*/
sds sdsMakeRoomFor(sds s, size_t addlen) { struct sdshdr *sh, *newsh; // 获取 s 目前的空余空间长度
size_t free = sdsavail(s); size_t len, newlen; // s 目前的空余空间已经足够,无须再进行扩展,直接返回
if (free >= addlen) return s; // 获取 s 目前已占用空间的长度
len = sdslen(s);
sh = (void*)(s - (sizeof(struct sdshdr))); // s 最少需要的长度
newlen = (len + addlen); // 根据新长度,为 s 分配新空间所需的大小
if (newlen < SDS_MAX_PREALLOC)
// 如果新长度小于 SDS_MAX_PREALLOC 最大预先分配长度
// 那么为它分配两倍于所需长度的空间 空间预分配策略
newlen *= ;
else
// 否则,分配长度为目前长度加上 SDS_MAX_PREALLOC
newlen += SDS_MAX_PREALLOC;
// T = O(N)
newsh = zrealloc(sh, sizeof(struct sdshdr) + newlen + ); // 内存不足,分配失败,返回
if (newsh == NULL) return NULL; // 更新 sds 的空余长度
newsh->free = newlen - len; // 返回 sds
return newsh->buf;
}

sdscat函数调用了sdscatlen函数,sdscatlen函数调用sdsMakeRoomFor函数

我们可以发现sdsMakeRoomFor函数采用了空间预分配的策略,确保在对buf进行长度扩展的时候至少为有addlen+1长度的空余空间,addlen为buf后面拼接的C字符串长度

sdsMakeRoomFor函数中有个宏定义的常量SDS_MAX_PREALLOC ,为最大预先分配长度,是为空间预分配策略服务的

sdsMakeRoomFor函数中调用了zrealloc函数,zrealloc函数的作用是分配指定内存大小空间给sds,此函数属于内存分配模块,我们先不探究

9)sdscatsds函数:将给定的SDS字符串拼接到另一个SDS字符串的末尾

/*
* 将另一个 sds 追加到一个 sds 的末尾
*
* 返回值
* sds :追加成功返回新 sds ,失败返回 NULL
*
* 复杂度
* T = O(N)
*/ sds sdscatsds(sds s, const sds t) {
return sdscatlen(s, t, sdslen(t));
}

sdscatsds函数调用的两个函数:sdscatlen和sdslen

已经在上面解析过了,这里不再解析

10)sdscpy函数:将给定的C字符串复制到SDS里面,覆盖SDS原有的字符串

/*
* 将字符串复制到 sds 当中,
* 覆盖原有的字符。
*
* 如果 sds 的长度少于字符串的长度,那么扩展 sds 。
*
* 复杂度
* T = O(N)
*
* 返回值
* sds :复制成功返回新的 sds ,否则返回 NULL
*/ sds sdscpy(sds s, const char *t) {
return sdscpylen(s, t, strlen(t));
}
/*
* 将字符串 t 的前 len 个字符复制到 sds s 当中,
* 并在字符串的最后添加终结符。
*
* 如果 sds 的长度少于 len 个字符,那么扩展 sds
*
* 复杂度
* T = O(N)
*
* 返回值
* sds :复制成功返回新的 sds ,否则返回 NULL
*/ sds sdscpylen(sds s, const char *t, size_t len) { struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr))); // sds 现有 buf 的长度
size_t totlen = sh->free + sh->len; // 如果 s 的 buf 长度不满足 len ,那么扩展它
if (totlen < len) {
// T = O(N)
s = sdsMakeRoomFor(s, len - sh->len); //扩展失败,返回NULL
if (s == NULL) return NULL; //扩展成功
sh = (void*)(s - (sizeof(struct sdshdr)));
totlen = sh->free + sh->len;
} // 复制内容
// T = O(N)
memcpy(s, t, len); // 添加终结符号
s[len] = '\0'; // 更新属性
sh->len = len;
sh->free = totlen - len; // 返回新的 sds
return s;
}

sdscpy函数调用了sdscpylen函数,sdscpylen函数又调用了sdsMakeRoomFor函数

代码分析看注释就好

11)sdsgrowzero函数:用空字符将SDS扩展至给定长度

/*
* 将 sds 扩充至指定长度,未使用的空间以 0 字节填充。
*
* 返回值
* sds :扩充成功返回新 sds ,失败返回 NULL
*
* 复杂度:
* T = O(N)
*/
sds sdsgrowzero(sds s, size_t len) { struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr)));//*sh指向s的头部 size_t totlen, curlen = sh->len;//总长度 已经使用的长度 // 如果 len 比字符串的现有长度小,
// 那么直接返回,不做动作
if (len <= curlen) return s; // 扩展 sds
// T = O(N)
s = sdsMakeRoomFor(s, len - curlen); // 如果内存不足,直接返回
if (s == NULL) return NULL; // 将新分配的空间用 0 填充,防止出现垃圾内容
// T = O(N)
sh = (void*)(s - (sizeof(struct sdshdr)));
memset(s + curlen, , (len - curlen + )); // also set trailing \0 byte // 更新属性
totlen = sh->len + sh->free;
sh->len = len;
sh->free = totlen - sh->len; // 返回新的 sds
return s;
}

没有判断len-curlen和free的关系,就算free>=len-curlen也会进行一次扩容操作

12.sdsrange函数:保留SDS给定区间内的数据,不在区间内的数据会被覆盖或者清除

/*
* 按索引对截取 sds 字符串的其中一段
* start 和 end 都是闭区间(包含在内)
*
* 索引从 0 开始,最大为 sdslen(s) - 1
* 索引可以是负数, sdslen(s) - 1 == -1
*
* 复杂度
* T = O(N)
*/
/*
* s = sdsnew("Hello World");
* sdsrange(s,1,-1); => "ello World"
*/
void sdsrange(sds s, int start, int end) { //sh指向s头部
struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr))); size_t newlen, len = sdslen(s); //没有可以截取的字符串,直接返回
if (len == ) return; //start参数规则
if (start < ) {
start = len + start;
if (start < ) start = ;
} //end参数规则
if (end < ) {
end = len + end;
if (end < ) end = ;
} //len取决于start和end的关系
newlen = (start > end) ? : (end - start) + ; //新的sds的len!=0
if (newlen != ) { //需要截取的起点大于等于有符号的len 那么新的sds的len=0
if (start >= (signed)len) {
newlen = ;
} //终点超出了有符号的len 终点就是len-1
else if (end >= (signed)len) {
end = len - ; //重新计算len
newlen = (start > end) ? : (end - start) + ;
}
}
else {
start = ;
} // 如果有需要,对字符串进行移动
// T = O(N)
if (start && newlen) memmove(sh->buf, sh->buf + start, newlen); // 添加终结符
sh->buf[newlen] = ; // 更新属性
sh->free = sh->free + (sh->len - newlen);
sh->len = newlen;
}

注意start和end参数的设置,以及有时候需要对字符串进行移动操作

13.sdstrim函数:接受一个SDS和一个C字符串作为参数,从SDS左右两端分别移除所有在C字符串中出现过的字符

/*
* 对 sds 左右两端进行修剪,清除其中 cset 指定的所有字符
*
* 在头部遇到某个字符不属于cset,则头部清除停下
* 在尾部遇到某个字符不属于cset,则尾部清除停下
*
* 比如 sdsstrim(xxyayabcycyxy, "xy") 将返回 "ayabcyc"
*
* 复杂性:
* T = O(M*N),M 为 SDS 长度, N 为 cset 长度。
* Example:
*
* s = sdsnew("AA...AA.a.aa.aHelloWorld :::");
* s = sdstrim(s,"A. :");
* printf("%s\n", s);
*
* Output will be just "a.aa.aHello World".
*/
sds sdstrim(sds s, const char *cset) {
struct sdshdr *sh = (void*)(s - (sizeof(struct sdshdr)));
char *start, *end, *sp, *ep;
size_t len; // 设置和记录指针
sp = start = s;
ep = end = s + sdslen(s) - ; // 修剪, T = O(N^2)
while (sp <= end && strchr(cset, *sp)) sp++; //从头部开始清除,遇到第一个不属于cset里面的字符则停止头部清除工作
while (ep > start && strchr(cset, *ep)) ep--;//从尾部开始清除,遇到第一个不属于cset里面的字符则停止尾部清除工作 // 计算 trim 完毕之后剩余的字符串长度
len = (sp > ep) ? : ((ep - sp) + ); // 如果有需要,前移字符串内容
// T = O(N)
if (sh->buf != sp) memmove(sh->buf, sp, len); // 添加终结符
sh->buf[len] = '\0'; // 更新属性
sh->free = sh->free + (sh->len - len);
sh->len = len; // 返回修剪后的 sds
return s;
}

注意sdstrim函数不是移除所有在子串中出现过的字符,而是移除头部和尾部在子串中出现的字符

举个例子:比如 sdsstrim(xxyayabcycyxy, "xy") 将返回 "ayabcyc"

14)sdscmp函数:比较两个SDS字符串是否相等

/*
* 对比两个 sds , strcmp 的 sds 版本
*
* 返回值
* int :相等返回 0 ,s1 较大返回正数, s2 较大返回负数
*
* T = O(N)
*/
int sdscmp(const sds s1, const sds s2) {
size_t l1, l2, minlen;
int cmp; //s1长度
l1 = sdslen(s1); //s2长度
l2 = sdslen(s2); //s1和s2最小长度
minlen = (l1 < l2) ? l1 : l2; //比较
cmp = memcmp(s1, s2, minlen); //s1较大返回正数,s2较大返回负数,相等返回0
if (cmp == ) return l1 - l2; return cmp;
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

参考:《Redis设计与实现》