LOH 碎片 - 2015 年更新

有大量有关 .NET LOH 的信息，并且已在各种文章中进行了解释。不过，有些文章似乎缺乏一点精确性。

过时的信息

In Brian Rasmussen 的回答 (2009)，Microsoft 项目经理 https://stackoverflow.com/a/687155/480982，他说限制是 85000 字节。他还让我们知道还有一个更奇怪的案例double[]大小为 1000 个元素。同样的 85000 限制由Maoni Stephens（MSDN，2008），CLR 团队成员 https://msdn.microsoft.com/en-us/magazine/cc534993.aspx.

在评论中，Brian Rasmussen 变得更加准确，让我们知道它可以用byte[]85000 字节 - 12 字节。

2013年更新

Mario Hewardt（《高级 Windows 调试》作者） http://blogs.msdn.com/b/mariohewardt/archive/2013/06/26/no-more-memory-fragmentation-on-the-large-object-heap.aspx2013 年告诉我们，.NET 4.5.1 现在也可以压缩 LOH，如果我们告诉它这样做的话。由于默认情况下它是关闭的，因此问题仍然存在，除非您已经意识到这一点。

2015年更新

我无法重现byte[]再举个例子吧。通过一个简短的强力算法，我发现我必须减去 24 (byte[84999-24]在苏俄，byte[85000-24]在洛）：

    static void Main(string[] args)
    {
        int diff = 0;
        int generation = 3;
        while (generation > 0)
        {
            diff++;
            byte[] large = new byte[85000-diff];
            generation = GC.GetGeneration(large);
        }            
        Console.WriteLine(diff);
    }

我也无法重现double[]陈述。暴力破解给了我 10622 个元素作为边界（double[10621]在苏俄，double[10622]在洛）：

    static void Main(string[] args)
    {
        int size = 85000;
        int step = 85000/2;
        while (step>0)
        {
            double[] d = new double[size];
            int generation = GC.GetGeneration(d);
            size += (generation>0)?-step:step;
            step /= 2;
        }
        Console.WriteLine(size);
    }

即使我为较旧的 .NET 框架编译应用程序，也会发生这种情况。它也不依赖于发布或调试版本。

如何解释这些变化？

从 12 到 24 的变化byte[]这个例子可以通过 CPU 架构从 32 位到 64 位的变化来解释。在为 x64 或 AnyCPU 编译的程序中，.NET 开销从 2*4 字节（4 字节对象头 + 4 字节方法表）增加到 2*8 字节（8 字节对象头 + 8 字节方法表）。此外，该数组的长度属性为 4 字节（32 位）与 8 字节（64 位）。

For the double[]例如，只需使用计算器：double 类型的 85000 字节/64 位 = 10625 项，这已经很接近了。考虑到 .NET 开销，结果为（85000 字节 - 24 字节）/每个双精度数 8 字节 = 10622 双精度数。所以没有特殊处理double[]不再有。

顺便说一句，我以前从未找到过任何 LOH 碎片的有效演示，所以我自己写了一个。只需为 x86 编译以下代码并运行即可。它甚至包括一些调试提示。

当编译为 x64 时，它不会正常工作，因为 Windows 可能会增加页面文件的大小，因此随后的 20 MB 内存分配可能会再次成功。

class Program
{
    static IList<byte[]> small = new List<byte[]>();
    static IList<byte[]> big = new List<byte[]>(); 

    static void Main()
    {
        int totalMB = 0;
        try
        {
            Console.WriteLine("Allocating memory...");
            while (true)
            {
                big.Add(new byte[10*1024*1024]);
                small.Add(new byte[85000-3*IntPtr.Size]);
                totalMB += 10;
                Console.WriteLine("{0} MB allocated", totalMB);
            }
        }
        catch (OutOfMemoryException)
        {
            Console.WriteLine("Memory is full now. Attach and debug if you like. Press Enter when done.");
            Console.WriteLine("For WinDbg, try `!address -summary` and  `!dumpheap -stat`.");
            Console.ReadLine();

            big.Clear();
            GC.Collect();
            Console.WriteLine("Lots of memory has been freed. Check again with the same commands.");
            Console.ReadLine();

            try
            {
                big.Add(new byte[20*1024*1024]);
            }
            catch(OutOfMemoryException)
            {
                Console.WriteLine("It was not possible to allocate 20 MB although {0} MB are free.", totalMB);
                Console.ReadLine();
            }
        }
    }
}