wasmtime 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 278e090fef9ae4f35850cc892273ddbe94b2b838b0fc619ca835a17505129957
-  data.tar.gz: fbafd3a60ace1ec5f4806ac94d86e73264feb16e5b4f781c09ad9927c070758e
+  metadata.gz: 51b9d23eb473612cd8d79f307021bdcf6ccbce2c1e522996af1bf3c1ebb85c1a
+  data.tar.gz: cde5dc2a81f5cc73a4e8abd70268d1e9322bad3093cf7ce8f1d3d13fa44aafda
 SHA512:
-  metadata.gz: '016450946bf0d7ee92ffbc44bdc1be90a83602a14a209e3c24e7cc438883845b0b19aa173288169beb5248a080205c8b1d9abe46b373868b72e5caed3e5831bb'
-  data.tar.gz: 8dda113d2501e84a1222dd5ccbc1683cc84490d30628f98f489c681db4e2712d0aa24d65261ae0f223377602d74293472e56166d6aae55d9253bebc78ce1d17d
+  metadata.gz: e5a78a30dd600e7c9618c2c0612b5d657d3002e027e826375522455762756b56f4606b433b94070a0227ceb2319321752744d6c86ce613bda672bc3e067c5423
+  data.tar.gz: 301fbc2e124b4653b957cee6e260408a5cefed5743da6bc7327f7a7d153f29f2ba63ddf331cb93da0fbb16f593cdd7f4b555dfae6b242e7c97bc2067b50ffa88

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2020-05-19
+
+- Exported functions now live on `Wasmtime::Instance#exports` instead of `#funcs`.
+- Exports hash is now keyed by strings instead of symbols.
+- Added support for `Wasmtime::Memory` exports with `#data_size`, `#size` and `#grow` methods.
+
 ## [0.1.0] - 2020-05-07
 
 ### Added
@@ -16,5 +22,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for 32 and 64-bit integers and floats in arguments and as return values.
 - Require patch for defining a Ruby module with functions for each export.
 
-[unreleased]: https://github.com/dtcristo/wasmtime-ruby/compare/v0.1.0...HEAD
+[unreleased]: https://github.com/dtcristo/wasmtime-ruby/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/dtcristo/wasmtime-ruby/releases/tag/v0.2.0
 [0.1.0]: https://github.com/dtcristo/wasmtime-ruby/releases/tag/v0.1.0

data/README.md

@@ -2,7 +2,7 @@
   <h1>wasmtime-ruby</h1>
   <p>
     <strong>
-      <a href="https://github.com/bytecodealliance/wasmtime">Wasmtime</a> WebAssembly runtime in Ruby
+      Ruby bindings for <a href="https://github.com/bytecodealliance/wasmtime">Wasmtime</a>, a WebAssembly runtime
     </strong>
   </p>
   <p>
@@ -17,13 +17,10 @@
 
 ## Introduction
 
-This gem allows you to use the [Wasmtime](https://wasmtime.dev/) WebAssembly
-runtime from within your Ruby project.
-
-Why would you want that? [WebAssembly](https://webassembly.org/) (or WASM) is a
-technology that allows you to write programs that run at near-native speeds in a
-safe sandboxed environment. Wasmtime is a runtime for WASM programs. This gem
-embedds Wasmtime in a native extension so you can now run WASM from Ruby.
+This project provides Ruby bindings for [Wasmtime](https://github.com/bytecodealliance/wasmtime),
+a [WebAssembly](https://webassembly.org/) runtime. This allows you to execute
+WASM modules from within Ruby executing at near-native speeds in a safe
+sandboxed environment.
 
 This is pretty experimental and not production ready right now. There are quite
 a few things that aren't built yet, see [TODO](#todo) section below.
@@ -42,7 +39,7 @@ Install the `wasmtime` gem. Pre-compiled binaries are available for
 gem install wasmtime
 ```
 
-WASM has two formats `*.wasm` (binary) and `*.wat` (human-readable text). Both
+WASM has two formats `.wasm` (binary) and `.wat` (human-readable text). Both
 formats are supported. With the following `fibonacci.wat` file in your current
 directory.
 
@@ -65,7 +62,7 @@ directory.
 ```
 
 In a ruby file, `require 'wasmtime/require'` to activate the Wasmtime require
-patch, allowing you to require any `*.wasm` or `*.wat` module as if it were a
+patch, allowing you to require any `.wasm` or `.wat` module as if it were a
 Ruby file. Doing so will internally create a `Wasmtime::Instance` and define a
 Ruby module with functions for each export.
 
@@ -86,7 +83,7 @@ use this approach too.
 require 'wasmtime'
 
 instance = Wasmtime::Instance.new('fibonacci.wat')
-puts instance.funcs[:fib].call(11) #=> 89
+puts instance.exports['fib'].call(11) #=> 89
 ```
 
 ## Benchmarks

data/lib/wasmtime/require.rb

@@ -60,8 +60,11 @@ module Wasmtime
       end
     mod = Object.const_set(module_name.camelize, Module.new)
     instance = Wasmtime::Instance.new(absolute_path)
-    instance.funcs.each do |name, func|
-      mod.define_singleton_method(name) { |*args| func.call(*args) }
+    instance.exports.each do |name, export|
+      case export
+      when Wasmtime::Func
+        mod.define_singleton_method(name) { |*args| export.call(*args) }
+      end
     end
     $LOADED_FEATURES << absolute_path
     true

data/lib/wasmtime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wasmtime
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/src/export.rs

@@ -0,0 +1,19 @@
+use rutie::{AnyObject, Object};
+use wasmtime as w;
+
+use crate::func::{Func, RubyFunc};
+use crate::memory::RubyMemory;
+
+pub enum Export {
+    Func(Func),
+    Memory(w::Memory),
+}
+
+impl From<Export> for AnyObject {
+    fn from(export: Export) -> Self {
+        match export {
+            Export::Func(func) => RubyFunc::from(func).value().into(),
+            Export::Memory(memory) => RubyMemory::from(memory).value().into(),
+        }
+    }
+}

data/src/func.rs

@@ -8,7 +8,8 @@ use rutie::{
 use std::mem;
 use wasmtime as w;
 
-use crate::vm::*;
+use crate::ruby_type::RubyType;
+use crate::vm::raise;
 
 pub struct Func {
     func: w::Func,
@@ -23,58 +24,24 @@ impl Func {
         self.func.call(args).expect("failed to call func").to_vec()
     }
 
-    pub fn into_ruby(self) -> RubyFunc {
-        Module::from_existing("Wasmtime")
-            .get_nested_class("Func")
-            .wrap_data(self, &*FUNC_WRAPPER)
-    }
-
     fn parse_param_types(&self) -> Vec<RubyType> {
         self.func
             .ty()
             .params()
             .iter()
-            .map(|val_type| val_type_to_ruby_type(val_type))
+            .map(|val_type| val_type.into())
             .collect()
     }
 
     fn parse_result_type(&self) -> RubyType {
         match self.func.ty().results().len() {
             0 => RubyType::NilClass,
-            1 => val_type_to_ruby_type(self.func.ty().results().first().unwrap()),
+            1 => self.func.ty().results().first().unwrap().into(),
             _ => raise("StandardError", "multiple return values are not supported"),
         }
     }
 }
 
-fn val_type_to_ruby_type(val_type: &w::ValType) -> RubyType {
-    match val_type {
-        w::ValType::I32 => RubyType::Integer32,
-        w::ValType::I64 => RubyType::Integer64,
-        w::ValType::F32 => RubyType::Float32,
-        w::ValType::F64 => RubyType::Float64,
-        _ => RubyType::Unsupported,
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-enum RubyType {
-    Integer32,
-    Integer64,
-    Float32,
-    Float64,
-    // String,
-    // Boolean,
-    NilClass,
-    Unsupported,
-}
-
-impl Into<AnyObject> for RubyType {
-    fn into(self) -> AnyObject {
-        RString::new_utf8(&format!("{:?}", self)).into()
-    }
-}
-
 fn translate_incoming(args: Array, param_types: &[RubyType]) -> Vec<w::Val> {
     if args.length() != param_types.len() {
         raise(
@@ -141,6 +108,14 @@ fn translate_outgoing(native_results: Vec<w::Val>) -> AnyObject {
 wrappable_struct!(Func, FuncWrapper, FUNC_WRAPPER);
 class!(RubyFunc);
 
+impl From<Func> for RubyFunc {
+    fn from(func: Func) -> Self {
+        Module::from_existing("Wasmtime")
+            .get_nested_class("Func")
+            .wrap_data(func, &*FUNC_WRAPPER)
+    }
+}
+
 #[rustfmt::skip]
 methods!(
     RubyFunc,

data/src/instance.rs

@@ -1,11 +1,11 @@
 use lazy_static::lazy_static;
-use rutie::{class, methods, wrappable_struct, Hash, Module, Object, RString, Symbol};
+use rutie::{class, methods, wrappable_struct, AnyObject, Hash, Module, Object, RString};
 use std::collections::HashMap;
 use std::fs;
 use wasmtime as w;
 
+use crate::export::Export;
 use crate::func::Func;
-use crate::memory::Memory;
 
 pub struct Instance {
     instance: w::Instance,
@@ -27,58 +27,57 @@ impl Instance {
         Instance { instance }
     }
 
-    fn exports(&self) -> (HashMap<String, Func>, HashMap<String, Memory>) {
-        let mut funcs = HashMap::new();
-        let mut memories = HashMap::new();
+    fn exports(&self) -> HashMap<String, Export> {
+        let mut exports = HashMap::new();
 
         for export in self.instance.exports() {
             match export.ty() {
                 w::ExternType::Func(_) => {
                     let name = export.name().to_string();
-                    let func = Func::new(export.into_func().expect("failed to create func"));
-                    funcs.insert(name, func);
+                    let func = Func::new(export.into_func().unwrap());
+                    exports.insert(name, Export::Func(func));
                 }
                 w::ExternType::Memory(_) => {
-                    let memory = Memory::new();
-                    memories.insert(export.name().to_string(), memory);
+                    let name = export.name().to_string();
+                    let memory = export.into_memory().unwrap();
+                    exports.insert(name, Export::Memory(memory));
                 }
                 _ => {}
             }
         }
 
-        (funcs, memories)
+        exports
     }
+}
 
-    pub fn funcs(&self) -> HashMap<String, Func> {
-        let (functions, _) = self.exports();
-        functions
-    }
+wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
+class!(RubyInstance);
 
-    pub fn into_ruby(self) -> RubyInstance {
+impl From<Instance> for RubyInstance {
+    fn from(instance: Instance) -> Self {
         Module::from_existing("Wasmtime")
             .get_nested_class("Instance")
-            .wrap_data(self, &*INSTANCE_WRAPPER)
+            .wrap_data(instance, &*INSTANCE_WRAPPER)
     }
 }
 
-wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
-class!(RubyInstance);
-
 #[rustfmt::skip]
 methods!(
     RubyInstance,
     itself,
 
     fn ruby_instance_new(path: RString) -> RubyInstance {
-        Instance::new(path.expect("failed read path").to_string()).into_ruby()
+        Instance::new(path.expect("failed read path").to_string()).into()
     }
 
-    fn ruby_instance_funcs() -> Hash {
-        let mut funcs = Hash::new();
-        for (export_name, func) in itself.get_data(&*INSTANCE_WRAPPER).funcs().into_iter() {
-            funcs.store(Symbol::new(&export_name), func.into_ruby());
+    fn ruby_instance_exports() -> Hash {
+        let mut exports = Hash::new();
+
+        for (export_name, export) in itself.get_data(&*INSTANCE_WRAPPER).exports().into_iter() {
+            exports.store::<RString, AnyObject>(RString::new_utf8(&export_name), export.into());
         }
-        funcs
+
+        exports
     }
 );
 
@@ -88,7 +87,7 @@ pub fn ruby_init() {
             .define_nested_class("Instance", None)
             .define(|class| {
                 class.def_self("new", ruby_instance_new);
-                class.def("funcs", ruby_instance_funcs);
+                class.def("exports", ruby_instance_exports);
             });
     });
 }

data/src/lib.rs

@@ -1,6 +1,8 @@
+mod export;
 mod func;
 mod instance;
 mod memory;
+mod ruby_type;
 mod vm;
 
 #[allow(non_snake_case)]
@@ -16,4 +18,5 @@ pub extern "C" fn Init_native() {
 
     instance::ruby_init();
     func::ruby_init();
+    memory::ruby_init();
 }

data/src/memory.rs

@@ -1,7 +1,48 @@
-pub struct Memory {}
+use lazy_static::lazy_static;
+use rutie::{class, methods, wrappable_struct, AnyObject, Integer, Module, NilClass, Object};
+use wasmtime as w;
 
-impl Memory {
-    pub fn new() -> Self {
-        Memory {}
+wrappable_struct!(w::Memory, MemoryWrapper, MEMORY_WRAPPER);
+class!(RubyMemory);
+
+impl From<w::Memory> for RubyMemory {
+    fn from(memory: w::Memory) -> Self {
+        Module::from_existing("Wasmtime")
+            .get_nested_class("Memory")
+            .wrap_data(memory, &*MEMORY_WRAPPER)
+    }
+}
+
+#[rustfmt::skip]
+methods!(
+    RubyMemory,
+    itself,
+
+    fn ruby_instance_data_size() -> Integer {
+        Integer::from(itself.get_data(&*MEMORY_WRAPPER).data_size() as u32)
     }
+
+    fn ruby_instance_size() -> Integer {
+        Integer::from(itself.get_data(&*MEMORY_WRAPPER).size())
+    }
+
+    fn ruby_instance_grow(delta: Integer) -> AnyObject {
+        let memory = itself.get_data(&*MEMORY_WRAPPER);
+        let delta = delta.unwrap().to_i32();
+        if delta < 0 { return NilClass::new().into() }
+        match memory.grow(delta as u32) {
+            Ok(original) => Integer::from(original).into(),
+            Err(_) => NilClass::new().into()
+        }
+    }
+);
+
+pub fn ruby_init() {
+    Module::from_existing("Wasmtime").define(|module| {
+        module.define_nested_class("Memory", None).define(|class| {
+            class.def("data_size", ruby_instance_data_size);
+            class.def("size", ruby_instance_size);
+            class.def("grow", ruby_instance_grow);
+        });
+    });
 }

data/src/ruby_type.rs

@@ -0,0 +1,32 @@
+use rutie::{AnyObject, RString};
+use wasmtime as w;
+
+#[derive(Debug, Copy, Clone)]
+pub enum RubyType {
+    Integer32,
+    Integer64,
+    Float32,
+    Float64,
+    // String,
+    // Boolean,
+    NilClass,
+    Unsupported,
+}
+
+impl From<RubyType> for AnyObject {
+    fn from(ruby_type: RubyType) -> AnyObject {
+        RString::new_utf8(&format!("{:?}", ruby_type)).into()
+    }
+}
+
+impl From<&w::ValType> for RubyType {
+    fn from(val_type: &w::ValType) -> Self {
+        match val_type {
+            w::ValType::I32 => RubyType::Integer32,
+            w::ValType::I64 => RubyType::Integer64,
+            w::ValType::F32 => RubyType::Float32,
+            w::ValType::F64 => RubyType::Float64,
+            _ => RubyType::Unsupported,
+        }
+    }
+}

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: wasmtime
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - David Cristofaro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-07 00:00:00.000000000 Z
+date: 2020-05-19 00:00:00.000000000 Z
 dependencies: []
-description: This gem allows you to use the Wasmtime WebAssembly runtime from within
-  your Ruby project.
+description: 
 email:
 - david@dtcristo.com
 executables: []
@@ -33,10 +32,12 @@ files:
 - lib/wasmtime/refinements.rb
 - lib/wasmtime/require.rb
 - lib/wasmtime/version.rb
+- src/export.rs
 - src/func.rs
 - src/instance.rs
 - src/lib.rs
 - src/memory.rs
+- src/ruby_type.rs
 - src/vm.rs
 homepage: https://github.com/dtcristo/wasmtime-ruby
 licenses:
@@ -62,5 +63,5 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Wasmtime WebAssembly runtime
+summary: Ruby bindings for Wasmtime, a WebAssembly runtime
 test_files: []