Findfirst/Findnext in Assembler

[negaH]

Zitat:

Ich bin halt ein kleiner Größenfetischist.

Ich weis, und ich hatte früher ähnliche Motive Assembler zu lernen. Das wichtigste am Lernen von Assembler ist es das man gleichzeitg lernt wie die Maschine funktioniert und somit auch besser verstehen kann wie ein Compiler arbeiten muß.

Aus Sicht der Ökonomie ist aber Assembler nur hilfreich wenn es um Spezialprobleme geht die nicht durch den Compiler lösbar sind. Nur bei solchen Problemen kann ein Asselbersource 200-1000% mehr Leistung bringen.

Da aber die meisten Programmierer nicht so wie WIR sind, ist es besser von vornherein darauf hinzuweisen das Assembler effektiv viel Zeit und Wissen kostet und wirklich nicht viel bringt. Speicher ist cheap, und demzufolge ist es relativ unwichtig ob eine EXE 20Kb oder 400Kb groß ist. Nur bei der Programmierung von Viren usw. ist es tatsächlich wichtig enorm kurze Programme zu schreiben. Allerdings die 400Kb eines Delphiprogrammes kommen nicht von einem schlechten Compiler, sondern von der VCL. Man kann also mit Delphi, nach Änderung der Unit System/SysUtils auf's Minimum, ebenfalls Programme schreiben die nur 8-14Kb groß sind. Kleiner gehts dann nur mit COM Files, da bei EXE's das PE Fileformat die minimale Größe vorgibt.
Ich glaube Luckie und ich hatten mal darüber eine Diskussion.

Gruß Hagen

[neolithos]

Das Problem ist bei mir! Ich habe im "guten alten" (denkste ) DOS kleine COM Anwendungen geschrieben (meist TSR sachen) und auf nemm 80535 glaube ich in der Schule. Doch Dummerweise kann ich die erfahrungen nicht auf den Inline-Assambler anwenden. Daher ich geben auf! *schnief*

[Lillebrohr]

Guten Tag Hagen,

Jo das es vie Zeit kostet weiß ich aber es macht irgendwie Spaß. Ich hatte mal einen Bildviewer in ASM programmiert. Das selbe nochmal in Delphi. Und die Effektitivtät ist echt beraubend. Das waren mehrere tausen Zeilen in ASM und wenige hundert in Delphi.

Naja also ich mache fast alles nur in Delphi außer keymakers oder ähnliches.


Von daher stimme ich dir zu.


MFG


LB

[Assarbad]

Zitat:

Jeder Compiler wie Delphi/C wird genau so guten Assembler compilieren wie der Mensch. Das liegt daran das bei einer FindFirst()/FindNext() Schleife du nicht viele Möglichkeiten hast durch manuellen Assembler was zu verbessern.

*huestel* das ist ein Vergleich ... Singlepass und Multipass-Compiler ... also C ist immer noch effizienter. Dafuer dauert ne Kompilierung auch ("unwesentlich") laenger

Zitat:

Doch Dummerweise kann ich die erfahrungen nicht auf den Inline-Assambler anwenden. Daher ich geben auf! *schnief*

Ups, wohl doch nicht richtig gelernt? Sogar wenn jemand auf dem ARM oder einer anderen Architektur ASM lernt, kann er es leicht auf andere Architekturen erweitern. Zumal BASM in Delphi ja echte ASM-Mnemonics nimmt, im Gegensatz zu Pascal wo man dann lange Zahlenreihen eintippen musste

[Assarbad]

Zitat von Hagen:

demzufolge ist es relativ unwichtig ob eine EXE 20Kb oder 400Kb groß ist.

Relativ ... als jemand der selbst noch mit dem Modem im IN unterwegs ist, bin ich zB von "relativ" betroffen. Und wenn man manchmal 1MB-Klopper sieht, die nix weiter machen als ein paar EDITs usw zu bieten, da kommt einem schon manchmal das ulfen ...

Uebrigens, mit Modifikation der System-Units bringt man es mit Delphi auf minimal 3,5 kB! (Aber dann kann man auch gleich nen Assembler mit HLL-Syntax nehmen, wie zB MASM).

Assembler ist fuer einzelne Sachen immer mal wieder wichtig ... zB wenn man Bytes in einem DWORD drehen will (BSWAP in ASM) dann ist das mit Delphi allein sehr umstaendlich. Fuer meine Implementation in der TScreenShotClass habe ich aber genau das benoetigt, und dann eben den groessten Teil einer ganzen Schleife gleich in ASM verfasst. Bei Bildverarbeitung ist Performanz immer noch eine wichtige Sache!

[neolithos]

@Assarbad: Die größten Probleme sind die Parameter und der Result.

Delphi-Quellcode:

procedure _Swap(var a, b : Cardinal);
asm
  mov eax, [a]
  mov ebx, [b]
  mov [a], ebx // <- Zugriffsverletzung
  mov [b], eax
end;

Ganz leicht aber Funktiuoniert nicht. Und genau hier hab ich die Segel gestreift.

[negaH]

Delphi-Quellcode:

procedure _Swap(var a, b : Cardinal); 
asm 
  mov eax, [a] 
  mov ebx, [b] 
  mov [a], ebx // <- Zugriffsverletzung 
  mov [b], eax 
end

Überlege dir mal wie der Delphi Compiler der procedure _Swap die Paramter übergibt !

Delphi-Quellcode:

procedure _Swap(var a {EAX}, b {EDX} : Cardinal); {register}
asm 
  PUSH  EBX   
//  mov eax, [a] 
  MOV   EAX,[EAX] 
//  mov ebx, [b] 
  MOV   EBX,[EDX] 
//  mov [a], ebx // <- Zugriffsverletzung 
  MOV   [EAX],EBX
// mov [b], eax 
  MOV   [EDX],EAX
  POP   EBX
end

Wie du oben siehst wird A in EAX und B in EDX übergeben. Dein Zugriff mit MOV EAX,[a] -> MOV EAX,[EAX] überschreibt also die Adresse von A mit dem Wert in Adresse A, etwa so MOV A,[A].
Zudem nutzt du register EBX in deiner Funtion OHNE es zu sichern. Ließ die Delphi Hilfe, die besagt das nur EAX,EDX,ECX im Assemblersource frei benutzt werden können. D.h. EAX,EDX,ECX müssten nicht gesichert werden, alle anderen Register wie EBX,EDI,ESI,EBP aber schon.

Delphi-Quellcode:

procedure Swap(var A,B: Cardinal);
asm
  MOV  ECX,[A]
  XCHG ECX,[B]
  MOV  [A],ECX
end;
//oder
procedure Swap(var A,B: Cardinal);
asm
  PUSH  DWord Ptr [A]
  PUSH  DWord Ptr [B]
  POP   DWord Ptr [A]
  POP   DWord Ptr [B]
end;
// oder
procedure Swap(var A,B: Cardinal);
asm
  PUSH  EBX
  MOV   ECX,[A]
  MOV   EBX,[B]
  MOV   [B],ECX
  MOV   [A],EBX
  POP   EBX
end;

Gruß Hagen

[neolithos]

Kurz und auf den Punkt!
Danke! Werde darauf aufbauen.

[neolithos]

Kurz und auf den Punkt!
Danke! Werde darauf aufbauen.

EDIT:
Man war ich blöd!

[Hansa]

Hi,

ich habe da mal eine Zwischenfrage. Kann mir jemand mal ein klassisches Beispiel für den Einsatz von ASM geben ? Also wo es sich gegenüber Delphi Programmierung wirklich sichtbar auswirkt ? Nicht mit 10 % und so. Ich habe nämlich noch nie einen zwingenden Grund gesehen, daß es anders nicht zumindest akzeptabel gehen sollte.

Performanceprobleme kommen doch eher von anderer Seite, z.B. Dateigrößen, die nicht auf das Windows-Dateisystem abgestimmt sind. Datenbanken mit schlecht entworfenen Indices, usw. Was mehr oder weniger die Festplatten betrifft.

Oder Sortierungen, die unnötig zuviel sortieren, falsche Schleifen, die zu lange laufen, was dann eher den Hauptspeicher betrifft. Was kann ich da mit einer von Hand zu Fuß Verschiebung der Register noch spürbar ausgleichen ?

Ich wurde mal gezwungen einen 8 Bit DEC-Prozessor (ohne PC, wohlgemerkt) zu programmieren. Nicht mal in ASM sondern sogar in Oktal-Code, also ohne Mnemonics. Der hatte sogar noch Spezialbefehle und war inkompatibel. Wer macht denn sowas freiwillig ? Mir gruselts heute noch. Vor allem, da der Compiler von sich aus schon viel optimiert und bei einer Division durch 2 glaube SHR ??? ausführt und keine real-Operation.

So ein klassisches Beispiel, mit Erklärung hat doch bestimmt jemand ?