redis源码阅读——sds.c

sds.c

sds.c文件中，主要是一些sds的底层具体的实现，和一些对sds的操作。

了解下sds底层的具体实现，可以加深我们对字符串的更深的理解。

同时，一些内存分配、回收、扩展的一些方式也很值得我们学习。

//这两个函数一个根据type返回size，一个根据size判断type，比较简单
static inline int sdsHdrSize(char type) {
    switch(type&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return sizeof(struct sdshdr5);
        case SDS_TYPE_8:
            return sizeof(struct sdshdr8);
        case SDS_TYPE_16:
            return sizeof(struct sdshdr16);
        case SDS_TYPE_32:
            return sizeof(struct sdshdr32);
        case SDS_TYPE_64:
            return sizeof(struct sdshdr64);
    }
    return 0;
}

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创建函数

sds创建函数通过不同的initlen来判断创建的动态字符串的类型，从而创建不同的sds，代码以及解析如下。

sds sdsnewlen(const void *init, size_t initlen) {
    void *sh;       //
    sds s;
    //根据长度来判断类型，如果是sds5类型的话，那么会重新设定为sds8
    //根据不同的长度设定hdr，从而分配空间
    char type = sdsReqType(initlen);     
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;         
    int hdrlen = sdsHdrSize(type);
    unsigned char *fp; /* flags pointer. */
	
    //分配空间
    sh = s_malloc(hdrlen+initlen+1);
    if (init==SDS_NOINIT)
        init = NULL;
    else if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    if (sh == NULL) return NULL;
    //sh + hdrlen 即为数据部分的启始指针
    s = (char*)sh+hdrlen;
    //fp = flags指针
    fp = ((unsigned char*)s)-1;
    //根据不同的类型来设定hdr中的内容、
    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);//拷贝数据内容并且加入终止符（兼容C）
    s[initlen] = '\0';
    return s;
}

sds调整空间

sds既然是变长字符串，那么关键就是在于它可以自动调整长度，下面就是sds自动调整长度的函数

sds空间调整规则如下：

１．如果原字符串大小小于１Ｍ的话，那么将字符串扩展为原来的两倍

２．如果字符串大小大于１Ｍ的话，那么在原有基础上，扩展１Ｍ的空间

//sds调整空间的函数
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;

    //在空间足够的情况下，那么就直接返回sds即可
    if (avail >= addlen) return s;jjj

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);
    newlen = (len+addlen);
    //在字符串长度小于1m(1024 * 1024)的情况下，将字符串空间扩展为原来的两倍，否则将字符串长度增加1m
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;

    //根据新长度来判断新的类型
    type = sdsReqType(newlen);

    //依旧不适用sds5
    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
	
    //重新判断hdrlen
    hdrlen = sdsHdrSize(type);
    if (oldtype==type) {
        //如果类型没有变化的话，直接重新省内请内存既可以
        newsh = s_realloc(sh, hdrlen+newlen+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        //如果是hdr类型变化的话，后面的字符串将会被移动位置，那么就不能使用recalloc函数重新分配内存了
        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分配了过多的空间，但是这些空间我们可能一直用不上，这个时候就可以使用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;
//新的类型
    type = sdsReqType(len);
    hdrlen = sdsHdrSize(type);

    //如果类型依旧没有变化的话，那么直接将原来的内存重新分配一下就可以了，否则的话就要重新分配，然后重新设置属性了。
    //最后将alloc和len都设置为len长度，这样的话，多余的空间都可以被回收
    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，等于hdr + hdrlen
        s = (char*)newsh+hdrlen;
        s[-1] = type;//设置type
        sdssetlen(s, len);
    }
    sdssetalloc(s, len);
    return s;
}

几个小函数

//创建一个空的sds
//其实就是创建一个initlen为0的
sds sdsempty(void) {
    return sdsnewlen("",0);
}

//从一个const char创建
sds sdsnew(const char *init) {
    size_t initlen = (init == NULL) ? 0 : strlen(init);
    return sdsnewlen(init, initlen);
}

//可以理解为复制构造函数
sds sdsdup(const sds s) {
    return sdsnewlen(s, sdslen(s));
}
//释放空间
void sdsfree(sds s) {
    if (s == NULL) return;
    s_free((char*)s-sdsHdrSize(s[-1]));
}
//将sds当做char *处理
//将len设置为第一个'\0'的位置
void sdsupdatelen(sds s) {
    size_t reallen = strlen(s);
    sdssetlen(s, reallen);
}

//将sds清零
void sdsclear(sds s) {
    sdssetlen(s, 0);
    s[0] = '\0';
}

一些其他的函数也本身比较容易理解，主要是实现了一些其他的功能。比如说，按照long long来生成sds，或者是将所有的字母都变成大写/小写，再或者是range函数等等，都是比较容易实现的。

这里仅仅讨论一些主要的实现函数，比如sds如果实现二进制安全，如何分配内存，回收内存的。底层是如何实现的，了解这些东西之后，再去看一些对sds进行操作的代码的话是十分水到渠成的事情了。