那些遇到过的问题

分配引用类型时,c#中的奇怪stackoverflow

atl*_*ste 13 .net c# stack-overflow

在做一些奇特的代码生成时,我遇到了一个我不理解的堆栈溢出.

我的代码基本上是这样的:

static Tuple<string, int>[] DoWork() 
{
    // [ call some methods ]
    Tuple<string, int>[] tmp = new Tuple<string, int>[100];
    tmp[0] = new Tuple<string, int>("blah 1", 0);
    tmp[1] = new Tuple<string, int>("blah 2", 1);
    tmp[2] = new Tuple<string, int>("blah 3", 2);
    // ...
    tmp[99] = new Tuple<string, int>("blah 99", 99);
    return tmp;
}
Run Code Online (Sandbox Code Playgroud)

如果你使用这里的小数字(100)一切正常.如果数字很大,就会发生奇怪的事情.在我的情况下,我尝试发出大约10K行代码,这会触发堆栈溢出异常.

那么......为什么我认为这很奇怪:

  • tmp是引用类型的本地,因此我希望只在堆上分配指针.
  • 元组是引用类型并在堆上分配.
  • 没有递归或其他怪异; afaik应该限制堆上的存储要求.

再现陌生感......

我无法在最小的测试用例中重现stackoverflow,但我确实注意到它似乎是在64位.NET 4.5上触发的.我能给出的是一些证明正在发生的事情的证据.

另请注意,真正的代码使用Reflection.Emit代码生成此代码...它不像代码本身具有所有这些代码行...发出的IL代码是正确的BTW.

在Visual Studio中 - 在最后一行放置一个断点.注意在反汇编中使用堆栈指针(ASM,而不是IL).

现在在代码中添加一个新行 - 例如tmp[100] = // the usuals.在这里放一个断点,注意使用的堆栈空间增长.

至于尝试使用最小的测试用例来重现Reflection.Emit,这是代码(它不能奇怪地重现这个问题 - 但是非常接近我所做的触发堆栈溢出...它应该给我正在尝试做的一些图片,也许其他人可以用这个来制作一个可行的测试用例.开始:

public static void Foo()
{
    Console.WriteLine("Foo!");
}

static void Main(string[] args)
{
    // all this just to invoke one opcode with no arguments!
    var assemblyName = new AssemblyName("MyAssembly");

    var assemblyBuilder =
        AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
        AssemblyBuilderAccess.RunAndCollect);

    // Create module
    var moduleBuilder = assemblyBuilder.DefineDynamicModule("MyModule");

    var type = moduleBuilder.DefineType("MyType", TypeAttributes.Public, typeof(object));

    var method = type.DefineMethod("Test", System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Tuple<string, int>[]), new Type[0]);

    ILGenerator gen = method.GetILGenerator();
    int count = 0x10000;

    gen.Emit(OpCodes.Call, typeof(StackOverflowGenerator).GetMethod("Foo"));

    var loc = gen.DeclareLocal(typeof(Tuple<string, int>[]));
    gen.Emit(OpCodes.Ldc_I4, count);
    gen.Emit(OpCodes.Newarr, typeof(Tuple<string, int>));
    gen.Emit(OpCodes.Stloc, loc);

    for (int i = 0; i < count; ++i)
    {
        // Load array
        gen.Emit(OpCodes.Ldloc, loc);
        gen.Emit(OpCodes.Ldc_I4, i);

        // Construct tuple:
        gen.Emit(OpCodes.Ldstr, "This is the string");
        gen.Emit(OpCodes.Ldc_I4, i);
        gen.Emit(OpCodes.Newobj, typeof(Tuple<string, int>).GetConstructor(new[] { typeof(string), typeof(int) }));

        // Store in the array
        gen.Emit(OpCodes.Stelem_Ref);
    }

    // Return the result
    gen.Emit(OpCodes.Ldloc, loc);
    gen.Emit(OpCodes.Ret);

    var materialized = type.CreateType();

    var tmp = checked((Tuple<string, int>[])materialized.GetMethod("Test").Invoke(null, new object[0]));

    int total = 0;
    foreach (var item in tmp)
    {
        total += item.Item1.Length + item.Item2;
    }
    Console.WriteLine("Total: {0}", total);
    Console.ReadLine();
}
Run Code Online (Sandbox Code Playgroud)

我的问题

这样的事情怎么会产生一个国有企业？这里发生了什么？为什么事情在这种情况下放在堆栈上呢？

Mar*_*gal 13

生成的代码存在一些问题,但更深层次的问题在于JIT引擎

TL;博士

无论优化和发布/调试模式如何,new函数中的每个操作符都需要DWORD堆栈,甚至是堆栈new object()!这实际上意味着您new根据堆栈大小限制函数中关键字出现的次数.

是什么原因造成的？

引发SOF是因为JIT生成的代码试图在堆栈上分配太多空间(使用sub esp <number>).JIT选择在检查函数中堆栈的使用时分配多少.如果你有很多局部变量,你的函数将不得不在堆栈上使用更多内存,并且JIT无法知道堆栈在运行时的大小,因此它在运行时崩溃.临时解决方案可能是使用编译器标志等使堆栈更大.

谁的错呢？

你的代码在堆栈上没有使用很多变量,事实上,你只显式地使用了一个指向数组的指针.

然而,你的代码(不优化使用时)创造了许多"临时一次性"的变量,分别用于各自string各integer您在使用new Tuple<...>.它们将在优化打开时消失.

即,而不是这样的事情:

var x = new Tuple<string, int>("blah 1", 0);
tmp[0] = x;
x = new Tuple<string, int>("blah 2", 1);
tmp[1] = x;
Run Code Online (Sandbox Code Playgroud)

你最终得到这样的东西:

var str1 = "blah 1";
var int1 = 0;
var x = new Tuple<string, int>(str1, int1);
tmp[0] = x;
var str2 = "blah 2";
var int2 = 1;
var x2 = new Tuple<string, int>(str2, int2);
tmp[1] = x2;
Run Code Online (Sandbox Code Playgroud)

正如您在此反汇编中所看到的:

            tmp[0] = new Tuple<string, int>("blah 1", 0);
00FB26AE  mov         ecx,6D5203BCh  
00FB26B3  call        00F32100  
00FB26B8  mov         dword ptr [ebp-48h],eax  
00FB26BB  push        0  
00FB26BD  mov         edx,dword ptr ds:[3B721F0h]  
00FB26C3  mov         ecx,dword ptr [ebp-48h]  
00FB26C6  call        6D47C0DC  
00FB26CB  push        dword ptr [ebp-48h]  
00FB26CE  mov         ecx,dword ptr [ebp-3Ch]   // ecx = (ebp - 0x3C) [ == tmp ]
00FB26D1  xor         edx,edx  
00FB26D3  call        6E2883FF                  // ecx.setElement(0, ebp - 0x48) 
            tmp[1] = new Tuple<string, int>("blah 2", 1);
00FB26D8  mov         ecx,6D5203BCh  
00FB26DD  call        00F32100  
00FB26E2  mov         dword ptr [ebp-4Ch],eax  
00FB26E5  push        1  
00FB26E7  mov         edx,dword ptr ds:[3B721F4h]  
00FB26ED  mov         ecx,dword ptr [ebp-4Ch]  
00FB26F0  call        6D47C0DC  
00FB26F5  push        dword ptr [ebp-4Ch]
00FB26F8  mov         ecx,dword ptr [ebp-3Ch]  // ecx = (ebp - 0x3C) [ == tmp ]
00FB26FB  mov         edx,1  
00FB2700  call        6E2883FF                 // ecx.setElement = (1, ebp - 0x4C)
Run Code Online (Sandbox Code Playgroud)

让我们将您的代码更改为以下内容:

Tuple<string, int>[] tmp = new Tuple<string, int>[10000];
var str = "blah 1";
var i = 0;
var x = new Tuple<string, int>(str, i);
tmp[0] = x;

str = "blah 2";
i = 1;
x = new Tuple<string, int>(str, i);
tmp[1] = x;
Run Code Online (Sandbox Code Playgroud)

此代码生成一个在堆栈堆栈上使用较少内存的函数.但是,经过深入检查,该代码还会在堆栈上为每个代码生成"一次性"变量new Tuple,因此通过增加分配量,您还可以增加堆栈使用量.

            str = "blah 2";
008A26E9  mov         eax,dword ptr ds:[32421F4h]  
008A26EF  mov         dword ptr [ebp-10h],eax  
            i = 1;
008A26F2  mov         dword ptr [ebp-8],1  
            x = new Tuple<string, int>(str, i);
008A26F9  mov         ecx,6D5203BCh  
008A26FE  call        006C2100  
008A2703  mov         dword ptr [ebp-20h],eax           // this is the one-time variable
008A2706  push        dword ptr [ebp-8]  
008A2709  mov         ecx,dword ptr [ebp-20h]  
008A270C  mov         edx,dword ptr [ebp-10h]  
008A270F  call        6D47C0DC  
008A2714  mov         eax,dword ptr [ebp-20h]  
008A2717  mov         dword ptr [ebp-14h],eax  
            tmp[1] = x;
008A271A  push        dword ptr [ebp-14h]  
008A271D  mov         ecx,dword ptr [ebp-0Ch]  
008A2720  mov         edx,1  
008A2725  call        6E2883FF  

            str = "blah 3";
008A272A  mov         eax,dword ptr ds:[32421F8h]  

            str = "blah 3";
008A2730  mov         dword ptr [ebp-10h],eax  
            i = 2;
008A2733  mov         dword ptr [ebp-8],2  
            x = new Tuple<string, int>(str, i);
008A273A  mov         ecx,6D5203BCh  
008A273F  call        006C2100  
008A2744  mov         dword ptr [ebp-24h],eax           // this is the one-time variable
008A2747  push        dword ptr [ebp-8]  
008A274A  mov         ecx,dword ptr [ebp-24h]  
008A274D  mov         edx,dword ptr [ebp-10h]  
008A2750  call        6D47C0DC  
008A2755  mov         eax,dword ptr [ebp-24h]  
008A2758  mov         dword ptr [ebp-14h],eax  
            tmp[2] = x;
008A275B  push        dword ptr [ebp-14h]  
008A275E  mov         ecx,dword ptr [ebp-0Ch]  
008A2761  mov         edx,2  
008A2766  call        6E2883FF
Run Code Online (Sandbox Code Playgroud)

更糟糕的是,即使在启用优化的发布模式下,它也会在堆栈中产生这个"一次性"变量!

这使我相信这是JIT引擎或编译器本身的问题.所以让我们检查编译器给我们的MSIL:

ldstr    aBlah2         // "blah 2"
stloc.1                 // Pop value from stack into local variable 1
ldc.i4.1                // Push 1 onto the stack as I4
stloc.2                 // Pop value from stack into local variable 2
ldloc.1                 // Load local variable 1 onto stack
ldloc.2                 // Load local variable 2 onto stack
newobj   instance void class [mscorlib]System.Tuple`2<string, int32>::.ctor(var<u1>, !!T0) // Create a new object
stloc.3                 // Pop value from stack into local variable 3
ldloc.0                 // Load local variable 0 onto stack
ldc.i4.1                // Push 1 onto the stack as I4
ldloc.3                 // Load local variable 3 onto stack
stelem.ref              // Replace array element at index with the ref value on the s
Run Code Online (Sandbox Code Playgroud)

评论时,它是:

push "blah 2"
local_str = pop // "blah 2"
push 1
local_int = pop
push local_str // "blah 2"
push local_int // 1

push new Tuple(...)
local_tuple = pop
push local_array
push 0
push local_tuple
pop[pop] = pop (i.e arr[indx] = value)
Run Code Online (Sandbox Code Playgroud)

所以JIT代码通常看起来没问题.

因此,我得出结论,这是JIT引擎中的一个问题

通常,这意味着对于Tuple类的每个构造,DWORD在堆栈中使用不必要的,这对于像您这样的情况非常糟糕,但对于没有像您的代码那样做很多"手动"分配的程序并不意味着什么.确实.

即使对于小功能也会发生这种情况,这真的很奇怪!

在x64位中,以下C#代码:

var a = new object();
a = new object();
a = new object();
a = new object();
a = new object();
a = new object();
a = new object();
Run Code Online (Sandbox Code Playgroud)

编译和JIT:

            a = new object();
00007FFAD0033B5F  call        00007FFB2F662300  
00007FFAD0033B64  mov         qword ptr [rsp+40h],rax  
00007FFAD0033B69  mov         rax,qword ptr [rsp+40h]  
00007FFAD0033B6E  mov         qword ptr [rsp+48h],rax  
00007FFAD0033B73  mov         rcx,qword ptr [rsp+48h]  
00007FFAD0033B78  call        00007FFB2E455BC0  
00007FFAD0033B7D  nop  
            a = new object();
00007FFAD0033B7E  lea         rcx,[7FFB2E6611B8h]  
00007FFAD0033B85  call        00007FFB2F662300  
00007FFAD0033B8A  mov         qword ptr [rsp+50h],rax  
00007FFAD0033B8F  mov         rax,qword ptr [rsp+50h]  
00007FFAD0033B94  mov         qword ptr [rsp+58h],rax  
00007FFAD0033B99  mov         rcx,qword ptr [rsp+58h]  
00007FFAD0033B9E  call        00007FFB2E455BC0  
00007FFAD0033BA3  nop  
// and so on....
Run Code Online (Sandbox Code Playgroud)

并产生许多未使用的QWORDs.

在x86上,代码如下所示:

            a = new object();
00882687  mov         ecx,6D512554h  
0088268C  call        00652100  
00882691  mov         dword ptr [ebp-0Ch],eax  
00882694  mov         ecx,dword ptr [ebp-0Ch]  
00882697  call        6D410B40  
0088269C  nop  
            a = new object();
0088269D  mov         ecx,6D512554h  
008826A2  call        00652100  
008826A7  mov         dword ptr [ebp-10h],eax  
008826AA  mov         ecx,dword ptr [ebp-10h]  
008826AD  call        6D410B40  
008826B2  nop  
// and so on...
Run Code Online (Sandbox Code Playgroud)

哪个更有效率,但仍然"浪费"许多DWORDS.

你能做什么？

实际上,并不多.问题的根源在于JIT必须DWORD为每个new运算符分配堆栈(也许它可以跟踪它们？我无法分辨).您唯一的解决方案(没有修复)是制作多个功能,每个功能将处理您需要的部分分配.

  • @MarkSegal这里是"真正的"答案(来自微软的反馈).当方法代码大小太大时,JIT禁用优化器(可以在以下网址找到限制:https://github.com/dotnet/coreclr/blob/01a5e9b4580cf6ea21de672f627402c30658ef22/src/jit/compiler.h#L7131).默认情况下,JIT为每个新的临时分配一个新的临时值:https://github.com/dotnet/coreclr/blob/01a5e9b4580cf6ea21de672f627402c30658ef22/src/jit/importer.cpp#L11108.将它与我写的代码结合起来 - 就是这样.:-) (6认同)

归档时间：

查看次数：

531 次

最近记录：

10 年，6 月 前
相关归档
方法签名中的新关键字 112
使用此复合形式时,为什么使用XOR交换值失败？ 76
格式化C#中输出的双精度数 62
在 C# 8.0 中调用方法之前感叹号是什么意思？ 58
对于任何数值,Enum.TryParse都返回true 52
将设置类添加到UWP应用程序 42
如何实现返回Task <T>的接口方法？ 38
如何为每个客户管理同一软件的多个版本？ 23
如何分享App.config？ 22
C#:有人可以解释反思的实用性吗？ 18
难疑归档
Python有一个字符串'contains'子串方法吗？ 3601
如何检查列表是否为空？ 3235
C++中指针变量和引用变量之间有什么区别？ 3115
配置错误:此配置部分不能在此路径中使用 1694
命令折叠代码的所有部分？ 1576
为什么Java有瞬态字段？ 1406
JavaScript中是否有"null coalescing"运算符？ 1305
如何删除重复的行？ 1254
获取Android上的当前时间和日期 1058
如何测量函数执行所花费的时间 1057