[master] Update dependencies from dotnet/arcade dotnet/xharness

* Add Parallel.ForEachAsync

* Address PR feedback and add a few more tests

Also clean up a few things in the src, adding a few more asserts and moving nullable suppressions closer to the point where they're relevant.

* Fix lots of uint[] allocation in BigInteger

- Lots of temporary uint[]s are being created and fed into BigInteger's ctor, which then creates a new one.  This enables using the input in most cases.
- GetPartsForBitManipulation is creating uint[]s for small values, after which it generally gets thrown away.  Stop doing that.
- Stack allocation can be used for smaller values in many cases.

* Address PR feedback

* Fix fragmenetation counter to not return NaN

* add regression test

* Prefer ucontext.h over sys/ucontext.h

* Cleanup redundant _XOPEN_SOURCE definitions

* Remove unused makefile from PAL tests

* Add more sleeps after flush

* remove sleeps and add retry loop

* Fix build

Normally, any JIT-EE GUID change would be accompanied by
a change in the JIT source code, so a JIT build would be
kicked off. But in some cases, such as a change in the
SuperPMI data format to cause an incompatible format, with
a manual change of the GUID to compensate, should also
kick off a JIT build so asmdiff baselines have a JIT
with an appropriate GUID.

[master] Update dependencies from dotnet/xharness

* Ignore data breakpoint during GC
* Simplify disabling DebuggerDataBreakpoint during GC
* Fix destroy pinned handle
* Fix CordbModule::IsMappedLayout  assert to allow using VS with debug/checked runtime builds
Co-authored-by: NChuck Ries <chuckr@microsoft.com>

[master] Update dependencies from mono/linker

* extend the __LINKEDIT. section to cover the single-exe metadata.

* codesign test

Phase 1 of replacing existing infrastructure around handling of pgo data with more flexible schema based approach.

The schema based approach allows the JIT to define the form of data needed for instrumentation.
- The schema associates 4 32bit integers with each data collection point (ILOffset, InstrumentationKind, Count, and Other)
  - Rich meaning is attached to InstrumentationKind, and Count
    - InstrumentationKind defines the size and layout of individual instrumentation data items
    - Count allows a single schema item to be repeated
  - ILOffset and Other are not processed in any specific way by the infrastructure

Changes part of this phase
- PgoManager holds arbitrary amount of pgo data instead of a slab
  - Aware of collectible assemblies
  - Match with pgo data utilizes hash of IL body in addition to IL size information for greater accuracy in match
- JIT no longer uses block count apis, and instead uses schema based apis
  - JIT now explicitly defines the shape of data collected for both basic block and type probes
  - The rest of the system handles that without deep knowledge of what those formats are
- Text file format for pgo data updated
- Existing IBC infrastructure adjusted to speak in terms of schema concept
- Uncompressed and binary encoded implementation of Pgo schema handling
- Update SuperPMI to handle new apis

Future Changes for static Pgo
- Move Pgo type handle histogram processing into JIT
- Extract Pgo data from process using Event infrastructure
- Triggers for controlling Pgo data extraction
- Instrumented Pgo processing as part of dotnet-pgo tool
- Pgo data flow in crossgen2

* Rewrite ARM64 IJW bootstrap thunk.

* Fix alignment.

* Enable AOT Profiler

* Add a `browser-profile` sample

* Clean up Makefile add AotInterp mode to MonoAotMode

* move the shared make logic to wasm.mk
Co-authored-by: NSteve Pfister <steveisok@users.noreply.github.com>
Co-authored-by: NAnkit Jain <radical@gmail.com>

* [wasm][debugger] Move DevToolsQueue to a separate file

* Move Inspector to separate file, mv Support.cs=>DebuggerTest.cs

* [wasm][debugger][tests] Some improvements to DevToolsQueue

- `Pump` -> `TryPump`
- use a ConcurrentQueue instead of a List, for tracking the pending
requests.

DevToolsClient:
- use DevToolsQueue, and remove the redundant code.
- Wake up the runloop when a new send task gets added

* [wasm][debugger] Check Proxy's client_initiated_close early

- this allows the proxy to shutdown quicker, and not have to wait for
the other tasks to get scheduled.

- Fixes the issue of chrome processes left around.

* [wasm][debugger][tests] Inspector - handle event being received before a waiter

.. gets added.

This handles the case where `NotifyOf` gets invoked before a
corresponding `WaitFor` gets called.

* [wasm][debugger][tests] Refactor test harness to support simpler test code

Problem:

- Currently, test methods must call `insp.Ready(..)` with a
callback. And `Ready` takes care of the init, and shutdown for
the proxy, and browser.

- But this means that we have to repeat that boiler plate code in all
the test methods. And the stack traces are deeply nested.

- Instead, we want to have the *test method* contain only the test
specific code.

Solution:

- we want to do that by using xunit's `IAsyncLifetime`, with
methods:
	- `InitializeAsync` - setup proxy+browser here
	- `DisposeAsync` - shutdown

- This would mean that when the *test method* runs, it already has
everything set up, so the code can be just specific to the actual test.

Implementation:

- Improve DevToolsClient's RunLoop, to support this
	- Tries to handle shutdown/close requests explicitly, and not throw
	errors in such cases

	- Adds a `RunLoopStopped` event, which gets invoked with the reason due
	to which it stopped. Eg - Exception getting thrown, cancellation,
	shutdown request etc.

	- With `insp.Ready(..)`, the whole setup (launch proxy, browser,
	run test code) happens from the same *test method*. But here we
	are doing it at separate times, from different methods, and it's
	all async.
		- IOW, there are multiple places where failure can
		happen, and we need to explicitly propogate that, and
		fail the appropriate listeners/tasks/etc
		-> causing the test to correctly fail.

Note: This does not change *any* actual test code! The `Ready` method is
adjusted to use the new init/shutdown bits.
Subsequent commits will make the test changes.

* [wasm][debugger][tests] Port some tests to the simpler test harness bits

We add a `SingleSessionTestBase` class, which implements
`IAsyncLifetime` to init/shutdown the proxy+browser outside the test
methods.

And port `HarnessTests`, and `SteppingTests` to that.

Added a few more tests to `HarnessTests`, to check for common cases like
test methods throwing exceptions, or timing out, or commands failing
etc.
	- This is needed because with the older `insp.Ready` API, the
	whole thing was called from the test method, so failures would
	correctly fail the test.

	- But now we do these things in separate steps, so failing the
	test requires a bit more work in the harness.

Note: I didn't port all the tests in one go, to make the review a bit
simpler. A subsequent PR can move rest of the tests over, and do some
cleanup that it would afford.

* [wasm][debugger][tests] Fix race in ExceptionThrownInJSOutOfBand test

Fix the race where the `Runtime.exceptionThrown` message can be received
before the test calls `WaitFor`, causing it to get missed.

* [wasm][debugger] Formatting fixes on the changes

* Remove unncessary AssertHelpers.ThrowsAsync

Suggested by @lewing !

* [wasm][debugger][tests] Fix a race when sending messages

DevToolsClient.Send adds to `pending_ops`, which can happen while the
list is being modified in `RunLoop`.

Fix: Since, we need to modify it outside `RunLoop` only when a new send
task is available, we can let `RunLoop` itself add it to the list. And use
a taskCompletionSource to wake up the loop.

* Enable host tests on OSX

* initialize Ssl shim on demand

* fix OpenSsl.Tests

* partial modifier

* fixed Cryptography.Algorithms

* first to dlopen libssl wins

* Set official build value to false

* Add pr trigger

* Remove PR

* Adding support for ReciprocalEstimate and ReciprocalSqrtEstimate

* Adding basic documentation comments to the new Math.ReciprocalEstimate functions

* Increasing the epsilon for estimated functions to account for ARM64 only doing a single Newton-Raphson iteration

Follow up change missing in #46323

Fixes #46908

[master] Update dependencies from dotnet/xharness dotnet/runtime-assets dotnet/llvm-project dotnet/icu (#46853)
Co-authored-by: Ndotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Just an unnecessary allocation.  The AsnEncodedData ctor makes a copy regardless of whether the input is a span or an array, so may as well avoid allocating another array on top of that.

Microsoft.NET.ILLink.Tasks
 From Version 6.0.0-alpha.1.21061.5 -> To Version 6.0.0-alpha.1.21063.1
Co-authored-by: Ndotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

My previous unsuccessful pull request   https://github.com/mono/mono/pull/19804
I have improved the logic so that the code is more systematic
Co-authored-by: Nalexger97 <alexger97@users.noreply.github.com>

* Specify a GUID for the IL SDK and expose it to slngen

* Fix 32-bit platform handling of CORINFO_SIG_INST

Previous code was reading an array of pointers as an array of
8-byte elements, leading to some cases of reading beyond
allocated memory and causing access violations. Convert remaining
cases to properly serialized/deserialized pointers.

This is a follow-up to #46604.

Moves all Agnostic types to their own file, agnostic.h, so MethodContext
and CompileResult can share helpers with the same types (previously,
they each had a copy of AgnosticCORINFO_SIG_INFO).

* Remove duplicate types

* Convert CompileResult to use common CORINFO_SIG_INFO functions

Add CrSigInstHandleMap to store handle map for CompileResults.

* Change JIT/EE GUID

SuperPMI format has changed, so change the GUID.

* Revert "Partial rollback of #46244 to workaround #46389 (#46390)"

This reverts commit 43d07801.

* [threads] Check for null longlived thread data

This might happen on netcore if the managed Thread constructor throws an
exception before calling InitInternal.  In that case the finalizer may see a
partially initialized object.

* update TraceEvent version

* remove MicrosoftDiagnosticsTracingTraceEventPackageVersion and consolidate using TraceEventVersion

* Fix profiler test

* extend SocketTestHelper

* SocketHelperMemoryNativeTask: implement UDP methods

* unified test for ReceiveSentMessages_Success

* oops, these overloads are not here yet

* ReceiveSentMessages_ReuseEventArgs_Success

* altering bufferMode does not work on Linux

* remove ReceiveMessageFromAsync.cs

* use AssertExtensions.SequenceEqual

Optimize branches where a branch outcome is fully determined by a dominating
branch, and both true and false values can reach the dominated branch.

throws `System.PlatformNotSupportedException : Cannot wait on monitors on this runtime.`

Partially fixes https://github.com/dotnet/runtime/issues/46768