Le premier langage GPU de haut niveau, le parallélisme massif, c'est comme écrire Python, a reçu 8 500 étoiles

Après près de 10 ans d'efforts inlassables et de recherches approfondies sur le cœur de l'informatique, les gens ont enfin réalisé un rêve : exécuter des langages de haut niveau sur des GPU.

Le week-end dernier, un langage de programmation appelé Bend a suscité de vives discussions au sein de la communauté open source, et le nombre d'étoiles sur GitHub a dépassé les 8 500.

GitHub : https://github.com/HigherOrderCO/Bend

En tant que langage de programmation de haut niveau massivement parallèle, il est encore au stade de la recherche, mais les idées proposées ont déjà convaincu les gens Je me sens très... surpris. Avec Bend, vous pouvez écrire du code parallèle pour les CPU/GPU multicœurs sans avoir besoin d'être un expert C/CUDA avec 10 ans d'expérience, cela ressemble à Python !

Oui, Bend utilise la syntaxe Python.

Bend est un paradigme de programmation qui prend en charge les langages expressifs tels que Python et Haskell. Il est différent des alternatives de bas niveau telles que CUDA et Metal. Bend propose une allocation rapide des objets, une prise en charge complète de la fermeture pour les fonctions d'ordre supérieur, une récursivité illimitée et une accélération quasi linéaire basée sur le nombre de cœurs. Bend fonctionne sur du matériel massivement parallèle et fournit une prise en charge de l'exécution basée sur HVM2.

Le principal contributeur du projet, Victor Taelin, est originaire du Brésil. Il a partagé les principales fonctionnalités et idées de développement de Bend sur la plateforme X.

Tout d'abord, Bend n'est pas adapté aux algorithmes d'apprentissage automatique modernes, car ces algorithmes sont hautement régularisés (multiplication matricielle) et ont une mémoire pré-alloué, et généralement de bons noyaux CUDA sont déjà écrits.

L'énorme avantage de Bend réside dans les applications pratiques, car les "vraies applications" n'ont généralement pas le budget nécessaire pour créer des cœurs GPU dédiés. Question, qui a créé le site Web dans CUDA ? Et même si quelqu'un le faisait, ce serait irréalisable car :

1. Une vraie application devrait importer des fonctions de nombreuses bibliothèques différentes et il n'y a aucun moyen d'écrire des noyaux CUDA pour elles

2. avoir des fonctions et des fermetures dynamiques ;

3. Les applications réelles allouent de grandes quantités de mémoire de manière dynamique et imprévisible.

Bend a réalisé quelques nouvelles tentatives et peut être assez rapide dans certains cas, mais il n'est certainement pas possible d'écrire de grands modèles de langage maintenant.

L'auteur a comparé l'ancienne méthode avec la nouvelle méthode, en utilisant le même arbre d'algorithmes pour le tri bitonique, impliquant l'allocation et les opérations JSON. Node.js dure 3,5 secondes (Apple M3 Max) et Bend dure 0,5 seconde (NVIDIA RTX 4090).

Oui, Bend nécessite actuellement un GPU entier pour battre Node.js sur un seul cœur. Mais d’un autre côté, il s’agit encore d’une nouvelle approche naissante par rapport à un compilateur JIT qu’une grande entreprise (Google) optimise depuis 16 ans. Il existe de nombreuses possibilités dans le futur.

Comment utiliser

Sur GitHub, l'auteur présente brièvement le processus d'utilisation de Bend.

Tout d’abord, installez Rust. Si vous souhaitez utiliser le runtime C, installez un compilateur C (tel que GCC ou Clang) ; si vous souhaitez utiliser le runtime CUDA, installez la boîte à outils CUDA (CUDA et nvcc) version 12.x. Bend ne prend actuellement en charge que les GPU Nvidia.

Ensuite, installez HVM2 et Bend :

cargo +nightly install hvmcargo +nightly install bend-lang

Enfin, écrivez quelques fichiers Bend et exécutez-le avec l'une des commandes suivantes :

bend run<file.bend> # uses the Rust interpreter (sequential)bend run-c<file.bend> # uses the C interpreter (parallel)bend run-cu <file.bend> # uses the CUDA interpreter (massively parallel)

Vous pouvez également utiliser gen-c et gen -cu Compile Bend dans des fichiers C/CUDA autonomes pour de meilleures performances. Mais gen-c et gen-cu en sont encore à leurs balbutiements et sont bien moins matures que les compilateurs SOTA comme GCC et GHC.

Programmation parallèle dans Bend

Voici des exemples de programmes qui peuvent être exécutés en parallèle dans Bend. Par exemple, l'expression :

(((1 + 2) + 3) + 4)

ne peut pas être exécutée en parallèle car + 4 dépend de + 3, qui à son tour dépend de (1+2). Et l'expression :

((1 + 2) + (3 + 4))

peut être exécutée en parallèle car (1+2) et (3+4) sont indépendants. La condition pour que Bend s'exécute en parallèle est de se conformer à la logique parallèle.

Regardons un exemple de code plus complet :

# Sorting Network = just rotate trees!def sort (d, s, tree):switch d:case 0:return treecase _:(x,y) = treelft = sort (d-1, 0, x)rgt = sort (d-1, 1, y)return rots (d, s, lft, rgt)# Rotates sub-trees (Blue/Green Box)def rots (d, s, tree):switch d:case 0:return treecase _:(x,y) = treereturn down (d, s, warp (d-1, s, x, y))(...)

该文件实现了具有不可变树旋转的双调排序器。它不是很多人期望的在 GPU 上快速运行的算法。然而，由于它使用本质上并行的分治方法，因此 Bend 会以多线程方式运行它。一些速度基准：

•  CPU，Apple M3 Max，1 个线程：12.15 秒
•  CPU，Apple M3 Max，16 线程：0.96 秒
•  GPU，NVIDIA RTX 4090，16k 线程：0.21 秒

不执行任何操作即可实现 57 倍的加速。没有线程产生，没有锁、互斥锁的显式管理。我们只是要求 Bend 在 RTX 上运行我们的程序，就这么简单。

Bend 不限于特定范例，例如张量或矩阵。任何的并发系统，从着色器到类 Erlang 的 actor 模型都可以在 Bend 上进行模拟。例如，要实时渲染图像，我们可以简单地在每个帧上分配一个不可变的树：

# given a shader, returns a square imagedef 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 / 2color = shader (i % width, i /width)return color# given a position, returns a color# for this demo, it just busy loopsdef demo_shader (x, y):bend i = 0:when i < 5000:color = fork (i + 1)else:color = 0x000001return color# renders a 256x256 image using demo_shaderdef main:return render (16, demo_shader)

它确实会起作用，即使涉及的算法在 Bend 上也能很好地并行。长距离通信通过全局 beta 缩减（根据交互演算）执行，并通过 HVM2 的原子链接器正确有效地同步。

最后，作者表示 Bend 现在仅仅是第一个版本，还没有在合适的编译器上投入太多精力。大家可以预期未来每个版本的原始性能都会大幅提高。而现在，我们已经可以使用解释器，从 Python 高级语言的角度一睹大规模并行编程的样子了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!