Introduzione alla programmazione ROCm e HIP: Un tutorial pratico

Panoramica: Questa lezione fornisce una panoramica fondamentale della piattaforma ROCm e del linguaggio di programmazione HIP. Espone il rapporto tra l'intero stack ROCm, l'interfaccia HIP e le librerie di alto livello, stabilendo aspettative realistiche per la portabilità da CUDA a AMD e per l'ingegneria delle prestazioni.

Risultati dell'apprendimento:

• Definire HIP e il suo ruolo nell'ecosistema ROCm in una singola frase concisa.
• Distinguere tra ROCm (piattaforma), HIP (interfaccia) e le librerie ROCm (elementi costitutivi).
• Identificare i livelli gerarchici dell'architettura ROCm dal hardware ai framework applicativi.

Panoramica: Questa lezione guida sviluppatori GPU e ingegneri HPC attraverso le strategie essenziali per configurare un ambiente pronto per HIP sia su Linux che su Windows. Sottolinea un approccio basato sulla "realtà della piattaforma", in cui gli sviluppatori devono verificare la compatibilità hardware/software prima di procedere con un flusso di installazione strutturato e una verifica finale tramite il compilatore hipcc.

Risultati dell'apprendimento:

• Definire il rapporto tra l'SDK HIP e la piattaforma ROCm su diversi sistemi operativi.
• Eseguire un flusso di installazione sistematico, compresa la verifica della matrice di supporto e la configurazione dei percorsi post-installazione.
• Compilare ed eseguire un programma di verifica minimo per risolvere problemi comuni di driver e accesso all'ambiente.

Panoramica: Questa lezione esplora lo strumentario essenziale e le strategie organizzative per lo sviluppo di applicazioni HIP su hardware AMD. Trasferisce lo sviluppatore da semplici compilazioni in linea di comando con il driver hipcc a configurazioni professionali e pronte per la produzione utilizzando CMake. Temi chiave includono macro per lancio di kernel portabili, ottimizzazione specifica per architettura e la distinzione cruciale tra portabilità a livello di sorgente e prestazioni binarie.

Risultati dell'apprendimento:

• Comprendere perché una strategia di build robusta è essenziale per conciliare la portabilità del codice sorgente con le prestazioni specifiche dell'architettura.
• Implementare lanci di kernel portabili utilizzando il macro hipLaunchKernelGGL come alternativa alla sintassi a triple parentesi angolari di CUDA.
• Configurare progetti CMake di livello produttivo che mirino a architetture ROCm specifiche e gestiscano dipendenze esterne.

Panoramica: Questa lezione esplora l'architettura fondamentale dei kernel HIP, concentrandosi su come il lavoro viene mappato da problemi logici all'esecuzione hardware tramite griglie e blocchi. Fornisce un modello per una programmazione GPU robusta, coprendo la formula di esecuzione essenziale, i colli di bottiglia di prestazione (memoria vs. calcolo) e l'implementazione obbligatoria di controlli degli errori e sincronizzazione per codice pronto per la produzione.

Risultati dell'apprendimento:

• Definire l'anatomia di un kernel HIP e applicare la formula base per l'indicizzazione dei thread.
• Configurare efficacemente dimensioni di griglia e blocco e implementare benchmark per trovare il throughput ottimale.
• Implementare macro robuste per il controllo degli errori e applicare semantica di sincronizzazione per gestire l'interazione host-dispositivo.

Panoramica: Questa lezione si concentra sul pilastro centrale della programmazione GPU: la gestione della memoria. Copre la categorizzazione dei tipi di memoria (Accessibile, Pinned, Dispositivo e Gestita), gli impatti prestazionali dei meccanismi di trasferimento dati e il ruolo critico dei modelli di accesso alla memoria — in particolare il coalescing — per raggiungere prestazioni massime. Gli studenti impareranno a bilanciare la facilità d'uso offerta dalla memoria gestita con il controllo esplicito richiesto per applicazioni HPC ad alte prestazioni.

Risultati dell'apprendimento:

• Distinguere tra memoria host accessibile e pinned e identificare quando utilizzare ciascuna per ottenere la velocità di trasferimento ottimale.
• Implementare l'allocazione della memoria dispositivo e la memoria unificata/gestita usando le API HIP (hipMalloc, hipHostMalloc, hipMallocManaged).
• Analizzare i modelli di accesso alla memoria per garantire accesso coalesced e evitare colli di bottiglia prestazionali come accessi con stride.

Panoramica: Questa lezione accompagna gli sviluppatori da un modello di programmazione sincrona a un approccio concorrente, concentrando l'attenzione su come massimizzare l'utilizzo della GPU tramite stream e eventi HIP. Copre i meccanismi per sovrapporre trasferimenti di dati con l'esecuzione del kernel tramite pipeline segmentate e introduce i compromessi tra cattura di stream e costruzione esplicita di grafi. Inoltre, evidenzia considerazioni critiche in produzione, incluse l'uso di librerie sicure per i grafi e la temporizzazione ad alta precisione sulla GPU.

Risultati dell'apprendimento:

• Identificare i benefici prestazionali dell'esecuzione asincrona e dei stream concorrenti rispetto all'esecuzione sincrona.
• Implementare pipeline segmentate per sovrapporre la comunicazione host-dispositivo con il calcolo del kernel.
• Distinguere tra cattura di stream e costruzione esplicita di grafi per ridurre il carico di lancio.

Panoramica: Questa lezione stabilisce un quadro scientifico per ottimizzare il software su hardware AMD, andando oltre il tentativo casuale verso un approccio sistematico e guidato da misurazioni. Copre il rapporto architetturale tra Unità di Calcolo, wavefronts e pressione sui registri, fornendo metodologie pratiche per il profiling con rocprofv3 e implementando scheletri robusti per benchmark.

Risultati dell'apprendimento:

• Implementare il flusso di ottimizzazione HIP a 6 passi per identificare e risolvere i colli di bottiglia prestazionali.
• Analizzare il trade-off tra pressione sui registri e occupazione per massimizzare l'utilizzo hardware.
• Eseguire misurazioni di prestazione accurate utilizzando eventi hardware e best practice per benchmark multi-iterazione.

Panoramica: Questa lezione introduce il principio ingegneristico "prima le librerie", che privilegia librerie ROCm ad alte prestazioni e pre-costruite rispetto allo sviluppo di kernel personalizzati. Copre la categorizzazione dello stack di librerie ROCm (Matematica, FFT, Primitive, ML/AI) e fornisce un framework decisionale per scegliere tra interfacce portabili hip* e implementazioni native AMD roc*. Inoltre, gli studenti esploreranno i requisiti critici per la "sicurezza dei grafi" quando si integrano librerie nei flussi di cattura grafica HIP.

Risultati dell'apprendimento:

• Applicare il principio ingegneristico "prima le librerie" per giustificare l'uso di primitive testate rispetto ai kernel personalizzati.
• Distinguere tra librerie hip* e roc* in base alle esigenze di portabilità e prestazioni.
• Categorizzare le librerie ROCm nei loro rispettivi domini funzionali (Matematica, FFT, Primitive, ML/AI).

Panoramica: Questa lezione copre la transizione sistematica del codice sorgente CUDA al framework C++ portabile HIP. Gli studenti impareranno a eseguire un flusso di porting incrementale utilizzando strumenti automatizzati come hipify-perl e hipify-clang, a identificare trappole critiche di portabilità come ipotesi specifiche dell'hardware su warpSize, e a implementare un processo rigoroso di validazione per confrontare prestazioni e correttezza dopo il migrazione.

Risultati dell'apprendimento:

• Eseguire il flusso di porting incrementale a 6 passi per minimizzare l'overhead di debug.
• Selezionare e applicare lo strumento di traduzione automatica appropriato (hipify-perl vs. hipify-clang) in base alla complessità del codice sorgente.
• Identificare e risolvere trappole di portabilità sensibili all'architettura, in particolare quelle relative a warpSize e errori di traduzione meccanica.

Panoramica: Questa lezione copre gli strumenti e le metodologie essenziali per portare i kernel GPU dallo sviluppo alla produzione sulla piattaforma ROCm. Dettaglia l'uso di ROCgdb e AddressSanitizer per rilevare errori, stabilisce una strategia rigorosa a quattro livelli per il testing e fornisce un checklist di produzione per garantire correttezza del kernel e stabilità delle prestazioni.

Risultati dell'apprendimento:

• Usare ROCgdb, ltrace e AddressSanitizer per identificare bug a livello di sorgente e errori di accesso alla memoria nel codice GPU.
• Implementare una strategia di testing a quattro livelli per validare helper, correttezza del kernel, casi limite e regressioni di prestazione.
• Applicare modelli di codice di produzione e checklists per gestire interfacce di kernel, documentazione e debugging guidato dall'ambiente.