Speicher Adresse überwachen?

[4dk2]

Hallo,
ist es evtl. möglich die Speicheradresse bei dem folgenden Beispiel die Schreibzugriffe oder vielleicht sogar Lesezugriffe zu überwachen?
Ohne Wert auf die dadurch sinkende Performance zu legen

Klar ich kann mir den Wert merken und an geeigneter Stelle vergleichen, aber geht das auch anders?

Ich denke mal mit den Delphi Boardmitteln geht es nicht. aber vielleicht mit FastMM und Co?

Delphi-Quellcode:

var
  Form1: TForm1;
  IntWert1:integer;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var i1,i2:integer;
    p:PInteger;
begin
  //init:
  IntWert1:=100;

  p:=@IntWert1;

  //ab hier die Adresse überwachen?
  p^:= 123456;
  IntWert1 := 654321;
  
  i1:=p^;
  i2:=IntWert1;

end;

wünsche euch eine schönes Wochenende

[himitsu]

Debugger > Datenhaltepunkt
Ob das auch auf Lesen reagiert ... k.A.

PS: F5 = Codehaltepunkt




Oder VirtualProtect und dann auf die Exception reagieren.

[4dk2]

, ne ich das Programm. Im Programm darauf reagieren.

[Neutral General]

Was er mit VirtualProtect meint ist, dass du das PAGE_GUARD übergeben kannst.
Dadurch wird eine Exception ausgelöst sobald jmd auf die Page zugreift. Problem ist allerdings dass du damit mehr als nur eine Variable überwachst sondern eben direkt die ganze Page (meistens 4KB).

Ansonsten gibt es soweit ich weiß keine Möglichkeit sowas festzustellen.
Hatte auch mal danach gesucht, aber nichts gefunden.

[Zacherl]

Also der Ansatz über die Exceptions ist schonmal richtig. Fangen kannst du diese am besten, indem du einen eigenen Top-Level Exception-Handler mit AddVectoredExceptionHandler registrierst.

PAGE_GUARD ist allerdings denkbar ungünstig (EXTREM unperformant), weil es halt die komplette Page betrifft.

Als Alternative kannst du im betroffenen (oder allen) Thread mit SetThreadContext die Debug Register entsprechend setzen, um einen "Hardware Breakpoint" zu aktivieren. Diese Hardware Breakpoints können je nach Wunsch durch Read, Write oder Execute getriggert werden. Nachteile gibt es allerdings auch: Du kannst maximal 4 HWBPs pro Thread setzen und die "Länge" des Breakpoints erstreckt sich nur bis maximal 4 Byte (evtl. 8 Byte unter 64-Bit, da bin ich mir grade nicht mehr sicher).

[Sir Rufo]

Eine Variable überwachen macht man idR nicht. Wenn hat man eine Eigenschaft und wenn sich diese ändert feuert man einen Event.

[4dk2]

Zitat von Sir Rufo:

Eine Variable überwachen macht man idR nicht. Wenn hat man eine Eigenschaft und wenn sich diese ändert feuert man einen Event.

ja ich weiss. Es geht bei mir aber um Variablen von komplexen Berechnungen. Die werden u.a. auch unterschiedlichst über var Parameter in Funktionen benutzt. Daher fallen property von klassen
leider weg.
Und wenn ihr sagt ist VirtualProtect 4k nutzt, denke ich, dass das auch nicht das optimal ist, da es sich um ca 300 variablen handelt.

Mein Ansatz bisher ist, alle Pointer,werte, typen und Bezeichnungen der Variablen in einem Verwalter abzulegen, und nach den Berechnungen alle durchzugehen und zu vergleichen welche verändert worden sind.
Ich wollte nur mal Interesse halber hören ob es nicht vielleicht eine Möglichkeit gibt, Die Pointer zu überwachen

[Sir Rufo]

Dann wirst du dein Konzept wohl überdenken müssen.

Es gibt da so einige Möglichkeiten (Records, Interfaces, ...). Mit einem konkreten Beispiel können wir dir auch eine konkrete Lösung anbieten

[hoika]

Hallo,

< Die werden u.a. auch unterschiedlichst über var Parameter in Funktionen benutzt >

Dann ändere das halt ab.
Definiere dir eine Datenklarr, wo alle Variablen Properties sind und nutze diese eine Datenklasse statt deiner var-Parameter.

Zur Not nutzt du eine globale Variable für deine Datenklasse (jaja, macht man nicht ...).
Benenne die Properties alle mit einem _ vor dem eigentlichen Namen,
also Name -> _Name.

Das sollte der Compiler alles sehr schnell finden.


Heiko

[4dk2]

Ok, ich probier mal, das ist alles pseudo code, daher ist die Sinnhaftigkeit von den Variable Zuweisungen erstmal irrelevant.

Delphi-Quellcode:

type TTest=class
  private
    FA: double;
    FC: double;
    FB: double;
    procedure SetA(const Value: double);
    procedure SetB(const Value: double);
    procedure SetC(const Value: double);
  public
    property A:double read FA write SetA;
    property B:double read FB write SetB;
    property C:double read FC write SetC;

end;

var
  test:TTest;
  x,y,z,a,b,c {usw....}:double;


procedure init;
procedure calc;
procedure calc_help1(var a1,b1,c1);

implementation

procedure init;
begin
  //laden...
  x:=0;
  y:=1.5;
  z:=2.5;
  a:=0;
  b:=0;
  c:=0;
  //...

  //test per klasse:
  test:=TTest.create;
  test.A:=100;


end;

procedure calc;
var b2:double;
begin
  a:=100;
  calc_help1(a,b2,c);

  //das geht logischerweise nicht per klasse:
  //[Fehler] : Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden
  with test do
    calc_help1(a,b,c);

end;

procedure calc_help1(var a1,b1,c1);
begin


  if a>100 then
  begin
    a1 := a1 - c1;
    b1 := c1 + a1;
  end;

  if a>200 then
  begin
    a1 := b1 - c1;
    b1 := c1 + a1;
  end;
end;

procedure calc_help2(var b1,c1);
begin
  //ich hab auch Funktionen die sich and den globalen variablen bedienen und ergebnisse liefern...
  b1 := a + c;
  c1 := 12345;
end;


{$R *.dfm}

{ TTest }

procedure TTest.SetA(const Value: double);
begin
  FA := Value;
end;

procedure TTest.SetB(const Value: double);
begin
  FB := Value;
end;

procedure TTest.SetC(const Value: double);
begin
  FC := Value;
end;

Ich würd es gerne per OOP regeln, aber ich kann nicht die paar tausend zeilen von den Berechnungen dafür umbauen.

und zu @hoika, ich kann leider die var parameter nicht entfernen. Das sind Funktionen wie calc_help1, die z.b. Geometrische Daten berechnen, und von überall aufgerufen werden können, mit unterschiedlichen parametern und mehrere Werte zurückliefern (bzw. können).
Gut ich könnte die nen Record zurückgeben lassen, aber dann müsste ich jeweils an dem Aufruf die Variabeln setzten.
Ich möchte aber solche intensiven Kode-Änerungen vermeiden.
Dann gibt es auch noch funktionen wie calc_help2, die auch noch teile von den Globalen Variablen nutzen und Ergebnisse liefern.
Mit einem with test do begin {...} end; könnte ich ja noch leben