Unterschied zwischen uint8_t, uint_fast8_t und uint_least8_t

Der C99-Standard führt die folgenden Datentypen ein. Die Dokumentation ist zu finden hier für die AVR stdint Bibliothek.

• uint8_t bedeutet, dass es sich um einen 8-Bit-Typ ohne Vorzeichen handelt.
• uint_fast8_t bedeutet, dass es das schnellste unsigned int mit mindestens 8 Bit ist.
• uint_least8_t bedeutet, dass es sich um ein unsigned int mit mindestens 8 Bit handelt.

Ich verstehe uint8_t und was ist uint_fast8_t(Ich weiß nicht, wie es auf Registerebene implementiert ist).

1. Können Sie erklären, was „es ist ein unsigned int mit mindestens 8 Bit”?

2.Wie uint_fast8_t und uint_least8_t helfen, die Effizienz/den Coderaum im Vergleich zu zu erhöhen uint8_t?

uint_least8_t ist der kleinste Typ, der mindestens 8 Bits hat.
uint_fast8_t ist der schnellste Typ, der mindestens 8 Bits hat.

Sie können die Unterschiede erkennen, indem Sie sich exotische Architekturen vorstellen. Stellen Sie sich eine 20-Bit-Architektur vor. Es ist unsigned int hat 20 Bit (ein Register) und seine unsigned char hat 10 bit. So sizeof(int) == 2aber mit char -Typen erfordert zusätzliche Anweisungen, um die Register zu halbieren. Dann:

• uint8_t: ist undefiniert (kein 8-Bit-Typ).
• uint_least8_t: ist unsigned charder kleinste Typ mit mindestens 8 Bit.
• uint_fast8_t: ist unsigned intweil in meiner imaginären Architektur eine Halbregistervariable langsamer ist als eine Vollregistervariable.

uint8_t bedeutet: gib mir ein unsigned int von genau 8 Bits.

uint_least8_t bedeutet: gib mir die kleinste Art von unsigned int, die mindestens 8 Bit hat. Optimieren Sie den Speicherverbrauch.

uint_fast8_t bedeutet: gib mir einen unsigned int von mindestens 8 bit. Wählen Sie aus Gründen der Ausrichtung einen größeren Typ, wenn dadurch mein Programm schneller wird. Auf Geschwindigkeit optimieren.

Auch im Gegensatz zur Ebene int -Typen ist die signierte Version der obigen stdint.h-Typen garantiert im 2er-Komplement-Format.

Die Theorie geht ungefähr so:

uint8_t muss genau 8 Bit sein, muss aber nicht existieren. Sie sollten es also dort verwenden, wo Sie sich auf das Modulo-256-Zuweisungsverhalten * einer 8-Bit-Ganzzahl verlassen und wo Sie einen Kompilierungsfehler einem Fehlverhalten auf obskuren Architekturen vorziehen würden.

uint_least8_t muss der kleinste verfügbare vorzeichenlose Ganzzahltyp sein, der mindestens 8 Bit speichern kann. Sie würden es verwenden, wenn Sie den Speicherverbrauch von Dingen wie großen Arrays minimieren möchten.

uint_fast8_t soll der “schnellste” vorzeichenlose Typ sein, der mindestens 8 Bit speichern kann; Es ist jedoch nicht garantiert, dass es für einen bestimmten Vorgang auf einem bestimmten Prozessor der schnellste ist. Sie würden es in Verarbeitungscode verwenden, der viele Operationen mit dem Wert ausführt.

Die Praxis ist, dass die Typen “schnell” und “am wenigsten” nicht oft verwendet werden.

Die “geringsten” Typen sind nur dann wirklich nützlich, wenn Sie sich um die Portabilität zu obskuren Architekturen mit CHAR_BIT != 8 kümmern, was die meisten Leute nicht tun.

Das Problem mit den „schnellen“ Typen ist, dass „am schnellsten“ schwer festzumachen ist. Ein kleinerer Typ kann eine geringere Belastung des Speicher-/Cache-Systems bedeuten, aber die Verwendung eines Typs, der kleiner als der native ist, kann zusätzliche Anweisungen erfordern. Darüber hinaus kann sich die beste Lösung zwischen Architekturversionen ändern, aber Implementierer möchten in solchen Fällen häufig vermeiden, ABI zu brechen.

Wenn man sich einige populäre Implementierungen ansieht, scheint es, dass die Definitionen von uint_fastn_t sind ziemlich willkürlich. glibc scheint sie als mindestens die “native Wortgröße” des betreffenden Systems zu definieren, ohne die Tatsache zu berücksichtigen, dass viele moderne Prozessoren (insbesondere 64-Bit-Prozessoren) spezielle Unterstützung für schnelle Operationen auf Elementen haben, die kleiner als ihr natives Wort sind Größe. IOS definiert sie anscheinend als äquivalent zu den Typen mit fester Größe. Andere Plattformen können abweichen.

Alles in allem, wenn die Leistung von engem Code mit winzigen Ganzzahlen Ihr Ziel ist, sollten Sie ein Benchmarking durchführen dein Code auf den Plattformen, die Ihnen wichtig sind, mit Typen unterschiedlicher Größe, um zu sehen, was am besten funktioniert.

* Beachten Sie, dass das Modulo-256-Zuweisungsverhalten leider nicht immer Modulo-256-Arithmetik impliziert, dank der Integer-Promotion-Fehlfunktion von C.

Einige Prozessoren können mit kleineren Datentypen nicht so effizient arbeiten wie mit großen. Zum Beispiel gegeben:

uint32_t foo(uint32_t x, uint8_t y)
{
  x+=y;
  y+=2;
  x+=y;
  y+=4;
  x+=y;
  y+=6;
  x+=y;
  return x;
}

wenn y war uint32_t ein Compiler für den ARM Cortex-M3 könnte einfach generiert werden

add r0,r0,r1,asl #2   ; x+=(y<<2)
add r0,r0,#12         ; x+=12
bx  lr                ; return x

aber seit y ist uint8_t Der Compiler müsste stattdessen Folgendes generieren:

add r0,r0,r1          ; x+=y
add r1,r1,#2          ; Compute y+2
and r1,r1,#255        ; y=(y+2) & 255
add r0,r0,r1          ; x+=y
add r1,r1,#4          ; Compute y+4
and r1,r1,#255        ; y=(y+4) & 255
add r0,r0,r1          ; x+=y
add r1,r1,#6          ; Compute y+6
and r1,r1,#255        ; y=(y+6) & 255
add r0,r0,r1          ; x+=y
bx  lr                ; return x

Der beabsichtigte Zweck der “schnellen” Typen war es, Compilern zu ermöglichen, kleinere Typen, die nicht effizient verarbeitet werden konnten, durch schnellere zu ersetzen. Leider ist die Semantik von “schnellen” Typen ziemlich schlecht spezifiziert, was wiederum unklare Fragen darüber hinterlässt, ob Ausdrücke mit vorzeichenbehafteter oder vorzeichenloser Mathematik ausgewertet werden.

1. Können Sie erklären, was “es ist ein unsigned int mit mindestens 8 Bits” bedeutet?

Das sollte klar sein. Dies bedeutet, dass es sich um einen vorzeichenlosen Integer-Typ handelt und dass seine Breite mindestens 8 Bit beträgt. In der Tat bedeutet dies, dass es zumindest die Zahlen 0 bis 255 enthalten kann, und es kann definitiv keine negativen Zahlen enthalten, aber es kann in der Lage sein, Zahlen über 255 zu speichern.

Natürlich sollten Sie keinen dieser Typen verwenden, wenn Sie vorhaben, eine Zahl außerhalb des Bereichs von 0 bis 255 zu speichern (und Sie möchten, dass sie portierbar ist).

2.Wie tragen uint_fast8_t und uint_least8_t dazu bei, die Effizienz/den Coderaum im Vergleich zu uint8_t zu erhöhen?

uint_fast8_t erforderlich ist, um schneller zu sein, also sollten Sie dies verwenden, wenn Ihre Anforderung darin besteht, dass der Code schnell ist. uint_least8_t auf der anderen Seite erfordert, dass es keinen Kandidaten mit geringerer Größe gibt – also würden Sie das verwenden, wenn es um die Größe geht.

Und natürlich verwenden Sie nur uint8_t wenn es unbedingt genau 8 Bit sein müssen. Verwenden uint8_t kann den Code als nicht portierbar machen uint8_t muss nicht vorhanden sein (weil ein solcher kleiner ganzzahliger Typ auf bestimmten Plattformen nicht vorhanden ist).

Die “schnellen” Ganzzahltypen sind definiert als die schnellste verfügbare Ganzzahl mit mindestens der erforderlichen Anzahl von Bits (in Ihrem Fall 8).

Eine Plattform kann definieren uint_fast8_t wie uint8_t Dann gibt es absolut keinen Geschwindigkeitsunterschied.

Der Grund dafür ist, dass es Plattformen gibt, die langsamer sind, wenn sie nicht ihre native Wortlänge verwenden.

Ich verwende die schnellen Datentypen (uint_fast8_t) für lokale Variablen und Funktionsparameter und die normalen (uint8_t) in Arrays und Strukturen, die häufig verwendet werden, und der Speicherbedarf ist wichtiger als die wenigen Zyklen, die durch Nichtvorhandensein eingespart werden könnten zum Löschen oder Signieren erweitern Sie die oberen Bits. Funktioniert super, außer mit MISRA Checkers. Sie werden verrückt von den schnellen Typen. Der Trick besteht darin, dass die schnellen Typen durch abgeleitete Typen verwendet werden, die für MISRA-Builds anders definiert werden können als für normale.

Ich denke, diese Typen eignen sich hervorragend zum Erstellen von portablem Code, der sowohl auf Low-End-Mikrocontrollern als auch auf großen Anwendungsprozessoren effizient ist. Die Verbesserung ist vielleicht nicht riesig oder bei guten Compilern völlig vernachlässigbar, aber besser als nichts.