Assembler in Delphi! Speichersack?

[neolithos]

mit dem LEA
das leuchtet mir noch nicht ein!
Warum verwendest du das in dem zusammenhang?

[negaH]

Weil es effizient ist :)

LEA EAX,[EAX * 8 + EAX] ist identisch mit IMUL EAX,9 aber es ist wesentlich schneller und kompakter. Zusätzlich kann man mit LEA Instruktionen ein besseres Instruktions-shuffling/pairing durchführen. Dies bedeutet LEA OpCodes können auf Pipelined Prozessoren, also allen neueren Prozessoren, mit den nachfolgenden/vorhergehenden Operationen in parallel durchgeführt werden. Dadurch erhöht sich die Performance des Algos. um 2,3,4,x mal, je nach Anzahl der Pipelines.
IMUL/MUL können nur in der V Pipeline decodiert und ausgeführt werden. Somit sind sie langsammer und "blockieren" die CPU.

Aber um das alles zu begreifen und zudem noch die ganzen Unterschiede zwischen den einzelnen CPU's zu berücksichtigen, musste dich schon selber bemühen und viele Dokumentationen lesen.
Um gleichmal allen anderen Experten zuvorzukommen: obige Ausschweifungen sind stark vereinfacht und auf's wesentlichste reduziert. Sie sind also eine fast schon falsche Verallgemeinerung der Tatsachen. Wollte man alles in diesem Zusammenhang warum man nun LEA statt IMUL/MUL benutzt erklären könnte man ein Buch draus machen :)

Gruß hagen

[neolithos]

die zwei lea's mahnt Delphi mit einem Compiler fehler!

[negaH]

Shit, das hatte ich schon erwartet, war mir aber nicht mehr sicher :)
Ok, das Problem ist man darf nur mit 1,2,4,8 multiplizieren !.

Also ersetzen durch:

Delphi-Quellcode:

   IMUL  EAX,17
   IMUL  EDX,17

Alle anderen Kombinationen sind dann in fact langsammer.
Man könnte:

Delphi-Quellcode:

   MOV  ESI,EAX
   SHL  EAX,4
   ADD  EAX,ESI

   MOV  ESI,EDX
   SHL  EDX,4
   ADD  EDX,ESI

benutzen, aber das dürfte wohl langsammer sein.

Sorry für meinen Fehler :)

Gruß Hagen

PS: alle obigen Postings habe ich NICHT getestet, sie sind aus dem Kopf und es dürfte deine Aufgabe sein sie korrekt lauffähig zu machen. Dies ist übrigens eben das Problem mit Assembler, jeder noch so kleine Source muß ausgiebig getestet werden.

[neolithos]

Es war bis jetzt nur ein Syntaxfehler dabei! Respekt!

Trotzdem weis ich noch nix mit dem lea anzufangen?

[negaH]

Tja wie erklärt man was was einem selber wie Wasser und Luft der Programmierung vorkommt, schwierig ?

Also, LEA = Load Effective Address = Lade Effektive Adresse ist eigentlich ein OpCode der zur schnelleren Adressberechnungen mit Zeigern entwickelt wurde. Also in EAX ist ein Zeiger auf eine Datenstruktur in einem Array. Diese Datenstruktur wurde so entwickelt das sie aus zwei Integern besteht. Z.b:

Delphi-Quellcode:

type
  PDaten = ^TDaten;
  TDaten = packed record 
    X,Y: Integer;
  end;

  PDatenArray = ^TDatenArray;
  TDatenArray = array[0..127] of TDaten;

Wir habe nun einen Zeiger P der vom Typ PDatenArray ist und wollen ausgehend von P auf das neunte Element, sprich @P[9] zugreifen.

Delphi-Quellcode:

   
   MOV  EAX,P
   MOV  ECX,9
   
   LEA  EAX,[EAX + ECX * 8]

ECX = 9 also Index ins Array in P und SizeOf(TDaten) = 8 also PChar(P) + SizeOf(TDaten) * 9 = @P[9]
oder eben LEA EAX,[P + 9 * 8] -> LEA EAX,[EAX + ECX * 8] wenn in ECX z.b. ein Zähler ist.

Somit ist LEA ein OpCode der besonders in Recordbasierten Strukturen die über Indexe arbeiten benutzt wird. Aber wer sagt das EAX ein Zeiger auf ein Array sein muß, und das ECX ein Index in dieses Array sein muß und das 8 die Größe eines Records sein muß ?? Keiner, man kann also LEA benutzen um 1 MOV + 1 MUL mit 2,4,8 + 1 ADD/SUB in eine einzigste Instruktion zu packen.

Gruß Hagen

[neolithos]

Der Vollständigkeithalber...

Delphi-Quellcode:

asm
  test edx, edx
  jns @@1
  xor eax, eax
  mov [ecx].TRect.Left, eax
  mov [ecx].TRect.Top, eax
  mov [ecx].TRect.Right, eax
  mov [ecx].TRect.Bottom, eax
  ret
@@1:
  mov eax, edx
  xor edx, edx
  push ebx
  mov ebx, 8 // damit die 8 durch etwas anderes ersetzt werden kann
  div ebx // eax = y  edx = x
  pop ebx

  imul eax, 17
  imul edx, 17

  mov [ecx].TRect.Left, edx
  mov [ecx].TRect.Top, eax
  add eax, 14
  add edx, 14
  mov [ecx].TRect.Right, edx
  mov [ecx].TRect.Bottom, eax
end;

lea hab ich jetzt gefunden!

[negaH]

Vermeide EBX, ok das hat jetzt keine wesentliche Bedeutung in deinem Beispiel aber es ist besser EBX nur im Notfall zu benutzen, um besseren Assembler zu erzeugen der auch in Kylix ohne Probleme oder Nacharbeiten lauffähig ist. In deinem Fall nehme ECX

Delphi-Quellcode:

    PUSH ECX
    MOV  ECX,8
    MOV  EAX,EDX
    XOR  EDX,EDX
    DIV  ECX
    POP  ECX

Oder noch einfacher

Delphi-Quellcode:

const
  Dimension: Cardinal = 8;
asm
....
   
   MOV  EAX,EDX
   XOR  EDX,EDX
   DIV  Dimension
 
...
end;

Gruß Hagen

[neolithos]

Darf ich mal loswerten!

80x86-Assembler komplizierter als 80c535!

Anmerk:
ebx getauscht!

[negaH]

Zitat:

80x86-Assembler komplizierter als 80c535

Naja, das hängt davon ab. Ich habe in meinem Leben mindestens 7 verschiedene Assembler und CPU Typen programmiert. Das was am meisten nervt sind RISC Prozessoren, und Assembler deren Parameterstrukturen vertauscht sind, sprich statt MOV EAX,Value, eben MOV Value,EAX aber beide meinen das Gleiche. Ansonsten ist es mir egal ob es ein x86, ein Motorola oder PIC oder SmartCard Chip ist.

Wo du aber recht hast ist der Punkt das manch "Deutsches" Produkt eine bessere und klarere Logik enthält.

Gruß Hagen

PS: Was hast du mit einem 80c535 gemacht ?