Build Host, Target, Receiver: Where a Native .NET Build Runs

Follow an Intake build from macOS to Windows and Linux. Diagnose a missing loader and see which CPU and operating system each native, virtualized or translated run actually tested.

An Edwardian railway engineer matches the key profile of a brass coupling to a signal mechanism before testing the fit.

How .NET Runs Your Code, part 7 of 11. Previous, Trimming and Reflection. Next, Part 8, Startup and First Response.

Docker reports exec /tmp/intake-service: no such file or directory on Alpine Linux. Before launch, Ravi, Intake’s build engineer, copied that executable back out of the container and checked its SHA-256 fingerprint against the file he sent. The bytes matched. On another Linux image, the same Arm64 executable accepted a job called rebuild-index. Which file is missing?

The missing file was the dynamic loader, the program Linux opens to load the libraries Intake needs. Its pathname is built into the service’s ELF (Executable and Linking Format) file. The missing-path error ENOENT can refer to either file. Lena has repaired the exporter and the API’s error response. Dana, the release owner on this fictional team, still has to find out which machines can start the code that passed Lena’s tests.

  • Use the sender’s and receiver’s hashes to check the copy. If an existing Linux executable reports a missing file, inspect the loader pathname it requests.
  • A self-contained ordinary publish can select runtime files for another operating system. A native publish also needs an appropriate linker and native libraries.
  • After the kernel opens the loader, check the required C library version. If the runtime starts, its own diagnostic can identify missing culture data.
  • Record the builder, target and oldest tested receiver together. Exercise a valid and an invalid request on the delivered files.

A successful build fills only two columns

The build host runs the SDK. The target describes the operating system and processor for which the SDK should produce files. The receiver is the machine or container where those files must do their job. In the Alpine incident the copy reached its destination. To see what a build alone can prove, start with a delivery where Ravi changes operating systems.

Ravi publishes on an Apple M3 Max using win-x64, the runtime identifier (RID) for 64-bit x86 Windows. macOS returns Exec format error if he starts the Windows launcher there. Dana copies the folder to the AMD EPYC workstation running Windows Server 2022. Its Windows process accepts the named job and preserves the journal after an invalid one.

Ravi then requests native ahead-of-time (AOT) compilation, which produces the application’s machine code during publish. The Mac refuses the Windows native build. Would changing only the processor, from Arm64 macOS to x64 macOS, stop the build at the same point? Predict that row before moving the slider.

Explorable

Eight API replies, a CPU probe and a refused publish answer different questions

Build hostmacOS on M3 MaxTarget fileWindows x64 · ordinaryRan onWindows on AMD EPYCCheck8 API requests
  1. The Mac emits a Windows launcher. Its complete managed folder reaches the AMD workstation, which exercises the valid and invalid requests.
  2. The native publish stops on the Mac. The pipeline cannot award a receiver result to an output that never existed.
  3. The Windows toolchain completes the native link. The Windows executable must still preserve journal state when it rejects an unnamed job.
  4. An x64 Mach-O serves the same requests on Apple silicon. The live process reports translation, so the Intel Mac row stays open.
  5. Windows Subsystem for Linux version 2 (WSL 2) supplies the Linux kernel on the EPYC. The Ubuntu receiver answers with invariant globalization enabled.
  6. A physical Xeon runs all three short probes. The record establishes feature behavior on Intel Linux. An Intake API rollout needs its own service check.
  7. The processor underneath QEMU is AMD. The program sees the older modeled feature set and exits before its managed feature command can run.

The service rows use the Part 7 publish and receiver records. The physical Intel probe is in results/platforms-native/. The QEMU control is in results/linux/part07/.

The Mac-built Windows launcher occupied 73,728 bytes in a folder containing 340 files. The Windows-built native service executable occupied 10,832,384 bytes. Comparing just those two files leaves the runtime alongside the ordinary launcher out of the shipping cost. Record both the launch command and the complete folder the operator needs.

Write publish refused when there is no file. Write built, receiver untested when the target is unavailable. Ravi produced an ordinary Windows Arm64 folder on the Mac. The team had no Windows Arm64 receiver on which to qualify it.

VHS · macOS Watch which of the two publish commands leaves Ravi a file to transfer. Full recording

An ordinary publish selects files for the target

NuGet uses the target RID when it chooses platform-specific package assets. Those can include a launcher, a runtime library and native dependencies shipped by a package. The SDK delivering those files can itself be an Arm64 process on a Mac. Microsoft’s RID catalog.

Does the ordinary cross-publish also work on .NET 10? Both macOS and Windows built ordinary folders for all six targets on .NET 10 and .NET 11. The .NET 10 Mac-built Windows x64 folder also passed the eight requests on Windows.

Compare the commands. They use the same project, Release configuration, RID and self-contained setting. Only the native compilation property changes.

dotnet publish src/Intake.Api -c Release -r win-x64 --self-contained true -p:PublishAot=false
dotnet publish src/Intake.Api -c Release -r win-x64 --self-contained true -p:PublishAot=true

The first publish builds managed assemblies containing intermediate language, or IL. The Windows process can translate that IL to instructions with its just-in-time compiler, the JIT. The native runtime binaries alongside the assemblies are already Windows x64 files. Copying a ready-made launcher into a folder is a different operation from linking Intake’s application code into a new Windows program.

The Mac-built Windows and Linux application DLLs had different SHA-256 values. Managed assemblies carry metadata and other build-dependent bytes alongside IL. Use a hash to identify a delivered file and a method listing to inspect its code. Later we will send identical managed DLLs to several processors and examine what each executes.

Follow the RID and publish mode into the SDK call. Where can the helper first distinguish a refused publish from a file it could send?

Code walkthrough

The RID selects a target before a native link can succeed

flags = ["-r", rid, "--self-contained", "true", f"-p:TargetLine=net{line}.0", "-p:RuntimeFrameworkVersion=" + runtime,
         "-p:PublishAot=" + str(mode == "native").lower(), "-p:PublishReadyToRun=" + str(mode == "r2r").lower(), *extra]
log = work / "publish.log"
record = publish(ROOT / "src" / folder / (folder + ".csproj"), flags, work / "published", work / "obj",
                 log, work / "publish.binlog" if mode == "native" else None, sdkdir)
exe = work / "published" / name
record.update({"host_os": platform.system(), "host_cpu": platform.machine(), "rid": rid, "mode": mode,
               "sdk": sdk, "runtime": runtime, "executable": name, "bytes": exe.stat().st_size if exe.exists() else 0,
               "sha256": sha(exe) if exe.exists() else None})
  1. The target RID and self-contained setting are inputs in every mode. The runtime version stays fixed while the selected compilation step changes.
  2. The SDK receives the application project and these properties. Its native route reaches the compiler and the operating system’s linker when the platform permits it.
  3. The helper inspects the promised executable after the SDK returns. A rejected native publish can therefore record an absent file alongside its diagnostic.

Excerpt from tools/part07.py, build(), with SDK selection and log reporting omitted. The matching publish logs are under results/mac/part07 and results/win/part07.

The Mac also published working ReadyToRun folders for Windows x64 and Linux x64. ReadyToRun adds precompiled method bodies to a managed image and keeps the JIT available. Both receivers passed the request checks. What extra step does the fully native Windows build need?

The native route runs the IL compiler, produces object code and asks a platform linker to combine it with the runtime and platform libraries. Look at one input and one dependency in the successful binary logs. On macOS, clang received intake-api.o and a destination executable. On Windows, link.exe received a response file listing inputs including System.Globalization.Native.Aot.lib. An emulated Linux x64 build invoked gcc to drive its Linux link. A string such as win-x64 supplies none of those tools. Native AOT cross-compilation requirements.

Which tool failed on the Mac-to-Windows attempt? The diagnostic names an SDK target. It ran before the operating system linker could make a Windows executable.

Cross-OS native compilation is not supported.

On the same Mac, a Linux Arm64 target reached the symbol-stripping check. Disabling that step exposed a linker failure. Look at the first error in each log.

Symbol stripping tool ('llvm-objcopy' or 'objcopy') not found in PATH.
clang : error : invalid linker name in argument '-fuse-ld=bfd'

These failures send Ravi to different queues. A failed restore points to a package source. A Windows native publish refused before linking belongs on a Windows build host. Disabling symbol stripping on the Linux attempt showed which linker was missing.

The build workstation has the Desktop development with C++ workload installed.
Visual Studio Installer In the checked Desktop development with C++ workload, the installation details list the x64/x86 tools and Windows SDK.

The Windows x64 machine had the desktop C++ build tools. Native publication there succeeded for Windows x64, then the published service handled the test requests. Its Windows Arm64 native job failed while locating the required Visual Studio components. The workstation therefore qualifies one native Windows target. Adding the Arm64 tools and securing a real Arm64 receiver would be separate jobs.

Visual Studio Developer PowerShell Follow the invalid job through the read that follows it. Full recording

One Arm64 Mac can test two process architectures

The M3 Max also produced an x64 Mach-O, the macOS executable format. It ran on the same Mac and answered the eight requests. How could Dana tell that this particular service process used translation?

The probe queried the macOS kernel for the translation flag on the actual service process IDs. The Arm64 process returned P_TRANSLATED=0 and the x64 process returned P_TRANSLATED=1. A second program queried sysctl.proc_translated from inside each architecture and also returned zero and one respectively. Apple’s Rosetta translation environment.

Write macOS x64 through Rosetta on Apple silicon in the memo. An Intel Mac would execute x64 instructions directly. The Rosetta result gives the team a functional regression check while that hardware remains untested.

A Linux file can exist and still be impossible to execute

Return to the Alpine receiver. The Machine field in the executable’s ELF header says AArch64, the name for 64-bit Arm. Both receiver images ran on Linux Arm64. The linux-arm64 candidate came from a Linux SDK image with the GNU C library (glibc). A second SDK image, Alpine with musl, supplied the C library and build tools for linux-musl-arm64.

Look at the first argument in each build command. The project and runtime line stay fixed while the RID and the SDK container supply the target’s C library and linker inputs.

sh /series/infra/part07/build-linux.sh linux-arm64 11 api native /study/net11-linux-arm64-api-native
sh /series/infra/part07/build-linux.sh linux-musl-arm64 11 api native /study/net11-linux-musl-arm64-api-native

Now choose a fix for the failed deployment. You can send the linux-musl-arm64 file to the same Alpine image, or send the original file again with its verified checksum. Which change would let Dana receive an HTTP response? Make your prediction, then watch which receiver gets as far as the HTTP probe.

VHS · Docker Compare the path in the failure with the interpreter requested in the ELF header. Full recording

The musl build answered all eight requests on that Alpine image. The glibc build reached none. Even docker start returned zero for that failed launch. The container’s exit status was 255. What changed was a program header named PT_INTERP. For these dynamically linked executables it contains the absolute path to the loader Linux must open. Read the two readelf -lW lines in order, first from the glibc build and then from the musl build. ELF program headers.

[Requesting program interpreter: /lib/ld-linux-aarch64.so.1]
[Requesting program interpreter: /lib/ld-musl-aarch64.so.1]

Linux calls the execution request execve. It can return ENOENT, the missing-path error, when either the requested program or its ELF interpreter is absent. Here the copy check proves the service file exists, and its header explains the second lookup. The reverse swap, with the musl build on the glibc image, failed the same way. On x64 the equivalent builds requested /lib64/ld-linux-x86-64.so.2 and /lib/ld-musl-x86_64.so.1. Inspect the artifact for your own CPU before looking for the loader on the receiver. Linux execve error conditions.

What if the receiver does have the requested loader? The .NET 11 Arm64 build host had glibc 2.43. The executable’s version-needs section, shown by readelf -V, names the library interfaces it uses. Its highest requested version was GLIBC_2.34. On Ubuntu 20.04 the loader could open libc.so.6. Read what that library could not supply.

/tmp/intake-service: /lib/aarch64-linux-gnu/libc.so.6: version `GLIBC_2.34' not found (required by /tmp/intake-service)

The diagnostic moves the investigation past the kernel. The loader found the C library and identified a missing version of its interfaces. Debian 11 also failed this check. The .NET 10 Arm64 and x64 files requested the same highest version, as did the .NET 11 x64 build. That shared floor says which symbol versions must exist. Dana still needs a launch on each receiver she promises to support.

The Linux Arm64 loader identifies a required glibc symbol that the receiver cannot provide.
GNU readelf · Docker Look for the required symbol version in the receiver’s loader diagnostic.

The minimal Ubuntu 22.04 image got further. The .NET runtime reported a missing ICU (International Components for Unicode) package. ICU supplies the data for operations such as language-sensitive sorting. Invariant globalization lets .NET start without ICU. Would enabling it help on Ubuntu 20.04, minimal Ubuntu 22.04, or both? Trace the same executable through each receiver before reading the last case.

Explorable

The receiver determines how far the same ELF runs

Alpine 3.24 Kernel opens loaderENOENT Loader resolves libcUnreached .NET startsUnreached API handles requestsUnreached Same ELF in every run Target RIDlinux-arm64 ELF machineAArch64 SHA-256 prefix5e67c5a9cb8a
  1. The copied file matches the sender. Its program header requests a GNU loader that this musl image cannot supply, so Intake never sees a request.
  2. Ubuntu’s loader reports a missing glibc symbol version. Invariant mode was already enabled in this run, but execution stopped before .NET could use it.
  3. The same file gets far enough to report a missing ICU package. This is the first failure here that a .NET globalization setting can change.
  4. Only the globalization setting changes from the previous case. The receiver can now return the accepted job and preserve the journal after an invalid submission.

Linux Arm64. The four receiver reports and native ELF header are under results/mac/part07. Compare the executable digest before comparing the loader and globalization messages.

Ubuntu 22.04 is the receiver this setting rescued. On Ubuntu 20.04 the loader had already failed by the time a .NET option could matter. Debian 12 also handled the requests with DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1. With default globalization, minimal Ubuntu 22.04 had produced different exit codes on Arm64 and x64, 133 and 139, yet both logs identified ICU. For a service that sorts names by language, keep ICU in the image and test the required order. Intake’s journal check exercises a different requirement. .NET globalization settings.

The file header and the CPU answer different questions

Windows calls its executable format Portable Executable, or PE. The ordinary launcher and the native Windows service both identified as PE x64. The ordinary launcher loads the application DLL. In the native build, the application has already been linked into the executable. A header reader can tell Ravi what kind of program the operating system sees. Identifying the deployment mode also takes the folder, its configuration and the build record.

For a target without a file, the build log identifies where the attempt stopped. Open the target that checked the operating systems. Its refusal explains why the Mac produced no Windows native header to inspect.

The failed Intake.Api publish expands the Error task under _ComputeAssembliesToCompileToNative and selects its cross-OS diagnostic.
MSBuild Structured Log Viewer Follow the Error task into Parameters. The SDK rejects this OS pair before the linker could produce an executable.

The Alpine incident began with a correct architecture label. A successful match on x64 also leaves a question open. Which instructions can the receiving processor execute? For .NET 11 the documented JIT and AOT minimum rose to x86-64-v2, which includes SSE4.2 and POPCNT. The default ReadyToRun target on Windows and Linux rose to x86-64-v3. On a v2 processor the runtime can use the JIT when a precompiled body needs v3. Microsoft’s minimum hardware requirements.

The Linux x64 engine on the EPYC workstation also hosted QEMU, a user-space emulator. Its Conroe model reported neither SSE4.2 nor POPCNT. The Nehalem and Haswell models exposed different instruction sets on the same host. Which result distinguishes a rejected CPU model from an emulator that cannot run the program at all? QEMU user-mode emulation.

Linux x64 candidateConroe modelNehalem and Haswell controls
.NET 10 ordinaryStarted, reported SSE4.2 falseStarted
.NET 10 Native AOTIllegal instruction, exit 132Started
.NET 11 ordinaryMissing baseline instructions, exit 134Started
.NET 11 Native AOTMissing baseline instructions, exit 134Started

QEMU 10.0.13 ran these functional controls. Both .NET 11 builds diagnosed the missing baseline. The .NET 10 ordinary control ran below it. The .NET 10 native file also failed there, with an illegal-instruction signal and no equivalent explanation. A generic compatibility table cannot qualify that particular executable. Test the program intended for the oldest receiver. A development machine with newer hardware cannot represent that instruction limit.

The .NET process on the Conroe CPU model reports missing baseline instructions.
Terminal · QEMU This guest reports no SSE4.2 or POPCNT before the runtime rejects the CPU.

Which receiver can qualify this delivery?

Read each row from the processor to the OS that loaded the file. A Linux virtual machine can execute Arm64 instructions directly on an Arm64 chip. Native AOT describes a separate choice made during publish. Which row qualifies your shipping artifact, and which only exercises a method?

Physical processorOS and execution pathWhat the receiver actually did
AMD EPYC 7502PWindows Server 2022, native x64 processThe Windows PE service passed eight requests. Windows reported a hypervisor present.
AMD EPYC 7502PLinux x64 in the WSL 2 VM, native x64The glibc and musl ELF services passed the requests in their matching Linux containers.
Intel Xeon W-2295Ubuntu 24.04.4 x64, directly on the hostA .NET 11 process ran the portable bit-count, feature and vector-sum probes. The full Intake HTTP check remains open on this CPU.
AMD EPYC 7502PLinux x64 container, QEMU CPU modelsConroe, Nehalem and Haswell supplied controlled feature sets for the startup checks above.
Apple M3 MaxmacOS Arm64 directlyThe Arm64 Mach-O service passed eight requests. Its Darwin translation flag was zero.
Apple M3 MaxmacOS x64 through RosettaThe x64 Mach-O service also passed eight requests. Its translation flag was one.
Apple M3 MaxLinux Arm64 in Docker’s Linux VM, native Arm64The Arm64 ELF services passed in their matching images. Crossing glibc and musl stopped them before listening.
Apple M3 MaxLinux x64 in Docker’s Linux VM, emulated x64The emulated x64 service passed eight requests. This is a distinct run from native Linux x64 on the EPYC.

If the EPYC service fails only on Alpine, start with the Linux image and its musl loader. Moving the investigation to Windows on that workstation also changes the kernel and libraries. WSL 2 runs a Linux kernel inside a managed virtual machine. Microsoft’s WSL architecture comparison.

The earlier course recorded eight responses on Ubuntu 24.04.4 x64. That record names the kernel, glibc and executable hash, but omits the CPU model. The new Xeon record identifies the processor and the short managed programs it executed. Combining those rows would assign a service run to hardware its original record never identified.

Suppose a Windows x64 worker adds an optional path for AVX-512F, an x86 vector instruction set, and a fallback for machines that lack it. Each receiver used its own .NET 11.0.0 runtime to run identical managed assemblies. The comparison covered Windows and Linux on the EPYC, macOS and Linux on the M3, and Ubuntu on the Xeon. The EPYC reported Avx512F.IsSupported=false under Windows and Linux, so it can exercise the fallback. The physical Xeon executed the explicit AVX-512F branch under Ubuntu even though Vector512.IsHardwareAccelerated was false. Record the flag your code tests. .NET’s vector-width check.

Send the shipping Windows worker to the EPYC and verify the partner document from its fallback. To qualify the 512-bit path for Windows on Intel, send the same Windows release and job to an AVX-512F-capable Intel workstation and check the document there. Before enabling that path by default, time it against the fallback on the same workstation with the batch sizes your users send. Part 2 times that choice on the Linux Xeon with batches of temperature readings.

The final check belongs to the copied artifact

Ravi could run one macOS job for every RID and mark any nonempty folder green. Lena attaches each target to a suitable build host, identifies the transferred files and exercises them on the chosen receiver.

One green job per target label

Check only the publish exit and the presence of a file. A Windows launcher can pass both checks on macOS. A Linux binary can pass both while the Alpine receiver cannot open its loader.

One verified transfer per supported receiver

Check the folder manifest for a managed deployment or the executable digest for a single native file. Start that candidate on the selected receiver, exercise its observable behavior and record when the process stopped.

On Arm64 Linux the clean SDK image failed to compile a native x64 API. Adding the x64 compiler, C runtime development files and zlib produced an x64 ELF. The EPYC Linux receiver checked its hash and answered all eight requests. Supplying the target toolchain made this cross-architecture build possible.

The cross-built and emulated builds produced separate files. Which record tells Dana that the file in her release ticket reached the intended receiver?

Sequence

The receiver checks identity before behavior

  1. The builder records the candidate digest while the artifact is still on the machine that produced it.
  2. The store delivers the selected candidate. A target label remains the same even when two builds have different contents.
  3. The receiver calculates its own digest before launch. A mismatched folder or executable stops the qualification here.
  4. The probe submits both valid and invalid jobs and reads the journal after each operation on the published service.
  5. The response body and the journal state let the client distinguish a correct rejection from an unintended write.
  6. The probe stops the service and records which receiver ran the candidate with the checked digest.

Transfer recorded by tools/part07_transfer.py and the receiver probe. The Windows reports in results/win/part07 contain all eight replies and process closure.

For the managed Windows delivery the check hashed the names and contents of every regular file, in a stable order. For the Linux native delivery it copied the service out of the staged receiver and compared it with the sender’s digest before starting it. A matching hash answers “did we send these bytes?” The sequence after launch answers “did these bytes do our job?”

The probe first reads health and the empty journal. It submits an invalid job, expects a structured 400 and verifies the journal is still empty. Next it submits rebuild-index, expects a 202 with a Location header, reads the one queued job, repeats the invalid submission and checks the journal again. Reading after both writes distinguishes a correct status code from a handler that silently changed state. The caller still needs a separate observation to claim the worker finished the job. What a 202 acceptance promises.

A base image also chooses a patch owner

A framework-dependent API expects a compatible shared ASP.NET Core runtime in its receiver image. A self-contained API carries the runtime files in the published folder. A Native AOT API incorporates runtime code into its executable and still needs the operating-system dependencies we just inspected. A multi-architecture image index can select an image for each CPU, but the publisher still needs suitable files in each image. Microsoft’s .NET container image variants.

Part 1 measured that effect for this API. On Linux Arm64 and .NET 11, the complete framework-dependent image occupied 252,416,677 bytes uncompressed, the self-contained JIT image 252,275,673 bytes and the native image 162,760,121 bytes. The first two totals ended close despite very different application folder sizes. Their base images provide different contents, and Docker can share layers between deployments. These totals identify the shipped images. They do not measure network transfer, startup or memory per running instance.

When the shared runtime needs a fix, Ravi can rebuild the framework-dependent image using the patched runtime base and redeploy it. Replacing the OS base of a self-contained image does not replace its application-supplied runtime. Rebuild that publish, and rebuild the native file for each target in the native row. Keep the qualifying requests attached to the rebuild so a routine patch cannot silently reintroduce the error-response failure from part 6. Tracing a request that changes after deployment.

Choose the smallest build matrix that answers the release question

The operator tool has the widest receiver set. If those workstations already have a maintained runtime, a portable framework-dependent DLL launched with dotnet is worth considering. The API and worker have a narrower container fleet, so a build per CPU and libc family may be affordable. For the MVC operations console, Dana can choose an ordinary or ReadyToRun publish and test the rendered page. A successful API run qualifies neither the web console nor the partner export.

  • Write down the build OS and CPU, SDK, target RID, publish mode and the oldest supported receiver.
  • Inspect the executable format. For a Linux ELF, identify its interpreter, needed libraries and highest glibc symbol version.
  • Record globalization policy and required CPU features. Label execution on translated or emulated hardware.
  • Verify the transferred folder or file, run a valid and an invalid operation, and inspect the resulting state.
  • Name who will rebuild each affected artifact when the runtime or operating system needs a patch.

Run the receiver check on a machine you can name

To investigate the Alpine failure from the download alone, open results/mac/part07/net11-linux-arm64-api-crossed.json. Compare sender_sha256 with receiver_sha256, then read logs. Open net11-linux-musl-arm64-api-matching.json beside it. The receiver image is the same, the executable digest is different, and the responses array now records what Intake returned.

To exercise your own published API, run ./run.sh 7 or .\run.ps1 7 from the solution directory. Watch the two reads after invalid inputs. Each should return the journal in the state the observer saw before the request. Then inspect tools/part07_probe.py and change the sender hash in a scratch invocation. A mismatched file stops the check before the process starts.

The video course’s lesson 04 follows one build onto a receiver. Here the per-machine folders supply the full target matrix, ELF headers, dependency names and response bodies. To repeat a foreign-target publish, use tools/part07.py build --help and give the command a fresh output directory. Copy the whole managed folder for an ordinary build. On a native receiver, start the probe with the executable and the SHA-256 from the sender’s build record. Keep an untested cell open when the intended receiver is unavailable. Defining what an observation measures.

Further reading

For Alpine Arm64, Dana records the musl-targeted executable and the receiver image that accepted the named job. The glibc delivery has its own file, tested images and globalization settings. Windows x64 on AMD has a verified transfer. The Xeon qualifies the tested code paths on Linux. A Windows/Intel worker, a physical Intel Mac and Windows Arm64 still need their own receiver checks. A change to the runtime, image or processor baseline reopens that row for testing.

Ravi originally proposed native code because the first caller waited after scale-out. The qualified service receivers returned all eight expected responses. Those checks recorded no user-facing latency. Does the wait end when the process starts listening, or when the first correct response reaches the caller?

How .NET Runs Your Code, part 7 of 11. Previous, Trimming and Reflection. Next, Part 8, Startup and First Response.

Written by

Marcin Borecki

Software architect and entrepreneur, Microsoft Regional Director since 2014, with CloudExpert since 2011. I help teams design, measure and ship .NET, Azure, data and AI systems that hold up in production.

Facing this problem in your own system?

I run focused investigations and architecture reviews, and take hands-on roles as an accountable chief architect.

See how I can help