@amxts/core 0.2.3 → 0.3.0

package/runtime/deps/assemblyscript/dist/asc.js

@@ -29,7 +29,11 @@ function ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: b
     // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.
     let newCapacity = max(newSize, MIN_SIZE) << alignLog2;
     if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);
-    let newData = __renew(oldData, newCapacity);
+    // amxts: elements kept in the array's own object (the constructor's
+    // \`inline\`) move out to a buffer of their own; the object stays.
+    let newData = oldData == array
+      ? moveOut(changetype<ArrayBufferView>(array).dataStart, oldCapacity, newCapacity)
+      : __renew(oldData, newCapacity);
     // __new / __renew already init memory range as zeros in Incremental runtime.
     // So try to avoid this.
     if (ASC_RUNTIME != Runtime.Incremental) {
@@ -44,6 +48,13 @@ function ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: b
   }
 }
 
+// amxts: a new buffer of \`capacity\` bytes, starting with the \`size\` bytes at \`data\`.
+function moveOut(data: usize, size: usize, capacity: usize): usize {
+  let buffer = __new(capacity, idof<ArrayBuffer>());
+  memory.copy(buffer, data, size);
+  return buffer;
+}
+
 export class Array<T> {
   [key: number]: T;
 
@@ -73,17 +84,28 @@ export class Array<T> {
     return array;
   }
 
-  constructor(length: i32 = 0) {
-    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);
-    // reserve capacity for at least MIN_SIZE elements
-    let bufferSize = max(<usize>length, MIN_SIZE) << alignof<T>();
-    let buffer = changetype<ArrayBuffer>(__new(bufferSize, idof<ArrayBuffer>()));
-    if (ASC_RUNTIME != Runtime.Incremental) {
-      memory.fill(changetype<usize>(buffer), 0, bufferSize);
+  // amxts: \`inline\` makes an array of \`length\` with no buffer: the subclass
+  // that asks for it points the array at room in its own object (Vector), so
+  // it is one allocation, its own buffer until it grows past that room.
+  // Inlined: a constant \`inline\` leaves one of the two paths.
+  // @ts-ignore: decorator
+  @inline constructor(length: i32 = 0, inline: bool = false) {
+    if (inline) {
+      this.buffer = changetype<ArrayBuffer>(0);
+      this.dataStart = 0;
+      this.byteLength = 0;
+    } else {
+      if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);
+      // reserve capacity for at least MIN_SIZE elements
+      let bufferSize = max(<usize>length, MIN_SIZE) << alignof<T>();
+      let buffer = changetype<ArrayBuffer>(__new(bufferSize, idof<ArrayBuffer>()));
+      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;
     }
-    this.buffer = buffer; // links
-    this.dataStart = changetype<usize>(buffer);
-    this.byteLength = <i32>bufferSize;
     this.length_ = length;
   }
 
@@ -319,6 +341,17 @@ export class Array<T> {
     return out;
   }
 
+  // amxts: flatMap, as in JavaScript, for a function that returns an array:
+  // its elements, one array after another.
+  flatMap<U>(fn: (value: T, index: i32, array: Array<T>) => Array<U>): Array<U> {
+    let out = changetype<Array<U>>(__newArray(0, alignof<U>(), idof<Array<U>>()));
+    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {
+      let part = fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this);
+      for (let j = 0, count = part.length_; j < count; ++j) out.push(load<U>(part.dataStart + (<usize>j << alignof<U>())));
+    }
+    return out;
+  }
+
   filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
     let result = changetype<Array<T>>(__newArray(0, alignof<T>(), idof<Array<T>>()));
     for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {
@@ -462,7 +495,7 @@ export class Array<T> {
     return this;
   }
 
-  sort(comparator: (a: T, b: T) => i32 = COMPARATOR<T>()): Array<T> {
+  sort(comparator: (a: T, b: T) => f64 = COMPARATOR<T>()): Array<T> {
     SORT<T>(this.dataStart, this.length_, comparator);
     return this;
   }
@@ -4646,13 +4679,15 @@ export function __box<T>(value: T): usize {
   return changetype<usize>(new __Box<T>(value));
 }
 
-/** amxts: what the box holds. */
-export function __box_get<T>(box: usize): T {
+/** amxts: what the box holds - a load where it is read, not a call. */
+// @ts-ignore: decorator
+@inline export function __box_get<T>(box: usize): T {
   return changetype<__Box<T>>(box).value;
 }
 
-/** amxts: \`value\` into the box, and back. */
-export function __box_set<T>(box: usize, value: T): T {
+/** amxts: \`value\` into the box, and back - a store where it is written, not a call. */
+// @ts-ignore: decorator
+@inline export function __box_set<T>(box: usize, value: T): T {
   changetype<__Box<T>>(box).value = value;
   return value;
 }
@@ -11195,7 +11230,25 @@ function visitRoots(cookie: u32): void {
 function visitStack(cookie: u32): void {
   let ptr = __stack_pointer;
   while (ptr < __heap_base) {
-    __visit(load<usize>(ptr), cookie);
+    let word = load<usize>(ptr);
+    // amxts: a function's objects made in its frame, behind a mark and the
+    // bytes they take (src/passes/stackobjects.ts): stepped over, or, behind
+    // -2, each one whose slot has 1 at 8 visited as an object on the heap is
+    if (word == <usize>-1 || word == <usize>-2) {
+      let end = ptr + load<usize>(ptr, sizeof<usize>());
+      if (word == <usize>-2) {
+        // a slot: 12 bytes, the object's header, the object, to 16 bytes
+        let slot = ptr;
+        while (slot + 32 <= end) {
+          let obj = slot + 32;
+          if (load<u32>(slot, 8)) __visit_members(obj, cookie);
+          slot = obj + ((<usize>load<u32>(obj - 4) + 15) & ~15);
+        }
+      }
+      ptr = end;
+      continue;
+    }
+    __visit(word, cookie);
     ptr += sizeof<usize>();
   }
 }
@@ -11287,7 +11340,9 @@ function free(obj: Object): void {
 @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();
+  // amxts: ASC_GC_STRESS steps the collector on every allocation, for the
+  // tests of what the shadow stack keeps
+  if (isDefined(ASC_GC_STRESS) || total >= threshold) interrupt();
   let obj = changetype<Object>(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);
   obj.rtId = id;
   obj.rtSize = <u32>size;
@@ -11401,7 +11456,7 @@ export function __collect(): void {
   // perform a full cycle
   step();
   while (state != STATE_IDLE) step();
-  threshold = <usize>(<u64>total * IDLEFACTOR / 100) + GRANULARITY;
+  threshold = <usize>(<u64>total * IDLEFACTOR / 100) + IDLEGAP;
   if (TRACE) trace("GC (full) done at cur/max", 2, total, memory.size() << 16);
   if (RTRACE || PROFILE) oncollect(total);
 }
@@ -11418,6 +11473,14 @@ export function __collect(): void {
 // @ts-ignore: decorator
 @inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;
 
+/**
+ * amxts: how much more is allocated, at least, before the next cycle starts.
+ * A cycle visits every root and every live object: with a small heap and
+ * the gap GRANULARITY alone, it ran every few hundred allocations.
+ */
+// @ts-ignore: decorator
+@inline const IDLEGAP: usize = isDefined(ASC_GC_IDLEGAP) ? ASC_GC_IDLEGAP : 1024 * 1024;
+
 /** 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;
@@ -11433,9 +11496,9 @@ function interrupt(): void {
       if (TRACE) trace("\u2514 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;
+        threshold = total * (IDLEFACTOR / 100) + IDLEGAP;
       } else {
-        threshold = <usize>((<u64>total * IDLEFACTOR) / 100) + GRANULARITY;
+        threshold = <usize>((<u64>total * IDLEFACTOR) / 100) + IDLEGAP;
       }
       if (PROFILE) onyield(total);
       return;
@@ -12405,6 +12468,19 @@ export function freeBlock(root: Root, block: Block): void {
   insertBlock(root, block);
 }
 
+// amxts: a small block freed goes on a list of its size, and the next
+// allocation of that size takes it back: no search, split or merge. It stays
+// a used block to TLSF, so no neighbour merges with it, and it is not given
+// back to TLSF for other sizes. Its first word links the list. The sizes are
+// TLSF's own (16 n + 12 on 32 bits), a list each, up to SMALL_MAX.
+
+// @ts-ignore: decorator
+@inline const SMALL_MAX: usize = 124;
+
+/** The lists' heads, by a block's size >> AL_BITS. */
+// @ts-ignore: decorator
+@lazy let SMALL = memory.data(<i32>(((SMALL_MAX >> AL_BITS) + 1) << alignof<usize>()));
+
 /** Checks that a used block is valid to be freed or reallocated. */
 function checkUsedBlock(ptr: usize): Block {
   let block = changetype<Block>(ptr - BLOCK_OVERHEAD);
@@ -12418,6 +12494,14 @@ function checkUsedBlock(ptr: usize): Block {
 // @ts-ignore: decorator
 @global @unsafe
 export function __alloc(size: usize): usize {
+  if (size <= SMALL_MAX) {
+    let head = SMALL + (computeSize(size) >> AL_BITS << alignof<usize>());
+    let block = load<usize>(head);
+    if (block) {
+      store<usize>(head, load<usize>(block, BLOCK_OVERHEAD));
+      return block + BLOCK_OVERHEAD;
+    }
+  }
   if (!ROOT) initialize();
   return changetype<usize>(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;
 }
@@ -12436,8 +12520,16 @@ export function __realloc(ptr: usize, size: usize): usize {
 @global @unsafe
 export function __free(ptr: usize): void {
   if (ptr < __heap_base) return;
+  let block = checkUsedBlock(ptr);
+  let size = block.mmInfo & ~TAGS_MASK;
+  if (size <= SMALL_MAX) {
+    let head = SMALL + (size >> AL_BITS << alignof<usize>());
+    store<usize>(ptr, load<usize>(head));
+    store<usize>(head, changetype<usize>(block));
+    return;
+  }
   if (!ROOT) initialize();
-  freeBlock(ROOT, checkUsedBlock(ptr));
+  freeBlock(ROOT, block);
 }
 `,set:`/// <reference path="./rt/index.d.ts" />
 
@@ -13206,7 +13298,7 @@ export class StaticArray<T> {
     return false;
   }
 
-  sort(comparator: (a: T, b: T) => i32 = COMPARATOR<T>()): StaticArray<T> {
+  sort(comparator: (a: T, b: T) => f64 = COMPARATOR<T>()): StaticArray<T> {
     SORT<T>(changetype<usize>(this), this.length, comparator);
     return this;
   }
@@ -14356,7 +14448,7 @@ export class Int8Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {
+  sort(comparator: (a: i8, b: i8) => f64 = COMPARATOR<i8>()): Int8Array {
     SORT<i8>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -14498,7 +14590,7 @@ export class Uint8Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {
+  sort(comparator: (a: u8, b: u8) => f64 = COMPARATOR<u8>()): Uint8Array {
     SORT<u8>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -14641,7 +14733,7 @@ export class Uint8ClampedArray extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {
+  sort(comparator: (a: u8, b: u8) => f64 = COMPARATOR<u8>()): Uint8ClampedArray {
     SORT<u8>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -14783,7 +14875,7 @@ export class Int16Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {
+  sort(comparator: (a: i16, b: i16) => f64 = COMPARATOR<i16>()): Int16Array {
     SORT<i16>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -14925,7 +15017,7 @@ export class Uint16Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {
+  sort(comparator: (a: u16, b: u16) => f64 = COMPARATOR<u16>()): Uint16Array {
     SORT<u16>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15067,7 +15159,7 @@ export class Int32Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {
+  sort(comparator: (a: i32, b: i32) => f64 = COMPARATOR<i32>()): Int32Array {
     SORT<i32>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15209,7 +15301,7 @@ export class Uint32Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {
+  sort(comparator: (a: u32, b: u32) => f64 = COMPARATOR<u32>()): Uint32Array {
     SORT<u32>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15351,7 +15443,7 @@ export class Int64Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {
+  sort(comparator: (a: i64, b: i64) => f64 = COMPARATOR<i64>()): Int64Array {
     SORT<i64>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15493,7 +15585,7 @@ export class Uint64Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {
+  sort(comparator: (a: u64, b: u64) => f64 = COMPARATOR<u64>()): Uint64Array {
     SORT<u64>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15635,7 +15727,7 @@ export class Float32Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {
+  sort(comparator: (a: f32, b: f32) => f64 = COMPARATOR<f32>()): Float32Array {
     SORT<f32>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -15777,7 +15869,7 @@ export class Float64Array extends ArrayBufferView {
     return this;
   }
 
-  sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {
+  sort(comparator: (a: f64, b: f64) => f64 = COMPARATOR<f64>()): Float64Array {
     SORT<f64>(this.dataStart, this.length, comparator);
     return this;
   }
@@ -20132,7 +20224,9 @@ function wholeWithoutFraction(buffer: usize, length: i32): i32 {
 }
 `,"util/sort":`import { compareImpl } from "./string";
 
-type Comparator<T> = (a: T, b: T) => i32;
+// amxts: a comparator returns a number, and its sign orders two elements, as
+// in JavaScript: \`(a, b) => a - b\` sorts fractions too. NaN is 0, equal.
+type Comparator<T> = (a: T, b: T) => f64;
 
 // @ts-ignore: decorator
 @lazy @inline const EMPTY = u32.MAX_VALUE;
@@ -20338,7 +20432,7 @@ function insertionSort<T>(
       let a = load<T>(ptr + (<usize>i << alignof<T>()), 0);
       let b = load<T>(ptr + (<usize>i << alignof<T>()), 1 << alignof<T>());
       let min = b, max = a;
-      if (comparator(a, b) <= 0) {
+      if (!(comparator(a, b) > 0)) {
         min = a, max = b;
       }
       let j = i - 1;
@@ -20384,10 +20478,10 @@ function extendRunRight<T>(
   ) > 0) {
     while (
       j < right &&
-      (comparator(
+      comparator(
         load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),
         load<T>(ptr + (<usize>j << alignof<T>()))
-      ) >>> 31) // < 0
+      ) < 0
     ) ++j;
     // reverse
     let k = j;
@@ -20399,10 +20493,10 @@ function extendRunRight<T>(
   } else {
     while (
       j < right &&
-      comparator(
+      !(comparator(
         load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),
         load<T>(ptr + (<usize>j << alignof<T>()))
-      ) >= 0
+      ) < 0)
     ) ++j;
   }
   return j;
@@ -24010,7 +24104,7 @@ declare class Array<T> {
   unshift(element: T): i32;
   slice(from?: i32, to?: i32): Array<T>;
   splice(start: i32, deleteCount?: i32, ...items: T[]): Array<T>;
-  sort(comparator?: (a: T, b: T) => i32): this;
+  sort(comparator?: (a: T, b: T) => f64): this;
   join(separator?: string): string;
   reverse(): this;
   /** Flattens an array of arrays. If any null entries exist in the array, they are ignored, unlike JavaScript's version of Array#flat(). */
@@ -24047,7 +24141,7 @@ declare class StaticArray<T> {
   concat<U extends ArrayLike<T>>(other: U): U;
   slice(from?: i32, to?: i32): Array<T>;
   slice<U extends ArrayLike<T>>(from?: i32, to?: i32): U;
-  sort(comparator?: (a: T, b: T) => i32): this;
+  sort(comparator?: (a: T, b: T) => f64): this;
   join(separator?: string): string;
   reverse(): this;
   toString(): string;