Go Mmap 文件内存映射简明教程

HelloWorld官方 等级 1085 0 1

Go Mmap 文件内存映射简明教程

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的内容。

package main

import (
    "fmt"
    "golang.org/x/exp/mmap"
)

func main() {
    at, _ := mmap.Open("./tmp.txt")
    buff := make([]byte, 2)
    _, _ = at.ReadAt(buff, 4)
    _ = at.Close()
    fmt.Println(string(buff))
}
$ echo "abcdefg" > tmp.txt
$ go run .
ef

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

package main

import (
    "fmt"
    "os"
)

func main() {
    f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
    _, _ = f.WriteAt([]byte("abcdefg"), 0)

    buff := make([]byte, 2)
    _, _ = f.ReadAt(buff, 4)
    _ = f.Close()
    fmt.Println(string(buff))
}

3 mmap(linux)

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

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

每个参数的含义分别是:

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

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

const defaultMaxFileSize = 1 << 30        // 假设文件最大为 1G
const defaultMemMapSize = 128 * (1 << 20) // 假设映射的内存大小为 128M

type Demo struct {
    file    *os.File
    data    *[defaultMaxFileSize]byte
    dataRef []byte
}

func _assert(condition bool, msg string, v ...interface{}) {
    if !condition {
        panic(fmt.Sprintf(msg, v...))
    }
}
  • 内存有换页机制,映射的物理内存可以远小于文件。
  • Demo结构体由3个字段构成,file 即文件描述符,data 是映射内存的起始地址,dataRef 用于后续取消映射。

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

func (demo *Demo) mmap() {
    b, err := syscall.Mmap(int(demo.file.Fd()), 0, defaultMemMapSize, syscall.PROT_WRITE|syscall.PROT_READ, syscall.MAP_SHARED)
    _assert(err == nil, "failed to mmap", err)
    demo.dataRef = b
    demo.data = (*[defaultMaxFileSize]byte)(unsafe.Pointer(&b[0]))
}

func (demo *Demo) grow(size int64) {
    if info, _ := demo.file.Stat(); info.Size() >= size {
        return
    }
    _assert(demo.file.Truncate(size) == nil, "failed to truncate")
}

func (demo *Demo) munmap() {
    _assert(syscall.Munmap(demo.dataRef) == nil, "failed to munmap")
    demo.data = nil
    demo.dataRef = nil
}
  • 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, world!

func main() {
    _ = os.Remove("tmp.txt")
    f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
    demo := &Demo{file: f}
    demo.grow(1)
    demo.mmap()
    defer demo.munmap()

    msg := "hello world!"

    demo.grow(int64(len(msg) * 2))
    for i, v := range msg {
        demo.data[2*i] = byte(v)
        demo.data[2*i+1] = byte(' ')
    }
}
  • 在调用mmap 之前,调用了grow(1),因为在mmap 中使用 &b[0]获取到映射内存的起始地址,所以文件大小至少为 1 byte

  • 接下来,便是通过直接操作 demo.data,修改文件内容了。

运行:

$ go run .
$ cat tmp.txt
h e l l o   w o r l d!
4 mmap(Windows)

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

func (demo *Demo) mmap() {
    h, err := syscall.CreateFileMapping(syscall.Handle(demo.file.Fd()), nil, syscall.PAGE_READWRITE, 0, defaultMemMapSize, nil)
    _assert(h != 0, "failed to map", err)

    addr, err := syscall.MapViewOfFile(h, syscall.FILE_MAP_WRITE, 0, 0, uintptr(defaultMemMapSize))
    _assert(addr != 0, "MapViewOfFile failed", err)

    err = syscall.CloseHandle(syscall.Handle(h));
    _assert(err == nil, "CloseHandle failed")

    // Convert to a byte array.
    demo.data = (*[defaultMaxFileSize]byte)(unsafe.Pointer(addr))
}

func (demo *Demo) munmap() {
    addr := (uintptr)(unsafe.Pointer(&demo.data[0]))
    _assert(syscall.UnmapViewOfFile(addr) == nil, "failed to munmap")
}
  • 需要 CreateFileMappingMapViewOfFile 两步才能完成内存映射。MapViewOfFile 返回映射成功的内存地址,因此可以直接将该地址转换成 byte 数组。

  • Windows 对文件的大小没有要求,直接操作内存data,文件大小会自动发生改变。

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

func main() {
    _ = os.Remove("tmp.txt")
    f, _ := os.OpenFile("tmp.txt", os.O_CREATE|os.O_RDWR, 0644)
    demo := &Demo{file: f}
    demo.mmap()
    defer demo.munmap()

    msg := "hello world!"
    for i, v := range msg {
        demo.data[2*i] = byte(v)
        demo.data[2*i+1] = byte(' ')
    }
}
$ go run .
$ cat .	mp.txt
h e l l o   w o r l d !
收藏
评论区

相关推荐

Go Mmap 文件内存映射简明教程
1 mmap 简介 In computing, mmap is a POSIXcompliant Unix system call t
godoc 命令和 golang 代码文档管理
介绍 godoc 是 golang 自带的文档查看器,更多的提供部署服务 go doc 和 godoc 在 golang 1.13 被移除了,可以自行安装 golang.org go1.13 godoc(https://links.jianshu.com/go?tohttps%3A%2F%2Fgolang.org%2Fdoc%2Fg
为什么GOPROXY对Golang开发如此重要
为什么GOPROXY对Golang开发如此重要 引言 从Go 1.13开始,Go Module作为Golang中的标准包管理器,在安装时自动启用,并附带一个默认的GOPROXY。 但是对于其他的GOPROXY选项,比如JFrog GoCenter,以及你自己的Go Module包,你需要在公众视野中保持安全,你应该选择什么样的配置? 你怎样才能
【Golang】GoWeb框架之Gin-简明教程
Gin 简介 Gin is a HTTP web framework written in Go (Golang). It features a
Go 语言编程 — go mod 依赖包管理
目录 == ### 文章目录 * 目录 * go mod 依赖包管理 * 使用 go mod go mod 依赖包管理 ============ go mod 是 Golang 1.11 版本引入的依赖包管理工具。其中,Golang 对 Modules 的定义:Modules 是相关 Go Packages 的集合,是源代码交换和版本控制
Go语言基础之并发
转载自[https://www.liwenzhou.com/posts/Go/14\_concurrence/](https://www.oschina.net/action/GoToLink?url=https%3A%2F%2Fwww.liwenzhou.com%2Fposts%2FGo%2F14_concurrence%2F) Go语言基础之并发 ==
go系列(3)
这篇讲讲如何在beego框架使用redis。 golang中比较好用的第三方开源redisclient有: * go-redis * 源码地址:[https://github.com/go-redis/redis](https://www.oschina.net/action/GoToLink?url=https%3A%2F%2Fgith
vs code 下安装golang支持
1)安装gocode go get -u -v github.com/nsf/gocode 2)安装godef go get -u -v github.com/rogpeppe/godef 3)安装golint go get -u -v github.com/golang/lint/golint 4)安装go-find-references g
Android so注入(inject)和Hook技术学习(一)
  以前对Android so的注入只是通过现有的框架,并没有去研究so注入原理,趁现在有时间正好拿出来研究一下。   首先来看注入流程。Android so的注入流程如下: _attach到远程进程 -> 保存寄存器环境 -> 获取目标程序的mmap, dlopen, dlsym, dlclose 地址 -> 远程调用mmap函数申请内存空间用来保存参
Archlinux下Visual Studio Code配置Golang开发环境
一、Golang的安装 ----------- GoLang安装并验证一下: [cox@localhost ~]$ sudo pacman -S go [cox@localhost ~]$ go version go version go1.8.3 linux/amd64s 要注意,Golang的安装要确保两个环境变量,一个是G
Golang 开发环境搭建
Golang 是 Google 发布的开发语言,Go 编译的程序速度可以媲美 C/C++。 安装 -- sudo apt-get install golang sudo apt-get install golang-go.tools 使用 -- * 编译运行程序 go run main.go * 查看命令文
Linux中mmap函数使用
一、前言 ---- * * * 除了标准的文件IO,例如open,read,write,内核还提供接口运行应用将文件map到内存,使得内存中的一个字节与文件中的一个字节一一对应。这就是今天要说的`mmap`,它在android中的用处非常多,比如binder,还有腾讯的开源的IO框架[MMKV](https://www.oschina.net/actio
Linux内存管理之mmap详解
一. mmap系统调用 1. mmap系统调用 mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上,如果文件的大小不是所有页的大小之和,最后一个页不被使用的空间将会清零。munmap执行相反的操作,删除特定地址区域的对象映射。 当使用mmap映射文件到进程后,就可以直接操作这段虚拟地址进行文件的读写等操作,不必再调用read,writ
Native memory allocation (mmap) failed to map xxx bytes for committing reserved memory
<div id="content\_views" class="markdown\_views"> <!-- flowchart 箭头图标 勿删 --> <svg xmlns="http://www.w3.org/2000/svg" style="display: none;"> <path stroke-linecap="round" d="M5,0 0,
Sentinel
![9.28头图.png](https://ucc.alicdn.com/pic/developer-ecology/af7ab6c27c3c4c3aa5dc2cce3c9e8ab9.png) > \*\*导读:\*\*2020年,Sentinel 推出 Go 原生版本[Sentinel-Golang](https://www.oschina.net/ac