Chapitre 10 : Fiabilité et tolérance aux pannes dans la conception de GPU

Alors que les GPU deviennent de plus en plus présents dans les applications critiques pour la sécurité telles que les véhicules autonomes, la robotique et les dispositifs médicaux, assurer leur fiabilité et leur tolérance aux pannes devient primordial. Les GPU sont susceptibles à divers types de pannes et d'erreurs pouvant entraîner des défaillances du système, des corruptions de données ou des résultats incorrects. Dans ce chapitre, nous explorerons les types de pannes et d'erreurs dans les GPU, les schémas de détection et de correction d'erreurs, les mécanismes de sauvegarde et de récupération, ainsi que les principes de conception pour la fiabilité et la résilience.

Types de pannes et d'erreurs dans les GPU

Les pannes et les erreurs dans les GPU peuvent être classées en plusieurs catégories en fonction de leur origine, de leur durée et de leur impact sur le système. Comprendre ces différents types de pannes et d'erreurs est essentiel pour développer des stratégies d'atténuation efficaces.

Erreurs transitoires

Les erreurs transitoires, également connues sous le nom de pannes transitoires, sont des erreurs temporaires causées par des facteurs externes tels que les rayons cosmiques, les particules alpha ou les interférences électromagnétiques. Ces erreurs ne causent pas de dommages permanents au matériel et peuvent être corrigées en réécrivant les données affectées ou en redémarrant l'opération affectée.

Les erreurs transitoires peuvent se manifester dans diverses parties du GPU, telles que :

Bascules et verrous : Un événement de perturbation unique (SEU) peut faire changer l'état d'une bascule ou d'un verrou, entraînant des données ou un flux de contrôle incorrects.
Cellules SRAM : Les erreurs transitoires dans les cellules SRAM, comme celles utilisées dans les caches et les registres, peuvent corrompre les données stockées.
Cellules DRAM : Bien que moins fréquentes que les erreurs transitoires dans les SRAM, les cellules DRAM peuvent également subir des inversions de bits dues à des facteurs externes.

La figure 10.1 illustre l'impact d'une erreur transitoire sur une bascule.

           Rayon cosmique
               |
               |
               v
        +------------+
        |            |
D ----->|  Bascule   |----> Q
        |            |
        +------------+
               |
               |
               v
```Erreur douce

Figure 10.1 : Erreur douce causée par un rayon cosmique frappant une bascule.

Erreurs dures

Les erreurs dures, également connues sous le nom de défauts permanents, sont des défauts physiques irréversibles dans le matériel qui persistent dans le temps. Ces erreurs peuvent être causées par des défauts de fabrication, l'usure ou des dommages physiques au dispositif.

Exemples d'erreurs dures dans les GPU :

Défauts de type "stuck-at" : Un signal ou un élément de stockage est bloqué de manière permanente à une valeur logique '0' ou '1', quel que soit l'entrée.
Défauts de pontage : Deux lignes de signal ou plus sont accidentellement connectées, provoquant un court-circuit.
Défauts d'ouverture : Une ligne de signal est accidentellement déconnectée, provoquant une valeur flottante ou indéterminée.
Défauts de retard : Un signal met plus longtemps que prévu à se propager dans un chemin, entraînant des violations de chronologie.

La figure 10.2 montre un exemple de défaut de type "stuck-at-0" dans une porte logique.

        Défaut de type "stuck-at-0"
               |
               |
               v
           +---+
        -->| & |-->
           |   |
        -->|   |
           +---+

Figure 10.2 : Défaut de type "stuck-at-0" dans une porte ET.

Erreurs intermittentes

Les erreurs intermittentes sont des défauts qui se produisent de manière sporadique et sont difficiles à reproduire de manière cohérente. Ces erreurs peuvent être causées par divers facteurs, tels que :

Matériel marginal : Des composants qui fonctionnent à la limite de leurs limites spécifiées, les rendant plus sensibles aux facteurs environnementaux ou au vieillissement.
Facteurs environnementaux : Les fluctuations de température, les variations de tension ou les interférences électromagnétiques peuvent déclencher des erreurs intermittentes.
Effets de vieillissement : Au fur et à mesure que le dispositif vieillit, certains composants peuvent devenir plus sujets aux défaillances intermittentes en raison de l'usure ou de la dégradation.

Les erreurs intermittentes posent un défi important pour la détection et la correction des erreurs, car elles peuvent ne pas être capturées par les techniques de test ou de surveillance traditionnelles.

Corruption silencieuse des données

La corruption silencieuse des données (SDC) fait référence à des erreurs qui corrompent les données sansVoici la traduction française du fichier Markdown, avec les commentaires traduits mais le code non traduit :

Détection de silencieuse des erreurs (SDC) sur les GPU

La détection silencieuse des erreurs (SDC) fait référence à des erreurs qui ne sont pas détectées par le matériel ou le logiciel. Les SDC peuvent entraîner des résultats incorrects ou des défaillances du système qui peuvent passer inaperçues pendant une période prolongée.

Exemples de SDC sur les GPU :

Erreurs arithmétiques : Les défauts dans les unités arithmétiques, comme les additionneurs ou les multiplicateurs, peuvent produire des résultats incorrects sans déclencher de drapeaux d'erreur.
Erreurs de mémoire : Les erreurs transitoires ou les défauts permanents dans les cellules mémoire peuvent corrompre les données sans être détectés par les mécanismes de vérification des erreurs.
Erreurs de flux de contrôle : Les défauts dans la logique de contrôle ou les décodeurs d'instructions peuvent faire dévier le programme de son chemin d'exécution prévu sans déclencher d'exceptions.

Les SDC sont particulièrement dangereuses car elles peuvent se propager dans le système et affecter la sortie finale sans aucun symptôme visible. La détection et l'atténuation des SDC nécessitent une combinaison de techniques matérielles et logicielles.

Schémas de détection et de correction des erreurs

Pour atténuer l'impact des défauts et des erreurs sur les GPU, divers schémas de détection et de correction des erreurs ont été développés. Ces schémas visent à identifier la présence d'erreurs et, dans certains cas, à les corriger pour assurer le bon fonctionnement du système.

Vérification de parité

La vérification de parité est une technique de détection d'erreurs simple qui ajoute un bit supplémentaire (le bit de parité) à chaque mot de données pour que le nombre total de bits '1' soit soit pair (parité paire), soit impair (parité impaire). En vérifiant la parité du mot de données, les erreurs à un seul bit peuvent être détectées.

La figure 10.3 illustre un exemple de vérification de parité paire.

    Mot de données : 1011010
    Bit de parité :      1
    Transmis : 10110101

    Reçu :   10110111
    Bit de parité :      0
    Erreur détectée !

Figure 10.3 : Vérification de parité paire pour la détection d'erreurs.

La vérification de parité peut être appliquée à divers composants du GPU, tels que les registres, les caches et les interfaces mémoire. Cependant, la vérification de parité ne peut détecter que les erreurs à un nombre impair de bits et ne peut pas les corriger.

Codes de correction d'erreurs (ECC)

Les codes de correction d'erreurs (ECC) sontVoici la traduction française du fichier Markdown, avec les commentaires traduits mais le code non traduit :

Des schémas de détection et de correction d'erreurs plus avancés qui peuvent non seulement détecter les erreurs mais aussi les corriger. L'ECC fonctionne en ajoutant des bits redondants au mot de données, ce qui permet au récepteur d'identifier et de corriger un nombre limité d'erreurs de bits.

Un schéma ECC courant est le code de correction d'erreurs simples, de détection d'erreurs doubles (SECDED), qui peut corriger les erreurs de bits simples et détecter les erreurs de bits doubles. Les codes SECDED sont souvent utilisés dans les systèmes de mémoire, comme la DRAM et les caches, pour se protéger contre les erreurs transitoires.

La figure 10.4 montre un exemple d'un code SECDED.

    Mot de données : 1011010
    Bits ECC :        01101
    Transmis : 101101001101

    Reçu :     101101011101
                       ^
                       |
                   Erreur de bit

    Corrigé :  101101001101

Figure 10.4 : Code SECDED pour la correction et la détection d'erreurs.

D'autres schémas ECC, comme les codes de Bose-Chaudhuri-Hocquenghem (BCH) et les codes de Reed-Solomon, peuvent corriger plusieurs erreurs de bits au prix d'une redondance et d'une complexité plus élevées.

Exécution redondante

L'exécution redondante est une technique qui effectue le même calcul plusieurs fois, soit sur le même matériel, soit sur différentes unités matérielles, et compare les résultats pour détecter les erreurs. Si les résultats ne correspondent pas, une erreur est détectée et le système peut prendre les mesures appropriées, comme réessayer le calcul ou lancer un processus de récupération.

L'exécution redondante peut être mise en œuvre à différents niveaux dans le GPU :

Redondance au niveau de l'instruction : Chaque instruction est exécutée plusieurs fois et les résultats sont comparés avant d'être validés dans le registre ou la mémoire.
Redondance au niveau du thread : Plusieurs threads effectuent le même calcul et leurs résultats sont comparés pour détecter les erreurs.
Redondance au niveau du noyau : L'ensemble du noyau est exécuté plusieurs fois et les sorties finales sont comparées pour détecter les erreurs.

La figure 10.5 illustre la redondance au niveau du thread dans un GPU.

    Thread 0   Thread 1   Thread 2   Thread 3
```Voici la traduction française du fichier Markdown, avec les commentaires traduits mais le code non traduit :

|          |          |          |
       v          v          v          v
    +-------+  +-------+  +-------+  +-------+
    | Comp. |  | Comp. |  | Comp. |  | Comp. |
    +-------+  +-------+  +-------+  +-------+
       |          |          |          |
       v          v          v          v
    +------------+------------+------------+
    |          Comparateur                |
    +------------+------------+------------+
                 |
                 v
            Détection d'erreurs

Figure 10.5 : Redondance au niveau des threads pour la détection d'erreurs.

L'exécution redondante peut détecter une large gamme d'erreurs, y compris les erreurs transitoires, les pannes matérielles et les erreurs silencieuses. Cependant, elle entraîne un coût en termes de temps d'exécution et de consommation d'énergie.

Minuteries de surveillance (Watchdog)

Les minuteries de surveillance sont des mécanismes matériels ou logiciels qui surveillent l'exécution du GPU et détectent si le système devient non réactif ou ne parvient pas à terminer une tâche dans un délai spécifié. Si la minuterie de surveillance expire, cela indique une erreur, et le système peut lancer un processus de récupération, comme la réinitialisation du GPU ou le redémarrage de l'opération affectée.

Les minuteries de surveillance peuvent être mises en œuvre à différents niveaux dans le GPU :

Minuterie de surveillance au niveau du noyau : Surveille le temps d'exécution de chaque noyau et détecte si un noyau ne parvient pas à se terminer dans un délai spécifié.
Minuterie de surveillance au niveau du thread : Surveille le temps d'exécution de chaque thread et détecte si un thread ne parvient pas à se terminer dans un délai spécifié.

Mécanismes de sauvegarde et de récupération

Les mécanismes de sauvegarde et de récupération sont utilisés pour sauvegarder l'état d'une application GPU à intervalles réguliers et restaurer l'état en cas de défaillance. En sauvegardant périodiquement l'état de l'application, le système peut se remettre des défaillances sans avoir à redémarrer le calcul complet depuis le début.

Les mécanismes de sauvegarde et de récupération peuvent être mis en œuvre à différents niveaux dans le GPU :

Sauvegarde au niveau de l'application : L'application elle-même est responsable de la sauvegarde de son état.Voici la traduction française du fichier Markdown, avec les commentaires traduits mais le code non traduit :
Checkpointing au niveau de l'application : L'application elle-même est responsable de sauvegarder son état à intervalles réguliers. Cela peut être fait en enregistrant explicitement le contenu de la mémoire et des registres dans un fichier de point de contrôle.
Checkpointing au niveau du système : Le système d'exécution ou le pilote GPU est responsable de sauvegarder l'état de l'application. Cela peut être fait de manière transparente pour l'application, sans nécessiter de modifications du code de l'application.
Checkpointing au niveau du matériel : Le matériel GPU lui-même fournit un support pour sauvegarder et restaurer l'état de l'application. Cela peut être fait à l'aide de mécanismes matériels dédiés, tels que la mémoire non volatile ou des registres spéciaux.

La figure 10.8 illustre un processus typique de point de contrôle et de récupération.

    Exécution normale
          |
          |
          v
      Point de contrôle
          |
          |
          v
    Exécution normale
          |
          |
          v
       Défaillance
          |
          |
          v
        Restauration
          |
          |
          v
    Exécution normale

Figure 10.8 : Processus de point de contrôle et de récupération.

Pendant l'exécution normale, le système sauvegarde périodiquement l'état de l'application dans un point de contrôle. En cas de défaillance, le système restaure l'état à partir du point de contrôle le plus récent et reprend l'exécution à partir de ce point.

Les mécanismes de point de contrôle et de récupération peuvent contribuer à améliorer la fiabilité et la résilience des applications GPU, en particulier pour les calculs de longue durée. Cependant, ils introduisent également un surcoût en termes d'espace de stockage et de temps d'exécution, car la sauvegarde et la restauration de l'état nécessitent des ressources supplémentaires.

Conception pour la fiabilité et la résilience

La conception de GPU pour la fiabilité et la résilience implique une combinaison de techniques matérielles et logicielles. Quelques principes de conception et techniques clés incluent :

Détection et correction d'erreurs : Incorporation de mécanismes de détection et de correction d'erreurs, tels que la correction d'erreurs et le contrôle de parité, à différents niveaux du GPU, y compris les mémoires, les caches et les interconnexions.
Redondance : Utilisation de redondanceVoici la traduction française du fichier markdown :

Composants matériels de l'ant, tels que des cœurs de rechange ou des modules de mémoire, pour assurer la tolérance aux pannes et permettre une dégradation en douceur en cas de défaillances.

Checkpoint et récupération : Mise en œuvre de mécanismes de checkpoint et de récupération pour sauvegarder l'état de l'application et permettre la récupération en cas de défaillances.
Confinement des pannes : Conception de l'architecture GPU pour limiter la propagation des erreurs et empêcher la diffusion des pannes dans tout le système. Cela peut être réalisé à l'aide de techniques telles que le partitionnement, l'isolation et les barrières de confinement des erreurs.
Résilience logicielle : Développement de techniques logicielles, telles que la tolérance aux pannes basée sur les algorithmes (ABFT), permettant aux applications de détecter et de récupérer des erreurs grâce à la redondance et à la vérification au niveau logiciel.
Ordonnancement sensible à la fiabilité : Adaptation de l'ordonnancement des tâches et des ressources dans le GPU pour tenir compte des caractéristiques de fiabilité des différents composants et optimiser à la fois les performances et la fiabilité.

Exemple : Ordonnancement sensible à la fiabilité dans un GPU

Considérons un GPU avec plusieurs cœurs, dont certains sont plus sujets aux erreurs que d'autres. Un ordonnanceur sensible à la fiabilité peut affecter les tâches critiques ou les tâches ayant des exigences de fiabilité élevées aux cœurs les plus fiables, tandis qu'il affectera les tâches moins critiques aux cœurs les moins fiables.

La figure 10.9 illustre une approche d'ordonnancement sensible à la fiabilité.

    File d'attente des tâches
    +-------+
    | Tâche1|
    | Tâche2|
    | Tâche3|
    | Tâche4|
    +-------+
        |
        |
        v
    Ordonnanceur sensible à la fiabilité
        |
        |
        v
    +--------+--------+
    | Cœur 1 | Cœur 2 |
    |  (HR)  |  (LR)  |
    +--------+--------+
    | Tâche1 | Tâche3 |
    | Tâche2 | Tâche4 |
    +--------+--------+

Figure 10.9 : Ordonnancement sensible à la fiabilité dans un GPU (HR : Haute fiabilité, LR : Faible fiabilité).

Dans cet exemple, l'ordonnanceur affecte les Tâche1 et Tâche2, qui ont des exigences de fiabilité élevées, au Cœur 1, qui est connu pour être plusVoici la traduction française du fichier markdown :

Conclusion

La fiabilité et la tolérance aux pannes sont des aspects essentiels de la conception et du fonctionnement des GPU, d'autant plus que les GPU sont de plus en plus utilisés dans des applications critiques pour la sécurité. Comprendre les types de pannes et d'erreurs qui peuvent se produire dans les GPU, ainsi que les techniques de détection, de correction et de récupération de ces pannes, est essentiel pour concevoir des systèmes GPU fiables et résilients.

Les schémas de détection et de correction des erreurs, tels que l'ECC et la vérification de parité, jouent un rôle crucial dans l'identification et l'atténuation des erreurs transitoires et des pannes permanentes dans les différents composants du GPU. Les mécanismes de sauvegarde et de récupération permettent au système d'enregistrer l'état de l'application et de se remettre des défaillances, améliorant ainsi la résilience globale du système.

La conception de GPU pour la fiabilité et la résilience implique une approche globale combinant des techniques matérielles et logicielles. La redondance, le confinement des pannes, la résilience logicielle et l'ordonnancement sensible à la fiabilité sont quelques-unes des principales techniques qui peuvent être utilisées pour améliorer la fiabilité et la tolérance aux pannes des GPU.

Alors que les GPU continuent d'évoluer et de trouver de nouvelles applications dans des domaines tels que les véhicules autonomes, la robotique et les soins de santé, assurer leur fiabilité et leur résilience deviendra de plus en plus important. Des techniques novatrices de détection et de correction des erreurs, de sauvegarde et de récupération, ainsi que de gestion des ressources sensible à la fiabilité, seront essentielles pour permettre la prochaine génération de GPU fiables et tolérants aux pannes.

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