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

Add initial Set implementation to tests, see #17; Fix check when shrinking a Map

Browse Source
This commit is contained in:
dcodeIO
2018-06-21 00:57:46 +02:00
parent dd4be7b693
commit c44cbec2c7
9 changed files with 34835 additions and 16995 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
tests/compiler/std/map.ts
View File

@ -2,7 +2,7 @@ import {
hash
} from "internal/hash";
// A deterministic hash table based on CloseTable from https://github.com/jorendorff/dht
// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
const INITIAL_CAPACITY = 4;
const FILL_FACTOR: f64 = 8 / 3;
@ -19,6 +19,9 @@ class MapEntry<K,V> {
/** Empty bit. */
const EMPTY: usize = 1 << 0;
/** Size of a bucket. */
const BUCKET_SIZE = sizeof<usize>();
/** Computes the alignment of an entry. */
@inline function ENTRY_ALIGN<K,V>(): usize {
// can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits
@ -51,7 +54,7 @@ class Map<K,V> {
constructor() { this.clear(); }
clear(): void {
const bucketsSize = INITIAL_CAPACITY * <i32>sizeof<usize>();
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,V>();
@ -71,29 +74,27 @@ class Map<K,V> {
}
has(key: K): bool {
return this.find(key, hash(key)) !== null;
return this.find(key, hash<K>(key)) !== null;
}
get(key: K): V {
var entry = this.find(key, hash(key));
var entry = this.find(key, hash<K>(key));
return entry ? entry.value : <V>unreachable();
}
set(key: K, value: V): void {
var hashCode = hash(key);
var hashCode = hash<K>(key);
var entry = this.find(key, hashCode);
if (entry) {
entry.value = value;
} else {
// check if rehashing is necessary
let capacity = this.entriesCapacity;
if (this.entriesOffset == capacity) {
if (this.entriesOffset == this.entriesCapacity) {
this.rehash(
this.entriesCount >= <i32>(capacity * FREE_FACTOR)
? (this.bucketsMask << 1) | 1 // grow capacity to next 2^N
: this.bucketsMask // just rehash if 1/4+ entries are empty
this.entriesCount < <i32>(this.entriesCapacity * FREE_FACTOR)
? this.bucketsMask // just rehash if 1/4+ entries are empty
: (this.bucketsMask << 1) | 1 // grow capacity to next 2^N
);
capacity = this.entriesCapacity;
}
// append new entry
let entries = this.entries;
@ -102,48 +103,51 @@ class Map<K,V> {
);
entry.key = key;
entry.value = value;
++this.entriesCount;
// link with previous entry in bucket
let bucketIndex = hashCode & this.bucketsMask;
entry.taggedNext = this.buckets.load<usize>(bucketIndex);
this.buckets.store<usize>(bucketIndex, changetype<usize>(entry));
++this.entriesCount;
}
}
delete(key: K): bool {
var entry = this.find(key, hash(key));
var entry = this.find(key, hash<K>(key));
if (!entry) return false;
entry.taggedNext |= EMPTY;
--this.entriesCount;
// check if rehashing is appropriate
var halfBucketsMask = this.bucketsMask >> 1;
if (
this.bucketsMask > <u32>INITIAL_CAPACITY &&
this.entriesCount < <i32>(this.entriesOffset * FREE_FACTOR)
) this.rehash(this.bucketsMask >> 1);
halfBucketsMask + 1 >= max<u32>(INITIAL_CAPACITY, this.entriesCount) &&
this.entriesCount < <i32>(this.entriesCapacity * FREE_FACTOR)
) this.rehash(halfBucketsMask);
return true;
}
private rehash(newBucketsMask: i32): void {
var newBucketsCapacity = newBucketsMask + 1;
var newBuckets = new ArrayBuffer(newBucketsCapacity * sizeof<usize>());
private rehash(newBucketsMask: u32): void {
var newBucketsCapacity = <i32>(newBucketsMask + 1);
var newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
var newEntriesCapacity = <i32>(newBucketsCapacity * FILL_FACTOR);
var newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE<K,V>(), true);
var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K,V>(), true);
// copy old entries to new entries
var p = changetype<usize>(this.entries) + ArrayBuffer.HEADER_SIZE;
var q = changetype<usize>(newEntries) + ArrayBuffer.HEADER_SIZE;
var k = p + this.entriesOffset * ENTRY_SIZE<K,V>();
while (p != k) {
let pEntry = changetype<MapEntry<K,V>>(p);
let qEntry = changetype<MapEntry<K,V>>(q);
if (!(pEntry.taggedNext & EMPTY)) {
qEntry.key = pEntry.key;
qEntry.value = pEntry.value;
let bucketIndex = hash(pEntry.key) & newBucketsMask;
qEntry.taggedNext = newBuckets.load<usize>(bucketIndex);
newBuckets.store<MapEntry<K,V>>(bucketIndex, qEntry);
q += ENTRY_SIZE<K,V>();
var oldPtr = changetype<usize>(this.entries) + ArrayBuffer.HEADER_SIZE;
var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<K,V>();
var newPtr = changetype<usize>(newEntries) + ArrayBuffer.HEADER_SIZE;
while (oldPtr != oldEnd) {
let oldEntry = changetype<MapEntry<K,V>>(oldPtr);
if (!(oldEntry.taggedNext & EMPTY)) {
let newEntry = changetype<MapEntry<K,V>>(newPtr);
newEntry.key = oldEntry.key;
newEntry.value = oldEntry.value;
let newBucketIndex = hash<K>(oldEntry.key) & newBucketsMask;
let newBucketPtr = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
newEntry.taggedNext = load<usize>(newBucketPtr, ArrayBuffer.HEADER_SIZE);
store<usize>(newBucketPtr, newPtr, ArrayBuffer.HEADER_SIZE);
newPtr += ENTRY_SIZE<K,V>();
}
p += ENTRY_SIZE<K,V>();
oldPtr += ENTRY_SIZE<K,V>();
}
this.buckets = newBuckets;
@ -160,54 +164,55 @@ function test<K,V>(): void {
var map = new Map<K,V>();
// insert new
for (let k: K = 1; k <= 200; ++k) {
map.set(k, 100 + <V>k);
for (let k: K = 0; k < 100; ++k) {
assert(!map.has(k));
map.set(k, 10 + <V>k);
assert(map.has(k));
assert(!map.has(k + 1));
assert(map.get(k) == 100 + k);
assert(map.get(k) == 10 + <V>k);
}
assert(map.size == 200);
assert(map.size == 100);
// insert duplicate
for (let k: K = 50; k <= 100; ++k) {
for (let k: K = 0; k < 100; ++k) {
assert(map.has(k));
assert(map.get(k) == 100 + <V>k);
map.set(k, 100 + <V>k);
assert(map.get(k) == 10 + <V>k);
map.set(k, 20 + <V>k);
assert(map.has(k));
assert(map.get(k) == 100 + <V>k);
assert(map.get(k) == 20 + <V>k);
}
assert(map.size == 200);
assert(map.size == 100);
// delete
for (let k: K = 1; k <= 100; ++k) {
for (let k: K = 0; k < 50; ++k) {
assert(map.has(k));
assert(map.get(k) == 100 + <V>k);
assert(map.get(k) == 20 + <V>k);
map.delete(k);
assert(!map.has(k));
assert(map.has(k + 1));
}
assert(map.size == 100);
assert(map.size == 50);
// insert + delete
for (let k: K = 1; k <= 50; ++k) {
for (let k: K = 0; k < 50; ++k) {
assert(!map.has(k));
map.set(k, 100 + <V>k);
map.set(k, 10 + <V>k);
assert(map.has(k));
map.delete(k);
assert(!map.has(k));
}
assert(map.size == 100);
assert(map.size == 50);
// clear
map.clear();
assert(map.size == 0);
}
test<i32,i32>();
test<i64,i32>();
test<i64,i64>();
test<i32,i64>();
test<i8,i32>();
test<u8,i32>();
test<i16,i32>();
test<i16,i64>();
test<i32,i16>();
test<i64,i16>();
test<u16,i32>();
test<i32,i32>();
test<u32,i32>();
test<i64,i32>();
test<u64,i32>();
test<f32,i32>();
test<f64,i32>();