Multiplizieren in Assembler langsammer als in Bascom

**Trexis5** · 27.09.2010, 17:23

Hi,

ich habe einen Code mit einem GLCD 320*240.
Dort zähle ich die Zeit für das Aufauen des Bildes.

Nun tausche ich einige Code Zeilen von Bascom in Assembler.
Das bringt sehr viel, jetzt ist das Display schon 45% schneller.

Mein ganzes Projekt ist fertig und ich möchte nicht alles neu in einem anderen Code machen. Desshalb wäre ich dankbar für eine kleine Hilfestellung

Z.B.

Code:

 Pix_x = Gl_x / 8

in.

Code:

 lds R24, {Gl_x}
 lds R25, {Gl_x+1}
 lsr r25
 ror r24                                                    '/2
 lsr r25
 ror r24                                                    '/4
 lsr r25
 ror r24                                                    '/8
 sts {Pix_x} , R24
 sts {Pix_x+1} , R25

Das geht viel schneller. Auch schieben in Bascom ist noch langesamer.

So nun das Problem, ich denke der Code ist nicht optimal.

in Bascom:
Lcd_cr ist ein Byte und Gl_y ist ein Word.
Also 16bit mit 8bit malnehmen.

Code:

Lcd_cr = 40
Gl_y = 340
Pix_y = Gl_y * Lcd_cr

Assembler ist:

Code:

Lcd_cr = 40
Gl_y = 340
Gl_addrhi = High(gl_y)
Gl_addrlo = Low(gl_y)

$asm

 lds R17, {Gl_addrhi}                                       '; obere 8 Bitsvon y
 lds R16, {Gl_addrlo}                                       '; niedrigere 8Bits y
 lds R18, {Lcd_cr}                                          '; 8-BitKonstante
 mul R16,R18                                                ';Multipliziere LSB
 mov R2,R0                                                  '; kopiereErgebnis in Ergebnisregister
 mov R3,R1
 mul R17,R18                                                '; Multiplizere MSB
 mov R4,R1                                                  '; Kopiere MSBdes Ergebnisses zum Ergebnis-Byte 3
 add R3,R0                                                  '; Addiere LSBdes Ergebnisses zum Ergebnis-Byte 2
 brcc NoInc1                                                '; Wenn Carrynicht gesetzt, springe
 inc R4                                                     '; erhoeheErgebnis-Byte 3
NoInc1:
 sts {Pix_y} , R2
 sts {Pix_y+1} , R3

$end Asm

Warum ist der Assembler code langsamer?
Geht das kürzer?

Danke.

**yaro** · 27.09.2010, 19:02

In Assembler ist es langsamer, weil Bascom es schon beim Compilieren ausrechnet und dann nur noch das Ergebnis zu laden braucht.

Gruß, Yaro

**Trexis5** · 27.09.2010, 19:44

Hi,

ne das stimmt nicht. Die Variablen ändern nich ja immer.
Ich habe die nur mal hier im Code vorbelegt.
Auf dem Display sehe ich das es langsamer ist.

**yaro** · 28.09.2010, 21:42

Wie misst du denn die Ausführzeit?
Wodurch ändern sich die Variablen?

Gruß, Yaro

**Besserwessi** · 28.09.2010, 22:43

Der ASM Code sieht schon sehr gut aus. Mehr als vielleicht 1 Zyklus beim Übertrag der Addition sehe ich da nicht mehr als Optimierungsmöglichkeit.

Die Längere Laufzeit könnte aber durch die extra Zuweisungen vor dem ASM Teil kommen, also das
Gl_addrhi = High(gl_y)

Da sollte sich doch eine Lösung finden lassen ohne die extra Zuweisung.