wardite 0.5.1 → 0.6.0

data/lib/wardite/wasm_module.rb

@@ -0,0 +1,53 @@
+# rbs_inline: enabled
+
+module Wardite
+  # @rbs!
+  #   interface _WasmCallable
+  #     def call: (Store, Array[wasmValue]) -> wasmFuncReturn
+  #     def []: (Store, Array[wasmValue]) -> wasmFuncReturn
+  #   end
+
+  # @rbs!
+  #   type wasmModuleSrc = Hash[Symbol, _WasmCallable] | WasmModule | HashModule
+  #   type wasmModule    = WasmModule | HashModule
+
+  module WasmModule
+    # @rbs fnname: Symbol
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: wasmFuncReturn
+    def invoke(fnname, store, *args)
+      self.__send__(fnname, store, args)
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs return: _WasmCallable
+    def callable(fnname)
+      self.method(fnname)
+    end
+  end
+
+  class HashModule
+    attr_accessor :hash #: Hash[Symbol, _WasmCallable]
+
+    # @rbs ha: Hash[Symbol, _WasmCallable]
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: wasmFuncReturn
+    def invoke(fnname, store, *args)
+      fn = self.hash[fnname.to_sym]
+      fn.call(store, args)
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs return: _WasmCallable
+    def callable(fnname)
+      self.hash[fnname.to_sym]
+    end
+  end
+end

data/lib/wardite.rb

@@ -20,8 +20,6 @@ require_relative "wardite/alu_f32.generated"
 require_relative "wardite/alu_f64.generated"
 require_relative "wardite/convert.generated"
 
-require_relative "wardite/wasi"
-
 require "stringio"
 
 module Wardite
@@ -38,13 +36,23 @@ module Wardite
 
     attr_accessor :exports #: Exports
 
-    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    attr_reader :import_object #: Hash[Symbol, wasmModule]
+
+    attr_accessor :wasi #: WasiSnapshotPreview1?
 
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    # @rbs import_object: Hash[Symbol, wasmModuleSrc]
     # @rbs &blk: (Instance) -> void
     def initialize(import_object, &blk)
+      @wasi = nil
+
       blk.call(self)
-      @import_object = import_object
+      import_object.each_pair do |k, v|
+        if v.is_a?(Hash)
+          import_object[k] = HashModule.new(v)
+        end
+      end
+
+      @import_object = import_object #: Hash[Symbol, wasmModule]
 
       @store = Store.new(self)
       @exports = Exports.new(self.export_section, store)
@@ -281,7 +289,8 @@ module Wardite
 
       case fn
       when WasmFunction
-        invoke_internal(fn)
+        r = invoke_internal(fn)
+        r
       when ExternalFunction
         invoke_external(fn)
       else
@@ -313,25 +322,7 @@ module Wardite
         raise LoadError, "stack too short"
       end
       self.stack = drained_stack(local_start)
-
-      wasm_function.locals_count.each_with_index do |count, i|
-        typ = wasm_function.locals_type[i]
-        count.times do
-          case typ
-          when :i32, :u32
-            locals.push I32(0)
-          when :i64, :u64
-            locals.push I64(0)
-          when :f32
-            locals.push F32(0.0)
-          when :f64
-            locals.push F64(0.0)
-          else
-            $stderr.puts "warning: unknown type #{typ.inspect}. default to I32"
-            locals.push I32(0)
-          end
-        end
-      end
+      locals.concat(wasm_function.default_locals)
 
       arity = wasm_function.retsig.size
       frame = Frame.new(-1, stack.size, wasm_function.body, arity, locals)
@@ -888,7 +879,7 @@ module Wardite
   class Store
     attr_accessor :funcs #: Array[WasmFunction|ExternalFunction]
 
-    # FIXME: attr_accessor :modules
+    attr_accessor :modules #: Hash[Symbol, wasmModule]
 
     attr_accessor :memories #: Array[Memory]
 
@@ -907,21 +898,19 @@ module Wardite
 
       import_section = inst.import_section
       @funcs = []
+      @modules = inst.import_object
 
       if type_section && func_section && code_section
         import_section.imports.each do |desc|
           callsig = type_section.defined_types[desc.sig_index]
           retsig = type_section.defined_results[desc.sig_index]
-          imported_module = inst.import_object[desc.module_name.to_sym]
-          if !imported_module
+          target_module = self.modules[desc.module_name.to_sym]
+          if target_module.nil?
             raise ::NameError, "module #{desc.module_name} not found"
           end
-          imported_proc = imported_module[desc.name.to_sym]
-          if !imported_proc
-            raise ::NameError, "function #{desc.module_name}.#{desc.name} not found"
-          end
+          target_name = desc.name.to_sym
           
-          ext_function = ExternalFunction.new(callsig, retsig, imported_proc)
+          ext_function = ExternalFunction.new(target_module, target_name, callsig, retsig)
           self.funcs << ext_function
         end
 
@@ -1213,7 +1202,10 @@ module Wardite
   end
 
   # TODO: common interface btw. WasmFunction and ExternalFunction?
+  #       may be _WasmCallable?
   class WasmFunction
+    include ValueHelper
+
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
@@ -1222,6 +1214,8 @@ module Wardite
 
     attr_accessor :findex #: Integer
 
+    attr_accessor :default_locals #: Array[wasmValue]
+
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
     # @rbs code_body: CodeSection::CodeBody
@@ -1232,6 +1226,7 @@ module Wardite
 
       @code_body = code_body
       @findex = 0 # for debug
+      @default_locals = construct_default_locals
     end
 
     # @rbs return: Array[Op]
@@ -1249,6 +1244,30 @@ module Wardite
       code_body.locals_count
     end
 
+    # @rbs return: Array[wasmValue]
+    def construct_default_locals
+      locals = [] #: Array[wasmValue]
+      locals_count.each_with_index do |count, i|
+        typ = locals_type[i]
+        count.times do
+          case typ
+          when :i32, :u32
+            locals.push I32(0)
+          when :i64, :u64
+            locals.push I64(0)
+          when :f32
+            locals.push F32(0.0)
+          when :f64
+            locals.push F64(0.0)
+          else
+            $stderr.puts "warning: unknown type #{typ.inspect}. default to I32"
+            locals.push I32(0)
+          end
+        end
+      end
+      locals
+    end
+
     # @rbs override_type: Type?
     # @rbs return: WasmFunction
     def clone(override_type: nil)
@@ -1263,23 +1282,32 @@ module Wardite
 
   # @rbs!
   #   type wasmFuncReturn = Object|nil
-  #   type wasmCallable = ^(Store, Array[wasmValue]) -> wasmFuncReturn
 
   class ExternalFunction
+    attr_accessor :target_module #: wasmModule
+
+    attr_accessor :name #: Symbol
+
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
 
-    attr_accessor :callable #: wasmCallable
+    #attr_accessor :callable #: _WasmCallable
 
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
-    # @rbs callable: wasmCallable
+    # @rbs callable: _WasmCallable
     # @rbs return: void
-    def initialize(callsig, retsig, callable)
+    def initialize(target_module, name, callsig, retsig)
+      @target_module = target_module
+      @name = name
       @callsig = callsig
       @retsig = retsig
-      @callable = callable
+    end
+
+    # @rbs return: _WasmCallable
+    def callable()
+      target_module.callable(self.name)
     end
 
     # @rbs override_type: Type?
@@ -1287,9 +1315,9 @@ module Wardite
     def clone(override_type: nil)
       if override_type
         # callable is assumed to be frozen, so we can copy its ref
-        ExternalFunction.new(override_type.callsig, override_type.retsig, callable)
+        ExternalFunction.new(target_module, name, override_type.callsig, override_type.retsig)
       else
-        ExternalFunction.new(callsig, retsig, callable)
+        ExternalFunction.new(target_module, name, callsig, retsig)
       end
     end
   end

data/misc/proposals/rubykaigi2025.md

@@ -0,0 +1,46 @@
+# RubyKaigi 2025 Proposal
+
+## title:
+
+Implementing WASM Runtime in Ruby - ruby.wasm works on Ruby?
+
+## Abstract
+
+<!--
+
+Create an abstract of talk in English, following below:
+
+- 作者はWarditeというRubyのWASMランタイムを開発した
+- WarditeはPure Rubyで、RBSに完全対応している
+- Warditeでruby.wasmを動かすことをマイルストーンにしており、その取り組みについて報告する。
+- 例えば、WASI preview 1 対応、パフォーマンス改善など。
+
+-->
+
+The author has developed a WASM runtime named Wardite, which is implemented entirely in pure Ruby and fully annotated by RBS. The primary milestone for Wardite is to successfully run ruby.wasm. This presentation will dive deeply into the various efforts and challenges encountered in reaching this milestone. Key topics will include the implementation of support for WASI preview 1, performance enhancements, and other technical advancements. Attendees will gain insights into the current status of Wardite, its architecture, and the approaches taken to eficciently implement WebAssembly runtime in Ruby. The talk aims to provide a comprehensive overview of the progress made so far and the future directions for Wardite, highlighting its potential impact on the Ruby and WebAssembly ecosystems.
+
+## Details
+
+現在、以下のような内容を考えています
+
+- なぜ、Warditeを作ったか？
+    - Pure Rubyであることのメリット
+    - cf. wazero in Go
+- 簡単なWarditeの紹介
+    - 動作のデモ
+- Warditeの実装
+    - WASM Core 1.0を動かすために必要な仕様の解説
+        - 簡単な内部設計
+        - 命令の概要
+    - RBSによる型情報の利用
+- Wardite開発上の技術的チャレンジ
+    - パフォーマンス改善の取り組み
+        - 基本的な計測（ruby-prof、perf）
+        - オブジェクト生成の低減・最適化
+- Warditeでruby.wasmを動かすための取り組み
+    - WASI preview 1 対応
+- 今後の展望
+    - 更なるパフォーマンス改善
+    - Component 対応
+
+## Pitch

data/misc/slides/fib.c

@@ -0,0 +1,4 @@
+int fib(int n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}

data/misc/slides/fib.html

@@ -0,0 +1,13 @@
+<!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>