---
title: "マイクロベンチマークとは？正しい測り方と落とし穴をJMH・Go 1.27の実測で解説"
url: "https://www.issoh.co.jp/tech/details/8711/"
published: 2025-09-08
updated: 2026-11-07
categories: ["テスト"]
publisher: "株式会社一創"
---

# マイクロベンチマークとは？正しい測り方と落とし穴をJMH・Go 1.27の実測で解説

マイクロベンチマークは、関数1つ・ループ1つといった小さなコード片の実行時間を繰り返し測る手法です。手軽に書ける反面、何も工夫せずに書くと「計算そのものが消えた空ループ」や「JITコンパイル前の遅い状態」、「キャッシュに載りきった理想的な状態」を測ってしまい、桁違いの数字が出ます。

本記事では、JMH 1.37とGo 1.27.2で実際に計測した数値を使って、結果を歪める原因と対策、差を統計で判定する手順、言語別ツールの選び方を説明します。計測環境はIntel Core i9-9880H（L1データキャッシュ32KB・L2 256KB・L3 16MB）搭載のmacOS機で、数値はこの環境のものです。

## まとめ：マイクロベンチマークの要点

- 対象は関数単位の短いコードで、問いは「AとBのどちらが速いか」です。システム全体の処理能力を見る負荷テストとは役割が違います。
- 結果を捨てるベンチマークは、コンパイラに計算を消されます。JMHでは1,000要素の総和が2.25ns/opと表示され、戻り値を返す版（142ns/op）の約60分の1でした。
- JVMやV8のようなJIT環境では、最初の数回は遅い状態を測ります。手書き計測では1ラウンド目が約1万5,000ns、3ラウンド目以降は約190nsでした。
- 同じ入力を繰り返すと、キャッシュと分岐予測が本番より効きます。同じ値をソート済みで渡すとシャッフル済みの約6.4倍速く、作業領域を16KBから64MBに広げると1アクセスが約51倍遅くなりました。
- 差の有無は平均値1回の比較で決めず、複数回の実行結果を検定にかけます。Goでは benchstat が中央値とMann-Whitney U検定で判定します。
- 計測は自前のループより、言語ごとのハーネス（JMH・BenchmarkDotNet・Google Benchmark・testing.B・criterion・pyperf・Jetpack Microbenchmark）に任せます。

## マイクロベンチマークの定義と負荷テスト・プロファイリングとの違い

マイクロベンチマーク（microbenchmark）は、計測対象を数行から数十行のコードに絞り、同じ処理を数百万回単位で繰り返して1回あたりの時間やメモリ割り当て量を出します。「文字列連結を `+` と `strings.Builder` のどちらで書くか」「HashMapとTreeMapのどちらで引くか」といった実装判断の根拠に使います。

「ベンチマーク」の元の意味は比較の基準点です。ビジネスでは自社の業績や業務手順を他社の優れた例と比べる手法を指し、ハードウェアの分野ではCPUやスマートフォンの総合性能を点数化する測定（AnTuTuやGeekbenchなど）を指します。本記事が扱うのは、ソフトウェア開発で書くコード単位の計測です。

| 手法         | 対象       | 答える問い          | 代表ツール                |
| ---------- | -------- | -------------- | -------------------- |
| マイクロベンチマーク | 関数・ループ   | 実装AとBのどちらが速いか  | JMH、testing.B        |
| マクロベンチマーク  | アプリやDB全体 | 代表的な処理全体の所要時間  | TPC系、自作シナリオ          |
| 負荷テスト      | 稼働中のシステム | 何リクエスト毎秒まで耐えるか | k6、Locust、JMeter     |
| プロファイリング   | 実行中のプロセス | どこで時間を使っているか   | pprof、async-profiler |

実務で効く順序は「プロファイリングで遅い箇所を特定する → その箇所だけをマイクロベンチマークで比べる → 負荷テストで全体への効果を確かめる」です。本番環境で常時プロファイルを取る方法は[継続的プロファイリングの仕組み](/tech/details/15709/)で、リクエスト単位の性能は[k6による負荷テスト](/tech/details/7581/)や[Locustの負荷試験](/tech/details/10870/)で扱っています。

## 結果を歪める原因と実測で見る影響

手書きのマイクロベンチマークが外れる原因は、コンパイラ最適化、JITのウォームアップ、本番と違うキャッシュと分岐予測の状態、計測ノイズの4系統です。影響の大きさを実測値で示します。

### デッドコード除去による計算の消失と結果の消費

コンパイラは、結果がどこからも参照されない計算を「実行しなくても挙動が変わらない」と判断して削除します。JMH 1.37で、1,000要素の配列を走査して総和を出す処理を3通りに書いて比べました（2026年10月2日計測、Temurin 25.0.4.1、ウォームアップ1秒×3回、測定1秒×5回、フォーク2回）。以下はベンチマークメソッドの抜粋です。計測モードは `@BenchmarkMode(Mode.AverageTime)`、出力単位は `@OutputTimeUnit(TimeUnit.NANOSECONDS)` とし、クラスには `@State(Scope.Benchmark)` を付け、`@Setup` メソッドで `int[] data` に0〜999を入れています。

```
@Benchmark
public void sumDiscard() {        // 結果を捨てる
    int s = 0;
    for (int v : data) s += v * 31;
}

@Benchmark
public int sumReturn() {          // 戻り値はJMHが消費する
    int s = 0;
    for (int v : data) s += v * 31;
    return s;
}

@Benchmark
public void sumBlackhole(Blackhole bh) {
    int s = 0;
    for (int v : data) s += v * 31;
    bh.consume(s);                // 複数の値を逃がすときはBlackhole
}
```

| 書き方                        | 結果（ns/op）        |
| -------------------------- | ---------------- |
| sumDiscard（結果を捨てる）         | 2.253 ± 0.066    |
| sumReturn（戻り値を返す）          | 142.407 ± 17.545 |
| sumBlackhole（Blackholeへ渡す） | 145.982 ± 7.221  |

1,000回の乗算と加算が2.25ナノ秒で終わることはありません。sumDiscardはループごと消え、ほぼ空のメソッド呼び出しを測っています。JMHのBlackholeは[ソースコードのコメント](https://github.com/openjdk/jmh/blob/master/jmh-core/src/main/java/org/openjdk/jmh/infra/Blackhole.java)で「値を消費し、その値を生む計算のデッドコード除去を防ぐ」仕組みと説明されています。JDK 25上のJMH 1.37は起動時に `Blackhole mode: compiler (auto-detected)` と表示し、JVM側の仕組みで値を逃がす方式を自動で選びました。

Goでも同じことが起きます。Go 1.27.2で、インライン展開される小さなハッシュ関数を `b.N` ループで呼び、結果を捨てた版は0.66〜0.75ns/opでした。`go tool objdump` で確認すると、ループ本体には乗算命令（IMUL）が1つも残らず、カウンタを増やして比較する3命令（INCQ・CMPQ・JG）だけになっていました。結果をパッケージ変数に代入した版は約2.2ns/op、Go 1.24で追加された `b.Loop` を使った版は約4.1ns/opです。

```
func mix(x uint64) uint64 {
    x ^= x >> 33
    x *= 0xff51afd7ed558ccd
    x ^= x >> 33
    return x
}

// Go 1.24以降の書き方
func BenchmarkMix(b *testing.B) {
    x := uint64(12345)          // ループ前の準備は計測されない
    for b.Loop() {
        mix(x)                  // 引数と戻り値が生存扱いになる
    }
}
```

[testing.B.Loopのドキュメント](https://pkg.go.dev/testing#B.Loop)によると、`for b.Loop() { ... }` の波括弧内にある関数呼び出しの引数と戻り値は生存状態に保たれ、ループ本体が最適化で消えなくなります。初回呼び出しでタイマーをリセットするため、ループ前の準備処理も計測に混ざりません。ただしこの扱いはループ条件を `b.Loop()` と書いたときだけ有効です。Go 1.24以降が前提のコードなら、`b.N` のループより `b.Loop` を選びます。

### JITウォームアップ前後の実行時間の差

JavaやJavaScriptの実行環境は、最初はインタプリタで実行し、何度も呼ばれたコードを機械語にコンパイルし直します（仕組みは[JVMのJITとメモリの解説](/tech/details/7151/)を参照）。JMHを使わずに `System.nanoTime()` で同じ処理（1,000要素の走査）を2,000回ずつ10ラウンド計測すると、次のように推移しました。

| ラウンド            | 1回あたり（3回実行の範囲）  |
| --------------- | --------------- |
| 1ラウンド目          | 13,195〜15,166ns |
| 2ラウンド目          | 194〜4,316ns     |
| 3ラウンド目以降        | 155〜194ns       |
| 参考：-Xint（JITなし） | 約46,000ns       |

1ラウンド目は定常状態の約70〜80倍遅く、2ラウンド目は実行ごとに20倍以上ぶれました。最初の1回だけを測った比較には、JITコンパイルの進行やキャッシュなどの初期状態が混ざるため、定常状態の性能差とは区別する必要があります。JMHの既定値（[Defaults.java](https://github.com/openjdk/jmh/blob/master/jmh-core/src/main/java/org/openjdk/jmh/runner/Defaults.java)）はウォームアップ5回・各10秒、測定用のJVMフォーク5回で、ウォームアップの結果は集計から外します。既定のままでは1メソッドの計測に数分かかるため、上の計測のように注釈で短くしても構いません。ただし定常状態の性能を比べるなら、ウォームアップは省きません。初回実行のコストを測る場合は例外で、JMHのSingleShotTimeモードは既定のウォームアップが0回です。

フォークを分ける理由もあります。同じJVMで複数のベンチマークを続けて実行すると、先に走ったコードのプロファイルが後のコードのコンパイルに影響します。JMHが既定でベンチマークごとにJVMを起動し直すのはこのためです。

### 同じ入力の繰り返しで効きすぎるキャッシュと分岐予測

マイクロベンチマークは同じデータを何百万回も処理するので、データはCPUキャッシュに載ったままになり、条件分岐の向きもCPUに覚えられます。本番では他の処理がキャッシュを奪い合い、入力も毎回変わります。[AndroidのMicrobenchmark解説](https://developer.android.com/topic/performance/benchmarking/microbenchmark-overview?hl=ja)も「キャッシュのみを測定しないように」と注意し、ループごとに異なるパラメータを渡すよう勧めています。Go 1.27.2で、この影響を2通りに測りました（各5回の中央値）。測定中は同じ機械で他の処理も動いていたため、以下の倍率にはその揺れも含まれます。

```
// 分岐予測：0〜255の値65,536個を、ソート済みとシャッフル済みで渡す
func countBig(data []int32) int {
    n := 0
    for _, v := range data {
        if v >= 128 {
            n += int(v) & 7
            n++
        }
    }
    return n
}

// キャッシュ：大きさだけ違う配列を、ランダムな順に65,536回たどる
func chase(p []uint32, steps int) uint32 {
    x := uint32(0)
    for i := 0; i < steps; i++ {
        x = p[x]                // 次に読む位置が前の値で決まる
    }
    return x
}
```

| 条件               | 結果           |
| ---------------- | ------------ |
| countBig・ソート済み   | 101.7µs/op   |
| countBig・シャッフル済み | 651.7µs/op   |
| chase・作業領域16KB   | 3.8ns/アクセス   |
| chase・作業領域256KB  | 12.1ns/アクセス  |
| chase・作業領域4MB    | 74.4ns/アクセス  |
| chase・作業領域64MB   | 191.3ns/アクセス |

countBigは中身が同じ値の集まりでも、並び順だけで約6.4倍の差が出ました。ソート済みでは `v >= 128` の結果が前半はずっと偽、後半はずっと真になるため、分岐予測がほぼ外れません。chaseは命令列が同じでも、作業領域がL1データキャッシュ（32KB）に収まる16KBと、L3（16MB）を超える64MBで1アクセスの時間が約51倍違います。

Googleの性能チームによる記事[「Beware microbenchmarks bearing gifts」](https://abseil.io/fast/39)も、マイクロベンチマークの作業領域は小さくキャッシュに常駐しやすいが、実際のコードはそうではないと指摘しています。対策は、入力を本番のデータ分布から作ること、件数を本番の規模に合わせること、複数の大きさで測って傾きを見ることです。小さな入力1種類だけで「Aの方が速い」と結論しないでください。

### CPUクロックの変動と計測ノイズの抑え方

同じコードを同じ機械で測っても値は揺れます。Pythonの `timeit.repeat` で1,000要素のソートを1,000回ずつ7セット測ると、1回あたり207.2〜231.8マイクロ秒に散らばりました（最小207.2・中央値212.4・平均216.8・標準偏差10.3）。[Pythonの公式ドキュメント](https://docs.python.org/3/library/timeit.html)は、他のプロセスの割り込みで値は遅い方にしかずれないため、平均や標準偏差より `min()` を見るべきだと書いています。

CPUのクロック変動は、計測値が揺れる原因の一つです。Intel CPUのTurbo Boostは、動いているコア数や温度に応じて周波数を上げ下げします。Linuxでは [pyperfのsystemコマンド](https://pyperf.readthedocs.io/en/latest/system.html)の `tune` が、CPUの周波数制御（scaling governor）を `performance` に固定し、Turbo Boostも制御します。Androidの[Jetpack Microbenchmark](https://developer.android.com/topic/performance/benchmarking/microbenchmark-overview?hl=ja)は、root権限のある端末なら `gradlew lockClocks` でクロックを固定でき、対応端末では `Window.setSustainedPerformanceMode()` で最大周波数を抑えます。どちらも使えない端末では、温度上昇による性能低下を検出すると実行を一時停止し、冷えてから再試行します。

```
$ python3 -m pyperf system show    # 現在の設定を確認する
$ sudo python3 -m pyperf system tune   # 計測前に周波数制御などを固定する
$ sudo python3 -m pyperf system reset  # 計測後に既定の状態へ戻す
```

クロック以外の揺れの原因は、他プロセスとのCPU共有、ガベージコレクション、メモリ配置の違いです。ノートPCで電源接続を切り替えただけで結果が変わることもあるため、比較する2つの計測は同じ機械・同じ状態で続けて実行します。

## 差を判定する計測手順とbenchstatの読み方

「Bに変えたら速くなった」と言えるのは、ばらつきを超える差が出たときだけです。手順は次のとおりです。

1. プロファイラで、実行時間の大きな割合を占める関数を特定する
2. その関数を、外部I/Oを含まない形でハーネスのベンチマークに切り出す
3. 入力データの件数や偏りを本番に近づける
4. 変更前と変更後を、同じ機械で10回ずつ実行して保存する
5. 検定で差を判定し、機械・OS・ランタイムの版と一緒に記録する

Goでは `golang.org/x/perf/cmd/benchstat` がこの判定を担います。文字列を100個連結する処理を、`+=` 版と `strings.Builder` 版で10回ずつ測った結果です（Go 1.27.2）。環境変数 `IMPL` で実装を切り替えます。以下を既存のGoモジュール内の `join_test.go` に置き、先頭にパッケージ宣言と `os`、`strconv`、`strings`、`testing` のimportを追加してください。比較コマンドはbenchstatのインストール済み環境で実行します。

```
func joinPlus(n int) string {
    s := ""
    for i := 0; i < n; i++ {
        s += strconv.Itoa(i) + ","
    }
    return s
}

func joinBuilder(n int) string {
    var sb strings.Builder
    for i := 0; i < n; i++ {
        sb.WriteString(strconv.Itoa(i))
        sb.WriteByte(',')
    }
    return sb.String()
}

func BenchmarkJoin(b *testing.B) {
    f := joinPlus
    if os.Getenv("IMPL") == "builder" {
        f = joinBuilder
    }
    b.ReportAllocs()
    for b.Loop() {
        f(100)
    }
}
```

```
$ IMPL=plus    go test -run=^$ -bench=Join -count=10 > old.txt
$ IMPL=builder go test -run=^$ -bench=Join -count=10 > new.txt
$ benchstat old.txt new.txt
        │   old.txt    │               new.txt               │
        │    sec/op    │   sec/op     vs base                │
Join-16   20.353µ ± 3%   2.847µ ± 2%  -86.01% (p=0.000 n=10)

        │   old.txt    │              new.txt               │
        │  allocs/op   │ allocs/op   vs base                │
Join-16   100.000 ± 0%   7.000 ± 0%  -93.00% (p=0.000 n=10)
```

[benchstatのドキュメント](https://pkg.go.dev/golang.org/x/perf/cmd/benchstat)によると、benchstatは既定で、要約値に中央値を、A/B比較にMann-Whitney U検定を使います。`p=0.000` は偶然では説明しにくい差を意味し、`± 3%` は中央値の信頼区間の幅です。同じ `+=` 版を10回ずつ2組測って比べると、結果は `20.35µ ± 3% 20.08µ ± 10% ~ (p=0.393 n=10)` となり、差の欄が `~`（有意差なし）になりました。約1%の差が出ていても、この測定では統計的に有意な差は確認できません。有意差なしは「差が無い」の証明ではなく、「この回数と揺れでは差を見分けられない」という意味です。

割り当て回数が100回から7回に減った行も見るべき点です。実行時間は機械の状態で揺れますが、`b.ReportAllocs()` で出る割り当て回数は揺れにくく、改善の理由を説明する材料になります。C#での割り当て量の測り方は[ゼロアロケーションの実装と割り当て量の測り方](/tech/details/5647/)で扱っています。

## 言語別マイクロベンチマークツールと最適化防止の書き方

主要ツールの最新安定版（2026年11月7日にMaven Central・Google Maven・NuGet・crates.io・PyPI・npm・GitHub Releasesで確認）と、デッドコード除去を防ぐAPIをまとめます。

| 言語                   | ツール                    | 最新安定版         | 結果を逃がすAPI                   |
| -------------------- | ---------------------- | ------------- | --------------------------- |
| Java                 | JMH                    | 1.37          | 戻り値、Blackhole.consume       |
| Kotlin・Java（Android） | Jetpack Microbenchmark | 1.5.0         | BlackHole.consume           |
| C++                  | Google Benchmark       | v1.10.0       | DoNotOptimize、ClobberMemory |
| C#                   | BenchmarkDotNet        | 0.15.8        | 戻り値                         |
| Go                   | testing（標準）            | Go本体に同梱       | b.Loop（1.24以降）              |
| Rust                 | criterion              | 0.8.2         | std::hint::black\_box       |
| Python               | timeit（標準）、pyperf      | pyperf 2.10.0 | 不要（JITなしの実装）                |
| JavaScript           | tinybench、mitata       | 6.2.3、1.0.34  | 戻り値を外の変数へ                   |

### JMHとBenchmarkDotNetの反復設定と既定動作

JMHは注釈で計測モードと反復回数を指定します。`@State` のフィールドに入力を置き、`@Setup` で初期化すると、準備処理が計測から外れます。BenchmarkDotNetは既定で反復回数をヒューリスティックで決め、ウォームアップは6〜50回、測定は15〜100回の範囲に収まります。どちらも自前で回数を決める必要がないのが手書きループとの最大の違いです。.NETでの割り当て計測の具体例は[C#のボックス化の実測](/tech/details/4277/)にあります。

### Google BenchmarkとRustの最適化抑止API

C++のGoogle Benchmarkでは `benchmark::DoNotOptimize(expr)` で結果をメモリかレジスタに置かせます。公式ガイドによると、これは式の結果を保存させるだけで、式自体への最適化は禁止しません。グローバルメモリへの書き込みを確定させたいときは `benchmark::ClobberMemory()` を併用します。Rustでは `std::hint::black_box` がRust 1.66.0で安定化され、criterionのベンチマーク内で入力と結果を包むのに使います。

### Pythonの反復設定とJavaScriptのタイマー分解能

Pythonの `timeit.repeat()` は、既定で1セット100万回を5セット実行します。`timeit.timeit()` は、既定で100万回の計測を1セット実行します。コマンドラインでは `-n` を省くと1、2、5、10、20、50…と回数を増やして適切な値を探します。結果を比較して公表するなら、前述のシステム調整も含むpyperfが向いています。

ブラウザの `performance.now()` は、[High Resolution Time仕様](https://www.w3.org/TR/hr-time-3/)で精度が意図的に落とされています。クロスオリジン分離されていないページでは100マイクロ秒以上、分離されたページでも5マイクロ秒以上の単位に丸められます。1回数ナノ秒の処理を1回ずつ測っても0か丸め単位しか出ないので、tinybenchやmitataのように多数回をまとめて測るツールを使います。Node.jsの実行環境については[Node.jsの仕組みと版の選び方](/tech/details/17433/)を参照してください。

## CIで性能回帰を検知するときの組み方

マイクロベンチマークをCIに入れる目的は、性能を落とす変更をマージ前に見つけることです。共有ランナーは隣で動く他のジョブとCPUを分け合うため、前日の結果と今日の結果を比べると、コードの変更よりランナーの差が大きく出ます。

- 同じジョブの中で、ベースブランチと変更後のブランチを交互に実行して比べる（Goなら両方 `-count=10` で保存してbenchstatに渡す）
- 有意差（benchstatの `~` 以外）かつ一定以上の悪化だけを失敗扱いにする。閾値は同じコード同士を比べたときの揺れ幅より大きく取る（上の実測では同じコード同士でも ± 10% の幅が出た）
- 実行時間より揺れにくい割り当て回数（allocs/op）を主な監視対象にする
- 時間の推移を見たい場合は、クロックを固定した専用マシンで夜間に実行する

毎回のプルリクエストで全ベンチマークを回すと、本数や反復時間に応じてCIの所要時間が延びます。プロファイルで重いと分かっている数本に絞るのが現実的です。性能監視をリリース後の運用手順に組み込む体制づくりは、[システムの保守運用・内製化支援](/service/system/maintenance/)でも支援しています。

## マイクロベンチマークで判断してはいけない場面

マイクロベンチマークの数字が正しくても、それで実装を決めてはいけない場面があります。

- **処理時間の大半がI/Oの場合**：1回のDB問い合わせに数ミリ秒かかる処理で、前後の変換処理を100ナノ秒縮めても、応答時間全体への効果はごく小さくなります。
- **プロファイル上の比率が小さい場合**：全体の処理時間の2%を占める関数を2倍速くしても、他の処理が変わらなければ、全体の処理時間は1%しか短縮しません。
- **入力の大きさが本番と違う場合**：要素数が変わると、データがCPUキャッシュに収まるかどうかや、比較回数の差の効き方が変わります。末尾の要素を探す実測では、要素数16では線形探索が速く、128付近で二分探索が逆転しました（[二分探索のJavaScript実装](/tech/details/4867/)）。
- **速くするためにコード量が大きく増える場合**：abseilの記事によると、glibcの `memcmp` は約6KBあり、命令キャッシュのミスを起こし、他の関数も追い出していました。単体では速い実装でも、命令キャッシュを圧迫して周りのコードを遅くし、アプリ全体では遅くなることがあります。
- **差がナノ秒単位で、読みやすさを犠牲にする場合**：保守コストの増加に見合うかを先に考えます。

マイクロベンチマークは「この2つの書き方の差」を正確に答える道具です。「アプリが速くなるか」には答えないので、採用前に負荷テストかプロファイルで全体の変化を確認してください。

## よくある質問

### マイクロベンチマークとベンチマークテストの違いは何ですか？

ベンチマークテストは性能を測る試験の総称で、CPUの総合スコアやシステム全体の処理能力も含みます。マイクロベンチマークはその中でも、関数やループ単位の小さなコードを対象にしたものを指します。

### ウォームアップは何回にすればよいですか？

JMHの既定値はウォームアップ5回・各10秒です。本記事の手書き計測ではJITの影響が3ラウンド目までに収まりましたが、必要な回数はコードと実行環境で変わります。ハーネスが出すウォームアップごとの値を見て、値が横ばいになってから測定に入っているかを確認してください。

### 結果は平均値と中央値のどちらを見ればよいですか？

指標は測定目的とツールに合わせます。代表的な実行時間には中央値、外乱の少ない実行時間の下限を見る場合には最小値が候補になります。Goのbenchstatは要約に中央値を使い、Pythonのtimeitの公式ドキュメントは最小値を見るよう勧めています。平均値は一度のGCや割り込みで大きく動きます。

### 高精度イベントタイマー（HPET）を無効にするとベンチマーク結果は変わりますか？

Windowsの高精度タイマーAPI（QueryPerformanceCounter）は、[Microsoft Learnの解説](https://learn.microsoft.com/ja-jp/windows/win32/sysinfo/acquiring-high-resolution-time-stamps)によると、Windows 7以降の多くの機種でCPUのTSCを基準にしています。HPETのようなプラットフォームタイマーはTSCよりも読み取りに時間がかかります。OSのタイマー設定を変えた前後の計測値には、タイマー読み取りコストの変化が影響する可能性があります。ただし、差が出たことだけでは原因を特定できません。設定を変えたら、変更前の結果とは比較しないでください。

### 手書きのループと System.nanoTime だけで測ってはいけませんか？

おすすめしません。JITのない実行環境でも、計算の除去やキャッシュ、CPUの状態によって結果は歪みます。処理がミリ秒単位でも、結果の消費と測定条件の管理が必要です。ナノ秒からマイクロ秒単位の処理では、本記事の実測どおりデッドコード除去やウォームアップの影響が結果の数十倍に達するため、ハーネスを使ってください。

## 関連記事

- [k6とは？Grafana k6の使い方とインストール手順・負荷テストの書き方【v2.3対応】](/tech/details/7581/)
- [Locustとは？Pythonで書く負荷試験の使い方・ramp-up・分散実行【2.47対応】](/tech/details/10870/)
- [Continuous Profilingとは｜継続的プロファイリングの仕組み・フレームグラフ・導入判断を実装目線で解説](/tech/details/15709/)
- [Java仮想マシン（JVM）とは？仕組み・メモリ・JITとインストール手順を実機で解説](/tech/details/7151/)
- [ゼロアロケーション（zero-allocation）とは？C#の実装手法と割り当て量の測り方](/tech/details/5647/)

---

出典: [マイクロベンチマークとは？正しい測り方と落とし穴をJMH・Go 1.27の実測で解説](<https://www.issoh.co.jp/tech/details/8711/>)（株式会社一創）
