timestamp.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/timestamp.cc" -*-
#ifndef CLICK_TIMESTAMP_HH
#define CLICK_TIMESTAMP_HH
#include <click/glue.hh>
#include <click/type_traits.hh>
#include <click/integers.hh>
#if !CLICK_LINUXMODULE && !CLICK_BSDMODULE
# include <math.h>
#endif
CLICK_DECLS
class String;
class Timestamp;
Timestamp operator+(Timestamp, const Timestamp &);
 
// Timestamp has three possible internal representations, selected by #defines.
// * TIMESTAMP_REP_FLAT64: a 64-bit integer number of nanoseconds
// * TIMESTAMP_REP_BIG_ENDIAN: 32 bits of seconds plus 32 bits of subseconds
// * TIMESTAMP_REP_LITTLE_ENDIAN: 32 bits of subseconds plus 32 bits of seconds
//
// Rationale: The linuxmodule driver must select the same representation as
// Linux's sk_buff tstamp member, which may use any of these representations.
// (Linuxmodule Packet objects are equivalent to sk_buffs, and
// Packet::timestamp_anno() maps to sk_buff::tstamp.  We want to avoid
// conversion expense when accessing timestamp_anno().  More seriously, it is
// very convenient to treat timestamp_anno() as a modifiable reference.)
 
#if !TIMESTAMP_REP_FLAT64 && !TIMESTAMP_REP_BIG_ENDIAN && !TIMESTAMP_REP_LITTLE_ENDIAN
# if CLICK_LINUXMODULE
#  if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
#   define TIMESTAMP_REP_BIG_ENDIAN 1
#  elif BITS_PER_LONG == 64 || defined(CONFIG_KTIME_SCALAR)
#   define TIMESTAMP_REP_FLAT64 1
#  elif defined(__BIG_ENDIAN)
#   define TIMESTAMP_REP_BIG_ENDIAN 1
#  else
#   define TIMESTAMP_REP_LITTLE_ENDIAN 1
#  endif
# elif HAVE_INT64_TYPES && SIZEOF_LONG == 8
#  define TIMESTAMP_REP_FLAT64 1
# elif HAVE_INT64_TYPES && CLICK_BYTE_ORDER == CLICK_LITTLE_ENDIAN
#  define TIMESTAMP_REP_LITTLE_ENDIAN 1
# else
#  define TIMESTAMP_REP_BIG_ENDIAN 1
# endif
#endif
 
 
// Timestamp can use microsecond or nanosecond precision.  Nanosecond
// precision is used if TIMESTAMP_NANOSEC == 1.  In the Linux kernel, we
// choose what Linux uses for sk_buff::tstamp.  Elsewhere, we default to
// microsecond precision (XXX); "./configure --enable-nanotimestamp" selects
// nanosecond precision.
 
#ifndef TIMESTAMP_NANOSEC
# if CLICK_LINUXMODULE
#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
#   define TIMESTAMP_NANOSEC 1
#  endif
# endif
#endif
 
 
// Define TIMESTAMP_MATH_FLAT64 if despite a seconds-and-subseconds
// representation, 64-bit arithmetic should be used for timestamp addition,
// subtraction, and comparisons.  This can be faster than operating on two
// separate 32-bit integers.
 
#if HAVE_INT64_TYPES && !TIMESTAMP_REP_FLAT64
# if (TIMESTAMP_REP_BIG_ENDIAN && CLICK_BYTE_ORDER == CLICK_BIG_ENDIAN) \
    || (TIMESTAMP_REP_LITTLE_ENDIAN && CLICK_BYTE_ORDER == CLICK_LITTLE_ENDIAN)
#  define TIMESTAMP_MATH_FLAT64 1
# endif
#endif
 
 
// If a Timestamp's internal representation is identical to struct timespec
// or struct timeval, define TIMESTAMP_PUNS_TIMESPEC or TIMESTAMP_PUNS_TIMEVAL.
 
#if TIMESTAMP_REP_BIG_ENDIAN
# if !TIMESTAMP_NANOSEC && SIZEOF_STRUCT_TIMEVAL == 8
#  define TIMESTAMP_PUNS_TIMEVAL 1
# elif TIMESTAMP_NANOSEC && HAVE_STRUCT_TIMESPEC && SIZEOF_STRUCT_TIMESPEC == 8
#  define TIMESTAMP_PUNS_TIMESPEC 1
# endif
#endif
 
 
// Timestamp::value_type is the type of arguments to, for example,
// Timestamp::make_msec(), and should be as large as possible.  This is
// int64_t at userlevel.  In the linuxmodule driver, int64_t can only be used
// if the relevant Linux provides 64-bit divide, which is do_div.
// TIMESTAMP_VALUE_INT64 is defined to 1 if Timestamp::value_type is int64_t.
 
#if !defined(TIMESTAMP_VALUE_INT64) && HAVE_INT64_TYPES
# if CLICK_LINUXMODULE && defined(do_div)
#  define TIMESTAMP_VALUE_INT64 1
# elif !CLICK_LINUXMODULE && !CLICK_BSDMODULE
#  define TIMESTAMP_VALUE_INT64 1
# endif
#endif
 
 
// PRITIMESTAMP is a printf format string for Timestamps.  The corresponding
// printf argument list is Timestamp::sec() and Timestamp::subsec(), in that
// order.
 
#if TIMESTAMP_NANOSEC
# define PRITIMESTAMP "%d.%09d"
#else
# define PRITIMESTAMP "%d.%06d"
#endif
 
 
// TIMESTAMP_WARPABLE is defined if this Timestamp implementation supports
// timewarping.
 
#if !CLICK_LINUXMODULE && !CLICK_BSDMODULE && !CLICK_NS && HAVE_SIMTIME
# define TIMESTAMP_WARPABLE 1
#endif
 
#if HAVE_USER_TIMING
typedef int64_t (*user_clock_fct)(void* user, bool steady);
#endif
 
class Timestamp { public:
 
    typedef int32_t seconds_type;
#if TIMESTAMP_VALUE_INT64
    typedef int64_t value_type;
#else
    typedef int32_t value_type;
#endif
 
    enum {
        max_seconds = (seconds_type) 2147483647U,
        min_seconds = (seconds_type) -2147483648U
    };
 
    enum {
        nsec_per_sec = 1000000000,
        nsec_per_msec = 1000000,
        nsec_per_usec = 1000,
        usec_per_sec = 1000000,
        usec_per_msec = 1000,
        msec_per_sec = 1000,
#if TIMESTAMP_NANOSEC
        subsec_per_sec = nsec_per_sec,
#else
        subsec_per_sec = usec_per_sec,
#endif
        subsec_per_msec = subsec_per_sec / msec_per_sec,
        subsec_per_usec = subsec_per_sec / usec_per_sec
#if CLICK_NS
        , schedule_granularity = usec_per_sec
#endif
    };
 
    enum {
        NSUBSEC = subsec_per_sec
    };
 
    typedef uninitialized_type uninitialized_t;
 
    union rep_t;
 
 
    inline Timestamp() {
        assign(0, 0);
    }
 
    explicit inline Timestamp(long sec, uint32_t subsec = 0) {
        assign(sec, subsec);
    }
    explicit inline Timestamp(int sec, uint32_t subsec = 0) {
        assign(sec, subsec);
    }
    explicit inline Timestamp(unsigned long sec, uint32_t subsec = 0) {
        assign(sec, subsec);
    }
    explicit inline Timestamp(unsigned sec, uint32_t subsec = 0) {
        assign(sec, subsec);
    }
#if HAVE_FLOAT_TYPES
    explicit inline Timestamp(double);
#endif
 
    inline Timestamp(const struct timeval &tv);
#if HAVE_STRUCT_TIMESPEC
    inline Timestamp(const struct timespec &ts);
#endif
 
    inline Timestamp(const rep_t &rep)
        : _t(rep) {
    }
 
    inline Timestamp(const uninitialized_t &unused) {
        (void) unused;
    }
 
    typedef seconds_type (Timestamp::*unspecified_bool_type)() const;
    inline operator unspecified_bool_type() const;
 
    inline bool is_negative() const {
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
        return _t.x < 0;
#else
        return sec() < 0;
#endif
    }
 
    inline seconds_type sec() const;
    inline uint32_t subsec() const;
    inline uint32_t msec() const;
    inline uint32_t usec() const;
    inline uint32_t nsec() const;
 
    inline void set_sec(seconds_type sec);
    inline void set_subsec(uint32_t subsec);
 
    inline seconds_type msec1() const CLICK_DEPRECATED;
    inline seconds_type usec1() const CLICK_DEPRECATED;
    inline seconds_type nsec1() const CLICK_DEPRECATED;
 
#if TIMESTAMP_PUNS_TIMEVAL
    inline const struct timeval &timeval() const;
    inline const struct timeval &timeval_ceil() const;
#else
    inline struct timeval timeval() const;
    inline struct timeval timeval_ceil() const;
#endif
#if HAVE_STRUCT_TIMESPEC
# if TIMESTAMP_PUNS_TIMESPEC
    inline const struct timespec &timespec() const;
# else
    inline struct timespec timespec() const;
# endif
#endif
 
#if HAVE_INT64_TYPES
    inline int64_t longval() const;
    inline void assignlong(int64_t);
#endif
 
#if HAVE_FLOAT_TYPES
    inline double doubleval() const;
#endif
    inline value_type msecval() const {
#if TIMESTAMP_REP_FLAT64
        return value_div(_t.x, subsec_per_sec / msec_per_sec);
#else
        return (value_type) _t.sec * msec_per_sec + subsec_to_msec(_t.subsec);
#endif
    }
    inline value_type usecval() const {
#if TIMESTAMP_REP_FLAT64
        return value_div(_t.x, subsec_per_sec / usec_per_sec);
#else
        return (value_type) _t.sec * usec_per_sec + subsec_to_usec(_t.subsec);
#endif
    }
    inline value_type nsecval() const {
#if TIMESTAMP_REP_FLAT64
        return _t.x * (nsec_per_sec / subsec_per_sec);
#else
        return (value_type) _t.sec * nsec_per_sec + subsec_to_nsec(_t.subsec);
#endif
    }
 
    inline Timestamp msec_ceil() const {
        uint32_t x = subsec() % subsec_per_msec;
        return (x ? *this + Timestamp(0, subsec_per_msec - x) : *this);
    }
    inline Timestamp usec_ceil() const {
#if TIMESTAMP_NANOSEC
        uint32_t x = subsec() % subsec_per_usec;
        return (x ? *this + Timestamp(0, subsec_per_usec - x) : *this);
#else
        return *this;
#endif
    }
    inline Timestamp nsec_ceil() const {
        return *this;
    }
 
#if !CLICK_TOOL
    static inline Timestamp make_jiffies(click_jiffies_t jiffies);
    static inline Timestamp make_jiffies(click_jiffies_difference_t jiffies);
    inline click_jiffies_t jiffies() const;
#endif
 
    static inline Timestamp make_sec(seconds_type sec) {
        return Timestamp(sec, 0);
    }
    static inline Timestamp make_msec(seconds_type sec, uint32_t msec) {
        return Timestamp(sec, msec_to_subsec(msec));
    }
    static inline Timestamp make_msec(value_type msec) {
        Timestamp t = Timestamp::uninitialized_t();
#if TIMESTAMP_REP_FLAT64
        t._t.x = msec * (subsec_per_sec / msec_per_sec);
#else
        value_div_mod(t._t.sec, t._t.subsec, msec, msec_per_sec);
        t._t.subsec *= subsec_per_sec / msec_per_sec;
#endif
        return t;
    }
    static inline Timestamp make_usec(seconds_type sec, uint32_t usec) {
        return Timestamp(sec, usec_to_subsec(usec));
    }
    static inline Timestamp make_usec(value_type usec) {
        Timestamp t = Timestamp::uninitialized_t();
#if TIMESTAMP_REP_FLAT64
        t._t.x = usec * (subsec_per_sec / usec_per_sec);
#else
        value_div_mod(t._t.sec, t._t.subsec, usec, usec_per_sec);
        t._t.subsec *= subsec_per_sec / usec_per_sec;
#endif
        return t;
    }
    static inline Timestamp make_nsec(seconds_type sec, uint32_t nsec) {
        return Timestamp(sec, nsec_to_subsec(nsec));
    }
    static inline Timestamp make_nsec(value_type nsec) {
        Timestamp t = Timestamp::uninitialized_t();
#if TIMESTAMP_REP_FLAT64
        t._t.x = value_div(nsec, nsec_per_sec / subsec_per_sec);
#else
        value_div_mod(t._t.sec, t._t.subsec, nsec, nsec_per_sec);
        t._t.subsec /= nsec_per_sec / subsec_per_sec;
#endif
        return t;
    }
 
 
    static inline Timestamp epsilon() {
        return Timestamp(0, 1);
    }
 
    inline void clear() {
        assign(0, 0);
    }
 
 
    inline void assign(seconds_type sec, uint32_t subsec = 0) {
#if TIMESTAMP_REP_FLAT64
        _t.x = (int64_t) sec * subsec_per_sec + subsec;
#else
        _t.sec = sec;
        _t.subsec = subsec;
#endif
    }
    inline void assign_usec(seconds_type sec, uint32_t usec) {
        assign(sec, usec_to_subsec(usec));
    }
    inline void assign_nsec(seconds_type sec, uint32_t nsec) {
        assign(sec, nsec_to_subsec(nsec));
    }
 
    inline void set(seconds_type sec, uint32_t subsec = 0) CLICK_DEPRECATED;
    inline void set_usec(seconds_type sec, uint32_t usec) CLICK_DEPRECATED;
    inline void set_nsec(seconds_type sec, uint32_t nsec) CLICK_DEPRECATED;
    inline void set_now() CLICK_DEPRECATED;
#if !CLICK_LINUXMODULE && !CLICK_BSDMODULE && !CLICK_MINIOS
    int set_timeval_ioctl(int fd, int ioctl_selector);
#endif
 
 
    static inline Timestamp now();
 
    inline void assign_now();
 
    static inline Timestamp recent();
 
    inline void assign_recent();
 
 
    static inline Timestamp now_steady();
 
    inline void assign_now_steady();
 
    static inline Timestamp recent_steady();
 
    inline void assign_recent_steady();
 
    inline void assign_now_nouser(bool steady);
 
 
    String unparse() const;
 
    String unparse_interval() const;
 
 
    inline static uint32_t msec_to_subsec(uint32_t msec) {
        return msec * (subsec_per_sec / msec_per_sec);
    }
    inline static uint32_t usec_to_subsec(uint32_t usec) {
        return usec * (subsec_per_sec / usec_per_sec);
    }
    inline static uint32_t nsec_to_subsec(uint32_t nsec) {
        return nsec / (nsec_per_sec / subsec_per_sec);
    }
    inline static uint32_t subsec_to_msec(uint32_t subsec) {
        return subsec / (subsec_per_sec / msec_per_sec);
    }
    inline static uint32_t subsec_to_usec(uint32_t subsec) {
        return subsec / (subsec_per_sec / usec_per_sec);
    }
    inline static uint32_t subsec_to_nsec(uint32_t subsec) {
        return subsec * (nsec_per_sec / subsec_per_sec);
    }
 
 
    union rep_t {
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
        int64_t x;
#endif
#if TIMESTAMP_REP_BIG_ENDIAN
        struct {
            int32_t sec;
            int32_t subsec;
        };
#elif TIMESTAMP_REP_LITTLE_ENDIAN
        struct {
            int32_t subsec;
            int32_t sec;
        };
#endif
#if CLICK_LINUXMODULE
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
        ktime_t ktime;
# elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
        skb_timeval skbtime;
# endif
#endif
#if TIMESTAMP_PUNS_TIMEVAL
        struct timeval tv;
#elif TIMESTAMP_PUNS_TIMESPEC
        struct timespec tspec;
#endif
    };
 
#if TIMESTAMP_WARPABLE
    enum warp_class_type {
        warp_none = 0,          
        warp_linear = 1,        
        warp_nowait = 2,        
                                //   but don't wait for timers.
        warp_simulation = 3     
    };
 
 
    static inline int warp_class();
 
    static inline double warp_speed();
 
 
    static void warp_set_class(warp_class_type w, double s = 1.0);
 
    static void warp_set_now(const Timestamp &t_system, const Timestamp &t_steady);
 
 
    inline Timestamp warp_real_delay() const;
 
    static inline bool warp_jumping();
 
    static void warp_jump_steady(const Timestamp &expiry);
 
 
    static inline Timestamp now_unwarped();
 
    inline void assign_now_unwarped();
 
    static inline Timestamp now_steady_unwarped();
 
    inline void assign_now_steady_unwarped();
 
 
    static void set_warp_tick(unsigned long tick);
#endif
 
#if HAVE_USER_TIMING
    static bool set_clock(user_clock_fct clock, void* user);
#endif
 
  private:
 
    rep_t _t;
 
#if HAVE_USER_TIMING
    static void* _user_data;
    static user_clock_fct _user_clock;
#endif
 
    inline void add_fix() {
#if TIMESTAMP_REP_FLAT64
        /* no fix necessary */
#elif TIMESTAMP_MATH_FLAT64
        if (_t.subsec >= subsec_per_sec)
            _t.x += (uint32_t) -subsec_per_sec;
#else
        if (_t.subsec >= subsec_per_sec)
            _t.sec++, _t.subsec -= subsec_per_sec;
#endif
    }
 
    inline void sub_fix() {
#if TIMESTAMP_REP_FLAT64
        /* no fix necessary */
#elif TIMESTAMP_MATH_FLAT64
        if (_t.subsec < 0)
            _t.subsec += subsec_per_sec;
#else
        if (_t.subsec < 0)
            _t.sec--, _t.subsec += subsec_per_sec;
#endif
    }
 
    static inline value_type value_div(value_type a, uint32_t b) {
        return int_divide(a, b);
    }
 
    static inline void value_div_mod(int32_t &div, int32_t &rem,
                                     value_type a, uint32_t b) {
        value_type quot;
        rem = int_remainder(a, b, quot);
        div = quot;
    }
 
    inline void assign_now(bool recent, bool steady, bool unwarped, bool no_user = false);
 
#if TIMESTAMP_WARPABLE
    static inline void warp_adjust(bool steady, const Timestamp &t_raw, const Timestamp &t_warped);
    inline Timestamp warped(bool steady) const;
    void warp(bool steady, bool from_now);
#endif
 
    friend inline bool operator==(const Timestamp &a, const Timestamp &b);
    friend inline bool operator<(const Timestamp &a, const Timestamp &b);
    friend inline Timestamp operator-(const Timestamp &b);
    friend inline Timestamp &operator+=(Timestamp &a, const Timestamp &b);
    friend inline Timestamp &operator-=(Timestamp &a, const Timestamp &b);
 
};
 
class UserClock {public:
    enum {h_now, h_now_steady};
    virtual int64_t now(bool steady) = 0;
};
 
#if TIMESTAMP_WARPABLE
class TimestampWarp {
    static Timestamp::warp_class_type kind;
    static double speed;
    static Timestamp flat_offset[2];
    static double offset[2];
    friend class Timestamp;
};
inline int Timestamp::warp_class() {
    return TimestampWarp::kind;
}
 
inline double Timestamp::warp_speed() {
    return TimestampWarp::speed;
}
 
inline bool Timestamp::warp_jumping() {
    return TimestampWarp::kind >= warp_nowait;
}
 
inline Timestamp Timestamp::warped(bool steady) const {
    Timestamp t = *this;
    if (TimestampWarp::kind)
        t.warp(steady, false);
    return t;
}
#endif
 
 
inline
Timestamp::Timestamp(const struct timeval& tv)
{
    assign(tv.tv_sec, usec_to_subsec(tv.tv_usec));
}
 
#if HAVE_STRUCT_TIMESPEC
inline
Timestamp::Timestamp(const struct timespec& ts)
{
    assign(ts.tv_sec, nsec_to_subsec(ts.tv_nsec));
}
#endif
 
inline
Timestamp::operator unspecified_bool_type() const
{
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
    return _t.x ? &Timestamp::sec : 0;
#else
    return _t.sec || _t.subsec ? &Timestamp::sec : 0;
#endif
}
 
inline void
Timestamp::assign_now(bool recent, bool steady, bool unwarped, bool nouser)
{
    (void) recent, (void) steady, (void) unwarped, (void) nouser;
 
#if TIMESTAMP_PUNS_TIMESPEC
# define TIMESTAMP_DECLARE_TSP struct timespec &tsp = _t.tspec
# define TIMESTAMP_RESOLVE_TSP /* nothing */
#else
# define TIMESTAMP_DECLARE_TSP struct timespec ts, &tsp = ts
# define TIMESTAMP_RESOLVE_TSP assign(tsp.tv_sec, nsec_to_subsec(tsp.tv_nsec))
#endif
#if TIMESTAMP_PUNS_TIMEVAL
# define TIMESTAMP_DECLARE_TVP struct timeval &tvp = _t.tv
# define TIMESTAMP_RESOLVE_TVP /* nothing */
#else
# define TIMESTAMP_DECLARE_TVP struct timeval tv, &tvp = tv
# define TIMESTAMP_RESOLVE_TVP assign(tvp.tv_sec, usec_to_subsec(tvp.tv_usec))
#endif
 
#if HAVE_USER_TIMING
    if (!nouser && _user_clock != 0) {
        int64_t current = _user_clock(_user_data,steady);
        assignlong(current);
    } else
#endif
    {
#if CLICK_LINUXMODULE
# if !TIMESTAMP_NANOSEC
    if (!recent && !steady) {
        TIMESTAMP_DECLARE_TVP;
        do_gettimeofday(&tvp);
        TIMESTAMP_RESOLVE_TVP;
        return;
    }
# endif
    TIMESTAMP_DECLARE_TSP;
    if (recent && steady) {
# if HAVE_LINUX_GET_MONOTONIC_COARSE
        tsp = get_monotonic_coarse();
# elif HAVE_LINUX_GETBOOTTIME && HAVE_LINUX_KTIME_MONO_TO_ANY
        // XXX Is this even worth it????? Would it be faster to just get the
        // current time?
        tsp = current_kernel_time();
        struct timespec delta =
            ktime_to_timespec(ktime_mono_to_any(ktime_set(0, 0), TK_OFFS_REAL));
        set_normalized_timespec(&tsp, tsp.tv_sec - delta.tv_sec,
                                tsp.tv_nsec - delta.tv_nsec);
# elif HAVE_LINUX_GETBOOTTIME
        tsp = current_kernel_time();
        struct timespec delta;
        getboottime(&delta);
        monotonic_to_bootbased(&delta);
        set_normalized_timespec(&tsp, tsp.tv_sec - delta.tv_sec,
                                tsp.tv_nsec - delta.tv_nsec);
# else
        // older kernels don't export enough information to produce a recent
        // steady timestamp; produce a current steady timestamp
        ktime_get_ts(&tsp);
# endif
    } else if (recent)
        tsp = current_kernel_time();
    else if (steady)
        ktime_get_ts(&tsp);
    else
        getnstimeofday(&tsp);
    TIMESTAMP_RESOLVE_TSP;
 
#elif TIMESTAMP_NANOSEC && CLICK_BSDMODULE
    TIMESTAMP_DECLARE_TSP;
    if (recent && steady)
        getnanouptime(&tsp);
    else if (recent)
        getnanotime(&tsp);
    else if (steady)
        nanouptime(&tsp);
    else
        nanotime(&tsp);
    TIMESTAMP_RESOLVE_TSP;
 
#elif CLICK_BSDMODULE
    TIMESTAMP_DECLARE_TVP;
    if (recent && steady)
        getmicrouptime(&tvp);
    else if (recent)
        getmicrotime(&tvp);
    else if (steady)
        microuptime(&tvp);
    else
        microtime(&tvp);
    TIMESTAMP_RESOLVE_TVP;
 
#elif CLICK_MINIOS
    TIMESTAMP_DECLARE_TVP;
    gettimeofday(&tvp, (struct timezone *) 0);
    TIMESTAMP_RESOLVE_TVP;
 
#elif CLICK_NS
    if (schedule_granularity == usec_per_sec) {
        TIMESTAMP_DECLARE_TVP;
        simclick_gettimeofday(&tvp);
        TIMESTAMP_RESOLVE_TVP;
    } else {
        assert(0 && "nanosecond precision not available yet");
    }
 
#elif HAVE_USE_CLOCK_GETTIME
    TIMESTAMP_DECLARE_TSP;
    if (steady)
        clock_gettime(CLOCK_MONOTONIC, &tsp);
    else
        clock_gettime(CLOCK_REALTIME, &tsp);
    TIMESTAMP_RESOLVE_TSP;
 
#else
    TIMESTAMP_DECLARE_TVP;
    gettimeofday(&tvp, (struct timezone *) 0);
    TIMESTAMP_RESOLVE_TVP;
#endif
 
#undef TIMESTAMP_DECLARE_TSP
#undef TIMESTAMP_RESOLVE_TSP
#undef TIMESTAMP_DECLARE_TVP
#undef TIMESTAMP_RESOLVE_TVP
 
    }
#ifdef TIMESTAMP_WARPABLE
    // timewarping
    if (!unwarped && TimestampWarp::kind)
        warp(steady, true);
#endif
}
 
inline void
Timestamp::assign_now()
{
    assign_now(false, false, false);
}
 
inline Timestamp
Timestamp::now()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_now();
    return t;
}
 
inline void
Timestamp::assign_recent()
{
    assign_now(true, false, false);
}
 
inline Timestamp
Timestamp::recent()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_recent();
    return t;
}
 
inline void
Timestamp::assign_now_steady()
{
    assign_now(false, true, false);
}
 
inline Timestamp
Timestamp::now_steady()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_now_steady();
    return t;
}
 
inline void
Timestamp::assign_recent_steady()
{
    assign_now(true, true, false);
}
 
inline Timestamp
Timestamp::recent_steady()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_recent_steady();
    return t;
}
 
inline void
Timestamp::assign_now_nouser(bool steady)
{
    assign_now(false, steady, false, true);
}
 
 
#if TIMESTAMP_WARPABLE
inline void
Timestamp::assign_now_unwarped()
{
    assign_now(false, false, true);
}
 
inline Timestamp
Timestamp::now_unwarped()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_now_unwarped();
    return t;
}
 
inline void
Timestamp::assign_now_steady_unwarped()
{
    assign_now(false, true, true);
}
 
inline Timestamp
Timestamp::now_steady_unwarped()
{
    Timestamp t = Timestamp::uninitialized_t();
    t.assign_now_steady_unwarped();
    return t;
}
#endif
 
inline void
Timestamp::set_sec(seconds_type sec)
{
#if TIMESTAMP_REP_FLAT64
    uint32_t ss = subsec();
    _t.x = (int64_t) sec * subsec_per_sec + ss;
#else
    _t.sec = sec;
#endif
}
 
inline void
Timestamp::set_subsec(uint32_t subsec)
{
#if TIMESTAMP_REP_FLAT64
    seconds_type s = sec();
    _t.x = (int64_t) s * subsec_per_sec + subsec;
#else
    _t.subsec = subsec;
#endif
}
 
inline Timestamp::seconds_type
Timestamp::sec() const
{
#if TIMESTAMP_REP_FLAT64
    if (unlikely(_t.x < 0))
        return -value_div(-(_t.x + 1), subsec_per_sec) - 1;
    else
        return value_div(_t.x, subsec_per_sec);
#else
    return _t.sec;
#endif
}
 
inline uint32_t
Timestamp::subsec() const
{
#if TIMESTAMP_REP_FLAT64
    return _t.x - (uint32_t) sec() * subsec_per_sec;
#else
    return _t.subsec;
#endif
}
 
inline uint32_t
Timestamp::msec() const
{
    return subsec_to_msec(subsec());
}
 
inline uint32_t
Timestamp::usec() const
{
    return subsec_to_usec(subsec());
}
 
inline uint32_t
Timestamp::nsec() const
{
    return subsec_to_nsec(subsec());
}
 
inline Timestamp::seconds_type
Timestamp::msec1() const
{
#if TIMESTAMP_REP_FLAT64
    return value_div(_t.x, subsec_per_sec / msec_per_sec);
#else
    return _t.sec * msec_per_sec + subsec_to_msec(_t.subsec);
#endif
}
 
inline Timestamp::seconds_type
Timestamp::usec1() const
{
#if TIMESTAMP_REP_FLAT64
    return value_div(_t.x, subsec_per_sec / usec_per_sec);
#else
    return _t.sec * usec_per_sec + subsec_to_usec(_t.subsec);
#endif
}
 
inline Timestamp::seconds_type
Timestamp::nsec1() const
{
#if TIMESTAMP_REP_FLAT64
    return _t.x * (nsec_per_sec / subsec_per_sec);
#else
    return _t.sec * nsec_per_sec + subsec_to_nsec(_t.subsec);
#endif
}
 
#if !CLICK_TOOL
inline click_jiffies_t
Timestamp::jiffies() const
{
# if TIMESTAMP_REP_FLAT64
    // This is not very precise when CLICK_HZ doesn't divide NSUBSEC evenly.
    return value_div(_t.x, subsec_per_sec / CLICK_HZ);
# else
    click_jiffies_t j = ((click_jiffies_t) sec()) * CLICK_HZ;
#  if CLICK_HZ == 100 || CLICK_HZ == 1000 || CLICK_HZ == 10000 || CLICK_HZ == 100000 || CLICK_HZ == 1000000
    return j + ((click_jiffies_t) subsec()) / (subsec_per_sec / CLICK_HZ);
#  else
    // This is not very precise when CLICK_HZ doesn't divide NSUBSEC evenly.
    return j + ((click_jiffies_t) subsec()) / (subsec_per_sec / CLICK_HZ);
#  endif
# endif
}
 
inline Timestamp
Timestamp::make_jiffies(click_jiffies_t jiffies)
{
    // Not very precise when CLICK_HZ doesn't evenly divide subsec_per_sec.
    Timestamp t = Timestamp::uninitialized_t();
# if TIMESTAMP_REP_FLAT64
    t._t.x = (int64_t) jiffies * (subsec_per_sec / CLICK_HZ);
# else
    t._t.sec = jiffies / CLICK_HZ;
    t._t.subsec = (jiffies - t._t.sec * CLICK_HZ) * (subsec_per_sec / CLICK_HZ);
# endif
    return t;
}
 
inline Timestamp
Timestamp::make_jiffies(click_jiffies_difference_t jiffies)
{
    // Not very precise when CLICK_HZ doesn't evenly divide subsec_per_sec.
    Timestamp t = Timestamp::uninitialized_t();
# if TIMESTAMP_REP_FLAT64
    t._t.x = (int64_t) jiffies * (subsec_per_sec / CLICK_HZ);
# else
    if (jiffies < 0)
        t._t.sec = -(-(jiffies + 1) / CLICK_HZ) - 1;
    else
        t._t.sec = jiffies / CLICK_HZ;
    t._t.subsec = (jiffies - t._t.sec * CLICK_HZ) * (subsec_per_sec / CLICK_HZ);
# endif
    return t;
}
#endif
 
inline void Timestamp::set_now() {
    assign_now(false, false, false);
}
 
inline void Timestamp::set(seconds_type sec, uint32_t subsec) {
    assign(sec, subsec);
}
 
inline void Timestamp::set_usec(seconds_type sec, uint32_t usec) {
    assign_usec(sec, usec);
}
 
inline void Timestamp::set_nsec(seconds_type sec, uint32_t nsec) {
    assign_nsec(sec, nsec);
}
inline bool
operator==(const Timestamp &a, const Timestamp &b)
{
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
    return a._t.x == b._t.x;
#else
    return a.sec() == b.sec() && a.subsec() == b.subsec();
#endif
}
 
inline bool
operator!=(const Timestamp &a, const Timestamp &b)
{
    return !(a == b);
}
 
inline bool
operator<(const Timestamp &a, const Timestamp &b)
{
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
    return a._t.x < b._t.x;
#else
    return a.sec() < b.sec() || (a.sec() == b.sec() && a.subsec() < b.subsec());
#endif
}
 
inline bool
operator<(const Timestamp &a, int b)
{
    return a < Timestamp(b);
}
 
inline bool
operator<=(const Timestamp &a, const Timestamp &b)
{
    return !(b < a);
}
 
inline bool
operator<=(const Timestamp &a, int b)
{
    return a <= Timestamp(b);
}
 
inline bool
operator>=(const Timestamp &a, const Timestamp &b)
{
    return !(a < b);
}
 
inline bool
operator>=(const Timestamp &a, int b)
{
    return a >= Timestamp(b);
}
 
inline bool
operator>(const Timestamp &a, const Timestamp &b)
{
    return b < a;
}
 
inline bool
operator>(const Timestamp &a, int b)
{
    return a > Timestamp(b);
}
 
inline Timestamp &
operator+=(Timestamp &a, const Timestamp &b)
{
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
    a._t.x += b._t.x;
#else
    a._t.sec += b._t.sec;
    a._t.subsec += b._t.subsec;
#endif
    a.add_fix();
    return a;
}
 
inline Timestamp &
operator-=(Timestamp &a, const Timestamp &b)
{
#if TIMESTAMP_REP_FLAT64 || TIMESTAMP_MATH_FLAT64
    a._t.x -= b._t.x;
#else
    a._t.sec -= b._t.sec;
    a._t.subsec -= b._t.subsec;
#endif
    a.sub_fix();
    return a;
}
 
inline Timestamp
operator+(Timestamp a, const Timestamp &b)
{
    a += b;
    return a;
}
 
inline Timestamp
operator-(Timestamp a, const Timestamp &b)
{
    a -= b;
    return a;
}
 
inline Timestamp
operator-(const Timestamp &a)
{
#if TIMESTAMP_REP_FLAT64
    Timestamp t = Timestamp::uninitialized_t();
    t._t.x = -a._t.x;
    return t;
#else
    if (a.subsec())
        return Timestamp(-(a.sec() + 1), Timestamp::subsec_per_sec - a.subsec());
    else
        return Timestamp(-a.sec(), 0);
#endif
}
 
#if HAVE_INT64_TYPES
inline int64_t
Timestamp::longval() const
{
#if TIMESTAMP_REP_FLAT64
    return _t.x;
#else
    return _t.sec * subsec_per_sec + _t.subsec;
#endif
}
 
inline void Timestamp::assignlong(int64_t i) {
#if TIMESTAMP_REP_FLAT64
    _t.x = i;
#else
        _t.sec = i / subsec_per_sec;
        _t.subsec = i % subsec_per_sec;
#endif
}
#endif
 
#if HAVE_FLOAT_TYPES
inline double
Timestamp::doubleval() const
{
# if TIMESTAMP_REP_FLAT64
    return _t.x / (double) subsec_per_sec;
# else
    return _t.sec + (_t.subsec / (double) subsec_per_sec);
# endif
}
 
inline
Timestamp::Timestamp(double d)
{
# if TIMESTAMP_REP_FLAT64
    _t.x = (int64_t) floor(d * subsec_per_sec + 0.5);
# else
    double dfloor = floor(d);
    _t.sec = (seconds_type) dfloor;
    _t.subsec = (uint32_t) ((d - dfloor) * subsec_per_sec + 0.5);
    add_fix();
# endif
}
 
inline Timestamp
operator*(const Timestamp &a, double b)
{
    return Timestamp(a.doubleval() * b);
}
 
inline Timestamp
operator*(const Timestamp &a, int b)
{
    return Timestamp(a.doubleval() * b);
}
 
inline Timestamp
operator*(const Timestamp &a, unsigned b)
{
    return Timestamp(a.doubleval() * b);
}
 
inline Timestamp
operator*(double a, const Timestamp &b)
{
    return Timestamp(b.doubleval() * a);
}
 
inline Timestamp
operator*(int a, const Timestamp &b)
{
    return Timestamp(b.doubleval() * a);
}
 
inline Timestamp
operator*(unsigned a, const Timestamp &b)
{
    return Timestamp(b.doubleval() * a);
}
 
inline Timestamp
operator/(const Timestamp &a, double b)
{
    return Timestamp(a.doubleval() / b);
}
 
inline Timestamp
operator/(const Timestamp &a, int b)
{
    return Timestamp(a.doubleval() / b);
}
 
inline Timestamp
operator/(const Timestamp &a, unsigned b)
{
    return Timestamp(a.doubleval() / b);
}
 
inline double
operator/(const Timestamp &a, const Timestamp &b)
{
    return a.doubleval() / b.doubleval();
}
#endif /* HAVE_FLOAT_TYPES */
 
StringAccum& operator<<(StringAccum&, const Timestamp&);
 
#if TIMESTAMP_WARPABLE
inline Timestamp
Timestamp::warp_real_delay() const
{
    if (likely(!TimestampWarp::kind) || TimestampWarp::speed == 1.0)
        return *this;
    else
        return *this / TimestampWarp::speed;
}
#endif
 
#if TIMESTAMP_PUNS_TIMEVAL
inline const struct timeval &
Timestamp::timeval() const
{
    return _t.tv;
}
 
inline const struct timeval &
Timestamp::timeval_ceil() const
{
    return _t.tv;
}
#else
inline struct timeval
Timestamp::timeval() const
{
    struct timeval tv;
    tv.tv_sec = sec();
    tv.tv_usec = usec();
    return tv;
}
 
inline struct timeval
Timestamp::timeval_ceil() const
{
    return (*this + Timestamp(0, subsec_per_usec - 1)).timeval();
}
#endif
 
#if HAVE_STRUCT_TIMESPEC
# if TIMESTAMP_PUNS_TIMESPEC
inline const struct timespec &
Timestamp::timespec() const
{
    return _t.tspec;
}
# else
inline struct timespec
Timestamp::timespec() const
{
    struct timespec ts;
    ts.tv_sec = sec();
    ts.tv_nsec = nsec();
    return ts;
}
# endif
#endif
 
 
class ArgContext;
extern const ArgContext blank_args;
bool cp_time(const String &str, Timestamp *result, bool allow_negative);
 
class TimestampArg { public:
    TimestampArg(bool is_signed = false)
        : is_signed(is_signed) {
    }
    bool parse(const String &str, Timestamp &value, const ArgContext &args = blank_args) {
        (void) args;
        return cp_time(str, &value, is_signed);
    }
    bool is_signed;
};
 
template<> struct DefaultArg<Timestamp> : public TimestampArg {};
template<> struct has_trivial_copy<Timestamp> : public true_type {};
 
CLICK_ENDDECLS
#endif