Go切片大起始索引的内存效率与实现探讨

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

package main

import "fmt"
import "unsafe" // 用于获取SliceHeader信息

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, len: %d, cap: %d\n", a, len(a), cap(a))
    fmt.Printf("切片 b: %v, len: %d, cap: %d\n", b, len(b), cap(b))
    fmt.Printf("切片 c: %v, len: %d, cap: %d\n", c, len(c), cap(c))
    fmt.Printf("切片 d: %v, len: %d, cap: %d\n", d, len(d), cap(d))

    // 打印SliceHeader信息（需要unsafe包）
    // fmt.Printf("a header: %+v\n", (*reflect.SliceHeader)(unsafe.Pointer(&a)))
    // fmt.Printf("b header: %+v\n", (*reflect.SliceHeader)(unsafe.Pointer(&b)))
    // fmt.Printf("c header: %+v\n", (*reflect.SliceHeader)(unsafe.Pointer(&c)))
    // fmt.Printf("d header: %+v\n", (*reflect.SliceHeader)(unsafe.Pointer(&d)))
}

底层固定数组: [ 0 1 2 3 4 5 6 7 8 9 ]  (假设起始地址为 $ADDR_A)
切片 a       :   . . . . . . . . . .    > SliceHeader{Data:$ADDR_A, Len:10, Cap:10}
切片 b       :       . . . . . .        > SliceHeader{Data:$ADDR_A + sizeof(int)*2, Len:6, Cap:8} (b[0] 对应 a[2])
切片 c       :                   . .    > SliceHeader{Data:$ADDR_A + sizeof(int)*8, Len:2, Cap:2} (c[0] 对应 a[8])
切片 d       :           . .            > SliceHeader{Data:$ADDR_A + sizeof(int)*4, Len:2, Cap:6} (d[0] 对应 b[2] 或 a[4])

package main

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

// mmap 将文件的指定部分映射到内存并返回一个 []byte 切片
// fd: 文件描述符
// offset: 文件中开始映射的字节偏移量
// size: 映射的字节大小
func mmap(fd *os.File, offset, size int) ([]byte, error) {
    // 确保文件指针在开始映射前位于文件开头，
    // 尽管Mmap的offset参数会覆盖这一行为，但这是一个好的实践
    _, err := fd.Seek(0, 0)
    if err != nil {
        return nil, fmt.Errorf("seeking file start 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() {
    // 示例：创建一个临时文件并写入一些数据
    fileName := "testfile.bin"
    fileContent := []byte("This is some data in the file, with a large logical offset in mind.")
    err := os.WriteFile(fileName, fileContent, 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }
    defer os.Remove(fileName) // 程序结束时删除文件

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

    // 假设我们想从文件的第 10 个字节开始映射 5 个字节
    // 逻辑上，我们希望访问文件中的 's i s'
    // 在返回的切片中，'s' 将是 mmappedSlice[0]
    mapOffset := 10 // 文件的起始偏移量
    mapSize := 5    // 映射的字节大小

    mmappedSlice, err := mmap(f, mapOffset, mapSize)
    if err != nil {
        fmt.Println("Error mmapping file:", err)
        return
    }
    // 使用完毕后，务必调用 syscall.Munmap 解除映射
    defer func() {
        err := syscall.Munmap(mmappedSlice)
        if err != nil {
            fmt.Println("Error unmapping memory:", err)
        }
    }()

    fmt.Printf("Mapped slice: %s\n", string(mmappedSlice)) // 输出: some
    fmt.Printf("Mapped slice length: %d\n", len(mmappedSlice)) // 输出: 5
    fmt.Printf("First byte of mapped slice: %c\n", mmappedSlice[0]) // 输出: s (对应文件中的第10个字节)
}