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

Minor optimizations to array sorting

Browse Source 
...to get a handle on the code
This commit is contained in:
dcodeIO
2018-04-08 01:53:22 +02:00
parent ac2281b14b
commit 0f49e054d2
5 changed files with 317 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,93 +2,77 @@ import { Array } from "../array";
/** Obtains the default comparator for the specified type. */
export function defaultComparator<T>(): (a: T, b: T) => i32 {
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b)); // compiles to a constant function index
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b)); // compiles to a constant table index
}
/** Sorts an Array with the 'Insertion Sort' algorithm. */
export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
var a: T, b: T, j: i32;
const typeShift = alignof<T>();
const shiftT = alignof<T>();
var memory = arr.__memory;
for (let i: i32 = 0, len: i32 = arr.length; i < len; i++) {
a = load<T>(arr.__memory + (i << typeShift)); // a = <T>arr[i];
j = i - 1;
let a = load<T>(memory + (i << shiftT)); // a = arr[i]
let j = i - 1;
while (j >= 0) {
b = load<T>(arr.__memory + (j << typeShift)); // b = <T>arr[j];
let b = load<T>(memory + (j << shiftT)); // b = arr[j]
if (comparator(a, b) < 0) {
store<T>(arr.__memory + ((j + 1) << typeShift), b); // arr[j + 1] = b;
j--;
store<T>(memory + ((j-- + 1) << shiftT), b); // arr[j + 1] = b
} else break;
}
store<T>(arr.__memory + ((j + 1) << typeShift), a); // arr[j + 1] = a;
store<T>(memory + ((j + 1) << shiftT), 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> {
const shiftT = alignof<T>();
const shift32 = alignof<i32>();
var length = arr.length;
var bitsetSize = (length + 31) >> 5 << shift32;
var bitset = allocate_memory(bitsetSize); // indexed in 32-bit chunks below
set_memory(bitset, 0, bitsetSize);
// see: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.1863&rep=rep1&type=pdf
var len: i32 = arr.length;
var i: i32, j: i32, y: i32, p: i32, a: T, b: T;
const typeShift = alignof<T>();
const intShift = alignof<i32>();
var blen = (len + 31) >> 5;
var bitset = allocate_memory(blen << intShift);
set_memory(bitset, 0, blen << intShift);
for (i = len - 1; i > 0; i--) {
j = i;
while ((j & 1) == ((load<i32>(bitset + ((j >> 6) << intShift)) >> ((j >> 1) & 31)) & 1)) {
j >>= 1;
}
p = j >> 1;
a = load<T>(arr.__memory + (p << typeShift)); // a = <T>arr[p];
b = load<T>(arr.__memory + (i << typeShift)); // b = <T>arr[i];
var memory = arr.__memory;
for (let i = length - 1; i > 0; i--) {
let j = i;
while ((j & 1) == (load<i32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
let p = j >> 1;
let a = load<T>(memory + (p << shiftT)); // a = arr[p]
let b = load<T>(memory + (i << shiftT)); // b = arr[i]
if (comparator(a, b) < 0) {
store<i32>(
bitset + ((i >> 5) << intShift),
load<i32>(bitset + ((i >> 5) << intShift)) ^ (1 << (i & 31))
bitset + (i >> 5 << shift32),
load<i32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
);
store<T>(arr.__memory + (i << typeShift), a); // arr[i] = a;
store<T>(arr.__memory + (p << typeShift), b); // arr[p] = b;
store<T>(memory + (i << shiftT), a); // arr[i] = a
store<T>(memory + (p << shiftT), b); // arr[p] = b
}
}
for (i = len - 1; i >= 2; i--) {
/*
a = <T>arr[0];
arr[0] = <T>arr[i];
arr[i] = a;
*/
a = load<T>(arr.__memory, 0);
store<T>(arr.__memory, load<T>(arr.__memory + (i << typeShift)), 0);
store<T>(arr.__memory + (i << typeShift), a);
for (let i = length - 1; i >= 2; i--) {
let a = load<T>(memory, 0); // a = arr[0]
store<T>(memory, load<T>(memory + (i << shiftT)), 0); // arr[0] = arr[1]
store<T>(memory + (i << shiftT), a); // arr[1] = a
let x = 1;
while ((y = (x << 1) + ((load<i32>(bitset + ((x >> 5) << intShift)) >> (x & 31)) & 1)) < i) {
x = y;
}
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 = load<T>(arr.__memory, 0); // a = <T>arr[0];
b = load<T>(arr.__memory + (x << typeShift)); // b = <T>arr[x];
a = load<T>(memory, 0); // a = arr[0]
let b = load<T>(memory + (x << shiftT)); // b = arr[x]
if (comparator(a, b) < 0) {
store<i32>(
bitset + ((x >> 5) << intShift),
load<i32>(bitset + ((x >> 5) << intShift)) ^ (1 << (x & 31))
bitset + (x >> 5 << shift32),
load<i32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
);
store<T>(arr.__memory + (x << typeShift), a); // arr[x] = a;
store<T>(arr.__memory, b, 0); // arr[0] = b;
store<T>(memory + (x << shiftT), a); // arr[x] = a
store<T>(memory, b, 0); // arr[0] = b
}
x >>= 1;
}
@ -96,14 +80,8 @@ export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32):
free_memory(bitset);
/*
let t = <T>arr[1];
arr[1] = <T>arr[0];
arr[0] = t;
*/
var t = load<T>(arr.__memory, sizeof<T>());
store<T>(arr.__memory, load<T>(arr.__memory, 0), sizeof<T>());
store<T>(arr.__memory, t, 0);
var t = load<T>(memory, sizeof<T>()); // t = arr[1]
store<T>(memory, load<T>(memory, 0), sizeof<T>()); // arr[1] = arr[0]
store<T>(memory, t, 0); // arr[0] = t
return arr;
}