@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -0,0 +1,236 @@
+import { PARTICLE_VM_REGISTER_SLOTS } from "../ParticleConstants.js";
+import { VM_KIND, VM_OP, vm_f32_value } from "../isa/ParticleVMISA.js";
+import { decode_particle_instruction, particle_read_slots } from "./particle_program_analysis.js";
+
+/**
+ * Which register slots hold an integer, and how big it can be — the one fact that makes a float
+ * rewrite exact.
+ *
+ * `a * b + c` as `MAD` is a different number from `MUL` then `ADD` because the pair rounds the
+ * product before adding it and the fused form does not. When the product is an integer below 2^24
+ * it needs no rounding, and the two forms are then the same number on every executor — whether the
+ * hardware contracts the `MAD` into an FMA or not. So the peephole can fuse those pairs without
+ * giving anything up, provided it can PROVE the product is that small, and this is the analysis
+ * that proves it.
+ *
+ * The facts come from the shapes effects are actually made of. A comparison or a `step` is 0 or 1;
+ * a mask built from one, `cmp * 2 - 1`, is -1 or 1; a literal is whatever it is. Those flow through
+ * copies, negation, `abs`, `floor`, `min`, `max`, `clamp` and `select` unchanged in kind, and
+ * through the arithmetic with their bounds combined. Everything else — a draw, an attribute, a
+ * builtin, `fract`, a division, a transcendental — is unknown. So is any value whose bound would
+ * pass 2^24: above it an integer may no longer be representable, and once a rounding could have
+ * happened nothing downstream is exact any more.
+ *
+ * ## Why the bound is a magnitude and not an interval
+ *
+ * Exactness of a product is a question about magnitudes, and `|a * b| <= |a| * |b|` is all it
+ * needs. An interval would prove more — that `x - floor(x / 289) * 289` is small, say, which is
+ * the other shape the noise library is made of — but only from a bound on `x`, which is a
+ * position, and there is none. That rewrite stays behind the `fuse_multiply_add` switch.
+ *
+ * The file starts zeroed on both executors, so every slot begins as the integer 0.
+ */
+export class ParticleIntegerBounds {
+    /**
+     * @param {ArrayLike<number>} constants the shared constant pool, which `LOAD_CONST` reads
+     * @param {number} [slots]
+     */
+    constructor(constants, slots = PARTICLE_VM_REGISTER_SLOTS) {
+        /** @type {ArrayLike<number>} */
+        this.constants = constants;
+        /** @type {Float64Array} per slot, the largest magnitude the integer it holds can have; `Infinity` when it is not known to hold one */
+        this.bound = new Float64Array(slots);
+    }
+
+    /**
+     * @param {import("./particle_program_analysis.js").ParticleOperandRun} read a `REG` run
+     * @param {number} [lanes] how many lanes are read; the operand's own count when left out
+     * @returns {number} the largest bound among the lanes read, or `Infinity`
+     */
+    bound_of_read(read, lanes = read.lanes) {
+        let bound = 0;
+
+        for (const slot of particle_read_slots(read, lanes)) {
+            if (slot < 0 || slot >= this.bound.length) {
+                return Infinity;
+            }
+
+            bound = Math.max(bound, this.bound[slot]);
+        }
+
+        return bound;
+    }
+
+    /**
+     * @param {import("./particle_program_analysis.js").ParticleOperandRun} source any operand
+     * @param {number} [lanes] how many lanes are read; the operand's own count when left out
+     * @returns {number} the bound on what it reads: a literal's own magnitude, or a run's
+     */
+    bound_of_source(source, lanes = source.lanes) {
+        return source.kind === VM_KIND.IMM
+            ? particle_integer_bound_of_value(vm_f32_value(source.word))
+            : this.bound_of_read(source, lanes);
+    }
+
+    /**
+     * Record what an instruction leaves in its destination.
+     *
+     * @param {ArrayLike<number>} words the four words of a single instruction, as they will run
+     */
+    publish(words) {
+        const instruction = decode_particle_instruction(words);
+
+        if (instruction.write === null) {
+            return;
+        }
+
+        const { base, span } = instruction.write;
+        const lanes = this.lanes_written(instruction, span);
+
+        for (let lane = 0; lane < span; lane++) {
+            if (base + lane < this.bound.length) {
+                this.bound[base + lane] = lanes[lane];
+            }
+        }
+    }
+
+    /**
+     * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
+     * @param {number} span lanes the instruction writes
+     * @returns {number[]} the bound each written lane will hold — gathered before anything is
+     *   written, since a source may alias the destination
+     */
+    lanes_written(instruction, span) {
+        const [a, b, c] = instruction.sources;
+        const per_lane = (combine) => {
+            const out = new Array(span);
+
+            for (let lane = 0; lane < span; lane++) {
+                out[lane] = capped(combine(lane));
+            }
+
+            return out;
+        };
+        const lane_of = (source, lane) => (source.kind === VM_KIND.IMM
+            ? particle_integer_bound_of_value(vm_f32_value(source.word))
+            : this.bound_of_slot(source, lane));
+
+        // `LOAD_CONST` is the one operation whose lanes come from somewhere other than its
+        // operands, so it is answered here; every other one is the scalar rule below.
+        if (instruction.op === VM_OP.LOAD_CONST) {
+            return per_lane(lane => particle_integer_bound_of_value(this.constants[instruction.words[1] + lane]));
+        }
+
+        return per_lane(lane => particle_integer_bound_of_operation(
+            instruction.op,
+            a === undefined ? Infinity : lane_of(a, lane),
+            b === undefined ? Infinity : lane_of(b, lane),
+            c === undefined ? Infinity : lane_of(c, lane),
+            instruction.operation_width,
+            // The reductions read every lane, so their bound is over the whole operand rather than
+            // over one lane of it.
+            () => [this.bound_of_source(a, instruction.operation_width), this.bound_of_source(b, instruction.operation_width)]
+        ));
+    }
+
+    /**
+     * @param {import("./particle_program_analysis.js").ParticleOperandRun} read a `REG` run
+     * @param {number} lane
+     * @returns {number} the bound of the slot that lane reads
+     */
+    bound_of_slot(read, lane) {
+        const slot = particle_read_slots(read, lane + 1)[lane];
+
+        return slot >= 0 && slot < this.bound.length ? this.bound[slot] : Infinity;
+    }
+}
+
+/**
+ * The bound on one lane of an operation's result, from the bounds on that lane of its sources.
+ *
+ * The rules are magnitudes and nothing else — `|a * b| <= |a| * |b|` — so they say the same thing
+ * about a lane of an instruction and about a node of a value graph, and both callers read them from
+ * here rather than each keeping a copy of the table.
+ *
+ * @param {number} op
+ * @param {number} a bound on source 0, `Infinity` when it is unknown or absent
+ * @param {number} b bound on source 1
+ * @param {number} c bound on source 2
+ * @param {number} [width] lanes the operation spans — read only by the reductions
+ * @param {function(): number[]} [whole_operands] bounds over EVERY lane of sources 0 and 1, which is
+ *   what a reduction sums over; never called for a lanewise operation
+ * @returns {number}
+ */
+export function particle_integer_bound_of_operation(op, a, b, c, width = 1, whole_operands = () => [a, b]) {
+    switch (op) {
+        case VM_OP.CMP_LT:
+        case VM_OP.CMP_LE:
+        case VM_OP.CMP_GT:
+        case VM_OP.CMP_GE:
+        case VM_OP.CMP_EQ:
+        case VM_OP.STEP:
+            return 1;
+
+        case VM_OP.MOV:
+        case VM_OP.NEG:
+        case VM_OP.ABS:
+        case VM_OP.FLOOR:
+            return capped(a);
+
+        case VM_OP.MIN:
+        case VM_OP.MAX:
+            return capped(Math.max(a, b));
+
+        case VM_OP.CLAMP:
+            return capped(Math.max(a, b, c));
+
+        // Whichever of the two the condition picks, and the condition itself is not a value.
+        case VM_OP.SELECT:
+            return capped(Math.max(a, b));
+
+        case VM_OP.ADD:
+        case VM_OP.SUB:
+            return capped(a + b);
+
+        case VM_OP.MUL:
+            return capped(a * b);
+
+        case VM_OP.MAD:
+            return capped(a * b + c);
+
+        // Every product exact and every partial sum within the cap is what makes the sum an
+        // integer whatever order the hardware adds it in.
+        case VM_OP.DOT: {
+            const [whole_a, whole_b] = whole_operands();
+
+            return capped(width * whole_a * whole_b);
+        }
+
+        default:
+            return Infinity;
+    }
+}
+
+/**
+ * Integers up to here are exactly representable as `f32`, and so are all their sums and products
+ * that stay under it. Above it, integers thin out and a rounding could have happened.
+ *
+ * @type {number}
+ */
+export const PARTICLE_EXACT_INTEGER_LIMIT = 2 ** 24;
+
+/**
+ * @param {number} value
+ * @returns {number} the value's magnitude when it is an integer, `Infinity` otherwise
+ */
+export function particle_integer_bound_of_value(value) {
+    return Number.isInteger(value) ? capped(Math.abs(value)) : Infinity;
+}
+
+/**
+ * @param {number} bound
+ * @returns {number} the bound, or `Infinity` once it is past what is exact
+ */
+function capped(bound) {
+    return bound <= PARTICLE_EXACT_INTEGER_LIMIT ? bound : Infinity;
+}

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

@@ -0,0 +1,371 @@
+/**
+ * The analysis every optimizer pass reads: instructions decoded into the operands they resolve and
+ * the run they write, the def-use graph over those, and per-lane liveness.
+ *
+ * Everything here is derived, never authoritative — the instruction words are. A pass rewrites
+ * words and the next one re-derives, which is why there is no incremental update path and no
+ * mutation of an analysis in place: the programs are at most
+ * {@link ../ParticleConstants.js PARTICLE_VM_MAX_INSTRUCTIONS} instructions over
+ * {@link PARTICLE_VM_REGISTER_SLOTS} slots, and re-deriving all of it is cheaper than keeping it
+ * honest.
+ *
+ * ## Lanes, not registers
+ *
+ * A register is one `f32` slot and a value of width `w` is a run of `w` of them, so nothing here is
+ * per-register: a value's producer is per (instruction, lane), and so is its liveness. Which slots a
+ * source reads is the operand's own business — its base and its swizzle, read at as many lanes as the
+ * opcode takes of it — and {@link particle_read_slots} is the one place that turns an operand into
+ * slots. The ISA's {@link vm_visit_operands} is the one place that says how many lanes that is.
+ *
+ * ## Kinds
+ *
+ * A source is a register run or a literal, by the kind bits its instruction carries. Only the first
+ * is a run of the file, so `reads` holds only those — every question about liveness, aliasing and
+ * dependency is a question about the file, and a literal whose bits happen to look like a slot index
+ * must never answer it. The passes that care what a source *is* rather than where it lives — folding,
+ * sharing, the copy rewrites — read `sources`, which lists every operand with its kind.
+ */
+/**
+ * @typedef {object} ParticleOperandRun
+ * @property {number} operand which source slot this is, `0..2`; `-1` for the destination
+ * @property {number} kind a `VM_KIND`; `REG` for every entry of `reads` and for the write
+ * @property {number} word the operand word as encoded
+ * @property {number} base first register slot, or `-1` for a literal
+ * @property {number} pattern the swizzle the operand reads through, as `pack_swizzle` packs one; the
+ *   identity for a write
+ * @property {number} lanes how many lanes the instruction reads of it — the operation's width, or one
+ *   for a slot the ISA marks scalar; for the write, how many it writes
+ * @property {number} span consecutive slots the operand reaches from its base
+ */
+/**
+ * @typedef {object} ParticleDecodedInstruction
+ * @property {number} index position in the stream
+ * @property {number[]} words the four instruction words
+ * @property {number} op
+ * @property {number} width the encoded width field
+ * @property {number} dst the encoded destination register
+ * @property {number} kinds the three source kinds as one field, as word 0 carries them
+ * @property {number} operation_width lanes the operation spans, after the ISA's fixed-width rules
+ * @property {object} meta the {@link VM_ISA} entry
+ * @property {import("./particle_vm_semantics.js").ParticleOpSemantics} semantics
+ * @property {ParticleOperandRun|null} write destination run, or null when the opcode writes nothing
+ * @property {ParticleOperandRun[]} reads every register operand the instruction reads — the `REG` sources
+ * @property {ParticleOperandRun[]} sources every source operand, whatever its kind, in slot order
+ */
+/**
+ * Decode one instruction into the operands it resolves and the run it writes.
+ *
+ * @param {ArrayLike<number>} words the four words of a single instruction
+ * @param {number} [index]
+ * @returns {ParticleDecodedInstruction}
+ */
+export function decode_particle_instruction(words: ArrayLike<number>, index?: number): ParticleDecodedInstruction;
+/**
+ * @param {ArrayLike<ArrayLike<number>>} instructions four-word tuples
+ * @returns {ParticleDecodedInstruction[]}
+ */
+export function decode_particle_instructions(instructions: ArrayLike<ArrayLike<number>>): ParticleDecodedInstruction[];
+/**
+ * The slots a register operand reads, one per lane read — in lane order, and a slot appears once per
+ * lane that reads it, so a broadcast lists the same slot several times.
+ *
+ * @param {ParticleOperandRun} read a `REG` run
+ * @param {number} [lanes] how many lanes to read; the operand's own count when left out
+ * @returns {number[]}
+ */
+export function particle_read_slots(read: ParticleOperandRun, lanes?: number): number[];
+/**
+ * Whether an instruction fits the register file: its kinds agree with its opcode, and every run it
+ * touches ends inside the file.
+ *
+ * There is no aliasing rule to check. Every executor resolves every source before it writes the
+ * destination, so a source may overlap the destination in any way and mean what it held before the
+ * instruction — which is also what lets a pass move a base or fold a swizzle without asking how the
+ * result sits against the other operands.
+ *
+ * @param {ArrayLike<number>} words the four words of a single instruction
+ * @returns {boolean}
+ */
+export function particle_instruction_is_well_formed(words: ArrayLike<number>): boolean;
+/**
+ * Def-use over the instruction stream: an edge `i -> j` says instruction `j` reads a slot
+ * instruction `i` last wrote.
+ *
+ * Straight-line code with no control flow, so "last wrote" is exact rather than a may-reach
+ * approximation: one forward scan of a slot-indexed table finds every producer. The result is a
+ * {@link CSRGraph} because that is what the rest of the engine walks — `edge_addresses` /
+ * `adjacency` directly, without a per-vertex closure — and because dead-code elimination is then a
+ * reachability question over it rather than a bespoke container.
+ *
+ * A read of a slot nothing has written yet has no producer and contributes no edge: the register
+ * file starts zeroed on both executors, so such a read is a constant, not a dependency.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} [register_slots]
+ * @returns {CSRGraph} vertices are instructions; vertex `i`'s adjacency lists its consumers
+ */
+export function build_particle_def_use_graph(decoded: ParticleDecodedInstruction[], register_slots?: number): CSRGraph;
+/**
+ * @typedef {object} ParticleLaneAnalysis
+ * @property {Uint8Array} keep per instruction: whether it has to survive — it runs, and either it
+ *   has an effect beyond its destination or something reads a lane it writes
+ * @property {Int32Array} width per instruction: the width field it could carry, once the lanes
+ *   nothing reads are dropped. Equal to the encoded one wherever narrowing is not allowed.
+ * @property {Uint8Array} live_lanes per instruction: bitmask of destination lanes read later
+ * @property {number} halt_index index of the first `HALT`, or `-1`
+ */
+/**
+ * Backward per-lane liveness: which lanes of each instruction's destination anything downstream
+ * actually reads, and therefore how narrow the instruction could be and whether it is needed at all.
+ *
+ * Registers do not outlive a section — both executors start a particle with a zeroed file — so the
+ * walk starts with nothing live and everything a program means has already been written to the
+ * record, the kill flag or the RNG by the time it ends.
+ *
+ * Narrowing is decided inside the same backward pass rather than after it, because an instruction's
+ * reads follow its width: a narrowed copy reads fewer lanes of its source, which is what makes the
+ * value above it dead. Deciding both at once reaches that fixed point in one sweep.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} [register_slots]
+ * @returns {ParticleLaneAnalysis}
+ */
+export function analyze_particle_lanes(decoded: ParticleDecodedInstruction[], register_slots?: number): ParticleLaneAnalysis;
+/**
+ * The most slots alive at once anywhere in the section — what a perfect allocator would need, and
+ * the one measure of an instruction order the scheduling pass is for.
+ *
+ * A slot is alive between a write and a later read of it; a read at the instruction that overwrites
+ * the slot counts for the value above, since every executor reads its sources before it writes.
+ * `HALT` is not special here: what follows one is dead code, and counting it can only overstate.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} [register_slots]
+ * @returns {number}
+ */
+export function particle_peak_live_slots(decoded: ParticleDecodedInstruction[], register_slots?: number): number;
+/**
+ * @param {number} base_a
+ * @param {number} span_a
+ * @param {number} base_b
+ * @param {number} span_b
+ * @returns {boolean} whether the two runs share a slot
+ */
+export function particle_runs_overlap(base_a: number, span_a: number, base_b: number, span_b: number): boolean;
+/**
+ * Whether anything in `[from, to)` reads or writes any slot of a run.
+ *
+ * What a pass moving an instruction has to ask: a value that nothing in the gap looks at or
+ * disturbs can be produced anywhere in that gap. A read is taken at its whole span, which is at
+ * least what it touches.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} from inclusive
+ * @param {number} to exclusive
+ * @param {number} base
+ * @param {number} span
+ * @returns {boolean}
+ */
+export function particle_run_is_touched_between(decoded: ParticleDecodedInstruction[], from: number, to: number, base: number, span: number): boolean;
+/**
+ * Whether anything in `[from, to)` writes any slot of a run — the weaker question, for a pass that
+ * needs a value to still be where it was but does not mind who has looked at it in between.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} from inclusive
+ * @param {number} to exclusive
+ * @param {number} base
+ * @param {number} span
+ * @returns {boolean}
+ */
+export function particle_run_is_written_between(decoded: ParticleDecodedInstruction[], from: number, to: number, base: number, span: number): boolean;
+/**
+ * Whether every slot of a run is overwritten — or the section ends — before anything reads it again.
+ *
+ * A run that is dead from `index` onwards belongs to nobody, so the instruction that filled it may
+ * be retargeted, folded into its consumer, or dropped.
+ *
+ * @param {ParticleDecodedInstruction[]} decoded
+ * @param {number} index the instruction after which to look
+ * @param {number} base
+ * @param {number} span
+ * @returns {boolean}
+ */
+export function particle_run_is_dead_after(decoded: ParticleDecodedInstruction[], index: number, base: number, span: number): boolean;
+/**
+ * Which value each register slot holds, as a number, and where that value was first computed.
+ *
+ * Two passes ask questions that turn out to be the same question underneath. "Is this register still
+ * the copy it was?" and "has this expression already been evaluated?" both reduce to comparing value
+ * numbers, and both need a copy to carry its source's number across rather than minting a new one —
+ * otherwise a value moved between registers stops being recognisable as itself.
+ *
+ * Numbers are minted per write and inherited by `MOV`, the one opcode that moves a value without
+ * changing it — through whatever swizzle its source carries, so a broadcast's lanes all hold one
+ * number and a permutation's hold the source's in the permuted order. Because a number is never
+ * reused, a slot overwritten since simply fails to match, and there is no invalidation step to get
+ * wrong.
+ */
+export class ParticleValueNumbering {
+    /**
+     * @param {number} [slots]
+     */
+    constructor(slots?: number);
+    /** @type {number} */
+    slots: number;
+    /** @type {Int32Array} the value in each slot */
+    value_id: Int32Array;
+    /** @type {Int32Array} the slot each value was first computed in */
+    home: Int32Array;
+    /** @type {Int32Array} which publish computed the value in each slot; `-1` for the reset's zero */
+    producer: Int32Array;
+    /** @type {number} */
+    next_id: number;
+    /** @type {number} publishes so far, which is what names a producer */
+    published: number;
+    /**
+     * @param {number} base
+     * @param {number} span
+     * @returns {number[]|null} the numbers in that run, or `null` if it leaves the file
+     */
+    ids_of(base: number, span: number): number[] | null;
+    /**
+     * The numbers a register operand reads, one per lane, through its swizzle.
+     *
+     * @param {ParticleOperandRun} read a `REG` run
+     * @returns {number[]|null} `null` if a lane reaches outside the file
+     */
+    ids_read(read: ParticleOperandRun): number[] | null;
+    /**
+     * @param {number} base
+     * @param {number[]} ids
+     * @returns {boolean} whether that run still holds exactly those values
+     */
+    holds(base: number, ids: number[]): boolean;
+    /**
+     * The register operand that reads the same values from where they were first computed.
+     *
+     * Lane by lane, the value a read sees has a home slot; if every home still holds its value and
+     * the homes fit in the four slots a swizzle can reach from one base, the read can be redirected
+     * there. That is how a copy is read through, a broadcast folds into the consumer's swizzle, and a
+     * value moved between registers stays recognisable as itself.
+     *
+     * Every lane has to come from ONE instruction. Two producers' results side by side could be named
+     * by one swizzled operand too, but folding them there would leave both producers where they are;
+     * forwarding one of them into the copy's slot deletes the copy outright, and that is the rewrite
+     * the copy-propagation pass wants to have the chance to make.
+     *
+     * @param {ParticleOperandRun} read a `REG` run
+     * @returns {number} a register operand word, or `-1` when the values are not all at home, come from
+     *   more than one producer, or their homes do not fit one operand
+     */
+    origin_of_read(read: ParticleOperandRun): number;
+    /**
+     * Record what an instruction leaves in its destination.
+     *
+     * Takes the words as they will be EMITTED rather than as they were read, because a pass may have
+     * moved a source or rewritten the opcode by the time it gets here — the state has to describe
+     * the program that will run.
+     *
+     * @param {ArrayLike<number>} words the four words of a single instruction
+     */
+    publish(words: ArrayLike<number>): void;
+}
+export type ParticleOperandRun = {
+    /**
+     * which source slot this is, `0..2`; `-1` for the destination
+     */
+    operand: number;
+    /**
+     * a `VM_KIND`; `REG` for every entry of `reads` and for the write
+     */
+    kind: number;
+    /**
+     * the operand word as encoded
+     */
+    word: number;
+    /**
+     * first register slot, or `-1` for a literal
+     */
+    base: number;
+    /**
+     * the swizzle the operand reads through, as `pack_swizzle` packs one; the
+     * identity for a write
+     */
+    pattern: number;
+    /**
+     * how many lanes the instruction reads of it — the operation's width, or one
+     * for a slot the ISA marks scalar; for the write, how many it writes
+     */
+    lanes: number;
+    /**
+     * consecutive slots the operand reaches from its base
+     */
+    span: number;
+};
+export type ParticleDecodedInstruction = {
+    /**
+     * position in the stream
+     */
+    index: number;
+    /**
+     * the four instruction words
+     */
+    words: number[];
+    op: number;
+    /**
+     * the encoded width field
+     */
+    width: number;
+    /**
+     * the encoded destination register
+     */
+    dst: number;
+    /**
+     * the three source kinds as one field, as word 0 carries them
+     */
+    kinds: number;
+    /**
+     * lanes the operation spans, after the ISA's fixed-width rules
+     */
+    operation_width: number;
+    /**
+     * the {@link VM_ISA } entry
+     */
+    meta: object;
+    semantics: import("./particle_vm_semantics.js").ParticleOpSemantics;
+    /**
+     * destination run, or null when the opcode writes nothing
+     */
+    write: ParticleOperandRun | null;
+    /**
+     * every register operand the instruction reads — the `REG` sources
+     */
+    reads: ParticleOperandRun[];
+    /**
+     * every source operand, whatever its kind, in slot order
+     */
+    sources: ParticleOperandRun[];
+};
+export type ParticleLaneAnalysis = {
+    /**
+     * per instruction: whether it has to survive — it runs, and either it
+     * has an effect beyond its destination or something reads a lane it writes
+     */
+    keep: Uint8Array;
+    /**
+     * per instruction: the width field it could carry, once the lanes
+     * nothing reads are dropped. Equal to the encoded one wherever narrowing is not allowed.
+     */
+    width: Int32Array;
+    /**
+     * per instruction: bitmask of destination lanes read later
+     */
+    live_lanes: Uint8Array;
+    /**
+     * index of the first `HALT`, or `-1`
+     */
+    halt_index: number;
+};
+import { CSRGraph } from "../../../../core/graph/csr/CSRGraph.js";
+//# sourceMappingURL=particle_program_analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"particle_program_analysis.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_analysis.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,mDAJW,UAAU,MAAM,CAAC,UACjB,MAAM,GACJ,0BAA0B,CAiDtC;AAED;;;GAGG;AACH,2DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,GAC1B,0BAA0B,EAAE,CAUxC;AAED;;;;;;;GAOG;AACH,0CAJW,kBAAkB,UAClB,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;;GAWG;AACH,2DAHW,UAAU,MAAM,CAAC,GACf,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,QAAQ,CAyDpB;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,oBAAoB,CA6EhC;AAED;;;;;;;;;;;GAWG;AACH,kDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,MAAM,CAmClB;AAeD;;;;;;GAMG;AACH,8CANW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAanB;AAED;;;;;;;;;;;GAWG;AACH,oDANW,0BAA0B,EAAE,SAC5B,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;;;;;;;;GAaG;AACH;IACI;;OAEG;IACH,oBAFW,MAAM,EAsBhB;IAnBG,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,gDAAgD;IAChD,UADW,UAAU,CACgB;IACrC,mEAAmE;IACnE,MADW,UAAU,CACY;IACjC,kGAAkG;IAClG,UADW,UAAU,CACyB;IAC9C,qBAAqB;IACrB,SADW,MAAM,CACG;IACpB,sEAAsE;IACtE,WADW,MAAM,CACC;IAUtB;;;;OAIG;IACH,aAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAczB;IAED;;;;;OAKG;IACH,eAHW,kBAAkB,GAChB,MAAM,EAAE,GAAC,IAAI,CAUzB;IAED;;;;OAIG;IACH,YAJW,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAcnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBAJW,kBAAkB,GAChB,MAAM,CAiDlB;IAED;;;;;;;;OAQG;IACH,eAFW,UAAU,MAAM,CAAC,QAgD3B;CACJ;;;;;aArsBa,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;aACN,MAAM;;;;;WAEN,MAAM;;;;UAEN,MAAM;;;;;;WAKN,MAAM;;;;WACN,MAAM,EAAE;QACR,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;WACN,MAAM;;;;qBACN,MAAM;;;;UACN,MAAM;eACN,OAAO,4BAA4B,EAAE,mBAAmB;;;;WACxD,kBAAkB,GAAC,IAAI;;;;WACvB,kBAAkB,EAAE;;;;aACpB,kBAAkB,EAAE;;;;;;;UAoMpB,UAAU;;;;;WAEV,UAAU;;;;gBAEV,UAAU;;;;gBACV,MAAM;;yBAvRK,wCAAwC"}