主页 / coding / 问题 / 79560227
Accepted
Pavel Chersky
Asked: 2025-04-07 23:08:12 +0800 CST

使用“一次分配”实现二维切片的效率如何？

  • 772

我正在学习 Go，现在开始研究数组和切片。我参考了《Effective Go》和《A Tour of Go》。我对切片容量的计算公式有些疑问。请参阅下面代码中的注释。

package main

import "fmt"

func main() {

    // let's say I need to implement 5x5 picture with 2D slice
    // and I have two ways to do that in acc. with
    // https://go.dev/doc/effective_go#two_dimensional_slices

    // that said:
    // 1. six slices - six underlying arrays
    picture := make([][]uint8, 5)
    for i := range picture {
        picture[i] = make([]uint8, 5)
    }

    // 2. six slices - two* underlying arrays
    // *I THOUGHT the efficiency is hiding in number of arrays
    picture = make([][]uint8, 5)
    pixels := make([]uint8, 25)
    for i := range picture {
        // every iteration pixels[5:] allocates new array...
        picture[i], pixels = pixels[:5], pixels[5:]
        // ...but in the new iteration it's deleted
        // leaving slice of initial pixels array in picture[i]...
    }
    // ...and here we have only two arrays...
    // ...         ^^^ B5t ^^^

    // there are six arrays anyway
    // but their capacity is 5 for picture and
    // 25, 20...5 respectively for its contents
    fmt.Print(cap(picture), " ")
    for i := range picture {
        fmt.Print(cap(picture[i]), " ")
    }
    fmt.Println()
    // if you don't understand let me explain my position
    // capacity is characteristic of underlying array rather than
    // of slice itself

    // in acc. with https://go.dev/tour/moretypes/11
    // "The capacity of a slice is the number of
    // elements in the underlying array..."

    // I believe that capacity of array is immutable one and
    // one array cannot have different cap's at the same time

    picture = make([][]uint8, 5)
    for i := range picture {
        picture[i] = make([]uint8, 5)
    }

    // here we have six arrays but capacity of each is 5
    // so the first solution works efficiently than second one
    //                  I believe
    fmt.Print(cap(picture), " ")
    for i := range picture {
        fmt.Print(cap(picture[i]), " ")
    }
    fmt.Println()

}

该代码的输出是：

5 25 20 15 10 5 
5 5 5 5 5 5

有人可以解释一下使用一种分配方法的效率隐藏在哪里吗？

arrays

1 个回答

  1. Best Answer

    第二个有效 Go二维切片示例是在完整切片表达式添加到Go 编程语言规范之前创建的。

    one allocation, sliced into lines:

// Allocate the top-level slice, the same as before.
picture := make([][]uint8, YSize) // One row per unit of y.
// Allocate one large slice to hold all the pixels.
pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
// Loop over the rows, slicing each row from the front of the remaining pixels slice.
for i := range picture {
    picture[i], pixels = pixels[:XSize], pixels[XSize:]

    第二个例子应为：

    one allocation, sliced into lines:

// Allocate the top-level slice, the same as before.
picture := make([][]uint8, YSize) // One row per unit of y.
// Allocate one large slice to hold all the pixels.
pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
// Loop over the rows, slicing each row from the front of the remaining pixels slice.
for i := range picture {
    // Use a full slice expression for the correct row capacity
    picture[i], pixels = pixels[:XSize:XSize], pixels[XSize:]
}

    package main

import (
    "fmt"
)

func main() {
    XSize, YSize := 5, 5

    // Effective Go: Two-dimensional slices
    // https://go.dev/doc/effective_go#two_dimensional_slices
    // one allocation, sliced into lines:
    // Allocate the top-level slice, the same as before.
    picture := make([][]uint8, YSize) // One row per unit of y.
    // Allocate one large slice to hold all the pixels.
    pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
    // Loop over the rows, slicing each row from the front of the remaining pixels slice.
    for i := range picture {
        // Use a full slice expression for the correct row capacity
        // https://go.dev/ref/spec#Slice_expressions
        picture[i], pixels = pixels[:XSize:XSize], pixels[XSize:]
    }

    fmt.Print(cap(picture), " ")
    for i := range picture {
        fmt.Print(cap(picture[i]), " ")
    }
    fmt.Println()
}

    https://go.dev/play/p/7I2ZL5Jj8Lw。

    输出：

    5 5 5 5 5 5

    一个简单的Go 基准测试说明了最小化分配的一些效果。

    Benchmark1stExample-16  6710131  175.6 ns/op  154 B/op  6 allocs/op
Benchmark2ndExample-16  9674449  121.3 ns/op  160 B/op  2 allocs/op
    • 1

相关问题