Introduction à la programmation ROCm et HIP : Un tutoriel pratique

Aperçu : Cette leçon fournit une vue d'ensemble fondamentale de la plateforme ROCm et du langage de programmation HIP. Elle clarifie la relation entre la pile complète ROCm, l'interface HIP et les bibliothèques haut niveau, tout en établissant des attentes réalistes concernant la portabilité CUDA vers AMD et l'ingénierie des performances.

Objectifs d'apprentissage :

• Définir HIP et son rôle au sein de l'écosystème ROCm en une phrase concise.
• Distinction entre ROCm (plateforme), HIP (interface) et les bibliothèques ROCm (éléments constitutifs).
• Identifier les niveaux hiérarchiques de l'architecture ROCm, allant du matériel aux frameworks d'application.

Aperçu : Cette leçon guide les développeurs GPU et ingénieurs HPC à travers les stratégies essentielles pour configurer un environnement prêt à utiliser HIP sur les plates-formes Linux et Windows. Elle met l'accent sur une approche "réaliste de la plateforme", où les développeurs doivent vérifier la compatibilité matériel/logiciel avant de procéder à un flux d'installation structuré et à une vérification finale via le compilateur hipcc.

Objectifs d'apprentissage :

• Définir la relation entre l'SDK HIP et la plateforme ROCm sur différentes architectures système.
• Exécuter un flux d'installation systématique, incluant la vérification de la matrice de support et la configuration des chemins post-installation.
• Compiler et exécuter un programme minimal de vérification afin de diagnostiquer les problèmes courants liés au pilote et à l'accès environnemental.

Aperçu : Cette leçon explore les outils essentiels et les stratégies organisationnelles pour développer des applications HIP sur matériel AMD. Elle permet de passer des compilations simples en ligne de commande avec le driver hipcc vers des configurations professionnelles et prêtes à produire, utilisant CMake. Les axes clés incluent les macros de lancement de noyaux portables, l'optimisation spécifique à l'architecture, et la distinction cruciale entre portabilité au niveau source et performance binaire.

Objectifs d'apprentissage :

• Comprendre pourquoi une stratégie de construction robuste est essentielle pour concilier la portabilité du code source avec les performances spécifiques à l'architecture.
• Implémenter des lancements de noyaux portables à l'aide de la macro hipLaunchKernelGGL, alternative syntaxique à la notation en triple angle de CUDA.
• Configurer des projets CMake de qualité production ciblant des architectures ROCm spécifiques et gérant les dépendances externes.

Aperçu : Cette leçon explore l'architecture fondamentale des noyaux HIP, en se concentrant sur la manière dont le travail est mappé depuis les problèmes logiques jusqu'à l'exécution matérielle via des grilles et des blocs. Elle fournit un cadre solide pour le développement GPU, couvrant la formule d'exécution essentielle, les goulets d'étranglement de performance (mémoire vs calcul), et l'implémentation obligatoire de contrôles d'erreur et de synchronisation pour un code prêt à la production.

Objectifs d'apprentissage :

• Décrire l'anatomie d'un noyau HIP et appliquer la formule élémentaire d'exécution pour l'indexation des threads.
• Configurer efficacement les tailles de grille et de bloc, et implémenter des benchmarks pour trouver le débit optimal.
• Implémenter des macros de gestion d'erreurs robustes et appliquer des sémantiques de synchronisation pour gérer les interactions hôte-dispositif.

Aperçu : Cette leçon se concentre sur le pilier central du développement GPU : la gestion de la mémoire. Elle couvre la catégorisation des types de mémoire (accessible, fixée, périphérique et partagée), les implications de performance des mécanismes de transfert de données, et le rôle critique des motifs d'accès mémoire — notamment le regroupement — pour atteindre les performances maximales. Les étudiants apprendront à équilibrer la facilité d'utilisation offerte par la mémoire partagée avec le contrôle explicite requis pour les applications HPC à haute performance.

Objectifs d'apprentissage :

• Différencier la mémoire hôte accessible et fixée, et identifier quand utiliser chacune pour une vitesse de transfert optimale.
• Implémenter l'allocation de mémoire périphérique et la mémoire unifiée/partagée à l’aide des API HIP (hipMalloc, hipHostMalloc, hipMallocManaged).
• Analyser les motifs d'accès mémoire pour garantir un accès regroupé et éviter les goulets d’étranglement de performance comme les accès à pas.

Aperçu : Cette leçon amène les développeurs d’un modèle de programmation synchrone à un état d’esprit concurrent, en se concentrant sur la manière d’optimiser l’utilisation du GPU via les files d’attente HIP et les événements. Elle couvre les mécanismes de superposition des transferts de données avec l’exécution de noyaux via des pipelines fractionnés, et introduit les compromis entre la capture de file et la construction explicite de graphes. En outre, elle souligne des considérations critiques en production, notamment l’utilisation de bibliothèques compatibles graphes et la temporisation haute précision sur le GPU.

Objectifs d'apprentissage :

• Identifier les bénéfices de performance de l’exécution asynchrone et des files concurrentes par rapport à l’exécution synchrone.
• Implémenter des pipelines fractionnées pour superposer la communication hôte-dispositif avec le calcul de noyau.
• Différencier la capture de file et la construction explicite de graphe pour réduire la surcharge de lancement.

Aperçu : Cette leçon établit un cadre scientifique pour optimiser les logiciels sur matériel AMD, en passant d’une approche basée sur l’intuition à une méthode systématique et pilotée par la mesure. Elle couvre la relation architecturale entre unités de calcul, ondes et pression de registres, tout en proposant des méthodologies pratiques pour le profilage avec rocprofv3 et l’implémentation de squelettes de benchmark robustes.

Objectifs d'apprentissage :

• Mettre en œuvre le workflow d'optimisation HIP en 6 étapes pour identifier et résoudre les goulets d'étranglement de performance.
• Analyser le compromis entre pression de registres et occupation pour maximiser l’utilisation du matériel.
• Exécuter des mesures de performance précises à l’aide d’événements matériels et suivre les meilleures pratiques de benchmarking multi-itérations.

Aperçu : Cette leçon présente la philosophie d’ingénierie « première bibliothèque », qui privilégie les bibliothèques ROCm hautement performantes et pré-construites plutôt que le développement personnalisé de noyaux. Elle couvre la catégorisation de la pile de bibliothèques ROCm (Mathématiques, FFT, Primitives, ML/IA) et fournit un cadre décisionnel pour choisir entre interfaces portables hip* et implémentations natives AMD roc*. Les apprenants exploreront également les exigences critiques de « sécurité des graphes » lors de l’intégration de bibliothèques dans des flux de capture de graphes HIP.

Objectifs d'apprentissage :

• Appliquer le principe d’ingénierie « première bibliothèque » pour justifier l’utilisation de primitives testées plutôt que de noyaux personnalisés.
• Différencier les bibliothèques hip* et roc* selon les besoins de portabilité et de performance.
• Catégoriser les bibliothèques ROCm selon leurs domaines fonctionnels respectifs (Mathématiques, FFT, Primitives, ML/IA).

Aperçu : Cette leçon traite de la transition systématique du code source CUDA vers le cadre portable HIP C++. Les étudiants apprendront à exécuter un flux de portage incrémental à l’aide d’outils automatisés tels que hipify-perl et hipify-clang, à identifier les pièges critiques de portabilité comme les hypothèses spécifiques au matériel sur warpSize, et à mettre en œuvre un processus rigoureux de validation pour comparer performance et correction après migration.

Objectifs d'apprentissage :

• Exécuter le flux de portage incrémental en 6 étapes afin de minimiser la charge de débogage.
• Sélectionner et appliquer l’outil de traduction automatique approprié (hipify-perl vs. hipify-clang) selon la complexité du code source.
• Identifier et résoudre les « pièges de portabilité » sensibles à l’architecture, notamment ceux impliquant warpSize et les erreurs de traduction mécanique.

Aperçu : Cette leçon couvre les outils et méthodologies essentielles pour faire passer les noyaux GPU du développement à la production sur la plateforme ROCm. Elle détaille l’utilisation de ROCgdb et AddressSanitizer pour détecter les erreurs, établit une stratégie rigoureuse de test en quatre couches, et fournit une check-list de production pour garantir la correction des noyaux et la stabilité des performances.

Objectifs d'apprentissage :

• Utiliser ROCgdb, ltrace et AddressSanitizer pour identifier les bugs au niveau source et les erreurs d’accès mémoire dans le code GPU.
• Mettre en œuvre une stratégie de test en quatre couches pour valider les fonctions auxiliaires, la correction des noyaux, les cas limites et les régressions de performance.
• Appliquer des modèles de code de production et des check-lists pour gérer les interfaces de noyaux, la documentation et le débogage piloté par l’environnement.