go - Go 中具有大起始索引的 slice (的底层数组)可以有效地分配内存吗？

Question

我正在尝试使用起始索引非常大的 slice ，比如 mySlice。与其始终将起始索引用作 mySlice[index - mySliceStartIndex]，不如明确地减去起始索引，我很想简单地定义 slice ，这样我就可以在不使用 这样的算术的情况下使用它mySlice[索引]。这可以在不为所有未使用的低索引分配内存的情况下完成吗？

执行此操作的简单方法是分配一个 slice ，然后对其进行重新 slice (例如 mySlice = mySlice[3*1024*1024*1024:4*1024*1024*1024])显然内存效率低下，因为底层数组不仅需要为整个范围分配，而且仍然分配。 甚至不起作用，因为之后以前位于索引 3*1024*1024*1024 的数据现在位于索引处0，而我的目标是将其保持在原始索引。

我能否以不分配低于 slice 开始位置的索引的方式分配 slice (或其底层数组)，理想情况下甚至在初始时也不分配？

Answer 1

如果不实际/不/分配未使用的部分，这是不可能的。在 Go 中定义 slice 的方式是通过 reflect.SliceHeader

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

它不包含起始索引字段。仅仅是对底层固定大小数组的引用。正是这个底层数组保存了您的实际数据。 slice 只是该数组的一个“窗口”，它始终从索引 0 开始。 0 可能位于基础数组中的任何位置。

例如，考虑 following code :

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

这会产生如下内存布局:

fixed array: [ 0 1 2 3 4 5 6 7 8 9 ]  > [10]int at address 273785072
slice a    :   . . . . . . . . . .    > SliceHeader{Data:273785072 Len:10 Cap:10}
slice b    :       . . . . . .        > SliceHeader{Data:273785080 Len:6 Cap:8}
slice c    :                   . .    > SliceHeader{Data:273785104 Len:2 Cap:2}
slice d    :           . .            > SliceHeader{Data:273785088 Len:2 Cap:6}

Data 的值只是固定数组中的地址偏移量，所有四个 slice 共享底层存储。

a =:= $273785072
b =:= $273785080 =:= $a + sizeof(int)*2 =:= $a + 8
c =:= $273785104 =:= $a + sizeof(int)*8 =:= $a + 32
d =:= $273785088 =:= $b + sizeof(int)*2 =:= $a + sizeof(int)*4 =:= $a + 16

无论您在什么索引处重新 slice 现有 slice ，新 slice 的索引总是从 0 到 len(s)，因为底层的地址是固定的它指向的数组将它放在那里。

内存映射

如果您的数据是从磁盘上的文件加载的，您可以有不同的选择:使用 syscall.Mmap从所需的索引开始，通过 slice 提供对数据的访问。返回的 slice 现在是 0 的索引，它仅涵盖您指定的范围。

func mmap(fd *os.File, start, size int) ([]byte, error) {
    _, err := fd.Seek(0, 0)
    if err != nil {
        return nil, err
    }

    return syscall.Mmap(int(fd.Fd()), start, size,
        syscall.PROT_READ, syscall.MAP_SHARED)
}

别忘了调用syscall.Munmap在返回的 slice 上，当您使用完它时。