RubyGems - wardite - Versions diffs - 0.5.1 → 0.6.1 - Mend

wardite 0.5.1 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

checksums.yaml +4 -4
data/README.md +2 -2
data/Steepfile +1 -0
data/exe/wardite +11 -5
data/lib/wardite/instruction.rb +7 -9
data/lib/wardite/load.rb +14 -9
data/lib/wardite/revisitor.rb +1 -1
data/lib/wardite/value.rb +28 -23
data/lib/wardite/version.rb +1 -1
data/lib/wardite/wasi/consts.rb +129 -0
data/lib/wardite/wasi.rb +268 -7
data/lib/wardite/wasm_module.rb +53 -0
data/lib/wardite.rb +68 -40
data/misc/bench-value.rb +25 -0
data/misc/slides/fib.c +4 -0
data/misc/slides/fib.html +13 -0
data/misc/slides/image-1.png +0 -0
data/misc/slides/image-2.png +0 -0
data/misc/slides/image.png +0 -0
data/misc/slides/tokyo12.html +614 -0
data/misc/slides/tokyo12.md +624 -0
data/sig/fcntl.rbs +7 -0
data/sig/generated/wardite/leb128.rbs +1 -1
data/sig/generated/wardite/load.rbs +2 -2
data/sig/generated/wardite/value.rbs +12 -10
data/sig/generated/wardite/wasi/consts.rbs +137 -0
data/sig/generated/wardite/wasi.rbs +62 -5
data/sig/generated/wardite/wasm_module.rbs +42 -0
data/sig/generated/wardite.rbs +24 -9
metadata +16 -7
data/examples/add.wasm +0 -0

data/misc/slides/tokyo12.md ADDED Viewed

@@ -0,0 +1,624 @@
+---
+marp: true
+theme: default
+paginate: true
+backgroundColor: #fff
+header: '超入門WebAssembly（のランタイムをRubyで書く方法）'
+# footer: 'Page %page%'
+---
+# 超入門WebAssembly<br>（のランタイムをRubyで書く方法）
+---
+# 自己紹介
+- Uchio Kondo
+- @udzura
+---
+# 最近の生活
+- 趣味: VM実装になりつつある...
+---
+# mruby/edge
+- Rustで書いたmrubyランタイム（mruby 3.x のバイトコードを実行可能）
+- 基本的にmruby/cをベースにしている（一部必要な機能はmrubyから移植したい）
+---
+# Wardite
+- Rubyで書いたWebAssemblyランタイム
+---
+# 今日は Wardite の話をします
+---
+# 前提: WebAssembly とは
+---
+# WebAssembly とは
+- ブラウザで動くバイナリフォーマット
+- バイトコードをいろいろな言語（C, C++, Rust, ...）からコンパイルして、そのプログラムをブラウザの上で実行できる
+---
+# WebAssembly とは
+- ~~ブラウザで~~ いろいろなところで動くバイナリフォーマット
+---
+# WebAssembly のメリット
+- 言語を選ばずにバイナリを作れる
+- そのバイナリは、ブラウザを中心にいろいろなところで動かせる
+    - Write Once, Run Anywhere なのじゃよ...
+- 多くのランタイムで高速に動くことが期待できる
+  - （安全性等もメリットですが今日は割愛）
+---
+# さて、Wardite
+---
+# Wardite の特徴
+- Pure Ruby 製
+  - 標準添付ライブラリ以外に動作上の依存ライブラリはなし
+- Fully RBS annotated (rbs-inline)
+<!-- ちなみに標準添付ライブラリもstringioだけです。これも削っちゃおうかな？ -->
+---
+`<!--`
+# 名前の由来
+- `WA` で始まる鉱石の名前を探して、それを採用した
+- ワード石: NaAl<sub>3</sub>(PO<sub>4</sub>)<sub>2</sub>(OH)<sub>4</sub>2(H<sub>2</sub>O)
+- [Image CC BY-SA 4.0](https://en.wikipedia.org/wiki/Wardite#/media/File:Wardite.jpg)
+`-->`
+---
+# なぜ Ruby で WebAssembly ランタイムを書くのか
+- C拡張ベースの組み込みWebAssembly ランタイムなら実際結構ある
+    - Wasmtime, Wasmedge, Wasmer, ...
+- 速度面でも強みはあるでしょう...
+---
+# でも...
+- みなさん、このメッセージ好きですか？
+```
+Building native extensions. This could take a while...
+```
+---
+# cf. [wazero](https://github.com/tetratelabs/wazero)
+- Pure Go の WebAssembly ランタイム
+- cgo を避けたいGoのコミュニティで受け入れられている
+    - wazero + tinygo でGoだけのプラグイン機構があったりする
+    - https://github.com/knqyf263/go-plugin
+---
+# Pure Rubyであることのメリット
+- インストール・セットアップが簡単
+    - Rubyが動けば動く、プラットフォームに依存しにくい
+- さらに、Warditeを頑張って高速化することで色々貢献も出てきそう
+## とはいえ
+- 最初は「勉強目的」ではあった。思ったよりちゃんと動くので色んなユースケースを考えている
+---
+# demo
+---
+# こういうCのコードがあります
+```c
+/* fibonacci number in C */
+int fib(int n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}
+```
+---
+# これをWebAssemblyにコンパイルしてみましょう
+```
+$ clang --target=wasm32 \
+    --no-standard-libraries \
+    -Wl,--export-all -Wl,--no-entry \
+    -o fib.wasm \
+    fib.c
+```
+---
+# ブラウザで動かす
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+        WebAssembly.instantiateStreaming(fetch('./fib.wasm'))
+            .then(obj => {
+                alert(`fib(20) = ${obj.instance.exports.fib(20)}`);
+            });
+    </script>
+  </head>
+  <body>
+  </body>
+</html>
+```
+----
+```javascript
+// WebAssemblyをフェッチしてインスタンス化する
+WebAssembly.instantiateStreaming(
+    fetch('./fib.wasm')
+).then(obj => {
+    // obj.instance にインスタンスがあり、
+    // さっきの fib がexportされている
+    const value = obj.instance.exports.fib(20)
+    alert(`fib(20) = ${value}`);
+});
+```
+----
+![w:800](./image.png)
+----
+# 手元で動作
+```
+$ wasmtime --invoke fib fib.wasm 20
+warning: using `--invoke` with a function that takes arguments
+is experimental and may break in the future
+warning: using `--invoke` with a function that returns values
+is experimental and may break in the future
+6765
+```
+---
+# そして... Warditeでも動作
+```
+$ bundle exec wardite fib.wasm fib 20
+return value: I32(6765)
+```
+---
+# Wardite を支える技術
+---
+# 最初の実装
+- ゴリラさんの「[RustでWasm Runtimeを実装する](https://zenn.dev/skanehira/books/writing-wasm-runtime-in-rust)」を参考に実装を開始した
+- 元のコードがRustなので、強烈に型で守られたかったのと、RBS自体経験が浅いので勉強も兼ね、Full RBSを目指して移植していった
+---
+## 当時のメモを見ながら振り返ると
+- 最初はとにかくデータ構造を把握しようとした
+  - [Wasmバイナリの全体像](https://zenn.dev/skanehira/books/writing-wasm-runtime-in-rust/viewer/04_wasm_binary_structure#wasm%E3%83%90%E3%82%A4%E3%83%8A%E3%83%AA%E3%81%AE%E5%85%A8%E4%BD%93%E5%83%8F)
+- なぜかCの構造体で表現してるメモが...
+```c
+struct SectionHeader {
+    u8 code;
+    u32LEB128 size; //先頭2バイトを除いたセクションデータのバイト数
+    union {
+        u32LEB128 nr_types;
+        u32LEB128 nr_functions;
+        u32LEB128 nr_memories; // num memoriesはメモリの個数だが、
+        // version 1の仕様ではメモリは1モジュールに1つしか定義できないので、
+        // 実質的にこの値は1で固定される。
+        u32LEB128 nr_data_segments;
+        u32LEB128 nr_imports;
+        u32LEB128 nr_exports;
+    }
+}
+```
+<!-- この発表本当にRubyのコードでないなw -->
+---
+## > section sizeはLEB128[1]でエンコードされたu32
+- LEB128っち何??????
+- DWARFの中とかで使われている可変長の数値表現らしい...
+---
+## Rubyで実装しないといけないので...
+- 自分で書いた
+- 当時はまだそんなにCopilot使ってなかったんですよ...
+```ruby
+def to_i_by_uleb128(bytes)
+   dest = 0
+   bytes.each_with_index do |b, level|
+     upper, lower = (b >> 7), (b & (1 << 7) - 1)
+     dest |= lower << (7 * level)
+     if upper == 0
+       return dest
+     end
+   end
+   raise "unreachable"
+end
+to_i_by_uleb128 "\xB9\x64".unpack("C*")
+# => 12857
+```
+---
+## この辺りの情報をもとにバイナリパーサを書く
+- StringIO/File どちらも取る想定
+- バイト列を一つ一つ読み取る感じの実装になっている
+```ruby
+    # @rbs return: Integer
+    def self.preamble
+      asm = @buf.read 4
+      raise LoadError, "buffer too short" if !asm
+      raise LoadError, "invalid preamble" asm != "\u0000asm"
+      vstr = @buf.read(4)
+      version = vstr.to_enum(:chars)
+        .with_index
+        .inject(0) {|dest, (c, i)| dest | (c.ord << i*8) }
+      raise LoadError, "unsupported ver: #{version}" if version != 1
+      version
+    end # ...
+```
+---
+## 命令を把握する
+- [Wasm SpecのIndex of Instructions](https://www.w3.org/TR/wasm-core-1/#a7-index-of-instructions)
+- メモには「思ったより多くなかった」って書いてあるが、いや多いでしょ（190個ぐらい）
+---
+## [WebAssembly Opcodes Table](https://pengowray.github.io/wasm-ops/) が便利
+![w:1000](./image-1.png)
+---
+## 頑張っていた過去の自分
+- 楽しそうですね
+![w:550](./image-2.png)
+---
+## VM周りの実装
+- [Runtime Structure](https://webassembly.github.io/spec/core/exec/runtime.html#) も見ながら
+- Runtimeは以下のデータ構造を保持している
+    - Store と呼ばれるglobal stateを表現した構造体
+    - 3つのスタック
+        - Call Stack
+        - Value Stack
+        - Label Stack
+---
+## Ruby で書けばこういう感じ
+```ruby
+  class Store
+    attr_accessor :funcs #: Array[WasmFunction|ExternalFunction]
+    attr_accessor :modules #: Hash[Symbol, wasmModule]
+    attr_accessor :memories #: Array[Memory]
+    attr_accessor :globals #: Array[Global]
+    attr_accessor :tables #: Array[Table]
+    attr_accessor :elements #: Array[[Symbol, Integer, Array[Integer]]]
+    #...
+```
+```ruby
+  class Runtime
+    attr_accessor :store #: Store
+    attr_accessor :stack #: Array[wasmValue]
+    attr_accessor :call_stack #: Array[Frame]
+    attr_accessor :labels #: Array[Label]
+    #...
+```
+- 実際にはもっとごちゃついた関係になってる。整理したい...
+---
+## 命令はパースしてこういうクラスに
+```ruby
+class Op
+  attr_accessor :namespace #: Symbol -- :i32/:i64/...
+  attr_accessor :code #: Symbol
+  attr_accessor :operand #: Array[operandItem]
+  attr_accessor :meta #: Hash[Symbol, Integer]
+end
+```
+---
+## VMの命令実行部分
+- フレームに現在実行しているコード自体とその位置の情報がある
+- それを上からやっていく
+```ruby
+# @rbs return: void
+def execute!
+  loop do
+    cur_frame = self.call_stack.last #: Frame
+    if !cur_frame
+      break
+    end
+    cur_frame.pc += 1
+    insn = cur_frame.body[cur_frame.pc]
+    if !insn
+      break
+    end
+    eval_insn(cur_frame, insn)
+  end
+end
+```
+----
+## VM名物でっかいcase文
+```ruby
+# @rbs frame: Frame
+# @rbs insn: Op
+# @rbs return: void
+def eval_insn(frame, insn)
+  # unmached namespace...
+  case insn.code
+  when :unreachable
+    raise Unreachable, "unreachable op"
+  when :nop
+    return
+  when :br
+    level = insn.operand[0]
+    pc = do_branch(frame.labels, stack, level)
+    frame.pc = pc
+    #...
+```
+---
+## ところで
+- i32/i64,f32/f64で共通の処理が多い
+- Generatorでまとめて作るようにした
+```ruby
+when :i32_add
+  right, left = runtime.stack.pop, runtime.stack.pop
+  if !right.is_a?(I32) || !left.is_a?(I32)
+    raise EvalError, "maybe empty or invalid stack"
+  end
+  runtime.stack.push(I32(left.value + right.value))
+# ...
+when :i64_add
+  right, left = runtime.stack.pop, runtime.stack.pop
+  if !right.is_a?(I64) || !left.is_a?(I64)
+    raise EvalError, "maybe empty or invalid stack"
+  end
+  runtime.stack.push(I64(left.value + right.value))
+```
+---
+## こういうDSLで生成するようにした
+```ruby
+task :generate do
+  GenAlu.execute(libdir + "/wardite/alu_i32.generated.rb", prefix: "i32", defined_ops: [
+    :load,
+    :load8_s,
+    :load8_u,
+    :load16_s,
+    :load16_u,
+    :store,
+    :store8,
+    :store16,
+    :const,
+    :eqz,
+    :eq,
+    :ne,
+    :lts,
+    # ...
+    :rotr,
+  ])
+```
+- あとは `rake generate`
+---
+## なぜコード生成？
+- メタプログラミングは今回はやめとこかと思った
+  - 命令はすごい数そのパスを通るので、パフォーマンス面の心配
+  - RBS/rbs-inline と相性が悪そうな予感(杞憂かもだが)
+<!-- GoとRustを結構書いてきたので、別に生成すれば良くね？って自然な気持ちで思ったのが大きいかな... -->
+---
+## 関数を呼ぶときの命令の解説
+- 関数インスタンスを取り出してフレームをプッシュする
+```ruby
+when :call
+  idx = insn.operand[0]
+  fn = self.instance.store.funcs[idx]
+  case fn
+  when WasmFunction
+    push_frame(fn)
+  # ... call external
+  else
+    raise GenericError, "got a non-function pointer"
+  end
+```
+---
+## フレームをプッシュするコード
+- 初期変数（引数＋コードで使う変数）をフレームに積む
+- pcを -1 に初期化
+- フレームをコールスタックに積む
+```ruby
+def push_frame(wasm_function)
+  local_start = stack.size - wasm_function.callsig.size
+  locals = stack[local_start..]
+  self.stack = drained_stack(local_start)
+  locals.concat(wasm_function.default_locals)
+  arity = wasm_function.retsig.size
+  frame = Frame.new(-1, stack.size, wasm_function.body, arity, locals)
+  self.call_stack.push(frame)
+end
+```
+---
+## returnする時
+- stackを巻き戻します
+```ruby
+def stack_unwind(sp, arity)
+  if arity > 0
+    if arity > 1
+      raise ::NotImplementedError, "return artiy >= 2 not yet supported ;;"
+    end
+    value = stack.pop
+    self.stack = stack[0...sp]
+    stack.push value
+  else
+    self.stack = stack[0...sp]
+  end
+end
+```
+---
+# WASI
+---
+## > WASI（WebAssembly System Interface）とは何であるのかについて理解が深まる話をします
+- ...やばい！時間がなくてあんまできない！
+- と言ってもWASIはシンプルだと思う
+  - 基本的にはWASM Moduleにインポートする関数群
+  - Rubyのような言語でWASIに対応した関数を書く場合
+  - 本当にシンプルに、OS側のシステムコールに対応させるだけ
+    - 簡単とは言ってないよ！量が多いし！
+- ちなみにpreview1/preview2というのがあるが
+  - p2はComponent向け。まず基本p1を実装中
+---
+## WASI (p1) 周り
+- ただのimport moduleなのでまずその仕組みを作った
+- あとはこういう関数を地道に実装するだけやで...
+```ruby
+class WasiSnapshotPreview1
+  # @rbs store: Store
+  # @rbs args: Array[wasmValue]
+  # @rbs return: Object
+  def random_get(store, args)
+    buf, buflen = args[0].value, args[1].value
+    randoms = SecureRandom.random_bytes(buflen) #: String
+    store.memories[0].data[buf...(buf+buflen)] = randoms
+    0
+  end
+end
+```
+- ちなみに、hello worldだけなら `fd_write` のみでいける
+---
+# という感じで地道に実装中
+---
+# 他、話していないこと
+- WASM specに対応したテスト実行の仕方
+    - [ブログに少し書いた](https://udzura.hatenablog.jp/entry/2024/11/24/210124)
+    - 超カバレッジ低い、i32系だけ。
+- パフォーマンスチューニング
+    - [ブログ書いた](https://udzura.hatenablog.jp/entry/2024/12/20/173728)
+---
+# 今後の展望
+- WASI、specカバレッジ、パフォチューを地道に
+- `ruby.wasm` を動かしたいぞん
+    - ひとまずWASIサポート関数を増やすなど頑張りが必要
+    - 速度は... 我慢で対応(?)
+- Component も読めるようにしたい
+    - 簡単なものならまあ...
+- もちろん、松山でWarditeの話をしたいですね
+    - mruby/edgeか、どちらかをね。

data/sig/fcntl.rbs ADDED Viewed

@@ -0,0 +1,7 @@
+# No fcntl RBS file by default
+module Fcntl
+  O_APPEND: Integer
+  O_NONBLOCK: Integer
+  F_GETFL: Integer
+  F_SETFL: Integer
+end

data/sig/generated/wardite/leb128.rbs CHANGED Viewed

@@ -6,7 +6,7 @@ module Wardite
     # @rbs buf: File|StringIO
     # @rbs max_level: Integer
     # @rbs return: Integer
-    def fetch_uleb128: (File | StringIO buf, ?max_level: Integer) -> Integer
+    def self?.fetch_uleb128: (File | StringIO buf, ?max_level: Integer) -> Integer
     # @rbs buf: File|StringIO
     # @rbs return: Integer

data/sig/generated/wardite/load.rbs CHANGED Viewed

@@ -173,10 +173,10 @@ module Wardite
     self.@buf: File | StringIO
     # @rbs buf: File|StringIO
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    # @rbs import_object: Hash[Symbol, wasmModuleSrc]
     # @rbs enable_wasi: boolish
     # @rbs return: Instance
-    def self.load_from_buffer: (File | StringIO buf, ?import_object: Hash[Symbol, Hash[Symbol, wasmCallable]], ?enable_wasi: boolish) -> Instance
+    def self.load_from_buffer: (File | StringIO buf, ?import_object: Hash[Symbol, wasmModuleSrc], ?enable_wasi: boolish) -> Instance
     # @rbs return: Integer
     def self.preamble: () -> Integer

data/sig/generated/wardite/value.rbs CHANGED Viewed

@@ -19,16 +19,6 @@ module Wardite
     # @rbs value: Float
     # @rbs return: F64
     def F64: (Float value) -> F64
-    private
-    # @rbs value: Integer
-    # @rbs return: Integer
-    def as_u32: (Integer value) -> Integer
-    # @rbs value: Integer
-    # @rbs return: Integer
-    def as_u64: (Integer value) -> Integer
   end
   extend ValueHelper
@@ -42,6 +32,15 @@ module Wardite
     # when we want to access signed value, it'd be done via #value_s
     attr_accessor value: Integer
+    @@i32_object_pool: Hash[Integer, I32]
+    # @rbs value: Integer
+    # @rbs return: I32
+    def self.cached_or_initialize: (Integer value) -> I32
+    # @rbs value: Integer
+    def initialize: (?Integer value) -> untyped
     # @rbs str: String
     # @rbs size: Integer|nil
     # @rbs signed: bool
@@ -126,6 +125,9 @@ module Wardite
     attr_accessor value: Integer
+    # @rbs value: Integer
+    def initialize: (?Integer value) -> untyped
     # @rbs str: String
     # @rbs size: Integer|nil
     # @rbs signed: bool