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

Question

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

简而言之，C#执行代码需要32秒，而D需要54秒。该代码对于片段来说有点大，但如果有人能提供一点时间来解释为什么我的 D 代码 happened/what 有问题，那就太好了。

这是我的一小段代码：

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 次查找而不是一次查找，你应该使用这个：

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

GetFromDict 函数相同

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

3.) 没有必要使用 std.container.Array，你可以使用带 appender

的标准 D 数组

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

cast(char)('0' + sym)

5.) DMD 很慢，您应该尝试使用 ldc 和 gdc 以及适当的标志，例如：

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

通过一些更改，我能够将其速度从将近 50 秒缩短到 15 秒

这是我的代码： modified code

更新

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

http://dpaste.dzfl.pl/cd6a7af786ec

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

Why is this D code slower than a similar C# implementation?

performance

d