8/16 bit Integer Operationen auf Cortex M3

[Stefan F. (Gast)]

Wenn ich in meinem C/C++ Program 8 oder 16bit Integer Variablen 
miteinander verrechne, wie wirkt sich das auf die Performance aus, 
verglichen mit nativen 32bit?

uint8_t a=5;
uint8_t b=7;
uint8_t c=a+b;

uint16_t a=5;
uint16_t b=7;
uint16_t c=a+b;

Ich könnte es natürlich einfach testen, aber mich interessiert auch die 
Erklärung, warum es so ist.

[Cyblord -. (cyblord)]

Stefan U. schrieb:
> Ich könnte es natürlich einfach testen, aber mich interessiert auch die
> Erklärung, warum es so ist.

Dann schau dir die ASM Listings an.

[Stefan F. (Gast)]

Ich habe eine schön kompakte Antwort auf einer Webseite von TI bezüglich 
Stellaris µC gefunden:

"Smaller globals and statics are okay, but locals are best as ints and 
unsigned ints (or longs). If globals/static are used a lot, copy to int 
locals for duration, and copy back. It is not unusual to have a 40% 
increase in function size due to use of short locals"

http://www.ti.com/lit/an/spma014/spma014.pdf

Etwas weiter unten wird das Thema weiter erläutert.

Damit ist meine Frage umfassend beantwortet. Schade, dass ich dieses 
Dokument nicht schon gestern gefunden hatte.

[m.n. (Gast)]

Stefan U. schrieb:
> Damit ist meine Frage umfassend beantwortet

Die Antwort bezieht sich allerdings nur auf lokale Variablen. Sobald man 
globale Variablen benötigt, wird man auch auf den RAM-Bedarf sehen 
müssen. Daß diese Variablen bei Berechnungen dann auf 32 Bit 
"aufgepustet" werden, muß man hinnehmen.

[Stefan F. (Gast)]

> Sobald man globale Variablen benötigt, wird man auch auf den RAM-Bedarf
> sehen müssen.

Na klar, das hatte ich bereits zwischen den Zeilen heraus gelesen. Nicht 
umsonst hat TI im Text mehrfach von "lokalen Variablen" geschrieben 
(anstatt einfach nur "Variablen").

[Stefan F. (Gast)]

Ich habe noch etwas gefunden, bezüglich Funktionsargumente und return 
Type:
https://books.google.de/books?id=vdk4ZGRqMskC&pg=PA111

[Stefan K. (stefan64)]

Der Cortex rechnet auf Registerebene die meisten Sachen auf 32Bit 
Registerebene. Auch Functionsparameter werden in 32Bit Registern 
übergeben. Wenn Du lokale Variablen oder Functionsparameter kleiner 
definierst, dann muss der Compiler nach jeder Rechenoperation sein 
Ergebnis mit einem zusätzlichen Befehl auf 8 oder 16Bit truncaten. Dies 
gilt auch für einen Function Rückgabewert, der kleiner als 32Bit ist.

Das heisst, alle Berechnungen sollten auf 32Bit laufen. Da lokale 
Variablen meistens in Registern gehalten werden, wird dadurch auch kein 
zusätzlicher Speicher belegt.

Es macht aber keine Performanceverluste, aus 8 oder 16Bit Variablen oder 
Arrays zu lesen und zu speichern, vorausgesetzt, die Zwischenrechnungen 
können in 32Bit erfolgen.

Es gibt auch Ausnahmen, so gibt es beim F4 einige DSP-Befehle, die auf 
q7_t und q15_t optimiert sind und dabei 2 oder 4 Parameter parallel 
verarbeiten können.

Viele Grüße, Stefan

[Stefan F. (Gast)]

Ich benutze jetzt uint_fast8_t für Funktionsargumente und lokale 
Variablen. So kann ich die Library sowohl für AVR als auch für den 
ESP8266 compilieren und es wird stets der dazu optimale Datentyp 
verwendet.