如何从可观察序列计算出预计到达时间？

Question

I have a method that sends push me updates with the % complete at a given time.

public Task MyMethod(IObserver<double> progress)
{
   ...
}

My consumer does this:

ISubject<double> progressObserver = new Subject<double>();
await MyMethod(progressObserver);

It subscribes to the subject to watch for updates:

progressObserver.Subscribe(percent => Console.WriteLine(percent));

That works nicely, but I would like to calculate an ETA (the estimated time to complete). I know it can be calculated considering the time and percentage, but how?

For sure there's an elegant way to do it using Observables (System.Reactive), maybe taking the last n percentage notifications and the elapsed time between them to estimate when the 100% will be accomplished.

But, excuse me, I don't have a clue on how to do it nicely and elegantly.

Answer 1

It could look like this:

var secondsRemaining = progressObservable
    .Timestamp()
    .Buffer(5, 1)
    .Select(l => ((l[4].Timestamp - l[0].Timestamp).TotalMilliseconds / (l[4].Value - l[0].Value)) * (100 - l[4].Value))
    .Select(msRemaining => msRemaining / 1000);

Explanation:

For each progress update,

• .Buffer(5, 1) releases a list of the last 5 progress updates.
• .Timestamp() staples the timestamp onto each one.
• The first Select operator calculates the amount of milliseconds between the most distant timestamp and the most recent, divides it by progress achieved, and then multiplies it by progress remaining, outputting milliseconds remaining.
• The last Select divides by 1000 to achieve seconds left.

Answer 2

Here's how I would look at this:

IObservable<Timestamped<double>> estimatedCompletion =
    progressObservable
        .Timestamp()
        .Buffer(2, 1)
        .Where(x => x.Count() == 2)
        .Scan((a, b) => a.Take(1).Concat(b).Take(1).Concat(b.Skip(1)).ToList())
        .Select(x => new
        {
            current = x[1].Value,
            delta = x[1].Timestamp.Subtract(x[0].Timestamp),
        })
        .Select(x => new
        {
            x.current,
            rate = x.current / x.delta.TotalSeconds,
        })
        .Select(x => new
        {
            x.current,
            estimated = DateTimeOffset.Now.AddSeconds((1.0 - x.current) / x.rate),
        })
        .Select(x => new Timestamped<double>(x.current, x.estimated));

This produces an IObservable<Timestamped<double>> where the timestamp is the estimated DateTimeOffset that the observable will reach 1.0 (or 100% ).

The key thing is that it uses .Buffer(2, 1).Where(x => x.Count() == 2) to make pairs of values as the observable produces values and then it uses the seemingly complicated .Scan((a, b) => a.Take(1).Concat(b).Take(1).Concat(b.Skip(1)).ToList()) to always produce a pair of the first value with the latest one.

Then it just simply does the estimate calculation in a series of steps.

Because the original sequence goes from 0.0 to 1.0 this will most accurately hone in on the final time. It's only an estimate, but if the steps to get there are fairly consistent then this will be fairly accurate.

You can test it with this code:

var rnd = new Random();
var progressObservable = Observable.Generate(0, x => x <= 100, x => x + 1, x => x / 100.0, x => TimeSpan.FromSeconds(rnd.NextDouble()));