c# - 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 );
    }
}

他们都做同样的事情:

1. 创建堆栈(第一个示例在 <int> 中通用，第二个示例在对象堆栈中)。

2. 声明一个递归调用自身 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 堆栈没有显着过载，为什么它会比第一个示例“更快”崩溃？

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 指令并不是衡量“工作量”的准确方法。

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

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

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

如果您在“反汇编”窗口中检查它，您会发现通用版本和非通用版本之间的差异非常显着，并且比生成的 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。