fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-24 04:01:46 +00:00
Code Issues Projects Releases Wiki Activity

Implement reference counting (#592)

Browse Source
This commit is contained in:
Daniel Wirtz
2019-06-05 23:15:39 +02:00
committed by GitHub
parent 3ed76a97f0
commit 0484a6b740
601 changed files with 261645 additions and 146131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
std/assembly/set.ts
View File

@ -1,16 +1,20 @@
import {
HEADER_SIZE as HEADER_SIZE_AB
} from "./internal/arraybuffer";
/// <reference path="./rt/index.d.ts" />
import {
HASH
} from "./internal/hash";
import { HASH } from "./util/hash";
// A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
@inline const INITIAL_CAPACITY = 4;
@inline const FILL_FACTOR: f64 = 8 / 3;
@inline const FREE_FACTOR: f64 = 3 / 4;
// @ts-ignore: decorator
@inline
const INITIAL_CAPACITY = 4;
// @ts-ignore: decorator
@inline
const FILL_FACTOR: f64 = 8 / 3;
// @ts-ignore: decorator
@inline
const FREE_FACTOR: f64 = 3 / 4;
/** Structure of a set entry. */
@unmanaged class SetEntry<K> {
@ -19,26 +23,34 @@ import {
}
/** Empty bit. */
@inline const EMPTY: usize = 1 << 0;
// @ts-ignore: decorator
@inline
const EMPTY: usize = 1 << 0;
/** Size of a bucket. */
@inline const BUCKET_SIZE = sizeof<usize>();
// @ts-ignore: decorator
@inline
const BUCKET_SIZE = sizeof<usize>();
/** Computes the alignment of an entry. */
@inline function ENTRY_ALIGN<K>(): usize {
// @ts-ignore: decorator
@inline
function ENTRY_ALIGN<T>(): usize {
// can align to 4 instead of 8 if 32-bit and K is <= 32-bits
const align = (sizeof<K>() > sizeof<usize>() ? sizeof<K>() : sizeof<usize>()) - 1;
const align = (sizeof<T>() > sizeof<usize>() ? sizeof<T>() : sizeof<usize>()) - 1;
return align;
}
/** Computes the aligned size of an entry. */
@inline function ENTRY_SIZE<K>(): usize {
const align = ENTRY_ALIGN<K>();
const size = (offsetof<SetEntry<K>>() + align) & ~align;
// @ts-ignore: decorator
@inline
function ENTRY_SIZE<T>(): usize {
const align = ENTRY_ALIGN<T>();
const size = (offsetof<SetEntry<T>>() + align) & ~align;
return size;
}
export class Set<K> {
export class Set<T> {
// buckets holding references to the respective first entry within
private buckets: ArrayBuffer; // usize[bucketsMask + 1]
@ -58,32 +70,31 @@ export class Set<K> {
const bucketsSize = INITIAL_CAPACITY * <i32>BUCKET_SIZE;
this.buckets = new ArrayBuffer(bucketsSize);
this.bucketsMask = INITIAL_CAPACITY - 1;
const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<K>();
this.entries = new ArrayBuffer(entriesSize, true);
const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>();
this.entries = new ArrayBuffer(entriesSize);
this.entriesCapacity = INITIAL_CAPACITY;
this.entriesOffset = 0;
this.entriesCount = 0;
}
private find(key: K, hashCode: u32): SetEntry<K> | null {
var entry = load<SetEntry<K>>(
changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE,
HEADER_SIZE_AB
private find(key: T, hashCode: u32): SetEntry<T> | null {
var entry = load<SetEntry<T>>( // unmanaged!
changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
);
while (entry) {
if (!(entry.taggedNext & EMPTY) && entry.key == key) return entry;
entry = changetype<SetEntry<K>>(entry.taggedNext & ~EMPTY);
entry = changetype<SetEntry<T>>(entry.taggedNext & ~EMPTY);
}
return null;
}
has(key: K): bool {
return this.find(key, HASH(key)) !== null;
has(key: T): bool {
return this.find(key, HASH<T>(key)) !== null;
}
add(key: K): void {
var hashCode = HASH(key);
var entry = this.find(key, hashCode);
add(key: T): void {
var hashCode = HASH<T>(key);
var entry = this.find(key, hashCode); // unmanaged!
if (!entry) {
// check if rehashing is necessary
if (this.entriesOffset == this.entriesCapacity) {
@ -94,23 +105,22 @@ export class Set<K> {
);
}
// append new entry
let entries = this.entries;
entry = changetype<SetEntry<K>>(
changetype<usize>(entries) + HEADER_SIZE_AB + this.entriesOffset++ * ENTRY_SIZE<K>()
);
entry.key = key;
entry = changetype<SetEntry<T>>(changetype<usize>(this.entries) + this.entriesOffset++ * ENTRY_SIZE<T>());
entry.key = isManaged<T>()
? changetype<T>(__retain(changetype<usize>(key)))
: key;
++this.entriesCount;
// link with previous entry in bucket
let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
entry.taggedNext = load<usize>(bucketPtrBase, HEADER_SIZE_AB);
store<usize>(bucketPtrBase, changetype<usize>(entry), HEADER_SIZE_AB);
if (isManaged<K>()) __gc_link(changetype<usize>(this), changetype<usize>(key)); // tslint:disable-line
entry.taggedNext = load<usize>(bucketPtrBase);
store<usize>(bucketPtrBase, changetype<usize>(entry));
}
}
delete(key: K): bool {
var entry = this.find(key, HASH<K>(key));
delete(key: T): bool {
var entry = this.find(key, HASH<T>(key)); // unmanaged!
if (!entry) return false;
if (isManaged<T>()) __release(changetype<usize>(entry.key)); // exact 'key'
entry.taggedNext |= EMPTY;
--this.entriesCount;
// check if rehashing is appropriate
@ -126,24 +136,24 @@ export class Set<K> {
var newBucketsCapacity = <i32>(newBucketsMask + 1);
var newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
var newEntriesCapacity = <i32>(newBucketsCapacity * FILL_FACTOR);
var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K>(), true);
var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<T>());
// copy old entries to new entries
var oldPtr = changetype<usize>(this.entries) + HEADER_SIZE_AB;
var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<K>();
var newPtr = changetype<usize>(newEntries) + HEADER_SIZE_AB;
var oldPtr = changetype<usize>(this.entries);
var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<T>();
var newPtr = changetype<usize>(newEntries);
while (oldPtr != oldEnd) {
let oldEntry = changetype<SetEntry<K>>(oldPtr);
let oldEntry = changetype<SetEntry<T>>(oldPtr); // unmanaged!
if (!(oldEntry.taggedNext & EMPTY)) {
let newEntry = changetype<SetEntry<K>>(newPtr);
let newEntry = changetype<SetEntry<T>>(newPtr); // unmanaged!
newEntry.key = oldEntry.key;
let newBucketIndex = HASH<K>(oldEntry.key) & newBucketsMask;
let newBucketIndex = HASH<T>(oldEntry.key) & newBucketsMask;
let newBucketPtrBase = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
newEntry.taggedNext = load<usize>(newBucketPtrBase, HEADER_SIZE_AB);
store<usize>(newBucketPtrBase, newPtr, HEADER_SIZE_AB);
newPtr += ENTRY_SIZE<K>();
newEntry.taggedNext = load<usize>(newBucketPtrBase);
store<usize>(newBucketPtrBase, newPtr);
newPtr += ENTRY_SIZE<T>();
}
oldPtr += ENTRY_SIZE<K>();
oldPtr += ENTRY_SIZE<T>();
}
this.buckets = newBuckets;
@ -153,24 +163,43 @@ export class Set<K> {
this.entriesOffset = this.entriesCount;
}
values(): T[] {
// FIXME: this is preliminary, needs iterators/closures
var start = changetype<usize>(this.entries);
var size = this.entriesOffset;
var values = Array.create<T>(size);
for (let i = 0; i < size; ++i) {
let entry = changetype<SetEntry<T>>(start + <usize>i * ENTRY_SIZE<T>());
if (!(entry.taggedNext & EMPTY)) {
values.push(entry.key);
}
}
return values;
}
toString(): string {
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>();
// RT integration
@unsafe private __visit_impl(cookie: u32): void {
__visit(changetype<usize>(this.buckets), cookie);
var entries = changetype<usize>(this.entries);
if (isManaged<T>()) {
let cur = entries;
let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<T>();
while (cur < end) {
let entry = changetype<SetEntry<T>>(cur);
if (!(entry.taggedNext & EMPTY)) {
let val = changetype<usize>(entry.key);
if (isNullable<T>()) {
if (val) __visit(val, cookie);
} else __visit(val, cookie);
}
cur += ENTRY_SIZE<T>();
}
}
__visit(entries, cookie);
}
}