fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-29 06:31:59 +00:00
Code Issues Projects Releases Wiki Activity

Improve inlining where locals can be aliased; Add a crude mechanism for explicit unchecked array accesses

Browse Source 
The `unchecked` builtin should be handled with ultimate care and it would be a lot better if there'd be a mechanism doing this automatically.
This commit is contained in:
dcodeIO
2018-04-25 05:04:35 +02:00
parent 391db28fe2
commit 6d6d1dddcf
47 changed files with 5374 additions and 15672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
std/assembly/internal/array.ts
View File

@ -14,24 +14,24 @@ export function defaultComparator<T>(): (a: T, b: T) => i32 {
}
/** Sorts an Array with the 'Insertion Sort' algorithm. */
export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
export function insertionSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32): Array<T> {
var buffer = arr.buffer_;
for (let i: i32 = 0, length: i32 = arr.length; i < length; i++) {
let a = loadUnsafe<T>(buffer, i); // a = arr[i]
let a = loadUnsafe<T,V>(buffer, i); // a = arr[i]
let j = i - 1;
while (j >= 0) {
let b = loadUnsafe<T>(buffer, j); // b = arr[j]
let b = loadUnsafe<T,V>(buffer, j); // b = arr[j]
if (comparator(a, b) < 0) {
storeUnsafe<T>(buffer, j-- + 1, b); // arr[j + 1] = b
storeUnsafe<T,V>(buffer, j-- + 1, b); // arr[j + 1] = b
} else break;
}
storeUnsafe<T>(buffer, j + 1, a); // arr[j + 1] = a
storeUnsafe<T,V>(buffer, j + 1, a); // arr[j + 1] = a
}
return arr;
}
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
export function weakHeapSort<T,V>(arr: Array<T>, comparator: (a: V, b: V) => i32): Array<T> {
const shift32 = alignof<i32>();
var length = arr.length;
@ -47,37 +47,37 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
while ((j & 1) == (load<i32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
let p = j >> 1;
let a = loadUnsafe<T>(buffer, p); // a = arr[p]
let b = loadUnsafe<T>(buffer, i); // b = arr[i]
let a = loadUnsafe<T,V>(buffer, p); // a = arr[p]
let b = loadUnsafe<T,V>(buffer, i); // b = arr[i]
if (comparator(a, b) < 0) {
store<i32>(
bitset + (i >> 5 << shift32),
load<i32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
);
storeUnsafe<T>(buffer, i, a); // arr[i] = a
storeUnsafe<T>(buffer, p, b); // arr[p] = b
storeUnsafe<T,V>(buffer, i, a); // arr[i] = a
storeUnsafe<T,V>(buffer, p, b); // arr[p] = b
}
}
for (let i = length - 1; i >= 2; i--) {
let a = loadUnsafe<T>(buffer, 0); // a = arr[0]
storeUnsafe<T>(buffer, 0, loadUnsafe<T>(buffer, i)); // arr[0] = arr[i]
storeUnsafe<T>(buffer, i, a); // arr[i] = a
let a = loadUnsafe<T,V>(buffer, 0); // a = arr[0]
storeUnsafe<T,V>(buffer, 0, loadUnsafe<T,V>(buffer, i)); // arr[0] = arr[i]
storeUnsafe<T,V>(buffer, i, a); // arr[i] = a
let x = 1, y: i32;
while ((y = (x << 1) + ((load<i32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
while (x > 0) {
a = loadUnsafe<T>(buffer, 0); // a = arr[0]
let b = loadUnsafe<T>(buffer, x); // b = arr[x]
a = loadUnsafe<T,V>(buffer, 0); // a = arr[0]
let b = loadUnsafe<T,V>(buffer, x); // b = arr[x]
if (comparator(a, b) < 0) {
store<i32>(
bitset + (x >> 5 << shift32),
load<i32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
);
storeUnsafe<T>(buffer, x, a); // arr[x] = a
storeUnsafe<T>(buffer, 0, b); // arr[0] = b
storeUnsafe<T,V>(buffer, x, a); // arr[x] = a
storeUnsafe<T,V>(buffer, 0, b); // arr[0] = b
}
x >>= 1;
}
@ -85,8 +85,8 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
free_memory(bitset);
var t = loadUnsafe<T>(buffer, 1); // t = arr[1]
storeUnsafe<T>(buffer, 1, loadUnsafe<T>(buffer, 0)); // arr[1] = arr[0]
storeUnsafe<T>(buffer, 0, t); // arr[0] = t
var t = loadUnsafe<T,V>(buffer, 1); // t = arr[1]
storeUnsafe<T,V>(buffer, 1, loadUnsafe<T,V>(buffer, 0)); // arr[1] = arr[0]
storeUnsafe<T,V>(buffer, 0, t); // arr[0] = t
return arr;
}

12
std/assembly/internal/arraybuffer.ts
View File

@ -60,21 +60,21 @@ export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuf
}
@inline
export function loadUnsafe<T>(buffer: ArrayBuffer, index: i32): T {
return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE);
export function loadUnsafe<T,V>(buffer: ArrayBuffer, index: i32): V {
return <V>load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE);
}
@inline
export function storeUnsafe<T>(buffer: ArrayBuffer, index: i32, value: T): void {
export function storeUnsafe<T,V>(buffer: ArrayBuffer, index: i32, value: V): void {
store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE);
}
@inline
export function loadUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, byteOffset: i32): T {
return load<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), HEADER_SIZE);
export function loadUnsafeWithOffset<T,V>(buffer: ArrayBuffer, index: i32, byteOffset: i32): V {
return <V>load<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), HEADER_SIZE);
}
@inline
export function storeUnsafeWithOffset<T>(buffer: ArrayBuffer, index: i32, value: T, byteOffset: i32): void {
export function storeUnsafeWithOffset<T,V>(buffer: ArrayBuffer, index: i32, value: V, byteOffset: i32): void {
store<T>(changetype<usize>(buffer) + <usize>byteOffset + (<usize>index << alignof<T>()), value, HEADER_SIZE);
}

24
std/assembly/internal/typedarray.ts
View File

@ -6,12 +6,8 @@ import {
storeUnsafeWithOffset
} from "./arraybuffer";
import {
ArrayBufferView
} from "../arraybuffer";
/** Typed array base class. Not a global object. */
export abstract class TypedArray<T> implements ArrayBufferView<T> {
export abstract class TypedArray<T,V> {
readonly buffer: ArrayBuffer;
readonly byteOffset: i32;
@ -37,21 +33,31 @@ export abstract class TypedArray<T> implements ArrayBufferView<T> {
var byteOffset = this.byteOffset;
var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
return loadUnsafeWithOffset<T>(this.buffer, index, byteOffset);
return loadUnsafeWithOffset<T,T>(this.buffer, index, byteOffset);
}
@operator("{}")
protected __unchecked_get(index: i32): T {
return loadUnsafeWithOffset<T,T>(this.buffer, index, this.byteOffset);
}
@operator("[]=")
protected __set(index: i32, value: T): void {
protected __set(index: i32, value: V): void {
var byteOffset = this.byteOffset;
var elementLength = (this.byteLength - byteOffset) >>> alignof<T>();
if (<u32>index >= <u32>elementLength) throw new Error("Index out of bounds");
storeUnsafeWithOffset<T>(this.buffer, index, value, byteOffset);
storeUnsafeWithOffset<T,V>(this.buffer, index, value, byteOffset);
}
@operator("{}=")
protected __unchecked_set(index: i32, value: V): void {
storeUnsafeWithOffset<T,V>(this.buffer, index, value, this.byteOffset);
}
// copyWithin(target: i32, start: i32, end: i32 = this.length): this
@inline
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T> {
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T,V> {
var length = this.length;
if (begin < 0) begin = max(length + begin, 0);
else begin = min(begin, length);