C# 和.NET : stackalloc

Question

我对 stackalloc 运算符的功能有一些疑问。

1. 它实际上是如何分配的？我认为它会做类似的事情:

   void* stackalloc(int sizeInBytes)
   {
       void* p = StackPointer (esp);
       StackPointer += sizeInBytes;
       if(StackPointer exceeds stack size)
           throw new StackOverflowException(...);
       return p;
   }
   

   但我已经做了一些测试，但我不确定它是如何工作的。我们无法确切知道它的作用以及它是如何做到的，但我想了解基础知识。

2. 我认为堆栈分配(嗯，实际上我确定)比堆分配更快。那么为什么这个例子:

    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw1 = new Stopwatch();
            sw1.Start();
            StackAllocation();
            Console.WriteLine(sw1.ElapsedTicks);
   
            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            HeapAllocation();
            Console.WriteLine(sw2.ElapsedTicks);
        }
        static unsafe void StackAllocation()
        {
            for (int i = 0; i < 100; i++)
            {
                int* p = stackalloc int[100];
            }
        }
        static void HeapAllocation()
        {
            for (int i = 0; i < 100; i++)
            {
                int[] a = new int[100];
            }
        }
    }
   

给出280~ 堆栈分配滴答 的平均结果，通常1-0 滴答堆分配？(在我的个人计算机上，Intel Core i7)。

在我现在使用的计算机(Intel Core 2 Duo)上，结果比以前的更有意义(可能是因为 Optimize code 没有在 VS 中检查): 堆栈分配 460~ ticks，堆分配大约 380 ticks。

但这仍然没有意义。为什么会这样？我猜 CLR 注意到我们没有使用数组，所以它可能甚至没有分配它？

Answer 1

stackalloc 更快的情况:

 private static volatile int _dummy; // just to avoid any optimisations
                                         // that have us measuring the wrong
                                         // thing. Especially since the difference
                                         // is more noticable in a release build
                                         // (also more noticable on a multi-core
                                         // machine than single- or dual-core).
 static void Main(string[] args)
 {
     System.Diagnostics.Stopwatch sw1 = new System.Diagnostics.Stopwatch();
     Thread[] threads = new Thread[20];
     sw1.Start();
     for(int t = 0; t != 20; ++t)
     {
        threads[t] = new Thread(DoSA);
        threads[t].Start();
     }
     for(int t = 0; t != 20; ++t)
        threads[t].Join();
     Console.WriteLine(sw1.ElapsedTicks);

     System.Diagnostics.Stopwatch sw2 = new System.Diagnostics.Stopwatch();
     threads = new Thread[20];
     sw2.Start();
     for(int t = 0; t != 20; ++t)
     {
        threads[t] = new Thread(DoHA);
        threads[t].Start();
     }
     for(int t = 0; t != 20; ++t)
        threads[t].Join();
     Console.WriteLine(sw2.ElapsedTicks);
     Console.Read();
 }
 private static void DoSA()
 {
    Random rnd = new Random(1);
    for(int i = 0; i != 100000; ++i)
        StackAllocation(rnd);
 }
 static unsafe void StackAllocation(Random rnd)
 {
    int size = rnd.Next(1024, 131072);
    int* p = stackalloc int[size];
    _dummy = *(p + rnd.Next(0, size));
 }
 private static void DoHA()
 {
    Random rnd = new Random(1);
    for(int i = 0; i != 100000; ++i)
        HeapAllocation(rnd);
 }
 static void HeapAllocation(Random rnd)
 {
    int size = rnd.Next(1024, 131072);
    int[] a = new int[size];
    _dummy = a[rnd.Next(0, size)];
 }

此代码与问题中的代码之间的重要区别:

1. 我们有几个线程在运行。通过堆栈分配，他们在自己的堆栈中进行分配。通过堆分配，它们从与其他线程共享的堆中进行分配。

2. 分配更大的尺寸。

3. 每次分配不同的大小(尽管我为随机生成器设置了种子以使测试更具确定性)。这使得堆碎片更有可能发生，从而使堆分配的效率低于每次相同的分配。

除此之外，还值得注意的是 stackalloc通常会用作使用 fixed 的替代方法将数组固定在堆上。固定数组不利于堆性能(不仅对于该代码，而且对于使用同一堆的其他线程也是如此)，因此如果声明的内存在任何合理的时间内使用，那么性能影响会更大。

虽然我的代码演示了 stackalloc 的情况提供了性能优势，在问题中可能更接近于大多数情况，在大多数情况下，有人可能会急切地通过使用它来“优化”。希望这两段代码一起显示整个 stackalloc可以提升性能，但也会严重损害性能。

一般来说，你甚至不应该考虑 stackalloc除非您无论如何都需要使用固定内存与非托管代码进行交互，否则应将其视为 fixed 的替代方案。而不是一般堆分配的替代方案。在这种情况下使用仍然需要谨慎，开始前要深思熟虑，完成后进行分析。

在其他情况下使用可能会带来好处，但它应该远远低于您要尝试的性能改进列表。

编辑:

回答问题的第 1 部分。 Stackalloc 在概念上与您描述的差不多。它获得堆栈内存的一 block ，然后返回指向该 block 的指针。它不会检查内存是否适合这样，而是如果它试图将内存获取到堆栈的末尾 - 这在线程创建时受 .NET 保护 - 那么这将导致操作系统向运行时返回异常，然后它变成 .NET 托管异常。如果您只是在具有无限递归的方法中分配一个字节，就会发生同样的情况——除非对调用进行优化以避免堆栈分配(有时可能)，否则一个字节最终加起来足以触发堆栈溢出异常。