Redis 底层数据结构 - litter-fish/ReadSource GitHub Wiki

struct sdshdr {
    // buf数组已经存储的字符长度
    unsigned int len;
    // buf数组未使用的字符长度
    unsigned int free;
    // 字节数组，用于保存字符串
    char buf[];
};

typedef struct listNode {
    // 前置节点
    struct listNode *prev;
    // 后置节点
    struct listNode *next;
    // 节点的值
    void *value;
} listNode;

typedef struct list {
    // 表头
    listNode *head;
    // 表尾
    listNode *tail;
    // 节点值复制函数
    void *(*dup)(void *ptr);
    // 节点值释放函数
    void (*free)(void *ptr);
    // 节点值对比函数
    int (*match)(void *ptr, void *key);
    // 链表包含节点个数
    unsigned long len;
} list;

typedef struct dictEntry {
    // 键
    void *key;
    // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    // 指向下一个哈希表节点，用于解决哈希冲突
    struct dictEntry *next;
} dictEntry;

typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
    // 哈希表大小
    unsigned long size;
    // 哈希表大小掩码，用于计算索引值，等于size-1
    unsigned long sizemask;
    // 该哈希表已有节点的个数，
    unsigned long used;
} dictht;

typedef struct dict {
    // 
    dictType *type;
    void *privdata;
    // 一般情况下只会使用ht[0]的哈希表，ht[1]哈希表之后在对ht[0]进行rehash的时候使用
    dictht ht[2];
    // 记录rehash进度
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    int iterators; /* number of iterators currently running */
} dict;

typedef struct zskiplistNode {
    // 成员对象
    robj *obj;
    // 分值
    double score;
    // 后退指针
    struct zskiplistNode *backward;
    // 层
    struct zskiplistLevel {
        // 前进指针
        struct zskiplistNode *forward;
        // 跨度
        unsigned int span;
    } level[];
} zskiplistNode;

typedef struct zskiplist {
    // 表头节点、表尾节点
    struct zskiplistNode *header, *tail;
    // 表中节点数量
    unsigned long length;
    // 表中节点层数最大的
    int level;
} zskiplist;

typedef struct intset {
    // 集合编码方式
    uint32_t encoding;
    // 集合元素个数
    uint32_t length;
    // 集合内容
    int8_t contents[];
} intset;

typedef struct redisObject {
    // 类型
    unsigned type:4;
    // 编码
    unsigned encoding:4;
    // 对象最后一次被访问的时间
    unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
    // 对象被引用次数，使用引用计数器算法进行内存回收
    int refcount;
    // 指向底层实现数据结构的指针
    void *ptr;
} robj;

struct redisServer {
    ......
    // 服务器维护一个与之相连的客户端列表
    list *clients;              /* List of active clients */
    .....
};

typedef struct redisClient {
    uint64_t id;            /* Client incremental unique ID. */
    // 套接字描述符，-1表示一个伪客户端，AOF还原数据时使用
    int fd;
    redisDb *db;
    int dictid;
    // 客户端名称
    robj *name;             /* As set by CLIENT SETNAME */
    // 客户端的输入缓冲区，保存客户端发送的命令请求
    sds querybuf;
    size_t querybuf_peak;   /* Recent (100ms or more) peak of querybuf size */
    
    // 服务器对接收到的命令进行解析，将解析的命令参数个数和命令参数保存到argc和argv属性中
    int argc;
    robj **argv;
    
    // 服务器根据argv[0]中的值去命令表中查找对应的命令函数。
    struct redisCommand *cmd, *lastcmd;
    
    int reqtype;
    int multibulklen;       /* number of multi bulk arguments left to read */
    long bulklen;           /* length of bulk argument in multi bulk request */
    
    
    unsigned long reply_bytes; /* Tot bytes of objects in reply list */
    int sentlen;            /* Amount of bytes already sent in the current
                               buffer or object being sent. */
    // 记录客户端创建时间
    time_t ctime;           /* Client creation time */
    // 客户端与服务端最后一次互动时间，可用于计算客户端的空转时间
    time_t lastinteraction; /* time of the last interaction, used for timeout */
    // 输出缓冲区第一次到达软性限制时间
    time_t obuf_soft_limit_reached_time;
    // 标示客户端的角色、以及目前客户端所处状态
    int flags;              /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
    // 表示客户端是否通过认证，0 - 未通过认证，除AUTH命令其他命令将被拒绝，
    int authenticated;      /* when requirepass is non-NULL */
    
    int replstate;          /* replication state if this is a slave */
    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
    int repldbfd;           /* replication DB file descriptor */
    off_t repldboff;        /* replication DB file offset */
    off_t repldbsize;       /* replication DB file size */
    sds replpreamble;       /* replication DB preamble. */
    long long reploff;      /* replication offset if this is our master */
    long long repl_ack_off; /* replication ack offset, if this is a slave */
    long long repl_ack_time;/* replication ack time, if this is a slave */
    long long psync_initial_offset; /* FULLRESYNC reply offset other slaves
                                       copying this slave output buffer
                                       should use. */
    char replrunid[REDIS_RUN_ID_SIZE+1]; /* master run id if this is a master */
    int slave_listening_port; /* As configured with: SLAVECONF listening-port */
    int slave_capa;         /* Slave capabilities: SLAVE_CAPA_* bitwise OR. */
    multiState mstate;      /* MULTI/EXEC state */
    blockingState bpop;   /* blocking state */
    list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
    dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
    list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
    sds peerid;             /* Cached peer ID. */

    /* Response buffer */
    // 命令回复缓冲区，一个固定大小的内存，用于存储长度比较小的回复，REDIS_REPLY_CHUNK_BYTES=16kb
    int bufpos; // 记录buf目前使用的字节数量
    char buf[REDIS_REPLY_CHUNK_BYTES];
    
    // 一个可变长的回复缓冲区，通过使用链表来连接多个字符串，服务器可以为客户端保存比较长的回复
    list *reply;
} redisClient;

struct redisCommand {
    // 命令名字
    char *name;
    // 命令的实现函数
    redisCommandProc *proc;
    // 命令参数个数，用于检测命令请求的格式是否正确
    int arity;
    // 命令的属性标识，命令是写命令、读命令
    char *sflags; /* Flags as string representation, one char per flag. */
    // 对sflags分析得到的二进制标识
    int flags;    /* The actual flags, obtained from the 'sflags' field. */
    /* Use a function to determine keys arguments in a command line. */
    redisGetKeysProc *getkeys_proc;
    /* What keys should be loaded in background when calling this command? */
    int firstkey; /* The first argument that's a key (0 = no keys) */
    int lastkey;  /* The last argument that's a key */
    int keystep;  /* The step between first and last key */
    // 服务器执行这个命令所耗费的总时长，服务器总共执行了多少次这个命令
    long long microseconds, calls;
};

void initServerConfig(void) {
    int j;

    // 设置服务器的运行ID
    getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);
    // 设置默认配置文件路径
    server.configfile = NULL;
    server.hz = REDIS_DEFAULT_HZ;
    // 为运行ID加上结尾字符
    server.runid[REDIS_RUN_ID_SIZE] = '\0';
    // 设置服务器运行架构
    server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
    // 设置默认端口
    server.port = REDIS_SERVERPORT;
    
     // 命令表初始化
    server.commands = dictCreate(&commandTableDictType,NULL);
    server.orig_commands = dictCreate(&commandTableDictType,NULL);
    populateCommandTable();
    server.delCommand = lookupCommandByCString("del");
    server.multiCommand = lookupCommandByCString("multi");
    server.lpushCommand = lookupCommandByCString("lpush");
    server.lpopCommand = lookupCommandByCString("lpop");
    server.rpopCommand = lookupCommandByCString("rpop");

    /* Slow log */
    server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
    server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;

    /* Latency monitor */
    server.latency_monitor_threshold = REDIS_DEFAULT_LATENCY_MONITOR_THRESHOLD;

    /* Debugging */
    server.assert_failed = "<no assertion failed>";
    server.assert_file = "<no file>";
    server.assert_line = 0;
    server.bug_report_start = 0;
    server.watchdog_period = 0;
}

void loadDataFromDisk(void) {
    long long start = ustime();
    // 如果开启aof，则使用aof进行还原
    if (server.aof_state == REDIS_AOF_ON) {
        if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)
            redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        // 没有开启AOF则使用RDB进行还原
        if (rdbLoad(server.rdb_filename) == REDIS_OK) {
            redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
            redisLog(REDIS_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));
            exit(1);
        }
    }
}