Optimizer

[Froggerprogger]

Ganz interessant ist folgendes:

Was denn daran ?
Bei mir laufen beide Schleifen etwa gleich schnell, allerdings die erste immer etwas schneller, was aber mit der Messmethode zusammenhängen wird.

Bzgl. Optimizer:
Feine Sache!

[remi_meier]

Naja bei mir ist die 1. Schleife grad mal doppelt so schnell wie die 2.
Hm... Muss wohl noch n bisschen im Internet stöbern, bis ich herausgefunden hab, wie ich mit den NOP's richtig umgehen muss (war hier einfach ein bisschen Zufall).

greetz
remi

PS: Neue Version Online: Kleine Optimierungen entfernt und noch 2 hinzugefügt.

[Helle]

Die NOP´s (wie jeder andere Befehl auch) verändern die Speicherausricht-
ung nachfolgender Daten. Landet dann ein Datum (z.B.Variable) auf einer
glatt durch 4 teilbaren Speicheradresse geschehen ware Geschwindigkeits-
wunder! Man könnte auch Versuche mit dem zwangsweisen Setzen des AC-Flags (Alignment-Check) machen, aber das Ganze hängt von zuviel
Unwägbarkeiten ab.

[remi_meier]

@Helle: Das Problem ist hier leider, dass ich die Bytes für die Adressen berechnen müsste, wie es der Assembler macht. Und das scheint mir im Moment leider ziemlich unmöglich

Wenn jemand ne Idee hat...

[remi_meier]

Ein kleines Update und das aktuelle Beispiel:

Code: Alles auswählen

a = 5
b = 6
c = 7
d = 3
e = 1
#N = 49999999
Delay(1000)

time1 = ElapsedMilliseconds()
For z = 1 To #N
  ;{ Integer
  b - 1
  c - a / d
  c = a % 2
  a % 2
  a = b * 3
  a * 3
  zahl = i2/e
  zahl = -i2 - -c
  c = a
  a = b
  b = c
  ;}
Next
time1 = ElapsedMilliseconds() - time1

time2 = ElapsedMilliseconds()
For z = 1 To #N
  ;{ Integer
  !DEC [v_b] 
  
  !MOV    Ebx,dword [v_c] 
  !MOV    Eax,dword [v_a] 
  !MOV    Edi,dword [v_d] 
  !CDQ 
  !IDIV   Edi 
  !SUB    Ebx,Eax 
  !MOV    dword [v_c],Ebx
  
  !MOV    Eax,dword [v_a] 
  !AND    Eax,1
  !MOV    dword [v_c],Eax 
  
  !AND    dword[v_c], 1
  
  !MOV Eax,[v_b] 
  !LEA Eax,[Eax*2+Eax] 
  !MOV [v_a],Eax
  
  !MOV Eax,[v_a] 
  !LEA Eax,[Eax*2+Eax] 
  !MOV [v_a],Eax
  
  !MOV   Ebx, dword [v_e] 
  !MOV   Eax, dword [v_i2] 
  !CDQ 
  !IDIV   Ebx 
  !MOV    dword [v_zahl],Ebx
  
  !MOV    Ebx,dword [v_i2]
  !NEG    Ebx
  !ADD    Ebx,dword [v_c]
  !MOV    dword [v_zahl],Ebx
  
  !MOV  Eax,dword [v_a]
  !MOV  Ebx,dword [v_b]
  !MOV  dword [v_b],Eax
  !MOV  dword [v_a],Ebx
  !MOV  dword [v_c],Eax
  ;}
Next
time2 = ElapsedMilliseconds() - time2

MessageRequester("", Str(time1)+" "+Str(time2))

Resultate sind etwa 1 zu 2 in Geschwindigkeit!
greetz
remi

[Helle]

@remi: Da FASM die Direktive align bietet habe ich mal einige Tests mit
"!ALIGN 4" gemacht und war mit den Werten sehr zufrieden!
Weitere Optimierungen: Da LEA ausser dem Faktor 2 auch noch 4 und 8
zulässt geht auch z.B. LEA EAX,[EAX*4+EAX] für Multiplikation mit 5.
Gruss
Helle

[remi_meier]

@Helle: Hm.. Kannst du mir erklären, wie ich dieses !ALIGN 4 anwenden muss? Werd aus der knappen Fasm Hilfe nicht schlau...
Das mit LEA werd ich noch hinzufügen

cu
remi

EDIT: ist das normal, dass LEA auch mit eax*3 also a*4 geht?

[Helle]

Einfach "!ALIGN 4" als Zeile einfügen! In deinem NOP-Beispiel alle NOP´s
entfernen und einmal diese Zeile rein. Warum soll man sich Arbeit machen, wenn der Assembler das selbst kann?
Das mit LEA hat mich selbst überrascht. Bei mir wurden die Faktoren
0, 1, 2, 3, 4, 7(!) und 8 vom FASM akzeptiert. Mein alter TASM kennt 3 und 7 nicht. Habe in der Eile auch im Internet nichts Brauchbares dazu
gefunden. Möglicherweise ein neues Feature ab irgendeiner Prozessor-
Familie. 3 und 7 machen ja Sinn für Multiplikationen mit 4 oder 8. Ob´s
schneller als SHL ist teste ich mal nach dem Frühstück.

[Helle]

Anbei ein kleiner Test für Multiplikation mit 4:
Code:
;------------- Test Multiplikation mit 4 ------------
!ALIGN 4

#N = 49999999

a = 5
time1 = ElapsedMilliseconds()
For z = 1 To #N
!MOV Eax,[v_a]
!LEA Eax,[Eax*3+Eax]
!MOV [v_a],Eax
Next
time1 = ElapsedMilliseconds() - time1

a = 5
time2 = ElapsedMilliseconds()
For z = 1 To #N
!MOV Eax,[v_a]
!LEA Eax,[Eax*4]
!MOV [v_a],Eax
Next
time2 = ElapsedMilliseconds() - time2

a = 5
time3 = ElapsedMilliseconds()
For z = 1 To #N
!MOV Eax,[v_a]
!SHL Eax,2
!MOV [v_a],Eax
Next
time3 = ElapsedMilliseconds() - time3

MessageRequester("", Str(time1)+" "+Str(time2)+" "+Str(time3))

Alle Zeiten sind in etwa gleich. Die Problematik mit dem Speicher-
Alignment erkennt man, wenn ALIGN an anderen Stellen eingefügt wird!

[DarkDragon]

@DarkDragon

lässt sich sowieso mit der neuen PB beta nichtmehr nutzen

TailBite funktioniert bei mir einwandfrei mit PB 3.93 Beta 2

Kann ich bestätigen, hier auch alles im grünen Bereich.

Bei meinem Post hatte ich noch die Beta 1 und den Beta 2 Post nicht gelesen.