Memoryleak oder doch nicht?

[EWeiss]

Die Meldung.

Zitat:

--------------------------------------------------------------------------------------------------------------------------------------
|Methods |Details|Stack |Address |Module |Offset |Unit |Class |Procedure/Method |Line |
--------------------------------------------------------------------------------------------------------------------------------------
|+Leak #1: Type=UnicodeString: Ref count - 1, Content: "'WARNING: DO NOT CHANGE THE ORDER OF THE PROPERTIES!"; Total size=118; Count=1|
|------------------------------------------------------------------------------------------------------------------------------------|
|00000002|03 |00000000|005E8586|SK_Aero.dll |00008586|System | |InternalUStrFromPCharLen | |
|00000002|04 |00000000|0082C55B|SK_Aero.dll |0024C55B|uSkinConfig|TSkinConfig|FBuffin |976[12] |
|00000002|04 |00000000|0082ABEF|SK_Aero.dll |0024ABEF|uSkinConfig|TSkinConfig|GetConfiguration |308[5] |
|00000002|04 |00000000|008234C4|SK_Aero.dll |002434C4|uSkin |TSkinEngine|InitSkin |644[25] |
|00000002|04 |00000000|00833E1B|SK_Aero.dll |00253E1B|uMaster | |SKAERO_InitSkin |806[4] |
|00000002|03 |00000000|75213366|kernel32.dll|00013366|kernel32 | |BaseThreadInitThunk | |
|00000002|03 |00000000|77019900|ntdll.dll |00039900|ntdll | | (possible RtlInitializeExceptionChain+97)| |
|00000002|03 |00000000|770198CE|ntdll.dll |000398CE|ntdll | | (possible RtlInitializeExceptionChain+47)| |
|------------------------------------------------------------------------------------------------------------------------------------|

Wie soll ich das jetzt interpretieren?
Wo oder was ist der Leak UnicodeString?

Aber wie soll dieser entstehen wenn ich doch die Classe beim beenden freigebe?

Delphi-Quellcode:

destructor TSkinEngine.Destroy;
begin

  if Assigned(SkinConfig) then
    SkinConfig.free;

  SkinLoaded := False;
  SkinEngine := nil;

  inherited;
end;

Noch mehr kann ich nicht tun.
Und hier wird das File geschlossen.

Delphi-Quellcode:

procedure TSkinConfig.FBuffin(FileName: string);
var
  sBuffer: string;

begin

  if not FExist(FileName) then
    Exit;

  Assignfile(ParseFile, FileName);
  reset(ParseFile);

  try
    try
      while not eof(ParseFile) do
      begin
        ReadLN(ParseFile, sBuffer);
        AppendToLinkedList(nReading, sBuffer);
        inc(nReading);
      end;
    except
      raise Exception.Create(SysErrorMessage(GetLastError));
    end;
  finally
    nReading := 0;
    sBuffer := '';
    CloseFile(ParseFile);
  end;
end;

noch bevor die Anwendung beendet wird.
Was will er mir jetzt mit dem FBuffin sagen?

EDIT:
Dieser string wird aus der Textdatei geladen
'WARNING: bla, bla!"

Nun die Datei wird ordnungsgemäß geschlossen und die Classe freigegeben verstehe wer will.
Der String existiert doch dann gar nicht mehr.

gruss

[Stevie]

Also gemäß des Callstacks geht es um den Inhalt von sBuffer. Innerhalb der FBuffin Methode läuft da alles gut, also bleibt nur die Frage: Was wird in

Delphi-Quellcode:

AppendToLinkedList(nReading, sBuffer)

damit gemacht?

:glaskugel: Meine Vermutung: dort wird irgendwie der RefCount des strings aus dem Gleichgewicht gebracht.

[EWeiss]

Zitat:

Zitat von Stevie (Beitrag 1397540)

Also gemäß des Callstacks geht es um den Inhalt von sBuffer. Innerhalb der FBuffin Methode läuft da alles gut, also bleibt nur die Frage, was wird in

Delphi-Quellcode:

AppendToLinkedList(nReading, sBuffer);

damit gemacht.

:glaskugel: Meine Vermutung: dort wird irgendwie der RefCount des strings aus dem Gleichgewicht gebracht.

Bitte das hier..

Delphi-Quellcode:

procedure TSkinConfig.AppendToLinkedList(nReading: Integer; sBuffer: string);
begin

  New(FPBuffer);

  if nReading = 0 then
  Begin
    New(FToPBuffer);
    LineStart := FToPBuffer;
    LineStart^.Nr := 0;
  end;

  FPBuffer^.Nr    := nReading;
  FPBuffer^.Str   := sBuffer;
  LineStart^.Max  := nReading;
  FToPBuffer^.Ptr := FPBuffer;
  FToPBuffer      := FPBuffer;

end;

Es werden nur die Zuweisungen aktualisiert.

EDIT:

Delphi-Quellcode:

  PParseFile = ^TParseFile;
  TParseFile = record
    Nr    :Integer;
    Str   : string;
    Ptr   : PParseFile;
    Max   : Integer;
  end;

Delphi-Quellcode:

    LineStart            : PParseFile;
    FPBuffer             : PParseFile;
    FToPBuffer           : PParseFile;

gruss

[Whookie]

Dann liegt wohl da der Hund begraben:

Delphi-Quellcode:

  FPBuffer^.Str := sBuffer;

[EWeiss]

Zitat:

Zitat von Whookie (Beitrag 1397544)

Dann liegt wohl da der Hund begraben:

Delphi-Quellcode:

  FPBuffer^.Str := sBuffer;

Warum ?
Beides sind string.

gruss

[Fritzew]

Wann und vor allem wie gibst Du

Delphi-Quellcode:

FPBuffer^.Str := sBuffer;

wieder frei?

[EWeiss]

Zitat:

Zitat von Fritzew (Beitrag 1397549)

Wann und vor allem wie gibst Du

Delphi-Quellcode:

FPBuffer^.Str := sBuffer;

wieder frei?

Nach dem Parsen des TextFile.

Delphi-Quellcode:

  // Resourcen Freigeben
  Dispose(FPBuffer);
  FPBuffer := nil;
  Dispose(LineStart);
  LineStart := nil;
  Result := True;

EDIT:
Mit new erstellt und Dispose freigegeben.

gruss

[Fritzew]

Da liegt der Hund begraben.....
Der String wird nich freigegeben.

mach einfach

Delphi-Quellcode:

finalize(FPbuffer^);
//oder 
FPBuffer^.Str := nil;

Dispose(FPBuffer);
FPBuffer := nil;

Wenn Du nur den Speicher freigibst werden die Strings nicht gelöscht.

Aus der Hilfe zu finalize

Zitat:

Die Variable enthält lange Strings, Varianten und Interfaces, die nicht alle leer sind bzw. den Wert Unassigned haben.

Finalize setzt einfach alle langen Strings auf einen leeren Wert und alle Varianten und Interfaces auf Unassigned und sorgt somit für die ordnungsgemäße Freigabe des betreffenden Speichers.

[EWeiss]

Dann werde ich es mal so bearbeiten wie von dir vorgeschlagen.. Danke.

Hmmm dachte eigentlich ein Dispose würde reichen.
Ok wieder was gelernt.

gruss

[EWeiss]

Jetzt habe ich nur noch eins.
Dann ist alles bereinigt.

Zitat:

--------------------------------------------------------------------------------------------------------------------------------------
|Methods |Details|Stack |Address |Module |Offset |Unit |Class |Procedure/Method |Line |
--------------------------------------------------------------------------------------------------------------------------------------
|+Leak #1: Type=Data at $05C5FF90; Total size=480; Count=30 |
|------------------------------------------------------------------------------------------------------------------------------------|
|00000002|03 |00000000|009C9865|SK_Aero.dll |00009865|System | |_New | |
|00000002|04 |00000000|00C0DECF|SK_Aero.dll |0024DECF|uSkinConfig|TSkinConfig|FBuffin |989[13] |
|00000002|04 |00000000|00C0C4EE|SK_Aero.dll |0024C4EE|uSkinConfig|TSkinConfig|GetConfiguration |305[5] |
|00000002|04 |00000000|00C11ADF|SK_Aero.dll |00251ADF|uSkin |TSkinEngine|InitSkin |648[28] |
|00000002|04 |00000000|00C08DCB|SK_Aero.dll |00248DCB|uMaster | |SKAERO_InitSkin |804[2] |
|00000002|03 |00000000|75213366|kernel32.dll|00013366|kernel32 | |BaseThreadInitThunk | |
|00000002|03 |00000000|77019900|ntdll.dll |00039900|ntdll | | (possible RtlInitializeExceptionChain+97)| |
|00000002|03 |00000000|770198CE|ntdll.dll |000398CE|ntdll | | (possible RtlInitializeExceptionChain+47)| |
--------------------------------------------------------------------------------------------------------------------------------------

Deine Änderung hat geholfen Danke nochmal.

Delphi-Quellcode:

  // Resourcen Freigeben
  finalize(FPbuffer^);
  Dispose(FPBuffer);
  FPBuffer := nil;
  finalize(LineStart^);
  Dispose(LineStart);
  LineStart := nil;
  Result := True;

gruss

[Fritzew]

Das wird sicher nur 1+ durchlaufen?

Delphi-Quellcode:

if nReading = 0 then
  Begin
    New(FToPBuffer);
    LineStart := FToPBuffer;
    LineStart^.Nr := 0;
  end;

[EWeiss]

Zitat:

Zitat von Fritzew (Beitrag 1397560)

Das wird sicher nur 1+ durchlaufen?

Delphi-Quellcode:

if nReading = 0 then
  Begin
    New(FToPBuffer);
    LineStart := FToPBuffer;
    LineStart^.Nr := 0;
  end;

Ja wenn nReading = 0

EDIT:
Und LineStart wird ja freigegeben.
Da es der gleiche Pointer wie der von FToPBuffer ist darf ich FToPBuffer nicht nochmals freigeben das wäre ja dann doppelt gemoppelt.


gruss

[Fritzew]

Ohne mehr Code kann ich Dir nicht mehr sagen,
aber es wird ja wohl definitiv mehr erzeugt als freigeben wird.....
Mach doch mal Spasseshalber zum Debugger eine globale Variable die du hochzählst bei jedem! erzeugen und runterzählst beim freigeben. Sollte ja am Ende 0 sein :-)

[EWeiss]

Zitat:

Zitat von Fritzew (Beitrag 1397568)

Ohne mehr Code kann ich Dir nicht mehr sagen,
aber es wird ja wohl definitiv mehr erzeugt als freigeben wird.....
Mach doch mal Spasseshalber zum Debugger eine globale Variable die du hochzählst bei jedem! erzeugen und runterzählst beim freigeben. Sollte ja am Ende 0 sein :-)

Kein Problem muss mich da wohl durch wurschteln. Danke.

gruss

[Stevie]

Davon abgesehen kannst dir evtl den ganzen Pointerkrams/New/Dispose und ne linked list sparen und ein Array nutzen. Linked lists sind nur dann wirklich besser als arrays wenn man zwischendurch viele! Hinzufüge oder Entfernen Operationen hat, da sie die nachfolgenden Elemente in einem Array nicht verschieben müssen oder das Array resizen müssen. Und auch dann würd ich das nur nach ausgiebigen Performancetests unterschreiben, denn selbst dann spielt noch eine Rolle über was für eine Lebensspanne der liste wir reden. Lebt sie lang genug, wird sie irgendwann Opfer von Speicherfragmentierung (die ganzen Nodes liegen kreuz und quer im RAM) wogegen der CPU Cache/Prefetcher bei nem Array nur kurz zuckt.

[EWeiss]

Ich lese eine Textdatei ein und diese bzw.. die geparsten Daten davon leben solange wie die Classe lebt.
Ein Array nutzt in dem fall gar nichts.

EDIT:
Die eingelesenen Daten werden über die gesamte Classe verteilt.

gruss

[Stevie]

Zitat:

Zitat von EWeiss (Beitrag 1397584)

Ich lese eine Textdatei ein und diese bzw.. die geparsten Daten davon leben solange wie die Classe lebt.
Ein Array nutzt in dem fall gar nichts.

Ein array of TParseFile statt einer linked list nützt nichts weil?

[EWeiss]

Zitat:

Zitat von Stevie (Beitrag 1397586)

Zitat:

Zitat von EWeiss (Beitrag 1397584)

Ich lese eine Textdatei ein und diese bzw.. die geparsten Daten davon leben solange wie die Classe lebt.
Ein Array nutzt in dem fall gar nichts.

Ein array of TParseFile statt einer linked list nützt nichts weil?

Ach so meinst du das jo könnte man machen.
Muss mir das mal überlegen.

EDIT:
Ich werde das mit der linkedlist behalten um das zu ändern brauche ich wieder Tage.

gruss

[EWeiss]

Denke das ist nicht so einfach zu beheben.
Bei jeden Fenster das ich erstelle muss ich die Textdatei einlesen.

Selbst wenn ich die Classe vorher zerstöre und neu erstellen lasse bleiben die strings irgendwie im Speicher.
Was dann zu dem besagten Speicherleck führt.

Das Hauptproblem ist das ich die Classe nicht zerstören kann wenn ich das Fenster schließe so bleibt immer was im Speicher zurück.
Glaube muss mein Konzept nochmal überdenken nur mit einem Array of Class ist es nicht getan.

Hmmm...

EDIT:
Musste noch kleine Änderungen hinzufügen..
Ein einfaches

Delphi-Quellcode:

FPBuffer.Str := ''

oder

Delphi-Quellcode:

finalize(FPBuffer^);

hat leider nichts gebracht die Strings waren immer noch im Speicher.

Aber so geht's.

Delphi-Quellcode:

  FPBuffer := LineStart;
  while (FPBuffer.Nr < LineStart.Max) do
  begin
    FPBuffer := FPBuffer.Ptr;
    FPBuffer.Str := '';
  end;
  Dispose(FPBuffer);
  FPBuffer := nil;

Jetzt noch den Data Kram dann sollte es gut sein.

gruss