Avr-gcc/Optimierungen: Unterschied zwischen den Versionen

Version vom 27. November 2012, 23:30 Uhr

Beim Programmieren in C möchte man sich möglichst wenig mit der Codeerzeugung selbst auseinandersetzen. Man verwendet ja gerade deshalb einen Compiler und programmiert nicht in Assembler, weil man sich nicht um Register-Belegungen o.ä. kümmern will, sondern nur um die zu lösende Aufgabe.

GCC erzeugt zwar recht guten Code, aber er ist nicht perfekt. Gerade auf Systemen wie AVR mit nur sehr begrenzten Resourcen muss man daher dem Compiler hilfreich zur Seite stehen, wenn man noch dichteren/schnelleren Code erhalten möchte.

"Unlike most other C compilers, GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may not exist at all; flow of control may briefly move where you did not expect it; some statements may not be executed because they compute constant results or their values were already at hand; some statements may execute in different places because they were moved out of loops.

Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs."

Um das Ergebnis zu beurteilen, hilft ein Blick ins Listfile. Siehe dazu auch die Abschnitte "Listfile erstellen" und "Die Größe ermitteln" im Hallo Welt für AVR.

Optimierungsgrad

Als Optimierungsgrad erweist sich -Os (Optimize for Size) als der beste, evtl. noch -O2. Ohne Angabe eines Optimierungsgrades wird nicht optimiert, was gleichbedeutend mit der Option -O0 ist. Abzuraten ist von der maximalen Optimierung -O3, die wegen function inlining und loop unrolling zu sehr breitem Code führt und für AVR absolut nicht angesagt ist.

Vermeide printf, scanf, malloc

Funktionen von diesem Kaliber sind die absoluten Platz- und Zeitfresser.

Alternativen findet man reichlich in der avr-libc wie itoa und atoi. Und für malloc und Konsorten sind dynamische Arrays und das Compiler-Builtin __builtin_alloca effizientere Alternativen, siehe auch im Abschnitt "Dynamische Speicherallokierung".

Konstante Strings ins Flash

Konstante Strings, wie sie zu Ausgabezwecken Verwendung finden, werden im Programm oft nicht verändert und brauchen nicht SRAM zu belegen (und damit auch Flash, von wo aus sie vom Startup-Code ins SRAM kopiert werden), sondern gehören ins Flash!

Entsprechende Routinen, um auf Strings im Flash zuzugreifen, tragen die Suffix _P, wie z.B. strcmp_P mit dem Prototyp

extern int *strcmp_P (char *, const prog_char *)

Die Implementierungen befinden sich in der avr-libc.

Anwendung:

#include <avr/pgmspace.h>

const prog_char str_p[]     = "Ein String im Flash";
const char str2_p[] PROGMEM = "Noch ein String im Flash";
...
  // String im SRAM mit String im Flash vergleichen
  if (!strcmp_P (str_sram, str_p))
  {
      // mach was bei Gleichheit
  }

  // "foo" wird im RAM angelegt. Ineffizient für konstante Strings!  
  // Beachte, daß damit strcmp (nicht strcmp_P) benutzt werden muss.  
  if (!strcmp (str_sram, "foo"))
  {
      // mach was bei Gleichheit
  }

  // PSTR bewirkt, daß die String-Konstante "foo"
  // im Flash angelegt wird
  if (!strcmp_P (str_sram, PSTR ("foo"))
  {
      // mach was bei Gleichheit
  }
...
}

Sprungtabelle

Genauso macht man auch eine Sprungtabelle, um anhand von Kommando-Strings dazugehörige Funktionen ausführen zu lassen:

#include <avr/pgmspace.h>

int func1 (int arg)
{
   ...
}

#define TEXT_LEN 15

// Die Kommandostruktur
typedef struct 
{
   int (*func)(int);      // Zeiger auf die auszuführende Funktion
   int arg;               // das Argument, das mitübergeben wird
   char text[1+TEXT_LEN]; // Text, maximal TEXT_LEN Zeichen lang
} command_t;

// Das Array mit den Kommandos.
// Die funcx sind vom Prototyp (z.B. func1 oben)
// int funcx (int arg);
const command_t commands[] PROGMEM =
{
   { func1, 0, "Befehl 1" },
   { func2, 3, "Befehl für func2" }
};

// Sucht in commands[] nach text und führt gegebenenfalls
// die dazugehörige Funktion funcx mit Argument arg aus.
// Liefert den Rückgabewert von funcx
// oder -1, falls text nicht gefunden wurde.
int execute (const char *text)
{
   // Schleifenvariable
   unsigned char i;

   // Wandert durch das Array mit Kommando-Strukturen
   const command_t * cmd = commands;

   // sizeof wird von gcc ausgewertet und ist wie eine Konstante,
   // denn beide sizeofs sind zur Compilezeit bekannt
   for (i=0; i < sizeof(commands) / sizeof(command_t); i++)
   {
      // Ist das der gesuchte String? 
      if (strcmp_P (text, cmd->text))
      {
        // Nein, dann weitersuchen
        cmd++;
        continue;
      }

      // Ja
      int (*func)(int), arg;

      // Dann Funktionszeiger und Argument besorgen,
      func = (int(*)(int)) pgm_read_word (& cmd->func);
      arg  = (int)         pgm_read_word (& cmd->arg);

      // Funktion ausführen und deren Wert zurückliefern 
      return func (arg);
   }

   // text ist nicht in commands
   return -1;
}

Nachteil dabei ist, daß jeder String den maximalen Platz von TEXT_LEN+1 Zeichen belegt. Falls man da noch weiter sparen will, dann kann man die Strings wieder ins Flash legen und ihre Adresse in der Struktur merken. Dadurch belegt ein String nur noch Länge+3 Zeichen (+3 wegen 1 Endezeichen und 2 Bytes für seine in der Struktur gemerkte Adresse). Die Definition der Tabelle wird aber umständlicher, weil jeder String einzeln angegeben werden muss:

#include <avr/pgmspace.h>

// Die Kommandostruktur
typedef struct 
{
   ...
   char * text;  // Zeiger auf Text
} command_t;

const prog_char str_1[] = "Befehl 1";
const prog_char str_2[] = "Befehl für func2";

const command_t commands[] PROGMEM =
{
   { func1, 0, str_1 },
   { func2, 3, str_2 }
};

// Sucht in commands[] nach text und führt gegebenenfalls
// die dazugehörige Funktion funcx mit Argument arg aus.
// Liefert den Rückgabewert von funcx
// oder -1, falls text nicht gefunden wurde.
int execute (const char *text)
{
   // Schleifenvariable
   unsigned char i;

   // Wandert durch das Array mit Kommando-Strukturen
   const command_t * cmd = commands;

   // sizeof wird von gcc ausgewertet und ist wie eine Konstante,
   // denn beide sizeofs sind zur Compilezeit bekannt
   for (i=0; i < sizeof(commands) / sizeof (command_t); i++)
   {
      const prog_char * text_P;

      // Liest die Startadresse von str_x
      text_P = (const prog_char *) pgm_read_word (& cmd->text);

      // Ist das der gesuchte String?        
      if (strcmp_P (text, text_P))
      {
         ...

Lokale Variablen verwenden

Beim Manipulieren globaler Variablen kann es günstig sein, diese in eine lokale Variable zu kopieren, dort zu verändern, und sie danach wieder zu schreiben

char var;

void foo1()
{
   var++;
   if (var > 10)
      var = 1;
} 

Dadurch wird einmal unnötig gespeichert (der dritte Befehl kann vermieden werden).

foo1:
  lds r24,var        ; *movqi/4 [length = 2]
  subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
  sts var,r24        ; *movqi/3 [length = 2]
  cpi r24,lo8(11)    ; cmpqi/2  [length = 1]
  brlt .L3           ; branch   [length = 1]
  ldi r24,lo8(1)     ; *movqi/2 [length = 1]
  sts var,r24        ; *movqi/3 [length = 2]
.L3:
  ret   

Indem man eine lokale Variable (var2) verwendet für die Änderung von var vermeidet man dies:

char var;

void foo2()
{
   char var2 = var;
   
   var2++;
   if (var2 > 10)
      var2 = 1;
      
   var = var2;
} 

Dadurch wird erst am Ende gespeichert. var2 lebt in Register r24.

foo2:
  lds r24, var       ; *movqi/4   [length = 2]
  subi r24,lo8(-(1)) ; addqi3/2   [length = 1]
  cpi r24,lo8(11)    ; cmpqi/2    [length = 1]
  brlt .L2           ; branch     [length = 1]
  ldi r24,lo8(1)     ; *movqi/2   [length = 1]
.L2:
  sts var, r24       ; *movqi/3   [length = 2]
  ret

Bei diesem einfachen Beispiel spart man lediglich eine Instruktion. Bei komplexeren Rechnungen oder längeren Datentypen kann es aber durchaus lohnender sein, in lokale Register zu kopieren.

Arithmetik

Daten zerlegen/zusammensetzen

In systemnahen Programmen hat man oft was Problem, auf die einzelnen Bytes oder Bitfelder einer grösseren Datenstruktur zuzugreifen. Indem man sich ein Komposit baut, das die gewünschten Strukturen überlagert, kann man effizient z.B. auf Bytes zugreifen. Ausnahme sind Bitfelder, deren Verwendung etwas breiten Code ergibt. Bitfelder "von Hand" zu manipulieren, ist da manchmal effizienter, führt jedoch zu schlecht lesbarem Code.

Oft benötigt wird der Zugriff auf die einzelnen Bytes eines int, also der Zugriff auf die Bytes eines 16-Bit-Wertes:

typedef union
{
   unsigned char  asByte[2];
   unsigned short asWord;
   int            asInt;
} data16_t;

data16_t data;
...
   int foo;
   uint8_t wert;

   data.asInt = foo;
   wert = data.asByte[1]; // die oberen 8 Bits von foo

Ein komplexeres Beispiel, das noch mehr Datentypen überlagert:

typedef ... foo_t;

typedef union
{
    unsigned char byte[4];      //  Zugriff als Bytes (8 Bit) 
    unsigned short word[2];     //  Zugriff als Words (16 Bit) 
    signed long slong;          //  Zugriff als signed long (32 Bit) 

    struct //  Zugriff auf einzelne Bitgruppen 
    {
        unsigned bit_0_3 : 4;   //  4 Bits (0..3) 
        unsigned bit_4_8 : 5;   //  5 Bits (4..8) 
        unsigned bit_9_21 : 13; //  13 Bits (9..21) 
        unsigned bit_22_31: 10; //  10 Bits (22..31) 
    };

    foo_t foo; //  Zugriff als foo-Struktur 
} data_t;

...
{
    data_t data;

    data.byte[2] = 12;          //  setzt byte 2 auf 12 
    data.bit_4_8 = 0x1f;        //  setzt bits 4..8 (5 Stück) alle auf 1 

    int anInt = data.foo.anInt; //  liest ein Feld von foo (hier ein int) 
    ...
        }

libgcc2 verwenden

In der libgcc2 sind einige Arithmetik-Routinen in Assembler implementiert. Dazu gehören ein paar Algorithmen zu Division (mit Rest) und Multiplikation.

Von diesen Algorithmen werden durch die avr-libc jedoch nur zwei Strukturen und Funktionen veröffentlicht: div_t und ldiv_t resp. die Funktionen div() und ldiv(). Siehe dazu deine Dokumentation zur avr-libc. Damit kann man Quotient und zusätzlich den Rest bei einer Division 16/16 bzw. 32/32 berechnen lassen; den Rest bekommt man quasi kostenlos als Nebenprodukt. Das ist praktisch, wenn man z.b. eine Zahl in Dezimaldarstellung umwandeln möchte oder von/nach BCD.

Zusätzlich zu den via avr-libc veröffentlichten Funktionen gibt es aber noch Routinen, die z.B. auf 8-Bit-Werten operieren oder mit unsigned Typen und dementsprechend effizienter sind.

Beispiel: Umwandeln nach Dezimalstring

Hier ein Beispiel, das Division mit Rest für unsigned short verwendet, um eine 16-Bit-Zahl in Dezimaldarstellung zu wandeln:

//  Struktur definieren und Funktion bekannt machen 
typedef struct
{
    unsigned short quot;
    unsigned short rem;
} udiv_t;

extern udiv_t udiv (unsigned short, unsigned short) __asm__("__udivmodhi4");

//  5 Ziffern (0...65535) und evtl. noch eine führende 0 
#define DIGITS 6

//  +1 wegen String-Ende (wird im Startup auf 0 gesetzt) 
char string[DIGITS+1];

//  Wandelt zahl in Dezimaldarstellung um. 
//  Der return-Wert zeigt irgendwo ins string[]-Array. 
//  string[] wird verändert. 
char* toString (unsigned short zahl)
{
    //  s zeigt auf das Ende von string 
    //  string wird von hinten nach vorne gefüllt 
    char *s = string + DIGITS;
 
    //  qrem enthält Quotient (quot) und Rest (rem) der Divisionen 
    udiv_t qrem = {.quot = zahl}; 

    do
    {
        //  Division mit Rest durch 10 
        //  quot: Ergebnis für den nächsten Durchlauf 
        //  rem: Rest ist die Ziffer im 10er-System 
        qrem = udiv (qrem.quot, 10);
 
        //  Ziffer in Zeichen wandeln und speichern 
        *(--s) = '0' + qrem.rem;
    } 
    while (0 != qrem.quot);
 
    //  Falls eine führende '0' gespeichert wurde: weg damit 
    //  ausser zahl war selbst schon 0 
    if (*s == '0' && *(s+1) != '\0')
        s++;

    return s;
}

Falls man eine Division und/oder Rest für 8-Bit braucht, dann geht für unsigned analog.

Beispiel: BCD-Umrechnung

Wandeln einer 8-Bit-Zahl 0 <= num < 100 nach BCD

typedef struct
{
    unsigned char quot; //  Quotient 
    unsigned char rem;  //  Rest (remainder) 
} udiv8_t;

extern udiv8_t udiv8 (unsigned char, unsigned char) __asm__ ("__udivmodqi4");

//  Wandelt num nach BCD um, 0 <= num <= 99 
//  return-Wert ist dann 0x0 <= return <= 0x99 
unsigned char to_bcd (unsigned char num)
{
    udiv8_t qrem = udiv8 (num, 10);

    return (unsigned char) (qrem.quot << 4) | qrem.rem;
}

Division durch Multiplikation

Bei den AVRs (Mega...) sind Multiplikationen deulich schneller als Divisionen. Besonders bei Fleißkommazahlen lohnt es daher eine Division durch die Multiplikation mit dem Kehrwert zu ersetzen. Bei Integer Zahlen sind dem durch die Rundung Grenzen gesetzt.

Vermeiden von float und double

GCC kennt für die AVRs zur Zeit nur einen Fleißkommatyp. Da keine Hardwareunterstützung dafür vorhanden ist, dauern Fleißkommarechnungen relativ lange. Gerade Additionen sind deutlich langsamer als bei Integer. Auch die Codelänge nimmt erheblich zu, selbst wenn nur wenige Fleißkommazahlen genutzt werden.

Ein Alternative zu Fleißkommazahlen ist die Benutzung von Festkommazahlen, auch wenn die nicht direkt von GCC unterstützt werden. Die Werte werden einfach alle mit einem konstanten Faktor (z.B. 256,1024 oder 1000) skaliert. Es wird dann mit Integer oder Long Integer gerechnet und bei Multiplicationen / Divisionen der zusätzliche Skalenfaktor berücksichtig.