Atomic Inkrement von 64 Bit Variable auf 32 Bit Umgebung

Question

Schreiben Sie eine Antwort für another question einige interessante Dinge kamen heraus und jetzt kann ich nicht verstehen, wie Interlocked.Increment(ref long value) auf 32-Bit-Systemen funktioniert. Lassen Sie mich erklären.

Mutter InterlockedIncrement64 jetzt nicht verfügbar ist, wenn für 32-Bit-Umgebung kompiliert, OK, ist es sinnvoll, da in .NET können Sie nicht Speicher auszurichten, wie erforderlich und es kann aufgerufen werden, von verwalten dann ließ sie es.

In .NET wir Interlocked.Increment() mit einer Referenz auf einen 64-Bit-Variable nennen können, wir haben noch keine Einschränkung über seine Ausrichtung (zum Beispiel in einer Struktur, wo wir auch FieldOffset und StructLayout verwenden können), sondern Dokumentation doesn Erwähnen Sie keine Einschränkung (AFAIK). Es ist Magie, es funktioniert!

Hans Passant bemerkt, dass Interlocked.Increment() ist ein spezielle Methode von JIT-Compiler erkannt und es wird einen Aufruf an COMInterlocked::ExchangeAdd64() aussenden, die dann FastInterlockExchangeAddLong nennen, die ein Makro für InterlockedExchangeAdd64 ist die gleiche Einschränkungen von InterlockedIncrement64 teilt.

Jetzt bin ich perplex.

Vergessen Sie für eine Sekunde verwaltete Umgebung und gehen Sie zurück zu nativen. Warum kann InterlockedIncrement64 nicht funktionieren aber InterlockedExchangeAdd64 funktioniert? InterlockedIncrement64 ist ein Makro, wenn intrinsics nicht verfügbar sind und InterlockedExchangeAdd64 Werke dann kann es als Aufruf an InterlockedExchangeAdd64 implementiert werden ...

Lasst uns verwalteten zurück: wie ein Atom-64-Bit-Zuwachs auf 32-Bit-Systemen umgesetzt wird? Ich nehme an Satz "Diese Funktion ist atomisch in Bezug auf Aufrufe zu anderen verriegelten Funktionen" ist wichtig, aber immer noch sah ich keinen Code (danke Hans, um auf tiefere Implementierung hinweisen), es zu tun. Lassen Sie uns InterlockedExchangedAdd64 Implementierung von winbase.h holen, wenn intrinsics nicht verfügbar sind:

FORCEINLINE 
LONGLONG 
InterlockedExchangeAdd64(
    _Inout_ LONGLONG volatile *Addend, 
    _In_ LONGLONG Value 
    ) 
{ 
    LONGLONG Old; 

    do { 
     Old = *Addend; 
    } while (InterlockedCompareExchange64(Addend, 
              Old + Value, 
              Old) != Old); 

    return Old; 
} 

Wie kann es zum Lesen/Schreiben atomar sein?

Answer 1

Sie müssen dem Pfad folgen, InterlockedExchangeAdd64() führt Sie zur WinNt.h SDK-Headerdatei. Wo Sie viele Versionen davon sehen werden, abhängig von der Zielarchitektur.

Dies kollabiert im Allgemeinen:

#define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 

, die den Dollar zu einem intrinsischen Compiler übergibt, in vc erklärt/include/intrin.h und vom Compiler Back-End implementiert.

Oder mit anderen Worten, verschiedene Builds der CLR werden verschiedene Implementierungen davon haben. Es gab viele im Laufe der Jahre, x86, x64, Itanium, ARM, ARM8, PowerPC von der Spitze meines Kopfes, ich vermisse sicherlich einige, die WindowsCE zu booten, bevor Apple es irrelevant gemacht. Für x86 wird dies letztendlich durch LOCK CMPXCHNG8B erledigt, eine dedizierte Prozessoranweisung, die mit fehlausgerichteten 64-Bit-Variablen umgehen kann. Ich habe nicht die Hardware, um zu sehen, wie es auf anderen 32-Bit-Prozessoren aussieht.

Bedenken Sie, dass die Zielarchitektur für verwalteten Code nicht zur Kompilierungszeit festgelegt wird. Es ist der Jitter, der die MSIL zur Laufzeit an das Ziel anpasst.Das ist für C++/CLI-Projekte nicht ganz so relevant, da Sie normalerweise ein Ziel auswählen müssen, wenn Sie mit/clr statt/clr: pure kompilieren und nur x86 und x64 funktionieren. Aber die Installation ist sowieso vorhanden, also ist ein Makro einfach nicht sehr nützlich.