Staged Miniwasm Interpreter (#88)

* try lms

* compose all parts

* Frame should be opaque

* function call

* factor out getFuncType

* fix: use restK when non-tail call

* compile Block-like instructions(if-else, loop, block)

* branching instructions

* local set

* operators

* global instructions

* placeholder for mem instructions

* scala code generation

* some imported function

* polish

* ci

* tweak

* try some simplification

* improve runtime(the prelude)

* some fixes

* fix: Frame creation is not optimizable

* demo br_table's attempts

* fix: tail call

* fix global

* fix: code generation for global.set

* brtable seems to work, but there is code duplication problem

* effectful staged interpreter

* remove non-sense tests

* scratch cpp backend

* some tweaks

* fix some of the nothing type

* manually supply the reflect's type arguments

* lift every function to top level & avoid lms's common subexpr elimination

* stack pop example

* not inlining + shallow

* an almost work runtime

* emit functions

* read a dummy node to avoid lambda lifting

it seems that the lambda lifting is unsound

* capture by value is not friendly with recursion

* redirect generated code to a file

* fix printing logic in test

* extract the dummy writing pattern as a function

* don't inline stack-pop to improve readability

* make topFun work

* update runtime

* add all passed test cases

* store/load operation

* more memory operations

* some fixes

* some little polish

* shift stack elements when exiting block instructions

* fix: evalTop should be aware of frame size

* comment IO statements

* benchmark code

* with std c++17

* ensure the compiled program is executed correctly

* utilize type information

* lifting to the top

* avoid re-registering top function

* remove std::vector usages & use O3 in benchmark

* split header from prelude

* move NewStagedEvalCPS.scala to attic

---------

Co-authored-by: ahuoguo <ahuoguo@gmail.com>
Co-authored-by: Guannan Wei <guannan.wei@tufts.edu>

Author: 3 people

.github/workflows/scala.yml

@@ -78,3 +78,4 @@ jobs:
         sbt 'testOnly gensym.wasm.TestScriptRun'
         sbt 'testOnly gensym.wasm.TestConcolic'
         sbt 'testOnly gensym.wasm.TestDriver'
+        sbt 'testOnly gensym.wasm.TestStagedEval'

benchmarks/wasm/global.wat

@@ -0,0 +1,19 @@
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func))
+  
+  (func (;0;) (type 0) (result i32)
+    i32.const 42
+    global.set 0
+    global.get 0
+  )
+  (func (;1;) (type 1)
+    call 0
+    ;; should be 42
+    ;; drop
+    )
+  (start 1)
+  (memory (;0;) 2)
+  (export "main" (func 1))
+  (global (;0;) (mut i32) (i32.const 0))
+)

benchmarks/wasm/performance/ack.wat

@@ -0,0 +1,70 @@
+(module $ack.wat.temp
+  (type (;0;) (func (param i32 i32) (result i32)))
+  (type (;1;) (func (result i32)))
+  (func $ack (type 0) (param i32 i32) (result i32)
+    local.get 0
+    local.set 0
+    local.get 1
+    local.set 1
+    block  ;; label = @1
+      loop  ;; label = @2
+        local.get 1
+        local.set 1
+        local.get 0
+        local.tee 0
+        i32.eqz
+        br_if 1 (;@1;)
+        block  ;; label = @3
+          block  ;; label = @4
+            local.get 1
+            br_if 0 (;@4;)
+            i32.const 1
+            local.set 1
+            br 1 (;@3;)
+          end
+          local.get 0
+          local.get 1
+          i32.const -1
+          i32.add
+          call $ack
+          local.set 1
+        end
+        local.get 0
+        i32.const -1
+        i32.add
+        local.set 0
+        local.get 1
+        local.set 1
+        br 0 (;@2;)
+      end
+    end
+    local.get 1
+    i32.const 1
+    i32.add)
+  (func $real_main (type 1) (result i32)
+    (local i32 i32)
+    i32.const 10000
+    local.set 0
+    loop
+      i32.const 2
+      i32.const 1
+      call $ack
+      local.set 1
+      local.get 0
+      i32.const 1
+      i32.sub
+      local.tee 0
+      br_if 0
+    end
+    local.get 1)
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) 16)
+  (global $__stack_pointer (mut i32) (i32.const 1048576))
+  (global (;1;) i32 (i32.const 1048576))
+  (global (;2;) i32 (i32.const 1048576))
+  (export "memory" (memory 0))
+  (export "ack" (func 0))
+  (export "real_main" (func 1))
+  (start 1)
+  (export "__data_end" (global 1))
+  (export "__heap_base" (global 2)))

benchmarks/wasm/performance/pow.wat

@@ -0,0 +1,55 @@
+(module $pow.temp
+  (type (;0;) (func (param i32 i32) (result i32)))
+  (type (;1;) (func (result i32)))
+  (func $power (type 0) (param i32 i32) (result i32)
+    (local i32)
+    i32.const 1
+    local.set 2
+    local.get 1
+    local.set 1
+    block  ;; label = @1
+      loop  ;; label = @2
+        local.get 2
+        local.set 2
+        local.get 1
+        local.tee 1
+        i32.eqz
+        br_if 1 (;@1;)
+        local.get 2
+        local.get 0
+        i32.mul
+        local.set 2
+        local.get 1
+        i32.const -1
+        i32.add
+        local.set 1
+        br 0 (;@2;)
+      end
+    end
+    local.get 2)
+  (func $real_main (type 1) (result i32)
+    (local i32 i32)
+    i32.const 10000     ;; loop counter
+    local.set 0         ;; reuse param 0 as loop counter
+    loop              ;; label = @2
+      i32.const 2
+      i32.const 20
+      call $power
+      local.set 1
+      local.get 0
+      i32.const 1
+      i32.sub
+      local.tee 0
+      br_if 0         ;; continue loop if counter != 0
+    end
+    local.get 1)
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) 16)
+  (global $__stack_pointer (mut i32) (i32.const 1048576))
+  (global (;1;) i32 (i32.const 1048576))
+  (global (;2;) i32 (i32.const 1048576))
+  (export "memory" (memory 0))
+  (export "power" (func 0))
+  (export "real_main" (func 1))
+  (export "__data_end" (global 1))
+  (export "__heap_base" (global 2)))

benchmarks/wasm/staged/brtable.wat

@@ -0,0 +1,12 @@
+(module $push-drop
+  (global (;0;) (mut i32) (i32.const 1048576))
+  (func (;0;) (type 1) (result i32)
+    i32.const 2
+    (block
+     (block
+      i32.const 1
+      br_table 0 1 0 ;; br_table will consume an element from the stack
+     )
+    )
+  )
+  (start 0))

benchmarks/wasm/staged/pop.wat

@@ -0,0 +1,8 @@
+(module $push-drop
+  (global (;0;) (mut i32) (i32.const 1048576))
+  (func (;0;) (type 1) (result)
+    i32.const 2
+    i32.const 2
+    i32.add
+  )
+  (start 0))

headers/wasm.hpp

@@ -0,0 +1,6 @@
+#ifndef WASM_HEADERS
+#define WASM_HEADERS
+
+#include "wasm/concrete_rt.hpp"
+
+#endif

headers/wasm/concrete_rt.hpp

@@ -0,0 +1,203 @@
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <iostream>
+#include <memory>
+#include <ostream>
+#include <variant>
+#include <vector>
+
+void info() {
+#ifdef DEBUG
+  std::cout << std::endl;
+#endif
+}
+
+template <typename T, typename... Args>
+void info(const T &first, const Args &...args) {
+#ifdef DEBUG
+  std::cout << first << " ";
+  info(args...);
+#endif
+}
+
+struct Num {
+  Num(int64_t value) : value(value) {}
+  Num() : value(0) {}
+  int64_t value;
+  int32_t toInt() { return static_cast<int32_t>(value); }
+
+  bool operator==(const Num &other) const { return value == other.value; }
+  bool operator!=(const Num &other) const { return !(*this == other); }
+  Num operator+(const Num &other) const { return Num(value + other.value); }
+  Num operator-(const Num &other) const { return Num(value - other.value); }
+  Num operator*(const Num &other) const { return Num(value * other.value); }
+  Num operator/(const Num &other) const {
+    if (other.value == 0) {
+      throw std::runtime_error("Division by zero");
+    }
+    return Num(value / other.value);
+  }
+  Num operator<(const Num &other) const { return Num(value < other.value); }
+  Num operator<=(const Num &other) const { return Num(value <= other.value); }
+  Num operator>(const Num &other) const { return Num(value > other.value); }
+  Num operator>=(const Num &other) const { return Num(value >= other.value); }
+  Num operator&(const Num &other) const { return Num(value & other.value); }
+};
+
+static Num I32V(int v) { return v; }
+
+static Num I64V(int64_t v) { return v; }
+
+using Slice = std::vector<Num>;
+
+const int STACK_SIZE = 1024 * 64;
+
+class Stack_t {
+public:
+  Stack_t() : count(0), stack_ptr(new Num[STACK_SIZE]) {}
+
+  std::monostate push(Num &&num) {
+    stack_ptr[count] = num;
+    count++;
+    return std::monostate{};
+  }
+
+  std::monostate push(Num &num) {
+    stack_ptr[count] = num;
+    count++;
+    return std::monostate{};
+  }
+
+  Num pop() {
+#ifdef DEBUG
+    if (count == 0) {
+      throw std::runtime_error("Stack underflow");
+    }
+#endif
+    Num num = stack_ptr[count - 1];
+    count--;
+    return num;
+  }
+
+  Num peek() {
+#ifdef DEBUG
+    if (count == 0) {
+      throw std::runtime_error("Stack underflow");
+    }
+#endif
+    return stack_ptr[count - 1];
+  }
+
+  int32_t size() { return count; }
+
+  void shift(int32_t offset, int32_t size) {
+#ifdef DEBUG
+    if (offset < 0) {
+      throw std::out_of_range("Invalid offset: " + std::to_string(offset));
+    }
+    if (size < 0) {
+      throw std::out_of_range("Invalid size: " + std::to_string(size));
+    }
+#endif
+    // shift last `size` of numbers forward of `offset`
+    for (int32_t i = count - size; i < count; ++i) {
+      stack_ptr[i - offset] = stack_ptr[i];
+    }
+    count -= offset;
+  }
+
+  void print() {
+    std::cout << "Stack contents: " << std::endl;
+    for (int32_t i = 0; i < count; ++i) {
+      std::cout << stack_ptr[count - i - 1].value << std::endl;
+    }
+  }
+
+  void initialize() {
+    // do nothing for now
+  }
+
+private:
+  int32_t count;
+  Num *stack_ptr;
+};
+static Stack_t Stack;
+
+const int FRAME_SIZE = 1024;
+
+class Frames_t {
+public:
+  Frames_t() : count(0), stack_ptr(new Num[FRAME_SIZE]) {}
+
+  std::monostate popFrame(std::int32_t size) {
+    assert(size >= 0);
+    count -= size;
+    return std::monostate{};
+  }
+
+  Num get(std::int32_t index) {
+    auto ret = stack_ptr[count - 1 - index];
+    return ret;
+  }
+
+  void set(std::int32_t index, Num num) { stack_ptr[count - 1 - index] = num; }
+
+  void pushFrame(std::int32_t size) {
+    assert(size >= 0);
+    count += size;
+  }
+
+private:
+  int32_t count;
+  Num *stack_ptr;
+};
+
+static Frames_t Frames;
+
+static void initRand() {
+  // for now, just do nothing
+}
+
+static std::monostate unreachable() {
+  std::cout << "Unreachable code reached!" << std::endl;
+  throw std::runtime_error("Unreachable code reached");
+}
+
+static int32_t pagesize = 65536;
+static int32_t page_count = 0;
+
+struct Memory_t {
+  std::vector<uint8_t> memory;
+  Memory_t(int32_t init_page_count) : memory(init_page_count * pagesize) {}
+
+  int32_t loadInt(int32_t base, int32_t offset) {
+    return *reinterpret_cast<int32_t *>(static_cast<uint8_t *>(memory.data()) +
+                                        base + offset);
+  }
+
+  std::monostate storeInt(int32_t base, int32_t offset, int32_t value) {
+    *reinterpret_cast<int32_t *>(static_cast<uint8_t *>(memory.data()) + base +
+                                 offset) = value;
+    return std::monostate{};
+  }
+
+  // grow memory by delta bytes when bytes > 0. return -1 if failed, return old
+  // size when success
+  int32_t grow(int32_t delta) {
+    if (delta <= 0) {
+      return memory.size();
+    }
+
+    try {
+      memory.resize(memory.size() + delta * pagesize);
+      auto old_page_count = page_count;
+      page_count += delta;
+      return memory.size();
+    } catch (const std::bad_alloc &e) {
+      return -1;
+    }
+  }
+};
+
+static Memory_t Memory(1); // 1 page memory