Arbeitsspeicher läuft über - wie leeren

[alfold]

Bei mehrdimensionalen Arrays must Du explizit jede Dimension freigeben
z.B

Delphi-Quellcode:

For i:=0 to hight(meinarray[0],[0]) do
begin
   setlength(meinarray[0],[i], 0);
end

so ungefähr. Müsste selbst erst nachschauen. Steht aber in der DH so drin und im Forum findest Du bestimmt auch Hinweise!
Somit würdest Du nur die 2. Dimension freigeben und der rest bleibt bestehen.
Aber ändert nix daran, das Du trotzdem irgend wann, spätestens wenn Du Dein Programm beendest, alles freigeben musst!!
Also jede Dimension!

Gruss alfold

[Ykcim]

Das probiere ich mal aus.
Wenn ich mein Programm beende, dann wird der ganze Speicher wieder freigegeben, wie ich im Taskmanager verfolgen kann....

Gruß

Patrick

[alfold]

Zitat von Ykcim:

....Wenn ich mein Programm beende, dann wird der ganze Speicher wieder freigegeben, wie ich im Taskmanager verfolgen kann....

Stimmt so nicht! Wenn ich mich recht entsinne werden Dynamische Arrays anders behandelt,(pointer). Auch wenn Du Dein Programm beendest,(und es sieht so aus das alles Frei gegeben wird), ist der Speicher noch reserviert! Darum auch der Hinweis, beim Beenden Deines Progs alles explizit Frei zugegeben!

Gruss alfold

[xZise]

Moin,

Zitat von Teekeks:

Zitat von alfold:

Delphi-Quellcode:

setlength(Cols4,15);//<----???? wird speicehr belegt
Cols4:=Cols41;
setlength(Cols4,15);//<---- wird neuer belegt

Genau das ist das Problem.
Wenn du ein SetLength mit exakt der gleichen Größe machst, wird einfach nur neuer Speicher reserviert und der Alte nicht freigegeben → Voilà! Unser Speicherleck!

http://www.delphipraxis.net/153654-s...ml#post1041224

Ich wäre mir da nicht sicher. Oder habe ich da was übersehen?

MfG
Fabian

[Ykcim]

Das hat den gleichen Effekt wie setlength(meinArray,0,0);

Ich habe auch noch festgestellt, dass die Häfigkeit, wie oft meine For-Schleifen mit dem setlength() durchlaufen werden keine Auswirkung auf den Speicherzuwachs hat.

Ich habe deshalb einfach mal die Hälfte meiner Datensätze, die ich in die Software einlese und dann nicht weiter benötige von meinem SQL-Server geschmissen.
Ich wollte damit testen, ob der Speicher bei meiner Procedure oder schon beim Einlesen der Daten, aus dem MySQL Server heraus, geblockt wird.

Obwohl das Ergebnis meiner Suchprocedure das gleiche ist, also die setlength() Befehle genauso oft aufgerufen werden wie vorher, ist das Speicherleck auf 150kbyte runter.

Das führt mich wieder zu meiner Annahme, dass ich aus irgendeinem Grund meine Arrays nicht geleert bekomme.

Diese Annahme wird weiter gestützt durch die Tatsache, dass ich auch bei anderen Proceduren Speicherlecks habe, wo Daten quasi nur von dem MySQL Server geholt und ausgegeben werden...

Nachfolgend die Funktion, die ich für den Datentransfer nutze...

Delphi-Quellcode:

function ExecQuery(const Datenbank, query: string; var Cols: TCols; var Rows: TRows): Boolean;
var
   i: Integer;
   j: Integer;
   Startzeit1, Startzeit2, Endzeit1, Endzeit2 : cardinal;
begin
   // Datenbank auswählen
   ErrorCode := mysql_select_db(_mycon, PChar(Datenbank));
   if ErrorCode = 0 then
   begin
     // Query ausführen
     ErrorCode := mysql_real_query(_mycon, PChar(query), length(query));
     if ErrorCode <> 0 then
     begin
       ShowMessage(mysql_error(_myCon));
       Exit;
     end
     else
     begin
       // Query speichern
       MySQLRes := mysql_store_result(_mycon);
       if Assigned(MySQLRes) then
       begin
         // zurückgelieferte Anzahl der Spalten
         ColCount := mysql_num_fields(MySQLRes);
         SetLength(Cols, ColCount);
         // Spalten-Array füllen
         for i := 0 to ColCount - 1 do
         begin
           Field := mysql_fetch_field_direct(MySQLRes, i);
           Cols[i] := Field.Name;
         end;
         // Anzahl der betroffenen Zeilen ermitteln
         AffectedRows := mysql_affected_rows(_mycon);
         SetLength(Rows, ColCount, AffectedRows);
         // neu ->
         // Zeilen-array füllen
         // alle Zeilen ...
         for j := 0 to AffectedRows - 1 do
         begin
           // ... werden eingelesen
           MySQLRow := mysql_fetch_row(MySQLRes);
           // alle Spalten ...
           for i := 0 to ColCount - 1 do
           begin
             // ... werden in Rows[] übertragen
             Rows[i, j] := MySQLRow[i];

           end;
         end;
         // gespeicherte Abfrage wieder freigeben
         {mysql_free_result(MySQLRes);}
       end
     end
   end;
   result := ErrorCode = 0;
end;

Könnt Ihr mir hlefen?

Danke
Patrick

[alfold]

Zitat von xZise:

Moin,....Ich wäre mir da nicht sicher. Oder habe ich da was übersehen?

MfG
Fabian

Nein hast Du nicht. Aber er verwendet doch das erste array nicht. Sollte also nur der Hinweis sein das er ein Array erstellt und es nicht benutzt. Hatt er selber schon korrigiert

@Ykcim, mach mal nach

Delphi-Quellcode:

Function......
var
   .....
begin
 SetLength(Cols, 0);
 .....
 .....
if Assigned(MySQLRes) then
begin
    // zurückgelieferte Anzahl der Spalten
    ColCount := mysql_num_fields(MySQLRes);
    SetLength(Cols, ColCount);
    SetLength(Rows, ColCount, 0);

Gruss alfold

[Teekeks]

Warum ist den das hier Auskommentiert?

Delphi-Quellcode:

         // gespeicherte Abfrage wieder freigeben
         {mysql_free_result(MySQLRes);} //←Das da

Da wird doch der Speicher wieder freigegeben!

[Ykcim]

Leider keinerlei Veränderungen. Habe es mit dem Taschenrechner bei mehrfacher Wiederholung getstet. Immer das gleiche Muster... seufz

[Luckie]

Zitat von alfold:

Auch wenn Du Dein Programm beendest,(und es sieht so aus das alles Frei gegeben wird), ist der Speicher noch reserviert!

Das ist barer Unsinn. Wo hast du das her? Wenn der Prozess beendet wird, dann wird der Adressbereich des Prozesses komplett wieder frei gegeben und steht anderen Programmen zur Verfügung. Und es spielt keine Rolle, ob du den von dir reservierten Speicher frei gibst oder nicht. Beim beenden räumt Windows hinter dir auf.

Aber nochmal zum Code von Ykcim von der ersten oder zweiten Seite. Wie viele Zeilen hat die Prozedur? Tausend? Da blickt doch kein Schwein mehr durch. Zerleg das ganze mal in kleinere, übersichtliche Prozeduren. Dann siehst du wahrscheinlich auch, wo du unnötig und doppelt Speicher reservierst.

[xZise]

Zitat von Luckie:

[...]Beim beenden räumt Windows hinter dir auf.

Ist das nicht eher so, dass Windows gar nicht mehr weiß, dass in den RAM Zellen Sowieso Werte des Prozesses Soundso stehen

MfG
Fabian