@zeix/cause-effect 0.13.1 → 0.13.2

package/test/util/dependency-graph.ts

@@ -1,10 +1,10 @@
-import { TestConfig } from "./framework-types";
-import { Computed, ReactiveFramework, Signal } from "./reactive-framework";
-import { Random } from "random";
+import { TestConfig } from './framework-types'
+import { Computed, ReactiveFramework, Signal } from './reactive-framework'
+import { Random } from 'random'
 
 export interface Graph {
-  sources: Signal<number>[];
-  layers: Computed<number>[][];
+	sources: Signal<number>[]
+	layers: Computed<number>[][]
 }
 
 /**
@@ -17,25 +17,27 @@ export interface Graph {
  * @returns the graph
  */
 export function makeGraph(
-  framework: ReactiveFramework,
-  config: TestConfig,
-  counter: Counter
+	framework: ReactiveFramework,
+	config: TestConfig,
+	counter: Counter,
 ): Graph {
-  const { width, totalLayers, staticFraction, nSources } = config;
-
-  return framework.withBuild(() => {
-    const sources = new Array(width).fill(0).map((_, i) => framework.signal(i));
-    const rows = makeDependentRows(
-      sources,
-      totalLayers - 1,
-      counter,
-      staticFraction,
-      nSources,
-      framework
-    );
-    const graph = { sources, layers: rows };
-    return graph;
-  });
+	const { width, totalLayers, staticFraction, nSources } = config
+
+	return framework.withBuild(() => {
+		const sources = new Array(width)
+			.fill(0)
+			.map((_, i) => framework.signal(i))
+		const rows = makeDependentRows(
+			sources,
+			totalLayers - 1,
+			counter,
+			staticFraction,
+			nSources,
+			framework,
+		)
+		const graph = { sources, layers: rows }
+		return graph
+	})
 }
 
 /**
@@ -44,146 +46,146 @@ export function makeGraph(
  * @return the sum of all leaf values
  */
 export function runGraph(
-  graph: Graph,
-  iterations: number,
-  readFraction: number,
-  framework: ReactiveFramework
+	graph: Graph,
+	iterations: number,
+	readFraction: number,
+	framework: ReactiveFramework,
 ): number {
-  const rand = new Random("seed");
-  const { sources, layers } = graph;
-  const leaves = layers[layers.length - 1];
-  const skipCount = Math.round(leaves.length * (1 - readFraction));
-  const readLeaves = removeElems(leaves, skipCount, rand);
-  const frameworkName = framework.name.toLowerCase();
-  // const start = Date.now();
-  let sum = 0;
-
-  if (frameworkName === "s-js" || frameworkName === "solidjs") {
-    // [S.js freeze](https://github.com/adamhaile/S#sdatavalue) doesn't allow different values to be set during a single batch, so special case it.
-    for (let i = 0; i < iterations; i++) {
-      framework.withBatch(() => {
-        const sourceDex = i % sources.length;
-        sources[sourceDex].write(i + sourceDex);
-      });
-
-      for (const leaf of readLeaves) {
-        leaf.read();
-      }
-    }
-
-    sum = readLeaves.reduce((total, leaf) => leaf.read() + total, 0);
-  } else {
-    framework.withBatch(() => {
-      for (let i = 0; i < iterations; i++) {
-        // Useful for debugging edge cases for some frameworks that experience
-        // dramatic slow downs for certain test configurations. These are generally
-        // due to `computed` effects not being cached efficiently, and as the number
-        // of layers increases, the uncached `computed` effects are re-evaluated in
-        // an `O(n^2)` manner where `n` is the number of layers.
-        /* if (i % 100 === 0) {
+	const rand = new Random('seed')
+	const { sources, layers } = graph
+	const leaves = layers[layers.length - 1]
+	const skipCount = Math.round(leaves.length * (1 - readFraction))
+	const readLeaves = removeElems(leaves, skipCount, rand)
+	const frameworkName = framework.name.toLowerCase()
+	// const start = Date.now();
+	let sum = 0
+
+	if (frameworkName === 's-js' || frameworkName === 'solidjs') {
+		// [S.js freeze](https://github.com/adamhaile/S#sdatavalue) doesn't allow different values to be set during a single batch, so special case it.
+		for (let i = 0; i < iterations; i++) {
+			framework.withBatch(() => {
+				const sourceDex = i % sources.length
+				sources[sourceDex].write(i + sourceDex)
+			})
+
+			for (const leaf of readLeaves) {
+				leaf.read()
+			}
+		}
+
+		sum = readLeaves.reduce((total, leaf) => leaf.read() + total, 0)
+	} else {
+		framework.withBatch(() => {
+			for (let i = 0; i < iterations; i++) {
+				// Useful for debugging edge cases for some frameworks that experience
+				// dramatic slow downs for certain test configurations. These are generally
+				// due to `computed` effects not being cached efficiently, and as the number
+				// of layers increases, the uncached `computed` effects are re-evaluated in
+				// an `O(n^2)` manner where `n` is the number of layers.
+				/* if (i % 100 === 0) {
            console.log("iteration:", i, "delta:", Date.now() - start);
         } */
 
-        const sourceDex = i % sources.length;
-        sources[sourceDex].write(i + sourceDex);
+				const sourceDex = i % sources.length
+				sources[sourceDex].write(i + sourceDex)
 
-        for (const leaf of readLeaves) {
-          leaf.read();
-        }
-      }
-	  
-      sum = readLeaves.reduce((total, leaf) => leaf.read() + total, 0);
-    });
-  }
+				for (const leaf of readLeaves) {
+					leaf.read()
+				}
+			}
 
-  return sum;
+			sum = readLeaves.reduce((total, leaf) => leaf.read() + total, 0)
+		})
+	}
+
+	return sum
 }
 
 function removeElems<T>(src: T[], rmCount: number, rand: Random): T[] {
-  const copy = src.slice();
-  for (let i = 0; i < rmCount; i++) {
-    const rmDex = rand.int(0, copy.length - 1);
-    copy.splice(rmDex, 1);
-  }
-  return copy;
+	const copy = src.slice()
+	for (let i = 0; i < rmCount; i++) {
+		const rmDex = rand.int(0, copy.length - 1)
+		copy.splice(rmDex, 1)
+	}
+	return copy
 }
 
 export class Counter {
-  count = 0;
+	count = 0
 }
 
 function makeDependentRows(
-  sources: Computed<number>[],
-  numRows: number,
-  counter: Counter,
-  staticFraction: number,
-  nSources: number,
-  framework: ReactiveFramework
+	sources: Computed<number>[],
+	numRows: number,
+	counter: Counter,
+	staticFraction: number,
+	nSources: number,
+	framework: ReactiveFramework,
 ): Computed<number>[][] {
-  let prevRow = sources;
-  const rand = new Random("seed");
-  const rows = [];
-  for (let l = 0; l < numRows; l++) {
-    const row = makeRow(
-      prevRow,
-      counter,
-      staticFraction,
-      nSources,
-      framework,
-      l,
-      rand
-    );
-    rows.push(row as never);
-    prevRow = row;
-  }
-  return rows;
+	let prevRow = sources
+	const rand = new Random('seed')
+	const rows = []
+	for (let l = 0; l < numRows; l++) {
+		const row = makeRow(
+			prevRow,
+			counter,
+			staticFraction,
+			nSources,
+			framework,
+			l,
+			rand,
+		)
+		rows.push(row as never)
+		prevRow = row
+	}
+	return rows
 }
 
 function makeRow(
-  sources: Computed<number>[],
-  counter: Counter,
-  staticFraction: number,
-  nSources: number,
-  framework: ReactiveFramework,
-  _layer: number,
-  random: Random
+	sources: Computed<number>[],
+	counter: Counter,
+	staticFraction: number,
+	nSources: number,
+	framework: ReactiveFramework,
+	_layer: number,
+	random: Random,
 ): Computed<number>[] {
-  return sources.map((_, myDex) => {
-    const mySources: Computed<number>[] = [];
-    for (let sourceDex = 0; sourceDex < nSources; sourceDex++) {
-      mySources.push(sources[(myDex + sourceDex) % sources.length]);
-    }
-
-    const staticNode = random.float() < staticFraction;
-    if (staticNode) {
-      // static node, always reference sources
-      return framework.computed(() => {
-        counter.count++;
-
-        let sum = 0;
-        for (const src of mySources) {
-          sum += src.read();
-        }
-        return sum;
-      });
-    } else {
-      // dynamic node, drops one of the sources depending on the value of the first element
-      const first = mySources[0];
-      const tail = mySources.slice(1);
-      const node = framework.computed(() => {
-        counter.count++;
-        let sum = first.read();
-        const shouldDrop = sum & 0x1;
-        const dropDex = sum % tail.length;
-
-        for (let i = 0; i < tail.length; i++) {
-          if (shouldDrop && i === dropDex) continue;
-          sum += tail[i].read();
-        }
-
-        return sum;
-      });
-      return node;
-    }
-  });
+	return sources.map((_, myDex) => {
+		const mySources: Computed<number>[] = []
+		for (let sourceDex = 0; sourceDex < nSources; sourceDex++) {
+			mySources.push(sources[(myDex + sourceDex) % sources.length])
+		}
+
+		const staticNode = random.float() < staticFraction
+		if (staticNode) {
+			// static node, always reference sources
+			return framework.computed(() => {
+				counter.count++
+
+				let sum = 0
+				for (const src of mySources) {
+					sum += src.read()
+				}
+				return sum
+			})
+		} else {
+			// dynamic node, drops one of the sources depending on the value of the first element
+			const first = mySources[0]
+			const tail = mySources.slice(1)
+			const node = framework.computed(() => {
+				counter.count++
+				let sum = first.read()
+				const shouldDrop = sum & 0x1
+				const dropDex = sum % tail.length
+
+				for (let i = 0; i < tail.length; i++) {
+					if (shouldDrop && i === dropDex) continue
+					sum += tail[i].read()
+				}
+
+				return sum
+			})
+			return node
+		}
+	})
 }

package/test/util/framework-types.ts

@@ -1,5 +1,5 @@
-import { TestResult } from "./perf-tests";
-import { ReactiveFramework } from "./reactive-framework";
+import { TestResult } from './perf-tests'
+import { ReactiveFramework } from './reactive-framework'
 
 /** Parameters for a running a performance benchmark test
  *
@@ -19,35 +19,35 @@ import { ReactiveFramework } from "./reactive-framework";
  * number of non-signal updated.
  */
 export interface TestConfig {
-  /** friendly name for the test, should be unique */
-  name?: string;
+	/** friendly name for the test, should be unique */
+	name?: string
 
-  /** width of dependency graph to construct */
-  width: number;
+	/** width of dependency graph to construct */
+	width: number
 
-  /** depth of dependency graph to construct */
-  totalLayers: number;
+	/** depth of dependency graph to construct */
+	totalLayers: number
 
-  /** fraction of nodes that are static */ // TODO change to dynamicFraction
-  staticFraction: number;
+	/** fraction of nodes that are static */ // TODO change to dynamicFraction
+	staticFraction: number
 
-  /** construct a graph with number of sources in each node */
-  nSources: number;
+	/** construct a graph with number of sources in each node */
+	nSources: number
 
-  /** fraction of [0, 1] elements in the last layer from which to read values in each test iteration */
-  readFraction: number;
+	/** fraction of [0, 1] elements in the last layer from which to read values in each test iteration */
+	readFraction: number
 
-  /** number of test iterations */
-  iterations: number;
+	/** number of test iterations */
+	iterations: number
 
-  /** sum and count of all iterations, for verification */
-  expected: Partial<TestResult>;
+	/** sum and count of all iterations, for verification */
+	expected: Partial<TestResult>
 }
 
 export interface FrameworkInfo {
-  /** wrapper/adapter for a benchmarking a reactive framework */
-  framework: ReactiveFramework;
+	/** wrapper/adapter for a benchmarking a reactive framework */
+	framework: ReactiveFramework
 
-  /** verify the number of nodes executed matches the expected number */
-  testPullCounts?: boolean;
+	/** verify the number of nodes executed matches the expected number */
+	testPullCounts?: boolean
 }

package/test/util/perf-tests.ts

@@ -1,42 +1,42 @@
-import { FrameworkInfo, TestConfig } from "./framework-types";
+import { FrameworkInfo, TestConfig } from './framework-types'
 
 export interface TestResult {
-  sum: number;
-  count: number;
+	sum: number
+	count: number
 }
 
 export interface TimingResult<T> {
-  result: T;
-  timing: TestTiming;
+	result: T
+	timing: TestTiming
 }
 
 export interface TestTiming {
-  time: number;
+	time: number
 }
 
 export function verifyBenchResult(
-  perfFramework: FrameworkInfo,
-  config: TestConfig,
-  timedResult: TimingResult<TestResult>
+	perfFramework: FrameworkInfo,
+	config: TestConfig,
+	timedResult: TimingResult<TestResult>,
 ): void {
-  const { testPullCounts, framework } = perfFramework;
-  const { expected } = config;
-  const { result } = timedResult;
+	const { testPullCounts, framework } = perfFramework
+	const { expected } = config
+	const { result } = timedResult
 
-  if (expected.sum) {
-    console.assert(
-      result.sum == expected.sum,
-      `sum ${framework.name} ${config.name} result:${result.sum} expected:${expected.sum}`
-    );
-  }
-  if (
-    expected.count &&
-    (config.readFraction === 1 || testPullCounts) &&
-    testPullCounts !== false
-  ) {
-    console.assert(
-      result.count === expected.count,
-      `count ${framework.name} ${config.name} result:${result.count} expected:${expected.count}`
-    );
-  }
+	if (expected.sum) {
+		console.assert(
+			result.sum == expected.sum,
+			`sum ${framework.name} ${config.name} result:${result.sum} expected:${expected.sum}`,
+		)
+	}
+	if (
+		expected.count &&
+		(config.readFraction === 1 || testPullCounts) &&
+		testPullCounts !== false
+	) {
+		console.assert(
+			result.count === expected.count,
+			`count ${framework.name} ${config.name} result:${result.count} expected:${expected.count}`,
+		)
+	}
 }

package/test/util/reactive-framework.ts

@@ -3,20 +3,19 @@
  * Implement this interface to add a new reactive framework to the test and performance test suite.
  */
 export interface ReactiveFramework {
-	name: string;
-	signal<T>(initialValue: T): Signal<T>;
-	computed<T>(fn: () => T): Computed<T>;
-	effect(fn: () => void): void;
-	withBatch<T>(fn: () => T): void;
-	withBuild<T>(fn: () => T): T;
+	name: string
+	signal<T>(initialValue: T): Signal<T>
+	computed<T>(fn: () => T): Computed<T>
+	effect(fn: () => void): void
+	withBatch<T>(fn: () => T): void
+	withBuild<T>(fn: () => T): T
 }
-  
+
 export interface Signal<T> {
-	read(): T;
-	write(v: T): void;
+	read(): T
+	write(v: T): void
 }
-  
+
 export interface Computed<T> {
-	read(): T;
+	read(): T
 }
-