Question

How could I estimate the instantaneous throughput ? For example, in a way similar to what the browser does when downloading a file. It’s not just a mean throughput, but rather the an instantaneous estimation, maybe with a ‘moving average’. I’m looking for the algorithm, but you can specify it in c++. Ideally, it would not involve a thread (i.e., being continuously refreshed, say every second) but rather be only evaluated when the value is asked.

Answer 1

You can use an exponential moving average, as explained here, but I’ll repeat the formula:

accumulator = (alpha * new_value) + (1.0 - alpha) * accumulator

To achieve an estimation, suppose you intend to query the computation every second, but you want an average over the last minute. Then, here would be one way to get that estimate:

struct AvgBps {
    double rate_;            // The average rate
    double last_;            // Accumulates bytes added until average is computed
    time_t prev_;            // Time of previous update
    AvgBps () : rate_(0), last_(0), prev_(time(0)) {}
    void add (unsigned bytes) {
        time_t now = time(0);
        if (now - prev_ < 60) {       // The update is within the last minute
            last_ += bytes;           // Accumulate bytes into last
            if (now > prev_) {        // More than a second elapsed from previous
                // exponential moving average
                // the more time that has elapsed between updates, the more
                // weight is assigned for the accumulated bytes
                double alpha = (now - prev_)/60.0;
                rate_ = (1 -alpha) * last_ + alpha * rate_;
                last_ = 0;            // Reset last_ (it has been averaged in)
                prev_ = now;          // Update prev_ to current time
            }
        } else {                      // The update is longer than a minute ago
            rate_ = bytes;            // Current update is average rate
            last_ = 0;                // Reset last_
            prev_ = now;              // Update prev_
        }
    }
    double rate () {
        add(0);                       // Compute rate by doing an update of 0 bytes
        return rate_;                 // Return computed rate
    }
};

You should actually use a monotonic clock instead of time.