深入剖析 redis RDB 持久化策略
簡介 redis 持久化 RDB、AOF
redis 提供兩種持久化方式：RDB 和 AOF。redis 允許兩者結合，也允許兩者同時關閉。
- RDB 可以定時備份內存中的數據集。服務器啟動的時候，可以從 RDB 文件中回復數據集。
- AOF 可以記錄服務器的所有寫操作。在服務器重新啟動的時候，會把所有的寫操作重新執行一遍，從而實現數據備份。當寫操作集過大（比原有的數據集還大），redis 會重寫寫操作集。
本篇主要講的是 RDB 持久化，了解 RDB 的數據保存結構和運作機制。redis 主要在 rdb.h 和 rdb.c 兩個文件中實現 RDB 的操作。
數據結構 rio
持久化的 IO 操作在 rio.h 和 rio.c 中實現，核心數據結構是 struct rio。RDB 中的幾乎每一個函數都帶有 rio 參數。struct rio 既適用于文件，又適用于內存緩存，從 struct rio 的實現可見一斑。
struct _rio {
// 函數指針，包括讀操作，寫操作和文件指針移動操作
/* Backend functions.
* Since this functions do not tolerate short writes or reads the return
* value is simplified to: zero on error, non zero on complete success. */
size_t (*read)(struct _rio *, void *buf, size_t len);
size_t (*write)(struct _rio *, const void *buf, size_t len);
off_t (*tell)(struct _rio *);
// 校驗和計算函數
/* The update_cksum method if not NULL is used to compute the checksum of
* all the data that was read or written so far. The method should be
* designed so that can be called with the current checksum, and the buf
* and len fields pointing to the new block of data to add to the checksum
* computation. */
void (*update_cksum)(struct _rio *, const void *buf, size_t len);
// 校驗和
/* The current checksum */
uint64_t cksum;
// 已經讀取或者寫入的字符數
/* number of bytes read or written */
size_t processed_bytes;
// 每次最多能處理的字符數
/* maximum single read or write chunk size */
size_t max_processing_chunk;
// 可以是一個內存總的字符串，也可以是一個文件描述符
/* Backend-specific vars. */
union {
struct {
sds ptr;
// 偏移量
off_t pos;
} buffer;
struct {
FILE *fp;
// 偏移量
off_t buffered; /* Bytes written since last fsync. */
off_t autosync; /* fsync after 'autosync' bytes written. */
} file;
} io;
};
typedef struct _rio rio;</pre>
redis 定義兩個 struct rio，分別是 rioFileIO 和 rioBufferIO，前者用于內存緩存，后者用于文件 IO：
// 適用于內存緩存
static const rio rioBufferIO = {
rioBufferRead,
rioBufferWrite,
rioBufferTell,
NULL, / update_checksum /
0, / current checksum /
0, / bytes read or written /
0, / read/write chunk size /
{ { NULL, 0 } } / union for io-specific vars /
};
// 適用于文件 IO
static const rio rioFileIO = {
rioFileRead,
rioFileWrite,
rioFileTell,
NULL, / update_checksum /
0, / current checksum /
0, / bytes read or written /
0, / read/write chunk size /
{ { NULL, 0 } } / union for io-specific vars /
};</pre>
RDB 持久化的運作機制
redis 支持兩種方式進行 RDB：當前進程執行和后臺執行（BGSAVE）。RDB BGSAVE 策略是 fork 出一個子進程，把內存中的數據集整個 dump 到硬盤上。兩個場景舉例：
- redis 服務器初始化過程中，設定了定時事件，每隔一段時間就會觸發持久化操作；進入定時事件處理程序中，就會 fork 產生子進程執行持久化操作。
- redis 服務器預設了 save 指令，客戶端可要求服務器進程中斷服務，執行持久化操作。
這里主要展開的內容是 RDB 持久化操作的寫文件過程，讀過程和寫過程相反。子進程的產生發生在 rdbSaveBackground() 中，真正的 RDB 持久化操作是在 rdbSave()，想要直接進行 RDB 持久化，調用 rdbSave() 即可。
以下主要以代碼的方式來展開 RDB 的運作機制：
// 備份主程序
/ Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success /
int rdbSave(char filename) {
dictIterator di = NULL;
dictEntry de;
char tmpfile[256];
char magic[10];
int j;
long long now = mstime();
FILE fp;
rio rdb;
uint64_t cksum;
// 打開文件，準備寫
snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
fp = fopen(tmpfile,"w");
if (!fp) {
redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
strerror(errno));
return REDIS_ERR;
}
// 初始化 rdb 結構體。rdb 結構體內指定了讀寫文件的函數，已寫/讀字符統計等數據
rioInitWithFile(&rdb,fp);
if (server.rdb_checksum) // 校驗和
rdb.update_cksum = rioGenericUpdateChecksum;
// 先寫入版本號
snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
if (rdbWriteRaw(&rdb,magic,9) == -1) goto werr;
for (j = 0; j < server.dbnum; j++) {
// server 中保存的數據
redisDb *db = server.db+j;
// 字典
dict *d = db->dict;
if (dictSize(d) == 0) continue;
// 字典迭代器
di = dictGetSafeIterator(d);
if (!di) {
fclose(fp);
return REDIS_ERR;
}
// 寫入 RDB 操作碼
/* Write the SELECT DB opcode */
if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
// 寫入數據庫序號
if (rdbSaveLen(&rdb,j) == -1) goto werr;
// 寫入數據庫中每一個數據項
/* Iterate this DB writing every entry */
while((de = dictNext(di)) != NULL) {
sds keystr = dictGetKey(de);
robj key,
*o = dictGetVal(de);
long long expire;
// 將 keystr 封裝在 robj 里
initStaticStringObject(key,keystr);
// 獲取過期時間
expire = getExpire(db,&key);
// 開始寫入磁盤
if (rdbSaveKeyValuePair(&rdb,&key,o,expire,now) == -1) goto werr;
}
dictReleaseIterator(di);
}
di = NULL; /* So that we don't release it again on error. */
// RDB 結束碼
/* EOF opcode */
if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_EOF) == -1) goto werr;
// 校驗和
/* CRC64 checksum. It will be zero if checksum computation is disabled, the
* loading code skips the check in this case. */
cksum = rdb.cksum;
memrev64ifbe(&cksum);
rioWrite(&rdb,&cksum,8);
// 同步到磁盤
/* Make sure data will not remain on the OS's output buffers */
fflush(fp);
fsync(fileno(fp));
fclose(fp);
// 修改臨時文件名為指定文件名
/* Use RENAME to make sure the DB file is changed atomically only
* if the generate DB file is ok. */
if (rename(tmpfile,filename) == -1) {
redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
unlink(tmpfile);
return REDIS_ERR;
}
redisLog(REDIS_NOTICE,"DB saved on disk");
server.dirty = 0;
// 記錄成功執行保存的時間
server.lastsave = time(NULL);
// 記錄執行的結果狀態為成功
server.lastbgsave_status = REDIS_OK;
return REDIS_OK;
werr:
// 清理工作，關閉文件描述符等
fclose(fp);
unlink(tmpfile);
redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
if (di) dictReleaseIterator(di);
return REDIS_ERR;
}
// bgsaveCommand(),serverCron(),syncCommand(),updateSlavesWaitingBgsave() 會調用 rdbSaveBackground()
int rdbSaveBackground(char *filename) {
pid_t childpid;
long long start;
// 已經有后臺程序了，拒絕再次執行
if (server.rdb_child_pid != -1) return REDIS_ERR;
server.dirty_before_bgsave = server.dirty;
// 記錄這次嘗試執行持久化操作的時間
server.lastbgsave_try = time(NULL);
start = ustime();
if ((childpid = fork()) == 0) {
int retval;
// 取消監聽
/* Child */
closeListeningSockets(0);
redisSetProcTitle("redis-rdb-bgsave");
// 執行備份主程序
retval = rdbSave(filename);
// 臟數據，其實就是子進程所消耗的內存大小
if (retval == REDIS_OK) {
// 獲取臟數據大小
size_t private_dirty = zmalloc_get_private_dirty();
// 記錄臟數據
if (private_dirty) {
redisLog(REDIS_NOTICE,
"RDB: %zu MB of memory used by copy-on-write",
private_dirty/(1024*1024));
}
}
// 退出子進程
exitFromChild((retval == REDIS_OK) ? 0 : 1);
} else {
/* Parent */
// 計算 fork 消耗的時間
server.stat_fork_time = ustime()-start;
// fork 出錯
if (childpid == -1) {
// 記錄執行的結果狀態為失敗
server.lastbgsave_status = REDIS_ERR;
redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
strerror(errno));
return REDIS_ERR;
}
redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
// 記錄保存的起始時間
server.rdb_save_time_start = time(NULL);
// 子進程 ID
server.rdb_child_pid = childpid;
updateDictResizePolicy();
return REDIS_OK;
}
return REDIS_OK; /* unreached */
}</pre>
如果采用 BGSAVE 策略，且內存中的數據集很大，fork() 會因為要為子進程產生一份虛擬空間表而花費較長的時間；如果此時客戶端請求數量非常大的話，會導致較多的寫時拷貝操作；在 RDB 持久化操作過程中，每一個數據都會導致 write() 系統調用，CPU 資源很緊張。因此，如果在一臺物理機上部署多個 redis，應該避免同時持久化操作。
那如何知道 BGSAVE 占用了多少內存？子進程在結束之前，讀取了自身私有臟數據 Private_Dirty 的大小，這樣做是為了讓用戶看到 redis 的持久化進程所占用了有多少的空間。在父進程 fork 產生子進程過后，父子進程雖然有不同的虛擬空間，但物理空間上是共存的，直至父進程或者子進程修改內存數據為止，所以臟數據 Private_Dirty 可以近似的認為是子進程，即持久化進程占用的空間。
RDB 數據的組織方式
RDB 的文件組織方式為：數據集序號1：操作碼：數據1：結束碼：校驗和—-數據集序號2：操作碼：數據2：結束碼：校驗和……
其中，數據的組織方式為：過期時間：數據類型：鍵：值，即 TVL（type，length，value)。
舉兩個字符串存儲的例子，其他的大概都以至于的形式來組織數據：
可見，RDB 持久化的結果是一個非常緊湊的文件，幾乎每一位都是有用的信息。如果對 redis RDB 數據組織方式的細則感興趣，可以參看 rdb.h 和 rdb.c 兩個文件的實現。
對于每一個鍵值對都會調用 rdbSaveKeyValuePair()，如下：
int rdbSaveKeyValuePair(rio rdb, robj key, robj val,
long long expiretime, long long now)
{
// 過期時間
/ Save the expire time /
if (expiretime != -1) {
/ If this key is already expired skip it */
if (expiretime < now) return 0;
if (rdbSaveType(rdb,REDIS_RDB_OPCODE_EXPIRETIME_MS) == -1) return -1;
if (rdbSaveMillisecondTime(rdb,expiretime) == -1) return -1;
}
/* Save type, key, value */
// 數據類型
if (rdbSaveObjectType(rdb,val) == -1) return -1;
// 鍵
if (rdbSaveStringObject(rdb,key) == -1) return -1;
// 值
if (rdbSaveObject(rdb,val) == -1) return -1;
return 1;
}</pre>
如果對 redis RDB 數據格式細則感興趣，歡迎訪問我的 github & 歡迎討論。
參考文檔
http://redis.io/topics/persistence
—-
搗亂 2014-3-26