Codevergleich AVR-Compiler

Ein wichtiges Merkmal eines Compilers ist die Güte des erzeugten Codes. Immerhin soll die Hardware optimal genutzt werden, und die geschriebenen Programme sollen möglichst wenig Laufzeit brauchen und möglichst wenig Speicher – also RAM und Flash – belegen.

Dieser Artikel ist noch lange nicht vollständig. Der Auto/Initiator hofft das sich weitere User am Ausbau des Artikels beteiligen. Das Ergänzen ist also ausdrücklich gewünscht! Besonders folgende Dinge würden noch fehlen: Bascom Beispiele

Ein Vergleich der erzeugten Codes ist jedoch nicht einfach, denn ein Problem kann bereits innerhalb ein und der selben Programmiersprache auf sehr unterschiedliche Art und Weisen formuliert oder gelöst werden.

Dieser Artikel versucht ansatzweise einen Codevergleich weit verbreiteter AVR-Compiler anhand sehr einfacher Aufgaben, die "geradeaus" und ohne Umschweife programmiert wurden.

Ein Vergleich der Programmierung von Hardware-Komponenten und Peripherie wie Timer-, UART- oder I2C-Module scheint dabei weniger interessant, denn obwohl die Codes zum Steuern dieser Komponente in unterschiedlichen Sprachen recht verschieden aussehen, werden sie doch auf die selben Maschinen-Codes abgebildet, die sich im wesentlichen auf das Setzen und Lesen von Registern (SFRs) reduzieren. Der BASCOM Compiler hat allerdings gerade bei IO Aufgaben seine Stärken, wenn dafür vorgefertigte Funktionen existieren.

Neben diesen für jedes Programm essenziellen Abschnitten besteht ein Programm aber zum großen Teil aus hardwareunabhängigen Aufgaben wie Registerverwaltung, Funktionsaufrufen, Schleifen, Abfragen, Zuweisungen, Parameterübergaben, Abfragen von Bedingungen, Arithmetik, Implementierung von Interrupt Service Routinen, etc.

Interessanter erscheint ein Vergleich einfacher Aufgaben, die erkennen lassen, wie gut ein Compiler in der Lage ist, die Ressourcen eines Mikrocontrollers zu nutzen bzw. zu schonen.

Rahmenbedingungen

avr-gcc

Die Assembler-Ausgaben wurden mit der Optimierungsstufe "auf Größe optimieren" (-Os) für einen ATmega8 erstellt. GCC-Version war 3.4.x. Andere Optimierungsstufen haben wenig bis keinen Einfluss auf den erzeugtenCode. Codes für andere Controller der ATmega-Familie unterscheiden sich praktisch nicht vom ATmega8-Code.

Die acr-gcc Assembler-Dumps wurden erzeugt mit

> avr-gcc -mmcu=atmega8 -g -Os datei.c -c -o datei.o
> avr-objdump -d -S datei.o

(Zu beachten ist, daß datei.o ein noch nicht loktiertes Objekt ist und daher Adressen noch mit Platzhaltern (üblicherweise 0) gefüllt sind und daher im Dump noch als 0 angezeigt werden.)

Bascom

Das einzige Assembler-Code-Listing von Bascom (Aufsummieren in einer Schleife) wurde von PicNick mit einem selbstgestrickten *.HEX File Analyzer erstellt, da der Disassembler von AVR-Studio etwas schwer lesbar ist.

Keil-ARM7

Es wurden einige weitere Codezeilen für ein RISC ARM7 System (LPC2138) mit Keil Compiler jeweils unter die gcc-avr Varianten gestellt um auch hier einen Vergleich außerhalb der Konkurrenz gcc-avr/Bascom ziehen zu können. Die Optimierung lag auf 'speed' und Registeroptimierung. Man sieht gewisse Ähnlichkeiten zwischen gcc-avr und Keil-Arm7, im Detail sind die Aufgaben jedoch unterschiedlich gelöst. Auf Grund von deutlichen Unterschieden z.B. im Interrupt Handling sind die Codebeispiele teilweise nicht 1:1 vergleichbar. Die Codebeispiele sind ebenfalls noch nicht loktierte / gelinkte Objekte. Siehe oben.

Summe der ersten n Zahlen

Berechnet wird die Summe der ersten n Zahlen:

[math] \operatorname{sum}(n) \,=\, \sum_{k=1}^n k \,=\, 1 + 2 + \ldots + n [/math]

Die Zahl n wird als 16-Bit Zahl angegeben und das Ergebnis als 16-Bit-Zahl berechnet. Ein eventueller Überlauf wird nicht beachtet.

Der Code wird jeweils als eigene Funktion implementiert, um Abhängigkeiten vom umliegenden Code zu vermeiden.

Für diese Berechnung gibt es mehrere Möglichkeiten.

Aufsummieren in einer Schleife

Quellcodes:

avr-gcc unsigned int sum_n_loop (unsigned int n) { unsigned int sum = 0; unsigned int i; for (i=n; i > 0; i--) sum += i; return sum; }

BASCOM Declare Function Sum_n_loop(byval N As Integer) As Integer Dim X As Integer 'Start X = Sum_n_loop(10) End ' ----- Function Sum_n_loop(byval N As Integer) As Integer Sum_n_loop = 0 While N > 0 Sum_n_loop = Sum_n_loop + N Decr N Wend End Function

Compilat:

avr-gcc 00000000 <sum_n_loop>: unsigned int sum_n_loop (unsigned int n) { unsigned int sum = 0; 0: ldi r18, 0x00 2: ldi r19, 0x00 unsigned int i; for (i=n; i > 0; i--) 4: sbiw r24, 0x00 6: breq .+8  ; 0x10 sum += i; 8: add r18, r24 a: adc r19, r25 c: sbiw r24, 0x01 e: rjmp .-12  ; 0x4 return sum; } 10: movw r24, r18 12: ret das Ganze aus Spass auch noch als Keil-ARM7 Code *** CODE SEGMENT '?PR?sum_n_loop?A?main': 283: unsigned int sum_n_loop (unsigned int n) 00 MOV R2,R0 ; n 284: { 285: unsigned int sum = 0; 04 MOV R1,#0x0 288: for (i=n; i > 0; i--) 08 MOV R0,R2 ; n 0C B L_11  ; Targ=0x1C 10 L_12: 289: sum += i; 10 MOV R2,R0 ; i 14 ADD R1,R1,R2 ; sum 18 SUB R0,R0,#0x0001 ; i 1C L_11: 1C MOV R2,R0 ; i 20 CMP R2,#0x0000 ; i 24 BHI L_12  ; Targ=0x10 291: return sum; 28 MOV R0,R1 ; sum 292: } 2C BX R14 30 ENDP ; 'sum_n_loop?A'

BASCOM ;--------------------------------------------------------- ; Function Sum_n_loop(byval N As Integer) As Integer ;--------------------------------------------------------- L_0x00B4: ;--------------------------------------------------------- ; Sum_n_loop = 0 ;--------------------------------------------------------- LDI r24,0x00  ; clear LDI r25,0x00  ; LDD XL,Y + 2  ; return value addr (softstack) LDD XH,Y + 3 ST X+,r24  ; ST X,r25 L_0x00C0: ;--------------------------------------------------------- ; While N > 0 ;--------------------------------------------------------- LDD XL,Y + 0  ; argument addr (softstack) LDD XH,Y + 1 LD r16,X+  ; load r16:r17 LD r17,X CPI r16,0x00  ; LOW <> 0 ? LDI r21,0x00 CPC r17,r21  ; HIGH <> 0 ? BRLT L_0x00D6  ; branch lower ->function exit BREQ L_0x00D6  ; branch equal ->function exit JMP L_0x00DA  ; continue L_0x00D6: JMP L_0x0102  ; jmp function exit L_0x00DA: ;--------------------------------------------------------- ; Sum_n_loop = Sum_n_loop + N ;--------------------------------------------------------- LDD XL,Y + 2  ; summ_n_loop LDD XH,Y + 3 LD r16,X+  ; into r16:r17 LD r17,X LDD XL,Y + 0  ; N LDD XH,Y + 1 LD r20,X+  ; into r20:r21 LD r21,X ADD r16,r20  ; add r16, r20 ADC r17,r21  ; add+cy r17, r21 LDD XL,Y + 2  ; LDD XH,Y + 3 ST X+,r16  ; store sum ST X,r17 ;--------------------------------------------------------- ; Decr N ;--------------------------------------------------------- LDD XL,Y + 0 LDD XH,Y + 1 CALL L_0x0114 ;--------------------------------------------------------- ; Wend ;--------------------------------------------------------- JMP L_0x00C0 ; reenter loop ;--------------------------------------------------------- L_0x0102: RET  ; end function ;--------------------------------------------------------- ; library function : decrement integer ;--------------------------------------------------------- L_0x0114: LD ZL,X+ LD ZH,X SBIW ZL,0x0001 ST X,ZH ST -X,ZL RET Remark: Das reine Register-rechnen (GCC) macht Bascom nicht. Er arbeitet immer im SRAM , brav mit Load & Store. (PicNick)

Berechnung mit rekursiver Funktion

Quellcodes:

avr-gcc unsigned int sum_n_rekursiv (unsigned int n) { if (n == 0) return 0; return n + sum_n_rekursiv (n-1); }

BASCOM Function Summe(byval N As Integer) As Integer Local M As Integer M = 0 If N > 1 Then N = N - 1 M = Summe(n ) End If Summe = N + M End Function Damit das Programm auch richtig läuft muß der Stackbereich deutlich erweitert werden.

Compilat:

avr-gcc 00000000 <sum_n_rekursiv>: unsigned int sum_n_rekursiv (unsigned int n) { 0: push r28 2: push r29 4: movw r28, r24 if (n == 0) 6: sbiw r24, 0x00 8: breq .+8  ; 0x12 return 0; return n + sum_n_rekursiv (n-1); a: sbiw r24, 0x01 c: rcall .-14  ; 0x0 e: add r24, r28 10: adc r25, r29 } 12: pop r29 14: pop r28 16: ret daraus macht der Keil-ARM7 folgendes *** CODE SEGMENT '?PR?sum_n_rekursiv?A?main': 283: unsigned int sum_n_rekursiv (unsigned int n) 00 STMDB R13!,{R4,LR} 04 MOV R4,R0 ; n 285: if (n == 0) 08 MOV R0,R4 ; n 0C CMP R0,#0x0000 ; n 10 BNE L_9  ; Targ=0x1C 286: return 0; 14 MOV R0,#0x0 18 B L_10  ; Targ=0x30 1C L_9: 288: return n + sum_n_rekursiv (n-1); 1C MOV R0,R4 ; n 20 SUB R0,R0,#0x0001 ; n 24 BL sum_n_rekursiv?A  ; Targ=0x0 28 MOV R1,R4 ; n 2C ADD R0,R1,R0 ; n 289: } 30 L_10: 30 LDMIA R13!,{R4} 34 LDMIA R13!,{R3} 38 BX R3

BASCOM ???

Berechnung durch Formel

Quellcodes:

avr-gcc unsigned int sum_n_formel (unsigned int n) { return n*(n+1) / 2; }

BASCOM Bascom mag keine Formeln. Diese müssen erst zerlegt werden. Ob diese Art der Berechnug schlechter ist kann so nicht gesagt werden. Auf jedem Fall ist diese Methode nicht elegant und ziemlich unübersichtlich, da der Zusammenhang verloren geht. Declare Function Sum_n_formel(byval I As Integer) As Integer Dim X As Integer 'Start X = Sum_n_formel(10) End ' ----- Function Sum_n_formel(byval I As Integer) X = I + 1 '(n+1) X = X * I 'n * (n+1) Sum_n_formel = X / 2 'n * (n+1) / 2 End Function

avr-gcc 00000000 <sum_n_formel>: unsigned int sum_n_formel (unsigned int n) { return n*(n+1) / 2; 0: mul r24, r24 2: movw r18, r0 4: mul r24, r25 6: add r19, r0 8: mul r25, r24 a: add r19, r0 c: eor r1, r1 e: add r18, r24 10: adc r19, r25 } 12: movw r24, r18 14: lsr r25 16: ror r24 18: ret Es geht auch mit deutlich weniger Registern im ARM7 *** CODE SEGMENT '?PR?sum_n_formel?A?main': 284: sum_n_formel (unsigned int n) 00 MOV R2,R0 ; n 286: return n*(n+1) / 2; 04 MOV R1,R2 ; n 08 ADD R1,R1,#0x0001 ; n 0C MOV R0,R2 ; n 10 MUL R0,R1,R0 14 MOV R0,R0,LSR #1 287: } 18 BX R14

BASCOM ???

Interrupt-Routinen

Auch diese Beispiele machen nicht viel. Das erste zählt nur eine 16-Bit Variable hoch, das zweite macht nichts weiter, als ein Funktionsaufruf.

Eine Variable hochzählen

Quellcodes:

avr-gcc #include <avr/io.h> #include <avr/signal.h> int volatile count; SIGNAL (SIG_OVERFLOW0) { count++; }

BASCOM $regfile = "m8def.dat" Dim Count As Integer On Int0 Int0_int ' Initialise the INT0 Interrupt Enable Int0 ' enable the interrupt Enable Interrupts Do Loop Int0_int: ' The interrupt Handler for Int0 Incr Count Return

Compilat:

avr-gcc __vector_9: push __zero_reg__ push __tmp_reg__ in __tmp_reg__,__SREG__ push __tmp_reg__ clr __zero_reg__ push r24 push r25 lds r24,count lds r25,(count)+1 adiw r24,1 sts (count)+1,r25 sts count,r24 pop r25 pop r24 pop __tmp_reg__ out __SREG__,__tmp_reg__ pop __tmp_reg__ pop __zero_reg__ reti Variable holen, addieren, wegschreiben.. den Rest macht der ARM7 selbst. Viel interessanter ist, das der ARM den Counter in ein Register kriegt, der AVR aber über 2 Register rechnen muss (r24 und r25). Dafür muss aber der Arm 2 LDR ausführen um an die Countervariable zu kommen. *** CODE SEGMENT '?PR?ISR?A?main': 288: count++; 00 LDR R0,=count ; count 04 LDR R1,[R0,#0x0] ; count 08 ADD R1,R1,#0x0001 0C STR R1,[R0,#0x0] ; count 10 BX R14 Der Code ist auf Grund der Architektur nicht direkt vergleichbar mit dem AVR. Der Arm 7 besitzt einen eigenen Interrupt Stack, Befehle um ganze Registersätze zu popen/puschen, einen Vectorinterruptcontroller und User/Supervisor Prioritätsebenen, ähnlich der einer x86 CPU. Das wäre als wolle man avr-gcc und Bascom vergleichen :)

BASCOM PUSH R0  ;Push register on stack PUSH R1 PUSH R2 PUSH R3 PUSH R4 PUSH R5 PUSH R7 PUSH R10 PUSH R11 PUSH R16 PUSH R17 PUSH R18 PUSH R19 PUSH R20 PUSH R21 PUSH R22 PUSH R23 PUSH R24 PUSH R25 PUSH R26 PUSH R27 PUSH R28 PUSH R29 PUSH R30 PUSH R31 IN R24,0x3F  ; get SREG PUSH R24 LDI R26,0x00  ;Load immediate LDI R27,0x01  ;Load immediate RCALL PC+0x001D  ;Relative call sub_inc: POP R24  ;Pop register from stack OUT 0x3F,R24  ;Out SREG POP R31 POP R30 POP R29 POP R28 POP R27 POP R26 POP R25 POP R24 POP R23 POP R22 POP R21 POP R20 POP R19 POP R18 POP R17 POP R16 POP R11 POP R10 POP R7 POP R5 POP R4 POP R3 POP R2 POP R1 POP R0 RETI sub_inc: LD R30,X+  ;Load indirect and postincrement LD R31,X  ;Load indirect SUBI R30,0xFF  ;Subtract immediate SBCI R31,0xFF  ;Subtract immediate with carry ST X,R31  ;Store indirect ST -X,R30  ;Store indirect and predecrement RET  ;Subroutine return

Eine Funktion aufrufen

Quellcodes:

avr-gcc #include <avr/io.h> #include <avr/signal.h> extern void foo(); SIGNAL (SIG_OVERFLOW1) { foo(); }

BASCOM

Compilat:

avr-gcc __vector_8: push __zero_reg__ push __tmp_reg__ in __tmp_reg__,__SREG__ push __tmp_reg__ clr __zero_reg__ push r18 push r19 push r20 push r21 push r22 push r23 push r24 push r25 push r26 push r27 push r30 push r31 rcall foo pop r31 pop r30 pop r27 pop r26 pop r25 pop r24 pop r23 pop r22 pop r21 pop r20 pop r19 pop r18 pop __tmp_reg__ out __SREG__,__tmp_reg__ pop __tmp_reg__ pop __zero_reg__ reti Und hier der Arm 7 Code. *** CODE SEGMENT '?PR?ISR?A?main': 285: void ISR( void ) 00 STMDB R13!,{LR} 287: foo(); 04 BL foo?A  ; Targ=0x0 08 LDMIA R13!,{R3} 0C BX R3 Der Code ist auf Grund der Architektur nicht direkt vergleichbar mit dem AVR. Der Arm 7 besitzt einen eigenen Interrupt Stack, Befehle um ganze Registersätze zu popen/puschen, einen Vectorinterruptcontroller und User/Supervisor Prioritätsebenen, ähnlich der einer x86 CPU. Das wäre als wolle man avr-gcc und Bascom vergleichen :)

BASCOM

Sortieren mit Bubble-Sort

Zum Abschluss noch ein komplexeres Beispiel: Ein Array mit 8-Bit-Werten soll mit Bubble-Sort der Größe nach sortiert werden.

Im Array wird nach dem größten Wert gesucht und dieser ans Ende getauscht. Danach macht man den Teilbereich, in dem man das Maximum sucht, um 1 kleiner, bis man fertig ist. Die größten Zahlen wandern wie Blasen nach oben, daher der Name Bubble-Sort für diesen Sortier-Algorithmus.

Variablen:

• n Array-Größe
• a das Array
• i Größe der Teilbereichs
• j Laufvariable durch den Teilbereich

Quellcodes:

avr-gcc #include <limits.h> #include <inttypes.h> void bubble_sort (uint8_t n, char * a) { uint8_t i; // Bereich schrumpft von n auf 2 for (i = n; i >= 2; i--) { char max = CHAR_MIN; uint8_t j, j_max; // im Bereich nach MAX suchen for (j = 0; j < i; j++) { if (a[j] >= max) { // MAX und Pos. merken j_max = j; max = a[j_max]; } } // MAX ans Ende tauschen a[j_max] = a[i-1]; a[i-1] = max; } }

BASCOM

Compilat:

avr-gcc 00000000 <bubble_sort>: { uint8_t i; // Bereich schrumpft von n auf 2 for (i = n; i >= 2; i--) 0: cpi r24, 0x02 2: brcs .+54  ; 0x3a 4: movw r26, r22 6: add r26, r24 8: adc r27, r1 a: sbiw r26, 0x01 { char max = CHAR_MIN; c: ldi r20, 0x80 uint8_t j, j_max; // im Bereich nach MAX suchen for (j = 0; j < i; j++) e: ldi r19, 0x00 10: cp r19, r24 12: brcc .+18  ; 0x26 14: movw r30, r22 { if (a[j] >= max) 16: ld r18, Z+ 18: cp r18, r20 1a: brlt .+4  ; 0x20 { // MAX und Pos. merken j_max = j; 1c: mov r21, r19 max = a[j_max]; 1e: mov r20, r18 20: subi r19, 0xFF 22: cp r19, r24 24: brcs .-16  ; 0x16 } } // MAX ans Ende tauschen a[j_max] = a[i-1]; 26: movw r30, r22 28: add r30, r21 2a: adc r31, r1 2c: ld r18, X 2e: st Z, r18 a[i-1] = max; 30: st X, r20 32: subi r24, 0x01 34: sbiw r26, 0x01 36: cpi r24, 0x02 38: brcc .-46  ; 0xc 3a: ret } Und hier das Ganze noch mal als ARM7 Code *** CODE SEGMENT '?PR?bubble_sort?A?main': 285: void bubble_sort (uint8_t n, char * a) 00 STMDB R13!,{R4-R6} 04 MOV R3,R0 ; n 286: { 290: for (i = n; i >= 2; i--) 08 MOV R0,R3 ; n 0C B L_11  ; Targ=0xD4 10 L_12: 291: { 292: char max = CHAR_MIN; 10 MOV R3,#0x0 14 MOV R6,R3 ; max 296: for (j = 0; j < i; j++) 18 B L_16  ; Targ=0x64 1C L_17: 298: if (a[j] >= max) 1C MOV R4,R3 ; j 20 MOV R5,R4,LSL #24 ; j 24 MOV R5,R5,LSR #24 28 MOV R4,R1 ; a 2C LDRB R4,[R4,+R5] 30 MOV R5,R6 ; max 34 MOV R5,R5,LSL #24 ; max 38 MOV R5,R5,LSR #24 3C CMP R4,R5 40 BCC L_14  ; Targ=0x5C 301: j_max = j; 44 MOV R2,R3 ; j 302: max = a[j_max]; 48 MOV R4,R2 ; j_max 4C MOV R5,R4,LSL #24 ; j_max 50 MOV R5,R5,LSR #24 54 MOV R4,R1 ; a 58 LDRB R6,[R4,+R5] 304: } 5C L_14: 5C ADD R3,R3,#0x0001 ; j 60 AND R3,R3,#0x00FF 64 L_16: 64 MOV R4,R0 ; i 68 MOV R5,R4,LSL #24 ; i 6C MOV R5,R5,LSR #24 70 MOVR R4,R3 ; j 74 MOV R4,R4,LSL #24 ; j 78 MOV R4,R4,LSR #24 7C CMP R4,R5 80 BCC L_17  ; Targ=0x1C 307: a[j_max] = a[i-1]; 84 MOV R3,R0 ; i 88 MOV R4,R3,LSL #24 ; i 8C MOV R4,R4,LSR #24 90 MOV R3,R1 ; a 94 ADD R3,R3,R4 ; a 98 LDRB R3,[R3,#0xFFFFFFFF] 9C MOV R4,R2 ; j_max A0 MOV R5,R4,LSL #24 ; j_max A4 MOV R5,R5,LSR #24 A8 MOV R4,R1 ; a AC STRB R3,[R4,+R5] 308: a[i-1] = max; B0 MOV R3,R6 ; max B4 MOV R4,R0 ; i B8 MOV R5,R4,LSL #24 ; i BC MOV R5,R5,LSR #24 C0 MOV R4,R1 ; a C4 ADD R4,R4,R5 ; a C8 STRB R3,[R4,#0xFFFFFFFF] 309: } CC SUB R0,R0,#0x0001 ; i D0 AND R0,R0,#0x00FF D4 L_11: D4 MOV R3,R0 ; i D8 MOV R3,R3,LSL #24 ; i DC MOV R3,R3,LSR #24 E0 CMP R3,#0x0002 E4 BGE L_12  ; Targ=0x10 310: } E8 LDMIA R13!,{R4-R6} EC BX R14

BASCOM

Die Codes wurden etwas nachkommentiert und -formatiert, um besser den Zusammenhang mit der Quelle durchblicken zu können.

Zusammenfassung

Für diese drei Summier-Routinen erhält man folgende Ergebnisse für Laufzeit und Platzverbrauch. Die Laufzeittest wurden gemacht für N=20, d.h. es wurden die ersten 20 ganzen Zahlen aufsummiert.

Verbrauch an Flash (in Bytes)	avr-gcc	BASCOM
sum_n_loop	20	ca. 40 + 6
sum_n_rekursiv	24	ca. 188 ?
sum_n_formel	26	ca. 300

Verbrauch an Zeit (in CPU-Zyklen)	avr-gcc	BASCOM
sum_n_loop (20)	191	ca. 1355
sum_n_rekursiv (20)	477	ca. 2058
sum_n_formel (20)	19	ca. 417

Die Formelversion ist in BASCOM so langsam, weil eine echte Division benutzt wird. Bei so einer kurzen Schleife sind die Vorteile durch die Optimierung von GCC besonders groß. Bei anderem Code wird der Unterschied eher kleiner ausfallen. Die Code-Größe enthält zum Teil vom Compiler bereitgestellte Unterroutinen (z.B. für die Division). Bei einem längeren Code taucht dieser Teil nur einmal auf. Die 2. Division wird entsprechend viel kürzer als die erste.

Siehe auch

• Sourcevergleich
• avr-gcc
• Bascom
• AVR
• ARM