InterlockedIncrement in welcher Unit?

[delphifan2004]

Hallo,

in welcher Unit finde ich die Routine InterkolckedIncrement? In der Windows Unit ist sie offenbar nicht.

[supermulti81]

Hallo,

hilft dir das weiter:
https://docwiki.embarcadero.com/Libr...s.TInterlocked

Increment ist eine Methode von TInterlocked.

Viele Grüße

[Uwe Raabe]

Zitat:

Zitat von delphifan2004 (Beitrag 1542728)

In der Windows Unit ist sie offenbar nicht.

Ist sie doch:

Delphi-Quellcode:

function InterlockedIncrement(var Addend: Integer): Integer; stdcall; inline;
{$EXTERNALSYM InterlockedIncrement}

[delphifan2004]

Danke soweit, aber dann stimmt irgendwas in meinen Projekteinstellungen nicht. Hab System.SynObjs jetzt in der Uses Klausel aber der Compiler meldet Routine immer noch als nicht gefunden.

Was könnte da noch faul sein?

Ist da eventuell die Schreibweise falsch:

so steht die Routine in meinem Projekt:

InterlockedIncrement --- mit Copy und Paste aus dem Projekt hierher kopiert!

Kann ich mir echt nicht erklären, habe doch Delphi nach Standard installiert!

[Papaschlumpf73]

Vielleicht könntest du uns auch mal eine ganze Zeile Code zeigen?

[Uwe Raabe]

Dann zeig doch mal den ganzen Code (falls zu groß als Anhang). Manchmal sieht man ja den Wald vor lauter Bäumen nicht.

[Papaschlumpf73]

Oder du probierst das mal ganz einfach aus:

Delphi-Quellcode:

procedure TFMain.Button1Click(Sender: TObject);
var A: Integer;
begin
A:=1;
Winapi.Windows.InterlockedIncrement(A);
showmessage(A.ToString);
end;

Da sollte dann 2 rauskommen. :-D

[himitsu]

Verwende stattdessen das "neue" platformunabhänige AtomicIncrement (aus der System-Unit)

Aber wenn man das InterlockedIncrement richtig schreibt, dann lässt es sich auch in der Windows-Unit (Winapi.Windows) finden. :stupid:

[delphifan2004]

Das hieße ja dass ich die Klasse TInterlocked nicht erst instanziieren muss?

Ich habe ein Internet Beispielprogramm das mir einen eigenen Speichermanager bereit stellt, ich habe mir daraus die folgende Unit gebaut:

Delphi-Quellcode:

unit mem_mgr;

interface
uses Windows, System.SyncObjs;

var
  OldMemMgr       : TMemoryManagerEx;
  GetMemCalls     : Integer;
  FreeMemCalls    : Integer;
  MaxAvail        : Integer;
  ReallocMemCalls : Integer;
  AllocMemCalls   : Integer;

function MyGetMem(Size: Integer): Pointer;
function MyFreeMem(P: Pointer): Integer;
function MyReallocMem(P: Pointer; Size: Integer): Pointer;
function MyAllocMem(Size: Cardinal): Pointer;


implementation

//uses System.SyncObjs;

function MyGetMem(Size: Integer): Pointer;
begin
  { Route the call. }
  Result := OldMemMgr.GetMem(Size);

  { Safely increment the counter. }
  winapi.windows.InterlockedIncrement(GetMemCalls); //Bereits hier meckert der Compiler
end;

function MyFreeMem(P: Pointer): Integer;
begin
  { Route the call. }
  Result := OldMemMgr.FreeMem(P);

  { Safely increment the counter. }
  Interlocke1dIncrement(FreeMemCalls);
end;

function MyReallocMem(P: Pointer; Size: Integer): Pointer;
begin
  { Route the call. }
  Result := OldMemMgr.ReallocMem(P, Size);

  { Safely increment the counter. }
  InterlockedIncrement(ReallocMemCalls);
end;

function MyAllocMem(Size: Cardinal): Pointer;
begin
  { Route the call. }
  Result := OldMemMgr.AllocMem(Size);

  { Safely increment the counter. }
  InterlockedIncrement(AllocMemCalls);
end;

(*
procedure TForm2.btPerformSomethingClick(Sender: TObject);
var
  X : Integer;
  I : ^Integer;
begin
  { Perform some allocations and free operations. }
  for X := 0 to 999 do
  begin
    New(I);
    Dispose(I);
  end;
end;

procedure TForm2.btUseMyMemMgrClick(Sender: TObject);
var
  MyMemMgr : TMemoryManagerEx;
begin
  { Switch button states. }
  btUseSystemMemMgr.Enabled := true;
  btUseMyMemMgr.Enabled := false;

  { Get the old memory manager. }
  GetMemoryManager(OldMemMgr);

  { Create your instance. }
  MyMemMgr.GetMem := MyGetMem;
  MyMemMgr.FreeMem := MyFreeMem;
  MyMemMgr.ReallocMem := MyReallocMem;
  MyMemMgr.AllocMem := MyAllocMem;

  { Use the defaults for this--not important. }
  MyMemMgr.RegisterExpectedMemoryLeak := OldMemMgr.RegisterExpectedMemoryLeak;
  MyMemMgr.UnregisterExpectedMemoryLeak := OldMemMgr.UnregisterExpectedMemoryLeak;

  { Clear out the count variables. }
  GetMemCalls := 0;
  FreeMemCalls := 0;
  ReallocMemCalls := 0;
  AllocMemCalls := 0;

  { Install the new memory manager. }
  SetMemoryManager(MyMemMgr);
end;
*)
end.

Ich dachte zuerst man müsse eine Klasse vom Typ TInterlocked instanziieren, um Interlocked verwenden zu können wie oben ein User suggereiert hat der mich auf die DocWiki verwiesen hat. Demnach brauche ich ja die Klsse TInterlocked, die aber in diesem Internetbeispiel nicht verwendet wird.

Wie aufwendig ist eigentlich der Bau einer eigenen Interlocked Routine um mein Problem zu umgehen?

[Papaschlumpf73]

Und was ist das?

Delphi-Quellcode:

function MyFreeMem(P: Pointer): Integer;
begin
  { Route the call. }
  Result := OldMemMgr.FreeMem(P);

  { Safely increment the counter. }
  Interlocke1dIncrement(FreeMemCalls);
end;

Interlocke1???

[Uwe Raabe]

Außerdem:

Delphi-Quellcode:

interface
uses Windows, System.SyncObjs;

aber dann:

Delphi-Quellcode:

  { Safely increment the counter. }
  winapi.windows.InterlockedIncrement(GetMemCalls); //Bereits hier meckert der Compiler

Entweder WinApi an beiden Stellen (empfohlen) oder an keiner.

[Papaschlumpf73]

Richtig, bei 10.3 war das ja noch in der System.SyncObjs. Wir sollten eine Delphi-PRAXis-History für Fragen zu den älteren Delphi-Versionen einführen. Zumindest gefühlt werden das ja immer mehr.

[Stevie]

Zitat:

Zitat von himitsu (Beitrag 1542744)

Verwende stattdessen das "neue" platformunabhänige AtomicIncrement (aus der System-Unit)

Dem kann ich nur zustimmen - die Atomic intrinsics gibt es ab XE3.

Der Text in der Hilfe ist leider immer noch etwas irreführend, da dort steht dass sie für "mobile Delphi-Compiler" seien, was kompetter Unfug ist. Diese Routinen stehen für alle Platformen zur Verfügung und generieren den entsprechenden Binärcode.

Edit: fwiw, ich hab das mal reported

[delphifan2004]

Genau da meckert aber mein Compiler Delphi 11.3 Community Edition und genau das kann ich mir nicht erklären. Ich weiß neichet mehr was ich noch tun soll. Warum gibt es solche böden Fehler nur bei Mir?

Besser ich baue mir eine eigene Rotine dafür aber wie fange ich das an? Da zugehörige Projet ist im Delphi Pfad wie er installiert ist under dem Ordner Prokekte.Delphi legt ja dafür unter

c:\Users\Konta\Documents\Embarcadero\Studio\Projek te\

meinen Pfad an und dort gibt es meinjen Unterordner für das Projekt. Für jedes Projekt ein Unterordner in /Projekte

Warum findet der Compiler dann eine Unit nicht? Bin verzweifelt!:(

[delphifan2004]

Danke @Stevie! AtomicIncrement ist die Lösung!:cheers:

Echt frustrierend wenn sich die Lokationen der Bezeichner auch noch von Version zu Verion ändern, da ist es kein Wunder, wenn/dass man irgendwann frustriert aufgibt, was als Hobby Programmierer ja geht. Wie aber soll der professionelle Programmierer einem Kunden erklären dass das Programm wegen solcher vermeidbaren Probleme so teuer ist???. Und es ist sinnlos vergeudete Arbeitszeit in der professionellen Programmierung, die der programmierende zu Recht anständig bezahlt haben will.

[himitsu]

Zitat:

Zitat von delphifan2004 (Beitrag 1542745)

Das hieße ja dass ich die Klasse TInterlocked nicht erst instanziieren muss?

Natürlich nicht, denn

Delphi-Quellcode:

  TInterlocked = class sealed
  public
    class function Increment(var Target: Integer): Integer; overload; static; inline;
    class function Increment(var Target: Int64): Int64; overload; static; inline;

(man beachte das CLASS)

Delphi-Quellcode:

var MyVar: Integer;

AtomicIncrement(MyVar);  // die System.pas ist immer eingebunden
InterlockedIncrement(MyVar);  // Winapi.Windows.pas
TInterlocked.Increment(MyVar);  // System.SyncObjs.pas

[Stevie]

Zitat:

Zitat von delphifan2004 (Beitrag 1542751)

Danke @Stevie! AtomicIncrement ist die Lösung!:cheers:

Ich hab nur zitiert, was himi schon geschrieben hatte...

Zitat:

Zitat von delphifan2004 (Beitrag 1542751)

wenn sich die Lokationen der Bezeichner auch noch von Version zu Verion ändern

Übertreiben wir hier ein wenig? Die Atomic Intrinsics gibt es seit XE3, welches die erste Delphiversion war, die über Windows hinaus ging.

Zitat:

Zitat von delphifan2004 (Beitrag 1542751)

der professionelle Programmierer

Aus eigener Erfahrung kann ich dir berichten, dass man sich - so wie in allen Berufen, wo sich regelmäßig Dinge ändern und nicht Jahrzehnte gleich bleiben - mit seinen Werkzeugen auseinander setzen muss.

[Rollo62]

Zitat:

Zitat von Stevie (Beitrag 1542753)

Übertreiben wir hier ein wenig? Die Atomic Intrinsics gibt es seit XE3, welches die erste Delphiversion war, die über Windows hinaus ging.

<KlugScheisserei>

Eigentlich war schon XE2 ziemlich über Windows hinweg :-D
aber ja, XE3 war sicher stabiler und es gab noch eine Menge Änderungen ... :stupid:

https://de.wikipedia.org/wiki/Embarc...dename_Pulsar)

</KlugScheisserei>

[Stevie]

Stimmt, außer OSX32 lief das allerdings über FPC und für OSX32 funktionierte noch der x86 asm Code, deshalb sah man zu diesem Zeitpunkt wohl noch nicht die Notwendigkeit für platformübergreifende Intrinsics.
Muss ich verdrängt haben 8-)