Expose new ASC_RUNTIME compiletime constant. Avoid mem cleanups in std containers for Incremental Runtime (AssemblyScript#2122)

Author: MaxGraey

cli/asc.js

@@ -426,9 +426,15 @@ exports.main = function main(argv, options, callback) {
   }
 
   // Set up options
-  var program;
+  var program, runtime;
   const compilerOptions = __pin(assemblyscript.newOptions());
+  switch (opts.runtime) {
+    case "stub": runtime = 0; break;
+    case "minimal": runtime = 1; break;
+    default: runtime = 2; break;
+  }
   assemblyscript.setTarget(compilerOptions, 0);
+  assemblyscript.setRuntime(compilerOptions, runtime);
   assemblyscript.setNoAssert(compilerOptions, opts.noAssert);
   assemblyscript.setExportMemory(compilerOptions, !opts.noExportMemory);
   assemblyscript.setImportMemory(compilerOptions, opts.importMemory);

src/common.ts

@@ -158,7 +158,7 @@ export namespace CommonNames {
   export const constructor = "constructor";
   // constants
   export const ASC_TARGET = "ASC_TARGET";
-  export const ASC_NO_TREESHAKING = "ASC_NO_TREESHAKING";
+  export const ASC_RUNTIME = "ASC_RUNTIME";
   export const ASC_NO_ASSERT = "ASC_NO_ASSERT";
   export const ASC_MEMORY_BASE = "ASC_MEMORY_BASE";
   export const ASC_TABLE_BASE = "ASC_TABLE_BASE";
@@ -256,4 +256,5 @@ export namespace CommonNames {
 // shared
 export { Feature, featureToString } from "../std/assembly/shared/feature";
 export { Target } from "../std/assembly/shared/target";
+export { Runtime } from "../std/assembly/shared/runtime";
 export { Typeinfo, TypeinfoFlags } from "../std/assembly/shared/typeinfo";

src/compiler.ts

@@ -64,6 +64,7 @@ import {
   CommonNames,
   Feature,
   Target,
+  Runtime,
   featureToString
 } from "./common";
 
@@ -212,6 +213,8 @@ export class Options {
 
   /** WebAssembly target. Defaults to {@link Target.WASM32}. */
   target: Target = Target.WASM32;
+  /** Runtime type. Defaults to Incremental GC. */
+  runtime: Runtime = Runtime.Incremental;
   /** If true, replaces assertions with nops. */
   noAssert: bool = false;
   /** It true, exports the memory to the embedder. */

src/index.ts

@@ -33,7 +33,7 @@
  * When compiling to WebAssembly `glue/wasm/index.ts` must be included.
  */
 
-import { Target, Feature } from "./common";
+import { Target, Runtime, Feature } from "./common";
 import { Compiler, Options } from "./compiler";
 import { IDLBuilder, TSDBuilder } from "./definitions";
 import { DiagnosticMessage, DiagnosticCategory, formatDiagnosticMessage } from "./diagnostics";
@@ -52,6 +52,10 @@ export function setTarget(options: Options, target: Target): void {
   options.target = target;
 }
 
+export function setRuntime(options: Options, runtime: Runtime): void {
+  options.runtime = runtime;
+}
+
 /** Sets the `noAssert` option. */
 export function setNoAssert(options: Options, noAssert: bool): void {
   options.noAssert = noAssert;

src/program.ts

@@ -1013,6 +1013,8 @@ export class Program extends DiagnosticEmitter {
     // register compiler hints
     this.registerConstantInteger(CommonNames.ASC_TARGET, Type.i32,
       i64_new(options.isWasm64 ? Target.WASM64 : Target.WASM32));
+    this.registerConstantInteger(CommonNames.ASC_RUNTIME, Type.i32,
+      i64_new(options.runtime));
     this.registerConstantInteger(CommonNames.ASC_NO_ASSERT, Type.bool,
       i64_new(options.noAssert ? 1 : 0, 0));
     this.registerConstantInteger(CommonNames.ASC_MEMORY_BASE, Type.i32,

std/assembly/array.ts

@@ -1,6 +1,7 @@
 /// <reference path="./rt/index.d.ts" />
 
 import { BLOCK_MAXSIZE } from "./rt/common";
+import { Runtime } from "shared/runtime";
 import { COMPARATOR, SORT } from "./util/sort";
 import { REVERSE } from "./util/bytes";
 import { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from "./util/string";
@@ -22,7 +23,11 @@ function ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: b
     let newCapacity = max(newSize, MIN_SIZE) << alignLog2;
     if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);
     let newData = __renew(oldData, newCapacity);
-    memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);
+    // __new / __renew already init memory range as zeros in Incremental runtime.
+    // So try to avoid this.
+    if (ASC_RUNTIME != Runtime.Incremental) {
+      memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);
+    }
     if (newData !== oldData) { // oldData has been free'd
       store<usize>(array, newData, offsetof<ArrayBufferView>("buffer"));
       store<usize>(array, newData, offsetof<ArrayBufferView>("dataStart"));
@@ -66,7 +71,9 @@ export class Array<T> {
     // reserve capacity for at least MIN_SIZE elements
     var bufferSize = max(<usize>length, MIN_SIZE) << alignof<T>();
     var buffer = changetype<ArrayBuffer>(__new(bufferSize, idof<ArrayBuffer>()));
-    memory.fill(changetype<usize>(buffer), 0, bufferSize);
+    if (ASC_RUNTIME != Runtime.Incremental) {
+      memory.fill(changetype<usize>(buffer), 0, bufferSize);
+    }
     this.buffer = buffer; // links
     this.dataStart = changetype<usize>(buffer);
     this.byteLength = <i32>bufferSize;

std/assembly/arraybuffer.ts

@@ -1,6 +1,7 @@
 /// <reference path="./rt/index.d.ts" />
 
 import { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from "./rt/common";
+import { Runtime } from "shared/runtime";
 import { idof } from "./builtins";
 import { E_INVALIDLENGTH } from "./util/error";
 
@@ -17,7 +18,9 @@ export abstract class ArrayBufferView {
   protected constructor(length: i32, alignLog2: i32) {
     if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);
     var buffer = changetype<ArrayBuffer>(__new(length = length << alignLog2, idof<ArrayBuffer>()));
-    memory.fill(changetype<usize>(buffer), 0, <usize>length);
+    if (ASC_RUNTIME != Runtime.Incremental) {
+      memory.fill(changetype<usize>(buffer), 0, <usize>length);
+    }
     this.buffer = buffer; // links
     this.dataStart = changetype<usize>(buffer);
     this.byteLength = length;
@@ -48,7 +51,9 @@ export abstract class ArrayBufferView {
   constructor(length: i32) {
     if (<u32>length > <u32>BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);
     var buffer = changetype<ArrayBuffer>(__new(<usize>length, idof<ArrayBuffer>()));
-    memory.fill(changetype<usize>(buffer), 0, <usize>length);
+    if (ASC_RUNTIME != Runtime.Incremental) {
+      memory.fill(changetype<usize>(buffer), 0, <usize>length);
+    }
     return buffer;
   }
 

std/assembly/index.d.ts

@@ -52,6 +52,8 @@ declare type dataref = object | null;
 
 /** Compiler target. 0 = JS, 1 = WASM32, 2 = WASM64. */
 declare const ASC_TARGET: i32;
+/** Runtime type. 0 = Stub, 1 = Minimal, 2 = Incremental. */
+declare const ASC_RUNTIME: i32;
 /** Provided noAssert option. */
 declare const ASC_NO_ASSERT: bool;
 /** Provided memoryBase option. */

std/assembly/shared/runtime.ts

@@ -0,0 +1,11 @@
+// This file is shared with the compiler and must remain portable
+
+/** Runtime types. */
+export enum Runtime {
+  /** Simple bump allocator without GC. */
+  Stub = 0,
+  /** Stop the world semi-automatic GC. */
+  Minimal = 1,
+  /** incremental GC. */
+  Incremental = 2,
+}

std/assembly/staticarray.ts

@@ -1,6 +1,7 @@
 /// <reference path="./rt/index.d.ts" />
 
 import { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from "./rt/common";
+import { Runtime } from "shared/runtime";
 import { COMPARATOR, SORT } from "./util/sort";
 import { REVERSE } from "./util/bytes";
 import { idof } from "./builtins";
@@ -90,7 +91,9 @@ export class StaticArray<T> {
     if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);
     var outSize = <usize>length << alignof<T>();
     var out = changetype<StaticArray<T>>(__new(outSize, idof<StaticArray<T>>()));
-    memory.fill(changetype<usize>(out), 0, outSize);
+    if (ASC_RUNTIME != Runtime.Incremental) {
+      memory.fill(changetype<usize>(out), 0, outSize);
+    }
     return out;
   }