Danke Bitnugger Der Server ist ein Synology NAS (sorry, war nicht so klar geschrieben). Da kenne ich mich auch zu wenig aus, würde also lieber was an meinem Script anpassen....
Beiträge von Ovik
-
-
ist praktisch gleich wie die Version mit _ArrayCollinsert (uns musste noch die $aFiles in $FileAndDate ändern, war ja ungetestet...).
Die Arraysort-Funktion ist sehr schnell. Mir scheint das Ermitteln der FileGetTime das Problem zu sein.... Geht da noch was :-)??
Mittelwerte für 10 Durchläufe bei knapp 1000 Dateien:
Version0: 2.2588356952025
Version1: 1.83035228628271
Version2: 1.82812738483125
3 Versionen der Funktion
Code
Alles anzeigenFunc _fetchParaFile_Support0($SoureDirectory) Local $func = '_fetchParaFile_Support' Local $aFiles = _FileListToArray($SoureDirectory, '*.txt', 1) If $aFiles[0] > 0 Then Local $aFileAndDate[0][2] For $iFile = 1 To $aFiles[0] Step 1 Local $date = FileGetTime($SoureDirectory & $aFiles[$iFile], 0, 1) _ArrayAdd($aFileAndDate, $aFiles[$iFile] & '|' & $date) Next _ArraySort($aFileAndDate, 0, 0, 0, 1) ;SORT ASCENDING, OLDEST FILE FIRST Return $SoureDirectory & $aFileAndDate[0][0] EndIf Return 0 EndFunc ;==>_fetchParaFile_Support Func _fetchParaFile_Support1($SoureDirectory) Local $func = '_fetchParaFile_Support' Local $aFiles = _FileListToArray($SoureDirectory, '*.txt', 1) _ArrayColInsert($aFiles, 1) If $aFiles[0][0] > 0 Then For $iFile = 1 To $aFiles[0][0] Step 1 $aFiles[$iFile][1] = FileGetTime($SoureDirectory & $aFiles[$iFile][0], 0, 1) Next _ArraySort($aFiles, 0, 0, 0, 1) ;SORT ASCENDING, OLDEST FILE FIRST Return $SoureDirectory & $aFiles[0][0] EndIf Return 0 EndFunc ;==>_fetchParaFile_Support1 Func _fetchParaFile_Support2($SoureDirectory) Local $aFiles = _FileListToArray($SoureDirectory, '*.txt', 1) If $aFiles[0] > 0 Then Local $aFileAndDate[$aFiles[0]+1][2] ;Array gleich in der richtigen Größe erstellen For $iFile = 1 To $aFiles[0] Step 1 Local $date = FileGetTime($SoureDirectory & $aFiles[$iFile], 0, 1) $aFileAndDate[$iFile][0] = $aFiles[$iFile] ;Filename $aFileAndDate[$iFile][1] = $date ;Datum Next _ArraySort($aFileAndDate, 0, 0, 0, 1) ;SORT ASCENDING, OLDEST FILE FIRST Return $SoureDirectory & $aFileAndDate[0][0] EndIf Return 0 EndFunc ;==>_fetchParaFile_Support2
-
Danke alpines und gute Idee, an die ich nicht gedacht habe (ReDim geht übrigens nicht, aber _ArrayColInsert does the trick...
Hab das grad mal versucht und bringt praktisch nichts (bei 1000 Files 2.3 statt 2.4 Sekunden, mehrere Versuche...). Das Nadelöhr ist wohl das einsammeln der Datumsinformationen. Kann man das irgendwie beschleunigen. Leider zieht _FileListToArray diese Informationen nicht
-
Hallo,
Ich muss aus einem SMB-Verzeichnis eine grosse Anzahl (>1000) von Dateien lesen. Genau genommendie Dateinamen und die Datumsinfo der Datei, keine Inhalte. Ich mache folgendes:
1. Dateien mit _FileReadToArray einlesen
2. Jede Datei im Array mit den Datumsinformationen (FileGetTime) versehen
3. Das Array dann nach dem Datum sortieren
4. Älteste Datei zurückgeben
Punkt 1 geht recht schnell, Punkt 2 braucht viel Zeit und Punkt 3 geht auch wieder schnell. Kennt jemand eine Lösung, wie ich das beschleunigen kann?
Das ist alles ziemlich zeitkritisch, da eine grosse Anzahl von Clients (>100) gleichzeitig auf den Server auf das gleiche Verzeichnis zugreift.
Danke schon einmal....
-ovik
Die zugehörige Funktion sieht folgendermaßen aus:
Code
Alles anzeigenFunc _fetchParaFile_Support($SoureDirectory) Local $aFiles = _FileListToArray($SoureDirectory, '*.txt', 1) If $aFiles[0] > 0 Then Local $aFileAndDate[0][2] For $iFile = 1 To $aFiles[0] Step 1 Local $date = FileGetTime($SoureDirectory & $aFiles[$iFile], 0, 1) _ArrayAdd($aFileAndDate, $aFiles[$iFile] & '|' & $date) Next _ArraySort($aFileAndDate, 0, 0, 0, 1) ;SORT ASCENDING, OLDEST FILE FIRST Return $SoureDirectory & $aFileAndDate[0][0] EndIf Return 0 EndFunc
-
manoman! Also Ihr (insbesondere Bitnugger) seid echt grossartig. Vielen vielen Dank für die super Hilfe
Weil BitOperations64 nicht mit X86 geht (bzw. mein Script bei X64 nicht mehr richtig läuft), habe ich das AffinityMask-Setzen in eine externe exe ausgelagert, die ich getrost mit X64 Mode kompilieren kann.
Ich werde mir dann noch genauer das Binary-Beispiel ansehen und das dann wohl im nächsten Schritt in mein Script integrieren.
Nochmals vielen Dank und schöne Festtage an alle!
-ovik
-
Vielen Dank, Bignugger für die super Erklärung. Echt genial gute Darstellung!!
Das Script hab ich laufen lassen. Mir ist nun auch klar, warum die Prozessoren 32-35 nicht ansprechbar sind (Maske hat ja nur 32 Bits). Aber wie verbinde ich denn nun einen Prozess mit den Prozessoren 32-35? Im Process Explorer kann das ja manuell machen. Aber wie machen die das??? Übersehe ich etwas?
Hier noch der Script-Output:
Code
Alles anzeigen> @AutoItVersion = 3.3.14.4 @AutoItPID = 7652 > $g_iNumberOfProcessors = 1 > $g_iNumberOfLogicalProcessors = 36 > $g_iNumberOfCores = 18 > $g_iNumberOfEnabledCore = 18 $aLogicalProcessors[ 0] = 0x00000001 BitMask --> 000000000000000000000000000000000001 $aLogicalProcessors[ 1] = 0x00000002 BitMask --> 000000000000000000000000000000000010 $aLogicalProcessors[ 2] = 0x00000004 BitMask --> 000000000000000000000000000000000100 $aLogicalProcessors[ 3] = 0x00000008 BitMask --> 000000000000000000000000000000001000 $aLogicalProcessors[ 4] = 0x00000010 BitMask --> 000000000000000000000000000000010000 $aLogicalProcessors[ 5] = 0x00000020 BitMask --> 000000000000000000000000000000100000 $aLogicalProcessors[ 6] = 0x00000040 BitMask --> 000000000000000000000000000001000000 $aLogicalProcessors[ 7] = 0x00000080 BitMask --> 000000000000000000000000000010000000 $aLogicalProcessors[ 8] = 0x00000100 BitMask --> 000000000000000000000000000100000000 $aLogicalProcessors[ 9] = 0x00000200 BitMask --> 000000000000000000000000001000000000 $aLogicalProcessors[10] = 0x00000400 BitMask --> 000000000000000000000000010000000000 $aLogicalProcessors[11] = 0x00000800 BitMask --> 000000000000000000000000100000000000 $aLogicalProcessors[12] = 0x00001000 BitMask --> 000000000000000000000001000000000000 $aLogicalProcessors[13] = 0x00002000 BitMask --> 000000000000000000000010000000000000 $aLogicalProcessors[14] = 0x00004000 BitMask --> 000000000000000000000100000000000000 $aLogicalProcessors[15] = 0x00008000 BitMask --> 000000000000000000001000000000000000 $aLogicalProcessors[16] = 0x00010000 BitMask --> 000000000000000000010000000000000000 $aLogicalProcessors[17] = 0x00020000 BitMask --> 000000000000000000100000000000000000 $aLogicalProcessors[18] = 0x00040000 BitMask --> 000000000000000001000000000000000000 $aLogicalProcessors[19] = 0x00080000 BitMask --> 000000000000000010000000000000000000 $aLogicalProcessors[20] = 0x00100000 BitMask --> 000000000000000100000000000000000000 $aLogicalProcessors[21] = 0x00200000 BitMask --> 000000000000001000000000000000000000 $aLogicalProcessors[22] = 0x00400000 BitMask --> 000000000000010000000000000000000000 $aLogicalProcessors[23] = 0x00800000 BitMask --> 000000000000100000000000000000000000 $aLogicalProcessors[24] = 0x01000000 BitMask --> 000000000001000000000000000000000000 $aLogicalProcessors[25] = 0x02000000 BitMask --> 000000000010000000000000000000000000 $aLogicalProcessors[26] = 0x04000000 BitMask --> 000000000100000000000000000000000000 $aLogicalProcessors[27] = 0x08000000 BitMask --> 000000001000000000000000000000000000 $aLogicalProcessors[28] = 0x10000000 BitMask --> 000000010000000000000000000000000000 $aLogicalProcessors[29] = 0x20000000 BitMask --> 000000100000000000000000000000000000 $aLogicalProcessors[30] = 0x40000000 BitMask --> 000001000000000000000000000000000000 $aLogicalProcessors[31] = 0x80000000 BitMask --> 000010000000000000000000000000000000 $aLogicalProcessors[32] = 0x00000000 BitMask --> 000000000000000000000000000000000000 $aLogicalProcessors[33] = 0x00000000 BitMask --> 000000000000000000000000000000000000 $aLogicalProcessors[34] = 0x00000000 BitMask --> 000000000000000000000000000000000000 $aLogicalProcessors[35] = 0x00000000 BitMask --> 000000000000000000000000000000000000 - Default AffinityMask > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0xFFFFFFFF Process affinity mask BitMask --> 000011111111111111111111111111111111 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 24 $aLogicalProcessors[24] --> 0x01000000 - New AffinityMask ($iMask = 0x00000001) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00000001 Process affinity mask BitMask --> 000000000000000000000000000000000001 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 0 $aLogicalProcessors[0] --> 0x00000001 - New AffinityMask ($iMask = 0x00000002) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00000002 Process affinity mask BitMask --> 000000000000000000000000000000000010 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 1 $aLogicalProcessors[1] --> 0x00000002 - New AffinityMask ($iMask = 0x00000008) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00000008 Process affinity mask BitMask --> 000000000000000000000000000000001000 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 3 $aLogicalProcessors[3] --> 0x00000008 - New AffinityMask ($iMask = 0x00000030) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00000030 Process affinity mask BitMask --> 000000000000000000000000000000110000 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 4 $aLogicalProcessors[4] --> 0x00000010 - New AffinityMask ($iMask = 0x00000090) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00000090 Process affinity mask BitMask --> 000000000000000000000000000010010000 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 4 $aLogicalProcessors[4] --> 0x00000010 - New AffinityMask ($iMask = 0x00009800) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00009800 Process affinity mask BitMask --> 000000000000000000001001100000000000 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 11 $aLogicalProcessors[11] --> 0x00000800 - New AffinityMask ($iMask = 0x00001800) > $aAffinityMask[0] = True True on success, otherwise False > $aAffinityMask[1] = 0x00001800 Process affinity mask BitMask --> 000000000000000000000001100000000000 > $aAffinityMask[2] = 0xFFFFFFFF System affinity mask BitMask --> 000011111111111111111111111111111111 + Used ProcessorNumber = 11 $aLogicalProcessors[11] --> 0x00000800 ! $iMask (-1) ist zu klein! (1 to 68719476735 for 36 Logical Processors) +>07:08:39 AutoIt3.exe ended.rc:0 +>07:08:39 AutoIt3Wrapper Finished. >Exit code: 0 Time: 2.084
-
So, hatte nun endlich Zeit, den Code von Bitnugger einmal durchzutesten und bin auf das einfache Problem gestossen, dass ich logische Prozessoren >32 nicht setzen kann. Ich habe mit dem 18 Core und Hyperthreading 36 ausgewiesene logische Prozessoren. Alles bis $iLogicalProcessor32 (die ich vorher entsprechend definiert habe) funktioniert.
Weiss jemand, wie ich die Maske setzen muss, um die anderen Prozessoren zu setzen? Sorry, wenn ich danach so doof nachfrage, aber die bit-weisen operationen sind haben sich mir noch nicht erschlossen...
-
@bignugger: Danke auch für Deine Überarbeitung. Das ist natürlich etwas sorgfälter durchprogrammiert, als ich das hätte machen können. Super und schau ich mir gerne an.
-
Andy: Danke für die Erklärungen. Hab mir den Link auch noch angesehen, bin aber dafür dann doch zu wenig Experte um das im Detail zu verstehen. Was ich (glaube) verstanden zuhaben ist, dass der Scheduler der Flaschenhals ist. Da warten viele Kollegen auf Arbeit, aber der Chef kommt nicht nach die vielen Aufgaben zu verteilen. Die Möglichkeit, das stärker zu verteilen könnte ich natürlich machen, indem ich meinen 18-Kerner in mehrere Instanzen virtualisiere und auf jeder virtuellen Maschine ein eigenes Windows installiere. Das wird mir dann aber zu aufwändig und - wegen der Lizenzen - auch zu teuer. Das hier von mir aufgeführte Szenario mit den 15% ist ein Extremszenario und kommt so sehhhr selten zum Einsatz. Aber ich wollte das einmal besser verstehen, ob ich evtl. etwas übersehe. Habe also verstanden, dass ich hier nichts ändern kann bzw. dann sozusagen alles richtig gemacht habe.
Noch eine Verständnisfrage: In meinem Szenario ist vermutlich der Prozess, der das Display steuert am Anschlag (denn der ist mit den vielen abzuarbeitenden msg-Boxen voll beschäftigt). Der ist vermutlich nicht in verschiedene Threads parallelisiert, weswegen alle auf den Prozess warten. Damit wäre es wohl nicht der Scheduler, der überfordert ist, sondern eben doch der Window manager? Wenn also MS den Window manager elegant beschleunigen könnte, wäre das alle schneller?
-
Tja - ich habe ja das Thema eigentlich auf "Erledigt" gesetzt. Aber das ist es leider nicht. Denn so sehr ich mich nun darüber freue, dass ich die Prozesse den Cores zuordnen kann, erreiche ich damit nicht den gewünschten Effekt. Ich teste das gerade auf meinem 18-Kerner. Ich lasse gerade 36 instanzen parallel laufen (also 36 Instanzen meiner Software und 36 Instanzen der kompilierten AutoIt Steuerungen - jeweils zugeorndet auf einen anderen Kern). Theoretisch müsste das den Prozessor zu 100% auslasten. Tatsächlich werden schlappe 15% (!!) gebraucht. Ich habe die Einstellungen so gewählt, dass sehr viele msg-Boxen bearbeitet werden müssen. Und auf dem Desktop poppen fleissig fenster auf, die sofort abgearbeitet werden. Aber die Fenster werden reichlich "clumsy" angezeigt, also poppen auf und verschwinden irgendwie langsam, man kann fast zuschauen wie sie aufgebaut werden....
WARUM IST DAS SO LANGSAM??? CPU-Power ist mehr als genug da.
Wenn ich versuche, andere Fenster anzuklicken, geht das extrem langsam (also die visuelle Bestätigung funktioniert kaum und die Reaktion von Klicks sind ebenfalls entsprechend verlangsamt). Es wirkt irgendwie so als ist hier das Display der Flaschenhals? Zur Erinnerung: ich nutze den computer via Remote-Desktop.
Gibt es noch ideen, wie ich das beschleunigen kann oder ist das einfach so bei Windows?
-
Danke Andy und Bitnugger. Mein Ziel war immer nur, eine PID einem einzigen Prozessor zuzuordnen.
Wie muss der Code aussehen, damit ich bestimmen kann, welchem Prozessor (und eben nur diesem einen) ein Prozess zugeordnet werden soll???
Das ist mir nun mit folgender ganz einfachen Funktion gelungen (geht vermutlich noch reduzierter, aber aus meienr pragmatischen Sicht funktioniert das nun):
CodeFunc ProcessSetAffinity($iProcessID, $g_useCore) local $hPID = _WinAPI_OpenProcess($PROCESS_ALL_ACCESS, 0, $iProcessID, True) _WinAPI_SetProcessAffinityMask( $hPID, 2 ^ ($g_useCore - 1)) EndFunc
Getestet und funktioniert gut. Wie gesagt, mehr als einen core brauch ich ja nicht.
Danke an alle!
-
Danke danke für die Nachtarbeit, Bitnugger !
Ich hab das nun mit einer längeren Schleife versehen und dann kompiliert. So kann man im ProcessExplorer gut prüfen, welche Kerne verwendet werden.
Funktioniert leider nicht wie gewünscht: Bei der Anweisung unten wird nur core0 benutzt. Prima.
CodeGlobal $g_bAffinityMask = _UsedCoresToAffinityMask($g_iNumberCores, $iCore01), $g_iUsedCores = @extended ; Nur Core 1 benutzen
Bei der Anweisung unten wird aber nicht nur core 1 benutzt, sondern 1 und 3 !?
CodeGlobal $g_bAffinityMask = _UsedCoresToAffinityMask($g_iNumberCores, $iCore02), $g_iUsedCores = @extended ; Nur Core 2 benutzen
Und wenn ich $iCore03 einsetze, dann werden Core 2, 5 und 6 verwendet....
Irgendwas ist mit der Mask nicht gut?
-
hmm ok ... sorry, komme dem trotzdem nicht auf die Schliche (evtl. auch zu spät...).
Ich habe nun in die Funktion folgendes eingebaut:
Code; translate processornumber to bitmask Local $bProcessor = Int("'" & StringReplace(_StringRepeat("0", $NumberCores), $NumberCores - $iProcessor + 1, '1', 1)& "'" )
und übergebe dann später $bProcessor anstelle von $iProcessor
CodeLocal $aAffinity = DllCall($hDLL, 'int', 'SetProcessAffinityMask', 'int', $aProcessHandle[0], 'int', $bProcessor)
Aber wenn ich dann im Taskmgr schaue, sind alle CPU's selektiert. Bei 1 und 2 funktioniert das allerdings prima (habe das in einer VM mit 8 CPU's in der VM laufen) ....
Kannst du mir hier etwas im Code helfen?
-
Hallo nochmal. Ich habe nun versucht, meine Prozesse an einen Prozessor zu binden. Ich habe Rechner mit 4, 8 und 18 Kernen (durch HT, also 8,16 und 36 "Prozessoren"). Ich habe mit der Funktion unten erste Versuche gemacht, aber es gelingt mir nicht, die "affinity Mask" richtig zu setzen. Wie muss der Code aussehen, damit ich bestimmen kann, welchem Prozessor (und eben nur diesem einen) ein Prozess zugeordnet werden soll???
Also die Funktion
möchte ich den ProzessID mitgeben und anschliessend, auf welchem Prozessor der Prozess gemappt werden soll. Die funktion erwartet aber schon eine Affinity Mask (glaube ich), von der ich nicht weiss, wie ich die korrekt erstellen soll
Danke schon einmal..
Code
Alles anzeigen;; Function ProcessSetAffinity ;; ;; Inputs: ;; iProcessID - the PID of the process to change affinity ;; iProcessor - the integer value of the binary affinity bitmask (see below) ;; ;; Results: ;; Returns -1 and sets @error = 1 if the process doesn't exist ;; Returns -1 and sets @error = 2 if this script isn't able to get sufficient access to the process handle ;; Returns 1 if the affinity was set to your request ;; Returns 0 if the affinity could not be set ;; ;; How Affinity Bitmasks Work: ;; ;; Bitmasks are a binary representation of what processor(s) a thread or process is allowed to run on ;; One binary digit per CPU, a zero means it -cannot- run on that CPU, a one means it -can- run on that CPU ;; So, if your machine has two processors: ;; ;; Binary | Integer | Description ;; 01 = 1 = Can run on the first CPU, but not the second ;; 10 = 2 = Can run on the second CPU, but not the first ;; 11 = 3 = Can run on the first and second CPU's ;; ;; If your machine had four processors: ;; ;; 0001 = 1 = Can run on the first CPU, but not the second, third or fourth ;; 0010 = 2 = Can run on the second CPU, but not the first, third or fourth ;; 0011 = 3 = Can run on the first and second CPU's, but not the third or fourth ;; 0100 = 4 = Can run on the third CPU, but not the first, second or fourth ;; 0101 = 5 = Can run on the first and third CPU's, but not the second or fourth ;; ... (continued ad-nauseum) Func ProcessSetAffinity($iProcessID,$iProcessor = 1) Local $func = "ProcessSetAffinity " ; translate processornumber to bitmask local $bProcessor = StringReplace(_StringRepeat("0", $NumberCores),$NumberCores-$iProcessor+1,'1',1) Local $i_PID = ProcessExists($iProcessID) If Not $i_PID Then SetError(1) Return -1 EndIf Local $hDLL = DllOpen('kernel32.dll') Local $aProcessHandle = DllCall($hDLL, 'int', 'OpenProcess', 'int', 0x0200, 'int', False, 'int', $i_PID) if $aProcessHandle[0] = 0 Then SetError(2) Return -1 EndIf Local $aAffinity = DllCall($hDLL, 'int', 'SetProcessAffinityMask', 'int', $aProcessHandle[0], 'int', $bProcessor) DllCall($hDLL, 'int', 'CloseHandle', 'int', $aProcessHandle[0]) DllClose($hDLL) Return $aAffinity[0] EndFunc ;==>ProcessSetAffinity
-
Während eine MsgBox aktiv angezeigt wird, wartet diese Programminstanz auf das schliessen und dieses Warten erzeugt natürlich keine Prozessorlast. Du kannst aber den TimeOut Parameter von MsgBox verwenden um die MsgBox automatisch zu beenden.
Danke, autoBert. Die Messageboxen kommen nicht von AutoIt, sondern vom zu automatisierenden Programm. Mein Script braucht keinerlei Input "von aussen".
Andy: die Sache mit dem Scheduler könnte hinkommen. Mir ist allerdings nicht klar, was ein Verschieben verursacht: Wenn die Berechnungen lang sind und wenige msg-Boxen vom Programm (nicht AutoIt) komme ich auf 100% CPU-Auslastung. Lang heisst: 5 sek Formulare ausfüllen und msg-boxen bedienen und dann so 10 min. rechnen. Bei 40 Instanzen ist dann "nicht so viel auf dem Bildschirm los". Wenn die Berechnungen kürzer ausfallen, scheint windows zu beschäftigt, wartet oder sonst was. Ich schau mal, womit ich sehe, auf welcher CPU ein Prozess grad läuft und ob der oft wechselt. Wenn das der Fall wäre, könnte ich ja evtl. die CPU-ID fest einstellen....
-
Hallo miteinander,
Ich habe eine etwas unübersichtliche Fragestellung und weiss nicht, wo ich genau anfangen soll:
Ich automatisiere eine Software, welche für mich Berechnungen durchführt. Für die Vorbereitung der Berechnungen müssen verschiedene Daten in Formulare geschrieben werden und es müssen eine Reihe von Message-boxen (der Software) behandelt werden. Dann erfolgt die Berechnung - währenddem wartet mein (kompiliertes) Script auf ein Ergebnisfenster. Sobald das da ist, werden Ergebnisse verarbeitet und anschliessend geht der Zirkus von vorne los (Formular einfüllen, msg-boxen bearbeiten und wieder rechnen).
Soweit alles prima - läuft flüssig und Fehlerfrei.
Um die Rechenleistung optimal zu nutzen, habe ich mehrere Instanzen (insgesamt 40) der Software parallel laufen. Für jede Instanz läuft ein eigenes Script, welches die zugehörigen Fenster, msg-boxen etc. korrekt der "eigenen" Instanz zuornet und diese parallel behandelt.
Auch alles prima - läuft auch flüssig und Fehlerfrei.
Das ganze läuft bei mir auf einem separaten Windows Rechner (Intel 18-Kerner mit 40 Programminstanzen und jeweils 40 zugehörigen Scripten). Auf den Rechner greife ich via Remote-Desktop zu.
Wenn die verschiedenen Instanzen gleichzeitig viele Msg-Boxen anzeigen sehe ich, dass "das System langsam wird". D. h. es geht die Prozessornutzung runter, weil wohl zu viel auf die Bearbeitung am Bildschirm wartet (?). Wenn der "Stau" auf dem Bildschirm nicht so gross ist, habe ich 100% Prozessorlast, wenn aber viel los ist, geht die Prozessornutzung runter.
Ich habe schon alle Anzeige-eigenschaften so einfach wie möglich eingestellt (also Fensterinhalt nicht mit Fenster verschieben etc.). Nun frage ich mich, ob ich die Abarbeitung der msg-boxen irgendwie beschleunigen kann. Klar kann ich die verschiedenen Sleep-Zeiten in Autoit anpassen, das ist es aber nicht, sondern irgendwo gibt es da einen Stau innerhalb von Windows.
Mir ist schon klar, dass die Konstellation mit den vielen instanzen eher speziell ist, aber wie gesagt, funktioniert fehlerfrei (hat mich auch 2 Jahre gebraucht, das so hinzukriegen...).
Hat mir jemand Hinweise, wo ich da eventuell im Windows hingreifen könnte?
Danke für Eure Hilfe und Grüsse
-ovik
-
Hallo zusammen,
Kann mir jemand einen Hinweis geben, wie ich die Reihenfolge der Icons in der Taskleiste mit AutoIt verändern kann? Ich habe weder eine Möglichkeit in AutoIt noch irgendein anderes externes Programm gefunden, mit dem ich diese Reihenfolge automatisch verändern kann. Hintergrund ist folgender: ich starte und stoppe mehrere Instanzen eines Programmes immer wieder. Die Instanzen erscheinen als Icons mit text in der Taskleiste (z.B. "Prog-1" für erste Instanz, "Prog-2" für zweite Instanz usw.). In der Summe können das bis zu 40 Instanzen sein, die ich gelegentlich direkt aufrufen muss. Durch starten und stoppen der Instanzen geht in der Taskleiste alles komplett durcheinander. Gruppieren etc. ist keine Option. Daher würde ich das Durcheinander von Zeit zu Zeit gerne mit AutoIt wieder "in Ordnung" bringen.
Gibt es hier irgendwelche Ideen?
Danke und Grüsse