我在计算key和value的空间的时候，发现我使用命令获取的和自己算的总是对不上。比如
命令行执行
代码语言：javascript复制local:0>set 5ycode yxkong
"OK"
local:0>OBJECT ENCODING 5ycode
"embstr"
local:0>DEBUG OBJECT 5ycode
"Value at:0x7f9dc6a0e180 refcount:1 encoding:embstr serializedlength:7 lru:14046288 lru_seconds_idle:32"
local:0>memory usage 5ycode
"56"
local:0>Append 5ycode 1
"7"
local:0>OBJECT ENCODING 5ycode
"raw"
local:0>memory usage 5ycode
"66"我开始手动计算，我的依据是以下的数据结构：
图1typedef struct redisObject {
//robj存储的对象类型
unsigned type:4; //4位
// 编码
unsigned encoding:4; //4位
/**
* @brief 24位
* LRU的策略下：lru存储的是 秒级时间戳的低24位，约194天会溢出
* LFU的策略下：24位拆为两块，高16位(最大值65535)低8位（最大值255）
* 高16存储的是 存储的是分钟级&最大存储位的值，要溢出的话，需要65535`$ 约 45天溢出
* 低8位存储的是近似统计位
* 在lookupKey进行更新
*/
unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
* LFU data (least significant 8 bits frequency
* and most significant 16 bits access time). */
//引用次数，当为0的时候可以释放就，c语言没有垃圾回收的机制，通过这个可以释放空间
int refcount; //4字节
/**
* 指针有两个属性
* 1，指向变量/对象的地址；
* 2，标识变量/地址的长度;
* void 因为没有类型，所以不能判断出指向对象的长度
*/
void *ptr; // 8字节
} robj;//一个robj 占16字节
//因为在客户端解析的时候创建的是sdshdr8
struct __attribute__ ((__packed__)) sdshdr8 {
//1字节 max= 255 已用空间
uint8_t len; /* used */
//1字节 申请的buf的总空间，max255（不包含flags、len、alloc这些）
uint8_t alloc;
// 1字节 max= 255
unsigned char flags;
// 字节数组 1结尾
char buf[];
};//4 n 长度
//key val关系
typedef struct dictEntry {
void *key;//64位系统占8字节 32位系统占4字节
void *val;//64位系统占8字节 32位系统占4字节
struct dictEntry *next; //64位系统占8字节 32位系统占4字节
} dictEntry; //占24字节开始计算embstr编码的：
key 是一个sds字符串，共计：10字节:
len alloc flags=3字节
buf[] = 6(5ycode) 1( )=7字节
dictEntry三个指针总和大小
entry:3*8= 24 字节
value 是一个robj sdshdr8: 26字节
robj结构体：16字节
sds中： len alloc flags:3字节
buf[] 6(yxkong) 1( )=7
共计：10 24 26=60 what？
memory usage 5ycode 打印的结果是56字节，手动算出来是60字节？
不对啊，开始撸代码
代码语言：javascript复制db.c
/**
* @brief 将对应的key 和 redisObject对象塞入到全局hash表中
*
* @param db
* @param key
* @param val
*/
void dbAdd(redisDb *db, robj *key, robj *val) {
//生成一个固定长度的sds字符串作为key（因为key没有动态扩容，所以不需要多申请空间）
sds copy = sdsdup(key->ptr);
//添加key,val 到全局hash表
int retval = dictAdd(db->dict, copy, val);
// 输出信息
serverAssertWithInfo(NULL,key,retval == DICT_OK);
if (val->type == OBJ_LIST ||
val->type == OBJ_ZSET)
//list和zset添加数据后会触发signalKeyAsReady（这里应该再加个stream，ps:stream已经单独处理了）
signalKeyAsReady(db, key);
if (server.cluster_enabled) slotToKeyAdd(key);
}
dict.c
/**
* @brief 添加一个key val到对应的hash表
* @param d 目标hash表
* @param key sds字符串 的指针
* @param val robj的指针
* @return int
*/
int dictAdd(dict *d, void *key, void *val)
{
dictEntry *entry = dictAddRaw(d,key,NULL);
if (!entry) return DICT_ERR;
//将val赋值给entry
dictSetVal(d, entry, val);
return DICT_OK;
}
object.c中
/**
* @brief 创建embstr字符串
* 好处是空间连续，只需创建一次
* @param ptr 字符串指针
* @param len 实际字符长度 小于44位
* @return robj* 在这里明确创建了一个SDS_TYPE_8类型的embstr
*/
robj *createEmbeddedStringObject(const char *ptr, size_t len) {
// 申请一个robj sdshrd8 的连续空间
//16 （3 1） len 最大64字节，这里会做内存对齐
robj *o = zmalloc(sizeof(robj) sizeof(struct sdshdr8) len 1);
//字符串结构体开始位置, 1是因为o->type o->encoding=1字节
/**
* 因为o是一个robj类型
* o 1等价于sizeof(o) 1 1表示o结构体的一个单位
* sizeof(o)就是robj类型的结构体大小
* 所以sh的指针就是在申请的内存空间里排除了robj对象的大小
*/
struct sdshdr8 *sh = (void*)(o 1);
o->type = OBJ_STRING;
o->encoding = OBJ_ENCODING_EMBSTR;
/**
* 这块刚开始还有点想不明白，为什么 1？
* 指针是可以在知道结构体类型的情况下，指针是可以自加操作，1个单位表示结构体的大小
* void 指针因为不知道结构体类型，所以无法自加，也可以防止误操作
*/
o->ptr = sh 1;
//占用4字节
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;
if (ptr == SDS_NOINIT)
sh->buf[len] = ' ';
else if (ptr) {
//将原来的字符串拷贝过去
memcpy(sh->buf,ptr,len);
sh->buf[len] = ' ';
} else {
memset(sh->buf,0,len 1);
}
return o;
}
图2没问题，我计算的没问题。
既然这样，我看下memory usage是怎么算的？
代码语言：javascript复制在object.c中
void memoryCommand(client *c) {
if (!strcasecmp(c->argv[1]->ptr,"usage") && c->argc >= 3) {
dictEntry *de;
long long samples = OBJ_COMPUTE_SIZE_DEF_SAMPLES;
for (int j = 3; j < c->argc; j ) {
if (!strcasecmp(c->argv[j]->ptr,"samples") &&
j 1 < c->argc)
{
if (getLongLongFromObjectOrReply(c,c->argv[j 1],&samples,NULL)
== C_ERR) return;
if (samples < 0) {
addReply(c,shared.syntaxerr);
return;
}
if (samples == 0) samples = LLONG_MAX;;
j ; /* skip option argument. */
} else {
addReply(c,shared.syntaxerr);
return;
}
}
if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
addReply(c, shared.nullbulk);
return;
}
//计算value的长度
size_t usage = objectComputeSize(dictGetVal(de),samples);
serverLog(LL_WARNING, "memoryCommand usage dictGetVal size:%d",usage);
//计算key的长度
usage = sdsAllocSize(dictGetKey(de));
serverLog(LL_WARNING, "memoryCommand usage dictGetVal dictGetKey size:%d",usage);
//计算dictEntry的长度
usage = sizeof(dictEntry);
serverLog(LL_WARNING, "memoryCommand usage dictGetVal dictGetKey dictEntry size:%d",usage);
addReplyLongLong(c,usage);
}
}
/**
* @brief 计算robj的大小
*
* @param o
* @param sample_size
* @return size_t
*/
size_t objectComputeSize(robj *o, size_t sample_size) {
sds ele, ele2;
dict *d;
dictIterator *di;
struct dictEntry *de;
size_t asize = 0, elesize = 0, samples = 0;
if (o->type == OBJ_STRING) {
if(o->encoding == OBJ_ENCODING_INT) {
//int类型，直接
asize = sizeof(*o);
} else if(o->encoding == OBJ_ENCODING_RAW) {
//raw编码申请空间的长度 结构体的长度
asize = sdsAllocSize(o->ptr) sizeof(*o);
} else if(o->encoding == OBJ_ENCODING_EMBSTR) {
//embstr实际字符串的使用长度 2 16，这块有点想不明白了
asize = sdslen(o->ptr) 2 sizeof(*o);
} else {
serverPanic("Unknown string encoding");
}
}
}加日志，编译启动
代码语言：javascript复制10284:M 08 Jan 2022 15:26:31.985 # memoryCommand usage dictGetVal size:24
10284:M 08 Jan 2022 15:26:31.985 # memoryCommand usage dictGetVal dictGetKey size:32
10284:M 08 Jan 2022 15:26:31.985 # memoryCommand usage dictGetVal dictGetKey dictEntry size:56从日志上看：
代码语言：javascript复制val ： 计算出来的是24 从代码算出来是26
dictGetKey ： 计算出来的是8 出代码算出来是10
dictEntry： 计算出来的是24 这个没问题key和val 各差了两字节；
- 在计算embstr类型val的长度时计算公式为：sdslen(o->ptr) 2 sizeof(*o)
- 计算key占用的空间时用的 sdsHdrSize(s[-1]) alloc 1。
val计算的逻辑有点不理解，但是key计算的逻辑没问题，怎么就少了2字节？
断点了下,有如下发现：
图3从内存中看key的前一位是0，也就是类型是sdshdr5
图4val 我就看不明白了
图5从上图可以看出key的结构体是一个sdshdr5的结构体。
然后我又撸了一遍代码
- 在接收的时候：createStringObject 通过createEmbeddedStringObject创建了sdshdr8类型的ebmstr字符串；
- 在setCommand 中通过tryObjectEncoding进行尝试压缩优化,但是val本身就是embstr类型了，这里什么都没做，日志输出也证明了；
- 在setGenericCommand中setKey->dbAdd 方法里sdsdup->sdsnewlen 在这里将key变成了sdshdr5
具体代码如下
代码语言：javascript复制/**
* @brief 初始化sds字符串
* 返回的是一个sds指针，这个指针是在对应的结构体开始指针 结构体大小
* @param init 初始化字符串
* @param initlen 初始化字符串的长度
* @return sds
*/
sds sdsnewlen(const void *init, size_t initlen) {
void *sh;
sds s;
//获取结构体的类型，在这里根据长度将key转成了sdshdr5
char type = sdsReqType(initlen); //重点
/* Empty strings are usually created in order to append. Use type 8
* since type 5 is not good at this. */
// SDS_TYPE_5并且字符串长度为0的情况下修复为SDS_TYPE_8
if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
//计算对应sds类型结构体的size
int hdrlen = sdsHdrSize(type);
unsigned char *fp; /* flags pointer. */
assert(hdrlen initlen 1 > initlen); /* Catch size_t overflow */
// 申请空间（结构体类型长度 字符串长度 1）
sh = s_malloc(hdrlen initlen 1);
// printf("key: %s initlen:%d type:%d hdrlen:%d size %d n",init,initlen,type,hdrlen,(hdrlen initlen 1));
if (init==SDS_NOINIT)
init = NULL;
else if (!init)
memset(sh, 0, hdrlen initlen 1);
if (sh == NULL) return NULL;
//s是在申请的sh指针的地址上，加上了结构体大小
s = (char*)sh hdrlen;
fp = ((unsigned char*)s)-1;
switch(type) {
case SDS_TYPE_5: {
*fp = type | (initlen << SDS_TYPE_BITS);
break;
}
}
if (initlen && init)
memcpy(s, init, initlen);
s[initlen] = ' ';
return s;
}顺带梳理了下set命令tryObjectEncoding的逻辑
图6key的计算没问题了，就剩val了
然后我添加各种日志，从接收参数到执行命令对应的sds类型一直是1.
代码语言：javascript复制15299:M 08 Jan 2022 21:07:58.742 # processMultibulkBuffer param:set type:1
15299:M 08 Jan 2022 21:07:58.742 # processMultibulkBuffer param:5ycode type:1
15299:M 08 Jan 2022 21:07:58.742 # processMultibulkBuffer param:yxkong type:1
15299:M 08 Jan 2022 21:07:58.742 # processCommand call before param:yxkong type:1
15299:M 08 Jan 2022 21:07:58.742 # call before param:yxkong type:1
15299:M 08 Jan 2022 21:07:58.742 # setCommand tryObjectEncoding before param:yxkong type:1
15299:M 08 Jan 2022 21:07:58.742 # setCommand tryObjectEncoding after param:yxkong type:1
15299:M 08 Jan 2022 21:07:58.742 # setCommand setGenericCommand after param:yxkong type:1想不明白，然后去github上查。
代码语言：javascript复制https://github.com/redis/redis/issues/6263
https://github.com/redis/redis/pull/6198大意是在申请内存的时候，使用了内存对齐，然后将对齐内存后的大小，增加到了used_memory上（在zmalloc.c中），用于标记申请的总内存，这些对齐的内存叫内存碎片。这和jemalloc有关。
在objectComputeSize上，注释也说返回的结果是一个近似值,特别是在集合类型下，那我想string类型应该是准确的吧，但是也单对embstr的结果计算是不准确的。
redis的作者基于什么样的考量这么设计？后续有空了再跟进下。
最后更新下从代码层面梳理的数据结构图：
图7原文：
redis源码阅读-终于把内存占用算清楚了 - 墨天轮 (modb.pro)
