Interlocked* mit Operator Überladung

[Win32.API]

Hallo,

ist das Ganze so Threadsafe, oder koennte es Probleme geben?

Delphi-Quellcode:

type
  TThreadSafeInteger = record
  private
    Value: Integer;
  public
    class operator Add(a: TThreadSafeInteger; b: Integer): Integer;
    class operator Subtract(a: TThreadSafeInteger; b: Integer): Integer;
    class operator Implicit(a: TThreadSafeInteger): Integer;
    class operator Implicit(a: Integer): TThreadSafeInteger;
    class operator Explicit(a: TThreadSafeInteger): Integer;
    class operator Explicit(a: Integer): TThreadSafeInteger;
  end;

implementation

{ TThreadSafeInteger }

class operator TThreadSafeInteger.Add(a: TThreadSafeInteger; b: Integer): Integer;
begin
  InterlockedExchangeAdd(a.Value, b);
  InterlockedExchange(result, a.Value);
end;

class operator TThreadSafeInteger.Subtract(a: TThreadSafeInteger; b: Integer): Integer;
begin
  InterlockedExchangeAdd(a.Value, -b);
  InterlockedExchange(result, a.Value);
end;

class operator TThreadSafeInteger.Explicit(a: TThreadSafeInteger): Integer;
begin
  InterlockedExchange(result, a.Value);
end;

class operator TThreadSafeInteger.Implicit(a: TThreadSafeInteger): Integer;
begin
  InterlockedExchange(result, a.Value);
end;

class operator TThreadSafeInteger.Explicit(a: Integer): TThreadSafeInteger;
begin
  InterlockedExchange(result.Value, a);
end;

class operator TThreadSafeInteger.Implicit(a: Integer): TThreadSafeInteger;
begin
  InterlockedExchange(result.Value, a);
end;

Grüße, Win32.API

[himitsu]

Delphi-Quellcode:

class operator TThreadSafeInteger.Add(a: TThreadSafeInteger; b: Integer): Integer;
begin
  a.Value := a.Value + b;  // sinnlos, da hier nur eine Kopie von a verändert wird
                           // und kein anderer darauf zugreifen kann
  result := a.Value;  // lesezugriff
end;

class operator TThreadSafeInteger.Subtract(a: TThreadSafeInteger; b: Integer): Integer;
begin
  a.Value := a.Value - b;  // siehe add
  result := a.Value;  // lesezugriff
end;

class operator TThreadSafeInteger.Explicit(a: TThreadSafeInteger): Integer;
begin
  result := a.Value;  // Lesezugriffe brauchen hier nicht geschützt werden,
                      // da es die Schreibzugriffe schon ausreichend machen
end;

class operator TThreadSafeInteger.Implicit(a: TThreadSafeInteger): Integer;
begin
  result, a.Value);
end;

class operator TThreadSafeInteger.Explicit(a: Integer): TThreadSafeInteger;
begin
  result.Value := a;  // sinnloas, da Result intern eh won keinem Anderem
                      // gesetzt werden kann und die externe Zuweisung ist vollkommen ungeschützt
end;

class operator TThreadSafeInteger.Implicit(a: Integer): TThreadSafeInteger;
begin
  result.Value := a;  // siehe vorher
end;

Fazit: hier ist garnichts geschützt, da alles nur intern abläuft und extern kein Schutz besteht.

Man benötigt vorallem bei den Schreibvorgängen direkten Zugriff auf die Variablen und das ist via Result nicht möglich.

[Win32.API]

Dankeschoen fuer die Erklaerung, gibt es eine Moeglichkeit sowas zu implementieren, oder muss ich weiterhin die unschoenen Api Calls in meinem Programm verwenden?

[himitsu]

sowas könnte gehn

Delphi-Quellcode:

type
  TThreadSafeInteger = record
  private
    Value: Integer;
  public
    class operator Implicit(a: TThreadSafeInteger): Integer;

    procedure Put     (i: Integer);
    procedure Add     (i: Integer);
    procedure Subtract(i: Integer);
    procedure Inc;
    procedure Dec;
    property  Get: Integer read Value;
  end;

class operator TThreadSafeInteger.Implicit(a: TThreadSafeInteger): Integer;
begin
  result := a.Value;
end;

procedure TThreadSafeInteger.Put(i: Integer);
begin
  InterlockedExchange(Value, i);
end;

procedure TThreadSafeInteger.Add(i: Integer);
begin
  InterlockedExchangeAdd(Value, i);
end;

procedure TThreadSafeInteger.Subtract(i: Integer);
begin
  InterlockedExchangeAdd(Value, -i);
end;

procedure TThreadSafeInteger.Inc;
begin
  InterlockedIncrement(Value);
end;

procedure TThreadSafeInteger.Dec;
begin
  InterlockedDecrement(Value);
end;

theoretisch ginge auch sowas,

Delphi-Quellcode:

class operator TThreadSafeInteger.Implicit(a: TThreadSafeInteger): Integer;
asm
  //mov eax, &a
end;

procedure TThreadSafeInteger.Put(i: Integer);
asm
  lock mov [&Self], &i
end;

procedure TThreadSafeInteger.Add(i: Integer);
asm
  lock add [&Self], &i
end;

procedure TThreadSafeInteger.Subtract(i: Integer);
asm
  lock sub [&Self], &i
end;

procedure TThreadSafeInteger.Inc;
asm
  lock inc [&Self]
end;

procedure TThreadSafeInteger.Dec;
asm
  lock dec [&Self]
end;

wenn da nicht der blöde Fehler im LOCK MOV wäre

Zitat:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt Project3.exe ist eine Exception der Klasse EExternalException mit der Meldung 'Externe Exception C000001E' aufgetreten.
---------------------------
Anhalten Fortsetzen Hilfe
---------------------------

[Win32.API]

Vielen Dank fuer deine Muehe, aber wenn ich z.b. "sowas könnte gehn" oder "theoretisch ginge auch sowas" lese, bin ich sehr skeptisch, ob ich es in einer Anwendung einsetzen sollte.

Grueße,
Win32.API

[himitsu]

Zitat von Win32.API:

bin ich sehr skeptisch

soll heißen es geht theoretisch, aber ich hab's jetzt nicht in Delphi getestet, ob es kompiliert oder ob was falsch geschrieben ist.
PS: die Compare-Operatoren kannst du genauso wie den Lese-Operator noch mit einbinden, da es ja auch nur Lesezugriffe sind.

und das "theoretisch" hieß,
daß es irgendwie geht, wenn man 'nen Umweg für LOCK MOV V, i einsetzt
und z.B. LOCK AND V, 0 und danach noch LOCK ADD V, i verwendet, aber das ist nicht unbedingt so die optimalste Lösung, da der Wert ja für ein paar Takte auf 0 steht

[Khabarakh]

Generell ist diese Interlocked-Sache von der Theorie ganz nett, aber in der Praxis meistens einfach doch zu aufwendig.
Es gibt fast kein Problem, bei dem man früher oder später nicht sowieso zu "gröberen" Locks greifen muss, warum also sich so den Kopf zerbrechen und nicht gleich in den meisten Fällen richtige Locks einsetzen? Als ob Multithreading nicht schon schwierig genug wäre ...

[himitsu]

Zitat von Khabarakh:

warum also sich so den Kopf zerbrechen und nicht gleich in den meisten Fällen richtige Locks einsetzen?

vermutlich deswegen?

94 ms - Inc (nicht threadsave)
281 ms - LOCK
359 ms - InterlockedExchangeAdd
1344 ms - EnterCriticalSection
1438 ms - TCriticalSection

Delphi-Quellcode:

uses Windows, SyncObjs;

type
  TInteger = record
  private
    Value: Integer;
  public
    procedure Add(i: Integer);
  end;

  TLockedInteger = record
  private
    Value: Integer;
  public
    procedure Add(i: Integer);
  end;

  TInterlockedInteger = record
  private
    Value: Integer;
  public
    procedure Add(i: Integer);
  end;

  TRTLCriticalSectionInteger = record
  private
    Value: Integer;
    Lock:  TRTLCriticalSection;
  public
    procedure Init;
    procedure Finalize;
    procedure Add(i: Integer);
  end;

  TCriticalSectionInteger = record
  private
    Value: Integer;
    Lock:  TCriticalSection;
  public
    procedure Init;
    procedure Finalize;
    procedure Add(i: Integer);
  end;

procedure TInteger.Add(i: Integer);
begin
  Inc(Value, i);
end;

procedure TLockedInteger.Add(i: Integer);
asm
  lock add [eax], edx
end;

procedure TInterlockedInteger.Add(i: Integer);
begin
  InterlockedExchangeAdd(Value, i);
end;

procedure TRTLCriticalSectionInteger.Init;
begin
  InitializeCriticalSection(Lock);
end;

procedure TRTLCriticalSectionInteger.Finalize;
begin
  DeleteCriticalSection(Lock);
end;

procedure TRTLCriticalSectionInteger.Add(i: Integer);
begin
  EnterCriticalSection(Lock);
  try
    Inc(Value, i);
  finally
    LeaveCriticalSection(Lock);
  end;
end;

procedure TCriticalSectionInteger.Init;
begin
  Lock := TCriticalSection.Create;
end;

procedure TCriticalSectionInteger.Finalize;
begin
  Lock.Free;
end;

procedure TCriticalSectionInteger.Add(i: Integer);
begin
  Lock.Enter;
  try
    Inc(Value, i);
  finally
    Lock.Leave;
  end;
end;




procedure TForm2.FormCreate(Sender: TObject);
var C:  LongWord;
  L, k: Integer;
  I:    TInteger;
  LI:   TLockedInteger;
  II:   TInterlockedInteger;
  RCSI: TRTLCriticalSectionInteger;
  CSI:  TCriticalSectionInteger;
begin
  // cpu spin up
  for L := 0 to 100000000 do
    I.Add(10);

  C := GetTickCount;
  for L := 0 to 30000000 do
    I.Add(10);
  C := GetTickCount - C;
  Memo1.Lines.Add(IntToStr(C));

  C := GetTickCount;
  for L := 0 to 30000000 do
    LI.Add(10);
  C := GetTickCount - C;
  Memo1.Lines.Add(IntToStr(C));

  C := GetTickCount;
  for L := 0 to 30000000 do
    II.Add(10);
  C := GetTickCount - C;
  Memo1.Lines.Add(IntToStr(C));

  C := GetTickCount;
  RCSI.Init;
  Try
    for L := 0 to 30000000 do
      RCSI.Add(10);
  Finally
    RCSI.Finalize;
  End;
  C := GetTickCount - C;
  Memo1.Lines.Add(IntToStr(C));

  C := GetTickCount;
  CSI.Init;
  Try
    for L := 0 to 30000000 do
      CSI.Add(10);
  Finally
    CSI.Finalize;
  End;
  C := GetTickCount - C;
  Memo1.Lines.Add(IntToStr(C));
end;