﻿#AutoIt3Wrapper_UseX64=n                                ; 32Bit-Modus
#include <Memory.au3>
#include <MemoryConstants.au3>
#include <WinAPIHObj.au3>
#include <WinAPIInternals.au3>
#include <WinAPIProc.au3>
#include <WinAPIFiles.au3>
#include <WinAPISys.au3>

#Region ASM-Code
#Tidy_Off
#cs CheckBuffer
    Use32                                               ; 32Bit Modus!
    mov esi,[esp+4]                                     ; esi = Buffer (Pointer)
    mov edx,dword[esp+8]                                ; edx = Anzahl
    mov eax,dword[esp+12]                               ; eax = Startwert
    xor ecx,ecx                                         ; ecx = counter (auf 0 setzen)
	@loop:                                              ; Hauptschleife
		mov ebx,dword[esi+ecx*4]                        ; den Wert aus dem Buffer holen und in ebx speichern
		cmp ebx,eax                                     ; vergleichen, ob eax und ebx gleich sind
		jne @end                                        ; wenn Wert ungleich, dann Routine verlassen
		xor eax,0xffffffff                              ; eax invertieren
		inc ecx                                         ; counter++
		mov ebx,dword[esi+ecx*4]                        ; den Wert aus dem Buffer holen und in ebx speichern
		cmp ebx,eax                                     ; vergleichen, ob eax und ebx gleich sind
		jne @end                                        ; wenn Wert ungleich, dann Routine verlassen
		xor eax,0xffffffff                              ; eax wieder zurueck invertieren
		inc eax                                         ; eax++
		inc ecx                                         ; counter++
		cmp ecx,edx                                     ; Vergleich Counter mit Anzahl
		jb @loop                                        ; wenn kleiner, dann Schleife @loop weiter ausfuehren
		mov eax,0                                       ; kein Fehler, also 0 in eax laden (Rueckgabe an AutoIt)
		ret
	@end:
	mov eax,ecx                                         ; den Counter nach eax (Rueckgabe an AutoIt)
	ret
#ce

#cs FillBuffer
    Use32                                               ; 32Bit Modus!
    mov esi,[esp+4]                                     ; esi = Buffer (Pointer)
    mov edx,dword[esp+8]                                ; edx = Anzahl
    mov eax,dword[esp+12]                               ; eax = Startwert
    xor ecx,ecx                                         ; ecx = counter (auf 0 setzen)
	@loop:                                              ; Hauptschleife
		mov dword[esi+ecx*4],eax                        ; den Wert von eax in den Buffer schreiben
		xor eax,0xffffffff                              ; eax invertieren
		inc ecx                                         ; counter++
		mov dword[esi+ecx*4],eax                        ; den invertierten Wert von eax in den Buffer schreiben
		xor eax,0xffffffff                              ; eax wieder zurueck invertieren
		inc eax                                         ; eax++
		inc ecx                                         ; counter++
		cmp ecx,edx                                     ; Vergleich Counter mit Anzahl
		jb @loop                                        ; wenn kleiner, dann Schleife @loop weiter ausfuehren
	ret
#ce
#Tidy_On
#EndRegion ASM-Code

Global $__g_bASMCode = '0x8B7424048B5424088B44240C31C989048E83F0FF4189048E83F0FF404139D172EDC3' ; der obige FillBuffer-ASM-Code als Binaercode
Global $__g_bASMCode2 = '0x8B7424048B5424088B44240C31C98B1C8E39C3751A83F0FF418B1C8E39C3750F83F0FF404139D172E5B800000000C389C8C3' ; der obige CheckBuffer-ASM-Code als Binaercode

#Region ASM-Binaercode
Global Const $__g_iMemSize = StringLen($__g_bASMCode) / 2 - 1 ; Codelaenge ermitteln
Global Const $__g_pMem = _MemVirtualAlloc(0, $__g_iMemSize, $MEM_COMMIT, $PAGE_EXECUTE_READWRITE) ; Virtuellen Speicher reservieren
If $__g_pMem = 0 Then Exit MsgBox(16, 'Error!', "Can't allocate virtual memory!")
Global $__g_tASMCode = DllStructCreate('byte[' & $__g_iMemSize & ']', $__g_pMem) ; Structur fuer den Binaercode erstellen
DllStructSetData($__g_tASMCode, 1, $__g_bASMCode)       ; den Binaercode in die Structur schreiben
Global $__g_pASMCode = DllStructGetPtr($__g_tASMCode)   ; den Pointer der Structur holen
ConsoleWrite(StringFormat('FillBuffer-ASM-Code-Size:\t%i Bytes\r\n', $__g_iMemSize))

Global Const $__g_iMemSize2 = StringLen($__g_bASMCode2) / 2 - 1 ; Codelaenge ermitteln
Global Const $__g_pMem2 = _MemVirtualAlloc(0, $__g_iMemSize2, $MEM_COMMIT, $PAGE_EXECUTE_READWRITE) ; Virtuellen Speicher reservieren
If $__g_pMem2 = 0 Then Exit MsgBox(16, 'Error!', "Can't allocate virtual memory!")
Global $__g_tASMCode2 = DllStructCreate('byte[' & $__g_iMemSize2 & ']', $__g_pMem2) ; Structur fuer den Binaercode erstellen
DllStructSetData($__g_tASMCode2, 1, $__g_bASMCode2)       ; den Binaercode in die Structur schreiben
Global $__g_pASMCode2 = DllStructGetPtr($__g_tASMCode2)   ; den Pointer der Structur holen
ConsoleWrite(StringFormat('CheckBuffer-ASM-Code-Size:\t%i Bytes\r\n\r\n', $__g_iMemSize2))
#EndRegion ASM-Binaercode

HotKeySet('{ESC}', '_Cancel')
_WinAPI_SetPriorityClass($HIGH_PRIORITY_CLASS)

Global $sTestDir = 's:\temp', $sTestFile = '', $tBuffer, $pBuffer, $iTimer, $hFile, $nBytes, $ret, $bStop = False, $iDiff, $aRet, $iError = 0
Global $iTestCount = 4
If StringRight($sTestDir, 1) <> '\' Then $sTestDir &= '\'
If Not FileExists($sTestDir) Then DirCreate($sTestDir)
$tBuffer = DllStructCreate('dword[' & 0x200000 & ']')
$pBuffer = DllStructGetPtr($tBuffer)

Global $bNoWrite = False ; wenn bereits Testdaten vorhanden, dann auf TRUE setzen, um das schreiben zu ueberspringen
#Region Testdaten schreiben
If Not $bNoWrite Then
	For $iCount = 1 To $iTestCount ; Anzahl der 1 GB grossen Testdateien
		$sTestFile = StringFormat('%s%04i.ft', $sTestDir, $iCount)
		ConsoleWrite(StringFormat('Schreibe Datei: "%s"\r\n', $sTestFile))
		$iTimer = _WinAPI_GetTickCount()
;~ 		$hFile = _WinAPI_CreateFile($sTestFile, 1, 4)
		$hFile = _WinAPI_CreateFileEx($sTestFile, $CREATE_ALWAYS, $GENERIC_WRITE, BitOR($FILE_SHARE_READ, $FILE_SHARE_WRITE), $FILE_FLAG_NO_BUFFERING)
		If $hFile = 0 Then
			ConsoleWrite(StringFormat('Fehler: "Konnte Datei nicht öffnen!"\r\n'))
			ContinueLoop
		Else
			For $i = 0 To 127 ; 128 mal 8 MB = 1024 MB (1 GB)
				DllCallAddress('uint:cdecl', $__g_pASMCode, 'ptr', $pBuffer, 'dword', 0x200000, 'dword', 0x800000 * $i) ; ASM-Routine fuellt den 8MB-Buffer
				If Not _WinAPI_WriteFile($hFile, $pBuffer, 0x800000, $nBytes) Then ; der 8MB-Buffer wird in die Datei geschrieben
					ConsoleWrite(StringFormat('Fehler: "Ein Teil (%s) der Datei konnte nicht geschrieben werden!"\r\n', Hex(0x800000 * $i, 8)))
					_WinAPI_CloseHandle($hFile)
					ExitLoop 2
				EndIf
				If $bStop Then
					_WinAPI_CloseHandle($hFile)
					ExitLoop 2
				EndIf
			Next
;~ 			_WinAPI_FlushFileBuffers($hFile)
			_WinAPI_CloseHandle($hFile)
		EndIf
		$iDiff = (_WinAPI_GetTickCount() - $iTimer) / 1000 ; Rueckgabe von _WinAPI_GetTickCount in Millisekunden geteilt durch 1000 ergibt Sekunden (Kommazahl)
		ConsoleWrite(StringFormat('Zeit: %.3f s\r\n', $iDiff))
		ConsoleWrite(StringFormat('Schreibrate: %.1f MB/s\r\n\r\n', 1024 / $iDiff)) ; Schreibrate: 1024 MB (1 GB) geteilt durch die Sekunden
	Next
EndIf
#EndRegion

#Region Testdaten lesen
For $iCount = 1 To $iTestCount ; Anzahl der 1 GB grossen Testdateien
	$sTestFile = StringFormat('%s%04i.ft', $sTestDir, $iCount)
	ConsoleWrite(StringFormat('Lese Datei: "%s"\r\n', $sTestFile))
	$iTimer = _WinAPI_GetTickCount()
	$hFile = _WinAPI_CreateFileEx($sTestFile, $OPEN_EXISTING, $GENERIC_READ, $FILE_SHARE_READ, $FILE_FLAG_NO_BUFFERING)
	If $hFile = 0 Then
		ConsoleWrite(StringFormat('Fehler: "Konnte Datei nicht öffnen!"\r\n'))
		ContinueLoop
	Else
		For $i = 0 To 127 ; 128 mal 8 MB = 1024 MB (1 GB)
			If Not _WinAPI_ReadFile($hFile, $pBuffer, 0x800000, $nBytes) Then ; ein 8MB-Buffer wird aus der Datei gelesen
				ConsoleWrite(StringFormat('Fehler: "Ein Teil (%s) der Datei konnte nicht gelesen werden!"\r\n', Hex(0x800000 * $i, 8)))
				_WinAPI_CloseHandle($hFile)
				ExitLoop 2
			EndIf
			$aRet = DllCallAddress('uint:cdecl', $__g_pASMCode2, 'ptr', $pBuffer, 'dword', 0x200000, 'dword', 0x800000 * $i) ; ASM-Routine testet den 8MB-Buffer
			If $aRet[0] Then ; die Rueckgabe der ASM-Routine enthaelt das fehlerhafte DWORD oder "0" fuer kein Fehler
				ConsoleWrite(StringFormat('Fehler: "Fehlerhaftes DWORD an Adresse: %s"\r\n', Hex(0x800000 * $i + $aRet[0] * 4, 8)))
				$iError += 1
			EndIf
			If $bStop Then
				_WinAPI_CloseHandle($hFile)
				ExitLoop 2
			EndIf
		Next
		_WinAPI_CloseHandle($hFile)
		If $iError Then
			ConsoleWrite(StringFormat('Achtung! Das deutet auf einen defekten Datenträger hin!\r\n'))
			$iError = 0
		EndIf
	EndIf
	$iDiff = (_WinAPI_GetTickCount() - $iTimer) / 1000 ; Rueckgabe von _WinAPI_GetTickCount in Millisekunden geteilt durch 1000 ergibt Sekunden (Kommazahl)
	ConsoleWrite(StringFormat('Zeit: %.3f s\r\n', $iDiff))
	ConsoleWrite(StringFormat('Leserate: %.1f MB/s\r\n\r\n', 1024 / $iDiff)) ; Leserate: 1024 MB (1 GB) geteilt durch die Sekunden
Next
#EndRegion

If $__g_pMem > 0 Then _MemVirtualFree($__g_pMem, $__g_iMemSize, $MEM_DECOMMIT)
If $__g_pMem2 > 0 Then _MemVirtualFree($__g_pMem2, $__g_iMemSize, $MEM_DECOMMIT)
Exit

Func _Cancel()
	$bStop = True
	ToolTip('STOP', Default, Default, 'FlashTest', $TIP_ERRORICON)
EndFunc

