我对stackalloc运算符的功能有几个疑问。
它是如何实际分配的？我认为它的确如下：
void* stackalloc(int sizeInBytes)
{
void* p = StackPointer (esp);
StackPointer += sizeInBytes;
if(StackPointer exceeds stack size)
throw new StackOverflowException(...);
return p;
}
但是我做了一些测试，我不确定它是如何工作的。我们无法准确知道它的作用以及它是如何做到的，但我想了解基础知识。
我认为堆栈分配（好吧，我实际上肯定关于它）比堆分配更快。那么为什么这个例子：
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注意到我们不使用数组，所以也许它甚至不分配它？
答案 0 :(得分：11)
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)];
}
此代码与问题中的重要区别：
我们有几个线程在运行。使用堆栈分配，它们在自己的堆栈中进行分配。使用堆分配时，它们是从与其他线程共享的堆中分配的。
分配的尺寸更大。
每次分配不同的大小（虽然我播种随机生成器以使测试更具确定性）。这使得堆碎片更容易发生，使得堆分配效率低于每次使用相同分配的效率。
除此之外，值得注意的是stackalloc通常会被用作替代使用fixed来固定堆上的数组。固定数组不利于堆性能（不仅对于该代码，而且对于使用相同堆的其他线程），因此如果声明的内存将在任何合理的时间长度内使用，性能影响将更大。
虽然我的代码演示了stackalloc带来性能优势的情况，但问题中的问题可能更接近于大多数人可能会急切地“优化”使用它的情况。希望这两段代码一起显示整个stackalloc可以提升，它也会对性能产生很大影响。
通常，您甚至不应该考虑stackalloc，除非您需要使用固定内存来与非托管代码进行交互，并且应该将其视为fixed的替代方案而不是替代方案一般堆分配。在这种情况下使用仍然需要谨慎，在开始之前需要预先考虑，并在完成后进行分析。
在其他情况下使用可能会带来好处，但它应该远远低于您尝试的性能改进列表。
编辑：
回答问题的第1部分。 Stackalloc在概念上与您描述的一样多。它获取堆栈内存的一大块，然后返回指向该块的指针。它没有检查内存是否适合这样，但是如果它试图获取内存到堆栈的末尾 - 这在创建线程时受.NET保护 - 那么这将导致操作系统返回运行时的异常，然后它变成.NET托管异常。如果你只是在一个具有无限递归的方法中分配一个字节，就会发生同样的情况 - 除非调优得到优化以避免堆栈分配（有时可能），然后单个字节最终会加起来足以触发堆栈溢出异常。
答案 1 :(得分：3)
我无法给出确切的答案，但stackalloc是使用IL操作码localloc实现的。我查看了由stackalloc的发布版本生成的机器代码，它比我预期的更复杂。我不知道localloc是否会检查您的if指示的堆栈大小，或者当硬件堆栈实际溢出时CPU是否检测到堆栈溢出。
对此答案的评论表明，提供给localloc的链接从“本地堆”分配空间。问题是，除了PDF格式的实际标准外，MSIL没有良好的在线参考。上面的链接来自System.Reflection.Emit.OpCodes类，它与MSIL无关，而是用于生成MSIL的库。
但是，在标准文件ECMA 335 - Common Language Infrastructure中有更准确的描述：
每个方法状态的一部分是本地内存池。可以使用
localloc指令从本地内存池中显式分配内存。在方法出口处回收本地内存池中的所有内存，这是回收本地内存池内存的唯一方法（没有提供释放在此方法调用期间分配的本地内存的指令）。本地内存池用于分配在编译时未知类型或大小的对象，以及程序员不希望在托管堆中分配的对象。
所以基本上“本地内存池”就是所谓的“堆栈”，C＃语言使用stackalloc运算符从这个池中分配。
在发布版本中，优化器足够智能，可以完全删除对HeapAllocation的调用，从而大大缩短执行时间。在使用stackalloc时，似乎不够聪明，无法执行相同的优化。如果您关闭优化或以某种方式使用分配的缓冲区，您会看到stackalloc稍快一些。