Berechnungen auf avr 8 bit

[rechner (Gast)]

Morgen,

mal ne frage, was geht schneller auf nem avr 8 bit:

unsigned int j=(zahl<<1)-(i<<9);

unsigned int j=(zahl-256*i)*2;

[Hmm... (Gast)]

Ersteres, da keine Multiplikation...

[Michael G. (linuxgeek)]

Ohne die Aequivalenz der Operationen vorauszusetzen natuerlich 
ersteres...

[Steven (. (ovular)]

Seht doch einfach nach der Anzahl der Operatoren? Das reicht in dem Fall 
schon...

Ich wünsche noch eine angenehme Nacht!
Gruß Ovular

[rechner (Gast)]

Jo, danke

macht sinn.
hab ja schon umgeformt ...

wenn man die klammer auflöst steht da ja : 2*j-512*i

[rechner (Gast)]

Äh,
wenn man die klammer auflöst steht da ja : j= 2*zahl-512*j


so gute nach :)

[Michael G. (linuxgeek)]

Das sind immernoch zwei Multiplikationen Schnuffel :D

[rechner (Gast)]

ja schon,
aber zahl<<1 ist zahl*2
und  j<<9 ist j*512

mir ist nicht klar ob der compiler oder wer auch immer, nicht auch 
einfach schiebt bei *2, warscheinlich schon oder?

[Michael G. (linuxgeek)]

Kannste nicht von ausgehen ;)

[G. L. (sprintersb)]

Zweiteres ist schneller, einfach GCC fragen (hier avr-gcc 3.4.6, 
ATmega8, -Os)

:-))

unsigned int foo1 (unsigned int zahl, unsigned int i)
{
    return (zahl<<1)-(i<<9);
}    

unsigned int foo2 (unsigned int zahl, unsigned int i)
{
    return (zahl-256*i)*2;
}

foo1:
  movw r18,r22   ;  i, i   ;  4  *movhi/1  [length = 1]
  lsl r24   ;  tmp45   ;  31  *ashlhi3_const/2  [length = 2]
  rol r25   ;  tmp45
  mov r19,r18   ;  i   ;  30  *ashlhi3_const/5  [length = 3]
  clr r18   ;  i
  lsl r19   ;  i
  sub r24,r18   ;  <result>, i   ;  22  subhi3/1  [length = 2]
  sbc r25,r19   ;  <result>, i
  ret
/* function foo1 size 9 (8) */

foo2:
  movw r18,r22   ;  i, i   ;  4  *movhi/1  [length = 1]
  mov r19,r18   ;  tmp45, i   ;  33  *ashlhi3_const/3  [length = 2]
  clr r18   ;  tmp45
  sub r24,r18   ;  tmp47, tmp45   ;  14  subhi3/1  [length = 2]
  sbc r25,r19   ;  tmp47, tmp45
  lsl r24   ;  <result>   ;  32  *ashlhi3_const/2  [length = 2]
  rol r25   ;  <result>
  ret
/* function foo2 size 8 (7) */

Kann er aber noch etwas besser (-Os -morder1):

foo2:
  mov r19,r22   ;  tmp45, i   ;  35  *ashlhi3_const/3  [length = 2]
  clr r18   ;  tmp45
  sub r24,r18   ;  zahl, tmp45   ;  14  subhi3/1  [length = 2]
  sbc r25,r19   ;  zahl, tmp45
  lsl r24   ;  <result>   ;  34  *ashlhi3_const/2  [length = 2]
  rol r25   ;  <result>
  ret
/* function foo2 size 7 (6) */

[rechner (Gast)]

jau, danke.

-Os ist optimiert auf size, aber was ist -morder1 ?

[G. L. (sprintersb)]

rechner wrote:
> aber was ist -morder1 ?

avr-gcc bietet 2 undokumentierte Optionen, welche die 
Registerallokierung (d.h. Abbildung von pseudo-regs auf hard-regs) 
beeinflussen. Neben der Standard-Rgisterreihenfolge gibt's noch -morder1 
und -morder2 (zumindest in avr-gcc 3.4.x). Wahrscheinlich von Chertikov 
zum Rumexperimentieren?