Bend - Bahasa Tingkat Tinggi yang Berjalan di GPU (menggunakan HVM2)

 (github.com/HigherOrderCO)
1 poin oleh GN⁺ 2024-05-18 | 1 komentar | Bagikan ke WhatsApp
  • Bend adalah bahasa pemrograman tingkat tinggi yang mendukung pemrosesan paralel skala besar
  • Tidak seperti alternatif tingkat rendah seperti CUDA dan Metal, Bend menawarkan nuansa dan kemampuan bahasa yang ekspresif seperti Python dan Haskell
  • Mencakup alokasi objek cepat, fungsi tingkat tinggi dengan dukungan closure penuh, rekursi tanpa batas, bahkan continuation
  • Namun tetap berjalan di perangkat keras paralel masif seperti GPU, dan menunjukkan peningkatan kecepatan yang hampir linear sesuai jumlah core
  • Sama sekali tidak memerlukan anotasi paralel eksplisit: tidak perlu pembuatan thread, lock, mutex, atau operasi atomik
  • Bend ditenagai oleh runtime HVM2

Demo singkat

Menggunakan Bend

Saat ini tidak berjalan di Windows, dan harus menggunakan WSL2 sebagai alternatif.

  • Pertama, Anda harus memasang Rust nightly.
  • Lalu, Anda harus memasang HVM2 dan Bend: 
    cargo +nightly install hvm  
cargo +nightly install bend-lang
  • Terakhir, Anda dapat menulis file Bend dan menjalankannya dengan salah satu perintah berikut: 
    bend run   # gunakan interpreter Rust (sekuensial)  
bend run-c  # gunakan interpreter C (paralel)  
bend run-cu  # gunakan interpreter CUDA (paralel masif)
  • Anda juga dapat mengompilasi Bend menjadi file C/CUDA mandiri dengan gen-c dan gen-cu untuk performa maksimum. Namun, pembuatan kode masih dalam tahap awal dan belum sematang compiler mutakhir seperti GCC atau GHC.

Pemrograman paralel di Bend

  • Untuk menulis program paralel di Bend... Anda tidak perlu melakukan apa pun. Asalkan program ditulis agar tidak bersifat sekuensial secara inheren.
  • Sebagai contoh, ekspresi berikut tidak dapat dijalankan secara paralel: 
    (((1 + 2) + 3) + 4)
    karena +4 bergantung pada +3, dan +3 bergantung pada (1+2).
  • Namun, ekspresi berikut dapat dijalankan secara paralel: 
    ((1 + 2) + (3 + 4))
    karena (1+2) dan (3+4) saling independen. Sesuai prinsip dasar Bend, segala sesuatu yang bisa dijalankan secara paralel akan dijalankan secara paralel.

Contoh kode

  • Sebagai contoh yang lebih lengkap, pertimbangkan kode berikut:

    # jaringan pengurutan = rotasi pohon  
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)  

# rotasi subpohon  
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))

  • File ini mengimplementasikan pengurut bitonik menggunakan rotasi pohon immutable. Ini bukan algoritma yang biasanya diharapkan berjalan cepat di GPU. Namun, karena menggunakan pendekatan divide-and-conquer, algoritma ini secara inheren paralel. Bend menjalankannya dengan multi-threading. Beberapa benchmark:

    • CPU, Apple M3 Max, 1 thread: 12,15 detik
    • CPU, Apple M3 Max, 16 thread: 0,96 detik
    • GPU, NVIDIA RTX 4090, 16k thread: 0,21 detik
    • Peningkatan kecepatan 57x dicapai tanpa melakukan apa pun. Tidak ada pengelolaan eksplisit untuk pembuatan thread, lock, atau mutex. Cukup meminta Bend menjalankan program di RTX.

Dukungan untuk beragam sistem paralel

  • Bend tidak terbatas pada paradigma tertentu seperti tensor atau matriks. Segala jenis sistem paralel, dari shader hingga model aktor seperti Erlang, dapat diemulasikan di Bend.

  • Sebagai contoh, untuk merender gambar secara real-time, Anda dapat mengalokasikan pohon immutable untuk setiap frame:

    # bila diberi shader, kembalikan gambar persegi  
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  

# bila diberi posisi, kembalikan warna  
# dalam demo ini, hanya menjalankan busy loop  
def demo_shader(x, y):  
  bend i = 0:  
    when i < 5000:  
      color = fork(i + 1)  
    else:  
      color = 0x000001  
  return color  

# render gambar 256x256 menggunakan demo_shader  
def main:  
  return render(16, demo_shader)

  • Ini benar-benar berfungsi. Bahkan algoritma yang kompleks pun dapat diparalelkan dengan baik di Bend. Komunikasi jarak jauh dilakukan melalui global beta reduction (sesuai interaction calculus), dan disinkronkan secara benar serta efisien oleh atomic linker milik HVM2.

Materi tambahan

  • Untuk langsung mulai, lihat GUIDE.md milik Bend.
  • Untuk melihat daftar fitur, lihat FEATURES.md.
  • Untuk memahami teknologi di balik Bend, lihat paper HVM2.
  • Bend dikembangkan oleh HigherOrderCO.com - bergabunglah ke Discord.

Opini GN⁺

  • Penyederhanaan pemrograman paralel: Bend sangat menyederhanakan pemrograman paralel, sehingga bahkan software engineer pemula pun dapat mengaksesnya dengan mudah. Ini secara signifikan menurunkan hambatan masuk untuk pemrograman paralel.
  • Dukungan perangkat keras yang beragam: Bend dapat berjalan efisien tidak hanya di CPU tetapi juga di GPU, sehingga bisa dimanfaatkan di berbagai lingkungan perangkat keras.
  • Bahasa yang ekspresif: Dengan menggabungkan keunggulan Python dan Haskell, Bend memungkinkan penulisan kode yang ekspresif. Ini meningkatkan keterbacaan dan kemudahan pemeliharaan kode.
  • Pembuatan kode yang masih tahap awal: Saat ini pembuatan kode di Bend masih berada pada tahap awal, sehingga performanya bisa kalah dibanding compiler yang sudah matang. Ini perlu ditingkatkan ke depannya.
  • Dukungan untuk beragam sistem paralel: Bend tidak terbatas pada paradigma tertentu dan mendukung berbagai sistem paralel, sehingga pemrograman yang fleksibel menjadi mungkin. Ini memungkinkan Bend digunakan di berbagai bidang aplikasi.

Bacaan terkait

1 komentar

 
GN⁺ 2024-05-18
Opini Hacker News

Ringkasan kumpulan komentar Hacker News

  • Perbandingan performa Python dan PyPy

    • Saat menjalankan kode yang sama di Python dan PyPy, PyPy jauh lebih cepat.
    • Hasil benchmark di Apple M3 Max dan NVIDIA RTX 4090 dibagikan.
    • Performa di Intel i7-1270P sangat lambat.
    • Pengujian juga diperlukan di platform lain selain Mac.

  • Umpan balik positif

    • Mengingat proyek ini masih dalam tahap awal, pencapaiannya dipuji.
    • Dibandingkan dengan Futhark, disayangkan belum mendukung berbagai target.
    • Masalah performa tampaknya bisa diatasi.

  • Pendapat kritis

    • Meski masih versi awal, proyek ini mendapat banyak kritik.
    • Homepage-nya intuitif dan mudah dipahami.
    • Disebutkan adanya perbedaan antara harapan dan kenyataan terkait algoritma paralel.

  • Harapan terhadap pemrograman paralel

    • Menyampaikan harapan terhadap masa depan pemrograman paralel.
    • Membagikan pengalaman bereksperimen dengan pemrograman paralel melalui Rust dan Shadertoy.
    • Ada antusiasme terhadap bahasa paralel umum yang memanfaatkan GPU.

  • Perbandingan performa

    • Loop sederhana yang ditulis dalam C++ menunjukkan performa yang mirip dengan Bend.
    • Kode C++ yang dioptimalkan jauh lebih cepat.

  • Harapan terhadap perkembangan proyek

    • Memuji keberhasilan mengatasi kesulitan paralelisasi otomatis.
    • Menaruh harapan pada perkembangan proyek ini.

  • Sudut pandang skeptis

    • Menunjukkan karakteristik DSL Bend yang terbatas.
    • Menekankan bahwa performanya kurang baik.
    • Menyebut bahwa array penting dalam komputasi paralel berperforma tinggi yang nyata.
    • Bersikap skeptis terhadap kegunaan Bend.

  • Prospek positif

    • Menyebut kemungkinan Bend dapat memaksimalkan pemanfaatan GPU.
    • Mengharapkan berbagai kemungkinan pemanfaatan GPU selain untuk LLM.

  • Karakteristik bahasa Bend

    • Memuji kemudahan penggunaan Bend dan peningkatan performanya.
    • Disayangkan karena hanya mendukung integer 24-bit.
    • Disebutkan perlunya dukungan integer dengan bit yang lebih tinggi.