Große Dateien einlesen? Alternative zu FileReadLine & FileReadToArray?

MorsGER

Hallo AutoIT-Community,

ich stehe bei einem aktuellen Projekt vor der Aufgabe große (500+ MB / 5Mio+ Zeilen) Dateien (=Datenbank) einzulesen und relevante Daten in einem Array abzuspeichern. Im Vornherein sei also gesagt, dass ich nicht die gesamte Datei im Arbeitsspeicher brauche. Fakt ist, dass meine bisherigen Versuche an verschiedenen Dingen scheiterten. Hauptsächlich aber an der benötigten Zeit.

Meine bisherigen Ansätze waren:

FileReadToArray - Ich habe die gesamte Datei versucht einzulesen um sie dann im Arbeitsspeicher zu untersuchen.
Gescheitert an: Das Skript ist irgendwann abgestürzt. Vermutlich weil AutoIT mit der Datenmenge nicht umgehen konnte. RAM war um ein vielfaches der Dateigröße ausgelastet.
FileRead / FileReadLine - Ich habe die Datei als Handle, und dann zeilenweise eingelesen. Hierbei ging ich schrittweise vor, sodass er ressourcensparend immer nur 1000 Zeilen im RAM hat.
Gescheitert an: Benötigte Zeit (~30 Minuten). Generell ist bei vielen Zeilen FileReadToArray deutlich im Vorteil. Somit ist das Skript super langsam wenn es jede Zeile einzeln einliest.

Mit meinen (zusammengefasst) zwei Ansätzen hatte ich also bisher keinen Erfolg. Mein neuer Ansatz wäre komplett die Dateien in kleine (10MB) Portionen aufzuteilen und einzeln per FileReadToArray einzulesen. Dieser Lösungsweg ist mir aber nicht so lieb, da ich gerne ein übersichtliches Daten-System pflege, ohne hundert von ähnlichen Dateien.

Hat jemand von euch vielleicht ein effektiveren Ansatz parat? Ich bin über jede Hilfe dankbar!

Freundliche Grüße!

**Oscar**

Benutze FileReadLine niemals mit Angabe der Zeilennummer, wenn Du die ganze Datei durchgehen willst! Das dauert ewig.
Stattdessen die Datei zum Lesen öffnen (FileOpen) und dann FileReadLine mit dem Dateihandle (Rückgabe von FileOpen), aber ohne Angabe der Zeilennummer (bei jedem Aufruf von FileReadLine wird dann jeweils nächste Zeile verwendet). Abschließend die Datei wieder schließen (FileClose), sonst bleibt ein Datei-Lock zurück.

**alpines**

Zitat von MorsGER

FileRead / FileReadLine - Ich habe die Datei als Handle, und dann zeilenweise eingelesen. Hierbei ging ich schrittweise vor, sodass er ressourcensparend immer nur 1000 Zeilen im RAM hat.
Gescheitert an: Benötigte Zeit (~30 Minuten). Generell ist bei vielen Zeilen FileReadToArray deutlich im Vorteil. Somit ist das Skript super langsam wenn es jede Zeile einzeln einliest.

Hast du bei FileReadLine das Handle der Datei durch FileOpen genommen oder einfach den Dateipfad? Mit dem Handle sollte das um einiges fixer gehen.

Zitat von MorsGER

Mit meinen (zusammengefasst) zwei Ansätzen hatte ich also bisher keinen Erfolg. Mein neuer Ansatz wäre komplett die Dateien in kleine (10MB) Portionen aufzuteilen und einzeln per FileReadToArray einzulesen. Dieser Lösungsweg ist mir aber nicht so lieb, da ich gerne ein übersichtliches Daten-System pflege, ohne hundert von ähnlichen Dateien.

Wenn du im vorhinein schon auf 10 MB aufteilen kannst ist das okay aber wenn du das im Script machen musst killt dir das dennoch deine Laufzeit oder nicht?

MorsGER

Zitat von Oscar

Benutze FileReadLine niemals mit Angabe der Zeilennummer, wenn Du die ganze Datei durchgehen willst! Das dauert ewig.

Das steht ja so in der Help-File von "FileReadLine". Drum schrieb ich, dass ich die Datei über den FileHandle einlese - war aber wohl etwas unverständlich formuliert.
Aber danke nochmal für den Hinweis.

Zitat von alpines

Hast du bei FileReadLine das Handle der Datei durch FileOpen genommen oder einfach den Dateipfad? Mit dem Handle sollte das um einiges fixer gehen.

Wenn du im vorhinein schon auf 10 MB aufteilen kannst ist das okay aber wenn du das im Script machen musst killt dir das dennoch deine Laufzeit oder nicht?

- Genau. Habe den FileHandle genommen.
- Ja, ich würde die Datei einmalig splitten, sodass zukünftig die "portionierten" Dateien bereitliegen. Während der Laufzeit wäre das tatsächlich sinnlos.

Aber ich danke für euren Beitrag!

**alpines**

Zitat von MorsGER

Genau. Habe den FileHandle genommen.

Dann hast du glaube ich was falsch gemacht. Ich habe mir gerade eine 390MB Textdatei erstellt und mit

AutoIt

$h = FileOpen("test.dat", 0)
ConsoleWrite(FileReadLine($h, 5000) & @CRLF)
FileClose($h)

ausgeben lassen was drinne stand und es hat nicht mal ein Bruchteil einer Sekunde gedauert. Der Text wurde mir direkt angezeigt.

**AspirinJunkie**

Zitat von MorsGER

Das steht ja so in der Help-File von "FileReadLine". Drum schrieb ich, dass ich die Datei über den FileHandle einlese - war aber wohl etwas unverständlich formuliert.

Das mit dem FileHandle ist ja nur ein Trick.
Der andere (noch wichtigere) ist ohne Zeilennummerparameter zu arbeiten.
Das ist die eigentliche Frage auf die Oscar hinaus wollte.

Zeig am besten mal ein kleines Minimalskript wie du die Datei bei dir abarbeitest und dann können wir gemeinsam schauen ob und wo es da noch Flaschenhälse gibt bzw. was man wie verbessern könnte.

MorsGER

Danke für den Hinweis, AspirinJunkie!

Also nochmal zur Aufklärung:

Als ich mich bei diesem Projekt dem FileReadLine zuwendete war mein erster Ansatz (wie ihr alle vermutet) eine Schleife sowie eine Zeilennummer als Parameter:

Code

$File = FileOpen("test.txt")
For $t = 1 To 5000000
 $output = FileReadLine($File, $t)
 ;Sonstiger Code
Next
FileClose($File)

Da dieses Script bei jedem Durchgang aber langsamer wurde (und die Zeilennummer nicht vonnöten ist) änderte ich es zu:

Code

$File = FileOpen("test.txt")
For $t = 1 To 5000000
 $output = FileReadLine($File)
 ;Sonstiger Code
Next
FileClose($File)

Das ist nun natürlich nur ein Beispiel da ich es (ähnlich dem 2. Fall) so umgebaut hatte, dass die Schleife immer nur 1000 Zeilen auf einmal einliest ..

@alpines
Lediglich eine Zeile zu lesen geht natürlich deutlich schneller als 5mio.

**alpines**

Berechne dir mal die Geschwindigkeit mit Timern und lass dir die mal ausgeben, eventuell ist deine HDD in Kombination mit AutoIt einfach zu langsam?
Vielleicht versuchst du mal mehrere Zeilen gleichzeitig einzulesen mit einem Buffer von 2 MB? Dann hast du auch die Zugriffszeiten auf die HDD nicht mehr.

MorsGER

Zitat von alpines

Berechne dir mal die Geschwindigkeit mit Timern und lass dir die mal ausgeben, eventuell ist deine HDD in Kombination mit AutoIt einfach zu langsam?
Vielleicht versuchst du mal mehrere Zeilen gleichzeitig einzulesen mit einem Buffer von 2 MB? Dann hast du auch die Zugriffszeiten auf die HDD nicht mehr.

Die Hinweise in deiner Antwort kann ich nun nicht ganz nachvollziehen.

Dein Beispiel macht meine Festplatte ebenso innerhalb max. 1 Millisekunde, inkl. dem öffnen und schließen des Handles. Ich würde es für unwahrscheinlich halten, dass sich die Lesegeschwindigket von 2 handelsüblichen Festplatten um ein 2-millionenfaches unterscheiden.

Dein Vorschlag des "Buffers" schrieb ich ja bereits in meinem ursprünglichen Beitrag, sowie wies im letzten darauf hin.

Danke trotzdem für deinen Beitrag.

**alpines**

Zitat von MorsGER

Dein Beispiel macht meine Festplatte ebenso innerhalb max. 1 Millisekunde, inkl. dem öffnen und schließen des Handles. Ich würde es für unwahrscheinlich halten, dass sich die Lesegeschwindigket von 2 handelsüblichen Festplatten um ein 2-millionenfaches unterscheiden.

Wie du selber auf meine Antwort geschrieben hast willst du aber Millionen von Zeilen einlesen, also meine ich natürlich nicht das Timen von einer Leseoperation sondern von mehreren Millionen ohne Buffer.

In deinem ursprünglichen Beitrag kann ich nichts zum Buffer finden, du hast versucht das ganze komplett einzulesen was kein Buffer ist (bis auf die 1k Zeilen mit FileReadLine).

Ein Buffer soll dazu dienen das du weniger Leseoperationen auf deine Festplatte anwenden musst, so kannst du z.B. 10 MB lesen und die 10 MB abarbeiten statt eine Zeile zu lesen, abzuarbeiten und dann nochmal zu lesen wo du die Zugriffszeit bzw. Idle-Time der Platte noch draufrechnen musst.

Das sollte man mit FileRead und FileSetPosition glaube ich hinkriegen.

MorsGER

Dann danke ich dir für deine Mühen.
Genau nach "dem Buffer" suche ich. Mein bisheriger Buffer funktioniert so:

Öffne Datei mittels Filehandle.
Lese eine vorgegebene Anzahl an Zeilen aus der Datei (-> 1.). Ohne die Verwendung von Zeilennummer ö.ä.
Verarbeite die bisherigen eingelesenen Daten (Bsp.: 1000 Zeilen)
Gehe wieder zu 2.
Wenn fertig dann Handle schließen.

Die Verwendung von FileSetPosition ist in diesem Fall unnütz, da die Datei genau an der Position weitergelesen wird wo man zuletzt gelesen hat. Somit habe ich deinen vorgeschlagenen Buffer schon umgesetzt, mit dem Ergebnis, dass das Script anstatt mehrerer Stunden nur noch 30 Minuten für die Muster-Datei brauchte.

**alpines**

Oh das ist ja schon mal eine gute Steigerung. Was passiert denn wenn du statt FileReadLine die ungefähre Anzahl an Bytes mit FileRead liest?
Im Startthread steht ja FileRead / FileReadLine, ist da kein Unterschied egal was du verwendest?

**Oscar**

Du schreibst immer von 5000000 Zeilen.
Wie viele Zeichen sind denn pro Zeile vorhanden?
Und ist die Datenbank überhaupt zeilenbasiert (jeder Datensatz mit CRLF abgeschlossen)?
Befinden sich u.U. Nullbytes in den Daten?

Vielleicht kannst Du mal eine Testdatei zur Verfügung stellen? Aber bitte nicht mit 5000000 Zeilen.

MorsGER

Ich danke euch allen schon mal vielmals um eure Hilfe. Ich vermute aber es gibt einfach keine Möglichkeit es noch schneller zu machen.
Die besten Ergebnisse hatte ich nun tatsächlich, wie im ersten Beitrag beschrieben, indem ich die Dateien im Vornherein aufspalte und einzeln in tragbaren Größen per _FileReadToArray einzulesen. Das dauert zwar immer noch ein paar Minuten, aber bei weitem nicht mehr eine halbe Stunde.

Aber falls trotzdem noch jemand eine Lösung parat hat, beantworte ich noch die offenen Fragen:

@alpines - Im Eröffnungsbeitrag sprach ich irrtümlich von "FileRead". Eigentlich meinte ich damit "FileOpen", was wohl auch die Vermutungen in die falsche Richtung gelenkt hat.
Das einlesen der Bytes wäre tatsächlich ein guter Ansatz, den ich mal noch überprüfen werde.

@Oscar - Es sind exakt 52 (inkl. CR & LF) Zeichen pro Zeile vorhanden.
Ja, die Datenbank ist Zeilenbasiert. Pro Zeile steht ein Wert mit 50 Zeichen + CRLF.
Letzteres dürfte eigentlich nicht der Fall sein.

Ich danke euch nochmals für eure Zeit und Bemühungen und werde das hier als erledigt markieren.
Eine schöne Winterzeit wünsche ich euch!

**BugFix**

Ich habe mal getestet, Datei erstellt mit 5 Mio Einträgen und 50 Zeichen je Zeile.
Erstellen dauert ~2 min, Einlesen in Array etwas mehr als 1 min. Ist doch ganz passabel.

AutoIt

$sFile = 'c:\temp\5mio.txt'
;~ _5_MioLineFile($sFile)   ; Laufzeit 138 s


Func _5_MioLineFile($_sPath)
	Local $sWrite = ''
	For $i = 1 To 5000000
		$sWrite &= StringFormat('%07i ==========================================%s', $i, @CRLF)
	Next
	FileWrite($_sPath, $sWrite)
EndFunc


$t = TimerInit()
$aRet = _5_MioLineToArray($sFile)
ConsoleWrite('Time: ' & TimerDiff($t) & @CRLF) ; ==> Time: 75888.0056925964 ms


Func _5_MioLineToArray($_sPath)
	Local $aLines[10*1000000], $iIndex = 0 ; max. 10 Mio Einträge
	Local $hFile = FileOpen($_sPath)
	While True
		$aLines[$iIndex] = FileReadLine($hFile)
		If @error Then ExitLoop
		$iIndex += 1
	WEnd
	FileClose($hFile)
	ReDim $aLines[$iIndex]
	Return $aLines
EndFunc

Alles anzeigen

**Oscar**

Bei nur 52 Zeichen je Zeile mal 5 Millionen Zeilen sind das 260 Millionen Zeichen insgesamt.
Ich habe mir mal so eine Datei erstellt:

AutoIt

Global $sFilename = @ScriptDir & '\!bigdata.txt'
Global $sData = ''
For $i = 1 To 5000000
	For $j = 1 To 50
		$sData &= Chr(Random(65, 90, 1))
	Next
	$sData &= @CRLF
	If Not Mod($i, 1000) Then ToolTip($i)
Next
$hFile = FileOpen($sFilename, 2)
FileWrite($hFile, $sData)
FileClose($hFile)

Alles anzeigen

und diese mit Filehandle geöffnet und mit 5 Millionen mal FileReadLine eingelesen:

AutoIt

$sFilename = @ScriptDir & '\!bigdata.txt'
$iTimer = TimerInit()
$hFile = FileOpen($sFilename)
For $i = 1 To 5000000
	$sData = FileReadLine($hFile)
	If Not Mod($i, 1000) Then ToolTip($i)
Next
FileClose($hFile)
ConsoleWrite(TimerDiff($iTimer) & @CR)

Das Ganze dauert bei mir etwas über 10 Sekunden (von Festplatte, nicht SSD).
Entweder machst Du etwas ganz anders oder Dein Rechner ist aus der Steinzeit.

**alpines**

Zitat von Oscar

Entweder machst Du etwas ganz anders oder Dein Rechner ist aus der Steinzeit.

Er hat bisher keinen Code rausgegeben, wundert mich ehrlich gesagt schon etwas.

misterspeed

Zitat von Oscar

Das Ganze dauert bei mir etwas über 10 Sekunden (von Festplatte, nicht SSD).

Nach mehreren Tests denke ich, dass die Ergebnisse evtl. nicht ganz korrekt sind. Mein erster Durchlauf benötigte trotz SSD und flotter i7 CPU ca. 20 Sekunden, bei weiteren Durchläufen 10 und nach ca. 5 Durchläufen nur noch 5 Sekunden. Ich gehe davon aus, dass sowohl Caching innerhalb des Datenträgers als auch Caching durch Windows nach kurzer Zeit eine Verfälschung der Messwerte verursachen.

Dennoch... selbst 20 Sekunden sind absolut hinnehmbar bei dieser Datenmenge.

Vermutlich entsteht der Performance Engpass beim Threadersteller erst innerhalb der Schleife bei der Weiterverarbeitung der Daten. Ich könnte mir zum Beispiel vorstellen, dass je nach Zeileninhalt ein Listview befüllt wird. Aus Erfahrung mit eigenen Projekten sei der Tipp erwähnt, dass es bei Listview Befüllung wichtig ist das Neuzeichnen der GUI für die Zeit des Updates mit _GUICtrlListView_BeginUpdate bzw. _GUICtrlListView_EndUpdate zu pausieren.

**Andy**

Hi,

das Lesen großer Dateien massiv zu beschleunigen hatten wir HIER schon einmal...AspirinJunkie hat da eine wirklich klasse Funktion erstellt! (siehe Anhang Script)
Diese Funktion hat genau wie alle Fileread-Funktionen bei sehr großen Dateien den Nachteil, dass AutoIt mit einem Speicherfehler abstürzt....

Sehr große Dateien liest man blockweise per SetFilePointer aus. Zu beachten ist, dass die Datei schon per WIN_API-Funktion zu öffnen und weiterzubearbeiten ist.
Datei öffnen, SetFilePointer, Datenblöcke auslesen, so stellt sich das dar.
Die 520MB große Beispieldatei (auskommentierte Zeilen ausführen und Kaffee trinken gehen) wird erstellt, jede Zeile besteht aus 50 Stellen, wobei die Zeilennummer rechts ausgerichtet ist (einfach mal in Scite öffnen)
Das eigentliche Lesen der Datei in Blöcken dauert bei mir nur ca.5 Sekunden (Laptop). In der Console werden jeweils die ersten und letzten beiden Zeilen eines jeden Blocks angezeigt.

AutoIt

#include <WinAPI.au3>


Global $kerneldll = DllOpen("kernel32.dll")


Global $sFilename = @ScriptDir & '\!bigdata.txt'
;~ Global $sData = ''
;~ For $j = 1 To 10000000
;~     $sData &= StringFormat("%050s", $j) & @CRLF
;~     If Mod($j, 50000) = 0 Then ToolTip($j)
;~ Next
;~ $hfile = FileOpen($sFilename, 2)
;~ FileWrite($hfile, $sData)
;~ FileClose($hfile)




$t = TimerInit()
$filesize = FileGetSize($sFilename)
$Zeilen = $filesize / 52
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $Zeilen = ' & $Zeilen & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


$hfile = _WinAPI_CreateFile($sFilename, 2, 2)
$blocksize = 5200000                                                             ;gleich große Blöcke                                          ;50MB
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $blocksize = ' & $blocksize & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


$nbytes = 0
Local $blockstruct = DllStructCreate("char[" & $blocksize & "]")




For $i = 0 To $filesize Step $blocksize
    FileSetPos($hfile, $i, $FILE_BEGIN)
    DllCall($kerneldll, "bool", "SetFilePointer", "handle", $hfile, "long", $i, "long", 0, "dword", $FILE_BEGIN)
    _WinAPI_ReadFileXXX($hfile, DllStructGetPtr($blockstruct), $blocksize, $nbytes)
;~     ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $nbytes = ' & $nbytes & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    $a = DllStructGetData($blockstruct, 1)
    $left = StringLeft($a, 104)
    ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $left = ' & $left & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    $right = StringRight($a, 104)
    ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $right = ' & $right & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
Next                                                                             ;ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $a = ' & $a & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


ConsoleWrite(StringFormat("%i MB Datei geladen in %f ms", Int($filesize / 1000000), Int(1000 * TimerDiff($t)) / 1000) & @CRLF & @CRLF)

Alles anzeigen

Hier nochmal AspirinJunkie´s Funktion für "kleine" Dateien (bis ca. 300MB)
CSV Datei Zeilen zählen - extrem schnell - GNUWin32

@Oscar, wenn ich deine Scripte aus Post #16 ausführe, dann dauert das bei mir (Laptop mit SSD) länger als eine Minute...könnte es sein, dass bei dir irgendwelche Caching-Geschichten mitspielen? Ich hatte schon damals (s. Thread bzgl. AspirinJunkie´s Funktion) festgestellt, dass es große Unterschiede beim Dateilesen gibt, wenn Windows bestimmte Dateien cached! //EDIT hast das ja auch gepostet, ich war zu langsam...

**Oscar**

Ich habe den Test mit meinem Script von oben (Post#16) nochmal auf neu gestarteten Rechner gemacht.
Aber mit gleichem Ergebnis: 10.8 sek.
Bei mir zeigt sich auch kein Caching-Effekt bei mehreren Aufrufen hintereinander.