我在 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 堆栈没有显着过载，为什么它会比第一个示例“更快”崩溃？

最佳答案

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。

关于c# - Stackoverflow 在 C# 中进行装箱，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28865139/