1 mmap 简介

In computing, mmap is a POSIX-compliant Unix system call that maps files or devices into memory. It is a method of memory-mapped file I/O.
— mmap - wikipedia.org
简单理解，mmap 是一种将文件/设备映射到内存的方法，实现文件的磁盘地址和进程虚拟地址空间中的一段虚拟地址的一一映射关系。也就是说，可以在某个进程中通过操作这一段映射的内存，实现对文件的读写等操作。修改了这一段内存的内容，文件对应位置的内容也会同步修改，而读取这一段内存的内容，相当于读取文件对应位置的内容。

mmap 另一个非常重要的特性是：减少内存的拷贝次数。在 linux 系统中，文件的读写操作通常通过 read 和 write 这两个系统调用来实现，这个过程会产生频繁的内存拷贝。比如 read 函数就涉及了 2 次内存拷贝：

  1. 操作系统读取磁盘文件到页缓存；
  2. 从页缓存将数据拷贝到 read 传递的 buf 中(例如进程中创建的byte数组)。

而mmap 只需要一次拷贝。即操作系统读取磁盘文件到页缓存，进程内部直接通过指针方式修改映射的内存。因此 mmap 特别适合读写频繁的场景，既减少了内存拷贝次数，提高效率，又简化了操作。KV数据库 bbolt 就使用了这个方法持久化数据。

2 标准库 mmap

Go 语言标准库 golang.org/x/exp/mmap 仅实现了 read 操作，后续能否支持 write 操作未知。使用场景非常有限。看一个简单的例子：

从第4个byte开始，读取 tmp.txt 2个byte的内容。

  1. package main
  2. import (
  3.     "fmt"
  4.     "golang.org/x/exp/mmap"
  5. )
  6. func main() {
  7.     at, _ := mmap.Open("./tmp.txt")
  8.     buff := make([]byte, 2)
  9.     _, _ = at.ReadAt(buff, 4)
  10.     _ = at.Close()
  11.     fmt.Println(string(buff))
  12. }
  1. $ echo "abcdefg" > tmp.txt
  2. $ go run .
  3. ef

如果使用 os.File 操作，代码几乎是一样的，os.File 还支持写操作 WriteAt：

  1. package main
  2. import (
  3.     "fmt"
  4.     "os"
  5. )
  6. func main() {
  7.     f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
  8.     _, _ = f.WriteAt([]byte("abcdefg"), 0)
  9.     buff := make([]byte, 2)
  10.     _, _ = f.ReadAt(buff, 4)
  11.     _ = f.Close()
  12.     fmt.Println(string(buff))
  13. }

3 mmap(linux)

如果要支持 write 操作，那么就需要直接调用 mmap 的系统调用来实现了。Linux 和 Windows 都支持 mmap，但接口有所不同。对于 linux 系统，mmap 方法定义如下：

  1. func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error)

每个参数的含义分别是：

  1. - fd：待映射的文件描述符。
  2. - offset：映射到内存区域的起始位置，0 表示由内核指定内存地址。
  3. - length：要映射的内存区域的大小。
  4. - prot：内存保护标志位，可以通过或运算符`|`组合
  5.     - PROT_EXEC  // 页内容可以被执行
  6.     - PROT_READ  // 页内容可以被读取
  7.     - PROT_WRITE // 页可以被写入
  8.     - PROT_NONE  // 页不可访问
  9. - flags：映射对象的类型，常用的是以下两类
  10.     - MAP_SHARED  // 共享映射，写入数据会复制回文件, 与映射该文件的其他进程共享。
  11.     - MAP_PRIVATE // 建立一个写入时拷贝的私有映射，写入数据不影响原文件。

首先定义2个常量和数据类型Demo：

  1. const defaultMaxFileSize = 1 << 30        // 假设文件最大为 1G
  2. const defaultMemMapSize = 128 * (1 << 20) // 假设映射的内存大小为 128M
  3. type Demo struct {
  4.     file    *os.File
  5.     data    *[defaultMaxFileSize]byte
  6.     dataRef []byte
  7. }
  8. func _assert(condition bool, msg string, v ...interface{}) {
  9.     if !condition {
  10.         panic(fmt.Sprintf(msg, v...))
  11.     }
  12. }
  • 内存有换页机制，映射的物理内存可以远小于文件。
  • Demo结构体由3个字段构成，file 即文件描述符，data 是映射内存的起始地址，dataRef 用于后续取消映射。

定义 mmap, grow, ummap 三个方法：

  1. func (demo *Demo) mmap() {
  2.     b, err := syscall.Mmap(int(demo.file.Fd()), 0, defaultMemMapSize, syscall.PROT_WRITE|syscall.PROT_READ, syscall.MAP_SHARED)
  3.     _assert(err == nil, "failed to mmap", err)
  4.     demo.dataRef = b
  5.     demo.data = (*[defaultMaxFileSize]byte)(unsafe.Pointer(&b[0]))
  6. }
  7. func (demo *Demo) grow(size int64) {
  8.     if info, _ := demo.file.Stat(); info.Size() >= size {
  9.         return
  10.     }
  11.     _assert(demo.file.Truncate(size) == nil, "failed to truncate")
  12. }
  13. func (demo *Demo) munmap() {
  14.     _assert(syscall.Munmap(demo.dataRef) == nil, "failed to munmap")
  15.     demo.data = nil
  16.     demo.dataRef = nil
  17. }
  • mmap 传入的内存保护标志位为 syscall.PROT_WRITE|syscall.PROT_READ，即可读可写，映射类型为 syscall.MAP_SHARED，即对内存的修改会同步到文件。
  • syscall.Mmap 返回的是一个切片对象，需要从该切片中获取到内存的起始地址，并转换为可操作的 byte 数组，byte数组的长度为 defaultMaxFileSize。
  • grow 用于修改文件的大小，Linux 不允许操作超过文件大小之外的内存地址。例如文件大小为 4K，可访问的地址是data[0~4095]，如果访问 data[10000] 会报错。
  • munmap 用于取消映射。

在文件中写入 hello, geektutu!

  1. func main() {
  2.     _ = os.Remove("tmp.txt")
  3.     f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
  4.     demo := &Demo{file: f}
  5.     demo.grow(1)
  6.     demo.mmap()
  7.     defer demo.munmap()
  8.     msg := "hello geektutu!"
  9.     demo.grow(int64(len(msg) * 2))
  10.     for i, v := range msg {
  11.         demo.data[2*i] = byte(v)
  12.         demo.data[2*i+1] = byte(' ')
  13.     }
  14. }
  • 在调用 mmap 之前，调用了 grow(1)，因为在 mmap 中使用 &b[0] 获取到映射内存的起始地址，所以文件大小至少为 1 byte。
  • 接下来，便是通过直接操作 demo.data，修改文件内容了。

运行：

  1. $ go run .
  2. $ cat tmp.txt
  3. h e l l o   g e e k t u t u !

4 mmap(Windows)

相对于 Linux，Windows 上 mmap 的使用要复杂一些。

  1. func (demo *Demo) mmap() {
  2.     h, err := syscall.CreateFileMapping(syscall.Handle(demo.file.Fd()), nil, syscall.PAGE_READWRITE, 0, defaultMemMapSize, nil)
  3.     _assert(h != 0, "failed to map", err)
  5.     addr, err := syscall.MapViewOfFile(h, syscall.FILE_MAP_WRITE, 0, 0, uintptr(defaultMemMapSize))
  6.     _assert(addr != 0, "MapViewOfFile failed", err)
  8.     err = syscall.CloseHandle(syscall.Handle(h));
  9.     _assert(err == nil, "CloseHandle failed")
  11.     // Convert to a byte array.
  12.     demo.data = (*[defaultMaxFileSize]byte)(unsafe.Pointer(addr))
  13. }
  14. func (demo *Demo) munmap() {
  15.     addr := (uintptr)(unsafe.Pointer(&demo.data[0]))
  16.     _assert(syscall.UnmapViewOfFile(addr) == nil, "failed to munmap")
  17. }
  • 需要 CreateFileMapping 和 MapViewOfFile 两步才能完成内存映射。MapViewOfFile 返回映射成功的内存地址，因此可以直接将该地址转换成 byte 数组。
  • Windows 对文件的大小没有要求，直接操作内存data，文件大小会自动发生改变。

使用时无需关注文件的大小。

  1. func main() {
  2.     _ = os.Remove("tmp.txt")
  3.     f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
  4.     demo := &Demo{file: f}
  5.     demo.mmap()
  6.     defer demo.munmap()
  7.     msg := "hello geektutu!"
  8.     for i, v := range msg {
  9.         demo.data[2*i] = byte(v)
  10.         demo.data[2*i+1] = byte(' ')
  11.     }
  12. }
  1. $ go run .
  2. $ cat .\tmp.txt
  3. h e l l o   g e e k t u t u !

附 参考