Bend - Un langage de haut niveau qui s’exécute sur GPU (avec HVM2)
(github.com/HigherOrderCO)- Bend est un langage de programmation de haut niveau qui prend en charge le traitement massivement parallèle
- Contrairement aux alternatives de bas niveau comme CUDA et Metal, Bend offre les sensations et les fonctionnalités de langages expressifs comme Python et Haskell
- Il inclut une allocation d’objets rapide, des fonctions d’ordre supérieur avec prise en charge complète des closures, une récursion sans restriction, et même les continuations
- Pourtant, il s’exécute sur du matériel massivement parallèle comme les GPU, avec des gains de vitesse presque linéaires selon le nombre de cœurs
- Aucune annotation parallèle explicite n’est nécessaire : pas besoin de création de threads, de verrous, de mutex ni d’opérations atomiques
- Bend est propulsé par le runtime HVM2
Démo rapide
Utiliser Bend
Ne fonctionne pas actuellement sous Windows ; il faut utiliser WSL2 comme alternative.
- D’abord, il faut installer Rust nightly.
- Ensuite, il faut installer HVM2 et Bend :
cargo +nightly install hvm cargo +nightly install bend-lang - Enfin, vous pouvez écrire un fichier Bend et l’exécuter avec l’une des commandes suivantes :
bend run # utilise l’interpréteur Rust (séquentiel) bend run-c # utilise l’interpréteur C (parallèle) bend run-cu # utilise l’interpréteur CUDA (massivement parallèle) - Vous pouvez aussi compiler Bend en fichiers C/CUDA autonomes avec
gen-cetgen-cupour obtenir les meilleures performances. Cependant, la génération de code en est encore à ses débuts et n’est pas aussi mature que des compilateurs de pointe comme GCC ou GHC.
Programmation parallèle dans Bend
- Pour écrire un programme parallèle dans Bend... il n’y a rien à faire. Il suffit de l’écrire de façon à ce qu’il ne soit pas intrinsèquement séquentiel.
- Par exemple, l’expression suivante ne peut pas être exécutée en parallèle :
car(((1 + 2) + 3) + 4)+4dépend de+3, et+3dépend de(1+2). - En revanche, l’expression suivante peut être exécutée en parallèle :
car((1 + 2) + (3 + 4))(1+2)et(3+4)sont indépendants. Selon le principe fondamental de Bend, tout ce qui peut être exécuté en parallèle le sera.
Exemple de code
-
Pour un exemple plus complet, considérons le code suivant :
# réseau de tri = rotations d’arbre def sort(d, s, tree): switch d: case 0: return tree case _: (x, y) = tree lft = sort(d-1, 0, x) rgt = sort(d-1, 1, y) return rots(d, s, lft, rgt) # rotations de sous-arbre def rots(d, s, tree): switch d: case 0: return tree case _: (x, y) = tree return down(d, s, warp(d-1, s, x, y)) -
Ce fichier implémente un trieur bitonique à l’aide de rotations d’arbres immuables. Ce n’est pas un algorithme que l’on s’attendrait à voir s’exécuter rapidement sur GPU. Mais comme il adopte une approche de type diviser pour régner, il est intrinsèquement parallèle. Bend l’exécute en multithread. Quelques benchmarks :
- CPU, Apple M3 Max, 1 thread : 12,15 secondes
- CPU, Apple M3 Max, 16 threads : 0,96 seconde
- GPU, NVIDIA RTX 4090, 16k threads : 0,21 seconde
- Un gain de vitesse de 57x obtenu sans rien faire. Pas de gestion explicite de la création de threads, des verrous ou des mutex. Il a simplement suffi de demander à Bend d’exécuter le programme sur la RTX.
Prise en charge de différents systèmes parallèles
-
Bend n’est pas limité à un paradigme spécifique comme les tenseurs ou les matrices. Tout système parallèle, des shaders jusqu’au modèle d’acteurs façon Erlang, peut être émulé dans Bend.
-
Par exemple, pour rendre une image en temps réel, il est possible d’allouer un arbre immuable pour chaque frame :
# étant donné un shader, renvoie une image carrée def render(depth, shader): bend d = 0, i = 0: when d < depth: color = (fork(d+1, i*2+0), fork(d+1, i*2+1)) else: width = depth / 2 color = shader(i % width, i / width) return color # étant donné une position, renvoie une couleur # dans cette démo, on effectue simplement une boucle occupée def demo_shader(x, y): bend i = 0: when i < 5000: color = fork(i + 1) else: color = 0x000001 return color # rend une image 256x256 avec demo_shader def main: return render(16, demo_shader) -
Cela fonctionne réellement. Même des algorithmes complexes se parallélisent bien dans Bend. Les communications à longue distance sont réalisées via une réduction bêta globale (selon le calcul d’interaction) et synchronisées de manière correcte et efficace par l’atomic linker de HVM2.
Ressources complémentaires
- Pour commencer immédiatement, consultez le GUIDE.md de Bend.
- Pour voir la liste des fonctionnalités, consultez FEATURES.md.
- Pour comprendre la technologie de Bend, consultez l’article scientifique sur HVM2.
- Bend est développé chez HigherOrderCO.com — rejoignez le Discord.
L’avis de GN⁺
- Simplification de la programmation parallèle : Bend simplifie fortement la programmation parallèle, ce qui la rend accessible même aux ingénieurs logiciels débutants. Cela réduit considérablement la barrière à l’entrée.
- Prise en charge de divers matériels : Bend peut s’exécuter efficacement non seulement sur CPU mais aussi sur GPU, ce qui le rend exploitable dans des environnements matériels variés.
- Langage expressif : En combinant les atouts de Python et de Haskell, il permet d’écrire un code expressif. Cela améliore la lisibilité et la maintenabilité du code.
- Génération de code encore précoce : La génération de code de Bend en est encore à ses débuts et peut être moins performante que celle de compilateurs matures. Des améliorations seront nécessaires à l’avenir.
- Prise en charge de divers systèmes parallèles : Bend n’est pas limité à un paradigme donné et prend en charge divers systèmes parallèles, ce qui permet une programmation souple. Cela rend Bend exploitable dans de nombreux domaines d’application.
1 commentaires
Commentaires sur Hacker News
Résumé des commentaires de Hacker News
Comparaison des performances entre Python et PyPy
Retours positifs
Avis critiques
Attentes autour de la programmation parallèle
Comparaison de performances
Attentes quant à l’évolution du projet
Point de vue sceptique
Perspective positive
Caractéristiques linguistiques de Bend