mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-06-22 03:01:55 +00:00
slim down runtime
This commit is contained in:
dcode
@ -1,154 +1,154 @@
|
||||
export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c
|
||||
var w: u32, x: u32;
|
||||
// export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c
|
||||
// var w: u32, x: u32;
|
||||
|
||||
// copy 1 byte each until src is aligned to 4 bytes
|
||||
while (n && (src & 3)) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
n--;
|
||||
}
|
||||
// // copy 1 byte each until src is aligned to 4 bytes
|
||||
// while (n && (src & 3)) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// n--;
|
||||
// }
|
||||
|
||||
// if dst is aligned to 4 bytes as well, copy 4 bytes each
|
||||
if ((dest & 3) == 0) {
|
||||
while (n >= 16) {
|
||||
store<u32>(dest , load<u32>(src ));
|
||||
store<u32>(dest + 4, load<u32>(src + 4));
|
||||
store<u32>(dest + 8, load<u32>(src + 8));
|
||||
store<u32>(dest + 12, load<u32>(src + 12));
|
||||
src += 16; dest += 16; n -= 16;
|
||||
}
|
||||
if (n & 8) {
|
||||
store<u32>(dest , load<u32>(src ));
|
||||
store<u32>(dest + 4, load<u32>(src + 4));
|
||||
dest += 8; src += 8;
|
||||
}
|
||||
if (n & 4) {
|
||||
store<u32>(dest, load<u32>(src));
|
||||
dest += 4; src += 4;
|
||||
}
|
||||
if (n & 2) { // drop to 2 bytes each
|
||||
store<u16>(dest, load<u16>(src));
|
||||
dest += 2; src += 2;
|
||||
}
|
||||
if (n & 1) { // drop to 1 byte
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
return;
|
||||
}
|
||||
// // if dst is aligned to 4 bytes as well, copy 4 bytes each
|
||||
// if ((dest & 3) == 0) {
|
||||
// while (n >= 16) {
|
||||
// store<u32>(dest , load<u32>(src ));
|
||||
// store<u32>(dest + 4, load<u32>(src + 4));
|
||||
// store<u32>(dest + 8, load<u32>(src + 8));
|
||||
// store<u32>(dest + 12, load<u32>(src + 12));
|
||||
// src += 16; dest += 16; n -= 16;
|
||||
// }
|
||||
// if (n & 8) {
|
||||
// store<u32>(dest , load<u32>(src ));
|
||||
// store<u32>(dest + 4, load<u32>(src + 4));
|
||||
// dest += 8; src += 8;
|
||||
// }
|
||||
// if (n & 4) {
|
||||
// store<u32>(dest, load<u32>(src));
|
||||
// dest += 4; src += 4;
|
||||
// }
|
||||
// if (n & 2) { // drop to 2 bytes each
|
||||
// store<u16>(dest, load<u16>(src));
|
||||
// dest += 2; src += 2;
|
||||
// }
|
||||
// if (n & 1) { // drop to 1 byte
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// return;
|
||||
// }
|
||||
|
||||
// if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each
|
||||
// doing shifts if faster when copying enough bytes (here: 32 or more)
|
||||
if (n >= 32) {
|
||||
switch (dest & 3) {
|
||||
// known to be != 0
|
||||
case 1: {
|
||||
w = load<u32>(src);
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
n -= 3;
|
||||
while (n >= 17) {
|
||||
x = load<u32>(src + 1);
|
||||
store<u32>(dest, w >> 24 | x << 8);
|
||||
w = load<u32>(src + 5);
|
||||
store<u32>(dest + 4, x >> 24 | w << 8);
|
||||
x = load<u32>(src + 9);
|
||||
store<u32>(dest + 8, w >> 24 | x << 8);
|
||||
w = load<u32>(src + 13);
|
||||
store<u32>(dest + 12, x >> 24 | w << 8);
|
||||
src += 16; dest += 16; n -= 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
w = load<u32>(src);
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
n -= 2;
|
||||
while (n >= 18) {
|
||||
x = load<u32>(src + 2);
|
||||
store<u32>(dest, w >> 16 | x << 16);
|
||||
w = load<u32>(src + 6);
|
||||
store<u32>(dest + 4, x >> 16 | w << 16);
|
||||
x = load<u32>(src + 10);
|
||||
store<u32>(dest + 8, w >> 16 | x << 16);
|
||||
w = load<u32>(src + 14);
|
||||
store<u32>(dest + 12, x >> 16 | w << 16);
|
||||
src += 16; dest += 16; n -= 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
w = load<u32>(src);
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
n -= 1;
|
||||
while (n >= 19) {
|
||||
x = load<u32>(src + 3);
|
||||
store<u32>(dest, w >> 8 | x << 24);
|
||||
w = load<u32>(src + 7);
|
||||
store<u32>(dest + 4, x >> 8 | w << 24);
|
||||
x = load<u32>(src + 11);
|
||||
store<u32>(dest + 8, w >> 8 | x << 24);
|
||||
w = load<u32>(src + 15);
|
||||
store<u32>(dest + 12, x >> 8 | w << 24);
|
||||
src += 16; dest += 16; n -= 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each
|
||||
// // doing shifts if faster when copying enough bytes (here: 32 or more)
|
||||
// if (n >= 32) {
|
||||
// switch (dest & 3) {
|
||||
// // known to be != 0
|
||||
// case 1: {
|
||||
// w = load<u32>(src);
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// n -= 3;
|
||||
// while (n >= 17) {
|
||||
// x = load<u32>(src + 1);
|
||||
// store<u32>(dest, w >> 24 | x << 8);
|
||||
// w = load<u32>(src + 5);
|
||||
// store<u32>(dest + 4, x >> 24 | w << 8);
|
||||
// x = load<u32>(src + 9);
|
||||
// store<u32>(dest + 8, w >> 24 | x << 8);
|
||||
// w = load<u32>(src + 13);
|
||||
// store<u32>(dest + 12, x >> 24 | w << 8);
|
||||
// src += 16; dest += 16; n -= 16;
|
||||
// }
|
||||
// break;
|
||||
// }
|
||||
// case 2: {
|
||||
// w = load<u32>(src);
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// n -= 2;
|
||||
// while (n >= 18) {
|
||||
// x = load<u32>(src + 2);
|
||||
// store<u32>(dest, w >> 16 | x << 16);
|
||||
// w = load<u32>(src + 6);
|
||||
// store<u32>(dest + 4, x >> 16 | w << 16);
|
||||
// x = load<u32>(src + 10);
|
||||
// store<u32>(dest + 8, w >> 16 | x << 16);
|
||||
// w = load<u32>(src + 14);
|
||||
// store<u32>(dest + 12, x >> 16 | w << 16);
|
||||
// src += 16; dest += 16; n -= 16;
|
||||
// }
|
||||
// break;
|
||||
// }
|
||||
// case 3: {
|
||||
// w = load<u32>(src);
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// n -= 1;
|
||||
// while (n >= 19) {
|
||||
// x = load<u32>(src + 3);
|
||||
// store<u32>(dest, w >> 8 | x << 24);
|
||||
// w = load<u32>(src + 7);
|
||||
// store<u32>(dest + 4, x >> 8 | w << 24);
|
||||
// x = load<u32>(src + 11);
|
||||
// store<u32>(dest + 8, w >> 8 | x << 24);
|
||||
// w = load<u32>(src + 15);
|
||||
// store<u32>(dest + 12, x >> 8 | w << 24);
|
||||
// src += 16; dest += 16; n -= 16;
|
||||
// }
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// copy remaining bytes one by one
|
||||
if (n & 16) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
if (n & 8) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
if (n & 4) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
if (n & 2) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
if (n & 1) {
|
||||
store<u8>(dest++, load<u8>(src++));
|
||||
}
|
||||
}
|
||||
// // copy remaining bytes one by one
|
||||
// if (n & 16) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// if (n & 8) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// if (n & 4) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// if (n & 2) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// if (n & 1) {
|
||||
// store<u8>(dest++, load<u8>(src++));
|
||||
// }
|
||||
// }
|
||||
|
||||
// @ts-ignore: decorator
|
||||
@inline
|
||||
export function memmove(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memmove.c
|
||||
if (dest === src) return;
|
||||
if (src + n <= dest || dest + n <= src) {
|
||||
memcpy(dest, src, n);
|
||||
return;
|
||||
}
|
||||
// if (src + n <= dest || dest + n <= src) {
|
||||
// memcpy(dest, src, n);
|
||||
// return;
|
||||
// }
|
||||
if (dest < src) {
|
||||
if ((src & 7) == (dest & 7)) {
|
||||
while (dest & 7) {
|
||||
|
||||
@ -45,3 +45,49 @@ export function adjust(payloadSize: usize): usize {
|
||||
// MAX_LENGTH -> 2^30 = 0x40000000 (MAX_SIZE_32)
|
||||
return <usize>1 << <usize>(<u32>32 - clz<u32>(payloadSize + HEADER_SIZE - 1));
|
||||
}
|
||||
|
||||
/** Reallocates the memory of a managed object that turned out to be too small or too large. */
|
||||
// @ts-ignore: decorator
|
||||
@unsafe
|
||||
export function reallocate(ref: usize, newPayloadSize: usize): usize {
|
||||
// Background: When managed objects are allocated these aren't immediately registered with GC
|
||||
// but can be used as scratch objects while unregistered. This is useful in situations where
|
||||
// the object must be reallocated multiple times because its final size isn't known beforehand,
|
||||
// e.g. in Array#filter, with only the final object making it into GC'ed userland.
|
||||
var header = changetype<HEADER>(ref - HEADER_SIZE);
|
||||
var payloadSize = header.payloadSize;
|
||||
if (payloadSize < newPayloadSize) {
|
||||
let newAdjustedSize = adjust(newPayloadSize);
|
||||
if (select(adjust(payloadSize), 0, ref > HEAP_BASE) < newAdjustedSize) {
|
||||
// move if the allocation isn't large enough or not a heap object
|
||||
let newHeader = changetype<HEADER>(memory.allocate(newAdjustedSize));
|
||||
newHeader.classId = header.classId;
|
||||
if (isDefined(__ref_collect)) {
|
||||
newHeader.reserved1 = 0;
|
||||
newHeader.reserved2 = 0;
|
||||
}
|
||||
let newRef = changetype<usize>(newHeader) + HEADER_SIZE;
|
||||
memory.copy(newRef, ref, payloadSize);
|
||||
memory.fill(newRef + payloadSize, 0, newPayloadSize - payloadSize);
|
||||
if (header.classId == HEADER_MAGIC) {
|
||||
// free right away if not registered yet
|
||||
assert(ref > HEAP_BASE); // static objects aren't scratch objects
|
||||
memory.free(changetype<usize>(header));
|
||||
} else if (isDefined(__ref_collect)) {
|
||||
// if previously registered, register again
|
||||
// @ts-ignore: stub
|
||||
__ref_register(ref);
|
||||
}
|
||||
header = newHeader;
|
||||
ref = newRef;
|
||||
} else {
|
||||
// otherwise just clear additional memory within this block
|
||||
memory.fill(ref + payloadSize, 0, newPayloadSize - payloadSize);
|
||||
}
|
||||
} else {
|
||||
// if the size is the same or less, just update the header accordingly.
|
||||
// unused space is cleared when grown, so no need to do this here.
|
||||
}
|
||||
header.payloadSize = newPayloadSize;
|
||||
return ref;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user