リストを個々のゴルーチンによって処理される小さなチャンクに分割しているにもかかわらず、同時実行性が増加しても「moving_avg_concurrent2」のパフォーマンスが向上しないのはなぜですか?

同時実行の増加に伴って、moving_avg_concurrent2 のパフォーマンスが向上しないのはなぜですか?

moving_avg_concurrent2 は、リストをより小さな部分に分割し、単一の goroutine を使用して各部分を処理します。何らかの理由で (理由は明らかではありませんが)、1 つの goroutine を使用するこの関数は、moving_avg_serial4 よりも高速ですが、複数の goroutine を使用すると、moving_avg_serial4 よりもパフォーマンスが低下し始めます。

moving_avg_concurrent3 は、moving_avg_serial4 よりもはるかに遅いのはなぜですか?

ゴルーチンを使用する場合、moving_avg_concurrent3 のパフォーマンスは、moving_avg_serial4 よりも悪くなります。 num_goroutines を増やすとパフォーマンスが向上しますが、それでも move_avg_serial4 よりも悪くなります。

ゴルーチンは軽量ではありますが、完全に無料というわけではありません。発生するオーバーヘッドが非常に大きく、moving_avg_serial4 よりも遅くなる可能性はありますか?

はい、ゴルーチンは軽量ですが、無料ではありません。複数のゴルーチンを使用する場合、それらの起動、管理、スケジュール設定のオーバーヘッドが、並列処理の増加によるメリットを上回る可能性があります。

コード

関数:

// 返回包含输入移动平均值的列表（已提供，即未优化）
func moving_avg_serial(input []float64, window_size int) []float64 {
    first_time := true
    var output = make([]float64, len(input))
    if len(input) > 0 {
        var buffer = make([]float64, window_size)
        // 初始化缓冲区为 NaN
        for i := range buffer {
            buffer[i] = math.NaN()
        }
        for i, val := range input {
            old_val := buffer[int((math.Mod(float64(i), float64(window_size))))]
            buffer[int((math.Mod(float64(i), float64(window_size))))] = val
            if !NaN_in_slice(buffer) && first_time {
                sum := 0.0
                for _, entry := range buffer {
                    sum += entry
                }
                output[i] = sum / float64(window_size)
                first_time = false
            } else if i > 0 && !math.IsNaN(output[i-1]) && !NaN_in_slice(buffer) {
                output[i] = output[i-1] + (val-old_val)/float64(window_size) // 无循环的解决方案
            } else {
                output[i] = math.NaN()
            }
        }
    } else { // 空输入
        fmt.Println("moving_avg is panicking!")
        panic(fmt.Sprintf("%v", input))
    }
    return output
}

// 返回包含输入移动平均值的列表
// 重新排列控制结构以利用短路求值
func moving_avg_serial4(input []float64, window_size int) []float64 {
    first_time := true
    var output = make([]float64, len(input))
    if len(input) > 0 {
        var buffer = make([]float64, window_size)
        // 初始化缓冲区为 NaN
        for i := range buffer {
            buffer[i] = math.NaN()
        }
        for i := range input {
            //            fmt.Printf("in mvg_avg4: i=%v\n", i)
            old_val := buffer[int((math.Mod(float64(i), float64(window_size))))]
            buffer[int((math.Mod(float64(i), float64(window_size))))] = input[i]
            if first_time && !NaN_in_slice(buffer) {
                sum := 0.0
                for j := range buffer {
                    sum += buffer[j]
                }
                output[i] = sum / float64(window_size)
                first_time = false
            } else if i > 0 && !math.IsNaN(output[i-1]) /* && !NaN_in_slice(buffer)*/ {
                output[i] = output[i-1] + (input[i]-old_val)/float64(window_size) // 无循环的解决方案
            } else {
                output[i] = math.NaN()
            }
        }
    } else { // 空输入
        fmt.Println("moving_avg is panicking!")
        panic(fmt.Sprintf("%v", input))
    }
    return output
}

// 返回包含输入移动平均值的列表
// 将列表拆分为较小的片段以使用 goroutine，但不使用串行版本，即我们仅在开头具有 NaN，因此希望减少一些开销
// 仍然不能扩展（随着大小和 num_goroutines 的增加，性能下降）
func moving_avg_concurrent2(input []float64, window_size, num_goroutines int) []float64 {
    var output = make([]float64, window_size-1, len(input))
    for i := 0; i  0 {
        num_items := len(input) - (window_size - 1)
        var barrier_wg sync.WaitGroup
        n := num_items / num_goroutines
        go_avg := make([][]float64, num_goroutines)
        for i := 0; i  0 {
        num_windows := len(input) - (window_size - 1)
        var output = make([]float64, len(input))
        for i := 0; i 

以上がリストを個々のゴルーチンによって処理される小さなチャンクに分割しているにもかかわらず、同時実行性が増加しても「moving_avg_concurrent2」のパフォーマンスが向上しないのはなぜですか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。