Stackoverflow 在 C# 中进行装箱

Question

我在 C# 中有这两段代码：

第一个

class Program
{
    static Stack<int> S = new Stack<int>();

    static int Foo(int n) {
        if (n == 0)
            return 0;
        S.Push(0);
        S.Push(1);
        ...
        S.Push(999);
        return Foo( n-1 );
    }
}

第二个

class Program
{
    static Stack S = new Stack();

    static int Foo(int n) {
        if (n == 0)
            return 0;
        S.Push(0);
        S.Push(1);
        ...
        S.Push(999);
        return Foo( n-1 );
    }
}

他们都做同样的事情：

创建堆栈（第一个示例在 <int> 中通用，第二个示例在对象堆栈中通用）。
声明一个递归调用自身 n 次 (n >= 0) 并在每一步中将 1000 个整数压入创建的堆栈的方法。

当我运行第一个例子 Foo(30000) 没有异常发生，但是第二个例子崩溃 Foo(1000)，只是 n = 1000.

当我看到为这两种情况生成的 CIL 时，唯一的区别是每次推送的装箱部分：

第一个

IL_0030:  ldsfld     class [System]System.Collections.Generic.Stack`1<int32> Test.Program::S
IL_0035:  ldc.i4     0x3e7
IL_003a:  callvirt   instance void class [System]System.Collections.Generic.Stack`1<int32>::Push(!0)
IL_003f:  nop

第二个

IL_003a:  ldsfld     class [mscorlib]System.Collections.Stack Test.Program::S
IL_003f:  ldc.i4     0x3e7
IL_0044:  box        [mscorlib]System.Int32
IL_0049:  callvirt   instance void [mscorlib]System.Collections.Stack::Push(object)
IL_004e:  nop

我的问题是：如果第二个示例的 CIL 堆栈没有显着过载，为什么它会比第一个示例崩溃 "faster"？

Answer 1

Why, if there is not significant overload of CIL's stack for second example, does it crash "faster" than the first one?

请注意，CIL 指令的数量并不准确表示将使用的工作量或内存量。单个指令的影响可能很小，也可能很大，因此计算 CIL 指令数并不是衡量 "work".

的准确方法

还意识到 CIL 不是被执行的。 JIT 将 CIL 编译为实际的机器指令，具有优化阶段，因此 CIL 可能与实际执行的指令有很大不同。

在第二种情况下，由于您使用的是非泛型集合，因此每个 Push 调用都需要装箱整数，正如您在 CIL 中确定的那样。

装箱一个整数可以有效地为您创建一个 "wraps" 和 Int32 的对象。它现在必须将 32 位整数加载到堆栈上，而不是仅仅将 32 位整数加载到堆栈上，然后将其装箱，这实际上也将对象引用加载到堆栈上。

如果您在反汇编中检查它 window，您会发现通用版本和非通用版本之间的差异非常显着，并且比生成的 CIL 所建议的要重要得多。

通用版本有效地编译为一系列调用，如下所示：

0000022c  nop 
            S.Push(25);
0000022d  mov         ecx,dword ptr ds:[03834978h] 
00000233  mov         edx,19h 
00000238  cmp         dword ptr [ecx],ecx 
0000023a  call        71618DD0 
0000023f  nop 
            S.Push(26);
00000240  mov         ecx,dword ptr ds:[03834978h] 
00000246  mov         edx,1Ah 
0000024b  cmp         dword ptr [ecx],ecx 
0000024d  call        71618DD0 
00000252  nop 
            S.Push(27);

另一方面，非泛型必须创建盒装对象，而不是编译为：

00000645  nop 
            S.Push(25);
00000646  mov         ecx,7326560Ch 
0000064b  call        FAAC20B0 
00000650  mov         dword ptr [ebp-48h],eax 
00000653  mov         eax,dword ptr ds:[03AF4978h] 
00000658  mov         dword ptr [ebp+FFFFFEE8h],eax 
0000065e  mov         eax,dword ptr [ebp-48h] 
00000661  mov         dword ptr [eax+4],19h 
00000668  mov         eax,dword ptr [ebp-48h] 
0000066b  mov         dword ptr [ebp+FFFFFEE4h],eax 
00000671  mov         ecx,dword ptr [ebp+FFFFFEE8h] 
00000677  mov         edx,dword ptr [ebp+FFFFFEE4h] 
0000067d  mov         eax,dword ptr [ecx] 
0000067f  mov         eax,dword ptr [eax+2Ch] 
00000682  call        dword ptr [eax+18h] 
00000685  nop 
            S.Push(26);
00000686  mov         ecx,7326560Ch 
0000068b  call        FAAC20B0 
00000690  mov         dword ptr [ebp-48h],eax 
00000693  mov         eax,dword ptr ds:[03AF4978h] 
00000698  mov         dword ptr [ebp+FFFFFEE0h],eax 
0000069e  mov         eax,dword ptr [ebp-48h] 
000006a1  mov         dword ptr [eax+4],1Ah 
000006a8  mov         eax,dword ptr [ebp-48h] 
000006ab  mov         dword ptr [ebp+FFFFFEDCh],eax 
000006b1  mov         ecx,dword ptr [ebp+FFFFFEE0h] 
000006b7  mov         edx,dword ptr [ebp+FFFFFEDCh] 
000006bd  mov         eax,dword ptr [ecx] 
000006bf  mov         eax,dword ptr [eax+2Ch] 
000006c2  call        dword ptr [eax+18h] 
000006c5  nop

由此可见拳击的意义

在您的例子中，装箱整数会导致装箱的对象引用加载到堆栈中。在我的系统上，这会导致任何大于 Foo(127)（32 位）的调用发生堆栈溢出，这表明整数和盒装对象引用（每个 4 个字节）都保存在堆栈中，如 127* 1000*8==1016000，这非常接近 .NET 应用程序的默认 1 MB 线程堆栈大小。

使用通用版本时，由于没有装箱对象，整数不必全部存储在堆栈上，并且可以重复使用同一个寄存器。这允许您在用完堆栈之前递归更多（在我的系统上 >40000）。

请注意，这将取决于 CLR 版本和平台，因为 x86/x64 上也有不同的 JIT。

Stackoverflow 在 C# 中进行装箱

Stackoverflow doing boxing in C#

c#

stack-overflow

il

第一个

第二个

第一个

第二个