fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-22 19:21:47 +00:00
Code Issues Projects Releases Wiki Activity

more general gc hooks?

Browse Source
This commit is contained in:
dcode
2019-03-21 10:44:14 +01:00
parent 658a380786
commit 3fc9f550ad
13 changed files with 200 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
std/assembly/array.ts
View File

@ -1,4 +1,4 @@
import { ALLOCATE, REALLOCATE, DISCARD, LINK, REGISTER, MAX_BYTELENGTH, ArrayBufferView, UNLINK } from "./runtime";
import { ALLOCATE, REALLOCATE, DISCARD, RETAIN, RELEASE, REGISTER, MAX_BYTELENGTH, ArrayBufferView } from "./runtime";
import { ArrayBuffer } from "./arraybuffer";
import { COMPARATOR, SORT } from "./util/sort";
import { itoa, dtoa, itoa_stream, dtoa_stream, MAX_DOUBLE_LENGTH } from "./util/number";
@ -76,8 +76,8 @@ export class Array<T> extends ArrayBufferView {
if (isManaged<T>()) {
let offset = this.dataStart + (<usize>index << alignof<T>());
let oldValue = load<T>(offset);
store<T>(offset, LINK<T,this>(value, this));
UNLINK<T,this>(oldValue, this); // order is important
store<T>(offset, RETAIN<T,this>(value, this));
RELEASE<T,this>(oldValue, this); // order is important
} else {
store<T>(this.dataStart + (<usize>index << alignof<T>()), value);
}
@ -140,7 +140,7 @@ export class Array<T> extends ArrayBufferView {
this.length_ = newLength;
store<T>(this.dataStart + (<usize>(newLength - 1) << alignof<T>()),
isManaged<T>()
? LINK<T,this>(element, this)
? RETAIN<T,this>(element, this)
: element
);
return newLength;
@ -156,13 +156,13 @@ export class Array<T> extends ArrayBufferView {
let thisStart = this.dataStart;
for (let offset: usize = 0; offset < thisSize; offset += sizeof<T>()) {
let element = load<T>(thisStart + offset);
store<T>(outStart + offset, LINK<T,Array<T>>(element, out));
store<T>(outStart + offset, RETAIN<T,Array<T>>(element, out));
}
let otherStart = other.dataStart;
let otherSize = <usize>otherLen << alignof<T>();
for (let offset: usize = 0; offset < otherSize; offset += sizeof<T>()) {
let element = load<T>(otherStart + offset);
store<T>(outStart + thisSize + offset, LINK<T,Array<T>>(element, out));
store<T>(outStart + thisSize + offset, RETAIN<T,Array<T>>(element, out));
}
} else {
memory.copy(outStart, this.dataStart, thisSize);
@ -221,7 +221,7 @@ export class Array<T> extends ArrayBufferView {
let result = callbackfn(value, index, this);
store<U>(outStart + (<usize>index << alignof<U>()),
isManaged<U>()
? LINK<U,Array<U>>(result, out)
? RETAIN<U,Array<U>>(result, out)
: result
);
}
@ -296,7 +296,7 @@ export class Array<T> extends ArrayBufferView {
);
store<T>(base,
isManaged<T>()
? LINK<T,this>(element, this)
? RETAIN<T,this>(element, this)
: element
);
this.length_ = newLength;
@ -316,7 +316,7 @@ export class Array<T> extends ArrayBufferView {
let element = load<T>(thisBase + offset);
store<T>(sliceBase + offset,
isManaged<T>()
? LINK<T,Array<T>>(element, slice)
? RETAIN<T,Array<T>>(element, slice)
: element
);
}
@ -334,8 +334,8 @@ export class Array<T> extends ArrayBufferView {
for (let i = 0; i < deleteCount; ++i) {
let deleted = load<T>(thisBase + (<usize>i << alignof<T>()));
if (isManaged<T>()) {
store<T>(resultStart + (<usize>i << alignof<T>()), LINK<T,Array<T>>(deleted, result));
UNLINK<T,this>(deleted, this); // order is important
store<T>(resultStart + (<usize>i << alignof<T>()), RETAIN<T,Array<T>>(deleted, result));
RELEASE<T,this>(deleted, this); // order is important
} else {
store<T>(resultStart + (<usize>i << alignof<T>()), deleted);
}
@ -655,16 +655,17 @@ export class Array<T> extends ArrayBufferView {
return this.join();
}
// private __gc(): void {
// var buffer = this.buffer_;
// __gc_mark(changetype<usize>(buffer)); // tslint:disable-line
// if (isManaged<T>()) {
// let offset: usize = 0;
// let end = <usize>this.length_ << alignof<usize>();
// while (offset < end) {
// __gc_mark(load<usize>(changetype<usize>(buffer) + offset, HEADER_SIZE)); // tslint:disable-line
// offset += sizeof<usize>();
// }
// }
// }
// GC integration
@unsafe private __iter(fn: (ref: usize) => void): void {
fn(changetype<usize>(this.data));
if (isManaged<T>()) {
let cur = this.dataStart;
let end = cur + <usize>this.dataLength;
while (cur < end) {
fn(load<usize>(cur));
cur += sizeof<usize>();
}
}
}
}

5
std/assembly/collector/pure.ts
View File

@ -1,8 +1,7 @@
// A Pure Reference Counting Garbage Collector
//
// After the paper by DAVID F. BACON, CLEMENT R. ATTANASIO, V.T. RAJAN, STEPHEN E. SMITH
// D. Bacon, IBM T.J. Watson Research Center
// 2001 ACM 0164-0925/99/0100-0111 $00.75
// After the paper by D. Bacon et al., 2001, IBM T.J. Watson Research Center
// https://researcher.watson.ibm.com/researcher/files/us-bacon/Bacon03Pure.pdf
import { HEADER, HEADER_SIZE } from "../runtime";

19
std/assembly/fixedarray.ts
View File

@ -1,4 +1,4 @@
import { ALLOCATE, REGISTER, MAX_BYTELENGTH, HEADER, HEADER_SIZE, LINK, UNLINK } from "./runtime";
import { ALLOCATE, REGISTER, MAX_BYTELENGTH, HEADER, HEADER_SIZE, RETAIN, RELEASE } from "./runtime";
// NOTE: DO NOT USE YET!
@ -38,10 +38,23 @@ export class FixedArray<T> {
if (isManaged<T>()) {
let offset = changetype<usize>(this) + (<usize>index << alignof<T>());
let oldValue = load<T>(offset);
store<T>(offset, LINK<T,this>(value, this));
UNLINK<T,this>(oldValue, this); // order is important
store<T>(offset, RETAIN<T,this>(value, this));
RELEASE<T,this>(oldValue, this); // order is important
} else {
store<T>(changetype<usize>(this) + (<usize>index << alignof<T>()), value);
}
}
// GC integration
@unsafe private __iter(fn: (ref: usize) => void): void {
if (isManaged<T>()) {
let cur = changetype<usize>(this);
let end = cur + changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize;
while (cur < end) {
fn(load<usize>(cur));
cur += sizeof<usize>();
}
}
}
}

52
std/assembly/map.ts
View File

@ -1,4 +1,4 @@
import { LINK, UNLINK } from "./runtime";
import { RETAIN, RELEASE, HEADER } from "./runtime";
import { HASH } from "./util/hash";
// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
@ -106,8 +106,8 @@ export class Map<K,V> {
if (entry) {
if (isManaged<V>()) {
let oldValue = entry.value;
entry.value = LINK<V,this>(value, this);
UNLINK<V,this>(oldValue, this); // order is important
entry.value = RETAIN<V,this>(value, this);
RELEASE<V,this>(oldValue, this); // order is important
} else {
entry.value = value;
}
@ -126,8 +126,8 @@ export class Map<K,V> {
changetype<usize>(entries) + this.entriesOffset++ * ENTRY_SIZE<K,V>()
);
// link with the map
entry.key = isManaged<K>() ? LINK<K,this>(key, this) : key;
entry.value = isManaged<V>() ? LINK<V,this>(value, this) : value;
entry.key = isManaged<K>() ? RETAIN<K,this>(key, this) : key;
entry.value = isManaged<V>() ? RETAIN<V,this>(value, this) : value;
++this.entriesCount;
// link with previous entry in bucket
let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
@ -139,8 +139,8 @@ export class Map<K,V> {
delete(key: K): bool {
var entry = this.find(key, HASH<K>(key));
if (!entry) return false;
if (isManaged<K>()) UNLINK<K,this>(entry.key, this);
if (isManaged<V>()) UNLINK<V,this>(entry.value, this);
if (isManaged<K>()) RELEASE<K,this>(entry.key, this);
if (isManaged<V>()) RELEASE<V,this>(entry.value, this);
entry.taggedNext |= EMPTY;
--this.entriesCount;
// check if rehashing is appropriate
@ -188,23 +188,23 @@ export class Map<K,V> {
return "[object Map]";
}
// private __gc(): void {
// __gc_mark(changetype<usize>(this.buckets)); // tslint:disable-line
// var entries = this.entries;
// __gc_mark(changetype<usize>(entries)); // tslint:disable-line
// if (isManaged<K>() || isManaged<V>()) {
// let offset: usize = 0;
// let end: usize = this.entriesOffset * ENTRY_SIZE<K,V>();
// while (offset < end) {
// let entry = changetype<MapEntry<K,V>>(
// changetype<usize>(entries) + HEADER_SIZE_AB + offset * ENTRY_SIZE<K,V>()
// );
// if (!(entry.taggedNext & EMPTY)) {
// if (isManaged<K>()) __gc_mark(changetype<usize>(entry.key)); // tslint:disable-line
// if (isManaged<V>()) __gc_mark(changetype<usize>(entry.value)); // tslint:disable-line
// }
// offset += ENTRY_SIZE<K,V>();
// }
// }
// }
// GC integration
@unsafe private __iter(fn: (ref: usize) => void): void {
fn(changetype<usize>(this.buckets));
var entries = this.entries;
fn(changetype<usize>(entries));
if (isManaged<K>() || isManaged<V>()) {
let cur = changetype<usize>(entries);
let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<K,V>();
while (cur < end) {
let entry = changetype<MapEntry<K,V>>(cur);
if (!(entry.taggedNext & EMPTY)) {
if (isManaged<K>()) fn(changetype<usize>(entry.key));
if (isManaged<V>()) fn(changetype<usize>(entry.value));
}
cur += ENTRY_SIZE<K,V>();
}
}
}
}

16
std/assembly/runtime.ts
View File

@ -141,17 +141,17 @@ function doRegister(ref: usize, classId: u32): usize {
return ref;
}
/** Links a registered object with an object that is now referencing it. */
/** Retains a registered object. */
// @ts-ignore: decorator
@unsafe @inline
export function LINK<T,TParent>(ref: T, parentRef: TParent): T {
export function RETAIN<T,TParent>(ref: T, parentRef: TParent): T {
if (!isManaged<T>()) ERROR("managed reference expected");
if (!isManaged<TParent>()) ERROR("managed reference expected");
doLink(changetype<usize>(ref), changetype<usize>(parentRef));
doRetain(changetype<usize>(ref), changetype<usize>(parentRef));
return ref;
}
function doLink(ref: usize, parentRef: usize): void {
function doRetain(ref: usize, parentRef: usize): void {
if (!ASC_NO_ASSERT) {
assertRegistered(ref);
assertRegistered(parentRef);
@ -160,16 +160,16 @@ function doLink(ref: usize, parentRef: usize): void {
if (GC_IMPLEMENTED) __gc_link(changetype<usize>(ref), changetype<usize>(parentRef));
}
/** Unlinks a registered object from an object that was referencing it. */
/** Releases a registered object. */
// @ts-ignore: decorator
@unsafe @inline
export function UNLINK<T,TParent>(ref: T, parentRef: TParent): void {
export function RELEASE<T,TParent>(ref: T, parentRef: TParent): void {
if (!isManaged<T>()) ERROR("managed reference expected");
if (!isManaged<TParent>()) ERROR("managed reference expected");
doUnlink(changetype<usize>(ref), changetype<usize>(parentRef));
doRelease(changetype<usize>(ref), changetype<usize>(parentRef));
}
function doUnlink(ref: usize, parentRef: usize): void {
function doRelease(ref: usize, parentRef: usize): void {
if (!ASC_NO_ASSERT) {
assertRegistered(ref);
assertRegistered(parentRef);

38
std/assembly/set.ts
View File

@ -1,4 +1,4 @@
import { LINK, UNLINK } from "./runtime";
import { RETAIN, RELEASE } from "./runtime";
import { HASH } from "./util/hash";
// A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
@ -109,7 +109,7 @@ export class Set<K> {
changetype<usize>(entries) + this.entriesOffset++ * ENTRY_SIZE<K>()
);
// link with the set
entry.key = isManaged<K>() ? LINK<K,this>(key, this) : key;
entry.key = isManaged<K>() ? RETAIN<K,this>(key, this) : key;
++this.entriesCount;
// link with previous entry in bucket
let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
@ -121,7 +121,7 @@ export class Set<K> {
delete(key: K): bool {
var entry = this.find(key, HASH<K>(key));
if (!entry) return false;
if (isManaged<K>()) UNLINK<K,this>(entry.key, this);
if (isManaged<K>()) RELEASE<K,this>(entry.key, this);
entry.taggedNext |= EMPTY;
--this.entriesCount;
// check if rehashing is appropriate
@ -168,20 +168,20 @@ export class Set<K> {
return "[object Set]";
}
// private __gc(): void {
// __gc_mark(changetype<usize>(this.buckets)); // tslint:disable-line
// var entries = this.entries;
// __gc_mark(changetype<usize>(entries)); // tslint:disable-line
// if (isManaged<K>()) {
// let offset: usize = 0;
// let end: usize = this.entriesOffset * ENTRY_SIZE<K>();
// while (offset < end) {
// let entry = changetype<SetEntry<K>>(
// changetype<usize>(entries) + HEADER_SIZE_AB + offset * ENTRY_SIZE<K>()
// );
// if (!(entry.taggedNext & EMPTY)) __gc_mark(changetype<usize>(entry.key)); // tslint:disable-line
// offset += ENTRY_SIZE<K>();
// }
// }
// }
// GC integration
@unsafe private __iter(fn: (ref: usize) => void): void {
fn(changetype<usize>(this.buckets));
var entries = this.entries;
fn(changetype<usize>(entries));
if (isManaged<K>()) {
let cur = changetype<usize>(entries);
let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<K>();
while (cur < end) {
let entry = changetype<SetEntry<K>>(cur);
if (!(entry.taggedNext & EMPTY)) fn(changetype<usize>(entry.key));
cur += ENTRY_SIZE<K>();
}
}
}
}

4
std/assembly/string.ts
View File

@ -1,4 +1,4 @@
import { ALLOCATE, REGISTER, HEADER, HEADER_SIZE, ArrayBufferView, LINK } from "./runtime";
import { ALLOCATE, REGISTER, HEADER, HEADER_SIZE, ArrayBufferView, RETAIN } from "./runtime";
import { MAX_SIZE_32 } from "./util/allocator";
import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./util/string";
@ -365,7 +365,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
// result[i] = charStr
store<String>(resultStart + (<usize>i << alignof<usize>()),
isManaged<String>()
? LINK<String,Array<String>>(REGISTER<String>(charStr), result)
? RETAIN<String,Array<String>>(REGISTER<String>(charStr), result)
: REGISTER<String>(charStr)
);
}