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

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

但这仍然没有意义.为什么会这样？我想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在概念上与您描述的一样多.它获取堆栈内存的一大块,然后返回指向该块的指针.它没有检查内存是否适合这样,但是如果它试图获取内存到堆栈的末尾 - 这在创建线程时受.NET保护 - 那么这将导致操作系统返回运行时的异常,然后它变成.NET托管异常.如果你只是在一个具有无限递归的方法中分配一个字节,就会发生同样的情况 - 除非调优得到优化以避免堆栈分配(有时可能),然后单个字节最终会加起来足以触发堆栈溢出异常.