Rewrite runtime, switch to tracing GC and bootstrap

.github/workflows/test.yml

@@ -140,12 +140,12 @@ jobs:
         npm run build
         cd ..
         npm test rt-full
-    - name: Test stub runtime
-      run: |
-        cd tests/allocators/rt-stub
-        npm run build
-        cd ..
-        npm test rt-stub
+    # - name: Test stub runtime
+    #   run: |
+    #     cd tests/allocators/rt-stub
+    #     npm run build
+    #     cd ..
+    #     npm test rt-stub
   test-loader:
     name: "Loader"
     runs-on: ubuntu-latest

cli/asc.js

@@ -34,6 +34,11 @@ const fs = require("fs");
 const path = require("path");
 const process = require("process"); // ensure shim
 
+process.exit = ((exit) => function(code) {
+  if (code) console.log(new Error("exit " + code.toString()).stack);
+  exit(code);
+})(process.exit);
+
 const utf8 = require("./util/utf8");
 const colorsUtil = require("./util/colors");
 const optionsUtil = require("./util/options");
@@ -360,6 +365,7 @@ exports.main = function main(argv, options, callback) {
   assemblyscript.setNoUnsafe(compilerOptions, opts.noUnsafe);
   assemblyscript.setPedantic(compilerOptions, opts.pedantic);
   assemblyscript.setLowMemoryLimit(compilerOptions, opts.lowMemoryLimit >>> 0);
+  assemblyscript.setNoExportRuntime(compilerOptions, opts.noExportRuntime);
 
   // Add or override aliases if specified
   if (opts.use) {
@@ -624,18 +630,11 @@ exports.main = function main(argv, options, callback) {
     }
   }
 
-  // Include runtime template before entry files so its setup runs first
+  // Include runtime before entry files so its setup runs first
   {
-    let runtimeName = String(opts.runtime);
-    let runtimePath = "rt/index-" + runtimeName;
+    let runtimePath = opts.noExportRuntime ? "rt/index-noexport" : "rt/index";
     let runtimeText = exports.libraryFiles[runtimePath];
-    if (runtimeText == null) {
-      runtimePath = runtimeName;
-      runtimeText = readFile(runtimePath + extension.ext, baseDir);
-      if (runtimeText == null) return callback(Error("Runtime '" + runtimeName + "' not found."));
-    } else {
-      runtimePath = "~lib/" + runtimePath;
-    }
+    if (runtimeText == null) return callback(Error("Runtime entry not found."));
     stats.parseCount++;
     stats.parseTime += measure(() => {
       assemblyscript.parse(program, runtimeText, runtimePath + extension.ext, true);
@@ -754,7 +753,6 @@ exports.main = function main(argv, options, callback) {
 
   // Optimize the module
   const debugInfo = opts.debug;
-  const usesARC = opts.runtime == "half" || opts.runtime == "full";
   const converge = opts.converge;
   const runPasses = [];
   if (opts.runPasses) {
@@ -771,13 +769,13 @@ exports.main = function main(argv, options, callback) {
 
   stats.optimizeTime += measure(() => {
     stats.optimizeCount++;
-    module.optimize(optimizeLevel, shrinkLevel, debugInfo, usesARC);
+    module.optimize(optimizeLevel, shrinkLevel, debugInfo);
     module.runPasses(runPasses);
     if (converge) {
       let last = module.toBinary();
       do {
         stats.optimizeCount++;
-        module.optimize(optimizeLevel, shrinkLevel, debugInfo, usesARC);
+        module.optimize(optimizeLevel, shrinkLevel, debugInfo);
         module.runPasses(runPasses);
         let next = module.toBinary();
         if (next.output.length >= last.output.length) {

cli/asc.json

@@ -67,19 +67,11 @@
     "type": "b",
     "default": false
   },
-  "runtime": {
+  "noExportRuntime": {
     "category": "Optimization",
-    "description": [
-      "Specifies the runtime variant to include in the program.",
-      "",
-      " full  Default runtime based on TLSF and reference counting.",
-      " half  Same as 'full', but not exported to the host.",
-      " stub  Minimal stub implementation without free/GC support.",
-      " none  Same as 'stub', but not exported to the host.",
-      ""
-    ],
-    "type": "s",
-    "default": "full"
+    "description": "Does not export the runtime helpers (e.g. __new).",
+    "type": "b",
+    "default": false
   },
 
   "outFile": {

lib/loader/index.d.ts

@@ -15,6 +15,7 @@ export type Imports = {
     seed?(): number;
     abort?(msg: number, file: number, line: number, column: number): void;
     trace?(msg: number, numArgs?: number, ...args: number[]): void;
+    mark?(): void;
   };
 };
 
@@ -87,14 +88,18 @@ export interface ASUtil {
   __newString(str: string): number;
   /** Allocates a new array in the module's memory and returns a reference (pointer) to it. */
   __newArray(id: number, values: ArrayLike<number>): number;
-  /** Retains a reference to a managed object externally, making sure that it doesn't become collected prematurely. Returns the pointer. */
+  /** Retains a reference to a managed object externally, preventing it from becoming collected. */
   __retain(ptr: number): number;
-  /** Releases a previously retained reference to a managed object, allowing the runtime to collect it once its reference count reaches zero. */
+  /** Releases a reference to a managed object, allowing it to become collected. */
   __release(ptr: number): void;
-  /** Forcefully resets the heap to its initial offset, effectively clearing dynamic memory. Stub runtime only. */
-  __reset?(): void;
+  /** Keeps a reference to a managed object alive externally while it is reachable. */
+  __keepalive(ptr: number): number;
   /** Tests whether a managed object is an instance of the class represented by the specified base id. */
   __instanceof(ptr: number, baseId: number): boolean;
+  /** Introduces a link from a parent object to a child object, i.e. upon `parent.field = child`. */
+  __link(parentPtr: number, childPtr: number, expectMultiple: boolean): void;
+  /** Marks an externally retained value as reachable during the collection phase. */
+  __mark(ptr: number): void;
   /** Forces a cycle collection. Only relevant if objects potentially forming reference cycles are used. */
   __collect(): void;
 }

lib/loader/index.js

@@ -39,6 +39,7 @@ const THIS = Symbol();
 
 const STRING_DECODE_THRESHOLD = 32;
 const decoder = new TextDecoder("utf-16le");
+const rootsSym = Symbol();
 
 /** Gets a string from an U32 and an U16 view on a memory. */
 function getStringImpl(buffer, ptr) {
@@ -54,6 +55,8 @@ function getStringImpl(buffer, ptr) {
 function preInstantiate(imports) {
   const extendedExports = {};
 
+  extendedExports[rootsSym] = new Map();
+
   function getString(memory, ptr) {
     if (!memory) return "<yet unknown>";
     return getStringImpl(memory.buffer, ptr);
@@ -70,6 +73,11 @@ function preInstantiate(imports) {
     console.log(`trace: ${getString(memory, msg)}${n ? " " : ""}${args.slice(0, n).join(", ")}`);
   };
   env.seed = env.seed || Date.now;
+  env.mark = env.mark || function() {
+    for (const ptr of extendedExports[rootsSym].keys()) {
+      extendedExports.__mark(ptr);
+    }
+  };
   imports.Math = imports.Math || Math;
   imports.Date = imports.Date || Date;
 
@@ -81,16 +89,16 @@ function postInstantiate(extendedExports, instance) {
   const exports = instance.exports;
   const memory = exports.memory;
   const table = exports.table;
-  const new_ = exports["__new"];
-  const retain = exports["__retain"];
-  const rttiBase = exports["__rtti_base"] || ~0; // oob if not present
+  const __new = exports.__new;
+  const __link = exports.__link;
+  const __rtti_base = exports.__rtti_base || ~0; // oob if not present
 
   /** Gets the runtime type info for the given id. */
   function getInfo(id) {
     const U32 = new Uint32Array(memory.buffer);
-    const count = U32[rttiBase >>> 2];
+    const count = U32[__rtti_base >>> 2];
     if ((id >>>= 0) >= count) throw Error(`invalid id: ${id}`);
-    return U32[(rttiBase + 4 >>> 2) + id * 2];
+    return U32[(__rtti_base + 4 >>> 2) + id * 2];
   }
 
   /** Gets and validate runtime type info for the given id for array like objects */
@@ -103,9 +111,9 @@ function postInstantiate(extendedExports, instance) {
   /** Gets the runtime base id for the given id. */
   function getBase(id) {
     const U32 = new Uint32Array(memory.buffer);
-    const count = U32[rttiBase >>> 2];
+    const count = U32[__rtti_base >>> 2];
     if ((id >>>= 0) >= count) throw Error(`invalid id: ${id}`);
-    return U32[(rttiBase + 4 >>> 2) + id * 2 + 1];
+    return U32[(__rtti_base + 4 >>> 2) + id * 2 + 1];
   }
 
   /** Gets the runtime alignment of a collection's values. */
@@ -118,10 +126,10 @@ function postInstantiate(extendedExports, instance) {
   //   return 31 - Math.clz32((info >>> KEY_ALIGN_OFFSET) & 31); // -1 if none
   // }
 
-  /** Allocates a new string in the module's memory and returns its retained pointer. */
+  /** Allocates a new string in the module's memory and returns its pointer. */
   function __newString(str) {
     const length = str.length;
-    const ptr = new_(length << 1, STRING_ID);
+    const ptr = __new(length << 1, STRING_ID);
     const U16 = new Uint16Array(memory.buffer);
     for (var i = 0, p = ptr >>> 1; i < length; ++i) U16[p + i] = str.charCodeAt(i);
     return ptr;
@@ -158,27 +166,32 @@ function postInstantiate(extendedExports, instance) {
     throw Error(`unsupported align: ${alignLog2}`);
   }
 
-  /** Allocates a new array in the module's memory and returns its retained pointer. */
+  /** Allocates a new array in the module's memory and returns its pointer. */
   function __newArray(id, values) {
     const info = getArrayInfo(id);
     const align = getValueAlign(info);
     const length = values.length;
-    const buf = new_(length << align, info & STATICARRAY ? id : ARRAYBUFFER_ID);
+    const buf = __new(length << align, info & STATICARRAY ? id : ARRAYBUFFER_ID);
     let result;
     if (info & STATICARRAY) {
       result = buf;
     } else {
-      const arr = new_(info & ARRAY ? ARRAY_SIZE : ARRAYBUFFERVIEW_SIZE, id);
+      const arr = __new(info & ARRAY ? ARRAY_SIZE : ARRAYBUFFERVIEW_SIZE, id);
       const U32 = new Uint32Array(memory.buffer);
-      U32[arr + ARRAYBUFFERVIEW_BUFFER_OFFSET >>> 2] = retain(buf);
+      U32[arr + ARRAYBUFFERVIEW_BUFFER_OFFSET >>> 2] = buf;
       U32[arr + ARRAYBUFFERVIEW_DATASTART_OFFSET >>> 2] = buf;
       U32[arr + ARRAYBUFFERVIEW_DATALENGTH_OFFSET >>> 2] = length << align;
       if (info & ARRAY) U32[arr + ARRAY_LENGTH_OFFSET >>> 2] = length;
+      __link(arr, buf, 1);
       result = arr;
     }
     const view = getView(align, info & VAL_SIGNED, info & VAL_FLOAT);
     if (info & VAL_MANAGED) {
-      for (let i = 0; i < length; ++i) view[(buf >>> align) + i] = retain(values[i]);
+      for (let i = 0; i < length; ++i) {
+        const value = values[i];
+        view[(buf >>> align) + i] = value;
+        __link(result, value, 1);
+      }
     } else {
       view.set(values, buf >>> align);
     }
@@ -224,6 +237,47 @@ function postInstantiate(extendedExports, instance) {
 
   extendedExports.__getArrayBuffer = __getArrayBuffer;
 
+  /** Retains a reference to a managed object externally, preventing it from becoming collected. */
+  function __retain(ptr) {
+    // Must coerce `ptr` to a number in case it is a shadow object
+    const roots = extendedExports[rootsSym];
+    roots.set(+ptr, (roots.get(+ptr) | 0) + 1);
+    return ptr; // ...but return the potential shadow object again
+  }
+
+  extendedExports.__retain = __retain;
+
+  /** Releases a reference to a managed object, allowing it to become collected. */
+  function __release(ptr) {
+    // Must coerce `ptr` to a number in case it is a shadow object
+    const roots = extendedExports[rootsSym];
+    const count = roots.get(+ptr);
+    if (count === 1) {
+      roots.delete(+ptr);
+    } else {
+      if (!count) throw Error(`Superfluous release on object ${+ptr}`);
+      roots.set(+ptr, count - 1);
+    }
+  }
+
+  extendedExports.__release = __release;
+
+  // At the time of this comment, FinalizationRegistry is supported in latest V8
+  // and SpiderMonkey but not yet supported in JavaScriptCore.
+  if (typeof FinalizationRegistry !== "undefined") {
+    // eslint-disable-next-line no-undef
+    const registry = new FinalizationRegistry(ptr => { __release(ptr); });
+
+    /** Keeps a reference to a managed object alive externally while it is reachable. */
+    function __keepalive(ptr) {
+      const shadowObj = new Number(__retain(+ptr));
+      registry.register(shadowObj, +ptr);
+      return shadowObj;
+    }
+
+    extendedExports.__keepalive = __keepalive;
+  }
+
   /** Copies a typed array's values from the module's memory. */
   function getTypedArray(Type, alignLog2, ptr) {
     return new Type(getTypedArrayView(Type, alignLog2, ptr));
@@ -267,7 +321,7 @@ function postInstantiate(extendedExports, instance) {
   function __instanceof(ptr, baseId) {
     const U32 = new Uint32Array(memory.buffer);
     let id = U32[ptr + ID_OFFSET >>> 2];
-    if (id <= U32[rttiBase >>> 2]) {
+    if (id <= U32[__rtti_base >>> 2]) {
       do {
         if (id == baseId) return true;
         id = getBase(id);