@amxts/core 0.1.0

package/node_modules/assemblyscript/std/assembly/rt/README.md

@@ -0,0 +1,83 @@
+The AssemblyScript Runtime
+==========================
+
+The runtime provides the functionality necessary to dynamically allocate and deallocate memory of objects, arrays and buffers, as well as collect garbage that is no longer used. The current implementation is either a Two-Color Mark & Sweep (TCMS) garbage collector that must be called manually when the execution stack is unwound or an Incremental Tri-Color Mark & Sweep (ITCMS) garbage collector that is fully automated with a shadow stack, implemented on top of a Two-Level Segregate Fit (TLSF) memory manager. It's not designed to be the fastest of its kind, but intentionally focuses on simplicity and ease of integration until we can replace it with the real deal, i.e. Wasm GC.
+
+Interface
+---------
+
+### Garbage collector / `--exportRuntime`
+
+* **__new**(size: `usize`, id: `u32` = 0): `usize`<br />
+  Dynamically allocates a GC object of at least the specified size and returns its address.
+  Alignment is guaranteed to be 16 bytes to fit up to v128 values naturally.
+  GC-allocated objects cannot be used with `__realloc` and `__free`.
+
+* **__pin**(ptr: `usize`): `usize`<br />
+  Pins the object pointed to by `ptr` externally so it and its directly reachable members and indirectly reachable objects do not become garbage collected.
+
+* **__unpin**(ptr: `usize`): `void`<br />
+  Unpins the object pointed to by `ptr` externally so it can become garbage collected.
+
+* **__collect**(): `void`<br />
+  Performs a full garbage collection.
+
+### Internals
+
+* **__alloc**(size: `usize`): `usize`<br />
+  Dynamically allocates a chunk of memory of at least the specified size and returns its address.
+  Alignment is guaranteed to be 16 bytes to fit up to v128 values naturally.
+
+* **__realloc**(ptr: `usize`, size: `usize`): `usize`<br />
+  Dynamically changes the size of a chunk of memory, possibly moving it to a new address.
+
+* **__free**(ptr: `usize`): `void`<br />
+  Frees a dynamically allocated chunk of memory by its address.
+
+* **__renew**(ptr: `usize`, size: `usize`): `usize`<br />
+  Like `__realloc`, but for `__new`ed GC objects.
+
+* **__link**(parentPtr: `usize`, childPtr: `usize`, expectMultiple: `bool`): `void`<br />
+  Introduces a link from a parent object to a child object, i.e. upon `parent.field = child`.
+
+* **__visit**(ptr: `usize`, cookie: `u32`): `void`<br />
+  Concrete visitor implementation called during traversal. Cookie can be used to indicate one of multiple operations.
+
+* **__visit_globals**(cookie: `u32`): `void`<br />
+  Calls `__visit` on each global that is of a managed type.
+
+* **__visit_members**(ptr: `usize`, cookie: `u32`): `void`<br />
+  Calls `__visit` on each member of the object pointed to by `ptr`.
+
+* **__typeinfo**(id: `u32`): `RTTIFlags`<br />
+  Obtains the runtime type information for objects with the specified runtime id. Runtime type information is a set of flags indicating whether a type is managed, an array or similar, and what the relevant alignments when creating an instance externally are etc.
+
+ITCMS / `--runtime incremental`
+-----
+
+The Incremental Tri-Color Mark & Sweep garbage collector maintains a separate shadow stack of managed values in the background to achieve full automation. Maintaining another stack introduces some overhead compared to the simpler Two-Color Mark & Sweep garbage collector, but makes it independent of whether the execution stack is unwound or not when it is invoked, so the garbage collector can run interleaved with the program.
+
+There are several constants one can experiment with to tweak ITCMS's automation:
+
+* `--use ASC_GC_GRANULARITY=1024`<br />
+  How often to interrupt. The default of 1024 means "interrupt each 1024 bytes allocated".
+* `--use ASC_GC_STEPFACTOR=200`<br />
+  How long to interrupt. The default of 200% means "run at double the speed of allocations".
+* `--use ASC_GC_IDLEFACTOR=200`<br />
+  How long to idle. The default of 200% means "wait for memory to double before kicking in again".
+* `--use ASC_GC_MARKCOST=1`<br />
+  How costly it is to mark one object. Budget per interrupt is `GRANULARITY * STEPFACTOR / 100`.
+* `--use ASC_GC_SWEEPCOST=10`<br />
+  How costly it is to sweep one object. Budget per interrupt is `GRANULARITY * STEPFACTOR / 100`.
+
+TCMS / `--runtime minimal`
+----
+
+If automation and low pause times aren't strictly necessary, using the Two-Color Mark & Sweep garbage collector instead by invoking collection manually at appropriate times when the execution stack is unwound may be more performant as it simpler and has less overhead. The execution stack is typically unwound when invoking the collector externally, at a place that is not indirectly called from Wasm.
+
+STUB / `--runtime stub`
+----
+
+The stub is a maximally minimal runtime substitute, consisting of a simple and fast bump allocator with no means of freeing up memory again, except when freeing the respective most recently allocated object on top of the bump. Useful where memory is not a concern, and/or where it is sufficient to destroy the whole module including any potential garbage after execution.
+
+See also: [Garbage collection](https://www.assemblyscript.org/garbage-collection.html)

package/node_modules/assemblyscript/std/assembly/rt/common.ts

@@ -0,0 +1,81 @@
+// Alignment guarantees
+
+// @ts-ignore: decorator
+@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128
+// @ts-ignore: decorator
+@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;
+// @ts-ignore: decorator
+@inline export const AL_MASK: usize = AL_SIZE - 1;
+
+// Extra debugging
+
+// @ts-ignore: decorator
+@inline export const DEBUG = true;
+// @ts-ignore: decorator
+@inline export const TRACE = false;
+// @ts-ignore: decorator
+@inline export const RTRACE = isDefined(ASC_RTRACE);
+// @ts-ignore: decorator
+@inline export const PROFILE = isDefined(ASC_PROFILE);
+
+// Memory manager
+
+// ╒════════════ Memory manager block 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
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
+// │                           MM info                             │ -4
+// ╞>ptr═══════════════════════════════════════════════════════════╡
+// │                              ...                              │
+@unmanaged export class BLOCK {
+  /** Memory manager info. */
+  mmInfo: usize;
+}
+
+/** Overhead of a memory manager block. */
+// @ts-ignore: decorator
+@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();
+
+/** Maximum size of a memory manager block's payload. */
+// @ts-ignore: decorator
+@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;
+
+// Garbage collector
+
+// ╒══════════ Garbage collector 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
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
+// │                     Memory manager block                      │ -20
+// ╞═══════════════════════════════════════════════════════════════╡
+// │                            GC info                            │ -16
+// ├───────────────────────────────────────────────────────────────┤
+// │                            GC info                            │ -12
+// ├───────────────────────────────────────────────────────────────┤
+// │                            RT id                              │ -8
+// ├───────────────────────────────────────────────────────────────┤
+// │                            RT size                            │ -4
+// ╞>ptr═══════════════════════════════════════════════════════════╡
+// │                              ...                              │
+@unmanaged export class OBJECT extends BLOCK {
+  /** Garbage collector info. */
+  gcInfo: u32;
+  /** Garbage collector info. */
+  gcInfo2: u32;
+  /** Runtime class id. */
+  rtId: u32;
+  /** Runtime object size. */
+  rtSize: u32;
+}
+
+/** Overhead of a garbage collector object. Excludes memory manager block overhead. */
+// @ts-ignore: decorator
+@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;
+
+/** Maximum size of a garbage collector object's payload. */
+// @ts-ignore: decorator
+@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;
+
+/** Total of memory manager and garbage collector overhead. */
+// @ts-ignore: decorator
+@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;

package/node_modules/assemblyscript/std/assembly/rt/index-incremental.ts

@@ -0,0 +1,2 @@
+import "./tlsf";
+import "./itcms";

package/node_modules/assemblyscript/std/assembly/rt/index-minimal.ts

@@ -0,0 +1,2 @@
+import "./tlsf";
+import "./tcms";

package/node_modules/assemblyscript/std/assembly/rt/index-stub.ts

@@ -0,0 +1 @@
+import "./stub";

package/node_modules/assemblyscript/std/assembly/rt/index.d.ts

@@ -0,0 +1,37 @@
+// Memory manager
+declare function __alloc(size: usize): usize;
+declare function __realloc(ptr: usize, size: usize): usize;
+declare function __free(ptr: usize): void;
+declare function __reset(): void;
+
+// Garbage collector
+declare function __new(size: usize, id: u32): usize;
+declare function __renew(ptr: usize, size: usize): usize;
+declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;
+declare function __collect(): void;
+
+// Runtime type info
+declare function __typeinfo(id: u32): u32;
+
+// Visitors
+declare function __visit(ptr: usize, cookie: i32): void;
+declare function __visit_globals(cookie: u32): void;
+declare function __visit_members(ptr: usize, cookie: u32): void;
+
+// Allocation helpers
+declare function __newBuffer(size: usize, id: u32, data?: usize): usize;
+declare function __newArray(length: i32, alignLog2: usize, id: u32, data?: usize): usize;
+
+// Finalization
+declare function __finalize(ptr: usize): void;
+
+// Debugging
+declare const ASC_RTRACE: bool;
+declare const ASC_PROFILE: bool;
+
+// Incremental GC constants
+declare const ASC_GC_GRANULARITY: i32;
+declare const ASC_GC_SWEEPFACTOR: i32;
+declare const ASC_GC_IDLEFACTOR: i32;
+declare const ASC_GC_MARKCOST: i32;
+declare const ASC_GC_SWEEPCOST: i32;

package/node_modules/assemblyscript/std/assembly/rt/itcms.ts

@@ -0,0 +1,419 @@
+import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from "./common";
+import { onvisit, oncollect, oninterrupt, onyield } from "./rtrace";
+import { TypeinfoFlags } from "../shared/typeinfo";
+import { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from "../util/error";
+
+// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===
+// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc
+
+// ╒═════════════╤══════════════ Colors ═══════════════════════════╕
+// │ Color       │ Meaning                                         │
+// ├─────────────┼─────────────────────────────────────────────────┤
+// │ WHITE*      │ Unprocessed                                     │
+// │ BLACK*      │ Processed                                       │
+// │ GRAY        │ Processed with unprocessed children             │
+// │ TRANSPARENT │ Manually pinned (always reachable)              │
+// └─────────────┴─────────────────────────────────────────────────┘
+// * flipped between cycles
+
+// @ts-ignore: decorator
+@lazy let white = 0;
+// @ts-ignore: decorator
+@inline const gray = 2;
+// @ts-ignore: decorator
+@inline const transparent = 3;
+// @ts-ignore: decorator
+@inline const COLOR_MASK = 3;
+
+/** Size in memory of all objects currently managed by the GC. */
+// @ts-ignore: decorator
+@lazy let total: usize = 0;
+
+/** Currently transitioning from SWEEP to MARK state. */
+// @ts-ignore: decorator
+@inline const STATE_IDLE = 0;
+/** Currently marking reachable objects. */
+// @ts-ignore: decorator
+@inline const STATE_MARK = 1;
+/** Currently sweeping unreachable objects. */
+// @ts-ignore: decorator
+@inline const STATE_SWEEP = 2;
+/** Current collector state. */
+// @ts-ignore: decorator
+@lazy let state = STATE_IDLE;
+
+// @ts-ignore: decorator
+@lazy let fromSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));
+// @ts-ignore: decorator
+@lazy let toSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));
+// @ts-ignore: decorator
+@lazy let pinSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));
+// @ts-ignore: decorator
+@lazy let iter: Object = changetype<Object>(0); // unsafe initializion below
+
+function initLazy(space: Object): Object {
+  space.nextWithColor = changetype<usize>(space);
+  space.prev = space;
+  return space;
+}
+
+/** Visit cookie indicating scanning of an object. */
+// @ts-ignore: decorator
+@inline const VISIT_SCAN = 0;
+
+// ╒═══════════════ 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
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
+// │                      Memory manager block                     │
+// ╞═══════════════════════════════════════════════════════════╤═══╡
+// │                              next                         │ C │ = nextWithColor
+// ├───────────────────────────────────────────────────────────┴───┤
+// │                              prev                             │
+// ├───────────────────────────────────────────────────────────────┤
+// │                              rtId                             │
+// ├───────────────────────────────────────────────────────────────┤
+// │                              rtSize                           │
+// ╞>ptr═══════════════════════════════════════════════════════════╡
+// │                               ...                             │
+// C: color
+
+/** Represents a managed object in memory, consisting of a header followed by the object's data. */
+@unmanaged class Object extends BLOCK {
+  /** Pointer to the next object with color flags stored in the alignment bits. */
+  nextWithColor: usize; // *u32
+  /** Pointer to the previous object. */
+  prev: Object; // *u32
+  /** Runtime id. */
+  rtId: u32;
+  /** Runtime size. */
+  rtSize: u32;
+
+  /** Gets the pointer to the next object. */
+  get next(): Object {
+    return changetype<Object>(this.nextWithColor & ~COLOR_MASK);
+  }
+
+  /** Sets the pointer to the next object. */
+  set next(obj: Object) {
+    this.nextWithColor = changetype<usize>(obj) | (this.nextWithColor & COLOR_MASK);
+  }
+
+  /** Gets this object's color. */
+  get color(): i32 {
+    return i32(this.nextWithColor & COLOR_MASK);
+  }
+
+  /** Sets this object's color. */
+  set color(color: i32) {
+    this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;
+  }
+
+  /** Gets the size of this object in memory. */
+  get size(): usize {
+    return BLOCK_OVERHEAD + (this.mmInfo & ~3);
+  }
+
+  /** Tests if this object is pointerfree. */
+  get isPointerfree(): bool {
+    let rtId = this.rtId;
+    // 0: Object, 1: ArrayBuffer, 2: String
+    return rtId <= idof<string>() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;
+  }
+
+  /** Unlinks this object from its list. */
+  unlink(): void {
+    let next = this.next;
+    if (next == null) {
+      if (DEBUG) assert(this.prev == null && changetype<usize>(this) < __heap_base);
+      return; // static data not yet linked
+    }
+    let prev = this.prev;
+    if (DEBUG) assert(prev);
+    next.prev = prev;
+    prev.next = next;
+  }
+
+  /** Links this object to the specified list, with the given color. */
+  linkTo(list: Object, withColor: i32): void {
+    let prev = list.prev;
+    this.nextWithColor = changetype<usize>(list) | withColor;
+    this.prev = prev;
+    prev.next = this;
+    list.prev = this;
+  }
+
+  /** Marks this object as gray, that is reachable with unscanned children. */
+  makeGray(): void {
+    if (this == iter) iter = assert(this.prev);
+    this.unlink();
+    this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);
+  }
+}
+
+/** Visits all objects considered to be program roots. */
+function visitRoots(cookie: u32): void {
+  __visit_globals(cookie);
+  let pn = pinSpace;
+  let iter = pn.next;
+  while (iter != pn) {
+    if (DEBUG) assert(iter.color == transparent);
+    __visit_members(changetype<usize>(iter) + TOTAL_OVERHEAD, cookie);
+    iter = iter.next;
+  }
+}
+
+/** Visits all objects on the stack. */
+function visitStack(cookie: u32): void {
+  let ptr = __stack_pointer;
+  while (ptr < __heap_base) {
+    __visit(load<usize>(ptr), cookie);
+    ptr += sizeof<usize>();
+  }
+}
+
+/** Performs a single step according to the current state. */
+function step(): usize {
+  // Magic constants responsible for pause times. Obtained experimentally
+  // using the compiler compiling itself. 2048 budget pro run by default.
+  const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;
+  const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;
+  let obj: Object;
+  switch (state) {
+    case STATE_IDLE: {
+      state = STATE_MARK;
+      visitCount = 0;
+      visitRoots(VISIT_SCAN);
+      iter = toSpace;
+      return visitCount * MARKCOST;
+    }
+    case STATE_MARK: {
+      let black = i32(!white);
+      obj = iter.next;
+      while (obj != toSpace) {
+        iter = obj;
+        if (obj.color != black) { // skip already-blacks (pointerfree)
+          obj.color = black;
+          visitCount = 0;
+          __visit_members(changetype<usize>(obj) + TOTAL_OVERHEAD, VISIT_SCAN);
+          return visitCount * MARKCOST;
+        }
+        obj = obj.next;
+      }
+      visitCount = 0;
+      visitRoots(VISIT_SCAN);
+      obj = iter.next;
+      if (obj == toSpace) {
+        visitStack(VISIT_SCAN);
+        obj = iter.next;
+        while (obj != toSpace) {
+          if (obj.color != black) {
+            obj.color = black;
+            __visit_members(changetype<usize>(obj) + TOTAL_OVERHEAD, VISIT_SCAN);
+          }
+          obj = obj.next;
+        }
+        let from = fromSpace;
+        fromSpace = toSpace;
+        toSpace = from;
+        white = black;
+        iter = from.next;
+        state = STATE_SWEEP;
+      }
+      return visitCount * MARKCOST;
+    }
+    case STATE_SWEEP: {
+      obj = iter;
+      if (obj != toSpace) {
+        iter = obj.next;
+        if (DEBUG) assert(obj.color == i32(!white)); // old white
+        free(obj);
+        return SWEEPCOST;
+      }
+      toSpace.nextWithColor = changetype<usize>(toSpace);
+      toSpace.prev = toSpace;
+      state = STATE_IDLE;
+      break;
+    }
+  }
+  return 0;
+}
+
+/** Frees an object. */
+function free(obj: Object): void {
+  if (changetype<usize>(obj) < __heap_base) {
+    obj.nextWithColor = 0; // may become linked again
+    obj.prev = changetype<Object>(0);
+  } else {
+    total -= obj.size;
+    if (isDefined(__finalize)) {
+      __finalize(changetype<usize>(obj) + TOTAL_OVERHEAD);
+    }
+    __free(changetype<usize>(obj) + BLOCK_OVERHEAD);
+  }
+}
+
+// Garbage collector interface
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __new(size: usize, id: i32): usize {
+  if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);
+  if (total >= threshold) interrupt();
+  let obj = changetype<Object>(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);
+  obj.rtId = id;
+  obj.rtSize = <u32>size;
+  obj.linkTo(fromSpace, white); // inits next/prev
+  total += obj.size;
+  let ptr = changetype<usize>(obj) + TOTAL_OVERHEAD;
+  // may be visited before being fully initialized, so must fill
+  memory.fill(ptr, 0, size);
+  return ptr;
+}
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __renew(oldPtr: usize, size: usize): usize {
+  let oldObj = changetype<Object>(oldPtr - TOTAL_OVERHEAD);
+  // Update object size if its block is large enough
+  if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {
+    oldObj.rtSize = <u32>size;
+    return oldPtr;
+  }
+  // If not the same object anymore, we have to move it move it due to the
+  // shadow stack potentially still referencing the old object
+  let newPtr = __new(size, oldObj.rtId);
+  memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));
+  return newPtr;
+}
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {
+  // Write barrier is unnecessary if non-incremental
+  if (!childPtr) return;
+  if (DEBUG) assert(parentPtr);
+  let child = changetype<Object>(childPtr - TOTAL_OVERHEAD);
+  if (child.color == white) {
+    let parent = changetype<Object>(parentPtr - TOTAL_OVERHEAD);
+    let parentColor = parent.color;
+    if (parentColor == i32(!white)) {
+      // Maintain the invariant that no black object may point to a white object.
+      if (expectMultiple) {
+        // Move the barrier "backward". Suitable for containers receiving multiple stores.
+        // Avoids a barrier for subsequent objects stored into the same container.
+        parent.makeGray();
+      } else {
+        // Move the barrier "forward". Suitable for objects receiving isolated stores.
+        child.makeGray();
+      }
+    } else if (parentColor == transparent && state == STATE_MARK) {
+      // Pinned objects are considered 'black' during the mark phase.
+      child.makeGray();
+    }
+  }
+}
+
+// @ts-ignore: decorator
+@lazy let visitCount = 0;
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __visit(ptr: usize, cookie: i32): void {
+  if (!ptr) return;
+  let obj = changetype<Object>(ptr - TOTAL_OVERHEAD);
+  if (RTRACE) if (!onvisit(obj)) return;
+  if (obj.color == white) {
+    obj.makeGray();
+    ++visitCount;
+  }
+}
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __pin(ptr: usize): usize {
+  if (ptr) {
+    let obj = changetype<Object>(ptr - TOTAL_OVERHEAD);
+    if (obj.color == transparent) {
+      throw new Error(E_ALREADY_PINNED);
+    }
+    obj.unlink(); // from fromSpace
+    obj.linkTo(pinSpace, transparent);
+  }
+  return ptr;
+}
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __unpin(ptr: usize): void {
+  if (!ptr) return;
+  let obj = changetype<Object>(ptr - TOTAL_OVERHEAD);
+  if (obj.color != transparent) {
+    throw new Error(E_NOT_PINNED);
+  }
+  if (state == STATE_MARK) {
+    // We may be right at the point after marking roots for the second time and
+    // entering the sweep phase, in which case the object would be missed if it
+    // is not only pinned but also a root. Make sure it isn't missed.
+    obj.makeGray();
+  } else {
+    obj.unlink();
+    obj.linkTo(fromSpace, white);
+  }
+}
+
+// @ts-ignore: decorator
+@global @unsafe
+export function __collect(): void {
+  if (TRACE) trace("GC (full) at", 1, total);
+  if (state > STATE_IDLE) {
+    // finish current cycle
+    while (state != STATE_IDLE) step();
+  }
+  // perform a full cycle
+  step();
+  while (state != STATE_IDLE) step();
+  threshold = <usize>(<u64>total * IDLEFACTOR / 100) + GRANULARITY;
+  if (TRACE) trace("GC (full) done at cur/max", 2, total, memory.size() << 16);
+  if (RTRACE || PROFILE) oncollect(total);
+}
+
+// Garbage collector automation
+
+/** How often to interrupt. The default of 1024 means "interrupt each 1024 bytes allocated". */
+// @ts-ignore: decorator
+@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;
+/** How long to interrupt. The default of 200% means "run at double the speed of allocations". */
+// @ts-ignore: decorator
+@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;
+/** How long to idle. The default of 200% means "wait for memory to double before kicking in again". */
+// @ts-ignore: decorator
+@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;
+
+/** Threshold of memory used by objects to exceed before interrupting again. */
+// @ts-ignore: decorator
+@lazy let threshold: usize = ((<usize>memory.size() << 16) - __heap_base) >> 1;
+
+/** Performs a reasonable amount of incremental GC steps. */
+function interrupt(): void {
+  if (PROFILE) oninterrupt(total);
+  if (TRACE) trace("GC (auto) at", 1, total);
+  let budget: isize = GRANULARITY * STEPFACTOR / 100;
+  do {
+    budget -= step();
+    if (state == STATE_IDLE) {
+      if (TRACE) trace("└ GC (auto) done at cur/max", 2, total, memory.size() << 16);
+      if (IDLEFACTOR % 100 == 0) {
+        // optimization for the default GC parameters which idle factor is 200%
+        threshold = total * (IDLEFACTOR / 100) + GRANULARITY;
+      } else {
+        threshold = <usize>((<u64>total * IDLEFACTOR) / 100) + GRANULARITY;
+      }
+      if (PROFILE) onyield(total);
+      return;
+    }
+  } while (budget > 0);
+  if (TRACE) trace("└ GC (auto) ongoing at", 1, total);
+  threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);
+  if (PROFILE) onyield(total);
+}

package/node_modules/assemblyscript/std/assembly/rt/rtrace.ts

@@ -0,0 +1,15 @@
+import { BLOCK } from "./common";
+
+export declare function oninit(heapBase: usize): void;
+
+// Memory Allocator
+export declare function onalloc(block: BLOCK): void;
+export declare function onresize(block: BLOCK, oldSizeInclOverhead: usize): void;
+export declare function onmove(oldBlock: BLOCK, newBlock: BLOCK): void;
+export declare function onfree(block: BLOCK): void;
+
+// Garbage collector
+export declare function onvisit(block: BLOCK): bool;
+export declare function oncollect(total: usize): void;
+export declare function oninterrupt(total: usize): void;
+export declare function onyield(total: usize): void;