Zwei Schleifen über uint8_t oder eine über uint16_t mit AVR?

[Gast (Gast)]

Was ist der Unterschied?

uint8_t x,y;
for (y=0; y<67; y++)
{
 for (x=0; x<98; x++)
 {  
   do();
 }
}

uint16_t z;
for (z=0; z<6566; z++)
{
   do();
}

Genauso beim Funktionsaufruf: besser zwei Byte übergeben oder eine 16 
Bit-Variable?

[... .. (docean)]

schau dir doch an was der Compiler erzeugt... z.B. in AvrStudio 
Debugger..

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> Was ist der Unterschied?
Die erste Lösung ist unübersichtlicher  :-o

[Jörg W. (dl8dtl) (Moderator)]

Da es SBIW als Befehl gibt, müsste die 16-bit-Variante ein Wort
pro Schleifendurchlauf weniger brauchen.

[Horst (Gast)]

im do hast du einmal die werte x und y und einmal 'nur' z zur Verfügung.
Wenn du in der zweiten Variante die beiden Werte brauchst, dann mußt du 
sie erst durch Division und Modulo bei jedem Durchgang berechnen.
Wenn du einfach 6566 mal etwas machen willst, dann ist die 2. Variante 
übersichtlicher.
Wenn du 67 mal 98 mal etwas machen willst (also wenn x und y 
aussagekräftige namen haben und man daraus sieht warum eine Schleife 67 
mal, die andere 98 mal durchlaufen wird) dann ist die 1. Variante 
übersichtlicher.

Wenn du die Optimierung eingeschaltet hast würd ich mir für beide 
Codeschnipsel die selbe Übersetzung erwarten.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> Wenn du die Optimierung eingeschaltet hast würd ich mir für beide
> Codeschnipsel die selbe Übersetzung erwarten.
Da muß der Compiler aber hübsch optimieren, denn in der Variante 2 kann 
das LSB ungehindert auf 255 durch- und überlaufen. In der Variante 1 ist 
schon bei 98 Schluss...

Hier mit Schalter -Os

void variante1 (void) {
  f6:  30 e0         ldi  r19, 0x00  ; 0
  f8:  19 c0         rjmp  .+50       ; 0x12c <variante1+0x36>

  do(); 38 Bytes

 120:  2f 5f         subi  r18, 0xFF  ; 255
 122:  22 36         cpi  r18, 0x62  ; 98
 124:  51 f7         brne  .-44       ; 0xfa <variante1+0x4>
 126:  3f 5f         subi  r19, 0xFF  ; 255
 128:  33 34         cpi  r19, 0x43  ; 67
 12a:  11 f0         breq  .+4        ; 0x130 <variante1+0x3a>
 12c:  20 e0         ldi  r18, 0x00  ; 0
 12e:  e5 cf         rjmp  .-54       ; 0xfa <variante1+0x4>
}

void variante2 (void) {
 132:  20 e0         ldi  r18, 0x00  ; 0
 134:  30 e0         ldi  r19, 0x00  ; 0

 do(); 38 Bytes

 15c:  2f 5f         subi  r18, 0xFF  ; 255
 15e:  3f 4f         sbci  r19, 0xFF  ; 255
 160:  89 e1         ldi  r24, 0x19  ; 25
 162:  26 3a         cpi  r18, 0xA6  ; 166
 164:  38 07         cpc  r19, r24
 166:  39 f7         brne  .-50       ; 0x136 <variante2+0x4>
}