c# - 使用 64 位进程读取文本文件非常慢

Question

我正在将文本文件 (.itf) 与文件夹中的一些逻辑合并。当我将它编译为 32 位(控制台应用程序，.Net 4.6)时，一切正常，除了如果文件夹中有大量数据，我会得到 outofmemory 异常。将其编译为 64 位可以解决该问题，但与 32 位进程相比，它的运行速度非常慢(慢 15 倍以上)。

我用 BufferedStream 和 ReadAllLines 试过了，但两者的表现都很差。探查器告诉我这些方法使用了 99% 的时间。我不知道问题是...

代码如下:

private static void readData(Dictionary<string, Topic> topics)
{
    foreach (string file in Directory.EnumerateFiles(Path, "*.itf"))
    {
        Topic currentTopic = null;
        Table currentTable = null;
        Object currentObject = null;
        using (var fs = File.Open(file, FileMode.Open))
        {
            using (var bs = new BufferedStream(fs))
            {
                using (var sr = new StreamReader(bs, Encoding.Default))
                {
                    string line;
                    while ((line = sr.ReadLine()) != null)
                    {
                        if (line.IndexOf("ETOP") > -1)
                        {
                            currentTopic = null;
                        }
                        else if (line.IndexOf("ETAB") > -1)
                        {
                            currentTable = null;
                        }
                        else if (line.IndexOf("ELIN") > -1)
                        {
                            currentObject = null;
                        }
                        else if (line.IndexOf("MTID") > -1)
                        {
                            MTID = line.Replace("MTID ", "");
                        }
                        else if (line.IndexOf("MODL") > -1)
                        {
                            MODL = line.Replace("MODL ", "");
                        }
                        else if (line.IndexOf("TOPI") > -1)
                        {
                            var name = line.Replace("TOPI ", "");
                            if (topics.ContainsKey(name))
                            {
                                currentTopic = topics[name];
                            }
                            else
                            {
                                var topic = new Topic(name);
                                currentTopic = topic;
                                topics.Add(name, topic);
                            }
                        }
                        else if (line.IndexOf("TABL") > -1)
                        {
                            var name = line.Replace("TABL ", "");
                            if (currentTopic.Tables.ContainsKey(name))
                            {
                                currentTable = currentTopic.Tables[name];
                            }
                            else
                            {
                                var table = new Table(name);
                                currentTable = table;
                                currentTopic.Tables.Add(name, table);
                            }
                        }
                        else if (line.IndexOf("OBJE") > -1)
                        {
                            if (currentTable.Name != "Metadata" || currentTable.Objects.Count == 0)
                            {
                                var shortLine = line.Replace("OBJE ", "");
                                var obje = new Object(shortLine.Substring(shortLine.IndexOf(" ")));
                                currentObject = obje;
                                currentTable.Objects.Add(obje);
                            }
                        }
                        else if (currentTopic != null && currentTable != null && currentObject != null)
                        {
                            currentObject.Data.Add(line);
                        }
                    }
                }
            }
        }
    }
}

Answer 1

你的程序最大的问题是，当你让它在 64 位模式下运行时，它可以读取更多的文件。这很好，64 位进程的地址空间是 32 位进程的一千倍，用完它的可能性极小。

但您不会获得多一千倍的 RAM。

工作中“天下没有免费的午餐”的普遍原则。在这样的程序中，拥有足够的 RAM 非常重要。首先，它由文件系统缓存使用。使它看起来就像从磁盘读取文件的神奇操作系统功能非常便宜。它根本不是您在程序中可以做的最慢的事情之一，但它非常善于隐藏它。当您多次运行您的程序时，您将调用它。第二次和随后的时间，您根本不会从磁盘读取数据。这是一个非常危险的特性，当您测试您的程序时很难避免，您会得到非常关于它的效率的不切实际的假设。

64 位进程的问题在于它很容易使文件系统缓存失效。由于您可以读取更多文件，从而使缓存不堪重负。并删除旧文件数据。现在你第二次运行你的程序时，它不会再快了。您读取的文件将不再在缓存中，但必须从磁盘中读取。您现在将看到程序的真实 性能，它在生产中的表现方式。这是一件好事，即使你不太喜欢它:)

RAM 的次要问题是较小的一个，如果您分配大量内存来存储文件数据，那么您将迫使操作系统寻找 RAM 来存储它。这可能会导致大量硬页面错误，当它必须取消映射另一个进程或您的进程使用的内存以释放您需要的 RAM 时，就会发生这种情况。一个称为“抖动”的通用问题。您可以在任务管理器中看到页面错误，使用“查看”>“选择列”来添加它。

鉴于文件系统缓存最有可能是速度下降的原因，您可以做的一个简单测试是重启您的机器，以确保缓存不会有任何文件数据，然后运行 ​​32 位版本。预测它也会很慢并且 BufferedStream 和 ReadAllLines 是瓶颈。就像他们应该的那样。

最后一点，即使您的程序与模式不匹配，您也不能对 .NET 4.6 性能问题做出强有力的假设。直到 this very nasty bug得到修复。