当前位置：网站首页>Redis 6.0源码学习 Simple Dynamic String

       
       struct 
       
       sdshdr {
       
       // buf 中已占用空间的长度
       
       int 
       
       len;
       
       // buf 中剩余可用空间的长度
       
       int 
       
       free;
       
       // 数据空间
       
       char 
       
       buf[];
       
};
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

len记录了buf中已经使用的字节数，即SDS所表示的字符串长度；free记录了buf中未使用的字节数。buf是一个字节数组，数组长度为len+free+1，因为它需要多存一个’\0’作为结束标识。

通过对数据结构的了解，就能计算出SDS所需的内存大小。以64位系统为例，一个字节的字符串对应的SDS至少需要10个字节。

SDS对上层暴露的指针不是指向SDS结构体的指针，而是直接指向buf的指针。由于buf中会在字符串结尾冗余’\0’作为结束标识，所以SDS能兼容C语言标准字符串处理函数。

数据结构

Redis 3.2之后的SDS结构变成了5种:sdshdr5、sdshdr8、sdshdr16、sdshdr32、sdshdr64。sdshdr是Simple Dynamic String Header的缩写，新的结构由不定长的头部和字符数组组成。

       
       struct 
       
       __attribute__ ((
       
       __packed__)) 
       
       sdshdr5 {
       
       unsigned 
       
       char 
       
       flags; 
       
       /* 3 lsb of type, and 5 msb of string length */
       
       char 
       
       buf[];
       
};
      
1.
2.
3.
4.

当字符串长度小于32时，会使用sdshdr5结构。sdshdr5结构仅使用了flags表示了结构类型和长度，低3位表示结构类型，高5位表示存储长度。

       
       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[];
       
};
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

sdshdr8、sdshdr16、sdshdr32和sdshdr64的结构相同，将len和free单独存放。

关于注释中sdshdr5未被使用的存疑

       
       /* 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[];
       
};
      
1.
2.
3.
4.
5.
6.

sdshdr5中有一句注释“sdshdr5 is never used.”，在阅读创建字符串源码时，发现sdshdr5实际中被使用了。此处直接呈上“LNMPRG源码研究”的结论。

最终可以确认，长度小于32的键值对，键的底层是sdshdr5,而值的robj底层是sdshdr8。
Q1:为什么用sdshdr5存key可以，存value不行？
个人猜想是键不更新而值会更新，故键用尽可能小的结构存；值更新会引起扩容，索性直接用大些的结构存。
Q2:为什么解析参数时，Redis又抛弃了小的sdshdr5？
个人猜想是为了编码方便。不同命令的参数个数都不相同，一开始分不清哪个位置是key哪个位置是value，索性统一处理，在具体场景下，再单独优化。

创建字符串

Redis通过sdsnewlen函数创建SDS。在函数中会根据字符串长度选择合适的类型，初始化完相应的统计值后，返回指定字符串内容的指针。

       
       sds 
       
       sdsnewlen(
       
       const 
       
       void 
       
       *
       
       init, 
       
       size_t 
       
       initlen) {
       
       void 
       
       *
       
       sh;
       
       sds 
       
       s;
       
       char 
       
       type 
       
       = 
       
       sdsReqType(
       
       initlen);
       
       //1. 根据字符串选择不同的类型
       
       /* 通常创建空字符串是用于之后追加，所以使用SDS8型。*/
       
       if (
       
       type 
       
       == 
       
       SDS_TYPE_5 
       
       && 
       
       initlen 
       
       == 
       
       0) 
       
       type 
       
       = 
       
       SDS_TYPE_8;
       
       int 
       
       hdrlen 
       
       = 
       
       sdsHdrSize(
       
       type);
       
       //2. 计算不同头部所需的长度
       
       unsigned 
       
       char 
       
       *
       
       fp; 
       
       /* 指向flags的指针 */
       
       assert(
       
       initlen 
       
       + 
       
       hdrlen 
       
       + 
       
       1 
       
       > 
       
       initlen); 
       
       /* Catch size_t overflow */
       
       sh 
       
       = 
       
       s_malloc(
       
       hdrlen
       
       +
       
       initlen
       
       +
       
       1);
       
       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;
       
       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 
       
       = 
       
       initlen;
       
       *
       
       fp 
       
       = 
       
       type;
       
       break;
       
        }
       
       case 
       
       SDS_TYPE_16: {
       
       SDS_HDR_VAR(
       
       16,
       
       s);
       
       sh
       
       ->
       
       len 
       
       = 
       
       initlen;
       
       sh
       
       ->
       
       alloc 
       
       = 
       
       initlen;
       
       *
       
       fp 
       
       = 
       
       type;
       
       break;
       
        }
       
       case 
       
       SDS_TYPE_32: {
       
       SDS_HDR_VAR(
       
       32,
       
       s);
       
       sh
       
       ->
       
       len 
       
       = 
       
       initlen;
       
       sh
       
       ->
       
       alloc 
       
       = 
       
       initlen;
       
       *
       
       fp 
       
       = 
       
       type;
       
       break;
       
        }
       
       case 
       
       SDS_TYPE_64: {
       
       SDS_HDR_VAR(
       
       64,
       
       s);
       
       sh
       
       ->
       
       len 
       
       = 
       
       initlen;
       
       sh
       
       ->
       
       alloc 
       
       = 
       
       initlen;
       
       *
       
       fp 
       
       = 
       
       type;
       
       break;
       
        }
       
    }
       
       if (
       
       initlen 
       
       && 
       
       init)
       
       memcpy(
       
       s, 
       
       init, 
       
       initlen);
       
       s[
       
       initlen] 
       
       = 
       
       '\0'; 
       
       //buf最后追加\0
       
       return 
       
       s;
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.

源码详解：1处

sdsReqType方法的作用就是基于字符串长度返回对应的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
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.