chore: upgrade to vitest 5 and migrate benchmarks to vitest bench

package.json

@@ -19,6 +19,7 @@
   "scripts": {
     "tsc": "tsc -p tsconfig.build.json --skipLibCheck --outDir dist --declaration true --sourceMap true",
     "test": "vitest run",
+    "bench": "vitest bench --reporter=verbose",
     "stryker": "stryker run",
     "build": "npm run tsc && npm run rollup",
     "prettier": "prettier --parser typescript -l src/**/*.ts",
@@ -44,20 +45,17 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
-    "@types/benchmark": "^2.1.5",
     "@types/node": "^22.0.0",
     "assemblyscript": "^0.27.32",
     "assemblyscript-unittest-framework": "^2.0.0",
-    "benchmark": "^2.1.4",
-    "benny": "^3.6.14",
     "fast-check": "^4.6.0",
     "node-notifier": ">=8.0.1",
     "prettier": "^3.8.2",
     "rollup": "^4.60.1",
     "ts-loader": "^9.5.7",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.4",
+    "vitest": "^5.0.5",
     "yargs": "^18.0.0"
   },
   "files": [

src/bench/histogram-add.bench.ts

@@ -0,0 +1,25 @@
+import { initWebAssembly } from "../wasm";
+import { buildFilledHistogram } from "./support";
+
+beforeAll(() => initWebAssembly());
+
+test("Histogram add", async ({ bench }) => {
+  const int32 = buildFilledHistogram();
+  const int32Other = buildFilledHistogram();
+  const wasm32 = buildFilledHistogram({ useWebAssembly: true });
+  const wasm32Other = buildFilledHistogram({ useWebAssembly: true });
+  const packed = buildFilledHistogram({ bitBucketSize: "packed" });
+  const packedOther = buildFilledHistogram({ bitBucketSize: "packed" });
+
+  await bench.compare(
+    bench("Int32Histogram", () => {
+      int32.add(int32Other);
+    }),
+    bench("WASM 32B Histogram", () => {
+      wasm32.add(wasm32Other);
+    }),
+    bench("Packed Histogram", () => {
+      packed.add(packedOther);
+    })
+  );
+});

src/bench/histogram-data-access-co.bench.ts

@@ -0,0 +1,64 @@
+import { build } from "../index";
+import { initWebAssembly } from "../wasm";
+
+const randomInteger = () => Math.floor(Math.random() * 1000000);
+const randomSmallInteger = () => Math.floor(Math.random() * 1000);
+const expectedInterval = 100000;
+
+beforeAll(() => initWebAssembly());
+
+test("Histogram data access with coordinated omissions", async ({ bench }) => {
+  const int32 = build({ bitBucketSize: 32 });
+  const int32NoCorrection = build({ bitBucketSize: 32 });
+  const packed = build({ bitBucketSize: "packed" });
+  const packedNoCorrection = build({ bitBucketSize: "packed" });
+  const wasm32 = build({ useWebAssembly: true });
+  const wasm32NoCorrection = build({ useWebAssembly: true });
+  const wasmPacked = build({ useWebAssembly: true, bitBucketSize: "packed" });
+  const wasmPackedNoCorrection = build({
+    useWebAssembly: true,
+    bitBucketSize: "packed"
+  });
+
+  await bench.compare(
+    bench("Int32Histogram", () => {
+      int32.recordValueWithExpectedInterval(randomInteger(), expectedInterval);
+    }),
+    bench("Int32Histogram no correction needed", () => {
+      int32NoCorrection.recordValueWithExpectedInterval(
+        randomSmallInteger(),
+        expectedInterval
+      );
+    }),
+    bench("PackedHistogram", () => {
+      packed.recordValueWithExpectedInterval(randomInteger(), expectedInterval);
+    }),
+    bench("PackedHistogram no correction needed", () => {
+      packedNoCorrection.recordValueWithExpectedInterval(
+        randomSmallInteger(),
+        expectedInterval
+      );
+    }),
+    bench("WASM Int32Histogram", () => {
+      wasm32.recordValueWithExpectedInterval(randomInteger(), expectedInterval);
+    }),
+    bench("WASM Int32Histogram no correction needed", () => {
+      wasm32NoCorrection.recordValueWithExpectedInterval(
+        randomSmallInteger(),
+        expectedInterval
+      );
+    }),
+    bench("WASM PackedHistogram", () => {
+      wasmPacked.recordValueWithExpectedInterval(
+        randomInteger(),
+        expectedInterval
+      );
+    }),
+    bench("WASM PackedHistogram no correction needed", () => {
+      wasmPackedNoCorrection.recordValueWithExpectedInterval(
+        randomSmallInteger(),
+        expectedInterval
+      );
+    })
+  );
+});

src/bench/histogram-data-access.bench.ts

@@ -0,0 +1,47 @@
+import { build } from "../index";
+import { initWebAssembly } from "../wasm";
+
+const randomInteger = () =>
+  Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+
+beforeAll(() => initWebAssembly());
+
+test("Histogram data access", async ({ bench }) => {
+  const int32 = build({ bitBucketSize: 32 });
+  const packed = build({ bitBucketSize: "packed" });
+  const float64 = build({ bitBucketSize: 64 });
+  const int32Eager = build({
+    bitBucketSize: 32,
+    highestTrackableValue: Number.MAX_SAFE_INTEGER
+  });
+  const wasm32 = build({ useWebAssembly: true });
+  const wasmPacked = build({ useWebAssembly: true, bitBucketSize: "packed" });
+  const float64Eager = build({
+    bitBucketSize: 64,
+    highestTrackableValue: Number.MAX_SAFE_INTEGER
+  });
+
+  await bench.compare(
+    bench("Int32Histogram", () => {
+      int32.recordValue(randomInteger());
+    }),
+    bench("PackedHistogram", () => {
+      packed.recordValue(randomInteger());
+    }),
+    bench("Float64Histogram", () => {
+      float64.recordValue(randomInteger());
+    }),
+    bench("Int32Histogram eager allocation", () => {
+      int32Eager.recordValue(randomInteger());
+    }),
+    bench("WASM Int32Histogram", () => {
+      wasm32.recordValue(randomInteger());
+    }),
+    bench("WASM PackedHistogram", () => {
+      wasmPacked.recordValue(randomInteger());
+    }),
+    bench("Float64Histogram eager allocation", () => {
+      float64Eager.recordValue(randomInteger());
+    })
+  );
+});