您的位置: 首页  >  技术问答  >  将入站消息的等待延迟限制为每秒的消息数量

将入站消息的等待延迟限制为每秒的消息数量

分类: 技术问答 • 2022-07-22 22:01:01
问题描述：

我正在尝试将循环(正在发送消息)限制为每秒特定数量的消息. _throttle是每秒的消息数.

I am trying to throttle a loop (which is sending messages) to a particular number of messages per second. _throttle is the number of messages per second.

下面描述了我的初始算法，但是延迟并不平稳.
我可以做些什么改善，以消除颇为崎bump的延迟和突发消息.

My initial algorithm is depicted below, but the delays are not smooth.
What improvements can I make to smooth out the rather bumpy delays and bursts of messages.

我一直在打勾和最大间隔，但是入站数量如此之大，难以弥补.在我的实现中，关闭油门后可以达到的最大速率约为15000/秒.我正在以每秒300到1000之间的速率进行测试，因此我试图将其速度放慢一些.

I have played around with the tick, and the interval max, but the inbound count is so large it's hard to compensate. The maximum rate I can achieve with the throttle off in my implementation is about 15000/second. I am testing with rates between 300 and 1000 per second, so I am trying to slow it down quite a bit.

private class ThrottleCalculator
{
    private readonly int _throttle;
    private DateTime _lastCalculation = DateTime.Now;
    private int _count = 0;
    private int _interval = 0;

    public ThrottleCalculator(int throttle)
    {
        this._throttle = throttle;
    }

    public async Task CalculateThrottle()
    {
        this._count += 1;
        var elapsed = DateTime.Now.Subtract(this._lastCalculation).TotalMilliseconds;
        var tick = 50;
        if (elapsed > tick)
        {
            this._lastCalculation = DateTime.Now;
            int projection = this._count * (1000 / tick);
            var errorTerm = this._throttle - projection;
            this._interval = this._interval - errorTerm;
            if (this._interval < 0)
                this._interval = 0;

            // this is often several thousand, so I have to limit.
            if (this._interval > 100)
                this._interval = 100;
            await Task.Delay(this._interval);
            this._count = 0;
        }
    }
}

使用此代码的代码每次迭代都调用此代码.

The code that uses this just calls this every iteration.

var throttle = new ThrottleCalculator(600); // 600/s
while (message = getMessage())
{
    ... // do stuff with message.
    if (throttle != null)
       await throttle.CalculateThrottle();

答

PID控制器算法

对于其他尝试此操作的人，正确的方法是 PID控制器算法.
Proportional / Integral / Derivative Controller

PID Controller Algorithm

for anyone else attempting this, the correct approach is the PID controller algorithm.
Proportional / Integral / Derivative Controller

我以Wiki底部的算法为基础. 我的kp / ki / kd似乎可以很好地与此处的值配合使用，将它们保持成比例似乎可以产生稳定的消息流以及非常紧凑的延迟值.

I used the algorithm at the bottom of the wiki as a base. My kp / ki / kd seem to work well with the values here, keeping them in proportion seems to result in a nice steady stream of messages, and very tight delay values.

private class ThrottleCalculator
{
    private readonly int _throttle;
    private DateTime _lastCalculationTime;
    private double _measured = 0;
    private double _totalError = 0;
    private double _integral = 0;
    private double _lastError = 0;

    public ThrottleCalculator(int throttle)
    {
        this._throttle = throttle;
        this._lastCalculationTime = DateTime.MinValue;
    }

    public async Task CalculateThrottle()
    {
        var kp = -.1d;      // proportional gain
        var ki = -.1d;      // integral gain
        var kd = -.1d;      // derivative gain
        var dt = 30d;       // rate of change of time. calculcations every ms;

        this._measured += 1;
        if (this._lastCalculationTime == DateTime.MinValue)
            this._lastCalculationTime = DateTime.Now;
        var elapsed = (double)DateTime.Now.Subtract(this._lastCalculationTime)
                     .TotalMilliseconds;
        if (elapsed > dt)
        {
            this._lastCalculationTime = DateTime.Now;
            var error = ((double)this._throttle / (1000d / dt)) - this._measured;
            this._totalError += error;
            var integral = this._totalError;
            var derivative = (error - this._lastError) / elapsed;
            var actual = (kp * error) + (ki * integral) + (kd * derivative);
            var output = actual;
            if (output < 1)
                output = 0;

            // i don't like this, but it seems necessary
            // so that wild wait values are never used.
            if (output > dt * 4)
                output = dt * 4;
            if (output > 0)
                await Task.Delay((int)output);
            this._measured = 0;
            this._lastError = error;
        }
    }
}

我的值如下:

Actual: 19.2000 Output: 19.2000 Integral:   -209 Derivative:      .0000 Error:   17
Actual: 17.5000 Output: 17.5000 Integral:   -192 Derivative:      .0000 Error:   17
Actual: 15.8000 Output: 15.8000 Integral:   -175 Derivative:      .0000 Error:   17
Actual: 33.8104 Output: 33.8104 Integral:   -255 Derivative:    -3.1040 Error:  -80
Actual: 21.8931 Output: 21.8931 Integral:   -238 Derivative:     2.0686 Error:   17
Actual: 20.4000 Output: 20.4000 Integral:   -221 Derivative:      .0000 Error:   17
Actual: 18.7000 Output: 18.7000 Integral:   -204 Derivative:      .0000 Error:   17
Actual: 17.0000 Output: 17.0000 Integral:   -187 Derivative:      .0000 Error:   17
Actual: 15.3000 Output: 15.3000 Integral:   -170 Derivative:      .0000 Error:   17
Actual: 31.0752 Output: 31.0752 Integral:   -239 Derivative:    -2.7520 Error:  -69

相关推荐