Bahasa peringkat tinggi GPU pertama, paralelisme besar-besaran seperti menulis Python, telah menerima 8500 bintang

Selepas hampir 10 tahun usaha tanpa henti dan penyelidikan mendalam tentang teras sains komputer, orang ramai akhirnya merealisasikan impian: menjalankan bahasa peringkat tinggi pada GPU.

Hujung minggu lalu, bahasa pengaturcaraan yang dipanggil Bend mencetuskan perbincangan hangat dalam komuniti sumber terbuka, dan bilangan bintang di GitHub telah melebihi 8,500.

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

Sebagai bahasa pengaturcaraan peringkat tinggi yang selari secara besar-besaran, ia masih dalam peringkat penyelidikan, tetapi idea yang dicadangkan telah membuat rasa sangat... terkejut. Dengan Bend anda boleh menulis kod selari untuk CPU/GPU berbilang teras tanpa perlu menjadi pakar C/CUDA dengan pengalaman 10 tahun, rasanya seperti Python!

Ya, Bend menggunakan sintaks Python.

Bend ialah paradigma pengaturcaraan yang menyokong bahasa ekspresif seperti Python dan Haskell Ia berbeza daripada alternatif peringkat rendah seperti CUDA dan Metal. Bend menampilkan peruntukan objek pantas, sokongan penutupan penuh untuk fungsi tertib lebih tinggi, rekursi tanpa had dan kelajuan hampir linear berdasarkan kiraan teras. Bend berjalan pada perkakasan selari secara besar-besaran dan menyediakan sokongan masa jalan berasaskan HVM2.

Penyumbang utama projek, Victor Taelin, adalah dari Brazil Dia berkongsi ciri utama dan idea pembangunan Bend pada platform X.

Pertama sekali, Bend tidak sesuai untuk algoritma pembelajaran mesin moden, kerana algoritma ini sangat teratur (pendaraban matriks) dan mempunyai memori pra-peruntukan, dan biasanya kernel CUDA yang baik sudah pun ditulis.

Kelebihan besar Bend adalah dalam aplikasi praktikal, kerana "aplikasi sebenar" biasanya tidak mempunyai bajet untuk membuat teras GPU khusus. Soalan, siapa yang membuat laman web di CUDA? Dan walaupun seseorang melakukannya, ia tidak dapat dilaksanakan kerana:

1 Aplikasi sebenar perlu mengimport fungsi dari banyak perpustakaan yang berbeza dan tidak ada cara untuk menulis kernel CUDA untuk mereka

2 mempunyai fungsi dinamik dan penutupan;

3.

Bend telah menyelesaikan beberapa percubaan baharu dan boleh menjadi agak pantas dalam sesetengah kes, tetapi sudah pasti tidak mungkin untuk menulis model bahasa yang besar sekarang.

Pengarang membandingkan kaedah lama dengan kaedah baharu, menggunakan pepohon algoritma yang sama untuk pengisihan bitonik, melibatkan peruntukan dan operasi JSON. Node.js ialah 3.5 saat (Apple M3 Max) dan Bend ialah 0.5 saat (NVIDIA RTX 4090).

Ya, pada masa ini Bend memerlukan keseluruhan GPU untuk mengalahkan Node.js pada satu teras. Tetapi sebaliknya, ini masih merupakan pendekatan baharu yang baharu berbanding pengkompil JIT yang telah dioptimumkan oleh syarikat besar (Google) selama 16 tahun. Terdapat banyak kemungkinan di masa hadapan.

Cara menggunakan

Di GitHub, penulis memperkenalkan secara ringkas proses penggunaan Bend.

Mula-mula, pasang Rust. Jika anda ingin menggunakan masa jalan C, pasang pengkompil C (seperti GCC atau Clang); jika anda ingin menggunakan masa jalan CUDA, pasang kit alat CUDA (CUDA dan nvcc) versi 12.x. Bend pada masa ini hanya menyokong GPU Nvidia.

Kemudian, pasang HVM2 dan Bend:

cargo +nightly install hvmcargo +nightly install bend-lang

Akhir sekali, tulis beberapa fail Bend dan jalankan dengan salah satu arahan berikut:

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

rreee-cu Compile Bend ke dalam fail C/CUDA kendiri untuk prestasi terbaik. Tetapi gen-c dan gen-cu masih di peringkat awal dan jauh kurang matang daripada penyusun SOTA seperti GCC dan GHC.

Pengaturcaraan Selari di Bend

Berikut adalah contoh program yang boleh dijalankan secara selari di Bend. Sebagai contoh, ungkapan:

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

tidak boleh dijalankan secara selari kerana + 4 bergantung kepada + 3, yang seterusnya bergantung kepada (1+2). Dan ungkapan:

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

boleh dijalankan secara selari kerana (1+2) dan (3+4) adalah bebas. Syarat untuk Bend berjalan selari adalah mematuhi logik selari.

Mari kita lihat contoh kod yang lebih lengkap:

# 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 高级语言的角度一睹大规模并行编程的样子了。