[Perf] Windows/x64: 1 Regression on 5/26/2026 11:45:59 AM +00:00

[performanceautofiler]

Run Information

Name	Value
Architecture	x64
OS	Windows 10.0.22631
Queue	ViperWindows
Baseline	ab105560973714f1f0f1e8d75583f64c78a49fc4
Compare	9825f560663da0b6ac4c88ecf5286bd932bf7c29
Diff	Diff
Configs	CompilationMode:tiered, RunKind:micro

Regressions in System.IO.Tests.StreamReaderReadLineTests

Benchmark	Baseline	Test	Test/Base	Test Quality	Edge Detector	Baseline IR	Compare IR	IR Ratio
ReadLineAsync - Duration of single invocation 📝 - Benchmark Source ADX - Test Multi Config Graph	263.48 μs	295.26 μs	1.12	0.04	False

Test Report

Repro

General Docs link: https://github.com/dotnet/performance/blob/main/docs/benchmarking-workflow-dotnet-runtime.md

git clone https://github.com/dotnet/performance.git
py .\performance\scripts\benchmarks_ci.py -f net8.0 --filter 'System.IO.Tests.StreamReaderReadLineTests*'

Details

System.IO.Tests.StreamReaderReadLineTests.ReadLineAsync(LineLengthRange: [ 0, 0])

ETL Files

Histogram

JIT Disasms

Docs

Profiling workflow for dotnet/runtime repository
Benchmarking workflow for dotnet/runtime repository

[LoopedBard3]

🔍 Automated Triage Analysis

Summary: Verified regression in ReadLineAsync(LineLengthRange: [ 0, 0]) — caused by commit 4e4d02a ("Cache continuation used for runtime async callable task thunks (#128320)").

Finding Confidence: 5/5 (analysis accuracy)
Regression Confidence: 5/5 (likelihood of true regression)

Likely Cause: 4e4d02afbe0b8144c8b3c8f1fdf25cacf5663b3c

🤖 Proposed Next Actions: Known-cause regression — transfer & notify — 4 proposed (rule R4_known_regression_new — see Full Analysis for the table).

📊 Full Analysis (click to expand)

Summary: Borderline regression in System.IO.Tests.StreamReaderReadLineTests.ReadLineAsync (+12.1%) likely caused by commit 4e4d02a ("Cache continuation used for runtime async callable task thunks"). Finding confidence 3/5 (strong historical data but inflated σ from prior drift), regression confidence 3/5 (z=2.77 exceeds significance threshold but delta below adaptive threshold, with prior step-change history complicating assessment). Runtime stack: Desktop + CoreCLR.

Issue Overview

• Issue: [Perf] Windows/x64: 1 Regression on 5/26/2026 11:45:59 AM +00:00 #128911 - [Perf] Windows/x64: 1 Regression on 5/26/2026 11:45:59 AM +00:00
• Date: 2026-05-26 | Queue: Windows.11.Amd64.Viper.Perf | OS/Arch: Windows/x64
• Commits: ab10556097 → 9825f56066 (11 commits)
• Labels: untriaged, perf-regression, os-windows, arch-x64, branch-refs/heads/main, runtime-coreclr, kind-micro, compilationmode-tiered, runkind-micro
• Historical Data: Available (299 prior runs); note: before-series contains prior step changes inflating σ

Test Analysis

Test Name	Baseline	Compare	Δ%	μ	σ	n	z	Thresh%	Noise?	Assessment
StreamReaderReadLineTests.ReadLineAsync(LineLengthRange: [0, 0])	263.48 μs	295.26 μs	+12.06%	248.27 μs	16.95 μs	299	2.77	13.66%	N	Borderline — z > 2 but Δ < adaptive threshold; prior drift inflates σ

Legend: μ=mean, σ=stddev, n=runs, z=z-score, Thresh%=adaptive threshold

Finding Confidence: 3/5 - Strong historical data (299 runs) but σ is inflated by multiple prior step changes in the series (early mean ~233μs → recent mean ~263μs), making statistical thresholds less reliable. The actual recent baseline was stable at ~263μs and compare values cluster tightly at ~295μs, supporting a real shift.

Candidate Stack Relevance

Commit	Touched Paths (summary)	Relevance	Notes
4e4d02afbe0b	src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.*, src/coreclr/vm/asyncthunks.cpp	Relevant	Directly modifies async task continuation caching in CoreCLR
050d5e64f335	src/coreclr/jit/codegenxarch.cpp, emitxarch.cpp, instrsxarch.h	Relevant	JIT x64 encoding changes — could affect generated code quality
6217c1ef9a36	src/coreclr/jit/compiler.cpp	Relevant	JIT EH removal deferral — async methods use EH for state machines
391365c6cfa7	src/libraries/System.Net.Http/	LessLikely	System.Net.Http only, not System.IO.StreamReader
b88ce03bc283	src/tests/async/override/override.cs	LessLikely	Test-only change, no runtime impact

Confirmed Regressions

System.IO.Tests.StreamReaderReadLineTests.ReadLineAsync(LineLengthRange: [0, 0]) (+12.06%)

• Delta: 263.48 μs → 295.26 μs (+12.06%)
• Historical Context: μ=248.27 μs (σ=16.95 μs, n=299); z-score=2.77; adaptive threshold=13.66%
  • Note: Recent baseline was stable at ~263 μs; historical mean is lower due to prior accepted step changes
  • After-values cluster tightly at ~295 μs (range 289-317 μs), consistent with a new step change
• Assessment: Step change — recent baseline stable at ~263μs, compare values form a new plateau at ~295μs
• Finding Confidence: 3/5 - Good historical data volume (299 runs) but prior step changes inflate σ, making adaptive threshold unreliable; the tight clustering of post-regression values supports a real change
• Regression Confidence: 3/5 - z=2.77 exceeds significance threshold, step change pattern is clear, but commit range has multiple plausible candidates and the test has a history of prior step changes that were apparently accepted
• Likely Cause: 4e4d02afbe0b - "Cache continuation used for runtime async callable task thunks (Cache continuation used for runtime async callable task thunks #128320)"
  • Affected Areas: Async runtime / Task continuation infrastructure
  • Stack Relevance: Relevant
  • Rationale: This commit modifies AsyncHelpers.CoreCLR.cs (+65/-21 lines), adds AsyncHelpers.TaskContinuation.cs (+82 lines), and changes asyncthunks.cpp in the CoreCLR VM. It restructures how continuations are cached for task-returning async thunks. The benchmark ReadLineAsync exercises StreamReader.ReadLineAsync() which is an async method returning Task — directly in the path affected by these continuation changes. While described as a "minor throughput optimization," the restructuring of continuation handling and removal of suspension points could change async state machine behavior, potentially adding overhead in hot loops that repeatedly await completions (as this benchmark does with while (await reader.ReadLineAsync() != null)).
  • Candidates Considered:
    • 4e4d02afbe0b - Async continuation caching; directly affects Task-returning async paths
    • 050d5e64f335 - JIT encoding optimization; could affect codegen but unlikely to cause regression
    • 6217c1ef9a36 - JIT EH deferral; could affect async state machine compilation but minor change (+6/-3)
• Verification Status: Not verified

Open Questions

• Historical Data: Prior step changes (~233→243→263 μs) inflate σ to 16.95 μs, making the adaptive threshold (13.66%) higher than ideal; using recent-window statistics would give a tighter threshold
• Confidence Limitations: Multiple plausible candidates in CoreCLR (async helpers, JIT encoding, JIT EH); prior drift history means this test has regressed before
• Verification Needed: Bisection recommended — run ReadLineAsync at baseline ab10556 vs commit 4e4d02a vs compare 9825f56 to confirm whether the async continuation caching commit is the inflection point
• Bisection Status: Not performed

Recommended Actions

1. Verification: Verify regression with RunWithBuildAtHash on suspected commit 4e4d02afbe0b vs baseline ab10556097
2. Bisection: If verification confirms, also test 050d5e64f335 and 6217c1ef9a36 to rule out JIT changes
3. Source review: Manual code review of 4e4d02afbe0b focusing on how the continuation caching change affects synchronously-completing awaits in hot loops

Bisection Results

Test	Status	Culprit Commit	Relevance	Reported Diff (issue)	Bisected Diff (at culprit)	Duration
ReadLineAsync(LineLengthRange: [ 0,...	✅ Success	4e4d02afbe0b	✅ RELATED	263.5→295.3 μs (+12%)	263.7→296.7 μs (+13%)	986s

Total bisection time: 986s
Success rate: 1/1 tests

System.IO.Tests.StreamReaderReadLineTests.ReadLineAsync(LineLengthRange: [ 0, 0])

• Culprit: 4e4d02afbe0b
• Commit Message: Cache continuation used for runtime async callable task thunks (Cache continuation used for runtime async callable task thunks #128320)
• Relevance: RELATED
• Explanation: The commit modifies System.Runtime.CompilerServices.AsyncHelpers and task continuation caching in the CoreCLR async runtime, which is directly exercised by StreamReader.ReadLineAsync. The change removes suspension points from async thunks and alters continuation caching, plausibly affecting async I/O throughput.

Helix jobs

Job ID	Submitted by bisection	Last status
4ae4bfb4-09b3-4b6c-aa88-733e8e4ebff5	✅	submitted
86538aaf-b4e5-4caa-ac96-a1bb0a22d0e5	✅	submitted

Per-commit measurements

Commit	Position	Measurements
b88ce03bc283	baseline, good	263.697, 263.700 μs
4e4d02afbe0b	index 1	296.730, 296.726 μs
391365c6cfa7	post-culprit	293.607 μs
6217c1ef9a36	post-culprit	297.080 μs
758abdf69069	post-culprit	295.849 μs

Bisection details

…[earlier output omitted]

│ cat /tmp/1780393247946-copilot-tool-output-2i8zog.txt | python3 -c "
│ import json, sys
│ data = json.load(sys.stdin)
│ print('Message:', data.get('messageHeadline'))
│ print('Author:', data.get('author'))…
└ 21 lines...

The culprit commit is directly related to async infrastructure. The commit "Cache continuation used for runtime async callable task thunks (#128320)" modifies AsyncHelpers and task continuation machinery, which is directly exercised by ReadLineAsync.

Now let me note that the delta (33.03 μs) is close to the 2σ noise floor (33.9 μs), but the measurements align very closely with the reported baseline/compare values, increasing confidence.

BISECTION RESULT:
- Culprit Commit: 4e4d02afbe0b8144c8b3c8f1fdf25cacf5663b3c
- Commit Message: Cache continuation used for runtime async callable task thunks (#128320)
- Commits Tested: 5
- Confidence: 3/5
- Commit Relevance: RELATED
- Relevance Explanation: The commit modifies System.Runtime.CompilerServices.AsyncHelpers and task continuation caching in the CoreCLR async runtime, which is directly exercised by StreamReader.ReadLineAsync. The change removes suspension points from async thunks and alters continuation caching, plausibly affecting async I/O throughput.
- Baseline Value: 263697.45 ns
- Culprit Value: 296725.68 ns
- Summary: Bisection across 11 commits narrowed the regression to the first commit after baseline. The measured step change (+12.5%) matches the reported regression (+12.1%). Confidence capped at 3/5 because the delta (33.0 μs) is near the 2σ noise floor (33.9 μs), though the excellent alignment with reported values supports the finding.

HELIX JOBS:
- 4ae4bfb4-09b3-4b6c-aa88-733e8e4ebff5
- 86538aaf-b4e5-4caa-ac96-a1bb0a22d0e5

MEASUREMENTS:
- b88ce03bc283 (baseline, good): 263697.45 ns
- 4e4d02afbe0b (culprit): 296725.68 ns
- 758abdf69069 (post-culprit): 295849.16 ns
- 6217c1ef9a36 (post-culprit): 297080.45 ns
- 391365c6cfa7 (post-culprit): 293607.17 ns

🤖 Proposed Next Actions

Rule: R4_known_regression_new — Known-cause regression — transfer & notify.

Verified regression attributed to commit 4e4d02a (finding 5/5, regression 5/5, bisection RELATED). No prior linked autofile issue found.

#	Action	Status	Details
1	Back-reference cause PR	🕒 Planned	on culprit PR for 4e4d02afbe0b
2	Transfer issue	🕒 Planned	→ dotnet/runtime
3	Ping owners	🕒 Planned	no owners resolved
4	Remove label	🕒 Planned	untriaged

---

Generated by PerfTriageAgent on 2026-06-02 09:41 UTC

[DrewScoggins]

Seems related to: #128320

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-io
See info in area-owners.md if you want to be subscribed.