stgsharp/StgSharp.Common/Threading/AdaptiveBackoffStrategy.cs

// -----------------------------------------------------------------------------
// file="AdaptiveBackoffStrategy"
// Project: StgSharp
// Copyright (c) Nitload.
// SPDX-License-Identifier: MIT
// -----------------------------------------------------------------------------

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;

/// <summary>
///   Efficient adaptive backoff strategy that dynamically selects optimal backoff methods based on
///   system load and success rate
/// </summary>
public struct AdaptiveBackoffStrategy
{

    private const int EVALUATION_INTERVAL_MS = 2000;   // Global re-evaluation interval
    private const int EXPLORATION_PROBABILITY = 10;     // 10% probability to explore non-optimal strategies
    private const int FAST_CONVERGENCE_THRESHOLD = 1000; // Fast convergence threshold

    // Configuration constants
    private const int INITIAL_SPINWAIT_THRESHOLD = 8;  // Cheap spin count for first few SpinWait iterations
    private const int MIN_SAMPLES_FOR_EVALUATION = 100; // Minimum sample count before starting evaluation

    // Global shared state (all threads share learning results)
    private static readonly PerformanceStats[] s_globalStats = new PerformanceStats[3];
    private static volatile BackoffMethod s_globalBestMethod;
    private static volatile int s_evaluationInProgress;
    private static long s_lastGlobalEvaluationTicks;
    private BackoffMethod _currentMethod;
    private int _consecutiveFailures;
    private int _localAttempts;

    // Instance state
    private SpinWait _spinWait;
    private uint _fastRng; // Lightweight pseudo-random number generator

    // Static constructor: initialize optimal strategy based on system characteristics
    static AdaptiveBackoffStrategy()
    {
        // Based on your benchmark results:
        // - Low core count (<= 8): SpinWait has clear advantage
        // - Medium core count (<= 16): Close performance, slightly favor SpinWait
        // - High core count (>= 20): Sleep0 has significant advantage under high concurrency
        int logicalCores = Environment.ProcessorCount;

        if (logicalCores <= 8)
        {
            s_globalBestMethod = BackoffMethod.SpinWait;
        } else if (logicalCores <= 16)
        {
            s_globalBestMethod = BackoffMethod.SpinWait; // Default conservative choice
        } else
        {
            // High core count systems, based on your 64-thread benchmark results   
            s_globalBestMethod = BackoffMethod.Sleep0;
        }

        s_lastGlobalEvaluationTicks = Environment.TickCount64;

        // Initialize statistics array
        for (int i = 0; i < s_globalStats.Length; i++)
        {
            s_globalStats[i].Reset();
        }
    }

    /// <summary>
    ///   Gets the currently used backoff method (for debugging/monitoring)
    /// </summary>
    public readonly BackoffMethod CurrentMethod => _currentMethod;

    /// <summary>
    ///   Gets the globally considered optimal backoff method
    /// </summary>
    public static BackoffMethod GlobalBestMethod => s_globalBestMethod;

    /// <summary>
    ///   Creates a new adaptive backoff strategy instance
    /// </summary>
    public static AdaptiveBackoffStrategy Create()
    {
        return new AdaptiveBackoffStrategy
        {
            _spinWait = default,
            _currentMethod = s_globalBestMethod,
            _consecutiveFailures = 0,
            _localAttempts = 0,
            _fastRng =
            (uint)(Environment.TickCount64 ^ Thread.CurrentThread.ManagedThreadId * 0x9E3779B9U)
        };
    }

    /// <summary>
    ///   Gets global statistics for the specified strategy (for monitoring)
    /// </summary>
    public static (long attempts, long successes, double successRate) GetGlobalStats(
                                                                      BackoffMethod method
    )
    {
        PerformanceStats stats = s_globalStats[(int)method];
        return (stats.Attempts, stats.Successes, stats.SuccessRate);
    }

    /// <summary>
    ///   Called after CAS failure, performs backoff and may switch strategies
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void OnFailureAndBackoff()
    {
        _consecutiveFailures++;

        // Record failure
        s_globalStats[(int)_currentMethod].RecordAttempt(success:false);

        // Periodically re-evaluate global optimal strategy
        if (ShouldEvaluateGlobalStrategy())
        {
            EvaluateAndUpdateGlobalStrategy();
        }

        // Decide whether to switch strategies based on failure count and current strategy
        if (_consecutiveFailures >= INITIAL_SPINWAIT_THRESHOLD && ShouldSwitchStrategy())
        {
            SwitchToOptimalStrategy();
        }

        // Perform the actual backoff operation
        PerformBackoff();
    }

    /// <summary>
    ///   Called after CAS success, resets state
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void OnSuccess()
    {
        // Record success
        s_globalStats[(int)_currentMethod].RecordAttempt(success:true);

        // Reset state
        _spinWait = default;
        _consecutiveFailures = 0;

        // Fast convergence: tend to keep current strategy when continuously successful
        if (_localAttempts < FAST_CONVERGENCE_THRESHOLD)
        {
            _localAttempts++;
        }
    }

    /// <summary>
    ///   Evaluates and updates the global optimal strategy
    /// </summary>
    private static void EvaluateAndUpdateGlobalStrategy()
    {
        // Use CAS to ensure only one thread performs evaluation
        if (Interlocked.CompareExchange(ref s_evaluationInProgress, 1, 0) != 0)
        {
            return;
        }

        try
        {
            long now = Environment.TickCount64;

            // Double-check to avoid duplicate evaluation
            if (now - Volatile.Read(ref s_lastGlobalEvaluationTicks) <= EVALUATION_INTERVAL_MS)
            {
                return;
            }

            BackoffMethod bestMethod = s_globalBestMethod;
            double bestSuccessRate = -1.0;

            // Find the strategy with the highest success rate
            for (int i = 0; i < s_globalStats.Length; i++)
            {
                PerformanceStats stats = s_globalStats[i];
                if (stats.Attempts >= MIN_SAMPLES_FOR_EVALUATION)
                {
                    double successRate = stats.SuccessRate;
                    if (successRate > bestSuccessRate)
                    {
                        bestSuccessRate = successRate;
                        bestMethod = (BackoffMethod)i;
                    }
                }
            }

            // Update global optimal strategy
            s_globalBestMethod = bestMethod;
            Volatile.Write(ref s_lastGlobalEvaluationTicks, now);

            // Reset statistics (maintain exploratory behavior)
            for (int i = 0; i < s_globalStats.Length; i++)
            {
                s_globalStats[i].Reset();
            }
        }
        finally
        {
            Volatile.Write(ref s_evaluationInProgress, 0);
        }
    }

    /// <summary>
    ///   Fast pseudo-random number generator (LCG)
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private uint NextRandom()
    {
        _fastRng = _fastRng * 1103515245U + 12345U;
        return _fastRng;
    }

    /// <summary>
    ///   Performs the actual backoff operation
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)] // Avoid inlining to reduce hot path code size
    private void PerformBackoff()
    {
        switch (_currentMethod)
        {
            case BackoffMethod.SpinWait:
                if (_consecutiveFailures <= INITIAL_SPINWAIT_THRESHOLD)
                {
                    _spinWait.SpinOnce(sleep1Threshold:-1);
                } else if (_spinWait.NextSpinWillYield)
                {
                    int yields = (int)(NextRandom() & 7) + 1; // 1-8 times
                    for (int i = 0; i < yields; i++) {
                        _ = Thread.Yield();
                    }
                } else
                {
                    _spinWait.SpinOnce(sleep1Threshold:-1);
                }
                break;

            case BackoffMethod.Yield:
                _ = Thread.Yield();
                break;

            case BackoffMethod.Sleep0:
                Thread.Sleep(0);
                break;
            default:
                break;
        }
    }

    /// <summary>
    ///   Checks whether global strategy evaluation should be performed
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool ShouldEvaluateGlobalStrategy()
    {
        long now = Environment.TickCount64;
        return now - Volatile.Read(ref s_lastGlobalEvaluationTicks) > EVALUATION_INTERVAL_MS;
    }

    /// <summary>
    ///   Determines whether strategy should be switched
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private bool ShouldSwitchStrategy()
    {
        // Fast convergence phase: reduce strategy switching
        if (_localAttempts < FAST_CONVERGENCE_THRESHOLD && _consecutiveFailures < 32)
        {
            return false;
        }

        // Small probability exploration: occasionally try other strategies even when current is optimal
        return NextRandom() % 100 < EXPLORATION_PROBABILITY || _currentMethod != s_globalBestMethod;
    }

    /// <summary>
    ///   Switches to the currently considered optimal strategy
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void SwitchToOptimalStrategy()
    {
        BackoffMethod targetMethod;

        // Most of the time choose the globally optimal
        if (NextRandom() % 100 >= EXPLORATION_PROBABILITY)
        {
            targetMethod = s_globalBestMethod;
        } else
        {
            // Small probability random exploration
            targetMethod = (BackoffMethod)(NextRandom() % 3);
        }

        if (targetMethod != _currentMethod)
        {
            _currentMethod = targetMethod;
            _spinWait = default; // Reset SpinWait state when switching strategies
            _localAttempts = 0;
        }
    }

    public enum BackoffMethod : byte
    {

        SpinWait = 0,
        Yield = 1,
        Sleep0 = 2

    }

    private struct PerformanceStats
    {

        public long Attempts;
        public long LastResetTicks;
        public long Successes;

        public readonly double SuccessRate => Attempts == 0 ? 0.0 : (double)Successes / Attempts;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void RecordAttempt(
                    bool success
        )
        {
            _ = Interlocked.Increment(ref Attempts);
            if (success) {
                _ = Interlocked.Increment(ref Successes);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Reset()
        {
            Attempts = 0;
            Successes = 0;
            LastResetTicks = Environment.TickCount64;
        }

    }

}