@driftengine/texture 4.4.0 → 4.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/texture",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "description": "DriftTexture: a texture as a compiled, sampled field rather than an image",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,7 +27,7 @@
   ],
   "sideEffects": false,
   "peerDependencies": {
-    "@driftengine/core": "4.4.0"
+    "@driftengine/core": "4.4.1"
   },
   "author": "Drift Technologies",
   "repository": {

package/dist/tensor/reuse.d.ts

@@ -1,33 +0,0 @@
-/**
- * Which values of a graph may share one buffer, as one rule both sides plan by: the reference
- * evaluator here, and the device's runner in `@driftengine/core`.
- *
- * **A value's buffer is given back after the last node that reads it, and not before** — so a
- * node's output never shares a buffer with any of its own inputs, since the inputs are read while
- * the output is written. What is `held` keeps a buffer of its own for the life of the plan, and so
- * does every output; a value that is neither written by a node nor held is not planned at all,
- * which is how the evaluator leaves weights and inputs in the caller's own arrays.
- *
- * **Two implementations of this would drift**, and the failure is a network that runs, validates
- * and answers wrongly — a value overwritten before its last reader reads it.
- *
- * What it gives up: a free buffer is taken first-come rather than by the size that fits best, so a
- * small value may hold a large buffer while a larger one waits. The transformers this runs repeat a
- * block of identically shaped values, where first-come and best-fit choose the same buffers.
- */
-export interface BufferReuse {
-    /** The buffer each planned value lives in. */
-    readonly slotOf: ReadonlyMap<string, number>;
-    /** Each buffer's size, in values: the largest value it ever holds. */
-    readonly sizes: readonly number[];
-}
-export declare function planReuse(graph: {
-    readonly nodes: readonly {
-        readonly inputs: readonly string[];
-        readonly output: string;
-    }[];
-    /** Values given a buffer each before any node runs, in this order. */
-    readonly held: readonly string[];
-    /** Values never given back, claimed where they are written. */
-    readonly outputs: readonly string[];
-}, sizeOf: (name: string) => number): BufferReuse;

package/dist/tensor/reuse.js

@@ -1,59 +0,0 @@
-/**
- * Which values of a graph may share one buffer, as one rule both sides plan by: the reference
- * evaluator here, and the device's runner in `@driftengine/core`.
- *
- * **A value's buffer is given back after the last node that reads it, and not before** — so a
- * node's output never shares a buffer with any of its own inputs, since the inputs are read while
- * the output is written. What is `held` keeps a buffer of its own for the life of the plan, and so
- * does every output; a value that is neither written by a node nor held is not planned at all,
- * which is how the evaluator leaves weights and inputs in the caller's own arrays.
- *
- * **Two implementations of this would drift**, and the failure is a network that runs, validates
- * and answers wrongly — a value overwritten before its last reader reads it.
- *
- * What it gives up: a free buffer is taken first-come rather than by the size that fits best, so a
- * small value may hold a large buffer while a larger one waits. The transformers this runs repeat a
- * block of identically shaped values, where first-come and best-fit choose the same buffers.
- */
-export function planReuse(graph, sizeOf) {
-    const slotOf = new Map();
-    const sizes = [];
-    const pinned = new Set([...graph.held, ...graph.outputs]);
-    const claim = (name) => {
-        sizes.push(sizeOf(name));
-        slotOf.set(name, sizes.length - 1);
-        return sizes.length - 1;
-    };
-    for (const name of graph.held)
-        claim(name);
-    /* The last node reading each value; a value never read is last read where it is written. */
-    const lastRead = new Map();
-    graph.nodes.forEach((node, at) => {
-        lastRead.set(node.output, at);
-        for (const input of node.inputs)
-            lastRead.set(input, at);
-    });
-    const free = [];
-    graph.nodes.forEach((node, at) => {
-        if (pinned.has(node.output)) {
-            claim(node.output);
-        }
-        else {
-            const reuse = free.shift();
-            if (reuse === undefined)
-                claim(node.output);
-            else {
-                slotOf.set(node.output, reuse);
-                sizes[reuse] = Math.max(sizes[reuse], sizeOf(node.output));
-            }
-        }
-        /* Only after the node has run: its inputs are read while its output is written. */
-        for (const value of new Set([...node.inputs, node.output])) {
-            const slot = slotOf.get(value);
-            if (slot === undefined || pinned.has(value) || lastRead.get(value) !== at)
-                continue;
-            free.push(slot);
-        }
-    });
-    return { slotOf, sizes };
-}