Compiler on κeenのHappy Hacκing Blog

コンパイル時に定数を処理してしまうアレ

Sun, 22 Aug 2021 13:23:58 +0900

κeenです。コンパイル時に定数を処理する最適化技法あるじゃないですか。あれの名称がイマイチはっきりしないのでモヤモヤするなーという記事です。

自作コンパイラをブラウザ上で動かす

Mon, 30 Nov 2020 01:47:29 +0900

このエントリは言語実装 Advent Calendar 2020の1日目の記事です。次はsisshiki1969さんで「RustでつくるRuby、その後の進捗」です。

κeenです。昔からちまちま作ってるSML処理系をブラウザ上で動かすことができたのでその進捗報告です。

最小限のELF

Sun, 12 Apr 2020 17:30:06 +0900

κeenです。先日の記事で言及した最小限のELFが需要ありそうだったので解説してみます。コンパイラを作るときの参考にしてみて下さい

タネ明かし: Whitespaceコンパイラを作った話の裏側

Wed, 01 Apr 2020 21:25:03 +0900

κeenです。今朝、エイプリルフールのネタ記事を書いたのでそのタネ明かしをします。タネとはいっても、ほぼ手書きなんですけどね。

Whitespaceのセルフホストコンパイラ作ったよ！

Wed, 01 Apr 2020 00:00:00 +0900

ハ〜イ、κeenさんだよー。Whitespaceのセルフホストコンパイラを作ったから紹介するねー。

WebAssemblyとABI

Sat, 10 Nov 2018 00:49:26 +0900

# WebAssemblyとABI
----------------------
[コンパイラ勉強会 - connpass](https://connpass.com/event/103976/)

===
# About Me
---------
![κeenのアイコン](/images/kappa.png)

* κeen
 * [@blackenedgold](https://twitter.com/blackenedgold)
 * Github: [KeenS](https://github.com/KeenS)
 * [Idein Inc.](https://idein.jp/)のエンジニア
 * Lisp, ML, Rust, Shell Scriptあたりを書きます

===

# WebAssmblyとは
----------------

* Webブラウザで動く
* アセンブリ
* ではない

===
# WASMの動作環境
------------------------

* ブラウザ
* NodeJS
* [CommonWA](https://github.com/CommonWA/cwa-spec)
* [losfair/IceCore](https://github.com/losfair/IceCore) : Build efficient and reliable backend applications in WebAssembly.
* [Introducing Wasmjit: A kernel mode WebAssembly runtime for Linux | Packt Hub](https://hub.packtpub.com/introducing-wasmjit-a-kernel-mode-webassembly-runtime-for-linux/)
* [piranna/wasmachine: Put WebAssembly in your washing machine](https://github.com/piranna/wasmachine)

===

# 言語としてのWASM
-----------------

* アセンブラっぽい雰囲気
* スタックマシン
* 無限のレジスタ(変数)とスタックがある
* コードの単位は関数
* 上位にモジュールがある
* モジュール毎に1仮想マシン(インスタンス)

===

# コード例1
-----------

```webassembly
(module
  (func $add (param $lhs i32) (param $rhs i32) (result i32)
    get_local $lhs
    get_local $rhs
    i32.add)
  (export "add" (func $add)))
```

===

# コード例2
-----------

``` webassembly
(func $sum1 (param $n i32) (result i32) (local $sum i32) (local $i i32)
  block $break
    loop $loop
      get_local $i
      get_local $n
      i32.ge_s
      br_if $break
      get_local $sum
      get_local $i
      i32.add
      set_local $sum
      get_local $i
      i32.const 1
      i32.add
      set_local $i
      br $loop
    end
  end
  get_local $sum
  return)
```

===
# コード例3
------------

``` webassembly
(func $sum2 (param $n i32) (result i32) (local $sum i32) (local $i i32)
  (block $break
    (loop $loop
      (br_if $break (i32.ge_s (get_local $i) (get_local $n)))
      (set_local $sum (i32.add (get_local $sum) (get_local $i)))
      (set_local $i (i32.add (get_local $i) (i32.const 1)))
      (br $loop)))
  (return (get_local $sum)))
```

===

# WASM詳細
-----------

* 型は4つ (`i32`, `i64`, `f32`, `f64`)
* モジュールに色々ついてくる
  * メモリ
  * 関数import/export
  * グローバル変数
* インスタンスの情報はJS側から色々アクセスできる

===
# import/export
----------------

``` webassembly
(module
  (type $alert_type (func (param i32)))
  (import "module" "alert" (func $alert (type $alert_type)))
  (func $add (param $lhs i32) (param $rhs i32) (result i32)
    get_local $lhs
    get_local $rhs
    i32.add)
  (func $run
    (call $alert (call $add (i32.const 1) (i32.const 2))))
  (export "run" (func $run)))
```

===
# import/export
----------------

``` webassembly
fetch('../out/main.wasm').then(response =>
  response.arrayBuffer()
).then(bytes =>
   WebAssembly.instantiate(bytes, {"module": {"alert": alert}})
).then(results => {
  instance = results.instance;
  instance.exports.run();
}).catch(console.error);
```

===
# メモリのexport
----------------

``` webassembly
(module
  (memory $mem 10)
  (export "memory" (memory $mem)))
```

``` javascript
// メモリを直接いじれる
instance.exports.memory.buffer

```

===
# 本題
------

* この仕様でJS-WASM間のABIどうしたらいい？
  + 型は4種類の即値のみ
  + メモリは触れる
===

# 答え
------

* Rustが既に実装している
* [Rust and WebAssembly](https://github.com/rustwasm)
* 以後追っていく

===
# JS -> Rust
-------------

* Rustでメモリを確保してJSが渡す

===
# JS -> Rust
-------------

``` webassembly
#[wasm_bindgen]
fn greet(name: &str) {
  alert(&format!("hello, {}!", name))
}
```

===
# JS -> Rust
-------------

``` webassembly
function passStringToWasm(arg) {
    const buf = cachedTextEncoder.encode(arg);
    const ptr = wasm.__wbindgen_malloc(buf.length);
    getUint8Memory().set(buf, ptr);
    return [ptr, buf.length];
}
```

===
# JS -> Rust
-------------

``` webassembly
export function greet(arg0) {
    const [ptr0, len0] = passStringToWasm(arg0);
    try {
        return wasm.greet(ptr0, len0);

} finally {
        wasm.__wbindgen_free(ptr0, len0 * 1);

}

}
```

===
# Rust -> JS
------------

* 可能ならポインタのまま渡す
* 不可能なら指定されたメモリに書き込む

===

# Rust -> JS
------------
ポインタ

``` rust
#[wasm_bindgen]
impl Universe {
    pub fn new() -> Universe {
        // ...
    }
}
```

===
# Rust -> JS
------------
ポインタ

``` javascript
export class Universe {
    static __wrap(ptr) {
        const obj = Object.create(Universe.prototype);
        obj.ptr = ptr;

return obj;
    }

free() {
        const ptr = this.ptr;
        this.ptr = 0;
        freeUniverse(ptr);
    }

/**
    * @returns {Universe}
    */
    static new() {
        return Universe.__wrap(wasm.universe_new());
    }
}
```

===
# Rust ->  JS
--------
メモリ

``` rust
#[wasm_bindgen]
impl Universe {
    pub fn render(&self) -> String {
        self.to_string()
    }
}

```

===
# Rust -> JS
--------
メモリ

``` javascript

export class Universe {
    render() {
        const retptr = globalArgumentPtr();
        wasm.universe_render(retptr, this.ptr);
        const mem = getUint32Memory();
        const rustptr = mem[retptr / 4];
        const rustlen = mem[retptr / 4 + 1];

const realRet = getStringFromWasm(rustptr, rustlen).slice();
        wasm.__wbindgen_free(rustptr, rustlen * 1);
        return realRet;

}
}
```
===
# メモリ
------------
メモリ

``` javascript
let cachedGlobalArgumentPtr = null;
function globalArgumentPtr() {
    if (cachedGlobalArgumentPtr === null) {
        cachedGlobalArgumentPtr = wasm.__wbindgen_global_argument_ptr();
    }
    return cachedGlobalArgumentPtr;
}
```

===
# Rust -> JS
--------
メモリ

``` text
JS     retprt
            |      rustptr
----        |      |            データ
            v      v            v
WASM  [...|   |...|ptr|size|...|   |...]
           |       ^ |          ^
           +-------+ +----------+
```

===
# まとめ
---------

* WebAssemblyというWebとは限らないアセンブリでないものがあるよ
* シンプルな仕様だよ
* 任意のコンパイラ - JS連携できるよ
* RustからJSオブジェクトを扱う話はしてないよ

Inside Pattern Matchings

Sun, 16 Sep 2018 01:26:15 +0900

ML Day #2 での発表用。パターンマッチの実装について

WebAssemblyとコンパイラとランタイム

Thu, 16 Feb 2017 15:46:21 +0900

# WebAssemblyとコンパイラとランタイム
----------------------
[emscripten night !! #3 - connpass](https://emsn.connpass.com/event/48100/)

===
# About Me
---------
![κeenのアイコン](/images/kappa.png)

===
# 何の話
---------

* WebAssemblyをバックエンドに使う言語を作りたい
* [KeenS/webml: An ML like toy language compiler](https://github.com/KeenS/webml)
* 既に発表したものの補足記事的な
  + [コンパイラの人からみたWebAssembly | κeenのHappy Hacκing Blog](https://keens.github.io/slide/konpairanoninkaramitaWebAssembly/)
  + ある程度再度説明します

===
# アジェンダ
------------

* なぜWebAssembly
* コンパイラ
* コード生成
* ランタイム

===

# なぜWebAssembly

===
# なぜWebAssembly
----------------

* なんかバイナリでテンション上がる
* ポータブルでコンパクトで速い
* 機能的にJSを越えるかもしれない…？
* コンパイラがブラウザで動くと言語導入のハードル下がる
  + 気軽に試せる
  + コンパイラだけでなく吐いたコードもブラウザで動かしたい

===
# WASM over LLVM
----------------

* 既存のJS環境と協調する
  + JSとの相互呼び出しとか
* **non-determinismが少ない**
* 細かいアラインメント考える必要がない
* **API安定しそう**

===

# WASM over asm.js
--------------------

* ブラウザ以外への組込みもサポート
  + Node.jsとか
  + **JITエンジンに使えそう**
* プラットフォーム
* 実行までのレイテンシが短かい
* asm.jsより速度を出しやすい設計
* テキストフォーマットで生成コードの文法エラーが怖い
* 将来機能が増えるかも

===
# WebAssemblyの現状
-------------------

* Minimum Viable Product(MVP)
* 機能を削ってとりあえず動くものを作ってる
* 今はC/C++からLLVMを通して吐けるのが目標
  + C/C++には不要でも自分の言語に欲しい機能は……
* 今後SIMDとかスレッドとかDOM APIとか増えていく

===

# コンパイラ

===
# WASM概要
----------

* WASMには以下がある
  + 関数
    - 関数内ローカル変数
  + リニアメモリ
  + グローバル変数
  + テーブル
  + importテーブル
  + exportテーブル

===
# WASM実行モデル
--------------

* i32,i64,f32,f64のみ
* **スタックマシン**
  + 命令のオペランドや関数の引数はスタック経由で渡す
  + 1 passのコード生成が楽そう
* 無限のローカル変数が使える
  + 型がある
* 関数の引数はローカル変数経由で渡される
* コントロールフローはgotoじゃなくてstructured
  + 静的検証がしやすいらしい
  + 安全だけどコンパイラ的には…

===

# コントロールフロー
-------------------

* `loop` + `br` (名前付き)
* `block` + `br` (名前付き)
* `br_if` or `br_table`
* `if` + `else` + `end`
* `return`
* 等

===

# コントロールフロー
-------------------

* gotoがない
  + `br` はブランチじゃなくてブレイク
* gotoからstructuredに[変換出来る](https://github.com/kripken/emscripten/blob/master/docs/paper.pdf)
    + loop, block, br, br_ifを使う
* 高級言語から変換するなら `if` を使う
  + ifが2系統あることになる

===
# サンプル
---------

``` javascript
function geometricMean(start, end) {
  start = start|0; // start has type int
  end = end|0;     // end has type int
  return +exp(+logSum(start, end) / +((end - start)|0));
}
...
```

===
# サンプル
---------

```wasm
(module
  (type (;0;) (func (param i64 i64) (result f64)))
  (type (;1;) (func (param i64 i64) (result f64)))
  (type (;2;) (func (param f64) (result f64)))
  (func (;0;) (type 0) (param i64 i64) (result f64)
    (get_local 0)
    (get_local 1)
    (call 1)
    (get_local 1)
    (get_local 0)
    (i64.sub)
    (f64.convert_s/i64)
    (f64.div)
    (call 2))
  ...)
```

===
# サンプル
---------

```wasm
(module
  (type (;0;) (func (param i64 i64) (result f64)))
  (type (;1;) (func (param i64 i64) (result f64)))
  (type (;2;) (func (param f64) (result f64)))
  (func (;0;) (type 0) (param i64 i64) (result f64)
    (call 2
      (f64.div
       (call 1 (get_local 0) (get_local 1))
       (f64.convert_s/i64
        (i64.sub
         (get_local 1)
         (get_local 0))))))
  ...)
```

===

# WebMLコンパイラ
------------

* パーサ、AST、HIR、MIR、LIR
* LIRがRTLなのでそれをWASMに変換したい
* gotoからstructured control flow…

===

===

# 変数
------

* LIRはレジスタで計算する
* LIRはCFG由来の大量の変数を使う
  + レジスタ割り当ては一旦置いとく
* WASMはスタックで計算する
* どうコード生成すると最適か？

===

```
fun main: () -> i64 = {
    entry@0:
        r0: i64 <- 1
        r1: i32 <- 0
        r2: i64 <- 1
        r3: i64 <- 2
        r4: i64 <- 3
        r5: i64 <- r3 * r4
        r6: i64 <- 4
        r7: i64 <- r5 + r6
        r8: i64 <- r2 + r7
        r9: i64 <- 1
        r10: i64 <- 2
        r11: i64 <- r9 + r10
        r12: i64 <- 3
        r13: i64 <- r11 * r12
        r14: i64 <- 4
        r15: i64 <- r13 + r14
        r16: i32 <- 1
        jump_if_zero r16 then@1
        jump else@2
    then@1:
        r17: i64 <- r8
        jump join@3
    else@2:
        r17: i64 <- r15
        jump join@3
    join@3:
        r18: i64 <- 1
        r19: i64 <- r18 + r15
        r20: i64 <- 1
        r21: i64 <- call d@9(r20, )
        r22: i64 <- 2
        r23: i64 <- call #g37(r22, )
        r24: i64 <- 1
        r25: i64 <- heapalloc(16)
        [r25+0] <- <anonfun>@11
        [r25+8] <- r24
        r26: i64 <- 0
        ret r26
}
```

===

# 変数割り当て
--------------

* SSAの1変数 = WASMの1ローカル変数
* スタックの効率利用を完全に無視
* 計算はLV→スタック→LVに書き戻し
* どうせスタックもLVもレジスタ扱いにしてレジスタ割り当てされるでしょ
* （測ってないけど）多分速度は変わらない

===

# CFG
-----

* コンパイラが一旦gotoを使うコントロールフローグラフを作る
* WASMにはgotoがない
* どうやったら生成出来るか？
* そもそも生成出来るの？

===

# blockと前方ジャンプ
------------

* `block` + `break` で前方ジャンプ
* 閉じ括弧の位置にジャンプ
* `block` の位置は自由

===

<pre>
<code>
(<span class='hljs-keyword'>block</span>
  ...
  (<span class='hljs-keyword'>br</span> 0)--+
  ...     |
  )<------+
</code>
</pre>
<p>===</p>
</article>
<article>
<h1>コンパイラの人からみたWebAssembly</h1>
<p>Sun, 22 Jan 2017 13:35:46 +0900</p>
コンパイラ勉強会での発表用
</article>
</main></body></html>