vek-engine
Version:
Efficient WebAssembly-based vector math engine for JavaScript/TypeScript
1 lines • 627 kB
Source Map (JSON)
{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","wasm/src/ptr.ts","wasm/src/vector.ts","~lib/builtins.ts","~lib/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/util/number.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/rt.ts","~lib/staticarray.ts","~lib/util/sort.ts","~lib/string.ts","~lib/arraybuffer.ts","~lib/dataview.ts","~lib/math.ts","~lib/util/hash.ts","~lib/map.ts","~lib/set.ts","~lib/array.ts","~lib/typedarray.ts","~lib/memory.ts","wasm/src/vector-messagepack.ts","wasm/src/vector-iterator.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof<usize>() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load<Block>(changetype<usize>(block) - sizeof<usize>());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof<usize>();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof<u32>());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof<usize>();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof<usize>();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype<Root>(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load<u32>(\n changetype<usize>(root) + (fl << alignof<u32>()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store<u32>(\n changetype<usize>(root) + (fl << alignof<u32>()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load<Block>(\n changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store<Block | null>(\n changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load<Block>(\n changetype<usize>(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store<Block>(\n changetype<usize>(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype<usize>(block) + BLOCK_OVERHEAD + size == changetype<usize>(right)); // must match\n\n // set 'back' to itself at the end of block\n store<Block>(changetype<usize>(right) - sizeof<usize>(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = <u32>(size >> AL_BITS);\n } else {\n const inv: usize = sizeof<usize>() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz<usize>(boundedSize);\n sl = <u32>((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = <u32>(size >> AL_BITS);\n } else {\n const inv: usize = sizeof<usize>() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz<usize>(boundedSize);\n sl = <u32>((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = <u32>(size >> AL_BITS);\n } else {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof<usize>() * 8 - 1;\n const invRound = inv - SL_BITS;\n let requestSize = size < halfMaxSize\n ? size + (1 << (invRound - clz<usize>(size))) - 1\n : size;\n fl = inv - clz<usize>(requestSize);\n sl = <u32>((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz<usize>(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz<u32>(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz<u32>(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, end: usize): bool {\n if (DEBUG) assert(start <= end); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype<usize>(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype<usize>(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype<usize>(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype<Block>(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype<Block>(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n const halfMaxSize = BLOCK_MAXSIZE >> 1;\n if (size < halfMaxSize) { // don't round last fl\n const invRound = (sizeof<usize>() * 8 - 1) - SL_BITS;\n size += (1 << (invRound - clz<usize>(size))) - 1;\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((<usize>pagesBefore << 16) - BLOCK_OVERHEAD != changetype<usize>(GETTAIL(root)));\n let pagesNeeded = <i32>(((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, <usize>pagesBefore << 16, <usize>pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = <i32>((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype<Root>(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype<Block>(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = <usize>ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype<Block>(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype<usize>(newBlock) + BLOCK_OVERHEAD, changetype<usize>(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype<usize>(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype<Block>(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype<usize>(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype<usize>(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype<usize>(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n