@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js

@@ -0,0 +1,860 @@
+import { assert } from "../../../../../core/assert.js";
+import { VM_ISA, VM_MAX_WIDTH, VM_OP, swizzle_selector } from "../../isa/ParticleVMISA.js";
+import { vm_semantics_of } from "../particle_vm_semantics.js";
+import { PV_GROUP } from "./particle_vector_groups.js";
+import { PV } from "./particle_vector_graph.js";
+
+/**
+ * Turn the chosen values into the groups {@link ./particle_vector_lower.js} schedules, colours and
+ * emits.
+ *
+ * There is less here than the job sounds like, and that is the point. A packer over a graph of lanes
+ * needs superword grouping, lane-order search and a demand solver, all of it re-deriving a
+ * vectorisation that its own lift threw away — that was measured at eight hundred lines and it still
+ * lost. Here a value IS a vector, one value is one instruction, and every operand reads lanes of ONE
+ * value, so it is a base and a swizzle, always, with nothing to arrange and nothing to copy.
+ *
+ * The copies that remain are the ones the program really has: a `BUILD`, which is a vector assembled
+ * out of lanes of several others. Those come from a frontend's `vec4` constructor and from a load of
+ * record words that different stores wrote, and each is one `MOV` per lane until something coalesces
+ * them away.
+ */
+
+/**
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {import("./particle_vector_lift.js").ParticleLiftedVectorSection} section
+ * @param {import("./particle_vector_extract.js").ParticleValueExtraction} extraction
+ * @returns {import("./particle_vector_groups.js").ParticleValuePacking}
+ */
+export function pack_particle_vectors(graph, section, extraction) {
+    const demand = measure_demand(graph, section, extraction);
+    /** @type {import("./particle_vector_groups.js").ParticleValueGroup[]} */
+    const groups = [];
+    /** @type {Map<number, number>} per class, the group that computes it */
+    const of = new Map();
+    /** @type {Map<number, {group: number, lane: number}>} */
+    const placement = new Map();
+
+    const add = (shape) => {
+        const group = {
+            index: groups.length,
+            kind: PV_GROUP.COMPUTE,
+            op: VM_OP.NOP,
+            width: 1,
+            span: 0,
+            values: [],
+            raw: [-1, -1, -1],
+            operands: [],
+            gather: [],
+            constants: [],
+            draw: -1,
+            coalition: -1,
+            sequence: 0,
+            ...shape,
+        };
+
+        groups.push(group);
+
+        return group;
+    };
+
+    /**
+     * A source operand: lanes of one value, read where that value lives.
+     *
+     * @param {number} slot
+     * @param {number} value
+     * @param {number} pattern
+     * @param {number} lanes how many lanes the instruction reads of it
+     * @param {number} where the reading instruction's place in the section
+     * @returns {import("./particle_vector_groups.js").ParticleGroupOperand}
+     */
+    const operand = (slot, value, pattern, lanes, where) => {
+        const literals = graph.constants_of(value);
+
+        if (literals !== null) {
+            const read = [];
+
+            for (let lane = 0; lane < lanes; lane++) {
+                read.push(literals[Math.min(swizzle_selector(pattern, lane), literals.length - 1)]);
+            }
+
+            // Every lane the same literal is an operand with no instruction and no slot behind it,
+            // which is what most literals in an effect are.
+            if (read.every(one => Object.is(one, read[0]))) {
+                return { slot, group: -1, lanes: [], reads: [], value: read[0] };
+            }
+
+            // And one that is not uniform is a pool run made HERE, for this operand: sequenced at the
+            // instruction that reads it, not where the literal first appeared. Those are the same
+            // place for a literal used once near the top and thousands of instructions apart for a
+            // noise gradient, and on `curl4` the difference is the whole register file — sixty
+            // three-lane gradients loaded at the front and held to their single distant use are 185
+            // of its 210 slots. A literal is the cheapest thing there is to recompute; it should
+            // never be the thing that is kept.
+            const run = add({
+                kind: PV_GROUP.CONSTANT,
+                op: VM_OP.LOAD_CONST,
+                width: read.length,
+                span: read.length,
+                values: read.map(() => -1),
+                constants: read,
+                sequence: where,
+            });
+
+            return {
+                slot,
+                group: run.index,
+                lanes: read.map((unused, lane) => lane),
+                reads: read.map((unused, lane) => ({ group: run.index, lane })),
+                value: 0,
+            };
+        }
+
+        const place = of.get(graph.find(value));
+
+        assert.defined(place, `particle vector packing: class ${value} was never computed`);
+
+        const read = [];
+
+        for (let lane = 0; lane < lanes; lane++) {
+            // A lane past the value's own width is one the instruction does not really read — a
+            // `CROSS` asked for four lanes reads three — so it is clamped rather than invented.
+            read.push(place.base + Math.min(swizzle_selector(pattern, lane), place.width - 1));
+        }
+
+        const group = place.group;
+
+        return { slot, group, lanes: read, reads: read.map(lane => ({ group, lane })), value: 0 };
+    };
+
+    merge_draws(graph, extraction, demand, of, add);
+
+    for (const id of extraction.order) {
+        if (of.has(id)) {
+            continue;
+        }
+
+        const node = graph.node(extraction.choice.get(id));
+        const sequence = id;
+        const width = demand.get(id) ?? 0;
+
+        // Nothing reads it: an instruction that need not be written at all.
+        if (width === 0) {
+            continue;
+        }
+
+        // A literal is not an instruction until an operand needs it in a register, and most never
+        // do — see `operand` above.
+        if (node.op === PV.CONST) {
+            continue;
+        }
+
+        if (node.op === PV.ATTR) {
+            const group = add({
+                op: VM_OP.LOAD_ATTR,
+                width,
+                span: width,
+                raw: [node.imm[0], width, -1],
+                sequence,
+            });
+
+            of.set(id, { group: group.index, base: 0, width: group.span });
+            continue;
+        }
+
+        if (node.op === PV.BUILD) {
+            const group = add({
+                kind: PV_GROUP.GATHER,
+                op: VM_OP.MOV,
+                width: 1,
+                span: width,
+                gather: node.children.slice(0, width).map((child, lane) => {
+                    const literals = graph.constants_of(child);
+
+                    if (literals !== null) {
+                        return { group: -1, lane: 0, value: literals[Math.min(node.patterns[lane], literals.length - 1)] };
+                    }
+
+                    const from = of.get(graph.find(child));
+
+                    assert.defined(from, `particle vector packing: class ${child} was never computed`);
+
+                    return {
+                        group: from.group,
+                        lane: from.base + Math.min(node.patterns[lane], from.width - 1),
+                        value: 0,
+                    };
+                }),
+                sequence,
+            });
+
+            of.set(id, { group: group.index, base: 0, width: group.span });
+            continue;
+        }
+
+        const reads = narrowable(node) ? width : node.operand_width;
+        const group = add({
+            op: node.op,
+            width: Math.max(reads, VM_ISA.get(node.op).min_width),
+            span: narrowable(node) ? width : node.width,
+            raw: raw_fields(node),
+            draw: node.op === VM_OP.RANDOM ? node.imm[0] : -1,
+            sequence,
+        });
+
+        for (let source = 0; source < node.children.length; source++) {
+            group.operands.push(operand(
+                slot_of(node, source),
+                node.children[source],
+                node.patterns[source],
+                node.op === VM_OP.CURVE ? 1 : group.width,
+                sequence
+            ));
+        }
+
+        of.set(id, { group: group.index, base: 0, width: group.span });
+    }
+
+    for (const id of extraction.order) {
+        if (of.has(id)) {
+            placement.set(id, { group: of.get(id).group, lane: of.get(id).base });
+        }
+    }
+
+    for (const chunk of chunk_stores(section.stores)) {
+        const group = add({
+            kind: PV_GROUP.STORE,
+            op: VM_OP.STORE_ATTR,
+            width: chunk.length,
+            span: 0,
+            raw: [-1, chunk[0].word, chunk.length],
+            sequence: Math.max(...chunk.map(store => graph.find(store.place.value))),
+        });
+
+        group.operands.push(store_operand(graph, of, groups, chunk, add, group.sequence));
+    }
+
+    for (const kill of section.kills) {
+        const group = add({
+            kind: PV_GROUP.KILL,
+            op: VM_OP.KILL,
+            width: 1,
+            span: 0,
+            sequence: graph.find(kill.value),
+        });
+
+        const literals = graph.constants_of(kill.value);
+
+        if (literals !== null) {
+            group.operands.push({ slot: 0, group: -1, lanes: [], reads: [], value: literals[kill.lane] });
+            continue;
+        }
+
+        const from = of.get(graph.find(kill.value));
+
+        group.operands.push({
+            slot: 0,
+            group: from.group,
+            lanes: [from.base + kill.lane],
+            reads: [{ group: from.group, lane: from.base + kill.lane }],
+            value: 0,
+        });
+    }
+
+    return dissolve_builds({ groups, placement, coalitions: [] }, add);
+}
+
+/**
+ * The widest stretch of the file a coalition may claim — the runs it lays end to end, added up.
+ *
+ * A ceiling rather than a tuned number: swept over the library's effects, 4 costs `integrate` four
+ * instructions (a four-lane run plus a one-lane pool run is five slots) and everything from 6 upwards
+ * is identical. What actually limits a coalition is that the lanes one operand wants must fall inside
+ * ONE window of four, which no amount of room relaxes.
+ *
+ * @type {number}
+ */
+export const PARTICLE_VECTOR_COALITION_SLOTS = 8;
+
+/**
+ * Get rid of the copies by laying the runs where the copy was going to put them.
+ *
+ * A `BUILD` is a vector assembled from lanes of several values, and it is the only thing in this
+ * optimizer that costs an instruction without computing anything. But an operand can read any four
+ * consecutive slots: so if the runs it draws from are laid END TO END, and the lanes it wants happen
+ * to fall inside one window of four, whoever reads the `BUILD` can read those slots directly and the
+ * copies are simply not needed. Nothing about a destination says where it has to be — this optimizer
+ * chooses.
+ *
+ * That is the same thing a pass pipeline achieves by RETARGETING the instruction that feeds a copy,
+ * which is what `../pass_propagate_copies.js` does to the 1,227 `MOV`s a frontend emits for its
+ * vector constructors. Said in terms of layout rather than of rewriting, because here the layout is
+ * not yet decided and there is nothing to rewrite.
+ *
+ * A literal lane is a run too. Most of what a frontend's vector constructors build is three computed
+ * lanes and a constant `w` — `[x, y, z, 0]`, `[x, y, z, 1]` — and laying one pool run of the literals
+ * beside the computed ones turns four copies into a single `LOAD_CONST`. That is where the whole of
+ * `simplex4`'s remaining thirty copies were.
+ *
+ * Heaviest first, since a `BUILD` of four lanes is worth four copies and one of two is worth two, and
+ * a run may only be in one coalition.
+ *
+ * @param {import("./particle_vector_groups.js").ParticleValuePacking} packing
+ * @param {function(object): import("./particle_vector_groups.js").ParticleValueGroup} add
+ * @returns {import("./particle_vector_groups.js").ParticleValuePacking}
+ */
+function dissolve_builds(packing, add) {
+    const { groups } = packing;
+    /** @type {number[][]} */
+    const coalitions = [];
+    /** @type {Map<number, {anchor: number, slots: number[], reads: Array<{group: number, lane: number}>}>} */
+    const dissolved = new Map();
+
+    const builds = groups
+        .filter(group => group.kind === PV_GROUP.GATHER)
+        .sort((a, b) => b.gather.length - a.gather.length || a.index - b.index);
+
+    for (const build of builds) {
+        // Where this build's lanes come from: one entry per run it reads, and one more for its
+        // literal lanes, whose run does not exist yet and is only made if the layout works out.
+        /** @type {Array<{group: number, span: number}>} */
+        const plan = [];
+        /** @type {number[]} */
+        const literals = [];
+        const wanted = build.gather.map(source => {
+            if (source.group < 0) {
+                let lane = literals.findIndex(one => Object.is(one, source.value));
+
+                if (lane < 0) {
+                    lane = literals.push(source.value) - 1;
+                }
+
+                return { member: -1, lane };
+            }
+
+            let member = plan.findIndex(one => one.group === source.group);
+
+            if (member < 0) {
+                member = plan.push({ group: source.group, span: groups[source.group].span }) - 1;
+            }
+
+            return { member, lane: source.lane };
+        });
+        const pool = literals.length > 0 ? plan.push({ group: -1, span: literals.length }) - 1 : -1;
+
+        for (const source of wanted) {
+            if (source.member < 0) {
+                source.member = pool;
+            }
+        }
+
+        if (plan.length === 0 || plan.length > VM_MAX_WIDTH) {
+            continue;
+        }
+
+        // A build feeding a build is not something the rewrite below can follow — the reader it
+        // would have to retarget is another gather.
+        if (plan.some(one => one.group >= 0 && groups[one.group].kind === PV_GROUP.GATHER)) {
+            continue;
+        }
+
+        // A run may only be in one coalition — but a build reading a run that is already in one is
+        // not thereby lost. Its lanes may already lie where they need to: `simplex4` builds
+        // `[x, y, z, 0]`, `[y, z, 0]` and `[z, 0, 0]` from the same vector, and one layout serves all
+        // three. So being coalesced is a reason to JOIN, not a reason to refuse.
+        if (plan.some(one => one.group >= 0 && groups[one.group].coalition >= 0)) {
+            const joined = join_coalition(groups, coalitions, plan, wanted, literals, pool);
+
+            if (joined !== null) {
+                dissolved.set(build.index, joined);
+            }
+
+            continue;
+        }
+
+        // The literals' run is an instruction of its own, so it has to pay for itself. Joining an
+        // existing coalition costs nothing, which is why this is asked only of a fresh one.
+        if (build.gather.length <= (pool < 0 ? 0 : 1)) {
+            continue;
+        }
+
+        if (plan.reduce((slots, one) => slots + one.span, 0) > PARTICLE_VECTOR_COALITION_SLOTS) {
+            continue;
+        }
+
+        const chosen = arrangements(plan.map((unused, member) => member))
+            .map(arrangement => ({ arrangement, slots: window_of(plan, arrangement, wanted) }))
+            .find(candidate => candidate.slots !== null);
+
+        if (chosen === undefined) {
+            continue;
+        }
+
+        if (pool >= 0) {
+            plan[pool].group = add({
+                kind: PV_GROUP.CONSTANT,
+                op: VM_OP.LOAD_CONST,
+                width: literals.length,
+                span: literals.length,
+                values: literals.map(() => -1),
+                constants: literals,
+                sequence: build.sequence,
+            }).index;
+        }
+
+        const arrangement = chosen.arrangement.map(member => plan[member].group);
+        const index = coalitions.length;
+
+        coalitions.push(arrangement);
+
+        for (const group of arrangement) {
+            groups[group].coalition = index;
+        }
+
+        dissolved.set(build.index, {
+            anchor: arrangement[0],
+            slots: chosen.slots,
+            reads: wanted.map(source => ({ group: plan[source.member].group, lane: source.lane })),
+        });
+    }
+
+    if (dissolved.size === 0) {
+        return packing;
+    }
+
+    // Whoever read the `BUILD` now reads the runs where they lie.
+    for (const group of groups) {
+        for (const operand of group.operands) {
+            const gone = dissolved.get(operand.group);
+
+            if (gone === undefined) {
+                continue;
+            }
+
+            operand.reads = operand.lanes.map(lane => gone.reads[Math.min(lane, gone.reads.length - 1)]);
+            operand.lanes = operand.lanes.map(lane => gone.slots[Math.min(lane, gone.slots.length - 1)]);
+            operand.group = gone.anchor;
+        }
+
+        // A build may read a build — a four-wide load of a three-component attribute is a build, and
+        // anything assembled from it reads one. Those lanes are copies still to be made, so they take
+        // the run each lane ended up in rather than a window into it.
+        group.gather = group.gather.map(source => {
+            const gone = dissolved.get(source.group);
+
+            return gone === undefined
+                ? source
+                : { ...source, ...gone.reads[Math.min(source.lane, gone.reads.length - 1)] };
+        });
+    }
+
+    return renumber(groups, coalitions, dissolved);
+}
+
+/**
+ * Whether a `BUILD` can read the layout an existing coalition already has, without changing it.
+ *
+ * Nothing is laid out here and nothing is added: the question is only whether the lanes this build
+ * wants happen to fall inside one window of four of a layout that has already been decided. Its
+ * literal lanes have to be found in a pool run that coalition already holds — extending one would
+ * move everything after it, and the coalition's other readers have been told where their slots are.
+ *
+ * @param {import("./particle_vector_groups.js").ParticleValueGroup[]} groups
+ * @param {number[][]} coalitions
+ * @param {Array<{group: number, span: number}>} plan
+ * @param {Array<{member: number, lane: number}>} wanted
+ * @param {number[]} literals
+ * @param {number} pool which member of `plan` holds the literal lanes, or -1
+ * @returns {{anchor: number, slots: number[], reads: Array<{group: number, lane: number}>}|null}
+ */
+function join_coalition(groups, coalitions, plan, wanted, literals, pool) {
+    const anchored = plan.find(one => one.group >= 0 && groups[one.group].coalition >= 0);
+    const index = groups[anchored.group].coalition;
+    const members = coalitions[index];
+
+    // Every run it reads has to be in that same coalition, or the slots are not one stretch at all.
+    if (plan.some(one => one.group >= 0 && groups[one.group].coalition !== index)) {
+        return null;
+    }
+
+    const offset = new Map();
+
+    let at = 0;
+
+    for (const group of members) {
+        offset.set(group, at);
+        at += groups[group].span;
+    }
+
+    /** @type {Array<{group: number, lane: number}>} where each literal already sits, if it does */
+    const found = literals.map(value => {
+        for (const group of members) {
+            if (groups[group].kind !== PV_GROUP.CONSTANT) {
+                continue;
+            }
+
+            const lane = groups[group].constants.findIndex(one => Object.is(one, value));
+
+            if (lane >= 0) {
+                return { group, lane };
+            }
+        }
+
+        return null;
+    });
+
+    if (pool >= 0 && found.some(one => one === null)) {
+        return null;
+    }
+
+    const reads = wanted.map(source => (source.member === pool
+        ? found[source.lane]
+        : { group: plan[source.member].group, lane: source.lane }));
+    const slots = reads.map(read => offset.get(read.group) + read.lane);
+
+    if (Math.max(...slots) - Math.min(...slots) >= VM_MAX_WIDTH) {
+        return null;
+    }
+
+    return { anchor: members[0], slots, reads };
+}
+
+/**
+ * Where a `BUILD`'s lanes land if its runs are laid out in this order, and whether that is somewhere
+ * one operand can reach.
+ *
+ * @param {Array<{group: number, span: number}>} plan
+ * @param {number[]} arrangement the members of `plan`, in the order they would be laid out
+ * @param {Array<{member: number, lane: number}>} wanted
+ * @returns {number[]|null} the slot each lane sits at, measured from the first run's base
+ */
+function window_of(plan, arrangement, wanted) {
+    const offset = new Map();
+
+    let at = 0;
+
+    for (const member of arrangement) {
+        offset.set(member, at);
+        at += plan[member].span;
+    }
+
+    const slots = wanted.map(source => offset.get(source.member) + source.lane);
+
+    return Math.max(...slots) - Math.min(...slots) < VM_MAX_WIDTH ? slots : null;
+}
+
+/**
+ * Drop the groups that dissolved and close the gap in the numbering.
+ *
+ * @param {import("./particle_vector_groups.js").ParticleValueGroup[]} groups
+ * @param {number[][]} coalitions
+ * @param {Map<number, object>} dissolved
+ * @returns {import("./particle_vector_groups.js").ParticleValuePacking}
+ */
+function renumber(groups, coalitions, dissolved) {
+    const kept = groups.filter(group => !dissolved.has(group.index));
+    const moved = new Map();
+
+    kept.forEach((group, index) => moved.set(group.index, index));
+
+    for (const group of kept) {
+        group.index = moved.get(group.index);
+
+        for (const operand of group.operands) {
+            if (operand.group >= 0) {
+                operand.group = moved.get(operand.group);
+                operand.reads = operand.reads.map(read => ({ group: moved.get(read.group), lane: read.lane }));
+            }
+        }
+
+        group.gather = group.gather.map(source => (source.group >= 0
+            ? { ...source, group: moved.get(source.group) }
+            : source));
+    }
+
+    return {
+        groups: kept,
+        placement: new Map(),
+        coalitions: coalitions.map(members => members.map(group => moved.get(group))),
+    };
+}
+
+/**
+ * Every order a handful of runs could be laid out in. At most four of them, so at most twenty-four.
+ *
+ * @param {number[]} members
+ * @returns {number[][]}
+ */
+function arrangements(members) {
+    if (members.length <= 1) {
+        return [members];
+    }
+
+    const out = [];
+
+    for (let i = 0; i < members.length; i++) {
+        const rest = members.filter((unused, j) => j !== i);
+
+        for (const tail of arrangements(rest)) {
+            out.push([members[i], ...tail]);
+        }
+    }
+
+    return out;
+}
+
+/**
+ * The value a store writes, as one operand — or, where its words come from lanes of several values,
+ * the run a `BUILD` has to make first.
+ *
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {Map<number, number>} of
+ * @param {import("./particle_vector_groups.js").ParticleValueGroup[]} groups
+ * @param {Array<{word: number, place: {value: number, lane: number}}>} chunk
+ * @param {function(object): import("./particle_vector_groups.js").ParticleValueGroup} add
+ * @param {number} where the storing instruction's place in the section
+ * @returns {import("./particle_vector_groups.js").ParticleGroupOperand}
+ */
+function store_operand(graph, of, groups, chunk, add, where) {
+    const first = graph.find(chunk[0].place.value);
+
+    assert.ok(
+        chunk.every(store => graph.find(store.place.value) === first),
+        "particle vector packing: a store chunk should have been cut where its value changes"
+    );
+
+    const literals = graph.constants_of(first);
+
+    if (literals !== null) {
+        const read = chunk.map(store => literals[Math.min(store.place.lane, literals.length - 1)]);
+
+        if (read.every(one => Object.is(one, read[0]))) {
+            return { slot: 0, group: -1, lanes: [], reads: [], value: read[0] };
+        }
+
+        const run = add({
+            kind: PV_GROUP.CONSTANT,
+            op: VM_OP.LOAD_CONST,
+            width: read.length,
+            span: read.length,
+            values: read.map(() => -1),
+            constants: read,
+            sequence: where,
+        });
+
+        return {
+            slot: 0,
+            group: run.index,
+            lanes: read.map((unused, lane) => lane),
+            reads: read.map((unused, lane) => ({ group: run.index, lane })),
+            value: 0,
+        };
+    }
+
+    const place = of.get(first);
+    const group = place.group;
+    const lanes = chunk.map(store => place.base + store.place.lane);
+
+    return { slot: 0, group, lanes, reads: lanes.map(lane => ({ group, lane })), value: 0 };
+}
+
+/**
+ * Which record words go in one `STORE_ATTR`: consecutive words, taken from one value, no more than
+ * the four an operand spans — and cut where the original stores cut, so that a `vec3` position and a
+ * `vec4` colour in adjacent words stay two stores.
+ *
+ * @param {Array<{word: number, place: {value: number, lane: number}, origin: number}>} stores
+ * @returns {Array<Array<{word: number, place: {value: number, lane: number}, origin: number}>>}
+ */
+export function chunk_stores(stores) {
+    const chunks = [];
+
+    for (const store of stores) {
+        const chunk = chunks[chunks.length - 1];
+        const last = chunk?.[chunk.length - 1];
+
+        if (chunk !== undefined
+            && chunk.length < VM_MAX_WIDTH
+            && last.word + 1 === store.word
+            && last.origin === store.origin
+            && last.place.value === store.place.value) {
+            chunk.push(store);
+            continue;
+        }
+
+        chunks.push([store]);
+    }
+
+    return chunks;
+}
+
+/**
+ * @param {import("./particle_vector_graph.js").ParticleVectorNode} node
+ * @returns {number[]} the static operand words the opcode reads for itself
+ */
+function raw_fields(node) {
+    switch (node.op) {
+        case VM_OP.LOAD_BUILTIN:
+        case VM_OP.CURVE:
+            return [node.imm[0], -1, -1];
+
+        default:
+            return [-1, -1, -1];
+    }
+}
+
+/**
+ * @param {import("./particle_vector_graph.js").ParticleVectorNode} node
+ * @param {number} source which of the node's sources
+ * @returns {number} the instruction source slot it goes in
+ */
+function slot_of(node, source) {
+    // `CURVE` takes its handle in slot 0 and the value it samples in slot 1; everything else fills
+    // its slots in order.
+    return node.op === VM_OP.CURVE ? source + 1 : source;
+}
+
+/**
+ * How many lanes of each value anything actually reads.
+ *
+ * Walked backwards from what the section is obliged to produce, so a value nothing reads gets zero —
+ * which is dead-code elimination — and one whose upper lanes nothing reads gets fewer than it has,
+ * which is narrowing. Both fall out of the same number, and both are worth having twice over here:
+ * a narrower instruction is a smaller run as well as, sometimes, a cheaper one.
+ *
+ * Only the opcodes the ISA says may drop their trailing lanes are narrowed. A `RANDOM` may not — its
+ * width IS how many draws it takes — and neither may a reduction, which reads every lane to write
+ * one.
+ *
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {import("./particle_vector_lift.js").ParticleLiftedVectorSection} section
+ * @param {import("./particle_vector_extract.js").ParticleValueExtraction} extraction
+ * @returns {Map<number, number>} per class, the lanes of it that are read
+ */
+function measure_demand(graph, section, extraction) {
+    /** @type {Map<number, number>} */
+    const demand = new Map();
+    const want = (value, lanes) => {
+        const id = graph.find(value);
+
+        demand.set(id, Math.max(demand.get(id) ?? 0, lanes));
+    };
+
+    for (const store of section.stores) {
+        want(store.place.value, store.place.lane + 1);
+    }
+
+    for (const kill of section.kills) {
+        want(kill.value, kill.lane + 1);
+    }
+
+    // A draw is taken whether or not it is read, so a `RANDOM` is wanted whole.
+    for (const draw of section.draws) {
+        want(draw, graph.width_of(draw));
+    }
+
+    for (let i = extraction.order.length - 1; i >= 0; i--) {
+        const id = extraction.order[i];
+        const wanted = demand.get(id) ?? 0;
+
+        if (wanted === 0) {
+            continue;
+        }
+
+        const node = graph.node(extraction.choice.get(id));
+        const width = narrowable(node) ? Math.min(wanted, node.width) : node.width;
+
+        if (node.op === PV.BUILD) {
+            for (let lane = 0; lane < width; lane++) {
+                want(node.children[lane], node.patterns[lane] + 1);
+            }
+
+            continue;
+        }
+
+        const reads = node.op === VM_OP.CURVE
+            ? 1
+            : Math.max(narrowable(node) ? width : node.operand_width, VM_ISA.get(node.op)?.min_width ?? 1);
+
+        for (let source = 0; source < node.children.length; source++) {
+            let highest = 0;
+
+            for (let lane = 0; lane < reads; lane++) {
+                highest = Math.max(highest, swizzle_selector(node.patterns[source], lane) + 1);
+            }
+
+            want(node.children[source], highest);
+        }
+    }
+
+    return demand;
+}
+
+/**
+ * @param {import("./particle_vector_graph.js").ParticleVectorNode} node
+ * @returns {boolean} whether dropping its trailing lanes leaves the rest unchanged
+ */
+function narrowable(node) {
+    if (node.op === PV.ATTR || node.op === PV.BUILD) {
+        return true;
+    }
+
+    return vm_semantics_of(node.op).narrowable && node.width === node.operand_width;
+}
+
+/**
+ * Take consecutive draws in one instruction.
+ *
+ * A `RANDOM` of width n advances the generator n times and writes n slots, so two `RANDOM.1`s taking
+ * draws 4 and 5 compute exactly what one `RANDOM.2` taking draws 4 and 5 computes — the same numbers,
+ * in the same order, in two adjacent slots. The graph cannot see this, because a draw is identified by
+ * its index and two indices are two values; it is a fact about the instruction rather than about the
+ * values, so it belongs here, where instructions are chosen.
+ *
+ * Only runs that are consecutive with no gap are merged: draws 4 and 6 in one instruction would
+ * silently take draw 5 as well and hand the reader the wrong number.
+ *
+ * @param {import("./particle_vector_graph.js").ParticleVectorGraph} graph
+ * @param {import("./particle_vector_extract.js").ParticleValueExtraction} extraction
+ * @param {Map<number, number>} demand
+ * @param {Map<number, {group: number, base: number, width: number}>} of
+ * @param {function(object): import("./particle_vector_groups.js").ParticleValueGroup} add
+ */
+function merge_draws(graph, extraction, demand, of, add) {
+    const draws = extraction.order
+        .filter(id => (demand.get(id) ?? 0) > 0 && graph.node(extraction.choice.get(id)).op === VM_OP.RANDOM)
+        .map(id => ({ id, node: graph.node(extraction.choice.get(id)) }))
+        .sort((a, b) => a.node.imm[0] - b.node.imm[0]);
+
+    for (let first = 0; first < draws.length;) {
+        let last = first;
+        let width = draws[first].node.width;
+
+        while (last + 1 < draws.length
+            && draws[last + 1].node.imm[0] === draws[first].node.imm[0] + width
+            && width + draws[last + 1].node.width <= VM_MAX_WIDTH) {
+            width += draws[last + 1].node.width;
+            last += 1;
+        }
+
+        if (last > first) {
+            const group = add({
+                op: VM_OP.RANDOM,
+                width,
+                span: width,
+                raw: [-1, -1, -1],
+                draw: draws[first].node.imm[0],
+                sequence: Math.min(...draws.slice(first, last + 1).map(one => one.id)),
+            });
+
+            let base = 0;
+
+            for (const one of draws.slice(first, last + 1)) {
+                of.set(one.id, { group: group.index, base, width: one.node.width });
+                base += one.node.width;
+            }
+        }
+
+        first = last + 1;
+    }
+}