Redis源码阅读 - Redis数据结构动态字符串(SDS)

typedef char *sds;

// sdshdr5不会被使用，我们只是直接访问标志字节。 然而，此处旨在记录5类SDS字符串的布局。
struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {   // 8字节长度，最大存储255长的字符串
    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 {   // 最大长度 65535
    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[];
};

static inline size_t sdsAllocSize(sds s) {     // 获取sds实际申请的总内存大小， +1 是需要字符串终止符'\0'
    switch(sdsType(s)) {
        case SDS_TYPE_5:
            return sizeof(struct sdshdr5) + SDS_TYPE_5_LEN(s) + 1;
        case SDS_TYPE_8:
            return sizeof(struct sdshdr8) + SDS_HDR(8,s)->alloc + 1;
        case SDS_TYPE_16:
            return sizeof(struct sdshdr16) + SDS_HDR(16,s)->alloc + 1;
        case SDS_TYPE_32:
            return sizeof(struct sdshdr32) + SDS_HDR(32,s)->alloc + 1;
        case SDS_TYPE_64:
            return sizeof(struct sdshdr64) + SDS_HDR(64,s)->alloc + 1;
    }
    return 0;
}

static inline unsigned char sdsType(const sds s) {   // 获取字符串sds的类型
    unsigned char flags = s[-1];
    return flags & SDS_TYPE_MASK;   // 获取sdshdr的flag表示，即取出flag成员的低三位
}

sds sdsnew(const char *init) {   // 根据实际字符串大小初始化sds，自动计算长度
    size_t initlen = (init == NULL) ? 0 : strlen(init);
    return sdsnewlen(init, initlen);
}

sds sdsnewlen(const void *init, size_t initlen) {  // 根据传入字符串和长度初始化，如果失败就终止进程
    return _sdsnewlen(init, initlen, 0);
}

sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {    // 传入字符串和初始化大小，创建一个新的sds
    void *sh;
    char type = sdsReqType(initlen);
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;   // 如果创建空字符串，就使用type 8，因为type 5 添加字符不太擅长，要做位运算
    int hdrlen = sdsHdrSize(type);
    size_t bufsize;

    assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow  用于判断是否超出size_t类型支持的最大值 */
    sh = trymalloc?
        s_trymalloc_usable(hdrlen+initlen+1, &bufsize) :  // 申请内存，bufsize为实际可用的内存大小
        s_malloc_usable(hdrlen+initlen+1, &bufsize);
    if (sh == NULL) return NULL;

    adjustTypeIfNeeded(&type, &hdrlen, bufsize);   // 重新调整合适的类型
    return sdsnewplacement(sh, bufsize, type, init, initlen);  // 初始化sds结构，给成员变量赋值
}

  char *strcat(char *dest, const char *src) {
     char *tmp = dest;   //将目标字符串复制给tmp变量
     while(*dest)        //用一个while循环遍历目标字符串，直到遇到“\0”跳出循环，指向目标字符串的末尾
        dest++;
     while((*dest++ = *src++) != '\0' )   //将源字符串中的每个字符逐一赋值到目标字符串中，直到遇到结束字符
     return tmp;
  }

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

sds sdscatlen(sds s, const void *t, size_t len) { 
    size_t curlen = sdslen(s);  // 获取目标字符串s的当前长度

    s = sdsMakeRoomFor(s,len);  // 根据要追加的长度len和目标字符串s的现有长度，判断是否要增加新的空间 
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);   // 将源字符串t中len长度的数据拷贝到目标字符串结尾
    sdssetlen(s, curlen+len);   // 设置目标字符串的最新长度：拷贝前长度curlen加上拷贝长度
    s[curlen+len] = '\0';       // 拷贝后，在目标字符串结尾加上\0
    return s;
}

sds _sdsMakeRoomFor(sds s, size_t addlen, int greedy) {  // sds字符串变更扩充空间
    ......
    if (greedy == 1) {                 // 判断扩充内存是否是贪婪模式，如果不使用贪婪模式，则根据实际需要的大小去扩内存
        if (newlen < SDS_MAX_PREALLOC)  // 如果扩充后总长度小于 1024*1024，则扩充一倍
            newlen *= 2;
        else
            newlen += SDS_MAX_PREALLOC;   // 否则扩充 1024*1024。即每次预申请的内存必须小于 1024*1024
    }

    type = sdsReqType(newlen);    // 计算新sds的类型
    if (type == SDS_TYPE_5) type = SDS_TYPE_8;  // 不使用type 5类型
    hdrlen = sdsHdrSize(type);
    use_realloc = (oldtype == type);   // 如果扩充长度不需要改变sds的类型，即旧类型仍然可以容纳就使用realloc重新分配
    ......
    usable = bufsize - hdrlen - 1;   // 更新sds成员变量
    sdssetalloc(s, usable);
    return s;
}