RegEx、StringBuilder 和大对象堆碎片

Question

如何在大字符串中运行大量正则表达式（以查找匹配项）而不导致 LOH 碎片？

它是 .NET Framework 4.0，所以我使用 StringBuilder，因此它不在 LOH 中，但是一旦我需要在其上运行 RegEx，我就必须调用 StringBuilder.ToString() code> 这意味着它将位于 LOH 中。

这个问题有什么解决办法吗？实际上不可能有一个长时间运行的应用程序来处理这样的大字符串和正则表达式。

解决这个问题的想法：

在思考这个问题时，我想我找到了一个肮脏的解决方案。

在给定时间我只有 5 个字符串，这 5 个字符串（大于 85KB）将被传递给 RegEx.Match。

由于由于新对象无法容纳 LOH 中的空白空间而产生碎片，因此这应该可以解决问题：

1. PadRight 将所有字符串限制为最大值。接受的大小，比方说 1024KB（我可能需要使用 StringBuider 来做到这一点）
2. 通过这样做，所有新字符串都将适合已经清空的内存，因为先前的字符串已经超出范围
3. 不会有任何碎片因为对象大小始终相同，因此我只会在给定时间分配 1024*5，并且 LOH 中的这些空间将在这些字符串之间共享。

我想这个设计的最大问题是，如果其他大对象在 LOH 中分配这个位置，会发生什么，这会导致应用程序分配大量 1024 KB 字符串，可能会产生更糟糕的碎片。 fixed 语句可能会有所帮助，但是如何将固定字符串发送到 RegEx，而不实际创建一个不在固定内存地址中的新字符串？

关于这个理论有什么想法吗？ （不幸的是，我无法轻松重现问题，我通常尝试使用内存分析器来观察变化，并且不确定我可以为此编写什么样的隔离测试用例）

Answer 1

好的，这是我尝试以相当通用的方式解决这个问题，但有一些明显的限制。由于我没有在任何地方看到过这个建议，而且每个人都在抱怨 LOH 碎片，所以我想分享代码以确认我的设计和假设是正确的。

理论：

1. 创建一个共享的大型 StringBuilder （这是为了存储我们从流中读取的大字符串） - new StringBuilder(ChunkSize * 5);
2. 创建一个大型 String （必须大于最大可接受的大小），应使用空白空间进行初始化。 - 新字符串(' ', ChunkSize * 10);
3. 将字符串对象固定到内存中，这样 GC 就不会弄乱它。 GCHandle.Alloc(pinnedText, GCHandleType.Pinned)。尽管 LOH 对象通常是固定的，但这似乎可以提高性能。可能是因为不安全代码
4. 将流读入共享StringBuilder，然后使用索引器不安全地将其复制到pinnedText
5. 将pinnedText传递给RegEx

使用此实现，下面的代码就像没有LOH分配一样工作。如果我切换到 new string(' ') 分配而不是使用静态 StringBuilder 或使用 StringBuilder.ToString() 代码可以分配

我还使用内存分析器确认了结果，即此实现中不存在 LOH 碎片。我仍然不明白为什么 RegEx 不会引起任何意外的问题。我还使用不同且昂贵的正则表达式模式进行了测试，结果是相同的，没有碎片。

代码：

http://pastebin.com/ZuuBUXk3

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;

namespace LOH_RegEx
{
    internal class Program
    {
        private static List<string> storage = new List<string>();
        private const int ChunkSize = 100000;
        private static StringBuilder _sb = new StringBuilder(ChunkSize * 5);


        private static void Main(string[] args)
        {
            var pinnedText = new string(' ', ChunkSize * 10);
            var sourceCodePin = GCHandle.Alloc(pinnedText, GCHandleType.Pinned);

            var rgx = new Regex("A", RegexOptions.CultureInvariant | RegexOptions.Compiled);

            try
            {

                for (var i = 0; i < 30000; i++)
                {                   
                    //Simulate that we read data from stream to SB
                    UpdateSB(i);
                    CopyInto(pinnedText);                   
                    var rgxMatch = rgx.Match(pinnedText);

                    if (!rgxMatch.Success)
                    {
                        Console.WriteLine("RegEx failed!");
                        Console.ReadLine();
                    }

                    //Extra buffer to fragment LoH
                    storage.Add(new string('z', 50000));
                    if ((i%100) == 0)
                    {
                        Console.Write(i + ",");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.WriteLine("OOM Crash!");
                Console.ReadLine();
            }
        }


        private static unsafe void CopyInto(string text)
        {
            fixed (char* pChar = text)
            {
                int i;
                for (i = 0; i < _sb.Length; i++)
                {
                    pChar[i] = _sb[i];
                }

                pChar[i + 1] = '\0';
            }
        }

        private static void UpdateSB(int extraSize)
        {
            _sb.Remove(0,_sb.Length);

            var rnd = new Random();
            for (var i = 0; i < ChunkSize + extraSize; i++)
            {
                _sb.Append((char)rnd.Next(60, 80));
            }
        }
    }
}

Answer 2

您可以在某个时间点卸载的 AppDomain 中完成您的工作吗？

Answer 3

一种替代方法是找到某种方法在基于非数组的数据结构上执行正则表达式匹配。不幸的是，快速的谷歌并没有在基于流的正则表达式库方面提出太多建议。我猜想 reg-ex 算法需要进行大量的回溯，这是流不支持的。

您绝对需要正则表达式的全部功能吗？您是否可以实现自己的更简单的搜索函数，该函数可以在 85kb 以下的字符串链接列表上工作？

此外，如果您长时间保留大对象引用，LOH 碎片只会真正导致问题。如果你不断地创建和销毁它们，那么 LOH 就不会增长。

FWIW，我找到了 RedGate ANTS 内存分析器 非常擅长追踪 LOH 中的对象和碎片级别。