Speichern ist ziemlich langsam

[Jelly]

Hallo,

ich nutze folgenden Code um ein 3-dimensionales Array in ein Matlabfile zu speichern:

Delphi-Quellcode:

    { 3D-Matrix mit Parametern }
    for iz := 0 to G.z-1 do begin
       V_line := format('%s (:,:,%d) = [',[ArrayName,iz+1]) ;
       for ix := 0 to G.x-1 do begin
          for iy := 0 to G.y-1 do with Thread.Cells[ix,iy,iz] do begin
             V_line := V_line + format('%s ',[FloatToStr(C)]) ;
             if (iy = G.y-1) and (ix < G.x-1) then begin
                V_line := V_line + '; ' ;
             end ;
          end ;
       end ;
       V_line := V_line + '] ;' ;
       writeln (FF,V_line) ;
       V_line := '' ;
    end ;

Das klappt auch soweit, nur ist das alles sehr zäh und lahm. G.x, G.y, G.z betragen 100. Es wird also 100^3=1.000.000 mal durchlaufen, was ja im Grunde nicht viel ist für ein 2.5GHz Rechner. Kann es eventuell sein daß FloatToStr extrem langsam ist und sich nach 1000000 mal bemerkbar macht?

[alcaeus]

Hi Tom,

durch FloatToStr wirst du wohl durchmüssen. Die einzige Zeitersparnis erreichst du, wenn du die Daten im Speicher ablegst (z.B. in einem FileStream) und anschließend alles in einem Zug in die Datei schreibst. Inwiefern dies schneller ist, kann ich dir nicht genau sagen.
Ich habe bei einem Filespeicher-Algorithmus jedenfalls festgestellt, dass er am schnellsten läuft, wenn ich 512 Bytes auf einmal schreibe.

Greetz
alcaeus

[Hansa]

Du benutzt G.z mal :

Delphi-Quellcode:

writeln (FF,V_line) ;

Könnte man das nicht auch zuerst mal in ein Array legen und auf einen Schlag wegschreiben ?

[Jelly]

Zitat:

Zitat von Hansa

Könnte man das nicht auch zuerst mal in ein Array legen und auf einen Schlag wegschreiben ?

Können schon, aber nur wenns was bringt. Deshalb frage ich ja. Wenns nachher 3ms bringt, werd ichs wohl belassen :roll:

Aber vielleicht ist ja das Schreiben mittels writeln(FF,V_Line) auch der Grund, und ich tät besser dran, mit FileStreams o.ä. zu arbeiten.

Danke aber schon mal.

[sakura]

FloatToStr ist sehr langsam, das stimmt. Aber Du könntest doch die Werte im nativen Format speichern, oder? Dann würdest Du eine Million Aufrufe zu FloatToStr eingespart.

...:cat:...

[nailor]

aber er will sie doch danach in MatLab reinsaugen. Und ich glaube, es ist besser die Verrenkungen in Delphi zu machen, und MatLab normal einlesen zu lassen, als andersrum.

[choose]

Hallo Jelly,

ich habe Dein Programm mit diesen Daten

Delphi-Quellcode:

const
  GX = 50;
  GY = 50;
  GZ = 50;
  arrayname = 'AnArrayName';
  g:record x,y,z: Integer end = (x:GX; y:GY; z:GZ);

var
  iz, iy, ix: Integer;
  v_line: string;
  Thread: record Cells: array[0..GX-1, 0..GY-1, 0..GZ-1] of record c: double; end; end;
  FF: Textfile;

in AQTime untersucht und mein Verdacht, dass die Stringverarbeitung der limitiernde Faktor ist, hat sich bestätigt. Hier die Ergebnisse:

Code:

Routine Name | % with Children | with Count
-------------+-----------------+------------
Format       |           32,15 |     125050
FloatToStr   |           28,51 |     125000
LStrCat      |           26,81 |     127500

über 85% der Zeit innerhalb der Schleife wird folglich mit der Zusammensetzung verbracht und nur ein geringer Teil des Rests mit dem Schreiben auf den (lokalen) Datenträger.

Suche im Forum einmal nach Beiträgen von Hagen aka negaH zum Thema String-Konkatenation uä, um einen genaueren Überblick über die Thematik zu erlangen.

[Hansa]

Îch würde es testen, um zuerst einmal zu sehen, wie sich das ganze auswirkt. Also 100mal 10.000Byte wegschreiben und 1mal 1.000.000. Das Zeitverhalten des 100mal Schreib-Programmes 8) kannst du dann vergleichen mit deinem. Der Unterschied ist FloatToStr. Anderenfalls bleibt das hier nur Raterei.

Ich habe hier ein Programm, das schreibt 100.000 Datensätze in DB. Lasse ich hierbei nur einen Zähler in einem Memo mitlaufen, so ist es um den Faktor 3 langsamer. Das sind so Effekte, die man nicht unbedingt erwarten würde.

[sakura]

Zitat:

Zitat von nailor

aber er will sie doch danach in MatLab reinsaugen. Und ich glaube, es ist besser die Verrenkungen in Delphi zu machen, und MatLab normal einlesen zu lassen, als andersrum.

Sorry, da war das Tippen-vor-dem-vollständigen-Lesen-Syndrom :oops:

...:cat:...

[Jelly]

Zitat:

Zitat von choose

Code:

Routine Name | % with Children | with Count
-------------+-----------------+------------
Format       |           32,15 |     125050
FloatToStr   |           28,51 |     125000
LStrCat      |           26,81 |     127500

Na das nenn ich doch mal aussagekräftig. Somit sollte doch eigentlich klar sein, warums so lange dauert. Erstaunlich daß so Stringroutinen sich dermaßend gravierend auf das Ergebnis auswirken. Die "Format" Funktion kommt ja auch noch im Code vor, und die wird wohl nicht viel schneller sein. Somit wäre klar, daß nicht das Schreiben das Ganze langsam macht, sondern diese ganzen Stringroutinen... Ist jetzt aber auch nicht weiter gravierend, mir ists nur aufgefallen. Nach 12 Stunden rechnen, kommts dann nachher auch nicht mehr auf 5 Sekunden Speichern an...

Vielen Dank für dir zahlreichen Antworten.

Gruß