Bạn bọc một Stopwatch quanh vòng lặp, chạy một lần, thấy phương án B nhanh gấp ba, rồi dán con số đó vào pull request. Vài ngày sau trên máy CI con số đảo chiều và không ai giải thích được. Vấn đề thường không nằm ở code mà ở phép đo: JIT, tiered compilation, GC và nhiễu hệ điều hành khiến một lần chạy bằng Stopwatch không đủ để kết luận.
BenchmarkDotNet 0.15.8 là công cụ chuẩn để đo microbenchmark trong hệ sinh thái .NET hiện tại (.NET 10 LTS). Bài này hướng dẫn dựng harness đúng, đọc báo cáo theo thống kê thay vì nhìn một con số, và phân biệt benchmarking với profiling — phần lớn kết luận sai về hiệu năng đến từ việc lẫn lộn hai việc này.
Cập nhật 2026:
- BenchmarkDotNet 0.15.8 là bản stable mới nhất; harness chạy trên
net10.0, không còn lý do đo trên .NET 8/9 (cả hai hết hỗ trợ 2026-11-10). - Cột
Gen0/1/2của[MemoryDiagnoser]được chuẩn hóa trên 1.000 operation, không phải tổng số lần GC trong cả lần chạy — đây là chỗ nhiều bài viết cũ đọc sai. - Điểm vào chuẩn cho CI là
BenchmarkSwitchercộng--filter, không phảiBenchmarkRunner.Run<T>()không truyền args.
Mục lục
Vì sao Stopwatch và một lần chạy không đủ
Với một phương thức mất vài nanosecond, mọi thứ quanh phép đo đều lớn hơn đối tượng đo. Cụ thể:
- JIT và tiered compilation. Lần gọi đầu chạy IL được biên dịch nhanh, chưa tối ưu; sau vài trăm lần gọi, tier 1 mới xuất hiện với inlining và các tối ưu nặng. Đo ở lần thứ nhất, thứ hai và thứ một triệu cho ba kết quả khác nhau.
- GC. Code cấp phát nhiều object tạm sẽ kích hoạt Gen 0 giữa các lần đo, tạo pause không đều. Trung bình cộng của vài lần chạy bị nhiễu bởi đúng một lần GC thì không phản ánh chi phí thật.
- Tối ưu của compiler. Nếu kết quả không được dùng, JIT có thể xóa cả phép tính. Đây là lý do BenchmarkDotNet luôn tiêu thụ giá trị trả về qua
Consumerthay vì để nó rơi vào hư không. - Nhiễu môi trường. CPU frequency scaling, hypervisor, process khác, cache L1/L2 và branch predictor đóng góp sai số mà
Stopwatchkhông nhìn thấy. - Overhead của phép đo. Bản thân
Stopwatch.Start/Stoptốn thời gian; đo một operation 5 ns bằng một cặp lệnh mất 20 ns là đo chính cái cân, không đo hàng.
Dựng harness với BenchmarkDotNet 0.15.8
Luôn tách benchmark sang project console riêng, không nhét vào project web hay test. Project riêng giúp kiểm soát TargetFramework, tham chiếu và cả những gì được nạp vào process đo.
dotnet new console -n Evotek.Benchmarks -f net10.0
cd Evotek.Benchmarks
dotnet add package BenchmarkDotNet --version 0.15.8
dotnet add reference ../Evotek.Core/Evotek.Core.csproj
Một benchmark tối thiểu nhưng đủ để thấy vấn đề: nối chuỗi bằng + so với StringBuilder, chạy ở ba kích thước đầu vào.
// File: Benchmarks/StringJoinBenchmarks.cs
using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Order;
[MemoryDiagnoser]
[SimpleJob(warmupCount: 3, targetCount: 15)]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
[RankColumn]
public class StringJoinBenchmarks
{
[Params(10, 100, 1_000)]
public int Count { get; set; }
private string[] _parts = [];
[GlobalSetup]
public void Setup()
{
_parts = [.. Enumerable.Range(0, Count).Select(i => $"item-{i}")];
}
[Benchmark(Baseline = true)]
public string ConcatOperator()
{
var result = string.Empty;
for (var i = 0; i < _parts.Length; i++)
{
result += _parts[i];
}
return result;
}
[Benchmark]
public string StringBuilderAppend()
{
var builder = new StringBuilder(_parts.Length * 8);
for (var i = 0; i < _parts.Length; i++)
{
builder.Append(_parts[i]);
}
return builder.ToString();
}
}
Điểm vào nên nhận args để lọc benchmark khi chạy CI:
// File: Program.cs
using BenchmarkDotNet.Running;
var switcher = BenchmarkSwitcher.FromAssembly(typeof(StringJoinBenchmarks).Assembly);
switcher.Run(args);
Chạy:
dotnet run -c Release -- --filter *StringJoin*
Cái bẫy Debug và Release
BenchmarkDotNet sinh ra một project tạm và build project đó ở Release, nhưng code bạn đo là assembly bạn vừa build. Chạy dotnet run không có -c Release nghĩa là assembly đó là Debug: không inlining, có kiểm tra biên, codegen khác hoàn toàn. BDN phát hiện và cảnh báo; đừng bỏ qua cảnh báo đó. Nếu số liệu từ hai lần chạy Debug và Release gần nhau, gần như chắc chắn phép đo đang đo một thứ quá lớn (I/O, sleep) chứ không phải CPU.
Ngoài ra, gắn debugger sẽ làm sai kết quả. Trước khi chạy, đóng profiler, tắt ứng dụng nặng, và với laptop hãy cắm điện để CPU không hạ xung giữa các iteration.
Các attribute quyết định kết quả
Bốn thứ dưới đây chiếm 90% giá trị thực tế của BenchmarkDotNet:
[Benchmark]đánh dấu phương thức được đo. Mỗi phương thức là một case riêng, chạy trong process riêng theo toolchain mặc định, nên nhiễu của case trước không mang sang case sau.[Params(10, 100, 1_000)]chạy cùng benchmark với nhiều giá trị. Hiệu năng gần như luôn phụ thuộc kích thước đầu vào; một con số ởn = 1000không nói gì vền = 10. Với tập giá trị phức tạp, dùng[ParamsSource(nameof(Cases))]trả vềIEnumerable<int>.[GlobalSetup]chuẩn bị dữ liệu một lần cho mỗi tổ hợp benchmark × param × job, không phải một lần cho toàn bộ class. Điều này quan trọng: nếu setup tốn 200 ms và bạn đặt nó trong[Benchmark], bạn đang đo setup. Allocation trong[GlobalSetup]cũng không bị tính vào cộtAllocated.[MemoryDiagnoser]bật đo cấp phát. Không có nó, bạn chỉ thấy thời gian và sẽ bỏ qua loại bottleneck phổ biến nhất trong code .NET: allocation đẩy GC.
[Benchmark(Baseline = true)] chọn mốc so sánh và thêm cột Ratio; [RankColumn] thêm thứ hạng. Với tham số truyền trực tiếp cho một case, dùng [Arguments] hoặc [ArgumentsSource]. Đừng lạm dụng: mỗi tổ hợp param × method × job là một process, thời gian chạy tăng theo cấp số nhân.
Job, warmup và iteration
Mặc định BenchmarkDotNet chia mỗi case thành ba giai đoạn: warmup (làm nóng JIT, không tính điểm), pilot (ước lượng số invocation để một iteration đủ dài), và actual (đo thật). Số invocation mỗi iteration và số iteration được chọn tự động để kết quả ổn định mà không chạy quá lâu.
Khi cần so sánh công bằng giữa hai lần chạy (ví dụ trước và sau một refactor), hãy cố định tham số thay vì để auto:
// File: Benchmarks/JitJobs.cs
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;
public sealed class TwoJobs : ManualConfig
{
public TwoJobs()
{
AddJob(Job.Default.WithId("default")
.WithWarmupCount(3)
.WithIterationCount(15));
AddJob(Job.Default.WithId("long-iteration")
.WithInvocationCount(1_024)
.WithUnrollFactor(1));
}
}
Gắn [Config(typeof(TwoJobs))] lên class benchmark. Mỗi job là một cách chạy cùng code; kết quả được nhóm theo job id, nên bạn thấy ngay tác động của việc tăng độ dài iteration.
Vài knob có thật và có tác dụng:
| Knob | Tác dụng |
|---|---|
WarmupCount |
Số iteration làm nóng; tăng khi code có nhiều tiered compilation hoặc khởi tạo cache. |
IterationCount |
Số iteration đo; tăng để khoảng tin cậy hẹp lại, không làm kết quả “nhanh hơn”. |
InvocationCount / UnrollFactor |
Số lần gọi mỗi iteration và hệ số bung vòng lặp; dùng khi muốn kiểm soát chính xác chi phí mỗi lần gọi. |
LaunchCount |
Số process cho mỗi case; tăng khi nghi ngờ nhiễu môi trường giữa các process. |
Cấu hình GC để khớp production (WithGcServer(true), WithGcConcurrent(false)) khi app của bạn chạy server GC. Đo trên workstation GC rồi kết luận cho một service 32 core là so sánh sai đối tượng. BDN in cấu hình runtime trong phần thông tin môi trường của report, hãy đọc phần đó trước khi đọc số.
Đọc báo cáo: đừng chỉ nhìn Mean
Report mặc định nằm trong BenchmarkDotNet.Artifacts/results/, gồm bảng console, file .md và .html. Các cột cần hiểu đúng:
- Mean — trung bình cộng thời gian mỗi operation. Nhạy với outlier.
- Error — một nửa khoảng tin cậy 99,9% của Mean, không phải standard error of mean như nhiều bài viết cũ nói. Hai phương án có Mean lệch nhau 2% trong khi Error 3% thì chưa thể kết luận.
- StdDev — độ lệch chuẩn của các mẫu. StdDev lớn là tín hiệu môi trường bẩn hoặc code có nhánh phụ thuộc dữ liệu, không phải “cần chạy thêm vài lần là hết”.
- Median — trung vị; dùng
[MedianColumn]khi phân bố lệch vì GC pause. - Ratio — so với baseline. Đây là cột nên đưa vào báo cáo cho team, vì nó bất biến với máy.
- Allocated — byte cấp phát trên heap cho mỗi operation. Gen0/1/2 — số lần GC trên 1.000 operation.
Kết luận hợp lệ cần ba điều: chênh lệch lớn hơn sai số, có ý nghĩa thực tế (ví dụ giảm 40% allocation chứ không phải 3% thời gian), và không đổi giữa hai lần chạy độc lập trên cùng máy. Nếu chỉ đạt điều kiện thứ nhất, bạn có một quan sát, chưa có một kết luận.
Đo allocation
[MemoryDiagnoser] đo chính xác số byte cấp phát của thread chạy benchmark, không phải ước lượng. Vài lưu ý thực dụng:
- Allocation của
[GlobalSetup]không được tính; hãy tạo dữ liệu ở đó thay vì trong benchmark. - Đơn vị là byte/operation, nên
0 Blà mục tiêu thật của hot path, không phải con số lý thuyết. - Nếu một phương án nhanh hơn 10% nhưng cấp phát gấp 5 lần, nó thường là lựa chọn sai cho endpoint chịu tải: chi phí GC xuất hiện ở request khác, không ở benchmark của bạn.
- Đừng tự viết harness bằng
GC.GetAllocatedBytesForCurrentThread()để thay thế. Nó không xử lý warmup, tiering và thống kê, tức là lặp lại đúng những vấn đề củaStopwatch.
Benchmarking không phải profiling
Microbenchmark trả lời “giữa hai cách viết này, cách nào tốn ít CPU hơn cho cùng một operation”. Nó không trả lời “endpoint này tốn thời gian ở đâu” hay “hệ thống chịu được bao nhiêu request/giây”. Với câu hỏi thứ hai, bạn cần profiler và load test.
dotnet-trace collect -p <pid> --profile cpu-samplinglấy mẫu call stack của process đang chạy thật. Đổi sang Speedscope bằngdotnet-trace convert trace.nettrace --format speedscopeđể xem flame graph.dotnet-counters monitor -p <pid> --counters System.Runtime,Microsoft.AspNetCore.Hostingxem GC, allocation rate, request rate, số request đang xử lý. Đây là nơi bạn phát hiện vấn đề trước khi viết benchmark.- PerfView (Windows) mở
.etl/.nettrace, xem CPU Stacks, GC heap và JIT events; phù hợp khi cần đọc allocation stack hoặc GC pause chi tiết. - Profiler tích hợp trong Visual Studio 2026 hoặc Rider đủ cho phần lớn case hằng ngày.
Quy trình đúng: profile trên app thật để tìm hotspot, tối ưu bằng microbenchmark cho từng ứng viên, rồi xác nhận lại bằng load test. Làm ngược lại — tối ưu theo benchmark rồi hy vọng throughput tăng — là cách phổ biến để tối ưu phần code không phải bottleneck.
Các kết luận sai thường gặp
- Một lần chạy là đủ. Không. Cần ít nhất hai lần độc lập, và đọc Error/StdDev trước khi đọc Mean.
- So sánh kết quả giữa hai máy. Cùng code, cùng cấu hình nhưng CPU khác, turbo khác, cache khác thì Ratio mới là thứ so sánh được, không phải Mean.
- Chạy Debug rồi tin số. Kết quả vô nghĩa, kể cả khi thứ tự xếp hạng trông “hợp lý”.
- Microbenchmark = throughput của app. Một method nhanh gấp đôi trong vòng lặp nóng có thể không đổi gì khi thời gian request nằm ở database và serialization.
- Đo cả I/O trong microbenchmark. Nếu bạn đo HTTP call, bạn đang đo mạng và server, không đo code. Dùng load test cho việc đó.
- Bỏ qua allocation vì “chỉ chậm 5%”. 5% CPU cộng với 3 MB/request thì ở 1.000 RPS là 3 GB/giây cấp phát — GC sẽ là vấn đề của tuần sau.
- Đặt benchmark trên CI runner chia sẻ rồi fail build theo ms tuyệt đối. Runner ảo có nhiễu; hãy so Ratio với baseline trên runner riêng, hoặc chỉ theo dõi trend.
Khi nào dùng gì
| Công cụ | Dùng khi | Không dùng khi |
|---|---|---|
| BenchmarkDotNet | So sánh hai cách viết cho cùng logic, đo allocation, kiểm chứng một tối ưu cụ thể | Tìm hotspot trong app, đo throughput end-to-end |
| dotnet-trace / PerfView | Tìm hotspot, đọc call stack, kiểm tra JIT và GC | So sánh hai implementation nhỏ với sai số vài ns |
| Load test (k6, NBomber) | Đo throughput, p95/p99, hành vi dưới tải đồng thời | Xác định một method cụ thể nhanh hay chậm |
Checklist trước khi tin một con số
- Project benchmark riêng,
net10.0,BenchmarkDotNet0.15.8. - Chạy
dotnet run -c Release, không debugger, máy cắm điện, không có tác vụ nặng. - Có
[MemoryDiagnoser], ít nhất hai giá trị[Params], mộtBaseline = true. - Setup dữ liệu trong
[GlobalSetup]; không có I/O trong[Benchmark]. - Đọc Error, StdDev, Allocated trước khi kết luận từ Mean.
- Lặp lại lần hai; chỉ báo cáo khi kết quả nhất quán và chênh lệch vượt sai số.
Về phía trước: .NET 11 dự kiến GA trong tháng 11/2026 (STS), mang theo PGO và codegen mới, nên benchmark của bạn nên pin net10.0 và chỉ thêm runtime .NET 11 như một job so sánh có chủ đích, không đổi baseline của team theo từng bản RC.
Đọc tiếp trong series:
- So sánh EF Core, Dapper và RepoDB — cùng phương pháp đo, áp dụng cho tầng truy cập dữ liệu.
- Polly và khả năng chống chịu lỗi — chi phí của retry và circuit breaker, đo được bằng chính harness này.
- Cache in-memory vs cache phân tán — nơi allocation và độ trễ cache quyết định lựa chọn.



