Make Async Profiler tests compatible with single threaded runtime. (#127762)

Initial async profiler tests used some techniques to isolate tests
running on thread pool, but that doesn't work on single threaded
platforms like WASM.

* Split tests into tests that can run without multithreaded support and
tests that must have thread pool.
* Harden test to only look for specific events using a Task id mapping
to the marker frame used by the test.
* Fix failures on Native AOT due to missing native IP -> Method Name.
* Remove wrapper IP's from metadata event. With JIT they point to the
pre-stub, instead parsers needs rundown events and can create the
wrapper IP table through that. The wrapper count is still in the
metadata event, but the wrapper name is now part of the contract, so
parsers can use rundown events to locate the IP's and build wrapper
table.

With these changes we now have all tests running on CoreCLR, NativeAOT
and 38 out of 48 tests running on CoreCLR WASM single threaded
configuration.

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: lateralusX

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncProfiler.CoreCLR.cs

@@ -123,11 +123,12 @@ private static ulong GetId(ref AsyncDispatcherInfo info)
         /// through the wrapper at index (ContinuationIndex & COUNT_MASK), then increments the index.
         ///
         /// This creates a rotating pattern of unique return addresses on the native callstack. An OS
-        /// CPU profiler (e.g., ETW, perf) captures these native IPs in its stack samples. The async
-        /// profiler emits the wrapper IP table in the metadata event, so a post-processing tool can
-        /// identify which wrapper IPs appear in a native callstack and correlate them with the
-        /// async resume callstack events emitted at the same logical point. This bridges the gap
-        /// between synchronous native stack samples and the asynchronous continuation chain.
+        /// CPU profiler (e.g., ETW, perf) captures these native IPs in its stack samples. A post-processing
+        /// tool uses the wrapper name template and count (defined by the async profiler contract) to
+        /// format method names, resolve them via symbol data (rundown events), and correlate
+        /// native stack IPs with the async resume callstack events emitted at the same logical point.
+        /// This bridges the gap between synchronous native stack samples and the asynchronous
+        /// continuation chain.
         ///
         /// Every COUNT (32) continuations, a ResetAsyncContinuationWrapperIndex event is emitted
         /// so the tool knows the index has wrapped around and can correctly map subsequent samples.
@@ -138,6 +139,20 @@ private static ulong GetId(ref AsyncDispatcherInfo info)
         [StackTraceHidden]
         internal static partial class ContinuationWrapper
         {
+            /// <summary>
+            /// Name template for the continuation wrapper methods, defined by contract.
+            /// External tools format this template with the wrapper index (0..COUNT-1) to produce
+            /// method names for identifying wrapper frames in stacks.
+            /// Must match the actual method names below (e.g., Continuation_Wrapper_0, Continuation_Wrapper_1, ...).
+            /// </summary>
+            public const string NameTemplate = "Continuation_Wrapper_{0}";
+
+            /// <summary>
+            /// Number of distinct wrapper methods. The wrapper index rotates modulo this value.
+            /// </summary>
+            public const byte COUNT = 32;
+            public const byte COUNT_MASK = COUNT - 1;
+
             public static void InitInfo(ref Info info)
             {
                 info.ContinuationTable = ref Unsafe.As<ContinuationWrapperTable, nint>(ref s_continuationWrappers);
@@ -154,16 +169,6 @@ public static void InitInfo(ref Info info)
                 }
             }
 
-            public static long[] GetContinuationWrapperIPs()
-            {
-                long[] ips = new long[COUNT];
-                for (int i = 0; i < COUNT; i++)
-                {
-                    ips[i] = Unsafe.Add(ref Unsafe.As<ContinuationWrapperTable, nint>(ref s_continuationWrappers), i);
-                }
-                return ips;
-            }
-
             [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
             private static unsafe Continuation? Continuation_Wrapper_0(Continuation continuation, ref byte resultLoc)
             {

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncProfiler.cs

@@ -107,37 +107,28 @@ public static void EmitAsyncProfilerMetadataIfNeeded(AsyncThreadContext context)
                     {
                         if (s_metadataRevision != Revision)
                         {
-                            long[] wrapperIPs = ContinuationWrapper.GetContinuationWrapperIPs();
-
                             // Metadata payload:
                             // [qpcFrequency (compressed uint64)]
                             // [qpcSync (compressed uint64)]
                             // [utcSync (compressed uint64)]
                             // [eventBufferSize (compressed uint32)]
                             // [wrapperCount byte]
-                            // [wrapperIP0 (compressed uint64)] ... [wrapperIPn (compressed uint64)]
                             const int MaxStaticEventPayloadSize = Serializer.MaxCompressedUInt64Size + Serializer.MaxCompressedUInt64Size + Serializer.MaxCompressedUInt64Size + Serializer.MaxCompressedUInt32Size + 1;
-                            int maxDynamicEventPayloadSize = wrapperIPs.Length * Serializer.MaxCompressedUInt64Size;
 
                             ref EventBuffer eventBuffer = ref context.EventBuffer;
-                            if (Serializer.AsyncEventHeader(context, ref eventBuffer, AsyncEventID.AsyncProfilerMetadata, MaxStaticEventPayloadSize + maxDynamicEventPayloadSize))
+                            if (Serializer.AsyncEventHeader(context, ref eventBuffer, AsyncEventID.AsyncProfilerMetadata, MaxStaticEventPayloadSize))
                             {
                                 SyncClock(out long utcTimeSync, out long qpcSync);
 
-                                Span<byte> payloadSpan = eventBuffer.Data.AsSpan(eventBuffer.Index, MaxStaticEventPayloadSize + maxDynamicEventPayloadSize);
+                                Span<byte> payloadSpan = eventBuffer.Data.AsSpan(eventBuffer.Index, MaxStaticEventPayloadSize);
                                 int payloadSpanIndex = 0;
 
                                 payloadSpanIndex += Serializer.WriteCompressedUInt64(payloadSpan.Slice(payloadSpanIndex), (ulong)Stopwatch.Frequency);
                                 payloadSpanIndex += Serializer.WriteCompressedUInt64(payloadSpan.Slice(payloadSpanIndex), (ulong)qpcSync);
                                 payloadSpanIndex += Serializer.WriteCompressedUInt64(payloadSpan.Slice(payloadSpanIndex), (ulong)utcTimeSync);
                                 payloadSpanIndex += Serializer.WriteCompressedUInt32(payloadSpan.Slice(payloadSpanIndex), EventBufferSize);
 
-                                payloadSpan[payloadSpanIndex++] = (byte)wrapperIPs.Length;
-
-                                for (int i = 0; i < wrapperIPs.Length; i++)
-                                {
-                                    payloadSpanIndex += Serializer.WriteCompressedUInt64(payloadSpan.Slice(payloadSpanIndex), (ulong)wrapperIPs[i]);
-                                }
+                                payloadSpan[payloadSpanIndex++] = ContinuationWrapper.COUNT;
 
                                 eventBuffer.Index += payloadSpanIndex;
 
@@ -857,9 +848,6 @@ public static void EmitEvent(AsyncThreadContext context)
 
         internal static partial class ContinuationWrapper
         {
-            public const byte COUNT = 32;
-            public const byte COUNT_MASK = COUNT - 1;
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static void IncrementIndex(ref Info info)
             {