Go语言切片内存管理：大起始索引的效率与Mmap应用

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

package main

import "fmt"
import "unsafe" // 用于获取内存地址

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

    fmt.Printf("原始数组 a: %v, 地址: %p, Len: %d, Cap: %d\n", a, &a[0], len(a), cap(a))
    fmt.Printf("切片 b (a[2:8]): %v, 地址: %p, Len: %d, Cap: %d\n", b, &b[0], len(b), cap(b))
    fmt.Printf("切片 c (a[8:]): %v, 地址: %p, Len: %d, Cap: %d\n", c, &c[0], len(c), cap(c))
    fmt.Printf("切片 d (b[2:4]): %v, 地址: %p, Len: %d, Cap: %d\n", d, &d[0], len(d), cap(d))

    // 通过unsafe包查看更底层的SliceHeader数据（仅供理解，不推荐生产使用）
    // var aHeader *reflect.SliceHeader = (*reflect.SliceHeader)(unsafe.Pointer(&a))
    // var bHeader *reflect.SliceHeader = (*reflect.SliceHeader)(unsafe.Pointer(&b))
    // ...
    // fmt.Printf("a Data: %x, b Data: %x\n", aHeader.Data, bHeader.Data)
}

原始数组 a: [0 1 2 3 4 5 6 7 8 9], 地址: 0xc0000140a0, Len: 10, Cap: 10
切片 b (a[2:8]): [2 3 4 5 6 7], 地址: 0xc0000140b0, Len: 6, Cap: 8
切片 c (a[8:]): [8 9], 地址: 0xc0000140e0, Len: 2, Cap: 2
切片 d (b[2:4]): [4 5], 地址: 0xc0000140c0, Len: 2, Cap: 6

const mySliceStartIndex = 3 * 1024 * 1024 * 1024 // 假设的逻辑起始索引
actualSlice := make([]byte, 1024) // 实际分配一个较小的切片
// ... 填充 actualSlice 数据 ...

// 访问逻辑索引为 (mySliceStartIndex + offset) 的数据
func getValue(offset int) byte {
    if offset >= 0 && offset < len(actualSlice) {
        return actualSlice[offset]
    }
    // 处理越界情况
    return 0
}

// 示例使用
logicalIndex := mySliceStartIndex + 50
// 实际访问的是 actualSlice[50]
value := getValue(logicalIndex - mySliceStartIndex)

package main

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

// mmap 将文件描述符fd中从start偏移量开始，大小为size的区域映射到内存
func mmap(fd *os.File, start, size int) ([]byte, error) {
    // 确保文件指针在起始位置，虽然Mmap会使用指定的offset，
    // 但Seek操作可以帮助确认文件是可读的
    _, err := fd.Seek(0, 0)
    if err != nil {
        return nil, fmt.Errorf("failed to seek file: %w", err)
    }

    // syscall.Mmap 参数说明:
    // fd: 文件描述符
    // offset: 文件中映射的起始偏移量
    // length: 映射的长度
    // prot: 内存保护（例如PROT_READ, PROT_WRITE）
    // flags: 映射标志（例如MAP_SHARED, MAP_PRIVATE）
    mappedSlice, err := syscall.Mmap(int(fd.Fd()), int64(start), size,
        syscall.PROT_READ, syscall.MAP_SHARED) // 这里只读，共享映射
    if err != nil {
        return nil, fmt.Errorf("failed to mmap file: %w", err)
    }
    return mappedSlice, nil
}

func main() {
    // 1. 创建一个测试文件
    fileName := "testfile.bin"
    file, err := os.Create(fileName)
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer file.Close()
    defer os.Remove(fileName) // 程序结束时删除文件

    // 写入一些数据到文件，模拟一个大文件中的特定区域
    // 假设我们关心文件从第 1MB (1024*1024 字节) 开始的 4KB 数据
    totalFileSize := 2 * 1024 * 1024 // 2MB
    targetOffset := 1 * 1024 * 1024  // 1MB
    targetSize := 4 * 1024           // 4KB

    // 填充文件，确保文件足够大
    _, err = file.WriteAt(make([]byte, totalFileSize), 0)
    if err != nil {
        fmt.Println("Error writing to file:", err)
        return
    }

    // 在目标偏移量处写入特定数据
    dataToWrite := []byte("Hello Mmap World!")
    _, err = file.WriteAt(dataToWrite, int64(targetOffset))
    if err != nil {
        fmt.Println("Error writing target data:", err)
        return
    }
    file.Sync() // 确保数据写入磁盘

    // 2. 使用 mmap 映射文件的一部分
    mappedData, err := mmap(file, targetOffset, targetSize)
    if err != nil {
        fmt.Println("Error mmapping file:", err)
        return
    }
    // 3. 使用完毕后务必解除映射
    defer func() {
        if err := syscall.Munmap(mappedData); err != nil {
            fmt.Println("Error munmapping:", err)
        }
    }()

    // 4. 访问映射的切片，它现在是0-indexed
    fmt.Printf("映射切片的长度: %d\n", len(mappedData))
    // mappedData[0] 对应于文件中 targetOffset 处的数据
    // mappedData[1] 对应于文件中 targetOffset + 1 处的数据

    // 查找写入的字符串
    found := false
    for i := 0; i < len(mappedData)-len(dataToWrite); i++ {
        match := true
        for j := 0; j < len(dataToWrite); j++ {
            if mappedData[i+j] != dataToWrite[j] {
                match = false
                break
            }
        }
        if match {
            fmt.Printf("在映射切片的索引 %d 处找到数据: %s\n", i, string(mappedData[i:i+len(dataToWrite)]))
            found = true
            break
        }
    }
    if !found {
        fmt.Println("未在映射区域找到写入的数据。")
    }

    // 尝试访问映射区域之外的索引会报错
    // fmt.Println(mappedData[targetSize]) // 会导致panic: index out of range
}