Hoofdstuk 10: Betrouwbaarheid en Foutbestendigheid in GPU-ontwerp

Naarmate GPU's steeds prominenter worden in veiligheidskritische toepassingen zoals autonome voertuigen, robotica en medische apparaten, wordt het waarborgen van hun betrouwbaarheid en foutbestendigheid van cruciaal belang. GPU's zijn gevoelig voor verschillende soorten fouten en storingen die kunnen leiden tot systeemfouten, gegevensbeschadiging of onjuiste resultaten. In dit hoofdstuk zullen we de soorten fouten en storingen in GPU's, foutdetectie- en correctieschema's, checkpunt- en herstelprocessen, en ontwerpprincipes voor betrouwbaarheid en veerkracht verkennen.

Soorten Fouten en Storingen in GPU's

Fouten en storingen in GPU's kunnen worden ingedeeld in verschillende categorieën op basis van hun oorsprong, duur en impact op het systeem. Het begrijpen van deze verschillende soorten fouten en storingen is cruciaal voor het ontwikkelen van effectieve mitigatiestrategieën.

Zachte Fouten

Zachte fouten, ook wel bekend als tijdelijke fouten, zijn tijdelijke fouten veroorzaakt door externe factoren zoals kosmische straling, alfadeeltjes of elektromagnetische interferentie. Deze fouten veroorzaken geen permanente schade aan de hardware en kunnen worden gecorrigeerd door de aangetaste gegevens opnieuw te schrijven of de aangetaste bewerking opnieuw te starten.

Zachte fouten kunnen zich manifesteren in verschillende delen van de GPU, zoals:

Flip-flops en vergrendelingen: Een enkele gebeurtenis kan ertoe leiden dat de toestand van een flip-flop of vergrendeling verandert, wat kan leiden tot onjuiste gegevens of besturingsstromen.
SRAM-cellen: Zachte fouten in SRAM-cellen, zoals die gebruikt worden in caches en registerbestanden, kunnen de opgeslagen gegevens beschadigen.
DRAM-cellen: Hoewel minder vaak voorkomend dan SRAM-zachte fouten, kunnen ook DRAM-cellen bitflips ervaren als gevolg van externe factoren.

Figuur 10.1 illustreert de impact van een zachte fout op een flip-flop.

           Kosmische Straling
               |
               |
               v
        +------------+
        |            |
D ----->|  Flip-Flop |----> Q
        |            |
        +------------+
               |
               |
               v
```Zachte fout

Figuur 10.1: Zachte fout veroorzaakt door een kosmische straal die een flip-flop raakt.

Harde fouten

Harde fouten, ook bekend als permanente fouten, zijn onomkeerbare fysieke defecten in de hardware die over tijd blijven bestaan. Deze fouten kunnen worden veroorzaakt door fabricagedefecten, slijtage of fysieke schade aan het apparaat.

Voorbeelden van harde fouten in GPU's zijn:

Stuck-at-fouten: Een signaal of opslagelement is permanent vastgezet op een logische '0' of '1'-waarde, ongeacht de invoer.
Overbruggingsfouten: Twee of meer signaallijnen zijn per ongeluk met elkaar verbonden, waardoor er een kortsluiting ontstaat.
Open fouten: Een signaalfout is per ongeluk losgekoppeld, waardoor er een zwevende of onbepaalde waarde ontstaat.
Vertragingsfouten: Een signaal doet langer dan verwacht over het doorlopen van een pad, wat leidt tot timingschendingen.

Figuur 10.2 toont een voorbeeld van een stuck-at-0-fout in een logische poort.

        Stuck-at-0-fout
               |
               |
               v
           +---+
        -->| & |-->
           |   |
        -->|   |
           +---+

Figuur 10.2: Stuck-at-0-fout in een AND-poort.

Intermitterende fouten

Intermitterende fouten zijn fouten die sporadisch optreden en moeilijk consistent te reproduceren zijn. Deze fouten kunnen worden veroorzaakt door verschillende factoren, zoals:

Marginale hardware: Componenten die dicht bij hun gespecificeerde limieten werken, waardoor ze gevoeliger zijn voor omgevingsfactoren of veroudering.
Omgevingsfactoren: Temperatuurschommelingen, spanningsvariaties of elektromagnetische interferentie kunnen intermitterende fouten triggeren.
Verouderingseffecten: Naarmate het apparaat ouder wordt, kunnen bepaalde componenten vatbaarder worden voor intermitterende storingen als gevolg van slijtage of degradatie.

Intermitterende fouten vormen een aanzienlijke uitdaging voor foutdetectie en -correctie, aangezien ze mogelijk niet worden vastgelegd door traditionele test- of monitoringtechnieken.

Stille gegevensvervorming

Stille gegevensvervorming (SDC) verwijst naar fouten die gegevens vervormen zonder dat dit wordt opgemerkt. Dit kanHier is de Nederlandse vertaling van het Markdown-bestand, waarbij de code-opmerkingen zijn vertaald:

Soft Data Corruption (SDC) is een type fout waarbij fouten in de hardware of software niet worden gedetecteerd. SDC kan leiden tot onjuiste resultaten of systeemfouten die gedurende een lange periode onopgemerkt kunnen blijven.

Voorbeelden van SDC in GPU's zijn:

Rekenfouten: Fouten in rekenkundige eenheden, zoals optellers of vermenigvuldigers, kunnen onjuiste resultaten opleveren zonder dat er foutmeldingen worden gegeven.
Geheugenfouten: Zachte fouten of harde defecten in geheugencellen kunnen gegevens beschadigen zonder dat dit wordt gedetecteerd door foutcontrole-mechanismen.
Besturingsfout: Fouten in de besturingslogica of instructie-decoders kunnen ervoor zorgen dat het programma afwijkt van de bedoelde uitvoeringsweg zonder dat er uitzonderingen worden geactiveerd.

SDC is bijzonder gevaarlijk omdat het zich door het systeem kan verspreiden en de uiteindelijke output kan beïnvloeden zonder zichtbare symptomen. Het detecteren en mitigeren van SDC vereist een combinatie van hardware- en softwaretechnieken.

Foutdetectie- en correctieschema's

Om de impact van fouten en fouten in GPU's te beperken, zijn er verschillende foutdetectie- en correctieschema's ontwikkeld. Deze schema's zijn bedoeld om de aanwezigheid van fouten te identificeren en in sommige gevallen te corrigeren om de juiste werking van het systeem te garanderen.

Pariteitscontrole

Pariteitscontrole is een eenvoudige foutdetectietechniek waarbij een extra bit (het pariteitsbit) wordt toegevoegd aan elk gegevenswoord om het totale aantal '1'-bits ofwel even (even pariteit) ofwel oneven (oneven pariteit) te maken. Door de pariteit van het gegevenswoord te controleren, kunnen enkelvoudige bitfouten worden gedetecteerd.

Figuur 10.3 illustreert een voorbeeld van pariteitscontrole met even pariteit.

    Gegevenswoord: 1011010
    Pariteitsbit:      1
    Verzonden: 10110101

    Ontvangen:   10110111
    Pariteitsbit:      0
    Fout gedetecteerd!

Figuur 10.3: Pariteitscontrole met even pariteit voor foutdetectie.

Pariteitscontrole kan worden toegepast op verschillende componenten in de GPU, zoals registers, caches en geheugeninterfaces. Pariteitscontrole kan echter alleen oneven aantallen bitfouten detecteren en kan de fouten niet corrigeren.

Foutcorrigerende codes (ECC)

Foutcorrigerende codes (ECC) zijnHier is de Nederlandse vertaling van het bestand, waarbij de code-opmerkingen zijn vertaald:

Meer geavanceerde foutdetectie- en correctieschema's die niet alleen fouten kunnen detecteren, maar deze ook kunnen corrigeren. ECC werkt door redundante bits toe te voegen aan het datawoord, waardoor de ontvanger een beperkt aantal bitfouten kan identificeren en corrigeren.

Een veel voorkomend ECC-schema is de Single Error Correction, Double Error Detection (SECDED)-code, die enkelvoudige bitfouten kan corrigeren en dubbele bitfouten kan detecteren. SECDED-codes worden vaak gebruikt in geheugensystemen, zoals DRAM en caches, om te beschermen tegen zachte fouten.

Figuur 10.4 toont een voorbeeld van een SECDED-code.

    Datawoord: 1011010
    ECC-bits:    01101
    Verzonden: 101101001101

    Ontvangen:   101101011101
                       ^
                       |
                   Bitfout

    Gecorrigeerd:  101101001101

Figuur 10.4: SECDED-code voor foutcorrectie en -detectie.

Andere ECC-schema's, zoals Bose-Chaudhuri-Hocquenghem (BCH)-codes en Reed-Solomon-codes, kunnen meerdere bitfouten corrigeren tegen de prijs van een hogere redundantie en complexiteit.

Redundante uitvoering

Redundante uitvoering is een techniek waarbij dezelfde berekening meerdere keren wordt uitgevoerd, hetzij op dezelfde hardware, hetzij op verschillende hardwareeenheden, en de resultaten worden vergeleken om fouten te detecteren. Als de resultaten niet overeenkomen, wordt een fout gedetecteerd en kan het systeem passende maatregelen nemen, zoals de berekening opnieuw proberen of een herstelproces starten.

Redundante uitvoering kan op verschillende niveaus in de GPU worden geïmplementeerd:

Instructie-niveau redundantie: Elke instructie wordt meerdere keren uitgevoerd en de resultaten worden vergeleken voordat ze naar het registerbestand of het geheugen worden geschreven.
Thread-niveau redundantie: Meerdere threads voeren dezelfde berekening uit en hun resultaten worden vergeleken om fouten te detecteren.
Kernel-niveau redundantie: De volledige kernel wordt meerdere keren uitgevoerd en de uiteindelijke uitvoer wordt vergeleken om fouten te detecteren.

Figuur 10.5 illustreert thread-niveau redundantie in een GPU.

    Thread 0   Thread 1   Thread 2   Thread 3
```Hier is de Nederlandse vertaling van het Markdown-bestand, waarbij de code-opmerkingen zijn vertaald:

|          |          |          |          |
       v          v          v          v
    +-------+  +-------+  +-------+  +-------+
    | Comp. |  | Comp. |  | Comp. |  | Comp. |
    +-------+  +-------+  +-------+  +-------+
       |          |          |          |
       v          v          v          v
    +------------+------------+------------+
    |          Comparator                 |
    +------------+------------+------------+
                 |
                 v
            Foutdetectie

Figuur 10.5: Thread-level redundantie voor foutdetectie.

Redundante uitvoering kan een breed scala aan fouten detecteren, waaronder zachte fouten, harde fouten en SDC. Dit gaat echter ten koste van een langere uitvoeringstijd en een hoger energieverbruik.

Watchdog-timers

Watchdog-timers zijn hardware- of softwaremechanismen die de uitvoering van de GPU bewaken en detecteren of het systeem niet reageert of een taak niet binnen een bepaalde tijdslimiet voltooit. Als de watchdog-timer verloopt, duidt dit op een fout, en kan het systeem een herstelproces starten, zoals het resetten van de GPU of het opnieuw starten van de betreffende bewerking.

Watchdog-timers kunnen op verschillende niveaus in de GPU worden geïmplementeerd:

Kernel-level watchdog: Bewaakt de uitvoeringstijd van elke kernel en detecteert als een kernel niet binnen een bepaalde tijdslimiet wordt voltooid.
Thread-level watchdog: Bewaakt de uitvoeringstijd van elke thread en detecteert als een thread niet binnen een bepaalde tijdslimiet wordt voltooid.

Checkpoint- en herstel-mechanismen

Checkpoint- en herstel-mechanismen worden gebruikt om de toestand van een GPU-toepassing op regelmatige intervallen op te slaan en de toestand te herstellen in geval van een fout. Door de toestand van de toepassing periodiek op te slaan, kan het systeem herstellen van fouten zonder de volledige berekening opnieuw te moeten starten.

Checkpoint- en herstel-mechanismen kunnen op verschillende niveaus in de GPU worden geïmplementeerd:

Toepassings-level checkpointing: De toepassing zelf is verantwoordelijk voor het opslaan en herstellen van de toestand.Hier is de Nederlandse vertaling van het bestand:
Applicatie-niveau checkpointing: De applicatie zelf is verantwoordelijk voor het opslaan van zijn toestand op regelmatige intervallen. Dit kan worden gedaan door expliciet de inhoud van het geheugen en de registers op te slaan naar een checkpoint bestand.
Systeem-niveau checkpointing: Het GPU runtime systeem of de driver is verantwoordelijk voor het opslaan van de toestand van de applicatie. Dit kan transparant voor de applicatie gebeuren, zonder dat er wijzigingen aan de applicatiecode nodig zijn.
Hardware-niveau checkpointing: De GPU hardware zelf biedt ondersteuning voor het opslaan en herstellen van de toestand van de applicatie. Dit kan worden gedaan met behulp van speciale hardware mechanismen, zoals niet-vluchtig geheugen of speciale registers.

Figuur 10.8 illustreert een typisch checkpoint en herstelproces.

    Normale uitvoering
          |
          |
          v
      Checkpoint
          |
          |
          v
    Normale uitvoering
          |
          |
          v
       Fout
          |
          |
          v
        Herstel
          |
          |
          v
    Normale uitvoering

Figuur 10.8: Checkpoint en herstelproces.

Tijdens normale uitvoering slaat het systeem periodiek de toestand van de applicatie op in een checkpoint. Als er een fout optreedt, herstelt het systeem de toestand vanaf het meest recente checkpoint en hervat de uitvoering vanaf dat punt.

Checkpoint en herstel mechanismen kunnen de betrouwbaarheid en veerkracht van GPU applicaties verbeteren, vooral voor langlopende berekeningen. Ze brengen echter ook overhead met zich mee in termen van opslagruimte en uitvoeringstijd, omdat het opslaan en herstellen van de toestand extra resources vereist.

Ontwerpen voor betrouwbaarheid en veerkracht

Het ontwerpen van GPU's voor betrouwbaarheid en veerkracht omvat een combinatie van hardware- en softwaretechnieken. Enkele belangrijke ontwerpprincipes en -technieken zijn:

Foutdetectie en -correctie: Het opnemen van foutdetectie- en correctiemechanismen, zoals ECC en pariteitscontrole, op verschillende niveaus in de GPU, waaronder geheugens, caches en interconnecties.
Redundantie: Het gebruik van redundante componenten, zoals dubbele geheugenbanken of meerdere processoreenheden, om fouttolerantie te bieden.Hier is de Nederlandse vertaling van het bestand:

Ant hardware-componenten, zoals reservekernen of geheugenmodules, om fouttoleratie te bieden en geleidelijke degradatie mogelijk te maken bij het optreden van storingen.

Checkpointing en herstel: Het implementeren van checkpointing- en herstelmechanismen om de toestand van de toepassing op te slaan en herstel van storingen mogelijk te maken.
Foutbeperking: Het ontwerpen van de GPU-architectuur om de voortplanting van fouten te beperken en te voorkomen dat fouten zich over het hele systeem verspreiden. Dit kan worden bereikt door middel van technieken zoals partitionering, isolatie en foutbeperkende barrières.
Software-veerkracht: Het ontwikkelen van softwaretechnieken, zoals algoritme-gebaseerde fouttoleratie (ABFT), die applicaties in staat stellen om fouten te detecteren en te herstellen door middel van software-redundantie en controle.
Betrouwbaarheidsgerichte planning: Het aanpassen van de planning van taken en middelen in de GPU om rekening te houden met de betrouwbaarheidskenmerken van verschillende componenten en te optimaliseren voor zowel prestaties als betrouwbaarheid.

Voorbeeld: Betrouwbaarheidsgerichte planning in een GPU

Overweeg een GPU met meerdere cores, waarbij sommige cores bekender zijn voor fouten dan andere. Een betrouwbaarheidsgerichte planner kan kritieke taken of taken met hoge betrouwbaarheidseisen toewijzen aan de meer betrouwbare cores, terwijl minder kritieke taken worden toegewezen aan de minder betrouwbare cores.

Figuur 10.9 illustreert een betrouwbaarheidsgerichte planningsbenadering.

    Taakwachtrij
    +-------+
    | Taak1 |
    | Taak2 |
    | Taak3 |
    | Taak4 |
    +-------+
        |
        |
        v
    Betrouwbaarheidsgerichte planner
        |
        |
        v
    +--------+--------+
    | Core 1 | Core 2 |
    |  (HR)  |  (LR)  |
    +--------+--------+
    | Taak1  | Taak3  |
    | Taak2  | Taak4  |
    +--------+--------+

Figuur 10.9: Betrouwbaarheidsgerichte planning in een GPU (HR: Hoge betrouwbaarheid, LR: Lage betrouwbaarheid).

In dit voorbeeld wijst de planner Taak1 en Taak2, die hoge betrouwbaarheidseisen hebben, toe aan Core 1, die bekend staat als meerHier is de Nederlandse vertaling van het bestand:

Conclusie

Betrouwbaarheid en foutbestendigheid zijn kritieke aspecten van GPU-ontwerp en -werking, vooral omdat GPU's steeds vaker worden gebruikt in veiligheidskritische toepassingen. Het begrijpen van de soorten fouten en fouten die kunnen optreden in GPU's, evenals de technieken voor het detecteren, corrigeren en herstellen van deze fouten, is essentieel voor het ontwerpen van betrouwbare en veerkrachtige GPU-systemen.

Foutdetectie- en correctieschema's, zoals ECC en pariteitscontrole, spelen een cruciale rol bij het identificeren en verzachten van zachte fouten en harde storingen in verschillende onderdelen van de GPU. Checkpunt- en herstelmechanismen stellen het systeem in staat de toestand van de toepassing op te slaan en te herstellen na storingen, waardoor de algehele veerkracht van het systeem wordt verbeterd.

GPU's ontwerpen voor betrouwbaarheid en veerkracht vereist een holistische aanpak die hardware- en softwaretechnieken combineert. Redundantie, foutbeperking, softwarevertrouwen en betrouwbaarheidsgerichte planning zijn enkele van de belangrijkste technieken die kunnen worden ingezet om de betrouwbaarheid en foutbestendigheid van GPU's te verbeteren.

Naarmate GPU's zich blijven ontwikkelen en nieuwe toepassingen vinden in domeinen als autonome voertuigen, robotica en gezondheidszorg, zal het waarborgen van hun betrouwbaarheid en veerkracht steeds belangrijker worden. Nieuwe technieken voor foutdetectie en -correctie, checkpunt en herstel, en betrouwbaarheidsgerichte resourcemanagement zullen essentieel zijn voor het mogelijk maken van de volgende generatie betrouwbare en foutbestendige GPU's.

Chapter 9 Power Energy and Thermal Management Chapter 11 Gpu Research Directions on Scalarization and Affine Execution