ESBench: Ein modernes Benchmarking-Tool

benchmark.js endet im April 2024, es ist Zeit für die Entstehung einer neuen Generation von Tools!

ESBench ist ein neues JavaScript-Benchmarking-Tool, das im Jahr 2024 veröffentlicht wurde. Es wurde entwickelt, um einfache, skalierbare Benchmarking-Unterstützung für moderne JS-Projekte zu bieten.

GitHub-Repository

Das Problem

• Anfangs wurde JavaScript direkt aus dem Quellcode ausgeführt, doch mit zunehmender Komplexität der Anwendungen ist dies immer seltener der Fall. Moderne Anwendungen müssen oft erstellt werden, was Benchmarking-Tools erfordert, um den Build-Prozess integrieren zu können, und die Auswirkungen des Builds auf die Leistung müssen berücksichtigt werden.

• JavaScript hat keine „offizielle Laufzeit“, Browser, Node, Deno und neuerdings auch Bun behaupten alle, hohe Leistung zu haben. Aber was ist mit Ihrem eigenen Code? Es wäre cool, wenn es ein Tool gäbe, das Benchmarks in mehreren Laufzeiten ausführen und die Ergebnisse in einen Bericht exportieren könnte —— das war meine Hauptmotivation, ESBench zu erstellen.

• Es gibt einige nützliche Funktionen, die JS-Benchmark-Tools meiner Meinung nach nicht leisten können, wie z. B. die Berechnung der asymptotischen Komplexität, die Validierung des Rückgabewerts und die Darstellung der Ergebnisse in einem interaktiven Diagramm .

Benchmarking mit ESBench

Um diese Probleme zu lösen, habe ich beschlossen, ein neues Tool zu entwickeln, das alle von mir benötigten Funktionen enthält und über eine einfache API verfügt.

Nach etwa einem Jahr Entwicklungszeit war ESBench geboren.

Sie können ESBench online ausprobieren

Suite schreiben

ESBench entscheidet sich für deklarative APIs und Abschlüsse, was die beliebteste Art ist, JS zu schreiben.

Vergleichen Sie Set.has und Array.includes:

// benchmark/array-vs-set.js
export default scene => {
    const length = 1000;
    const array = Array.from({ length }, (_, i) => i);

    const set = new Set(array);
    const value = array[Math.floor(array.length / 2)];

    scene.bench("Set", () => set.has(value));
    scene.bench("Array", () => array.includes(value));
};

Führen Sie pnpm exec esbench aus, um die Suite auszuführen. Das Ergebnis:

Suite: benchmark/array-vs-set.js
| No. |  Name |      time | time.SD |
| --: | ----: | --------: | ------: |
|   0 |   Set |   3.64 ns | 0.00 ns |
|   1 | Array | 326.36 ns | 0.17 ns |

Ein bisschen mehr Funktionen

Parametrierung und Baselines sind häufige Anforderungen, ESBench unterstützt sie mit einfachen Optionen.

export default {
    baseline: { type: "type", value: Set },
    params: {
        length: [10, 10_000],
        type: [Set, Array],
    },
    setup(scene) {
        const { length, type } = scene.params;

        // Prepare
        const array = Array.from({ length }, (_, i) => i);
        const set = new Set(array);
        const value = array[Math.floor(array.length / 2)];

        // Support conditions
        if (type === Set) {
            // Define benchmark cases
            scene.bench("create", () => new Set(array));
            scene.bench("has", () => set.has(value));
        } else {
            scene.bench("create", () => [...array]);
            scene.bench("has", () => array.includes(value));
        }
    },
};

Der Textbericht:

Cross-Runtime

Zurück zum obigen Problem, Laufzeitübergreifend:

// esbench.config.js
import { defineConfig, ProcessExecutor, ViteBuilder, WebRemoteExecutor } from "esbench/host";

export default defineConfig({
    toolchains: [{
        // Build your benchmark code with Vite, require vite installed.
        builders: [new ViteBuilder()],
        executors: [
            // Run suite on Node.
            new ProcessExecutor("node"),

            // Run suite on Bun.
            new ProcessExecutor("bun"),

            // Open the default browser to run benchmark,
            // in my computer it's Firefox.
            {
                name: "Firefox",
                use: new WebRemoteExecutor({ open: {} }),
            },
        ],
    }],
});

Sie können auch eine Laufzeit als Basis festlegen:

import { defineSuite } from "esbench";

export default defineSuite({
    baseline: { type: "Executor", value: "node" },
    setup(scene) {
        const length = 1000;
        const array = Array.from({ length }, (_, i) => i);

        const set = new Set(array);
        const value = array[Math.floor(array.length / 2)];

        scene.bench("Set", () => set.has(value));
        scene.bench("Array", () => array.includes(value));
    },
});

Das Ergebnis:

| No. |  Name | Executor |      time | time.SD | time.ratio |
| --: | ----: | -------: | --------: | ------: | ---------: |
|   0 |   Set |     node |   3.69 ns | 0.03 ns |   baseline |
|   1 |   Set |      bun |   0.00 ns | 0.00 ns |   -100.00% |
|   2 |   Set |  Firefox |   0.00 ns | 0.00 ns |   -100.00% |
|     |       |          |           |         |            |
|   3 | Array |     node | 325.02 ns | 1.00 ns |   baseline |
|   4 | Array |      bun | 324.87 ns | 0.08 ns |     -0.04% |
|   5 | Array |  Firefox | 516.70 ns | 0.75 ns |    +58.98% |
Warnings:
[No.1] Set: The function duration is indistinguishable from the empty function duration.
[No.2] Set: The function duration is indistinguishable from the empty function duration.

Weitere Anwendungsfälle

ESBench kann viel mehr als nur die grundlegende Verwendung:

• Berechnen Sie die Big-O-Zeitkomplexität von Funktionen
• Komprimierungs-/Dekomprimierungszeit und Ausgabegröße von Zlib-Funktionen messen
• Validieren Sie den Rückgabewert vor dem Benchmark
• Benchmark der 3 Bilder von GitHub Action

Abschluss

Wenn Sie es satt haben, Benchmarks in JavaScript zu schreiben, ist ESBench die Bibliothek, auf die Sie gewartet haben.

Das obige ist der detaillierte Inhalt vonESBench: Ein modernes Benchmarking-Tool. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!