glue.hh

Click is a modular router toolkit. To use it you ll need to know how to compile and install the sof

typedef pthread_t click_processor_t;
#else
typedef int8_t click_processor_t;
#endif

inline click_processor_t
click_get_processor()
{
#if CLICK_LINUXMODULE
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    return get_cpu();
# else
    return current->processor;
# endif
#elif CLICK_USERLEVEL && HAVE_MULTITHREAD
    return pthread_self();
#else
    return 0;
#endif
}

inline void
click_put_processor()
{
#if CLICK_LINUXMODULE
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    put_cpu_no_resched();
# endif
#endif
}

inline click_processor_t
click_current_processor()
{
#if CLICK_LINUXMODULE
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    return smp_processor_id();
# else
    return current->processor;
# endif
#elif CLICK_USERLEVEL && HAVE_MULTITHREAD
    return pthread_self();
#else
    return 0;
#endif
}

inline click_processor_t
click_invalid_processor()
{
#if CLICK_LINUXMODULE
    return -1;
#elif CLICK_USERLEVEL && HAVE_MULTITHREAD
    return 0;
#else
    return -1;
#endif
}


// TIMEVALS AND JIFFIES
// click_jiffies_t is the type of click_jiffies() and is usually unsigned.
// click_jiffies_difference_t is the signed version of click_jiffies_t.
// CLICK_JIFFIES_MONOTONIC is true if click_jiffies() never goes backwards.

#if CLICK_LINUXMODULE
# define click_gettimeofday(tvp)	(do_gettimeofday(tvp))
typedef unsigned long click_jiffies_t;
typedef long click_jiffies_difference_t;
# define click_jiffies()		(jiffies)
# define CLICK_JIFFIES_MONOTONIC	1
# define CLICK_HZ			HZ
# define click_jiffies_less(a, b)	((click_jiffies_difference_t) ((a) - (b)) < 0)
#elif CLICK_BSDMODULE
# define click_gettimeofday(tvp)	(getmicrotime(tvp))
typedef int click_jiffies_t;
typedef int click_jiffies_difference_t;
# define click_jiffies()		(ticks)
# define CLICK_HZ			hz
# define click_jiffies_less(a, b)	((click_jiffies_difference_t) ((a) - (b)) < 0)
#else
CLICK_DECLS
void click_gettimeofday(timeval *tvp) CLICK_DEPRECATED;
typedef unsigned click_jiffies_t;
typedef int click_jiffies_difference_t;
click_jiffies_t click_jiffies();
# define click_jiffies_less(a, b)	((click_jiffies_difference_t) ((a) - (b)) < 0)
CLICK_ENDDECLS
# define CLICK_HZ			1000
#endif


// TIMEVAL OPERATIONS

#ifndef timercmp
// Convenience macros for operations on timevals.
// NOTE: 'timercmp' does not work for >= or <=.
# define timerisset(tvp)	((tvp)->tv_sec || (tvp)->tv_usec)
# define timerclear(tvp)	((tvp)->tv_sec = (tvp)->tv_usec = 0)
# define timercmp(a, b, CMP)			\
  (((a)->tv_sec == (b)->tv_sec) ?		\
   ((a)->tv_usec CMP (b)->tv_usec) :		\
   ((a)->tv_sec CMP (b)->tv_sec))
#endif
#ifndef timeradd
# define timeradd(a, b, result)						      \
  do {									      \
    (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;			      \
    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;			      \
    if ((result)->tv_usec >= 1000000)					      \
      {									      \
	++(result)->tv_sec;						      \
	(result)->tv_usec -= 1000000;					      \
      }									      \
  } while (0)
#endif
#ifndef timersub
# define timersub(a, b, result)						      \
  do {									      \
    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;			      \
    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;			      \
    if ((result)->tv_usec < 0) {					      \
      --(result)->tv_sec;						      \
      (result)->tv_usec += 1000000;					      \
    }									      \
  } while (0)
#endif

#ifndef CLICK_TIMEVAL_OPERATORS

inline timeval make_timeval(int sec, int usec) CLICK_DEPRECATED;
inline bool operator==(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline bool operator!=(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline bool operator<(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline bool operator<=(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline bool operator>(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline bool operator>=(const timeval &a, const timeval &b) CLICK_DEPRECATED;
inline timeval &operator+=(timeval &a, const timeval &b) CLICK_DEPRECATED;
inline timeval &operator-=(timeval &a, const timeval &b) CLICK_DEPRECATED;
inline timeval operator+(timeval a, const timeval &b) CLICK_DEPRECATED;
inline timeval operator-(timeval a, const timeval &b) CLICK_DEPRECATED;

inline struct timeval
make_timeval(int sec, int usec)
{
    struct timeval tv;
    tv.tv_sec = sec;
    tv.tv_usec = usec;
    return tv;
}

inline bool
operator==(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec == b.tv_sec && a.tv_usec == b.tv_usec;
}

inline bool
operator!=(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec != b.tv_sec || a.tv_usec != b.tv_usec;
}

inline bool
operator<(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec < b.tv_sec || (a.tv_sec == b.tv_sec && a.tv_usec < b.tv_usec);
}

inline bool
operator<=(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec < b.tv_sec || (a.tv_sec == b.tv_sec && a.tv_usec <= b.tv_usec);
}

inline bool
operator>=(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec > b.tv_sec || (a.tv_sec == b.tv_sec && a.tv_usec >= b.tv_usec);
}

inline bool
operator>(const struct timeval &a, const struct timeval &b)
{
    return a.tv_sec > b.tv_sec || (a.tv_sec == b.tv_sec && a.tv_usec > b.tv_usec);
}

inline struct timeval &
operator+=(struct timeval &a, const struct timeval &b)
{
    timeradd(&a, &b, &a);
    return a;
}

inline struct timeval &
operator-=(struct timeval &a, const struct timeval &b)
{
    timersub(&a, &b, &a);
    return a;
}

inline struct timeval
operator+(struct timeval a, const struct timeval &b)
{
    timeradd(&a, &b, &a);
    return a;
}

inline struct timeval
operator-(struct timeval a, const struct timeval &b)
{
    timersub(&a, &b, &a);
    return a;
}

#endif

CLICK_DECLS
class StringAccum;
StringAccum &operator<<(StringAccum &, const struct timeval &);
CLICK_ENDDECLS


// BYTE ORDER

#if CLICK_BYTE_ORDER == CLICK_LITTLE_ENDIAN
# define le16_to_cpu(x) (x)
# define cpu_to_le16(x) (x)
# define le32_to_cpu(x) (x)
# define cpu_to_le32(x) (x)
#elif CLICK_BYTE_ORDER == CLICK_BIG_ENDIAN && defined(__APPLE__)
# include <machine/byte_order.h>
# define le16_to_cpu(x) NXSwapShort((x))
# define cpu_to_le16(x) NXSwapShort((x))
# define le32_to_cpu(x) NXSwapInt((x))
# define cpu_to_le32(x) NXSwapInt((x))
#elif CLICK_BYTE_ORDER == CLICK_BIG_ENDIAN && HAVE_BYTESWAP_H
# include <byteswap.h>
# define le16_to_cpu(x) bswap_16((x))
# define cpu_to_le16(x) bswap_16((x))
# define le32_to_cpu(x) bswap_32((x))
# define cpu_to_le32(x) bswap_32((x))
#elif CLICK_BYTE_ORDER == CLICK_BIG_ENDIAN
# define le16_to_cpu(x) ((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))
# define cpu_to_le16(x) le16_to_cpu((x))
# define le32_to_cpu(x) (le16_to_cpu((x) >> 16) | (le16_to_cpu(x) << 16))
# define cpu_to_le32(x) le32_to_cpu((x))
#else
/* leave them undefined */
#endif


// CYCLE COUNTS

CLICK_DECLS

#if HAVE_INT64_TYPES
typedef uint64_t click_cycles_t;
#else
typedef uint32_t click_cycles_t;
#endif

inline click_cycles_t
click_get_cycles()
{
#if CLICK_LINUXMODULE && HAVE_INT64_TYPES && __i386__
    uint64_t x;
    __asm__ __volatile__ ("rdtsc" : "=A" (x));
    return x;
#elif CLICK_LINUXMODULE && HAVE_INT64_TYPES && __x86_64__
    uint32_t xlo, xhi;
    __asm__ __volatile__ ("rdtsc" : "=a" (xlo), "=d" (xhi));
    return xlo | (((uint64_t) xhi) << 32);
#elif CLICK_LINUXMODULE && __i386__
    uint32_t xlo, xhi;
    __asm__ __volatile__ ("rdtsc" : "=a" (xlo), "=d" (xhi));
    return xlo;
#elif CLICK_BSDMODULE
    return rdtsc();
#elif CLICK_USERLEVEL && HAVE_INT64_TYPES && __i386__
    uint64_t x;
    __asm__ __volatile__ ("rdtsc" : "=A" (x));
    return x;
#elif CLICK_USERLEVEL && HAVE_INT64_TYPES && __x86_64__
    uint32_t xlo, xhi;
    __asm__ __volatile__ ("rdtsc" : "=a" (xlo), "=d" (xhi));
    return xlo | (((uint64_t) xhi) << 32);
#elif CLICK_USERLEVEL && __i386__
    uint32_t xlo, xhi;
    __asm__ __volatile__ ("rdtsc" : "=a" (xlo), "=d" (xhi));
    return xlo;
#else
    // add other architectures here
    return 0;
#endif
}

CLICK_ENDDECLS

#endif