watr 0.0.0 → 1.0.0

package/test/examples.js

@@ -0,0 +1,155 @@
+import fs from 'fs'
+import t from 'tst'
+
+t.only('table', () => {
+  var buffer = fs.readFileSync('./table.wasm');
+  const mod = new WebAssembly.Module(buffer)
+  const instance = new WebAssembly.Instance(mod)
+
+  // console.time('instantiate')
+  // for (let i = 0; i < 30000; i++) new WebAssembly.Instance(mod)
+  // console.timeEnd('instantiate')
+  // 290ms to instantiate 30k modules
+
+  const {callByIndex, getByIndex} = instance.exports
+
+  console.log(callByIndex(0)) // => 42
+  console.log(callByIndex(1)) // => 13
+  // console.log(callByIndex(2)) // => error
+
+  let fn = getByIndex(0)
+  console.log(fn, fn?.())
+})
+
+t('global', () => {
+  var buf = fs.readFileSync('./global.wasm')
+  const mod = new WebAssembly.Module(buf)
+  const importObj = {
+    "js": {
+      "log": arg=>console.log(arg),
+      "g1": new WebAssembly.Global({value: 'i32', mutable: true}, 123)
+    }
+  }
+
+  console.log(importObj.js.g1)
+  const instance = new WebAssembly.Instance(mod, importObj)
+  const {getG1, setG1, getG0} = instance.exports
+
+  // console.log(getG0())
+  console.log(getG1())
+  setG1(100)
+  console.log(getG1())
+})
+
+
+t('stack', () => {
+  var buf = fs.readFileSync('./stack.wasm')
+  const mod = new WebAssembly.Module(buf)
+  const importObj = {"js": {}}
+  const instance = new WebAssembly.Instance(mod, importObj)
+  const {get, swap, mul} = instance.exports
+  console.log(mul(12,13))
+  // console.log(swap(1,2,3,4))
+  // console.log(get())
+})
+
+t('memory', () => {
+  var buf = fs.readFileSync('./memory.wasm')
+  const mod = new WebAssembly.Module(buf)
+  const mem = new WebAssembly.Memory({ initial: 1 })
+
+  const importObj = {
+    js: { log: arg=>console.log(arg) }
+  }
+  const instance = new WebAssembly.Instance(mod, importObj)
+  const api = instance.exports
+
+  console.log(mem.buffer)
+// console.log(api.mem, api.g)
+
+  // api.populate()
+  // let view = new DataView(mem.buffer)
+  // view.setInt16(1, 123)
+  let i32 = new Int32Array(mem.buffer)
+  i32[1] = 123
+  console.log(api.get(4))
+  api.set(4,2)
+  console.log(api.get(4))
+
+  // grow by one page
+  // console.log(mem.grow(4))
+})
+
+
+
+t('loop', () => {
+  var buf = fs.readFileSync('./loops.wasm')
+  const mod = new WebAssembly.Module(buf)
+  // const mem = new WebAssembly.Memory({ initial:1 })
+  // const f32mem = new Float32Array(mem.buffer)
+  const importObj = {console: {log:(arg)=>console.log(arg)}}
+  const instance = new WebAssembly.Instance(mod, importObj)
+
+})
+
+
+t('amp bench', () => {
+  const BLOCK = 1024
+  var buf = fs.readFileSync('./array.wasm')
+  const mod = new WebAssembly.Module(buf)
+  const mem = new WebAssembly.Memory({ initial:1 })
+  const blockSize = new WebAssembly.Global({value: 'i32', mutable: true}, BLOCK)
+  // blockSize.value
+  const f32mem = new Float32Array(mem.buffer)
+  const importObj = {js: {mem, blockSize}, console:{log(a,b){console.log(a,b)}}}
+  const instance = new WebAssembly.Instance(mod, importObj)
+  const {amp, ampMulti, ampShort} = instance.exports
+
+
+  let src = Array.from({length:BLOCK}, (a,i)=>i)
+
+
+  f32mem.set(src)
+  amp('2')
+  console.log(f32mem)
+
+  const MAX = 1e5
+  f32mem.set(src)
+  console.time('warmup')
+  for (let i = 0; i < MAX; i++) amp(.5)
+  console.timeEnd('warmup')
+
+  f32mem.set(src)
+  console.time('wasm amp')
+  for (let i = 0; i < MAX; i++) amp(.5)
+  console.timeEnd('wasm amp')
+
+  f32mem.set(src)
+  console.time('wasm amp multivariable')
+  for (let i = 0; i < MAX; i++) ampMulti(.5)
+  console.timeEnd('wasm amp multivariable')
+
+  f32mem.set(src)
+  console.time('wasm short')
+  for (let i = 0; i < MAX; i++) ampShort(.5)
+  console.timeEnd('wasm short')
+
+
+  console.time('js amp')
+  for (let i = 0; i < MAX; i++) for (let j = 0; j < src.length; j++) src[j]*=.5
+  console.timeEnd('js amp')
+})
+
+
+
+t('types', () => {
+  var buf = fs.readFileSync('./types.wasm')
+  const mod = new WebAssembly.Module(buf)
+  // const mem = new WebAssembly.Memory({ initial:1 })
+  // const f32mem = new Float32Array(mem.buffer)
+  const importObj = {console: {log:(...abc)=>console.log(...abc)}}
+  const instance = new WebAssembly.Instance(mod, importObj)
+  const {run} = instance.exports
+
+  console.log(run(123, 13.3, 'abc'))
+})

package/test/index.html

@@ -0,0 +1,14 @@
+<doctype html>
+
+<script type="importmap">
+{
+  "imports": {
+    "tst": "../node_modules/tst/tst.js",
+    "subscript": "../../subscript/subscript.js",
+    "subscript/parse.js": "../node_modules/subscript/parse.js"
+  }
+}
+</script>
+
+<script src="./parse.js" type="module"></script>
+<script src="./compile.js" type="module"></script>

package/test/index.js

@@ -0,0 +1,2 @@
+import './parse.js'
+import './compile.js'

package/test/parse.js

@@ -0,0 +1,179 @@
+import t, { is, ok, same } from 'tst'
+import parse from '../src/parse.js'
+
+t('parser: s-expr', () => {
+  const tree = parse('(module)')
+  is(tree, ['module'])
+})
+
+t.skip('parser: s-expr no instruction (throws)', () => {
+  try {
+    parse('()')
+  } catch (error) {
+    ok(/Empty/.test(error.message))
+    return
+  }
+  throw 'Failed'
+})
+
+t('parser: s-expr named', () => {
+  const tree = parse('(module $hello)')
+  is(tree, ['module', '$hello'])
+})
+
+t('parser: ref labels as children', () => {
+  const tree = parse('(elem (i32.const 0) $f1 $f2)')
+  is(tree, ['elem', ['i32.const', '0'], '$f1', '$f2'])
+})
+
+t('parser: s-expr number params', () => {
+  const tree = parse('(memory 1 2)')
+  is(tree, ['memory', '1', '2'])
+})
+
+t('parser: s-expr number params + named params', () => {
+  const tree = parse('(memory 1 2 shared)')
+  is(tree, ['memory', '1', '2', 'shared'])
+})
+
+t('parser: s-expr named params with = value', () => {
+  const tree = parse('(i32.load offset=0 align=4)')
+  is(tree, ['i32.load', ['offset','0'], ['align','4']])
+})
+
+t('parser: stack instruction', () => {
+  const code = '(func i32.const 42)'
+  const tree = parse(code)
+  is(tree, ['func', 'i32.const', '42'])
+})
+
+t('parser: many stack instructions', () => {
+  const code = '(func i32.const 22 i32.const 20 i32.add)'
+  const tree = parse(code)
+  is(tree, ['func', 'i32.const', '22', 'i32.const', '20', 'i32.add'])
+})
+
+t('parser: children', () => {
+  const code = '(func $answer (result i32) (i32.add (i32.const 20) (i32.const 22)))'
+  const tree = parse(code)
+  is(tree, ['func', '$answer', ['result', 'i32'], ['i32.add', ['i32.const', '20'], ['i32.const', '22']]])
+})
+
+t('parser: minimal export function', () => {
+  const code = '(func (export "answer") (result i32) (i32.const 42))'
+  const tree = parse(code)
+  is(tree, ['func', ['export', '"answer"'], ['result', 'i32'], ['i32.const', '42']])
+})
+
+t.skip('parser: children', () => {
+  const code = String.raw`(data (i32.const 0) "\2a")`
+  const tree = parse(code)
+  console.log(code)
+  is(tree, ['data', ['i32.const', '0'], '"\\2a"'])
+})
+
+t('parse: instr', () => {
+  const tokens = parse('hello')
+  is(tokens, 'hello')
+})
+
+t('parse: param', () => {
+  const tokens = parse('align=4')
+  is(tokens, ['align', '4'])
+})
+
+t('parse: label', () => {
+  const tokens = parse('$$hi')
+  is(tokens, '$$hi')
+})
+
+t.skip('parse: string', () => {
+  const r = String.raw
+  const tokens = parse(r`"hello""ano\"t\n\ther""more"`)
+  expect(tokens).to.deep.equal([
+    { value: 'hello', kind: 'string', index: 0 },
+    { value: r`ano\"t\n\ther`, kind: 'string', index: 7 },
+    { value: 'more', kind: 'string', index: 22 }
+  ])
+})
+
+t('parse: number', () => {
+  const tokens = parse('123')
+  is(tokens, '123')
+})
+
+t('parse: hex', () => {
+  const tokens = parse('0xf2')
+  is(tokens, '0xf2')
+})
+
+t('parse: comments', () => {
+  const tokens = parse('(an (; inline ;) comment\n;; line comment\n1)')
+  is(tokens, ['an', 'comment', '1'])
+})
+
+t('parse: nul', () => {
+  const tokens = parse(' \n\t')
+  is(tokens, undefined)
+})
+
+t.skip('parse: error', () => {
+  try {
+    let tree = parse('§what')
+  } catch (e) {
+    ok(/syntax/.test(e.message))
+  }
+})
+
+t('parse: number', t => {
+  ;[
+    '12',
+    '12.3',
+    '-12.3',
+    '+12.3',
+    '1e5',
+    '1.23e5',
+    '1.23e-5',
+    '1.23e+5',
+    'nan',
+    'inf',
+    '+inf',
+    '-inf',
+  ].forEach(n => {
+    const tokens = parse(n)
+    is(tokens, n)
+  })
+
+  ;[
+    '-0xf2',
+    '+0xf2',
+    '0xf2.ef',
+    '0xf2.ePf',
+    '0xf2.P-f',
+    'nan:0xff',
+  ].forEach(n => {
+    const tokens = parse(n)
+    is(tokens, n)
+  })
+})
+
+
+t('parse: complex case 1', () => {
+  const tokens = parse(`(
+(hello $hi
+"world")
+;; (should) be a comment
+and (; another ;) line 0x312 43.23
+)`)
+  is(tokens, [['hello', '$hi', '"world"'], 'and', 'line', '0x312', '43.23'])
+})
+
+t('parse: minimal function', () => {
+  let tokens = parse('(func (export "answer") (result i32) (i32.const 42))')
+  is(tokens, ['func', ['export', '"answer"'], ['result', 'i32'], ['i32.const', '42']])
+})
+
+t('parse: multiple functions', () => {
+  let tokens = parse('(func $a) (func $b)')
+  is(tokens, [['func','$a'],['func','$b']])
+})