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

checked builtin array get, optimize abv layout

Browse Source
This commit is contained in:
dcode
2019-03-17 08:46:26 +01:00
parent e63c6bd388
commit f21b339563
20 changed files with 4772 additions and 1568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
std/assembly/array.ts
View File

@ -4,6 +4,22 @@ import { COMPARATOR, SORT } from "./util/sort";
import { itoa, dtoa, itoa_stream, dtoa_stream, MAX_DOUBLE_LENGTH } from "./util/number";
import { isArray as builtin_isArray } from "./builtins";
/** Ensures that the given array has _at least_ the specified length. */
function ensureLength(array: ArrayBufferView, length: i32, alignLog2: u32): void {
var oldData = array.data;
var oldCapacity = oldData.byteLength >>> alignLog2;
if (<u32>length > <u32>oldCapacity) {
if (<u32>length > <u32>(MAX_BYTELENGTH >>> alignLog2)) throw new RangeError("Invalid array length");
let newByteLength = length << alignLog2;
let newData = REALLOCATE(changetype<usize>(oldData), <usize>newByteLength); // registers on move
if (newData !== changetype<usize>(oldData)) {
array.data = changetype<ArrayBuffer>(newData); // links
array.dataStart = newData;
array.dataLength = newByteLength;
}
}
}
export class Array<T> extends ArrayBufferView {
private length_: i32;
@ -25,26 +41,10 @@ export class Array<T> extends ArrayBufferView {
}
set length(length: i32) {
this.resize(length);
ensureLength(changetype<ArrayBufferView>(this), length, alignof<T>());
this.length_ = length;
}
private resize(length: i32): void {
var oldData = this.data;
var oldCapacity = oldData.byteLength >>> alignof<T>();
if (<u32>length > <u32>oldCapacity) {
const MAX_LENGTH = MAX_BYTELENGTH >>> alignof<T>();
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
let newCapacity = <usize>length << alignof<T>();
let newData = REALLOCATE(changetype<usize>(oldData), newCapacity); // registers on move
if (newData !== changetype<usize>(oldData)) {
this.data = changetype<ArrayBuffer>(newData); // links
this.dataStart = newData;
this.dataEnd = newData + newCapacity;
}
}
}
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
if (!callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
@ -59,33 +59,14 @@ export class Array<T> extends ArrayBufferView {
return -1;
}
// @operator("[]")
// private __get(index: i32): T {
// var buffer = this.buffer_;
// return <u32>index < <u32>(buffer.byteLength >>> alignof<T>())
// ? LOAD<T>(buffer, index)
// : <T>unreachable();
// }
// @operator("{}")
// private __unchecked_get(index: i32): T {
// return LOAD<T>(this.buffer_, index);
// }
@operator("[]=")
private __set(index: i32, value: T): void {
this.resize(index + 1);
private __set(index: i32, value: T): void { // unchecked is built-in
ensureLength(changetype<ArrayBufferView>(this), index + 1, alignof<T>());
store<T>(this.dataStart + (<usize>index << alignof<T>()), value);
if (isManaged<T>()) LINK(value, this);
if (index >= this.length_) this.length_ = index + 1;
}
// @operator("{}=")
// private __unchecked_set(index: i32, value: T): void {
// STORE<T>(this.buffer_, index, value);
// if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
// }
fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {
var dataStart = this.dataStart;
var length = this.length_;
@ -138,7 +119,7 @@ export class Array<T> extends ArrayBufferView {
push(element: T): i32 {
var newLength = this.length_ + 1;
this.resize(newLength);
ensureLength(changetype<ArrayBufferView>(this), newLength, alignof<T>());
this.length_ = newLength;
store<T>(this.dataStart + (<usize>(newLength - 1) << alignof<T>()), element);
if (isManaged<T>()) LINK(element, this);
@ -285,7 +266,7 @@ export class Array<T> extends ArrayBufferView {
unshift(element: T): i32 {
var newLength = this.length_;
this.resize(newLength);
ensureLength(changetype<ArrayBufferView>(this), newLength, alignof<T>());
var base = this.dataStart;
memory.copy(
base + sizeof<T>(),
@ -347,7 +328,7 @@ export class Array<T> extends ArrayBufferView {
reverse(): Array<T> {
var front = this.dataStart;
var back = this.dataEnd - sizeof<T>();
var back = this.dataStart + this.dataLength - sizeof<T>();
while (front < back) {
let temp = load<T>(front);
store<T>(front, load<T>(back));

138
std/assembly/dataview.ts
View File

@ -5,7 +5,7 @@ export class DataView {
private data: ArrayBuffer;
private dataStart: usize;
private dataEnd: usize;
private dataLength: u32;
constructor(
buffer: ArrayBuffer,
@ -18,7 +18,7 @@ export class DataView {
this.data = buffer; // links
var dataStart = changetype<usize>(buffer) + <usize>byteOffset;
this.dataStart = dataStart;
this.dataEnd = dataStart + <usize>byteLength;
this.dataLength = byteLength;
}
get buffer(): ArrayBuffer {
@ -30,169 +30,129 @@ export class DataView {
}
get byteLength(): i32 {
return <i32>(this.dataEnd - this.dataStart);
return this.dataLength;
}
getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
return littleEndian
? load<f32>(dataOffset)
? load<f32>(this.dataStart + <usize>byteOffset)
: reinterpret<f32>(
bswap<u32>(
load<u32>(dataOffset)
load<u32>(this.dataStart + <usize>byteOffset)
)
);
}
getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
return littleEndian
? load<f64>(dataOffset)
? load<f64>(this.dataStart + <usize>byteOffset)
: reinterpret<f64>(
bswap<u64>(
load<u64>(dataOffset)
load<u64>(this.dataStart + <usize>byteOffset)
)
);
}
getInt8(byteOffset: i32): i8 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<i8>(dataOffset);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
return load<i8>(this.dataStart + <usize>byteOffset);
}
getInt16(byteOffset: i32, littleEndian: boolean = false): i16 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i16 = load<i16>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: i16 = load<i16>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i16>(result);
}
getInt32(byteOffset: i32, littleEndian: boolean = false): i32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i32 = load<i32>(dataOffset);
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
var result: i32 = load<i32>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i32>(result);
}
getUint8(byteOffset: i32): u8 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<u8>(dataOffset);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
return load<u8>(this.dataStart + <usize>byteOffset);
}
getUint16(byteOffset: i32, littleEndian: boolean = false): u16 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u16 = load<u16>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: u16 = load<u16>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u16>(result);
}
getUint32(byteOffset: i32, littleEndian: boolean = false): u32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u32 = load<u32>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: u32 = load<u32>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u32>(result);
}
setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (littleEndian) store<f32>(dataOffset, value);
else store<u32>(dataOffset, bswap(reinterpret<u32>(value)));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
if (littleEndian) store<f32>(this.dataStart + <usize>byteOffset, value);
else store<u32>(this.dataStart + <usize>byteOffset, bswap<u32>(reinterpret<u32>(value)));
}
setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (littleEndian) store<f64>(dataOffset, value);
else store<u64>(dataOffset, bswap(reinterpret<u64>(value)));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
if (littleEndian) store<f64>(this.dataStart + <usize>byteOffset, value);
else store<u64>(this.dataStart + <usize>byteOffset, bswap<u64>(reinterpret<u64>(value)));
}
setInt8(byteOffset: i32, value: i8): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<i8>(dataOffset, value);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
store<i8>(this.dataStart + <usize>byteOffset, value);
}
setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
store<i16>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
store<i16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i16>(value));
}
setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
store<i32>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
store<i32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i32>(value));
}
setUint8(byteOffset: i32, value: u8): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<u8>(dataOffset, value);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
store<u8>(this.dataStart + <usize>byteOffset, value);
}
setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
store<u16>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
store<u16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
}
setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
store<u32>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
store<u32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
}
// Non-standard additions that make sense in WebAssembly, but won't work in JS:
getInt64(byteOffset: i32, littleEndian: boolean = false): i64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i64 = load<i64>(dataOffset);
return littleEndian ? result : bswap(result);
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
var result: i64 = load<i64>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i64>(result);
}
getUint64(byteOffset: i32, littleEndian: boolean = false): u64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
var result = load<u64>(dataOffset);
return littleEndian ? result : bswap(result);
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
var result = load<u64>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u64>(result);
}
setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
store<i64>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
store<i64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i64>(value));
}
setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
store<u64>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
store<u64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
}
toString(): string {

11
std/assembly/runtime.ts
View File

@ -122,6 +122,7 @@ function doReallocate(ref: usize, newPayloadSize: usize): usize {
// @ts-ignore: decorator
@unsafe @inline
export function REGISTER<T>(ref: usize): T {
if (!isReference<T>()) ERROR("reference expected");
return changetype<T>(doRegister(ref, CLASSID<T>()));
}
@ -137,6 +138,8 @@ function doRegister(ref: usize, classId: u32): usize {
// @ts-ignore: decorator
@unsafe @inline
export function LINK<T,TParent>(ref: T, parentRef: TParent): void {
if (!isReference<T>()) ERROR("reference expected");
if (!isReference<TParent>()) ERROR("reference expected");
doLink(changetype<usize>(ref), changetype<usize>(parentRef));
}
@ -174,7 +177,7 @@ function doWrapArray(buffer: ArrayBuffer, classId: u32, alignLog2: usize): usize
var newBuffer = doRegister(doAllocate(bufferSize), classId);
changetype<ArrayBufferView>(array).data = changetype<ArrayBuffer>(newBuffer); // links
changetype<ArrayBufferView>(array).dataStart = changetype<usize>(newBuffer);
changetype<ArrayBufferView>(array).dataEnd = changetype<usize>(newBuffer) + bufferSize;
changetype<ArrayBufferView>(array).dataLength = bufferSize;
store<i32>(changetype<usize>(array), <i32>(bufferSize >>> alignLog2), offsetof<i32[]>("length_"));
memory.copy(changetype<usize>(newBuffer), changetype<usize>(buffer), bufferSize);
return changetype<usize>(array);
@ -217,14 +220,14 @@ export abstract class ArrayBufferView {
// @ts-ignore: decorator
@unsafe
dataEnd: usize;
dataLength: u32;
protected constructor(length: i32, alignLog2: i32) {
if (<u32>length > <u32>MAX_BYTELENGTH >>> alignLog2) throw new RangeError("Invalid length");
var buffer = new ArrayBuffer(length = length << alignLog2);
this.data = buffer;
this.dataStart = changetype<usize>(buffer);
this.dataEnd = changetype<usize>(buffer) + <usize>length;
this.dataLength = length;
}
get byteOffset(): i32 {
@ -232,7 +235,7 @@ export abstract class ArrayBufferView {
}
get byteLength(): i32 {
return <i32>(this.dataEnd - this.dataStart);
return this.dataLength;
}
get length(): i32 {

4
std/assembly/string.ts
View File

@ -366,8 +366,8 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
charStr,
load<u16>(changetype<usize>(this) + (<usize>i << 1))
);
store<String>(resultStart + (<usize>i << alignof<String>()), REGISTER<String>(charStr));
LINK(charStr, result);
store<usize>(resultStart + (<usize>i << alignof<usize>()), charStr); // result[i] = charStr
LINK(REGISTER<String>(charStr), result);
}
return result;
} else if (!length) {

8
std/assembly/typedarray.ts
View File

@ -1,9 +1,9 @@
import { ALLOCATE, REGISTER, LINK, ArrayBufferView } from "./runtime";
import { COMPARATOR, SORT as SORT_IMPL } from "./util/sort";
function clampToByte(value: i32): i32 {
return ~(value >> 31) & (((255 - value) >> 31) | value); // & 255
}
// function clampToByte(value: i32): i32 {
// return ~(value >> 31) & (((255 - value) >> 31) | value); // & 255
// }
export class Int8Array extends ArrayBufferView {
@ -809,7 +809,7 @@ function SUBARRAY<TArray extends ArrayBufferView, T>(
var dataStart = array.dataStart;
changetype<ArrayBufferView>(out).data = data; // links
changetype<ArrayBufferView>(out).dataStart = dataStart + (<usize>begin << alignof<T>());
changetype<ArrayBufferView>(out).dataEnd = dataStart + (<usize>end << alignof<T>());
changetype<ArrayBufferView>(out).dataLength = (end - begin) << alignof<T>();
return out;
}