Und @Scriptdir?
Wo liegt das?
Wenn du den Ordner freigegeben hast, kann es passieren das die Nutzerrechte zurückgesetzt werden.
Also einmal die Rechte des Ordner prüfen ob ServiceAccount die nötigen Rechte darauf besitzt.
Beiträge von AspirinJunkie
-
-
Der Pfad hat zwei Backslashes.
Mal mit FileExists vor dem RunAs geprüft ob die Datei mit diesem Pfad gefunden wird?Gib auch mal den Pfad von @ScriptDir mit aus.
Wenn sich das Skript in einem User-Verzeichnis des aktuellen Nutzers befindet, kann der aufgerufene Nutzer nicht darauf zugreifen. -
Error-Code 267 von RunAs heißt: "The directory name is invalid".
Und wenn du dir deinen Aufruf (den 5. Parameter von RunAs) mal per msgbox oder consolewrite ausgibst, solltest du ganz schnell feststellen wo das Problem liegt.Überhaupt das wichtigste: Debuggen.
Lass dir schrittweise mal alles ausgeben. -
Warum reden hier alle von Parallelisierung?
Es ist in nativem AutoIt nicht möglich (zumindestens kein Threading).Damit kann man, gerade Algoryhtmen, bis zum Faktor 3 bis 4 beschleunigen OHNE große Eingriffe im Algo selber durchführen zu müssen.
Und dann wundern wenn dauernd falsche Ergebnisse zurückkommen...
Parallelisierung ist selten so einfach wie die meisten denken.
Einfach mal ein OpenMP-Tutorial durchlesen und seine Schleife parallelisieren führt selten zu einer linearen Skalierung mit den Threads.
Optimierung auf paralleler Ebene ist eben nochmal ein ganz anderer Schuh.In anderen Fällen stimmt das Ergebnis auf einmal nicht mehr.
Man sollte niemanden leichtfertig den Tipp geben, dass er seine Programme mit Parallelisierung mal ganz einfach um mehrere Vielfache beschleunigen kann ohne ihm vorher die Begriffe race condition, lost update oder Cache-Kohärenz zu erklären...Da es vorhin schon angesprochen wurde möchte ich es auch nochmal aufgreifen.
Wenn man seine Programme optimieren will setzt man nicht einfach irgendwelche Tricks in seinem Programm um, sondern man beginnt mit einem Profiling (und zieht das den gesamten Optimierungsprozess auch durch).
Die Teile, welche als relevant detektiert wurden, werden dann erst einmal auf Algorithmenebene optimiert bevor man die hier vorgestellten Tipps anwendet.
Aber einfach nach dem Gießkannenprinzip alle Performancetipps auf das Skript verteilen hat mit Optimierung nicht wirklich viel zu tun. -
Hier mal ein paar weitere Methoden. Diesmal thematisch jedoch eher durcheinander:
inline functions
Jeder Aufruf einer Funktion bedingt einen Overhead welcher das Skript verlangsamt. Gerade bei kleineren Funktionen welche nicht oft im Code aufgerufen werden bietet es sich an deren Inhalt direkt in den Code zu schreiben um den Funktionsoverhead zu vermeiden.
Beispiel (erstes Array-Element bis zum Ende durchreichen)
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]For $i = 1 To $N
[/autoit] [autoit][/autoit] [autoit]
__swap($A, $i, $i - 1)
Next; tauscht zwei Elemente in einem Array
[/autoit] [autoit][/autoit] [autoit]
Func __swap(ByRef $A, Const $i, Const $j)
Local Const $t = $A[$i]
$A[$i] = $A[$j]
$A[$j] = $t
EndFunc ;==>__swap; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]Global $t
[/autoit]
For $i = 1 To $N
$t = $A[$i]
$A[$i] = $A[$i - 1]
$A[$i - 1] = $t
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 1 To $N
__swap($A, $i, $i - 1)
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "Mit Funktionsaufruf", $iT))$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
Global $t
For $i = 1 To $N
$t = $A[$i]
$A[$i] = $A[$i - 1]
$A[$i - 1] = $t
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "Inline-function", $iT)); tauscht zwei Elemente in einem Array
[/autoit]
Func __swap(ByRef $A, Const $i, Const $j)
Local Const $t = $A[$i]
$A[$i] = $A[$j]
$A[$j] = $t
EndFunc ;==>__swapKurzschlussauswertung (short-circuit-evaluation
Bei bedingten Ausdrücken mit logischem "and" oder "or" wird zur Prüfung der Bedingung "x and y" immer erst beide Seiten ausgewertet bevor die Entscheidung zur Annahme fällt oder nicht. Wenn aber x schon nicht true ergibt, braucht man eigentlich y nicht mehr auszuwerten denn der Gesamtausdruck kann gar nicht mehr wahr werden. Die Idee hinter der short-circuit-evaluation ist es daher die logischen Ausdrücke in verschachtelte If-Else-Verzweigungen so umzuwandeln, dass die Auswertung der Einzelausdrücke nur dann gemacht wird wenn es auch sinnvoll ist.
Beispiel (Gemeinsames Vielfaches von 3 und 5)
[autoit]#Region Short-Circuit-Optimierung für And-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]If (Mod($i, 5) = 0) And (Mod($i, 3) = 0) Then
[/autoit] [autoit][/autoit] [autoit]
$x = $i
EndIf; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]If Mod($i, 5) = 0 Then
[/autoit] [autoit][/autoit] [autoit]
If Mod($i, 3) = 0 Then
$x = $i
EndIf
EndIf#EndRegion Short-Circuit-Optimierung für And-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]#Region Short-Circuit-Optimierung für Or-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]If (Mod($i, 5) = 0) Or (Mod($i, 3) = 0) Then
[/autoit] [autoit][/autoit] [autoit]
$x = $i
EndIf; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]If Mod($i, 5) = 0 Then
[/autoit] [autoit][/autoit] [autoit]
$x = $i
ElseIf Mod($i, 3) = 0 Then
$x = $i
EndIf#EndRegion Short-Circuit-Optimierung für Or-Verknüpfung
[/autoit]Zeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $x#Region Short-Circuit-Optimierung für And-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
If (Mod($i, 5) = 0) And (Mod($i, 3) = 0) Then
$x = $i
EndIf
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "Logisches Und", $iT))$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
If Mod($i, 5) = 0 Then
If Mod($i, 3) = 0 Then
$x = $i
EndIf
EndIf
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "If-Else", $iT))#EndRegion Short-Circuit-Optimierung für And-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]#Region Short-Circuit-Optimierung für Or-Verknüpfung
[/autoit] [autoit][/autoit] [autoit]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
If (Mod($i, 5) = 0) Or (Mod($i, 3) = 0) Then
$x = $i
EndIf
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "Logisches Or", $iT))$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
If Mod($i, 5) = 0 Then
$x = $i
ElseIf Mod($i, 3) = 0 Then
$x = $i
EndIf
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "If-ElseIf", $iT))#EndRegion Short-Circuit-Optimierung für Or-Verknüpfung
[/autoit]For-To vs. For-In
Wenn man über alle Elemente eines Arrays lesend iterieren möchte, bieten sich sowohl eine For-To-Schleife als auch eine For-In-Schleife an. Bei der For-In wird das jeweils aktuelle Element in die Iterationsvariable kopiert (deswegen nur lesender Zugriff) während man bei For-To mit dem Array-Index arbeit. Machen wir es kurz: For-In ist in AutoIt schneller. Das ist aber nur bei Sprachen wie Autoit der Fall weil dabei der Elementzugriff in nativen Code erfolgt anstatt in noch zu interpretierendem AutoIt-Code. In Sprachen wie C++ oder ähnlichen ist es hingegen langsamer, da noch eine Variablenzuweisung pro Schleifendurchlauf hinzukommt.
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $xFor $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$x = $A[$i]
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]For $i In $A
[/autoit]
$x = $i
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $x$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$x = $A[$i]
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "For-To", $iT))$iT = TimerInit()
[/autoit]
For $i In $A
$x = $i
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "For-In", $iT))Operatoren wie "^" durch weniger aufwendige Berechnungen ersetzen
Manche Operatoren können in einigen Fällen durch mathematisch äquivalente aber schnellere Ausdrücke ersetzt werden. Bekanntestes Beispiel wäre z.B. x^2 durch x*x zu ersetzen. Da der ^-Operator intern über eine Schleife berechnet (ich weiß es nicht genau) ist die Multiplikation in dem Fall schneller. In anderen Sprachen werden oftmals vor allem Integerberechnungen durch weitaus schnellere Bit-Operationen ersetzt (hier eine Auswahl: >>Link<<) . In AutoIt sind die Bit-Operationen aber als Funktionen implementiert, weswegen deren Overhead durch den Funktionsaufruf den Performancevorteil in der Regel wieder auffrisst.
Beispiel
[autoit]$x = $i^2
[/autoit] [autoit][/autoit] [autoit]; ist equivalent zu
[/autoit] [autoit][/autoit] [autoit]$x = $i*$i
[/autoit]Zeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $x$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$x = $i^2
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "^-Operator", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
$x = $i*$i
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Multiplikation", $iT))Hartkodierte Konstanten
Wenn man Konstanten definiert kann man anstatt auf Ihren Wert per Variablennamen zuzugreifen auch direkt ihren Wert eintragen.
Beispiel
[autoit]Global Const $PI = ACos(-1)
[/autoit] [autoit][/autoit] [autoit]$x = $i * $PI
[/autoit] [autoit][/autoit] [autoit]; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]$x = $i * 3.14159265358979
[/autoit]Zeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global Const $PI = ACos(-1)
Global $x$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$x = $i * $PI
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Konstante Variable", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
$x = $i * 3.14159265358979
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Direktes Einsetzen ", $iT))Auf den Datentyp achten
Integerberechnungen sind (in der Regel) schneller als Float-Berechnungen. Wenn man keine Nachkommastellen benötigt, sollte man auch nicht mit Floats rechnen.
Beispiel
[autoit]; Integer-Schleife
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
Next; vs.
[/autoit] [autoit][/autoit] [autoit]; Float-Schleife:
[/autoit]
For $i = 0.0 To $N
NextZeitmessung
[autoit]Global $N = 1e7
[/autoit] [autoit][/autoit] [autoit]; Integer-Schleife
[/autoit] [autoit][/autoit] [autoit]
$iT = TimerInit()
For $i = 0 To $N
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Integer", $iT)); Float-Schleife:
[/autoit]
$iT = TimerInit()
For $i = 0.0 To $N
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Float", $iT))Temporäre Variablen vermeiden
Anstatt Ausdrücke erst in eine Variable auszuwerten und dann weiterzuverwenden, kann man sie auch direkt in den Zielausdruck einfügen.
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $x, $tFor $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$t = $A[$i]
$x = $t
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]For $i = 0 To $N
[/autoit]
$x = $A[$i]
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $x, $t$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$t = $A[$i]
$x = $t
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Temporäre Variable", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
$x = $A[$i]
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Direktes Einsetzen ", $iT))2D-Arrays vs. multiple 1D-Arrays
Anstatt eines großen 2D-Arrays kann es der Performance zuträglich sein, wenn man die Spalten des 2D-Arrays als separate 1D-Arrays vorhält.
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1][3]
Global $X[$N + 1]
Global $Y[$N + 1]
Global $Z[$N + 1]For $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$A[$i][0] = $A[$i][1] + $A[$i][2]
Next; vs.
[/autoit] [autoit][/autoit] [autoit]For $i = 0 To $N
[/autoit]
$X[$i] = $Y[$i] + $Z[$i]
NextZeitmessung
[autoit]#Region 2D-Array vs. multiple 1D Arrays
[/autoit] [autoit][/autoit] [autoit]
Global $N = 1e6
Global $A[$N + 1][3]
Global $X[$N + 1]
Global $Y[$N + 1]
Global $Z[$N + 1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$A[$i][0] = $A[$i][1] + $A[$i][2]
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "2D Array", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
$X[$i] = $Y[$i] + $Z[$i]
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "1D Arrays", $iT))
#EndRegion 2D-Array vs. multiple 1D ArraysFunktionsparameter By Reference vs. By Value
Funktionsparameter werden in AutoIt standardmäßig als "By-Value" übergeben. Das heißt, für die Funktion wird eine Kopie der Variable erstellt. Dies ist oftmals unnötig oder sogar kontraproduktiv wenn man z.B. die Werte direkt in der Funktion ändern möchte. Daher gibt es in AutoIt das Schlüsselwort "ByRef" mit welchem man die Parameter als By-Reference markieren kann. Das erspart dem Skript das Kopieren des Wertes und man kann die Ausgangsvariablen direkt bearbeiten.
Beispiel
[autoit]Global $A[10]
[/autoit] [autoit][/autoit] [autoit]
Global $x$x = _A($A, 5)
[/autoit] [autoit][/autoit] [autoit]; Aufruf mit Array per By-Value
[/autoit] [autoit][/autoit] [autoit]
Func _A($A, $i)
Return $A[$i]
EndFunc; vs.
[/autoit] [autoit][/autoit] [autoit]$x = _B($A, 5)
[/autoit] [autoit][/autoit] [autoit]; Aufruf mit Array per By-Reference
[/autoit]
Func _B(ByRef $A, $i)
Return $A[$i]
EndFuncZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]
Global $A[10]
Global $x$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 1 To $N
$x = _A($A, 5)
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "By-Value", $iT))$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]
For $i = 1 To $N
$x = _B($A, 5)
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("%30s: %8.4f ms\n", "By-Reference", $iT)); Aufruf mit Array per By-Value
[/autoit] [autoit][/autoit] [autoit]
Func _A($A, $i)
Return $A[$i]
EndFunc; Aufruf mit Array per By-Reference
[/autoit]
Func _B(ByRef $A, $i)
Return $A[$i]
EndFunc -
Na dann denke ich wir fangen am besten mal mit dem Thema Schleifenoptimierung an, da dort wohl eine Menge Potential schlummert.
Ich gehe einfach mal einige übliche Optimierungen durch. Ich zeige dabei jeweils erst die unoptimierte Variante und dem gegenüber die optimierte. Nicht alles bringt auf AutoIt etwas (besonders die für Cache-optimierenden Verfahren). Deswegen hänge ich immer direkt daran ein kleines Testskript wo man das Potential bei sich selbst schnell ermitteln kann.Fangen wir an:
Loop-unrolling
Ziel ist es die Anzahl der Schleifendurchläufe zu verringern. In der Theorie ist das ganze schneller, da die Anzahl der Prüfungen der Schleifenbedingungen geringer sind und somit weniger Overhead entsteht. Das ganze geht aber einher mit einer Vervielfachung von Code und funktioniert nur, wenn die obere Schleifengrenze ein Vielfaches des "unroll factor" ist. In AutoIt bringt dieses Verfahren eher nix und kann das Skript sogar verlangsamen.
Beispiel
[autoit]Global $N = 1e4 + 3
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]For $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$A[$i] = "x"
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]For $i = 0 To $N Step 4
[/autoit]
$A[$i] = "x"
$A[$i + 1] = "x"
$A[$i + 2] = "x"
$A[$i + 3] = "x"
NextZeitmessung
[autoit]Global $N = 1e6 + 3
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$A[$i] = "x"
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Normale Schleife", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N Step 4
$A[$i] = "x"
$A[$i + 1] = "x"
$A[$i + 2] = "x"
$A[$i + 3] = "x"
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Optimierte Schleife", $iT))Loop Interchange
Ziel ist es, bei verschachtelten Schleifen, die Anzahl der Schleifeninitialisierungen, und damit Overhead, zu verringern. Unterscheiden sich die Anzahlen der Schleifendurchläufe der inneren und der äußeren Schleife stark, macht es Sinn die Schleife mit der kleineren Anzahl nach außen zu holen um somit die Anzahl der inneren Schleifenaufrufe zu minimieren. Heißt: Die Anzahl der Schleifeninitialisierungen wird verringert, die Anzahl der gesamten Schleifendurchgänge bleibt dennoch konstant.
Beispiel
[autoit]Global Const $u = 1e2 ; klein
[/autoit] [autoit][/autoit] [autoit]
Global Const $v = 1e6 ; großFor $i = 1 To $v
[/autoit] [autoit][/autoit] [autoit]
For $j = 1 To $u
Next
Next; ist equivalent zu (wenn in der Schleife keine Abhängigkeiten vorhanden sind):
[/autoit] [autoit][/autoit] [autoit]For $j = 1 To $u
[/autoit]
For $i = 1 To $v
Next
NextZeitmessung
[autoit]Global Const $u = 1e2
[/autoit] [autoit][/autoit] [autoit]
Global Const $v = 1e6$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 1 To $v
For $j = 1 To $u
Next
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Innen klein", $iT))$iT = TimerInit()
[/autoit]
For $j = 1 To $u
For $i = 1 To $v
Next
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Außen klein", $iT))Array Cache-Order Looping
Diese Optimierung kann sich mit dem, eben erwähnten, "Loop-unrolling" widersprechen. Wenn Elemente hintereinander im Speicher stehen und einzeln abgearbeitet werden, holt die CPU diese nicht einzeln aus dem Speicher sondern lädt gleich einen Block von Ihnen in seinen Cache und kann die nächsten Elemente so deutlich schneller abarbeiten. Es macht also Sinn seine Schleifen so aufzubauen, dass nacheinander Elemente abgearbeitet werden welche auch hintereinander im Speicher stehen. Besonders bei 2D-Arrays taucht daher die Frage auf: Gehe ich das Array zeilen- oder spaltenweise durch? C speichert z.B. seine Arrays reihenweise hintereinander (row-major-order) während Fortran diese spaltenweise hintereinander schreibt (column-major-order). In AutoIt ist die Sache durch den Variant-Datentyp zwar nicht ganz ideal für Cache-Optimierung aber prinzipiell sollte man AutoIt für C-Order (row-major) hin optimieren.
Beispiel
[autoit]Global $N = 1000
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1][$N+1]Global $x
[/autoit] [autoit][/autoit] [autoit]; optimal für column-major-order:
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
For $j = 0 To $N
$x = $A[$j][$i]
Next
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]; optimal für row-major-order:
[/autoit]
For $i = 0 To $N
For $j = 0 To $N
$x = $A[$i][$j]
Next
NextZeitmessung
[autoit]Global $N = 3500
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1][$N+1]Global $x
[/autoit] [autoit][/autoit] [autoit]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
For $j = 0 To $N
$x = $A[$j][$i]
Next
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Column-Major-Loop", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
For $j = 0 To $N
$x = $A[$i][$j]
Next
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Row-Major-Loop", $iT))Loop fusion
Wenn man zwei voneinander unabhängige Schleifen mit dem selben Iterationsbereich hat lohnt es sich diese beiden zu kombinieren um somit den Schleifenoverhead zu halbieren. Das Gegenteil "loop fission" (also eine Schleife in mehrere aufteilen) kann skurrilerweise auch den Code beschleunigen, nämlich wenn dadurch Elemente cache-optimiert abgearbeitet werden können während sie sich in der kombinierten Schleife gegenseitig um den Cache prügeln.
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $B[$N + 1]For $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$A[$i] = "x"
Next
For $i = 0 To $N
$B[$i] = "x"
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]For $i = 0 To $N
[/autoit]
$A[$i] = "x"
$B[$i] = "x"
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $B[$N + 1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$A[$i] = "x"
Next
For $i = 0 To $N
$B[$i] = "x"
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Zwei Schleifen", $iT))$iT = TimerInit()
[/autoit]
For $i = 0 To $N
$A[$i] = "x"
$B[$i] = "x"
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 20s: %8.4f ms\n", "Kombinierte Schleife", $iT))Loop peeling
Manche Schleifen, besonders welche, deren Werte iterativ aufeinander aufbauen, erfordern eine gesonderte Behandlung der ersten Werte. Vielfach wird einfach in der Schleife eine Abfrage hierfür eingebaut oder die Berechnung wird durch aufwändigere Konstrukte oder Hilfsvariablen realisiert. Einfacher und performanter ist es jedoch oft, die Behandlung der Spezialfälle aus der Schleife zu nehmen und die eigentliche Schleife damit zu vereinfachen.
Beispiel
[autoit]Global $N = 1e5
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1]For $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
If $i = 0 Then
$A[$i] = 0
Else
$A[$i] = $i + $A[$i-1]
EndIf
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]$A[0] = 0
[/autoit]
For $i = 1 To $N
$A[$i] = $i + $A[$i-1]
NextZeitmessung
[autoit]Global $N = 1e4
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
If $i = 0 Then
$A[$i] = 0
Else
$A[$i] = $i + $A[$i-1]
EndIf
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Sonderbehandling in Schleife", $iT))$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
$A[0] = 0
For $i = 1 To $N
$A[$i] = $i + $A[$i-1]
Next
$iT = TimerDiff($iT)ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Sonderbehandlung außerhalb der Schleife", $iT))
[/autoit]loop invariant variables
Die meiner Meinung nach wichtigste Regel bei der Codeoptimierung lautet: Was du einmal berechnet/ermittelt hast, hebe dir für die spätere Verwendung auf anstatt es neu zu berechnen. Angewandt auf Schleifen heißt das: Ausdrücke, deren Wert innerhalb einer Schleife konstant bleiben ("loop invariant") sollten aus der Schleife herausgeholt werden.
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1]For $i = 0 To $N
[/autoit] [autoit][/autoit] [autoit]
$A[$i] = $i * 2 * ACos(-1)
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]Global Const $2Pi = 2 * ACos(-1)
[/autoit]
For $i = 0 To $N
$A[$i] = $i * $2Pi
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N+1]$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$A[$i] = $i * 2 * ACos(-1)
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Neuberechnung von 2Pi", $iT))$iT = TimerInit()
[/autoit]
Global Const $2Pi = 2 * ACos(-1)
For $i = 0 To $N
$A[$i] = $i * $2Pi
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Wiederverwendung von 2Pi", $iT))strength reduction
Schleifen kann man dazu nutzen Ausdrücke in iterative Ausdrücke so umzuschreiben, dass ihre Berechnung pro Durchgang weniger aufwändig wird. So bietet es sich z.B. oft an, Multiplikationen der Iterationsvariable durch eine Addition (mit Hilfe einer Hilfsvariablen) zu ersetzen:
Beispiel
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $x$x = 4 ; der Multiplikationsfaktor
[/autoit] [autoit][/autoit] [autoit]
For $i = 0 To $N
$A[$i] = $x * $i
Next; ist equivalent zu:
[/autoit] [autoit][/autoit] [autoit]$x = 0
[/autoit]
For $i = 0 To $N
$A[$i] = $x
$x += 4
NextZeitmessung
[autoit]Global $N = 1e6
[/autoit] [autoit][/autoit] [autoit]
Global $A[$N + 1]
Global $x$iT = TimerInit()
[/autoit] [autoit][/autoit] [autoit]
$x = 4 ; der Multiplikationsfaktor
For $i = 0 To $N
$A[$i] = $x * $i
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Multiplikation", $iT))$iT = TimerInit()
[/autoit]
$x = 0
For $i = 0 To $N
$A[$i] = $x
$x += 4
Next
$iT = TimerDiff($iT)
ConsoleWrite(StringFormat("% 30s: %8.4f ms\n", "Addition", $iT)) -
Ich denke die wichtigste Regel sollte sein, dass man immer erst zu erst auf Algorithmenebene optimieren sollte bevor man sich an die Optimierung auf der Codeebene macht.
Die Frage ob man 20 ms bei 1000 Schleifendurchgängen rausholen kann durch z.B. eine For-To statt While-Schleife wird hinfällig wenn man den Programmablauf auch so realisieren kann, dass man nur 100 Schleifendurchgänge braucht. -
und sogar noch sortiert
Tatsache - und war gar nicht beabsichtigt

Brachte das Dictionary-Objekt mit sich. -
Spoiler anzeigen
[autoit]$hFile = FileOpen("Test.csv")
[/autoit] [autoit][/autoit] [autoit]
If @error Then Exit$dic_Paare = ObjCreate("Scripting.Dictionary")
[/autoit] [autoit][/autoit] [autoit]; Dictionary mit Paaren als Schlüssel und Nummern als Werte:
[/autoit] [autoit][/autoit] [autoit]
FileReadLine($hFile) ; erste Zeile überspringen (Überschrift)
Do
$s_Line = FileReadLine($hFile)
If @error Then ExitLoop$a_Split = StringSplit($s_Line, ";", 2)
[/autoit] [autoit][/autoit] [autoit]
If UBound($a_Split) < 3 Then ContinueLoop$key = $a_Split[1] & $a_Split[2]
[/autoit] [autoit][/autoit] [autoit]
$dic_Paare($key) = $dic_Paare.Exists($key) ? $dic_Paare($key) & "," & $a_Split[0] : $a_Split[0]
Until 0
FileClose($hFile); Dictionary wieder auslesen:
[/autoit]
For $i in $dic_Paare.Keys()
ConsoleWrite($i & "=" & $dic_Paare($i) & @CRLF)
NextEin Dictionary ist hierfür ideal, da man hier einem Schlüsselwert (deine 94) dynamisch Werte zuweisen möchte.
-
Weshalb wird in meinem Script der Schlüssel gewechselt und wie kann ich das unterbinden?
Weil du ein 64-Bit Windows betreibst, dein Skript aber als x86-Skript ausführst/kompilierst.
Windows lenkt auf 64-Bit-Systemen Registry-Aufrufe von x86-Programmen automatisch auf Wow6432Node um, damit diese sich nicht mit denen x64-Programme ins Gehege kommen.
Für das Programm (in deinem Fall dein AutoIt-Skript) sieht es dennoch so aus, als würde es in die normalen Pfade schreiben.Wie kann man das umgehen? - zwei Möglichkeiten:
- Programm als x64-Skript ausführen/kompilieren
- Mal die Hilfe zu RegWrite() lesen: >>Klickmich<<
-
Einfach mal ins Blaue geraten wegen der Verzeichnisse: Keine Rechte als Normaluser für die Verzeichnisse?
Also mal oben ein #RequireAdmin in das Skript und das Skript als Admin-Dienst eintragen. -
Ok zusammengefasst: Du hast ein x64-Windows und dein Skript wird als x86-Skript ausgeführt.
In dem Falle gibt es im Grunde genommen "zwei Registries" - eine für die x64-Programme und eine für die x86-Programme.
Umgesetzt wird dies, in dem die Einträge der x86 Programme nach Wow6432Node umgeleitet werden.Es gibt nun mehrere Möglichkeiten wie du den richtigen Pfad beschreiben kannst.
Erste Methode: Skript als x64 kompilieren.
Zweite Methode: Statt HKLM\ im Pfad HKLM64\ schreiben (Siehe Hilfe zu Regwrite). -
Schau mal per regedit.exe nach ob dein Eintrag unter "HKLM\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\OEMInformation" erstellt wurde.
-
Sofern ich in der Registry die Testdatei (ich hab mal nssm.exe zum Verusuch genommen) gegen meine kompilierte Script .exe austausche kommt die Fehlermeldung direkt...
Ich glaube du hast da etwas missverstanden. Du sollst nicht statt deiner exe die nssm.exe manuell als Dienst eintragen, sondern per NSSM.exe (einfach mal die exe ausführen) dein Programm als Dienst einrichten und schauen ob es dann funktioniert. Und eben nicht mehr mit srvany arbeiten - nur noch mit NSSM.
-
Dein Beispiel ist immer noch nicht nachvollziehbar.
Was ist das für ein Objekt?
Hat das Objekt einen Iterator implementiert (wichtig für For-In-Schleifen)?
Wie sind die Objekte verschachtelt - By-Reference oder By-Value?Aus den Codefetzen die du gepostet hast ist das nicht ersichtlich.
Vor allem da die Funktionen _AttribRules() und _Tree_Object() fehlen.Ich kann deine Frage daher nur allgemein beantworten:
[autoit]
Ja Objekte kann man verschachteln und mit For-In-Schleifen wieder auslesen:; Unterdictionary erstellen und füllen
[/autoit][autoit][/autoit][autoit]
$dic_Unter = ObjCreate("Scripting.Dictionary")
$dic_Unter("Wert 1") = "Test 1"
$dic_Unter("Wert 2") = "Test 2"
$dic_Unter("Wert 3") = "Test 3"; Oberdictionary erstellen und Unterdictionary hinzufügen:
[/autoit][autoit][/autoit][autoit]
$dic_Ober = ObjCreate("Scripting.Dictionary")
$dic_Ober.Add("Value1", $dic_Unter); Verschachtelte Objekte auslesen
[/autoit]
For $dic In $dic_Ober.Items
For $i In $dic.Items
ConsoleWrite($i & @CRLF)
Next
Next -
Zu deinem konkreten Problem kann ich dir nicht weiterhelfen.
Ich habe allerdings selbst mal lange nach einer stabilen Lösung für nginx als Windows-Dienst gesucht und habe sie schlussendlich in der Verwendung von NSSM gefunden: >>NSSM<<Bestimmt hat jemand Optimierungvorschläge, wenn mehere Druckerverzeichnisse überwacht werden sollen.
Für sowas muss es doch auch eine Schleife oder etwas eleganteres geben.Ja was eleganteres gibt es.
Du checkst bisher immer in regelmäßigen Abständen die Ordner auf PDF-Dateien.
Besser wäre es zu sagen: Hey Windows - sag mir einfach Bescheid wenn in dem Ordner eine neue Datei erstellt wird - ich leg mich bis dahin schlafen.
Diese Funktionalität erreicht man z.B. mit der API-Funktion ShellChangeNotifyRegister.
Eine beispielhafte Umsetzung findest du >>hier<<Für deinen Fall wäre ein prinzipieller Aufbau folgender (Hier mit msgbox statt deinem print-Zeug):
Spoiler anzeigen
[autoit]#RequireAdmin
[/autoit] [autoit][/autoit] [autoit]
#include <APIShellExConstants.au3>
#include <GUIConstantsEx.au3>
#include <WinAPI.au3>
#include <WinAPIShellEx.au3>HotKeySet("q", raus) ; mit "q" Programm beenden
[/autoit] [autoit][/autoit] [autoit]#Region ShellEvent registrieren
[/autoit] [autoit][/autoit] [autoit]
Global $h_GUI = GUICreate("")
Global $h_Msg = _WinAPI_RegisterWindowMessage('irgendwas') ; Die Message "irgendwas" wird an das Fenster $h_GUI gesendet wenn ein Event auftritt
GUIRegisterMsg($h_Msg, 'ReactOnEvents'); Die verschiedenen Ordner zur Überwachung registrieren:
[/autoit] [autoit][/autoit] [autoit]
Global $h_ShellNotify1 = _WinAPI_ShellChangeNotifyRegister($h_GUI, $h_Msg, $SHCNE_CREATE, 0x3, FileGetLongName("T:\_PDF_Druck\P003"))
Global $h_ShellNotify2 = _WinAPI_ShellChangeNotifyRegister($h_GUI, $h_Msg, $SHCNE_CREATE, 0x3, FileGetLongName("T:\_PDF_Druck\P006"))
#EndRegion ShellEvent registrieren; Endlosschleife
[/autoit] [autoit][/autoit] [autoit]
Do
Sleep(100)
Until 0; Funktion die aufgerufen wird wenn ein Event auftritt:
[/autoit] [autoit][/autoit] [autoit]
Func ReactOnEvents(Const $hWndGUI, Const $MsgID, Const $wParam, Const $lParam)
; vollständigen Pfad der erstellten Datei auslesen:
Local $s_FullPath = DllCall("Shell32.dll", "BOOLEAN", "SHGetPathFromIDListW", "ptr", DllStructCreate("PTR A; PTR", $wParam).A, "wstr", "")[2]
Local $s_Path = StringLeft($s_FullPath, StringInStr($s_FullPath, "\", 1, -1) - 1)
Local $s_Filename = StringTrimLeft($s_FullPath, StringInStr($s_FullPath, "\", 1, -1))
Local $s_FileExtension = StringTrimLeft($s_Filename, StringInStr($s_Filename, ".", 1, -1))If $s_FileExtension = "pdf" Then ; nur bei pdf-Dateien reagieren
[/autoit] [autoit][/autoit] [autoit]
; Abhängig vom Pfad anders reagieren:
Switch $s_Path
Case "T:\_PDF_Druck\P003"
MsgBox(0, "", 'Datei in "T:\_PDF_Druck\P003" erstellt: ' & $s_Filename)
Case "T:\_PDF_Druck\P006"
MsgBox(0, "", 'Datei in "T:\_PDF_Druck\P006" erstellt: ' & $s_Filename)
EndSwitch
EndIf
EndFunc ;==>ReactOnEventsFunc raus()
[/autoit]
_WinAPI_ShellChangeNotifyDeregister($h_ShellNotify1)
_WinAPI_ShellChangeNotifyDeregister($h_ShellNotify2)
Exit
EndFunc ;==>raus -
Gehts bisschen konkreter?
Welches Objekt?
Wo kommt dieses Objekt her?
Minimalbeispiel zum nachvollziehen? -
Ich würde nicht sagen, das PCRE eine Ausnahme darstellt bei der Behandlung von Lookarounds.
Das Pattern (mit Anpassung an die jeweilige Syntax) sollte genauso mit z.B. C#, VB, Ruby, PHP, Java und R laufen.
Lediglich Javascript, Python und Perl (von den größeren Enginges) machen da nicht mit.Wenn es aber ein Pattern sein soll, welches universell läuft (wieder auf entsprechende Syntax achten) dann kann man das ganze natürlich noch entsprechend simplifizieren:
[autoit]Global $sLangerText = "Ein sehr langer Text mit vielen Zeichen und vielen Worten der nicht so richtig passen will! Aber der soll hier rein und am besten auf die zweite Zeile!"
[/autoit]
Global $TEMP = StringRegExpReplace($sLangerText, "(.{1,40})(?:\s|$)", "$1" & @CRLF)
MsgBox(0, "", $TEMP) -
Ja in der Hilfe zu _FTP_ProgressDownload.
-
Eigentlich war deine Patternerklärung schon gar nicht mal so schlecht.
Ich versuche es dennoch mal bisschen anders zu erklären:.{1,40} findet eine Kette aus beliebigen Zeichen. Diese ist mindestens 1 Zeichen lang aber maximal 40 Zeichen.
Wichtig ist dabei zu wissen das RegEx standardmäßig gierig arbeitet. Es versucht also immer erst einmal so viel wie möglich zu finden. In unserem Falle also 40 Zeichen.
Er fängt also an zu suchen und probiert die ersten 40 Zeichen: "Ein sehr langer Text mit vielen Zeichen ".
In dem Fall schonmal ganz gut um danach einen Zeilenumbruch zu setzen.
Also geht es weiter - die nächsten 40 Zeichen: "und vielen Worten der nicht so richtig p". Hier passt es schon nicht mehr, da die 40 Zeichen mitten in einem Wort aufhören.
Wir möchten daher sagen: Ok. Versuche bis 40 Zeichen soviel wie möglich zu finden aber es muss mit einem vollständigen Wort enden.
Was kommt nach einem Wort im normalen Text? - genau - ein Leerzeichen.
Und genau diese Aufgabe übernimmt der Teil (?<=\s|$). Das bedeutet, dass das was davor steht nur matcht, wenn danach direkt ein Leerzeichen oder das Stringende steht.
Heißt also: Er fängt erst immer mit 40 Zeichen an und wenn danach kein Leerzeichen kommt, versucht er es ob die Bedingung bei 39 Zeichen klappt, wenn nicht bei 38... etc...Die Klammer um .{1,40} ist nur dafür da, dass dieser Teil gruppiert wird und man beim Ersetzen per $1 wieder darauf zugreifen kann.