Improve stack printing by resolving closures

Author: DaQuirm

runtime.js

@@ -1,11 +1,5 @@
 const fs = require('fs').promises;
 
-const CLS_ID_TABLE = {
-    0: 'I',
-    1: 'K',
-    2: 'S'
-}
-
 Promise.all([
     fs.readFile('./stack-machine.wasm'),
     fs.readFile('./program.wasm')
@@ -21,29 +15,39 @@ Promise.all([
             }
         ))
         .then(result => {
+            const STACK_SIZE = result.instance.exports.STACK_SIZE.value;
+            const STACK_FRAME_SIZE = result.instance.exports.STACK_FRAME_SIZE.value;
+
+            const CLS_SIZE = result.instance.exports.CLS_SIZE.value;
+            const CLS_HEAP_ADDR = result.instance.exports.CLS_HEAP_ADDR.value;
+
             const workingMemoryOffset = result.instance.exports.WM_ADDR.value;
             console.log(`Working Memory address: ${workingMemoryOffset}`);
             const programMem = new Uint8Array(result.instance.exports.mem.buffer, 0, workingMemoryOffset);
+
             const stackTopPointer = result.instance.exports.stack_top_pointer.value;
             console.log(`Stack Top pointer: ${stackTopPointer}`);
             const stackMem = new Uint8Array(result.instance.exports.mem.buffer, workingMemoryOffset, stackTopPointer - workingMemoryOffset);
-            const heapMem = new Uint8Array(result.instance.exports.mem.buffer, workingMemoryOffset + 1024, 13 * 20);
+
+            const clsHeapPointer = result.instance.exports.cls_heap_pointer.value;
+            const closureMemoryTotal = clsHeapPointer - CLS_HEAP_ADDR;
+            console.log(`Heap pointer: ${clsHeapPointer}, ${closureMemoryTotal / CLS_SIZE} closures ⨉ ${CLS_SIZE} bytes`);
+
+            const heapMem = new Uint8Array(result.instance.exports.mem.buffer, workingMemoryOffset + STACK_SIZE, closureMemoryTotal);
             console.log(`Program Memory: ${programMem}\n`);
 
             const stackClss = [];
 
-            for (let i = 0; i < stackMem.length; i += 4) {
-                const buffer = Buffer.from(stackMem.subarray(i, i + 4));
-                const clsId = buffer.readUIntLE(0, 4);
+            for (let i = 0; i < stackMem.length; i += STACK_FRAME_SIZE) {
+                const buffer = Buffer.from(stackMem.subarray(i, i + STACK_FRAME_SIZE));
+                const clsId = buffer.readUIntLE(0, buffer.length);
                 stackClss.push(clsId);
             }
 
-            console.log(`Stack:\n  ${stackClss.map((id, index) => `#${index} ${CLS_ID_TABLE[id]}`)}\n`);
-
             const heapClss = [];
 
-            for (let i = 0; i < heapMem.length; i += 13) {
-                const buffer = Buffer.from(heapMem.subarray(i, i + 13));
+            for (let i = 0; i < heapMem.length; i += CLS_SIZE) {
+                const buffer = Buffer.from(heapMem.subarray(i, i + CLS_SIZE));
                 const clsId = buffer.readUIntLE(0, 4);
                 const tag = buffer.readUIntLE(4, 1);
                 const data1 = buffer.readUIntLE(5, 4)
@@ -55,6 +59,8 @@ Promise.all([
             for (const heapCls of heapClss) {
                 console.log(`  ${formatHeapCLS(heapCls)}`)
             }
+
+            console.log(`\nStack:\n  ${stackClss.map((closureIndex, id) => formatStackFrame(heapClss, id, closureIndex))}`);
         })
 )
 
@@ -77,3 +83,7 @@ function formatHeapCLS({ clsId, tag, data1, data2 }) {
     }
     return `#${clsId} ${formatCLS()}`
 }
+
+function formatStackFrame (closures, id, closureIndex) {
+    return `#${id} ${formatHeapCLS(closures[closureIndex])}`
+}

stack-machine.wasm

@@ -9,8 +9,16 @@
 
     ;; exports
     (export "mem" (memory $mem))
+
     (export "WM_ADDR" (global $WM_ADDR))
+    (export "STACK_SIZE" (global $STACK_SIZE))
+    (export "STACK_FRAME_SIZE" (global $STACK_FRAME_SIZE))
+    (export "CLS_SIZE" (global $CLS_SIZE))
+    (export "CLS_HEAP_ADDR" (global $CLS_HEAP_ADDR))
+
     (export "stack_top_pointer" (global $stack_top_pointer))
+    (export "cls_heap_pointer" (global $cls_heap_pointer))
+
     (export "main" (func $main))
 
     ;; closure encoding tags
@@ -35,23 +43,23 @@
     (global $CLS_HEAP_ADDR (mut i32) (i32.const 0)) ;; current closure heap address (initialized with $WM_ADDR + $STACK_SIZE)
 
     (global $stack_top_pointer (mut i32) (i32.const 0)) ;; current stack top pointer (initialized with $wm_offset)
-    (global $cls_heap_offset (mut i32) (i32.const 0)) ;; current closure heap offset (initialized with $wm_offset + $STACK_SIZE)
+    (global $cls_heap_pointer (mut i32) (i32.const 0)) ;; current closure heap offset (initialized with $wm_offset + $STACK_SIZE)
     (global $cls_id (mut i32) (i32.const 0)) ;; next closure id
 
     (func $write_cls (param $tag i32) (param $data i32)
         ;; TODO: speed-up with shifts
         (local $offset i32)
-        (local.set $offset (global.get $cls_heap_offset))
+        (local.set $offset (global.get $cls_heap_pointer))
         (i32.store (local.get $offset) (global.get $cls_id)) ;; cls_id
         (global.set $cls_id (i32.add (global.get $cls_id) (i32.const 1))) ;; inc cls_id
         (i32.store8 (i32.add (local.get $offset) (i32.const 4)) (local.get $tag)) ;; tag
         (i32.store (i32.add (local.get $offset) (i32.const 5)) (local.get $data)) ;; data
-        (global.set $cls_heap_offset (i32.add (local.get $offset) (global.get $CLS_SIZE)))
+        (global.set $cls_heap_pointer (i32.add (local.get $offset) (global.get $CLS_SIZE)))
     )
 
     (func $write_cls_ext (param $tag i32) (param $data1 i32) (param $data2 i32)
         (local $offset i32)
-        (local.set $offset (global.get $cls_heap_offset))
+        (local.set $offset (global.get $cls_heap_pointer))
         (call $write_cls (local.get $tag) (local.get $data1))
         (i32.store (i32.add (local.get $offset) (i32.const 9)) (local.get $data2)) ;; data2
     )
@@ -220,7 +228,7 @@
 
         ;; init memory pointers
         (global.set $stack_top_pointer (global.get $WM_ADDR))
-        (global.set $cls_heap_offset (i32.add (global.get $WM_ADDR) (global.get $STACK_SIZE)))
+        (global.set $cls_heap_pointer (i32.add (global.get $WM_ADDR) (global.get $STACK_SIZE)))
 
         ;; init closure heap
         (call $write_cls (global.get $CLS_I) (i32.const 0))