[wasm-ep] Implement EventSource counters support; add an EventPipeSessionOptions builder to TS (dotnet#69567)

1. Implements support for creating event counters in WebAssembly apps.
   **Important change** adds `Thread.IsInternalThreadStartSupported` and `Thread.InternalUnsafeStart()` to `System.Threading.Thread` that can be used by System.Private.CoreLib to start threads on a runtime where `Thread.IsThreadStartSupported` is false.
   This is used to create the event counters polling thread.
   This is in addition to the native runtime being able to create threads using `mono_thread_create_internal`
2. Coop thread suspend: STW calls `mono_threads_platform_stw_defer_initial_suspend` which postpones suspending a thread until the next GC suspend phase.  Doesn't do anything on most platforms.  On WASM, suspend the main browser thread after all the other threads are suspended. This helps prevent deadlocks where the main thread is suspended while another thread is doing a call that is proxied to the main thread and cannot complete.  By suspending the main thread last, we give it a chance to service the other threads' requests.
2. Adds a `MONO.diagnostics.SessionOptionsBuilder` class that can be used to create an `EventPipeSessionOptions` instance and populate the provider string for an event pipe session.
3. Updated the `browser-eventpipe` sample to create an EventSource and some counters.  The sample is now interactive so you have to click "Start Work" in a browser for things to happen.

There's an outstanding issue dotnet#69568 that will be investigated in a follow-up PR

* Add custom EventSource and counter

   - Added a method for coop GC to suspend the main browser thread in the second phase (so that other threads are less likely to deadlock if they delegate work to it)

   - Added an event provider builder

   - Added a Thread.InternalUnsafeStart() method and a IsInternalThreadStartSupported property.  This allows EventSource to start a thread to poll the counter values.

   - The sample with counters can now record counter values.  But not at the same time as the default configuration (runtime, runtime private, sample profiler).  Not sure if it's a wasm issue or a limitation of EventPipe.

* Change ProvidersConfigBuilder to SessionOptionsBuilder

   it creates an entire EventPipeSessionOptions object, not just the providers config

* checkout interactive demo

* Add docs; fix whitespace

* more whitespace fixes

* add default arg value to ThrowIfNoThreadStart

* fix build

* Review feedback

Author: lambdageek

src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs

@@ -158,7 +158,7 @@ private void EnableTimer(float pollingIntervalInSeconds)
 #if ES_BUILD_STANDALONE
                         s_pollingThread.Start();
 #else
-                        s_pollingThread.UnsafeStart();
+                        s_pollingThread.InternalUnsafeStart();
 #endif
                     }
 

src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs

@@ -153,20 +153,24 @@ public Thread(ParameterizedThreadStart start, int maxStackSize)
             Initialize();
         }
 
-#if !TARGET_BROWSER
-        internal static bool IsThreadStartSupported => true;
-#else
-#if FEATURE_WASM_THREADS
+#if !TARGET_BROWSER || FEATURE_WASM_THREADS
         internal static bool IsThreadStartSupported => true;
+        internal static bool IsInternalThreadStartSupported => true;
+#elif FEATURE_WASM_PERFTRACING
+        internal static bool IsThreadStartSupported => false;
+        internal static bool IsInternalThreadStartSupported => true;
 #else
         internal static bool IsThreadStartSupported => false;
-#endif
+        internal static bool IsInternalThreadStartSupported => false;
 #endif
 
-        internal static void ThrowIfNoThreadStart()
+        internal static void ThrowIfNoThreadStart(bool internalThread = false)
         {
-            if (!IsThreadStartSupported)
-                throw new PlatformNotSupportedException();
+            if (IsThreadStartSupported)
+                return;
+            if (IsInternalThreadStartSupported && internalThread)
+                return;
+            throw new PlatformNotSupportedException();
         }
 
         /// <summary>Causes the operating system to change the state of the current instance to <see cref="ThreadState.Running"/>, and optionally supplies an object containing data to be used by the method the thread executes.</summary>
@@ -187,9 +191,9 @@ internal static void ThrowIfNoThreadStart()
         /// </remarks>
         public void UnsafeStart(object? parameter) => Start(parameter, captureContext: false);
 
-        private void Start(object? parameter, bool captureContext)
+        private void Start(object? parameter, bool captureContext, bool internalThread = false)
         {
-            ThrowIfNoThreadStart();
+            ThrowIfNoThreadStart(internalThread);
 
             StartHelper? startHelper = _startHelper;
 
@@ -224,9 +228,11 @@ private void Start(object? parameter, bool captureContext)
         /// </remarks>
         public void UnsafeStart() => Start(captureContext: false);
 
-        private void Start(bool captureContext)
+        internal void InternalUnsafeStart() => Start(captureContext: false, internalThread: true);
+
+        private void Start(bool captureContext, bool internalThread = false)
         {
-            ThrowIfNoThreadStart();
+            ThrowIfNoThreadStart(internalThread);
             StartHelper? startHelper = _startHelper;
 
             // In the case of a null startHelper (second call to start on same thread)

src/mono/mono/metadata/threads.c

@@ -4819,7 +4819,11 @@ ves_icall_System_Threading_Thread_StartInternal (MonoThreadObjectHandle thread_h
 	MonoThread *internal = MONO_HANDLE_RAW (thread_handle);
 	gboolean res;
 
-#if defined (DISABLE_THREADS) || defined (DISABLE_WASM_USER_THREADS)
+#if defined (DISABLE_THREADS)
+	/*
+	 * N.B. not checking DISABLE_WASM_USER_THREADS - managed utility threads are allowed; we assume all
+	 * callers of System.Thread.StartCore called System.Thread.ThrowIfNotSupported(bool internalThread)
+	 */
 	mono_error_set_platform_not_supported (error, "Cannot start threads on this runtime.");
 	return;
 #endif

src/mono/mono/utils/mono-threads-wasm.c

@@ -393,6 +393,23 @@ mono_threads_wasm_is_browser_thread (void)
 #endif
 }
 
+MonoNativeThreadId
+mono_threads_wasm_browser_thread_tid (void)
+{
+#ifdef DISABLE_THREADS
+	return (MonoNativeThreadId)1;
+#else
+	return (MonoNativeThreadId)emscripten_main_browser_thread_id ();
+#endif
+}
+
+gboolean
+mono_threads_platform_stw_defer_initial_suspend (MonoThreadInfo *info)
+{
+	/* Suspend the browser thread after all the other threads are suspended already. */
+	return mono_native_thread_id_equals (mono_thread_info_get_tid (info), mono_threads_wasm_browser_thread_tid ());
+}
+
 #ifndef DISABLE_THREADS
 void
 mono_threads_wasm_async_run_in_main_thread (void (*func) (void))

src/mono/mono/utils/mono-threads-wasm.h

@@ -9,6 +9,7 @@
 #define __MONO_THREADS_WASM_H__
 
 #include <glib.h>
+#include <mono/utils/mono-threads.h>
 
 #ifdef HOST_WASM
 
@@ -22,6 +23,9 @@
 gboolean
 mono_threads_wasm_is_browser_thread (void);
 
+MonoNativeThreadId
+mono_threads_wasm_browser_thread_tid (void);
+
 #ifndef DISABLE_THREADS
 /**
  * Runs the given function asynchronously on the main thread.

src/mono/mono/utils/mono-threads.c

@@ -1099,6 +1099,8 @@ begin_suspend_peek_and_preempt (MonoThreadInfo *info);
 MonoThreadBeginSuspendResult
 mono_thread_info_begin_suspend (MonoThreadInfo *info, MonoThreadSuspendPhase phase)
 {
+	if (phase == MONO_THREAD_SUSPEND_PHASE_INITIAL && mono_threads_platform_stw_defer_initial_suspend (info))
+		return MONO_THREAD_BEGIN_SUSPEND_NEXT_PHASE;
 	if (phase == MONO_THREAD_SUSPEND_PHASE_MOPUP && mono_threads_is_hybrid_suspension_enabled ())
 		return begin_suspend_peek_and_preempt (info);
 	else
@@ -2171,3 +2173,10 @@ mono_thread_info_get_tools_data (void)
 	return info ? info->tools_data : NULL;
 }
 
+#ifndef HOST_WASM
+gboolean
+mono_threads_platform_stw_defer_initial_suspend (MonoThreadInfo *info)
+{
+	return FALSE;
+}
+#endif

src/mono/mono/utils/mono-threads.h

@@ -634,6 +634,7 @@ void mono_threads_platform_init (void);
 gboolean mono_threads_platform_in_critical_region (THREAD_INFO_TYPE *info);
 gboolean mono_threads_platform_yield (void);
 void mono_threads_platform_exit (gsize exit_code);
+gboolean mono_threads_platform_stw_defer_initial_suspend (THREAD_INFO_TYPE *info);
 
 void mono_threads_coop_begin_global_suspend (void);
 void mono_threads_coop_end_global_suspend (void);

src/mono/sample/wasm/browser-eventpipe/Program.cs

@@ -5,10 +5,65 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Diagnostics.Tracing;
 
 
 namespace Sample
 {
+
+    [EventSource(Name = "WasmHello")]
+    public class WasmHelloEventSource  : EventSource
+    {
+        public static readonly WasmHelloEventSource Instance = new ();
+
+        private IncrementingEventCounter _calls;
+
+        private WasmHelloEventSource ()
+        {
+        }
+
+        [NonEvent]
+        public void NewCallsCounter()
+        {
+            _calls?.Dispose();
+            _calls = new ("fib-calls", this)
+            {
+                DisplayName = "Recursive Fib calls",
+            };
+        }
+
+        [NonEvent]
+        public void CountCall() {
+            _calls?.Increment(1.0);
+        }
+
+        protected override void Dispose (bool disposing)
+        {
+            _calls?.Dispose();
+            _calls = null;
+
+            base.Dispose(disposing);
+        }
+
+        [Event(1, Message="Started Fib({0})", Level = EventLevel.Informational)]
+        public void StartFib(int n)
+        {
+            if (!IsEnabled())
+                return;
+
+            WriteEvent(1, n);
+        }
+
+        [Event(2, Message="Stopped Fib({0}) = {1}", Level = EventLevel.Informational)]
+        public void StopFib(int n, string result)
+        {
+            if (!IsEnabled())
+                return;
+
+            WriteEvent(2, n, result);
+        }
+    }
+
     public class Test
     {
         public static void Main(string[] args)
@@ -34,24 +89,34 @@ private static long recursiveFib (int n)
                 return 0;
             if (n == 1)
                 return 1;
+            WasmHelloEventSource.Instance.CountCall();
             return recursiveFib (n - 1) + recursiveFib (n - 2);
         }
 
-        public static async Task<int> StartAsyncWork()
+        public static async Task<double> StartAsyncWork(int N)
         {
             CancellationToken ct = GetCancellationToken();
+            await Task.Delay(1);
             long b;
-            const int N = 35;
-            const long expected = 9227465;
+            WasmHelloEventSource.Instance.NewCallsCounter();
+            iterations = 0;
             while (true)
             {
-                await Task.Delay(1).ConfigureAwait(false);
+                WasmHelloEventSource.Instance.StartFib(N);
+                await Task.Delay(1);
                 b = recursiveFib (N);
+                WasmHelloEventSource.Instance.StopFib(N, b.ToString());
+                iterations++;
                 if (ct.IsCancellationRequested)
                     break;
-                iterations++;
             }
-            return b == expected ? 42 : 0;
+            long expected = fastFib(N);
+            if (expected == b)
+                return (double)b;
+            else {
+                Console.Error.WriteLine ("expected {0}, but got {1}", expected, b);
+                return 0.0;
+            }
         }
 
         public static void StopWork()
@@ -63,5 +128,19 @@ public static string GetIterationsDone()
         {
             return iterations.ToString();
         }
+
+        private static long fastFib(int N) {
+            if (N < 1)
+                return 0;
+            long a = 0;
+            long b = 1;
+            for (int i = 1; i < N; ++i) {
+                long tmp = a+b;
+                a = b;
+                b = tmp;
+            }
+            return b;
+        }
+
     }
 }

src/mono/sample/wasm/browser-eventpipe/Wasm.Browser.EventPipe.Sample.csproj

@@ -10,6 +10,7 @@
     <GenerateRunScriptForSample Condition="'$(ArchiveTests)' == 'true'">true</GenerateRunScriptForSample>
     <RunScriptCommand>$(ExecXHarnessCmd) wasm test-browser  --app=. --browser=Chrome $(XHarnessBrowserPathArg) --html-file=index.html --output-directory=$(XHarnessOutput) -- $(MSBuildProjectName).dll</RunScriptCommand>
     <FeatureWasmPerfTracing>true</FeatureWasmPerfTracing>
+    <NoWarn>CA2007</NoWarn> <!-- consider ConfigureAwait() -->
   </PropertyGroup>
 
   <ItemGroup>

src/mono/sample/wasm/browser-eventpipe/index.html

@@ -11,7 +11,11 @@
 
 <body>
   <h3 id="header">Wasm Browser EventPipe profiling Sample</h3>
-  Computing Fib repeatedly: <span id="out"></span>
+  <div>
+    <button id="startWork">Start Work</button>
+    <label for="inputN">N:</label> <input type="number" id="inputN" value="10"/>
+  </div>
+  <div>Computing Fib(N) repeatedly: <span id="out"></span>
   <script type="text/javascript" src="./dotnet.js"></script>
   <script type="text/javascript" src="./dotnet.worker.js"></script>
   <script type="text/javascript" src="./main.js"></script>