Go语言切片与大索引：内存效率挑战与syscall.Mmap实践

type SliceHeader struct {
    Data uintptr // 指向底层数组的起始地址
    Len  int     // 切片的长度
    Cap  int     // 切片的容量
}

package main

import (
    "fmt"
    "unsafe" // 仅用于演示底层地址，实际开发中应避免直接操作
)

func main() {
    a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    b := a[2:8] // b 的范围是 a[2] 到 a[7]
    c := a[8:]  // c 的范围是 a[8] 到 a[9]
    d := b[2:4] // d 的范围是 b[2] 到 b[3]，即 a[4] 到 a[5]

    fmt.Printf("原始数组 a: %v, 地址: %v\n", a, unsafe.Pointer(&a[0]))
    fmt.Printf("切片 b: %v, 地址: %v\n", b, unsafe.Pointer(&b[0]))
    fmt.Printf("切片 c: %v, 地址: %v\n", c, unsafe.Pointer(&c[0]))
    fmt.Printf("切片 d: %v, 地址: %v\n", d, unsafe.Pointer(&d[0]))

    // 验证地址关系
    // 假设 sizeof(int) 是 8 字节 (64位系统)
    fmt.Printf("b[0] 地址相对于 a[0] 的偏移: %d 字节\n", uintptr(unsafe.Pointer(&b[0]))-uintptr(unsafe.Pointer(&a[0]))) // 预期 2 * sizeof(int)
    fmt.Printf("c[0] 地址相对于 a[0] 的偏移: %d 字节\n", uintptr(unsafe.Pointer(&c[0]))-uintptr(unsafe.Pointer(&a[0]))) // 预期 8 * sizeof(int)
    fmt.Printf("d[0] 地址相对于 a[0] 的偏移: %d 字节\n", uintptr(unsafe.Pointer(&d[0]))-uintptr(unsafe.Pointer(&a[0]))) // 预期 4 * sizeof(int)
}

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "syscall"
)

// mmap 将文件的一部分映射到内存，并返回一个字节切片
func mmap(fd *os.File, startOffset, size int) ([]byte, error) {
    // 确保文件指针在正确的位置，虽然Mmap会使用文件描述符和偏移量，但良好的实践是检查
    _, err := fd.Seek(0, 0) // 重置文件指针到开头，Mmap会用自己的偏移量
    if err != nil {
        return nil, fmt.Errorf("seek file error: %w", err)
    }

    // syscall.Mmap 参数：
    // fd: 文件描述符
    // offset: 文件中的起始偏移量
    // length: 映射区域的长度
    // prot: 内存保护（如 syscall.PROT_READ, syscall.PROT_WRITE）
    // flags: 映射标志（如 syscall.MAP_SHARED, syscall.MAP_PRIVATE）
    return syscall.Mmap(int(fd.Fd()), int64(startOffset), size,
        syscall.PROT_READ, syscall.MAP_SHARED)
}

func main() {
    // 1. 创建一个示例文件并写入一些数据
    fileName := "large_data.txt"
    data := make([]byte, 1024*1024) // 1MB 数据
    for i := 0; i < len(data); i++ {
        data[i] = byte(i % 256)
    }
    err := ioutil.WriteFile(fileName, data, 0644)
    if err != nil {
        fmt.Printf("创建文件失败: %v\n", err)
        return
    }
    defer os.Remove(fileName) // 程序结束时删除文件

    // 2. 打开文件
    file, err := os.OpenFile(fileName, os.O_RDONLY, 0)
    if err != nil {
        fmt.Printf("打开文件失败: %v\n", err)
        return
    }
    defer file.Close()

    // 3. 映射文件的一部分：从文件偏移量 512KB 处开始，映射 256KB 的数据
    startOffset := 512 * 1024 // 512KB
    mapSize := 256 * 1024     // 256KB
    mappedSlice, err := mmap(file, startOffset, mapSize)
    if err != nil {
        fmt.Printf("Mmap 失败: %v\n", err)
        return
    }
    // 4. 使用完毕后，务必调用 syscall.Munmap 解除映射
    defer func() {
        if err := syscall.Munmap(mappedSlice); err != nil {
            fmt.Printf("Munmap 失败: %v\n", err)
        }
    }()

    // 5. 现在可以使用 mappedSlice，它的索引从 0 开始
    // mappedSlice[0] 对应文件中的 startOffset 字节
    // mappedSlice[1] 对应文件中的 startOffset + 1 字节
    fmt.Printf("映射切片的长度: %d 字节\n", len(mappedSlice))
    fmt.Printf("映射切片的第一个字节 (对应文件偏移量 %d): %d\n", startOffset, mappedSlice[0])
    fmt.Printf("映射切片的第100个字节 (对应文件偏移量 %d): %d\n", startOffset+99, mappedSlice[99])

    // 验证：直接读取文件对应位置的数据
    fileData := make([]byte, 1)
    _, err = file.ReadAt(fileData, int64(startOffset))
    if err != nil {
        fmt.Printf("ReadAt 失败: %v\n", err)
        return
    }
    fmt.Printf("直接从文件偏移量 %d 读取的字节: %d\n", startOffset, fileData[0])
}