Timer for event throttling

Question

I have the following problem. I want to write a class that handles events and passes it through but reduce its number if there recently was an event. Basically it is debounce. However there is a slight change that if we don't receive events for a while and the latest event was skipped we want to emit this event.

I wrote the following

public class Throttle
{
    private string _latest;
    private DateTime _date = DateTime.MinValue;
    private static TimeSpan _timeout = TimeSpan.FromSeconds(2);
    private readonly Timer _timer;

    public Throttle()
    {
        _timer = new Timer(OnTimer);
    }

    public void Handle(string e)
    {
        lock (_timer)
        {
            var now = DateTime.Now;
            if (now - _date < _timeout)
            {
                _latest = e;
                _timer.Change(TimeSpan.FromSeconds(1), Timeout.InfiniteTimeSpan);
            }
            else
            {
                _date = now;
                _latest = null;
                _timer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
                HandleNext(e);
            }
        }
    }
    
    private void OnTimer(object state)
    {
        lock (_timer)
        {
            if (_latest == null)
            {
                return;
            }
            var e = _latest;
            _latest = null;
            _date = DateTime.Now;
            HandleNext(e);
        }
    }

    private void HandleNext(string s)
    {
        Console.WriteLine(s);
    }
}

It behaves as I want. However when the number of Throttle classes gets high, it noticeably consumes CPU in comparison to version without the timer. However there is no way I can skip the the latest event or postpone it for a long time.

What can you suggest to make it more efficient? And what exactly is the problem?

Answer 1

Using the following function to test, 62% of your CPU usage is used by DateTime.Now and 15% by Timer.Change

static void Main()
{
    var throttle = new Throttle();
    for (int index=0; index < int.MaxValue; index++)
    {
        throttle.Handle("index = " + index);
    }
}

Total runtime: 690.76 seconds

DateTime.Now looks deceptively simple but it's quite expensive, see this for more details. A better approach would be to use Environment.TickCount or System.Diagnostics.Stopwatch which handles it for you:

public class Throttle
{
    private const double _interval = 2000; // timeout in miliseconds
    private string _latest = null;
    private Stopwatch _stopwatch = new Stopwatch();
    private Timer _timer = new Timer(_interval);

    public Throttle()
    {
        _timer.Elapsed += OnTimer;
    }

    public void Handle(string e)
    {
        if (_stopwatch.IsRunning == false)
        {
            HandleNext(e);
            _stopwatch.Start();
        }
        else
        {
            if (_stopwatch.ElapsedMilliseconds > _interval)
            {
                _timer.Stop();
                HandleNext(e);
                _stopwatch.Restart();
                _timer.Start();
            }
            else
            {
                _latest = e;
            }
        }
    }

    public void OnTimer(object sender, ElapsedEventArgs e)
    {
        if (_latest != null)
        {
            if (_stopwatch.ElapsedMilliseconds > _interval)
            {
                HandleNext(_latest);
                _latest = null;
                _stopwatch.Restart();
            }
        }
    }

    private void HandleNext(string s)
    {
        Console.WriteLine(s);
    }
}

Total runtime: 115.74 seconds

This is looking better but a lot of time is still wasted by polling ElapsedMilliseconds. We can refactor the class to simply start and stop the timer as needed:

public class Throttle
{
    private string _latest = null;
    private System.Timers.Timer _timer = null;

    public Throttle()
    {
        _timer = new Timer(2000);
        _timer.Elapsed += OnTimer;
    }

    public void Handle(string e)
    {
        if (_timer.Enabled == false)
        {
             HandleNext(e);
            _timer.Start();
        }
        else
        {
            _latest = e;
        }
    }

    public void OnTimer(object sender, ElapsedEventArgs e)
    {
        if (_latest != null)
        {
            HandleNext(_latest);
            _latest = null;
        }
        else
        {
            _timer.Stop();
        }
    }

    private void HandleNext(string s)
    {
        Console.WriteLine(s);
    }
}

Total runtime: 67.04 seconds

Finally, lots of CPU time is still wasted on formatting the progress string which is rarely used, we can refactor the code to only format it when needed:

public class Throttle
{
    private int _target;
    private int _latest = -1;
    private System.Timers.Timer _timer = null;

    public Throttle(int target, double interval = 200)
    {
        _target = target;
        _timer = new Timer(interval);
        _timer.Elapsed += OnTimer;
    }

    public void Handle(int e)
    {
        if (_timer.Enabled == false)
        {
             HandleNext(e);
            _timer.Start();
        }
        else
        {
            _latest = e;
        }
    }

    public void OnTimer(object sender, ElapsedEventArgs e)
    {
        if (_latest != -1)
        {
            HandleNext(_latest);
            _latest = -1;
        }
        else
        {
            _timer.Stop();
        }
    }

    private void HandleNext(int s)
    {
        Console.WriteLine("index = " + s + " / " + _target);
    }
}

class Program
{
    static void Main()
    {
        var throttle = new Throttle(int.MaxValue);
        for (int index = 0; index < int.MaxValue; index++)
        {
            throttle.Handle(index);
        }
    }
}

Total runtime: 1.07 seconds

Note that Timer is a disposable object and generally speaking you should always dispose of disposable resources. This can also be a good place to ensure that the final event is emitted.

public class Throttle : IDisposable
{
    public void Dispose()
    {
        _timer.Dispose();
        if (_latest != -1)
            HandleNext(_latest);
    }

}

class Program
{
    static void Main()
    {
        using (var throttle = new Throttle(int.MaxValue))
        {
            for (int index = 0; index < int.MaxValue; index++)
            {
                throttle.Handle(index);
            }
        }
    }
}