What changed when Intake moved to .NET 11?

Dana has three decisions to make. Does the operator wait less for an XML export? Can the API keep up as more requests arrive? How much CPU and memory does the worker use for a file the partner can actually read? Each comparison below uses the same application source on the same Windows Server x64 machine with an AMD EPYC 7502P. Both deployments use the ordinary JIT and the installed shared frameworks.

What would change the release decision?

CLI. Keep the latency budget in milliseconds from process launch to an export the partner can parse. For 600 fresh processes per version, the median of the six block p99s was 67.73 ms on .NET 10 and 57.07 ms on .NET 11. The paired change ranged from a 27.6% improvement to an 8.3% regression. The smaller .NET 11 Windows application download is a real deployment saving, but it does not buy a guaranteed reduction in the operator’s wait.

Worker. Keep CPU per correct file, files per second and tail wait on separate lines of the release memo. For 6,000 delivered files per version, five pairs recorded lower CPU per file on .NET 11 and one pair tied. The median paired CPU saving was 14.1%, while throughput ranged from 6.4% lower to 8.1% higher. Follow that lead with a production canary before budgeting a 10% saving. Order also mattered to the observed tail. In the three pairs with .NET 10 first, the median worker p99 ratio (11 divided by 10) was 1.147. With .NET 11 first it was 0.737. Each subgroup has only three pairs, so the cause remains open.

The GC observations show why it is worth measuring the worker separately from the operator tool. Each runtime completed 90 instrumented CLI launches without an observed collection. Across six warm worker windows with 1,000 files each, GC pauses totalled 17.464 ms on .NET 10 and 18.668 ms on .NET 11. These are sums over all six windows. They cannot identify which file a pause delayed.

API. At 50 scheduled requests/s, the six runs offered each version 3,000 requests. The client received 2,904 verified replies on .NET 10 and 2,837 on .NET 11. Every request that reached either server returned a valid acknowledgment. The missing 96 and 163 slots were dropped before sending. None of the six pairs at this level delivered the full schedule on both versions. Fix the injector limit or repeat with a separate load generator before attributing the difference to ASP.NET.

Host activity varied during the trial. The opening and closing one-minute observations recorded mean physical disk traffic of 24.35 and 42.60 MiB/s, against the original quiet-host limit of 12 MiB/s. The per-second observations accompany the individual pairs. These results describe this shared Windows workstation.

Compare like operations

The reference uses .NET 10.0.15 and the candidate uses .NET 11.0.0. Other workloads, including Docker and WSL, continued to run. The experiment recorded host activity throughout and alternated which version ran first. The six planned pairs put each version first three times.

In this table each runtime value is the median of its comparable block measurements. A block p99 is the 99th percentile within one run. The range in the final column comes from changes calculated within individual matched pairs. Subtracting two column medians can give a different answer.

Operation Measure Usable pairs .NET 10 .NET 11 Range of paired changes
CLI p99 wait (ms) 6/6 67.73 57.07 -27.6% to +8.3%
Worker Verified files/s 6/6 1,283.36 1,290.23 -6.4% to +8.1%
API at 10 requests/s p99 wait (ms) 3/6 794.24 762.20 -8.0% to +150.5%
API at 12 requests/s p99 wait (ms) 4/6 668.78 665.74 -11.1% to +4.0%
API at 25 requests/s p99 wait (ms) 5/6 888.10 875.87 -99.8% to +1.0%
API at 50 requests/s p99 wait (ms) 0/6 unavailable unavailable unavailable

A repeatable 10% effect requires all six usable pairs to cross the predeclared margin in the same direction. Fewer pairs or a range spanning the margin leaves a decision open. A service owner can still act on an absolute deadline violation in either version.

Count missed work before interpreting the tail

For each API level the table below counts every primary slot, including runs excluded from the paired calculation. A dropped slot was never sent. A completed HTTP call counts only after the client has verified the acknowledgment. The client also checked the final journal.

Offered level Runtime Runs Planned Verified Dropped Errors Median block p99 of verified replies (ms)
API at 10 requests/s 10.0.15 6 600 599 1 0 763.87
API at 10 requests/s 11.0.0 6 600 598 2 0 783.65
API at 12 requests/s 10.0.15 6 720 718 2 0 668.78
API at 12 requests/s 11.0.0 6 720 720 0 0 677.14
API at 25 requests/s 10.0.15 6 1500 1500 0 0 883.72
API at 25 requests/s 11.0.0 6 1500 1498 2 0 874.39
API at 50 requests/s 10.0.15 6 3000 2904 96 0 815.83
API at 50 requests/s 11.0.0 6 3000 2837 163 0 902.71

Read CPU and memory together

CPU measures time charged to the application process per verified operation. In the API it includes the final drain, while the journal read runs afterwards. Peak working set is the highest resident process memory observed over its lifetime. The sample tables in the archive give the start and end readings separately where applicable.

Profile Runtime CPU pairs CPU (ms/correct operation) Peak working set (MiB)
CLI 10.0.15 6 49.7656 17.20
CLI 11.0.0 6 46.5625 17.31
Worker 10.0.15 6 0.5703 41.33
Worker 11.0.0 6 0.4922 42.27
API at 10 requests/s 10.0.15 3 0.1562 52.82
API at 10 requests/s 11.0.0 3 0.1562 55.04
API at 12 requests/s 10.0.15 4 0.2604 52.69
API at 12 requests/s 11.0.0 4 0.1302 55.09
API at 25 requests/s 10.0.15 5 0.3125 52.81
API at 25 requests/s 11.0.0 5 0.1875 55.53
API at 50 requests/s 10.0.15 0 unavailable unavailable
API at 50 requests/s 11.0.0 0 unavailable unavailable

Time the garbage collector in its own run

The diagnostic runs are separate from the latency measurements. For a fresh CLI process the hook observes the managed lifetime. For the API and worker it subtracts counters at the warm-window boundaries. Gen 0, 1 and 2 counts overlap when a collection includes younger generations. Read each separately. Total paused time cannot establish the p99 of individual pauses.

Profile Runtime Blocks Process windows Total paused (ms) Share of observed time Gen 0/1/2
CLI 10.0.15 6 90 0 0% 0/0/0
CLI 11.0.0 6 90 0 0% 0/0/0
Worker 10.0.15 6 6 17.464 0.3672% 12/6/0
Worker 11.0.0 6 6 18.668 0.4113% 12/6/0
API at 10 requests/s 10.0.15 4 4 0 0% 0/0/0
API at 10 requests/s 11.0.0 4 4 0 0% 0/0/0
API at 12 requests/s 10.0.15 3 3 0 0% 0/0/0
API at 12 requests/s 11.0.0 3 3 0 0% 0/0/0
API at 25 requests/s 10.0.15 1 1 0 0% 0/0/0
API at 25 requests/s 11.0.0 1 1 3.331 0.0332% 1/0/0
API at 50 requests/s 10.0.15 0 0 unavailable unavailable unavailable
API at 50 requests/s 11.0.0 0 0 unavailable unavailable unavailable

Read the measurements visually

Per-block absolute results with sample count and separate units for cli.
Per-block absolute results with sample count and separate units for worker.
Mobile layout of absolute API endpoints, verified goodput, target CPU and client scheduling delay.
Unsent scheduled slots at every observed offered rate, across both accepted and rejected pairs.
Process-scoped cumulative GC pause and collection-count deltas from independent diagnostic replays.

Repeat a check

In the unpacked solution, open the workload instructions. The study directory contains the offer schedule, the run order, application results, per-second host counters and paired summaries. To inspect one surprising value, start with the source run listed in the summary for that workload, then read its original operation rows.