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.
Da haben wir klassisch aneinander vorbeigeredet 
010D enthält ein Zeichen, welches im ASCII-Bereich als Steuerzeichen gilt. Enthält ein Text (!) Dateiinhalt solch ein Zeichen, dann ist dieser UTF8-kodiert, wenn 000D auch UTF16.
Genau daher müssen diese Inhalte analysiert werden, um die Kodierungen zu erkennen.
Im ASM-Code habe ich es mir einfach gemacht und nur nach einem Zeichen gesucht. Ob CR oder LF ist unerheblich, man könnte auch die Anzahl aller "e" ermitteln.(letzter Parameter im DllCallAddress).
Man könnte den Code noch dahingehend erweitern, erst nach allen Zeichen unterhalb ASCII 31 zu schauen, wenn solch ein Zeichen vorkommt, dann "könnte" eine UTF8/16-Kodierung vorliegen und dann müsste entsprechend ausgewertet werden. Aber wer sagt, dass nicht eine EXE-Datei in eine Textdatei umbenannt wurde....
Lade mal eine ausführbare Datei in Scite, dann weißt du, worauf ich (nicht 
) hinaus will!
Ich werde mal gesamte Verzeichnisse einlesen, bei hunderten unterschiedlicher Dateien sollte sich ein plausibler Mittelwert ergeben.
Naja, mit den 100MB/s hab ich nicht mal schlecht geschätzt.
Ich habe meinen "C:\"-Ordner rekursiv durchsucht aber nur alle Dateien zwischen 60 und 400MB eingelesen. Dabei sind interessante Sachen herausgekommen.
Es gibt definitiv von Windows gecachte bzw. im Arbeitsspeicher stehende Dateien, diese haben bei Größen um die 330MB nur Lesezeiten im Millisekundenbereich, da wurde seitens System (ReadFile) einfach nur der Speicher gemapped, was zu "Leseraten" von 1GB/s führt. Das ist im Speichertransfer realistisch.
Dann gibt es Dateien, die haben 80 bis 100MB und werden in einer Sekunde eingelesen, auch realistische Transferzeiten von 80 bis 100MB/s.
Der überwiegende Teil der Dateien bewegt sich bei ca. 30-90MB/s. Im Schnitt erreiche ich 66MB/s.
Bei "kaltem" Rechner, also direkt nach dem Aufwachen aus dem Schlafmodus und niedriger Prozessor/Platten-Temperatur erreiche ich bei sonst gleichen Voraussetzungen 88 MB/s...das sind Abweichungen von 20-30%!!!!
Um nicht den schon angesprochenen "AutoIt-Speicher-Schiebe-Malus" einzurechnen, habe ich nur die reinen Transferzeiten von "Platte" nach "RAM" ermittelt (s. auskommentiertes Return in _TextFileRead() ).
AspirinJunkies _FileReadFast() gibt auch Strings zurück, daher dauerts auch so lange...
Wer mag, kann ja mal AspirinJunkies Funktion mit AutoIt-FileRead vergleichen.... 
#include <Array.au3>
#include <WinAPI.au3>
Global $kerneldll = DllOpen("kernel32.dll")
$files = _GetFilesFolder_Rekursiv("c:\", "*", 0, 0)
;_ArrayDisplay($files)
$gesamt_mb = 0
$gesamt_s = 0
For $i = 1 To UBound($files) - 1
$size = FileGetSize($files[$i])
If $size > 60e6 And $size < 400e6 Then ;>100 und kleiner 800MB
$t = TimerInit()
;$data = _FileReadFast($files[$i]) ;incl. Rückgabe als string
$data = _TextFileRead($files[$i]) ;excl. Rückgabe als String
$m = TimerDiff($t)
$len = $size ;StringLen($data)
$MB = Int($len / 1e6) ;Megabytes
$s = Int($m) / 1000 ;Sekunden
$MBS = Int($MB / $s)
$gesamt_mb += $MB
$gesamt_s += $s
ConsoleWrite($files[$i] & " " & Int($len / 1e6) & " MB $t= " & $s & "s MB/s: " & $MBS & @CRLF)
EndIf
Next
$gesamt_mbs = Int($gesamt_mb / $gesamt_s)
MsgBox(0, 0, $gesamt_mb & " MB gelesen in " & $gesamt_s & " Sekunden => " & $gesamt_mbs & " MB/s")
Func _TextFileRead($filename)
Local $nbytes
Local $filesize = FileGetSize($filename)
Local $filestruct = DllStructCreate("char[" & $filesize & "]")
Local $filestructptr = DllStructGetPtr($filestruct)
Local $hfile = _WinAPI_CreateFile($filename, 2, 2)
_WinAPI_ReadFileXXX($hfile, $filestructptr, $filesize, $nbytes)
_WinAPI_CloseHandle($hfile)
;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
; #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
;==================================================================================================
; Function Name: _GetFilesFolder_Rekursiv($sPath [, $sExt='*' [, $iDir=-1 [, $iRetType=0 ,[$sDelim='0']]]])
; Description: Rekursive Auflistung von Dateien und/oder Ordnern
; Parameter(s): $sPath der Basispfad für die Auflistung ('.' -aktueller Pfad, '..' -Parentpfad)
; $sExt Erweiterung für Dateiauswahl '*' oder -1 für alle (Standard)
; $iDir -1 Dateien+Ordner(Standard), 0 nur Dateien, 1 nur Ordner
; optional: $iRetType 0 gibt Array, 1 gibt String zurück
; optional: $sDelim legt Trennzeichen für Stringrückgabe fest
; 0 -@CRLF (Standard) 1 -@CR 2 -@LF 3 -';' 4 -'|'
; Return Value(s): Array (Standard) od. String mit den gefundenen Pfaden der Dateien und/oder Ordner
; Array[0] enthält die Anzahl der gefundenen Dateien/Ordner
; Author(s): BugFix (bugfix@autoit.de)
;==================================================================================================
Func _GetFilesFolder_Rekursiv($sPath, $sExt = '*', $iDir = -1, $iRetType = 0, $sDelim = '0')
Global $oFSO = ObjCreate('Scripting.FileSystemObject')
Global $strFiles = ''
Switch $sDelim
Case '1'
$sDelim = @CR
Case '2'
$sDelim = @LF
Case '3'
$sDelim = ' ;'
Case '4'
$sDelim = '|'
Case Else
$sDelim = @CRLF
EndSwitch
If ($iRetType < 0) Or ($iRetType > 1) Then $iRetType = 0
If $sExt = -1 Then $sExt = '*'
If ($iDir < -1) Or ($iDir > 1) Then $iDir = -1
_ShowSubFolders($oFSO.GetFolder($sPath), $sExt, $iDir, $sDelim)
If $iRetType = 0 Then
Local $aOut
$aOut = StringSplit(StringTrimRight($strFiles, StringLen($sDelim)), $sDelim, 1)
If $aOut[1] = '' Then
ReDim $aOut[1]
$aOut[0] = 0
EndIf
Return $aOut
Else
Return StringTrimRight($strFiles, StringLen($sDelim))
EndIf
EndFunc ;==>_GetFilesFolder_Rekursiv
Func _ShowSubFolders($Folder, $Ext = '*', $Dir = -1, $Delim = @CRLF)
If Not IsDeclared("strFiles") Then Global $strFiles = ''
If ($Dir = -1) Or ($Dir = 0) Then
For $file In $Folder.Files
If $Ext <> '*' Then
If StringRight($file.Name, StringLen($Ext)) = $Ext Then _
$strFiles &= $file.Path & $Delim
Else
$strFiles &= $file.Path & $Delim
EndIf
Next
EndIf
For $Subfolder In $Folder.SubFolders
If ($Dir = -1) Or ($Dir = 1) Then $strFiles &= $Subfolder.Path & '\' & $Delim
_ShowSubFolders($Subfolder, $Ext, $Dir, $Delim)
Next
EndFunc ;==>_ShowSubFolders
. Muster siehe 
). Weiterhin gehe ich einfach mal davon aus (korrigiere mich bitte wenn nötig! ), daß bei gleichverteilten RtlRandomEx-32-Bit-Ergebnissen, auch die darin enthaltenen einzelnen Bytes gleichverteilt sind.