디스코드가 일렉트론을 버리고 Rust 로 간다길래

디스코드가 데스크톱 앱을 Rust 로 다시 만든다는 소식을 봤다. UI 는 사람들이 예상하기로는 Tauri 였으나 GPUI 로 그린다고 한다. 공동 창업자이자 CTO 인 Stanislav Vishnevskiy 가 11월 초에 X 에 직접 올린 이야기라 소문은 아닌 것 같다 ( Windows Latest ). GPUI 는 Zed 에디터를 만든 팀이 쓰는 프레임워크다. 웹뷰를 띄우는 게 아니라 GPU 로 화면을 직접 그린다. 일렉트론은 앱마다 크롬을 하나씩 들고 다니는 구조라 메모리를 많이 먹는다는 얘기가 늘 따라다녔는데, 디스코드는 그 구조 자체를 내려놓기로 한 것 같다. 모바일도 같이 바뀐다고 한다. React Native 를 빼고, 화면은 각 플랫폼 네이티브로 두되 그 아래 코드는 Rust 로 데스크톱과 공유한다는 이야기다. 나는 메모리 숫자보다 이쪽이 더 눈에 들어왔다. 메모리 얘기도 돈다. 테스트 빌드가 300MB 조금 안 되게 쓴다는 스크린샷이다. 근데 출시 전 빌드 화면 한 장이고 출시일도 없어서, 그냥 그런 게 있구나 하고 보고 있다. 왜 C++ 에서 Rust 로 옮겼나 나도 C++ 로 짜던 코드를 Rust 로 옮겼다. 회사 일이라 자세히 쓰기는 어렵고, 이유만 적어 둔다. 한 번에 옮긴 건 아니다. 4년 전에는 일부 모듈만 Rust 로 바꿨고, 작년에 코어 로직 전부를 Rust 로 옮겼다. 지금 일렉트론은 UI 만 맡고 있다. 개인적으로 만드는 앱도 코어 로직은 전부 Rust 로 짠다. git 클라이언트인 git403 은 Tauri 로 만들었고, 데스크톱과 안드로이드를 같이 지원한다. vmdeck 은 애플 실리콘 맥 전용 가상화 앱이다. Parallels, VMware, UTM 을 대신하려고 만들었고, 회사에서도 라이선스 걱정 없이 쓰고 싶었다. 인텔 맥이나 윈도우용도 생각은 해 봤다. 그런데 윈도우는 이미 무료로 쓸 만한 앱이 많고, 인텔 맥은 단종돼서 아직은 손이 안 간다. 고민이 하나 있다. vmdeck 안에 윈도우를 설치해서 쓰...

C vs Rust vs Mojo, 이긴 쪽은 셋 다 쓰는 LLVM

error: 'fn' has been removed; use 'def' instead

Mojo 를 설치하고 처음 받은 문장이다. 내가 쓴 코드는 fn main(): 한 줄이었다.

C보다 빠르고 Rust 만큼 안전하다는 소개를 봤고, 만든 사람이 Chris Lattner 라는 것까지 듣고 나니 그냥 넘기기가 어려웠다. LLVM 을 만든 사람이 새 언어를 만들었다는 건 그 자체로 이력이다. 공개된 지 3년쯤 됐고 1.0 은 올해 여름에 나왔다.

그래서 속도를 재보려고 설치했는데 hello world 가 컴파일되지 않았다. fn 은 지난 3년간 이 언어를 상징한 키워드이고, 튜토리얼 대부분이 fn main(): 으로 시작하는데 그게 1.0 에서 없어졌다.

일단 def 로 바꾸고 속도부터 쟀다.

세 자루의 놋쇠 만년필이 부채꼴로 놓여 있고 펜촉이 모두 가운데 유리 잉크병 하나를 향하고 있다

벤치마크

같은 알고리즘을 C, Rust, Mojo, CPython 네 개로 썼다. mandelbrot 집합을 1000×1000 격자에서 최대 1000회까지 반복하는 코드이고, SIMD 도 병렬화도 없는 스칼라 단일 스레드로 통일했다. 언어를 바꿔서 얻는 것만 보고 싶었다.

def mandel(c_re: Float64, c_im: Float64, max_iter: Int) -> Int:
    var z_re: Float64 = 0.0
    var z_im: Float64 = 0.0
    var n: Int = 0
    while n < max_iter:
        var re2 = z_re * z_re
        var im2 = z_im * z_im
        if re2 + im2 > 4.0:
            break
        z_im = 2.0 * z_re * z_im + c_im
        z_re = re2 - im2 + c_re
        n += 1
    return n

C 는 clang -O2, Rust 는 rustc -O, Mojo 는 mojo build -O3 로 빌드해서 다섯 번씩 돌렸다.

m_c      : 0.33 0.32 0.32 0.32 0.32
m_rs     : 0.33 0.33 0.33 0.33 0.33
m_mojo   : 0.32 0.32 0.32 0.32 0.32

셋 다 0.3초 남짓이다. CPython 으로 같은 코드를 돌리면 9초쯤 나온다. 컴파일 언어 셋은 차이가 없고 파이썬보다는 서른 배 가까이 빠르다. Modular 마케팅에서 본 35,000배랑은 자릿수가 다르다. 그쪽 코드엔 SIMD 랑 병렬화가 다 들어가 있었을 거다.

내가 잰 결과로는 C보다 빠르지는 않고 C만큼 빠르다. 그런데 답을 얻고 나니 다른 게 이상했다.

네 언어가 같은 계산을 하는지 보려고 반복 횟수 총합을 출력하게 해뒀는데 그 값이 언어마다 달랐다.

C (기본)              : checksum: 172812500
Rust                  : checksum: 172812923
Mojo                  : checksum: 172812500
CPython               : checksum: 172812923

Mojo 랑 C 가 한 값, Rust 랑 CPython 이 다른 값이다. 차이는 400 남짓. 부동소수점이니 연산 순서 문제겠다 싶었다. 2.0 * z_re * z_im + c_im 을 fused multiply-add 로 합치면 중간 반올림이 한 번 사라지고, 경계에 있는 픽셀에서 반복 횟수가 하나씩 어긋난다.

C 를 -ffp-contract=off 로 다시 빌드하니 Rust 값이랑 딱 맞았다. 어셈블리를 보니 fmadd 가 C 기본 빌드랑 Mojo 에만 있었다. Mojo 는 clang 기본값처럼 연산을 합치고, Rust 는 소스에 적힌 연산 순서를 지킨다.

fmadd 를 쓰든 말든 속도는 그대로였다. 그런데 계산 결과는 달라졌다. 벤치마크 글에서 「같은 알고리즘」이라는 말을 그냥 넘기곤 했는데, 같은 알고리즘이 같은 계산은 아니었다. checksum 을 안 찍었으면 몰랐을 거다.

바이너리

세 언어가 왜 같은 속도를 냈는지는 아직 몰랐다. clang 은 LLVM 자체이고 rustc 는 LLVM 을 백엔드로 쓴다. Mojo 도 MLIR 위에 서 있다고 알려져 있으니 셋 다 같은 최적화기가 기계어를 만드는 거다. 그래서 설치된 컴파일러를 열었다.

.venv/lib/python3.12/site-packages/modular/bin/mojo
Mach-O 64-bit executable arm64, 118M

LLVM 24.0.0git 문자열이 있고, instcombine, licm, loop-vectorize 같은 LLVM 패스 이름이 그대로 들어 있다. 그런데 심볼을 세다가 예상 못 한 걸 봤다.

심볼 총계                : 585
C++ 맹글링(_Z) 심볼      : 191
Mojo 맹글링($) 심볼      : 0

컴파일러 안에 Mojo 로 쓴 코드 흔적이 없다. 보이는 건 전부 C++ 이름이고, 링크된 라이브러리 맨 앞에 libc++ 가 있다.

심볼 지운 릴리스 빌드라 그런가 싶어서 hello world 를 빌드해 봤다. 그 작은 바이너리에도 Mojo 심볼이 몇 개 남아 있는데, 100MB 넘는 본체엔 하나도 없다.

같은 방법을 rustc 에 써봤다. 처음에 which rustc 로 나온 경로를 쟀는데 그건 rustup 프록시였고, 본체는 librustc_driver dylib 이었다.

librustc_driver-05edb5a3925fcee9.dylib   177M
  Rust 맹글링 심볼 : 3,425
  C++ 맹글링 심볼  : 98,098

처음 이 숫자를 봤을 때는 내 생각이 틀린 줄 알았다. 그런데 그 C++ 은 rustc 가 링크한 LLVM 이다. rustc 는 파서와 타입 검사기, 빌림 검사기를 Rust 로 쓰고 기계어 생성은 LLVM 에 넘긴다. Mojo 는 프론트엔드도 C++ 이다. 컴파일러에 Mojo 로 쓰인 부분이 아직 없다.

여기까지 재고 나서 이걸 약점으로 볼 수 있나 싶어졌다. Mojo 소스 파일에 MLIR 연산을 직접 적어봤다.

def main():
    var x = __mlir_op.`index.constant`[value = __mlir_attr.`7 : index`]()
    print(Int(x))

Int(x) 변환에서 에러가 났는데, __mlir_op 와 __mlir_attr 자체는 파서에서 걸리지 않았다. Mojo 는 MLIR 을 감추지 않고 언어 문법에 넣어뒀다. MLIR 도 LLVM 도 Chris Lattner 가 시작한 프로젝트이고, 나는 Mojo 를 그 두 개 위에 얹은 프론트엔드로 설계된 언어라고 보고 있다. 그렇게 보면 컴파일러가 C++ 인 것도 이상한 선택이 아니다. 얹으려는 기반이 C++ 로 쓰인 MLIR 이니까.

다만 그러면 빠른 이유가 Mojo 에 있지 않다. Mojo 가 C만큼 빠른 건 C 를 빠르게 만드는 그 최적화기를 같이 쓰기 때문이다.

MLIR 통로로 하드웨어 벡터 타입에 닿는다면 그걸 써서 재보는 게 맞다. arm64 의 NEON 이 128비트라서 f64 SIMD width: 2 가 나온다. 픽셀을 두 개씩 묶으면 이론상 두 배다.

그런데 벡터끼리 비교하려고 < 를 썼더니 컴파일러가 거부했다.

constraint failed: Strict inequality is only defined for `Scalar`s;
did you mean to use `SIMD.lt(...)`?

요소별 비교는 lt 나 le 로 마스크를 받고, 그 마스크로 select 를 걸어 아직 발산하지 않은 요소만 갱신하고, reduce_or 로 다 발산했는지 봐야 한다.

var m = (r2 + i2).le(four)
if not m.reduce_or():
    break
zi = m.select(2.0 * zr * zi + ci, zi)
zr = m.select(r2 - i2 + cr, zr)
n = m.select(n + one, n)

처음엔 불편했는데 쓰다 보니 이유가 보였다. 벡터 비교를 참과 거짓 하나로 뭉개면 어느 요소가 걸렸는지가 사라진다. 그걸 조용히 해주지 않고 손으로 고르게 만든 거다.

m_mojo   : 0.32 0.32 0.32 0.32 0.32
m_simd   : 0.22 0.23 0.22 0.22 0.22
m_c      : 0.32 0.31 0.32 0.32 0.32

0.32초에서 0.22초, 1.45배다. checksum 도 그대로였다. 벡터 명령이 SIMD 버전에만 있었으니 clang -O2 는 이 루프를 벡터화 못 한 거다.

언어를 C 에서 Mojo 로 바꿔서 얻은 건 0이었고, 그 언어가 주는 벡터 문법을 써서 얻은 건 1.45배였다. 반복문 몇 줄 고치는 동안 헤더 한 번 안 찾아봤다.

1.0.0 changelog

다시 fn 얘기다. 1.0.0 changelog 를 통째로 검색했는데 fn 이 한 번도 안 나온다. 3년간 이 언어의 얼굴이던 키워드가 사라졌는데 그 이야기가 릴리스 노트에 없다. 같은 changelog 에는 이런 문장이 있다.

most core language features are stable, meaning they won't be removed
or changed in ways that breaks source compatibility

아마 fn 은 이 문장이 말하는 core language feature 목록에 안 들어갔을 거다. 그런데 밖에서 보면 구분이 안 된다. 인터넷에 있는 Mojo 예제 코드는 대부분 fn 으로 시작하고, 그게 지금 전부 컴파일되지 않는다.

파이썬 코드를 그대로 넣어보려고 print(lst[-1]) 을 썼더니 이것도 막혔다.

constraint failed: negative indexing is not supported,
use e.g. `x[len(x) - 1]`

음수 인덱스를 처리하려면 런타임 검사가 붙으니 그 비용을 안 내기로 한 건 이해가 간다. 다만 파이썬 슈퍼셋을 목표로 한 언어에서 lst[-1] 이 안 된다는 건 목표를 조금 물렸다는 뜻이다. 처음 넣어 본 몇 줄짜리 파이썬 코드에서 그대로 돈 건 for 랑 len() 정도였다.

1.0 이라는 숫자를 보고 언어가 굳었다고 읽었는데, 실제로는 굳히는 작업을 이제 시작한다는 표시였다. changelog 에 "We may still make breaking changes, but they'll be managed with care." 라고 적혀 있다.

여기까지 쓰고 보니 깎기만 한 것 같은데, 안전성은 얘기가 다르다. 지역 변수 참조를 반환하는 함수를 써봤다.

def make_ref() -> ref [origin_of()] Int:
    var local = 7
    return local
error: cannot return reference with incompatible origin:
'origin_of(local)' vs 'ImmUntrackedOrigin'

컴파일러가 잡았다. origin 이 Rust 의 lifetime 에 대응하는 개념이고 실물로 작동한다. 에러 메시지에 지역 변수 이름까지 들어가 있어서 어디가 문제인지 바로 보인다. 안전성을 표현하는 키워드가 1.0 에서 한 번 바뀌었고 또 바뀔 예정이라는 것만 찜찜하다.

지금 나는 이 언어를 볼 때 「빠르다」를 근거로 삼기는 어렵겠다고 보고 있다. 스칼라 코드가 빠른 건 LLVM 이 하는 일이다. Mojo 가 다른 건 그 아래 있는 벡터 명령과 MLIR 에 파이썬처럼 생긴 문법으로 닿게 해준다는 거고, 0.32초를 0.22초로 만든 게 그 문법이었다. 그게 이 언어를 쓸 이유라면 이유인데, 「C보다 빠른 언어」와는 다른 문장이다.

컴파일러를 언제 자기 언어로 옮기는지는 계속 볼 생각이다. 표준 라이브러리는 이미 Mojo 로 쓰여 있고 소스도 공개돼 있다. 못 하는 게 아니라 컴파일러를 아직 안 옮긴 거다.

댓글

이 블로그의 인기 게시물

아이들은 우리 게임에 들어오지 못한다

AI 부업 강의 여섯 편이 "리스크가 제로죠"라고 말했다

AI가 썼다는 브라우저 300만 줄에서 112만 줄은 남의 코드였다