Recht vielen Dank für Eure Antworten.
Ich muss sie mir nun erst einmal zu Gemüte ziehen.
Der Vorschlag von Oscar erscheint mir insofern problematisch, dass wenn das Programm aus irgendeinem Grund abbricht bevor die Semaphorendatei geschlossen wird, dann bleibt sie "hängen" und blockiert alles weitere. Es kommt dann zwar
MsgBox(0, 'Timeout', 'Zugriff verweigert'). Aber schön ist das auch nicht.
Gruß Dieter
Beiträge von DOheim
-
-
Ich habe zwei Programme, die auf die gleiche Datei zugreifen.Wenn das eine Programm die Datei geöffnet hat, soll das andere Programm, wenn es die Datei öffnen will, so lange warten bis das erste die Datei wieder geschlossen hat.FileOpen leistet das nicht.Wenn ich z. B. dieses Programm zweimal starte, können beide ungehindert mit der Datei parallel arbeiten.
Code$h=FileOpen("Text.txt",2) MsgBox(0,"","offen") FileWriteLine($h,"yyy") MsgBox(0,"","geschrieben") FileClose($h) MsgBox(0,"","geschlossen")
Was tun?
-
Vielen Dank für Deine Erklärungen.
Ich habe in den Tutorials ein "altes" AMD-Papier mit der Befehlsreferenz (incl. Zeichnungen/Bildern!!!) verlinkt, etwas besseres habe ich bisher zu diesem Thema nicht gefunden.
Wo finde ich das Tutorial?
Ich stehe allerdings auf dem Standpunkt, dass man mit zwei Handvoll x86-ASM-Befehle JEDES programmiertechnische Problem erschlagen kann.
Nachdem ich in meinem Bitmap-Programm den entsprechenden Abschnitt ersetzt habe, werden statt 31 Sekunden nur noch 57 Millisekunden benötigt. Erfolg 1:500
Gruß Dieter -
Außer "Zeile" waren ja alle Variablen in meinem Programm nicht notwendig. Ich habe sie eigentlich nur eingeführt, damit das Programm besser lesbar ist. Und statt "Zeile" habe ich einfach xmm1 verwendet. Übrigens habe ich über diese xmmi-Register nirgendwo etwas gefunden. Ich habe es mir einfach bei Dir abgeguckt. Es scheint so zu sein, dass sie nur mit anderen Registern korrespondieren können (z.B.: mov xmm1,eax), nicht aber mit Speichzellen (z.B.: mov xmm1,0 bzw. mov xmm1,[eax]).
Vielleicht hast du ja noch andere Scripte / Programm(teil)e, in denen man etwas beschleunigen könnte
Das Farben einsammeln war ja bisher erst der erste Teil. Nun kommt noch das Einfügen der veränderten Farben. Und das verbraucht bisher noch mehr Zeit. Aber wahrscheinlich muss ich mich jetzt erst einmal um den Umstieg auf Win10 kümmern. Im Sommer habe ich dafür dann keine Zeit mehr (Garten).
Ich sehe an deinem Code, du bist ( wieder?! ) mit dem ASM-Virus infiziert...das freut mich
Das habe ich aber nur dem hervorragenden Lehrgang, den ich bei Dir "besucht" habe zu verdanken. Schließlich war ich ja vom Embedding-Assembler völlig unbeleckt, als ich das Thema Assembler aufgesetzt hatte. Anhand dieser beiden Themen "Assembler" und "Assembler-Fortsetzung" kann jetzt jeder, der es möchte, in die Ass-Programmierung einsteigen.
Nochmals vielen Dank dafür! -
Recht vielen Dank Andy für Deine so ausführliche Antwort.
Jetzt werde ich es in den Griff bekommen.
Nein, das ist nur eine kleine Bitmap-Datei, mit der ich den Algorithmus getestet habe.
Es wird bestimmt nicht meine letzte Frage gewesen sein.
Nochmals herzlichen Dank!
Gruß
Dieter -
Hallo Andy,
ich möchte mein Assemblerprogramm in mein Bitmap-Programm einfügen und über DLLCallAdress aufrufen.
Test1.zip
Aber ich scheitere wenn ich die Zeile 243 aktiviere:
$binarycode ="0x8B7C240483C7368 ..."
Bei Deinem Programm ( siehe 16.1.16, 12:22) klappt das, aber bei mir nicht.
Was mache ich falsch? -
Total gut !!!
-
Hallo Andy,
das werde ich mir zu Gemüte ziehen.
Vielen Dank
DieterPS: Es ist ja der reine Wahnsinn. Innerhalb von 42 ms hat das Programm einen 2,5 MByte Screenshot ausgewertet.
Da werde ich eine ganze Passage verwenden können. Eigentlich wollte ich ja mühselig das ASS-Programmieren lernen. Aber wenn es einem so leicht gemacht wird, siegt natürlich der innere Schweinehund. -
Vielen Dank für Deinen Hinweis. Mein Bitmap-Programm habe ich ja schon lange fertig, und es klappt auch sehr gut. Aber es dauert eben so lange. Ich muss lediglich zwei Passagen durch ASS ersetzen. Seine Funktion hatte ich ja am 14. Dezember 2015 unter Assembler kurz vorgestellt.
In meinem oben am Mittwoch, 17:02, eingestellten Programm habe ich entsprechend Deinem Hinweis "str*" statt "str" geschrieben. Aber _ASMDBG_() zeigt mir dann im Register ebx alles andere als meine String-Bytes an. Habe ich da etwas falsch verstanden?
PS: Jetzt habe ich es kapiert: "str*" erzeugt die Adresse der Adresse des Strings.
-
Recht vielen Dank!
Du hast Dich ja schon sehr intensiv mit der Materie beschäftigt.
Jetzt habe ich ja eine Menge "Handwerkszeug" zur Verfügung.
Wie gesagt: Jetzt geht es erst einmal ans "Verdauen".
Nochmals vielen Dank
von Dieter -
Hallo Andy,
recht vielen Dank für Deine ausführlich Antwort.
Das wird mir sehr weiterhelfen. Schön ist es, dass Du zu jedem Problem immer ein passendes und anschauliches Musterprogramm mitschickst. Und ohne den prima Debugger würde ich ohnehin immer völlig im Dunkeln stehen.
Jetzt muss ich alles erst einmal verdauen.Die Frage ist, wo Strings mit enthaltenen Nullbytes herkommen, deren Vorkommen in der freien Wildbahn ist SEHR begrenzt! IdR. sind das sowieso BYTE Structs, daher sollte man diese auch so behandeln!
Auf diese Weise will ich die eingelesene Bitmap-Datei dem Assemblerprogramm zugänglich machen. Und Bitmap-Dateien haben ja naturgemäß jede Menge Nullbytes.
Bis bald Gruß DieterPS: noch eine weitere Frage:
Wie kann ich in meinem Assemblerprogramm einen zusammenhängenden Speicherbereich bestimmter Größe reservieren? -
Fortsetzung von:
Link
---------------------------------------------------------------------Ich habe die folgenden beiden Probleme
1. ProblemWie kann ich _AssembleIt2 einen String zugänglich machen, welcher Nullbytes beeinhaltet?
Mit folgendem ProgrammAutoIt: Test3
Alles anzeigen#include <assembleit2_64.au3> #cs _numberofpixel use32 org $PTR_SOURCE_ASMCODE ;only needed for assembleit debugger mov edi,[esp+4] ;pointer mov ecx,[esp+8] ;anzahl _ASMDBG_() ;debug-gui anzeigen mov eax,0 _next: mov ebx,[edi+eax] _ASMDBG_() ;debug-gui anzeigen add eax,1 ;next pixel cmp eax,ecx jne _next ret ;return, returns eax #ce ; $string="1234567890" $string="123"&Chr(0)&"4567890" $len=StringLen($string) Local $ret = _AssembleIt2("uint", "_numberofpixel", "str", $string, "int", $len)
erfolgt dieser Abbruch:
autoit.de/wcf/attachment/83503/
Ersetze ich in assembleit2_64.au3 die Zeile
If Eval("Type" & $n) <> "" Then $scriptstring &= ",'" & Eval("Type" & $n) & "'," & Eval("Param" & $n)
durch die Zeile
If Eval("Type" & $n) <> "" Then $scriptstring &= ",'" & Eval("Type" & $n) & "'," & "$Param" & $n
erfolgt zwar kein Abbruch, jedoch werden dem Assemblerprogramm nur die ersten drei Zeichen (bis zum Nullbyte) zur Verfügung
gestellt.
Am besten wäre es meines Erachtens, wenn man die Adresse des Strings ermittel könnte und diese dann dem Assemblerprogramm zur
Verfügung stellen könnte. Aber wie ermittle ich die Adresse eines Strings?2. Problem
Wenn das Assemblerprogramm als Ergebnis ein Feld erarbeitet, wie kann ich das dem aufrufenden Autoit-Programm zur Verfügung stellen?
Vielen Dank schon einmal für eine Antwort ! -
Danke Oscar, es klappt!
Ich hatte mich schon gewundert:
Ich hatte sowohl hinter dem Befehl
mov eax,0 ;counter pixel with Color
als auch hinter dem Befehl
cmp ebx,[edi+ecx*4] ;is dword=color ? (4 Bytes per pixel)
je einen Debuggeraufruf _ASMDBG_() eingefügt.
Der erste wurde angezeigt und bevor der zweite kam schmierte das Programm ab.
Eigentlich hätte ich das genauer untersuchen müssen.
Aber ich habe gedacht, dass ich - als Assemblereinsteiger - etwas falsch gemacht habe.Und Andy muss sich wirklich nicht innerlich zerfleischen. Ein Programmierer, der keine Fehler macht, wäre ein Monster.
Jedenfalls werden mir die Programmbeispiele von Andy und auch von Marc sehr bei meinem Studium des X86-Assemblers sehr helfen.
Bestimmt komme ich bald mit weiteren diesbezüglichen Fragen. Dann werde ich aber ein neues Thema aufmachen.Ich möchte mich sehr bei Euch dreien bedanken!
-
Kommentiere mal die Zeilen mit $ret = _AssembleIt2(blablub)
und die darauffolgende Consolewrite aus, so dass nur der Dllcall übrig bleibt, alle Sleeps auskommentieren.
Funktioniert das?Funktioniert nicht. Siehe Sreenshot1
Link: https://autoit.de/index.php/Atta…creenshot1-JPG/Aktiviere ich aber den Sleep BBB dann geht es. Siehe Sreenshot2
Link: https://autoit.de/index.php/Atta…creenshot2-JPG/
Allerdings ist die Anzahl Pixel =0:DllCallAddress() Anzahl Pixel = 0 Zeit [ms] = 2.147
Wenn es also am Aufruf von _AssembleIt() liegt, bitte mal ganz oben im Assemblercode nach dem Use32 ein RET eintragen, dann nochmal testen, immer noch ohne die Sleeps.
Funktioniert. Siehe Sceenshot3
Link: https://autoit.de/index.php/Atta…creenshot3-JPG/Auch wenn ich _AssembleIt2() und die 3 Sleeps wieder aktiviere, kommt Anzahl Pixel = 0
_AssembleIt2() Anzahl Pixel = 0 Zeit [ms] = 3.817
DllCallAddress() Anzahl Pixel = 0 Zeit [ms] = 1.88Übringens klappt es auch mit den drei Sleep nicht immer.
Rätselhaft!
Du wirst Dich wundern, wie ich auf die Sleeps gekommen bin. Ich hatte zunächst an diesen drei Stellen MsgBox-Befehle gestellt. Und da ging es. Eigentlich haben die ja nichts anders bewirkt, als das Programm zu verzögern.
Noch eine andere Frage. Es gibt Foren, da bekommt man eine E-Mail, wenn eine neue Antwort eingetroffen ist. Kann man das hier auch einrichten. Was haben eigentlich die Abbonierten Themen für einen Zweck?
-
Als Link zu dem Screenshot funktionieret dieser:
https://autoit.de/index.php/Atta…creenshot6-JPG/Übrigens dauert es zwischen den Zeilen:
@@ Debug(48) : $col = FF000000
>Error code: 0und:
!>10:56:48 AutoIt3.exe ended.rc:-1073741819
ein paar Sekunden. Also irgend etwas macht er.
AutoIt-Version: Stabil 3.3.12.0 (Stand 17.9.14)
Betriebssystem: Windows 7
Durch
#AutoIt3Wrapper_UseX64=n
ändert sich nichts.Bin als Administrator eingeloggt. Habe in dieser Hinsicht auch sonst keine Schwierigkeiten.
Dein Beispiel "Debugger Beispiele.au3" funktioniert ja auch einwandfrei.
Auch die Beispiele "Beispiel_1 ASM-Code AssembleIt2 Farbpalette.au3" usw. funktionieren.Gruß
DieterPS.:
Ich habe mal drei Sleep-Befehle eingefügt.
Jetzt klappt es:
screenshot2.JPG
Link: https://autoit.de/index.php/Atta…creenshot2-JPG/
Woran mag das wohl liegen?
Nochmals herzlichen Gruß -
Hallo Andy und Mars,
zunächst vielen Dank für die Mühe, die Ihr Euch mit mir gebt.
Zu dem Beispiel von Andy:
Ich bekomme es einfach nicht zum Laufen. Ich habe Verschiedenes herumexperimentiert, aber es läuft immer darauf hinaus wie im Screenshot dargestellt.autoit.de/wcf/attachment/83427/
Die beiden
- ConsoleWrite ('@@ Debug ...
erscheinen, aber
- ConsoleWrite("_AssembleIt2() ...
nicht mehr und das Program bricht mit einem Fehler ab..
Gestartet habe ich das Programm über Tools/Go. Ich habe es auch kompiliert und dann gestartet, das klappt aber auch nicht.
Problem ist, dass ich bisher nicht mit WinApi- und Dll-Funktionen gearbeitet habe, und es mir schwer fällt, alles so richtig zu kapieren.
Was habe ich falsch gemacht? Vielleicht kannst Du mir auf die Sprünge helfen. -
Lieber Andy,
Wenn du das Scriptfenster von Scite so verkleinerst, dass es neben das Debugfenster passt, wirst du feststellen, dass bei jedem _ASMdebug_() im ASM-code in die entsprechende Zeile in Scite gesprungen wird...
Das war mir gleich aufgefallen. Total gut!
Was willst du machen bzw. wozu Assembler in Kombination mit AutoIt?
Ich habe vor längerer Zeit ein Bitmap-Programm geschrieben, das mehrere Aufgaben erfüllt.
Alles funktioniert zur Zufriedenheit. Aber die eine Aufgabe dauert ewig:
An einem Mini-Beispiel erläutert:
Ich habe diese Bitmap:
aaa1.bmp
Das Programm ermittelt nun alle vorkommenden Farben (auf Wunsch auch Farbbereiche) und zeigt sie so an:
aaa2.bmp
Nun kann man nach belieben Farben verändern.
Und dieser ganze Prozess (in AutoIt geschrieben) dauert bei großen Bitmaps recht lange.
Die ganze Organisation rundherum macht sich mit AutoIt recht gut, aber das Filetstück mit der Bearbeitung von Millionen Bitmap-Pixeln möchte ich mit Assembler lösen.Kannst Du mir einen Tipp geben, wo ich ein Verzeichnis der möglichen Parameter-Typen für die Funktion _AssembleIt2 finde.
"int_ptr" scheint ja eine ganze Zahl zu bedeuten.
Was müsste man angeben, wenn man den Inhalt einer Bitmap-Datei als String (den man mit FileRead gelesen hat) übergeben möchte? -
Vielen Dank Euch beiden, Andy und Mars!
Jetzt habe ich ja reichlich Material für mein Assembler-Studium.
Wie kann man denn erkennen, dass z.B. elitepvpers eine schädliche Seite ist?
Hat diese etwa auf meinem PC schon einen Schaden angerichtet?
Dann müsste ich mir meinen letzten System-Backup zurückholen.PS.: Der Debugger ist ja eine feine Sache!
-
Erst einmal recht herzlichen Dank für Deine Antwort.
Dein FASM klapp ja prima. So habe ich jedenfalls erst einmal das BeispielCode
Alles anzeigen#include <FASM.au3> $zahl1=Inputbox("Zahl","Zahl1") $zahl2=Inputbox("Zahl","Zahl2") $Fasm = FasmInit() FasmReset($Fasm) FasmAdd($Fasm, "use32") FasmAdd($Fasm, "mov eax, [esp+4]") FasmAdd($Fasm, "mov edi, [esp+8]") FasmAdd($Fasm, "add eax, edi") FasmAdd($Fasm, "ret") $bytecode=FasmGetBinary($Fasm) $tCodebuffer=dllstructcreate("byte["&stringlen($Bytecode)/2-1&"]") dllstructsetdata($tCodeBuffer,1,$Bytecode) $Ret= DllCall("user32.dll", "int", "CallWindowProcW", "ptr", DllStructGetPtr($tCodeBuffer), "int", $zahl1, "int", $zahl2, "int", 0, "int", 0) MsgBox(0,"Ergebnis",$Ret[0])
von
[Link entfernt]zum Laufen bekommen. Jetzt muss ich mir das allerdings alles erst einmal zu Gemüte ziehen.
Ich habe in den 60er, 70er und 80er Jahren nur mit Assembler gearbeitet. Die "Großrechner" hatten einen gegenüber unseren PCs so geringe Arbeitsspeicher (1963: 2K Bytes, 1972: 64K Bytes), dass man mit jedem Byte geizten musste und keine höhere Sprache verwenden konnte. Ja und jetzt muss ich mit der Ass-Programmierung ganz von vorne anfangen. Aber um mit Bitmaps (mit beispielsweise 3 MByte) zu arbeiten, kommt man um Ass nicht herum.
Bestimmt werde ich bald mit weiteren Fragen kommen.
Also nochmals vielen Dank!Edit Oscar: Link entfernt. Bitte keine Links zu Botforen!
-
Drei Fragen:
1. Wo finde ich <ASM.au3> und <FASM.au3> ?
2. Worin besteht der Unterschied zwischen beiden?
3. Wo finde ich eine Beschreibung der Assemblerbefehle, die ich hier verwenden kann?
Schon einmal recht vielen Dank für eine Antwort.