6

在我们开始之前，我知道“过早优化”这个术语。然而，以下片段已被证明是可以进行改进的领域。

好吧。我们目前有一些网络代码可以处理基于字符串的数据包。我知道对数据包使用字符串是愚蠢、疯狂和缓慢的。遗憾的是，我们无法控制客户端，因此必须使用字符串。

每个数据包都被终止\0\r\n，我们目前使用 StreamReader/Writer 从流中读取单个数据包。我们的主要瓶颈来自两个地方。

首先：我们需要修剪掉字符串末尾那个讨厌的小空字节。我们目前使用如下代码：

line = await reader.ReadLineAsync();
line = line.Replace("\0", ""); // PERF this allocates a new string
if (string.IsNullOrWhiteSpace(line))
    return null;
var packet = ClientPacket.Parse(line, cl.Client.RemoteEndPoint);

正如你从那个可爱的小评论中看到的那样，我们在修剪 '\0' 时遇到了 GC 性能问题。有许多不同的方法可以修剪字符串末尾的 '\0'，但所有方法都会导致我们得到相同的 GC 锤击。因为所有字符串操作都是不可变的，所以它们会导致创建一个新的字符串对象。由于我们的服务器处理 1000 多个连接，所有连接都以每秒大约 25-40 个数据包的速度进行通信（它是一个游戏服务器），这个 GC 问题正在成为一个问题。所以我的第一个问题来了：有什么更有效的方法来修剪字符串末尾的 '\0'？高效我不仅指速度，还指 GC 明智（最终我想要一种在不创建新字符串对象的情况下摆脱它的方法！）。

我们的第二个问题也源于 GC 土地。我们的代码如下所示：

private static string[] emptyStringArray = new string[] { }; // so we dont need to allocate this
public static ClientPacket Parse(string line, EndPoint from)
{
    const char seperator = '|';

    var first_seperator_pos = line.IndexOf(seperator);
    if (first_seperator_pos < 1)
    {
        return new ClientPacket(NetworkStringToClientPacketType(line), emptyStringArray, from);
    }
    var name = line.Substring(0, first_seperator_pos);
    var type = NetworkStringToClientPacketType(name);
    if (line.IndexOf(seperator, first_seperator_pos + 1) < 1)
        return new ClientPacket(type, new string[] { line.Substring(first_seperator_pos + 1) }, from);
    return new ClientPacket(type, line.Substring(first_seperator_pos + 1).Split(seperator), from);
}

（哪里NetworkStringToClientPacketType只是一个大的开关盒块）

正如你所看到的，我们已经做了一些处理 GC 的事情。我们重用一个静态的“空”字符串，并检查没有参数的数据包。我唯一的问题是我们经常使用子字符串，甚至在子字符串的末尾链接一个拆分。这导致（对于一个平均数据包）几乎 20 个新的字符串对象被创建，12 个被处理掉每个数据包。当负载增加超过 400 个用户时，这会导致很多性能问题（我们得到了快速 ram：3）

有没有人以前有过这种事情的经验，或者可以给我们一些关于下一步要研究什么的指示？也许是一些神奇的课程或一些漂亮的指针魔法？

（PS。StringBuilder 没有帮助，因为我们没有构建字符串，我们通常将它们拆分。）

我们目前有一些基于索引的系统的想法，我们存储每个参数的索引和长度，而不是拆分它们。想法？

其他几件事。反编译 mscorlib 并浏览字符串类代码，在我看来IndexOf调用是通过 P/Invoke 完成的，这意味着它们为每个调用增加了开销，如果我错了，请纠正我？IndexOf使用char[]数组手动实现不是更快吗？

public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)
{
    ...
    return TextInfo.IndexOfStringOrdinalIgnoreCase(this, value, startIndex, count);
    ...
}

internal static int IndexOfStringOrdinalIgnoreCase(string source, string value, int startIndex, int count)
{
    ...
    if (TextInfo.TryFastFindStringOrdinalIgnoreCase(4194304, source, startIndex, value, count, ref result))
    {
        return result;
    }
    ...
}

...

[DllImport("QCall", CharSet = CharSet.Unicode)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool InternalTryFindStringOrdinalIgnoreCase(int searchFlags, string source, int sourceCount, int startIndex, string target, int targetCount, ref int foundIndex);

然后我们到达 String.Split ，它最终调用Substring自己（沿着这条线的某个地方）：

// string
private string[] InternalSplitOmitEmptyEntries(int[] sepList, int[] lengthList, int numReplaces, int count)
{
    int num = (numReplaces < count) ? (numReplaces + 1) : count;
    string[] array = new string[num];
    int num2 = 0;
    int num3 = 0;
    int i = 0;
    while (i < numReplaces && num2 < this.Length)
    {
        if (sepList[i] - num2 > 0)
        {
            array[num3++] = this.Substring(num2, sepList[i] - num2);
        }
        num2 = sepList[i] + ((lengthList == null) ? 1 : lengthList[i]);
        if (num3 == count - 1)
        {
            while (i < numReplaces - 1)
            {
                if (num2 != sepList[++i])
                {
                    break;
                }
                num2 += ((lengthList == null) ? 1 : lengthList[i]);
            }
            break;
        }
        i++;
    }
    if (num2 < this.Length)
    {
        array[num3++] = this.Substring(num2);
    }
    string[] array2 = array;
    if (num3 != num)
    {
        array2 = new string[num3];
        for (int j = 0; j < num3; j++)
        {
            array2[j] = array[j];
        }
    }
    return array2;
}

谢天谢地，Substring 看起来很快（而且效率很高！）：

private unsafe string InternalSubString(int startIndex, int length, bool fAlwaysCopy)
{
    if (startIndex == 0 && length == this.Length && !fAlwaysCopy)
    {
        return this;
    }
    string text = string.FastAllocateString(length);
    fixed (char* ptr = &text.m_firstChar)
    {
        fixed (char* ptr2 = &this.m_firstChar)
        {
            string.wstrcpy(ptr, ptr2 + (IntPtr)startIndex, length);
        }
    }
    return text;
}

在这里阅读此答案后，我认为可以找到基于指针的解决方案...想法？

谢谢。

4

1 回答 1

2

你可以“作弊”并在Encoder水平上工作......

public class UTF8NoZero : UTF8Encoding
{
    public override Decoder GetDecoder()
    {
        return new MyDecoder();
    }
}

public class MyDecoder : Decoder
{
    public Encoding UTF8 = new UTF8Encoding();

    public override int GetCharCount(byte[] bytes, int index, int count)
    {
        return UTF8.GetCharCount(bytes, index, count);
    }

    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
    {
        int count2 = UTF8.GetChars(bytes, byteIndex, byteCount, chars, charIndex);
        int i, j;

        for (i = charIndex, j = charIndex; i < charIndex + count2; i++)
        {
            if (chars[i] != '\0')
            {
                chars[j] = chars[i];
                j++;
            }
        }

        for (int k = j; k < charIndex + count2; k++)
        {
            chars[k] = '\0';
        }

        return count2 + (i - j);
    }
}

请注意，此作弊是基于StreamReader.ReadLineAsync仅使用GetChars(). char[]我们删除了使用的临时缓冲区缓冲区中的 '\0' StreamReader.ReadLineAsync。

于 2013-09-09T07:10:29.473 回答