mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-06-17 17:01:37 +00:00
Make the transition to ArrayBuffer backed Arrays (#70)
* Traverse base classes when resolving overloads * Implement preliminary TypedArray accessors * Extract decorator flags from common flags to make space * Add '**' overload * Implement basic explicit inlining * Support inlining of instance methods * Reduce number of required locals when inlining * Implement inlining of operator overloads * Fix issues when inlining generic functions
This commit is contained in:
Daniel Wirtz
GitHub
@ -1,3 +1,12 @@
|
||||
import {
|
||||
MAX_BLENGTH,
|
||||
HEADER_SIZE as HEADER_SIZE_AB,
|
||||
allocUnsafe,
|
||||
reallocUnsafe,
|
||||
loadUnsafe,
|
||||
storeUnsafe
|
||||
} from "./internal/arraybuffer";
|
||||
|
||||
import {
|
||||
defaultComparator,
|
||||
insertionSort,
|
||||
@ -6,147 +15,130 @@ import {
|
||||
|
||||
export class Array<T> {
|
||||
|
||||
__memory: usize;
|
||||
__capacity: i32; // capped to [0, 0x7fffffff]
|
||||
__length: i32; // capped to [0, __capacity]
|
||||
/* @internal */ buffer_: ArrayBuffer;
|
||||
/* @internal */ length_: i32;
|
||||
|
||||
private __grow(newCapacity: i32): void {
|
||||
var oldMemory = this.__memory;
|
||||
var oldCapacity = this.__capacity;
|
||||
assert(newCapacity > oldCapacity);
|
||||
var newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
|
||||
if (oldMemory) {
|
||||
move_memory(newMemory, oldMemory, <usize>oldCapacity * sizeof<T>());
|
||||
free_memory(oldMemory);
|
||||
}
|
||||
this.__memory = newMemory;
|
||||
this.__capacity = newCapacity;
|
||||
constructor(length: i32 = 0) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
|
||||
this.buffer_ = allocUnsafe(length << alignof<T>());
|
||||
this.length_ = length;
|
||||
}
|
||||
|
||||
constructor(capacity: i32 = 0) {
|
||||
if (capacity < 0) throw new RangeError("Invalid array length");
|
||||
this.__memory = capacity
|
||||
? allocate_memory(<usize>capacity * sizeof<T>())
|
||||
: 0;
|
||||
this.__capacity = capacity;
|
||||
this.__length = capacity;
|
||||
get length(): i32 {
|
||||
return this.length_;
|
||||
}
|
||||
|
||||
set length(length: i32) {
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>length > <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
|
||||
buffer = reallocUnsafe(buffer, length << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
this.length_ = length;
|
||||
}
|
||||
|
||||
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
|
||||
var toIndex: i32 = this.__length;
|
||||
var i: i32 = 0;
|
||||
while (i < toIndex && i < this.__length) {
|
||||
if (!callbackfn(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) {
|
||||
return false;
|
||||
}
|
||||
i += 1;
|
||||
var buffer = this.buffer_;
|
||||
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
|
||||
if (!callbackfn(loadUnsafe<T>(buffer, index), index, this)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
|
||||
var toIndex: i32 = this.__length;
|
||||
var i: i32 = 0;
|
||||
while (i < toIndex && i < this.__length) {
|
||||
if (predicate(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) {
|
||||
return i;
|
||||
}
|
||||
i += 1;
|
||||
var buffer = this.buffer_;
|
||||
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
|
||||
if (predicate(loadUnsafe<T>(buffer, index), index, this)) return index;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
get length(): i32 {
|
||||
return this.__length;
|
||||
}
|
||||
|
||||
set length(length: i32) {
|
||||
if (length < 0) throw new RangeError("Invalid array length");
|
||||
if (length > this.__capacity) this.__grow(max(length, this.__capacity << 1));
|
||||
this.__length = length;
|
||||
}
|
||||
|
||||
@operator("[]")
|
||||
private __get(index: i32): T {
|
||||
if (<u32>index >= <u32>this.__capacity) throw new Error("Index out of bounds");
|
||||
return load<T>(this.__memory + <usize>index * sizeof<T>());
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>index >= <u32>capacity) throw new Error("Index out of bounds");
|
||||
// return load<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), HEADER_SIZE_AB);
|
||||
return loadUnsafe<T>(buffer, index);
|
||||
}
|
||||
|
||||
@operator("[]=")
|
||||
private __set(index: i32, value: T): void {
|
||||
if (index < 0) throw new Error("Index out of bounds");
|
||||
var capacity = this.__capacity;
|
||||
if (index >= capacity) this.__grow(max(index + 1, capacity << 1));
|
||||
store<T>(this.__memory + <usize>index * sizeof<T>(), value);
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>index >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>index >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocUnsafe(buffer, (index + 1) << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
this.length_ = index + 1;
|
||||
}
|
||||
// store<T>(changetype<usize>(buffer) + (<usize>index << alignof<T>()), value, HEADER_SIZE_AB);
|
||||
storeUnsafe<T>(buffer, index, value);
|
||||
}
|
||||
|
||||
includes(searchElement: T, fromIndex: i32 = 0): bool {
|
||||
var length = this.__length;
|
||||
var length = this.length_;
|
||||
if (length == 0 || fromIndex >= length) return false;
|
||||
if (fromIndex < 0) {
|
||||
fromIndex = length + fromIndex;
|
||||
if (fromIndex < 0) {
|
||||
fromIndex = 0;
|
||||
}
|
||||
}
|
||||
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
|
||||
var buffer = this.buffer_;
|
||||
while (fromIndex < length) {
|
||||
if (load<T>(this.__memory + <usize>fromIndex * sizeof<T>()) == searchElement) return true;
|
||||
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return true;
|
||||
++fromIndex;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
indexOf(searchElement: T, fromIndex: i32 = 0): i32 {
|
||||
var length = this.__length;
|
||||
if (length == 0 || fromIndex >= length) {
|
||||
return -1;
|
||||
}
|
||||
if (fromIndex < 0) {
|
||||
fromIndex = length + fromIndex;
|
||||
if (fromIndex < 0) {
|
||||
fromIndex = 0;
|
||||
}
|
||||
}
|
||||
var memory = this.__memory;
|
||||
var length = this.length_;
|
||||
if (length == 0 || fromIndex >= length) return -1;
|
||||
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
|
||||
var buffer = this.buffer_;
|
||||
while (fromIndex < length) {
|
||||
if (load<T>(memory + <usize>fromIndex * sizeof<T>()) == searchElement) return fromIndex;
|
||||
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
|
||||
++fromIndex;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
lastIndexOf(searchElement: T, fromIndex: i32 = this.__length): i32 {
|
||||
var length = this.__length;
|
||||
lastIndexOf(searchElement: T, fromIndex: i32 = this.length_): i32 {
|
||||
var length = this.length_;
|
||||
if (length == 0) return -1;
|
||||
if (fromIndex < 0) {
|
||||
fromIndex = length + fromIndex;
|
||||
} else if (fromIndex >= length) {
|
||||
fromIndex = length - 1;
|
||||
}
|
||||
var memory = this.__memory;
|
||||
while (fromIndex >= 0) {
|
||||
if (load<T>(memory + <usize>fromIndex * sizeof<T>()) == searchElement) return fromIndex;
|
||||
if (fromIndex < 0) fromIndex = length + fromIndex; // no need to clamp
|
||||
else if (fromIndex >= length) fromIndex = length - 1;
|
||||
var buffer = this.buffer_;
|
||||
while (fromIndex >= 0) { // ^
|
||||
if (loadUnsafe<T>(buffer, fromIndex) == searchElement) return fromIndex;
|
||||
--fromIndex;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
push(element: T): i32 {
|
||||
var capacity = this.__capacity;
|
||||
var length = this.__length;
|
||||
if (length == capacity) {
|
||||
this.__grow(capacity ? capacity << 1 : 1);
|
||||
var length = this.length_;
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
var newLength = length + 1; // safe only if length is checked
|
||||
if (<u32>length >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocUnsafe(buffer, newLength << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
store<T>(this.__memory + <usize>length * sizeof<T>(), element);
|
||||
this.__length = ++length;
|
||||
return length;
|
||||
this.length_ = newLength;
|
||||
storeUnsafe<T>(buffer, length, element);
|
||||
return newLength;
|
||||
}
|
||||
|
||||
pop(): T {
|
||||
var length = this.__length;
|
||||
var length = this.length_;
|
||||
if (length < 1) throw new RangeError("Array is empty");
|
||||
var element = load<T>(this.__memory + <usize>--length * sizeof<T>());
|
||||
this.__length = length;
|
||||
var element = loadUnsafe<T>(this.buffer_, --length);
|
||||
this.length_ = length;
|
||||
return element;
|
||||
}
|
||||
|
||||
@ -154,158 +146,119 @@ export class Array<T> {
|
||||
callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
|
||||
initialValue: U
|
||||
): U {
|
||||
var accumulator: U = initialValue;
|
||||
var toIndex: i32 = this.__length;
|
||||
var i: i32 = 0;
|
||||
while (i < toIndex && i < /* might change */ this.__length) {
|
||||
accumulator = callbackfn(accumulator, load<T>(this.__memory + <usize>i * sizeof<T>()), i, this);
|
||||
i += 1;
|
||||
var accum = initialValue;
|
||||
var buffer = this.buffer_;
|
||||
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
|
||||
accum = callbackfn(accum, loadUnsafe<T>(buffer, index), index, this);
|
||||
}
|
||||
return accumulator;
|
||||
return accum;
|
||||
}
|
||||
|
||||
shift(): T {
|
||||
var length = this.__length;
|
||||
var length = this.length_;
|
||||
if (length < 1) throw new RangeError("Array is empty");
|
||||
var memory = this.__memory;
|
||||
var capacity = this.__capacity;
|
||||
var element = load<T>(memory);
|
||||
var buffer = this.buffer_;
|
||||
var element = loadUnsafe<T>(buffer, 0);
|
||||
var lastIndex = length - 1;
|
||||
move_memory(
|
||||
memory,
|
||||
memory + sizeof<T>(),
|
||||
<usize>(capacity - 1) * sizeof<T>()
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB,
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB + sizeof<T>(),
|
||||
<usize>lastIndex << alignof<T>()
|
||||
);
|
||||
set_memory(
|
||||
memory + <usize>(capacity - 1) * sizeof<T>(),
|
||||
0,
|
||||
sizeof<T>()
|
||||
);
|
||||
this.__length = length - 1;
|
||||
storeUnsafe<T>(buffer, lastIndex, isReference<T>() ? null : <T>0);
|
||||
this.length_ = lastIndex;
|
||||
return element;
|
||||
}
|
||||
|
||||
some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
|
||||
var toIndex: i32 = this.__length;
|
||||
var i: i32 = 0;
|
||||
while (i < toIndex && i < /* might change */ this.__length) {
|
||||
if (callbackfn(load<T>(this.__memory + <usize>i * sizeof<T>()), i, this)) return true;
|
||||
i += 1;
|
||||
var buffer = this.buffer_;
|
||||
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
|
||||
if (callbackfn(loadUnsafe<T>(buffer, index), index, this)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
unshift(element: T): i32 {
|
||||
var memory = this.__memory;
|
||||
var capacity = this.__capacity;
|
||||
var length = this.__length;
|
||||
if (this.__length == capacity) {
|
||||
// inlined __grow (avoids moving twice)
|
||||
let newCapacity: i32 = capacity ? capacity << 1 : 1;
|
||||
assert(newCapacity > capacity);
|
||||
let newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
|
||||
if (memory) {
|
||||
move_memory(
|
||||
newMemory + sizeof<T>(),
|
||||
memory,
|
||||
<usize>capacity * sizeof<T>()
|
||||
);
|
||||
free_memory(memory);
|
||||
}
|
||||
this.__memory = newMemory;
|
||||
this.__capacity = newCapacity;
|
||||
memory = newMemory;
|
||||
} else {
|
||||
move_memory(
|
||||
memory + sizeof<T>(),
|
||||
memory,
|
||||
<usize>capacity * sizeof<T>()
|
||||
);
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
var length = this.length_;
|
||||
var newLength = length + 1; // safe only if length is checked
|
||||
if (<u32>length >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocUnsafe(buffer, newLength << alignof<T>());
|
||||
capacity = buffer.byteLength >>> alignof<T>();
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
store<T>(memory, element);
|
||||
this.__length = ++length;
|
||||
return length;
|
||||
move_memory(
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB + sizeof<T>(),
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB,
|
||||
<usize>(capacity - 1) << alignof<T>()
|
||||
);
|
||||
storeUnsafe<T>(buffer, 0, element);
|
||||
this.length_ = newLength;
|
||||
return newLength;
|
||||
}
|
||||
|
||||
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {
|
||||
var length = this.__length;
|
||||
if (begin < 0) {
|
||||
begin = length + begin;
|
||||
if (begin < 0) {
|
||||
begin = 0;
|
||||
}
|
||||
} else if (begin > length) {
|
||||
begin = length;
|
||||
}
|
||||
if (end < 0) {
|
||||
end = length + end;
|
||||
} else if (end > length) {
|
||||
end = length;
|
||||
}
|
||||
if (end < begin) {
|
||||
end = begin;
|
||||
}
|
||||
var capacity = end - begin;
|
||||
assert(capacity >= 0);
|
||||
var sliced = new Array<T>(capacity);
|
||||
if (capacity) {
|
||||
var length = this.length_;
|
||||
if (begin < 0) begin = max(length + begin, 0);
|
||||
else if (begin > length) begin = length;
|
||||
if (end < 0) end = length + end; // no need to clamp
|
||||
else if (end > length) end = length;
|
||||
if (end < begin) end = begin; // ^
|
||||
var newLength = end - begin;
|
||||
assert(newLength >= 0);
|
||||
var sliced = new Array<T>(newLength);
|
||||
if (newLength) {
|
||||
move_memory(
|
||||
sliced.__memory,
|
||||
this.__memory + <usize>begin * sizeof<T>(),
|
||||
<usize>capacity * sizeof<T>()
|
||||
changetype<usize>(sliced.buffer_) + HEADER_SIZE_AB,
|
||||
changetype<usize>(this.buffer_) + HEADER_SIZE_AB + (<usize>begin << alignof<T>()),
|
||||
<usize>newLength << alignof<T>()
|
||||
);
|
||||
}
|
||||
return sliced;
|
||||
}
|
||||
|
||||
splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): void {
|
||||
if (deleteCount < 1) {
|
||||
return;
|
||||
}
|
||||
var length = this.__length;
|
||||
if (start < 0) {
|
||||
start = length + start;
|
||||
if (start < 0) {
|
||||
start = 0;
|
||||
} else if (start >= length) {
|
||||
return;
|
||||
}
|
||||
} else if (start >= length) {
|
||||
return;
|
||||
}
|
||||
if (deleteCount < 1) return;
|
||||
var length = this.length_;
|
||||
if (start < 0) start = max(length + start, 0);
|
||||
if (start >= length) return;
|
||||
deleteCount = min(deleteCount, length - start);
|
||||
var memory = this.__memory;
|
||||
var buffer = this.buffer_;
|
||||
move_memory(
|
||||
memory + <usize>start * sizeof<T>(),
|
||||
memory + <usize>(start + deleteCount) * sizeof<T>(),
|
||||
<usize>deleteCount * sizeof<T>()
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB + (<usize>start << alignof<T>()),
|
||||
changetype<usize>(buffer) + HEADER_SIZE_AB + (<usize>(start + deleteCount) << alignof<T>()),
|
||||
<usize>deleteCount << alignof<T>()
|
||||
);
|
||||
this.__length = length - deleteCount;
|
||||
this.length_ = length - deleteCount;
|
||||
}
|
||||
|
||||
reverse(): Array<T> {
|
||||
var memory = this.__memory;
|
||||
for (let front: usize = 0, back: usize = <usize>this.__length - 1; front < back; ++front, --back) {
|
||||
let temp = load<T>(memory + front * sizeof<T>());
|
||||
store<T>(memory + front * sizeof<T>(), load<T>(memory + back * sizeof<T>()));
|
||||
store<T>(memory + back * sizeof<T>(), temp);
|
||||
var buffer = this.buffer_;
|
||||
for (let front = 0, back = this.length_ - 1; front < back; ++front, --back) {
|
||||
let temp = loadUnsafe<T>(buffer, front);
|
||||
storeUnsafe<T>(buffer, front, loadUnsafe<T>(buffer, back));
|
||||
storeUnsafe<T>(buffer, back, temp);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
sort(comparator: (a: T, b: T) => i32 = defaultComparator<T>()): Array<T> {
|
||||
var len = this.length;
|
||||
if (len <= 1) return this;
|
||||
if (len == 2) {
|
||||
let memory = this.__memory;
|
||||
let a = load<T>(memory, sizeof<T>()); // var a = <T>arr[1];
|
||||
let b = load<T>(memory, 0); // var b = <T>arr[0];
|
||||
var length = this.length_;
|
||||
if (length <= 1) return this;
|
||||
var buffer = this.buffer_;
|
||||
if (length == 2) {
|
||||
let a = loadUnsafe<T>(buffer, 1); // a = arr[1]
|
||||
let b = loadUnsafe<T>(buffer, 0); // b = arr[0]
|
||||
if (comparator(a, b) < 0) {
|
||||
store<T>(memory, b, sizeof<T>()); // arr[1] = b;
|
||||
store<T>(memory, a, 0); // arr[0] = a;
|
||||
storeUnsafe<T>(buffer, 1, b); // arr[1] = b;
|
||||
storeUnsafe<T>(buffer, 0, a); // arr[0] = a;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
return len <= 256
|
||||
return length < 256
|
||||
? insertionSort<T>(this, comparator)
|
||||
: weakHeapSort<T>(this, comparator);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user