閱讀源碼: sds.h sds.c
SDSHDR 全稱 Simple Dynamic Strings Header
sds
char *的別名
typedef char *sds;
sdshdr
sdshdr有好幾個類別，它們分別是：sdshdr5，sdshdr8，sdshdr16，sdshdr32，sdshdr64，其中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[];
};
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[];
};
這五個結(jié)構(gòu)體中，len表示字符串的長度，alloc表示buf指針分配空間的大小，flags表示該字符串的類型(sdshdr5，sdshdr8，sdshdr16，sdshdr32，sdshdr64),是由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
#define SDS_TYPE_MASK 7
可以看出SDS_TYPE只占用了0,1,2,3,4五個數(shù)字，正好占用三位，我們就可以使用flags&SDS_TYPE_MASK來獲取動態(tài)字符串對應(yīng)的字符串類型
注意一個小細(xì)節(jié)：attribute ((packed))，這一段代碼的作用是取消編譯階段的內(nèi)存優(yōu)化對齊功能。
例如：struct aa {char a; int b;}; sizeof(aa) == 8;
但是struct attribute ((packed)) aa {char a; int b;}; sizeof(aa) == 5;
這個很重要，redis源碼中不是直接對sdshdr某一個類型操作，往往參數(shù)都是sds，而sds就是結(jié)構(gòu)體中的buf，在后面的源碼分析中，你可能會經(jīng)?？匆妔[-1]這種魔法一般的操作，而按照sdshdr內(nèi)存分布s[-1]就是sdshdr中flags變量，由此可以獲取到該sds指向的字符串的類型。
SDS中的宏定義函數(shù)
SDS_HDR_VAR(T,s)
#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
查看這段代碼首先得明白 C 語言中的宏定義##操作符，我在此就不再解釋了
這段代碼就很騷氣了，用個例子來解釋：
SDS_HDR_VAR(8,s);
//下面是對應(yīng)宏定義翻譯的產(chǎn)物
struct sdshdr8 *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
這樣就可以根據(jù)指向buf的sds變量s得到sdshdr8的指針，是不是感覺很神奇？
SDS_HDR(T,s)
#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
同上方的函數(shù)類似，根據(jù)指向buf的sds變量s得到sdshdr的指針，只不過這里是獲取的是指針地址，上方函數(shù)是創(chuàng)建了一個變量
SDS_TYPE_5_LEN(f)
#define SDS_TYPE_BITS 3
#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
看名字就知道該函數(shù)就是獲取sdshdr5字符串類型的長度，由于根本不使用sdshdr5類型，所以需要直接返回空，而flags成員使用最低三位有效位來表示類型，所以讓f代表的flags的值右移三位即可
上方基本上就是sds的核心內(nèi)容了，然后再看看sds中的幾個內(nèi)聯(lián)函數(shù)
static inline size_t sdslen(const sds s)
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;
}
該處就使用到了取消編譯階段的內(nèi)存優(yōu)化對齊功能，直接使用s[-1]獲取到flags成員的值，然后根據(jù)flags&&SDS_TYPE_MASK來獲取到動態(tài)字符串對應(yīng)的類型進(jìn)而獲取動態(tài)字符串的長度。
static inline size_t sdsavail(const sds s)
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;
}
獲取動態(tài)字符串可使用的空間，從這里可以看出來，SDS和我平常所用到的C語言的原生字符串有差別，因為從獲取可用空間的計算方法來看，并未考慮到字符串需要以\0結(jié)尾，因為結(jié)構(gòu)體本身帶有長度的成員len，不需要\0來做字符串結(jié)尾的判定，而且不使用\0作為結(jié)尾有很多好處，可以存儲的類型多樣性就提高了。
static inline void sdssetlen(sds s, size_t newlen)
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;
}
}
設(shè)置sds的長度
static inline void sdsinclen(sds s, size_t inc)
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)
/* sdsalloc() = sdsavail() + sdslen() */
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)
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;
}
}
設(shè)置sds已分配空間的大小
SDS函數(shù)
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);
這當(dāng)中的大部分函數(shù)都很簡單，只是對zmalloc文件里面的函數(shù)，sds中inline函數(shù)，或者是sdsnewlen函數(shù)的一層簡單調(diào)用，就不解釋，我們挑幾個重點的看看。
sds sdsnewlen(const void *init, size_t initlen)
/* Create a new sds string with the content specified by the 'init' pointer
* and 'initlen'.
* If NULL is used for 'init' the string is initialized with zero bytes.
* If SDS_NOINIT is used, the buffer is left uninitialized;
*
* The string is always null-termined (all the sds strings are, always) so
* even if you create an sds string with:
*
* mystring = sdsnewlen("abc",3);
*
* You can print the string with printf() as there is an implicit \0 at the
* end of the string. However the string is binary safe and can contain
* \0 characters in the middle, as the length is stored in the sds header. */
sds sdsnewlen(const void *init, size_t initlen) {
void *sh;
sds s;
// 根據(jù)initlen來獲取合適的字符串長度
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;
// 根據(jù)sds類型來獲取該sds類型對應(yīng)的結(jié)構(gòu)體大小
int hdrlen = sdsHdrSize(type);
unsigned char *fp; /* flags pointer. */
// 此處的s_malloc其實就是zmalloc函數(shù),只是一個別名,注意這里，會給sds多增加一個字節(jié)的空間，由后面的s[initlen] = '\0';可知，作者是為了兼容C語言的字符串類型，這樣就可以直接使用printf來輸出sds了，這樣非常的方便
sh = s_malloc(hdrlen+initlen+1);
// 如果init == "SDS_NOINIT",那么就會把sds置為未知字符串，如果init == NULL，那么就會把sds置為空字符串
if (init==SDS_NOINIT)
init = NULL;
else if (!init)
memset(sh, 0, hdrlen+initlen+1);
if (sh == NULL) return NULL;
s = (char*)sh+hdrlen;
fp = ((unsigned char*)s)-1;
// 根據(jù)sds類型來初始化sds的內(nèi)容
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;
}
}
// 在初始化完成后，將init的內(nèi)容拷貝進(jìn)sds對象中，但是init如果原來等于SDS_NOINIT，就會被置為NULL，所以sds還是一串未知的字符串
if (initlen && init)
memcpy(s, init, initlen);
s[initlen] = '\0';
return s;
}
該函數(shù)是一個生成新sds的函數(shù)，根據(jù)init指針和initlen參數(shù)來初始化sds的內(nèi)容，根據(jù)init是否是SDS_NOINIT來設(shè)置是否需要使用init的內(nèi)容初始化sds，如果是SDS_NOINIT，那么默認(rèn)會將sds置為一串為未知的字符串，如果init為NULL。那么默認(rèn)會將sds置為一個空字符串，并且sdsnewlen在為sds向系統(tǒng)申請一個新的空間的時候，新空間的長度是hdrlen+initlen+1，注意這里的+1，這多出來的一個字節(jié)，其實是放\0的，這樣sds就可以使用C自帶標(biāo)準(zhǔn)庫(strlen,strtoll之類的函數(shù))來操作sds中buf的內(nèi)容，不然還得自己寫一套，很是麻煩。
以下是使用sdsnewlen函數(shù)簡單調(diào)用構(gòu)成的函數(shù)：
// 創(chuàng)建一個新的sds，只不過這里只會給init參數(shù)，實際上initlen是通過strlen獲取的
sds sdsnew(const char *init);
// 創(chuàng)建一個空的sds
sds sdsempty(void);
// 根據(jù)原sds，創(chuàng)建一個sds的副本
sds sdsdup(const sds s);
以下是對zmalloc里面的函數(shù)簡單調(diào)用或者直接是別名的函數(shù):
#define s_malloc zmalloc
#define s_realloc zrealloc
#define s_free zfree
/* Free an sds string. No operation is performed if 's' is NULL. */
void sdsfree(sds s) {
if (s == NULL) return;
s_free((char*)s-sdsHdrSize(s[-1]));
}
void *sds_malloc(size_t size) { return s_malloc(size); }
void *sds_realloc(void *ptr, size_t size) { return s_realloc(ptr,size); }
void sds_free(void *ptr) { s_free(ptr); }
在動態(tài)字符串的所有操作中，大部分會進(jìn)行對內(nèi)存的擴(kuò)大和釋放，所以得介紹一下sds中對內(nèi)存擴(kuò)大和釋放的函數(shù)
擴(kuò)大sds的空閑空間 -- sdsMakeRoomFor函數(shù)
sds sdsMakeRoomFor(sds s, size_t addlen) {
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;
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);
if (oldtype==type) {
newsh = s_realloc(sh, hdrlen+newlen+1);
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(hdrlen+newlen+1);
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);
}
sdssetalloc(s, newlen);
return s;
}
該函數(shù)便是擴(kuò)大sds空間，但是感覺上還是想讓sds中available空間的大小能夠容納addlen大小的字符串，并不是改變了sds中buf的長度，而是改變了sds中available空間的大小，如果當(dāng)前available空間的大小大于addlen的大小，那么便不作修改，如果available空間的大小小魚addlen的大小，那么就會重新分配sds中alloc的大小，newlen并不是無腦直接讓alloc加上addlen，而且使用sds的長度加上addlen的長度作為newlen，但是經(jīng)常重新分配內(nèi)存會對效率有所影響，但是為了防止重新分配內(nèi)存對效率的影響而讓newlen無腦翻倍的話，又會對內(nèi)存造成影響，造成內(nèi)存占用過高，但是很大一部分內(nèi)存并沒有使用，所以取得了一個折中的辦法，就是在newlen小于SDS_MAX_PREALLOC(1M)，對newlen進(jìn)行翻倍，在newlen大于SDS_MAX_PREALLOC的情況下，讓newlen加上SDS_MAX_PREALLOC。
sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
void *sh, *newsh;
char type, oldtype = s[-1] & SDS_TYPE_MASK;
int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
size_t len = sdslen(s);
sh = (char*)s-oldhdrlen;
/* Check what would be the minimum SDS header that is just good enough to
* fit this string. */
type = sdsReqType(len);
hdrlen = sdsHdrSize(type);
/* If the type is the same, or at least a large enough type is still
* required, we just realloc(), letting the allocator to do the copy
* only if really needed. Otherwise if the change is huge, we manually
* reallocate the string to use the different header type. */
if (oldtype==type || type > SDS_TYPE_8) {
newsh = s_realloc(sh, oldhdrlen+len+1);
if (newsh == NULL) return NULL;
s = (char*)newsh+oldhdrlen;
} else {
newsh = s_malloc(hdrlen+len+1);
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);
}
sdssetalloc(s, len);
return s;
}
就是對sds中多余的空間進(jìn)行釋放，例如以前是一個sdshdr64的sds，在redis運行過程中，buf的內(nèi)容被修改了，變短了，那么多出來的內(nèi)容就需要釋放掉，還給系統(tǒng)，并且，如果修改得比較多，現(xiàn)在一個sdshdr16的sds就能容納下，那么當(dāng)前sds的type還會被修改，因為不同的sds類型占用的空間也是不一樣的，并且殺雞焉用宰牛刀，是吧。
其他的函數(shù)介紹意義其實并不大，都很簡單，我們僅需要知道sds的內(nèi)存分布，內(nèi)存操作即可。
