sds，即 Simple Dynamic Strings，是Redis中存储绝大部分字符串所采用的数据结构。
typedef char *sds;
一、类型
sds的类型包括SDS_TYPE_5, SDS_TYPE_8, SDS_TYPE_16, SDS_TYPE_32, SDS_TYPE_64五种：
#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
创建sds时根据初始字符串的长度指定sds类型。源码如下：
static inline char sdsReqType(size_t string_size) {
if (string_size < 1<<5)
return SDS_TYPE_5;
if (string_size < 1<<8)
return SDS_TYPE_8;
if (string_size < 1<<16)
return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
if (string_size < 1ll<<32)
return SDS_TYPE_32;
return SDS_TYPE_64;
#else
return SDS_TYPE_32;
#endif
}
标识SDS_TYPE的数字实际上指定了字符串长度能够由长度为几位的二进制数标识。
long long一般是8字节，只有当long也为8字节，且字符串长度用32位不足以表示时，才会将sds指定为SDS_TYPE_64类型。
疑问：函数参数
size_t string_size的类型实际为unsigned long long，为什么要考虑long型的长度？
由于一共有5种类型，需要二进制数至少三位来标识类型。这可以从下文得到印证。
二、结构
sds大致的结构为头部+字符串值。对于上述五种不同类型，sds结构大同小异。
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[];
};
__attribute__ ((__packed__))用于指示编译器以紧凑方式打包结构体，即不对成员进行对齐。
可以看到，公共的成员变量包括buf与flags。
buf用于实际存储数据flags共有的用途是指明sds的类型，具体存储在低3位
struct sdshdr5相对不复杂，仅在flags中记录了字符串的实际长度。由前文可知，当原字符串长度可以用不超过5位表示时，sds采用SDS_TYPE_5类型。于是将长度的5位与用于标识类型的3位组合为flags，很好地利用了空间。
对于其他类型的sds，flags中的高五位已不能满足长度记录需要，因此增加了字段。
len：指的是实际字符串的长度，与SDS_TYPE_5类型的sds中flags高五位的含义一致alloc：指的是分配的字节数，不包含头部与字符串尾部附加的'\0'
三、相关操作
(1) 创建
最简单的创建sds的函数定义如下所示，该函数接收一个C语言字符串作为参数（C语言字符串以'\0'为结尾）。
sds sdsnew(const char *init) {
size_t initlen = (init == NULL) ? 0 : strlen(init);
return sdsnewlen(init, initlen);
}
sds sdsnew(const char *init)方法实际调用了sdsnewlen方法，将原始字符串和字符串长度作为参数传入。sdsnewlen方法定义如下：
sds sdsnewlen(const void *init, size_t initlen) {
return _sdsnewlen(init, initlen, 0);
}
sdsnewlen仍然是一个壳子，调用了_sdsnewlen方法，其定义如下。
sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
void *sh;
sds s;
char type = sdsReqType(initlen);
/* Empty strings are usually created in order to append. Use type 8
* since type 5 is not good at this. */
if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
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;
fp = ((unsigned char*)s)-1;
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);
s[initlen] = '\0';
return s;
}
函数内部首先判定待创建的sds类别，存放在变量type中，所调用的sdsReqType我们在前文已经介绍过了。
有一个细节的处理是，如果字符串长度是0，手动将其设置为SDS_TYPE_8类型。原因在源码的注释中已经给出：字符串长度为0的sds一般是被创建用来拼接字符串的，而SDS_TYPE_5类型的sds并不擅长做这个。
接下来，调用函数sdsHdrSize根据类别获取头部长度，存放在变量hdrlen中。函数定义也很简单，就是根据type计算对应的头部结构体大小并返回。需要额外解释的是，每个sds头结构体实际用一个柔性数组存放字符串，在sizeof()计算时，柔型数组字段对应的size为0。以struct sdshdr8为例，其大小只有前三个成员的大小决定，为1+1+1字节。
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[];
};
接下来，为sds分配空间，对应这段代码：
sh = trymalloc?
s_trymalloc_usable(hdrlen+initlen+1, &usable) :
s_malloc_usable(hdrlen+initlen+1, &usable);
sdsnewlen调用_sdsnewlen时，传参trymalloc为0。于是我们查看s_malloc_usable方法。调用s_malloc_usable传入两个参数，第一个参数值hdrlen+initlen+1恰好指定sds所需的最小空间，包括头部空间，原始字符串，以及字符串末尾的\0。第二个参数用于接收分配的可用空间大小。
s_malloc_usable实际通过宏定义指向zmalloc_usable方法。
void *zmalloc_usable(size_t size, size_t *usable) {
size_t usable_size = 0;
void *ptr = ztrymalloc_usable_internal(size, &usable_size);
if (!ptr) zmalloc_oom_handler(size);
#ifdef HAVE_MALLOC_SIZE
ptr = extend_to_usable(ptr, usable_size);
#endif
if (usable) *usable = usable_size;
return ptr;
}
这一方法内部又调用了ztrymalloc_usable_internal方法：
static inline void *ztrymalloc_usable_internal(size_t size, size_t *usable) {
/* Possible overflow, return NULL, so that the caller can panic or handle a failed allocation. */
if (size >= SIZE_MAX/2) return NULL;
void *ptr = malloc(MALLOC_MIN_SIZE(size)+PREFIX_SIZE);
if (!ptr) return NULL;
#ifdef HAVE_MALLOC_SIZE
size = zmalloc_size(ptr);
update_zmalloc_stat_alloc(size);
if (usable) *usable = size;
return ptr;
#else
// 分析这里
*((size_t*)ptr) = size;
update_zmalloc_stat_alloc(size+PREFIX_SIZE);
if (usable) *usable = size;
return (char*)ptr+PREFIX_SIZE;
#endif
}
malloc分配处，将宏定义展开则为如下表达式：
void *ptr = malloc((size > 0 ? size : 0)+(sizeof(size_t)))
size_t实际为unsigned long long，额外分配的PREFIX_SIZE空间用于存储本次分配空间的大小，不包含PREFIX_SIZE空间大小。
调用update_zmalloc_stat_alloc的目的是维护记录分配空间大小的变量user_memory。
#define update_zmalloc_stat_alloc(__n) atomicIncr(used_memory,(__n))
static redisAtomic size_t used_memory = 0;
ztrymalloc_usable_internal最终返回的是所分配空间向后偏移PREFIX_SIZE的地址。
分配空间的部分我们已经解读完毕，接下来继续阅读_sdsnewlen剩余代码。
s = (char*)sh+hdrlen;，使s指向头部柔型数组成员。
fp = ((unsigned char*)s)-1;使fp指向柔型数组前一个成员，即flags。
switch语句根据type为头部每个成员赋值。其中SDS_HDR_VAR宏定义如下：
#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
这行代码让根据type和柔型数组首地址找到头部首地址，并将sh指向这一地址。
两个与长度相关的字段赋值如下：
sh->len = initlen;
sh->alloc = usable;
这时，usable与initlen的长度实际上是相等的。
接着复制字符串，并在末尾附加'\0'：
if (initlen && init)
memcpy(s, init, initlen);
s[initlen] = '\0';
最后返回的是s而非sh。也就是说，sds创建后，并不存在指向其头部首地址的指针，sds指针指向柔性数组字段。
(2) 空间扩展
sds扩展空间有两种方式，不同之处在于是否进行空间预分配，即分配额外的空间以避免每次增加字符都要重新分配内存。两个函数的定义如下：
/* Enlarge the free space at the end of the sds string more than needed,
* This is useful to avoid repeated re-allocations when repeatedly appending to the sds. */
sds sdsMakeRoomFor(sds s, size_t addlen) {
return _sdsMakeRoomFor(s, addlen, 1);
}
/* Unlike sdsMakeRoomFor(), this one just grows to the necessary size. */
sds sdsMakeRoomForNonGreedy(sds s, size_t addlen) {
return _sdsMakeRoomFor(s, addlen, 0);
}
可以看到，两个函数最终调用同一个函数_sdsMakeRoomFor，第三个参数指明是否需要进行预分配。
_sdsMakeRoomFor定义如下：
sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {
void *sh, *newsh;
size_t avail = sdsavail(s);
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);
reqlen = newlen = (len+addlen);
assert(newlen > len); /* Catch size_t overflow */
if (greedy == 1) {
if (newlen < SDS_MAX_PREALLOC)
newlen *= 2;
else
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;
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;
}
首先判断已有sds尚未使用的空间是否已达到addlen，sdsavail定义如下。
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;
}
若未使用空间已能够满足要求，则不额外分配，直接返回。
若继续分配，要确定新的空间大小：
reqlen = newlen = (len+addlen);
if (greedy == 1) {
if (newlen < SDS_MAX_PREALLOC)
newlen *= 2;
else
newlen += SDS_MAX_PREALLOC;
}
这里就是sdsMakeRoomForNonGreedy与sdsMakeRoomFor差异的根源。
if (greedy == 1)内newlen相比于自身原值增加的值就是预分配的空间。预分配空间是有上限的：
#define SDS_MAX_PREALLOC (1024*1024)
若newlen原值达不到预分配空间上限，就分配二倍的newlen空间，否则额外分配SDS_MAX_PREALLOC大小的空间。
接着指定新sds的类型：
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;
这里更加明确地避免了SDS_TYPE_5的使用。由前面sdsavail函数可以看到，SDS_TYPE_5的未使用空间永远是0，这也是为什么SDS_TYPE_5不适合用于字符串拼接：每次拼接都要重新分配空间。
后面的处理根据新旧type是否一致而存在差异。若新旧type一致，头部长度不变，新的空间数据分布与原空间一致，因此调用realloc，当新的空间大小大于原空间大小时，realloc的作用是在堆上开辟一块新的内存空间，将原空间的内容复制到新空间，然后释放新空间。若新旧type不一致，则新旧sds中buf的位置相对于头部首地址不同，不能直接利用realloc拷贝，因此调用malloc，并需要手动s_free原sds。
四、特性
(1) 结构特性
redis的sds由头部和实际字符串两部分组成，并在字符串末尾附加一个'\0'，其中字符串作为头部结构体最后一个成员变量存在，且sds实际指向柔型数组的首地址。这样的结构有很多好处：
- redis的字符串与头部空间可以同时分配、同时释放，且空间连续
- 头部维护元信息，简化了部分操作，计算字符串的长度
- 二进制安全：sds以头部的
len字段标识结尾处，而不在'\0'处结尾 - 兼容C字符串
(2) 空间预分配
初始创建sds时不预留空间，这是因为不是所有的sds都会执行拼接操作，预留空间未必有意义。而当对sds执行字符串拼接操作时，就要进行空间的预分配了。当存在预分配空间时，进行字符串拼接时若预分配空间足够，则不需要重新分配空间，提高了效率。