AtomicTypes - Atomare Boolean, Integer, Enum und Set Typen

[Zacherl]

Hallo zusammen,

in C++ gibt es den std::atomic<T> Typ, welcher mittels LOCK CXHG , LOCK INC , LOCK DEC , etc. intrinsische atomare Operationen implementiert. Hierbei werden die Operatoren so überladen, dass sich Variablen dieses Typs ganz genau wie der generische Grundtyp verwenden lassen.

Leider sind in Delphi sowohl die class operators , als auch die Generics im Vergleich zu C++ stark beschränkt, aber ich habe mich dennoch mal daran versucht entsprechende Typen nachzubilden. Statt einigen 100 Zeilen wurden hieraus dann leider mehrere 1000 Zeilen mit viel repetitivem Code. Zudem gibt es eine recht große Limitierung, bedingt dadurch, dass Delphi das Überladen des Assignment Operators nicht unterstützt. Neue Werte können nicht einfach zugewiesen werden, sondern müssen mit .Assign gesetzt werden.

Beispiel:

Delphi-Quellcode:

var
  I, J: TAtomicInt32;
  V: Integer;
  D: Double;
begin
  // Atomic writes
  I.Assign(42);         // I = 42
  J.Assign(24);         // J = 24
  V := J.Exchange(-1);  // V = 24, J = -1
  J.Inc;                // J = 0
  J.Sub(1);             // J = -1

  // We can use the atomic type just like a "normal" integer
  V := I + J;           // V = 41
  D := I / 4;           // D = 10.5

  // DON'T DO THIS! Not atomic!
  I := J;

Wer Interesse hat, kann ja mal reinschauen
Aktuellste Version auch immer auf GitHub.

Viele Grüße
Zacherl

[LTE5]

OT: Embarcadero sollte dich und Andreas Hausladen definitiv unter Vertrag nehmen. Ihr beiden würdet Delphi zu etwas machen, was es bis heute leider nicht ist.

[Uwe Raabe]

Kannst du das Assign nicht einfach mit einem Implicit-Operator implementieren?

Delphi-Quellcode:

class operator TAtomicInteger<T>.Implicit(A: T): TAtomicInteger<T>;
begin
  Result.Assign(A);
end;

Edit: Besser gleich mit dem generischen Typ.

[Zacherl]

Zitat von Uwe Raabe:

Kannst du das Assign nicht einfach mit einem Implicit-Operator implementieren?

Delphi-Quellcode:

class operator TAtomicInteger<T>.Implicit(A: Integer): TAtomicInteger<T>;
begin
  Result.Assign(A);
end;

Leider nein. Das Problem hierbei ist, dass Delphi beim Zuweisen eine neue temporäre RValue erstellt. Result liegt praktisch an einer komplett neuen Adresse auf dem Stack - würde dann zwar atomar zugewiesen (was natürlich sinnlos ist) - und dann nicht atomar der vorhandenen LValue zugewiesen.

[LTE5]

Für Idioten wie mich erklärt: was bringen diese atomaren ... Dinger?

[Zacherl]

Zitat von LTE5:

Für Idioten wie mich erklärt: was bringen diese atomaren ... Dinger?

Wenn mehrere Threads auf die gleiche Variable zugreifen, musst du konkurrierende Zugriffe normalerweise ja per TCriticalSection , TMonitor , etc. absichern. Diese Locks sind von der Performance her nicht wirklich gut, da sie entweder Spin-Locken oder einen Context-Switch in den Kernel bewirken. Die atomaren Typen werden ohne zusätzlichen (Software-)Overhead direkt von der CPU synchronisiert und sind deshalb besonders performant. Allerdings hat dieser Mechanismus auch seine Grenzen, wie dass er z.b. nur für triviale Typen bis maximal 8-Byte anwendbar ist.