Use contention detection for self-tuning

Author: VSadov

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Lock.NativeAot.cs

@@ -3,33 +3,27 @@
 
 using System.Diagnostics;
 using System.Diagnostics.Tracing;
+using System.Runtime;
 using System.Runtime.CompilerServices;
 
 namespace System.Threading
 {
     public sealed partial class Lock
     {
-        private const short SpinCountNotInitialized = short.MinValue;
-
         // NOTE: Lock must not have a static (class) constructor, as Lock itself is used to synchronize
         // class construction.  If Lock has its own class constructor, this can lead to infinite recursion.
         // All static data in Lock must be lazy-initialized.
         private static int s_staticsInitializationStage;
-        private static bool s_isSingleProcessor;
+        private static int s_processorCount;
         private static short s_maxSpinCount;
         private static short s_minSpinCount;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Lock"/> class.
-        /// </summary>
-        public Lock() => _spinCount = SpinCountNotInitialized;
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal bool TryEnterOneShot(int currentManagedThreadId)
         {
             Debug.Assert(currentManagedThreadId != 0);
 
-            if (State.TryLock(this))
+            if (this.TryLock())
             {
                 Debug.Assert(_owningThreadId == 0);
                 Debug.Assert(_recursionCount == 0);
@@ -54,20 +48,20 @@ internal void Exit(int currentManagedThreadId)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private ThreadId TryEnterSlow(int timeoutMs, ThreadId currentThreadId) =>
+        private bool TryEnterSlow(int timeoutMs, ThreadId currentThreadId) =>
             TryEnterSlow(timeoutMs, currentThreadId, this);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal bool TryEnterSlow(int timeoutMs, int currentManagedThreadId, object associatedObject) =>
-            TryEnterSlow(timeoutMs, new ThreadId((uint)currentManagedThreadId), associatedObject).IsInitialized;
+            TryEnterSlow(timeoutMs, new ThreadId((uint)currentManagedThreadId), associatedObject);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal bool GetIsHeldByCurrentThread(int currentManagedThreadId)
         {
             Debug.Assert(currentManagedThreadId != 0);
 
             bool isHeld = _owningThreadId == (uint)currentManagedThreadId;
-            Debug.Assert(!isHeld || new State(this).IsLocked);
+            Debug.Assert(!isHeld || this.IsLocked);
             return isHeld;
         }
 
@@ -76,14 +70,9 @@ internal uint ExitAll()
             Debug.Assert(IsHeldByCurrentThread);
 
             uint recursionCount = _recursionCount;
-            _owningThreadId = 0;
             _recursionCount = 0;
 
-            State state = State.Unlock(this);
-            if (state.HasAnyWaiters)
-            {
-                SignalWaiterIfNecessary(state);
-            }
+            ReleaseCore();
 
             return recursionCount;
         }
@@ -96,108 +85,65 @@ internal void Reenter(uint previousRecursionCount)
             _recursionCount = previousRecursionCount;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private TryLockResult LazyInitializeOrEnter()
+        // Returns false until the static variable is lazy-initialized
+        internal static bool IsSingleProcessor => s_processorCount == 1;
+
+        internal static void LazyInit()
         {
-            StaticsInitializationStage stage = (StaticsInitializationStage)Volatile.Read(ref s_staticsInitializationStage);
-            switch (stage)
+            s_maxSpinCount = DefaultMaxSpinCount;
+            s_minSpinCount = DefaultMinSpinCount;
+            s_processorCount = RuntimeImports.RhGetProcessCpuCount();
+
+            // the rest is optional, but let's try once
+            if (s_staticsInitializationStage != (int)StaticsInitializationStage.Complete)
             {
-                case StaticsInitializationStage.Complete:
-                    if (_spinCount == SpinCountNotInitialized)
-                    {
-                        _spinCount = s_maxSpinCount;
-                    }
-                    return TryLockResult.Spin;
-
-                case StaticsInitializationStage.Started:
-                    // Spin-wait until initialization is complete or the lock is acquired to prevent class construction cycles
-                    // later during a full wait
-                    bool sleep = true;
-                    while (true)
-                    {
-                        if (sleep)
-                        {
-                            Thread.UninterruptibleSleep0();
-                        }
-                        else
-                        {
-                            Thread.SpinWait(1);
-                        }
-
-                        stage = (StaticsInitializationStage)Volatile.Read(ref s_staticsInitializationStage);
-                        if (stage == StaticsInitializationStage.Complete)
-                        {
-                            goto case StaticsInitializationStage.Complete;
-                        }
-                        else if (stage == StaticsInitializationStage.NotStarted)
-                        {
-                            goto default;
-                        }
-
-                        if (State.TryLock(this))
-                        {
-                            return TryLockResult.Locked;
-                        }
-
-                        sleep = !sleep;
-                    }
-
-                default:
-                    Debug.Assert(stage == StaticsInitializationStage.NotStarted);
-                    if (TryInitializeStatics())
-                    {
-                        goto case StaticsInitializationStage.Complete;
-                    }
-                    goto case StaticsInitializationStage.Started;
+                InitStatics();
             }
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static bool TryInitializeStatics()
+        internal static bool InitStatics()
         {
-            // Since Lock is used to synchronize class construction, and some of the statics initialization may involve class
-            // construction, update the stage first to avoid infinite recursion
-            switch (
-                (StaticsInitializationStage)
-                Interlocked.CompareExchange(
-                    ref s_staticsInitializationStage,
-                    (int)StaticsInitializationStage.Started,
-                    (int)StaticsInitializationStage.NotStarted))
+            if (s_staticsInitializationStage != (int)StaticsInitializationStage.Started)
             {
-                case StaticsInitializationStage.Started:
-                    return false;
-                case StaticsInitializationStage.Complete:
+                // prevent reentrancy on the same thread
+                s_staticsInitializationStage = (int)StaticsInitializationStage.Started;
+                try
+                {
+                    s_minSpinCount = DetermineMinSpinCount();
+                    s_maxSpinCount = DetermineMaxSpinCount();
+                    NativeRuntimeEventSource.Log.IsEnabled();
+
+                    Volatile.Write(ref s_staticsInitializationStage, (int)StaticsInitializationStage.Complete);
                     return true;
+                }
+                catch
+                {
+                    // Callers can't handle this failure and also guarantee not coming here again because anything may take locks.
+                    // However initializing statics is optional, so just ignore the failure.
+                    s_staticsInitializationStage = (int)StaticsInitializationStage.NotStarted;
+                }
             }
 
-            try
-            {
-                s_isSingleProcessor = Environment.IsSingleProcessor;
-                s_maxSpinCount = DetermineMaxSpinCount();
-                s_minSpinCount = DetermineMinSpinCount();
+            return false;
+        }
 
-                // Also initialize some types that are used later to prevent potential class construction cycles
-                NativeRuntimeEventSource.Log.IsEnabled();
-            }
-            catch
+        internal static bool StaticsInitComplete()
+        {
+            if (Volatile.Read(ref s_staticsInitializationStage) == (int)StaticsInitializationStage.Complete)
             {
-                s_staticsInitializationStage = (int)StaticsInitializationStage.NotStarted;
-                throw;
+                return true;
             }
 
-            Volatile.Write(ref s_staticsInitializationStage, (int)StaticsInitializationStage.Complete);
-            return true;
+            return InitStatics();
         }
 
-        // Returns false until the static variable is lazy-initialized
-        internal static bool IsSingleProcessor => s_isSingleProcessor;
-
         // Used to transfer the state when inflating thin locks
         internal void InitializeLocked(int managedThreadId, uint recursionCount)
         {
             Debug.Assert(recursionCount == 0 || managedThreadId != 0);
 
-            _state = managedThreadId == 0 ? State.InitialStateValue : State.LockedStateValue;
+            _state = managedThreadId == 0 ? Unlocked : Locked;
             _owningThreadId = (uint)managedThreadId;
             _recursionCount = recursionCount;
         }

src/libraries/System.Private.CoreLib/src/System/Threading/Lock.NonNativeAot.cs

@@ -11,12 +11,8 @@ public sealed partial class Lock
         private static readonly short s_maxSpinCount = DetermineMaxSpinCount();
         private static readonly short s_minSpinCount = DetermineMinSpinCount();
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Lock"/> class.
-        /// </summary>
-        public Lock() => _spinCount = s_maxSpinCount;
-
-        private static TryLockResult LazyInitializeOrEnter() => TryLockResult.Spin;
+        private static void LazyInit() { }
+        private static bool StaticsInitComplete() => true;
         private static bool IsSingleProcessor => Environment.IsSingleProcessor;
 
         internal partial struct ThreadId