CSV Datei Zeilen zählen - extrem schnell - GNUWin32

Blaxxun

Hallo Forum,

da ich nun schon seit 2 Tagen nach einer schnellen Lösung suchte um große CSV Dateien auszulesen bin ich im Entwicklerforum auf ein kurzes Skript gestoßen welches bei mir allerdings nicht funtionierte.
Ich habe es deshalb etwas umgeschrieben und dachte daß es vielleicht mal jemand für nützlich erachten könnte.

Ich habe hier eine CSV Datei mit 1,8 Millionen Zeilen in 165 ms ausgelesen (Anzahl der Zeilen ermittelt). Das CSV File ist 80Mb groß.
Man benötigt dafür GNUWin32 installiert und daraus den wc und cut Befehl (ist in den CoreUtils).

AutoIt

#include <Timers.au3>
Local $GNU = "C:\Program Files (x86)\GnuWin32\bin"
Local $ReadFile = @MyDocumentsDir&"\CSV\Readme.csv"
Local $SaveFile = @MyDocumentsDir&"\CSV\Count.txt"
Local $starttime = _Timer_Init()
RunWait(@ComSpec & ' /c wc -l '&$ReadFile&' | cut -d " " -f 1 > '&$SaveFile, $GNU, @SW_HIDE)
ConsoleWrite(@CRLF & "Datei Groesse(MB) : " & Round((FileGetSize($ReadFile) / 1048576), 2))
ConsoleWrite(@CRLF & "Zeilen            : " & FileReadLine($SaveFile))
ConsoleWrite(@CRLF & "Dauer (ms)        : " & Round(_Timer_Diff($starttime), 2) & @CRLF)

Weis nicht ob das hier schon mal besprochen wurde....

**Mars**

Ich habe jetzt leider keine so große Datei am start und kann diese Methode nicht ausprobieren.
In der File.au3 gibts die (mit RegEx arbeitende) Funktion _FileCountLines. Die könntest du ebenfalls ausprobieren. Bei der Geschwindigkeit bin ich nicht sicher (die Funktion habe ich noch nie für große Dateien genutzt), aber sie funktioniert ohne GNU.

lg
M

Yaerox

Zitat von Blaxxun

da ich nun schon seit 2 Tagen nach einer schnellen Lösung suchte um große CSV Dateien auszulesen bin ich im Entwicklerforum auf ein kurzes Skript gestoßen welches bei mir allerdings nicht funtionierte.

Kannst du vll. noch ergänzend die Variationen aufzeigen die du ausprobiert hast und ggf. die Ergebnisse? Mich würden die Unterschiede und die angewandten Methoden der Auswertung interessieren.

Runa

Meine AutoIt-Version, die nicht die Installation eines weiteren Programmes erfordert (als Vergleich)

AutoIt

#include <Timers.au3>


Local $ReadFile = @ScriptDir & "\Text.csv"
Local $starttime = _Timer_Init()


$sFile  = 'set file="' & $ReadFile & '"' & @CRLF
$sFile &= 'set /a cnt=0' & @CRLF
$sFile &= 'for /f %%a in (''type "%file%"^|find "" /v /c'') do set /a cnt=%%a' & @CRLF
$sFile &= 'EXIT /B %cnt%'


FileWrite(@ScriptDir & "\Count.bat", $sFile)
$iLines = RunWait(@ScriptDir & "\Count.bat")
FileDelete(@ScriptDir & "\Count.bat")




ConsoleWrite(@CRLF & "Datei Groesse(MB) : " & Round((FileGetSize($ReadFile) / 1048576), 2))
ConsoleWrite(@CRLF & "Zeilen            : " & $iLines)
ConsoleWrite(@CRLF & "Dauer (sec)       : " & Round(_Timer_Diff($starttime)/1000, 2) & @CRLF)

Alles anzeigen

Datei Groesse(MB) : 68.66
Zeilen : 2000000
Dauer (sec) : 1.82

**AspirinJunkie**

Für reines AutoIt sollte folgendes flotter sein:

AutoIt

$iT = TimerInit()
StringReplace(FileRead($s_FilePath), @CRLF, @CRLF, 0, 1)
$d_Lines = @extended
ConsoleWrite(StringFormat("\n%s:\n\tZeilen: %d\n\tDauer:%4.1f s\n", "StringReplace", $d_Lines, TimerDiff($iT) / 1000))

Runa

Danke AspirinJunkie. Hab das mal getestet:

AutoIt

Local $ReadFile = @ScriptDir & "\Text.csv"
$sFile  = 'set file="' & $ReadFile & '"' & @CRLF
$sFile &= 'set /a cnt=0' & @CRLF
$sFile &= 'for /f %%a in (''type "%file%"^|find "" /v /c'') do set /a cnt=%%a' & @CRLF
$sFile &= 'EXIT /B %cnt%'
$iRuns = 1000
ConsoleWrite(@CRLF & "Test mit " & $iRuns & " Durchläufen...")
$iTotalTime = 0
$iMin = 1000
$iMax = 0
For $i = 1 To $iRuns
	$iT = TimerInit()
	FileWrite(@ScriptDir & "\Count.bat", $sFile)
	$iLines = RunWait(@ScriptDir & "\Count.bat", "", @SW_HIDE)
	$iTime = TimerDiff($iT) / 1000
	FileDelete(@ScriptDir & "\Count.bat")
	$iTotalTime += $iTime
	If $iTime < $iMin Then $iMin = $iTime
	If $iTime > $iMax Then $iMax = $iTime
Next
ConsoleWrite(@CRLF & "1: Gesamtdauer im Schnitt (sec): " & Round($iTotalTime/$iRuns, 2))
ConsoleWrite(@CRLF & "1: MIN                         : " & Round($iMin, 2))
ConsoleWrite(@CRLF & "1: MAX                         : " & Round($iMax, 2))
$iTotalTime = 0
$iMin = 1000
$iMax = 0
For $i = 1 To $iRuns
	$iT = TimerInit()
	StringReplace(FileRead($ReadFile), @LF, @LF, 0, 1)
	$iTime = TimerDiff($iT) / 1000
	$d_Lines = @extended
	$iTotalTime += $iTime
	If $iTime < $iMin Then $iMin = $iTime
	If $iTime > $iMax Then $iMax = $iTime
Next
ConsoleWrite(@CRLF & "2: Gesamtdauer im Schnitt (sec): " & Round($iTotalTime/$iRuns, 2))
ConsoleWrite(@CRLF & "2: MIN                         : " & Round($iMin, 2))
ConsoleWrite(@CRLF & "2: MAX                         : " & Round($iMax, 2))

Alles anzeigen

Output hier:

Spoiler anzeigen

Test mit 1000 Durchläufen...
1: Gesamtdauer im Schnitt (sec): 1.78
1: MIN : 1.75

1: MAX : 1.83
2: Gesamtdauer im Schnitt (sec): 1.73
2: MIN : 1.65
2: MAX : 2.69

Ich frage mich, warum die StringReplace-Variante so extreme "Ausbrüche" hat im Vergleich Fühlbar ist da aber im Dauertest kaum ein Unterschied. Vielleicht nur wegen den Ausbrechern hier auf dem System. Werde das mal nachher auf meiner Workstation laufen lassen. Eventuell macht das einiges klarer.

**UEZ**

Es gibt auch die Built-in Funktion,

AutoIt

#include <File.au3>
_FileCountLines()

die ähnlich der AspirinJunkie's Version ist.

Hier eine ASM Version:

AutoIt

#include <File.au3>
$sTestFile = @ScriptDir & "\Test.csv"
$fTimer = TimerInit()
ConsoleWrite(_FileCountLines($sTestFile) & " / " & TimerDiff($fTimer) & @CRLF)


$fTimer = TimerInit()
$hFile = FileOpen($sTestFile)
$iLines = _ASM_StringLFCharCount_Bin(FileRead($hFile))
FileClose($hFile)
ConsoleWrite($iLines & " / " & TimerDiff($fTimer) & @CRLF)




Func _ASM_StringLFCharCount_Bin($sString)
	Local $tCodeBuffer = DllStructCreate("byte ASM[27]") ;reserve memory for ASM opcode
	$tCodeBuffer.ASM = "0x8B7424048B7C240831DBAC3C0074093C0A75F783C301EBF2891FC3" ;write opcodes into memory (struct) / length: 27
	Local $tResult = DllStructCreate("dword AmountLF")
	DllCall("user32.dll", "none", "CallWindowProcW", "ptr", DllStructGetPtr($tCodeBuffer), "str", $sString, "ptr", DllStructGetPtr($tResult), "int", 0, "int", 0)
	Return $tResult.AmountLF
EndFunc

Alles anzeigen

Benötigt für eine 230 mb große CSV Datei ca. 7600 ms, um die Zeilen zu zählen. Built-in ca. 8500 ms. -> kein richtiger Gewinn. Ich frage mich, wie die GNU Variante auf 165 ms kommt!

**AspirinJunkie**

Zitat von Bioshade

Ich frage mich, warum die StringReplace-Variante so extreme "Ausbrüche" hat im Vergleich

Nur anhand von Minmum und Maximum-Wert kann man das schlecht beurteilen.
Möglich wäre, dass die Festplatte während eines Durchlaufes gerade ausgelastet war und deshalb dort das Laden der Datei mal länger dauerte.
Ob es sich um einen einzelnen Ausreißer handelt (der nicht repräsentativ das Verhalten abbildet) oder systematisch die Schwankung deutlich höher ist, kann man eher entscheiden wenn man sich die Standardabweichung dazu nimmt:

AutoIt

Global Const $i_Runs = 50
Global Const $s_FilePath = "C:\Test.csv"


ConsoleWrite("-------- Test mit " & $i_Runs & " Durchläufen -------------" & @CRLF & @CRLF)


Global $Sum = 0, $QuSum = 0, $min = 1e15, $max = 0
For $i = 1 To $i_Runs
	$iT = TimerInit()
	$sFile = 'set file="' & $s_FilePath & '"' & @CRLF & _
			'set /a cnt=0' & @CRLF & _
			'for /f %%a in (''type "%file%"^|find "" /v /c'') do set /a cnt=%%a' & @CRLF & _
			'EXIT /B %cnt%'
	FileWrite(@ScriptDir & "\Count.bat", $sFile)
	$iLines = RunWait(@ScriptDir & "\Count.bat", "", @SW_HIDE)
	FileDelete(@ScriptDir & "\Count.bat")
	$iT = TimerDiff($iT)


	$Sum += $iT / 1000
	$QuSum += ($iT / 1000) * ($iT / 1000)
	If $iT < $min Then $min = $iT
	If $iT > $max Then $max = $iT
Next
$f_StdDev = Sqrt(($QuSum - ($Sum ^ 2) / $i_Runs) / ($i_Runs - 1))
ConsoleWrite(StringFormat("Methode           : %s\nmittlere Dauer    : % 5.2f ms\nStandardabweichung: % 5.3f ms\nMinimum           : % 5.2f ms\nMaximum           : %5.2f ms\n\n", _
		"Batch-File", $Sum / $i_Runs, $f_StdDev, $min / 1000, $max / 1000))


Global $Sum = 0, $QuSum = 0, $min = 1e15, $max = 0
For $i = 1 To $i_Runs
	$iT = TimerInit()
	StringReplace(FileRead($s_FilePath), @LF, @LF, 0, 1)
	$d_Lines = @extended
	$iT = TimerDiff($iT)


	$Sum += $iT / 1000
	$QuSum += ($iT / 1000) * ($iT / 1000)
	If $iT < $min Then $min = $iT
	If $iT > $max Then $max = $iT
Next
$f_StdDev = Sqrt(($QuSum - ($Sum ^ 2) / $i_Runs) / ($i_Runs - 1))
ConsoleWrite(StringFormat("Methode           : %s\nmittlere Dauer    : % 5.2f ms\nStandardabweichung: % 5.3f ms\nMinimum           : % 5.2f ms\nMaximum           : %5.2f ms\n\n", _
		"StringReplace", $Sum / $i_Runs, $f_StdDev, $min / 1000, $max / 1000))

Alles anzeigen

Hier mal ein Ergebnis bei mir für eine 100mb Datei mit 2.000.000 Zeilen:

Code

-------- Test mit 5 Durchläufen -------------


Methode           : Batch-File
mittlere Dauer    :  2.44 ms
Standardabweichung:  0.042 ms
Minimum           :  2.39 ms
Maximum           :  2.50 ms


Methode           : StringReplace
mittlere Dauer    :  1.84 ms
Standardabweichung:  0.017 ms
Minimum           :  1.81 ms
Maximum           :  1.85 ms

Alles anzeigen

In diesem Beispiel zeigt sich dann, dass die StringReplace-Variante bei diesem Durchlauf weniger stark schwankt als die Batch-Variante.

Zitat von UEZ

Es gibt auch die Built-in Funktion,

Die zwar etwas langsamer ist aber dafür ein paar Sonderfälle mit abdeckt - für den Produktivbetrieb somit die bessere Funktion.

**Andy**

Zitat von UEZ

Benötigt für eine 230 mb große CSV Datei ca. 7600 ms, um die Zeilen zu zählen. Built-in ca. 8500 ms. -> kein richtiger Gewinn.

Naja, profilen hilft^^, und zwar vorher....
Wenn Fileread() etwa 90% der Zeit braucht, nützt es dir nichts bei den verbleibenden 10% in Beschleunigung zu investieren!
Dateien werden idR. nicht "am Stück", sondern in Blöcken zu einigen Bytes Größe eingelesen.
Das AutoIt-native FileRead() arbeitet höchstwahrscheinlich mit Blockgrößen von 2KB oder 4KB. Woher ich das weiß? Weil ich es ausprobiert und verglichen habe.
Bei kleinen Dateien ist das egal, aber wenn bei großen Dateien Blocks von 64kb gelesen werden, dann beschleunigt sich das Lesen der gesamten Datei in den Speicher um Faktor 3 bis 4.
Jedenfalls bei meinem Laptop (mit SSD), ihr könnt die Blockgrößen im anliegenden Script gerne variieren.

Habe mal die Vorgaben von ca. 96MB Dateigröße mit ca. 2Mio Zeilen umgesetzt und bei mir ist eine Blockgröße von 32 bis 64KB optimal...

Das Suchen von @LF habe ich (wen wundert´s) in Assembler umgesetzt.
Dazu habe ich ein XMM-Register als 16x 1 Byte(Char) verwendet, dort das Linefeed maskiert und die "Treffer" in ein 16-bit-Register geschrieben. Die Anzahl der gesetzten Bits in diesem Register ist die Anzahl der Linefeed innerhalb der 16 Bytes. Über die verschiedenen "popcount"-Methoden (Zählen von gesetzten Bits innerhalb eines Registers) wurden schon Bücher geschrieben. Div. Methoden hier
Ich habe, weil ich nur die Handvoll 32-Bit-Register verwenden wollte, eine 16 byte große LookUpTable (LUT) auf dem Stack erstellt und per XLATB-Befehl die Anzahl der gesetzten Bits (nibble von 4 Bits Größe, also nur die untere Hälfte vom AL-Register) ausgelesen. Alle diese ausgelesenen Anzahlen ergeben summiert die Gesamtzahl der LineFeeds im String.
Geht sicherlich noch schneller, @AspirinJunkie könnte ja mal den ( neuen? ) Intel-Compiler anwerfen . Muster siehe HIER. Habe echt keine Ahnung inwieweit der compilierte Code schneller ist als mein ASM-Pendant, würde mich aber absolut nicht wundern, habe ja auch eine komplett andere Methode angewandt.
Letztendlich ist es auch schnurz, ob die Anzahl der Linefeeds (oder auch anderer Zeichen) eine Handvoll Millisekunden schneller oder langsamer ist, wenn allein das Lesen des Dateiinhaltes schon 90% der Laufzeit ausmacht...
Alleine das "kopieren" des Strings in eine Variable dauert sehr lange, also $data=dllstructgetdata(blablub). Da man das für die vorliegende Problemstellung aber garnicht braucht, lässt man es weg...

Zusammenfassung:
Bei großen Dateien ist das AutoIt-FileRead() SEHR langsam, schneller ist die gezeigte Methode über _WinAPI_FileRead() mit einer auf das eigene System angepasster Blockgröße.
Benötigt man den Dateiinhalt nicht in Form einer Variable, ist es sinnvoller/schneller, direkt mit den Daten im Speicher (struct) zu arbeiten.

Auf meinem Laptop AMD A6-3400M APU with Radeon(tm) HD Graphics @2,3Ghz (Samsung SSD):
Vergleich Datei laden und die LF zählen:
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 65536 bytes time: 214 ms

AutoIt: Read 96MB File time: 5374 ms OHNE zählen der LF....wobei man fairerweise zugeben muss, daß natürlich die Rückgabe des Dateiinhaltes in einer Variable enthalten ist.

//EDIT
Speicherleck entfernt...

AutoIt

#include <WinAPI.au3>
#include <Memory.au3>
#include <MemoryConstants.au3>
#include <APIFilesConstants.au3>
;~ #include "assembleit2_64.au3"




#cs _crlf
    use32                            ;32 bit


    mov edi,[esp+4]                  ;adresse string
    mov ecx,[esp+8]                  ;anzahl zeichen


    mov edx,[esp+12]                 ;ein byte zeichen in alle bytes von edx
    mov dh,dl                        ;0x00000A0A
    shl edx,8                        ;0x000A0A00
    mov dl,dh                        ;0x000A0A0A
    shl edx,8                        ;0x0A0A0A00
    mov dl,dh                        ;0x0A0A0A0A
    movd xmm0,edx
    pshufd xmm0, xmm0, 0x00          ;maske LF, in allen 16 bytes steht das zeichen


    push ebp                         ;sichern
    sub esp,16                       ;platz für die LUT vom stack reservieren
    mov ebx,esp                      ;ebx  = startadresse der LUT, für XLATB


    mov dword[ebx],0x02010100        ;16 bytes LUT füllen, little endian... ;-)
    mov dword[ebx+4],0x03020201
    mov dword[ebx+8],0x03020201
    mov dword[ebx+12],0x04030302


    xor esi,esi                      ;zähler bytes
    xor ebp,ebp                      ;anzahl treffer


    _loop:


    movdqa xmm1,xmm0                 ;maske sichern
    PCMPEQB xmm1,[edi+esi]           ;16 bytes nach zeichen durchsuchen
    PMOVMSKB edx,xmm1                ;treffer -> bit =1 in dh/dl


    test edx,edx                     ;null?
    jz _weiter                       ;nur berechnen, wenn mindestens ein Bit gesetzt ist


    mov eax,edx                      ;erstes byte
    and eax,0xF                      ;erste 4 bit sind der index für die LUT
    XLATB                            ;al=LUT[al]  summe gesetzter bits
    add ebp,eax                      ;treffer zusammenzählen


    shr edx,4                        ;nächstes nibble
    mov eax,edx                      ;erstes byte
    and eax,0xF                      ;erste 4 bit
    XLATB                            ;al=LUT[al]  summe
    add ebp,eax                      ;treffer zusammenzählen


    shr edx,4                        ;nächstes nibble
    mov eax,edx                      ;erstes byte
    and eax,0xF                      ;erste 4 bit
    XLATB                            ;al=LUT[al]  summe
    add ebp,eax                      ;treffer zusammenzählen


    shr edx,4                        ;nächstes nibble
    mov eax,edx                      ;erstes byte
    and eax,0xF                      ;erste 4 bit
    XLATB                            ;al=LUT[al]  summe
    add ebp,eax                      ;treffer zusammenzählen


    ;~  _asmdbg_()
    _weiter:


    add esi,16                       ;nächste 16 bytes
    cmp esi,ecx                      ;ende erreicht?
    jbe _loop                        ;nein, weiter


    mov eax,ebp                      ;rückgabe=summe aller treffer
    add esp,16                       ;stack wiederherstellen
    pop ebp                          ;restaurieren!


    ret


#ce




Global $kerneldll = DllOpen("kernel32.dll") ;falls jemand die winapi-Funktion ausprobieren will, der zugriff über den handle ist schneller als über den dateinamen




;Erstellen einer Datei von 96MB und ca 2 Mio Zeilen


$a = ""
For $i = 1 To 44
    $a = $a & Chr($i + 40)           ;String erstellen )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST
Next
$a = $a & @CRLF                      ;zeilenende anhängen


For $i = 1 To 21                     ;auf 96MB aufpumpen
    $a &= $a
Next
$a &= "ENDE"
$b = StringReplace($a, @CRLF, @CRLF, 0, 1) ;crlf zählen
$anzahl_CRLF = @extended             ;anzahl der crlf
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $anzahl_CRLF = ' & $anzahl_CRLF & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
$stringlen = StringLen($a)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $stringlen = ' & $stringlen & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console






$filename = @ScriptDir & "\testdatei_96MB.txt" ;in Datei abspeichern
FileDelete($filename)
FileWrite($filename, $a)




Global $filestructptr


;~ $asmcode = _AssembleIt2("retbinary", "_crlf") ;erstellt den asmcode
;~ ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $asmcode = ' & $asmcode & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


$asmcode = "0x8B7C24048B4C24088B54240C88D6C1E20888F2C1E20888F2660F6EC2660F70C0005583EC1089E3C70300010102C7430401020203C7430801020203C7430C0203030431F631ED660F6FC8660F740C37660FD7D185D2742989D083E00FD701C5C1EA0489D083E00FD701C5C1EA0489D083E00FD701C5C1EA0489D083E00FD701C583C61039CE76BF89E883C4105DC3"
Global $codestruct = DllStructCreate("byte[" & StringLen($asmcode) / 2 - 1 & "]") ;speicher für asmcode...
DllStructSetData($codestruct, 1, $asmcode) ;...mit code füllen


ConsoleWrite("....bitte warten!" & @CRLF)


;20 blockgrößen von 4KB bis 80KB, jedes mal wird die 96MB-datei 10x gelesen


For $r = 1 To 7
    Local $nbytes
    Local $blocksize = 1024 * $r^3
    Local $filesize = FileGetSize($filename);dateigröße
    Local $filestruct = dllstructcreate("char[" & $filesize + $blocksize + 16 & "]") ;16-byte aligned , die Funktion dazu ist in AssembleIt64() enthalten, dann hier im script löschen
    Local $filestructptr = DllStructGetPtr($filestruct);pointer auf die struct,


    Local $blocks = Ceiling($filesize / $blocksize);anzahl der zu lesenden blöcke


    $av = 0                          ;durchschnitt


    For $p = 1 To 10                 ;für jede blockgröße 10 die datei lesen


        $t = TimerInit()


;~ $data=fileread($filename)  ;grausam langsam....


        Local $hfile = _WinAPI_CreateFile($filename, 2, 2) ;mit der richtigen blockgröße 3-4x schneller
        For $i = 0 To $blocks - 1
            Local $blockstruct = DllStructCreate("char[" & $blocksize & "]", $filestructptr + $i * $blocksize)
            _WinAPI_ReadFileXXX($hfile, DllStructGetPtr($blockstruct), $blocksize, $nbytes) ;tick schneller durch handle statt datei
        Next
        _WinAPI_CloseHandle($hfile)


        ;falls man den string nicht braucht....
        ;*************UNBEDINGT DIE FOLGENDEN ZEILEN AUSKLAMMERN***************
;~         $data = DllStructGetData($filestruct, 1) ;direkt auf die struct im speicher zugreifen, DAS dauert, speicherschieben ist nicht die stärke von AutoIt
;~         $len=stringlen($data)




;~  $tt = TimerInit()
;~ $ret=_ASM_StringLFCharCount_Bin($data)  ;by uEZ
;~ ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $ret = ' & $ret & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
;~  $mm = TimerDiff($tt)
;~  ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $mm = ' & $mm & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


        ;Linefeeds 0x0A zählen
;~         $tt = TimerInit()
        Local $ret = DllCallAddress("uint:cdecl", DllStructGetPtr($codestruct), "ptr", $filestructptr, "uint", $filesize, "dword", 0x0A)
        $nr_lf = $ret[0]
;~         $mm = TimerDiff($tt)
;~         ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $mm = ' & $mm & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console




;~         $tt = TimerInit()
;~         $nr_lf = _AssembleIt2("uint", "_crlf", "ptr", $filestructptr, "uint", $filesize, "dword", 0x0A)
;~         ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $nr_lf = ' & $nr_lf & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Consol
;~         $mm = TimerDiff($tt)
;~         ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $mm = ' & $mm & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console




        $m = TimerDiff($t)
        $av = $av + $m


    Next


    $av = $av / $p                   ;durchschnittliche zeit errechnen
    ConsoleWrite("WinAPI:   Read " & Int($filesize / 1e6) & "MB File    #Lines: " & $nr_lf & "   Blocksize: " & $blocksize & " bytes    time: " & Int($av) & " ms  " & @CRLF)


Next


;AutoIt zum Vergleich
$t = TimerInit()
$data = FileRead($filename)
$av = TimerDiff($t)
$filesize = StringLen($data)
ConsoleWrite(@CRLF & "Autoit:   Read " & Int($filesize / 1e6) & "MB File   time: " & Int($av) & " ms  " & @CRLF & @CRLF)










Func _ASM_StringLFCharCount_Bin($sString) ; by UEZ
    Local $tCodeBuffer = DllStructCreate("byte ASM[27]") ;reserve memory for ASM opcode
    $tCodeBuffer.ASM = "0x8B7424048B7C240831DBAC3C0074093C0A75F783C301EBF2891FC3" ;write opcodes into memory (struct) / length: 27
    Local $tResult = DllStructCreate("dword AmountLF")
    DllCall("user32.dll", "none", "CallWindowProcW", "ptr", DllStructGetPtr($tCodeBuffer), "str", $sString, "ptr", DllStructGetPtr($tResult), "int", 0, "int", 0)
    Return $tResult.AmountLF
EndFunc                              ;==>_ASM_StringLFCharCount_Bin




Func _TextFileRead($filename)


    Local $nbytes
    Local $blocksize = 4096 * 16
    Local $filesize = FileGetSize($filename)
    Local $filestruct = DllStructCreate("char[" & $filesize + $blocksize & "]")
    Local $filestructptr = DllStructGetPtr($filestruct)


    Local $blocks = Ceiling($filesize / $blocksize)


    Local $hfile = _WinAPI_CreateFile($filename, 2, 2)


    For $i = 0 To $blocks - 1
        Local $blockstruct = DllStructCreate("char[" & $blocksize & "]", $filestructptr + $i * $blocksize)
        _WinAPI_ReadFileXXX($hfile, DllStructGetPtr($blockstruct), $blocksize, $nbytes)


    Next


    Return DllStructGetData($filestruct, 1)


EndFunc                              ;==>_TextFileRead




Func _WinAPI_ReadFileXXX($hfile, $pBuffer, $iToRead, ByRef $iRead, $pOverlapped = 0)
    Local $aResult = DllCall($kerneldll, "bool", "ReadFile", "handle", $hfile, "ptr", $pBuffer, "dword", $iToRead, _
            "dword*", 0, "ptr", $pOverlapped)
    If @error Then Return SetError(@error, @extended, False)


    $iRead = $aResult[4]
    Return $aResult[0]
EndFunc                              ;==>_WinAPI_ReadFileXXX

Alles anzeigen

**UEZ**

Zitat von Andy

Wenn Fileread() etwa 90% der Zeit braucht, nützt es dir nichts bei den verbleibenden 10% in Beschleunigung zu investieren!

Ich meine mich erinnern zu können, dass das Lesen kein Ding war, eher das Suchen nach @LF. Aber mich wundern doch die 165ms ein wenig...

Das mit der Block Größe ist richtig . So kann man den Ladevorgang doch erheblich beschleunigen.

**Andy**

Script oben etwas geändert:

Code

WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 1024 bytes    time: 4599 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 8192 bytes    time: 679 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 27648 bytes    time: 282 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 65536 bytes    time: 184 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 128000 bytes    time: 150 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 221184 bytes    time: 136 ms  
WinAPI:   Read 96MB File    #Lines: 2097152   Blocksize: 351232 bytes    time: 129 ms  


Autoit:   Read 96MB File   time: 3616 ms

Sieht wohl so aus, als ob größere Blockgrößen doch schneller sind...selbst auf meinem langsamen Rechner und AutoIt komme ich in den Bereich der Ergebnisse des TE. Und die kommen aus (~~hoffentlich~~) optimierten GNU-Bibliotheken.
Btw. dauert die Suche nach den LF mit meinem unoptimierten ASM-Code ca. 30ms bei 96MB Dateigröße, das Laden dauert somit 100ms, nicht schlecht....

**AspirinJunkie**

Wow hätte nicht gedacht, dass FileRead noch dermaßen viel Optimierungspotential besitzt.
Hatte da gleich mal ne kleine Funktion basierend auf den API-Funktionen gemacht - und siehe da: Doppelt so schnell als FileRead.

Dann hab ich dein Skript genommen und dann nicht schlecht gestaunt dass eien 100mb Datei in 78 ms eingelesen sein sollte.
Zwar rechnest du mit dem falschen $p bei der Mittelwertberechnung ($p hat zu dem Zeitpunkt den Wert 11) aber das kann nicht der Grund für die krassen Ergebnisse sein.
Direkt ist mir nix weiter aufgefallen.
Also hab ich deine _TextFileRead als Funktion zum Einlesen einer Textdatei genommen und auf einmal sind die Ergebnisse nicht mehr so krass:

AutoIt

#include <WinAPI.au3>


Global Const $s_CSV_Path = "D:\Test.csv"
Global Const $i_Runs = 10


ConsoleWrite("-------- Test mit " & $i_Runs & " Durchläufen -------------" & @CRLF & @CRLF)


Global $Sum = 0, $QuSum = 0, $min = 1e15, $max = 0
For $i = 1 To $i_Runs
	$iT = TimerInit()
   MyFileRead($s_CSV_Path)
	$iT = TimerDiff($iT)


	$Sum += $iT / 1000
	$QuSum += ($iT / 1000) * ($iT / 1000)
	If $iT < $min Then $min = $iT
	If $iT > $max Then $max = $iT
Next
$f_StdDev = Sqrt(($QuSum - ($Sum ^ 2) / $i_Runs) / ($i_Runs - 1))
ConsoleWrite(StringFormat("Methode           : %s\nmittlere Dauer    : % 8.4f s\nStandardabweichung: % 8.4f s\nMinimum           : % 8.4f s\nMaximum           : %8.4f s\n\n", _
		"StringReplace MyFileRead", $Sum / $i_Runs, $f_StdDev, $min / 1000, $max / 1000))




Global $Sum = 0, $QuSum = 0, $min = 1e15, $max = 0
For $i = 1 To $i_Runs
	$iT = TimerInit()
_TextFileRead($s_CSV_Path)
	$iT = TimerDiff($iT)


	$Sum += $iT / 1000
	$QuSum += ($iT / 1000) * ($iT / 1000)
	If $iT < $min Then $min = $iT
	If $iT > $max Then $max = $iT
Next
$f_StdDev = Sqrt(($QuSum - ($Sum ^ 2) / $i_Runs) / ($i_Runs - 1))
ConsoleWrite(StringFormat("Methode           : %s\nmittlere Dauer    : % 8.4f s\nStandardabweichung: % 8.4f s\nMinimum           : % 8.4f s\nMaximum           : %8.4f s\n\n", _
		"_TextFileRead", $Sum / $i_Runs, $f_StdDev, $min / 1000, $max / 1000))




Global $Sum = 0, $QuSum = 0, $min = 1e15, $max = 0
For $i = 1 To $i_Runs
	$iT = TimerInit()
FileRead($s_CSV_Path)
	$iT = TimerDiff($iT)


	$Sum += $iT / 1000
	$QuSum += ($iT / 1000) * ($iT / 1000)
	If $iT < $min Then $min = $iT
	If $iT > $max Then $max = $iT
Next
$f_StdDev = Sqrt(($QuSum - ($Sum ^ 2) / $i_Runs) / ($i_Runs - 1))
ConsoleWrite(StringFormat("Methode           : %s\nmittlere Dauer    : % 8.4f s\nStandardabweichung: % 8.4f s\nMinimum           : % 8.4f s\nMaximum           : %8.4f s\n\n", _
		"FileRead", $Sum / $i_Runs, $f_StdDev, $min / 1000, $max / 1000))






Func MyFileRead(Const $s_FilePath, Const $flag_Encoding = 1)
	; by AspirinJunkie
	Local Static $h_DLL_KERNEL32 = DllOpen("kernel32.dll")
	Local $a_Ret


	$a_Ret = DllCall($h_DLL_KERNEL32, "handle", "CreateFileW", "wstr", $s_CSV_Path, "dword", 0x80000000, "dword", 1, "struct*", Null, "dword", 3, "dword", 0, "ptr", Null)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(1, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	Local $h_File = $a_Ret[0]


	$a_Ret = DllCall($h_DLL_KERNEL32, "bool", "GetFileSizeEx", "handle", $h_File, "int64*", 0)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(2, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	Local $d_Bytes = $a_Ret[2]


	Local $t_Buffer = DllStructCreate("byte[" & $d_Bytes & "]")
	DllCall($h_DLL_KERNEL32, 'bool', 'ReadFile', 'handle', $h_File, 'struct*', $t_Buffer, 'dword', $d_Bytes, 'dword*', 0, 'ptr', 0)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(3, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	DllCall($h_DLL_KERNEL32, "bool", "CloseHandle", "handle", $h_File)


	Return BinaryToString(DllStructGetData($t_Buffer, 1), $flag_Encoding)
EndFunc   ;==>MyFileRead




Func _TextFileRead($filename)
	; by Andy
	Local Static $h_DLL_KERNEL32 = DllOpen("kernel32.dll")
	Local $nbytes
	Local $blocksize = 4096 * 16
	Local $filesize = FileGetSize($filename)
	Local $filestruct = DllStructCreate("char[" & $filesize + $blocksize & "]")
	Local $filestructptr = DllStructGetPtr($filestruct)


	Local $blocks = Ceiling($filesize / $blocksize)


	Local $hfile = _WinAPI_CreateFile($filename, 2, 2)


	For $i = 0 To $blocks - 1
		Local $blockstruct = DllStructCreate("char[" & $blocksize & "]", $filestructptr + $i * $blocksize)


		Local $aResult = DllCall($h_DLL_KERNEL32, "bool", "ReadFile", "handle", $hfile, "ptr", DllStructGetPtr($blockstruct), "dword", $blocksize, "dword*", 0, "ptr", Null)
		If @error Then Return SetError(@error, @extended, False)
	Next
	DllCall($h_DLL_KERNEL32, "bool", "CloseHandle", "handle", $hfile)
	Return DllStructGetData($filestruct, 1)


EndFunc   ;==>_TextFileRead

Alles anzeigen

Jetzt deckt sich die Performance mit meiner Funktion.
Also entweder ich hab das falsch implementiert oder der Effekt ist auf was anderes zurückzuführen (Caching oder sowas?).
Vielleicht kannst du ja nochmal in mein Skript hier schauen und gucken ob ich deinen Ansatz korrekt eingebaut habe.

**Andy**

Bei deinem Script stimmt alles! In der Funktion _TextFileRead() steht nicht umsonst das "Text", denn AutoIt(C++)-typisch werden beim Schreiben in einen String (mein Auslesen der Struct) nur Daten bis zum ersten Nullbyte berücksichtigt.
Ansonsten liegen wir gleichauf^^. Würde AutoIt Pointer unterstützen, wäre das der Faktor 3 im Vergleich zur nativen Funktion!

Code

-------- Test mit 10 Durchläufen -------------


Methode           : StringReplace MyFileRead
mittlere Dauer    :   0.9206 s
Standardabweichung:   0.0148 s
Minimum           :   0.8795 s
Maximum           :   0.9322 s


Methode           : _TextFileRead
mittlere Dauer    :   0.9397 s
Standardabweichung:   0.0098 s
Minimum           :   0.9312 s
Maximum           :   0.9590 s


Methode           : FileRead
mittlere Dauer    :   3.5304 s
Standardabweichung:   0.0064 s
Minimum           :   3.5208 s
Maximum           :   3.5430 s

Alles anzeigen

Fraglich ist nur, wo die native AutoItfunktion die Zeit verliert. Ich bin ziemlich sicher, dass die DEV´s die C++-Standard-Bibliotheken benutzen...

**AspirinJunkie**

Na dann hab ich mir mal ne kleine Funktion erstellt - kann ich sicherlich noch paar mal brauchen:

AutoIt

; #FUNCTION#============================================================================================================
; Name...........: _FileReadFast
; Description ...: Read text or binary files into a variable. Faster than FileRead at big file sizes
; Syntax.........: _FileReadFast(Const $s_FilePath, [[Const $flag_Encoding = Default], [Const $flag_FileScan = 2]])
; Parameters ....: $s_FilePath - the file path as a string
;                  $flag_Encoding: Default = the file encoding is determined by the function
;                                  0 = file gets handled as a binary file -> return a binary-variable
;                                  other = possible values are the same es the flag parameter of BinaryToString (faster)
;                  $flag_FileScan: The mode-parameter of FileGetEncoding $flag_Encoding = Default
; Return values .: Success - the file content as a string or a binary-variable
;                  Failure - a Null-String and error gets set to:
;                      @error = 1: File doesn't exist
;                             = 2: Couldn't open file for reading
;                             = 3: Couldn't determine file size
;                             = 4: error while reading file
;                      @extended = WinAPI error code
; Author ........: AspirinJunkie
; ===============================================================================================================================
Func _FileReadFast(Const $s_FilePath, Const $flag_Encoding = Default, Const $flag_FileScan = 2)
	If Not FileExists($s_FilePath) Then Return SetError(1, 0, "")
	Local $h_DLL_KERNEL32 = DllOpen("kernel32.dll")
	Local $a_Ret
	$a_Ret = DllCall($h_DLL_KERNEL32, "handle", "CreateFileW", "wstr", $s_FilePath, "dword", 0x80000000, "dword", 1, "struct*", Null, "dword", 3, "dword", 0, "ptr", Null)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(2, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	Local $h_File = $a_Ret[0]
	$a_Ret = DllCall($h_DLL_KERNEL32, "bool", "GetFileSizeEx", "handle", $h_File, "int64*", 0)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(3, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	Local $d_Bytes = $a_Ret[2]
	Local $t_Buffer = DllStructCreate("byte[" & $d_Bytes & "]")
	DllCall($h_DLL_KERNEL32, 'bool', 'ReadFile', 'handle', $h_File, 'struct*', $t_Buffer, 'dword', $d_Bytes, 'dword*', 0, 'ptr', 0)
	If DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0] Then Return SetError(4, DllCall($h_DLL_KERNEL32, "dword", "GetLastError")[0], "")
	DllCall($h_DLL_KERNEL32, "bool", "CloseHandle", "handle", $h_File)
	DllClose($h_DLL_KERNEL32)


	Switch $flag_Encoding
		Case Default; determine file encoding
			Switch FileGetEncoding($s_FilePath, $flag_FileScan)
				Case 32, 1024 ; UTF-16 LE
					Return BinaryToString(DllStructGetData($t_Buffer, 1), 2)
				Case 64, 2048 ; UTF-16 BE
					Return BinaryToString(DllStructGetData($t_Buffer, 1), 3)
				Case 128, 256 ; UTF-8
					Return BinaryToString(DllStructGetData($t_Buffer, 1), 4)
				Case 512 ; ANSI
					Return BinaryToString(DllStructGetData($t_Buffer, 1), 1)
				Case Else ; handle as binary
					Return DllStructGetData($t_Buffer, 1)
			EndSwitch
		Case 0 ; binary file
			Return DllStructGetData($t_Buffer, 1)
		Case Else ; encoding set by user
			Return BinaryToString(DllStructGetData($t_Buffer, 1), $flag_Encoding)
	EndSwitch
EndFunc   ;==>_FileReadFast

Alles anzeigen

**Andy**

Ja, wird man sicherlich gebrauchen können, ich binde diese Funktion mal testweise in geschwindigkeitskritische Scripte ein.
Schaumamal, ob man so auch andere "Programmiersprachen" beschleunigen kann bzw. die Dateigrößen dort massiv erweitern kann, ohne an Performance zu verlieren...

Blaxxun

Wow!
Der Hammer wie hier einige abgehen!
Sehr informativ! Danke für die professionellen Beiträge!!!

Zitat von Yaerox

Kannst du vll. noch ergänzend die Variationen aufzeigen die du ausprobiert hast und ggf. die Ergebnisse? Mich würden die Unterschiede und die angewandten Methoden der Auswertung interessieren.

Also Variationen habe ich nicht sehr viele probiert. Ich war eher dran das Ding zum laufen zu bringen da die Apostrophe nicht stimmten und das DOS Fenster nur kurz aufblinkte und somit keinen Rückschluß zulies.

AutoIt

RunWait(@ComSpec & ' /k wc -l '&$ReadFile&' | cut -d " " -f 1 > '&$SaveFile, $GNU, @SW_HIDE) ; Das /k läßt das DOS Fenster offen.


RunWait(@ComSpec & ' /k&&cls&& wc -l '&$ReadFile&' | cut -d " " -f 1 > '&$SaveFile, $GNU, @SW_HIDE) ; Mit && kann man mehrere DOS Befehle in einer Zeile ausführen.




Auszug aus dem jeweiligen Befehl mittels --help


Aufruf: wc [OPTION]... [DATEI]...
 -c, --bytes            Byteanzahl ausgeben
 -m, --chars            Zeichenanzahl ausgeben
 -l, --lines            Zeilenanzahl ausgeben
 -L, --max-line-length  die Länge der längsten Zeile ausgeben
 -w, --words            Wortanzahl ausgeben




Aufruf: cut [OPTION]... [DATEI]...
  -b, --bytes=LIST        select only these bytes
  -c, --characters=LIST   select only these characters
  -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter
  -f, --fields=LIST       select only these fields;  also print any line
                            that contains no delimiter character, unless
                            the -s option is specified
  -n                      (ignored)
      --complement        complement the set of selected bytes, characters
                            or fields.
  -s, --only-delimited    keine Zeilen ausgeben, die keinen Trenner enthalten
      --ouput-delimiter=ZKETTE  ZKETTE als Ausgabetrennzeichen benutzen;
                            Voreinstellung ist das Eingabetrennzeichen

Alles anzeigen

@Mars @Bioshade

Ich habe letztendlich den _FileReadToArray($File, $CSV) Befehl genommen da dann in $CSV[0] die Anzahl der Zeilen enthalten ist.
Das ganze ist aber sehr langsam (6000ms) aber, wie ihr schon angedeutet habt einfach praktischer da man sich die GNU Installation erspart.

@Andy

Ich habe dein Skript laufen lassen und ich komme auf folgende Werte:

Code

WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 1024 bytes time: 2848 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 8192 bytes time: 433 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 27648 bytes time: 141 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 65536 bytes time: 90 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 128000 bytes time: 55 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 221184 bytes time: 41 ms
WinAPI: Read 96MB File #Lines: 2097152 Blocksize: 351232 bytes time: 40 ms


Autoit: Read 96MB File time: 1606 ms

Ich muss dazu sagen daß ich zwei SSD's im RAID-0 Verbund laufen habe. Die Zeiten sind der Hammer.

@UEZ
Die 165ms sind nicht gelogen. ich habe SSD's und das ist wahrscheinlich der Grund.

@AspirinJunkie
Ich habe deine neue Funktion auch getestet und ich bekomme Werte zwischen 270ms - 380ms mit den Default=Auto Settings.
Ich weis nur nicht warum ich 40ms mit Andy's Testskript erhalte.

Wenn ich jetzt noch herausfinden würde wie ich als Return der _FileReadFast() die Zeilenanzahl bekomme könnte ich mir die _FileReadToArray() Geschichte sparen.
Aber da steige ich leider wissenstechnisch momentan noch aus.

**Andy**

Hi, das Zählen der Zeilen ist mit dem Assemblercode recht schnell erledigt, in deinem Fall sicherlich nur einige Millisekunden...

AutoIt

$asmcode = "0x8B7C24048B4C24088B54240C88D6C1E20888F2C1E20888F2660F6EC2660F70C0005583EC1089E3C70300010102C7430401020203C7430801020203C7430C0203030431F631ED660F6FC8660F740C37660FD7D185D2742989D083E00FD701C5C1EA0489D083E00FD701C5C1EA0489D083E00FD701C5C1EA0489D083E00FD701C583C61039CE76BF89E883C4105DC3"
$codestruct = DllStructCreate("byte[" & StringLen($asmcode) / 2 - 1 & "]") ;speicher für asmcode...
DllStructSetData($codestruct, 1, $asmcode) ;...mit code füllen

erstellt einen Speicherbereich und schreibt den Code hinein.

AutoIt

$ret = DllCallAddress("uint:cdecl", DllStructGetPtr($codestruct), "ptr", $filestructptr, "uint", $filesize, "dword", 0x0A)
$nr_lf = $ret[0]  ;Anzahl der LF

ruft den Code auf und gibt die Anzahl der LF zurück.
$filestructptr ist der Pointer auf den von "readfile" verwendeten Puffer ( Achtung, Puffer PLUS einmal die Blockgröße! ), $filesize enthält die Dateigröße.

Ich denke, irgendwer wird diese Zeilen in die _FileReadFast()-Funktion einbauen können und per @extended die Anzahl der LF ausgeben...

//EDIT
Dann schreibe ich auch das Pendant in 64-Bit

**AspirinJunkie**

Zitat von Blaxxun

Wenn ich jetzt noch herausfinden würde wie ich als Return der _FileReadFast() die Zeilenanzahl bekomme

Die Funktion liefert den Dateiinhalt.
In dem Fall als String.
In diesem muss man nur noch die Zeilenenden zählen.
Wie das geht haben wir oben schon erläutert.
Z.B. über StringReplace - nur das die FileRead durch FileReadFast ersetzt wird.
Schneller geht es dann sicherlich über Andys ASM-Code.
Obwohl ich mir da noch unschlüssig bin wie sich die Funktion bei UTF-8 oder anderem verhält.

Ansonsten stocher ich noch bisschen im Dunkeln was die Zeiten bei Andys Skript angeht.
Plausibel erscheinen mir auf ner alten Notebookfestplatte Einlesezeiten von 78ms für 100mb überhaupt nicht.
Da spielen noch irgendwelche anderen Effekte rein.
Da fehlt mir aber ne ganze Menge Hintergrundwissen zum Caching von Windows und derartigem.

**Andy**

@AspirinJunkie,
nachdem ich mir deinen Code angeschaut hatte, frage ich mich auch, wieso ich in der ReadFile()-Funktion überhaupt blockweise Daten auslese
Die komplette Dateigröße hineingeworfen reicht, um ein gutes Ergebnis zu erzielen, der Overhead des Block-Loops fällt somit komplett weg.

Das Einlesen der 100MB in den Speicher dauert bei mir ca. 100ms, Übertragung aus der Struct in die Variable $string=dllstructgetdata(blablub) dauert EINE SEKUNDE! Die zehnfache Zeit für ein simples memcopy...ohne Worte.
Irgendetwas innerhalb von AutoIt werkelt da sehr gemächlich, und wahrscheinlich (eher sicher) sind es nicht die API-Funktionen, wie wir hier gezeigt haben.

Zitat von AspirinJunkie

Obwohl ich mir da noch unschlüssig bin wie sich die Funktion bei UTF-8 oder anderem verhält.

Das Problem ist, dass eine Datei grundsätzlich als ASCII eingelesen wird. Erst im Nachhinein wird versucht, durch diverse Verfahren herauszufinden, in welcher Kodierung die "Datei" vorliegt. Es gibt Betriebssysteme, in welchen es eine Dateibeschreibung gibt, in der bspw. stehen würde, dass eine UTF8/16-Kodierung vorliegt. Das hat den immensen Vorteil, die langwierigen "Testverfahren" garnicht erst einsetzen zu müssen.
UTF8/16 benutzen für EndOfLine 0x000D und/oder 0x000A statt Ascii 0x0D0A (CRLF) , haben also mitten im "Text" zwangsläufig Nullbytes. Sind diese vorhanden, zählt man statt 0x0A eben die 0x000A...

Zitat von AspirinJunkie

Plausibel erscheinen mir auf ner alten Notebookfestplatte Einlesezeiten von 78ms für 100mb überhaupt nicht.

Ja, 100-200MB pro Sekunde sollten eher hinkommen.
Ich werde mal gesamte Verzeichnisse einlesen, bei hunderten unterschiedlicher Dateien sollte sich ein plausibler Mittelwert ergeben.

**AspirinJunkie**

Zitat von Andy

Das Problem ist, dass eine Datei grundsätzlich als ASCII eingelesen wird. Erst im Nachhinein wird versucht, durch diverse Verfahren herauszufinden, in welcher Kodierung die "Datei" vorliegt.

Ich meinte nicht das Einlesen der Datei sondern deine Zeilenendezählung. Die arbeitet doch Byteweise oder?

Zitat von Andy

UTF8/16 benutzen für EndOfLine 0x000D und/oder 0x000A statt Ascii 0x0D0A (CRLF) , haben also mitten im "Text" zwangsläufig Nullbytes.

Eigentlich nur UTF-16. Bei UTF-8 sollte es auch weiterhin noch 0D0A sein. Diese Zeichen befinden sich ja noch im ASCII-Bereich und sollten bei UTF-8 ja auch nur 1 Byte verbrauchen.
Aber genau die Fälle meinte ich eigentlich.
Gehen wir mal von einem Fall aus, dass in der Datei das Zeichen č(010D) oder ȍ(020D) vorkommen.
Wenn die Kodierung außer Acht gelassen wird und nur Byteweise nach 0D oder 0A gesucht wird werden so diese fälschlicherweise als Zeilenende erkannt.

Käme deine ASM-Code mit sowas klar? - ich frage weil verstehen werde ich den Code eh nie