[Redis源碼閱讀]sds字符串實現

初衷

從開始工做就開始使用Redis,也有一段時間了,但都只是停留在使用階段,沒有往更深的角度探索,每次想讀源碼都止步在閱讀書籍上,由於看完書很快又忘了,此次逼本身先讀代碼。由於我的以爲寫做須要閱讀文字來加強靈感,那麼寫代碼的,就閱讀更多代碼來加強靈感吧。git

redis的實現原理,在《Redis設計與實現》一書中講得很詳細了,可是想經過結合代碼的形式再深刻探索,加深本身的理解,如今將本身探索的心得寫在這兒。github

sds結構體的定義

#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結構體,使用不一樣的結構體來保存不一樣長度大小的字符串
typedef char *sds;

struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* flags共8位,低三位保存類型標誌,高5位保存字符串長度,小於32(2^5-1) */
    char buf[]; // 保存具體的字符串
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* 字符串長度,buf已用的長度 */
    uint8_t alloc; /* 爲buf分配的總長度,alloc-len就是sds結構體剩餘的空間 */
    unsigned char flags; /* 低三位保存類型標誌 */
    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[];
};

sds結構體從4.0開始就使用了5種header定義,節省內存的使用,可是不會用到sdshdr5,我認爲是由於sdshdr5能保存的大小較少,2^5=32,所以就不使用它。redis

其餘的結構體保存了len、alloc、flags以及buf四個屬性。各自的含義見代碼的註釋。算法

sds結構體的獲取

上面能夠看到有5種結構體的定義,在使用的時候是經過一個宏來獲取的:安全

#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))

"##"被稱爲鏈接符,它是一種預處理運算符, 用來把兩個語言符號(Token)組合成單個語言符號。好比SDS_HDR(8, s),根據宏定義展開是:數據結構

((struct sdshdr8 *)((s)-(sizeof(struct sdshdr8))))

而具體使用哪個結構體,sds底層是經過flags屬性與SDS_TYPE_MASK作與運算得出具體的類型(具體的實現可見下面的sdslen函數),而後再根據類型去獲取具體的結構體。curl

sds特性的實現

在Redis設計與實現一書中講到,相比C字符串而言,sds的特性以下:函數

  • 常數複雜度獲取字符串長度性能

  • 杜絕緩衝區溢出學習

  • 減小內存從新分配次數

  • 二進制安全

那麼,它是怎麼作到的呢?看代碼。

常數複雜度獲取字符串長度

由於sds將長度屬性保存在結構體中,因此只須要讀取這個屬性就能獲取到sds的長度,具體調用的函數時sdslen,實現以下:

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;
}

能夠看到,函數是根據類型調用SDS_HDR宏來獲取具體的sds結構,而後直接返回結構體的len屬性。

杜絕緩衝區溢出

對於C字符串的操做函數來講,若是在修改字符串的時候忘了爲字符串分配足夠的空間,就有可能出現緩衝區溢出的狀況。而sds中的API就不會出現這種狀況,由於它在修改sds以前,都會判斷它是否有足夠的空間完成接下來的操做。

拿書中舉例的sdscat函數來看,若是strcat想在原來的"Redis"字符串的基礎上進行字符串拼接的操做,可是沒有檢查空間是否知足,就有可能會修改了"Redis"字符串以後使用到的內存,多是其餘結構使用了,也有多是一段沒有被使用的空間,所以有可能會出現緩衝區溢出。可是sdscat就不會,以下面代碼所示:

sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);
    sdssetlen(s, curlen+len);
    s[curlen+len] = '\0';
    return s;
}

sds sdscat(sds s, const char *t) {
    return sdscatlen(s, t, strlen(t));
}

從代碼中能夠看到,在執行memcpy將字符串寫入sds以前會調用sdsMakeRoomFor函數去檢查sds字符串s是否有足夠的空間,若是沒有足夠空間,就爲其分配足夠的空間,從而杜絕了緩衝區溢出。sdsMakeRoomFor函數的實現以下:

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;

    /* 只有有足夠空間就立刻返回,不然就繼續執行分配空間的操做 */
    if (avail >= addlen) return s;

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);
    newlen = (len+addlen);
    // SDS_MAX_PREALLOC == 1MB,若是修改後的長度小於1M,則分配的空間是原來的2倍,不然增長1MB的空間
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;

    type = sdsReqType(newlen);

    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 {
        /* 新增空間後超過當前類型的長度,使用malloc,並把原字符串拷貝過去 */
        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;
}

減小內存分配操做

sds字符串的不少操做都涉及到修改字符串內容,好比sdscat拼接字符串、sdscpy拷貝字符串等等。這時候就須要內存的分配與釋放,若是每次操做都分配剛恰好的大小,那麼對程序的性能一定有影響,由於內存分配涉及到系統調用以及一些複雜的算法。

sds使用了空間預分配以及惰性空間釋放的策略來減小內存分配操做。

空間預分配

前面提到,每次涉及到字符串的修改時,都會調用sdsMakeRoomFor檢查sds字符串,若是大小不夠再進行大小的從新分配。sdsMakeRoomFor函數有下面這幾行判斷:

// SDS_MAX_PREALLOC == 1MB,若是修改後的長度小於1M,則分配的空間是原來的2倍,不然增長1MB的空間
if (newlen < SDS_MAX_PREALLOC)
    newlen *= 2;
else
    newlen += SDS_MAX_PREALLOC;

函數判斷字符串修改後的大小,若是修改後的長度小於1M,則分配給sds的空間是原來的2倍,不然增長1MB的空間。

惰性空間釋放

若是操做後減小了字符串的大小,好比下面的sdstrim函數,只是在最後修改len屬性,不會立刻釋放多餘的空間,而是繼續保留多餘的空間,這樣在下次須要增長sds字符串的大小時,就不須要再爲其分配空間了。固然,若是以後檢查到sds的大小實在太大,也會調用sdsRemoveFreeSpace函數釋放多餘的空間。

sds sdstrim(sds s, const char *cset) {
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    /* 從頭部和尾部逐個字符遍歷往中間靠攏,若是字符在cest中,則繼續前進 */
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1); // 所有被去除了,長度就是0
    if (s != sp) memmove(s, sp, len); // 拷貝內容
    s[len] = '\0';
    sdssetlen(s,len);
    return s;
}

二進制安全

二進制安全指的是隻關心二進制化的字符串,不關心具體格式。只會嚴格的按照二進制的數據存取,不會妄圖以某種特殊格式解析數據。好比遇到'0'字符不會中止解析。

對於C字符串來講,strlen是判斷遇到'0'以前的字符數量。若是須要保存二進制的數據,就不能經過傳統的C字符串來保存,由於獲取不到它真實的長度。而sds字符串是經過len屬性保存字符串的大小,因此它是二進制安全的。

其餘小函數實現

在閱讀源碼的過程當中,也發現了兩個我的比較感興趣趣的函數:

  • sdsll2str(將long long類型的整型數字轉成字符串)

  • sdstrim (去除頭部和尾部的指定字符)

我這兩個函數拉出來作了測試,在項目的redis-4.0/tests目錄下。sdstrim函數的實現源碼上面有列出,看看sdsll2str的實現:

int sdsll2str(char *s, long long value) {
    char *p, aux;
    unsigned long long v;
    size_t l;

    /* 經過取餘數獲得原字符串的逆轉形式 */
    v = (value < 0) ? -value : value;
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p++ = '-';

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

    /* 反轉字符串 */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

函數是經過不斷取餘數,獲得原字符串的逆轉形式,接着,經過從尾部開始將字符逐個放到字符串s中,看起來像是一個反轉操做,從而實現了將整型轉爲字符串的操做。

以爲感興趣是由於sdsll2str這個函數在以前學習C語言的時候常常能看到做爲問題出現,能看到如此簡潔的實現,表示眼前一亮。而在PHP開發時常用trim函數,因此想看看它們的區別。

總結

經過詳細地閱讀sds的源碼,不只學習到sds的實現細節,還學習到了一些經常使用字符串操做函數的實現。若是隻是僅僅看看數據結構的定義也能夠初步瞭解,可是要深刻了解的話仍是須要詳細的閱讀具體函數的實現代碼。仍是那句,寫代碼的,須要閱讀更多代碼來加強靈感。

我在github有對Redis源碼更詳細的註解。感興趣的能夠圍觀一下,給個star。Redis4.0源碼註解。能夠經過commit記錄查看已添加的註解。

原創文章,文筆有限,才疏學淺,文中如有不正之處,萬望告知。

更多精彩內容,請關注我的公衆號。

相關文章
相關標籤/搜索