[für mich hier gelöst] Großer Heap dump unfreed memory: wie vorgehen?

[Ich934]

Hallo,

ich habe hier ein Projekt, das bei bestimmten Schritten reproduzierbar im Debug einen Heap Dump mit unfreed memory erzeugt. An sich schon mal sehr gut, denn ich kann das reproduzieren.

Problem ist jedoch, dass ich aus diesen fast 3.500 Zeilen nicht schlau werde. Im Prinzip steht dort immer wieder das gleiche drinnen und die genannten Zeilen in meinem Programm werden sauber mit freigegeben. Vermutlich habe ich hier etwas übersehen. Ich bin das schon zeilenweise im Debug durchgegangen, aber mir ist auch nichts aufgefallen.

Bei anderen Heap dumps konnte ich ja die fehlerhafte Stelle problemlos identifizieren und das Problem beheben.

Hat hier jemand einen Tipp/Idee, wie man in solchen Fällen noch vorgehen kann? Ich bin ja sicher nicht der Einzige, der ein solches Problem hat.

Schöne Grüße

[Zvoni]

Für jedes "New" brauchst du ein "Dispose"
Für jedes "GetMem" ein "FreeMem"
Für jedes "Create" ein "Free"
.... und was mir sonst gerade nicht einfällt

Hast du HeapTrc an?

[Ich934]

Hallo,

ja, das ist an sich bekannt und irgendwo wird das vergessen sein bzw. es wird eine Kombination auftreten, wo etwas nicht freigegeben wird. Die Frage ist, ob es eine Möglichkeit gibt, diesen riesigen Dump, der nicht viel aussagt, diese Information zu entlocken. Ansonsten war das ja immer kein Problem, wenn doch mal Speicher nicht freigegeben wurde.

Ja, ist natürlich aktiv, sonst würde ich den Dump ja nicht bekommen.

[Zvoni]

Hast du vielleicht nen "Klassiker" im Einsatz?
Ich denke da an FindAllFiles

[Ich934]

Nein. Ich habs gerade eben gefunden. In einer verdammt blöden Stelle wurde eine Klasse neu erzeugt und in einer bestimmten Kombination nicht freigegeben. Das ist beim Durchgehen nicht aufgefallen und bei 3.500 Zeilen Dump, der im Prinzip immer das Gleiche anzeigt, nicht aufgefallen. Vor allem, weil er genau das nicht zeigt...

Aber eine Lösung, wie man bei solchen riesigen Dumps vorgeht, hat sonst keiner?

[Zvoni]

Ich geh mal von aus dass du GlobalSkipIfNoLeaks aktiviert hast?
Und den HeapTrc auf ne Datei umleitest? SetHeapTraceOutput('Trace.log');

https://wiki.freepascal.org/heaptrc

oder vielleicht LeakView?
https://wiki.freepascal.org/leakview

[Ich934]

Ja schon. Sonst macht das ja keinen Sinn bei solchen Ausgaben hier zu suchen

[af0815]

Es macht bei einem riesigen Dump auch keinen Sinn sich blöd zu suchen. Man nimmt die ersten 10 Vorfälle, schaut sich die an und hat meisten 90% erledigt.
Und ja die Stellen sind immer blöd gelaufen. Weil sonst hätte man die auch nicht im Dump.

Generell, je früher man anfängt umso weniger Probleme hat man. Bei mir ist das erste, das ganze zu aktivieren, dann erst zu programmieren, so mit fällt einem das sofort auf und nicht später auf den Kopf.

[Ich934]

Guten Morgen,

ja, das ist einer der ersten Sachen, die ich aktiviere und einbaue. Hier ist es halt dumm gelaufen, da dieser Fehler halt nur in einer bestimmten Konstellation aufgetreten ist - so wie es sich für einen echten Bug gehört, der dann in sich schön versachtelt ist, mit Menüaufrufen etc.

In meinem Fall, und ich habe mir jetzt den Dump noch mal angeschaut, da ich ja jetzt genau weiß, wonach ich suchen muss, wäre ich so nach Zeile 700 drauf gekommen. Aber auch nur so indirekt. Egal. Fehler gefunden und hoffen, dass so was doofes einfach nicht mehr vorkommt.

[Mathias]

Aber eine Lösung, wie man bei solchen riesigen Dumps vorgeht, hat sonst keiner?

Ich kenne da nur eine Brutale Methode.
Project sichern, zB. in eine ZIP.
Dann eine Funktion nach dem anderen entfernen, und immer wieder probieren, ob es das Leek noch gibt.
So hab ich auch schon Leeks gefunden.

[fliegermichl]

Ich habe so ein ähnliches Problem. In einer stark verschachtelten Funktion werden Klassen erzeugt und diese später dann auch normalerweise wieder freigegeben.
Von 2000 werden aber ca. 10 nicht wieder freigegeben und ich suche mir einen Wolf, wo genau das auftritt.

Jetzt habe ich geschaut, ob ich dem Heaptrace irgendwelche zusätzlichen Infos unterjubeln kann, die er mir in dem Dump mit ausgibt.
Dabei habe ich SetHeapExtraInfo gefunden. Wenn ich allerdings danach goggele, finde ich hier
eine offensichtlich veraltete Info.

Weiss jemand, wie das aktuell gelöst wird?

Edit: Ich habe es lösen können. Hier ein Code der funktioniert:

Code: Alles auswählen

Program heapex;

uses sysutils;

{ Program used to demonstrate the usage of heaptrc unit }

Var P1 : ^Longint;
    P2 : Pointer;
    I : longint;
    Marker : Longint;

Procedure SetMarker (P : pointer);

Type PLongint = ^Longint;

begin
  PLongint(P)^:=Marker;
end;

procedure DisplayMarker(var ptext : text; p : Pointer);
begin
  writeln(ptext, ' p:', IntToHex(ptrint(p), sizeof(pointer)), ' I: ', IntToHex(PLongInt(p)^, 8));
end;

Procedure  Part1;

begin
  // Blocks allocated here are marked with $FFAAFFAA = -5570646
  Marker := $FFAAFFAA;
  New(P1);
  New(P1);
  Dispose(P1);
  For I:=1 to 10 do
    begin
    GetMem (P2,128);
    If (I mod 2) = 0 Then FreeMem(P2,128);
    end;
  GetMem(P2,128);
end;

Procedure  Part2;

begin
  // Blocks allocated here are marked with $FAFAFAFA = -84215046
  Marker := $FAFAFAFA;
  New(P1);
  New(P1);
  Dispose(P1);
  For I:=1 to 10 do
    begin
    GetMem (P2,128);
    If (I mod 2) = 0 Then FreeMem(P2,128);
    end;
  GetMem(P2,128);
end;

begin
 SetHeapExtraInfo(SizeOf(Marker),@SetMarker, @DisplayMarker);
 Writeln ('Part 1');
 part1;
 Writeln('Part 2');
 part2;
end.

Nochmal Edit: Damit man die Arbeitsweise sehen kann, muss das Programm aus der Konsole gestartet werden.

[fliegermichl]

Ich habe eine kleine Unit gebastelt, bei der man die Heapextra Informationen in seinem Programm nutzen kann:
defines.inc
muss dazu dann auch in der zu untersuchenden Unit eingebunden werden

Code: Alles auswählen

{$define useheapmarker}

heapextrainfo.pas

Code: Alles auswählen

unit heapextrainfo;
{$i defines.inc}
interface

uses
  SysUtils;

type
  PHeapMark = ^RHeapMark;
  RHeapMark = packed record
    HeapMarker : Longint;
    AllocCounter : Longint;
  end;

var
  HeapMark : RHeapMark;

implementation
uses heaptrc;

procedure SetMarker(p : Pointer);
begin
  PHeapMark(p)^.HeapMarker := HeapMark.HeapMarker;
  PHeapMark(p)^.AllocCounter := HeapMark.AllocCounter;
end;

procedure DisplayMarker(var ptext : text; p : Pointer);
begin
  writeln(ptext, 'ac: ', PHeapMark(p)^.AllocCounter, ' M: ', PHeapMark(p)^.HeapMarker);
end;

initialization
  SetHeapExtraInfo(SizeOf(RHeapMark), @SetMarker, @DisplayMarker);
end.

In der zu untersuchenden Unit kann dann beim allokieren eines Speichers diese verwendet werden. Der AllocCounter und Heapmarker erscheinen dann im Heapdump mit entsprechenden Werten.

Code: Alles auswählen

constructor TMyClass.Create;
begin
  {$ifdef useheapmarker}
   inc(HeapMark.AllocCounter);
   inc(HeapMark.HeapMarker)
  {$endif}
end;

destructor TMyClass.Destroy;
begin
  {$ifdef useheapmarker}
   dec(HeapMark.HeapMarker)
  {$endif}
end;

Da kann man dann schön sehen, der wievielte Aufruf von Create nicht mit einem entsprechenden Destroy zusammenpasst.