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

我正在将文本文件(.itf)与位于文件夹中的某些逻辑合并.当我将它编译为32位(控制台应用程序,.Net 4.6)时,一切正常,但如果文件夹中有大量数据,我会得到超出内存的异常.将它编译为64位可以解决这个问题,但与32位进程相比...

我正在将文本文件(.itf)与位于文件夹中的某些逻辑合并.当我将它编译为32位(控制台应用程序,.Net 4.6)时,一切正常,但如果文件夹中有大量数据,我会得到超出内存的异常.将它编译为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);
                        }
                    }
                }
            }
        }
    }
}

解决方法:

你的程序最大的问题是,当你让它在64位模式下运行时,它可以读取更多的文件.哪个好,64位进程的地址空间比32位进程多一千倍,用完它的可能性太小了.

但是你的内存不会多一千倍.

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

64位进程的问题在于它很容易使文件系统缓存无效.因为你可以读取更多的文件,从而压倒了缓存.并删除旧文件数据.现在,第二次运行程序时,它将不再快速.您读取的文件不再在缓存中,但必须从磁盘中读取.您现在将看到程序的实际性能,以及它在生产中的表现方式.这是一件好事,即使你不喜欢它:)

RAM的次要问题是较小的问题,如果你分配了大量内存来存储文件数据,那么你将强制操作系统找到存储它的RAM.这可能会导致很多硬页面错误,当它必须取消映射另一个进程使用的内存时,或者你的内存,以释放你需要的RAM.一个称为“颠簸”的通用问题.页面错误是您可以在任务管理器中看到的,使用View>选择列以添加它.

鉴于文件系统缓存最有可能是减速源,您可以做的一个简单测试是重新启动计算机,这可以确保缓存不能包含任何文件数据,然后运行32位版本.预测它也会很慢并且BufferedStream和ReadAllLines是瓶颈.就像他们应该的那样.

最后要注意的是,即使您的程序与模式不匹配,也无法对.NET 4.6性能问题做出强有力的假设.直到this very nasty bug才得到修复.