HikariTish

1
磁盘 → Page Cache → copy_to_user → 用户 buffer → 程序处理

1
// 传统 read：两次跨态拷贝
2
buf := make([]byte, 4096)
3
file.Read(buf) // syscall → 内核 copy → 用户 buf

1
磁盘 → Page Cache ──→ 用户虚拟地址空间（直接映射）
2
                         ↓
3
                    data[i] 即可访问

1
用户虚拟地址直接映射到 Page Cache 的物理页框
2
读取时若页未加载 → 缺页中断 → 内核自动加载 → 继续执行

1
#include <sys/mman.h>
2

3
void *mmap(void *addr, size_t length, int prot, int flags,
4
           int fd, off_t offset);

1
1. 程序访问 data[4096]
2
2. CPU 触发缺页中断
3
3. 内核将文件对应页加载到 Page Cache
4
4. 建立虚拟地址到物理页框的映射
5
5. 程序继续执行（感知不到中断）

1
活跃链表 (active list) ←→ 非活跃链表 (inactive list)
2
                            ↓ 内存紧张时
3
                         页面回收 (page reclaim)

1
package main
2

3
import (
4
    "fmt"
5
    "os"
6

7
    "golang.org/x/sys/unix"
8
)
9

10
func main() {
11
    file, err := os.Open("test.txt")
12
    if err != nil {
13
        panic(err)
14
    }
15
    defer file.Close()
16

17
    stat, _ := file.Stat()
18
    size := int(stat.Size())
19

20
    // 建立只读映射
21
    data, err := unix.Mmap(
22
        int(file.Fd()),    // fd
23
        0,                 // offset（页对齐）
24
        size,              // length
25
        unix.PROT_READ,    // 只读
26
        unix.MAP_SHARED,   // 共享映射
27
    )
28
    if err != nil {
29
        panic(err)
30
    }
31
    // ⚠️ 必须手动 Munmap
32
    defer unix.Munmap(data)
33

34
    // data 是 []byte，可以像普通切片一样访问
35
    fmt.Println(string(data))
36
}

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

1
// 可读写映射（修改会写回文件）
2
data, err := unix.Mmap(
3
    int(file.Fd()),
4
    0,
5
    size,
6
    unix.PROT_READ|unix.PROT_WRITE, // 可读可写
7
    unix.MAP_SHARED,                 // 修改写回文件
8
)
9

10
// 修改文件内容
11
data[0] = 'H'    // 直接修改，最终会写回磁盘
12
data[100] = '!'  // 内核负责将脏页刷盘

1
package main
2

3
import (
4
    "fmt"
5

6
    "golang.org/x/exp/mmap"
7
)
8

9
func main() {
10
    // 打开只读内存映射
11
    reader, err := mmap.Open("large_file.bin")
12
    if err != nil {
13
        panic(err)
14
    }
15
    defer reader.Close()
16

17
    // 按偏移量读取（避免将整个文件映射到内存）
18
    buf := make([]byte, 4096)
19
    n, err := reader.ReadAt(buf, 1024*1024*100) // 从 100MB 处读取
20
    if err != nil {
21
        panic(err)
22
    }
23
    fmt.Printf("读取 %d 字节: %x\n", n, buf[:n])
24
}

1
type ReaderAt interface {
2
    ReadAt(p []byte, off int64) (n int, err error)
3
    Close() error
4
    Len() int64
5
}

1
// 1. 确保修改对映射区域可见
2
//    （在 MAP_SHARED 下通常自动同步，但保险起见）
3

4
// 2. 刷盘：将脏页写回磁盘
5
unix.Msync(data, unix.MS_SYNC) // 同步等待刷盘完成
6

7
// 或异步刷盘
8
unix.Msync(data, unix.MS_ASYNC) // 异步，不等待
9

10
// 3. 也可以直接 fsync fd
11
file.Sync()

1
// 简化的 KV 存储模型
2
type KVStore struct {
3
    data   []byte          // mmap 映射的文件内容
4
    index  map[string]int64 // key → offset
5
    mu     sync.RWMutex
6
}
7

8
func (kv *KVStore) Get(key string) ([]byte, error) {
9
    kv.mu.RLock()
10
    defer kv.mu.RUnlock()
11

12
    offset, ok := kv.index[key]
13
    if !ok {
14
        return nil, ErrNotFound
15
    }
16

17
    // 直接从 mmap 内存中读取 value，零拷贝
18
    length := binary.LittleEndian.Uint32(kv.data[offset:])
19
    value := kv.data[offset+4 : offset+4+int64(length)]
20

21
    // ⚠️ 如果外部需要持有 value，必须 copy
22
    result := make([]byte, len(value))
23
    copy(result, value)
24
    return result, nil
25
}

1
key → offset (内存索引)
2
      ↓
3
直接 data[offset:n] 读取
4
      ↓
5
零 syscall，零拷贝

1
数据库需求          mmap 能力
2
──────────         ──────────
3
大文件             按需加载，不占物理内存
4
高频随机读         缺页中断自动加载，offset → 虚拟地址 O(1)
5
减少拷贝           数据直接可读，无 read buffer
6
多进程共享          MAP_SHARED 允许多进程访问同一文件
7
简化代码            像访问内存一样读文件，无需 seek → read 循环

1
// 顺序读场景：mmap vs bufio
2
//
3
// mmap 优点：
4
//   - 减少 syscall（缺页中断由内核批量处理）
5
//   - 内核可以预读（readahead），比你手动 read 更智能
6
//
7
// mmap 缺点：
8
//   - 预热成本：首次访问每页都触发缺页中断
9
//   - 内核的预读策略不一定适合你的访问模式
10
//   - 用 madvise 可以影响内核行为

1
// madvise 给内核访问提示
2
import "golang.org/x/sys/unix"
3

4
// 告诉内核：我将要顺序访问这段数据
5
unix.Madvise(data, unix.MADV_SEQUENTIAL)
6

7
// 告诉内核：我需要这些页尽快加载
8
unix.Madvise(data, unix.MADV_WILLNEED)
9

10
// 告诉内核：这些页不需要了，可以优先回收
11
unix.Madvise(data[oldOffset:], unix.MADV_DONTNEED)

1
┌─────────────────────────────────────────┐
2
│            Go 进程虚拟地址空间             │
3
├─────────────────┬───────────────────────┤
4
│   Go Heap       │   mmap 映射区域         │
5
│   (GC 管理)     │   (不受 GC 管理)        │
6
│                 │                       │
7
│  GC 扫描 → ✅   │   GC 扫描 → ❌ 跳过    │
8
│  自动回收 → ✅   │   必须手动 Munmap      │
9
│  panic 安全 → ✅ │   SIGSEGV 风险        │
10
└─────────────────┴───────────────────────┘

1
type SafeMmap struct {
2
    data   []byte
3
    file   *os.File
4
    closed atomic.Bool
5
}
6

7
func NewSafeMmap(path string) (*SafeMmap, error) {
8
    file, err := os.OpenFile(path, os.O_RDWR, 0644)
9
    if err != nil {
10
        return nil, err
11
    }
12

13
    stat, err := file.Stat()
14
    if err != nil {
15
        file.Close()
16
        return nil, err
17
    }
18

19
    size := int(stat.Size())
20
    data, err := unix.Mmap(int(file.Fd()), 0, size,
21
        unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED)
22
    if err != nil {
23
        file.Close()
24
        return nil, fmt.Errorf("mmap: %w", err)
25
    }
26

27
    return &SafeMmap{data: data, file: file}, nil
28
}
29

30
func (m *SafeMmap) ReadAt(buf []byte, offset int64) (int, error) {
31
    if m.closed.Load() {
32
        return 0, fmt.Errorf("already closed")
33
    }
34
    if offset < 0 || offset+int64(len(buf)) > int64(len(m.data)) {
35
        return 0, fmt.Errorf("read out of bounds: offset=%d len=%d mmap_len=%d",
36
            offset, len(buf), len(m.data))
37
    }
38
    // 使用 recover 作为最后防线（注：SIGSEGV 无法被 recover 捕获，
39
    // 但某些平台上的边界错误可能表现为 panic）
40
    return copy(buf, m.data[offset:]), nil
41
}
42

43
func (m *SafeMmap) Close() error {
44
    if m.closed.Swap(true) {
45
        return nil // 幂等
46
    }
47
    err1 := unix.Munmap(m.data)
48
    err2 := m.file.Close()
49
    if err1 != nil {
50
        return err1
51
    }
52
    return err2
53
}

1
传统 read/write:
2
  磁盘 → Page Cache → 用户 buffer → 程序处理
3
  特点：数据进入用户态，可自由修改
4

5
mmap:
6
  磁盘 → Page Cache ──→ 用户虚拟地址（直接映射）
7
  特点：像访问内存一样访问文件，随机访问极快
8

9
sendfile:
10
  磁盘 → Page Cache → socket buffer → 网卡
11
  特点：数据不进入用户态，纯内核态传输

1
场景                         推荐方案
2
────                         ────────
3
HTTP 静态文件下载             sendfile (io.Copy 自动)
4
日志文件顺序读取              bufio + Read
5
数据库索引随机查询            mmap
6
KV 存储读写                   mmap
7
JSON/Protobuf 反序列化        read + unmarshal
8
文件内容需要修改后写出         read → 修改 → write
9
大文件拷贝                    sendfile / splice
10
代理转发（不变内容）           splice

1
// ❌ 非对齐 offset 会导致 mmap 失败
2
offset := int64(1000) // 不是页大小整数倍
3

4
// ✅ 页对齐
5
pageSize := int64(os.Getpagesize()) // 通常 4096
6
alignedOffset := (offset / pageSize) * pageSize
7
diff := offset - alignedOffset
8

9
data, _ := unix.Mmap(fd, alignedOffset, size+int(diff), ...)
10
actualData := data[diff:] // 调整回真实内容

1
// ❌ 差：100GB 文件全部映射（在 64 位系统上可行但浪费虚拟地址空间）
2
data, _ := unix.Mmap(fd, 0, 100<<30, ...) // 不建议
3

4
// ✅ 好：分段映射，只保留热区
5
const chunkSize = 1 << 30 // 1GB per mapping
6
type ChunkedMmap struct {
7
    file   *os.File
8
    chunks map[int64][]byte // offset → mapped chunk
9
}
10

11
func (c *ChunkedMmap) ReadAt(buf []byte, offset int64) error {
12
    chunkOffset := (offset / chunkSize) * chunkSize
13
    chunk, ok := c.chunks[chunkOffset]
14
    if !ok {
15
        // 建立新映射
16
        var err error
17
        chunk, err = unix.Mmap(int(c.file.Fd()), chunkOffset, chunkSize,
18
            unix.PROT_READ, unix.MAP_SHARED)
19
        if err != nil {
20
            return err
21
        }
22
        c.chunks[chunkOffset] = chunk
23
    }
24
    local := int(offset - chunkOffset)
25
    copy(buf, chunk[local:])
26
    return nil
27
}

1
// 批量顺序读取
2
unix.Madvise(data, unix.MADV_SEQUENTIAL)
3

4
// 已知即将访问的页（预热）
5
unix.Madvise(data[hotOffset:hotOffset+hotLen], unix.MADV_WILLNEED)
6

7
// 释放不再需要的页（避免挤占 Page Cache）
8
unix.Madvise(data[coldOffset:coldOffset+coldLen], unix.MADV_DONTNEED)

1
// ❌ 危险：返回 mmap 切片给调用者
2
func (kv *KVStore) Get(key string) []byte {
3
    offset := kv.index[key]
4
    return kv.data[offset : offset+length] // 调用者可能长期持有
5
}
6

7
// ✅ 安全：拷贝一份
8
func (kv *KVStore) Get(key string) ([]byte, error) {
9
    offset, ok := kv.index[key]
10
    if !ok {
11
        return nil, ErrNotFound
12
    }
13
    result := make([]byte, length)
14
    copy(result, kv.data[offset:offset+length])
15
    return result, nil
16
}
17

18
// ✅ 高效：如果调用者承诺短时间使用，可以用闭包
19
func (kv *KVStore) GetWith(key string, fn func([]byte) error) error {
20
    offset := kv.index[key]
21
    return fn(kv.data[offset : offset+length])
22
    // 函数返回后，data 切片不再被外部引用
23
}

1
// mmap 区域本身是并发安全的（物理内存）
2
// 但需要注意：
3
//
4
// 1. 并发写：MAP_SHARED 的多个映射者看到相同内容
5
// 2. 原子性：单个字节读写是原子的，但多字节操作需要上层加锁
6
// 3. 不可依赖 Go 的 race detector 检测 mmap 区域的竞争
7

8
type SyncedKVStore struct {
9
    data  []byte
10
    index map[string]int64
11
    mu    sync.RWMutex // 保护 index 和 data 的逻辑一致性
12
}

1
// Go 1.26 推荐的 mmap 使用模式
2
//
3
// 1. 优先选择 x/sys/unix 用于生产
4
// 2. x/exp/mmap 用于简单只读场景
5
// 3. 始终封装 Close 语义
6

7
import "golang.org/x/sys/unix"
8

9
type MmapRegion struct {
10
    data []byte
11
}
12

13
func NewMmapRegion(fd, offset, length int, writable bool) (*MmapRegion, error) {
14
    prot := unix.PROT_READ
15
    if writable {
16
        prot |= unix.PROT_WRITE
17
    }
18
    data, err := unix.Mmap(fd, int64(offset), length, prot, unix.MAP_SHARED)
19
    if err != nil {
20
        return nil, err
21
    }
22
    return &MmapRegion{data: data}, nil
23
}
24

25
func (r *MmapRegion) Bytes() []byte { return r.data }
26
func (r *MmapRegion) Close() error  { return unix.Munmap(r.data) }

1
                    ┌─────────────────────────────┐
2
                    │     Linux 高性能 IO 体系       │
3
                    └─────────────┬───────────────┘
4
                                  │
5
        ┌─────────────┬───────────┼───────────┬─────────────┐
6
        │             │           │           │             │
7
        ▼             ▼           ▼           ▼             ▼
8
    ┌───────┐   ┌───────┐   ┌───────┐   ┌───────┐   ┌──────────┐
9
    │ epoll │   │ mmap  │   │sendfile│  │splice │   │ io_uring │
10
    │       │   │       │   │       │   │       │   │          │
11
    │连接管理│   │存储访问│   │文件传输│  │管道转发│   │ 下一代IO │
12
    └──┬────┘   └───┬───┘   └───┬───┘   └───┬───┘   └────┬─────┘
13
       │            │           │           │            │
14
       ▼            ▼           ▼           ▼            ▼
15
   netpoller    BoltDB      io.Copy    代理转发     实验性
16
   (Go runtime)  LMDB       HTTP文件    tee 拼接     Go 1.23+
17
                Lucene      CDN节点

1
mmap 的定位不是"高性能网络传输"，而是"高性能存储访问"
2

3
适用领域：
4
  ✓ 数据库存储引擎（索引、数据文件）
5
  ✓ 大文件随机读（日志查询、数据分析）
6
  ✓ 共享内存（跨进程通信）
7
  ✓ 零拷贝文件解析（直接读 mmap 区域）
8

9
不适用领域：
10
  ✗ 网络 IO（用 sendfile / splice / epoll）
11
  ✗ 流式处理（用 bufio）
12
  ✗ 需要改动的数据传输（用 read/write）