Bend - GPU'da Çalışan Gelişmiş Bir Dil (HVM2 kullanır)

(github.com/HigherOrderCO)

1 puan yazan GN⁺ 2024-05-18 | 1 yorum | WhatsApp'ta paylaş

Bend, büyük ölçekli paralel işlemeyi destekleyen yüksek seviyeli bir programlama dilidir
CUDA ve Metal gibi düşük seviyeli alternatiflerin aksine Bend, Python ve Haskell gibi ifade gücü yüksek dillerin hissini ve özelliklerini sunar
Hızlı nesne tahsisi, tam closure desteğine sahip yüksek dereceli fonksiyonlar, sınırsız özyineleme ve hatta continuations içerir
Ancak GPU gibi büyük ölçekli paralel donanımlarda çalışır ve çekirdek sayısına göre neredeyse doğrusal hız artışı gösterir
Hiçbir açık paralellik anotasyonu gerekmez: thread oluşturma, lock, mutex ve atomik işlemler gerekmez
Bend, HVM2 runtime tarafından desteklenir

Hızlı demo

Bend kullanımı

Şu anda Windows'ta çalışmıyor; alternatif olarak WSL2 kullanılmalı.

Önce Rust nightly kurulmalıdır.

Ardından HVM2 ve Bend kurulmalıdır:

cargo +nightly install hvm  
cargo +nightly install bend-lang

Son olarak bir Bend dosyası yazıp aşağıdaki komutlardan biriyle çalıştırabilirsiniz:

bend run   # Rust yorumlayıcısını kullanır (sıralı)  
bend run-c  # C yorumlayıcısını kullanır (paralel)  
bend run-cu  # CUDA yorumlayıcısını kullanır (büyük ölçekli paralel)

Ayrıca en yüksek performans için gen-c ve gen-cu kullanarak Bend'i bağımsız C/CUDA dosyalarına derleyebilirsiniz. Ancak kod üretimi hâlâ erken aşamadadır ve GCC veya GHC gibi gelişmiş derleyiciler kadar olgun değildir.

Bend'de paralel programlama

Bend'de paralel program yazmak için... hiçbir şey yapmanız gerekmez. Yalnızca doğası gereği sıralı olmayacak şekilde yazmanız yeterlidir.
Örneğin şu ifade paralel çalıştırılamaz:
```
(((1 + 2) + 3) + 4)  
```
Çünkü +4, +3e; +3 de (1+2)ye bağlıdır.
Ancak şu ifade paralel çalıştırılabilir:
```
((1 + 2) + (3 + 4))  
```
Çünkü (1+2) ile (3+4) birbirinden bağımsızdır. Bend'in temel ilkesine göre paralel çalışabilen her şey paralel çalıştırılır.

Örnek kod

Daha kapsamlı bir örnek olarak şu kodu ele alalım:

# sıralama ağı = ağaç döndürme  
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)  

# alt ağaç döndürme  
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))

Bu dosya, değiştirilemez ağaç döndürmeleri kullanan bir bitonic sorter uygular. Bu, GPU'da hızlı çalışması beklenecek bir algoritma değildir. Ancak böl ve yönet yaklaşımı kullandığı için doğası gereği paraleldir. Bend bunu çok iş parçacıklı olarak çalıştırır. Bazı benchmark sonuçları:
- CPU, Apple M3 Max, 1 thread: 12.15 saniye
- CPU, Apple M3 Max, 16 thread: 0.96 saniye
- GPU, NVIDIA RTX 4090, 16k thread: 0.21 saniye
- Hiçbir şey yapmadan 57 kat hızlanma elde edilir. Thread oluşturma, lock veya mutex için açık yönetim yoktur. Sadece Bend'den programı RTX üzerinde çalıştırmasını istemiş olursunuz.

Çeşitli paralel sistem desteği

Bend; tensor veya matris gibi belirli bir paradigma ile sınırlı değildir. Shader'lardan Erlang benzeri actor modeline kadar her türlü paralel sistem Bend içinde emüle edilebilir.

Örneğin gerçek zamanlı görüntü render etmek için her frame'de değiştirilemez ağaçlar tahsis edebilirsiniz:

# bir shader verildiğinde kare bir görüntü döndürür  
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  

# bir konum verildiğinde renk döndürür  
# bu demoda yalnızca yoğun bir döngü çalıştırılır  
def demo_shader(x, y):  
  bend i = 0:  
    when i < 5000:  
      color = fork(i + 1)  
    else:  
      color = 0x000001  
  return color  

# demo_shader kullanarak 256x256 görüntü render eder  
def main:  
  return render(16, demo_shader)

Bu gerçekten çalışır. Karmaşık algoritmalar da Bend'de iyi şekilde paralelleştirilir. Uzun mesafeli iletişim global beta reduction ile (interaction calculus'a göre) gerçekleştirilir ve HVM2'nin atomic linker yapısı tarafından doğru ve verimli şekilde senkronize edilir.

Ek kaynaklar

Hemen başlamak için Bend'in GUIDE.md dosyasına bakın.
Özellik listesini görmek için FEATURES.md dosyasına bakın.
Bend'in teknolojisini anlamak için HVM2 makalesine göz atın.
Bend, HigherOrderCO.com tarafından geliştirilmektedir - Discord'a katılın.

GN⁺ görüşü

Paralel programlamanın sadeleşmesi: Bend, paralel programlamayı çok sade hâle getirerek başlangıç seviyesindeki yazılım mühendislerinin bile kolayca yaklaşabilmesini sağlar. Bu, paralel programlamaya giriş bariyerini ciddi biçimde düşürür.
Çeşitli donanım desteği: Bend yalnızca CPU'da değil, GPU'da da verimli şekilde çalışabilir; bu da farklı donanım ortamlarında kullanılabilmesini sağlar.
İfade gücü yüksek dil: Python ve Haskell'in avantajlarını birleştirerek ifade gücü yüksek kod yazılmasını sağlar. Bu da kodun okunabilirliğini ve bakımını iyileştirir.
Erken aşamadaki kod üretimi: Bend'in kod üretimi şu anda erken aşamadadır; bu nedenle olgun derleyicilerle kıyaslandığında performans geride kalabilir. Bu alanın gelecekte iyileştirilmesi gerekir.
Çeşitli paralel sistem desteği: Bend, belirli bir paradigma ile sınırlı kalmayıp farklı paralel sistemleri destekleyerek esnek programlama imkânı sunar. Bu da Bend'in çeşitli uygulama alanlarında kullanılmasını mümkün kılar.

1 yorum

GN⁺ 2024-05-18

Hacker News yorumu

Hacker News yorum derlemesi özeti

Python ve PyPy performans karşılaştırması
- Aynı kod Python ve PyPy ile çalıştırıldığında, PyPy çok daha hızlı.
- Apple M3 Max ve NVIDIA RTX 4090 üzerindeki benchmark sonuçları paylaşıldı.
- Intel i7-1270P üzerindeki performansın çok yavaş olduğu belirtildi.
- Mac dışındaki diğer platformlarda da test yapılması gerekiyor.
Olumlu geri bildirim
- Projenin erken aşamada olduğu göz önüne alındığında, elde edilen sonuçlar övülüyor.
- Futhark ile karşılaştırıldığında, farklı target'ları desteklememesi eksiklik olarak görülüyor.
- Performans sorunlarının çözülebilir olduğu düşünülüyor.
Eleştirel görüşler
- Erken sürüm olmasına rağmen çok fazla eleştiri aldığı belirtiliyor.
- Ana sayfanın sezgisel ve anlaşılması kolay olduğu söyleniyor.
- Paralel algoritmalara dair beklentiler ile gerçeklik arasındaki farktan bahsediliyor.
Paralel programlamaya dair beklenti
- Paralel programlamanın geleceğine dair heyecan ifade ediliyor.
- Rust ve Shadertoy ile paralel programlama deneyleri yapanların deneyimleri paylaşılıyor.
- GPU kullanan genel amaçlı paralel bir dile dair beklenti vurgulanıyor.
Performans karşılaştırması
- C++ ile yazılmış basit bir döngünün Bend'e benzer performans gösterdiği belirtiliyor.
- Optimize edilmiş C++ kodunun çok daha hızlı olduğu ifade ediliyor.
Projenin gelişimine dair beklenti
- Otomatik paralelleştirmenin zorluklarını aşma çabası övülüyor.
- Projenin gelecekte nasıl gelişeceği merakla bekleniyor.
Şüpheci bakış açısı
- Bend'in sınırlı bir DSL niteliği taşıdığına dikkat çekiliyor.
- Performansının iyi olmadığı özellikle vurgulanıyor.
- Gerçek yüksek performanslı paralel hesaplamada dizilerin önemli olduğu belirtiliyor.
- Bend'in pratikte ne kadar faydalı olacağı konusunda şüphe duyuluyor.
Olumlu beklenti
- Bend'in GPU kullanımını en üst düzeye çıkarma potansiyeline sahip olabileceği belirtiliyor.
- LLM'ler dışında da GPU'ların kullanılabileceği çeşitli olasılıklar konusunda beklenti dile getiriliyor.
Bend'in dil özellikleri
- Bend'in basit kullanımı ve performans artışı övülüyor.
- Yalnızca 24 bit tamsayıları desteklemesi eksiklik olarak görülüyor.
- Daha yüksek bit genişliğine sahip tamsayı desteğinin gerekli olduğu belirtiliyor.