chore: to thi.ng

bench/index.js

@@ -0,0 +1,93 @@
+import { createHash } from 'crypto';
+import objectHash from 'object-hash';
+import { identify } from 'object-identity';
+
+import { EMPTY, suite } from '@thi.ng/bench';
+
+const getObject = () => {
+	const c = [1];
+	// @ts-ignore
+	c.push(c);
+	return { a: { b: ['c', new Set(['d', new Map([['e', 'f']]), c, 'g'])] } };
+};
+
+const contenders = {
+	['object-identity']() {
+		return (o) => identify(o);
+	},
+	['object-hash']() {
+		const options = { algorithm: 'passthrough', unorderedSets: false };
+
+		return (o) => objectHash(o, options);
+	},
+
+	['object-identity :: hashed']() {
+		const hasher = (val) => createHash('sha1').update(val).digest('hex');
+
+		return (o) => identify(o, hasher);
+	},
+	['object-hash :: hashed']() {
+		const options = {
+			algorithm: 'sha1',
+			encoding: 'hex',
+			unorderedSets: false,
+		};
+
+		return (o) => objectHash(o, options);
+	},
+};
+
+runner(contenders);
+
+async function runner(contenders) {
+	const cases = [];
+	for (const [name, contender] of Object.entries(contenders)) {
+		const run = contender();
+		const o = getObject();
+		const fn = () => run(o);
+		cases.push({ fn, title: name });
+	}
+
+	suite(cases, {
+		warmup: 300,
+		size: 50,
+		iter: 10_000,
+		format: FORMAT(),
+	});
+}
+
+function FORMAT() {
+	const formatter = new Intl.NumberFormat('en-US');
+	return {
+		prefix: EMPTY,
+		suffix: EMPTY,
+		start: EMPTY,
+		warmup: EMPTY,
+		result: EMPTY,
+		total(a) {
+			const winner = a.slice().sort((a, b) => a.mean - b.mean)[0];
+			const compute = a.map((x) => {
+				return {
+					title: x.title,
+					won: x === winner,
+					ops: formatter.format(
+						Math.floor((x.iter * x.size) / (x.total / 1000)),
+					),
+					sd: (x.sd / 1000).toFixed(2),
+				};
+			});
+			const max_name = Math.max(...a.map((x) => x.title.length));
+			const max_ops = Math.max(...compute.map((x) => x.ops.length));
+			const lines = [];
+			for (const x of compute) {
+				const won = x.won ? '★ ' : '  ';
+				lines.push(
+					`${won}${x.title.padEnd(max_name)} ~ ${x.ops.padStart(
+						max_ops,
+					)} ops/sec ± ${x.sd}%`,
+				);
+			}
+			return lines.join('\n');
+		},
+	};
+}

bench/package.json

@@ -1,9 +1,9 @@
 {
-	"private": true,
+	"type": "module",
 	"dependencies": {
-		"@types/benchmark": "2.1.2",
-		"@types/node": "^18.16.1",
+		"@thi.ng/bench": "^3.2.10",
 		"benchmark": "2.1.4",
-		"object-hash": "^3.0.0"
+		"object-hash": "^3.0.0",
+		"object-identity": "file:.."
 	}
 }

package.json

@@ -21,7 +21,7 @@
 		"index.d.ts"
 	],
 	"scripts": {
-		"bench": "node -r tsm bench/index.ts",
+		"bench": "node bench/index.js",
 		"build": "bundt --minify",
 		"test": "uvu test -r tsm \".spec.ts$\"",
 		"typecheck": "tsc --noEmit"

readme.md

@@ -59,13 +59,10 @@ assert.toEqual(hashA, hashB);
 > via the [`/bench`](/bench) directory with Node v16.20.0 (Apple M1 Pro)
 
 ```
-benchmark :: hashed
-  object-hash          x    58,395 ops/sec ±0.23% (96 runs sampled)
-  object-identity      x 1,180,665 ops/sec ±0.44% (96 runs sampled)
-
-benchmark :: passed through
-  object-hash          x   123,699 ops/sec ±0.22% (99 runs sampled)
-  object-identity      x 1,188,861 ops/sec ±0.21% (99 runs sampled)
+  object-identity           ~ 1,759,250 ops/sec ± 0.03%
+  object-hash               ~   137,578 ops/sec ± 0.01%
+★ object-identity :: hashed ~ 1,842,540 ops/sec ± 0.02%
+  object-hash :: hashed     ~    58,219 ops/sec ± 0.01%
 ```
 
 > ^ `object-identity` is not as feature-full it's alternatives, specifically around `function` values and other node