Simple Science

La science de pointe expliquée simplement

# Informatique# Informatique distribuée, parallèle et en grappes# Performances

Avancées dans le GEMM pour un calcul fiable

Un nouveau design GEMM basé sur GPU offre de la vitesse et une correction d'erreur en temps réel.

― 6 min lire


Conception de GEMMConception de GEMMrévolutionnairefiabilité malgré les erreurs de calcul.Le GEMM optimisé assure rapidité et
Table des matières

La multiplication de matrices générale (GEMM) est une opération clé dans plein de domaines comme l'apprentissage machine et le calcul scientifique. Ça consiste à multiplier deux matrices pour en produire une troisième. GEMM est essentiel parce que beaucoup de calculs complexes dépendent de son efficacité. Plus GEMM est rapide et fiable, meilleure est la performance globale de ces calculs.

Importance de la performance et de la fiabilité

À mesure que les systèmes informatiques deviennent plus grands et plus complexes, ils sont aussi plus susceptibles aux erreurs. Ces erreurs, souvent appelées fautes transitoires, peuvent se produire pendant le traitement des données ou lors de leur stockage. Des facteurs comme la taille réduite des puces et l'augmentation de l'activité électrique contribuent à ces fautes. Si ces erreurs ne sont pas gérées, elles peuvent causer des problèmes significatifs, comme des pannes de serveurs ou des échecs de clusters de calcul.

Pour lutter contre ces problèmes, les chercheurs se concentrent sur l'amélioration de la rapidité et de la fiabilité des opérations GEMM. Cet article présente un nouveau design pour un GEMM basé sur GPU qui peut corriger les erreurs en temps réel, ce qui garantit que les calculs restent précis même en cas de fautes.

Fautes en informatique

Quand une erreur survient en informatique, elle tombe dans l'une des deux grandes catégories. La première s'appelle les erreurs de type "fail-stop", où l'application plante complètement. La deuxième est celle des erreurs de type "fail-continue", où l'application continue de tourner mais avec des résultats incorrects. Les erreurs de type "fail-stop" peuvent souvent être réparées en redémarrant l'application ou en utilisant des méthodes de codage spéciales pour éviter les plantages. Par contre, les erreurs de type "fail-continue" peuvent être plus dangereuses car elles peuvent produire des données incorrectes sans qu'on s'en rende compte tout de suite.

Cet article se concentre sur les erreurs de type "fail-continue" et propose des moyens de corriger ces erreurs pendant l'opération GEMM elle-même. L'objectif est de protéger les résultats des erreurs qui se produisent pendant les calculs.

Techniques actuelles de gestion des erreurs

Une façon courante de gérer les erreurs est d'utiliser la redondance modulaire duale (DMR). Cette technique crée une copie des opérations réalisées pour vérifier les résultats. Bien que la DMR soit efficace, elle peut ralentir les calculs car elle duplique tout le travail. Pour optimiser la performance, de nouvelles méthodes connues sous le nom de tolérance aux fautes basée sur des algorithmes (ABFT) ont été développées. Ces méthodes aident à détecter et corriger les erreurs sans dupliquer entièrement chaque opération.

Création d'un GEMM haute performance

Créer un GEMM efficace qui inclut aussi la Correction d'erreurs en temps réel nécessite de partir d'une base solide. Les chercheurs ont commencé par développer une version très efficace de GEMM, qui sert de fondement pour mettre en œuvre des stratégies de correction d'erreurs.

Optimisation de la performance de GEMM

Pour améliorer la performance initiale de GEMM, plusieurs étapes d'optimisation ont été mises en œuvre :

  1. Tiling : Cette technique permet de diviser la charge de travail en sections plus petites et plus gérables, améliorant le traitement des données et l'utilisation de la mémoire.

  2. Réutilisation des données : En réutilisant les données stockées en mémoire au lieu de les récupérer constamment, le temps nécessaire pour les opérations peut être réduit.

  3. Prefetching : Cela consiste à charger les données en mémoire à l'avance afin qu'elles soient prêtes à être utilisées quand nécessaire, minimisant les délais pendant les calculs.

Ces optimisations combinées entraînent des gains de performance significatifs, permettant au nouveau design GEMM de dépasser les solutions existantes.

Mise en œuvre de la tolérance aux fautes dans GEMM

Avec un GEMM haute performance établi, la prochaine étape est d'intégrer la tolérance aux fautes. L'objectif est de s'assurer que même en cas d'erreurs, les résultats peuvent encore être fiables.

Différents niveaux de tolérance aux fautes

La tolérance aux fautes peut être appliquée à divers niveaux dans le processus informatique :

  1. Niveau de thread : Cette méthode met en œuvre la détection et la correction des erreurs au sein des threads individuels pendant les calculs.

  2. Niveau de warp : Ici, plusieurs threads travaillent ensemble pour gérer les erreurs, permettant une communication plus efficace entre eux.

  3. Niveau de bloc de threads : C'est l'approche la plus avancée, où des groupes de threads fonctionnent comme une unité pour gérer les erreurs sans accroc.

En utilisant ces techniques, les chercheurs ont réussi à créer un GEMM capable de détecter et de réparer les erreurs au fur et à mesure qu'elles se produisent, améliorant considérablement la fiabilité sans perdre en vitesse.

Évaluation des Performances

Pour valider l'efficacité de la nouvelle conception du GEMM, il a été évalué sur deux modèles avancés de GPU. Les résultats ont été comparés à des solutions précédentes à la pointe de la technologie.

Résultats sans tolérance aux fautes

Lors des tests sans aucune méthode de correction d'erreurs, le nouveau GEMM a surpassé les solutions existantes. De simples optimisations ont conduit à des améliorations de performance substantielles, démontrant la force de la nouvelle conception.

Résultats avec tolérance aux fautes

Quand la tolérance aux fautes était active, le GEMM maintenait des indicateurs de performance solides. La surcharge supplémentaire associée à la correction des erreurs était minimale, permettant presque la même rapidité que les versions sans tolérance aux fautes.

Avantages de la nouvelle approche

Cette nouvelle conception offre plusieurs avantages clés :

  1. Haute performance : Le GEMM est optimisé pour la rapidité et surpasse les mises en œuvre existantes.

  2. Correction d'erreurs en temps réel : En intégrant la gestion des erreurs directement dans le processus de calcul, il peut corriger les erreurs à la volée.

  3. Application flexible : L'approche peut facilement s'adapter à différentes tailles et formes de matrices, ce qui la rend polyvalente pour diverses tâches.

Conclusion

Le développement d'une conception GEMM efficace et fiable représente une avancée significative dans les performances informatiques. En intégrant la correction d'erreurs en temps réel, cette nouvelle approche garantit que les calculs complexes restent précis, même face à des erreurs système. Ces avancées ont le potentiel d'améliorer considérablement la fiabilité de diverses applications dans l'apprentissage machine et le calcul scientifique.

Travaux futurs

Les développements futurs envisageront d'élargir la gamme d'opérations prises en charge par ce GEMM, y compris d'autres types de données. L'objectif est d'appliquer cette approche haute performance et tolérante aux fautes à des tâches de calcul plus complexes dans divers environnements informatiques.

Source originale

Titre: Anatomy of High-Performance GEMM with Online Fault Tolerance on GPUs

Résumé: General Matrix Multiplication (GEMM) is a crucial algorithm for various applications such as machine learning and scientific computing, and an efficient GEMM implementation is essential for the performance of these systems. While researchers often strive for faster performance by using large compute platforms, the increased scale of these systems can raise concerns about hardware and software reliability. In this paper, we present a design for a high-performance GEMM with algorithm-based fault tolerance for use on GPUs. We describe fault-tolerant designs for GEMM at the thread, warp, and threadblock levels, and also provide a baseline GEMM implementation that is competitive with or faster than the state-of-the-art, proprietary cuBLAS GEMM. We present a kernel fusion strategy to overlap and mitigate the memory latency due to fault tolerance with the original GEMM computation. To support a wide range of input matrix shapes and reduce development costs, we present a template-based approach for automatic code generation for both fault-tolerant and non-fault-tolerant GEMM implementations. We evaluate our work on NVIDIA Tesla T4 and A100 server GPUs. Experimental results demonstrate that our baseline GEMM presents comparable or superior performance compared to the closed-source cuBLAS. The fault-tolerant GEMM incurs only a minimal overhead (8.89\% on average) compared to cuBLAS even with hundreds of errors injected per minute. For irregularly shaped inputs, the code generator-generated kernels show remarkable speedups of $160\% \sim 183.5\%$ and $148.55\% \sim 165.12\%$ for fault-tolerant and non-fault-tolerant GEMMs, outperforming cuBLAS by up to $41.40\%$.

Auteurs: Shixun Wu, Yujia Zhai, Jinyang Liu, Jiajun Huang, Zizhe Jian, Bryan M. Wong, Zizhong Chen

Dernière mise à jour: 2023-05-01 00:00:00

Langue: English

Source URL: https://arxiv.org/abs/2305.01024

Source PDF: https://arxiv.org/pdf/2305.01024

Licence: https://creativecommons.org/licenses/by-sa/4.0/

Changements: Ce résumé a été créé avec l'aide de l'IA et peut contenir des inexactitudes. Pour obtenir des informations précises, veuillez vous référer aux documents sources originaux dont les liens figurent ici.

Merci à arxiv pour l'utilisation de son interopérabilité en libre accès.

Plus d'auteurs

Articles similaires