Concurrent Scheduling of High-Level Parallel Programs on Multi-GPU Systems

I moderni supercomputer non sono più solo versioni più veloci delle macchine di qualche decennio fa; sono vaste collezioni di migliaia di processori specializzati che lavorano insieme. Per ottenere il massimo da questi sistemi massicci, gli scienziati si affidano a software in grado di decidere automaticamente quale parte di un calcolo vada a quale processore e come i dati si muovano tra di essi. Questo è un compito difficile perché il software deve gestire la memoria e la comunicazione senza rallentare il lavoro effettivo. Se il sistema passa troppo tempo a decidere dove collocare i dati o come mantenerli coerenti, i potenti processori rimangono inattivi, sprecando energia e tempo. La sfida è rendere queste decisioni abbastanza velocemente da evitare che il computer si fermi a riflettere, mantenendo il flusso di lavoro fluido come il flusso dell'acqua in un fiume.

I ricercatori dell'Università di Innsbruck hanno sviluppato un nuovo modo per gestire questo problema di pianificazione per sistemi dotati di molte unità di elaborazione grafica, o GPU. Questi chip sono progettati per gestire enormi quantità di lavoro parallelo, ma coordinare centinaia di essi richiede un gestore sofisticato. Il team ha introdotto un metodo chiamato "instruction-graph scheduling" (pianificazione tramite grafo di istruzioni), che funge da mappa dettagliata e a basso livello di ogni singola operazione che il computer deve eseguire. Invece di prendere decisioni al volo man mano che ogni passaggio diventa necessario, il sistema costruisce un piano completo che include l'allocazione della memoria, i trasferimenti di dati e i calcoli effettivi. Questo piano viene generato mentre il computer sta già lavorando su compiti precedenti, permettendo effettivamente allo scheduler di guardare avanti e preparare i passaggi successivi senza interrompere il flusso corrente.

Il cuore di questo approccio è un cambiamento nel modo in cui il software vede il lavoro. Precedentemente, il sistema generava un elenco di alto livello di compiti e poi determinava i dettagli specifici, come la copia della memoria, solo quando era il momento di eseguirli. Ciò causava spesso ritardi perché il sistema doveva analizzare le dipendenze nel mezzo di un calcolo. Il nuovo metodo scompone ogni compito nelle sue componenti più piccole, come l'allocazione di un blocco specifico di memoria o l'invio di un piccolo pezzo di dati a un processore vicino. Disponendo questi piccoli passi in un unico grafo interconnesso, il sistema può vedere esattamente quali passaggi possono avvenire contemporaneamente. Ciò consente al computer di sovrapporre la comunicazione al calcolo, il che significa che i dati possono muoversi tra i processori mentre i chip sono impegnati a elaborare numeri, invece di aspettare che uno finisca prima che l'altro inizi.

Per testare questa idea, i ricercatori hanno integrato il loro sistema in un framework software chiamato Celerity, progettato per eseguire simulazioni complesse su cluster di GPU. Hanno eseguito tre diverse applicazioni scientifiche per vedere quanto bene il nuovo scheduler si comportasse rispetto alla versione standard. Un'applicazione simulava l'attrazione gravitazionale tra miliardi di particelle, un'altra modellava come il suono rimbalza in una stanza e la terza tracciava il movimento delle onde attraverso un mezzo. In ogni caso, hanno misurato quanto velocemente il programma girasse aggiungendo più GPU, una metrica nota come "strong scaling" (scalabilità forte). I risultati hanno mostrato che il nuovo approccio superava costantemente il sistema di base, specialmente all'aumentare del numero di processori. Su un sistema con 128 GPU, il nuovo scheduler ha permesso all'applicazione di simulazione della stanza di girare più del doppio rispetto al vecchio metodo, mentre la simulazione delle particelle ha registrato un significativo incremento di velocità.

Un'innovazione chiave in questo lavoro è una tecnica chiamata "scheduler lookahead", che risolve un problema specifico relativo all'uso della memoria. In molte simulazioni, la quantità di dati che un programma deve memorizzare può cambiare da un passaggio all'altro. Senza un modo per prevedere questi cambiamenti, il software potrebbe allocare un blocco di memoria piccolo, per poi accorgersi un momento dopo di essere troppo piccolo, costringendolo ad allocarne uno più grande e a copiare tutti i dati. Questo processo di ridimensionamento è lento e può sprecare tempo prezioso. Il nuovo sistema guarda avanti ai compiti imminenti per vedere se i requisiti di memoria stanno crescendo. Se rileva un pattern in cui la dimensione dei dati aumenterà, attende ad allocare la memoria finché non conosce la dimensione finale necessaria, evitando completamente il costoso passaggio di ridimensionamento. Questo è particolarmente efficace per le applicazioni in cui i dati crescono costantemente, consentendo al sistema di allocare la quantità corretta di memoria in un'unica soluzione.

I ricercatori hanno inoltre costruito un'architettura di sistema che separa il lavoro di pianificazione dal lavoro di esecuzione. Hanno creato un thread dedicato, ovvero una linea di esecuzione separata, che è responsabile esclusivamente della costruzione di questi grafi di istruzioni dettagliati. Nel frattempo, altri thread gestiscono l'esecuzione effettiva delle istruzioni sulle GPU. Questa separazione assicura che il processo di pianificazione dei passaggi successivi non ostacoli i passaggi correnti che vengono eseguiti. I due processi corrono fianco a fianco, comunicando attraverso una coda snella che trasmette le istruzioni dal pianificatore all'esecutore. Questo design minimizza il tempo che il sistema trascorre in attesa, assicurando che le GPU siano occupate con lavoro utile piuttosto che restare inattive mentre il software decide cosa fare dopo.

Gli esperimenti sono stati condotti sul supercomputer Leonardo in Italia, una macchina con migliaia di processori e connessioni ad alta velocità. Il team ha utilizzato codici scientifici reali per garantire che le loro scoperte fossero applicabili in scenari pratici. Hanno scoperto che, sebbene il nuovo metodo non cambiasse i limiti fondamentali di quanta memoria potesse essere memorizzata o di quanto grande potesse essere un problema, migliorava significativamente l'efficienza con cui quel lavoro veniva distribuito. I miglioramenti sono stati più evidenti nelle applicazioni in cui i pattern di accesso ai dati erano complessi o variabili, poiché il sistema poteva meglio nascondere il tempo speso nella comunicazione e nella gestione della memoria. Per le applicazioni con passaggi di calcolo molto brevi, il nuovo scheduler ha ridotto l'overhead a tal punto da mantenere l'efficienza di scalabilità del sistema anche con un gran numero di processori.

Questo lavoro dimostra che il modo in cui il software gestisce la logistica interna di un supercomputer è importante quanto la potenza bruta dell'hardware stesso. Spostando il carico pesante della pianificazione fuori dal percorso critico e inserendolo in un processo parallelo, i ricercatori hanno dimostrato che è possibile mantenere queste enormi macchine alla massima efficienza. L'approccio basato sul grafo di istruzioni fornisce un modo per visualizzare e gestire la complessa rete di dipendenze che esiste nei moderni programmi paralleli, trasformando ciò che un tempo era un collo di bottiglia in una pipeline fluida. Man mano che i supercomputer continuano a crescere in dimensioni e complessità, tecniche come questa saranno essenziali per garantire che gli scienziati possano ottenere il massimo dai loro investimenti, permettendo loro di risolvere problemi che prima erano troppo grandi o troppo lenti da affrontare.