@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/dist/internal/compiler/wasm.js

@@ -2,15 +2,15 @@ import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { Fail, State } from "../../Input.js";
 import { floatTexts, toFloat } from "../numbers.js";
+import { nodeOf } from "../node.js";
 import { backend as backend$1, jitSupported } from "./jit.js";
 import * as Option from "effect/Option";
 import { charOf, fastLimit, latin1, string, utf16be, utf16le, utf8 } from "../text.js";
 import * as Arr from "effect/Array";
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { nodeOf } from "../node.js";
 import { buildsEntries, isDiagnostic, pairOf } from "./entries.js";
 import { TableSize, kindOfEncoding, textSet, tokenSet } from "./sets.js";
-import { countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js";
+import { countInlined, countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js";
 import { Body, F64, I32, Op, Simd, encodeModule } from "./wasmAsm.js";
 // src/internal/compiler/wasm.ts
 /**
@@ -84,6 +84,32 @@ const Slack = 65536;
 const MaxWrites = 4096;
 /** Bytes left after the cursor beyond which a driver's parse of the same buffer runs the JIT (see `run`). */
 const LargeRest = 4096;
+/**
+* The most linear memory a module is grown to: 2 GiB. Every offset into the
+* memory, the trace's included, is then a non-negative `i32`. A parse that
+* would need more (its input copied, and four to seven times as much of
+* trace), or whose `memory.grow` the engine refuses, runs on the JIT, which
+* needs neither (#123).
+*/
+const MaxMemory = 2 ** 31;
+/**
+* Above this much linear memory after a parse (128 MiB), the module is
+* given a new memory: `WebAssembly.Memory` never shrinks, so one large
+* input would otherwise hold five to ten times its size for the life of
+* the process, per compiled parser and input kind.
+*/
+const ReleaseAbove = 134217728;
+/** What `grow` throws when the trace cannot grow: the parse starts again on the JIT. */
+var MemoryExhausted = class {};
+/**
+* A repetition bound as the `i32` it is compared with, unsigned. A count
+* never reaches 2^32 - 1 (the input is in a 32-bit memory), so a larger
+* minimum is one that cannot be met, and a larger maximum is none at all
+* (see `unbounded`); written as given, it was truncated to its low 32 bits.
+*/
+const bound = (n) => n >= 4294967295 ? 4294967295 : n;
+/** Whether a maximum can never be reached by a count (see {@link bound}). */
+const unbounded = (max) => max >= 4294967295;
 /** The most literals a compiled `takeUntilAny` checks at each candidate; more are searched in JavaScript. */
 const MaxUntil = 64;
 /** The most leading bytes of each literal a SIMD search tests at once. */
@@ -341,6 +367,8 @@ var WasmCompiler = class WasmCompiler {
 	rules = [/* @__PURE__ */ new WeakMap(), /* @__PURE__ */ new WeakMap()];
 	pending = [];
 	refs = /* @__PURE__ */ new WeakMap();
+	/** How many parsers have been inlined (see `countInlined`). */
+	inlined = 0;
 	decoders = /* @__PURE__ */ new WeakMap();
 	floatScanners = /* @__PURE__ */ new WeakMap();
 	/** The float scanner of `Token` / `Ascii` text, which has no encoding. */
@@ -578,6 +606,7 @@ var WasmCompiler = class WasmCompiler {
 		return isBuiltin(enc) && kindOfEncoding(enc) === this.kind;
 	}
 	inline(p, out, b, fail, bf, depth) {
+		this.inlined = countInlined(this.inlined);
 		const node = nodeOf(p);
 		const s = {
 			p,
@@ -1040,7 +1069,7 @@ var WasmCompiler = class WasmCompiler {
 	stop(b, fail, n, min, restore, done) {
 		this.unlessBacktrack(b, fail);
 		if (min > 0) {
-			b.get(n).i32(min).op(Op.i32LtU);
+			b.get(n).i32(bound(min)).op(Op.i32LtU);
 			b.if(() => b.br(fail));
 		}
 		restore();
@@ -1069,11 +1098,11 @@ var WasmCompiler = class WasmCompiler {
 		b.i32(0).set(n);
 		b.block((done) => {
 			this.loop(b, (again) => {
-				if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(done);
+				if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(done);
 				const saved = this.save(b);
 				this.attempt(b, (bad) => {
 					elementCode = element(b, bad, bf);
-					if (max === Infinity) this.progress(b, fail, saved[0]);
+					this.progress(b, fail, saved[0]);
 					this.nextElement(b, n, again);
 				}, () => this.stop(b, fail, n, min, () => this.restore(b, saved), done));
 			});
@@ -1115,10 +1144,10 @@ var WasmCompiler = class WasmCompiler {
 				b.br(done);
 			});
 			this.loop(b, (again) => {
-				if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(done);
+				if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(done);
 				mark();
 				this.attempt(b, (bad) => this.gen(node.separator, "", b, bad, bf, d), () => this.stop(b, fail, n, min, back, done));
-				if (max === Infinity) this.progress(b, fail, st);
+				this.progress(b, fail, st);
 				this.attempt(b, (bad) => {
 					element(b, bad, new Vars());
 					this.nextElement(b, n, again);
@@ -1360,14 +1389,14 @@ var WasmCompiler = class WasmCompiler {
 			b.loop((again) => {
 				this.atEnd(b, 0);
 				b.brIf(stop);
-				if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(stop);
+				if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(stop);
 				this.whileStep(enc, b, set, w, wide, stop);
 				if (counted) b.get(n).i32(1).op(Op.i32Add).set(n);
 				b.br(again);
 			});
 		});
 		if (min > 0) {
-			if (counted) b.get(n).i32(min).op(Op.i32LtU);
+			if (counted) b.get(n).i32(bound(min)).op(Op.i32LtU);
 			else b.get(0).get(st).op(Op.i32Eq);
 			this.failIf(b, s.fail);
 		}
@@ -2600,7 +2629,7 @@ const exportedGlobal = (exports, name) => {
 	return g instanceof WebAssembly.Global ? Result.succeed(g) : Result.fail(`no global ${name}`);
 };
 const run = (root, c, bytes, kind, build, source) => {
-	const memory = new WebAssembly.Memory({ initial: 2 });
+	let memory = new WebAssembly.Memory({ initial: 2 });
 	let size = memory.buffer.byteLength;
 	let i32 = new Int32Array(memory.buffer);
 	let f64 = new Float64Array(memory.buffer);
@@ -2610,13 +2639,20 @@ const run = (root, c, bytes, kind, build, source) => {
 		f64 = new Float64Array(memory.buffer);
 		u8 = new Uint8Array(memory.buffer);
 	};
-	/** Grows the memory to at least `bytes`, doubling it. */
+	/**
+	* Grows the memory to at least `bytes`, doubling it: false when that is
+	* more than {@link MaxMemory}, or more than the engine will give.
+	*/
 	const reserve = (bytes) => {
 		const have = size;
-		if (have >= bytes) return;
-		memory.grow(Math.ceil((Math.max(bytes, have * 2) - have) / PageSize));
+		if (have >= bytes) return true;
+		if (bytes > MaxMemory) return false;
+		const pages = Math.ceil((Math.min(Math.max(bytes, have * 2), MaxMemory) - have) / PageSize);
+		const grown = Result.try(() => memory.grow(pages));
+		if (Result.isFailure(grown)) return false;
 		size = memory.buffer.byteLength;
 		views();
+		return true;
 	};
 	const steps = c.islands.map(({ parser }) => backend$1.build(parser, kind, false).step ?? parser.step);
 	const used = c.islands.map(({ used }) => used);
@@ -2624,8 +2660,7 @@ const run = (root, c, bytes, kind, build, source) => {
 	const checks = c.checks;
 	let state = idle;
 	const values = [];
-	const imports = { env: {
-		mem: memory,
+	const env = {
 		island: (id, pos) => {
 			const s = state;
 			s.pos = pos;
@@ -2635,14 +2670,14 @@ const run = (root, c, bytes, kind, build, source) => {
 			return s.pos;
 		},
 		grow: () => {
-			reserve(size * 2);
+			if (size >= MaxMemory || !reserve(Math.min(size * 2, MaxMemory))) throw new MemoryExhausted();
 			build.bind(i32, f64, state.input, state.end, values, state);
 			return size - Slack;
 		},
 		test: (id, cp) => tests[id](cp),
 		check: (id, from) => {
 			const s = state;
-			const a = checks[id](build.value(id, from >> 2));
+			const a = checks[id](build.value(id, from >>> 2));
 			if (a === Fail) {
 				s.mode = "Backtrack";
 				return 0;
@@ -2654,17 +2689,29 @@ const run = (root, c, bytes, kind, build, source) => {
 			const input = state.input;
 			return toFloat(Predicate.isString(input) ? input.slice(start, end) : latin1.text(input, start, end).replace(/\0/g, ""));
 		}
-	} };
-	const exported = new WebAssembly.Instance(new WebAssembly.Module(bytes), imports).exports;
-	const rootFn = exported.root;
-	if (!Predicate.isFunction(rootFn)) return Result.fail("no root function");
-	const widenFn = kind === 0 ? exported.widen : rootFn;
-	if (!Predicate.isFunction(widenFn)) return Result.fail("no widen function");
-	const startFn = exported.start;
-	if (!Predicate.isFunction(startFn)) return Result.fail("no start function");
-	const globals = Result.all(["mode"].map((name) => exportedGlobal(exported, name)));
-	if (Result.isFailure(globals)) return Result.fail(globals.failure);
-	const [mode] = globals.success;
+	};
+	const module = new WebAssembly.Module(bytes);
+	/** The entry points of an instance of the module over `mem`. */
+	const instantiate = (mem) => {
+		const exported = new WebAssembly.Instance(module, { env: {
+			...env,
+			mem
+		} }).exports;
+		const rootFn = exported.root;
+		if (!Predicate.isFunction(rootFn)) return Result.fail("no root function");
+		const widenFn = kind === 0 ? exported.widen : rootFn;
+		if (!Predicate.isFunction(widenFn)) return Result.fail("no widen function");
+		const startFn = exported.start;
+		if (!Predicate.isFunction(startFn)) return Result.fail("no start function");
+		return Result.map(exportedGlobal(exported, "mode"), (mode) => ({
+			widen: widenFn,
+			start: startFn,
+			mode
+		}));
+	};
+	const first = instantiate(memory);
+	if (Result.isFailure(first)) return Result.fail(first.failure);
+	let entries = first.success;
 	let busy = false;
 	/** The JIT's step for the parser, built on first use. */
 	let fallback = (s) => {
@@ -2680,7 +2727,7 @@ const run = (root, c, bytes, kind, build, source) => {
 	*/
 	const copyString = (input, staging) => {
 		const { written } = utf8Encoder.encodeInto(input, u8.subarray(staging, staging + 3 * input.length));
-		const replaced = widenFn(staging, written);
+		const replaced = entries.widen(staging, written);
 		if (replaced === 0) return;
 		const view = new DataView(memory.buffer);
 		const list = staging + written + 3 >> 2;
@@ -2696,7 +2743,7 @@ const run = (root, c, bytes, kind, build, source) => {
 		const n = input.length;
 		const inputBytes = kind === 0 ? 2 * n : n;
 		const traceStart = Input$1 + inputBytes + 15 & -16;
-		reserve(traceStart + Math.max(Slack * 4, inputBytes * 4, kind === 0 ? 7 * n + 16 : 0));
+		if (!reserve(traceStart + Math.max(Slack * 4, inputBytes * 4, kind === 0 ? 7 * n + 16 : 0))) throw new MemoryExhausted();
 		if (Predicate.isString(input)) {
 			if (input !== copied) {
 				copied = "";
@@ -2707,13 +2754,29 @@ const run = (root, c, bytes, kind, build, source) => {
 		values.length = 0;
 		state = s;
 		build.bind(i32, f64, input, s.end, values, s);
-		const r = startFn(s.pos, s.end, n, traceStart, size - Slack);
+		const r = entries.start(s.pos, s.end, n, traceStart, size - Slack);
 		if (r < 0) {
-			s.mode = mode.value === Cut ? "Cut" : "Backtrack";
+			s.mode = entries.mode.value === Cut ? "Cut" : "Backtrack";
 			return Fail;
 		}
 		s.pos = r;
-		return build.root(traceStart >> 2);
+		return build.root(traceStart >>> 2);
+	};
+	/**
+	* Gives the module a new memory of the initial size, dropping the one a
+	* large parse grew (and the string it held). An instance is bound to its
+	* memory, so the module is instantiated again; its data segments fill
+	* the tables in.
+	*/
+	const release = () => {
+		const fresh = new WebAssembly.Memory({ initial: 2 });
+		const next = instantiate(fresh);
+		if (Result.isFailure(next)) return;
+		memory = fresh;
+		size = fresh.buffer.byteLength;
+		views();
+		copied = "";
+		entries = next.success;
 	};
 	/** The bytes copied by the latest parse: parsing them again from further on is a driver at work. */
 	let lastBytes = /* @__PURE__ */ new Uint8Array(0);
@@ -2730,13 +2793,21 @@ const run = (root, c, bytes, kind, build, source) => {
 		}
 		busy = true;
 		pending = s;
+		const from = s.pos;
 		const result = Result.try(parsePending);
 		build.unbind();
 		state = idle;
 		pending = idle;
 		busy = false;
 		values.length = 0;
-		if (Result.isFailure(result)) throw result.failure;
+		if (size > ReleaseAbove) release();
+		if (Result.isFailure(result)) {
+			if (result.failure instanceof MemoryExhausted) {
+				s.pos = from;
+				return fallback(s);
+			}
+			throw result.failure;
+		}
 		return result.success;
 	};
 	return Result.succeed({