Serialize process-wide memory barriers under Rosetta

[agocke]

Summary

• Serialize the Apple process-wide memory barrier when an x64 process is running under Rosetta.
• Leave native arm64 and Intel macOS behavior unchanged.
• Add an isolated regression test that invokes Interlocked.MemoryBarrierProcessWide concurrently from four threads.

Motivation

Under Rosetta, concurrent calls to thread_get_register_pointer_values can deadlock while reconstructing translated x64 thread state. A standalone stress repro hung in 5 out of 5 runs, with every worker blocked in:

thread_get_register_pointer_values
thread_get_state
Rosetta Runtime Routines

Serializing the existing Mach-based barrier avoids this deadlock while retaining the mechanism recommended for Apple platforms.

This addresses the concurrent-barrier hang reported in #133797. It intentionally does not add a pthread_atfork handler for the separate raw-fork interaction. Normal .NET process creation on macOS uses posix_spawn after #126063.

Validation

• Clean baseline: ./build.sh clr+libs+host
• Changed build: ./build.sh clr+libs+host
• Rosetta runtime: ./build.sh clr+libs+host -arch x64 -cross
• Release CoreCLR builds:
  • ./build.sh clr.native -c Release
  • ./build.sh clr.native -c Release -arch x64 -cross
• System.Threading.Tests: 714 passed on native arm64
• System.Threading.Tests: 714 passed on x64 under Rosetta
• New targeted test passed on native arm64 and x64 under Rosetta
• Negative validation: the new test consistently timed out after 20 seconds when run with an unfixed x64 libcoreclr; it completes in about 5.5 seconds with the fix

Performance

Single-threaded Interlocked.MemoryBarrierProcessWide latency was measured using a Debug x64 testhost under Rosetta, taking the median of 10 process runs with 10,000 calls per run:

	Median latency
Before	35.7 us/call
After	36.4 us/call

The uncontended mutex adds approximately 2% in this configuration. Concurrent calls are intentionally serialized because issuing the Mach register-state queries concurrently is the operation that deadlocks Rosetta.

Note

This pull request description was generated with GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @VSadov
See info in area-owners.md if you want to be subscribed.

[Copilot]

Copilot review overview

🟡 Changes recommended

The regression test must skip when multithreading is unsupported.

Get a fresh assessment by requesting another Copilot review.

Review effort: Lite
Findings: 1

Open (1)

• Skip test when multithreading is unsupported · New

What changed in this PR

This PR serializes process-wide memory barriers under Rosetta to prevent concurrent Mach-state query deadlocks and adds regression coverage.

Changes:

• Adds Rosetta-specific mutex serialization.
• Adds a concurrent four-thread barrier test.

File	Description
src/​native/​minipal/​memorybarrierprocesswide.c	Serializes barrier calls under Rosetta.
src/​libraries/​System.Threading/​tests/​InterlockedTests.cs	Adds concurrent barrier regression coverage.

[eduardo-vp]

LGTM!

[Copilot]

Copilot review overview

🟢 Approval recommended

The targeted synchronization and regression coverage address the documented Rosetta deadlock without affecting other platforms.

Review effort: Balanced
Findings: None

Resolved since last review (1)

• Skip test when multithreading is unsupported