Przepełnienie C # dla niesprawdzonego uint

Testowałem ten kod na https://dotnetfiddle.net/ :

using System;

public class Program
{
    const float scale = 64 * 1024;

    public static void Main()
    {
        Console.WriteLine(unchecked((uint)(ulong)(1.2 * scale * scale + 1.5 * scale)));
        Console.WriteLine(unchecked((uint)(ulong)(scale* scale + 7)));
    }
}

Jeśli skompiluję z .NET 4.7.2, dostanę

859091763

7

Ale jeśli robię Roslyn lub .NET Core, dostaję

859091763

0

Dlaczego to się dzieje?

Moje wnioski były błędne. Zobacz aktualizację, aby uzyskać więcej informacji.

Wygląda jak błąd w pierwszym kompilatorze, którego użyłeś. Zero jest poprawnym wynikiem w tym przypadku . Kolejność operacji podanych w specyfikacji C # jest następująca:

1. pomnóż scaleprzez scale, dająca
2. wykonać a + 7, ustępującb
3. oddać bdo ulongotrzymującc
4. oddać cdo uintotrzymującd

Pierwsze dwie operacje pozostawiają wartość zmiennoprzecinkową równą b = 4.2949673E+09f. Zgodnie ze standardową arytmetyką zmiennoprzecinkową jest to 4294967296( możesz to sprawdzić tutaj ). To pasuje do ulongporządku, więc c = 4294967296, ale jest dokładnie o jeden więcej uint.MaxValue, więc w obie strony 0, więc d = 0. Teraz, tu niespodzianka, bo arytmetyka zmiennoprzecinkowa jest funky, 4.2949673E+09fi 4.2949673E+09f + 7jest dokładnie taka sama liczba w IEEE 754. Więc scale * scaledaje taką samą wartość floatjak scale * scale + 7, a = btak drugi operacji jest w zasadzie nie-op.

Kompilator Roslyn wykonuje (niektóre) operacje const w czasie kompilacji i optymalizuje całe to wyrażenie 0. Ponownie, jest to poprawny wynik , a kompilator może wykonywać wszelkie optymalizacje, które spowodują takie same zachowanie, jak kod bez nich.

Moje przypuszczenie jest, że .NET 4.7.2 kompilator użyty również stara się zoptymalizować to daleko, ale ma błąd, który powoduje, że ocena oddanych w niewłaściwym miejscu. Oczywiście, jeśli najpierw rzucisz scalena, uinta następnie wykonasz operację, otrzymasz 7, ponieważ w scale * scaleobie strony do, 0a następnie dodajesz 7. Jest to jednak niespójne z wynikiem, który można uzyskać, oceniając wyrażenia krok po kroku w czasie wykonywania . Ponownie, podstawowa przyczyna jest tylko zgadywaniem, gdy patrzy się na wytworzone zachowanie, ale biorąc pod uwagę wszystko, co powiedziałem powyżej, jestem przekonany, że jest to naruszenie specyfikacji po stronie pierwszego kompilatora.

AKTUALIZACJA:

Zrobiłem głupek. Jest trochę specyfikacji C # , o której istnieniu nie wiedziałem, pisząc powyższą odpowiedź:

Operacje zmiennoprzecinkowe mogą być wykonywane z większą precyzją niż typ wyniku operacji. Na przykład niektóre architektury sprzętowe obsługują zmiennoprzecinkowy „rozszerzony” lub „długi podwójny” o większym zakresie i precyzji niż typ podwójny i domyślnie wykonują wszystkie operacje zmiennoprzecinkowe przy użyciu tego typu o wyższej precyzji. Tylko przy nadmiernym koszcie wydajności można stworzyć taką architekturę sprzętową, aby wykonywać operacje zmiennoprzecinkowe z mniejszą precyzją i zamiast wymagać implementacji, aby utracić zarówno wydajność, jak i precyzję, C # pozwala na zastosowanie typu o wyższej precyzji dla wszystkich operacji zmiennoprzecinkowych . Poza dostarczaniem bardziej precyzyjnych wyników, rzadko ma to wymierne efekty. Jednak w wyrażeniach postaci x * y / z

C # gwarantuje operacje zapewniające poziom precyzji przynajmniej na poziomie IEEE 754, ale niekoniecznie dokładnie to. To nie jest błąd, to funkcja specyfikacji. Kompilator Roslyn ma prawo do oceny wyrażenia dokładnie tak, jak określa to IEEE 754, a drugi kompilator ma prawo wydedukować 2^32 + 7to 7po włożeniu uint.

Przykro mi z powodu mojej wprowadzającej w błąd pierwszej odpowiedzi, ale przynajmniej dzisiaj wszyscy się czegoś nauczyliśmy.

Chodzi tutaj o to (jak widać w dokumentach ), że wartości zmiennoprzecinkowe mogą mieć podstawę tylko do 2 ^ 24 . Tak więc, gdy przypisujesz wartość 2 ^ 32 ( 64 * 2014 * 164 * 1024 = 2 ^ 6 * 2 ^ 10 * 2 ^ 6 * 2 ^ 10 = 2 ^ 32 ), staje się w rzeczywistości 2 ^ 24 * 2 ^ 8 , czyli 4294967000 . Dodanie 7 spowoduje dodanie tylko do części obciętej przez konwersję na ulong .

Jeśli zmienisz na double , który ma podstawę 2 ^ 53 , będzie działać na to, czego chcesz.

Może to być problem z czasem wykonywania, ale w tym przypadku jest to problem z czasem kompilacji, ponieważ wszystkie wartości są stałymi i zostaną ocenione przez kompilator.

Przede wszystkim używasz niezaznaczonego kontekstu, który jest instrukcją dla kompilatora, na pewno jesteś programistą, że wynik nie zostanie przepełniony i nie zobaczysz żadnego błędu kompilacji. W twoim scenariuszu jesteś celowo przepełniony i spodziewasz się spójnego zachowania w trzech różnych kompilatorach, z których jeden prawdopodobnie jest kompatybilny z historią w porównaniu do Roslyn i .NET Core, które są nowymi.

Po drugie, łączysz konwersje niejawne i jawne. Nie jestem pewien co do kompilatora Roslyn, ale zdecydowanie .NET Framework i kompilatory .NET Core mogą używać różnych optymalizacji dla tych operacji.

Problem polega na tym, że pierwszy wiersz kodu używa tylko wartości / typów zmiennoprzecinkowych, ale drugi wiersz jest kombinacją wartości / typów zmiennoprzecinkowych i wartości / typu całkowego.

Jeśli od razu utworzysz zmiennoprzecinkowe liczby całkowite (7> 7.0), uzyskasz taki sam wynik dla wszystkich trzech skompilowanych źródeł.

using System;

public class Program
{
    const float scale = 64 * 1024;

    public static void Main()
    {
        Console.WriteLine(unchecked((uint)(ulong)(1.2 * scale * scale + 1.5 * scale))); // 859091763
        Console.WriteLine(unchecked((uint)(ulong)(scale * scale + 7.0))); // 7
    }
}

Powiedziałbym więc odwrotnie niż na to, co odpowiedział V0ldek: „Błąd (jeśli to naprawdę błąd) najprawdopodobniej występuje w kompilatorach Roslyn i .NET Core”.

Kolejny powód, by sądzić, że wynik pierwszego niezaznaczonego wyniku obliczeń jest taki sam dla wszystkich i jest to wartość przekraczająca maksymalną wartość UInt32typu.

Console.WriteLine(unchecked((uint)(ulong)(1.2 * scale * scale + 1.5 * scale) - UInt32.MaxValue - 1)); // 859091763

Jest jeden minus, gdy zaczynamy od zera, czyli wartości, którą trudno jest odjąć. Jeśli moje matematyczne rozumienie przepełnienia jest prawidłowe, zaczynamy od następnej liczby po wartości maksymalnej.

AKTUALIZACJA

Zgodnie z komentarzem Jalsh

7.0 jest podwójnym, nie zmiennoprzecinkowym, spróbuj 7.0f, wciąż da ci 0

Jego komentarz jest poprawny. W przypadku użycia liczby zmiennoprzecinkowej nadal otrzymujesz 0 dla Roslyn i .NET Core, ale z drugiej strony przy podwójnych wynikach w 7.

Zrobiłem kilka dodatkowych testów i wszystko staje się jeszcze dziwniejsze, ale ostatecznie wszystko ma sens (przynajmniej trochę).

Zakładam, że kompilator .NET Framework 4.7.2 (wydany w połowie 2018 r.) Naprawdę używa innych optymalizacji niż kompilatory .NET Core 3.1 i Roslyn 3.4 (wydany pod koniec 2019 r.). Te różne optymalizacje / obliczenia są wykorzystywane wyłącznie dla stałych wartości znanych w czasie kompilacji. Dlatego konieczne było użycie uncheckedsłowa kluczowego, ponieważ kompilator już wie, że dzieje się przepełnienie, ale do optymalizacji końcowej IL zastosowano inne obliczenia.

Ten sam kod źródłowy i prawie taka sama IL oprócz instrukcji IL_000a. Jeden kompilator oblicza 7, a drugi 0.

Kod źródłowy

using System;

public class Program
{
    const float scale = 64 * 1024;

    public static void Main()
    {
        Console.WriteLine(unchecked((uint)(ulong)(1.2 * scale * scale + 1.5 * scale)));
        Console.WriteLine(unchecked((uint)(scale * scale + 7.0)));
    }
}

.NET Framework (x64) IL

.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit Program
    extends [mscorlib]System.Object
{
    // Fields
    .field private static literal float32 scale = float32(65536)

    // Methods
    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 17 (0x11)
        .maxstack 8

        IL_0000: ldc.i4 859091763
        IL_0005: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_000a: ldc.i4.7
        IL_000b: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_0010: ret
    } // end of method Program::Main

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x2062
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: ret
    } // end of method Program::.ctor

} // end of class Program

Oddział kompilatora Roslyn (wrzesień 2019) IL

.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit Program
    extends [System.Private.CoreLib]System.Object
{
    // Fields
    .field private static literal float32 scale = float32(65536)

    // Methods
    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 17 (0x11)
        .maxstack 8

        IL_0000: ldc.i4 859091763
        IL_0005: call void [System.Console]System.Console::WriteLine(uint32)
        IL_000a: ldc.i4.0
        IL_000b: call void [System.Console]System.Console::WriteLine(uint32)
        IL_0010: ret
    } // end of method Program::Main

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x2062
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [System.Private.CoreLib]System.Object::.ctor()
        IL_0006: ret
    } // end of method Program::.ctor

} // end of class Program

Zaczyna iść właściwą drogą, gdy dodajesz wyrażenia niestałe (domyślnie są unchecked), jak poniżej.

using System;

public class Program
{
    static Random random = new Random();

    public static void Main()
    {
        var scale = 64 * random.Next(1024, 1025);       
        uint f = (uint)(ulong)(scale * scale + 7f);
        uint d = (uint)(ulong)(scale * scale + 7d);
        uint i = (uint)(ulong)(scale * scale + 7);

        Console.WriteLine((uint)(ulong)(1.2 * scale * scale + 1.5 * scale)); // 859091763
        Console.WriteLine((uint)(ulong)(scale * scale + 7f)); // 7
        Console.WriteLine(f); // 7
        Console.WriteLine((uint)(ulong)(scale * scale + 7d)); // 7
        Console.WriteLine(d); // 7
        Console.WriteLine((uint)(ulong)(scale * scale + 7)); // 7
        Console.WriteLine(i); // 7
    }
}

Który generuje „dokładnie” tę samą IL przez oba kompilatory.

.NET Framework (x64) IL

.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit Program
    extends [mscorlib]System.Object
{
    // Fields
    .field private static class [mscorlib]System.Random random

    // Methods
    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 164 (0xa4)
        .maxstack 4
        .locals init (
            [0] int32,
            [1] uint32,
            [2] uint32
        )

        IL_0000: ldc.i4.s 64
        IL_0002: ldsfld class [mscorlib]System.Random Program::random
        IL_0007: ldc.i4 1024
        IL_000c: ldc.i4 1025
        IL_0011: callvirt instance int32 [mscorlib]System.Random::Next(int32, int32)
        IL_0016: mul
        IL_0017: stloc.0
        IL_0018: ldloc.0
        IL_0019: ldloc.0
        IL_001a: mul
        IL_001b: conv.r4
        IL_001c: ldc.r4 7
        IL_0021: add
        IL_0022: conv.u8
        IL_0023: conv.u4
        IL_0024: ldloc.0
        IL_0025: ldloc.0
        IL_0026: mul
        IL_0027: conv.r8
        IL_0028: ldc.r8 7
        IL_0031: add
        IL_0032: conv.u8
        IL_0033: conv.u4
        IL_0034: stloc.1
        IL_0035: ldloc.0
        IL_0036: ldloc.0
        IL_0037: mul
        IL_0038: ldc.i4.7
        IL_0039: add
        IL_003a: conv.i8
        IL_003b: conv.u4
        IL_003c: stloc.2
        IL_003d: ldc.r8 1.2
        IL_0046: ldloc.0
        IL_0047: conv.r8
        IL_0048: mul
        IL_0049: ldloc.0
        IL_004a: conv.r8
        IL_004b: mul
        IL_004c: ldc.r8 1.5
        IL_0055: ldloc.0
        IL_0056: conv.r8
        IL_0057: mul
        IL_0058: add
        IL_0059: conv.u8
        IL_005a: conv.u4
        IL_005b: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_0060: ldloc.0
        IL_0061: ldloc.0
        IL_0062: mul
        IL_0063: conv.r4
        IL_0064: ldc.r4 7
        IL_0069: add
        IL_006a: conv.u8
        IL_006b: conv.u4
        IL_006c: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_0071: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_0076: ldloc.0
        IL_0077: ldloc.0
        IL_0078: mul
        IL_0079: conv.r8
        IL_007a: ldc.r8 7
        IL_0083: add
        IL_0084: conv.u8
        IL_0085: conv.u4
        IL_0086: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_008b: ldloc.1
        IL_008c: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_0091: ldloc.0
        IL_0092: ldloc.0
        IL_0093: mul
        IL_0094: ldc.i4.7
        IL_0095: add
        IL_0096: conv.i8
        IL_0097: conv.u4
        IL_0098: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_009d: ldloc.2
        IL_009e: call void [mscorlib]System.Console::WriteLine(uint32)
        IL_00a3: ret
    } // end of method Program::Main

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x2100
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: ret
    } // end of method Program::.ctor

    .method private hidebysig specialname rtspecialname static 
        void .cctor () cil managed 
    {
        // Method begins at RVA 0x2108
        // Code size 11 (0xb)
        .maxstack 8

        IL_0000: newobj instance void [mscorlib]System.Random::.ctor()
        IL_0005: stsfld class [mscorlib]System.Random Program::random
        IL_000a: ret
    } // end of method Program::.cctor

} // end of class Program

Oddział kompilatora Roslyn (wrzesień 2019) IL

.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit Program
    extends [System.Private.CoreLib]System.Object
{
    // Fields
    .field private static class [System.Private.CoreLib]System.Random random

    // Methods
    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 164 (0xa4)
        .maxstack 4
        .locals init (
            [0] int32,
            [1] uint32,
            [2] uint32
        )

        IL_0000: ldc.i4.s 64
        IL_0002: ldsfld class [System.Private.CoreLib]System.Random Program::random
        IL_0007: ldc.i4 1024
        IL_000c: ldc.i4 1025
        IL_0011: callvirt instance int32 [System.Private.CoreLib]System.Random::Next(int32, int32)
        IL_0016: mul
        IL_0017: stloc.0
        IL_0018: ldloc.0
        IL_0019: ldloc.0
        IL_001a: mul
        IL_001b: conv.r4
        IL_001c: ldc.r4 7
        IL_0021: add
        IL_0022: conv.u8
        IL_0023: conv.u4
        IL_0024: ldloc.0
        IL_0025: ldloc.0
        IL_0026: mul
        IL_0027: conv.r8
        IL_0028: ldc.r8 7
        IL_0031: add
        IL_0032: conv.u8
        IL_0033: conv.u4
        IL_0034: stloc.1
        IL_0035: ldloc.0
        IL_0036: ldloc.0
        IL_0037: mul
        IL_0038: ldc.i4.7
        IL_0039: add
        IL_003a: conv.i8
        IL_003b: conv.u4
        IL_003c: stloc.2
        IL_003d: ldc.r8 1.2
        IL_0046: ldloc.0
        IL_0047: conv.r8
        IL_0048: mul
        IL_0049: ldloc.0
        IL_004a: conv.r8
        IL_004b: mul
        IL_004c: ldc.r8 1.5
        IL_0055: ldloc.0
        IL_0056: conv.r8
        IL_0057: mul
        IL_0058: add
        IL_0059: conv.u8
        IL_005a: conv.u4
        IL_005b: call void [System.Console]System.Console::WriteLine(uint32)
        IL_0060: ldloc.0
        IL_0061: ldloc.0
        IL_0062: mul
        IL_0063: conv.r4
        IL_0064: ldc.r4 7
        IL_0069: add
        IL_006a: conv.u8
        IL_006b: conv.u4
        IL_006c: call void [System.Console]System.Console::WriteLine(uint32)
        IL_0071: call void [System.Console]System.Console::WriteLine(uint32)
        IL_0076: ldloc.0
        IL_0077: ldloc.0
        IL_0078: mul
        IL_0079: conv.r8
        IL_007a: ldc.r8 7
        IL_0083: add
        IL_0084: conv.u8
        IL_0085: conv.u4
        IL_0086: call void [System.Console]System.Console::WriteLine(uint32)
        IL_008b: ldloc.1
        IL_008c: call void [System.Console]System.Console::WriteLine(uint32)
        IL_0091: ldloc.0
        IL_0092: ldloc.0
        IL_0093: mul
        IL_0094: ldc.i4.7
        IL_0095: add
        IL_0096: conv.i8
        IL_0097: conv.u4
        IL_0098: call void [System.Console]System.Console::WriteLine(uint32)
        IL_009d: ldloc.2
        IL_009e: call void [System.Console]System.Console::WriteLine(uint32)
        IL_00a3: ret
    } // end of method Program::Main

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x2100
        // Code size 7 (0x7)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [System.Private.CoreLib]System.Object::.ctor()
        IL_0006: ret
    } // end of method Program::.ctor

    .method private hidebysig specialname rtspecialname static 
        void .cctor () cil managed 
    {
        // Method begins at RVA 0x2108
        // Code size 11 (0xb)
        .maxstack 8

        IL_0000: newobj instance void [System.Private.CoreLib]System.Random::.ctor()
        IL_0005: stsfld class [System.Private.CoreLib]System.Random Program::random
        IL_000a: ret
    } // end of method Program::.cctor

} // end of class Program

Tak więc ostatecznie uważam, że powodem różnych zachowań jest po prostu inna wersja frameworka i / lub kompilatora, które używają różnych optymalizacji / obliczeń dla stałych wyrażeń, ale w innych przypadkach zachowanie jest bardzo takie samo.