Update()

int int newSampleMs System.Threading.PortableThreadPool.HillClimbing.Update ( int currentThreadCount, double sampleDurationSeconds, int numCompletions )

inline

Definition at line 480 of file PortableThreadPool.cs.

        {
            if (currentThreadCount != _lastThreadCount)
            {
                ForceChange(currentThreadCount, StateOrTransition.Initializing);
            }
            _secondsElapsedSinceLastChange += sampleDurationSeconds;
            _completionsSinceLastChange += numCompletions;
            sampleDurationSeconds += _accumulatedSampleDurationSeconds;
            numCompletions += _accumulatedCompletionCount;
            if (_totalSamples > 0 && ((double)currentThreadCount - 1.0) / (double)numCompletions >= _maxSampleError)
            {
                _accumulatedSampleDurationSeconds = sampleDurationSeconds;
                _accumulatedCompletionCount = numCompletions;
                return (newThreadCount: currentThreadCount, newSampleMs: 10);
            }
            _accumulatedSampleDurationSeconds = 0.0;
            _accumulatedCompletionCount = 0;
            double num = (double)numCompletions / sampleDurationSeconds;
            if (NativeRuntimeEventSource.Log.IsEnabled())
            {
                NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadAdjustmentSample(num, 0);
            }
            int num2 = (int)(_totalSamples % _samplesToMeasure);
            _samples[num2] = num;
            _threadCounts[num2] = currentThreadCount;
            _totalSamples++;
            Complex complex = default(Complex);
            Complex complex2 = default(Complex);
            double num3 = 0.0;
            Complex complex3 = default(Complex);
            double num4 = 0.0;
            StateOrTransition state = StateOrTransition.Warmup;
            int num5 = (int)Math.Min(_totalSamples - 1, _samplesToMeasure) / _wavePeriod * _wavePeriod;
            if (num5 > _wavePeriod)
            {
                double num6 = 0.0;
                double num7 = 0.0;
                for (int i = 0; i < num5; i++)
                {
                    num6 += _samples[(_totalSamples - num5 + i) % _samplesToMeasure];
                    num7 += _threadCounts[(_totalSamples - num5 + i) % _samplesToMeasure];
                }
                double num8 = num6 / (double)num5;
                double num9 = num7 / (double)num5;
                if (num8 > 0.0 && num9 > 0.0)
                {
                    double period = (double)num5 / ((double)num5 / (double)_wavePeriod + 1.0);
                    double num10 = (double)num5 / ((double)num5 / (double)_wavePeriod - 1.0);
                    complex2 = GetWaveComponent(_samples, num5, _wavePeriod) / num8;
                    num3 = (GetWaveComponent(_samples, num5, period) / num8).Abs();
                    if (num10 <= (double)num5)
                    {
                        num3 = Math.Max(num3, (GetWaveComponent(_samples, num5, num10) / num8).Abs());
                    }
                    complex = GetWaveComponent(_threadCounts, num5, _wavePeriod) / num9;
                    if (_averageThroughputNoise == 0.0)
                    {
                        _averageThroughputNoise = num3;
                    }
                    else
                    {
                        _averageThroughputNoise = _throughputErrorSmoothingFactor * num3 + (1.0 - _throughputErrorSmoothingFactor) * _averageThroughputNoise;
                    }
                    if (complex.Abs() > 0.0)
                    {
                        complex3 = (complex2 - _targetThroughputRatio * complex) / complex;
                        state = StateOrTransition.ClimbingMove;
                    }
                    else
                    {
                        complex3 = new Complex(0.0, 0.0);
                        state = StateOrTransition.Stabilizing;
                    }
                    double num11 = Math.Max(_averageThroughputNoise, num3);
                    num4 = ((!(num11 > 0.0)) ? 1.0 : (complex.Abs() / num11 / _targetSignalToNoiseRatio));
                }
            }
            double num12 = Math.Min(1.0, Math.Max(-1.0, complex3.Real));
            num12 *= Math.Min(1.0, Math.Max(0.0, num4));
            double num13 = _maxChangePerSecond * sampleDurationSeconds;
            num12 = Math.Pow(Math.Abs(num12), _gainExponent) * (double)((num12 >= 0.0) ? 1 : (-1)) * num13;
            num12 = Math.Min(num12, _maxChangePerSample);
            PortableThreadPool threadPoolInstance = ThreadPoolInstance;
            if (num12 > 0.0 && threadPoolInstance._cpuUtilization > 95)
            {
                num12 = 0.0;
            }
            _currentControlSetting += num12;
            int val = (int)(0.5 + _currentControlSetting * _averageThroughputNoise * _targetSignalToNoiseRatio * _threadMagnitudeMultiplier * 2.0);
            val = Math.Min(val, _maxThreadWaveMagnitude);
            val = Math.Max(val, 1);
            int maxThreads = threadPoolInstance._maxThreads;
            int minThreadsGoal = threadPoolInstance.MinThreadsGoal;
            _currentControlSetting = Math.Min(maxThreads - val, _currentControlSetting);
            _currentControlSetting = Math.Max(minThreadsGoal, _currentControlSetting);
            int val2 = (int)(_currentControlSetting + (double)(val * (_totalSamples / (_wavePeriod / 2) % 2)));
            val2 = Math.Min(maxThreads, val2);
            val2 = Math.Max(minThreadsGoal, val2);
            if (NativeRuntimeEventSource.Log.IsEnabled())
            {
                NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadAdjustmentStats(sampleDurationSeconds, num, complex.Real, complex2.Real, num3, _averageThroughputNoise, complex3.Real, num4, _currentControlSetting, (ushort)val, 0);
            }
            if (val2 != currentThreadCount)
            {
                ChangeThreadCount(val2, state);
                _secondsElapsedSinceLastChange = 0.0;
                _completionsSinceLastChange = 0.0;
            }
            int item = ((!(complex3.Real < 0.0) || val2 != minThreadsGoal) ? _currentSampleMs : ((int)(0.5 + (double)_currentSampleMs * (10.0 * Math.Min(0.0 - complex3.Real, 1.0)))));
            return (newThreadCount: val2, newSampleMs: item);
        }