Wie kann ich Bitschieberei beschleunigen

AVR Anfänger schrieb:

> Was kann ich in C tun um meine Bitschieberei zu beschleunigen?

Gar nicht schieben?

1

     Blub = ( ( Bla1 & 0x8000 ) ? 0x10 : 0x00 ) |

2

            ( ( Bla2 & 0x8000 ) ? 0x08 : 0x00 ) |

3

            ( ( Bla3 & 0x8000 ) ? 0x04 : 0x00 ) |

4

            ( ( Bla4 & 0x8000 ) ? 0x02 : 0x00 ) |      

5

            ( ( Bla5 & 0x8000 ) ? 0x01 : 0x00 ) );

AVR Anfänger schrieb:
>       Blub = (Bla1 & 0x8000)>>15
>           |(Bla2 & 0x8000)>>14
>           |(Bla3 & 0x8000)>>13
>           |(Bla4 & 0x8000)>>12
>           |(Bla5 & 0x8000)>>11;
> [...]
> Ich arbeite mit AVR Studio4, GCC und meine CPU ist ein ATtiny25
> Was kann ich in C tun um meine Bitschieberei zu beschleunigen?
Mein erster Gedanke:
Du musst doch nicht zwingend schieben, du kannst doch einfach Konstanten 
verodern:

Blub = 0;
if (Bla1 & 0x8000) Blub |= 1;
if (Bla2 & 0x8000) Blub |= 2;
if (Bla3 & 0x8000) Blub |= 4;
   :
   :

Gruß,
Bernd

Fies ist, dass GCC praktisch alle Versuche, Schiebeoperationen zu 
vermeiden, ziemlich konsequent als solche identifiziert und auf die 
Schiebeoperation zurückführt.

Irgendwann kam wohl mal ein kluger Geist drauf, dass alle Prozessoren 
(die er kannte?) billige Schiebeoperationen besitzen. Billiger 
jedenfalls als Sprünge. Also optimiert man alles was irgendwie geht 
entsprechend um. Und weil das so selbstverständlich ist muss man, anders 
als sonst, dafür auch keinen eigenen Schalter vorsehen.

Und irgendwie fehlt entweder dem AVR backend die richtige Peilung über 
die Kosten von Operationen, oder diese Optimierungsstufe fragt danach 
erst garnicht. Und so werden eben bei AVRs billige set-conditional 
Operationen (über skip conditional) durch sauteure Schiebeschleifen 
ersetzt.

Auch KHBs und Bernds Versionen werden von avr-gcc 4.3.4 entsprechend 
grauenvoll umgearbeitet

Es gab hier mal einen Thread dazu.

A. K. schrieb:

> Auch KHBs und Bernds Versionen werden von avr-gcc 4.3.4 entsprechend
> grauenvoll umgearbeitet

Ehrlich?
Das ist in der Tat fies!

A. K. schrieb:
> Auch KHBs und Bernds Versionen werden von avr-gcc 4.3.4 entsprechend
> grauenvoll umgearbeitet
Hast Du's wirklich ausprobiert oder geraten?

Ich hab's gerade mal durch den avr-gcc-4.3.3 laufen lassen, da sieht 
zumindest meine Version ganz ordentlich aus:

    Blub = 0;

    if (Bla1 & 0x8000) Blub |= 1;
    if (Bla2 & 0x8000) Blub |= 2;
 100:   57 fd           sbrc    r21, 7
 102:   32 60           ori r19, 0x02   ; 2
    if (Bla3 & 0x8000) Blub |= 4;
 104:   77 fd           sbrc    r23, 7
 106:   34 60           ori r19, 0x04   ; 4
    if (Bla4 & 0x8000) Blub |= 8;
 108:   f7 fd           sbrc    r31, 7
 10a:   38 60           ori r19, 0x08   ; 8
    if (Bla5 & 0x8000) Blub |= 16;
 10c:   b7 fd           sbrc    r27, 7
 10e:   30 61           ori r19, 0x10   ; 16

    target = Blub;
 110:   39 83           std Y+1, r19    ; 0x01


Gruß,
Bernd

Wo ist bla1 abgeblieben?

Bernd O. schrieb:

> Hast Du's wirklich ausprobiert oder geraten?

Anbei. Nicht wörtlich aber sinngemäss. Es wird nicht alles umgearbeitet,
aber stets mindestens eine der Operationen.

A. K. schrieb:
> Wo ist bla1 abgeblieben?

Vor meinem Code kam der Schiebe-Code von "AVR-Anfänger", der wohl R19 
schon "vorbehandelt" hat, weshalb für das erste Bit nichts mehr zu tun 
war.

Ich habe jetzt den Schiebe-Code entfernt und es sieht nun folgendermaßen 
aus:

    Blub = 0;

    if (Bla1 & 0x8000) Blub |= 1;
  b2:   8b 2f           mov r24, r27
  b4:   88 1f           adc r24, r24
  b6:   88 27           eor r24, r24
  b8:   88 1f           adc r24, r24
    if (Bla2 & 0x8000) Blub |= 2;
  ba:   57 fd           sbrc    r21, 7
  bc:   82 60           ori r24, 0x02   ; 2
    if (Bla3 & 0x8000) Blub |= 4;
  be:   77 fd           sbrc    r23, 7
  c0:   84 60           ori r24, 0x04   ; 4
    if (Bla4 & 0x8000) Blub |= 8;
  c2:   37 fd           sbrc    r19, 7
  c4:   88 60           ori r24, 0x08   ; 8
    if (Bla5 & 0x8000) Blub |= 16;
  c6:   f7 fd           sbrc    r31, 7
  c8:   80 61           ori r24, 0x10   ; 16

    target = Blub;
  ca:   89 83           std Y+1, r24    ; 0x01

Gruß,
Bernd

Ja.

Un bist du sicher das diese "optimierung" an der richtigen Stelle ist?

AVR Anfänger schrieb:

> Aber die "register" anweisung ist für den Compiler nicht wirklich
> bindend. (Glaube ich mal irgendwo gelesen zu haben)

Korrekt.