Bend - Ngôn ngữ bậc cao chạy trên GPU (dùng HVM2)

(github.com/HigherOrderCO)

1 điểm bởi GN⁺ 2024-05-18 | 1 bình luận | Chia sẻ qua WhatsApp

Bend là một ngôn ngữ lập trình bậc cao hỗ trợ xử lý song song quy mô lớn
Không giống các lựa chọn cấp thấp như CUDA và Metal, Bend mang lại cảm giác và tính năng của các ngôn ngữ giàu khả năng biểu đạt như Python và Haskell
Có cấp phát đối tượng nhanh, hàm bậc cao với hỗ trợ closure đầy đủ, đệ quy không giới hạn, thậm chí cả continuations
Tuy nhiên, nó chạy trên phần cứng song song quy mô lớn như GPU và cho thấy mức tăng tốc gần tuyến tính theo số lượng lõi
Hoàn toàn không cần chú thích song song tường minh: không cần tạo thread, lock, mutex hay phép toán nguyên tử
Bend được vận hành bởi runtime HVM2

Demo nhanh

Sử dụng Bend

Hiện chưa hoạt động trên Windows, cần dùng WSL2 như một giải pháp thay thế.

Trước tiên, cần cài đặt Rust nightly.

Sau đó, cần cài đặt HVM2 và Bend:

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

Cuối cùng, có thể viết một file Bend và chạy bằng một trong các lệnh sau:

bend run   # dùng trình thông dịch Rust (tuần tự)  
bend run-c  # dùng trình thông dịch C (song song)  
bend run-cu  # dùng trình thông dịch CUDA (song song quy mô lớn)

Ngoài ra, có thể dùng gen-c và gen-cu để biên dịch Bend thành file C/CUDA độc lập nhằm đạt hiệu năng tối đa. Tuy nhiên, việc sinh mã vẫn đang ở giai đoạn đầu và chưa trưởng thành như các trình biên dịch tiên tiến như GCC hay GHC.

Lập trình song song trong Bend

Để viết chương trình song song trong Bend... không cần làm gì cả. Chỉ cần viết sao cho nó không mang tính tuần tự một cách cố hữu.
Ví dụ, biểu thức sau không thể chạy song song:
```
(((1 + 2) + 3) + 4)  
```
vì +4 phụ thuộc vào +3, và +3 lại phụ thuộc vào (1+2).
Nhưng biểu thức sau có thể chạy song song:
```
((1 + 2) + (3 + 4))  
```
vì (1+2) và (3+4) là độc lập. Theo nguyên lý cốt lõi của Bend, mọi thứ có thể chạy song song đều sẽ được chạy song song.

Mã ví dụ

Để có một ví dụ đầy đủ hơn, hãy xem đoạn mã sau:

# mạng sắp xếp = xoay cây  
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)  

# xoay cây con  
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 này triển khai một bộ sắp xếp bitonic dùng xoay cây bất biến. Đây không phải là thuật toán được kỳ vọng chạy nhanh trên GPU. Tuy nhiên, vì sử dụng cách tiếp cận chia để trị nên nó mang tính song song bẩm sinh. Bend sẽ chạy nó bằng đa luồng. Một vài benchmark:
- CPU, Apple M3 Max, 1 thread: 12.15 giây
- CPU, Apple M3 Max, 16 thread: 0.96 giây
- GPU, NVIDIA RTX 4090, 16k thread: 0.21 giây
- Đạt được tăng tốc 57 lần mà không cần làm gì cả. Không có quản lý tường minh việc tạo thread, lock hay mutex. Chỉ đơn giản là yêu cầu Bend chạy chương trình trên RTX.

Hỗ trợ nhiều hệ thống song song

Bend không bị giới hạn trong các mô hình cụ thể như tensor hay ma trận. Mọi hệ thống song song, từ shader đến mô hình actor kiểu Erlang, đều có thể được mô phỏng trong Bend.

Ví dụ, để render hình ảnh theo thời gian thực, có thể cấp phát một cây bất biến cho mỗi frame:

# cho một shader, trả về một ảnh hình chữ nhật  
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  

# cho một vị trí, trả về màu sắc  
# trong demo này chỉ đơn giản chạy một vòng lặp bận  
def demo_shader(x, y):  
  bend i = 0:  
    when i < 5000:  
      color = fork(i + 1)  
    else:  
      color = 0x000001  
  return color  

# render ảnh 256x256 bằng demo_shader  
def main:  
  return render(16, demo_shader)

Điều này thực sự hoạt động. Ngay cả các thuật toán phức tạp cũng được song song hóa tốt trong Bend. Giao tiếp tầm xa được thực hiện thông qua global beta reduction (theo interaction calculus) và được đồng bộ chính xác, hiệu quả nhờ atomic linker của HVM2.

Tài liệu bổ sung

Để bắt đầu ngay, hãy xem GUIDE.md của Bend.
Để xem danh sách tính năng, hãy xem FEATURES.md.
Để hiểu công nghệ của Bend, hãy xem bài báo về HVM2.
Bend được phát triển tại HigherOrderCO.com - hãy tham gia Discord.

Ý kiến của GN⁺

Đơn giản hóa lập trình song song: Bend đơn giản hóa rất nhiều việc lập trình song song, giúp ngay cả kỹ sư phần mềm mới vào nghề cũng có thể tiếp cận dễ dàng. Điều này làm giảm đáng kể rào cản gia nhập với lập trình song song.
Hỗ trợ nhiều phần cứng: Bend có thể chạy hiệu quả không chỉ trên CPU mà còn trên GPU, nên có thể được tận dụng trong nhiều môi trường phần cứng khác nhau.
Ngôn ngữ giàu khả năng biểu đạt: Kết hợp ưu điểm của Python và Haskell, cho phép viết mã giàu tính biểu đạt. Điều này giúp tăng tính dễ đọc và khả năng bảo trì của mã.
Sinh mã vẫn ở giai đoạn đầu: Hiện việc sinh mã của Bend vẫn đang ở giai đoạn đầu, nên hiệu năng có thể kém hơn khi so với các trình biên dịch đã trưởng thành. Đây là điểm cần được cải thiện trong tương lai.
Hỗ trợ nhiều hệ thống song song: Bend không bị giới hạn ở một mô hình cụ thể mà hỗ trợ nhiều hệ thống song song khác nhau, cho phép lập trình linh hoạt. Điều này giúp Bend có thể được ứng dụng trong nhiều lĩnh vực khác nhau.

1 bình luận

GN⁺ 2024-05-18

Ý kiến trên Hacker News

Tóm tắt các bình luận trên Hacker News

So sánh hiệu năng giữa Python và PyPy
- Khi chạy cùng một đoạn mã bằng Python và PyPy, PyPy nhanh hơn nhiều.
- Chia sẻ kết quả benchmark trên Apple M3 Max và NVIDIA RTX 4090.
- Hiệu năng trên Intel i7-1270P rất chậm.
- Cần thử nghiệm thêm trên các nền tảng khác ngoài Mac.
Phản hồi tích cực
- Xét đây là giai đoạn đầu của dự án, nhiều người khen ngợi thành quả đạt được.
- So với Futhark, điểm đáng tiếc là chưa hỗ trợ nhiều mục tiêu khác nhau.
- Có vẻ các vấn đề về hiệu năng vẫn có thể được giải quyết.
Ý kiến chỉ trích
- Dù là phiên bản đầu, dự án vẫn nhận khá nhiều chỉ trích.
- Trang chủ trực quan và dễ hiểu.
- Có nhắc đến khoảng cách giữa kỳ vọng và thực tế đối với thuật toán song song.
Kỳ vọng về lập trình song song
- Bày tỏ kỳ vọng vào tương lai của lập trình song song.
- Chia sẻ trải nghiệm thử nghiệm lập trình song song với Rust và Shadertoy.
- Kỳ vọng vào một ngôn ngữ song song tổng quát tận dụng GPU.
So sánh hiệu năng
- Một vòng lặp đơn giản viết bằng C++ cho hiệu năng tương tự Bend.
- Mã C++ được tối ưu hóa nhanh hơn rất nhiều.
Kỳ vọng về sự phát triển của dự án
- Khen ngợi việc vượt qua được khó khăn của tự động song song hóa.
- Mong đợi dự án tiếp tục phát triển.
Góc nhìn hoài nghi
- Chỉ ra đặc tính DSL hạn chế của Bend.
- Nhấn mạnh rằng hiệu năng không tốt.
- Đề cập rằng trong tính toán song song hiệu năng cao thực tế, mảng là yếu tố quan trọng.
- Hoài nghi về tính hữu dụng của Bend.
Triển vọng tích cực
- Đề cập khả năng Bend có thể tối đa hóa việc tận dụng GPU.
- Kỳ vọng nhiều khả năng ứng dụng GPU đa dạng ngoài LLM.
Đặc tính ngôn ngữ của Bend
- Khen ngợi cách sử dụng đơn giản và cải thiện hiệu năng của Bend.
- Đáng tiếc là chỉ hỗ trợ số nguyên 24-bit.
- Đề cập sự cần thiết phải hỗ trợ số nguyên với số bit cao hơn.