loop 512 mal - 16Bit oder 2*9Bit Counter?

[Oliver L. (ollil)]

Hi,

was ist schneller auf einem ATMega?

uint16_t counter=512;
do {
 irgendwas
} while ( --counter);

oder

uint8_t count1=2;
uint8_t count2=256;

do {
  do {
   irgendwas
  } while ( --count2);
} while ( --count1);

Eigentlich sollte das 2. doch schneller sein, da er hier direkt mit den 
8Bit-Registern arbeiten kann, oder? Ist nur die Frage, ob die zweifache 
Negation und Überprüfung des 2. Registern weniger Zeit in Anspruch nimmt 
als die 16-Bit-Aktionen.

Weiss das jemand?

[gurgl (Gast)]

wenn du mal das ganze so kompilierst, dass assemblercode rauskommt 
(siehe Einstellmöglichkeit deiner Programmierumgebung) und den dann hier 
postest, dann können wir das wirklich beurteilen...

[Wegstaben V. (wegstabenverbuchsler)]

Oliver Lehmann schrieb:
>
> Weiss das jemand?

warum programmierts du das nicht einfach mit einer Zählschleife oder so 
im Teil "irgendwas", und gibst dir das Ergebniss dann aus?

[gurgl (Gast)]

genau, dann kannste die Geschwindigkeit mit dem Oszilloskop ablesen.

[spess53 (Gast)]

Hi

>Eigentlich sollte das 2. doch schneller sein, da er hier direkt mit den
>8Bit-Registern arbeiten kann, oder?

Der ATMega hat auch 16-Bit-Befehle:

 adiw r25:r24,1 incrementiert den Wert in r25:r24

Die Frage ist nur, wie der Compiler das übersetzt. Teste es doch 
einfach. Das Ergebnis siehst du im lss-File.

MfG Spess

[h_ (Gast)]

Fehler:

uint8_t count2 = 256; // overflow

und den Reset von count2 vergessen:

do {
do {
 //irgendwas
} while ( --count2);
count2 = 255;
} while ( --count1);

Ohne Optimierungen erhalte ich 512 * 8 Instruktionen für die 16-Bit 
Variable und 256  2  5 + 2 * 7 Instruktionen (= 2574) - falls ich mich 
nicht vertan habe. Die Takte habe ich nicht ausgezählt.

[Oliver L. (ollil)]

Sieht für mich so aus, als ob eine Schleife schneller ist als 2:

#define nop()  __asm__ __volatile__ ("nop" ::)
void foo()
{
    uint16_t counter=512;
    do 
    {
        nop();
    } while (--counter);
}

ergibt:

foo:
.LFB1:
  .loc 1 14 0
  .cfi_startproc
.L__stack_usage = 0
.LVL0:
  .loc 1 14 0
  ldi r24,lo8(512)
  ldi r25,hi8(512)
.LVL1:
.L2:
  .loc 1 18 0 discriminator 1
  nop
  sbiw r24,1
  .loc 1 19 0 discriminator 1
  brne .L2
  .loc 1 20 0
  ret

#define nop()  __asm__ __volatile__ ("nop" ::)
void foo()
{
    uint8_t count1=2;
    uint8_t count2=255;
    
    do 
    {
        do 
        {
            nop();
        } while (count2--);
    } while (--count1);
}

ergibt:

foo:
.LFB1:
  .file 1 ".././CFile1.c"
  .loc 1 14 0
  .cfi_startproc
.L__stack_usage = 0
.LVL0:
  .loc 1 14 0
  ldi r24,lo8(-1)
  .loc 1 15 0
  ldi r25,lo8(2)
  rjmp .L2
.LVL1:
.L3:
  .loc 1 15 0 is_stmt 0 discriminator 1
  subi r24,lo8(-(-1))
.LVL2:
.L2:
  .loc 1 22 0 is_stmt 1 discriminator 1
  nop
  .loc 1 23 0 discriminator 1
  tst r24
  brne .L3
  .loc 1 24 0
  subi r25,lo8(-(-1))
.LVL3:
  brne .L3
  .loc 1 25 0
  ret

[Simon K. (simon)]

Oliver Lehmann schrieb:
> Sieht für mich so aus, als ob eine Schleife schneller ist als 2:

Und bei welchen Compilereinstellungen?

[Oliver L. (ollil)]

"C:\Program Files (x86)\Atmel\Atmel Studio 
6.0\extensions\Atmel\AVRGCC\3.4.0.65\AVRToolchain\bin\avr-gcc.exe" 
-funsigned-char -funsigned-bitfields -O1 -fpack-struct -fshort-enums -g2 
-Wall -Wundef -Werror -pedantic -pedantic-errors -c -std=gnu99 
-save-temps -MD -MP -MF "main.d" -MT"main.d" -MT"main.o" 
-mmcu=atmega1284p   -o"main.o" ".././main.c"