@woosh/meep-engine 3.12.0 → 3.13.1

package/src/shade/descriptor/pipeline/compute/ComputePipelineDescriptor.js

@@ -1,14 +1,79 @@
 import { assert } from "../../../../core/assert.js";
 import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import {
+    compute_infer_workgroup_size_from_source
+} from "../../../renderer/shader/util/compute_infer_workgroup_size_from_source.js";
 import { GPUShaderStage } from "../../GPUShaderStage.js";
 import { PipelineDescriptorBase } from "../PipelineDescriptorBase.js";
 import { PipelineLayoutDescriptor } from "../PipelineLayoutDescriptor.js";
 import { ProgrammableStage } from "../ProgrammableStage.js";
 import { ShaderModuleDescriptor } from "../ShaderModuleDescriptor.js";
 
+/**
+ * What {@link ComputePipelineDescriptor#workgroup_size} reads before any code has been set.
+ *
+ * Not a fallback for unreadable source — that throws. This is the value of a descriptor that has
+ * been constructed and not yet given a shader, which is a state only `new` produces.
+ *
+ * @type {readonly number[]}
+ */
+const WORKGROUP_SIZE_UNSET = Object.freeze([0, 0, 0]);
+
 export class ComputePipelineDescriptor extends PipelineDescriptorBase {
     compute = new ProgrammableStage();
 
+    /**
+     * @type {readonly number[]}
+     */
+    #workgroup_size = WORKGROUP_SIZE_UNSET;
+
+    /**
+     * `[x, y, z]` of this pipeline's `@workgroup_size`.
+     *
+     * Read once, when the code is set, and kept — the source cannot change under a descriptor
+     * without going back through one of the factories, each of which reads it again. So every
+     * consumer downstream, a profile capture included, gets the number for free.
+     *
+     * Frozen, because it is handed out by reference to per-pass profile records and a descriptor
+     * that outlives a whole capture must not be mutable through one of them.
+     *
+     * Takes no part in {@link equals} or {@link hash}: it is derived from `compute.module`, which
+     * both already cover, and a cache key computed two ways is a cache that can disagree with
+     * itself.
+     *
+     * @returns {readonly number[]}
+     */
+    get workgroup_size() {
+        return this.#workgroup_size;
+    }
+
+    /**
+     * Read the workgroup size out of the code just assigned to {@link compute}, and **throw** if it
+     * cannot be read.
+     *
+     * Loud, and at construction. Every consumer of this number divides a thread count by it, so a
+     * guess that is wrong silently dispatches the wrong fraction of the workload — and a descriptor
+     * that cannot state its own workgroup size is one nobody downstream can use correctly. Better
+     * that it cannot be built than that it be built and dealt with.
+     *
+     * @returns {void}
+     */
+    #read_workgroup_size() {
+        const code = this.compute.module.code;
+
+        try {
+            this.#workgroup_size = Object.freeze(compute_infer_workgroup_size_from_source(code));
+        } catch (e) {
+            const error = new Error(
+                `Compute pipeline '${this.label}' has no readable workgroup size: ${e.message}`
+            );
+
+            error.cause = e;
+
+            throw error;
+        }
+    }
+
     /**
      *
      * @param {string} label
@@ -24,6 +89,8 @@ export class ComputePipelineDescriptor extends PipelineDescriptorBase {
         r.label = label;
         r.compute.module = ShaderModuleDescriptor.fromCode(code);
 
+        r.#read_workgroup_size();
+
         return r;
 
     }
@@ -53,6 +120,8 @@ export class ComputePipelineDescriptor extends PipelineDescriptorBase {
             r.compute.constants = constants;
         }
 
+        r.#read_workgroup_size();
+
         return r;
     }
 
@@ -78,6 +147,10 @@ export class ComputePipelineDescriptor extends PipelineDescriptorBase {
         assert.isObject(json.compute, 'json.compute');
 
         this.compute.fromJSON(json.compute);
+
+        // `fromJSON` replaces the module in place, so the size read for whatever was here before is
+        // now the wrong shader's. Read it again rather than leaving a stale divisor behind.
+        this.#read_workgroup_size();
     }
 
     /**