Dann mach es schön:
#AutoIt3Wrapper_Run_AU3Check=n
Exakt für so etwas gibt es #forcedef.
Also die Funktion folgendermaßen definieren und man hat weiterhin Au3Check und keine Fehlermeldung:
Dann mach es schön:
#AutoIt3Wrapper_Run_AU3Check=n
Exakt für so etwas gibt es #forcedef.
Also die Funktion folgendermaßen definieren und man hat weiterhin Au3Check und keine Fehlermeldung:
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?
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 ![]()
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.
Na dann hab ich mir mal ne kleine Funktion erstellt - kann ich sicherlich noch paar mal brauchen:
; #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
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:
#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.
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:
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:
-------- 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.
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.
Das reguläre Leben der Zählervariable endet beim Austritt aus der Schleife, sie ist nämlich lokal und bedarf deshalb auch keiner Deklaration
Eine Zählervariable muss genauso wie jede andere Variable auch deklariert werden.
In der For-Schleife muss sie darüber hinaus sogar auch definiert werden (es findet ja eine eindeutige Wertzuweisung statt)
Implizit wird sie dann aber tatächlich als local deklariert:
AutoIt kennt als Gültigkeitsbereiche jedoch nur innerhalb vs. außerhalb von Funktionen.
Eine lokale Gültigkeit nur für den Bereich der For-Schleife wie es in späteren C-Standards möglich ist gibt es in AutoIt aber nicht.
Dass sie auch nicht allein für den For-Schleifenbereich Gültigkeit besitzt sieht man auch daran, dass Sie, bei Vorhandensein, auf vorher deklarierte Variablen zurückgreift und diese direkt verändert:
Es ist daher absolut legitim und notwendig sich über das Verhalten außerhalb der Schleife Gedanken zu machen.
Intuitiv hätte ich übrigens genauso wie CentuCore argumentiert.
Dass es nicht der Fall ist überrascht mich auch ein wenig.
Habe allerdings nicht direkt den Vergleich im Kopf wie es andere Sprachen handhaben.
Bei diesen kann es aber auch dazu kommen, dass sich die Frage nicht stellt, da diese, je nach Sprache, einen Gültigkeitsbereich nur für die Schleife kennen.
Dein Skript erzeugt schlicht keine Last.
Es kann auch keiner ausführen um es zu testen.
Mach doch am besten ein kleines Minimalbeispiel.
Ich vermute aber, dass du die Funktion in einer Endlosschleife immer wieder aufrufst.
Dabei wird immer ein neues WMI-Objekt erstellt und die Daten abgefragt - jedes mal aufs neue.
Eine Möglichkeit wäre daher wenigstens das WMI-Objekt immer wieder zu verwenden und die nächste Stufe wäre ein Refresher-Objekt zu verwenden.
Mal als Grundaufbau für deine Funktion:
Func _statusmode()
Local Static $o_WMI = ObjGet("winmgmts:\\.\root\cimv2")
Local Static $o_WMIRefresher = ObjCreate("WbemScripting.Swbemrefresher")
Local Static $o_ServiceData = $o_WMIRefresher.AddEnum($o_WMI, "Win32_Service").objectSet
$o_WMIRefresher.Refresh
For $o_Service In $o_ServiceData
ConsoleWrite($o_Service.DisplayName & @TAB & $o_Service.StartMode & @TAB & $o_Service.State & @CRLF)
Next
EndFunc
Alles anzeigen
In der Endlosschleife sollte auch noch ein Sleep mit eingebaut werden um der CPU ne Pause zu gönnen.
Bei der Gelegenheit: Die große Schrift sollte nicht als nonverbales Schreien oder sonstiges Ausdrücken erhöhter Gefühlslagen aufgefasst werden.
Der Text wurde vom Handy aus geschrieben und dabei ist irgendwie diese Schriftformatierung reingekommen.
Also lediglich eine sachliche gefühlskalte Aussage ![]()
Funktioniert bei mir problemlos.
Die Verknüpfung zum Startmenü wird korrekt auf C:\ erstellt.
Mal davon abgesehen, dass es bisschen umständlich hingeschrieben wurde.
So wird es sicherlich etwas übersichtlicher:
Run(@ComSpec & ' /c mklink /j "Startmenü" "C:\ProgramData\Microsoft\Windows\Start Menu"', "C:\", @SW_HIDE)
Wenn du das (und wirklich nur das!) ausführst - wird der Link tatsächlich woanders als in "C:\" erstellt?
Das würde tatsächlich nach einem Bug riechen.
Spontan vermute ich allerdings, dass dein Skript etwas umfangreicher ist und der Fehler an einer anderen Stelle zu suchen ist.
Also mal wirklich nur ein Skript mit dieser einen Zeile ausführen und schauen was passiert.
Kannst ja vielleicht nochmal folgende Ausgabe testen:
#include <AutoItConstants.au3>
$dPID = Run(@ComSpec & " /c dir", "C:\", @SW_HIDE, $STDOUT_CHILD)
ProcessWaitClose($dPID)
ConsoleWrite(StdoutRead($dPID) & @CRLF)
Wenn das Working-Dir korrekt angenommen wird sollte als Ergebnis die Datei/Verzeichnisliste von C:\ ausgegeben werden.
Nur mal als Beispiel was man mit einem Dictionary und Inis anstellen könnte:
Global $I = IniToObject("Test.ini")
; Direktzugriff
MsgBox(0, "", $I("Sektion2").Item("Key1"))
; ganze Section in Variable:
$S = $I("Sektion2")
; Zugriff auf Wert in Section-Variable:
MsgBox(0, "", $S("Key1"))
; liest eine Ini-Datei in eine Dictionary[Dictionary]-Struktur
Func IniToObject(Const $s_IniPath)
;by AspirinJunkie
If Not FileExists($s_IniPath) Then Return SetError(1, 0, "")
Local $a_SecNames = IniReadSectionNames($s_IniPath)
If Not IsArray($a_SecNames) Then Return SetError(2, @error, "")
Local $I, $j, $o_DicRet = ObjCreate("Scripting.Dictionary")
For $I = 1 To $a_SecNames[0]
Local $o_DicSec = ObjCreate("Scripting.Dictionary")
Local $a_IniSection = IniReadSection($s_IniPath, $a_SecNames[$I])
For $j = 1 To $a_IniSection[0][0]
$o_DicSec($a_IniSection[$j][0]) = $a_IniSection[$j][1]
Next
$o_DicRet($a_SecNames[$I]) = $o_DicSec
Next
Return $o_DicRet
EndFunc ;==>IniToObject
Alles anzeigen
schau im forum mal nach dem dictionary-objekt. Das wäre eine Implementierung für eine key-value-struktur. In den aktuellen betas gibt es auch noch den eingebauten map-datentyp welcher das Selbe darstellt.
Achte darauf dass es jeder direkt ohne irgendeine Änderung ausführen und nachvollziehen kann
Dein gezeigter code ist kein minimalbeispiel. Es sind nur lose codefetzen die keiner so ausführen kann.
Mach doch einfach ein ganz normales Miniskript was das Problem bei anderen direkt reproduzierbar macht.
Du schriebst, dass du Probleme beim ausführen von sql-befehlen hast. Die ganzen cryptsachen können da ja für ein Minibeispiel raus. Und so dünnst du schrittweise dein Skript auf das eigentliche Problem aus. Und mit etwas Glück stößt du bei diesem ausdünnungsprozess darauf, dass dein eigentliches Problem doch an einer ganz anderen stelle zu suchen ist.
Und behalte immer den Satz im Hinterkopf: Warum sollte jemand mehr Zeit in die Beantwortung deiner Frage investieren als du selbst in die Aufstellung der Frage investiert hat?
Mein Script kann ich euch leider nicht komplett hochladen sind 1000 Zeilen und zeigen darf ich es euch leider auch nicht.
Ernsthaft? - was erwartest du denn für Antworten auf sowas?
Sollen wir Karten legen oder in den Sternen lesen was für eine Problem bei dir besteht?
Du musst und sollst dein Skript auch gar nicht zeigen.
Weißt du was ein Minimalbeispiel ist?
Dies ist ein Skript, welches so klein wie möglich ist aber den Fehler reproduziert.
Es ist so geschrieben, dass es direkt ohne jegliche weitere Änderung lauffähig ist, so dass dein Problem von anderen direkt nachvollzogen werden kann.
Vorteile für dich:
Extrahiere eine Stelle die die Probleme aufweist.
Schmeiß alles raus was mit dem Problem nichts zu tun hat.
Achte darauf dass es jeder direkt ohne irgendeine Änderung ausführen und nachvollziehen kann und poste es hier.
Somit bekomme ich 4 zufällige Bytes! Und brauche also auch nur 1/4 der Berechnungen!
Ja das hatte Oscar ja auch schon so in AutoIt ausgenutzt.
Ich weiß nur halt nicht wie du das hinbekommst den Wertebereich jedes Bytes auf 33-127 einzudampfen.
Alle 4 durch Verschieben und Einzelbehandlung anpassen?
Wären das "vernünftige" Zahlengrenzen könnte man ja einfach ne Bitmaske drüber legen und gleich alle 4 Bytes mit einer Operation abhandeln - aber die sind hier ja leider etwas krumm geraten mit 33-127.
es wird nur 1.Kern zu 25% ausgelastet.
Dort sieht man alle CPUs und deren einzelnen Auslastungen und bei mir wird nun mal nur eine zu 25% ausgelastet
Was denn nun? - Kerne oder CPUs?
Wieviele Kerne hast du denn?
Und wieviele CPUs?
Geht die Auslastung auch mal über 25%?
Es wäre sehr verwunderlich wenn die Auslastung eines Kerns eine bestimmte Auslastungsgrenze hat.
Das bekommt man auch nicht wirklich hinprogrammiert, dass eine Programm einen einzelnen Kern auf einem stabilen Level auslastet.
Zumal die 25% sehr stark nach einem Teiler durch 4 (=4 Cores?) riechen.
Mach mal einen Screenshot davon um zu sehen was du wo genau abliest.
Nein Andy, es sind nur 25% auf einer CPU ;), die anderen CPus laufen gar nicht erst mit an.
Die Prozentzahl im Taskmanager gibt die Gesamtauslastung des Systems an.
Wenn du 4 Kerne hast, kannst du bei einem SingleThread-Prozess also nur maximal 25% Auslastung erreichen.
Der Kern ist also zu 100% ausgelastet und die gesamte CPU (also alle Kerne) nur zu 25%.
Wäre, wie du sagst, nur der einzelne Kern zu 25% ausgelastet würde der Taskmanager für diesen Prozess 6,25% Auslastung anzeigen.
Ist das der Fall?