Bend

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

★ 19,797 Open GitHub ↗

대규모 병렬 고수준 프로그래밍 언어

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Bend

고수준 병렬 프로그래밍 언어

## Index
1. [Introduction](#introduction)
2. [Important Notes](#important-notes)
3. [Install](#install)
4. [Getting Started](#getting-started)
5. [Speedup Example](#speedup-examples)
6. [Additional Resources](#additional-resources)
## Introduction
Bend는 Python 및 Haskell과 같은 표현력 있는 언어의 느낌과 기능을 제공합니다. 여기에는 빠른 객체 할당, 클로저가 포함된 고차 함수에 대한 완전한 지원, 제한 없는 재귀, 심지어 컨티뉴에이션(continuation)까지 포함됩니다.
Bend는 CUDA처럼 확장되며, 스레드 생성, 락(lock), 뮤텍스(mutex) 또는 아토믹(atomic) 같은 명시적인 병렬성 주석 없이도 코어 수에 따라 거의 선형적인 가속을 제공하며 GPU와 같은 대규모 병렬 하드웨어에서 실행됩니다.
Bend는 [HVM2](https://github.com/higherorderco/hvm) 런타임으로 구동됩니다.
## Important Notes
\* Bend는 10,000개 이상의 동시 스레드를 지원하며 코어에 따른 확장 성능이 뛰어나도록 설계되었습니다.
\* 현재 버전은 단일 코어 성능이 낮을 수 있습니다.
\* 코드 생성 및 최적화 기법을 발전시킴에 따라 상당한 성능 향상을 기대할 수 있습니다.
\* Windows 지원을 위해 계속 노력 중입니다. 대안으로 [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install)를 사용하세요.
\* [현재는 NVIDIA GPU만 지원합니다](https://github.com/HigherOrderCO/Bend/issues/341).
## Install
### Install dependencies
#### On Linux
```sh
# Install Rust if you haven't already.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# For the C version of Bend, use GCC. We recommend a version up to 12.x.
sudo apt install gcc
```
CUDA 런타임의 경우 버전 12.x [Linux용 CUDA 툴킷 설치](https://developer.nvidia.com/cuda-downloads?target\_os=Linux)를 진행하세요.
#### On Mac
```sh
# Install Rust if you haven't it already.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# For the C version of Bend, use GCC. We recommend a version up to 12.x.
brew install gcc
```
### Install Bend
1. 다음을 실행하여 HVM2를 설치합니다:
```sh
# HVM2 is HOC's massively parallel Interaction Combinator evaluator.
cargo install hvm
# This ensures HVM is correctly installed and accessible.
hvm --version
```
2. 다음을 실행하여 Bend를 설치합니다:
```sh
# This command will install Bend
cargo install bend-lang
# This ensures Bend is correctly installed and accessible.
bend --version
```
### Getting Started
#### Running Bend Programs
```sh
bend run  # uses the C interpreter by default (parallel)
bend run-rs  # uses the Rust interpreter (sequential)
bend run-c  # uses the C interpreter (parallel)
bend run-cu  # uses the CUDA interpreter (massively parallel)
# Notes
# You can also compile Bend to standalone C/CUDA files using gen-c and gen-cu for maximum performance.
# The code generator is still in its early stages and not as mature as compilers like GCC and GHC.
# You can use the -s flag to have more information on
# Reductions
# Time the code took to run
# Interaction per second (In millions)
```
#### Testing Bend Programs
아래 예제는 `start`부터 `target`까지의 범위에 있는 모든 숫자를 합산합니다. 이 작업은 본질적으로 순차적인 방식(따라서 병렬화할 수 없음)과 쉽게 병렬화할 수 있는 방식, 두 가지 방법으로 작성할 수 있습니다. (가시성을 위해 대부분의 예제에서 `-s` 플래그를 사용할 것입니다.)
#### Sequential version:
먼저 `sequential\_sum.bend`라는 파일을 생성합니다.
```sh
# Write this command on your terminal
touch sequential\_sum.bend
```
그런 다음 텍스트 편집기로 `sequential\_sum.bend` 파일을 열고, 아래 코드를 복사하여 파일에 붙여넣습니다.
```py
# Defines the function Sum with two parameters: start and target
def Sum(start, target):
if start == target:
# If the value of start is the same as target, returns start.
return start
else:
# If start is not equal to target, recursively call Sum with
# start incremented by 1, and add the result to start.
return start + Sum(start + 1, target)
def main():
# This translates to (1 + (2 + (3 + (...... + (999999 + 1000000)))))
# Note that this will overflow the maximum value

Bend에서의 숫자
return Sum(1, 1\_000\_000)
```
##### 파일 실행하기
Rust interpreter (순차)를 사용하여 실행할 수 있습니다.
```sh
bend run-rs sequential\_sum.bend -s
```
또는 C interpreter (순차)를 사용할 수도 있습니다.
```sh
bend run-c sequential\_sum.bend -s
```
NVIDIA GPU가 있는 경우, CUDA (순차)로도 실행할 수 있습니다.
```sh
bend run-cu sequential\_sum.bend -s
```
이 버전에서 다음에 계산될 값은 이전 합계에 의존하므로, 현재 연산이 완료될 때까지 다음 단계로 진행할 수 없습니다. 이제 쉽게 병렬화할 수 있는 버전을 살펴보겠습니다.
#### 병렬화 가능 버전:
먼저 이전 파일을 닫고 터미널에서 `parallel\_sum.bend` 파일을 생성합니다.
```sh
# 터미널에 이 명령어를 입력하세요
touch parallel\_sum.bend
```
그런 다음 텍스트 편집기로 `parallel\_sum.bend` 파일을 열고, 아래 코드를 복사하여 파일에 붙여넣습니다.
```py
# start와 target 두 개의 파라미터를 갖는 Sum 함수 정의
def Sum(start, target):
if start == target:
# start 값이 target과 같으면 start를 반환합니다.
return start
else:
# start가 target과 같지 않으면 중간 지점(half)을 계산한 다음,
# 양쪽 절반에 대해 Sum을 재귀적으로 호출합니다.
half = (start + target) / 2
left = Sum(start, half) # (Start -> Half)
right = Sum(half + 1, target)
return left + right
# 1부터 1000000까지의 숫자에 대한 병렬화 가능한 합계
def main():
# 이는 (((1 + 2) + (3 + 4)) + ... (999999 + 1000000)...)로 변환됩니다.
return Sum(1, 1\_000\_000)
```
이 예에서 (3 + 4)의 합은 (1 + 2)에 의존하지 않으므로, 두 연산이 동시에 발생할 수 있어 병렬로 실행될 수 있습니다.
##### 파일 실행하기
Rust interpreter (순차)를 사용하여 실행할 수 있습니다.
```sh
bend run-rs parallel\_sum.bend -s
```
또는 C interpreter (병렬)를 사용할 수도 있습니다.
```sh
bend run-c parallel\_sum.bend -s
```
NVIDIA GPU가 있는 경우, CUDA (대규모 병렬)로도 실행할 수 있습니다.
```sh
bend run-cu parallel\_sum.bend -s
```
Bend에서는 실행 명령어만 변경하여 병렬화할 수 있습니다. 코드\*\*가\*\* 병렬로 실행될 수 있다면, \*\*실제로\*\* 병렬로 실행됩니다.
### 속도 향상 예시
아래의 코드 스니펫은 \*불변 트리 회전(immutable tree rotations)\*을 사용하는 [bitonic sorter](https://en.wikipedia.org/wiki/Bitonic\_sorter)를 구현합니다. GPU에서 빠르게 실행될 것으로 기대되는 종류의 알고리즘은 아닙니다. 하지만 본질적으로 병렬 처리가 가능한 분할 정복(divide and conquer) 접근 방식을 사용하므로, Bend는 스레드 생성이나 명시적인 락(lock) 관리 없이 여러 스레드에서 이를 실행합니다.
#### Bitonic Sorter 벤치마크
- `bend run-rs`: CPU, Apple M3 Max: 12.15초
- `bend run-c`: CPU, Apple M3 Max: 0.96초
- `bend run-cu`: GPU, NVIDIA RTX 4090: 0.21초
**Bitonic Sorter 코드를 보려면 여기를 클릭하세요**
```py
# Sorting Network = 트리 회전만 수행!
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))
# 서브트리 회전 (파란색/초록색 박스)
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))
# 먼 거리의 값 교환 (빨간색 박스)
def warp(d, s, a, b):
switch d:
case 0:
return swap(s ^ (a > b), a, b)
case \_:
(a.a, a.b) = a
(b.a, b.b) = b
(A.a, A.b) = warp(d-1, s, a.a, b.a)
(B.a, B.b) = warp(d-1, s, a.b, b.b)
return ((A.a,B.a),(A.b,B.b))
# 아래로 전파
def down(d,s,t):
switch d:
case 0:
return t
case \_:
(t.a, t.b) = t
return (rots(d-1, s, t.a), rots(d-1, s, t.b))
# 단일 쌍 교환
def swap(s, a, b):
switch s:
case 0:
return (a,b)
case \_:
return (b,a)
# 테스트
# -------
# 큰 트리 생성
def gen(d, x):
switch d:
case 0:
return x
case \_:
return (gen(d-1, x \* 2 + 1), gen(d-1, x \* 2))
# 큰 트리의 합계 계산
def sum(d, t):
switch d:
case 0:
return t
case \_:
(t.a, t.b) = t
return sum(d-1, t.a) + sum(d-1, t.b)
# 큰 트리 정렬
def main:
return sum(20, sort(20, 0, gen(20, 0)))
```
다른 알고리즘에 관심이 있다면 [examples 폴더](https://github.com/HigherOrderCO/Bend/tree/m)를 확인해 보세요.

ain/examples)
### 추가 리소스
- Bend 이면의 기술을 이해하려면 HVM2 [논문](https://paper.higherorderco.com/)을 확인하세요.
- 공식 문서를 준비 중이며, 그동안 더 자세한 설명을 원하시면 [GUIDE.md](https://github.com/HigherOrderCO/Bend/blob/main/GUIDE.md)를 확인하세요.
- [FEATURES.md](https://github.com/HigherOrderCO/Bend/blob/main/FEATURES.md)에서 기능에 대해 읽어보세요.
- Bend는 [HigherOrderCO](https://higherorderco.com/)에서 개발했습니다. [Discord](https://discord.higherorderco.com)에 참여하세요!

Bend

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README