redis sds 源码

object encoding define

#define OBJ_ENCODING_RAW 0     /* Raw representation */
#define OBJ_ENCODING_INT 1     /* Encoded as integer */
#define OBJ_ENCODING_HT 2      /* Encoded as hash table */
#define OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define OBJ_ENCODING_LINKEDLIST 4 /* No longer used: old list encoding. */
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define OBJ_ENCODING_INTSET 6  /* Encoded as intset */
#define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */

char *strEncoding(int encoding) {
    switch(encoding) {
    case OBJ_ENCODING_RAW: return "raw";
    case OBJ_ENCODING_INT: return "int";
    case OBJ_ENCODING_HT: return "hashtable";
    case OBJ_ENCODING_QUICKLIST: return "quicklist";
    case OBJ_ENCODING_ZIPLIST: return "ziplist";
    case OBJ_ENCODING_INTSET: return "intset";
    case OBJ_ENCODING_SKIPLIST: return "skiplist";
    case OBJ_ENCODING_EMBSTR: return "embstr";
    default: return "unknown";
    }
}

获取sds类型

// 获取sds类型
static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5) // <32
        return SDS_TYPE_5;
    if (string_size < 1<<8) // <256
        return SDS_TYPE_8;
    if (string_size < 1<<16) // <65536
        return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX) // 我猜测估计判断是否是64位的
    if (string_size < 1ll<<32) // <4294967296
        return SDS_TYPE_32;
    return SDS_TYPE_64;
#else
    return SDS_TYPE_32;
#endif
}

创建sds对象

robj *dupStringObject(const robj *o) {
    robj *d;

    serverAssert(o->type == OBJ_STRING);

    switch(o->encoding) {
    case OBJ_ENCODING_RAW: //raw
        return createRawStringObject(o->ptr,sdslen(o->ptr));
    case OBJ_ENCODING_EMBSTR: //embstr
        return createEmbeddedStringObject(o->ptr,sdslen(o->ptr));  // sdshdr8起步
    case OBJ_ENCODING_INT: // int
        d = createObject(OBJ_STRING, NULL);
        d->encoding = OBJ_ENCODING_INT;
        d->ptr = o->ptr;
        return d;
    default:
        serverPanic("Wrong encoding.");
        break;
    }
}

createEmbeddedStringObject

robj *createEmbeddedStringObject(const char *ptr, size_t len) {
    robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr8)+len+1); // 分配内存
    struct sdshdr8 *sh = (void*)(o+1);

    o->type = OBJ_STRING; // string (type key)
    o->encoding = OBJ_ENCODING_EMBSTR; // embstr (type encoding key)
    o->ptr = sh+1;
    o->refcount = 1;
    if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        o->lru = (LFUGetTimeInMinutes()<<8) | LFU_INIT_VAL;
    } else {
        o->lru = LRU_CLOCK();
    }

    sh->len = len; // 使用长度
    sh->alloc = len; // 分配长度
    sh->flags = SDS_TYPE_8; // flags=SDS_TYPE_8
    if (ptr == SDS_NOINIT)
        sh->buf[len] = '\0';
    else if (ptr) {
        memcpy(sh->buf,ptr,len);  // void * memcpy ( void * dest, const void * src, size_t num )
        sh->buf[len] = '\0';
    } else { // 把buf数组清的值0
        memset(sh->buf,0,len+1); // memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符
    }
    return o;
}

createRawStringObject

robj *createRawStringObject(const char *ptr, size_t len) {
    return createObject(OBJ_STRING, sdsnewlen(ptr,len)); // sdsnewlen 会得到sdsReqType
}

createObject

robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type; // raw: OBJ_STRING = string
    o->encoding = OBJ_ENCODING_RAW; // raw
    o->ptr = ptr;
    o->refcount = 1;

    /* Set the LRU to the current lruclock (minutes resolution), or
     * alternatively the LFU counter. */
    if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        o->lru = (LFUGetTimeInMinutes()<<8) | LFU_INIT_VAL;
    } else {
        o->lru = LRU_CLOCK();
    }
    return o;
}

OBJ_ENCODING_INT

case OBJ_ENCODING_INT: // int
d = createObject(OBJ_STRING, NULL);
d->encoding = OBJ_ENCODING_INT; // int
d->ptr = o->ptr;
return d;

embstr or raw

#define OBJ_ENCODING_EMBSTR_SIZE_LIMIT 44
robj *createStringObject(const char *ptr, size_t len) {
    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT)
        return createEmbeddedStringObject(ptr,len); //embstr
    else
        return createRawStringObject(ptr,len); // raw
}

例子

127.0.0.1:6379[2]> set three 12345678901234567890123456789012345678901234
OK
127.0.0.1:6379[2]> object encoding three
"embstr"
127.0.0.1:6379[2]> set three 123456789012345678901234567890123456789012345
OK
127.0.0.1:6379[2]> object encoding three
"raw"