Redis源码分析（五）——简单动态字符串（sds）

Sds(Simple Dynamic String)是Redis底层所使用的字符串表示，它被用在几乎所有的Redis模块中。

Redis是一个键值对数据库（K-V DB），数据库的值可以是字符串、集合、列表等多种对象，而键则只能是字符串对象。 由于char*类型的功能单一，抽象层次低，不能高效的支持一些Redis常用的操作（比如对字符串的追加操作和长度计算操作，而在Redis中对字符串的追加以及计算长度都是很常见的操纵，每次对char*字符串进行追加都必然导致内存的重新分配（realloc）这将严重影响性能），另外Reids的字符串表示还应该是二进制安全的。
所以在Redis的内部绝大部分使用的都是sds而不是char*来表示字符串。

二进制安全字符串：二进制安全是一种主要用于字符串操作函数相关的计算机编程术语。其本质就是将字符串中的所有字符都看作 原始的、无任何特殊格式意义的数据流。将所有字符视为按照一串0和1的形式编码的二进制数据，而不会对'\0'
,'\n' 等“特殊”的字符赋予不同的特殊含义。

Sds字符串总是以\0作为结束（sds对应的sdshdr的len不包括末尾的\0），由于sdshdr保存了字符串的长度len，因此在sds的中间可以包括\0字符（二进制安全的）。

在对字符串sds的操作时，总是把目标的C字符串cher*（sds）转换为 sdshdr(相当于string对象)进行操（及时更新sdshdr的已有字符数len,剩余空间free和实际存放字符串的buf等成员参数），然后再返回更新后的sds。 这样就使得C的字符串cher*具有了类似高级string的各种操作方法，从而能够方便的对C字符串sds计算长度以及追加等复杂操作。

Rdis通过对sds封装为sdshdr结构体，为sds字符串的操作提供了大量的操作方法，使得在Rdis中方便高效的使用字符串。

以下对sds的主要API函数进行分析，具体见注释。

sds.c /sds.h :

<span style="font-size:18px;">typedef char *sds;     //sds是C char*的别名

//动态字符串结构体
struct sdshdr {
unsigned int len;//当前buf已占用空间
unsigned int free;//buf剩余空间
char buf[];//实际保存字符串数据的地方
};

//计算sds的长度，返回的size_t类型的数值
static __inline size_t sdslen(const sds s) {
struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
return sh->len;
}

//计算sds剩余可用长度
static __inline size_t sdsavail(const sds s) {
struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
return sh->free;
}

//创建一个指定长度的sds，接受一个C字符串作为初始值
sds sdsnewlen(const void *init, size_t initlen);
//创建一个sds，初始化为给定C字符串
sds sdsnew(const char *init);
//创建一个只包含空白串""的sds
sds sdsempty(void);
//获取sds的长度
size_t sdslen(const sds s);
//复制给定sds
sds sdsdup(const sds s);
//释放给定sds
void sdsfree(sds s);
//获取给定sds剩余可用空间
size_t sdsavail(const sds s);
//将给定sds的buf扩张至指定长度，无内容的部分用\0填充
sds sdsgrowzero(sds s, size_t len);
//将给定sds扩展至给定长度，并将一个给定C字符串追加到sds末尾
sds sdscatlen(sds s, const void *t, size_t len);
//将给定C字符串追加到给定sds末尾
sds sdscat(sds s, const char *t);
//将一个给定sds追加到另一个sds末尾
sds sdscatsds(sds s, const sds t);
//将一个给定C字符串的len部分复制到sds，需要时对sds进行扩展
sds sdscpylen(sds s, const char *t, size_t len);
//将一个给定C字符串复制到给定sds
sds sdscpy(sds s, const char *t);
//将已给 C字符串追加到给定sds末尾，并将sds内容格式化打印到另一给定C字符串
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);//对给定sds缩剪
void sdsrange(sds s, int start, int end);//对给定sds进行按范围截取
void sdsupdatelen(sds s);//更新sds长度
void sdsclear(sds s);//清除sds内容，初始化为""
int sdscmp(const sds s1, const sds s2);//比较两个sds
sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);//对sds分割子字符串
void sdsfreesplitres(sds *tokens, int count);//释放子串数组
void sdstolower(sds s);//将给定sds内容转换为小写字符
void sdstoupper(sds s);//将给定sds内容转换为大写字符
sds sdsfromlonglong(long long value);//创建数组sds？？
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); //以分隔符连接字符串子数组构成新的字符串

/* Low level functions exposed to the user API */
/* 开放给使用者的API */
sds sdsMakeRoomFor(sds s, size_t addlen);//对给定sds对应的sdshdr结构的buf扩展
void sdsIncrLen(sds s, int incr);//增加sds的长度
sds sdsRemoveFreeSpace(sds s);//将buf多余的空间释放掉
size_t sdsAllocSize(sds s);//计算给定的sds的buf的内存空间大小

#endif
</span>

sds.c:

<span style="font-size:18px;">//创建一个指定长度的sds，接受一个C字符串作为初始值。创建初始化时buf剩余空间buf为0，在下次追加时按照给定扩展算法，更新free
sds sdsnewlen(const void *init, size_t initlen) {
struct sdshdr *sh;
if (init) {
sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
} else {
sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
}
if (sh == NULL) return NULL;
sh->len = (int)initlen;
sh->free = 0;
if (initlen && init)
memcpy(sh->buf, init, initlen);//从源init所指的内存地址的起始位置开始拷贝initlen个字节到目标buf所指的内存地址的起始位置中

sh->buf[initlen] = '\0';//填充buf的末尾
return (char*)sh->buf;//返回C字符串 buf
}

/* Create an empty (zero length) sds string. Even in this case the string
* always has an implicit null term. */
//创建一个空sds。（始终有一个\0字符）
sds sdsempty(void) {
return sdsnewlen("",0);
}

/* Create a new sds string starting from a null termined C string. */
sds sdsnew(const char *init) {
size_t initlen = (init == NULL) ? 0 : strlen(init);
return sdsnewlen(init, initlen);
}</span>

扩容函数：（增加buf的free空间）：如果原来free足够用则直接返回。否则，如果buf->len+addlen 小于SDS_MAX_PREALLOC（1M），则buf总空间扩为len+addlen的两倍；否则buf总空间扩为len+SDS_MAX_PREALLOC的两倍。 这也是sds由于char*的主要原因之一。在sds追加内容的时候，按需要触发扩容操作，并预留free的剩余空间，这样在下次追加时当free足够大时就可以不用再次重新分配空间（realloc），从而提高性能。以空间换时间，类似于动态数组vector。
对于预留的空间，可用 sdsRemoveFreeSpace(sds s)函数释放归还。然而free剩余空间的释放不是自动进行的，这可以通过设置系统，比如让系统定时自动释放掉free的剩余空间。

<span style="font-size:18px;">//扩容（增加buf的free空间）：如果原来free足够用则直接返回。否则，如果buf->len+addlen 小于SDS_MAX_PREALLOC（1M），则buf总空间扩为len+addlen的两倍；否则buf总空间扩为len+SDS_MAX_PREALLOC的两倍
sds sdsMakeRoomFor(sds s, size_t addlen) {
struct sdshdr *sh, *newsh;
size_t free = sdsavail(s);//现有的free
size_t len, newlen;

if (free >= addlen) return s;
len = sdslen(s);
sh = (void*) (s-(sizeof(struct sdshdr)));
newlen = (len+addlen);
if (newlen < SDS_MAX_PREALLOC)
newlen *= 2;
else
newlen += SDS_MAX_PREALLOC;
newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1);
if (newsh == NULL) return NULL;

newsh->free = (int)(newlen - len);
return newsh->buf;
}

/* Reallocate the sds string so that it has no free space at the end. The
* contained string remains not altered, but next concatenation operations
* will require a reallocation.
*
* After the call, the passed sds string is no longer valid and all the
* references must be substituted with the new pointer returned by the call. */
//去掉传入sds的free。 下次在该sds末尾追加时需要额外分配空间
sds sdsRemoveFreeSpace(sds s) {
struct sdshdr *sh;

sh = (void*) (s-(sizeof(struct sdshdr)));
sh = (struct sdshdr *)zrealloc(sh, sizeof(struct sdshdr)+sh->len+1);
sh->free = 0;
return sh->buf;
}
</span>

<span style="font-size:18px;">//增加buf的len（buf的free对应的减少incr的长度），当incr为负数时，进行反向操作。用于比如在sds后追加了字符串（free足够大，没有触发重新的内存分配）
//每次更新len之后都需要移动\0到对应位置
void sdsIncrLen(sds s, int incr) {
struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));

if (incr >= 0)
assert(sh->free >= (unsigned int)incr);//从free分配到len,确保free大等于incr
else
assert(sh->len >= (unsigned int)(-incr));//从len分配到free，确保len大等于-incr
sh->len += incr;
sh->free -= incr;
s[sh->len] = '\0';
}
</span>

sdscpylen:将给定C串复制到指定sds（覆盖原有内容），需要时扩容，t为二进制安全的字符串，因此需要传入其长度，不能通过strlen函数计算（strlen函数计算长度时遇到\0则结束），如果给定的字符串为非二进制安全的，则不需要传入len参数。

<span style="font-size:18px;">sds sdscpylen(sds s, const char *t, size_t len) {
struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
size_t totlen = sh->free+sh->len;

if (totlen < len) {
s = sdsMakeRoomFor(s,len-sh->len);
if (s == NULL) return NULL;
sh = (void*) (s-(sizeof(struct sdshdr)));
totlen = sh->free+sh->len;
}
memcpy(s, t, len);
s[len] = '\0';
sh->len = (int)len;
sh->free = (int)(totlen-len);
return s;
}</span>

把数值转换为字符串存放到s指定位置 的辅助函数。 s指向的字符串长度至少等于SDS_LLSTR_SIZE，返回转换所得的以\0结尾的字符串的长度

<span style="font-size:18px;">int sdsll2str(char *s, long long value) {
char *p, aux;
unsigned long long v;
size_t l;

/* Generate the string representation, this method produces
* an reversed string. */
//把数值通过取余逐位的存入字符串（为逆序）
v = (value < 0) ? -value : value;//取value绝对值
p = s;
do {
*p++ = '0'+(v%10);//字符'0'加偏移量到对应数值的字符
v /= 10;
} while(v);
if (value < 0) *p++ = '-';//若是负数，最后加上 符号

/* Compute length and add null term. */
l = p-s;
*p = '\0';

/* Reverse the string. */
p--;
//字符串逆转（首尾字符交换）
while(s < p) {
aux = *s;
*s = *p;
*p = aux;
s++;
p--;
}
return (int)l;
}</span>

sds sdscatfmt(sds s, char const *fmt, ...)：字符串格式化输出，输入原字符串，格式，参数

字符串格式化输出到sds，输入原字符串，格式，各需要格式化到sds的参数 */

例： sds x="--";

x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);

memcmp(x,"--Hello Hi! World -9223372036854775808,9223372036854775807--",60) == 0)

<span style="font-size:18px;">sds sdscatfmt(sds s, char const *fmt, ...) {
struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
size_t initlen = sdslen(s);
const char *f = fmt;
int i;
va_list ap;

va_start(ap,fmt);
f = fmt;    /* Next format specifier byte to process. */
i = initlen; /* Position of the next byte to write to dest str. */
//关键再次，以此比较输入的格式类型
while(*f) {
char next, *str;
unsigned int l;
long long num;
unsigned long long unum;

/* Make sure there is always space for at least 1 char. */
if (sh->free == 0) {
s = sdsMakeRoomFor(s,1);
sh = (void*) (s-(sizeof(struct sdshdr)));
}

switch(*f) {
case '%':
/*如果是%,记住百分号后面的类型操作值*/
next = *(f+1);
f++;
switch(next) {
case 's':
case 'S':
str = va_arg(ap,char*);
//判断普通的str,还是sds类型，计算长度的方法不一样
l = (next == 's') ? strlen(str) : sdslen(str);
if (sh->free < l) {
s = sdsMakeRoomFor(s,l);
sh = (void*) (s-(sizeof(struct sdshdr)));
}
//如果是字符串，直接复制到后面
memcpy(s+i,str,l);
sh->len += l;
sh->free -= l;
i += l;
break;
case 'i':
case 'I':
if (next == 'i')
num = va_arg(ap,int);
else
num = va_arg(ap,long long);
{
char buf[SDS_LLSTR_SIZE];
//如果是数字，调用添加数值字符串方法
l = sdsll2str(buf,num);
if (sh->free < l) {
s = sdsMakeRoomFor(s,l);
sh = (void*) (s-(sizeof(struct sdshdr)));
}
memcpy(s+i,buf,l);
sh->len += l;
sh->free -= l;
i += l;
}
break;
case 'u':
case 'U':
//无符号整型同上
if (next == 'u')
unum = va_arg(ap,unsigned int);
else
unum = va_arg(ap,unsigned long long);
{
char buf[SDS_LLSTR_SIZE];
l = sdsull2str(buf,unum);
if (sh->free < l) {
s = sdsMakeRoomFor(s,l);
sh = (void*) (s-(sizeof(struct sdshdr)));
}
memcpy(s+i,buf,l);
sh->len += l;
sh->free -= l;
i += l;
}
break;
default: /* Handle %% and generally %<unknown>. */
s[i++] = next;
sh->len += 1;
sh->free -= 1;
break;
}
break;
default:
//非操作类型，直接单字符添加
s[i++] = *f;
sh->len += 1;
sh->free -= 1;
break;
}
f++;
}
va_end(ap);

/* Add null-term */
s[i] = '\0';
return s;
}
</span>

<span style="font-size:18px;">//将给定的sds从左右两边剪去连续存在于cset中的所有字符
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;//指向sds的头部
ep = end = s+sdslen(s)-1;//指向sds的最后一个字符
while(sp <= end && strchr(cset, *sp)) sp++;// 从sds的左边开始跳过所有连续在cset存在的字符
while(ep > start && strchr(cset, *ep)) ep--;//从sds的右边开始跳过所有连续在cset中存在的字符
len = (sp > ep) ? 0 : ((ep-sp)+1);//如此计算剩余的字符数：两个指针相减。如果左右移动已经交叉，则剩余空
if (sh->buf != sp) memmove(sh->buf, sp, len);//更新buf
sh->buf[len] = '\0';
sh->free = sh->free+(int)(sh->len-len);
sh->len = (int)len;
return s;
}</span>

小结：

对比C字符串，sds有以下特性：

* 可以高效的执行长度计算

* 可以高效的执行追加操作

* 二进制安全

sds会为追加操作进行优化： 加快追加操作的速度，并降低内存分配次数，代价是多占用了内存空间（buf的free预留空间），而且这些内存不会被主动释放。