1.09. Utilisation des capacités de calcul de la carte graphique

L’utilisation des capacités de calcul des cartes graphiques (GPU) avec Julia offre des avantages significatifs en termes de performance pour certaines tâches de calcul intensif. Julia intègre plusieurs packages permettant d’exploiter efficacement les GPU, notamment CUDA.jl pour les cartes NVIDIA et Metal.jl pour les GPU Apple Silicon. Ces outils permettent aux développeurs de tirer parti de l’architecture massivement parallèle des GPU pour accélérer considérablement les opérations matricielles, le traitement d’images, les simulations numériques et les algorithmes d’apprentissage automatique.

L’approche de Julia, combinant une syntaxe de haut niveau avec des performances proches du C, facilite l’écriture de code GPU efficace sans sacrifier la lisibilité ou la maintenabilité. De plus, l’écosystème Julia comprend des bibliothèques optimisées pour GPU comme CuArrays.jl, qui offrent des implémentations GPU transparentes pour de nombreuses opérations courantes, permettant aux utilisateurs de bénéficier de l’accélération GPU avec un minimum de modifications de leur code existant. Le site https://juliagpu.org/ fournit des ressources détaillées, des exemples de code et des tutoriels pour aider les développeurs à intégrer efficacement le calcul GPU dans leurs projets Julia.

Introduction à CUDA.jl

Exemple de code et comparaison des performances

Voyons ci-dessous un exemple de code qui :

1. définit une fonction calculer qui somme les carrés des éléments d’un tableau.
2. crée un grand tableau de nombres aléatoires et en fait une copie pour le GPU.
3. exécute la fonction calculer sur le CPU et sur le GPU, en mesurant le temps d’exécution avec @btime.
4. affiche les résultats et vérifie qu’ils sont identiques entre exécution sur CPU et sur GPU.
5. libère la mémoire du GPU.

using CUDA
using BenchmarkTools
 
# Définition de la fonction de calcul
function calculer(x)
    return sum(x -> x^2, x)
end
 
# Génération des données
n = 10_000_000
x_cpu = rand(Float32, n)
x_gpu = CuArray(x_cpu)
 
# Benchmark de la version CPU
print("Version CPU : ")
@btime calculer($x_cpu)
result_cpu = calculer(x_cpu)
 
# Benchmark de la version GPU
print("Version GPU : ")
@btime calculer($x_gpu)
result_gpu = calculer(x_gpu)
 
# Affichage des résultats
println("Résultat CPU : ", result_cpu)
println("Résultat GPU : ", result_gpu)
println("Les résultats correspondent : ", isapprox(result_cpu, result_gpu))
 
# Nettoyage de la mémoire GPU
CUDA.reclaim()

L’intérêt principal de ce programme est de comparer les performances entre CPU et GPU pour cette opération spécifique, en utilisant exactement la même fonction pour les deux. Cela met en évidence la capacité de Julia à utiliser le même code pour différents types de matériel, adaptant automatiquement l’exécution selon que les données sont sur CPU ou GPU.

A l’exécution du script, nous obtenons les résultats suivants

Version CPU :   1.084 ms (0 allocations: 0 bytes)
Version GPU :   194.900 μs (78 allocations: 1.95 KiB)
Résultat CPU : 3.3334825e6
Résultat GPU : 3.3334828e6

Le calcul sur GPU est environ 5,56 fois plus rapide que sur CPU pour cette opération spécifique. C’est une amélioration significative de la performance. Le CPU n’a pas besoin d’allocations supplémentaires, tandis que le GPU en fait quelques-unes. Cela est probablement dû à la gestion interne des opérations CUDA et au transfert des résultats.

L’objet du présent article n’est pas d’explorer en profondeur cet aspect.

julialanggpu