C# и .NET: stackalloc

У меня есть несколько вопросов о функциональности оператора 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)
    {
    Секундомер sw1 = new Stopwatch();
    sw1.Start();
    StackAllocation();
    Console.WriteLine(sw1.ElapsedTicks);
   
    Секундомер sw2 = новый Секундомер();
    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), результаты имеют больше смысла, чем предыдущие (Возможно, потому что Оптимизировать код не был проверен в VS): 460~ тиков для выделения стека, и около 380 тиков для выделения кучи.

Но это все еще не имеет смысла. Почему это так? Я думаю, что CLR замечает, что мы не используем массив, поэтому, возможно, он даже не выделяет его?