Add a more convenient tracing utility for debugging; Fix basic GC test

Author: dcodeIO

cli/asc.js

@@ -414,7 +414,8 @@ exports.main = function main(argv, options, callback) {
   // Initialize default aliases
   assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath");
   assemblyscript.setGlobalAlias(compilerOptions, "Mathf", "NativeMathf");
-  assemblyscript.setGlobalAlias(compilerOptions, "abort", "~lib/env/abort"); // to disable: --use abort=
+  assemblyscript.setGlobalAlias(compilerOptions, "abort", "~lib/env/abort");
+  assemblyscript.setGlobalAlias(compilerOptions, "trace", "~lib/env/trace");
 
   // Add or override aliases if specified
   if (args.use) {

src/builtins.ts

@@ -2700,6 +2700,7 @@ export function compileCall(
           }
         }
       }
+      compiler.currentType = Type.void;
       return exprs.length
         ? module.createBlock(null, exprs)
         : module.createNop();

src/program.ts

@@ -626,8 +626,8 @@ export class Program extends DiagnosticEmitter {
     }
 
     // register 'main' if present
-    if (this.elementsLookup.has("main")) {
-      let element = <Element>this.elementsLookup.get("main");
+    if (this.moduleLevelExports.has("main")) {
+      let element = (<ModuleExport>this.moduleLevelExports.get("main")).element;
       if (
         element.kind == ElementKind.FUNCTION_PROTOTYPE &&
         !(<FunctionPrototype>element).isAny(CommonFlags.GENERIC | CommonFlags.AMBIENT)

std/assembly/collector/itcm.ts

@@ -4,13 +4,37 @@
  * @module std/assembly/collector/itcm
  *//***/
 
-// Based on the concepts of Bach Le's μgc, see: https://github.com/bullno1/ugc
+// Largely based on the Bach Le's μgc, see: https://github.com/bullno1/ugc
+
+const TRACE = true;
 
 import {
   AL_MASK,
   MAX_SIZE_32
 } from "../internal/allocator";
 
+/** Collector states. */
+const enum State {
+  /** Not yet initialized. */
+  INIT = 0,
+  /** Currently transitioning from SWEEP to MARK state. */
+  IDLE = 1,
+  /** Currently marking reachable objects. */
+  MARK = 2,
+  /** Currently sweeping unreachable objects. */
+  SWEEP = 3
+}
+
+/** Current collector state. */
+var state = State.INIT;
+/** Current white color value. */
+var white = 0;
+
+// From and to spaces
+var from: ManagedObject;
+var to: ManagedObject;
+var iter: ManagedObject;
+
 // ╒═══════════════ Managed object layout (32-bit) ════════════════╕
 //    3                   2                   1
 //  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits
@@ -23,175 +47,144 @@ import {
 // └───────────────────────────────────────────────────────────────┘
 // F: flags
 
-/** Managed object flags. */
-namespace Flags {
-  /** Object is unreachable (so far). */
-  export var WHITE = 0;
-  /** Object is reachable. */
-  export var BLACK = 1;
-  /** Object is reachable but its children have not yet been scanned. */
-  export const GRAY = 2;
-  /** Mask to obtain just the flag bits. */
-  export const MASK = AL_MASK;
-}
-
 /** Represents a managed object in memory, consisting of a header followed by the object's data. */
 @unmanaged
 class ManagedObject {
 
-  /** Pointer to the next object with additional flags stored in the alignment bits. */
-  nextWithFlags: usize;
+  /** Pointer to the next object with color flags stored in the alignment bits. */
+  nextWithColor: usize;
 
   /** Pointer to the previous object. */
   prev: ManagedObject;
 
-  /** Visitor function called with the data pointer (excl. header). */
-  visitFn: (obj: usize) => void;
+  /** Visitor function called with the payload reference. */
+  visitFn: (ref: usize) => void;
 
   /** Size of a managed object after alignment. */
   static readonly SIZE: usize = (offsetof<ManagedObject>() + AL_MASK) & ~AL_MASK;
 
   /** Gets the pointer to the next object in the list. */
   get next(): ManagedObject {
-    return changetype<ManagedObject>(this.nextWithFlags & ~Flags.MASK);
+    return changetype<ManagedObject>(this.nextWithColor & ~3);
   }
 
   /** Sets the pointer to the next object in the list. */
   set next(obj: ManagedObject) {
-    this.nextWithFlags = changetype<usize>(obj) | (this.nextWithFlags & Flags.MASK);
+    this.nextWithColor = changetype<usize>(obj) | (this.nextWithColor & 3);
+  }
+
+  /** Gets this object's color. */
+  get color(): i32 {
+    return this.nextWithColor & 3;
+  }
+
+  /** Sets this object's color. */
+  set color(color: i32) {
+    this.nextWithColor = (this.nextWithColor & ~3) | color;
   }
 
   /** Inserts an object to this list. */
-  insert(obj: ManagedObject): void {
+  push(obj: ManagedObject): void {
     var prev = this.prev;
+    trace("   push", 3, objToRef(prev), objToRef(obj), objToRef(this));
     obj.next = this;
     obj.prev = prev;
     prev.next = obj;
     this.prev = obj;
   }
 
-  /** Removes this object from its list. */
-  remove(): void {
+  /** Unlinks this object from its list. */
+  unlink(): void {
     var next = this.next;
     var prev = this.prev;
+    if (TRACE) trace("   unlink", 3, objToRef(prev), objToRef(this), objToRef(next));
     next.prev = prev;
     prev.next = next;
   }
 
   clear(): void {
-    this.nextWithFlags = changetype<usize>(this);
+    if (TRACE) trace("   clear", 1, objToRef(this));
+    this.nextWithColor = changetype<usize>(this);
     this.prev = this;
   }
 
-  /** Tests if this object is white, that is unreachable (so far). */
-  get isWhite(): bool {
-    return (this.nextWithFlags & Flags.MASK) == Flags.WHITE;
-  }
-
-  /** Marks this object as white, that is unreachable (so far). */
-  makeWhite(): void {
-    this.nextWithFlags = (this.nextWithFlags & ~Flags.MASK) | Flags.WHITE;
-  }
-
-  /** Tests if this object is black, that is reachable. Root objects are always reachable. */
-  get isBlack(): bool {
-    return (this.nextWithFlags & Flags.MASK) == Flags.BLACK;
-  }
-
-  /** Marks this object as black, that is reachable. */
-  makeBlack(): void {
-    this.nextWithFlags = (this.nextWithFlags & ~Flags.MASK) | Flags.BLACK;
-  }
-
-  /** Tests if this object is gray, that is reachable with unscanned children. */
-  get isGray(): bool {
-    return (this.nextWithFlags & Flags.MASK) == Flags.GRAY;
-  }
-
   /** Marks this object as gray, that is reachable with unscanned children. */
   makeGray(): void {
-    if (this != iter) {
-      this.remove();
-      set2.insert(this);
-    } else {
-      iter = iter.prev;
-    }
-    this.nextWithFlags = (this.nextWithFlags & ~Flags.MASK) | Flags.GRAY;
+    if (TRACE) trace("   makeGray", 1, objToRef(this));
+    const gray = 2;
+    if (this == iter) iter = this.prev;
+    this.unlink();
+    to.push(this);
+    this.nextWithColor = (this.nextWithColor & ~3) | gray;
   }
 }
 
-/** Collector states. */
-const enum State {
-  /** Not yet initialized. */
-  INIT = 0,
-  /** Currently transitioning from SWEEP to MARK state. */
-  IDLE = 1,
-  /** Currently marking reachable objects. */
-  MARK = 2,
-  /** Currently sweeping unreachable objects. */
-  SWEEP = 3
+function markRoots(): void {
+  if (TRACE) trace("   markRoots");
+  gc.iterateRoots(function markRoot(ref: usize): void {
+    if (TRACE) trace("   markRoot", 1, ref);
+    if (ref) __gc_mark(ref);
+  });
 }
 
-/** Current collector state. */
-var state = State.INIT;
-
-// From and to spaces
-var set1: ManagedObject;
-var set2: ManagedObject;
-var iter: ManagedObject;
-
 /** Performs a single step according to the current state. */
 function step(): void {
   var obj: ManagedObject;
   switch (state) {
     case State.INIT: {
-      set1 = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
-      set1.clear();
-      set2 = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
-      set2.clear();
-      iter = set2;
+      if (TRACE) trace("gc~step/INIT");
+      from = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
+      from.visitFn = changetype<(ref: usize) => void>(<u32>-1); // would error
+      from.clear();
+      to = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
+      to.visitFn = changetype<(ref: usize) => void>(<u32>-1); // would error
+      to.clear();
+      iter = to;
+      state = State.IDLE;
+      if (TRACE) trace("gc~state = IDLE");
       // fall-through
     }
     case State.IDLE: {
-      // start by marking roots
-      gc.iterateRoots(function mark_root(ref: usize): void {
-        if (ref) {
-          let obj = changetype<ManagedObject>(ref - ManagedObject.SIZE);
-          obj.makeBlack();
-          obj.visitFn(ref);
-        }
-      });
+      if (TRACE) trace("gc~step/IDLE");
+      markRoots();
       state = State.MARK;
+      if (TRACE) trace("gc~state = MARK");
       break;
     }
     case State.MARK: {
       obj = iter.next;
-      if (obj != set2) {
+      if (obj !== to) {
+        if (TRACE) trace("gc~step/MARK iterate", 1, objToRef(obj));
         iter = obj;
-        obj.makeBlack();
-        obj.visitFn(changetype<usize>(obj) + ManagedObject.SIZE);
+        obj.color = <i32>!white;
+        obj.visitFn(objToRef(obj));
       } else {
+        if (TRACE) trace("gc~step/MARK finish");
+        markRoots();
         obj = iter.next;
-        if (obj == set2) {
-          let set1_ = set1;
-          set1 = set2;
-          set2 = set1_;
-          Flags.WHITE ^= 1;
-          Flags.BLACK ^= 1;
-          iter = set1.next;
+        if (obj === to) {
+          let prevFrom = from;
+          from = to;
+          to = prevFrom;
+          white = <i32>!white;
+          iter = prevFrom.next;
           state = State.SWEEP;
+          if (TRACE) trace("gc~state = SWEEP");
         }
       }
       break;
     }
     case State.SWEEP: {
       obj = iter;
-      if (obj !== set2) {
+      if (obj !== to) {
+        if (TRACE) trace("gc~step/SWEEP free", 1, objToRef(obj));
         iter = obj.next;
         memory.free(changetype<usize>(obj));
       } else {
-        set2.clear();
+        if (TRACE) trace("gc~step/SWEEP finish");
+        to.clear();
         state = State.IDLE;
+        if (TRACE) trace("gc~state = IDLE");
       }
       break;
     }
@@ -213,30 +206,33 @@ function step(): void {
   size: usize,
   visitFn: (ref: usize) => void
 ): usize {
-  assert(size <= MAX_SIZE_32 - ManagedObject.SIZE);
+  if (TRACE) trace("gc.allocate", 1, size);
+  if (size > MAX_SIZE_32 - ManagedObject.SIZE) unreachable();
+  step(); // also makes sure it's initialized
   var obj = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE + size));
-  obj.makeWhite();
   obj.visitFn = visitFn;
-  set1.insert(obj);
+  obj.color = white;
+  from.push(obj);
   return objToRef(obj);
 }
 
 /** Marks a reachable object. Called from the visitFn functions. */
 @global export function __gc_mark(ref: usize): void {
+  if (TRACE) trace("gc.mark", 1, ref);
   var obj = refToObj(ref);
-  if (state == State.SWEEP) return;
-  if (obj.isWhite) obj.makeGray();
+  if (obj.color == white) obj.makeGray();
 }
 
 /** Links a managed child object to its parent object. */
 @global export function __gc_link(parentRef: usize, childRef: usize): void {
+  if (TRACE) trace("gc.link", 2, parentRef, childRef);
   var parent = refToObj(parentRef);
-  var child = refToObj(childRef);
-  if (parent.isBlack && child.isWhite) parent.makeGray();
+  if (parent.color == <i32>!white && refToObj(childRef).color == white) parent.makeGray();
 }
 
 /** Performs a full garbage collection cycle. */
 @global export function __gc_collect(): void {
+  if (TRACE) trace("gc.collect");
   // begin collecting if not yet collecting
   switch (state) {
     case State.INIT:

std/assembly/env.ts

@@ -1,7 +1,16 @@
-/** Environment abort function called where assertions evaluate to false / on throw. */
 declare function abort(
   message?: string | null,
   fileName?: string | null,
   lineNumber?: u32,
   columnNumber?: u32
 ): void;
+
+declare function trace(
+  message: string,
+  n?: i32,
+  a0?: f64,
+  a1?: f64,
+  a2?: f64,
+  a3?: f64,
+  a4?: f64
+): void;

std/assembly/gc.ts

@@ -9,19 +9,19 @@ export namespace gc {
   }
 
   export function mark(ref: usize): void {
-    if (isDefined(__gc_mark)) return __gc_mark(ref); // tslint:disable-line
+    if (isDefined(__gc_mark)) { __gc_mark(ref); return; } // tslint:disable-line
     WARNING("Calling 'gc.mark' requires a garbage collector to be present.");
     unreachable();
   }
 
   export function link(parentRef: usize, childRef: usize): void {
-    if (isDefined(__gc_link)) return __gc_link(parentRef, childRef); // tslint:disable-line
+    if (isDefined(__gc_link)) { __gc_link(parentRef, childRef); return; } // tslint:disable-line
     WARNING("Calling 'gc.link' requires a garbage collector to be present.");
     unreachable();
   }
 
   export function collect(): void {
-    if (isDefined(__gc_collect)) return __gc_collect(); // tslint:disable-line
+    if (isDefined(__gc_collect)) { __gc_collect(); return; } // tslint:disable-line
     WARNING("Calling 'gc.collect' requires a garbage collector to be present.");
     unreachable();
   }