perf(core, engine): reduce allocations when writing shader module uniforms - #3421

Background

When an application draws many small models per frame, the per-draw CPU cost of uniform handling adds up. Model.draw() calls updateShaderInputs(), which passes the uniforms of every shader module to the model's UniformStore at every draw, and deck.gl calls ShaderInputs.setProps() for every module of every layer at every draw. A sampling heap profile of 500 deck.gl layers showed that most of the memory allocated per frame came from these two paths. Most of it was temporary arrays and strings that the result does not need.

This replaces the first version of this PR, which added per-module revision counters and wrote only changed modules. As requested in review, this version keeps the existing Model -> UniformStore update path and behavior. It only removes allocations.

Change List

• UniformStore.setUniforms(), UniformBlock.setUniforms(), ShaderBlockWriter flattening and serialization, and ShaderInputs uniform merging used Object.entries(), which allocates an array per key. These loops now use for...in.
• ShaderBlockWriter built every leaf path name (lights[0], lights[0].color, ...) again at every flatten. It now keeps the names it has built.
• UniformStore serialized a changed block with getData(). That flattened the block's values again, although UniformBlock already holds them flattened, and it created four typed-array views of the scratch buffer each time. The new ShaderBlockWriter.getFlatData() serializes values that are already flat. The views are created again only when the scratch buffer changes. getData() is now getFlatData(getFlatUniformValues(values)).
• When an array of structs was merged, the current array was copied twice. It is now copied once.
• cloneModuleUniformValue() cloned structs with Object.fromEntries(Object.entries().map()). It now uses a loop.
• ShaderInputs.getBindingValues() no longer uses Object.values().
• Docs: getFlatData() in the ShaderBlockLayout page.

What does not change: Model still passes every module to UniformStore. UniformStore still compares each value with its own copy. ShaderInputs.setProps() still makes a new uniforms object for each module it is given, with copied values. So a value changed in place in the object returned by getUniformValues() still reaches the GPU at the next updateShaderInputs().

Measurements

Setup: Chrome with ANGLE on Metal, Apple M1 Max, luma.gl 9.4.0 and deck.gl 9.4.0 (the changed code is the same on master). The page has 500 deck.gl layers of one type, each with 1–2 features, and the view pans every frame. The metric is the CPU time of deck's frame callback (Deck._onRenderFrame). A runtime flag in the same page switches the change off and on, and the two arms alternate. Each value is the median of the paired runs, with the range in brackets. Run A has 5 pairs and run B has 7.

SolidPolygonLayer gains most because its lighting uniforms are an array of structs. That makes many leaf paths and nested objects per draw. In a sampling heap profile over 60 frames, the bytes allocated fell from 865 MB to 500 MB for the polygon scene and from 523 MB to 327 MB for the scatterplot scene.

The first version of this PR (writing only changed modules) saved more in the polygon scene without picking (17.3 -> 11.9 ms, measured with other fixes applied). It saved almost nothing with picking. This version saves less without picking and more with picking. The two could be combined later if revision tracking is still wanted.

Verification

• Node 24.14.0, yarn lint: passed. yarn build: passed.
• yarn bundle-size: @luma.gl/core is 100,994 B minified (budget 101,000 B; master is 100,751 B). The first push of this version was 157 B over the budget, so a second commit merges the two name helpers into one and creates the scratch views in getFlatData() itself. The measurements above were taken before that size change, which does not change behavior.
• yarn test-node: 4,189 passed, 8 skipped (497 files).
• Headless Chromium, full npx vitest run --project headless --no-coverage: 381 files, 2,749 passed, 23 skipped.
• New test Model#updateShaderInputs writes uniform values changed in place (null device): it changes a scalar, and then an array element twice, in the object returned by getUniformValues(), and checks the bytes written to the uniform buffer after each updateShaderInputs(). It also checks that a call with nothing changed writes nothing. The test fails if UniformBlock stores the value without copying it. It would also fail with the first version of this PR.
• New test ShaderBlockWriter flattens and serializes repeated values consistently: leaf names are built again correctly for different values, getFlatData() gives the same bytes as getData(), and data from an earlier serialization is cleared. The test fails if the name cache ignores the parent name, or if the scratch buffer is not cleared.

CI on the first version

Browser coverage (3/3) failed in Model#updateShaderInputs writes only changed modules with GLSL compilation errors ... WebGL did not provide a shader compiler log. The log shows that the GPU process failed (GPU state invalid after WaitForGetOffsetInRange) just after the WebGPU test Model#draw skips WebGPU render pipelines that failed init. The new test was the next one to compile a WebGL shader, so its compile failed with no log. Aggregate test coverage failed only because that shard failed. That test is removed with the revision tracking. The new Model test uses the null device and does not compile shaders.