Question

我正在玩D并移植了一个我用C＃编写的示例项目来测试它的表现。我不敢说我看到D比C＃慢得多，我并不感到惊讶，因为这是我第一次尝试在D中写东西。

简而言之，C＃在32秒内执行代码，而D需要54秒。代码对于一个片段来说有点大，但是如果有人能够提供一点时间来解释为什么会发生这种情况/我的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以及例如。：

的appropeiate标志

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

通过一些变化，我能够将它从近50秒增加到15秒

这是我的代码： modified code

<强>更新

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

http://dpaste.dzfl.pl/cd6a7af786ec

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

1 个答案: