Go 存儲編程怎么使用 O_DIRECT 模式？

今天分享一個存儲細(xì)節(jié)，Go 存儲編程怎么使用 O_DIRECT 模式？

之前提過很多次，操作系統(tǒng)的 IO 過文件系統(tǒng)的時候，默認(rèn)是會使用到 page cache，并且采用的是 write back 的方式，系統(tǒng)異步刷盤的。由于是異步的，如果在數(shù)據(jù)還未刷盤之前，掉電的話就會導(dǎo)致數(shù)據(jù)丟失。

如果想要明確數(shù)據(jù)寫到磁盤有兩種方式：要么就每次寫完主動 sync 一把，要么就使用 direct io 的方式，指明每一筆 io 數(shù)據(jù)都要寫到磁盤才返回。

那么在 Go 里面怎么使用 direct io 呢？

有同學(xué)可能會說，那還不簡單，open 文件的時候 flag 用 O_DIRECT 嘛，然后。。。

是嗎？有這么簡單嗎？

提兩個問題，童鞋們可以先思考下：

• O_DIRECT 這個定義在 Go 標(biāo)準(zhǔn)庫的哪個文件？
• direct io 需要 io 大小和偏移扇區(qū)對齊，且還要滿足內(nèi)存 buffer 地址的對齊，這個怎么做到？

O_DIRECT 的知識點(diǎn)

在此之前，先回顧 O_DIRECT 相關(guān)的知識。direct io 也就是常說的 DIO，是在 Open 的時候通過 flag 來指定 O_DIRECT 參數(shù)，之后的數(shù)據(jù)的 write/read 都是繞過 page cache，直接和磁盤操作，從而避免了掉電丟數(shù)據(jù)的尷尬局面，同時也讓應(yīng)用層可以自己決定內(nèi)存的使用（避免不必要的 cache 消耗）。

direct io 一般解決兩個問題：

• 數(shù)據(jù)落盤，確保掉電不丟失；
• 減少內(nèi)核 page cache 的內(nèi)存使用，業(yè)務(wù)層自己控制內(nèi)存，更加靈活；

direct io 模式需要用戶保證對齊規(guī)則，否則 IO 會報錯，有 3 個需要對齊的規(guī)則：

• IO 的大小必須扇區(qū)大小（512字節(jié)）對齊
• IO 偏移按照扇區(qū)大小對齊；
• 內(nèi)存 buffer 的地址也必須是扇區(qū)對齊；

思考標(biāo)題

為什么 Go 的 O_DIRECT 知識點(diǎn)值得一提？

以下按照兩層意思分析思考。

第一層意思：O_DIRECT 平臺不兼容

劃重點(diǎn)：Go 標(biāo)準(zhǔn)庫 os 中的是沒有 O_DIRECT 這個參數(shù)的。

為什么呢？

Go os 庫實(shí)現(xiàn)的是各個操作系統(tǒng)兼容的實(shí)現(xiàn)，direct io 這個在不同的操作系統(tǒng)下實(shí)現(xiàn)形態(tài)不一樣。其實(shí) O_DIRECT 這個 Open flag 參數(shù)本就是只存在于 linux 系統(tǒng)。

以下才是各個平臺兼容的 Open 參數(shù) ( os/file.go )。

const (
   // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
   O_RDONLY int = syscall.O_RDONLY // open the file read-only.
   O_WRONLY int = syscall.O_WRONLY // open the file write-only.
   O_RDWR   int = syscall.O_RDWR   // open the file read-write.
   // The remaining values may be or'ed in to control behavior.
   O_APPEND int = syscall.O_APPEND // append data to the file when writing.
   O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
   O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
   O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
   O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
)

發(fā)現(xiàn)了嗎？O_DIRECT 根本不在其中。O_DIRECT 其實(shí)是和系統(tǒng)平臺強(qiáng)相關(guān)的一個參數(shù)。

問題來了，那么 O_DIRECT 定義在那里？

跟操作系統(tǒng)強(qiáng)相關(guān)的自然是定義在 syscall 庫中：

// syscall/zerrors_linux_amd64.go
const (
    // ...
 O_DIRECT                         = 0x4000
)

怎么打開文件呢？

// +build linux
// 指明在 linux 平臺系統(tǒng)編譯
fp := os.OpenFile(name, syscall.O_DIRECT|flag, perm)

第二層意思：Go 無法精確控制內(nèi)存分配地址

標(biāo)準(zhǔn)庫或者內(nèi)置函數(shù)沒有提供讓你分配對齊內(nèi)存的函數(shù)。

direct io 必須要滿足 3 種對齊規(guī)則：io 偏移扇區(qū)對齊，長度扇區(qū)對齊，內(nèi)存 buffer 地址扇區(qū)對齊。前兩個還比較好滿足，但是分配的內(nèi)存地址作為一個小程序員無法精確控制。

先對比回憶下 c 語言，libc 庫是調(diào)用 posix_memalign 直接分配出符合要求的內(nèi)存塊。go 里面怎么做？

先問個問題：Go 里面怎么分配 buffer 內(nèi)存？

io 的 buffer 其實(shí)就是字節(jié)數(shù)組嘛，很好回答，最常見自然是用 make 來分配，如下：

buffer := make([]byte, 4096)

那這個地址是對齊的嗎？

答案是：不確定。

那怎么才能獲取到對齊的地址呢？

劃重點(diǎn)：方法很簡單，就是先分配一個比預(yù)期要大的內(nèi)存塊，然后在這個內(nèi)存塊里找對齊位置。 這是一個任何語言皆通用的方法，在 Go 里也是可用的。

什么意思？

比如，我現(xiàn)在需要一個 4096 大小的內(nèi)存塊，要求地址按照 512 對齊，可以這樣做：

• 先分配要給 4096 + 512 大小的內(nèi)存塊，假設(shè)得到的地址是 p1 ;
• 然后在 [ p1, p1+512 ] 這個地址范圍找，一定能找到 512 對齊的地址（這個能理解嗎？），假設(shè)這個地址是 p2 ;
• 返回 p2 這個地址給用戶使用，用戶能正常使用 [ p2, p2 + 4096 ] 這個范圍的內(nèi)存塊而不越界；

以上就是基本原理了，童鞋理解了不？下面看下代碼怎么寫。

const (
    AlignSize = 512
)
// 在 block 這個字節(jié)數(shù)組首地址，往后找，找到符合 AlignSize 對齊的地址，并返回
// 這里用到位操作，速度很快；
func alignment(block []byte, AlignSize int) int {
   return int(uintptr(unsafe.Pointer(&block[0])) & uintptr(AlignSize-1))
}
// 分配 BlockSize 大小的內(nèi)存塊
// 地址按照 512 對齊
func AlignedBlock(BlockSize int) []byte {
   // 分配一個，分配大小比實(shí)際需要的稍大
   block := make([]byte, BlockSize+AlignSize)
   // 計算這個 block 內(nèi)存塊往后多少偏移，地址才能對齊到 512 
   a := alignment(block, AlignSize)
   offset := 0
   if a != 0 {
      offset = AlignSize - a
   }
   // 偏移指定位置，生成一個新的 block，這個 block 將滿足地址對齊 512；
   block = block[offset : offset+BlockSize]
   if BlockSize != 0 {
      // 最后做一次校驗(yàn) 
      a = alignment(block, AlignSize)
      if a != 0 {
         log.Fatal("Failed to align block")
      }
   }
   return block
}

所以，通過以上 AlignedBlock 函數(shù)分配出來的內(nèi)存一定是 512 地址對齊的。

有啥缺點(diǎn)嗎？

浪費(fèi)空間嘛。 命名需要 4k 內(nèi)存，實(shí)際分配了 4k+512 。

我太懶了，一行代碼都不愿多寫，有開源的庫嗎？

還真有，推薦個：https://github.com/ncw/directio ，內(nèi)部實(shí)現(xiàn)極其簡單，就是上面的一樣。

使用姿勢很簡單：

步驟一：O_DIRECT 模式打開文件：

// 創(chuàng)建句柄
fp, err := directio.OpenFile(file, os.O_RDONLY, 0666)

封裝關(guān)鍵在于：O_DIRECT 是從 syscall 庫獲取的。

步驟二：讀數(shù)據(jù)

// 創(chuàng)建地址按照 4k 對齊的內(nèi)存塊
buffer := directio.AlignedBlock(directio.BlockSize)
// 把文件數(shù)據(jù)讀到內(nèi)存塊中
_, err := io.ReadFull(fp, buffer)

關(guān)鍵在于：buffer 必須是特制的 [ ]byte 數(shù)組，而不能僅僅根據(jù) make([ ]byte, 512 ) 這樣去創(chuàng)建，因?yàn)閮H僅是 make 無法保證地址對齊。

總結(jié)

• direct io 必須滿足 io 大小，偏移，內(nèi)存 buffer 地址三者都扇區(qū)對齊；
• O_DIRECT 不在 os 庫，而在于操作系統(tǒng)相關(guān)的 syscall 庫；
• Go 中無法直接使用 make 來分配對齊內(nèi)存，一般的做法是分配一塊大一點(diǎn)的內(nèi)存，然后在里面找到對齊的地址即可；

以上就是Go存儲基礎(chǔ)使用direct io方法實(shí)例的詳細(xì)內(nèi)容，更多關(guān)于Go存儲direct io 的資料請關(guān)注腳本之家其它相關(guān)文章！