chore: update benchmarks

Author: bowheart

bench/package.json

@@ -13,10 +13,12 @@
   "license": "ISC",
   "dependencies": {
     "@angular/core": "16.0.0-next.0",
+    "@legendapp/state": "^3.0.0-beta.23",
     "@preact/signals": "^1.1.3",
     "@reactively/core": "^0.0.8",
     "@solidjs/reactivity": "^0.0.9",
     "@vue/reactivity": "^3.2.47",
+    "alien-signals": "^1.0.0",
     "compostate": "^0.5.1",
     "jotai": "^2.9.1",
     "kairo": "0.6.0-rc.0",

bench/pnpm-lock.yaml

@@ -1,5 +1,5 @@
 // The following is an implementation of the cellx benchmark https://github.com/Riim/cellx/blob/master/perf/perf.html
-import { logPerfResult } from './util/perfLogging'
+import { assert, logPerfResult } from './util/perfLogging'
 import { Computed, ReactiveFramework } from './util/reactiveFramework'
 
 const cellx = (framework: ReactiveFramework, layers: number) => {
@@ -125,12 +125,12 @@ export const cellxbench = (framework: ReactiveFramework) => {
     const [before, after] = results[layers]
     const [expectedBefore, expectedAfter] = expected[layers]
 
-    console.assert(
+    assert(
       arraysEqual(before, expectedBefore),
       `Expected first layer ${expectedBefore}, found first layer ${before}`
     )
 
-    console.assert(
+    assert(
       arraysEqual(after, expectedAfter),
       `Expected last layer ${expectedAfter}, found last layer ${after}`
     )

bench/src/cellxBench.ts

@@ -1,9 +1,11 @@
 import { TestConfig, FrameworkInfo } from './util/frameworkTypes'
 
+import { alienFramework } from './frameworks/alienSignals'
 import { angularFramework } from './frameworks/angularSignals'
 import { compostateFramework } from './frameworks/compostate'
 import { jotaiFramework } from './frameworks/jotai'
 import { kairoFramework } from './frameworks/kairo'
+import { legendFramework } from './frameworks/legend'
 import { mobxFramework } from './frameworks/mobx'
 import { molWireFramework } from './frameworks/molWire'
 import { obyFramework } from './frameworks/oby'
@@ -17,10 +19,12 @@ import { xReactivityFramework } from './frameworks/xReactivity'
 import { zeduxFramework } from './frameworks/zedux'
 
 export const frameworkInfo: FrameworkInfo[] = [
+  // { framework: alienFramework, testPullCounts: true },
   // { framework: angularFramework, testPullCounts: true },
   // { framework: compostateFramework, testPullCounts: true },
   // { framework: jotaiFramework, testPullCounts: true },
   // { framework: kairoFramework, testPullCounts: true },
+  // { framework: legendFramework, testPullCounts: true },
   // { framework: mobxFramework, testPullCounts: true },
   // { framework: molWireFramework, testPullCounts: true },
   // { framework: obyFramework, testPullCounts: true },

bench/src/config.ts

@@ -0,0 +1,26 @@
+import { Computed, Effect, endBatch, Signal, startBatch } from 'alien-signals'
+import { ReactiveFramework } from '../util/reactiveFramework'
+
+export const alienFramework: ReactiveFramework = {
+  name: 'alien-signals',
+  signal: initial => {
+    const data = new Signal(initial)
+    return {
+      read: () => data.get(),
+      write: v => data.set(v),
+    }
+  },
+  computed: fn => {
+    const c = new Computed(fn)
+    return {
+      read: () => c.get(),
+    }
+  },
+  effect: fn => new Effect(fn).run(),
+  withBatch: fn => {
+    startBatch()
+    fn()
+    endBatch()
+  },
+  withBuild: fn => fn(),
+}

bench/src/frameworks/alienSignals.ts

@@ -0,0 +1,22 @@
+import { ReactiveFramework } from '../util/reactiveFramework'
+import { batch, Observable, observable, observe } from '@legendapp/state'
+
+export const legendFramework: ReactiveFramework = {
+  name: 'Legend',
+  signal: initialValue => {
+    const s = observable(initialValue)
+    return {
+      write: v => (s as Observable<any>).set(v),
+      read: () => s.get(),
+    }
+  },
+  computed: <T>(fn: () => T) => {
+    const memo = observable(fn)
+    return {
+      read: () => memo.get() as T,
+    }
+  },
+  effect: fn => observe(fn),
+  withBatch: fn => batch(fn),
+  withBuild: fn => fn(),
+}

bench/src/frameworks/legend.ts

@@ -1,35 +1,48 @@
-import { Ecosystem, atom, createEcosystem } from '@zedux/atoms'
+import {
+  Ecosystem,
+  SelectorInstance,
+  Signal,
+  createEcosystem,
+} from '../../../packages/atoms' // '@zedux/atoms'
 import { Computed, ReactiveFramework } from '../util/reactiveFramework'
 
 let ecosystem: Ecosystem
 let counter = 0
 
+class CustomSelector extends SelectorInstance {
+  /**
+   * Zedux cleans up graph nodes when it detects they're no longer in use. These
+   * benchmarks don't expect that behavior. Making `node.m`aybeDestroy a noop is
+   * all that's needed to prevent automatic destruction, while still allowing
+   * manual destruction via `node.destroy()`.
+   */
+  m() {}
+}
+
 export const zeduxFramework: ReactiveFramework = {
   name: 'Zedux',
   signal: initialValue => {
-    const instance = ecosystem.getInstance(
-      atom((counter++).toString(), initialValue)
-    )
+    const s = new Signal(ecosystem, (counter++).toString(), initialValue)
 
     return {
-      write: v => instance.set(v),
-      read: () => ecosystem.live.get(instance),
+      read: () => s.get(),
+      write: v => s.set(v),
     }
   },
   computed: <T>(fn: () => T): Computed<T> => {
-    const instance = ecosystem.getNode(fn)
+    const s = new CustomSelector(ecosystem, (counter++).toString(), fn, [])
 
     return {
-      read: () => ecosystem.live.select(instance),
+      read: () => s.get(),
     }
   },
   effect: fn => ecosystem.getNode(fn),
   withBatch: fn => ecosystem.batch(fn),
   withBuild: fn => {
-    if (ecosystem) {
-      ecosystem.reset()
-    }
+    if (ecosystem) ecosystem.reset()
+
     ecosystem = createEcosystem()
+    globalThis.ecosystem = ecosystem
     return fn()
   },
 }

bench/src/frameworks/zedux.ts

@@ -1,3 +1,4 @@
+import { assert } from '../util/perfLogging'
 import { ReactiveFramework } from '../util/reactiveFramework'
 import { busy } from './util'
 
@@ -18,12 +19,12 @@ export function avoidablePropagation(bridge: ReactiveFramework) {
     bridge.withBatch(() => {
       head.write(1)
     })
-    console.assert(computed5.read() === 6)
+    assert(computed5.read() === 6)
     for (let i = 0; i < 1000; i++) {
       bridge.withBatch(() => {
         head.write(i)
       })
-      console.assert(computed5.read() === 6)
+      assert(computed5.read() === 6)
     }
   }
 }

bench/src/kairo/avoidable.ts

@@ -1,37 +1,38 @@
-import { Counter } from "../util/dependencyGraph";
-import { Computed, ReactiveFramework } from "../util/reactiveFramework";
+import { assert } from '../util/perfLogging'
+import { Counter } from '../util/dependencyGraph'
+import { Computed, ReactiveFramework } from '../util/reactiveFramework'
 
 /** broad propagation */
 export function broadPropagation(bridge: ReactiveFramework) {
-  let head = bridge.signal(0);
-  let last = head as Computed<number>;
-  let callCounter = new Counter();
+  let head = bridge.signal(0)
+  let last = head as Computed<number>
+  let callCounter = new Counter()
   for (let i = 0; i < 50; i++) {
     let current = bridge.computed(() => {
-      return head.read() + i;
-    });
+      return head.read() + i
+    })
     let current2 = bridge.computed(() => {
-      return current.read() + 1;
-    });
+      return current.read() + 1
+    })
     bridge.effect(() => {
-      current2.read();
-      callCounter.count++;
-    });
-    last = current2;
+      current2.read()
+      callCounter.count++
+    })
+    last = current2
   }
 
   return () => {
     bridge.withBatch(() => {
-      head.write(1);
-    });
-    const atleast = 50 * 50;
-    callCounter.count = 0;
+      head.write(1)
+    })
+    const atleast = 50 * 50
+    callCounter.count = 0
     for (let i = 0; i < 50; i++) {
       bridge.withBatch(() => {
-        head.write(i);
-      });
-      console.assert(last.read() === i + 50);
+        head.write(i)
+      })
+      assert(last.read() === i + 50)
     }
-    console.assert(callCounter.count === atleast, callCounter.count);
-  };
+    assert(callCounter.count === atleast, callCounter.count)
+  }
 }