From 558d59a4989cae156df9af10e06532c7f1925558 Mon Sep 17 00:00:00 2001 From: fm_li <57042727+Shinnosuke0722@users.noreply.github.com> Date: Tue, 11 Aug 2026 01:01:54 +0800 Subject: [PATCH 1/2] Add benchmark evidence and macOS protocol --- docs/benchmarking-macos.md | 463 +++++++++++++++++++++++ docs/performance-benchmark-2026-08-11.md | 253 +++++++++++++ docs/performance.md | 110 ++++++ website/.vitepress/config.mts | 14 + website/.vitepress/theme/Landing.vue | 39 ++ website/.vitepress/theme/custom.css | 74 +++- website/guide/benchmarking-macos.md | 7 + website/guide/getting-started.md | 2 + website/guide/performance.md | 7 + website/scripts/check-built-site.mjs | 10 + 10 files changed, 978 insertions(+), 1 deletion(-) create mode 100644 docs/benchmarking-macos.md create mode 100644 docs/performance-benchmark-2026-08-11.md create mode 100644 docs/performance.md create mode 100644 website/guide/benchmarking-macos.md create mode 100644 website/guide/performance.md diff --git a/docs/benchmarking-macos.md b/docs/benchmarking-macos.md new file mode 100644 index 0000000..b8f64ef --- /dev/null +++ b/docs/benchmarking-macos.md @@ -0,0 +1,463 @@ +# Run the competitive benchmark on macOS + +Use this protocol to add macOS evidence to the existing Windows comparison. It +is intentionally stricter than timing `--version`: the matrix covers startup, +memory, local-state scaling, project resolution, shell initialization, +concurrency, remote queries, and a controlled installation pipeline. + +Do not merge macOS numbers into the public cross-platform claim until the run +passes the validation and review gates at the end of this guide. + +## 1. Freeze the comparison + +Use the same versions as the Windows run so operating-system differences are +not mixed with release differences: + +| Tool | Version | +|---|---:| +| jm | 1.0.2 | +| jabba | 0.15.0 | +| javm | 0.13.2 | +| mise | 2026.8.3 | + +Run all four as native binaries for the same architecture. Do not compare an +Apple Silicon binary with an x86-64 binary running under Rosetta. + +```sh +uname -m +sysctl -in sysctl.proc_translated 2>/dev/null || true +``` + +Expected architecture values are `arm64` or `x86_64`; the translation check +must be absent or `0`. + +Download official release artifacts into an isolated directory rather than +using package-manager shims. The release pages are the source of truth: + +- [jm 1.0.2](https://github.com/Shinnosuke0722/jm/releases/tag/v1.0.2) +- [jabba 0.15.0](https://github.com/Jabba-Team/jabba/releases/tag/0.15.0) +- [javm 0.13.2](https://github.com/felipebz/javm/releases/tag/v0.13.2) +- [mise 2026.8.3](https://github.com/jdx/mise/releases/tag/v2026.8.3) + +Use these native assets: + +| Architecture | jm | jabba | javm | mise | +|---|---|---|---|---| +| Apple Silicon | `jm-macos-aarch64.tar.gz` | `jabba-0.15.0-darwin-arm64` | `javm-darwin-arm64.tar.gz` | `mise-v2026.8.3-macos-arm64` | +| Intel | `jm-macos-x86_64.tar.gz` | `jabba-0.15.0-darwin-amd64` | `javm-darwin-x86_64.tar.gz` | `mise-v2026.8.3-macos-x64` | + +Verify every artifact against its release SHA-256 before extracting it. Record +the hash of the final executable too: + +```sh +shasum -a 256 downloads/* +shasum -a 256 bin/jm bin/jabba bin/javm bin/mise +file bin/jm bin/jabba bin/javm bin/mise +bin/jm --version +bin/jabba --version +bin/javm --version +bin/mise --version +``` + +Pinned SHA-256 values from those release assets: + +| Architecture | jm | jabba | javm | mise | +|---|---|---|---|---| +| Apple Silicon | `13e72b77b8ed8fcbd655c68351fcc931e5765b2ab72d8bc9710f1a79cb925356` | `6dab7523cfc2eb34eff877df2534c09a652390db9b6c3b9105e9f7b461c4229e` | `fe2f9946c5f23431d617063d9ae3bc3de2670f919443ea6987ae3dc5fc5b25e1` | `e2f25fc3a2fe82f15c33a2c7a2ec4cc0ed09eb9a1edc5cbcfe2f7f9902bfa4af` | +| Intel | `9f19b8280b2596fb36f2ca5350e4234aed361b9747930e61aca5201110b51b86` | `dbc469be6ed31e40a05904f82cc062e87b1fbff0ecb8007a6ce14502457b5c33` | `e1182edfa58f535532b584eb94b253c68f27fec26f72f7012a80c0d003ccac53` | `2bc0c80e8a7a33e545490dcfe73a73f20dfa964e62c237f296b34eff6c55a2d2` | + +Do not copy a digest across architectures. Recheck the release metadata before +the run and record any mismatch instead of silently replacing the pinned +binary. + +## 2. Prepare a quiet machine + +Use a dedicated benchmark directory and a plugged-in Mac. Disable Low Power +Mode, close developer tools and sync-heavy applications, and wait for indexing +or backups to finish. Do not run with `sudo` except where the controlled HTTPS +certificate setup explicitly requires it. + +Record the machine state before testing: + +```sh +mkdir -p results +{ + date -u + sw_vers + uname -a + system_profiler SPHardwareDataType + sysctl -n hw.memsize + sysctl -n hw.ncpu + sysctl -n hw.physicalcpu + sysctl -n hw.logicalcpu + pmset -g batt + pmset -g custom +} > results/machine.txt +``` + +Run a short dry run, then confirm the machine is not thermally constrained: + +```sh +pmset -g therm +``` + +If macOS reports CPU, GPU, or thermal pressure, cool the machine and restart the +whole formal run. Do not keep only the faster half of a throttled run. + +Install the timing tool and record its version: + +```sh +brew install hyperfine +hyperfine --version | tee results/hyperfine-version.txt +python3 --version | tee results/python-version.txt +``` + +## 3. Use isolated state + +Create one benchmark root and keep all tool-owned state below it: + +```sh +export BENCH_ROOT="$PWD/.benchmark-work" +mkdir -p "$BENCH_ROOT"/{bin,fixtures,results,tmp} +export NO_COLOR=1 +export TERM=dumb +export TMPDIR="$BENCH_ROOT/tmp" +``` + +For every tool and fixture size, set independent homes: + +```sh +export JM_HOME="$BENCH_ROOT/fixtures/n100/jm" +export JABBA_HOME="$BENCH_ROOT/fixtures/n100/jabba" +export JAVM_HOME="$BENCH_ROOT/fixtures/n100/javm" +export MISE_DATA_DIR="$BENCH_ROOT/fixtures/n100/mise-data" +export MISE_CONFIG_DIR="$BENCH_ROOT/fixtures/n100/mise-config" +export MISE_CACHE_DIR="$BENCH_ROOT/fixtures/n100/mise-cache" +export MISE_STATE_DIR="$BENCH_ROOT/fixtures/n100/mise-state" +export MISE_NO_AUTO_INSTALL=1 +``` + +Generate equivalent fixture counts of 0, 10, 100, and 1,000. Each fake JDK must +contain an executable `bin/java` file; javm fixtures also need a `release` file +with `JAVA_VERSION`, `JAVA_VENDOR`, and `OS_ARCH`. jm's `registry.json` must +contain the same number of registered installations. mise installations live +under `installs/java/VERSION`, and jabba/javm installations use +`jdk/temurin@VERSION`. + +The following generator creates that layout plus the project-depth fixtures: + +```sh +python3 <<'PY' +import json +import os +import platform +from pathlib import Path + +root = Path(os.environ["BENCH_ROOT"]).resolve() +java_arch = "aarch64" if platform.machine() == "arm64" else "x86_64" + +def write_jdk(path: Path, version: str, release: bool = False) -> None: + binary = path / "bin" / "java" + binary.parent.mkdir(parents=True, exist_ok=True) + binary.write_text("#!/bin/sh\nexit 0\n", encoding="ascii") + binary.chmod(0o755) + if release: + (path / "release").write_text( + f'JAVA_VERSION="{version}"\n' + 'JAVA_VENDOR="Eclipse Adoptium"\n' + f'OS_ARCH="{java_arch}"\n', + encoding="ascii", + ) + +for scale in (0, 10, 100, 1000): + fixture = root / "fixtures" / f"n{scale}" + jm_home = fixture / "jm" + jabba_home = fixture / "jabba" + javm_home = fixture / "javm" + mise_data = fixture / "mise-data" + for path in ( + jm_home, + jabba_home / "jdk", + javm_home / "jdk", + mise_data / "installs" / "java", + fixture / "cwd", + ): + path.mkdir(parents=True, exist_ok=True) + + installations = [] + for index in range(1, scale + 1): + version = f"21.0.{index}" + identifier = f"temurin-{version}" + jm_path = jm_home / "jdks" / identifier + write_jdk(jm_path, version) + installations.append({ + "id": identifier, + "distribution": "temurin", + "java_version": { + "major": 21, + "minor": 0, + "patch": index, + "build": None, + }, + "full_version": version, + "major_version": 21, + "path": str(jm_path), + "installed_at": "2026-08-11T00:00:00Z", + "is_lts": True, + }) + write_jdk(jabba_home / "jdk" / f"temurin@{version}", version) + write_jdk(javm_home / "jdk" / f"temurin@{version}", version, True) + write_jdk(mise_data / "installs" / "java" / version, version) + + (jm_home / "registry.json").write_text( + json.dumps({"format_version": 1, "installations": installations}), + encoding="utf-8", + ) + autodiscover = javm_home / "autodiscover" + autodiscover.mkdir(parents=True, exist_ok=True) + (autodiscover / "config.json").write_text(json.dumps({ + "enabled": True, + "sources": { + "system": False, + "jabba": False, + "gradle": False, + "intellij": False, + "javm": True, + }, + "cache_ttl": 86400000000000, + }), encoding="utf-8") + +current = root / "fixtures" / "n10" / "jm" / "current" +current.symlink_to(root / "fixtures" / "n10" / "jm" / "jdks" / "temurin-21.0.1") + +for depth in (0, 5, 20, 50, 100): + project = root / "fixtures" / "projects" / f"d{depth}" + project.mkdir(parents=True, exist_ok=True) + (project / ".java-version").write_text("21.0.1\n", encoding="ascii") + (project / ".jabbarc").write_text("temurin@21.0.1\n", encoding="ascii") + (project / "mise.toml").write_text('[tools]\njava = "21.0.1"\n', encoding="ascii") + leaf = project + for _ in range(depth): + leaf /= "d" + leaf.mkdir(parents=True, exist_ok=True) + (project / "leaf.txt").write_text(str(leaf), encoding="utf-8") +PY +``` + +Run the generator only inside the disposable benchmark root. If rerunning in +the same directory, delete that exact fixture root first so a previous cache, +symlink, or partial install cannot contaminate the next run. + +Validate every list command before timing it. The number of recognized entries +must equal the requested fixture scale. Save this validation output; a fast +empty result is a failed fixture, not a benchmark win. + +Warm javm's ordinary discovery cache once for its normal-list test. Also keep a +separate first-discovery scenario that deletes only javm's generated discovery +cache before every sample. + +## 4. Measure wall-clock latency + +Use direct binaries and disable Hyperfine's shell so shell startup is not added +to the CLI result. Use five warmups and interleave tools with `--random-order`. +The following example covers `--version`; repeat the pattern for every row in +the matrix below. + +```sh +hyperfine \ + --shell=none \ + --warmup 5 \ + --runs 50 \ + --random-order \ + --export-json results/startup-version.json \ + "$BENCH_ROOT/bin/jm --version" \ + "$BENCH_ROOT/bin/jabba --version" \ + "$BENCH_ROOT/bin/javm --version" \ + "$BENCH_ROOT/bin/mise --version" +``` + +Hyperfine commands that intentionally fail need `--ignore-failure`. Verify their +exit codes separately before the formal run. + +Use these minimum formal sample counts: + +| Scenario | Runs per tool | +|---|---:| +| `--version` | 50 | +| `--help`, invalid command | 40 each | +| local list: 0 and 10 entries | 30 each | +| local list: 100 entries | 20 | +| local list: 1,000 entries | 10 | +| current JDK, resolve JDK home, shell init | 30 each | +| project resolution at each depth | 25 | +| first discovery | 10 | +| eight-process concurrent batches | 12 | +| cold remote query | 5 | +| controlled install | 10 after 1 warmup | + +Report median and P95. Do not rank by the minimum sample. + +## 5. Measure peak resident memory separately + +Do not infer memory from Hyperfine. Run at least ten additional samples per +scenario through macOS `/usr/bin/time -l` and extract `maximum resident set +size`, which is reported in bytes: + +```sh +for run in $(seq 1 10); do + /usr/bin/time -l "$BENCH_ROOT/bin/jm" --version \ + >/dev/null 2>>results/jm-version-memory.txt +done + +grep 'maximum resident set size' results/jm-version-memory.txt +``` + +Calculate the median and P95 in bytes, then convert to MiB by dividing by +1,048,576. Keep timing and memory samples as separate distributions; the +`time` wrapper adds overhead and must not replace direct wall-clock samples. + +Also record binary sizes: + +```sh +stat -f '%N,%z' "$BENCH_ROOT/bin/"{jm,jabba,javm,mise} \ + > results/binary-sizes.csv +``` + +## 6. Run the complete local matrix + +Use the nearest equivalent command for each tool and document differences: + +| Scenario | jm | jabba | javm | mise | +|---|---|---|---|---| +| Startup | `--version`, `--help`, invalid command | same | same | same | +| Local list | `list --no-color` | `ls` | `ls` | `ls --installed java --no-header` | +| Current JDK | `current --no-color` | `current` | `current` | not ranked unless an equivalent PATH-current command is identified | +| Resolve home | `which java --no-color` | `which 21` | `which 21` | `where java@21.0.1` | +| Project resolve | `env --detect --shell --no-color` | `--fd3 /dev/null use` at depth 0 only | same | `hook-env --force --quiet --shell zsh` | +| Shell init | `shell init zsh` | exclude if it writes a profile | `init zsh` | `activate zsh` | + +Create project trees at depths 0, 5, 20, 50, and 100. Put `.java-version`, +`.jabbarc`, and `mise.toml` at the root. Only rank tools at depths they actually +traverse; a tool that reads only the current directory has not completed the +same work. + +For concurrency, start eight 100-entry list processes at the same instant, +wait for all eight, and measure batch completion. Run two warmup batches and 12 +formal batches. Report batch median and `8 / batch_seconds` throughput. + +Capture stdout byte counts for every case. Default list output differs greatly +between tools, so the final report must disclose output volume next to scaling +results. + +## 7. Keep remote queries observational + +Use a brand-new isolated home/cache for every remote sample and rotate tool +order. Query Temurin 21: + +```sh +jm list --remote --distribution temurin --major 21 --no-color +jabba ls-remote 21 --latest major +javm ls-remote 21 --distribution temurin --latest major +mise ls-remote java@temurin-21 +``` + +Record elapsed time, exit code, response lines, and response bytes. Do not call +this a controlled backend benchmark because the tools may use different APIs, +filters, caches, and response models. + +## 8. Run installation through trusted local HTTPS + +Installation needs its own controlled test. Public CDN timings are too noisy, +and javm correctly rejects plain HTTP. + +1. Create a deterministic ZIP containing a top-level JDK directory with + executable `bin/java`, a `release` file, and at least 32 MiB of deterministic + payload data. +2. Use `mkcert` or another local CA to issue a `localhost` certificate trusted + by the macOS System Keychain. Record the certificate fingerprint. +3. Run a local HTTPS service that exposes Foojay-compatible `/packages` and + `/ids/PACKAGE_ID` JSON plus the same ZIP at `/fixture.zip`. +4. Configure jm's `api.disco_api_url` and `JAVM_DISCO_API` to that HTTPS base. + Give jabba the same `zip+https://localhost/.../fixture.zip` URL. +5. Use a fresh destination and tool home for every sample. Run one warmup and + ten randomized formal samples. +6. Measure and report metadata lookup, time to first byte, download, checksum, + extraction, registration/default-link work, total wall time, CPU time, peak + RSS, written bytes, and file count separately where the tool permits it. +7. Validate that every tool extracted the same payload and that `bin/java` + exists. A successful exit without the expected payload is a failed sample. +8. Remove the local CA and certificate from the Keychain after the run, stop + the server, and verify both are gone. + +Do not disable TLS verification or patch a competitor to accept HTTP. If all +three clients cannot trust the same local certificate, mark installation as +inconclusive instead of publishing a ranking. + +The comparable commands are: + +```sh +# jm: config.toml points api.disco_api_url at the mock Foojay service. +JM_HOME="$RUN_ROOT/jm" jm install temurin-21.0.1 --quiet --no-color + +# jabba: the exact same ZIP bypasses vendor discovery but not HTTPS transport. +JABBA_HOME="$RUN_ROOT/jabba" jabba install \ + "21.0.1=zip+https://localhost:PORT/fixture.zip" \ + --output "$RUN_ROOT/jabba-output" + +# javm: the mock Foojay service returns the exact same ZIP and checksum. +JAVM_HOME="$RUN_ROOT/javm" \ +JAVM_DISCO_API="https://localhost:PORT" \ + javm install temurin@21.0.1 --output "$RUN_ROOT/javm-output" +``` + +mise's normal Java backend cannot be assumed to accept that same custom +Foojay fixture. Unless its documented backend can be configured to consume the +identical artifact without patching mise, exclude it from the shared-artifact +ranking. You may run `mise install java@temurin-21.0.1` as a separate native +end-to-end observation, but label it as non-comparable because discovery and +download infrastructure differ. + +For a `mkcert` setup, record the generated CA location and leaf fingerprint, +then use `mkcert -uninstall` after the test. Confirm removal with Keychain +Access or `security find-certificate`; do not leave the benchmark CA trusted. + +## 9. Validate and package the evidence + +Before comparing results: + +- every case must have its expected sample count and exit status; +- fixture validation must show 0, 10, 100, and 1,000 recognized entries; +- no formal result may be silently dropped as an outlier; +- thermal pressure must remain clear; +- tool versions, executable hashes, machine metadata, stdout sizes, raw timing + JSON, and raw memory logs must be present; and +- the benchmark directory must not contain credentials, ordinary user config, + or unrelated shell profiles. + +Create a results archive before cleanup: + +```sh +tar -czf jm-macos-benchmark-results.tar.gz results +shasum -a 256 jm-macos-benchmark-results.tar.gz \ + > jm-macos-benchmark-results.tar.gz.sha256 +``` + +Keep raw machine-readable results outside the production site. Commit only the +reviewed summary and the archive checksum unless the repository deliberately +adopts a benchmark-data directory. + +## 10. Review gates before production + +The macOS evidence is ready to update the public claim only when: + +1. another reviewer can recompute every median and P95 from the raw files; +2. command semantics and output differences are documented; +3. installation uses the same trusted HTTPS service and artifact; +4. Apple Silicon and Intel results are not combined unless both were run; +5. Windows and macOS tables remain labeled separately; and +6. the homepage claim still describes the weakest supported result, not the + strongest isolated number. + +After review, update the [performance evidence page](performance.md), keep the +benchmark date and versions visible, run the documentation checks, and only +then promote the draft claim to production. diff --git a/docs/performance-benchmark-2026-08-11.md b/docs/performance-benchmark-2026-08-11.md new file mode 100644 index 0000000..70d930d --- /dev/null +++ b/docs/performance-benchmark-2026-08-11.md @@ -0,0 +1,253 @@ +# jm 与竞品性能对比报告(Windows) + +测试时间:2026-08-10 至 2026-08-11(Asia/Shanghai)
+被测提交:`5ccc0108ced112915323c3ca6b20d483321b042a`
+结论适用范围:本机 Windows x64、下述版本和测试场景;不能直接外推到 Linux、macOS 或其他版本。 + +## 1. 结论摘要 + +`jm` 在本地高频路径上确实明显更快、更省内存,但不能概括成“所有场景都领先”。 + +- `--version`:`jm` 中位数 **27.721 ms**,比本轮最快竞品 mise 的 48.415 ms 低 **42.7%**(约 **1.75×** 快)。 +- `--help` / 非法命令:`jm` 比各自最快竞品低 **38.8% / 37.9%**。 +- 本地 JDK 列表:0、10、100、1000 个安装项时,`jm` 比各规模下最快竞品分别低 **46.5%、46.2%、44.6%、30.1%**。 +- 启动峰值工作集:`jm --version` 为 **6.52 MiB**,比内存最低竞品 jabba 的 7.70 MiB 低 **15.3%**;比 mise 的 13.59 MiB 低 **52.0%**。 +- 二进制体积:`jm` 为 **3.97 MiB**,比第二小的 jabba 低 **46.6%**。 +- 8 进程并发列出 100 个 JDK:`jm` 达到 **83.17 commands/s**,比第二名 jabba 高 **12.1%**。 +- 冷缓存公网查询不是 `jm` 的领先项:`jm` 中位数 **1.084 s**,比 javm 的 0.942 s 慢 **15.1%**,但快于 mise 和 jabba。此项受上游 API、CDN 和返回量影响,不适合作为核心宣传数字。 +- “内存更低”不是绝对结论:列出 1000 个 JDK 时,`jm` 峰值工作集 **8.79 MiB**,高于 jabba 的 7.93 MiB,但仍低于 javm 和 mise。 + +建议对外使用的严谨表述是: + +> 在本次 Windows x64 基准中,jm 的常用本地命令中位延迟通常比最快竞品低约 30%–46%;`--version` 峰值工作集比内存最低竞品低约 15%。 + +不要表述为“所有操作都快一倍”“内存始终最低”或“安装速度最快”。 + +## 2. 被测对象 + +| 工具 | 版本 | 二进制 SHA-256 | 来源 | +|---|---:|---|---| +| jm | 1.0.2 | `530769ad6165cda36de3bfdc0622c385aa4038e7a6cf0979fbc7d8ccfa9b0ce4` | 当前仓库 release 构建 | +| jabba | 0.15.0 | `8918f09b6632f7e3b3d14a74c9d07af86d589230804b38d09ee1412d29337a71` | [官方 release](https://github.com/Jabba-Team/jabba/releases/tag/0.15.0) | +| javm | 0.13.2 | `2e529d8849001b22e152de4d5f08e96bea63edb9a8ae69bb85063c2ce074b813` | [官方 release](https://github.com/felipebz/javm/releases/tag/v0.13.2) | +| mise | 2026.8.3 | `b09bfe160ffa33236f03547e6e0ef2bd937fcd7556b1feb5c2d227c174ef2a22` | [官方 release](https://github.com/jdx/mise/releases/tag/v2026.8.3) | + +`jm` 使用 `cargo build --release --locked` 构建。所有工具均直接执行原生 release 二进制,没有经过 PowerShell 函数包装。 + +## 3. 测试环境 + +| 项目 | 值 | +|---|---| +| 操作系统 | Microsoft Windows 10 Education 10.0.19045 | +| CPU | Intel Core i7-6700K @ 4.00 GHz | +| CPU 拓扑 | 4 核 / 8 逻辑处理器 | +| 内存 | 16 GiB | +| 电源计划 | 平衡 | +| 终端环境 | PowerShell,子进程 `NO_COLOR=1`、`TERM=dumb` | + +## 4. 方法与统计口径 + +### 4.1 计时与内存 + +- 每个正式样本都创建一个全新的 CLI 进程。 +- 计时范围是进程创建到退出,包含参数解析、读取配置/注册表、格式化和写入已重定向的 stdout/stderr。 +- 使用 Windows `GetProcessMemoryInfo` 读取进程退出时可获得的 `PeakWorkingSetSize` 与 `PeakPagefileUsage`。 +- 表中时间和内存使用中位数;同时保留 P95 用于观察抖动。 +- 核心矩阵每个 case 先预热 5 次,正式样本按随机顺序交错运行,避免某个工具固定占据冷热机顺序。 +- 公网查询每个工具使用全新隔离目录,5 次正式样本采用轮换顺序;因此测到的是冷缓存端到端时间。 + +### 4.2 样本量 + +| 场景 | 正式样本数 | +|---|---:| +| `--version` | 每工具 50 | +| `--help`、非法命令 | 每工具各 40 | +| 本地列表 0 / 10 个 | 每工具各 30 | +| 本地列表 100 个 | 每工具 20 | +| 本地列表 1000 个 | 每工具 10 | +| 当前版本、JDK home、shell init | 每工具各 30 | +| 项目解析每个深度 | 每工具 25 | +| javm 冷发现 1000 个 | 10 | +| 8 进程并发批次 | 每工具 12(每批 8 个命令) | +| 冷缓存公网查询 | 每工具 5 | + +### 4.3 隔离与等价性 + +- `JM_HOME`、`JABBA_HOME`、`JAVM_HOME`、mise 的 data/config/cache/state 目录全部隔离。 +- 本地列表使用等量的合成 JDK 目录;javm 的正常列表使用预热后的 24 小时发现缓存,并额外测试了删除缓存后的首次发现。 +- 输出内容并不完全相同。例如 1000 项列表时,`jm` 中位 stdout 为 162,514 bytes,jabba 为 16,893、javm 为 25,027、mise 为 14,893;因此列表结果应理解为各工具默认用户体验的端到端成本,而不是单位字节吞吐率。 +- mise 是通用多语言版本管理器,功能范围远大于专用 Java 管理器;本报告比较的是用户执行相近命令时的实际开销,不代表相同产品范围下的实现效率。 + +## 5. 核心结果 + +### 5.1 进程启动 + +中位耗时,单位 ms: + +| 工具 | `--version` | `--help` | 非法命令 | +|---|---:|---:|---:| +| **jm** | **27.721** | **28.201** | **28.207** | +| jabba | 49.224 | 49.622 | 49.287 | +| javm | 49.527 | 49.697 | 50.638 | +| mise | 48.415 | 46.110 | 45.417 | + +`--version` 峰值工作集,单位 MiB: + +| 工具 | 中位数 | P95 | +|---|---:|---:| +| **jm** | **6.52** | **6.58** | +| jabba | 7.70 | 7.86 | +| javm | 8.14 | 8.30 | +| mise | 13.59 | 13.86 | + +`jm` 的 P95 启动耗时为 30.662 ms;jabba、javm、mise 分别为 54.596、55.771、53.469 ms,领先不是由少数极快样本造成。 + +### 5.2 本地 JDK 列表扩展性 + +中位耗时,单位 ms: + +| 安装数 | jm | jabba | javm | mise | jm 相对本规模最快竞品 | +|---:|---:|---:|---:|---:|---:| +| 0 | **28.795** | 53.808 | 61.388 | 56.796 | 低 46.5% | +| 10 | **29.038** | 53.987 | 61.029 | 62.147 | 低 46.2% | +| 100 | **29.804** | 53.767 | 63.329 | 108.869 | 低 44.6% | +| 1000 | **40.195** | 57.493 | 85.561 | 569.017 | 低 30.1% | + +峰值工作集,单位 MiB: + +| 安装数 | jm | jabba | javm | mise | +|---:|---:|---:|---:|---:| +| 0 | **6.57** | 7.71 | 8.58 | 15.55 | +| 10 | **6.71** | 7.73 | 8.71 | 16.13 | +| 100 | **6.75** | 7.75 | 9.48 | 16.17 | +| 1000 | 8.79 | **7.93** | 14.13 | 17.67 | + +从 0 增长到 1000 项,`jm` 中位耗时增加 11.400 ms;jabba 增加 3.685 ms、javm 增加 24.173 ms、mise 增加 512.221 ms。jabba 的超大列表内存和增量开销更小,但 `jm` 的绝对完成时间仍更短且默认输出信息更多。 + +### 5.3 当前版本、路径解析与 shell 初始化 + +中位耗时,单位 ms: + +| 场景 | jm | jabba | javm | mise | 说明 | +|---|---:|---:|---:|---:|---| +| 当前激活版本 | **28.780** | 50.704 | 49.266 | — | mise 无完全等价的 PATH 当前值命令 | +| 解析 JDK home | **28.502** | 49.255 | 60.519 | 60.268 | 10 个本地安装 | +| PowerShell shell init | **28.064** | — | 50.222 | 51.847 | jabba 因写入用户 profile 而排除 | + +对应峰值工作集,`jm` 为 6.49–6.52 MiB;jabba 为 7.70–7.73 MiB;javm 为 8.12–8.73 MiB;mise 为 13.86–16.10 MiB。 + +### 5.4 项目目录向上解析 + +只有 `jm` 和 mise 在此处执行可比的父目录向上查找。jabba 和 javm 的项目文件只在当前目录读取,因此仅列深度 0。 + +中位耗时,单位 ms: + +| 子目录深度 | jm | mise | jm 低于 mise | +|---:|---:|---:|---:| +| 0 | **28.993** | 69.633 | 58.4% | +| 5 | **28.779** | 77.265 | 62.8% | +| 20 | **29.516** | 108.218 | 72.7% | +| 50 | **30.516** | 203.020 | 85.0% | + +深度 100 会让本测试目录超过传统 Win32 路径长度限制,进程在启动前即失败,因此正式上限设为 50;这不是任一 CLI 的性能失败。 + +深度 0 时 jabba 为 50.893 ms,javm 为 61.070 ms,但它们没有执行向上遍历,不能用于深层目录排名。 + +### 5.5 javm 首次发现成本 + +1000 个本地 JDK 时: + +| 状态 | 中位耗时 | P95 | 峰值工作集 | +|---|---:|---:|---:| +| javm 已缓存 | 85.561 ms | 95.755 ms | 14.13 MiB | +| javm 删除发现缓存 | 163.820 ms | 193.263 ms | 15.13 MiB | + +这说明 javm 的正常结果明显受发现缓存帮助。核心排名使用其正常缓存路径,并没有故意把首次扫描成本混入每次样本。 + +### 5.6 8 进程并发 + +每批同时启动 8 个“列出 100 个本地 JDK”命令: + +| 工具 | 批次中位耗时 | 中位吞吐量 | +|---|---:|---:| +| **jm** | **92.629 ms** | **83.17 commands/s** | +| jabba | 107.849 ms | 74.16 commands/s | +| javm | 124.328 ms | 63.42 commands/s | +| mise | 212.124 ms | 37.21 commands/s | + +## 6. 公网远程查询(观测项) + +查询 Temurin Java 21,每轮使用全新工具 home/cache: + +| 工具 | 样本 | 中位耗时 | P95 | 返回行数 | 返回 bytes | +|---|---:|---:|---:|---:|---:| +| **javm** | 5 | **942.303 ms** | 1,039.728 ms | 2 | 111 | +| jm | 5 | 1,084.221 ms | 1,132.997 ms | 5 | 509 | +| mise | 5 | 2,032.968 ms | 2,092.430 ms | 13 | 308 | +| jabba | 5 | 2,446.847 ms | 2,546.136 ms | 1 | 8 | + +命令分别为: + +- `jm list --remote --distribution temurin --major 21 --no-color` +- `jabba ls-remote 21 --latest major` +- `javm ls-remote 21 --distribution temurin --latest major` +- `mise ls-remote java@temurin-21` + +该结果不能解释 CLI 本体性能:各工具请求的上游、缓存策略、响应内容和输出量不同,而且网络状态会随时间变化。它只能回答“本次机器上用户实际等到结果要多久”。 + +## 7. 安装测试:为何没有给出排名 + +本轮尝试了两种安装基准,但都没有形成可以诚实排名的完整样本: + +1. **本地 HTTP、同一 32 MiB 合成 JDK ZIP**:jm 和 jabba可以使用;javm 明确拒绝非 HTTPS 下载。这是合理的安全策略差异,不应通过修改竞品二进制绕过。 +2. **固定 Temurin 21.0.12 官方 Windows ZIP(205,069,442 bytes)**:三者使用同一 HTTPS 资产,计划为 1 次预热 + 3 次正式。运行至第二轮时,GitHub release CDN 对 jabba 出现 TLS handshake timeout,整组样本不完整。失败资产来自 [Adoptium 官方发布文件](https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.12%2B8/OpenJDK21U-jdk_x64_windows_hotspot_21.0.12_8.zip)。 +3. **本地 HTTPS**:测试证书无法在全自动、无交互条件下让三种 TLS 栈一致信任。没有通过关闭证书校验或修改竞品来“制造”数字。 + +因此本报告不宣称 `jm` 的下载、校验、解压或安装速度快于竞品。要得到有效排名,应在 CI 或专用测试机上部署受三种客户端共同信任的 HTTPS 服务,固定带宽、延迟、证书链和归档,再执行至少 10 次轮换样本。安装时还应分别报告:元数据查询、首字节、下载、checksum、解压、注册和默认版本切换。 + +## 8. 二进制体积 + +| 工具 | 体积 | +|---|---:| +| **jm** | **3.97 MiB** | +| jabba | 7.43 MiB | +| javm | 7.86 MiB | +| mise | 136.61 MiB | + +mise 的大体积与其通用工具管理器范围有关,不能单独解释为实现低效。 + +## 9. 为什么 jm 会快这么多 + +从数据看,优势主要来自“固定启动成本小”和“热路径直接”,而不是简单归因于 Rust:mise 同样是原生 Rust 程序,但范围、插件/后端和配置能力更广。 + +可以从结果支持以下判断: + +1. **基础启动成本低**:`--version`、`--help`、非法命令和空列表都稳定在约 28–29 ms,说明大量优势在进入具体业务前已经形成。 +2. **专用 Java 范围**:jm 不需要启动通用多语言后端、插件发现和更复杂的配置模型。与 mise 的深目录差距随深度扩大,也符合配置发现路径更轻的表现。 +3. **注册表直读**:jm 的正常本地列表读取自己的安装注册表;javm 首次目录发现比缓存路径多约 78 ms,证明目录发现/校验是可观成本。 +4. **小二进制和小工作集**:3.97 MiB 二进制、约 6.5 MiB 启动峰值工作集,通常意味着需要映射和初始化的代码/数据更少。 +5. **格式化成本控制较好**:1000 项时 jm 输出约为 jabba 的 9.6 倍,但仍先完成;因此领先不只是“输出更少”。 + +这些是由测量现象支持的工程解释,不是逐函数的因果证明。若要精确分解,应补做 ETW/WPA 启动跟踪、CPU flamegraph、磁盘 I/O 和逐阶段内部埋点。 + +## 10. 测试过程中发现的兼容性与副作用 + +- jabba 0.15.0 的 `init` 会修改 Windows PowerShell profile;因此没有把它与只输出脚本的 `jm shell init powershell`、`mise activate pwsh`直接混排。测试产生的 profile 内容已删除,并确认测试前该 profile 不存在。 +- javm `init pwsh` 会在临时目录生成脚本;测试时 TEMP/TMP 已隔离。 +- 手工构造带 UTF-8 BOM 的 `registry.json` 会被 jm 1.0.2 拒绝。正式 fixture 改为无 BOM JSON 后运行;建议后续决定是明确记录该格式要求,还是让解析器容忍 BOM。 +- jabba/javm 的链接式 fixture 在当前 Windows 权限下不能创建符号链接,因此使用真实目录;jm 的全局 current 使用目录 junction。 +- 本地 HTTPS 尝试临时创建的 `localhost` 测试证书已从 `CurrentUser\My` 和 `CurrentUser\Root` 两处删除并复核不存在。 + +## 11. 覆盖范围与未覆盖项 + +本报告覆盖:进程启动、帮助/错误路径、本地列表扩展性、首次发现缓存、当前版本、JDK home、项目解析、shell init、并发、本地峰值内存、二进制体积和公网远程查询。 + +未形成有效排名的项目:安装/下载/解压。未测试:真实 JDK 启动性能(它属于 JDK 而非管理器)、长期驻留内存、Linux/macOS、杀毒软件开关差异、低配/高配机器、更新/卸载写操作、代理环境和离线失败恢复。 + +一次 `--version` 只能说明固定启动成本,不能替代上述完整矩阵。本轮结果也表明:`jm` 在启动上领先,但公网远程查询并非第一,1000 项列表的最低内存也不是第一。 + +## 12. 清理与可复核性 + +按测试要求,原始 CSV、fixture、竞品二进制、源码克隆、下载归档、临时脚本、服务器目录、证书和进程均不作为仓库成果保留,只留下本报告。仓库原有 README 和 `.github/assets/` 工作区改动不属于本测试,未作修改。 + +由于原始样本被要求删除,本报告保留了版本、SHA-256、环境、样本量、命令映射、统计口径、中位数/P95 和关键限制,但无法从仓库内重新计算原始分布。若该报告用于正式官网宣传,建议在可公开的 CI 基准项目中复跑并长期保存机器可读结果。 diff --git a/docs/performance.md b/docs/performance.md new file mode 100644 index 0000000..7c6d821 --- /dev/null +++ b/docs/performance.md @@ -0,0 +1,110 @@ +# jm performance: Windows benchmark evidence + +`jm` is designed to keep common local JDK-management paths small and direct. A +Windows x64 comparison measured process startup, peak working set, local JDK +listing, project resolution, shell initialization, concurrency, binary size, +and cold remote queries against jabba, javm, and mise. + +## What the benchmark supports + +On the tested Windows x64 machine: + +- common local commands completed with **30% to 46% lower median latency** than + the fastest competitor in each matching scenario; +- `jm --version` completed in **27.721 ms**, 42.7% below the fastest competing + result of 48.415 ms; +- `jm --version` used a **6.52 MiB peak working set**, 15.3% below the + lowest-memory competing result of 7.70 MiB; and +- the release build measured **3.97 MiB**, 46.6% smaller than the next-smallest + binary in the comparison. + +These claims apply to the measured Windows x64 environment and tool versions. +They do not claim that jm wins every command, operating system, or workload. + +## Startup latency and memory + +Median wall-clock time and peak working set for a new `--version` process: + +| Tool | Version | Median time | P95 time | Peak working set | +|---|---:|---:|---:|---:| +| **jm** | 1.0.2 | **27.721 ms** | **30.662 ms** | **6.52 MiB** | +| mise | 2026.8.3 | 48.415 ms | 53.469 ms | 13.59 MiB | +| jabba | 0.15.0 | 49.224 ms | 54.596 ms | 7.70 MiB | +| javm | 0.13.2 | 49.527 ms | 55.771 ms | 8.14 MiB | + +The same ordering held for `--help` and an invalid command. `jm` measured +28.201 ms and 28.207 ms respectively, 38.8% and 37.9% below the fastest +competing result for each scenario. + +## Local list scaling + +Median time to list isolated local JDK fixtures: + +| Installed JDKs | jm | jabba | javm | mise | jm versus fastest competitor | +|---:|---:|---:|---:|---:|---:| +| 0 | **28.795 ms** | 53.808 ms | 61.388 ms | 56.796 ms | 46.5% lower | +| 10 | **29.038 ms** | 53.987 ms | 61.029 ms | 62.147 ms | 46.2% lower | +| 100 | **29.804 ms** | 53.767 ms | 63.329 ms | 108.869 ms | 44.6% lower | +| 1,000 | **40.195 ms** | 57.493 ms | 85.561 ms | 569.017 ms | 30.1% lower | + +At 1,000 entries, jabba used less peak working-set memory than jm: 7.93 MiB +versus 8.79 MiB. That is why the evidence supports a lower startup-memory +claim, not an "always lowest memory" claim. + +## Other local paths + +| Scenario | jm | Next-fastest comparable result | +|---|---:|---:| +| Current active JDK | **28.780 ms** | javm, 49.266 ms | +| Resolve JDK home | **28.502 ms** | jabba, 49.255 ms | +| Generate shell initialization | **28.064 ms** | javm, 50.222 ms | +| Eight concurrent 100-entry list commands | **83.17 commands/s** | jabba, 74.16 commands/s | + +For parent-directory project detection, jm moved from 28.993 ms at the project +root to 30.516 ms at depth 50. The comparable mise results were 69.633 ms and +203.020 ms. jabba and javm only read their project file in the current +directory, so they were not ranked for parent traversal. + +## Where jm did not lead + +Cold, isolated remote Temurin 21 queries were an observational network test, +not a measure of CLI startup alone: + +| Tool | Median time | Returned bytes | +|---|---:|---:| +| **javm** | **942.303 ms** | 111 | +| jm | 1,084.221 ms | 509 | +| mise | 2,032.968 ms | 308 | +| jabba | 2,446.847 ms | 8 | + +The upstream APIs, response sizes, and formatting differ, so this result must +not be presented as a controlled backend benchmark. + +The Windows run also did not produce a valid installation ranking. A shared +public JDK download was interrupted by a CDN TLS timeout, while a local HTTP +fixture was rejected by javm's HTTPS-only download policy. No security check or +competitor binary was modified to manufacture a result. + +## Method and limits + +- Platform: Windows 10 x64, Intel Core i7-6700K, 16 GiB RAM, balanced power plan. +- Build under test: commit `5ccc0108ced112915323c3ca6b20d483321b042a`. +- Every formal timing sample created a new process and captured redirected + output as part of the measured command. +- Core cases used five warmups followed by randomized, interleaved formal runs. +- `--version` used 50 formal samples per tool. Other local cases used 10 to 40 + samples according to cost; network queries used five fresh-cache samples. +- Peak working set came from Windows `GetProcessMemoryInfo`. +- Tool homes, caches, configuration, and local JDK fixtures were isolated. +- Default outputs are not identical. The benchmark measures the real default + command experience, not normalized work per output byte. +- mise is a broader, multi-language tool; its results show end-user command + cost, not equal-scope implementation efficiency. + +The complete Chinese-language audit contains all tables, hashes, sample counts, +side effects, and interpretation limits: +[Windows benchmark report](https://github.com/Shinnosuke0722/jm/blob/main/docs/performance-benchmark-2026-08-11.md). + +To add macOS evidence before treating these results as cross-platform, follow +the [macOS competitive benchmark protocol](benchmarking-macos.md). Keep the +Windows and macOS results separate until both data sets pass the same review. diff --git a/website/.vitepress/config.mts b/website/.vitepress/config.mts index 2b319f7..71b832e 100644 --- a/website/.vitepress/config.mts +++ b/website/.vitepress/config.mts @@ -103,6 +103,7 @@ export default defineConfig({ { text: 'Windows', link: '/guide/windows.html' }, { text: 'Project switching', link: '/guide/project-switching.html' }, { text: 'JDK distributions', link: '/guide/jdk-distributions.html' }, + { text: 'Performance', link: '/guide/performance.html' }, { text: 'SDKMAN migration', link: '/guide/sdkman-migration.html' }, { text: 'GitHub', link: repositoryUrl }, ], @@ -130,6 +131,19 @@ export default defineConfig({ }, ], }, + { + text: 'Performance evidence', + items: [ + { + text: 'Windows benchmark results', + link: '/guide/performance.html', + }, + { + text: 'Reproduce on macOS', + link: '/guide/benchmarking-macos.html', + }, + ], + }, ], }, search: { diff --git a/website/.vitepress/theme/Landing.vue b/website/.vitepress/theme/Landing.vue index 325d6fd..9c2946e 100644 --- a/website/.vitepress/theme/Landing.vue +++ b/website/.vitepress/theme/Landing.vue @@ -105,6 +105,45 @@ async function copyInstallCommand() { +
+
+
+
+ +

Fast paths, with the evidence attached.

+
+

+ In the published Windows benchmark, jm's common local commands recorded 30% to 46% + lower median latency than the fastest competitor in each matching scenario. Results + are versioned, scoped to the test machine, and explicit about where jm did not lead. +

+
+ +
+
+
27.721 ms
+
jm --version median
+
+
+
6.52 MiB
+
jm --version peak working set
+
+
+
83.17 cmd/s
+
eight-process local-list throughput
+
+
+ + +

+ Windows 10 x64, jm 1.0.2, August 2026. This is not an all-platform or all-command claim. +

+
+
+
diff --git a/website/.vitepress/theme/custom.css b/website/.vitepress/theme/custom.css index 0702505..6ec7ff1 100644 --- a/website/.vitepress/theme/custom.css +++ b/website/.vitepress/theme/custom.css @@ -266,7 +266,7 @@ code, kbd, samp, pre { letter-spacing: -0.03em; } .jm-terminal code { color: #aebbd0; font-size: 11px; } .jm-terminal em, .jm-terminal b { margin-right: 8px; color: var(--jm-mint); font-style: normal; } -.jm-install, .jm-paths, .jm-distributions { padding: clamp(76px, 9vw, 120px) 0; } +.jm-install, .jm-performance, .jm-paths, .jm-distributions { padding: clamp(76px, 9vw, 120px) 0; } .jm-install { border-bottom: 1px solid var(--jm-line); background: #e9eff7; } .jm-install__layout { display: grid; @@ -319,6 +319,76 @@ code, kbd, samp, pre { letter-spacing: -0.03em; } } .jm-command > a:hover { color: var(--jm-white); } +.jm-performance { + color: var(--jm-white); + background: + linear-gradient(120deg, rgba(47, 91, 255, 0.17), transparent 48%), + #17243a; +} +.jm-performance__intro { + display: grid; + grid-template-columns: 1.1fr 0.9fr; + gap: clamp(42px, 8vw, 110px); + align-items: end; +} +.jm-performance h2 { + max-width: 720px; + margin: 0; + color: var(--jm-white); + font-size: clamp(2.35rem, 4.8vw, 4.7rem); + font-weight: 720; + line-height: 0.96; + letter-spacing: -0.065em; +} +.jm-performance__intro > p { + margin: 0; + color: #b6c3d7; + font-size: 15px; + line-height: 1.75; +} +.jm-metrics { + display: grid; + grid-template-columns: repeat(3, 1fr); + margin: 58px 0 0; + border-top: 1px solid rgba(255, 255, 255, 0.16); + border-left: 1px solid rgba(255, 255, 255, 0.16); +} +.jm-metrics > div { + min-width: 0; + padding: clamp(24px, 4vw, 38px); + border-right: 1px solid rgba(255, 255, 255, 0.16); + border-bottom: 1px solid rgba(255, 255, 255, 0.16); +} +.jm-metrics dt { + color: var(--jm-white); + font-family: var(--vp-font-family-mono); + font-size: clamp(1.85rem, 4vw, 3.65rem); + font-weight: 680; + letter-spacing: -0.07em; +} +.jm-metrics dt span { + color: var(--jm-amber); + font-size: 0.28em; + letter-spacing: 0.02em; + text-transform: uppercase; +} +.jm-metrics dd { + margin: 14px 0 0; + color: #91a2bb; + font-size: 12px; + line-height: 1.55; +} +.jm-metrics code { color: #cbd6e6; } +.jm-performance__actions { display: flex; flex-wrap: wrap; gap: 12px 28px; margin-top: 30px; } +.jm-performance__actions a { + color: var(--jm-amber); + font-family: var(--vp-font-family-mono); + font-size: 12px; + text-decoration: none; +} +.jm-performance__actions a:hover { color: var(--jm-white); } +.jm-performance__note { margin: 18px 0 0; color: #778ba8; font-size: 11px; } + .jm-section-head { display: grid; grid-template-columns: 1.25fr 0.75fr; @@ -423,6 +493,7 @@ code, kbd, samp, pre { letter-spacing: -0.03em; } .jm-hero__copy { max-width: 720px; } .jm-resolver { max-width: 680px; } .jm-section-head { grid-template-columns: 1fr; gap: 24px; } + .jm-performance__intro { grid-template-columns: 1fr; gap: 24px; } } @media (max-width: 680px) { @@ -441,6 +512,7 @@ code, kbd, samp, pre { letter-spacing: -0.03em; } .jm-doc-link--wide { grid-column: auto; } .jm-doc-link { grid-template-columns: 48px 1fr auto; gap: 14px; min-height: 190px; padding: 24px 20px; } .jm-command > code { padding-inline: 15px; } + .jm-metrics { grid-template-columns: 1fr; } } @media (prefers-reduced-motion: reduce) { diff --git a/website/guide/benchmarking-macos.md b/website/guide/benchmarking-macos.md new file mode 100644 index 0000000..7c90920 --- /dev/null +++ b/website/guide/benchmarking-macos.md @@ -0,0 +1,7 @@ +--- +title: Run the competitive benchmark on macOS +description: Reproduce the full jm, jabba, javm, and mise performance matrix on macOS with isolated state, peak RSS, scaling, concurrency, remote, and trusted-HTTPS install tests. +lastUpdated: false +--- + + diff --git a/website/guide/getting-started.md b/website/guide/getting-started.md index f338a0c..c67b54e 100644 --- a/website/guide/getting-started.md +++ b/website/guide/getting-started.md @@ -167,3 +167,5 @@ the same Java requirement. - Configure [Windows and PowerShell](windows.md). - Manage [Temurin, Corretto, and GraalVM](jdk-distributions.md) side by side. - Move an existing Java entry with the [SDKMAN migration guide](sdkman-migration.md). +- Review the measured [performance evidence](performance.md) and its limits. +- Reproduce the comparison with the [macOS benchmark protocol](benchmarking-macos.md). diff --git a/website/guide/performance.md b/website/guide/performance.md new file mode 100644 index 0000000..6108e97 --- /dev/null +++ b/website/guide/performance.md @@ -0,0 +1,7 @@ +--- +title: "jm performance: Windows benchmark evidence" +description: Review measured jm startup time, peak memory, local JDK scaling, concurrency, limitations, and the exact Windows evidence behind the published claims. +lastUpdated: false +--- + + diff --git a/website/scripts/check-built-site.mjs b/website/scripts/check-built-site.mjs index 3a88d2f..6932fbd 100644 --- a/website/scripts/check-built-site.mjs +++ b/website/scripts/check-built-site.mjs @@ -9,6 +9,8 @@ const pages = [ ['guide/windows.html', `${siteUrl}guide/windows.html`], ['guide/project-switching.html', `${siteUrl}guide/project-switching.html`], ['guide/jdk-distributions.html', `${siteUrl}guide/jdk-distributions.html`], + ['guide/performance.html', `${siteUrl}guide/performance.html`], + ['guide/benchmarking-macos.html', `${siteUrl}guide/benchmarking-macos.html`], ['guide/sdkman-migration.html', `${siteUrl}guide/sdkman-migration.html`], ] @@ -39,6 +41,10 @@ requireText(home, '

Java Manager.', 'index.html') requireText(home, '