@woosh/meep-engine 3.16.0 → 3.17.1

package/src/shade/renderer/particles/optimizer/pass_propagate_copies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pass_propagate_copies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_propagate_copies.js"],"names":[],"mappings":"AA2EsC,wJAStB;AA1EhB,qBAAqB;AACrB,6CADW,MAAM,CACgD"}
+{"version":3,"file":"pass_propagate_copies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_propagate_copies.js"],"names":[],"mappings":"AAwHe,wJAOX;AArHJ,qBAAqB;AACrB,6CADW,MAAM,CACgD"}

package/src/shade/renderer/particles/optimizer/pass_propagate_copies.js

@@ -1,268 +1,361 @@
-import { VM_OP, vm_decode_op, vm_encode_word0 } from "../isa/ParticleVMISA.js";
-import {
-    ParticleValueNumbering,
-    decode_particle_instructions,
-    particle_instruction_is_well_formed,
-    particle_run_is_dead_after,
-    particle_run_is_touched_between,
-    particle_runs_overlap,
-} from "./particle_program_analysis.js";
-
-/** @type {string} */
-export const PARTICLE_PASS_PROPAGATE_COPIES = "propagate_copies";
-
-/**
- * Get rid of copies — by reading past them where the original is still intact, and by having the
- * instruction that produced the value write where the copy was going.
- *
- * Copies are most of what a broadcast is. The node compiler widens a scalar with a `SWIZZLE` because
- * some consumer asked for four lanes; when the lanes that survive are the ones the scalar was
- * already in, the broadcast is a register renaming and nothing else.
- *
- * ## Reading past a copy
- *
- * Every write gives its lanes a fresh value number and records the slot the value was ORIGINALLY
- * computed in; a copy inherits both. A read of a run can then be redirected to that original, as
- * long as the original still holds it — which is exactly "the value numbers still match", so a slot
- * overwritten since fails the test rather than needing a separate invalidation.
- *
- * A run is redirected only when its lanes trace back to CONSECUTIVE original slots. Two lanes of a
- * broadcast trace back to the same one, which is not a run and stays where it is.
- *
- * ## Writing where the copy was going
- *
- * `MOV d, s` where `s` was produced by one instruction, read by nothing but this copy, and dead
- * afterwards is that instruction writing to the wrong register. Retargeting it and dropping the copy
- * is what turns the graph compiler's broadcast-and-select into the two-lane value hand-written
- * assembly would have built directly.
- *
- * The conditions are the obvious ones and all of them are checked: nothing between the producer and
- * the copy may read the source or touch the destination, nothing after may read the source, and the
- * retargeted instruction still has to satisfy the operand-overlap rule. Retargeting a `RANDOM` is
- * allowed — where its result lands is not part of the draw sequence.
- *
- * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
- */
-export function pass_propagate_copies(instructions, context) {
-    const rounds = context.max_iterations ?? 3;
-
-    let current = instructions;
-    let changed = false;
-
-    for (let round = 0; round < rounds; round++) {
-        const redirected = redirect_reads(current, context);
-        const forwarded = forward_destinations(redirected ?? current);
-
-        if (redirected === null && forwarded === null) {
-            break;
-        }
-
-        current = forwarded ?? redirected;
-        changed = true;
-    }
-
-    return changed ? current : null;
-}
-
-/**
- * Rewrite reads to name the slot the value was first computed in, and reduce the copies that are
- * spelled as something else — an identity `SWIZZLE` is a `MOV`, and a `MOV` onto its own source is
- * nothing at all.
- *
- * @param {number[][]} instructions
- * @param {object} context
- * @returns {number[][]|null}
- */
-function redirect_reads(instructions, context) {
-    const decoded = decode_particle_instructions(instructions);
-    const values = new ParticleValueNumbering(context.register_slots);
-
-    /** @type {number[][]} */
-    const out = [];
-
-    let changed = false;
-
-    for (const instruction of decoded) {
-        let words = instruction.words;
-
-        for (const read of instruction.reads) {
-            const candidate = redirect(words, read, values);
-
-            if (candidate !== null) {
-                words = candidate;
-                changed = true;
-            }
-        }
-
-        const reduced = reduce_copy(words, instruction);
-
-        if (reduced !== null) {
-            words = reduced;
-            changed = true;
-        }
-
-        // A copy of a register onto itself is nothing at all — and it is not something the dead-code
-        // pass can see, because the lanes it writes are live; they were simply already correct.
-        if (vm_decode_op(words[0]) === VM_OP.MOV && words[1] === words[2]) {
-            changed = true;
-        } else {
-            out.push(words);
-        }
-
-        values.publish(words);
-    }
-
-    return changed ? out : null;
-}
-
-/**
- * @returns {number[]|null} the instruction with this read redirected, or `null` to leave it
- */
-function redirect(words, read, values) {
-    const base = values.origin_of(read.base, read.span);
-
-    if (base < 0 || base === read.base) {
-        return null;
-    }
-
-    const candidate = words.slice();
-
-    candidate[read.operand < 0 ? 1 : 2 + read.operand] = base;
-
-    // Moving one operand changes how it sits against the others, and two runs of an instruction may
-    // name the same slots or none of the same ones.
-    return particle_instruction_is_well_formed(candidate) ? candidate : null;
-}
-
-/**
- * An identity `SWIZZLE` is a `MOV`, and a `MOV` whose destination is its source is nothing.
- *
- * @returns {number[]|null} the reduced instruction, `null` if there is nothing to reduce
- */
-function reduce_copy(words, instruction) {
-    const op = instruction.op;
-
-    if (op === VM_OP.SWIZZLE) {
-        for (let lane = 0; lane < instruction.operation_width; lane++) {
-            if (((words[3] >> (2 * lane)) & 3) !== lane) {
-                return null;
-            }
-        }
-
-        const candidate = [vm_encode_word0(VM_OP.MOV, instruction.width), words[1], words[2], 0, 0];
-
-        return particle_instruction_is_well_formed(candidate) ? candidate : null;
-    }
-
-    return null;
-}
-
-/**
- * Have the producer write where its copy was going.
- *
- * Applied one at a time and re-derived, because a forward changes what the next one is looking at:
- * a chain of copies collapses from the far end, and the analysis it needs is cheap enough that
- * keeping it incrementally honest would cost more than redoing it.
- *
- * @param {number[][]} instructions
- * @returns {number[][]|null}
- */
-function forward_destinations(instructions) {
-    let current = instructions;
-    let changed = false;
-
-    for (let attempt = 0; attempt < instructions.length; attempt++) {
-        const next = forward_one_destination(current);
-
-        if (next === null) {
-            break;
-        }
-
-        current = next;
-        changed = true;
-    }
-
-    return changed ? current : null;
-}
-
-/**
- * @param {number[][]} instructions
- * @returns {number[][]|null}
- */
-function forward_one_destination(instructions) {
-    const decoded = decode_particle_instructions(instructions);
-
-    for (let copy = 0; copy < decoded.length; copy++) {
-        const move = decoded[copy];
-
-        if (move.op !== VM_OP.MOV) {
-            continue;
-        }
-
-        const destination = move.write.base;
-        const source = move.reads[0].base;
-        const span = move.write.span;
-
-        if (destination === source) {
-            continue;
-        }
-
-        const producer = sole_producer(decoded, copy, source, span);
-
-        if (producer < 0
-            || particle_run_is_touched_between(decoded, producer + 1, copy, destination, span)
-            || !particle_run_is_dead_after(decoded, copy, source, span)) {
-            continue;
-        }
-
-        const words = decoded[producer].words.slice();
-
-        words[1] = destination;
-
-        if (!particle_instruction_is_well_formed(words)) {
-            continue;
-        }
-
-        const out = instructions.slice();
-
-        out[producer] = words;
-        out.splice(copy, 1);
-
-        return out;
-    }
-
-    return null;
-}
-
-/**
- * The one instruction that put the value in `[base, base + span)`, if it is the only writer, wrote
- * exactly that run, and nothing between it and `copy` read it.
- *
- * @returns {number} instruction index, or `-1`
- */
-function sole_producer(decoded, copy, base, span) {
-    for (let i = copy - 1; i >= 0; i--) {
-        const instruction = decoded[i];
-
-        // A HALT in between means the copy never runs; that is the dead-code pass's to sort out.
-        if (instruction.op === VM_OP.HALT) {
-            return -1;
-        }
-
-        // The write is checked first so a producer that reads the run it writes — `SIN r0, r0`, the
-        // in-place form the register allocator reaches for constantly — is recognised as the
-        // producer rather than rejected as an intervening reader of its own result.
-        if (instruction.write !== null
-            && particle_runs_overlap(instruction.write.base, instruction.write.span, base, span)) {
-            return instruction.write.base === base && instruction.write.span === span ? i : -1;
-        }
-
-        for (const read of instruction.reads) {
-            if (particle_runs_overlap(read.base, read.span, base, span)) {
-                return -1;
-            }
-        }
-    }
-
-    return -1;
-}
+import { VM_KIND, VM_OP, vm_operand_with_base, vm_register, vm_repack_instruction, vm_with_dst } from "../isa/ParticleVMISA.js";
+import {
+    ParticleValueNumbering,
+    decode_particle_instructions,
+    particle_instruction_is_well_formed,
+    particle_read_slots,
+    particle_run_is_dead_after,
+    particle_runs_overlap,
+} from "./particle_program_analysis.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_PROPAGATE_COPIES = "propagate_copies";
+
+/**
+ * Get rid of copies — by reading past them where the original is still intact, and by having the
+ * instruction that produced the value write where the copy was going.
+ *
+ * Copies are most of what a broadcast is. The node compiler widens a scalar with a `MOV` through
+ * `.xxxx` because some consumer asked for four lanes; when the consumer can read the scalar through
+ * that same swizzle, the copy is a register renaming and nothing else.
+ *
+ * ## Reading past a copy
+ *
+ * Every write gives its lanes a fresh value number and records the slot the value was ORIGINALLY
+ * computed in; a copy inherits both, through whatever swizzle it read its source with. A read can
+ * then be redirected to where its lanes' values live, as long as the originals still hold them —
+ * which is exactly "the value numbers still match", so a slot overwritten since fails the test rather
+ * than needing a separate invalidation. The redirected operand names the homes through a swizzle of
+ * its own, so a permutation, a broadcast and a plain copy are all read through alike: `MUL r0, r1,
+ * r2` where r2 is `r5.xxxx` becomes `MUL r0, r1, r5.xxxx`, and the broadcast is then dead.
+ *
+ * ## Writing where the copy was going
+ *
+ * `MOV d, s` where `s` was produced by one instruction, read by nothing but this copy, and dead
+ * afterwards is that instruction writing to the wrong register. Retargeting it and dropping the copy
+ * is what turns the graph compiler's broadcast-and-select into the two-lane value hand-written
+ * assembly would have built directly.
+ *
+ * The conditions are the obvious ones and all of them are checked: nothing between the producer and
+ * the copy may read the source or touch the destination, and nothing after may read the source.
+ * Retargeting a `RANDOM` is allowed — where its result lands is not part of the draw sequence.
+ *
+ * ## Copies spelled as something else
+ *
+ * A lane picked out of a vector — `MOV.1 r4, r0.y` — is the run at `r1`, and the assembler spells
+ * every operand canonically, so the pass never sees the difference. What is left to reduce here is
+ * a `MOV` of a register onto itself, which is nothing at all.
+ *
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_propagate_copies(instructions, context) {
+    const rounds = context.max_iterations ?? 3;
+
+    let current = instructions;
+    let changed = false;
+
+    for (let round = 0; round < rounds; round++) {
+        const redirected = redirect_reads(current, context);
+        const forwarded = forward_destinations(redirected ?? current);
+
+        if (redirected === null && forwarded === null) {
+            break;
+        }
+
+        current = forwarded ?? redirected;
+        changed = true;
+    }
+
+    return changed ? current : null;
+}
+
+/**
+ * Rewrite reads to name the slots their values were first computed in, and drop a `MOV` of a
+ * register onto itself.
+ *
+ * @param {number[][]} instructions
+ * @param {object} context
+ * @returns {number[][]|null}
+ */
+function redirect_reads(instructions, context) {
+    const decoded = decode_particle_instructions(instructions);
+    const values = new ParticleValueNumbering(context.register_slots);
+
+    /** @type {number[][]} */
+    const out = [];
+
+    let changed = false;
+
+    for (const instruction of decoded) {
+        let words = instruction.words;
+
+        for (const read of instruction.reads) {
+            const candidate = redirect(words, read, values);
+
+            if (candidate !== null) {
+                words = candidate;
+                changed = true;
+            }
+        }
+
+        // A copy of a register onto itself is nothing at all — and it is not something the dead-code
+        // pass can see, because the lanes it writes are live; they were simply already correct.
+        if (is_copy_onto_itself(words, instruction)) {
+            changed = true;
+        } else {
+            out.push(words);
+        }
+
+        values.publish(words);
+    }
+
+    return changed ? out : null;
+}
+
+/**
+ * @param {number[]} words the instruction as it stands after redirection
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
+ * @returns {boolean} whether it is a `MOV` reading its own destination run as it lies
+ */
+function is_copy_onto_itself(words, instruction) {
+    return instruction.op === VM_OP.MOV
+        && instruction.sources[0].kind === VM_KIND.REG
+        && words[1] === vm_register(instruction.dst);
+}
+
+/**
+ * @returns {number[]|null} the instruction with this read redirected, or `null` to leave it
+ */
+function redirect(words, read, values) {
+    const origin = values.origin_of_read(read);
+
+    if (origin < 0) {
+        return null;
+    }
+
+    const candidate = words.slice();
+
+    candidate[1 + read.operand] = origin;
+
+    const repacked = vm_repack_instruction(candidate);
+
+    if (repacked[1 + read.operand] === words[1 + read.operand]) {
+        return null;
+    }
+
+    return particle_instruction_is_well_formed(repacked) ? repacked : null;
+}
+
+/**
+ * Have the producer write where its copy was going.
+ *
+ * Applied one at a time and re-derived, because a forward changes what the next one is looking at:
+ * a chain of copies collapses from the far end, and the analysis it needs is cheap enough that
+ * keeping it incrementally honest would cost more than redoing it.
+ *
+ * @param {number[][]} instructions
+ * @returns {number[][]|null}
+ */
+function forward_destinations(instructions) {
+    let current = instructions;
+    let changed = false;
+
+    for (let attempt = 0; attempt < instructions.length; attempt++) {
+        const next = forward_one_destination(current);
+
+        if (next === null) {
+            break;
+        }
+
+        current = next;
+        changed = true;
+    }
+
+    return changed ? current : null;
+}
+
+/**
+ * @param {number[][]} instructions
+ * @returns {number[][]|null}
+ */
+function forward_one_destination(instructions) {
+    const decoded = decode_particle_instructions(instructions);
+
+    for (let copy = 0; copy < decoded.length; copy++) {
+        const move = decoded[copy];
+
+        // Only a plain copy of a register run has producers to retarget: a swizzled one reorders
+        // lanes the producers computed in order, and a MOV from a literal is a load, which the
+        // inlining pass deals with.
+        if (move.op !== VM_OP.MOV || move.sources[0].kind !== VM_KIND.REG) {
+            continue;
+        }
+
+        const source = move.sources[0];
+
+        if (source.word !== vm_register(source.base)) {
+            continue;
+        }
+
+        const destination = move.write.base;
+        const span = move.write.span;
+
+        // Overlapping runs would have the producers shift into each other's lanes; a copy of that
+        // shape is what a swizzle is for, and not worth the bookkeeping.
+        if (particle_runs_overlap(destination, span, source.base, span)) {
+            continue;
+        }
+
+        const plan = plan_forwarding(decoded, copy, source.base, span, destination);
+
+        if (plan === null) {
+            continue;
+        }
+
+        const out = instructions.slice();
+
+        for (const [index, words] of plan) {
+            out[index] = words;
+        }
+
+        out.splice(copy, 1);
+
+        return out;
+    }
+
+    return null;
+}
+
+/**
+ * How to have the producers of `[base, base + span)` write into `[destination, ...)` instead, so the
+ * copy at `copy` can go.
+ *
+ * Each lane has a producer — the last write to it before the copy — and every producer has to write
+ * within the run, so that moving it by `destination - base` moves lanes and nothing else. From the
+ * earliest producer to the copy, nothing may touch the destination: not a write, since the value is
+ * now being built there, and not a read, since what it read was the destination's old contents. A
+ * read of the source in that gap is a read of the value on its way to the copy and follows it to the
+ * destination — unless it comes before the producer of a lane it reads, in which case it wanted what
+ * the slot held before and stays as it is. A read that is half one and half the other is left
+ * alone, and so is the whole copy. After the copy, the source has to be dead.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
+ * @param {number} copy index of the `MOV`
+ * @param {number} base first slot of the source run
+ * @param {number} span
+ * @param {number} destination first slot of the destination run
+ * @returns {Array<[number, number[]]>|null} rewritten instructions by index, or `null` to leave the copy
+ */
+function plan_forwarding(decoded, copy, base, span, destination) {
+    /** @type {Int32Array} per lane, the instruction that produced it; `-1` until found */
+    const producer = new Int32Array(span).fill(-1);
+
+    let unproduced = span;
+
+    for (let i = copy - 1; i >= 0 && unproduced > 0; i--) {
+        const instruction = decoded[i];
+
+        // A HALT in between means the copy never runs; that is the dead-code pass's to sort out.
+        if (instruction.op === VM_OP.HALT) {
+            return null;
+        }
+
+        const write = instruction.write;
+
+        if (write === null || !particle_runs_overlap(write.base, write.span, base, span)) {
+            continue;
+        }
+
+        if (write.base < base || write.base + write.span > base + span) {
+            return null;
+        }
+
+        for (let lane = write.base - base; lane < write.base - base + write.span; lane++) {
+            if (producer[lane] < 0) {
+                producer[lane] = i;
+                unproduced--;
+            }
+        }
+    }
+
+    if (unproduced > 0) {
+        return null;
+    }
+
+    const earliest = Math.min(...producer);
+
+    /** @type {Map<number, number[]>} instruction index -> its rewritten words */
+    const rewritten = new Map();
+
+    const words_of = (index) => {
+        if (!rewritten.has(index)) {
+            rewritten.set(index, decoded[index].words.slice());
+        }
+
+        return rewritten.get(index);
+    };
+
+    for (let i = earliest + 1; i < copy; i++) {
+        const instruction = decoded[i];
+
+        if (instruction.op === VM_OP.HALT) {
+            return null;
+        }
+
+        if (instruction.write !== null
+            && particle_runs_overlap(instruction.write.base, instruction.write.span, destination, span)) {
+            return null;
+        }
+
+        for (const read of instruction.reads) {
+            if (particle_runs_overlap(read.base, read.span, destination, span)) {
+                return null;
+            }
+
+            const slots = particle_read_slots(read);
+            const inside = slots.filter(slot => slot >= base && slot < base + span);
+
+            if (inside.length === 0) {
+                continue;
+            }
+
+            if (inside.length !== slots.length) {
+                return null;
+            }
+
+            const produced = slots.filter(slot => producer[slot - base] < i).length;
+
+            if (produced === 0) {
+                continue;
+            }
+
+            if (produced !== slots.length) {
+                return null;
+            }
+
+            words_of(i)[1 + read.operand] = vm_operand_with_base(read.word, read.base - base + destination);
+        }
+    }
+
+    if (!particle_run_is_dead_after(decoded, copy, base, span)) {
+        return null;
+    }
+
+    for (const index of new Set(producer)) {
+        const words = words_of(index);
+
+        words[0] = vm_with_dst(words[0], decoded[index].write.base - base + destination);
+    }
+
+    const plan = [];
+
+    for (const [index, words] of rewritten) {
+        if (!particle_instruction_is_well_formed(words)) {
+            return null;
+        }
+
+        plan.push([index, words]);
+    }
+
+    return plan;
+}

package/src/shade/renderer/particles/optimizer/pass_schedule.d.ts

@@ -0,0 +1,4 @@
+export function pass_schedule(instructions: number[][], context: import("./optimize_particle_program.js").ParticleOptimizerContext): number[][];
+/** @type {string} */
+export const PARTICLE_PASS_SCHEDULE: string;
+//# sourceMappingURL=pass_schedule.d.ts.map

package/src/shade/renderer/particles/optimizer/pass_schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass_schedule.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_schedule.js"],"names":[],"mappings":"AAmHsD,gJAWoB;AA5H1E,qBAAqB;AACrB,qCADW,MAAM,CACgC"}