diff --git a/src/builtins.ts b/src/builtins.ts
index b1b68204..50a79d2b 100644
--- a/src/builtins.ts
+++ b/src/builtins.ts
@@ -484,10 +484,8 @@ export namespace BuiltinSymbols {
export const runtime_register = "~lib/runtime/runtime.register";
export const runtime_discard = "~lib/runtime/runtime.discard";
export const runtime_newArray = "~lib/runtime/runtime.newArray";
-
- // std/gc.ts
- export const gc_mark_roots = "~lib/gc/__gc_mark_roots";
- export const gc_mark_members = "~lib/gc/__gc_mark_members";
+ export const gc_mark_roots = "~lib/runtime/__gc_mark_roots";
+ export const gc_mark_members = "~lib/runtime/__gc_mark_members";
// std/typedarray.ts
export const Int8Array = "~lib/typedarray/Int8Array";
diff --git a/std/assembly/array.ts b/std/assembly/array.ts
index 47047e3a..2af424d4 100644
--- a/std/assembly/array.ts
+++ b/std/assembly/array.ts
@@ -1,13 +1,12 @@
///
-import { MAX_BYTELENGTH } from "./util/runtime";
+import { MAX_BYTELENGTH, reallocate } from "./util/runtime";
import { COMPARATOR, SORT } from "./util/sort";
-import { runtime, __runtime_id } from "./runtime";
+import { runtime, __runtime_id, __gc_mark_members } from "./runtime";
import { ArrayBuffer, ArrayBufferView } from "./arraybuffer";
import { itoa, dtoa, itoa_stream, dtoa_stream, MAX_DOUBLE_LENGTH } from "./util/number";
import { isArray as builtin_isArray } from "./builtins";
import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from "./util/error";
-import { __gc_mark_members } from "./gc";
/** Ensures that the given array has _at least_ the specified capacity. */
function ensureCapacity(array: ArrayBufferView, minCapacity: i32, alignLog2: u32): void {
@@ -15,7 +14,7 @@ function ensureCapacity(array: ArrayBufferView, minCapacity: i32, alignLog2: u32
if (minCapacity > (MAX_BYTELENGTH >>> alignLog2)) throw new RangeError(E_INVALIDLENGTH);
let oldData = array.data;
let newByteLength = minCapacity << alignLog2;
- let newData = runtime.reallocate(changetype(oldData), newByteLength); // registers on move
+ let newData = reallocate(changetype(oldData), newByteLength); // registers on move
if (newData !== changetype(oldData)) {
array.data = changetype(newData); // links
array.dataStart = newData;
diff --git a/std/assembly/collector/itcm.ts b/std/assembly/collector/itcm.ts
index a7704ef9..83fa90e8 100644
--- a/std/assembly/collector/itcm.ts
+++ b/std/assembly/collector/itcm.ts
@@ -5,7 +5,7 @@
const TRACE = isDefined(GC_TRACE);
import { HEADER_SIZE } from "../util/runtime";
-import { __gc_mark_roots, __gc_mark_members } from "../gc";
+import { __gc_mark_roots, __gc_mark_members } from "../runtime";
/** Collector states. */
const enum State {
diff --git a/std/assembly/fixedarray.ts b/std/assembly/fixedarray.ts
index 0602b2eb..40463ad5 100644
--- a/std/assembly/fixedarray.ts
+++ b/std/assembly/fixedarray.ts
@@ -1,7 +1,6 @@
import { HEADER, HEADER_SIZE, MAX_BYTELENGTH } from "./util/runtime";
-import { runtime, __runtime_id } from "./runtime";
+import { runtime, __runtime_id, __gc_mark_members } from "./runtime";
import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from "./util/error";
-import { __gc_mark_members } from "./gc";
// NOTE: DO NOT USE YET!
diff --git a/std/assembly/gc.ts b/std/assembly/gc.ts
deleted file mode 100644
index f19fc4a1..00000000
--- a/std/assembly/gc.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-///
-
-import { E_NOTIMPLEMENTED } from "./util/error";
-
-/** Marks root objects. */
-// @ts-ignore: decorator
-@unsafe @builtin
-export declare function __gc_mark_roots(): void;
-
-/** Marks class members. */
-// @ts-ignore: decorator
-@unsafe @builtin
-export declare function __gc_mark_members(classId: u32, ref: usize): void;
-
-// @ts-ignore
-@lazy
-var ROOT = new Set();
-
-/** Garbage collector interface. */
-export namespace gc {
-
- /** Whether the garbage collector interface is implemented. */
- // @ts-ignore: decorator
- @lazy
- export const implemented: bool = isDefined(__ref_collect);
-
- /** Performs a full garbage collection cycle. */
- export function collect(): void {
- if (isDefined(__ref_collect)) __ref_collect();
- else throw new Error(E_NOTIMPLEMENTED);
- }
-
- /** Retains a managed object externally, making sure that it doesn't become collected. */
- // @ts-ignore: decorator
- @unsafe
- export function retain(ref: usize): void {
- var root = ROOT;
- if (!root.has(ref)) {
- root.add(ref);
- if (implemented) {
- if (isDefined(__ref_link)) __ref_link(ref, changetype(root));
- else if (isDefined(__ref_retain)) __ref_retain(ref);
- }
- }
- }
-
- /** Releases a managed object externally, allowing it to become collected. */
- // @ts-ignore: decorator
- @unsafe
- export function release(ref: usize): void {
- var root = ROOT;
- if (root.has(ref)) {
- root.delete(ref);
- if (implemented) {
- if (isDefined(__ref_unlink)) __ref_unlink(ref, changetype(root));
- else if (isDefined(__ref_release)) __ref_release(ref);
- }
- }
- }
-}
diff --git a/std/assembly/map.ts b/std/assembly/map.ts
index 732ded47..3dadd668 100644
--- a/std/assembly/map.ts
+++ b/std/assembly/map.ts
@@ -1,8 +1,7 @@
///
import { HASH } from "./util/hash";
-import { __runtime_id } from "./runtime";
-import { __gc_mark_members } from "./gc";
+import { __runtime_id, __gc_mark_members } from "./runtime";
// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
diff --git a/std/assembly/runtime.ts b/std/assembly/runtime.ts
index 996ced3b..18a38f1b 100644
--- a/std/assembly/runtime.ts
+++ b/std/assembly/runtime.ts
@@ -4,6 +4,7 @@
import { HEADER, HEADER_SIZE, HEADER_MAGIC, adjust } from "./util/runtime";
import { HEAP_BASE, memory } from "./memory";
import { ArrayBufferView } from "./arraybuffer";
+import { E_NOTIMPLEMENTED } from "./util/error";
/** Gets the computed unique id of a class type. */
// @ts-ignore: decorator
@@ -15,6 +16,16 @@ export declare function __runtime_id(): u32;
@unsafe @builtin
export declare function __runtime_instanceof(id: u32, superId: u32): bool;
+/** Marks root objects when a tracing GC is present. */
+// @ts-ignore: decorator
+@unsafe @builtin
+export declare function __gc_mark_roots(): void;
+
+/** Marks class members when a tracing GC is present. */
+// @ts-ignore: decorator
+@unsafe @builtin
+export declare function __gc_mark_members(classId: u32, ref: usize): void;
+
/** Runtime implementation. */
@unmanaged
export class runtime {
@@ -49,52 +60,6 @@ export namespace runtime {
return changetype(header) + HEADER_SIZE;
}
- /** Reallocates the memory of a managed object that turned out to be too small or too large. */
- // @ts-ignore: decorator
- @unsafe
- export function reallocate(ref: usize, newPayloadSize: usize): usize {
- // Background: When managed objects are allocated these aren't immediately registered with GC
- // but can be used as scratch objects while unregistered. This is useful in situations where
- // the object must be reallocated multiple times because its final size isn't known beforehand,
- // e.g. in Array#filter, with only the final object making it into GC'ed userland.
- var header = changetype(ref - HEADER_SIZE);
- var payloadSize = header.payloadSize;
- if (payloadSize < newPayloadSize) {
- let newAdjustedSize = adjust(newPayloadSize);
- if (select(adjust(payloadSize), 0, ref > HEAP_BASE) < newAdjustedSize) {
- // move if the allocation isn't large enough or not a heap object
- let newHeader = changetype(memory.allocate(newAdjustedSize));
- newHeader.classId = header.classId;
- if (isDefined(__ref_collect)) {
- newHeader.reserved1 = 0;
- newHeader.reserved2 = 0;
- }
- let newRef = changetype(newHeader) + HEADER_SIZE;
- memory.copy(newRef, ref, payloadSize);
- memory.fill(newRef + payloadSize, 0, newPayloadSize - payloadSize);
- if (header.classId == HEADER_MAGIC) {
- // free right away if not registered yet
- assert(ref > HEAP_BASE); // static objects aren't scratch objects
- memory.free(changetype(header));
- } else if (isDefined(__ref_collect)) {
- // if previously registered, register again
- // @ts-ignore: stub
- __ref_register(ref);
- }
- header = newHeader;
- ref = newRef;
- } else {
- // otherwise just clear additional memory within this block
- memory.fill(ref + payloadSize, 0, newPayloadSize - payloadSize);
- }
- } else {
- // if the size is the same or less, just update the header accordingly.
- // unused space is cleared when grown, so no need to do this here.
- }
- header.payloadSize = newPayloadSize;
- return ref;
- }
-
/** Discards the memory of a managed object that hasn't been registered yet. */
// @ts-ignore: decorator
@unsafe
@@ -129,14 +94,14 @@ export namespace runtime {
// @ts-ignore: decorator
@unsafe
export function newString(length: i32): usize {
- return runtime.register(runtime.allocate(length << 1), __runtime_id());
+ return register(allocate(length << 1), __runtime_id());
}
/** Allocates and registers, but doesn't initialize the data of, a new `ArrayBuffer` of the specified byteLength. */
// @ts-ignore: decorator
@unsafe
export function newArrayBuffer(byteLength: i32): usize {
- return runtime.register(runtime.allocate(byteLength), __runtime_id());
+ return register(allocate(byteLength), __runtime_id());
}
/** Allocates and registers, but doesn't initialize the data of, a new `Array` of the specified length and element alignment.*/
@@ -148,9 +113,9 @@ export namespace runtime {
// called and the static buffer provided as `data`. This function can also be used to
// create typed arrays in that `Array` also implements `ArrayBufferView` but has an
// additional `.length_` property that remains unused overhead for typed arrays.
- var array = runtime.register(runtime.allocate(offsetof()), id);
+ var array = register(allocate(offsetof()), id);
var bufferSize = length << alignLog2;
- var buffer = runtime.register(runtime.allocate(bufferSize), __runtime_id());
+ var buffer = register(allocate(bufferSize), __runtime_id());
changetype(array).data = changetype(buffer); // links
changetype(array).dataStart = buffer;
changetype(array).dataLength = bufferSize;
@@ -158,4 +123,36 @@ export namespace runtime {
if (data) memory.copy(buffer, data, bufferSize);
return array;
}
+
+ /** Retains a managed object externally, making sure that it doesn't become collected. */
+ // @ts-ignore: decorator
+ @unsafe
+ export function retain(ref: usize): void {
+ if (isDefined(__ref_collect)) {
+ if (isDefined(__ref_link)) __ref_link(ref, changetype(ROOT));
+ else if (isDefined(__ref_retain)) __ref_retain(ref);
+ }
+ }
+
+ /** Releases a managed object externally, allowing it to become collected. */
+ // @ts-ignore: decorator
+ @unsafe
+ export function release(ref: usize): void {
+ if (isDefined(__ref_collect)) {
+ if (isDefined(__ref_unlink)) __ref_unlink(ref, changetype(ROOT));
+ else if (isDefined(__ref_release)) __ref_release(ref);
+ }
+ }
+
+ /** Performs a full garbage collection cycle. */
+ export function collect(): void {
+ if (isDefined(__ref_collect)) __ref_collect();
+ else throw new Error(E_NOTIMPLEMENTED);
+ }
}
+
+class Root {}
+
+// @ts-ignore
+@lazy
+var ROOT = new Root();
diff --git a/std/assembly/runtime/arena.ts b/std/assembly/runtime/arena.ts
index 8b75953b..9a31c7a4 100644
--- a/std/assembly/runtime/arena.ts
+++ b/std/assembly/runtime/arena.ts
@@ -1,3 +1 @@
import "allocator/arena";
-
-// export { memory };
diff --git a/std/assembly/runtime/default.ts b/std/assembly/runtime/default.ts
index 6131b14b..7178fe2a 100644
--- a/std/assembly/runtime/default.ts
+++ b/std/assembly/runtime/default.ts
@@ -1,4 +1,4 @@
import "allocator/tlsf";
import "collector/itcm";
-// export { memory, gc };
+export { runtime };
diff --git a/std/assembly/set.ts b/std/assembly/set.ts
index 5ac85463..367e3b3d 100644
--- a/std/assembly/set.ts
+++ b/std/assembly/set.ts
@@ -1,8 +1,7 @@
///
import { HASH } from "./util/hash";
-import { __runtime_id } from "./runtime";
-import { __gc_mark_members } from "./gc";
+import { __runtime_id, __gc_mark_members } from "./runtime";
// A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
diff --git a/std/assembly/util/memory.ts b/std/assembly/util/memory.ts
index 3b4af9d1..c9e4a82c 100644
--- a/std/assembly/util/memory.ts
+++ b/std/assembly/util/memory.ts
@@ -1,154 +1,154 @@
-export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c
- var w: u32, x: u32;
+// export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c
+// var w: u32, x: u32;
- // copy 1 byte each until src is aligned to 4 bytes
- while (n && (src & 3)) {
- store(dest++, load(src++));
- n--;
- }
+// // copy 1 byte each until src is aligned to 4 bytes
+// while (n && (src & 3)) {
+// store(dest++, load(src++));
+// n--;
+// }
- // if dst is aligned to 4 bytes as well, copy 4 bytes each
- if ((dest & 3) == 0) {
- while (n >= 16) {
- store(dest , load(src ));
- store(dest + 4, load(src + 4));
- store(dest + 8, load(src + 8));
- store(dest + 12, load(src + 12));
- src += 16; dest += 16; n -= 16;
- }
- if (n & 8) {
- store(dest , load(src ));
- store(dest + 4, load(src + 4));
- dest += 8; src += 8;
- }
- if (n & 4) {
- store(dest, load(src));
- dest += 4; src += 4;
- }
- if (n & 2) { // drop to 2 bytes each
- store(dest, load(src));
- dest += 2; src += 2;
- }
- if (n & 1) { // drop to 1 byte
- store(dest++, load(src++));
- }
- return;
- }
+// // if dst is aligned to 4 bytes as well, copy 4 bytes each
+// if ((dest & 3) == 0) {
+// while (n >= 16) {
+// store(dest , load(src ));
+// store(dest + 4, load(src + 4));
+// store(dest + 8, load(src + 8));
+// store(dest + 12, load(src + 12));
+// src += 16; dest += 16; n -= 16;
+// }
+// if (n & 8) {
+// store(dest , load(src ));
+// store(dest + 4, load(src + 4));
+// dest += 8; src += 8;
+// }
+// if (n & 4) {
+// store(dest, load(src));
+// dest += 4; src += 4;
+// }
+// if (n & 2) { // drop to 2 bytes each
+// store(dest, load(src));
+// dest += 2; src += 2;
+// }
+// if (n & 1) { // drop to 1 byte
+// store(dest++, load(src++));
+// }
+// return;
+// }
- // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each
- // doing shifts if faster when copying enough bytes (here: 32 or more)
- if (n >= 32) {
- switch (dest & 3) {
- // known to be != 0
- case 1: {
- w = load(src);
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- n -= 3;
- while (n >= 17) {
- x = load(src + 1);
- store(dest, w >> 24 | x << 8);
- w = load(src + 5);
- store(dest + 4, x >> 24 | w << 8);
- x = load(src + 9);
- store(dest + 8, w >> 24 | x << 8);
- w = load(src + 13);
- store(dest + 12, x >> 24 | w << 8);
- src += 16; dest += 16; n -= 16;
- }
- break;
- }
- case 2: {
- w = load(src);
- store(dest++, load(src++));
- store(dest++, load(src++));
- n -= 2;
- while (n >= 18) {
- x = load(src + 2);
- store(dest, w >> 16 | x << 16);
- w = load(src + 6);
- store(dest + 4, x >> 16 | w << 16);
- x = load(src + 10);
- store(dest + 8, w >> 16 | x << 16);
- w = load(src + 14);
- store(dest + 12, x >> 16 | w << 16);
- src += 16; dest += 16; n -= 16;
- }
- break;
- }
- case 3: {
- w = load(src);
- store(dest++, load(src++));
- n -= 1;
- while (n >= 19) {
- x = load(src + 3);
- store(dest, w >> 8 | x << 24);
- w = load(src + 7);
- store(dest + 4, x >> 8 | w << 24);
- x = load(src + 11);
- store(dest + 8, w >> 8 | x << 24);
- w = load(src + 15);
- store(dest + 12, x >> 8 | w << 24);
- src += 16; dest += 16; n -= 16;
- }
- break;
- }
- }
- }
+// // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each
+// // doing shifts if faster when copying enough bytes (here: 32 or more)
+// if (n >= 32) {
+// switch (dest & 3) {
+// // known to be != 0
+// case 1: {
+// w = load(src);
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// n -= 3;
+// while (n >= 17) {
+// x = load(src + 1);
+// store(dest, w >> 24 | x << 8);
+// w = load(src + 5);
+// store(dest + 4, x >> 24 | w << 8);
+// x = load(src + 9);
+// store(dest + 8, w >> 24 | x << 8);
+// w = load(src + 13);
+// store(dest + 12, x >> 24 | w << 8);
+// src += 16; dest += 16; n -= 16;
+// }
+// break;
+// }
+// case 2: {
+// w = load(src);
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// n -= 2;
+// while (n >= 18) {
+// x = load(src + 2);
+// store(dest, w >> 16 | x << 16);
+// w = load(src + 6);
+// store(dest + 4, x >> 16 | w << 16);
+// x = load(src + 10);
+// store(dest + 8, w >> 16 | x << 16);
+// w = load(src + 14);
+// store(dest + 12, x >> 16 | w << 16);
+// src += 16; dest += 16; n -= 16;
+// }
+// break;
+// }
+// case 3: {
+// w = load(src);
+// store(dest++, load(src++));
+// n -= 1;
+// while (n >= 19) {
+// x = load(src + 3);
+// store(dest, w >> 8 | x << 24);
+// w = load(src + 7);
+// store(dest + 4, x >> 8 | w << 24);
+// x = load(src + 11);
+// store(dest + 8, w >> 8 | x << 24);
+// w = load(src + 15);
+// store(dest + 12, x >> 8 | w << 24);
+// src += 16; dest += 16; n -= 16;
+// }
+// break;
+// }
+// }
+// }
- // copy remaining bytes one by one
- if (n & 16) {
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- }
- if (n & 8) {
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- }
- if (n & 4) {
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- store(dest++, load(src++));
- }
- if (n & 2) {
- store(dest++, load(src++));
- store(dest++, load(src++));
- }
- if (n & 1) {
- store(dest++, load(src++));
- }
-}
+// // copy remaining bytes one by one
+// if (n & 16) {
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// }
+// if (n & 8) {
+// store(dest++, load(src++));
+// store(dest++, load(src++));
+// store(dest++, load