为什么这个 D 代码比类似的 C# 实现慢？

Question

我在玩 D 并移植了一个我用 C# 编写的示例项目来测试它的性能。我不会撒谎说看到 D 比 C# 慢得多我并不感到惊讶，因为那是我第一次尝试用 D 编写东西。

简而言之，C# 执行代码需要 32 秒，而 D 需要 54 秒。代码对于 sn-p 来说有点大，但如果有人能提供一点时间来解释为什么会发生这种情况/我的 D 代码有什么问题，那就太好了。

这是我的一小段代码：

void ProcessReel(int reelIndex, string pattern, Game game)
{
    counter++;
    if(reelIndex == game.Reels.length) 
    {
        Symbol winningSymbol;
        auto patternLength = 0;


        auto p3_1 = pattern[0..3];
        auto p3_2 = pattern[2..5];
        auto p4_1 = pattern[0..4];
        auto p4_2 = pattern[1..5];

        auto pos = GetFromDict(p3_1, p3_2, game);
        if(pos != null)
        {
            winningSymbol = pos._Symbol;
            patternLength = pos.PatternLength;
        }

        pos = GetFromDict(p4_1, p4_2, game);
        if(pos != null)
        {
            winningSymbol = pos._Symbol;
            patternLength = pos.PatternLength;
        }

        if(pattern in patternTable)
        {
            auto combination = patternTable[pattern];
            winningSymbol = combination._Symbol;
            patternLength = combination.PatternLength;
        }

        if(winningSymbol !is null)
        {
            winningSymbol.Combinations++;
        }
        return;
    }

    auto reel = game.Reels[reelIndex];
    for(int i = 0; i < reel.ReelStrip.length; i++)
    {
        auto p = pattern;
        auto sym = reel.ReelStrip[i];
        p ~= std.conv.to!string(sym);
        ProcessReel(reelIndex + 1, p, game);
    }
}

完整代码可从here下载

我正在使用以下编译器参数进行编译

dmd Test.d -O -release -inline -boundscheck=off

谢谢。

更新

这是 C# 代码。它应该并行运行，这就是它内部有锁的原因，但为了公平竞争，我将它设置为串行，然而，即使有这个锁，C# 也能击败 D。

public static void ProcessReel(int reelIndex, Dictionary<int, Dictionary<byte, WinPossibility>> dict, string pattern, AnalyzedResult result)
{
    if (reelIndex == result.Game.ReelCollection[0].Reels.Count)  // This is the last reel. Time to analyze those shit :((
    {
        Symbol winningSymbol = null;
        var patternLength = 0;

        var p3_1 = pattern.Substring(0, 3);
        var p3_2 = pattern.Substring(2, 3);
        var p4_1 = pattern.Substring(0, 4);
        var p4_2 = pattern.Substring(1, 4);

        if (result.PatternTable.ContainsKey(p3_1) || result.PatternTable.ContainsKey(p3_2))
        {
            var winCombination = Helper.GetFromDict(p3_1, p3_2, result);
            var symbol = winCombination.Symbol;
            winningSymbol = symbol;
            patternLength = winCombination.PatternLength;
        }

        if (result.PatternTable.ContainsKey(p4_1) || result.PatternTable.ContainsKey(p4_2))
        {
            var winCombination = Helper.GetFromDict(p4_1, p4_2, result);
            var symbol = winCombination.Symbol;
            winningSymbol = symbol;
            patternLength = winCombination.PatternLength;
        }

        if (result.PatternTable.ContainsKey(pattern))
        {
            var winCombination = result.PatternTable[pattern];
            var symbol = winCombination.Symbol;
            winningSymbol = symbol;
            patternLength = winCombination.PatternLength;
        }

        if (winningSymbol != null)
        {
            lock (dict)
            {
                var d = dict[patternLength];
                if (d.ContainsKey(winningSymbol.Code))
                    d[winningSymbol.Code].Combinations += 1;
                else
                    d.Add(winningSymbol.Code, new WinPossibility(winningSymbol, patternLength, 1));
            }
        }

        return;
    }

    var reel = result.Game.ReelCollection[0].Reels[reelIndex];

    //if (reelIndex == 0)
    //{
    //    Parallel.For(0, reel.ReelStrip.Length, r1 =>
    //    {
    //        var p = pattern;
    //        var sym = reel.ReelStrip[r1];
    //        p += sym;

    //        ProcessReel(reelIndex + 1, dict, p, result);
    //    });
    //}
    //else
    //{
        for (int r1 = 0; r1 < reel.ReelStrip.Length; r1++)
        {
            var p = pattern;
            var sym = reel.ReelStrip[r1];
            p += sym;

            ProcessReel(reelIndex + 1, dict, p, result);
        }
    //}
}

更新 2

我刚刚下载了 GDCC 4.9。它有所帮助，计算时间现在从 54 秒减少到 38 秒，但仍然不如 .NET/C#...

Answer 1

有几件事让 D 版本变慢了。

1.)

if(pattern in patternTable) {
    auto combination = patternTable[pattern];

您在这里进行 2 次查找而不是 1 次，您应该使用这个：

auto combination = pattern in patternTable;
if(combination) {
    ...

GetFromDict 函数也一样

2.) 数组连接很慢最好使用std.array.Appender

3.) 无需使用 std.container.Array，您可以使用带有 appender 的标准 D 数组

4.) to!string(sym) 很慢，您可以通过以下方式提高 sym 在 0 .. 10 范围内的速度：

cast(char)('0' + sym)

5.) DMD 很慢，您应该尝试带有适当标志的 ldc 和 gdc，例如：

gdc -O3 -finline -fno-bounds-check  -frelease

通过一些更改，我能够将其从近 50 秒提高到 15 秒

这是我的代码： modified code

更新

我有一些错误，这是另一个速度稍慢但应该给出正确结果的版本：

http://dpaste.dzfl.pl/cd6a7af786ec