C# stackalloc比正则变量慢？

Question

我有两个函数以两种不同的方式实现uint128乘法:一种是使用变量，另一种是使用stackalloc“数组”。

变量版本

public static UInt128 operator *(UInt128 i, UInt128 j) {

 ulong I0 = i._uint0; ulong I1 = i._uint1; ulong I2 = i._uint2; ulong I3 = i._uint3;
 ulong J0 = j._uint0; ulong J1 = j._uint1; ulong J2 = j._uint2; ulong J3 = j._uint3;
 ulong R0 = 0; ulong R1 = 0; ulong R2 = 0; ulong R3 = 0;

 if (I0 != 0) {
   R0 += I0 * J0;
   R1 += I0 * J1;
   R2 += I0 * J2;
   R3 += I0 * J3;
 }
 if (I1 != 0) {
   R1 += I1 * J0;
   R2 += I1 * J1;
   R3 += I1 * J2;
 }
 if (I2 != 0) {
   R2 += I2 * J0;
   R3 += I2 * J1;
 }
 R3 += I3 * J0;

 R1 += R0 >> 32; R0 &= uint.MaxValue;
 R2 += R1 >> 32; R1 &= uint.MaxValue;
 R3 += R2 >> 32; R2 &= uint.MaxValue;
 R3 &= uint.MaxValue;

 return new UInt128((uint)R3, (uint)R2, (uint)R1, (uint)R0);
}

Stackalloc版本

[0 + 1]、[1 + 1]等只为清晰起见。无论如何，它们都将由C#编译器优化成常量。

public unsafe static UInt128 operator *(UInt128 i, UInt128 j) {

  var I = stackalloc ulong[4];
  var J = stackalloc ulong[4];
  var R = stackalloc ulong[4];

  I[0] = i._uint0; I[1] = i._uint1; I[2] = i._uint2; I[3] = i._uint3;
  J[0] = j._uint0; J[1] = j._uint1; J[2] = j._uint2; J[3] = j._uint3;


  if (I[0] != 0) {
    R[0] += I[0] * J[0];
    R[0 + 1] += I[0] * J[1];
    R[0 + 2] += I[0] * J[2];
    R[0 + 3] += I[0] * J[3];
  }
  if (I[1] != 0) {
    R[1] += I[1] * J[0];
    R[1 + 1] += I[1] * J[1];
    R[1 + 2] += I[1] * J[2];
  }
  if (I[2] != 0) {
    R[2] += I[2] * J[0];
    R[2 + 1] += I[2] * J[1];
  }
  R[3] += I[3] * J[0];


  R[1] += R[0] >> 32; R[0] &= uint.MaxValue;
  R[2] += R[1] >> 32; R[1] &= uint.MaxValue;
  R[3] += R[2] >> 32; R[2] &= uint.MaxValue;
  R[3] &= uint.MaxValue;

  return new UInt128((uint)R[3], (uint)R[2], (uint)R[1], (uint)R[0]);
}

由于某些原因，使用运行在x86 4.6.1上的C# 7.2编译器，“变量”版本似乎比x64和C#上的"stackalloc“版本快了20%(通过优化)。还没有检查新的/旧的框架的性能，但怀疑它会类似，所以我的问题并不仅限于4.6.1，因为一般情况下stackalloc要慢一些。

考虑到两个版本分配的内存(12 * sizeof(ulong))完全相同，并且按照相同的顺序执行完全相同的操作，堆栈版本是否会慢一些？我非常希望通过stackalloc而不是变量来处理数组。

Answer 1

可变版本(简化)：https://sharplab.io/#v2:C4LghgzgtgPgAgZgAQWAJwK4GNhIKoCSAdsAIwBMAHAN4CwAUEk0hgDYD2RA5kgPoYBLEgAYA3A2YsO3PoJKlxjZm049+Q4OUWSVM9SQTbmifMTJUAFHNxgANCw1IARvetIsrxwBMAlHSWSTPrAwkgAvEhgRoGyGqThztGBweQJWEmSwcgRXkkAvgyF9CZwpABspvJUSOwADgCmaGDA7GhIAFQWhFWUSAL23ea9AFY+SP4SujwEoRECAHTBYkiT0jwAUrNIw4vWy6uqSABKW/v0EgIAZkgWM0gAhBEUCAAsY/7MJ0gA1BF37UhNooJAVzmCkHAAOxIIj1ADulSGFisGh8wnsKJIaIx1mxN1xJx8ilBkjyQA=

数组版本(简化)：https://sharplab.io/#v2:C4LghgzgtgPgAgZgAQWAJwK4GNhIKoCSAdsAIwBMAHAN4CwAUEk0hgDYD2RA5kgPoYBLEgAYA3A2YsO3PoJKlxjZm049+Q4OUWSVM9SQTbmifMTJUAFHNxgANCw1IARvetIsrxwBMAlHSWSTPrAwkgAvEhgRoGyGqThztGBweQJWEmSwcgRXkkAvgyF9CYYRBBgAGYApkhwpABspvJUSOwADlVoYMDsaEgAVBaEzZRIAvbD5qMAVj5I/hJIAG5gfQQJqGBYANZgrBxYUqoA2qQAukYrfQBSG8Bbu/vsh7pcpxeLV0gASncPewcjtx3opFgRjsIzgkBAA6YJiJCLa4QqERaZw6xiIqLAQVJAWcGQpAAQgiFAQABY5v5JN8UUgANQRQlQ/pIZGQowFeiLOAAdiQRCqAHcmlMLFYND5hPZJSRpbLrAr8Uq6ZCfIpuZI8kA=

从数组版本IL(L0009 - L004E)来说，可变版本只是使用寄存器，而数组版本使用的是stack.Althrough，数据适合于CPU缓存，但仍然比寄存器慢。