.NET JIT möglichen Fehler?

Den folgenden code gibt verschiedene Ausgabe beim ausführen des release in Visual Studio, und das ausführen des release außerhalb von Visual Studio. Ich bin mit Visual Studio 2008 und targeting .NET 3.5. Ich hab auch schon versucht .NET 3.5 SP1.

Ausführung außerhalb von Visual Studio, die JIT-kick sollte. Entweder (a) gibt es etwas subtiler geht mit C#, die mir fehlt oder (b) der JIT ist tatsächlich ein Fehler vorliegt. Ich bin zweifelhaft, dass der JIT-kann schief gehen, aber ich bin keine andere Möglichkeiten...

Ausgegeben, wenn die Ausführung in Visual Studio:

    0 0,
    0 1,
    1 0,
    1 1,

Ausgabe beim ausführen release außerhalb von Visual Studio:

    0 2,
    0 2,
    1 2,
    1 2,

Was ist der Grund?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test
{
    struct IntVec
    {
        public int x;
        public int y;
    }

    interface IDoSomething
    {
        void Do(IntVec o);
    }

    class DoSomething : IDoSomething
    {
        public void Do(IntVec o)
        {
            Console.WriteLine(o.x.ToString() + " " + o.y.ToString()+",");
        }
    }

    class Program
    {
        static void Test(IDoSomething oDoesSomething)
        {
            IntVec oVec = new IntVec();
            for (oVec.x = 0; oVec.x < 2; oVec.x++)
            {
                for (oVec.y = 0; oVec.y < 2; oVec.y++)
                {
                    oDoesSomething.Do(oVec);
                }
            }
        }

        static void Main(string[] args)
        {
            Test(new DoSomething());
            Console.ReadLine();
        }
    }
}
  • Ja - wie wärs damit: Suche nach einem gravierenden Fehler in etwas so wichtig wie die .Net JIT - herzlichen Glückwunsch!
  • Dies scheint zu repro in meinem 9. Dezember bauen die 4.0 framework auf x86. Ich werde es weitergeben, um die jitter-team. Danke!
  • Dies ist eine der wenigen Fragen, die verdienen eine gold-Abzeichen.
  • Die Tatsache, dass wir alle daran interessiert sind, diese Frage zeigt, erwarten wir nicht, dass bugs in der .NET JIT, gut gemacht Microsoft.
  • Wir alle warten auf Microsoft Antworten gespannt .....
  • Dies ist derzeit die höchsten Punktzahlen Frage bei StackOverflow unter jenen, die weniger als 10.000 Aufrufe.

InformationsquelleAutor Philip Welch | 2010-01-13
  1. 210

    Es ist ein JIT-Optimierer-bug. Es ist unrolling der inneren Schleife, aber nicht die Aktualisierung der oVec.y-Wert korrekt:

          for (oVec.x = 0; oVec.x < 2; oVec.x++) {
0000000a  xor         esi,esi                         ; oVec.x = 0
        for (oVec.y = 0; oVec.y < 2; oVec.y++) {
0000000c  mov         edi,2                           ; oVec.y = 2, WRONG!
          oDoesSomething.Do(oVec);
00000011  push        edi  
00000012  push        esi  
00000013  mov         ecx,ebx 
00000015  call        dword ptr ds:[00170210h]        ; first unrolled call
0000001b  push        edi                             ; WRONG! does not increment oVec.y
0000001c  push        esi  
0000001d  mov         ecx,ebx 
0000001f  call        dword ptr ds:[00170210h]        ; second unrolled call
      for (oVec.x = 0; oVec.x < 2; oVec.x++) {
00000025  inc         esi  
00000026  cmp         esi,2 
00000029  jl          0000000C

    Der Fehler verschwindet, wenn Sie lassen Sie oVec.y-Inkrement auf 4, das sind zu viele Anrufe, zu entrollen.

    Eine Abhilfe ist diese:

      for (int x = 0; x < 2; x++) {
    for (int y = 0; y < 2; y++) {
      oDoesSomething.Do(new IntVec(x, y));
    }
  }

    UPDATE: re-geprüft im August 2012, dieser Fehler wurde behoben in der version 4.0.30319-jitter. Aber ist noch in der v2.0.50727 jitter. Es scheint unwahrscheinlich, dass Sie dieses Problem beheben in der alten version nach dieser langen.

    • +1, auf jeden Fall ein Fehler - ich hätte identifiziert, die Bedingungen für die Fehler, (nicht sagen, dass nobugz gefunden, weil von mir, aber!), aber das (und bei dir, Nick, also +1, auch für Sie) zeigt, dass der JIT ist der Schuldige. interessant, dass die Optimierung erfolgt entweder entfernt oder anders, wenn IntVec ist deklariert als eine Klasse. Auch wenn Sie explizit initialisieren der struct-Felder auf 0, bevor die Schleife, die das gleiche Verhalten zu sehen ist. Böse!
    • Passant welchem tool hast du benutzt um die Ausgabe der Assembler-code ?
    • Nur Visual Studio, copy/paste aus dem debugger-Fenster Disassembly und Kommentare von hand.
    InformationsquelleAutor Hans Passant
  2. 82

    Ich glaube, das ist in einem echten JIT-Kompilierung Fehler. Ich würde ein Bericht an Microsoft und sehen, was Sie sagen. Interessant fand ich, dass die x64-JIT nicht das gleiche problem haben.

    Hier ist meine Lektüre von x86 JIT.

    //save context
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        edi  
00000004  push        esi  
00000005  push        ebx  

//put oDoesSomething pointer in ebx
00000006  mov         ebx,ecx 

//zero out edi, this will store oVec.y
00000008  xor         edi,edi 

//zero out esi, this will store oVec.x
0000000a  xor         esi,esi 

//NOTE: the inner loop is unrolled here.
//set oVec.y to 2
0000000c  mov         edi,2 

//call oDoesSomething.Do(oVec) -- y is always 2!?!
00000011  push        edi  
00000012  push        esi  
00000013  mov         ecx,ebx 
00000015  call        dword ptr ds:[002F0010h] 

//call oDoesSomething.Do(oVec) -- y is always 2?!?!
0000001b  push        edi  
0000001c  push        esi  
0000001d  mov         ecx,ebx 
0000001f  call        dword ptr ds:[002F0010h] 

//increment oVec.x
00000025  inc         esi  

//loop back to 0000000C if oVec.x < 2
00000026  cmp         esi,2 
00000029  jl          0000000C 

//restore context and return
0000002b  pop         ebx  
0000002c  pop         esi  
0000002d  pop         edi  
0000002e  pop         ebp  
0000002f  ret

    Diese sieht aus wie eine Optimierung gone bad auf mich...

    InformationsquelleAutor Nick Guerrera
  3. 23

    Kopierte ich den code in eine neue Konsole App.

    • Debug-Build
      • Korrekte Ausgabe mit beiden debugger und ohne debugger
    • Geschaltet Release Build
      • Wieder, richtige Leistung beide Male
    • Erstellt eine neue x86-Konfiguration (ich bin läuft auf X64 Windows 2008 und wurde mit 'Any CPU')
    • Debug-Build
      • Habe den richtigen Ausgang F5 und STRG+F5
    • Release Build
      • Korrekte Ausgabe mit Debugger
      • Kein debugger - haben Sie die falsche Ausgabe

    So ist es die x86 JIT falsch Generierung des Codes. Gelöscht haben meinen ursprünglichen text über die Neuanordnung von loops usw. Ein paar andere Antworten hier haben bestätigt, dass der JIT ist der Abbau der Schleife nicht korrekt, wenn auf x86.

    Problem zu beheben, können Sie ändern Sie die Deklaration von IntVec von Klasse zu Klasse und es funktioniert in allen Geschmacksrichtungen.

    Denke, das muss das MS-Connect....

    -1 zu Microsoft!

    • Interessante Idee, aber sicher ist dies nicht "Optimierung", sondern ein sehr großen Fehler im compiler, wenn dies der Fall ist? Würde wurden jetzt wäre es nicht?
    • Ich Stimme mit Ihnen überein. Neuordnung Schleifen wie dies könnte ungeahnte Probleme. Tatsächlich scheint dies auch weniger wahrscheinlich, weil die for-Schleifen können nicht immer erreichen 2.
    • Sieht aus wie einer von diesen fiesen Heisenbugs 😛
    • Jede CPU wird nicht funktionieren, wenn der OP (oder jemand mit seiner Anwendung) hat einen 32-bit-x86-Maschine. Das problem ist, dass die x86 JIT mit Optimierungen aktiviert, erzeugt schlechten code.
    InformationsquelleAutor Andras Zoltan
Schreibe einen Kommentar