Go 语言切片的大起始索引与内存效率：深度解析与 Mmap 实践

type SliceHeader struct {
    Data uintptr // 指向底层数组第一个元素的指针
    Len  int     // 切片的长度，即当前可访问的元素数量
    Cap  int     // 切片的容量，即从 Data 指针开始，底层数组中剩余的元素数量
}

a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
b := a[2:8]
c := a[8:]
d := b[2:4]

底层数组: [ 0 1 2 3 4 5 6 7 8 9 ]  > [10]int 在地址 A
切片 a    :   . . . . . . . . . .    > SliceHeader{Data: A, Len: 10, Cap: 10}
切片 b    :       . . . . . .        > SliceHeader{Data: A + sizeof(int)*2, Len: 6, Cap: 8}
切片 c    :                   . .    > SliceHeader{Data: A + sizeof(int)*8, Len: 2, Cap: 2}
切片 d    :           . .            > SliceHeader{Data: A + sizeof(int)*4, Len: 2, Cap: 6}

package main

import (
    "fmt"
    "os"
    "syscall"
)

// mmap 将文件从指定的偏移量开始，映射指定大小的区域到内存
func mmap(fd *os.File, offset, size int) ([]byte, error) {
    // 确保文件指针在开始映射前位于文件开头，尽管Mmap会使用指定的offset
    // 但某些系统调用可能对文件描述符的当前偏移量有要求，这里作为一种健壮性处理
    _, err := fd.Seek(0, 0)
    if err != nil {
        return nil, fmt.Errorf("seek file failed: %w", err)
    }

    // 调用 syscall.Mmap 进行内存映射
    // fd.Fd() 获取文件描述符
    // offset 是文件中的起始偏移量
    // size 是要映射的区域大小
    // syscall.PROT_READ 表示映射区域可读
    // syscall.MAP_SHARED 表示映射是共享的，对内存的修改会反映到文件中
    data, err := syscall.Mmap(int(fd.Fd()), int64(offset), size,
        syscall.PROT_READ, syscall.MAP_SHARED)
    if err != nil {
        return nil, fmt.Errorf("mmap failed: %w", err)
    }
    return data, nil
}

func main() {
    // 假设我们有一个名为 "large_data.bin" 的大文件
    // 并且我们想从文件的第 3GB 处开始，读取 1GB 的数据
    filePath := "large_data.bin"
    fileSize := int64(5 * 1024 * 1024 * 1024) // 假设文件大小为 5GB

    // 创建一个模拟的大文件，如果文件不存在
    if _, err := os.Stat(filePath); os.IsNotExist(err) {
        fmt.Printf("Creating a dummy large file: %s\n", filePath)
        f, err := os.Create(filePath)
        if err != nil {
            fmt.Println("Error creating file:", err)
            return
        }
        err = f.Truncate(fileSize) // 设定文件大小
        if err != nil {
            fmt.Println("Error truncating file:", err)
            f.Close()
            return
        }
        f.Close()
        fmt.Println("Dummy file created.")
    }

    f, err := os.Open(filePath)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer f.Close()

    // 假设我们想从文件的 3GB 偏移量开始，映射 1GB 的数据
    startOffset := 3 * 1024 * 1024 * 1024 // 3GB
    mapLength := 1 * 1024 * 1024 * 1024   // 1GB

    mappedSlice, err := mmap(f, startOffset, mapLength)
    if err != nil {
        fmt.Println("Error mapping file:", err)
        return
    }
    // 使用完毕后，务必调用 syscall.Munmap 解除内存映射
    defer func() {
        if err := syscall.Munmap(mappedSlice); err != nil {
            fmt.Println("Error unmapping memory:", err)
        }
        fmt.Println("Memory unmapped successfully.")
    }()

    fmt.Printf("Mapped slice length: %d bytes\n", len(mappedSlice))
    fmt.Printf("Accessing first byte of mapped slice (corresponds to file offset %d): %v\n", startOffset, mappedSlice[0])
    fmt.Printf("Accessing last byte of mapped slice (corresponds to file offset %d): %v\n", startOffset + mapLength - 1, mappedSlice[len(mappedSlice)-1])

    // 现在你可以像操作普通 []byte 切片一样操作 mappedSlice
    // mappedSlice[0] 对应文件偏移量 startOffset
    // mappedSlice[N] 对应文件偏移量 startOffset + N
}