@alpines da fehlt noch das"GuiCtrlRead" in deiner for Schleife.
Beiträge von Xorianator
-
-
Nettes Video, nettes Spiel. Source wird später mal angeschaut

-
Was für lustige Wearables habt ihr nun?
-
"Oder in der Hosentasche" - Das sieht doch leicht verwerflich aus, wenn deine Hand die ganze Zeit in der Hosentasche rum mehrt

-
-
Das ist ja auch "klar" (wie Dozenten immer so schön zu sagen pflegen). Wenn der Prozessor langsamer taktet, die Zugriffszeit auf den RAM jedoch gleich bleibt, gehen "unterm Strich" noch mehr Takte verloren.
Angenommen er kann alle 2 Takte was aus dem RAM holen und jeden Takt aus dem Cache, hat aber nur 10 Hz, dann ist die Zugriffszeit für 5 Daten aus dem RAM eben 10t. Da man die Daten noch verarbeitet und den RAM währenddessen nicht nutzt, kann man eben in den Cache prefetchen und hat danach für alle weiteren Operanden eine Zugriffszeit für 5 Daten aus dem (nun) Cache eben 5t.
Mal ganz laienhaft modelliert
-
Nächste Idee: LED-Tetris oder ein LED-Jump 'n' Run.
Gerade wenn jemand auf deinem Shirt zockt, dann sähe das unglaublich ulkig aus, würde einiges her machen.
Dann wäre im Zusammenhang mit "Spiel" noch "Conways Game of Life" ganz amüsant. Lässt sich ja noch einfacher realisieren, als der komplette Rest.Alternativ noch "Klassiker": Ein Wasserfall, der z.B. irgendeine Form darstellt.
-
Hi Andy,
Zitat
Array [ i ][j] anstatt über Array[j] [ i ] iteriertDabei muss ich gerade daran denken, dass mein Beispiel auf Anderen Rechnern auch voll in die Hose gehen könnte (wobei ich das heutzutage nicht mehr glaube). Angenommen er würde die Daten in den Cache über die Zeile, statt über die Spalte pre-fetchen, so hätten wir absolut 0 Zeitgewinn gegenüber dem gezeigten Beispiel.
Zitat
wenn man die Schleife statt von 0 bis Ende, nun von Ende bis 0 läuft. Die im Speicher stehende Bitmap ist nämlich "Bottom-up"
Ebenfalls das mit der Bitmap - Wenn man vorher weiß, wie die Daten im Speicher liegen, dann kann man wunderbar den Zugriff umschreiben.Gebe dir absolut Recht, dass es heute noch viel zu viele Leute gibt, die sich ihre Daten (leider) nicht anschauen, bevor sie damit arbeiten. Und sich dann wundern, warum das Script wie n Karren Mist vom Zeitumfang ist.
Anbei noch zu AutoIt: Ich habe sowas in die Richtung schon vermutet, allerdings erschließt sich mir der Nutzen dahinter nicht. Da wir in AutoIt weder dynamisch das Array vergrößern / verkleinern können, ohne es zu überschreiben, liegt da in meinen Augen keine Notwendigkeit für. -
Gruß zur späten Stunde.
Aufgrund aktuellen Anlasses im Studium wollte ich mal ein kleines Snippet los werden, welches die Cache orientierte Programmierung nahe bringt.
Grundmodell ist das Transponieren einer Matrix.
Die native Lösung wäre folgende:
Wir können die Matrix tatsächlich auf keinem anderen Weg rotieren, so oder so müssen wir sie in dieser Art und Weise zuordnen. Allerdings können wir dabei effektiv den Cache nutzen.
Hier erstmal das Snippet (in Java):JavaCode
CacheTest.javaJavapublic class CacheTest { public static void main(String[] args) { matrixTester test = new matrixTester(); System.out.println("No Cache: " + (test.rotateMatrix() * 1e-6)); System.out.println("Cache: " + (test.rotateMatrixCache() * 1e-6)); System.out.println("No Cache Check: " + test.checkMatrixRightRotatedNoCache()); System.out.println("Cache Check: " + test.checkMatrixRightRotatedCache()); } }matrixTester.java
Java
Alles anzeigenpublic class matrixTester { private int[][] Matrix; private int[][] rotMatrix; private int[][] rotMatrixCache; matrixTester(){ this.Matrix = new int[4096][4096]; this.rotMatrix = new int[4096][4096]; this.rotMatrixCache = new int[4096][4096]; for(int x = 0; x < this.Matrix.length; x++){ for(int y = 0; y < this.Matrix.length; y++){ this.Matrix[x][y] = x + y; } } } public long rotateMatrix(){ long startTime = System.nanoTime(); for(int x = 0; x < this.Matrix.length; x++){ for(int y = 0; y < this.Matrix[0].length; y++){ this.rotMatrix[y][x] = this.Matrix[x][y]; } } long endTime = System.nanoTime(); return (endTime - startTime); } public long rotateMatrixCache(){ int stepWidth = 16; long startTime = System.nanoTime(); for(int x = 0; x < this.Matrix.length; x += stepWidth){ for(int y = 0; y < this.Matrix[0].length; y++){ for(int xNew = x; xNew < x + stepWidth; xNew++){ this.rotMatrixCache[y][xNew] = this.Matrix[xNew][y]; } } } long endTime = System.nanoTime(); return (endTime - startTime); } public boolean checkMatrixRightRotatedNoCache(){ for(int x = 0; x < this.Matrix.length; x++){ for(int y = 0; y < this.Matrix[0].length; y++){ if(this.Matrix[x][y] != this.rotMatrix[y][x]){return false;} } } return true; } public boolean checkMatrixRightRotatedCache(){ for(int x = 0; x < this.Matrix.length; x++){ for(int y = 0; y < this.Matrix[0].length; y++){ if(this.Matrix[x][y] != this.rotMatrixCache[y][x]){return false;} } } return true; } }Nun - Ich nutze meinen Cache selbstverständlich nicht optimal. Ohne die Specs meines Prozessors anzuschauen habe ich einfach mal die Annahme getroffen, dass eine Cache-Line 16 * 32 Bit lang ist (== 64 Byte). Um das genau heraus zu bekommen hätte ich ein Script gebraucht, welches mir mit verschiedenen Messungen sagen kann, wie groß eine Line meines L1 Caches tatsächlich ist.
Eventuell schreibe ich noch Eines zum Messen und stelle das ebenfalls hier rein.
Ferner nutze ich in dem Snippet auch nicht die Blockgröße aus. Zwar nutze ich die 64 Byte pro Cache-Line, allerdings beziehe ich mich überhaupt nicht auf die Anzahl der Cache Lines (in dem Falle die Anzahl der Zeilen, also y), das würde zusätzlich noch ein Speedup herbei bringen.Nun aber zum eigentlichen Inhalt des Ganzen: Es geht dabei darum, zu zeigen, dass man effektiver Speicher(zugriffe) macht, und somit in seinen Programmen die Laufzeit verkürzt. Primär ist eine Matrix Rotation das perfekte Anwendungsbeispiel, da wir nach und nach jeden Wert in den Speicher laden, ihn zuweisen, und ihn dann nicht mehr anrühren.
Allerdings ist die native Implementierung nicht gerade zeitgünstig. Wir befüllen den Cache immer wieder mit neuen Werten, sodass wir keinerlei Zeitgewinn gegenüber dem Zugriff auf den RAM haben. Es wird etwas in den Cache geladen, einmal angerührt, und schon wird das nächste nachgeladen.
Dabei hat unser Cache eine weit schnellere Zugriffszeit als unser Arbeitsspeicher (für die Details empfehle ich Wikipedia - Cache). Deshalb ist es sinnvoll, wenn wir im Cache nur genau die Werte betrachten, die bereits darin stehen.
Beim laden einer Zeile der Matrix wird genau so viel der Zeile in den Cache geladen, wie ab index i hinein passt (in dem Falle: 16 mal ein 32 Bit Integer, was äquivalent zu 64 Byte Speicher ist (n Bit / 8 = x Byte). Wenn wir nun allerdings permanent die Zeilen durchrödeln, statt bei der x-ten Stelle weiter zu springen, wird der Cache nicht fortlaufend belegt, sondern "irgendwie". Wie genau das funktioniert, das weiß nur der Hersteller (oder jemand, der davon tatsächlich Ahnung hat), Fakt ist allerdings, dass er nicht mehr nur die Cache Lines belegen wird.
Es ist also ratsam, dass man in solchen Fällen den Cache nur bis dahin nutzt, wo er voll geschrieben ist. Das schafft im Endeffekt einen enormen Geschwindigkeitsvorteil.Wie enorm ist denn der Vorteil?
Nun - In dem Beispiel von mir komme ich mit meinem i5-2500 auf folgende Ausgaben, ausgegeben in Millisekunden:ZitatAlles anzeigenNo Cache: 525.551611
Cache: 78.892377
No Cache Check: true
Cache Check: trueNo Cache: 291.565317
Cache: 65.253137
No Cache Check: true
Cache Check: trueNo Cache: 297.67008699999997
Cache: 68.514985
No Cache Check: true
Cache Check: trueNo Cache Check & Cache Check beziehen sich lediglich darauf, ob die Matrix richtig rotiert wurde. Wenn dies nicht der Fall ist, dann hätten wir ja nix gewonnen.
Warum der erste Wert so hoch ist weiß ich jetzt nicht, im Allgemeinen ist aber ein Geschwindigkeitsvorteil um den Faktor ~4.5 zu erkennen. Bei genügend großen Daten macht das durchaus schon mal was aus.Anbei noch die Bemerkung, warum der Code in Java ist: Ich versuchte in AutoIt ähnliches umzusetzen, ziemlich genau 1:1 den Code, jedoch mit weitaus kleineren Array Größen (AutoIt tut sich bei 4096*4096 im Minutenbereich weh). Allerdings erzielte ich in der Cache Lösung sogar eine langsamere Zeit, als in der NoCache Lösung, was sich mir absolut nicht erschloss. Vielleicht habe ich irgendwas falsch geschrieben, jemand Anderes kann gerne versuchen das in AutoIt umzusetzen und dann mitzuteilen. Vorab wäre mein Schluss für AutoIt daraus, dass der Interpreter "Sowieso macht, was er will", aber die Alteingesessenen wissen bestimmt, woran es liegt.
Damit Allen ein schönes Wochenende!
-
Es gibt auch für Laserdrucker bedruckbare "Sticker". Kenne das aus dem Betrieb wo ich 1 Jahr gearbeitet habe, wir haben die Beschriftung der Akten Ordner selbst bedruckt. Musst mal rumsuchen, ich vermute mal bei Staples.de gibt es sowas.
-
Die pr0gramm Taste gibt mir den Rest
- Sehr geil!
Als Anreiz würde ich dir aber glatt empfehlen, dir nen Arduino / was äquivalentes zuzulegen, damit du dir dein komplett eigenes Numpad zusammen bauen kannst. -
-
Die Frage ist, ob du diese Datensätze, die JTL-Wawi ansteuert, auch selbst irgendwie ansteuern kannst (rein vom Code her - Arbeitet das mit einer Datenbank? Oder wie wird es gespeichert?)
Dann könntest du besagte Aktion auch per Code lösen, alles im Hintergrund, ohne jegliche Fenster zu sehen geschweige denn warten zu müssen. -
Muss ich misterspeed Recht geben.
Bis dato ergibt das auch noch nicht so recht einen Sinn, weshalb du die VPN Verbindung aufbauen und dann deine Websiten besuchen willst (zumal ich mich frage: Wer eigene Websites benutzt, der bekommt das Problem welches du hast nicht selbst gelöst?) -
Hallo Entkalker,
da du neu hier bist: Wofür brauchst du das Ganze denn? -
-
Also dass er den Sleep Befehl überspringt, das bezweifle ich mal ganz stark (oder du hast nen anderen Code als wir).
Das hierAutoIt
Alles anzeigen; Den Abgleich starten Send("{SPACE}") ; Hier gibt es das Problem mit der Antwortzeit ; Warten bis Abgleich fertig ist while WinExists("Datenabgleich") sleep(200) WEnd ; Alle Datensätze markieren MouseMove(273, 209) MouseClick("left", 273, 209) Send("^+A") ; Warten bis alle Datensätze markiert sind Sleep(10000); Hier gibt es das Problem mit der Antwortzeit ; Kontextmenü aufrufen MouseMove(273, 209) MouseClick("right", 273, 209) Send("{DOWN 5}")funktioniert einwandfrei.
Kurze Frage: Warum 5 Minuten Sleep? -
AutoIt
Alles anzeigenLocal $Timer1 = TimerInit() Local $x = 0 For $i = 0 To 100000 Step 1 $x = Mod($i, 4) = 0 ? 4 : Mod($i, 4) Next Local $Timer1Zeit = TimerDiff($Timer1) Local $Timer2 = TimerInit() $x = 0 For $i = 0 To 100000 Step 1 $x = Mod($i, 4) If $x = 0 Then $x = 4 Next $Timer2Zeit = TimerDiff($Timer2) MsgBox(0, "Test", "A: " & $Timer2Zeit & @CRLF & "B: " & $Timer1Zeit)Hier kann das gerne jemand Testen, falls ihr euch streiten wollt.
Bioshades Methode ist tatsächlich schneller (oh wie überraschend, in AutoIt nicht wirklich).Allerdings muss ich dir soweit erstmal widersprechen, was das folgende angeht:
Kein Parser der Welt löst eine Abfrage mit 9 Rechenoperationen und eine Abfrage mit 6 Rechenoperationen zu dem gleichen Code auf - das ist absoluter Unfug.
Das Einzige was daran Unfug ist, ist anzunehmen, dass das nicht möglich ist. Das kommt auf den Parser an sich an. Ein guter Parser würde erkennen, dass es sich dabei um ein und die gleichen Befehle / Operationen handelt, und würde entsprechend anpassen. Analog dazu Compiler, welche den Code zu ein und dem Gleichen zusammen fassen würden.
-
Den Code, den du auf dieser Seite erhältst musst du einfach in einer ".bat" Datei speichern. Mehr Infos: BAT-Datei (Wikipedia)
Diese kannst du dann per ShellExecute (oder Run) in AutoIt ausführen.
Wenn du bestimmte Bedingungen abfragen willst, dann wird das ein wenig komplizierter (war auch deinem Startpost nicht zu entnehmen) - Was genau willst du abfragen?
Grüße -
Eventuell will der TE aber lediglich die Speicheradresse der Variable von AutoIt heraus bekommen... um diese eventuell auf etwas anderes zeigen zu lassen? Wo soll das hin führen?