gaprate.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/gaprate.cc" -*-
#ifndef CLICK_GAPRATE_HH
#define CLICK_GAPRATE_HH
#include <click/timestamp.hh>
CLICK_DECLS
class ErrorHandler;
 
class GapRate { public:
 
    inline GapRate();
 
    inline GapRate(uint64_t r);
 
    inline uint64_t rate() const;
 
    inline void set_rate(uint64_t r);
 
    void set_rate(uint64_t r, ErrorHandler *errh);
 
 
    inline bool need_update(const Timestamp &ts);
 
    inline Timestamp expiry() const;
 
    inline void update();
 
    inline void update_with(int64_t delta);
 
    inline void reset();
 
 
    enum { UGAP_SHIFT = 43 };
    enum { MAX_RATE = 1000000ULL << UGAP_SHIFT };
 
  private:
 
    uint64_t _ugap;             // (1000000 << UGAP_SHIFT) / _rate
    int64_t _sec_count;         // number of updates this second so far
    Timestamp::seconds_type _tv_sec;    // current second
    uint64_t _rate;             // desired rate
#if DEBUG_GAPRATE
    Timestamp _last;
#endif
 
    inline void initialize_rate(uint64_t rate);
 
};
 
inline void
GapRate::reset()
{
    _tv_sec = -1;
#if DEBUG_GAPRATE
    _last.set_sec(0);
#endif
}
 
inline void
GapRate::initialize_rate(uint64_t r)
{
    _rate = r;
    _ugap = (r == 0 ? MAX_RATE + 1 : MAX_RATE / r);
#if DEBUG_GAPRATE
    click_chatter("ugap: %u", _ugap);
#endif
}
 
inline void
GapRate::set_rate(uint64_t r)
{
    if (r > MAX_RATE)
        r = MAX_RATE;
    if (_rate != r) {
        initialize_rate(r);
        if (_tv_sec >= 0 && r != 0) {
            Timestamp now = Timestamp::now();
            _sec_count = (static_cast<uint64_t>(now.usec()) << UGAP_SHIFT) / _ugap;
        }
    }
}
 
inline
GapRate::GapRate()
{
    initialize_rate(0);
    reset();
}
 
inline
GapRate::GapRate(uint64_t r)
    : _rate(0)
{
    initialize_rate(r);
    reset();
}
 
inline uint64_t
GapRate::rate() const
{
    return _rate;
}
 
inline bool
GapRate::need_update(const Timestamp &now)
{
    // this is an approximation of:
    // uint64_t need = (uint64_t) ((now.usec() / 1000000.0) * _rate)
    uint64_t need = (static_cast<uint64_t>(now.usec()) << UGAP_SHIFT) / _ugap;
 
    if (_tv_sec < 0) {
        // 27.Feb.2005: often OK to send a packet after reset unless rate is
        // 0 -- requested by Bart Braem
        // check include/click/gaprate.hh (1.2)
        _tv_sec = now.sec();
        _sec_count = need + ((static_cast<uint64_t>(now.usec()) << UGAP_SHIFT) - (need * _ugap) > _ugap / 2);
    } else if (now.sec() > _tv_sec) {
        _tv_sec = now.sec();
        if (_sec_count > 0)
            _sec_count -= _rate;
    }
 
#if DEBUG_GAPRATE
    click_chatter("%p{timestamp} -> %u @ %u [%d]", &now, need, _sec_count, (int)need >= _sec_count);
#endif
    return ((int64_t)need >= _sec_count);
}
 
inline void
GapRate::update()
{
    _sec_count++;
}
 
inline void
GapRate::update_with(int64_t delta)
{
    _sec_count += delta;
}
 
inline Timestamp
GapRate::expiry() const
{
    if (_tv_sec < 0 || _rate == 0)
        return Timestamp();
    else if (_sec_count < 0)
        return Timestamp(_tv_sec, 0);
    else {
        Timestamp::seconds_type sec = _tv_sec;
        int64_t count = _sec_count;
        if ((uint64_t) count >= _rate) {
            sec += count / _rate;
            count = count % _rate;
        }
 
        // uint32_t usec = (int) (count * 1000000.0 / _rate)
        uint32_t usec = (count * _ugap) >> UGAP_SHIFT;
        return Timestamp::make_usec(sec, usec);
    }
}
 
CLICK_ENDDECLS
#endif