c# - 并行循环性能下降

Question

我目前正在优化并行执行的数据处理逻辑。我注意到，随着核心数量的增加，数据处理性能不一定会像我认为的那样提高。

测试代码如下:

Console.WriteLine($"{DateTime.Now}: Data processing start");
double lastElapsedMs = 0;
for (int i = 1; i <= Environment.ProcessorCount; i++)
{
    var watch = System.Diagnostics.Stopwatch.StartNew();
    ProccessData(i); // main processing method
    watch.Stop();
    double elapsedMs = watch.ElapsedMilliseconds;
    Console.WriteLine($"{DateTime.Now}: Core count: {i}, Elapsed: {elapsedMs}ms");
    lastElapsedMs = elapsedMs;
}
Console.WriteLine($"{DateTime.Now}: Data processing end");

和

public static void ProccessData(int coreCount)
{
    // First part is data preparation.
    // splitting 1 collection into smaller chunks, depending on core count
    ////////////////
    // combinations = collection of data
    var length = combinations.Length;
    int chuncSize = length / coreCount;
    int[][][] chunked = new int[coreCount][][];
    for (int i = 0; i < coreCount; i++)
    {
        int skip = i * chuncSize;
        int take = chuncSize;

        int diff = (length - skip) - take;
        if (diff < chuncSize)
        {
            take = take + diff;
        }

        var sub = combinations.Skip(skip).Take(take).ToArray();
        chunked[i] = sub.ToArray();
    }

    // Second part is itteration. 1 chunk of data processed per core.
    ////////////////
    Parallel.For(0, coreCount, new ParallelOptions() { MaxDegreeOfParallelism = coreCount }, (chunkIndex, state) =>
    {
        var chunk = chunked[chunkIndex];
        int chunkLength = chunk.Length;

        // itterate data inside chunk
        for (int idx = 0; idx < chunkLength; idx++)
        {
            // additional processing logic here for single data
        }
    });
}

结果如下:

正如您从结果集中看到的那样 - 通过使用 2 个内核而不是 1 个内核 - 您可以获得近乎理想的性能提升(假设 1 个内核以 4700Mhz 运行，但是 2每个内核以 4600Mhz 运行。

之后，当数据应该在 3 个内核上并行处理时，我期望看到与 2 个内核执行相比性能提高 33%。实际增加了21.62%。

接下来，随着核心数量的增加 - “并行”执行性能的下降继续增加。

最后，当我们有 12 个核心结果时 - 实际 和理想 结果之间的差异是原来的两倍多(96442 毫秒对 39610 毫秒)!

我当然没想到差异会这么大。我有一个 Intel 8700k 处理器。 6 个物理内核和 6 个逻辑内核 - 总共 12 个线程。 1 个内核以 4700Mhz 的频率在 Turbo 模式下运行，2C 4600、3C 4500、4C 4400、5-6C 4400、6C 4300。

如果重要 - 我在 Core-temp 中做了额外的观察:

• 当 1 个核心处理正在运行时 - 6 个核心中有 1 个忙 50%
• 当 2 个核心处理正在运行时 - 6 个核心中有 2 个忙 50%
• 当 3 个核心处理正在运行时 - 6 个核心中有 3 个忙 50%
• 当 4 个核心处理正在运行时 - 6 个核心中有 4 个忙 50%
• 当 5 个核心处理正在运行时 - 6 个核心中有 5 个忙 50%
• 当 6 个核心处理正在运行时 - 6 个核心中有 6 个忙 50%
• 当 7 个核心处理运行时 - 6 个核心中有 5 个忙 50%，1 个核心 100%
• 当 8 个核心处理运行时 - 6 个核心中有 4 个忙 50%，2 个核心 100%
• 当 9 个核心处理正在运行时 - 6 个核心中的 3 个核心忙于 50%，3 个核心忙于 100%
• 当 10 个核心处理正在运行时 - 6 个核心中的 2 个核心忙于 50%，4 个核心忙于 100%
• 当 11 个核心处理正在运行时 - 6 个核心中有 1 个处于繁忙状态 50%，5 个核心处于 100%
• 当 12 个核心处理正在运行时 - 所有 6 个核心都处于 100%

我当然可以看到最终结果不应该像ideal 结果那样高效，因为每个内核的频率降低了，但是仍然.. 有没有很好的解释为什么我的代码在 12 时表现如此糟糕核心？这种普遍情况是在每台机器上还是我的 PC 的局限性？

.net core 2 用于测试

编辑: 抱歉忘记提及数据分块可以优化，因为我已经将其作为解决方案草案完成。然而，拆分是在 1 秒内完成的，因此结果执行时间最多增加 1000-2000 毫秒。

Edit2: 我刚刚摆脱了所有分块逻辑并删除了 MaxDegreeOfParallelism 属性。数据按原样并行处理。现在的执行时间为 94196ms，与之前基本相同，不包括分块时间。似乎 .net 足够聪明，可以在运行时分块数据，因此不需要额外的代码，除非我想限制使用的内核数量。然而，事实是，这并没有显着提高性能。我倾向于“Ahmdahl 定律”的解释，因为我所做的一切都没有增加误差范围债券之外的性能。

Answer 1

是的，阿姆达尔定律。性能加速永远不会与解决问题的内核数量成线性关系。

也是互惠...