C#和.NET:stackalloc

我有一些关于stackalloc运算符function的问题。

  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~ticks的平均结果,通常为堆分配1-0滴答? (在我的个人计算机上,Intel Core i7)。

在我现在使用的计算机上(英特尔酷睿2双核处理器),结果比前面的计算机更有意义(可能是因为VS中没有检查优化代码 ): 460~用于堆栈分配的滴答 ,以及用于堆分配的380滴答

但这仍然没有意义。 为什么会这样? 我想CLR注意到我们不使用数组,所以也许它甚至没有分配它?

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 ,还值得注意的是, stackalloc通常用作使用fixedfixed堆上的数组的替代方法。 固定数组不利于堆性能(不仅适用于该代码,也适用于使用相同堆的其他线程),因此如果声明的内存将在任何合理的时间长度内使用,性能影响将更大。

虽然我的代码演示了stackalloc提供性能优势的情况,但问题中的问题可能更接近于大多数人可能会急切地“优化”使用它的情况。 希望这两段代码一起显示整个stackalloc可以提升,它也可以对性能造成太大影响。

通常,您甚至不应该考虑使用stackalloc除非您stackalloc都需要使用固定内存来与非托管代码进行交互,并且应该将其视为fixed而非替代常规堆分配的替代方法。 在这种情况下使用仍然需要谨慎,在开始之前需要预先考虑,并在完成后进行分析。

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

编辑:

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

  1. 我无法给出确切的答案,但stackalloc是使用IL操作码localloc 。 我查看了stackalloc发布版本生成的机器代码,它比我预期的更复杂。 我不知道localloc是否会检查堆栈大小,因为你指示if或者当硬件堆栈实际溢出时CPU是否检测到堆栈溢出。

    对此答案的评论表明,提供给localloc的链接从“本地堆”分配空间。 问题是,除了PDF格式的实际标准外,MSIL没有良好的在线参考。 上面的链接来自System.Reflection.Emit.OpCodes类,该类与MSIL无关,而是用于生成MSIL的库。

    但是,在标准文件ECMA 335 – 公共语言基础设施中,有一个更精确的描述:

    每个方法状态的一部分是本地内存池。 可以使用localloc指令从本地内存池显式分配内存。 在方法出口处回收本地内存池中的所有内存,这是回收本地内存池内存的唯一方法(没有提供释放在此方法调用期间分配的本地内存的指令)。 本地内存池用于分配在编译时未知类型或大小的对象,以及程序员不希望在托管堆中分配的对象。

    所以基本上“本地内存池”就是所谓的“堆栈”,C#语言使用stackalloc运算符从这个池中分配。

  2. 在发布版本中,优化器足够智能,可以完全删除对HeapAllocation的调用,从而大大降低执行时间。 在使用stackalloc时,似乎不够智能来执行相同的优化。 如果您关闭优化或以某种方式使用分配的缓冲区,您将看到stackalloc稍快。